From 9d6d3e1ad175457929ebe33c01a48ddc55f264f3 Mon Sep 17 00:00:00 2001 From: Sam Bray Date: Mon, 10 Jun 2024 15:50:51 -0700 Subject: [PATCH 01/42] Add organization tables for keypoint pose data --- src/spyglass/behavior/__init__.py | 0 src/spyglass/behavior/core.py | 80 +++++++++++++++++++ src/spyglass/position/position_merge.py | 50 ++++++++++++ .../v1/position_dlc_pose_estimation.py | 10 +++ 4 files changed, 140 insertions(+) create mode 100644 src/spyglass/behavior/__init__.py create mode 100644 src/spyglass/behavior/core.py diff --git a/src/spyglass/behavior/__init__.py b/src/spyglass/behavior/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/core.py new file mode 100644 index 000000000..0453c1817 --- /dev/null +++ b/src/spyglass/behavior/core.py @@ -0,0 +1,80 @@ +from pathlib import Path + +import datajoint as dj + +from spyglass.position.position_merge import PoseOutput +from spyglass.utils import SpyglassMixin, SpyglassMixinPart + +schema = dj.schema("behavior_core_v1") + + +@schema +class PoseGroup(SpyglassMixin, dj.Manual): + definition = """ + pose_group_name: varchar(80) + ---- + body_parts = NULL: longblob # list of body parts to include in the pose + """ + + class Pose(SpyglassMixinPart): + definition = """ + -> PoseGroup + -> PoseOutput.proj(pose_merge_id='merge_id') + """ + + def create_group( + self, + group_name: str, + keys: list[dict], + pose_variables: list[str] = None, + ): + """create a group of pose information + + Parameters + ---------- + group_name : str + name of the group + keys : list[dict] + list of keys from PoseOutput to include in the group + pose_variables : list[str], optional + body parts to include in the group, by default None includes all from every set + """ + group_key = { + "pose_group_name": group_name, + } + self.insert1( + { + **group_key, + "pose_variables": pose_variables, + }, + skip_duplicates=True, + ) + for key in keys: + self.Pose.insert1( + { + **key, + **group_key, + }, + skip_duplicates=True, + ) + + def fetch_pose_datasets(self, key: dict): + """fetch pose information for a group of videos + + Parameters + ---------- + key : dict + group key + + Returns + ------- + dict + dictionary of video name to pose dataset + """ + datasets = {} + for merge_key in self.Pose & key: + video_name = Path((PoseOutput & merge_key).fetch_video_name()).stem + datasets[video_name] = ( + PoseOutput & merge_key + ).fetch_dataset() # TODO: restrict returned dataframe to bodyparts of interest + return datasets diff --git a/src/spyglass/position/position_merge.py b/src/spyglass/position/position_merge.py index 72e330af6..1de935482 100644 --- a/src/spyglass/position/position_merge.py +++ b/src/spyglass/position/position_merge.py @@ -14,6 +14,7 @@ make_video, ) from spyglass.position.v1.position_dlc_pose_estimation import ( + DLCPoseEstimation, DLCPoseEstimationSelection, ) from spyglass.position.v1.position_dlc_selection import DLCPosV1 @@ -26,6 +27,7 @@ "IntervalPositionInfo": CommonPos, "DLCPosV1": DLCPosV1, "TrodesPosV1": TrodesPosV1, + "DLCPoseEstimation": DLCPoseEstimation, } @@ -260,3 +262,51 @@ def make(self, key): disable_progressbar=False, ) self.insert1(key) + + +@schema +class PoseOutput(_Merge, SpyglassMixin): + """ + Table to identify source of keypoint(s) tracking animal Pose from upstream options + (e.g. DLC, Sleap, etc...) To add another upstream option, a new Part table + should be added in the same syntax as DLCPos and TrodesPos. + """ + + definition = """ + merge_id: uuid + --- + source: varchar(32) + """ + + class DLCPoseEstimation(SpyglassMixin, dj.Part): + """ + Table to pass-through upstream DLC Pose Estimation information + """ + + definition = """ + -> PoseOutput + --- + -> DLCPoseEstimation + """ + + def fetch_dataframe(self): + # proj replaces operator restriction to enable + # (TableName & restriction).fetch1_dataframe() + key = self.merge_restrict(self.proj()).proj() + query = ( + source_class_dict[ + to_camel_case(self.merge_get_parent(self.proj()).table_name) + ] + & key + ) + return query.fetch_dataframe() + + def fetch_video_name(self): + key = self.merge_restrict(self.proj()).proj() + query = ( + source_class_dict[ + to_camel_case(self.merge_get_parent(self.proj()).table_name) + ] + & key + ) + return query.fetch_video_name() diff --git a/src/spyglass/position/v1/position_dlc_pose_estimation.py b/src/spyglass/position/v1/position_dlc_pose_estimation.py index 6ae7669bf..8252ee039 100644 --- a/src/spyglass/position/v1/position_dlc_pose_estimation.py +++ b/src/spyglass/position/v1/position_dlc_pose_estimation.py @@ -406,6 +406,16 @@ def fetch_dataframe(self, *attrs, **kwargs): axis=1, ) + def fetch_video_name(self): + """Return the video path for pose estimate + + Returns + ------- + str + absolute path to video file + """ + return (DLCPoseEstimationSelection & self).fetch1("video_path") + def convert_to_cm(df, meters_to_pixels): CM_TO_METERS = 100 From 28748f125fcce3fae837f87b597230f2e250faff Mon Sep 17 00:00:00 2001 From: Sam Bray Date: Tue, 11 Jun 2024 15:37:44 -0700 Subject: [PATCH 02/42] Add model training tables --- src/spyglass/behavior/core.py | 109 ++++++++++++++++++--- src/spyglass/behavior/moseq.py | 173 +++++++++++++++++++++++++++++++++ 2 files changed, 269 insertions(+), 13 deletions(-) create mode 100644 src/spyglass/behavior/moseq.py diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/core.py index 0453c1817..1779a8dc0 100644 --- a/src/spyglass/behavior/core.py +++ b/src/spyglass/behavior/core.py @@ -1,6 +1,9 @@ from pathlib import Path +from uuid import uuid4 import datajoint as dj +import numpy as np +import pandas as pd from spyglass.position.position_merge import PoseOutput from spyglass.utils import SpyglassMixin, SpyglassMixinPart @@ -13,7 +16,7 @@ class PoseGroup(SpyglassMixin, dj.Manual): definition = """ pose_group_name: varchar(80) ---- - body_parts = NULL: longblob # list of body parts to include in the pose + bodyparts = NULL: longblob # list of body parts to include in the pose """ class Pose(SpyglassMixinPart): @@ -25,8 +28,8 @@ class Pose(SpyglassMixinPart): def create_group( self, group_name: str, - keys: list[dict], - pose_variables: list[str] = None, + merge_ids: list[str], + bodyparts: list[str] = None, ): """create a group of pose information @@ -36,7 +39,7 @@ def create_group( name of the group keys : list[dict] list of keys from PoseOutput to include in the group - pose_variables : list[str], optional + bodyparts : list[str], optional body parts to include in the group, by default None includes all from every set """ group_key = { @@ -45,36 +48,116 @@ def create_group( self.insert1( { **group_key, - "pose_variables": pose_variables, + "bodyparts": bodyparts, }, skip_duplicates=True, ) - for key in keys: + for merge_id in merge_ids: self.Pose.insert1( { - **key, **group_key, + "pose_merge_id": merge_id, }, skip_duplicates=True, ) - def fetch_pose_datasets(self, key: dict): + def fetch_pose_datasets( + self, key: dict = None, format_for_moseq: bool = False + ): """fetch pose information for a group of videos Parameters ---------- key : dict group key + format_for_moseq : bool, optional + format for MoSeq, by default False Returns ------- dict dictionary of video name to pose dataset """ + if key is None: + key = {} + + bodyparts = (self & key).fetch1("bodyparts") datasets = {} - for merge_key in self.Pose & key: - video_name = Path((PoseOutput & merge_key).fetch_video_name()).stem - datasets[video_name] = ( - PoseOutput & merge_key - ).fetch_dataset() # TODO: restrict returned dataframe to bodyparts of interest + for merge_key in (self.Pose & key).proj(merge_id="pose_merge_id"): + video_name = ( + Path((PoseOutput & merge_key).fetch_video_name()).stem + ".mp4" + ) + bodyparts_df = (PoseOutput & merge_key).fetch_dataframe() + if bodyparts is None: + bodyparts = ( + bodyparts_df.keys().get_level_values(0).unique().values + ) + bodyparts_df = bodyparts_df[bodyparts] + datasets[video_name] = bodyparts_df + if format_for_moseq: + datasets = format_dataset_for_moseq(datasets, bodyparts) return datasets + + def fetch_video_paths(self, key: dict = None): + """fetch video paths for a group of videos + + Parameters + ---------- + key : dict + group key + + Returns + ------- + list[Path] + list of video paths + """ + if key is None: + key = {} + video_paths = [ + Path((PoseOutput & merge_key).fetch_video_name()) + for merge_key in (self.Pose & key).proj(merge_id="pose_merge_id") + ] + return video_paths + + +def format_dataset_for_moseq( + datasets: dict[str, pd.DataFrame], + bodyparts: list[str], + coordinate_axes: list[str] = ["x", "y"], +): + """format pose datasets for MoSeq + + Parameters + ---------- + datasets : dict[str, pd.DataFrame] + dictionary of video name to pose dataset + bodyparts : list[str] + list of body parts to include in the pose + + Returns + ------- + tuple[dict[str, np.ndarray], dict[str, np.ndarray] + coordinates and confidences for each video + """ + num_keypoints = len(bodyparts) + num_dimensions = len(coordinate_axes) + coordinates = {} + confidences = {} + + for video_name, bodyparts_df in datasets.items(): + coordinates_i = None + confidences_i = None + for i, bodypart in enumerate(bodyparts): + part_df = bodyparts_df[bodypart] + print(len(part_df)) + if coordinates_i is None: + num_frames = len(part_df) + coordinates_i = np.empty( + (num_frames, num_keypoints, num_dimensions) + ) + confidences_i = np.empty((num_frames, num_keypoints)) + coordinates_i[:, i, :] = part_df[coordinate_axes].values + confidences_i[:, i] = part_df["likelihood"].values + coordinates[video_name] = coordinates_i + confidences[video_name] = confidences_i + return coordinates, confidences diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py new file mode 100644 index 000000000..1183e9f13 --- /dev/null +++ b/src/spyglass/behavior/moseq.py @@ -0,0 +1,173 @@ +import os + +import datajoint as dj +import keypoint_moseq as kpms + +from spyglass.utils import SpyglassMixin + +from .core import PoseGroup + +schema = dj.schema("moseq_v1") + + +@schema +class MoseqModelParams(SpyglassMixin, dj.Manual): + definition = """ + model_params_name: varchar(80) + --- + model_params: longblob + """ + + +@schema +class MoseqModelSelection(SpyglassMixin, dj.Manual): + definition = """ + -> PoseGroup + -> MoseqModelParams + """ + # relevant parameters: + # - skeleton + # - num_ar_iters + # - kappa + # - num_epochs + # - anterior_bodyparts + # - posterior_bodyparts + + +@schema +class MoseqModel(SpyglassMixin, dj.Computed): + definition = """ + -> MoseqModelSelection + --- + project_dir: varchar(255) + epochs_trained: int + """ + + def make(self, key): + """Method to train a model and insert the resulting model into the MoseqModel table + + Parameters + ---------- + key : dict + key to a single MoseqModelSelection table entry + """ + model_params = (MoseqModelParams & key).fetch1("model_params") + + # set up the project and config + project_dir = ( + "/home/sambray/Documents/moseq_test_proj" # TODO: make this better + ) + video_dir = ( + "/home/sambray/Documents/moseq_test_vids" # TODO: make this better + ) + # make symlinks to the videos in a single directory + os.makedirs(video_dir, exist_ok=True) + video_paths = (PoseGroup & key).fetch_video_paths() + for video in video_paths: + destination = os.path.join(video_dir, os.path.basename(video)) + if not os.path.exists(destination): + os.symlink(video, destination) + bodyparts = (PoseGroup & key).fetch1("bodyparts") + skeleton = model_params["skeleton"] + anterior_bodyparts = model_params.get("anterior_bodyparts", None) + posterior_bodyparts = model_params.get("posterior_bodyparts", None) + + kpms.setup_project( + str(project_dir), + video_dir=str(video_dir), + bodyparts=bodyparts, + skeleton=skeleton, + use_bodyparts=bodyparts, + anterior_bodyparts=anterior_bodyparts, + posterior_bodyparts=posterior_bodyparts, + ) + + config = lambda: kpms.load_config(project_dir) + + # fetch the data and format it for moseq + coordinates, confidences = PoseGroup().fetch_pose_datasets( + key, format_for_moseq=True + ) + data, metadata = kpms.format_data(coordinates, confidences, **config()) + + # fit pca of data + pca = kpms.fit_pca(**data, **config()) + kpms.save_pca(pca, project_dir) + + # create the model + model = kpms.init_model(data, pca=pca, **config()) + # run the autoregressive fit on the model + num_ar_iters = model_params["num_ar_iters"] + model, model_name = kpms.fit_model( + model, + data, + metadata, + project_dir, + ar_only=True, + num_iters=num_ar_iters, + ) + # load model checkpoint + model, data, metadata, current_iter = kpms.load_checkpoint( + project_dir, model_name, iteration=num_ar_iters + ) + # update the hyperparameters + kappa = model_params["kappa"] + model = kpms.update_hypparams(model, kappa=kappa) + # run fitting on the complete model + num_epochs = model_params["num_epochs"] + model = kpms.fit_model( + model, + data, + metadata, + project_dir, + model_name, + ar_only=False, + start_iter=current_iter, + num_iters=current_iter + num_epochs, + )[0] + # reindex syllables by frequency + kpms.reindex_syllables_in_checkpoint(project_dir, model_name) + + self.insert1( + { + **key, + "project_dir": project_dir, + "epochs_trained": num_epochs + num_ar_iters, + } + ) + + def extend_training(self, key: dict, num_epochs: int): + """Method to run additional training epochs on a model and update the epochs_trained attribute + + Parameters + ---------- + key : dict + key to a single MoseqModel table entry + + Raises + ------ + NotImplementedError + This method is not implemented yet. + """ + raise NotImplementedError("This method is not implemented yet.") + + def analyze_pca(self, key: dict): + """Method to analyze the PCA of a model + + Parameters + ---------- + key : dict + key to a single MoseqModel table entry + + Raises + ------ + NotImplementedError + This method is not implemented yet. + """ + raise NotImplementedError("This method is not implemented yet.") + pca = kpms.fit_pca(**data, **config()) + kpms.save_pca(pca, project_dir) + + kpms.print_dims_to_explain_variance(pca, 0.9) + kpms.plot_scree(pca, project_dir=project_dir) + kpms.plot_pcs(pca, project_dir=project_dir, **config()) From 7d5d66c10f551e3070a1b056b4f5e59cebe3eb1c Mon Sep 17 00:00:00 2001 From: Sam Bray Date: Thu, 13 Jun 2024 08:28:50 -0700 Subject: [PATCH 03/42] apply fit moseq model to data --- src/spyglass/behavior/core.py | 36 +++++++++ src/spyglass/behavior/moseq.py | 143 ++++++++++++++++++++++++++++++--- 2 files changed, 170 insertions(+), 9 deletions(-) diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/core.py index 1779a8dc0..6b1ceaa43 100644 --- a/src/spyglass/behavior/core.py +++ b/src/spyglass/behavior/core.py @@ -161,3 +161,39 @@ def format_dataset_for_moseq( coordinates[video_name] = coordinates_i confidences[video_name] = confidences_i return coordinates, confidences + + +def results_to_df(results): + for key in results.keys(): + column_names, data = [], [] + + if "syllable" in results[key].keys(): + column_names.append(["syllable"]) + data.append(results[key]["syllable"].reshape(-1, 1)) + + if "centroid" in results[key].keys(): + d = results[key]["centroid"].shape[1] + column_names.append(["centroid x", "centroid y", "centroid z"][:d]) + data.append(results[key]["centroid"]) + + if "heading" in results[key].keys(): + column_names.append(["heading"]) + data.append(results[key]["heading"].reshape(-1, 1)) + + if "latent_state" in results[key].keys(): + latent_dim = results[key]["latent_state"].shape[1] + column_names.append( + [f"latent_state {i}" for i in range(latent_dim)] + ) + data.append(results[key]["latent_state"]) + + dfs = [ + pd.DataFrame(arr, columns=cols) + for arr, cols in zip(data, column_names) + ] + df = pd.concat(dfs, axis=1) + + for col in df.select_dtypes(include=[np.floating]).columns: + df[col] = df[col].astype(float).round(4) + + return df diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index 1183e9f13..b694ac842 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -1,11 +1,14 @@ import os +from pathlib import Path import datajoint as dj import keypoint_moseq as kpms +from spyglass.common import AnalysisNwbfile +from spyglass.position.position_merge import PoseOutput from spyglass.utils import SpyglassMixin -from .core import PoseGroup +from .core import PoseGroup, format_dataset_for_moseq, results_to_df schema = dj.schema("moseq_v1") @@ -41,6 +44,7 @@ class MoseqModel(SpyglassMixin, dj.Computed): --- project_dir: varchar(255) epochs_trained: int + model_name = "": varchar(255) """ def make(self, key): @@ -51,17 +55,22 @@ def make(self, key): key : dict key to a single MoseqModelSelection table entry """ + # TODO: make config a method + # TODO: set kappa during ARHMM + # TODO: make pca components settable + model_params = (MoseqModelParams & key).fetch1("model_params") # set up the project and config project_dir = ( - "/home/sambray/Documents/moseq_test_proj" # TODO: make this better + "/home/sambray/Documents/moseq_test_proj2" # TODO: make this better ) video_dir = ( - "/home/sambray/Documents/moseq_test_vids" # TODO: make this better + "/home/sambray/Documents/moseq_test_vids2" # TODO: make this better ) # make symlinks to the videos in a single directory os.makedirs(video_dir, exist_ok=True) + # os.makedirs(project_dir, exist_ok=True) video_paths = (PoseGroup & key).fetch_video_paths() for video in video_paths: destination = os.path.join(video_dir, os.path.basename(video)) @@ -127,12 +136,12 @@ def make(self, key): )[0] # reindex syllables by frequency kpms.reindex_syllables_in_checkpoint(project_dir, model_name) - self.insert1( { **key, "project_dir": project_dir, "epochs_trained": num_epochs + num_ar_iters, + "model_name": model_name, } ) @@ -151,7 +160,7 @@ def extend_training(self, key: dict, num_epochs: int): """ raise NotImplementedError("This method is not implemented yet.") - def analyze_pca(self, key: dict): + def analyze_pca(self, key: dict = None): """Method to analyze the PCA of a model Parameters @@ -164,10 +173,126 @@ def analyze_pca(self, key: dict): NotImplementedError This method is not implemented yet. """ - raise NotImplementedError("This method is not implemented yet.") - pca = kpms.fit_pca(**data, **config()) - kpms.save_pca(pca, project_dir) - + if key is None: + key = {} + project_dir = (self & key).fetch1("project_dir") + pca = kpms.load_pca(project_dir) + config = lambda: kpms.load_config(project_dir) kpms.print_dims_to_explain_variance(pca, 0.9) kpms.plot_scree(pca, project_dir=project_dir) kpms.plot_pcs(pca, project_dir=project_dir, **config()) + + def fetch_model(self, key: dict = None): + """Method to fetch the model from the MoseqModel table + + Parameters + ---------- + key : dict + key to a single MoseqModel table entry + + Returns + ------- + dict + model dictionary + """ + if key is None: + key = {} + model = kpms.load_checkpoint( + (self & key).fetch1("project_dir"), + (self & key).fetch1("model_name"), + )[0] + return model + + +@schema +class MoseqSyllableSelection(SpyglassMixin, dj.Manual): + definition = """ + -> PoseOutput.proj(pose_merge_id='merge_id') + -> MoseqModel + --- + num_iters = 500: int + """ + + def insert(self, rows, **kwargs): + """Override insert to check that the bodyparts in the model are in the data""" + for row in rows: + self.validate_bodyparts(row) + super().insert(rows, **kwargs) + + def validate_bodyparts(self, key): + if self & key: + return + model_bodyparts = (PoseGroup & key).fetch1("bodyparts") + merge_key = {"merge_id": key["pose_merge_id"]} + bodyparts_df = (PoseOutput & merge_key).fetch_dataframe() + data_bodyparts = bodyparts_df.keys().get_level_values(0).unique().values + for bodypart in model_bodyparts: + if bodypart not in data_bodyparts: + raise ValueError( + f"Error in row {row}: " + f"Bodypart {bodypart} not in data" + ) + + +@schema +class MoseqSyllable(SpyglassMixin, dj.Computed): + definition = """ + -> MoseqSyllableSelection + --- + -> AnalysisNwbfile + moseq_object_id: int + """ + + def make(self, key): + model = MoseqModel().fetch_model(key) + project_dir = (MoseqModel & key).fetch1("project_dir") + # video_dir = ( + # "/home/sambray/Documents/moseq_test_vids2" # TODO: make this better + # ) + + merge_key = {"merge_id": key["pose_merge_id"]} + bodyparts = (PoseGroup & key).fetch1("bodyparts") + config = lambda: kpms.load_config(project_dir) + model_name = (MoseqModel & key).fetch1("model_name") + num_iters = (MoseqSyllableSelection & key).fetch1("num_iters") + + # load data and format for moseq + video_path = (PoseOutput & merge_key).fetch_video_name() + video_name = Path(video_path).stem + ".mp4" + bodyparts_df = (PoseOutput & merge_key).fetch_dataframe() + + if bodyparts is None: + bodyparts = bodyparts_df.keys().get_level_values(0).unique().values + datasets = {video_name: bodyparts_df[bodyparts]} + coordinates, confidences = format_dataset_for_moseq(datasets, bodyparts) + data, metadata = kpms.format_data(coordinates, confidences, **config()) + + # apply model + results = kpms.apply_model( + model, + data, + metadata, + project_dir, + model_name, + **config(), + num_iters=num_iters, + ) + + # format results into dataframe for saving + results_df = results_to_df(results) + results_df.index = bodyparts_df.index + + # save results into a nwbfile + nwb_file_name = PoseOutput.merge_get_parent(merge_key).fetch1( + "nwb_file_name" + ) + nwb_file_name = PoseOutput.merge_get_parent(merge_key).fetch1( + "nwb_file_name" + ) + analysis_file_name = AnalysisNwbfile().create(nwb_file_name) + key["analysis_file_name"] = analysis_file_name + key["moseq_object_id"] = AnalysisNwbfile().add_nwb_object( + analysis_file_name, results_df.reset_index(), "moseq" + ) + AnalysisNwbfile().add(nwb_file_name, analysis_file_name) + + self.insert1(key) From 09779a6d45aa5191565756850aa496913fd15efa Mon Sep 17 00:00:00 2001 From: Sam Bray Date: Thu, 13 Jun 2024 11:47:03 -0700 Subject: [PATCH 04/42] add ability to initialize model training from pre-existing model --- src/spyglass/behavior/moseq.py | 112 ++++++++++++++++++++++++++------- 1 file changed, 89 insertions(+), 23 deletions(-) diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index b694ac842..55ac2e375 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -21,6 +21,52 @@ class MoseqModelParams(SpyglassMixin, dj.Manual): model_params: longblob """ + def make_training_extension_params( + self, model_key, num_epochs, new_name=None, skip_duplicates=False + ): + """Method to create a new set of model parameters for extending training + + Parameters + ---------- + model_key : dict + key to a single MoseqModelSelection table entry + num_epochs : int + number of epochs to extend training by + new_name : str, optional + name for the new model parameters, by default None + skip_duplicates : bool, optional + whether to skip duplicates, by default False + Returns + ------- + dict + key to a single MoseqModelParams table entry + """ + model_key = (MoseqModel & model_key).fetch1("KEY") + model_params = (self & model_key).fetch1("model_params") + model_params["num_epochs"] = num_epochs + model_params["initial_model"] = model_key + # increment param name + if new_name is None: + # increment the extension number + if model_key["model_params_name"][:-1].endswith("_extension"): + new_name = ( + model_key["model_params_name"][:-3] + + f"{int(model_key['model_params_name'][-3:]) + 1:03}" + ) + # add an extension number + else: + new_name = ( + model_key["pose_group_name"] + + model_key["model_params_name"] + + "_extension001" + ) + new_key = { + "model_params_name": new_name, + "model_params": model_params, + } + self.insert1(new_key, skip_duplicates=skip_duplicates) + return new_key + @schema class MoseqModelSelection(SpyglassMixin, dj.Manual): @@ -99,26 +145,41 @@ def make(self, key): ) data, metadata = kpms.format_data(coordinates, confidences, **config()) - # fit pca of data - pca = kpms.fit_pca(**data, **config()) - kpms.save_pca(pca, project_dir) + initial_model_key = model_params.get("initial_model", None) + if initial_model_key is None: + # fit pca of data + pca = kpms.fit_pca(**data, **config()) + kpms.save_pca(pca, project_dir) + + # create the model + model = kpms.init_model(data, pca=pca, **config()) + # run the autoregressive fit on the model + num_ar_iters = model_params["num_ar_iters"] + model, model_name = kpms.fit_model( + model, + data, + metadata, + project_dir, + ar_only=True, + num_iters=num_ar_iters, + ) + epochs_trained = num_ar_iters + # load model checkpoint + model, data, metadata, current_iter = kpms.load_checkpoint( + project_dir, model_name, iteration=num_ar_iters + ) + + else: + # begin training from an existing model + query = MoseqModel & initial_model_key + if not query: + raise ValueError( + f"Initial model: {initial_model_key} not found" + ) + model = query.fetch_model() + model_name = query.fetch1("model_name") + epochs_trained = query.fetch1("epochs_trained") - # create the model - model = kpms.init_model(data, pca=pca, **config()) - # run the autoregressive fit on the model - num_ar_iters = model_params["num_ar_iters"] - model, model_name = kpms.fit_model( - model, - data, - metadata, - project_dir, - ar_only=True, - num_iters=num_ar_iters, - ) - # load model checkpoint - model, data, metadata, current_iter = kpms.load_checkpoint( - project_dir, model_name, iteration=num_ar_iters - ) # update the hyperparameters kappa = model_params["kappa"] model = kpms.update_hypparams(model, kappa=kappa) @@ -131,8 +192,8 @@ def make(self, key): project_dir, model_name, ar_only=False, - start_iter=current_iter, - num_iters=current_iter + num_epochs, + start_iter=epochs_trained, + num_iters=epochs_trained + num_epochs, )[0] # reindex syllables by frequency kpms.reindex_syllables_in_checkpoint(project_dir, model_name) @@ -140,7 +201,7 @@ def make(self, key): { **key, "project_dir": project_dir, - "epochs_trained": num_epochs + num_ar_iters, + "epochs_trained": num_epochs + epochs_trained, "model_name": model_name, } ) @@ -239,7 +300,7 @@ class MoseqSyllable(SpyglassMixin, dj.Computed): -> MoseqSyllableSelection --- -> AnalysisNwbfile - moseq_object_id: int + moseq_object_id: varchar(80) """ def make(self, key): @@ -296,3 +357,8 @@ def make(self, key): AnalysisNwbfile().add(nwb_file_name, analysis_file_name) self.insert1(key) + + def fetch1_dataframe(self): + dataframe = self.fetch_nwb()[0]["moseq"] + dataframe.set_index("time", inplace=True) + return dataframe From 983f179db672ad46d77c396ac23f92d284cb8b30 Mon Sep 17 00:00:00 2001 From: Sam Bray Date: Thu, 13 Jun 2024 12:43:51 -0700 Subject: [PATCH 05/42] make model names unique --- src/spyglass/behavior/moseq.py | 32 ++++++++++++++------------------ 1 file changed, 14 insertions(+), 18 deletions(-) diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index 55ac2e375..336931528 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -1,3 +1,4 @@ +import hashlib import os from pathlib import Path @@ -145,6 +146,8 @@ def make(self, key): ) data, metadata = kpms.format_data(coordinates, confidences, **config()) + # either initialize a new model or load an existing one + model_name = self._make_model_name(key) initial_model_key = model_params.get("initial_model", None) if initial_model_key is None: # fit pca of data @@ -162,12 +165,13 @@ def make(self, key): project_dir, ar_only=True, num_iters=num_ar_iters, + model_name=model_name + "_ar", ) epochs_trained = num_ar_iters # load model checkpoint - model, data, metadata, current_iter = kpms.load_checkpoint( - project_dir, model_name, iteration=num_ar_iters - ) + # model, data, metadata, current_iter = kpms.load_checkpoint( + # project_dir, model_name, iteration=num_ar_iters + # ) else: # begin training from an existing model @@ -177,7 +181,6 @@ def make(self, key): f"Initial model: {initial_model_key} not found" ) model = query.fetch_model() - model_name = query.fetch1("model_name") epochs_trained = query.fetch1("epochs_trained") # update the hyperparameters @@ -206,20 +209,13 @@ def make(self, key): } ) - def extend_training(self, key: dict, num_epochs: int): - """Method to run additional training epochs on a model and update the epochs_trained attribute - - Parameters - ---------- - key : dict - key to a single MoseqModel table entry - - Raises - ------ - NotImplementedError - This method is not implemented yet. - """ - raise NotImplementedError("This method is not implemented yet.") + def _make_model_name(self, key: dict = None): + # make a unique model name based on the key + if key is None: + key = {} + key = (MoseqModelSelection & key).fetch1("KEY") + key_string = "_".join(key.values()) + return hashlib.sha1(key_string.encode("utf-8")).hexdigest()[:10] def analyze_pca(self, key: dict = None): """Method to analyze the PCA of a model From fdaff80d74fd59a42d85a2c26e536aa3af0fdfbd Mon Sep 17 00:00:00 2001 From: Sam Bray Date: Thu, 13 Jun 2024 12:50:04 -0700 Subject: [PATCH 06/42] add initial tutorial --- notebooks/60_MoSeq.ipynb | 1840 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 1840 insertions(+) create mode 100644 notebooks/60_MoSeq.ipynb diff --git a/notebooks/60_MoSeq.ipynb b/notebooks/60_MoSeq.ipynb new file mode 100644 index 000000000..b22c0c015 --- /dev/null +++ b/notebooks/60_MoSeq.ipynb @@ -0,0 +1,1840 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MoSeq Pipeline Tutorial\n", + "\n", + "**NOTE: This notebook is a work in progress.**\n", + "\n", + "This notebook provides a tutorial on how to use the MoSeq pipeline to analyze behavioral data. The pipeline is a tool for taking keypoint pose estimations and extracting behavioral syllables." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2024-06-12 16:01:13,293][WARNING]: MySQL server has gone away. Reconnecting to the server.\n", + "WARNING:datajoint:MySQL server has gone away. Reconnecting to the server.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + }, + { + "data": { + "text/plain": [ + "PosixPath('/nimbus/deeplabcut/projects/sideHomeOfficial-sc_eb-2024-04-16/videos')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import spyglass.position.v1 as sgp\n", + "from pathlib import Path\n", + "import numpy as np\n", + "\n", + "pose_estimation_key = {'nwb_file_name': 'SC100020230912_.nwb',\n", + " 'epoch': 9,\n", + " 'video_file_num': 14,\n", + " 'project_name': 'sideHomeOfficial',\n", + " 'dlc_model_name': 'sideHomeOfficial_tutorial_00',\n", + " 'dlc_model_params_name': 'default',\n", + " 'task_mode': 'trigger'}\n", + "\n", + "\n", + "(sgp.DLCPoseEstimation.BodyPart & pose_estimation_key).fetch('bodypart')\n", + "Path((sgp.DLCProject & pose_estimation_key).fetch1('config_path')).parents[0]/\"videos\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add Pose data to merge table" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# part_name = to_camel_case(self.table_name.split(\"__\")[-1])\n", + "\n", + "# TODO: The next line belongs in a merge table function\n", + "# PoseOutput._merge_insert(\n", + "# [insert_key], part_name=\"DLCPoseEstimation\", skip_duplicates=True\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create Pose Group for training" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from spyglass.position.position_merge import PoseOutput\n", + "from spyglass.behavior.core import PoseGroup\n", + "merge_key = PoseOutput().fetch(\"merge_id\")\n", + "PoseGroup().create_group(\"sb_test_group\", merge_key, ['forelimbL', 'forelimbR', 'nose',\n", + " 'spine1', 'spine3', 'spine5',\n", + " 'tailBase'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# test loading data from pose group\n", + "# %load_ext autoreload\n", + "# %autoreload 2\n", + "# from spyglass.behavior.core import PoseGroup\n", + "# PoseGroup().fetch_pose_datasets({'group_name': 'sb_test_group'}, format_for_moseq=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Make Moseq Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "
\n", + "

model_params_name

\n", + " \n", + "
\n", + "

model_params

\n", + " \n", + "
sb_testing_kappa-4=BLOB=
sb_testing_kappa0_mini=BLOB=
sb_testing_kappa4_mini=BLOB=
\n", + " \n", + "

Total: 3

\n", + " " + ], + "text/plain": [ + "*model_params_ model_para\n", + "+------------+ +--------+\n", + "sb_testing_kap =BLOB= \n", + "sb_testing_kap =BLOB= \n", + "sb_testing_kap =BLOB= \n", + " (Total: 3)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "from spyglass.behavior.moseq import MoseqModel, MoseqModelParams, MoseqModelSelection\n", + "\n", + "model_params_name = \"sb_testing_kappa4_mini\"\n", + "params = {}\n", + "params['skeleton'] = [['nose','spine1'],\n", + " ['spine1','forelimbL'],\n", + " ['spine1','forelimbR'],\n", + " ['spine1','spine3'],\n", + " ['spine3','spine5'],\n", + " ['spine5','tailBase']]\n", + "params['kappa'] = 1e4\n", + "params['num_ar_iters'] = 50\n", + "params['num_epochs'] = 50\n", + "params[\"anterior_bodyparts\"] = [\"nose\"]\n", + "params[\"posterior_bodyparts\"] = [\"tailBase\"]\n", + "# MoseqModelParams().update1({'model_params_name': model_params_name, 'model_params': params},)# skip_duplicates=True)\n", + "MoseqModelParams().insert1({'model_params_name': model_params_name, 'model_params': params}, skip_duplicates=True)\n", + "MoseqModelParams()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "
\n", + "

pose_group_name

\n", + " \n", + "
\n", + "

model_params_name

\n", + " \n", + "
sb_test_groupsb_testing_kappa-4
sb_test_groupsb_testing_kappa0_mini
sb_test_groupsb_testing_kappa4_mini
\n", + " \n", + "

Total: 3

\n", + " " + ], + "text/plain": [ + "*pose_group_na *model_params_\n", + "+------------+ +------------+\n", + "sb_test_group sb_testing_kap\n", + "sb_test_group sb_testing_kap\n", + "sb_test_group sb_testing_kap\n", + " (Total: 3)" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MoseqModelSelection().insert1({'model_params_name': model_params_name,\n", + " \"pose_group_name\":\"sb_test_group\"}, skip_duplicates=True)\n", + "\n", + "MoseqModelSelection()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The directory `/home/sambray/Documents/moseq_test_proj2` already\n", + "exists. Use `overwrite=True` or pick a different name\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "Outputs will be saved to\n", + "/home/sambray/Documents/moseq_test_proj2/2024_06_12-11_40_09\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 49%|█████████████████▏ | 25/51 [00:31<00:32, 1.23s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 98%|██████████████████████████████████▎| 50/51 [01:05<00:01, 1.24s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████| 51/51 [01:07<00:00, 1.32s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Outputs will be saved to\n", + "/home/sambray/Documents/moseq_test_proj2/2024_06_12-11_40_09\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 49%|█████████████████▏ | 25/51 [00:40<00:35, 1.37s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 98%|██████████████████████████████████▎| 50/51 [01:15<00:01, 1.37s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████| 51/51 [01:17<00:00, 1.52s/it]\n", + "Reindexing: 100%|█████████████| 5/5 [00:00<00:00, 5.27model snapshot/s]\n" + ] + } + ], + "source": [ + "MoseqModel().populate()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">=90.0% of variance exlained by 6 components.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA94AAADuCAYAAADP/98bAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC9JElEQVR4nOzddVwc19rA8d8a7g4RSIi7uyvxxpv21j3VW+/b3rreenvrmkrc3ZPG3YmHJCRACO6wNu8fs0HCEmWR8Hw/5dNlZnb2DOHhnGfmiEZRFAUhhBBCCCGEEEI4hLayCyCEEEIIIYQQQtzKJPEWQgghhBBCCCEcSBJvIYQQQgghhBDCgSTxFkIIIYQQQgghHEgSbyGEEEIIIYQQwoEk8RZCCCGEEEIIIRxIEm8hhBBCCCGEEMKBJPEWQgghhBBCCCEcSBJvIYQQQgghhBDCgSTxFkIIIYQQQgghHEgSbwe599570Wg0aDQaDAYD9evX5/nnnycnJ6fEcXPmzKFPnz54e3vj4eFBq1atePvtt0lNTS3z3O+99x7dunXDzc0NHx8fB1+JEOXDUTFx5swZHnjgAerVq4erqyuRkZG88cYbGI3GirgsIW6YI+uJkSNHUrduXVxcXAgNDeWuu+4iPj7e0ZckxE1xZExcUlBQQJs2bdBoNOzbt89BVyJE+XBkTERERBSe+9LXyy+/7OhLqtEk8XagqKgoEhISiImJ4d133+Xbb7/l+eefL9z/6quvMnHiRDp27MiyZcs4dOgQn376Kfv37+fPP/8s87xGo5Hx48fz2GOPVcRlCFFuHBETR48exWq18sMPPxAdHc3nn3/O999/z//93/9V1GUJccMcVU/07duXmTNncuzYMebMmcOpU6cYN25cRVySEDfFUTFxyYsvvkhYWJgjL0GIcuXImHj77bdJSEgo/HrttdccfTk1myIc4p577lFGjRpVYtuDDz6ohISEKIqiKNu3b1cA5YsvvrD7/rS0tKt+xm+//aZ4e3vfZEmFqBgVEROX/Pe//1Xq1at3o0UVokJUZEwsWLBA0Wg0itFovNHiCuFwjo6JpUuXKk2aNFGio6MVQNm7d285lFoIx3FkTISHhyuff/55OZVUXAt54l2BXF1dMZlMAPz99994eHgwefJku8dKF3JREzgqJjIyMvDz8yuPIgpRoRwRE6mpqfz9999069YNg8FQXkUVokKUV0wkJiby0EMP8eeff+Lm5uaIogpRIcqznvjoo4/w9/enTZs2vPfeezJMz8Ek8a4gO3bsYOrUqfTv3x+AEydOUL9+fWkEiRrLUTFx6tQpvv76ax599NHyKKYQFaa8Y+Kll17C3d0df39/YmNjWbBgQXkWVwiHK6+YUBSFe++9l0cffZQOHTo4oqhCVIjyrCeefvpppk+fzrp163jiiSf44osvykzgRfnQV3YBbmWLFy/Gw8MDs9mMyWRi1KhRfP3114BaCWg0mkouoRAVy9ExER8fT1RUFOPHj+fBBx8sjyIL4VCOjIkXXniBBx54gLNnz/LWW29x9913s3jxYql7RJXmiJj4+uuvyczM5JVXXinv4grhcI6qJ/79738Xvm7VqhW+vr6MGzeu8Cm4KH+SeDtQ3759+e677zAYDISFhZW4G9WoUSM2bdqEyWSSp96ixnBkTMTHx9O3b1+6du3Kjz/+WJ7FFsJhHBkTAQEBBAQE0KhRI5o2bUqdOnXYtm0bXbt2Lc9LEKJcOSIm1q5dy7Zt23B2di6xvUOHDtx5551MmTKl3MovRHmrqHyiS5cuAJw8eVISbweRruYO5O7uToMGDQgPDy8VDHfccQfZ2dl8++23dt+bnp5eASUUomI5Kibi4uLo06cP7dq147fffkOrlT9tonqoqHpCURRAXUpJiKrMETHx1VdfsX//fvbt28e+fftYunQpADNmzOC9994r1/ILUd4qqp7Yu3cvAKGhoTdcVnFl8sS7knTu3JkXX3yR5557jri4OEaPHk1YWBgnT57k+++/p0ePHjz99NN23xsbG0tqaiqxsbFYLJbCdSgbNGiAh4dHBV6FEOXnRmMiPj6ePn36ULduXT755BOSkpIK94WEhFTkJQhRrm40Jnbs2MGOHTvo0aMHvr6+xMTE8PrrrxMZGSlPu0W1dqMxUbdu3RLfX2orRUZGUrt27QopuxCOcKMxsXXrVrZt20bfvn3x9vZm586d/Pvf/2bkyJGl4kWUH0m8K9FHH31E+/bt+eabb/j++++xWq1ERkYybtw47rnnnjLf9/rrr5foFtW2bVsA1q1bR58+fRxdbCEc5kZiYuXKlZw8eZKTJ0+WakBdesonRHV1IzHh6urK3LlzeeONN8jJySE0NJSoqCimT59eqqutENXNjbadhLhV3UhMODs7M2PGDN566y0KCgoIDw/noYce4sUXX6zg0tcsGkVapkIIIYQQQgghhMPIQEghhBBCCCGEEMKBJPEWQgghhBBCCCEcSBJvIYQQQgghhBDCgSTxFkIIIYQQQgghHEgSbyGEEEIIIYQQwoEk8RZCCCGEEEIIIRxIEm8hhBBCCCGEEMKB9JVdACGEqCh5eXnMe2cifUzLCPMwA7AvzZtzjZ9gxGPvVnLphBBCCCHErUqjKIpS2YUQQoiKMO/TJxiZ+Q26y/r6JOQ6cbrv33SLGlc5BRNCCCGEELc06WouhKgRTCYTrmdXlEq6AULdjCTtmFrxhRJCCCGEEDWCJN5CiBohNSUFt9yzZe637JrH3PFNWPHdB2RlZlZgyYSwLz8/n4KCgsouhhBCCCHKgXQ1F0Lc0hRFYfXUz3Fa/yrZufkMa2T/uEXbYYSH+vpMDux1jsS59x10u+sZfPz8Kq7Aosbbv2Ylsb9+iceRnVi1OnJbdaXx5Jdo1KFzZRdNCCGEEDdIEm8hxC1r76ZlnP/jPoaGJqLTwqJj0L8euDmVPC76AhTEQDvv0uc4nwe7dOEYuk+k8z3PEhAUXDGFFzXSoQ3rMD5/O+1yLpbYvskngrDv51O/ZetKKpkQQgghboYk3kKIW865mGNs+3wCQ7wO4FEsybZYYf5RCPeG9mFgssA/mfXR9XgeL9+6nJn1BUFnNtHNMx+9nYE4F/JhB7Wg81g63fsCIbVqV9xFiRph0f1jGLF9nv19gx5gxOc/F35/bM8eTv75J7r0dCwNGtDzySfx8vKqqKIKIYQQ4jpI4i2EuGVkZqSz4uO76Jq3mNrF8g9FAY1GfW1V4EIWrD8LbiO+YND4h3Bzcyt2rML+zWs5Of1zAk6so5tnLk52kvDkAthmCcbcYRTt73mROvUiHXx1oiZY3jWCqEz7cxEsDG3ByNUHAVjx0UfUfu89mmdlAWABVjRpQsO//qJh+/YVVVwhhBBVxJ4VS4ib+iP600ewunth6dyP/i+8gbu7e2UXTdhI4i2EqPbMZjNLv3uJ8KNf0TrIXLTdqn656NXvT6VpiPRV/+TNvdiIMd8cu+J5FUXh8K6tHJ36CT5HVtPNPQtXXenj0o2w1eRPfuvhtLnnReo1blZu1yZqlqW9GjE05YTdfXO1YBk1nLp9n8Fj9OjCpLvEMX36MGbdOkcXUwghRBWyZcZf+H/4BI2NGYXbrApMb9afcVOX4uTkdIV3i4oiiXdFK8iHlIuAAt5+4O5Z2SUSonLdZExsmPczpmXP0r9WySRkW4ITTXyM+Liq32+/4IxBY6ZdsAWA1Q0/Z8Adz1zXZx3bv5tDf32C56HldHNNx0Nf+phsM2zJ8yGrRRQt73qBRq3aXddniJpt4dP3M3L1b6W2KwosrgUjesBf8+Ff++y/P8bJifzNm2nWoYNDyylEhZK2kxAlFYsJq6cPSyYOYMTZXaUOy7PCpue/Y+ADj1Z8GUUpknhXpPhYiDuttqAu8Q+G+k2K+sEKUZPcREwc3rWRYz/9i+HBsRiKPYU+mKRjr74bQ503EmDrQb7zghNxbV7htgtvAXAoSUuDT3JwcXG54aKfPnaYfVM+wmX/Ero5peBtKH1MngU253iS0XQATe54nmYduqKRWBdXEL99I3ufvZehaTGFIaAo8JuiYewoBW9XWD4fovbZf38usGPWLPqMG1dBJRbCwaTtJERJl8XEkZOncHnrIerp7ad0P/jVoesnf9KyUy9pg1QySbwrSlYGHNmrvi7IACcP0NiyhfCGEFyr8somRGW4wZi4EHeWDZ9MZKDzdnxdi7bHZ8EmpyjcG/ah45GXCbINadqV6ITfk9vZ+909jPU/AMDs9I6M+3xHuV3KudMn2fP7x+h2L6CrLhF/59LHFFhgS7YbKQ370uD2Z2ndva9UgKIkW0wkJSWzbe7f6M/FoGi1WCJb0PWx59iy7i8Co/9H+skCBq4BOx0u2OwOR8Y34LYPNxAQHFrhlyBEuZK2kxAl2YmJozFncH7jIeoZ7Kd0y3xhYH/bQwj3tvh1uYvOQ+/B3cOjAgsuQBLvinP6GCQlgMUISYfVbU4e4OINvmHQurtDP95sNqPT6aShL6qO64yJ3Jwcln72AO1SZ1Lfp+jPVq4JlqY3o8NTMzizfwNNdzxOsK0u2ZNowPvJ7YTUaUjcq1408lOwKrC9ywy6Rk1wyGUlnI9l55RPYfscOhNHsJ2H6iYrbMtyITGiB+ETnqF93yFotXZmcBM1yzXEREF+PvO/ehbtB98xPr3k203AwnYwdiTsv6gnrc9X9Bn/WEVfhRDlp5LbTkJUOXZiQjG4s/j9DxmRGlPq8FwrbGkGA1qV3B6TBgcLwtE0HkHrkU8SXr9RRZS+xpPEu6KcOARpyZCbBJlxJfc5OUHLDuAWAK7+4OxVbt2nNsz7hYwdf+CacYwCnRem8H70ffADvH18y+X8wjESEmI5eHAtgYH1adOm5615w+QaY8Lq7Muyv74gcO+HdAoxFh5iVWBpXCAhk36iQ79R/DPnBxpve5QQW9K996IBz8e20qBFe5b/+g5R514HYEu8M12+y62QRDf5YiLbp3yGafMMOljOUtu19DEWBXZkOnG+dhdqj3mSTlGj0elKzuB28vBBTu3fRf1W7WnYvFXpk4hbw3XUE9F7otl0zwT6xsRRywr73OFCExgxBJxsj8LzzTA/uwvD3lqOp5edRepFlacoCkeO7CErK4WWLXuUWIGhRqiktlNFs1qtHNy1HZOxgFaduslEWKJsZcTE1i278V08hyZKXuE2iwJfe9WldistrV3P0tDPfsqXVQDbk71ID+pO3X6P0r73sMJ2iNFo5J+5v2CO3QIaLa6N+tNz+J2l2ini2kjiXVHiY+F8DJjzIC8V8jPUu1UAPj5QN6LoWK0B3PzVisTVD7Q39su9ZuoXNN73MrXdCwq3KQrMyOrJmA9Wyx/2Kig/P5/Fix8lImIR7dqlcuGCnh07utK06X9p3LgLANlZWfyz4it0xt0oGNB796XPoAcwGOwMMq7KriEmtm1cS9r6LxhSt+TEaVsSXMjq+gaD7n4JjUbDxnk/02DLQ4Taku59F/W4P7qFhi07AjD/sXrcFnIGgNkFgxn3/vIKusgiaSkpbP3rSwr+mUrbglNElLG6x84MPWdCOhIyajKRHXqy5eMnaHFuLY0MuZwwunGwTl96vvIdwbXqVOwFCMe7gXpi3/4YVk75jI76dfQNt9o97dYEJ7Rj/qTzIMf08hCOceDAas6ceYtWrbbh5WVmz55ICgr+xdChb9yaN2PtqYS2U0XbvngmSbM+pm3qbpy1Crvcm2IY+Aj973u6sosmqqIrxMTek7Gc374Tw/lYLK6uWFp3YMDTz+HmX5tcxYUdK6aRtOV3wrL30Cm4oMT8OMXtuaAjxtAcXZNRZB1by3jPzbjampiZ+bBIM5Lxb86SPOIGSOJdUUwmiN4FxqIkGHM+GDOhbi3QmgE7/xQaLbj4FN3R1dsZPFqMoigkJSWxb8cmUmY8yKQGaaWOyTPBphbfMPD2yTd3TaLczZ59P6NH/8blNxKXLm1Mjx47KMjPZsPckdzWfXfhMbl5MG/7MMY/OLd6/RG8QkycLMhi3+w3GB4SV7gUGMCJVA0HPQcz9MG3cPGvDa7+bFryN/U3PkCYbZLb/Ul6XB7aSOPW6o2KpMQELJ+EEeIBBWY4MWojLTr0qMALLS0rM5Mtf39DztoptMg5TiOP0rGvKPDzGXioXun3z/Tqw/if1tacxndNcRP1RI7ZwIqpX9IwcTYtAy2lDskxwjxTf/zbjMEasxadORejXxM6jH6KsDoRDrskcWNiY49z7twAunc/V2J7erqGbdveIyrqles+Z3JSItvXf4dWuYiir0OPAY/j5eVVXkV2jApqO1WWg1vWw6djaalLLbH9vNmF05O+o+f4eyulXKIKu4GYsFgspKRn4+kfiqt/bRQXP6IP7Ob4sv/hHLuGTj5JBNp5GLDgKIxsXLojickCK+u+zbAH/1P+13eLk8S7ghiNRrbN/IuMWb9gOH8Ki8EFc50mDJj0AO6htSE4EALd1btXeamglG445RcYiU/J4uLFJOJijpMbfwiXrJP4KikEGHIJcDHj7QxuBth3Aep4QVAZ8yb8GNOM8Z9twNff38FXLq7VxYsJxMS0pkuXpFL7LBb49O1QnKzwzKSEUvtNJlh16n2Gjrn+xlilys+Dc6cgPQVSUkiJi2PNlp/o43+wcHI0gORcWJvTir73/IfAwIDC7ZvXraBe9IeFSffBJD2GB/+hSZtuhccs+OxxRmV9C8Cq814M/KlojcuqIDcnhy0zfiJj5S80yThMc0/1qeWOVKjrBiF2xohfNGqJeWweXQaPrODSCoe7LCbIygEPX/Dxv6Z6Ijs7l5XT/0ej9BW0CCx6Am61woxoGN4IPG05iKLAuvT61LpvKo1bd66oKxTXYNGiZxgx4ku7+6b95YGT6TZcvcJx94rAy68hgUH1CQwKwtnZfoK5Y9Nscs8+Te828Wg0ap2yalckddr+TPM2fRx4JeXgJmMCUMeFF3ZJr/ilyBRFITs7m8SEeFJOHyXr3EnyLpwhdv08HveLs/ueRT69GfHj+ootqKgerjEmlNwUVnz7J5ZFawk9G0+6tycZ3drR+/8ewS+0TmFMJKXnsHPBt2TvmUYLwymaBaip4ZLjMKyMod8zdkKo2Y0cvQcFrj6YPQLR+obgFFQHt9B6eNVpiH94I4JDQ2veEJkrkMTbwWL27+fQ++8Tt24FAzwzaFisEW1VYHpoO8a9/CEZOTkkWPJIJZOsuCNknT+ENi0GX2sSAU55BLpa8HUBdyfQXsNDroOJ4OMCdcoY1rd0O7TSwS5DfVwH3E+Pu5+W2Q0r2fr1s+jSZQJlrXC1bCoomTC0l/39S3f1Z+jdqx1XQAcqOH6cJd88Q1PrCpoGFCULBWZYnFyfFo/8RePGjSE3BXKTwVLA1vUrqXPwA2rbHtgcStKiG/Y/mnbqb+tq6AsaLcseDmRIrWQA5monMuaZz0CrV4+pYl0R8/Pz2Trnd1KW/kj2iX3cG1H2n+cVvd5m8BNyt/mWFRsLJ05QqvtLaCg0bgyKFfLTS8REcZmZWaz8+3Na5q2nsb/CP2egTQh42/n7srCgLyNfnV4lY6KmWr58KFFRy+zuO3QAfJKhdkjRtgIjXEyBlAwtmTku5BS4k2/xwYo/uWZfvDQbGdUnu9S5Fmxuw/D7d1WP8Zo3GROHDx8mZscy9MY0zO61qNf3Ppp3HaQ+HS/OlKue5yr1xKVk+kJ8HKlnjtmS6dMYk85BeiK67GRc8jPwMGfjrSkgyEkh0LlkG275BYgKsXt6VhaEMmDeeZl4U5TtKjGx6JVX6PXRR3gXS/UU4LfmDaj98AByEo5jTT+LhymJEKdsGvhacS/WcXL5CYhqaP+jlx+EqKv8apqtcLEAkkxaMnAhR+9OvosvFs8AtD5FSbpnsSTd3b2McXi3CHurkVQQIxAPZNiKEQLcWk9f42NiOD1hAsOOH2d5ICWSblD/+N4Wv4cFnw9ieDtoVXyIrrvt6wZYFWgaAMtP2k+8U3PBywS1PaA2MbD+NU4u+Q/7PZrhO/wxuk94sMy75uUuMxkyEsFiBncfdZZSfTUbq1xOQkLCOX/eiQYNjHb3GwvA/Qo/Gg05DiqZ4yiKwuo/P8Fl438YU7tkI2nFaTc8Gt7P2LefBXcvdQkZzzDwrsu2pX9Ru1jSHZ2sRTv4M5o2bQpZ8eqXRkdMfDI9AtSkOz0f2kcNhZTj6pu0eghoqo4JrCJcXFzoO2Ic9OrJ8tlTyd/0Pi522nwFFtB6B1Z8ASvcrV9P2GW1wrlzamMq+4I6fk+jUxOAU0ng56TGhFZfGBNYCtQnfrkpYMzCy8uTcY+9TnrG08z661M0ORvtJt0AIRfX8cfIprgFhWGo1waflj2p1bYHEQ0aoddXYjPhkhpYT1gsZXcBT02GupfdJ3d2gjqhUCfUirqaey6QBJxg+UYY2K30eQD6tt7H5vWz6dV/YjmV3EFuICb2rVrCuak/YjhznBNKLj1bpjA8xAzOgBkOz1rCuoOP0Hf0feqTPxdflLQYshNPcyExidT482RdiCcvuwBjehKkJ6LPTsY5Px0Pcw7emgKCnRQinaGhvQciOq7ajrNc4dGXycW77KS7BsZE2aSesBcTWU5GPP7+s0TSDaABJkafZNvqk4xuj/rjKoPJ/rQhABTkAld5XqfXQpgrhLle9ncp5zjkAHGAbWU0sxWSCuCUSUsGzmTrPch38cHiUZSku9qepPuFNyQ4NAyP4g8Mq0lMVFKNmo/6ky7e0E4CagMNKqVEjrD7yy8Zcfw4+4C2PvaPcdOCRzaFkxZcC4tVnYEwJV/DxTwdKUY3MrS+FLjVQpMew+3hF3A1QLAH7EuANsWWcs03wY+Ha9FRm4bJmovB9je9gbtCAyUaFj3BwalPccy/HSFjn6HryNsddyc84QSkFutilZMGafEQ0Racymgh3rLyadLEwty5LWjQYE+pvTt3OHMxYyiavA1Ait0zHDlwmkEWS5V9cqEoSokxyXs3LOX8X/cxNPQiutpFx+1K0JFo6EvUoCHotFo4sxcC/Qr3b9+4lrC97xTeVDqSrEXp+wHNI2tDxjlAAzo9aHTsm/M5Y2y9CjclejLcRwMZ8eAVAlYzJEVDrc5VZ/xfsZjo26c3q//5k2G6c6UOW6trSN9bfuxfzagn7MrNVcePgDpxjjmv5P4zuhIxUUijVRMPrR6MuWDMwodcxv/rYRb+ngXss/txfm7Q1SmVhpZUOHkITv6FeQ6czoU4qzsZbkGYA+rhFNECv+ZdCG/bnbDatSvmSVwNrSc8PUeSkjILf//SLd/9e/1I8ghAr8nCRZeDu0sB3u5GAnwVAn3B3r2SsqoFLw/IjT9fzqV3gOuMiW3L1uD1/ReMMGeTaQGnlmqPj+Ka+eRwZsOXTJ33B34U4GHNx0drIsiJm0qm7SmwwIV8SDbryNS4kmvwoMDVjxPOefS3nC51g1VRwNSin/2T3YIxkZ2dxZo1/0GvX4tOl4nJ1ITAwPvp0uVqE0JKPQHYjYld07bR9Zz9YQzugCkOaF+0zWJVlxg7n+tCusaXAqdAMB3gdBrUu2whpINpnrjc+wW7AsPIjD1ObsJpjBfPYU27gC47CZe8dNzN2Xgp+QQ6WQlypjDfKIteC6GuEOpqBfJsX0mQe0LN1+MprMIsipqkxxi1pCvO5GhdKNC7YXH1Bg8/nHwCcQ2qjVerXvg1aFmYpF/vvDjbFs0kafmvGBKOYnH1wtysH/2fegcPzxsfrlJJiXcMUACWHFByQeMKWlfQnAeCgWu8IEUBrOodnirIsFe9jaPlync1uez3wGyF1Dy4mKslMd+ZVKs3+a618AprRHBEU2rXa0RocAA+Gog0ZkNBBvt3bSN96y/0Lva01NMZtiQHcc6swaDXYtF7oQ3tyAsfPohWq+Pg/n0cX/oXoRf20NXbVNj9qaWnlZbGXTDtX+z4/l7OBrSi3rB7ad+tFxqtVi2wxvZV/LVGW3pbWa/zsuHcoaIZGzSaouTn4mmo3fSmf/7VixoTbVvdz8L5yUQNjeXSPGl79viQmfUmDz3zNNs2TCcm7kHq1yr5dHvHHhgRkcist1py28s7cHGrGsMG0pKT2fDRf9DvWIsuNxtTvabQZyj5R35niNdB2tYqOvZMuoadma0Z2mMiHVyLNR70RfG9c/M/BO95l7o+6vdHU7RYBnxMi9bt1A1WH7DFhJKfgU/a7sI/J4pPfTi8ELIS1N+1kI7gFgpJieARyjX93l7v65uICWeNhtCo+1m79Dv6OF9Eq1F7s6xX6hD0yCe4lDUmoRo6enQXp05NQadLxmSqQ/v2jxMWlkNNqCfsKp452Ruzqi/jWhRr0YzPeifQ+xfGhManLlbrPuzlysfjYPBlfzL0WmjoAQ3JAU5D+mnYtxb2fUXeH3AkR0OC4kaWawBW/zq41WlEQMM21GvaEn9/PzSXfvfLiInUlDS2zP8DffIZLM4ehHUfQduuPbhSTNSkeqJnz0nMnr2J7t1/IizMDIDRCIsXN2L87S8TEuxRLCZ0QHtycrScS7xAatIpMtNOkpt1BmPueU6c3UfXNkfwthMyp86CV0A1+DleR0woikLy3Dl0Matd67fqYUAz+6cd3MDCqsRkouzcx7qafAsk5kOyWUsmzuTo3DE6e6K4+6H1CsDJPxT3wFr41K5HQFgdQgMCCXd2KhETZouFGe89z5DEFfg5qQ3FXDMscO/C8H89Bsmx3OoxYTQaWbRoFBMnriv29+ksMTGb2LAhg169HrrCu2tGPmHXVWLC3deLLI0GlzJGFMfkGZibGIHGJxyfWk2oHdGAiGBPGlpzKcjLY8Vv7zCyBfxzRp03qmOYmsscyA4lsOlABtf3BA8PCG0Pmg5ltm/yCgqIS0ohJeEcmQmx5FyMw5h2EWtWMvqcNJyMWbhbcvDGSIDBSrDL1ZN0nUad/ybEpXiSngbEQTbq13lgz9eFSfoZo4Z0RX2SXuDijdkjAI1vKE4BtXENicCzTgP8IhoTElYLDw8PNs74mdoz/00XfY6aLZvAuu8gM/59gLHfLr/hyYwrYYy3AmwErOrtFnOxiaQ0BtDUA01j0LqD1gM0bqXH3yhGMJ6yvdcKWi9wqge6qrU29dIBAxi6Zg1WYGkADA8qfUyGBb4L9aNh44a4+Ybj26kfYZHNCQsJQK9FfSpnNYPFVPS6WIBZLBbm/fwRvS2rSsxIOO+UO53atKaWh+2Pc0gn8KyrjlfyLLkMkdVqZde2LcSunkG99CO09y4dwBYFtmQ4kRjSliZD76R5ixY3N6NyWjxkXCy5zcMPAuqq/97NyhjIfEsqGRN5WXFs2LIVRbmIxeJGi2bjCY/oXxgTm9bNIO3sDzQK3k2e0Ylde6GjTz6tbf+sCw7402fyTLyD2lZqTOTl5bFowgDGn9pSYkbMkxaIbwm9WqjfZ+TDiuRmdB/wf9QKCAbFDFaL+ruu10GH1oCVnesXE/DPk9TzUf9kHUvRUtD/M1q1aWe30tm3exfN97+AQQfnMsG93d34mRNs/aO4YkxUijJiIlXvxdblC9EZnLD4hNJl0mT8A2+dbuZr1nxJSMjrNG+eCajtn82ba+Hm9gTt2nW55euJMu3dCxkZare5MmICa7F64Qr1BEBaegZbfnyaYcFnS2xPyILlccGEOjuRk2dAk5OLhzGTIE0eDdwVPK7z9ny6EU7laUnWeJDjGgD+dfCo05DgRi2JbNAQDzdXjh89wum/3meg/nzhDd8z+QYONp/AiH89WKzQNbueUBSFXbtWcPHiPHS6PMCTXr1G4GZIua6YsFgszPupO+N6bb/s/DBrNrgrAXR/+ig+vlW8e+41xsTxI0fR3jeKBga1t8ByPUSNKfu0yzdDlI/6+lIynWKCdIuWXK0rRmcPFDdftL5hOPkG4R4Qik9IHQJCahEU4IvTTS7labVa2bJxA5lHd6CxWjCEt6D3wCEYDHaC7xaMiVWrvqNHj8m4upbet2RJG6KiypqDoObkE2W6QkxY27VkSf8RjNh3sNTbTjsZyPzjU1p3bllqn2K1Mu3DR7ij1kkA8s2wMimciEAvdFotzdr1ReMV7pC2U15+ARdTUkhJiCP9wnlyUxIwpiVhzUpBl5eOkzEbd0se3pqiJN2pHDteWRRILoCEAjiepWFC7dIpcq4Ztoz5jgH/evSGPqOSEu8N6v+Np8CSddnuIFDCim3Q2O5euavBo3ED49FijYpLd6g04NIadD4VcRHXZPGbbzL0rbfQot5x9a4FzYolxyYFZoZ35fbn30Hn5AQtW6rrUl6NYgWrmbPHD7L/s6GMrF30R/hCNmzW92d0/85o02MhL039QxM+SF3j0suWaCiK7Q6fUuK12WRiy5oVJG2YQ9O8UzTzLP3rUWCBjVmuZIR3pu3Iu6hfv/71/3BS4yDzstm7PfwhoI56p6xZ7+s/Z7V1/TGhaFw4fSYVZ1dfgoLrMPuj/kxqcazwiNVH3Gk+6WdC60dVWkws+/oTBnz3AgY792cW62HQKFh6oRaRD/xBy1ZdYf9+yM8vOkinK4yJ3esW4LdwdGHSfSJVS+6EpbTuPlg91hYTxb9m/2ck4zw3AzDvXAij73gAUs9ed0yUeu0oNTAmEhJiiY1tR+fOpYdPLFpUn6FDf0RnOXNL1xNlysu7YkxclZ2YOHsimiVvDKaVbx5ezrA/zY2w8Gb0bxFcKiYUFz8SLyZz5tghUk4cJD/+JLrU83gWpBKmyyPS/fobPBfy4Uy+nkMZ8GC4udT+mAInsm//mFatWqkbamBMlO3m2k7nYuPZsfop2kUeICLMxIHjWo4dsDKgLvh5wPLDvnScfBj/wCsM+Kxs1xgTx6Kj0Y9pRaReTbyjLeA6AOrbuV95Mk3LavMImrTphLebhUDtRYKUFJzMmVJPVJBly+5iyJC/7O47fx4uXNhAhw497eytOflEma4SE7vmz0fz6KO0T0ws3J2i1bJu8mTGff213Xpi1kePMJbZhTdFp8U3YNLALlWu7ZRfYORiSipJx/aRee4kuempFGSnoeRmojXl4WTJx92Sh5fGRIDBQsh1JOkH0sHfGWrZuRkEsKzhvxjy3p83VO5KmtX8EJAMlly1a4g1H5Q8UPLBUo8rjta3pILJ1vXGmKkOSvBoBoZA9Q6VS+sKuoary83NZcHQoUz45x90wH4dnHWHAm9nNI2b4tKlP4Mm3Y+TlxcEB8M13jVVFIVlP79Fo0Nv08Cv6J9vTZwnwQ8uoEWYK5zfpm7UOYFfQ9AZQOcMtTpd86y1+fn5bPr7WzKX/0i7vONEuJX+Vck2w8Y8PwrajqDTPc8TVqcuVw0+RYHcdIg9VLQdwOACrp7gFQh1ml9TGW8dNxcTivEsM77/hbGR0Vy6Sb7tlIHAIVOIbD2pIi6glOUPTyRq80y7+04ZYfOjr3LXs+8U9ZywWuHiRcjOBheXwpjY888ivOeNItJX/T05maYle+wi2vQcWuZnm81m9jzpRqcQdfzTKv8nGNghUt15EzEBXP13W7FeWyUkMcGSJW8wdOjbpdYIBcjKgr1736BX9063dD1xRWXExM1Y+bAvnf3TyTbCiZCJ9OnZ5bpjwmKxcO7Mac7t3Uza4R0Yzx7CKeUMPnlJ1NbnEeFW9uobJ2xt44Zl9ABd2vg+hj7/YY2NiSu7+bbToeizxMWeJjI8lL1bDzKqzmacbHXG6qNetHoomqCQ2mWfp7JdQ0woisLi4Z0ZcWZn4bbpnjB+MOi0JU810zKK29+dr244v61c2k62Qkg9cY2WLr2boUPtJzGxZ2HnAi2KWxQd+39KeL0mlx1RM/KJK7pKTJzYu5ejP/yA4dQpLD4+eI4eTc9Jk+z2Wl3158d0PfoiHrZe1DPOhzP+vqfU+TyqcUzk5+dzMTGR5NiTZMQeJzdeHZNuSY1Hm5WEc14abqYsdUy6wUJyPgS4qEu62rO04d0MfW/KtV97MZU0xrsekA46N6D4VQWBNRKUHLDmgDXb9v9cwDbBiNW2HIYxBQpS1dfZh8C7O5BZURdwTdzc3Bi1dCnLP/kEzYYNaEwmaNuW7k8/TVi9ejd0ztTki6x6ox9jA6LR28Yk5Rhhkak/t325CBdLBiQfVWe5zb4APvXUIHHxBf9G1xUkLi4uDHjgWXjgWTIzMlg25TOMa6fQyXqWUNvwUg89DPFMhZNTSHlxCousodB9Et0eeAn/QDt96y/xCVa7xFzeZUpngMCI6/uh3BJuLiY0Gg23PzCGuX8oDAo7jIcLdIk0cWjNv9if50vrLlEVfkXKFSZ5M2r1dB9xd8k//FothJR82rJv41I8595GpO0G06k0LZmj59PuCkk3wNalf9PTlnRHJ2vpOXG4+jO8yZgAio1fKmc1MCZ0uuwyf5SenhBz6gi9evXhVq4nrshOTNwsX1023i7qsmKZjTqojanrjAmdTkdEZAMiIhsA95TYV1BQwPFjR4jft4nMY7uwnDuCc1os/sZUIpyMpBihyRWGXeoUM3jb6o4aGBNXdvNtpxYNPWlRV02sG9Trz+xZHgwPWoGLEwxoksn6n5tgvvcAYbVvoCdbRbiGmNBoNATc+wxH359ME2MGAKMyYN4ScK4HjUMgLgt2p/kyedpU9U3ZF8CcXy5tJ1shpJ64Ri4u/cjK+hN781Xt3w6j+1nRapeSemEp81bUx7/Bq/Tod69tcseakU9c0VViomHbtjT8/vurnmbfxmU03fcSHrYFFZaf92b4M9+i1eZX+5hwcXGhbng4dcPDgf5XPF1BQQFKQgJbno2iLsdK7c80gWubMiY+vAaVuI53HurI93SKpv8PgctnGgPbXY08NWgKjtjGY2RA3mn1h631B0MQeDQHzz4VdwkVbMuSv3Ba8gAdgosmUNuTaCB38A/0GHWfOqlUwh71rhGAf2Nw8Va7zpTjrM3JFxPZ+vMHaLbOoLvuAr525heIy4Od+no497+Xnvf82/4MgIoC6RfUr0vT//vXqbazct688omJ5Yu20t5lJ4G2P56nkzTE1/+V7lH3Vsxl2KyZ8jNdPnwIdztdexY16sHwuRuuOE/A/k3LcZ01jEZ+6u9zTLqGtJHzaN931FU/e87TbRnrtw+A2YmNGPfiD+oOB8VEualhMbF+/Z+0a3c3XnZWTjqwB6xn4Xhie/qOeZvAoFCknrg5BQUFJL7iQl1vuJgDLnctxiuiXYXFRFZWFgd3bCHj44kM8cootd+iwPK+7zFs8v8VbaxhMXF15d92mj97FYN8F+Bm++fffMKV8Dv2UTuiUQVdk2PsWbmE7S/fQX1jJhYdZPhCRs97GZDxOyEesDXZm4E/pldY26nc3GIxYbFYmD59NBMmLCrReWHPbj0nNluYOKB0mrJhtyspykR6Df0I/wBP4uO2s2fTr+hJxqzUoUWnfxNR//Kn40g9UYbzp4+T/Elz2gSpQ4B2JxoI+dfv1AqzddWvgTGxbeF0PKdMprkurXCbyQozg0dw+1fzbngFoUpMvFUHDmwiPv4AYWGtaNWqx9XfYM2FvB3qa0seZB1BHZ9hAENt8BsMhhuf5r0qKsjPZ96btzFMuwJP2++7xQqzk5ow4M11+AfZlkaK3120nIBnmHpHysHOnznFrp/fw3XPfHq4pOFupw/FqRwN+92b4D30UXpMeqTEGuH5+flsXjQTU34enYaMxS8gwOFlvuXYiYlN67dSJ3M24bYf58UM2OvxLoNvf7XCimU2m5lxz2gm7F1cYpz3XvcgrG/+RPuhI8t874Gtq3CeHkVjW9J9Ol1D8vBZdOw/9qqfm5uTw7lXPGnsr/5p2xz+f3TvM7DCYkJcO4vFwpw5vZkwYfNl22HOLzDBViUcO6MlOvl+ht/+DRqNhk1rp1KQl0BASFvadx5U+gZODawnrsWpY4cJn9ocvRb2JWpp886RSomJ+e8/y6Bdn+N2WX2xWNec3j9uxfMmlmoRZbhKTCxcuIG+zl/jaRvTuD3GmeCxO4loUHrypepi4dfPMyz5U3RadUWI+R6P0WHcCwT+XB9XAxxPgXof52JIOlDhbSdRktFoZNWqD9FoVqHTZWEyNaZu3Ydp1LAb65Z+hDX1G/p3SMblspwvNgHm/VOPVg0z6NMutfCB6q4j/uT7fEKP/veW/aFSTwCQnZXJ1ufqMrCWejM0NkNDep8viubaqMExsX/jas4t+gnDhWNYnD1RWg1k4CMv3/CM5lCJiXd8fAxbtjxCp04bqFvXSGysEzt39qJLl++oVav02nvbNs4l+cw09MRhVnzwDepI95591Vlds2NA0YOunjrg37slOPlU/EU5wJHdmzj/w/DCgAD1yd+RJv/H0IeLjY+9eAhyk9XXTp4Q2rb07I0OduLQPg78+h6+h5fTwyPb7iQG0Vlajvi3JXj0Uxhzs7Es/oLe5hMYtLDFEkJK57sY+eJHNzdjek1kigPjSUApjIl9uw9jOPE/mtdWk9esPFid+xijH/22woplNBpZ9dXHsH012hx1ObEGdz1Ksy7dynzPoe1r0f89kCa29WvPpGtIGjqTjgPHXdNnrpzyIYPOvALAtng9HV9cjs7Vp1JiQlzdxYvn2bjxKcLD11K3bgbHjoUQfbAFwcoeRvdNLXHsX4uc0Dn7M7JHAu5uEH9Rz6ajvekz+neCgi8bl2onJm7VeuJabZ35KV2PPA/A2vNu9Psxq1JiwmKxsPiTl/HYNYsWBWdJVFw5Vac3bZ78L/WaVt9Er8q7SkwsXbKQ7ppP8Lb12N112gnfkVuJbNKuUot9Iw5tX4vfrP6E2fKmmYlNGP/NYQD2P66ngY+V5FzIGPY3rRvanupVUttJXJt9u9dwcucrdIjcRUQtNXUpMMKabTDUzmTua3fXpv2Ig3hfaTLKGl5PWCwW5j7RlPEhJwDIKoCdES/Sb9AQ9QCJiXJXKYm3oijMnt2H8eM3lNo3a1YPxo0r2QV1xfwPaeb1FnVCimbti09yYu+FyQwb/RRoPCH7HJhsyalGC17NwLn6Pj21Wq0s+OwJOl/4rrDiAFh0PpDmz62ifpNikz5kxEJajPpaq4ewDqCvvC5HiqJwaNsGjv35AaGn1tPVq6DURDt708BFB00v62KaYdKwbciHDH74xYor8K3Cmg+Wi+odW1tMnDy8nZSNT9E5Uh3vbDTDnHMjuf2F+VXy5sahHevQ/TWQpv7qLKOxGRoSBk+j8+CJ13yOeY9FMjpEjYdZae0Z/+wXlR4T4uouXIgjPj6G+vVb4OPji9VqZfm8twmyvk+H5iYys2HrPhhsp2PU7C3DGPfg4tI77MTErVRPXJeMWJb/+DpRueqEMAsT6jDy+9hKLVJOTg7HD+zFPySMuvWq6JjiW81VYmLF8uV0NH+An21Oqn1n9bgM+ocmrcq+WVrVZKanceClWvQIU59ib0lwodn75/Hx8yc1KYm/utWh1YUCAnPhSIA3zuOGM+yFh9HW7iT1RDWQlprMP0v/D2/L35hNufRsT6kn4aD2nFp58mOGjH7+yieswfXEtJeHMMl1OaD2pJ2nG8+4uyerO6tAPnErqpTEe+vW+TRsOJaAAGupfclJMPUbH8LDfLEqLmRkO1HL5zADu5pKHbvlgA++rTbSpGlzNFgh8zAU2Jal0WjAszG4VOGlMcoQHxvDtvf6MiasqFGUkgtr3W9n9P/9iV5frH9efjpc2E/hTH7BrcDVr0LLeyVWq5VdqxcRO/0TIuK30cFLHT+yKB5GhNl/zyLXDoyYstP+TnHtFAtkHib+9AGOLHyY/k1zC3dNPdyJCa9uLvm7VMkO79qAMqUfzQPUpPtcpoa4AX/RZcgd13yO5IuJGP8bQpgnGC1wtP3ntBp0d5WKCXF9crKzWTr9Hkxpc5kYpa6UcrmTsa6Y626kSbP2Vz6ZLSZuhXriutjqiXk/vsNo5zUAzMnoyNjPdlRuuUTlsxMTa9aso1XOW4XzhBw6r0PTezXN2/WptGJeK0VRmPlESyYGRQPqEquJty2ndffBWCwWZvXrx8QNG0qMiM8FVkx+mNHf/FApZRY3xmq18sPnd/LYkOllHrP44EsMn/jh9Z24htQTi/73IoMvfoyTrU6dmtKBSf/+uGj+syqWT9wqKqXVnZFxyG7SDRAQCI3qpxPVIR2AZRuhf2f75+naMp25f7dEGwSpuU5kmdzJt7pixh3F4IfBLQCXgGZ4hLbDN6QJwWF18fX1rZJP+i5Z/den1NrxEmPCLIXbNsa74nHnLMb3GlbyYHMBJB2mMOn2iahyQaLVauk0aBSdBo3CbDazcf7fJM77Cq11T5nv8Ug7Q0FBQYmx4OIGaHTg1YKw+nrcbp/Kwj/vZ2QrtevuHc12MOvtJgx7aT9u7u5XOZHjHdm9Cevv/WgRqP7en8+E8/3+oOt1JN0AW/56h5G2HiIb413p9+9RVS4mxPVx9/Bg/INzmPXrv9Dp/rZ7TIO6eczau/bqibctJsg6CvmJ6oQsmUfVOTLcqvASSjejWD1hyUwE21rGGu86lVosUUXYiYn+/fqwfoOBxmmvEeoDLWpbOLpxAPtNS2jdeXBll/iKFnzxDOMC1KTbYoVtYU9xW3e1zBv//puhlyXdoM6FHTxnASlvvot/oJ3FvkWVpNVq6TXwKWLOz6d+7fxS+5NSIGHz5+yp3Z123Udc+4lrQD2xZfGfdD33MU62YSUL4kIZ92KxpLsK5hO3ikpJvA2GUPLywNXOwuR5eZSYiAnUmfLt0WjA3QUahwEYbV9plx21RN2UBmk74XgmpOU6kWlyI1/xxqz3R3EORu9RC1efCDwCIvENaUJQaB38/PwclqRbrVZiTp3EycmZuuHhZGVmsOQ/AxjttQtnf/WYfDPMz+7K8E+W4+F5WZ9sRVEbUxbbDOeufuAd7pCylhe9Xk/PcffAuHtY+OQwSFxq97hct4CbmrhAFKPRgGcTfDR6Bj04lRk/PszENmpPivEtT7H44/p0e+IgfgFXWPrNAbKystg6bRqKxYJP0wjcZo+kpS3pjs+Cs31+p/uwf13fSRUF3eFpYMsn0oN7o/GJKN+Ci0rj5tUYq9V+fXDmHHgefZFZn2xi4AO/4uPrX/aJbDGBRg95ceq27JOgmME9wiFlrzSX1RN6U1H96BxYei4VUUPZiYk+vbqzactHWBNfopYfNAmzcGLHUPaY5tGuR9kTY1am/ZtX0CX+K3S2bvKzk5sz4c0vCvfn79yJnQUUAOiSmMiqhQsZ/MADDi+nKD/NW3Vl+tZB1Ku1sMRKVYoCa9bCgz2MpB8fyYwtw7ntyVk4u1xjt+lbuJ44cXAn/qvuJcCWV2+Md6PnU3/idCkjrAb5RHVWKYl3z553sXLl5wwfHl1q38IFoXh7Pcfyo1mYTekk5Jxlz5HFtGtqLnXskZOgNamTRnnaSeIv5+uhfhUl6enA2ZIHlZGk5yneWIol6S7e4XgGNrihJH3Tsl9JP/AtjV33kGnR81dyIzSnj3Nn46Lu9IeSdFzs8Tm33/6k/ZOknYIC2xgUnTMENHXM+ngO4tl9LKkzluNnKNnzwaKAudXgKt0rodrRaMCzIS5aA+Oe+JWp3z7D7S0OodXC8OYXWf99JA3+tbvClo5Z+d//4vS//9H/3Dk0wHo3SGoPLfurSXdMz1/oMeKeq57ncmd2r6BnkPpEP7MA2t/9UbWKCXFl3fpNZt3in+nfofS45F07YFwrgIUcmRLEGu0dRN3/He4eHvZPZosJtAbIOaNuyzmjTq7j0eDW+b25rJ5wV7ILd3nXaV5JhRJVkp2Y6NGtE9t2fIr53POEByg0DLFy+sBt7DBNp1PfCZVb3sukp6aQ8+dthISq32+Kd2XIRxtLtCWs9p722GQDbv5XuGEnqqxhk/5kzuzHqOO5nEa1U4lJ8GbTLh8GBJ5Fo1Hb/RM9FrPm4yACB8+hVaeB13biW7CeSLl4gcRvetMjVG17H0vREnr3X/h52PqbV8N8orqptFnNDxxYRVzcYwwceAq9HsxmWL06krCw72jVqmRQzPrtIYa3/hnXYjeqCowwf9e/GHff7yQnJ5MYf5qMxONkJ5+kICMWc04cmrw4nCzJuOpy8HQqwM/dQojPtSXp1yMtGxIzIT3XiSyTG7mKN2adH7iEoPcIw8VbfZLuF9qUcyd3EZnwDJEBOSXOsfsYeCRBQ1+Ym1CPHq+vI6RWGXeccpIg6dJNC40646BzWfdxqyZFUZj77jO02PUzjZ3VsceJJh2rw4Yy9tOZuFzrXUlxfXLPo2SdYOYvb3FbxD8429bM3HnaCa8h62ncsqtDP37LtGnUvf9+aueX7BaWpIFN/SDg8Z/oOfrB6z9xThJz3rmdsa5rAVhyPpBhP10sjyKLKmT3tgUkHXmefm1P4uQEqRkaZq2uTUhuIqPaGUscu+eMnljvRxhyz6dXHraSe159knGJS7DtSUc1b3jYqSd2PuNPxxD1JvbRsfto0qJ12e8XNddlMbFzz378T/6b+sFqczE2WcP5yN/pNujuyiphCYqiMHNyMyaGHAUgLgvSxq+hRed+JY47vmUNloEjaJqbV+oci1u3Zsju3Te8Nq+ofBcTEzh98iB1IpoQVqsuRw9s4fTcEQxpXrQ6RnIWrEsfz21P/o2h+KLhV3ML1BPGggKWPVmPUbUSAEjKgZNdvqVru6a2I6pnPlHdVOo63tnZ2Wzc+B0QB9SiR49H7a7fabFYWDbnLcheiIchjmxjCFb34Qwd987VJ4fKvwBZx0BRsFgsJGfruJjtTHriCbKTT1GQcRZLTjwUJOJkTcVVk4mnUx5+biaHJOlzt8OYMsasT1sGbq2eYuTTX5T9xNeUq67XrdjGgPs3UtfYq6aO7ttNzOpZaCwm/Nr2pdPAYfK029FsMbFg2tf09Z6Dl22Mz9F4HTntZtO+520O++hFI0YwYrGd2aeBP5s15K7o49d/UlMuStwu1r0bRb86aoNqoc9TjHz6y5spqqiicnNz2bTmV6ymi3j4tqBb73GYzWaW//EiYanf0qFeyYk4N59wIb3280Td+WbZjepi9QQAzv7g1bz6LqFip57I0/uS8pobtb3UCafcX8+U9bJF2S6Lib0HonE7/BSNbU/K4lLhVO0f6DXs4cosJQDzPpnMqOzv0GrUcd1LAp5j5JOflDzIFhMLP/qe9j/PpJapqBfl7qAgLN9+S6exYyu45MLRTCYT8/93N709pxPkXbR9xWFf6o5aSNM2dpbJKEs1ricURWH6M12Y5KdOqFlghpVB/2bEyNG3TD5RXVRq4n29FEUpnHTrupKzgmR1hkLF1q3Z4K2uzactO2m3WCwkJydzMeEM6ReOXZakX8RgScFNW5SkB3tTmMCUxWqF1QdhUBkPGeYdacbo10t3vy86gQUS9oDJ9rTcPRgCm5Z9vBBlscXE6sVTaWH+gRAfdfP5FA2nan1L7xGPOuRjl7dqRdTBg/b3RUQQdfr09Z3QFhMHdm2mye5/46RTu6s7vXiBgKDgciixqE5yc3JY/tsTNDb9SfPalhL71h71wNL0TQaMfdZ+/XED9USVVEY9cfL4Uer93RSdFvYm6mj7benhW0KUcFlMHIw+im7/EzSrpcZWYgZE+39Jv9FPVVoR925YQq3FwwmyzRE6I6k1E77eWzLGL4uJbRsOkbxyG/rUVEwRETR95BEatJbeH7eygzvXcGHZGAY2zSzcdiEdNuXdxW2Tf732FV6qaT0x+/17GWOcUri077S8KCY9+bbkE5WgWiXeN8WYDhkHi+7s6D3ApxVob34Sr8uT9JyUGPLSz2C9lKRbU3HTZOBhyOVCqpnbOtk/z9Lz/Rj67zVlf1DSYcixdZ81uENoO9BKtyhxg2wxsXXDCoIT3i/sRpiSBdv0rzLs7nfL/SMX9+/P8LVr7e/r2JHhO65zeSNbTMz+4nnG+e4GYN6F+oz+7tTNFlVUYxnpaaz89UHaOs2jQXBRFWe1woojfnh0/oQeUfeWTsAdWE9UmDLqiS3LZtBtx+0ArInzpP+PmVc4iRA2l8XEkaPHMe16nFZ11Bs3yVmw1/MjBo5/scKLlpp8kRP/qUvnkAIA/ol3p/0n8aUno5W2kwAK8vOZ//XtDAxYULhOPcCS6AAaTVhKw2Ydr+1E1ayeWP33Z3SOfg5P24irmRcaMfaN2ejybculSUxUqKrfP6K8OPmATxt1kgQAczak7wNL6SUIrpdOpyM4OJiWbTrTM+puou58k9GP/87YF1cy9j/7GPlGLANez6DLKyas9e7H3q0OkxmUwH6ld1ySGVdUcWh0ENRcgkTcHFtMdO09hNwmn7A/Vv198veEvtr3mPXVfZT3fTnDiBFk2dmeDzB06PWdzBYTFouF2nn7Cze7dXnoZooobgHePr6Mf3YO3uPPMzNmAOdtQ/y0WhjSPJWuGfez6M0wdvwzt+QbHVhPVIgr1BOZ54t6U+XoZJkYcY0ui4mmTRrh0uUH9pxVvw/whA7ZL7Hs77cqtFiKorDmPz0Kk+7zmRoCH1paOumWtpOwcXZxYeIL8znbeDHrjxUtozqseTJuGzsx99tHsFrtL3VcQjWqJ/ZvXkHjPc8XJt0r43wY+tqCoqRbYqLC1ZzEG8DgCT5t1Vn7AMy5kL5X/X8F6TXuPeac6Iy5WC/I3AKYcXoYAye8YP9NBZmQWmxSh4AmYLhKv3YhroUtJlq07YpX9x/YfEKNDTdnGB30O9M/jLq2iugaDXr6aZY//DAni80ue9bZmXl33EHUa69d+4mKxcS2jWvpEmabMCpFQ89xZawEIGqcwOAwJry0CoacYObxLiTZHvLqdTCyxQVanR/L3Dfqc3BXsV4YVaCeuCFXqSfyEk8Uvja5yjAMcR0ui4lGDerj0+sndp5Wn/D5ekB385ssnvJKhRVp7n8fZnyI+jttssC+Bi/TrEOvkgdJ20nY0bbbMDo/e5EZpwaTYfuzXssPxgT+yOK3ahFzfP+VTwDVop6IO3sSy9QR1PFSH6DsSTTQ7Lm1eJgSiw6SmKhwNaereXGWfMg4UBQgWgN4t1IDqQLk5OTwz8L/oU3biaLRYwjtR5/h99sfY2IxQfwusKh3dfGqA36RFVJOUYPYYuJi3Bn2zXmQQc2LnktPi27D2Fe24XSlmaGv0+EdOzg7bx5YrYQNHUrr3r2vo6wlY2L2J08yLvCQ+jq1DeO+3Ftu5RS3llNH97J35j0MCj9YYk6OrDxYcboZrcdPoWGzDurGSq4nrss11BOzn+vGOK+tAMzVjGPM67MqupSiurssJmLPnSdu1UN0jVSf9GXnw5qCpxn14BcOLcbudQsIX34bAbYYnp7Snolf7iw5dETaTuIa7PhnDsbNd9GjYdFM92eSNOx3eoqRD3x+9fmkqmg9kZOdxeZn6zKoVjoA5zI1pN62mNYRvhITlaxmJt4AViOkH1C7iIDa3cK7pdqFpKpQFEg8APlp6vfO3hDSplotXyCqEVtMZKVdYPVv9zO6dVLhrrkH6zLohYOlu/FVtMtiIs/ixOkvetIsQH0qv7HtFHqOrBpL3IiqK3rvBo4tuJ8hDU/hWmxYXkoWrInrSJc7/6Bu/Sa3VD2xYHJ9RgWrkxcuDXqZoY99UMEFFbeEy2LifFw8p5c+RM9GauKRZ4RlGQ8zZvIPDvn4lIsXiHkjnI4h6vKB6+I86PRZAu4exQbtSttJXIec7GwWfTWC4XXW41FsJdt5h+rQ4d6V1KnX5MonqGL1hNVqZfbjzZgQcgyArALY3vwTBvQfIDFRBdSsrubFaZ3UMRqXAkOxqHetCpIrs1QlpZ8pChKdkzoOQ4JEOIotJjz9azPskb+Yvq9+4a4xLWPZ9Fk9khLjKrGAlIqJjZs2FCbdOxIMdB16R+WVTVQbzdv2YsybJ4kOX8CCQ2FcWlnI3xMmNNmJfnVTZn7Ql8TExFumnnAzF61l61WneQUVTtxyLms71a4VRsMRv7LuqDpm1tUJhvn8yKyv7in3j7Zaraz7T/fCpPtshobQyStKJt0gbSdxXdw9PLj9/9ZxIORPtp4q6tk3usU5jEuas/j3/7vyfDdVLJ+Y+drIwqTbqsBy97sZMHSMxEQVUXMTb1Cn//dupa7FB+ryAJnR6lp9lS03BTLO2r7RQGAzNViEcCRbTDh5hTLhyZ+YeqgtFtsQ76hmqRz9pRFnTx2qnLLZiYmc7b8U7j7r3ePalwQRAujQYyQj3zzPDr8/WBrtz6XpDMJ8YUKD9eTODWfWZ2NIs4RV+3rCV6cuG2NVILC+LJ0kbsJlbaeQkGBajPmdVUfUHlHOBrgt8A9mfDqhXCfonPvh/YwLiwHAaIHoJv+hSZtuJQ+StpO4Qd0G/ovmj11g+tEu5Kn3dogMtjLU9QPmvhlJ/PmYst9cRfKJRd++zGjdksLvp6d2YNwzn0pMVCE1t6t5cYoCWUchv9iEAx4NwK125ZTHnK+OTbLaHsP4RoJ3ncopi6iZbDGh5F1g9u8fMLz2qsIuuftiDRj6rqR5uz4VVx47MZFqciH3gyBqe6mT60RHraJNtwEVVyZxS1EUhbXzv0Y5+BoDmpace/9IvJbD3E7U+H/jrs8u2lFN6onc3FzS/uNOLS9IyAKvt7Jxd3e3e6wQ1+yytlNqaho7pt9PVPN0AMwWmB07kokvzL/6WNmr2LlqNpFrxuNnm5dzWlpnJn2xreRB0nYS5eSfJT/hcfhx2keYCrcdi9cSE/gGUZP+U/bvcyXmE9uWTSVy3Z0E2v60L4gLZcjnR3BKOSgxUYVI4n2JokD2Scgr1pXWPRzc61VwOayQsAeMtsadW6DaJUSIilYsJhbP/pHurtPwtfXoO3lBS0rzv+nc7/YKKIf9mFj09XOMSP0MgLVx7vT9IeumG3dCWCwWVk5/D48zH9CzUcnlYfae1XPWeQJDRt2Ns4utS2I1qCeOH42mwfQWaDWw+4KO9t+ZK6ig4pZ3WdspIyODTX/dz7AW6tAGqxWmnxrIpFdW3PDf56QLcZx7ux7tgtUkaHWcF90+j8et+M0jaTuJcpaWmsyKrwczuuEenC+tHGaBeUca0/ux1QSFlJFMV0I+cSp6D+YfOtLYX+22tSnBlSZvniDAmiAxUcXU7K7mxWk04NkQ3COKtuWchawT2F1421FSThQFid4VAhpX3GcLUVyxmBg+7mH26Z8kzjZMtEGIlbqnJrFmzmeOL0cZMaE5+HfhIWm1h0rSLcqFTqdjyJ2v0/mFDBZmPMOu04bCfW3DzdwWMpU9f49kyZxfMJst1aKeSIo5gNYWHmkWedItytFlbSdvb2963T2FhQcDAdBq4Y6Gq5j6bt8bWprSarWy8Y3uhUn36XQNdZ9YVTLpBmk7iXLn6xfA7W/sZrPrl+yPVYex6XUwvsUxLk6NYPXsT+2/sYLzidTki8R/1bMw6T6WqiVo8noC9NkSE1WQJN6Xc49Qu4VckhendhupiEZVVgJkJ6ivNVoIaqGOGxGiMtliou/gMcSHvsnxBLUFH+oDHbKfY+Evzznus8uIibOnjtHTX+3KlVUAbSe+7rgyiBrJycmJkQ9+TrPH05h78T4OndcV7uvawMiwgL/Y+MtwVi2ZgTXnXJWuJzLORRe+ztH5ObJ0oqYq1nby9PRgwH1TmHsgtHD3nU3+Yfq73bBYLNd12jnv3cWYMHV8aoEZjrV8m0atOpU8SNpOwoH6jX6KWnfFMjO6eeFEnC3qWOhlep6Zb7UiNfmi/TdWQD5hLChg4/+1pWeYuqpAci6kDPydRvXqSExUUZJ42+NWG7yaFM34l58ImYfUmQodxZgNqSeKvvdvDE7yZEJUEbaY6Ni1D9ZWX7DnjPoH3NsNBrl8xszPby/XSXSAK8bEnunv4G1b9mNjcgD1G7co388WwsbN3Z0xj/9KnfuSmH1uLCcTi3pW9G2Sz0CP71n53Sg2LP0NJeNglawn8hOL3mN2C3FEyYQo0XZyc3dl6IO/MftAUXfcO5puZ+Y7HTGbr22ow7Zl0xiYO7Xw+7nZ3Yi6/7WSB0nbSVSAgKBQJrx5iHW6D4m23YR10sOEZgeJ/b0W6xd+a/+NDswnFEVhzkt9GFUrHlAnHNxS+zm6DRotMVGFSeJdFpcQ8Gqu3ikCKEhR1+mzOmBsnNUMF6PVMUoAnmHgEVz+nyPEzbDFRJPmbQjs+zMbjqmZr4sTjA2bwbT3+lz304wyXSEmFEXB88zCwkNNTSaUz2cKcQXePr6Me3Y23uPPMzNmIOdTivZFtcimGx+z6NO+bF/yWZWrJ5SM2MLXGplYRzhSsbaTi6szIx/+hRn7Iwp3T2q+l9nvtMZkMpV9DiAxPhaXxXfjY7vBuvK8N7e9t6rkQdJ2EhVs0ISX8J94ilkHGxau+NIm3EyXrMeZ8XZHMtJTS7/JQfnE3I8eZIJ30QSDc4yDGfn4hxITVZwk3lfiHKAuD6CxdTE0ZUD6PrAay+8zFAWSjoA5T/3eyRP8Glz5PUJUFltM1AmvT/Oxf7H0oDcAOi3c0XgDs95qRX5e3s19xlViInrXJnqGqLNOJ2RB1ztevbnPE+I6BAaHMeGllTD0BDOPdyUpU92u18HIVqm0zniReW/U5cD25eX3oTdZT+hzi5a0cQluVH7lEsKeYm0nJ2cnxjz2E9MPFP2+3t7iMPPeaU5Bfr7dt1ssFja/2Z02QWpiEpOmIfKZtbi6uRUdJG0nUUlCwsIZ99Yxlhtf51iCmka5OMHEprs4/mMom5b9VvpN5ZxPrJ32JQMzf0Vny+JmJTRgwruLJSaqAUm8r8bJB3zagPbSlIbZkLYXLPYrjOuWeQ7ybI9OtAbbovbyzyKqMFtM+AeG0PveqczeXzSO7/aWh1nxYQP7d32v1VVi4ui8d3G2DVXanhNBUEjYjX+WEDeodt0GTHh1C5k99jL7SCsy1CF2uDjB6FYJ1Ds2hNlvNuV49M6b/7CbrCfcLUXx6F272c2XR4irKdZ2Mhj0jJ/8PdMONCncPaHlCRa/35S83NxSb53zziTG1DoPQL4ZTrb7gMjm7UoeJG0nUYk0Gg3D7noL91FHmX0wgkvzBnasZ6Rdyv1Mf7cHWZkZJd9UTvnEwa2ridz5b7xsC2usivNmyMe70eXES0xUA/Ivci0MnuDTFnS233JLHqTvBXPOzZ03Lw3SThd9H9gU9C43d04hKoItJty9fRn12B9MO1A0W+aoFvHs+Ko+CXGnr3CCMlwlJqxWK7VS1xd+79LxgRspvRDlJrJxG8a9vp+41huYGx1JboG63dMVxjU/SsCOTsx8pyOxMUdv7APKoZ7w1al1lVWBwMjWN1YOIa5XsbaTTqdj4uPfMPVgy8LdY1ueYcVHjcjJzirctnnRHwwumFX4/fy83gy6+6WS55W2k6giaoc3ZOxbMSzOeYFTtvk/3Jzh9sabOfhNCNvWTi/5hpvMJ+JjT2H8cyjh3uqcOvsu6mn6yg489BaJiWpC1vG+HpZ8yDgAZtsdWq1B7Tpi8Lz+c5kLIH4XWG3jnHwi1C8hqhNbTCimHGb8+H+MbbANg+1p9NZTLgTdtpnIJu2ufI5LriEmti6fSdftEwE4nqqh1nuZuHt4lM+1CFEOdm+Yw/lVjzG0WVJhLAAkpMHGlN70uucPQsLqXtvJyqGeyMnJIeMND8I8IS4TfN/Jwa14l10hHK1Y20lRFKZ/9wITm+5Gq4V8I3yzxo0GjZqhNWeSHnOcVm7QOhBWxPnS56t4nF2KJRDSdhJV1NlTh9kzZRCjWxat352VB0vj+jHiqYUll8C7gXwiJzubTc/WZXCtNADOZ0LSqCW07dZfYqIakSfe10PnonYTuRQYVpM6RsOYdn3nUayQFF0UJK5+4B1eniUVomLYYkLj5MXtj3zAovjhZNt6TXWNzCdvWSf2b19x9fNcY0zErfik8PUBpaUk3aLKad9rLKPeOs8Ol7dZctCrsAtiqC9MaPAP+fMjmPXJCNJSk698onKqJ86fjSHEFiYXcnWSdIuKV6ztpNFouP2xj5lxrDP5RpizHZ4ZnMuoyF2MaHycu4aAPhzmnYJGz60vmXRL20lUYeGRzRj1Zizz054gNll9+u3pChMbrGXXF0Hs3rig6ODrzCesViuLX+xYmHRnG+Fwm//StmeUxEQ1I4n39dI6gXdrdawGqEsCZByEgqs0oopLi4GCSzPyuEBA06KlBoSoborFxJi7nmNT3r0k23oOtqhtwWv3EDYv//3K57iGmMjPz6epaXfh94H9ni7HixCiHGmd6D7qFYb+ez3rC55gVXRRshsRqDA+fDEX/gxmzld3kpOdbf8c5VRPJMXsR2t7W6pFblSJSlKsntBoNNz+yAd8/k8DRneicIKoS5pHQE5IXSIatSy5Q9pOoorTarXc9vDXmPruZuHBoMLtvRrlEnnqNmb8d1jRBLTXkU/M/M9tTAxWhytZFVjqcieD7npBYqIaksT7Rmj1apcQZ3/1e8UKmdGQf+HK7wPIuQiZ6qQhaLQQ2Bx0BseVVYiKUCwmom67hyPuz3PWVnfUC1RoeP4+Vkx/z/57rzEmNs39juaB6uPDXRf0dB9+tyOuRIjyodWj8WlNv1EP0++RhSxLu5cNx5wLdzcNszI2dCrHv/dl/g+TS87wXI71RMa56KLT6vxu6BxClIti9YRGo6FNs3DcnO0f2rXueY4fLfrdlbaTqE4im7Rl2BvxzEl8gDjb3JY+7jCx3lK2fhpU1BPwGvKJJd+/ymjtosLvp6e0Z/xrf0pMVFOSeN8ojRa8WoCLbX08RYHMo5B7vuz3mHIh+VjR934NwPkGxocLURUVi4mefYeRGv4+0efVPzFB3tDN+Brzvp9c8j3XERNZm78vfH3asxt6vd7ucUJUGbaY0LmHMeS2e+h632IWXhjHzpiixlHbcDO3+X3Hni98WDLlVcx5meVaTxQknSx8bXYLueHzCFEuiredrjDFkE6jYLVa1G+k7SSqIZ1Ox9gnfiar2xaWRvsXbu/bOJva0VHM/HQcRqPxivnE9hUz6BjzfuFKLovighn78SY05jyJiWpKEu+bodGAZxNwrVW0Lfsk5NiZzdlqgYuH1K4kAB4h6sL2QtxKisVE2w5dcer4P7afUpMMT1cY5v0d0/97G4qiXFdMpKWm0N75OABmK9Qf/nKFXI4QN61YTBgMekZOfJwWExcyN34CB8/pCg/rGlnAMLf32fhxCCuX/43Vai2XesKaHlv4WucrY/9EFWCLCV1QD/LLWMb4UHY7GjdtKW0nUe01admVQa9dYFbcnSTaVhjz94QJdeew/sNgovf8YzefiNmzDK8ldxBkm5NtS4ILXd/Zi7OTQWKiGpPE+2ZpNODZENwjirblnIWs42C1quv0mXMg5Zh61xbA4A5+DSuluEI4XLGYaNioKXWifmPNEXWMq5Mebq+3gOlvd8acGH3NMbF52ofU9VZfb4x3o13PKEdfhRDl57J6wtXNhTGTHiN8wjZmnxvLyQtFY/L6Ns1jkN8PrJxyG/9s/YebXXjEkJdY+NolqMFNnUuIcqPR0Gf8q8w71aVwAsJLTiR54tvyIbTWPGk7iVuCXq9n/DN/kdRuHSsPexduH9Q0nYA9fZj95b8wWyzsPxrP8mXLWDB3FjG/PUlTfzU4TqRq8X9oCQH+XhIT1ZwsJ1ae8uIg64T62pQBllxwDlYXtM9OBpc66iQKoe3B4FqpRRWiQthiIj09gw1/3svIVumFu2btDmDYHd/i5hN61ZhY/EgYw8MSAJijjGHsm3McXXIhHMNOPZGcZWDtrHfpGryfOgFFh5otsOxIMEF9/0fnPuNu6OPWPOxF/1rqbIdbOk2n25CJN3sFQpSb7Kws1vz1LPqU9eiUXIz6MMIa9aRDj+HSdhK3JKPRyPyvJ9Hfdy7+tt7h6Tnwx0YDIzpAvQAT+UZYuxuC8qGeJxxt8gjdh06QmLgFSOJd3vITIW23+sQbAB3kmdQxHBotRIwGzzqVWkQhKpQtJvIuHmTRtM+Y0P5i4a7F+z3o9uAG/CLalvn2c2dO4vF9Q3xd1SU0LvxrHw2atq6IkgvhGGXUE3GJqWxeP5U+9U8TVPRQhAITLD0WTv1hP9G608Dr+qg9j+lpF2LBYoWYOw7TsHHT8rsOIcqLtJ1EDbNv23JSV42nX5NsZm+DsZ1LT0i+4QCczuvCPQ9PRGLi1iBdzcubSzDovQENWM2QdhIK4tWxGG4BoCmo7BIKUbFsMeHq6sLYu55j2s7Qwq6Fw1tnc+CvHsSdPVHm23dOewdf2w3djUl+knSL6q+MeqJWsC8THniX7A6LmHWkNek56uHOBhjd4iyRxwYx+62mHDu0/Zo+JisrizAPdRxgQjbUrhvhmOsR4mZJ20nUMG26RNHt+Yt8t683EYH2VwHr2RL8wzwkJm4hkng7gs4AHpGQm6wGiDUflGzwCFXHewtR09hiQleQyu2jRzNrf30KTOquPo1zSZjRgmMHt9p9q+fpBYWvCxqNr4jSCuF4V6gn6kfUYfzr+0hou4m50Q3JtbWvPFxgXLOjBO7swqx3OnD21JErfsT5szGE2JbuTsjV4+oqXRJFFSZtJ1HDuLi60qLvMzSpZX+/RgN6rVVi4hYiibcjaF1A7wH+7UDnBDpnCOqoRpDOpbJLJ0TFKxYTGr0zE0ffxvLEEWTa5gfpUM+IsrYnuzfOL/G2w3u30jNYnQY0MRu63vmfCi64EA5yDfVE09bdGfPmcY7WX8yC6NoYzepb/TxgfJPdOK1pxsz3e3MhPtbuRySf3l/4Ot3i7vBLEuKmSNtJ1EARDVtyKtn+UmCKAmZDkMTELUQSb0dwtU3r7xoEYf0guDvo3dRAcZEp/0UNZCcmRt35LDuUR7iQru5qEmYhOHoM/ywqWq/78Jx3cLGtX7ktqy7BoWXcFhaiurmOeqJdt2GMevMcuwL+YsmhACy2oRqhvjCh4Qby50cw6+PhpKUml3hf5rnowtc5en+EqNKk7SRqoDrhkZxUBtjdty02gLbdRkpM3EJkcjVHyY2FnDOg2FpIGh14NADX0EotlhCVpoyY2Lp5DcFH76Z+sPqnKCULluc8iZeXF0mrP6C2k5VeobAu/A2GPPRmpRVfiHJ3A/WEoiisW/AN5v2vMqhZZol9R+O1RHM7g+//Hr3BwJePd6G1YT8WE1x06cB93+x04MUIUQ6k7SRqoOSLF1j98x30C/6HIC8rZgusOx2OR8f36dqth8TELUQSb0eymsCYpt6ZcvJTg0WImqyMmDi4czXWDUNoXdfMxiPq7u6N1f8XmGDBZmjywCZateteyRcgRDm7wXrCarWycsb7uMW8T69GeSX2Ld2rJTnfh4kdUnE2qN0Vl+93wbffr3TpP8kRVyFE+ZG2k6iBFEVh+z+LSI/bAwZvegx9CA8P2yQdEhO3DEm8hRBVwukT+znwa2eCPQro0qj0/rkxfRjz0rqKL5gQVZjJZGL5n68QnPQ1neobURSYtwPGdC597PpTYbR8cB/+AYEVX1AhhBCihpMx3kKIKqFew9bk136Izg3t7+/gvYUDuzdXbKGEqOIMBgMj7v+Elk+mMS/pQWZu09Ctsf1je9ePZ9vy7yq2gEIIIYQAJPEWQlQh3i5mu2tZAtTxM5Jw7njFFkiIasLVzY3Rk3/Cqe0nhPjYP0ajAZ0ppULLJYQQQgiVJN5CiCpDca+PyWx/3/44b5q27lGxBRKimmnRoT9HL7jZ3VdgAo1nZAWXSAghhBAgibcQogrpNWIyK2KaltquKHBciaJuvTL6oQshAGjYtDUHCgZib/aWFadb0GvYQxVfKCGEEEJI4i2EqDrc3d1pNOp35p3qTmKGOmvnoXgvZsdNYOhDP1Vy6YSoHgY98Auzz93GsUR3AC5m6ph7shtNb/sNV1fXSi6dEEIIUTPJrOZCCCGEEEIIIYQDyRNvIYQQQgghhBDCgSTxFkIIIYQQQgghHEgSbyGEEEIIIYQQwoEk8RZCCCGEEEIIIRxIEm8hhBBCCCGEEMKBJPEWQgghhBBCCCEcSBJvIYQQQgghhBDCgSTxFkIIIYQQQgghHEgSbyGEEEIIIYQQwoEk8RZCCCGEEEIIIRxIEm8hhBBCCCGEEMKBJPEWQgghhBBCCCEcSBJvIYQQQgghhBDCgSTxFkIIIYQQQgghHEgSbyGEEEIIIYQQwoEk8RZCCCGEEEIIIRxIEm8hhBBCCCGEEMKBJPEWQgghhBBCCCEcSBJvIYQQQgghhBDCgSTxFkIIIYQQQgghHEgSbyGEEEIIIYQQwoEk8RZCCCGEEEIIIRxIEm8hhBBCCCGEEMKBJPEWQgghhBBCCCEcSBJvIYQQQgghhBDCgSTxFkIIIYQQQgghHEgSbyGEEEIIIYQQwoEk8RZCCCGEEEIIIRxIEm8hhBBCCCGEEMKBJPEWQgghhBBCCCEcSBJvIYQQQgghhBDCgSTxFkIIIYQQQgghHEgSbyGEEEIIIYQQwoEk8RZCCCGEEEIIIRxIEm8Huffee9FoNGg0GgwGA/Xr1+f5558nJyenxHFz5syhT58+eHt74+HhQatWrXj77bdJTU294vmXLFlC586dcXV1JSAggDFjxjjycoS4aY6KifXr1xee9/KvnTt3VsSlCXFDHFlPHD9+nFGjRhEQEICXlxfdu3dn3bp1jr4kIW6KI2Niz549DBw4EB8fH/z9/Xn44YfJzs529CUJcV0cGQPvvfce3bp1w83NDR8fH7vHxMbGMmLECNzd3QkICOCpp57CaDSW5yXWaJJ4O1BUVBQJCQnExMTw7rvv8u233/L8888X7n/11VeZOHEiHTt2ZNmyZRw6dIhPP/2U/fv38+eff5Z53jlz5nDXXXdx3333sX//fjZv3swdd9xREZckxE1xREx069aNhISEEl8PPvggERERdOjQoaIuTYgb4qh6YtiwYZjNZtauXcvu3btp06YNw4cP58KFCxVxWULcMEfERHx8PAMGDKBBgwZs376d5cuXEx0dzb333ltBVyXEtXNUvWA0Ghk/fjyPPfaY3f0Wi4Vhw4aRk5PDpk2bmD59OnPmzOG5554r92ussRThEPfcc48yatSoEtsefPBBJSQkRFEURdm+fbsCKF988YXd96elpdndbjKZlFq1aik///xzeRZXCIdzVExczmg0KkFBQcrbb799M8UVwuEcFRNJSUkKoGzYsKFwW2ZmpgIoq1evLpeyC+EIjoqJH374QQkKClIsFkvhtr179yqAcuLEiXIpuxDloSLaSr/99pvi7e1davvSpUsVrVarxMXFFW6bNm2a4uzsrGRkZFzzNYiyyRPvCuTq6orJZALg77//xsPDg8mTJ9s9tqwuIHv27CEuLg6tVkvbtm0JDQ1lyJAhREdHO6rYQjhMecTE5RYuXEhycrI8yRDVUnnEhL+/P02bNuWPP/4gJycHs9nMDz/8QHBwMO3bt3dU0YVwiPKIiYKCApycnNBqi5q9rq6uAGzatKl8CyxEOXNEW8merVu30qJFC8LCwgq3DR48mIKCAnbv3n3D5xVFJPGuIDt27GDq1Kn0798fgBMnTlC/fn0MBsN1nScmJgaAN998k9dee43Fixfj6+tL7969rzouXIiqpLxi4nK//PILgwcPpk6dOuVRTCEqTHnFhEajYdWqVezduxdPT09cXFz4/PPPWb58+U01yoSoaOUVE/369ePChQt8/PHHGI1G0tLS+L//+z8AEhISyr3cQpQXR7WV7Llw4QLBwcEltvn6+uLk5CTDlMqJJN4OtHjxYjw8PHBxcaFr16706tWLr7/+GgBFUdBoNNd9TqvVCqjjO8aOHUv79u357bff0Gg0zJo1q1zLL0R5c0RMFHf+/HlWrFjBAw88UB7FFcLhHBETiqIwefJkgoKC2LhxIzt27GDUqFEMHz5ckgxR5TkiJpo3b86UKVP49NNPcXNzIyQkhPr16xMcHIxOpyvvSxDipji6rXQl9s7t6M+sSfSVXYBbWd++ffnuu+8wGAyEhYWVuDvVqFEjNm3ahMlkuq67VqGhoQA0a9ascJuzszP169cnNja2/AovhAM4IiaK++233/D392fkyJHlVWQhHMoRMbF27VoWL15MWloaXl5eAHz77besWrWKKVOm8PLLL5f7dQhRXhxVT9xxxx3ccccdJCYm4u7ujkaj4bPPPqNevXrlfQlC3BRHt5XKEhISwvbt20tsS0tLw2QylXoSLm6MPPF2IHd3dxo0aEB4eHip4LjjjjvIzs7m22+/tfve9PR0u9vbt2+Ps7Mzx44dK9xmMpk4c+YM4eHh5VZ2IRzBETFxiaIo/Pbbb9x9990O6YIlhCM4IiZyc3MBSoxnvfT9pV5TQlRVjqwnAIKDg/Hw8GDGjBm4uLgwcODA8ii2EOXG0TFQlq5du3Lo0KESPaNWrlyJs7OzzA9STuSJdyXp3LkzL774Is899xxxcXGMHj2asLAwTp48yffff0+PHj14+umnS73Py8uLRx99lDfeeIM6deoQHh7Oxx9/DMD48eMr+jKEKDc3GhOXrF27ltOnT0s3c3HLuNGY6Nq1K76+vtxzzz28/vrruLq68tNPP3H69GmGDRtWCVciRPm4mXrif//7H926dcPDw4NVq1bxwgsv8OGHH8q8B6JauZkYiI2NJTU1ldjYWCwWC/v27QOgQYMGeHh4MGjQIJo1a8Zdd93Fxx9/TGpqKs8//zwPPfRQYe8pcXMk8a5EH330Ee3bt+ebb77h+++/x2q1EhkZybhx47jnnnvKfN/HH3+MXq/nrrvuIi8vj86dO7N27Vp8fX0rsPRClL8bjQlQJ1Xr1q0bTZs2raDSCuF4NxITAQEBLF++nFdffZV+/fphMplo3rw5CxYsoHXr1hV8BUKUrxutJ3bs2MEbb7xBdnY2TZo04YcffuCuu+6qwJILUT5uNAZef/11pkyZUvh927ZtAVi3bh19+vRBp9OxZMkSJk+eTPfu3XF1deWOO+7gk08+cfg11RQaRVGUyi6EEEIIIYQQQghxq5Ix3kIIIYQQQgghhANJ4i2EEEIIIYQQQjiQJN5CCCGEEEIIIYQDSeIthBBCCCGEEEI4kCTeQgghhBBCCCGEA0niLYQQQgghhBBCOJAk3kIIIYQQQgghhANJ4i2EEEIIIYQQQjiQJN5CCCGEEEIIIYQDSeIthBBCCCGEEEI4kL6yCyCEEEJcTXZ2Njt3LsXV1YuOHQei0+kqu0iigqSlpLB3w0q8A0Jo16MPGo2msoskhBBCXDeNoihKZRdCCCGEsEdRFJYufRNX1yl063aW3FzYsqUtgYEv07nzhMounnAgi8XCwg+eI3DvLDpp4kk1adnh14mI+9+hVc8BlV08IYQQ4rpI4i1EDZCSnMTubYtxdfelW68R8rRQVBsrV35Khw4v4udnLbF9//4ADIYFNGvWrZJKJhxt4ccvMXDbf3G97M/VBqUOkZ/8Q63wepVTMCGEEOIGyBhvIW5hVquV+X//m2NrWjIg4n5au49m+R/t2bF5TmUXTYirUhSFgoJppZJugNatkzl58udKKJWoCHl5ebjtnFMq6QboyTn2TP+m4gslhBBC3ARJvIW4hS2Z/QYDG39Bt5aJaLXg5QHDOu9HlziZE0f3VnbxhLiirKws/P1jytzv5HSqAksjKtLZ0zE0yLH/76vRgP6i/NsLIYSoXiTxFuIWZTKZ0OfMwd2t9L72TS5ydM+PFV8oIa6Dm5sbWVk+Ze63WHwrrjCiQvkFBHKuoOwhMVZ3+bcX105RFE7HxHA6JgYZYSmEqCySeFeGvFzIyQb54y8c5EzMEX7/33hCvY6UeYxBOV2BJboKiQlhh16vJze3v91fi4wMDa6uwyu+UBWlBsdEbk4O6yb3JiXPYnd/rNGJ4L4ysV6Nc4MxsWP2bBb37El+kybkN27Mou7d2T5rloMKKUQFqsH1RHUly4lVpOxMOHMccrPV752coU4k+AdVbrnELSHxQhzb176PLmcWPVsncUdP2HGw7OONVp8KK1uZJCbEVfTr91+mTz/B8OH/4OmpbjtzBnbseIjx4x+o1LI5RA2PiQvnzrLvkXZM9EglwQ/mnIdhoeBie/h93OjGsV7PMKJvVOUWVFScm4iJA6tW4fbII4xITS3c1nTrVg4fPco+Ly/aDB7sqFIL4Tg3ERM5OTlsmToVS34+rUeNIrRuXQcXVhQns5o7WPzZs+yf/ReagnzC69ShaeNGoFhAY2tFaDTQuDV4+VRqOUX1lJmRwaZVn2BKmUKXZucI9i+5f+4qGD1A/TUrLiER/phVl+e/jqm8Gc6NBXBwJ1jMEhPiisxmM7/8+Dh1vX9EsUL8eVcefCW3sotV/mp4TBzZsZGs1wfSyasAAKsCf+raETjwLrTnD2NxcqP+4Dtp2q5jJZdUVJibjInF48YxfI79yUQXjR7NiLlzy7nAQjjYTcTEum+/xfrJJ/Q6fRo9sMvfn3N33MFtX3yBViudoCuCPPF2oMUfvE7IzG+IKkhFo4ETihPTm/Vk7J3DMLh6gos3OHnBhXO3fINKlJ/8/Hw2rf6ezPPf0y7yGEOblT4mIws2HQgi320Ef66O5rau2/DyUPcdOwlHd8NLfWP5+73e3PGfjWguz8wrwsX4oorjYjQY3CQmhF16vZ7efR+niaLOS7Db1VTJJXKQGhwTm2f/TshvD9DJS53BPtcMiyMncfd//66cv09VWGpKMlvXfoOeeMwE06n3ZAKDQiq7WI5xkzGhj44uc5/hCvuEqLJuMCZ2L19OnZdeokF2duG2jikpNP36a5YFBDDs9dcr6AJqtiqfeGdmZrB58/dotRdQlNr07Pko7u7ulV2sq9o0exrt//qQUExgazM01BipG72G5fNgxLjhYMwG4shIOkFi2gVqNWiOu19o6ceTNZjVamXzolnkHNmG1cmNZsPvJqJR48ouVoUzm81s3TCVxONf0bTWXgZEWqF+yWPyC2DDXm+ydSNo3/s1hj2k/pwsFgub1k4l7+x2zIoLJzcv4pkexwG4s+lmpn00nNtfWlzxjdu8HPX/BVmgWNV4sMUEuXEQ6A6u/uDsJTEhqFW7Hol7ITgAgv3M5Ofn4+LiUtnFKl81NCYW/fdFum3+GH9b1Z6QDwei3mXC5Fcrt2BV0N4dS0g9NpkhbWPRatWhnRtW/YpbxJd07D62sotX/m4yJqxXaC9eaZ+oXLm5uRiNRry9veXG2+VuMCbip0yhfbGk+xIPIPW7z1lV352wlr2JbNzipupWRVEq9N/MZDKRlZWFt7d35fXgvA5VOvHeu3cJSUlPMmjQaXQ6MJlg1aqfCA//gebNe1d28a4ofclMNem+jLMWtEePoCjDiEtK488f/sTnzAX6JuezPSyIjAE9GPbBGzh5h4KrH2ir/i+Ro6SnprLsxXEMSVmHj0Hdtn/D/1ja/zmGPnnr35lTFIXdO5ZxZv9/CffdQs/mJrjsoYbZDJv3u5JsHECzLq8y6P7Opc6j0+noPfAu4C4ATKM/YOY7zZjQ8iQA4yOWMvuruxn/9J8Ou5aMtDQ2fv8FukM7UDRarG260W/4CNxArTh0TmAxFr1BY4GMWPVLawA3f7UiqeExUZN5enpyKllLcICVkACIjTtH/ciGlV2s8uXkrP6/hsSE1WplxpMjGXNhCc62Sz+crSPniekMHjqucgtXBRmNRuIOvMjwbrGF2zQa6N02jhU7XiSnTVS1eDBxXW4yJsx9+mDdvbvUTMIKcCrEq0IuQVy7s2cPs2/fm3h5bcDVNZ+kpJb4+T1M9+53VXbRqo4bjAnD+fNlnjIiI512R57H/RScTYdzuS6kagMxetbDKaQFvg07U7dFD+qER9jtkq4oCqunfknBgZkYsmMxuwZhjRzKkIfeRK93TKqZm5vLiv8+j1v0Cnzzk0nyrIvSaQxDn3qjSnebr7JjvPPy8li3rjVDh54otW/BgtYMG7bLYf+Y5WH5qG5Endxqd9/SfA3xA/sSnLqRqCYmCsywcRd47oLOaTDvtoFM+Pz/QKMFFx9wC1ADR+9csRdRwaxWK2azGbPZjMlkYsmbDzPp/MxSN7HPGp1Jemo+HfrdmpPrHInezuFt7xHovJpurfKw92u+45CB2PRu1Gv9Iu06Dbnuu4v5eXks/7Aht7WIU783wvKcJ7nt4a/K4xJKSE5IYON9IxgVuxutrZgWBWZFdmPYs6/ieWm9M3M+FGRAfiaEBoCPneWCalhMiJLWTvGkX0f1jv221Dl06TGmkktUznJzIHpX0Qy1tpjITU9i487dkJmBxdOLTmNGEhDopx5TTWMiLzeXhXd3YKK2aOWFjZlu1PpkE/VbtK3EklVda5b9SrfgB3C18zDKZIK1Z79k8MinKr5gjlRGTFxrPZFjcWbB6HGMXb+eS5FhBOaEQ4sh4PzYdhq16lRBFyOuJCkpgd27+xMVVXI1lpgYdxISvqF793sqqWRVzA3GxOLH3mL4srV2T7nUH6Iehyvlq/lmOJWmIcHoSZYhBKtfQ1xrtyGwSXdObl/CkLTv8HGxFh5fYIa5uklMenPqzVytXYqiMG3ycG5PXlrYrgTIMcOKNo8z5vX/lftnlpcqm7lu3PgrAwaUTroB+vXbz+bNM+jd+84KLtW1MwfWgpP2953wULjDay2Boer3Bh0M6Q5H68LhqdB0zRbOnDpLeP26WLKSMKdfwGQyY9a6YHbyxqTzxKxzwWwyYTYZMRfkYzEWYDHmYzaqr63GAszGfKwmI1ZTAVaTEYupAMVkxGo2YjUZUcwmlEuvLSYUswnMJqwWExqzSd1mMYPFjMZiAqvttdWMxmoBqxmt1WJ7bUGrqF8aqwWtYkWLVf2/YkGHglaxosOKDsX2ZUWnUdBrFHSAXgMGrfr/fCuE5IDGzgSN4U4FHFwzDW6hxPvsmWPs+eddPKyL6Nkmg6ZdSx9z6KSWI3FtCGn8DF3HTKLTTdx4cnF1pf9z0Sz9LJKhzVNwcYIB1q9Z9rcfQ+5888YvxI4tn77F6HO7C4dcAOg0MPHUFhYvX0r3gVFsmzsfbUYmbiFBdB80GJ1zfXBxAW0+5KWqY5lAvcObl6p+ATh5FCUczp7lWm5R9eQUeANq4p2RHA3cYom3mzvUawJnT6hj+Kxaju05xonpPzM45xwGjdrW2rhyCU4PPkqXIf2rZUwkno9lzyPtmOieUrhtQW4oPf7Yg/+tOla5HJgLLtpNugEMBjh+aB4Dhj1eLbpbXjM7MUGmFdxrgXP4VesJd2Dsr++xfsYKLDsPkJefT3r6Su7sa8XFAOv/14/QT+Lw9PKu1MsUsG3bFwwfXnoJ1Pr1c4iO/gFFuVu6ncMNx4T3oK5cXPUPQeaSyzSagei6gWgSFAJ16UR6m/F1Lf2xLnpoHqjQnEwgEzgOF5aQdAoKUsDnssnRnfXQKXUaX47cQy1vT7UJqCio/U2KvS58/KugUS7fpxTuQwENCgpwNiWTSW5xaC8rp7seau+dQWL8KwSH1brOH2zFqLKJt9V6AScn+/s8PSEvr+wuE1VBwMhJnNuxmDqW/BLbc63gW1cdgnG5JnVgUX0YEZ3DlCfupXu9ksmoXqN2VXfXgF4LTpXdk0ID6Gxf5exMDoRdYYiJPiel7J1VyNmzx4iOno5GYyE8fBjNmhV1BU+6mMDWNe+jy55Jj1YXGW1not4zcbDnVGO86jxCj0GP0aIcx7R6ennT+fFDrP2+Ef2aZOHhAp2z32LtPD/6jS6/pyb6XRvsbtdoIHv9Mg79OZchCQlogAxgzsp/6PXaa4SEhEDjxlC3KeSnQ24y5KaApaDoJJfGNqWfAZ1zsW5VvupTD3ssRnWftsr++bsqRVHY888qkvZtxGpwocPY+wkKCa3sYjmcUQkE1F4aeVll3NmshsxmMzqdTm1UBgSDbwCcO4Ny6CCH509jdO65whtXGg30yk9m7W+/kNp/GH6uSrWKiaO7tpDxWj+GFJu5fIa+HWNmb8b5VhuzX84CwzoQd9FAraDSw9iS06B9+Hr++csHo/crDBzxUpVPwK95LGixmCD6ELgHgN4AiUlwUXPVesJZY2Tw7X3h9r6gc2bHjiiydzyDiwH61MphxstdmfBNdMmy3AL1RHVjMOwvc+qK4OCdxJ49S3hERIWWqcq6gZjoedsAFhw9Rf2/F9IyW10V5LxBz4Z+3Xjq129w9gkFV19SUlLZtn8rZ3atwHRuOz75ZwgxpFPL3UyQu5p/FLc7HgY3sF/MSD9odPQYQwrs779Ry00QYufmAEBHfTIrVs0n6p7Hy/dDy0kl/0XJBtIBAxBA8QzOza0pGRngbecmZHy8noCA1hVTxBvUZeQYVsS8yZmpX9I9OwGtBvYZvFkT0ZKmHpspdounBIM/5AG1PaGBR4UWucIZrWC2glkBk+3/ZkXdlmOG0znQpIwhWCa/qr3uoKIoLFjwEvXq/cjQoRkAnDz5CX/8MRI/14aYU/6kS7OzjLTza5yYAtsO18Lgfw/dB7zAmIE+Diunf2AITe7bx9a/mtM1Mh8/D2ia/DRbVvrSbVD5jKnSGvPL3Od07gy9Eoq6JnkDEw4dYs4XnzH2rTfg6CHw7wkuvuq4PX/UpOJS48qYVXQySwFkxatfGp2aaLgFqO/TOUFOEqSfBlMuoFH3+TWoel1zrRbITFLvZLv7gEvJPwQ52dksfGkSveJW0N7JhKLAttVfsn/YSwx88LnKKbNDFasn9LWAfQBY8mPLfks1oCgKq7/4gvwZM3A5cwajvz+mQYOI+uADdWKbpFS2Hz5Cr6Rjdm9u9slOYPmiNQx97tVqExOb50wh6Nf76Vxs5vJF9SZw+yfTr5yAXSUmaoq2Hfsz84c+TAhcVSpBWbsdxg8GjSYbeJU1f36Ixe81Bgx/vkqNd4w9dpT9X7+Pfu9mNBYzpmbtqX/f0zTveZV5e3Q6SEoFd28oyARTjjqOW6O77nqiU/vWzDswipHWBei0MDH4CLPfv4dxr/5xy9QT1ZHVWvbP2JRn5syGBuxYPZzuQ74grFbEZUeUnU/csm4gJkZ+EM6B4VH8PnUmxrRkLGHuBPlbWfT+RPQFabgpWXjr8gl2NdPWE5wDr14MjQYsVtCX8SN3xIBm6xXOabSCoQoPRa6kMd5W4AiQVGybHmiK+tuhzsQ8f34Pxo7dVurdP37fmIceOVItupykpaSwfeafYDLRNGokdWvVZunTTRlW55zd45csBuUodOyjjrW4PDG1ABZFY3utUb8UDRa0WNFg0WhQO3mDVaPDihZFq8Wq0WLV6MDghqLVYdXqUDR60OlQtHrQ6dU7uzo9is6ARqdHozOg6G2v9U5o9AY0OgNag+213gmtwQmt3gmNQX2tMzijNTijNTihd3JB6+SMzskZvZMLOidndLb/G5yc0ednoU8+jUGrQa/TodfrMPiGoA9vgc5gYOF/XyRqxyc4XxbMeywBeL29mgbNq+7Nl/Xrf6NFi4cICCjZpSc/H1ZPg+GXzYGWmQ0b9/tidu9Fl353EhwSyOUx4UhnTh4kdX572oWrT1LOJGlIbb2Adt1H3PS5F94zipG7Ftrfdw5GZpXeftDFCa8Pnic8JBAaRoC/r1qhaA3q7+mlLxR1Zk9jlm1WT21RxaPVqcdotOpxOUnqLJ9ag/r7DqB3hVody34SWNEykyHuiNqousQrEGo1LRx8Nee1Bxl97JcS45oATprcyX52IW169qvAAjtS6Xpi0fT/MaKVuibvvI1NGP1I6W6J1cWiV1+l+4cf4mctuvFkAaaPGMEd06ah2bmT5YvnErXs6zLP8UuTzjzw5ZfVIiYWffIyXTd+RICtbZ2YD3sGvsmQJ9+48huvISZqDispyRtZO+9VmoXsoUlEHkdPG9i13cTg1hDSGDXvKGbVdi8IfIP+Q58pTMBzc3PJzMwkMDCwQp+Kx5+O4dADwxmUWDJud3mE4PLxVFr06lv2m3NzYccO9XXKCTXJKO466wlFo2XGp//m9toxAKTlwZHGL9GtY9tqVU9YrVaSUtNxD66DR6P21TomVqz4ij59ni6caLG4hX/ByHbq64Qk2HS4JfXbf0j7TlFcLZ+oqsxmMxum/YHx5GGsnj50vucR/AOvIdO95LKYMOdnciEtk8S0RNIyLpCjz8NckIYmPwUncwae5ODnVECoh0KA282Xv8AMcVkQl6XFaLbSv37pYw5c1LPVEkWIf4C6QaOxzbSuUf/TaNXHkBqNmtPZ9mlKHKd+r6Aej0ZDYnIKbaOn0c6zdO+flaba9PrPL7gE1qqS9UQlJd6ngbOgmNRbIdpLfcq1QBdA/T429ig7dkymS5dN1K5t4vQp2L0RzOmeTHgqvUrdxb1m2dnMf+NuRnrMK/W7kJkPM6c4UWvyZDoN61OUjOr16PW6ktdrtagVSEGG+lW8UZIVr3aTysuC7ERwDYSg1uo6fz71wS3osl/+Yq+12tLbHPHaYoKTO9R//8v3B0ZAUARms5n5b00m/NBcOuhTyLXAeufmBNz5Op2HT3DYP1F5WLx4OMOHL7G7b8lsGNZMXf5r4z5PsjQjaNfrXiLqG64aE4509MAWrGt70ayW+rt0LF6Lpdc6mrXtdVPn3b9mJdoXJ9EyP7XE9g15EHwGGtv5C5QN7HvuAXp0aAGRdeHSRFJXUgNiIjMzk82TIhninmz3R7C48b0Mf+e3q/+sqoXS9cTaZfPoF65OALhsSwBDHky68imqqPS0NA60aEGv+PhS+y5qtcRMm0aXoCCOHj+K7vOnaKgt3bjIs8L6xpDnH0zDkS/RsnXb0h9UBWLCqijMfOVeRietKLyJejRbS8b9P9F56Ngrn+caYqJmKYqJmBNnOXUyhojISMx5ueSsfJ4O9Y3gA0ogaC5LwFds8ybX/QWs+mP4+q7F1zeVhIQGwASGDHm1Qh5kLHrlSUYstD/p0YzmAxk/fXnZ7brsbNi1S32ddKTk8Aq4oXoiN/0im6f8h4Hhaq+s6CQNnu3vpK6PU7WoJ9YuWUDunpWE5cSSpXUlLaIrHZ79gtr1q+dqDyaTiRkzxjBhwuISQ00XzHNDn5THsB4lGwsFRli90xdtwGj6Dx2Lk0FfKW2nG3H+5Am2PfUvok7vwMO2LOBG9xC0T79Pj3/dV+r4zMxM4mJPk3LmIJlxRylIOoUl5Qz69FhcNVl463MJdLVQy0sdi32zUnIhPhtS8/VkW5woUJywavQY3PxwC26MT2gkwQ27cPbMSeodeo3DF6FJANT1KTpHer6WNW53MfbRtxwSEwu/eJ1O274ixFBUPx4pcCep16P0GjysytYTlZR4bwZMYLoA5gug0YHGxfbVBLSNQOsOGj2KorBv3z8cOriKutr36W2747Xy2H8YNGQCYAGtDxjCStc0VZGikPvPP8z64zlGBO7Bz3bXKSYFZh8IY/TLH9OwVWN1IrNLX2V0Sy9+Tky5tsZVJlw8pE4ukhwDBbY1+wLbgk8kuAaAZ22HXuI1yUiEtISS2zz8IKAu6J2gcbfCzQnnYtm/bgkuXr50HzYWg6Hq/zsvW9aRIUN22d23cC7kJw+hedfXaN7y0nVee0yUyZwE5kRuJib2b1uO1+6h1AtSf+f2x+rxGL6DyMZ2GvXXYfeSBcT//hXBR3di0Wg57B1AZuopnjlM8TnXCm100lLvfx9TOzgA2jRTJziooTFxvsDA/nWLKTi1B+fE49RzsdKsjHmAlocOJepL+zd8qp/SMbF371naen+q7t3nTPdJ2Q6PCUdY8fPPDHzooVJLHF3ybd8O3PHyu/g4OTPrgxcYd25Xqa7F83UwdBQ46SGzAFak1KfjpNeIiKhn/6SVEBN5efksePsxbnc5U7htc4YzwY9+QYNGTa5+guuoJ2qGsuuJ+DgPDv91LwOaZKp/VH0h2wM8bPPrmUwwZzdMvI8Sv0uZGRrW//MiI0d+6PDSLxvZjSGn7K/2sswMdQdCotGDTH0wFu/6OIe1wK9BJ+q26EZYWC20O3eq3cbyUtUEVFEndkWj3HA9EXMsGtPSp2jsrx67/LQzfbr1wAXbEKkqWk+sXreeFicWEeJsLbF7kaEVvb75B28fn8op300yGo2sXfs/LJY16HT5GI0tad/+KXx9glmz+C2cc36gf8dMLu+oseOQjnMZLek5aAxBISEV3na6XnMmDWHsgeWltv9jdeF4/8746dJxLkjCw5qBrz6PUA8rQeWwUqDRAvFZcDFXR7rFlTyNJ2ZnXzTugTj7hOIZWBf/oBDC/D3wcTKjSYous57YuOcQkQm/EGb7GzM7Ggp8muHvbMJi8MGlbg/6DRjh0Jt6m/9ZR9rOlehzkjG5+hLeqhOtmjSo0vVEJXSCV+DS+tZKnu3/FlBygBxQjtteAxpnNFp32javQ9uWTzHzpzXAdgAMmR9jLuiNXq8DSxqYE8ClLWir2Dicy2k0uDVvTruuD3J462SyjJCQBe2GfMaLz42B8PCSxyuKrXKxVSSXZhcv/Lrse4sJrFZIOVbUvUKjAw/bxEtVZaIQi7nsfWZjiW9D69Ql9O7HHFyg8mWx1AbsJ95ap05MeHhpsS3XFxNo3W1fHrYKxQ2Mx9WGWGEBbiwmWneJYnvuVJxPTCLMD1rXNbN9XlecJx2kdviN30VvP2wU7YeNIiUlBa1WS1dfX9Ytms7KSZMYfFmPQQVIbGQlbtPXjHl1BU51G112wK0dE7n5Rnbu2UvSkV34Zp2no0c+w2xtgPwA2JRMmYm32bdqzuJ5/ezHRGiwJ9mp4OEGAT4FWLM3oNW5OjQmHEHv4oIJKKsUEfm7yFwexbq0MDQtejMNPW3P7aepJo94xcDqWi3I9U/BrMTiBHg5w/iwGC4suZ+ZSk/6PvE9gYGBlRoTFy9eZOeHD3O7d0bhtkWZvnT9v58ICLjGLqDXUU/c+q5cT4QFa/F88G/mfPsgY1slQip4pMG+LB2hkRYOnYUREyl1A8fLW8HL828yM1/By8EzeytX6taugWYB0FyTzf+3d9fhUV3pA8e/E3d3JZCEEMGCu3uCW9ntr0q3tlRXSnW7pQ51b7dCcXdosSLFLYQQgQSIEffMZOz3xx0mCUkgMlHO53n6lNx75+YOzDvnvvec8x5pzNMVyPsNTkD5EYgrkJGpsKZI7YDGzBMLhwCc3Lrh59MNr379kfl1uu2X1a+d6BzpzsGMxXgm/hc7c5gQoGDlwVPMGxaGzMikzbQTFUolWTn5ZMWfIy8lnpxTv+Hhpqlx3KSKC+z65VMmP/1KK1xl05mZmTFhwnPAczX2Rc19D632Xf78YzWZca8yokciTrqPbL9wNf04x40r51i73ZuuvaPp3t2oxe6dGiLhwnnCYw7Wum+YTE5xwkGmDG74efPKIb1YRp7CjGJsUVi6o7XxwsTJHyv3IBx8Q3Hz74qXhzudTIzqd++k1dbaThz88wjB+evw1CXdl3KMCJn5PuHhvRv5t9I4g4ePhIhgqd5BbdpgO9EK3yQywAYokT74aEAjl4YTAmirlKnTKqThRGppiOrg0U9zI/U4vh4wsq+cbRs/YMqkqWAZII0qUV4D89tu0tsiV1eyjIsYrcuxd153oOfMv0BtcztkMulJXUO+9LUa0FSAvb8UPNYeYOsByMCrr1QkRHurTL/u/1pNLdua88+AUlG5HcBUV9HWsm0ugdMQTk7zSU3dhY9P9cJixcVgYnL7EkiNjwkANCWgvCE94b11Q92EmOg/ah4HS/Mxy34CF1vo30XBweW9MH8kHlf3piV2zs6VN9wjo+Zx4GsVy59+kGn5KmyABFM42wUmR4GNeQprl04ialkMFpZV/g46WExoNRouXThPwvblGF85TphxPsNtkL6dHau/DQtjqeigUiOtdlDVRZUDnac8VP+/kzat9phwc7clIQ5CAsDbDbKz8nH3MGr2mDC0wbNmceA//2F8Ys0lM6+YgH838LMHP/t0YCVXusFuGy922Y5hwIIn+euYcchkMk4f2ErqiseY7JmBiRF42MAcDpH0UTgHHWcx4bnvsLGvo0JlM8ZE/LnT5L17P5PtK4cDr9SEMuPbDZibm9/xtfdSO9Ewd28nbO1siH5+OSs/WsTcbpcwMoKeNmr+/NOEOJk5o61Laz3zoMGpHD68g1Gj5jfrO1D1GIg2/nCtlatzbUChrn2YrKXprWWMbiXlqcBJKIayCxB7UEamUre2sGMXLL0icArqj3/YADw8PZGZ3Lla/vAH32TNG4nMYTUAswML2XLViF7Dp2Fp542rs2OztBNarYb8/AJupqeSdz2J4vRk5Nk3UOfdRFacg5m8AEtlCfbIcTFR42EBPsYQXwxd6uj9NJaB8fXz9f0naXdkMhmDhs+D4fNIuXqJvXsfJMzzJKGdpe8HXw/w9UijXP4l235ZgbnLfEaOmYWJSfPfO9VXanwcQzTltQ73k8nA5LZcUamGjBK4WW5CgdqaMmNHVFZuyOx8MXcJwNbRHyczZ7zsnAlzc0Pm7V17PtEYtbQTB44cp1v+Otx19fwu5hhjNH874b0Hi3yiHlppqHkWcKn6Jq1aqqWjCQZNOWhKQVsK2upPvNf8+HfmjIwB4M/zRvTu9Sjm9n5gO1Ca22HViMdErWDTuw8xTf4/ADbkRTDj4wuGOXFFKaSfhPxkaUihvZ9U0VBmBC4hYF3LwtitQaOBKyehorzmPt8wqXhOO7dr19tYWX3KkCEZyGRw6pQT16/fx4wZn9Qy9KbxMYEyFdQ5oCoDebr0JWTu1eSY2L3yLQZWvIydbjrE7kuODFiUhL1DPebRNYBcLmfp7H5EKGIIDoCuXtX3b0zzYeyHsdjY1pFA3E0bjImcrCxOr/+O4sPr8c65SB/bihqJ9C1ZcjitdKQ0aCi+kx8ifMgYtr2+kPCELYSZl6DUwAFZABazX2bonI6SeENdMXFk5UQG95SSjXMF39KzZ0iLxYQhHfj6a3xefJHA4srqggUyGV/29mNg72wGe5RhWksHYVyOEZdk4TgPf5JBUQ9gamrKHxu+RbHrRcb5FFU79myWCdcDH2fikx9gVnXSZDPGxNFNy3H59v8ItpZ648rVsMVvFnOWrmn4kMN7oJ1omPq1E1pNCeu+fJ0pnvuw1P2zL0+Avyyu/aw52TKuXN1F//7jmvPiKcjNZe9fJzIj5WS15HufcyB+n67B3NGJ6xePkp90AkXGRYwLr2KnysLLvIQAB2ld4IYoqYCrBUbcVNpSYuaJ1rELFt7dcQ7qT6ew/ri5u+s/kxp5MeufDGG2XzoHU6Q5rkGuRpRrLclwGEDInLfo2qP/nX+hjlwu52ZGBtkp8RRei6cs/SrKrBto89MxLs7GQlGIraoEJyMF7ubg1MBpyKllkFcB3R1q378jcAGTlixv2EnbrSxKik+xd+t32FTsZGQfeY36SUfPm5FZNpLhYxbi7FLl/qWV2om0lBRuTutFb2VBjX0aLXzgHUDw2BFYuQdh7xOKW0A4Xt4+uoeWLaiWdmLv3r10v/6Ffknk89kmmD9ykJCerTicu521E62UeANkAimAHOmxjzMQRI3BdxqFlGxoSkBTSk7aEQoSFhLoJ132poPhTJs8HSwCwLoLWDetEFRLWffCYGbZHgVgg3YaM17f2PSTalSQfhpUug+fma10A2VkDFauYNz6cxurUSogIwFK8qSnVKYWUhEEB4/WvjKDyc/P4/jx5Wi1Snr0mIWXl/8djm5cTKC4JDUgykJQZEmNh5GTQWJiy/fPM9Ziqf7mbctFD8b8IwkrawNMNrrNjm9fp8flN/CuJb/elubG0HfjsHdsYNLfRmJCqVRyeu820rb/D+srR4g0zcO1jja0QgOnikxJt+2EXa8xRM57AufA8BrHJV2KIfHwbowtbRgy836srAxQprTNqRkTO78bycRBUnG5fdc+ZdTEp1o0JgzpzK5dpP/4IyYpKaidnbGIjmbUwoUAnD+2j6St7+GZe5ABHgqMa3kwcz7LmESzXriP+jv9xs1h789v43j6HQZ6Vi88dSjdktKBrzDu/n9Ka140U0xsX7qYfgeX6D/bWQo4NeoVJi36T6PPeS+0Ew1T/3Zix/KX6av8AFc7uJAG1pOhSy0zhrZtDmZSVFyLFKzNz8nh8KfvYnLuCDKVCmW3SHoufAbf4K51vkatVpN6/Ro3Yo+Sf+UEioxYTIuSsVdl4WleSoAjmDWwOHuRQkrKs1R2lJp5orV0xsjWg/xzGxjTSYOvffXj9+V3xuX+VRgB+clxlKYmUZ6Zgjo3DaPCm5iX52FVUYS9Vo6rqRp3CzAz4F9nlhxuVsgo0JpTYmLDjbwSFvrWXKqzQAnn/7qc4TMWGO6Xt3lSTGg0ZRzet4fcpOWM6pWG/W2dnSlpMk4m9SZswEuEhnZr1XZi7cL5zDq8qsbojz0Onem79SSOTobt4GiwWu6dftu2jt5X3sFZd6txNssU68cOEdy9fg+kmlU7aidaMfEG6VOuQFpvr56NvSqXtd9PZ/bQQwCcvWxEcOgrWNs4gLk/uERLcxDauC1/8yPaU1pSbKfXK0x8tAk3JrdkXZTWrQTpZsqzF21m+Ys7USmlAimm5jUnoN1zGhcTyC+AVgEVN6HsCmAJMkuDxMS6Tx9kqsuPmOp6G9bFBBC9OA6zZnj6euHoHuS/RNPPQ1Fj3+40RyLfjMXF3bP+J2zFmEiOjyNm3Veoz+wgsPQqEXY15+PdklQi45KpD5ruY+k6/TFCInoi02pETAC3x8TGr0OYPjQegK0XniZq3ic1X9LMMdGSNBoNpw9u59rOD/EtOkp/z5oVzgFOZZqQbN0P9+FPkhN3gKDrPxDhWn05w12pjtiMeJ4hg3U9OQaKCY1Gw5pnZzEtdSMWur/WhFIj8v/2K/2j5jXp3Hqinaii/u3E0T0/4xb/IIEeGtYnwbCHwbXKgIbTx23RFD1O3zFL2k1MVKVWq7mecpVUXVJekXkJ06IUHDRZeJqXEeBArSNHaqPVwrYEiKrjGcDaQzDbgPlQmQoy5JCjNqXIyIpycztU1i5oHTwwcfHB0jMAW98gnDt3w8PbF1tbW30P/aUTh8l5/y8Mk13Tn69EBVs6L2Deez+3z1V/mqR6TCTGn+Hcgefo6fcHQf7V05zSMvj9tDe2Pk8zfEgkxkaqFm8niouK2LnoQXqc2k1XTSmFGjjg35suL31w52X1Wspt9067d+2gX8KrOOpm/Z2+aYrDk8foEtayc7rvqh20E62ceDdO0c2jXDs2lIgg6UZ2/YFIZk59AEyCwMwF7LtLazC2YX8stGKYt/Qk6eTwbfQdMblpJyy8AflXpD8bmYBXH7jLvCahA5FflIZMASiLoTQZMDJYTKx6bxpz/Dfrh3CtuhjB7FfPNssasNmZaRx5tR/TvGsutbQ/3ZaQl8/j6VtH5eaqWjgmiouKOLl5OXn7V+KSdoZ+1mVY1TE0skgJJ8ttyffvh9uYv9B3ylwsq85jF+q07tuRzBp8AIANx6Yw46GttR/YzDHRGtRqNSd+W0/qbx/RpfwEvd3VNY7RaOFEphnJ1v1QKlUMMz5OJ4fKZl6phu1prgRE/YseU55ockzIy8vZ9EB/5mlj9NuOFlng+s5Bgnr2a9K5BcO4dPYPyn4bS2SnCg6nQIENZGtscHaKINRvKEFBo9ptTNyJSqXiWnISabFHKbhykoqblzArvoa9OhtvyzI6OYBJlfw0pxSSC6BvHaVMdp2FCXcZFq7WSr3TWUojCrCg1MQWhZUjals3jJ28MPfwx9o7EIdOIbj5dcbVzQ0Tk8aVW0q9msTZVZ9hmh6H2swa88gJjJr/yD2YdNetsCCf/dv+jaP2Z4ZH1hyKfOiMObnK0YwY+xgONrIWbycSzp3l6vHD2Lh7MSh6etv4t7vt3mnnrl0MTH4LB11TcfKmOc5PH6Nzt56tdontWbtMvNFq2fDjfGb0lwphxCUb4RG0Fsdbc09NrMC+Bxi3zQrnSqWSlOfNCHKGYgWU/T0Dd48mDIeQF0Dmebi1dIZbBFjVs2qs0DFotVIlzltLYmiMoSwftLov8SbGhFarZcV/R7IgpLIS54q4Qcx/5XCzLBWhVCpZt3gSM8x/rzGv70iGJX4vnsG3yx2WI2qBmNBoNMQc+4Mrm77BLG4/EdpM/OsY7a3RwrkiY5Ltg7HoF02P2Y/h41+PhwdCDZt+eYBpkT8BsOFQL2Y8dqb2A5s5JlqbUqnkzx3Lydr/GSGqc4S71hxRodLAn+lmlGBFX6cCXKp8PksqYFdhGL2eXE6XRt5AZWekcfyR3kyxztJv21bqRv/vzuDq2VEq7HcMadeTiPupD2NCKqvMr7ngz5SHP8fKSjd1qJ3HREMolUpS4k6TfmwdBWmXUeVdR1Oag70yg3GBtb9mzXHwVZtRbGxFubkDKmtncPTE1NUXS88A7PyCcencDXdPL2xsbFr2DQl3pFar+eP3bylKfovRfVKxua2tTrou42xyD3oOeIEgH88O00402G33Ttu3bGZo5kfY6d7+sUxzPJ87jX9QWKtdYnvXPhNvoLysjNjtDvQJk4bdrT08kdkzXpaq7wEYW0hPqkza3rzHK4nx+P0SgqkxXMgyIuIzVeOTF3UFpJ+S/g9S5UFHcUMvAKpSKDhvsJjQaDSseiOS+8LP6betvDKJef/c1mzrNNY17/tkppn0xDW0lvXFmzEmMtNSObPuG8r/3Ih//mV62akwruOtp5XDOa0biq7D6RT1CD2Gjm6WEQL3mt2b/sv4YGmpnK1HfIh69Eb9X2zgmGgrFAoFRzZ/R/6hr4iQxRLsXLNZr1DDtULwtateOTqrFA5ohjDs2V/x8Par9+9MPHeS7H8NY5Bd5TzTlbIIpv94vPoqBEKbUVSYz28f9mJmROXw5B2xzvSZ/R1urg7Shg4SE3dVSzuxd+cmsjc+x7yaJTUoV8L+kI+Y9JdFLXudgsFdvnScmD+epU/nYwT4VP+uLCqBfWd8cXRbwNBBY6Ue6Hs0JrauW8HI/G+x0Y3yOJphge+LZ+/c6SHcVbtNvAG2rHyO6B7LAEhOk2EVGo+7RR6odcNJjMzAoTuYtK0nj4e2/MTQsw8A8FuaPWO/KWjcibRayDwnVRsEsHAE9+5tdl6D0ArUcinRMFBMKJVKNr4ZypyIJABUath4cwGzFzVfBdXzR3ajWB5NP4/qa2yczTLG8uGDhPSuUnnUwDGhUCg4uXM9mXt+xj75GH3MC3GsY6ihXA0nSyy46dEThxFz6Tv9AewdHBr1e4W6HTu8gQFOMwHYd9KGUf9XfJdX3MbAMdHWlJWWcnjDF5Qc+55eZgkEONRs4lVqaVlWoyphkVwg45TdVMY/9z/s7B3u+DuObVmJ41d/oauN1MsuV8Mmn+nMWbaubQyVFOqkVCpZ9/ZQ5nY9rp869OcVC1yGfUFQoO4BZQeLiRpqaSe2rvuVoWnvUySHi1kwMaiy2SitgE2ymcx9fVWjh4ULbU9ebjYHtr2Im8kqhvSqXldGo4GDpy0oUk5g1MhHsLV3vKdiYvOKbxlTugJr3f3O4QwrAv51Du9OtVRnFBqkXSfeFRUVHF/rwNBe0g3UmkMjmPPobii4AKoS6SAjE7CPAFP7O5ypZW356GmiCz8DYGNWMNM/j2/cifKuQJGut8fYXJrD2tYqlwutT1Nh0JiQl5ez650gpoWnAaBQwq6Sp5m6sJYiVwZS17zvy7kyKubtovsg3TI4TYwJrVZLQsw5Lm/4Gu353YQorhFiU/dXZFyxjHjLTsh6TiB05t8IDI1ott5/QXIlKQGvwq4kXINr6RD1pKYRy1QZNibaquKiIo789CryC2voY5eBTz1W5IvJNiap0yNMeuojzC0s0Gq1JCVcRqWsoGtoBLs+fZ0++97ETTf0MFsBJ4a/xOTn3mreNyMYjFarZe1H9xHltkq/YkVcmjElQUvo21c3L7+DxgRQrZ3QGpmx7qcvmKL4FUtdU7HvmjEpPvfhZZKPxtgCs+CxjJzxsBix1EGpVCoO7PqMsrT3GNMnA6vbBuxcTpYRk9yTyP6L8AqZwL493yErP4hMK0dp0oNeg/+Oj187T0irxMSmnz5lnHIDVrp4+CPdmsDFF/Dy69yKF9hxtOvEG2Dnhv8wMeQ1ANKzQd0pHl/fzlAYIy0RAFLFVrswMG8b857X/WsMsyz3ArBeMY6ZS3Y3/CSl2ZAdq/tBJlWmNW/kOsdCx6dRGTQmiosKObS0C5PCcgEokcMho9eYuOB1A11wTdK874nMtNhbbemYawWQE72RyH6DGxUTBfn5nNzwA4UH1+B+8wJ9beT6ysy3y6uAUwoHigIG4DXxASLHTWv5tTXvcdvWL0GTsZg+4VBcChfTBhPY+zV69BnbsBMZOCbapCrtRH5BEUcP7Ucdu47+tqm436Xj5mi6OTFO0/FUXyO04gTGqDmc4YBnXgFjHKVjEkqNyH3kJwZO/0szvxGhOWz/5RX6VfwXV93XZHo+xFo8w9gJU6UNHTwmNBotq778L3Os9umLrB1Kt8L/xZP4BYa24kUKrSXm3AEuH3uRAUGn8L1tAZWMLFi1y4yn76ug6sCHA2e74B25iqCQPi17sYZSJSY2fP8hk9imn450IN2GkFcv4uF9p6VwhYZo94m3Wq1m/8+OjOkvDTdcc7Afcx4/Dlo1FMZCRZ50oEwGtiFg4d6KVyvZ9EQg09ylioHbnJ5hytPLGnYCZZm0vp5WV9HWKQjsRCEb4S4MHBO52Zmc/yqYUSFS7OWVwDmHjxg1vXnnwO389nV6J7xRLXHIKYP4kH/Tf+ho8guLsffvgZlL7fO61Wo1Zw/u4drW77BMOERPo2y86piSqtLA6WJTUp26YTVoOr1nLcTd06sZ3pVQH/t2fEqY7fO4O1dfUutYrA9uvXbQOTCiYSdsw+1Ek92hncjKTOfY6ncxurSGQY6ZONXy+b94U6rQ3OO2up9XcyA7ETRY4LRkP117D2jmNyI0p6N7fsY94UG6uEvTBorLYU/uTGbc96Q0kqSDxoRSqWLdsmeY7x6r370rzYnI/1zA1UPcT93rsrMyOLTjebws1jOguzTNbccfMHYgmNYyiG7LqWlE37+xha/SAKrExLpv3iXKeJe+oO3eNDsi3ojFzdOnda+xg2n3iTfA3h2fMNJvEUZGkFsAeU6nCAqJBK0Gii+DvLLiKrZBYNm6X6p7F9ox2ltKVo70Wc7gyQvq/2KNGjLOgLJU+tnaHVy7NcNVCh2SgWMiPfUq15aHMbCLVGApowCS/X9i0Lj7DXCxdTt/ZDeaFVPo5aYCpDmrG+IAC3s62ynJM/Gg1HcCE578AEtLS26kXOX8mq+oOLWVgKJEetiqq81vrSqlDGJkXqjCRtFl6qOE9x8i5q22AVqtlu0/DmBK/xO17t9y9m9EL/iyESdum+1EkzSgnUi7nszJ1UswS9zEEJccffXaLZchuo4aOj+cMGHKt8m4eYkbso7g0tmDlP8+lshO0gMtlRrWxPdn7sK3KodXd6CYKC0tZeeyx5jlm6bfvTHdlzHvx2Br1wGH1guNplQq2bfjQ1RZS9Eos4kaUftxB8+4EDktuX1Vs68SE2u/eoupZr/rRxP+lmZPrzfjcHH3vPM5hAbrEIm3Vqtl53euTBiYy+EzcOGKI51D5+HiO5m+AyYiK02C8ipzQ60DwLp1hk1otVouPmVMhJuWCjWkP5BEp85d6n+C7DgovSn92dQaPHuDkZh3JDSAVgsliQaLiZSkGPI2RdLbX7ppu5YjI6/7ZnoNjjLE1dYpKyOV4y/3IMovj7WxEN2VakuPqTWw7JQLvdVy+lqWYFvHVO9SFZwosybXOxLnUfPpG70AG1vbZr12oeHy8vJI/K0T/SNqL6b2665A5v49rnHFjwwcE62uke1EStJlzqx5C+urm1HLi5lUx7TFnTd9mPhFA6rJC21e6rVE4n/uw+iQIv221ec7EfXwF1hZ64ZEdICYyM3N5dgXjzDZr0C/a1VWONM/PIm5RdPWtBc6ttWf92buyLO17vvzgh0h41NwdHRs4atqguw4tCWZrPnyTWZY7MdU10TsTnOk75LLOLm4te71dVAdohtHJpNh4fsuv26D7sHw1Nx8JkV8iZ9yKiu//Stqqy7VG4vSZChJkm62WlhGejqddVVmUwrA179T/V9cnF55MyUzBrcwkXQLDSeTgW2wwWKiU2AEVuMOcClN+iz6u2ixPj2NS2cP3uWVTePm6cOE98/wUZwfwc7UWO/b2AjmBuXgSM2k+0KRERs0QWzt9QzZ711m5K4SZn1/kJEL/iaS7jbKysqKEkXdc/YdVUkcf8+GDZ89QH5eTsNObuCYaFVNaCc6BYYw46VfCFt8iqzyuosSas1EjHQ0Pv5B9P17ChtiKpeUm9sjhQM/LiArSzcapJ3HROqNG1z46q/6pFutgRXFI5j9yTmRdAt3ZeU8ps6P/qW4Cqza0zKKxeloSzJZ/dlrzLSsTLp3pjnT/50EkXQ3ow6ReAMU5cVy32RwqHJf5uGqZnrfFezZskx6UmtTpWe5LBWK41u8Abked0Jfnj9DblX/KpmKIshNrPzZJQRMO/iagkLzMmBMhHQfhHLANpKzpPHbwZ4aVPvHcDW+9qfDBqEowrQohZCBk2rMQ73F1xFuaiFLDjtLnFnvOZUTj2wmdJuCGesSiPr3MjoFdm2+axQMxsLCgmJG1rqvpBTM5DA4SMEM95/IW+HG2iXDSIw707Bf0kbaiUZrYjuh1WrZ9sW/kH/cDRdzJUp1bceAyn+UAS5WaGvs7B2JeiWJlXH90EhTvpkUnk/S1vtJStStvtJOYyIhPo6MFQ8z0kdaBUehgvVGc5n//j5RrVyol/4jF7H7ZM2ie/FJEGYtZ8uScBRyeStcWQMpitDmJLDqk8XMtjmkLyy4Pc2VQe8m4ODk0rrX18F1mMTbVP47tX13WlqApnin9IOVL9h2rVycUZ4JRbHSHL8Wkpd0Uv/nQmPX+r1IrYSsWEDX0Nn5gHU9XysId2LAmOgxYAJZ3VaQrqtT1d1XRfamgaRdS7zzCxujSkwYmVigqiVBAOneML7TWIy/z2LijhxmfryJfuOixVqs7dTAcUvYcKgPyiq11XIKZHz6ixu+VaZmdnHXMjvoEG4nItn4emeO7PmVes+qagPtRKM0sZ24cTWejX/rxKSsdwl01DC2C6y8KK1hfItCBauLhzD8wTcNe+1Cm2Fqasq8V46xLn0u5bp/+0GBCipOPsGp44elDe0sJs6ePIpq21P09ZC+OIoUsMtlEXNeWyWWfxTqzc3dm9AR69l65j5+O+HNgdOOfLPKmsJ4GBAAsyOusHVJKPLy8ta+1LqplWhvXmTlsn8wx+5PjHVZ4NY0d4Z9kIi9o1PrXt89oEPM8QbY9YMvEwak1rpv7V4/Zj99rXKDIhuK4iobDTMHsAuX1q1sZutfjWam8VYA1pUMZdb7f9z5BVotZMVAuS6bMbcHj56VN4WCYAgGjImDW78kLPsJXHSjUf9IsKbbI/G4uhuoMM9tMVGiMuXw0jlMcE+vceiJPCd8XjiDl287nZco1FBWVsbB3Z+D/AwarQX2npMYPGIWRYUF7Fv5D1zzljMkuHqvg1oDey/bUeH/OKPnvIqlVT16gVuxnWiwJrQTt3q5QxPfp4tj5e3AqUxTCkd+hMzYHEXSftCoMPIdyPBZj2EhhuXeE3b88gr9lP/Vf5en5UGc+eOMmTRH2tAOYuLwtuX4xr6Pv+7B3M0SuBDxLmPv/0frXp/QrimVSlQqFeYUsfLtcSyIuKDftz7Gn8n/jsOirQ0912rR3rzAyrceYp7zGX2B2c1pnoz+8DI2tmJJ4pbQYRLvrT+OJKrfgVr3bdoASlUIAx/cgo+/rlpMRT4UXqxcasXUFuy7g1Hd89oMYf3T4cx0kZav2Gz1CFNf/PbOLyhIkf4DMDYDz0gwEesGC83AgDGxe+VbDKx4GTtdfrP7kiMDFiVh72CAp6m1xMQH8wKJ8kyla5URUjdKzLnY7RUmPrS46b9TaDfUajX7N32KPOYdxgTdxMKs+v6z10y4YjSFwXM/wvNua5O2UjvRYI1sJ25cjefUu+OY6nldfxNWroQtxX0Z/9pOHJw60PrNQqMc2f0jnokP0dldulUsLoffcqKYvuBZqbe4DcfE7h/epHfmD7haS5uSC2Skj/ofg6P+r3WvTehQtIo8Vrw1mgUR5/TbNsT4MvFfl+v3kLeFaPKusvKV6Sxwq3xIsDHNh3FL47BuT9XY27kOk3j/8fv3BJo+gZdrRbXtCUlQkgC9/eFqloyzPET0wi8xNTUFZREUxoBGN27RxArse4Bx8yW2uxc6M95b6pXY3+1zRs55ou6Dy3KlXgwAZODRAywcmu3aBMGQMbHl++cZa7EUS13is+WiB2P+kYSVtXXjr6+WmIg5fxa/TaNIKYDrBVBsF4x9p0hc+8+n36jmrawutG3nT/xO4q4XGOxxHs/bis2m5cHRrF50nfgB3fvcYc5yK7QTDdKIdkKr1bLt838SlvQBnav2ct80o2zMZwyb8WjzXa/Q7sSeOYBi7zh6V11u7HIkcx97V5of3QZjYuN7jzCmYhO2uku6mGOMeu42egyZ0LrXJnRI2opCVrw1ivmhZ7i1+uiGGB8m/PNy0+55DERTks2qF0dyn0fluvXr0/2ZtOxSm3o4cC/oMIk3wJ4t70H+twwJT0KpggPngrgSU8BTg7MxqzIS6rc4O+yH/0C/4TNBVQqFF0CtkHYaW0hPb02a54N4+nETIj3UaLSQMOssIeE9az9QJYf0U6CR1inGsTPY+9V+rCAYkgFjYt2nDzLV5UdMdfG3LiaA6MVxmJk34gatjpjY+Jg/072uA7Al1Z2obzLEvD2hmvTUFI6uXkQw2+nuV70gQHkF/J7ogVWPlxgR/UTthZZauJ2ot0a0EzeuXObke+OZdnsvd0k/xr+6Q/RyC7VKu5bI5duWG1tz3o8pD38lLTfWRmJCqyxnzb8nMs3yoH6li+OZ5jg/eZjA8D6tem1Cx6ZVlrByySjmhZzUJ9+bYrwY+4/4Vu1RVitKWb2oL/d5xum3rcvozJRlF9vecPh7QIdKvAHKy8s5fmQ7pqYW9B88ARMTE/Zv/gKLS88xMFChP65EDttT+jBq4WZcXZyg4DyodQURjEylBsTUsEum5Ofno37HCRcruFEIrkvKa58rp9VAxlmo0K1Xa+UCbuEGvRZBuCO13GAxseq9aczx36xviFZdjGD2q2cbVkm2jpg4su0X+p64HzNjKFPCpdGb6TMyusHXKNwbysvK+H3161je+IpRXYv1n8lb/kiwJM/pr4y6713s7B2q7zRgTBhEA9sJrVbL1s9eJPzK0mq93CdvmiEf+zlDpz/S3FcstHNFhfnsXdqD6eGVa7hvj7Gn35xvcXVzbfWYUKuUrF7Uj3mu5/QPlfan29J18Vm8/Lrc+cWCYABaVTkr3xrJvJDj+vZlc4wnY/4Rj7VNy8eFWqVk9VPduc/zsn7bmoxApn4UI5bQayUdLvGuS1lpKVu/mM8Ix624V6l+eynNiETb54n6v/9gVHQRVCXSDiMTqWiImYPBruHsn/vptUca0ng03ZxBX9ex7EBugrTuJICJJXhFts3iJULHpqmAggtNjgmtVsuK/45kQUjlut4r4gYx/5XD9e+ZriUmNBix+zEXJvrkA7DuZldmfXH5DicRBIlWq+XI7l/IPvYaowNS9LUIbolPN+JC+Qj6zPqEgMCwyh0GigmDaEA7cT0pjtPvj2e6V2XCVK6EzSX9mPjaTlHJVqg3pVLJ2iWDq/XqHUk0x2PEJ3QJDG61mFDI5WxcFM48ryv6bdvT3Bj09kUcncUqMELL0aoVrFoyijnBR/VVwzfHuDP6xYQWLWCmUqlY+1QE86sk3aszuzL9o/ONG3UoGMQ9k3jfEn/xOHFrZhIdllatt2PbRRf8J/9KRJArKAuljTIjsAsDc8MMvdvz09uMS3kJgO3pHkz+OqPmQSWZkHO58vd79gYzUfRAaCUalTS/tYkxodFoWPVGJPeFn9NvW3llEvP+ue3uyXcdMbHzh7eYeONlALJLoeD+UwSFRzbougQh8dJpzm1aRB/7owS4VW8O80pg/7UgvIcvof+ImdJn1UAx0ST1bCdu9XKHXVlarWL5iUwz5OM+Z5jo5RYaQavVsnbZPKLc1+hreFxKM6Ksy+v06T+0xWOiqCCffS+GMs0nU79tbXoAk5fGtIn5tcK9R6tWsurt0cwJOlS5ZFeMGyNeSMDWzv7OLzYApVLJ+qcjmOcZr9+2KrMbMz85L9W4ElrNPZd4g9Ro7F71Fh5pb9DTX6XfnlcCv2WMYuKCN7Cz1G2XycA2BCzcm/x7N/53PtPVqwBYX9CHmctOVj+gogQyzlQuX+MSAjYeTf69gtAkWjUUxkKFbqmiRsaEUqlk45uhzIlIAqQCPRtvLmD2ouV1v6iOmFDI5Zxc5MgQL2nUyJqiwcz58HCD35og3JKXm82BFc/jWbKagYHVi3Sq1PB7vAOaLosYM+clzEyNDRITjVLPdqKuXu4tpf2Z8OoO0cstNNn2nxfTX7VEv9xYeh5cMv8bYybNbbGYuJl+nfOvdWecT6F+24qsHsz+6KRIMIRWpdWoWP32WGYHHqhMvi+6MPy5xJpTmQyoQqFg46LuzPVM0G9bmRnK7E/PY2IiRs+2tnsy8b6lID+X3V/OZLzXQRyqPBQ9nWJKjttTjJsQVdkbZxsElk1bh3j9s32Y6XAagI3G85j+8srKnRoVpJ8GlW7+oK0XOAc36fcJgsFoNVB8GeRZldsaERPy8nJ2vRPEtPA0ABRK2FXyNFMXflLz4DvExMb3/8b0sq8BuFogw+qFFDy8RfFBoemUSiX7NnyIKu5DxnbNqVaYE+BksinXzaYzbP5SXC0LmxwTDVKPdkLq5X6B8KvL6OxQvZdbMf5Lhk57qPmuT7jnHNn1P7yuPKwfLVJUBr/nRDHjr89JBzRjTKQkxJC2tD+DPaV4UGlgTckw5r2/H6PbCzgIQivQatSsfnc8swL2YqIra7P9ojNDnk0wzPKqt1HI5Wx+JoI5nkn6bSsyQ5kjku42455OvG85f3wPaTvvY1JYrn6bWgNbLnoSMeE1AoO6ShutO0n/NdL2xzyZ7CUNhdrT6W3G/d+/KndmXYSyHOnPZrbg2UsariUIbYVWCyWJUJ5eua0RMVFcVMihpV308VYih0NGrzFxwevVD6wjJgoL8rn+sisRrlJ16rWaGcx+Y33j3pMg3MHpI9tJ2fsPhnlfwvW2qXk3cuBYTl9CRz9LWKBn5Y4mthN3dJd24lpiLGc/mMA0r1T9tjIlbCkdwMRXt4tebqFZxJ7Zj2LveP1yY0oVrI2vstxYM8RE7MkDVPw4jl5u0u8sU8JOoyhmvrFJ3DsJbYpWo2HNe5OY2Wm3PvneEevI4GeSDJp8y8vL2fZMOLO8ruq3rcgMY+6nZzE2EaM/2gqReOuo1Wq2/+9Fgks/JsRLo9+eUQCHsoYQtWAxllYWYOUD1l2kYVQN9Odj5gz0koYwnh1/gF4Dhks7Cq9Dvi5QjEzAqw+YiGqDQhtVmgyl1yp/bkRM5GZncv6rYEaFSBWZ80rgnMNHjJq+SDrgDjGx9pVoZptsBeBclgld3s5pkTlTwr3rekoCx9csItR0D2E+mmr7SuSwN9ED+673MWz0ZKmnrQntRJ3uEBMajYZtn71ARPJHBNzWy10x4SuGTH3QcNchCLWobbmx1ef8iH706ybfO93uxJ61OGyfR7CTFIv55XDU8S9Mfv5bce8ktFmr35vCDN/t+uVVd8Y6MPDviTg4uTT53OVlZex4NpSZXpX3Zr9mhjP/4+MYmYl1utsSkXjf5mbGDQ58O42ozmewqlL070iCGaqApxg+Jkqas2Qb0qAGpLy8nJzFVvjaQ04ZmPw7HwcHB5AXQOZ5QPfP4N4dLEWvhNDGld2AksrqsY2JifTUq1xbHsbALtI87YwCSPb/iUHDouuMibRrV1B/HISfvbRvk93TTHu2lmHqgtAMSktK+H3lS9hm/sCokNIa+/fFWVBsP5HRUY9g4xLQ4Jio0x3aiWuJsZx9fzzTvNP0h0u93AOZ9PqOZp1LKAhVFRbksW9Zz7qXG2tEO3G7/Ws+J/j4U3jrRqCkF0N856cZ+eDr4t5JaPPWfDCV6d5b9Mn3rlh7+j+VgKOLW6PPWVZayu5nQ5juXTnS6des7sx/by9G1k1P6gXDEol3HY7tW03pkUcZreuRA2k+6pZLvgycvgSfwJ5gF1rvIU1xMWfpur43RjI4nWlC5JdKUCkg4zSodYV8HDpJ/wlCeyDPhOJ4aQg6gLlLg2ICICUphrxNkfT2l4YLXsuRkef1Dr169JMOuC0m1jzbnzkOJwA4mGbFoM8LRAEdocVpNBoO7fieglP/YUyXVKxv62S7lGpEbGkk/aNfwy9iYtOGvtbRTmg0GrZ++hzdUz6p1st9PNOciglfMlT0cgutoEKhYP07Q5gfekq/7XCCGZ4jP5WWG2tEO3HL9q8WMzBlCU6W0s+JeTLy+71Kv8kPiHsnod1Yu3QWUz3X6+uH7I61o++T8Ti5NryYcklxEXuf78ZUb2kKoEYLq3J6Mf/N9cgcAwx52YKBiMT7DioqKtj69UIijX+mk2vlX1NylowzZeOJfuA/mDr3qtca2/vXfMHIuCcB2JXmzISvsyHzHCh0lTgtncAtwrBDEwWhuSlyoOhSZYVlMwdpDdcGrDt/+cJRNPuGEeotzdlOyDBCFbiU0MiR1WLi8rk/cVs1CCdLqXH5vcv7jPvrC4Z+R4LQIJfOHyF267MMcD6J722dC1mF8MeNznQa/QF9hk1v+Mm12lrbiZTEWM59MKFmL3fZICa9tl30cgutSlpubC7R7mux0C03FptqhDzwDSL7D2lUO7Hu7YeYVPo/rHTPWc/dNMZ0wgeE9R8l7p2EdmftsnlEu6/GXPd53nPJlsi/XcLZ3afe5yguKuTAC12J8r4JSLWpVuf3Zf5L3yJz7y5ioo0SiXc9XL96mRM/TSU6JKFahdvfL1lhF/kq/SY9B0Z37nXb/N4jTC3/HoANOWHMeGMTFOmGhRibS/P1jEXPndAOVeRD4UVp2TEAU1uw737XmKjq/LFd2J2epK+Me+G6MTYTj9I5tJ/+mPWPBzHTQ6rUuT3VmUnfZN99DXBBaCHZNzP4Y+Wz+FVsoG+Astq+ChX8Fu+MccjzjJ75Qv1HaeQlVWsnNB692fL5P+l57RM6VenlPpZhjmrSVwyJfsBA70YQmm77Ty8xQP02zrrlxtLyIM7iccZMnFPvdkKj0bB68RRmm+3ERNdJfiTdHO95X9ApsJu4dxLarXUfLyDKdYU++f7tkg29HovFxePuK7QU5udx+J8hTPbOBqSke03hAOY99yEy774iJtowUfqxHvw6hzDrjXiOWH/B0aTKMYVjQssIy/8Xq1/vTnZ68h3PocyuXMRea+tTeTOFDNzCRJAI7ZeZIzj0qLyBUhZDwVlQK+p9ih4RkWQ5LyZdtyxydz812VuHkXYtEYATv69nsouUdMtV4DzrC5F0C22Kq7snM59ZRY9nStipeI2dsQ4oVdI+MxOYHJbLBOOXOP2hDRs+vZ+83Ow7n7A0u1o7kVIgY+uTnZlW+LE+6S6tgFWFgwl9N1Mk3UKbM/n/lhDn+T3JWdJ3tbcT9ONLNi5fVq92QqlUsuqZ/sy3qEy699ywIfDBn+gU0EXcOwnt2qxFv7It937kullEY0NLOPdNKNnpV+/4uoK8XI7+M1ifdKs0sLZkKPMWvY3MPVzERBsnerwbqKy0lG1fLmCY/WY8HCq3X043IsHqKaY8vKzW9SO3PO5PtMd1AHZa/oWJcx6WdjgHS2uxCkJ7pyqFwguVN1LG5mDfA0zuUlFTWSatTaxVc/DAJsI0H+NiK/WObDtjgpdPJxS5VzFXaAg2g4uKzsz86sqdzykIrUyr1XJ876+k/fESIwNu4GRTfX9yloxTBQPpMe1jgsP6VHtdUW4mZrmxWJqboNFo2LL2V3pm/q9GL7d68jcMjrq/pd6SIDRK7On9KPaP19fykJYb68Pcx97B2Myq1nairLSU7c/3YLZn5Xf9pusujFr0PXZ2duLeSegwNnz2MBMdf8BSNy1jX5wV4Q+dxc0nuMaxeTlZnHwphPHe+QAo1bBRPoLZj7+KzKWriIl2QCTejZQQe4LY1TOIDkvDuEqevf2iE76TV9O935hqxx9caM1w7zIAjge9Sf9BQ8DaHVy7teRlC0LzUsuh4Dyoy6WfjUyl4YSmtrUfr1FDxhlQ6ipEW7uz+/cNdM56maSbMLFX9cOPXISi8C+YOPvx5nsPgmBIajnJZzZwaucHdLc/R1ev6k1uURnsTe6Ey4DXMZIZk3v+a1zU55GrTcmQd0Zx9SoPdc3TH19aAVvlQ5j82jaxjJ7QbqSmJJDwSx/9EpIAq875MfXRr7G0sa3WTuTnZnPk3+FM8c7SH7s6NYCpz3+JhYW5uHcSOpyNXz7GBLtv9Mn3/suWhP7fKdz9QvXH5NzM4Owr3RjrLdX8qFDDJsVo5jz+soiJdkQk3k2g1WrZvfJN3NP/Qy9/tX57fgnsyRjBhCfWY+/ghEql4sqzpgQ7SwVwiqLX4unjD569wci4Fd+BIDQDTQUUXABVifSzzBjsI6SCOrfLvgSlupsrU2t9THz0bG+eGXS21tNvzZhJ1N/XNc+1C0Jz0MVEUV4G+7Z8g1PZHoZ1rah2yKE4cLeH4Ns6LHYdg0hjcLWWerk1U75l0JS/tuDFC4JhFBbksX9ZD6aFVy57tD3GAZe+L5GbdhGZhSuWHgPRbHiQUd5Sgi5Vae7N3Gffw9jYuFo7IQgdyaavn2Cc9Zf6pYx/OWyGuV8UduYKilV2lBzbxIPdpA48hQq2qscza+G/REy0MyLxNoDCvCx2fTaZcb6ncKwynPBMiinnZA9ipUzBLm8PMi3k5MCQB38kYNBsMBWL2gsdlEYFhTGg1FVjlhmBXRiYO1ceU5QGeYm6/cbgFamPiZ0fDGKi/5+1nnpXvA/jF18Xc7yF9qVKTKjVag78tpnSK2sYG3wTC1PYdhqi+tR8mVYLG3aA0ln0cgvtn7Tc2GDmh55Gq4X1x6GrF0To6knFp8K58zDLH9Ra2KiaxJxHX5C+729rJwSho9n0zdOMs/qMk1fA1Q5CqxQ5v5QCWYkwwB12MJkZD78gYqIdEom3oWjVXDjwHTf2/4PJEUUAxKVCYRkMuG2axt6rXQieswPfgJrzNwShw9CqoTAWKnTDZLVKMLaRlrhQlkFBJpi5SUvKuIaBtav+pTs/HMxEv6O1nnZnvC8TFl8TibfQ/tQSE+cvXObk7o/o4XKVvl1qf9mKCxHc9+aFlrtOQWhGWq2WNUvnYJOzjqEhYHdbzlBeATt/A6MuU5k2e06d7YQgdEQrP3kc1+yvGNO95r69ZyBDOZy/PPGyiIl2SlQ1NxSZMd1HPMqEZw+zJWMGcWkykjJrJt0Aoztf4dxvy1r+GgWhJcmMwT4cLNxAo4SiBMg7DsXJkBMHFVlQliQVA7mt4VA5DqzztCqHQSLpFtqnWmKih7+a2fe/RLnKss6XObgFtOBFCkLzkslkzH1+LdkqvxpJN4ClGZQ6OTFt+tg7thOC0BE5enRlZHjt+0b0BBcfBxET7ZhIvA1JZoSxQzjRc5/Aud8ryFV1z7cwKTzVghcmCK1EZgS23aT/a5XSuNmcM6C4Ke03NgaLmgnHoKgX2ZzYq8b2P64F0G3Ui8191YLQfGqJCfuKyxSofWs9XKEEY4+RLXyRgtD8PFzs6tznaqu+azshCB2SqrRa0eaqjI2QaoaImGi3ROJtaDIZmNrh5hOCtXXdjYpWJoogCPcIXUxg4Q7leaAqB2UeqPLBsRMo82u8xNnVnUEPb2Nr4d/ZmRLJruTubM19CN/ozQSGRrb8exAEQ6olJkK79WDfZcdqh1WoYN21yYya9mQrXaggNB+Vee0PmwBUWN21nRCEjsin2wiuZpvXui85yxhvT3cRE+2YSWtfQIckMwILT1QWXYDae7bVjoNa9poEoTXpYgLzXJDrGgunrtJyY7Lan/+5unsR9cjHLXiRgtCCbouJQD83LH1eYeupI5gqb6A2ccHYYxSzn38aU1PT1r5aQTA4h27zybixF0/76hX+c4tlWNoHSj/cpZ0QhI4mvNdgVv0+iU7OGzGq8rHXaOB4qh/zJo8VMdGOieJqzaHsBpRc4dq1FBL3/JsxwZn6XVotbE7qzdBHd+Ds6t6KFykILUgXE4A0x1utBgfdjZVdqDTnVRDuJSImBIGdv/4Xm7QvGeyfjkwGx1IcybaaQNSEMcg0GhETwj2pvLycnT8swrFoGz7WGaSWuJBvFMqEiXOw8gyTDhIx0S6JxLs5aDVQeAEqCki9kcrZw2sxKYtHKzNH7TqaQdH/FEm3cG+pEhPVmLtKjYcolibca0RMCAIA+Xl5nNi3Aq1GTZ/e4bjY3TYVT8SEcI8qKS4iM/EAHo6m2FhXmdMtYqLdEol3c9FqQZENFTmATAoSM2cRJMK9S8SEIFQnYkIQqhMxIQjViZjoUETiLQiCIAiCIAiCIAjNSMzMFwRBEARBEARBEIRmJBJvQRAEQRAEQRAEQWhGIvEWBEEQBEEQBEEQhGYkEm9BEARBEARBEARBaEYi8RYEQRAEQRAEQRCEZiQSb0EQBEEQBEEQBEFoRiLxFgRBEARBEARBEIRmJBJvQRAEQRAEQRAEQWhGIvEWBEEQBEEQBEEQhGYkEm9BEARBEARBEARBaEYi8RYEQRAEQRAEQRCEZiQSb0EQBEEQBEEQBEFoRiLxFgRBEARBEARBEIRmJBJvQRAEQRAEQRAEQWhGIvEWBEEQBEEQBEEQhGb0/0xIb281OzXXAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "table = MoseqModel() & {'model_params_name': \"sb_testing_kappa4_mini\"}\n", + "# table.fetch_model()\n", + "table.analyze_pca()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model_key = MoseqModel().fetch1()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'skeleton': [['nose', 'spine1'],\n", + " ['spine1', 'forelimbL'],\n", + " ['spine1', 'forelimbR'],\n", + " ['spine1', 'spine3'],\n", + " ['spine3', 'spine5'],\n", + " ['spine5', 'tailBase']],\n", + " 'kappa': 1.0,\n", + " 'num_ar_iters': 50,\n", + " 'num_epochs': 50,\n", + " 'anterior_bodyparts': ['nose'],\n", + " 'posterior_bodparts': ['tailBase']}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MoseqModelParams.fetch(\"model_params\")[1]#[\"posterior_bodyparts\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

pose_group_name

\n", + " \n", + "
\n", + "

model_params_name

\n", + " \n", + "
\n", + "

project_dir

\n", + " \n", + "
\n", + "

epochs_trained

\n", + " \n", + "
\n", + "

model_name

\n", + " \n", + "
sb_test_groupsb_testing_kappa-4/home/sambray/Documents/moseq_test_proj550
sb_test_groupsb_testing_kappa0_mini/home/sambray/Documents/moseq_test_proj21002024_06_12-11_23_06
\n", + " \n", + "

Total: 2

\n", + " " + ], + "text/plain": [ + "*pose_group_na *model_params_ project_dir epochs_trained model_name \n", + "+------------+ +------------+ +------------+ +------------+ +------------+\n", + "sb_test_group sb_testing_kap /home/sambray/ 550 \n", + "sb_test_group sb_testing_kap /home/sambray/ 100 2024_06_12-11_\n", + " (Total: 2)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# key = MoseqModel().fetch(as_dict=True)[1]\n", + "# key[\"model_name\"] = \"2024_06_12-11_23_06\"\n", + "\n", + "# MoseqModel().update1(key)\n", + "MoseqModel()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run data through the trained model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the entry" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[08:57:59][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:57:59][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:57:59][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:57:59][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:57:59][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Applying model: 100%|█████████████████████| 3/3 [00:04<00:00, 1.34s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved results to /home/sambray/Documents/moseq_test_proj2/2024_06_12-1\n", + "1_40_09/results.h5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/hdmf/utils.py:668: UserWarning:\n", + "\n", + "Ignoring cached namespace 'hdmf-common' version 1.5.1 because version 1.8.0 is already loaded.\n", + "\n", + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/hdmf/utils.py:668: UserWarning:\n", + "\n", + "Ignoring cached namespace 'hdmf-experimental' version 0.2.0 because version 0.5.0 is already loaded.\n", + "\n", + "[08:58:07][INFO] Spyglass: Writing new NWB file SC100020230912_DYUAN3RMWT.nwb\n", + "INFO:spyglass:Writing new NWB file SC100020230912_DYUAN3RMWT.nwb\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

pose_merge_id

\n", + " \n", + "
\n", + "

pose_group_name

\n", + " \n", + "
\n", + "

model_params_name

\n", + " \n", + "
\n", + "

analysis_file_name

\n", + " name of the file\n", + "
\n", + "

moseq_object_id

\n", + " \n", + "
8206d0ad-d91b-0e46-649b-7be9c2e8b28csb_test_groupsb_testing_kappa4_miniSC100020230912_DYUAN3RMWT.nwb771d5bd7-a495-43b6-ae7f-e3e2d8aa08e2
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*pose_merge_id *pose_group_na *model_params_ analysis_file_ moseq_object_i\n", + "+------------+ +------------+ +------------+ +------------+ +------------+\n", + "8206d0ad-d91b- sb_test_group sb_testing_kap SC100020230912 771d5bd7-a495-\n", + " (Total: 1)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "from pathlib import Path\n", + "from spyglass.behavior.moseq import MoseqModel, MoseqModelParams, MoseqModelSelection\n", + "from spyglass.behavior.moseq import MoseqSyllableSelection, MoseqSyllable\n", + "from spyglass.behavior.core import PoseGroup, format_dataset_for_moseq\n", + "from spyglass.position.position_merge import PoseOutput\n", + "import keypoint_moseq as kpms\n", + "\n", + "model_key = MoseqModel().fetch(\"KEY\")[-1]\n", + "pose_key = PoseGroup().Pose().fetch(\"pose_merge_id\",as_dict=True)[0]\n", + "key = {**model_key, **pose_key, \"num_iters\": 3}\n", + "# MoseqSyllableSelection().insert1(key, skip_duplicates=True)\n", + "# MoseqSyllableSelection().update1(key)\n", + "# MoseqSyllableSelection()\n", + "\n", + "MoseqSyllable().populate(key)\n", + "MoseqSyllable()#.drop()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Extend model training" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-06-13 12:17:24.739011: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/cv2/../../lib64:\n", + "2024-06-13 12:17:24.739171: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/cv2/../../lib64:\n", + "2024-06-13 12:17:24.739182: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n", + "2024-06-13 12:17:32.027555: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 0 and 9; status: INTERNAL: failed to enable peer access from 0x7f85d06252b0 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.036055: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 1 and 9; status: INTERNAL: failed to enable peer access from 0x7f85c0627dd0 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.043434: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 2 and 9; status: INTERNAL: failed to enable peer access from 0x7f85ec625450 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.049566: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 3 and 9; status: INTERNAL: failed to enable peer access from 0x7f85cc625460 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.054423: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 4 and 9; status: INTERNAL: failed to enable peer access from 0x7f85e0625440 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.058130: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 5 and 9; status: INTERNAL: failed to enable peer access from 0x7f85c86254e0 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.060741: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 6 and 9; status: INTERNAL: failed to enable peer access from 0x7f85bc625390 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062035: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 7 and 9; status: INTERNAL: failed to enable peer access from 0x7f85b86393f0 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062132: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 8 and 9; status: INTERNAL: failed to enable peer access from 0x7f85d8625380 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062218: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 0; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85d06252b0: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062302: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 1; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85c0627dd0: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062398: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 2; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85ec625450: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062482: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 3; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85cc625460: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062593: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 4; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85e0625440: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062679: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 5; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85c86254e0: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062761: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 6; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85bc625390: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062841: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 7; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85b86393f0: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "2024-06-13 12:17:32.062923: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 8; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85d8625380: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/analysis.py:20: UserWarning:\n", + "\n", + "Using Panel interactively in VSCode notebooks requires the jupyter_bokeh package to be installed. You can install it with:\n", + "\n", + " pip install jupyter_bokeh\n", + "\n", + "or:\n", + " conda install jupyter_bokeh\n", + "\n", + "and try again.\n", + "\n" + ] + }, + { + "data": { + "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'plotly': 'https://cdn.plot.ly/plotly-2.31.1.min', 'tabulator': 'https://cdn.jsdelivr.net/npm/tabulator-tables@5.5.0/dist/js/tabulator.min', 'moment': 'https://cdn.jsdelivr.net/npm/luxon/build/global/luxon.min'}, 'shim': {}});\n require([\"plotly\"], function(Plotly) {\n\twindow.Plotly = Plotly\n\ton_load()\n })\n require([\"tabulator\"], function(Tabulator) {\n\twindow.Tabulator = Tabulator\n\ton_load()\n })\n require([\"moment\"], function(moment) {\n\twindow.moment = moment\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 3;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window.Plotly !== undefined) && (!(window.Plotly instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.4.4/dist/bundled/plotlyplot/plotly-2.31.1.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window.Tabulator !== undefined) && (!(window.Tabulator instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.4.4/dist/bundled/datatabulator/tabulator-tables@5.5.0/dist/js/tabulator.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window.moment !== undefined) && (!(window.moment instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.4.4/dist/bundled/datatabulator/luxon/build/global/luxon.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.holoviz.org/panel/1.4.4/dist/bundled/jquery/jquery.slim.min.js\", \"https://cdn.holoviz.org/panel/1.4.4/dist/bundled/plotlyplot/plotly-2.31.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.4/dist/bundled/datatabulator/tabulator-tables@5.5.0/dist/js/tabulator.min.js\", \"https://cdn.holoviz.org/panel/1.4.4/dist/bundled/datatabulator/luxon/build/global/luxon.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.4/dist/panel.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [\"https://cdn.holoviz.org/panel/1.4.4/dist/bundled/datatabulator/tabulator-tables@5.5.0/dist/css/tabulator_simple.min.css?v=1.4.4\"];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "bb4f667b-ccf5-46e9-a34b-45ca7e4eb79e" + } + }, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2024-06-13 12:17:37,066][INFO]: Connecting sambray@lmf-db.cin.ucsf.edu:3306\n", + "INFO:datajoint:Connecting sambray@lmf-db.cin.ucsf.edu:3306\n", + "[2024-06-13 12:17:37,102][INFO]: Connected sambray@lmf-db.cin.ucsf.edu:3306\n", + "INFO:datajoint:Connected sambray@lmf-db.cin.ucsf.edu:3306\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The directory `/home/sambray/Documents/moseq_test_proj2` already\n", + "exists. Use `overwrite=True` or pick a different name\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[12:17:39][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:40][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:40][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:41][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:41][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:42][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:43][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:43][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:44][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:44][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:45][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:45][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:46][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:46][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[12:17:47][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "Outputs will be saved to\n", + "/home/sambray/Documents/moseq_test_proj2/feeddb9ca2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|████████▍ | 25/101 [01:09<01:47, 1.41s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|████████████████▊ | 50/101 [01:47<01:11, 1.41s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 71%|████████████████████████▏ | 72/101 [02:21<00:56, 1.96s/it]\n", + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:41: UserWarning:\n", + "\n", + "\n", + "Early termination of fitting: NaNs encountered\n", + " - 2924 NaNs found in states/h\n", + " - 70210 NaNs found in states/s\n", + " - 20060 NaNs found in states/v\n", + " - 29240 NaNs found in states/x\n", + "\n", + "For additional information, see https://keypoint-moseq.readthedocs.io/en/latest/troubleshooting.html#nans-during-fitting\n", + "\n", + "Reindexing: 100%|█████████████| 3/3 [00:00<00:00, 5.61model snapshot/s]\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "from spyglass.behavior.moseq import MoseqModel, MoseqModelSelection, MoseqModelParams\n", + "\n", + "model_key = (MoseqModel() & {\"model_params_name\": \"sb_testing_kappa4_mini\"}).fetch1(\"KEY\")\n", + "\n", + "extension_params = MoseqModelParams().make_training_extension_params(model_key,100,skip_duplicates=True)\n", + "extension_params\n", + "model_key\n", + "new_model_key = {\"model_params_name\":extension_params[\"model_params_name\"],\n", + " \"pose_group_name\":model_key[\"pose_group_name\"]}\n", + "MoseqModelSelection().insert1(new_model_key,skip_duplicates=True)\n", + "MoseqModel().populate(new_model_key)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11:38:51][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:51][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:51][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "[11:38:53][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n", + "23864\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Applying model: 80%|███████████████▏ | 24/30 [00:34<00:08, 1.43s/it]\n", + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:41: UserWarning:\n", + "\n", + "\n", + "Early termination of fitting: NaNs encountered\n", + " - 2686 NaNs found in states/h\n", + " - 70210 NaNs found in states/s\n", + " - 20060 NaNs found in states/v\n", + " - 26860 NaNs found in states/x\n", + "\n", + "For additional information, see https://keypoint-moseq.readthedocs.io/en/latest/troubleshooting.html#nans-during-fitting\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved results to /home/sambray/Documents/moseq_test_proj2/2024_06_12-1\n", + "1_40_09/results.h5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/hdmf/utils.py:668: UserWarning:\n", + "\n", + "Ignoring cached namespace 'hdmf-common' version 1.5.1 because version 1.8.0 is already loaded.\n", + "\n", + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/hdmf/utils.py:668: UserWarning:\n", + "\n", + "Ignoring cached namespace 'hdmf-experimental' version 0.2.0 because version 0.5.0 is already loaded.\n", + "\n", + "[11:39:35][INFO] Spyglass: Writing new NWB file SC100020230912_WUAQVSMOGM.nwb\n", + "INFO:spyglass:Writing new NWB file SC100020230912_WUAQVSMOGM.nwb\n" + ] + } + ], + "source": [ + "from spyglass.behavior.moseq import MoseqSyllableSelection, MoseqSyllable\n", + "MoseqModel() & new_model_key\n", + "selection_key = {\"pose_merge_id\":\"8206d0ad-d91b-0e46-649b-7be9c2e8b28c\",\n", + " \"num_iters\":30,\n", + " **new_model_key}\n", + "MoseqSyllableSelection().insert1(selection_key,skip_duplicates=True)\n", + "MoseqSyllable().populate(selection_key)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

pose_group_name

\n", + " \n", + "
\n", + "

model_params_name

\n", + " \n", + "
\n", + "

project_dir

\n", + " \n", + "
\n", + "

epochs_trained

\n", + " \n", + "
\n", + "

model_name

\n", + " \n", + "
sb_test_groupsb_test_groupsb_testing_kappa4_mini_extension001/home/sambray/Documents/moseq_test_proj2200feeddb9ca2
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*pose_group_na *model_params_ project_dir epochs_trained model_name \n", + "+------------+ +------------+ +------------+ +------------+ +------------+\n", + "sb_test_group sb_test_groups /home/sambray/ 200 feeddb9ca2 \n", + " (Total: 1)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# (MoseqSyllableSelection & selection_key).delete(selection_key)\n", + "(MoseqModel() & new_model_key)#.delete(new_model_key)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[12:06:55][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`'}. Please submit a bug report with the snippet used.\n", + "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`'}. Please submit a bug report with the snippet used.\n" + ] + } + ], + "source": [ + "results = (MoseqSyllable & selection_key).fetch1_dataframe()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
syllablecentroid xcentroid yheadinglatent_state 0latent_state 1latent_state 2latent_state 3latent_state 4latent_state 5latent_state 6latent_state 7latent_state 8latent_state 9
time
1.694621e+0918050.84433697.37710.37610.3156-5.63792.36120.82332.49660.55984.4412-1.9404-3.85965.5380
1.694621e+0918052.63293697.3823-0.20970.06322.0453-2.620910.91644.15681.4786-5.30214.5947-0.88400.6200
1.694621e+0918054.46423697.6510-0.2156-0.7071-0.99330.67415.01103.8812-0.4811-2.2053-0.07533.25832.5587
1.694621e+0918055.35213698.3835-0.2828-0.6419-1.26131.01313.82454.0471-0.4889-1.6345-1.49504.37114.1248
1.694621e+0908056.80493697.1540-0.3571-0.6830-1.39180.92213.67343.8062-0.3035-1.6206-1.73404.36434.2387
.............................................
1.694622e+0917585.08874034.50342.72630.4718-0.90380.11010.9661-1.80750.7622-1.1263-0.4601-2.2455-5.3826
1.694622e+0947596.18104036.92172.79240.5502-0.82070.16041.1446-1.78950.8248-0.7973-0.8894-0.8934-3.6218
1.694622e+0917608.07224039.94652.71960.5995-0.66410.10431.1654-1.92160.8223-0.4043-0.8952-0.1921-2.8618
1.694622e+0907620.30544043.77152.83280.6144-0.56550.04340.9149-2.26970.9295-0.3872-0.90240.1956-3.3429
1.694622e+0967631.99604046.2695-2.11170.5553-0.35920.12730.2913-3.18370.7172-0.6188-0.68610.3468-0.6757
\n", + "

23864 rows × 14 columns

\n", + "
" + ], + "text/plain": [ + " syllable centroid x centroid y heading latent_state 0 \\\n", + "time \n", + "1.694621e+09 1 8050.8443 3697.3771 0.3761 0.3156 \n", + "1.694621e+09 1 8052.6329 3697.3823 -0.2097 0.0632 \n", + "1.694621e+09 1 8054.4642 3697.6510 -0.2156 -0.7071 \n", + "1.694621e+09 1 8055.3521 3698.3835 -0.2828 -0.6419 \n", + "1.694621e+09 0 8056.8049 3697.1540 -0.3571 -0.6830 \n", + "... ... ... ... ... ... \n", + "1.694622e+09 1 7585.0887 4034.5034 2.7263 0.4718 \n", + "1.694622e+09 4 7596.1810 4036.9217 2.7924 0.5502 \n", + "1.694622e+09 1 7608.0722 4039.9465 2.7196 0.5995 \n", + "1.694622e+09 0 7620.3054 4043.7715 2.8328 0.6144 \n", + "1.694622e+09 6 7631.9960 4046.2695 -2.1117 0.5553 \n", + "\n", + " latent_state 1 latent_state 2 latent_state 3 latent_state 4 \\\n", + "time \n", + "1.694621e+09 -5.6379 2.3612 0.8233 2.4966 \n", + "1.694621e+09 2.0453 -2.6209 10.9164 4.1568 \n", + "1.694621e+09 -0.9933 0.6741 5.0110 3.8812 \n", + "1.694621e+09 -1.2613 1.0131 3.8245 4.0471 \n", + "1.694621e+09 -1.3918 0.9221 3.6734 3.8062 \n", + "... ... ... ... ... \n", + "1.694622e+09 -0.9038 0.1101 0.9661 -1.8075 \n", + "1.694622e+09 -0.8207 0.1604 1.1446 -1.7895 \n", + "1.694622e+09 -0.6641 0.1043 1.1654 -1.9216 \n", + "1.694622e+09 -0.5655 0.0434 0.9149 -2.2697 \n", + "1.694622e+09 -0.3592 0.1273 0.2913 -3.1837 \n", + "\n", + " latent_state 5 latent_state 6 latent_state 7 latent_state 8 \\\n", + "time \n", + "1.694621e+09 0.5598 4.4412 -1.9404 -3.8596 \n", + "1.694621e+09 1.4786 -5.3021 4.5947 -0.8840 \n", + "1.694621e+09 -0.4811 -2.2053 -0.0753 3.2583 \n", + "1.694621e+09 -0.4889 -1.6345 -1.4950 4.3711 \n", + "1.694621e+09 -0.3035 -1.6206 -1.7340 4.3643 \n", + "... ... ... ... ... \n", + "1.694622e+09 0.7622 -1.1263 -0.4601 -2.2455 \n", + "1.694622e+09 0.8248 -0.7973 -0.8894 -0.8934 \n", + "1.694622e+09 0.8223 -0.4043 -0.8952 -0.1921 \n", + "1.694622e+09 0.9295 -0.3872 -0.9024 0.1956 \n", + "1.694622e+09 0.7172 -0.6188 -0.6861 0.3468 \n", + "\n", + " latent_state 9 \n", + "time \n", + "1.694621e+09 5.5380 \n", + "1.694621e+09 0.6200 \n", + "1.694621e+09 2.5587 \n", + "1.694621e+09 4.1248 \n", + "1.694621e+09 4.2387 \n", + "... ... \n", + "1.694622e+09 -5.3826 \n", + "1.694622e+09 -3.6218 \n", + "1.694622e+09 -2.8618 \n", + "1.694622e+09 -3.3429 \n", + "1.694622e+09 -0.6757 \n", + "\n", + "[23864 rows x 14 columns]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'439ee83193'" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import hashlib\n", + "key_string = \"_\".join(model_key.values())\n", + "hashlib.sha1(key_string.encode(\"utf-8\")).hexdigest()[:10]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "spyglass-moseq-1", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From c2b4d4f3056f7b4f0c40d9048bd65d5875c69592 Mon Sep 17 00:00:00 2001 From: Samuel Bray Date: Fri, 14 Jun 2024 15:17:56 -0700 Subject: [PATCH 07/42] add moseq pipeline diagram --- notebook-images/moseq_outline.png | Bin 0 -> 106224 bytes notebooks/60_MoSeq.ipynb | 6 +++++- 2 files changed, 5 insertions(+), 1 deletion(-) create mode 100644 notebook-images/moseq_outline.png diff --git a/notebook-images/moseq_outline.png b/notebook-images/moseq_outline.png new file mode 100644 index 0000000000000000000000000000000000000000..c187c267fc45e71cb0a851b4a798e88422af91c0 GIT binary patch literal 106224 zcmeFZcT`hb*DfAkJvLN4HWX>c28w`)fYgWukSZOiDoSrsLQfDC4$?#fL=t)LJJTQ?h4KG-aE!OzVF`qyMO$~w}(g1&R%=1x#pVlna`YSC4u+U z6b|lZ-w%O64&GI~tqFk~!b2c`#P9tV_(Y~v|jJi3N4;(RzD=cp}AVHUzNXg(mK-9W)Cc>_hbfISgc|}HMX>u9qsew zM?|?tl*O{tVz;cJ(J}o`mTrGuQ*=9ha$z?P^{>=>)_*y5xpC^~gyVnN@kAL6soNBB4eRt#P ze-F5=jsI5Zwkjb1Z8ZPwhnv>$AG(EnDgF<~o^J-uIUEb<{g7W(wilyYmK0LAENS54 z1<0 z$?e|&xqKVt)pSnYA(zqS42#HbYhLM@EcXNn8Ij!XKp?MA{-afA0W}L>>chL&Z`N}Z z>6R@Zh?+;Afj|_4w~_wJy%W*8S@`1RDh&N8hNZh}4>$Z6ri@0oiMg}`;`=?BwjF71 zTm?o@3WnjK_i!ZEm`; zBRR;FU?vRYyZlf2l7rY7bhlK553PAgpVC&%LKoZvfxJ1l9i$w4l+3DuemcmPzz`m{ z=z`lCgg{On{`a8N_WS98K4VB|ExnfJP`*r@n{y^MV7zD+MfUh^dMB8n3l(>BDkCG? zq-1thnRD*4AgYh;|&ap_Vdm|*h2l(@Z#7ul0Gy9d99 zBMH+wPsq1|j^^viUsfkaUU_9O6_2ndff?k9Xc?c7xmT7>E~6+!3z}H^2xjZaE{!AZ z8<|+4+~IJ0n5Q*n6sXd^zap==Z1zi;iAi?;ZYUJW23_Qe?Bd5%_*gu(N-nFwNseIm zwKS{Han&rzIYS@JS&}BO#4s|>(6TA2Wz^gvCDf>wWW^R8)i4!_Z35G5X=&m7pa}8( z%CoIO=_JsuXWu~7l~)V~F`>V_=*#$$?$xE|2u3vQkf=QvDYB`25x3A~N_!3~6;JE& z<0*y@j|t&1-TTkGWqQ$Tnv~gu${0P|F0Ary!dyXZvPRjvCzW8^#loL z$b2g@+O!l{^df!3;9NP3y=FdG8yXpuECx-X6K<})F!dgsjnu2anytD~OI~VpWD!?a z`#K$rByJXZwbcH(3hU~^p>a=dLm(}Cw;719(CP#))Q)-+M+7bcU7AVS$-6IUf{bHy zPi5suuN?`lOasFtD+BS%VuA)TQiie3NkYE{DDYNfQfQS-a)F z6z9(-C9Jx*sZsY9xL%9GwJ>dBYO!`tN+r6s$q-CN-)Mzk=m4ix-eDEBJG=|L41D5S zc*0&trIyk*YjQ6wa83?t;HNy8B9&QD8O5O8^pTo_egmtkMp8&`IGnV+T+&TQTWmuW zRuI3E%e+w6bfuxtt~uFKkMaJ5qP#E5Mp@T`qLiOPdTN<5R z>GxuxRJ3w?FSSlL&V%k?*CY}eWT4QZ@d03ZrWJ@hFQGvS!LoINmk4S0ln&$q03B4Txn{w zl5*^rIHEdF*QpWo}3jhWTVI1iIn>^JuA@fM^4 z!yxI?tJwq*GlL4uC2{qbT12wS#wn+Vi$N+Q96sa!*n*jPybylv%z)QICqH757tuHA z?*)fvoo!qh$J5&ZFy)(8ECK_b%BIWFa?4BzxZn~6)Lr0mj8!zE=T9fQ(MT!wBX0TJ zvVOYSRIsK@KniU#@mNk?asn%op*{nk8%{6Cpjgh5zRDe5mBgBqnpL}xxx>t@scl4w zVbtGMe5FkH2>{OfGu##D{0&TE#YWF7>`-lLzsUQ(w*A&cLfM$L46gA#kdu(@g@edt z(8x@e1iCTycm3qxhIXOcl+N;`w!gex-!Sf!jmQ(B^-HE*z-4X)an z?EDpso=*DiTGo*WFE4IIX-sU(XvJJjQ7Oj)!0e%JJk#Y#?-!$U;BBar6nNera*jYn zwDZkq721NHNe__f2!anx@C@r8kb$({cyxG|+-uMmL#fEpDXbYP-o+?0JxTpy0(>}{ z$M*0pAqGQlI2zqvs-T~vEL)t^J;OwcC+Pr#T!b>qfEh?IR`_YKR9tphD6Ewj+DzPs zuC1RdF{<4`vI1x(V`r85OXdfcG~-_A+P@nzM9%RZSCLzCn?7x>YIcRfdw`2|iDU&^ z$(eRKc89n0k$0Hf;kbl^UWdnDG74uslg%o#xyk&iUVH4s_WF4Xx)Fx-dZIazfnir3 z3YiTdzj&SE#utNFIy3z{%i8P5<6dF&z0i$Pfk8(UE3}tCb^5~3y*l%23TB#ap zTZ=3pD%lDNqP};@e0e$>-(E9}QF!+yT9~5ttGrBrvOmHTq@?lQ1UTE49nRdoeq~4B zU%?;MNdnSF*&t%w)|mfNCiu+r8bz&zGb9TA4jF@Ucr&|_1aToB<>KS=4gEOrh4>mo ziwWFgcF2P(ztcj1-XqQ>Tne~SpYg6DXoV}SIS@NH{dcXma&itAqO+BF9VaM>lPaO^ zL$jC>#(DNKNW_HmR|O!I1L520| z6p666hnZiBZa^j^*z}iqISeX5m#q@4N9si5@3C1xe0k%x8A;_=5F3YDN4jIuGVsN1 zYUi9el5-w;l((%I31(B5G8WYh%u`cCB?dpN4$$yYfmS;pyDRTuShh6fzTb#eZPq$c zgj+4NbkZDBeaTb-MUV3=z@GS{f`Zu`*`-1N603!za$6yg{JYz{g(DHzm&LKuk+DdNg2SrE7uM*$TIMD(_fFLf1>Ij%DeDWh-lp){m2 z@9wt#PO8Wh4iN9SzpH#IEvhU8@MP#28E_CmL6pl{9f%XsaF5Z*>}nw)<1#?R3WX5M zj3$!$mEeyc9?Vrrf{%YPys0=p->ZHbAJW66lxJ}IOH*UbKI;pofHE?Pr; zEnaUg+?DG?7dx4#eNQF~J@G@v6qDm7gablX%#jLi>w05>XQ7X<@BzDLM)Q7vJWqcB zUIXI6G}qz~OSFYWisXepP7VyPj{wBnF!m;=x`(qArHe<3L)lAKKX)5vF`zF(cKN1+Jt1i*_a;7zas!0IFqm7Gs# zV8$F*mqL3ldaT~CYPjK!QDCccEls1dC49j{4dozSXIWV3K-NFL%+-w1>wEs_Nwqb4VZo zp=Jge51(>Q^MgqfDXXH2UzmH^$a=I%!Iy7hdRIm8qM zF=t&SH%r>V3_$KTB=-6N^3dN+VKXgW1+l~p+9bmi+*^>=jE06`%#9~)1w27;H@UzJ zDgPkeJi5yQ6G08hiw$MLjppzV;s_f>j!CY;IP=*bHdDEEs#_@sr`8o@c@$F7C(k zxyz=&y1+G0H-tSz-b)2u3}W3SWWD(uLFGaOx2(w9NuNN}Y){Xm6U~YAE%~w18VY;D zV8Km0zG1ZGz`=uT^8T8)2)2UACNksU;a$Cku_!4@LaJt(ida{V>xJl+k$?yRTG~&_ zwC7uHL6vwf(z!`Ot6H9hiE&S+c3X^!)sQVbzoYh1JfE8Rm!>GExNO5r0T(;UmqUT2eOFQpB{BO_L6qc(x)>E;bbnxRXbfl zl}~E@h1(BDPibEg6@wR&4O7@63p$&W0JHK$6_(~-NAtg9G&=oGRn@N&9>*I4lBrS5 zn32Q$3*CtdDd-&aM8Q6rKAC%YHv5<5HLPxQ7q{$nDVbP-U@i}?&?J+C8NI!Rrz6u! z#?c2d-g4Inf&1skuSANzp9T5xma9YJ1>5QlBtEi|Mm7T`Q72P>8T;|dUOytL$w1Wl z8at7Os6OH*BUBqIWOy8<+C1$NE7 zxZaVotK~P(f=Gvaia2${EJ6hBQ23_!W!vq;yTGKCmLC?EcQOi1G6di&b%b3oxA!5P zG!{y+z zYqJEmU=q5{xn;qIfE-gJpXv*&BaF5{ZG4&m>U<@-`g}Iq7oWUcAb_~D-{qaVTz^8I zmnEsdk@j_VoN^&EBPc-?87tL#s2-hEm!@s)?Q{uhFgcqcax2aD;We+|V`KLuMLb9) z3!TZZsxkSb9OL_BMUlCYA1CBnWY!`bozEicIL2F9xwa!FWagYyA}jxaFDh_%bJBA7 zqa2^qR?AF59JKWgzYXBDPJ+=1$TcUbrIX*QqY+@zJ|&EquY}Bo)&t2RFWX)~NcP)= z0x}SI9@!{DY`kaf4T3%O^L?js-QG*t$e&I?nXsuLp1n>bt0N^PK;EMU_C?^IpU}$WQP)pWK8 zVW;{syS_DrSc_)r*=QWwEeE`*y<0^rwk0eWrqXHbYLmqNQsX3cs=yN!#Vxo??uyaL zxFyVNU<&bR8~f)`Sa}c15mM2wFl)0@CgV%L>LKiDxpgt>(0p{ zawj{#l$9Q_cW~_s`*`Kmx2D7+nSyM}!%4}3JI#=rM)(+Zco!AVUI-gOl zV-f^KE}a9teJM41e_cvaxRXW-B`irPDM`*v%uE#+i0y^F4{4e;@F2=5*nxK7-* zb^i!WU9C>bk~w+tgmQ$4F|2j}m@bwZ#&M^CEn6x1jS?yj8E?m%s&0Bl$XP5Ff8Y|Q zIMrLkuszD_`i-rb`91^XCb`4AEc`WJwmwQ;{o-13KP^~2LD`XEUXCSQJiSW};HqB) zckMlEOKMXnE}xe6mfPM=yL69wRmkjQ+asz6?0pmcNSstt>v++BuoC-iGxX3RUOq zocel~%vk7~&YXI+yc|!&UyKx2zHAvwu~+~Va)&ptr9XyT*rb$ff^wDUtnaa=3B?Gq zht$lDC#W_zE}joh7-;Cz4f^IH<~0!OF|dQVWwm}CI7fKAbW8Cde+f- zIHzFtd45%ADct;g5u4n=G7`dG=asoFqr~%D5Y3`%`!vBqL6p z5*YJWFqrF@Dgbzu)XEopf_mB24O^(s-onaeaKA;qy!3ur{_qElV^Mn1Z<^kcVfma* z-c}V0A5Ofae6po6lJ?~x!-ntGXDAbgtz`;4%L~g3PLb`5E3wPDP^$s`KFPpjt`5kw0Yh&kV5HJHPt7XS7j&%i4bfrK>I43_t(Aw)BaFa z+5x9(rfFZGRpVtOXX{hv47TSlt??;hkcCsCAK;;1MAuZUT#T#D`G9K-QtSEs%b54S@}iAfx_f7{+| z^d%ZBfs{?GQgTXjQ+4!@T~z=9$|5M{$!~zgT0X}m5kC*VW-UWpBPQCxi?0aF^un#p zB9Qdw4K}Q81SS6WMwdg_crWy#e>ppT(C?WGX*waVmBxgW)gP9%zU!>uY&E5`x}}F0 z!+jYcE43E6^iD?nO-If-+Eu97oP6?vd5UHlr7mrWzo^~THmVC)Q;(Y%e`NTOdu|K+ z*7^_Jy?{JmI`KCvh<{&iJVY7TA=Ics?*SwYc{Bka9`1El$vf+FT8~fllSm9RRv3%1 z1ADC>DH)gauQnVHRd1P==!8EUGAQmBbalHX!I%q_&ohR35WhYnjG*+t6$jn4dPHp+ zo}Tzr@UiY}^$VK@0#!;}VhvjOc(u3!P92doOOND52zhd%J{H7szHiXYE<*-N1WG=0j-MioNC zLK29xb2qI%_KOvpWat!$<-Tkc6sa{!GM;W8=5kg@<%v{^ge8XAnl10ZR5xgoT$-fY++;Ls#R+K59rnJZaD zoSzkaz#eN;u4f3adQo@ESu&zqh`m>r!|Pa{{o2eYPHTl!GndSc^UtLu7xlHq+rD=T zY8{v7Ug(q^3m;>7xi}60dRV11DFPk?hT-IQ4ZB~9uX~`E&$%Vi1K+#6RX4gXWdkKx z55lIPgYq6`c26j{THs=o7cPR)WXs&s_V(X}=Fax_uolIgQmPiojEz)U?G44|P1*35 zlRuWy`RXN(7(Rl=^d-ej)Qy^k6- zFv>bD+6x@)du#{x8`1qmkv_Wv0)0QNBcq^g#6_XTO`Y=MslEG1C50j}Rj_k5+nG&} z^ZFn>v<%2p9_w%k8Da`UeCLd{?wFFPIMUxGGebBxbk1b#P=A=@FIV3M0|7Mt-j+M{itZcQCL#SkWLD-XL|5b1FK zoWoY)U4eXepr{Bq;nDgpYRoJnMJCrp3@SohHTOW3EhY|UC@l|S_?(o7qP97acOAdwr14c`UE7HzXj$Bt&Al11lcICV#C!{xt?G(`wgaG?a|`5M#T5OTYfvLa7{ln{wY?{Lqa$al>Ub|B4(5Ex)$4>HQIqWa!+kn&*`4JC@W^?;ktZIS0Z=tnok&JKP;3AlTBj8uk!=mywbe-{ z0s98LSL$Qk(TMhbbS0OTWGr_=+$%gFcY*@mnk+@?_N}-ORh1ecZb3I?wSd#3?s~(I zti1V<5*767bIR#zQWINx2~ zNlWlQJxVXF0eLLQfIwQdP%Bk-fj@#Qh=(ouGt3lWTFv5Wb!}CmKn4}s zFXV2_QUvmAOVdMa@{+sXJ`yH@Y;K9bYdBg!@=2NMocVd^o2SlpR2*pM7~V;~lnX zG2&oRA)watWbcb!_quv<3H^#W?*PygBt-$Y@p@dYYgk5&{RVn%z7`u|p6BtARb1{C zp;0mCS2I;XqZlk!l38-!jN;Gz?X|cFBSG#vd-5w}1I_Nv{6kf4%mM`%m}`A{l)S3y zoT{-u4et(_1dF=C@Qq({F zMxnSJ+x6Ab>XA*-5xmCg=Y%L1kg+D$#dsEAn;A?7*z^2BSI&sjGDuHYPmtZ9i$^7+ zKAAA_#r-P1+LY0GSBUbQj39rCzW&m9*Yn))ufOhG;X8dQc>PA}pEny%C~p0@gEfMF za@{{3OrJUVHe}w1t)&UsV3F6}9wDN|{9|TT9g(#MlE?xqU*l}`BY5#^{@}$7b!*Ak z1Zk=ffN@hpqKr^%15)0_$=2xt)JWgZ7}sx6iaI_m`1Zo$>DOu&AP*>m&f6~!e)~Q@ z{gcrj3e2s0c@Xe*>C&F+pLb=OZo{s<1)B}Ah9#Jv4Y2sf0MYi;gz{cUbyHZg8H9n% zLU?v0^nCc1D-P_V628%S_Sz%7i(F$G%*V%@jmu_6mrI=A)I%x>5ujf7*oj%x&{#Xu zrJo^B2{x0AxSI+xx5v5NASl<3x&@r2osZy-2Xn|X$?!MqH^YgcoOxpw{_9{m_I6=na;#EjLvl%F)B|~zij*N`1Ep5k0mh!`OuDNS$yRU_bK8N zDIhwa*VTb_i`vAq)~b<8skz;&7p1YEU~ikpEXFZq#`p2Kp3E+r1p^fQt$IG=JMxrL z!I8z@*huS>g)4kTCU1aAOGn4mnfKNfwD(CNyq#*DR<~zPIHHpQc7A&I^Q)_?R?N1M zO~J&C1bfM)pr-%Q(i( zICM;fSo@F>d;SDw&jI#3`d4O>41v*lE!6YRIghUxAA(%@vAJ)u;$UF`UU|{Ea#36n z5T}8dSztC`UjPpkcO&8Ht=yp@$7#$r-Zf88PtT)wtLf<52u3Br^>#qK-U*D(#(ZG@ zFT}CueG~GFL6G%9gaO#Ex)CN@?v_pWaCJo)WC#cfKrd%^O%~vImutYDZTW2dKJ7ga z>8Vc<2@*hd=^Umsz7|c*&CR;{LDma!HjoNe`sy1PRIGK=TcV?(=rs?a;ndU%_$4fN zvx;iG%R@+|$Q{Y$7_d84c~qIXx#XT=t5ER8fXbT><{kF}Y)MtjQ51?8n1IoRoqG^- zlj0^G1giRnOOSz6e<4>J!EPV3C3F?LA!(ur1%OR6@BIW@Vsiw6l{` zWm4=-2yvhf65j5D94G^fe?8W^`-9PlpRvrtI}mqWX>sUU-|FhKQ=`d|JBJz|kn)I) z9Ps)L%1EBknd#KMl^$@WR(HwCuGEV9?p=Kvt0s@nJEL8oxNVhg8WANO&hQK`{SfKBWx{i zcx;W{K*iH**D{0_Ku47iLF>~Y=IgEPw_3Z?xEaFfx^8%czF-0z9MXa~?qV(o(Gu7_ z9^^ji!W$=Xe0TL#%*FO{cGHgxP}#K3SpKKS{hXn;4(}( zRAPHO!Qp47_ee)>x?|`QpYqwDDRCG+AwJHVU?UX2(bgNtZ1@m`*8u{b-xS!)!y((! z=>oE3We@&3{SoMr=b{D*XL*gr9DaUtGy8h!!a_a3fF7SUDx;GerIg&B&CKtQo>RIIa&kOocPmW41W7mUS0$+-}z*wdK8TcaF$|j>*~3-CEv$hH+UXx zOi##Ea^WUuG_dQAC^2G(@2$;a2iITmrQ;Y&_O(slX1>%gPih}H2{bTpZ%bv5T59T| z*E*}UgqWFc6`=$;$w!83Rp}OH$XZ4yB;O9Xj$F_X+-4IXSjomoMV_*|)s#wH? zoj+2^=OXYqh?=%4*q2GP*fgVn!U~i7*|siyWsWAp%>A0(T1l;a-Q5JY!`#__((9*>^$PI^0K@ZuvNlHXCH#VwJlTU)j*Z%;$-w4}&>QN$s zlr~|XQeKx(62K`u8ekLWRs(@dT`5u=l5ZjT2=i^ukQ5wvUw!Mbof~;1{F|aFINAvD zZEyW4bqX>Ovf<{HAMT(%dDYd_<~LuJl41_M^(yEMyz)OCt=~G(>6@x@OowSGU_S9{ zgzUBPP$}jq&K1plkQr^}DB$AR(bCjHMQ>!P6VOcqt*RT%W!eSviodt1%JsV&SGUeH z`hvQa#!YxCQu4vglQvS5;vb4ODoj;xhuTK68@^?+$aIG2#6iZ?J z&`26GQ=T8uEZiSGG|&SFn)kZNq(#dxz(Lmv#S33%K3s zJ@<;`nX^Qa5yt7xxybclDic5c^Ca~Dt;PP2W?cK@GYb#C`J}|hp`Db^87D6vDi@!8 z?3_7F&j}329k~^cN9_I}BERAV;`zpP@7Je@0OX%{zD{W5nj+e;p1Gs$&b2g);8z~X z2Rz_w8$J%&?nSO{mjeFpS?+%{ng35*<$rs?vq`_<;A9yWVkiyfMk-rKQ3R;G-w)vR z_I2aG>bcA}_qQO6aBsOdBs^Ekv0AMsHV!~M5BNXs7~*M%6Sr>)<}M>=BfCfCA?Hy6YBS*Za27hOHs`pi+LDQFO;*4 z{(+W9KH!qt`>06EDoz&zU$#x>Jj~To$bC zh=nSe;NVYsdbjxHl2yMqcawS_d88d;b~9^nyJKB`$h|8j{r7u&6%PHu+vB?UBvB&e zYjz>5w;ylf+`!6!Pu2Nv7Qjpe_PVsd(tK)%wh2inzf6HmSlVvKBzVql-ev5FX?>y?n=wD*`+Zy^>XLt zZ`}Af)Kr#9xXfGy!T?eBSu|ae*&C0`CL+3+X{JjbHSl>lMfPG0R1}V>r2cX?*M36c zmVsaXKC9@g^2bAO#~OjWF_ei;L<}ft-zc^+V^lX3)dqt62M{ z-u4_wD{R&A>x=c-D&gawTkUfG=;UrO!eZ^GJl=CKN8K&48P+6Q9n;T?FdRqU<{eFI z9Bt?=Tzvcz#e3S?rs#?8N$$AteI!%lq=N5i`PB%4c zrLpRYj(i%)A^UFFrkkOSVU`?PuNTtWGm`Nw`TIt7xcSJ7ypymd2Dd3+579ky;dZSA zt>-;n+F-5bnT%@f`*sJ>rMV!~`zw^`+tx0ImupX`le)`DfeLHaDrnCdGrUHBeFcIM z!b(>B39C1RFV62JbQJs(@Q>kn-@(vKs%Sd^9z|@O|$CeHw9V}f={e+JZk{(0$uD2 zliUpx3G${ZyBWQSi$MoxMWv(qqe{w1lgIU%R=zI{1dl}^zw4lNe%8Ll5^47(=i+ek z%D1E|q_3NFte|UrgzV`)X#B7I#voMs`|_1s8AjROtx(o4Fm zB(Z%uYB{|(EP8zK9uus}(VcNV8lh!o>QM%3^IDiR&xL3F4t+XnY9!9*A6!-Bgz)O% zun}cxcgMS5go#D}0-7RPA>h6_FUq zRxpNJsUSH?n^dm*#^3rAYtH^?KRZ;T!J+t!PJB4b1Rz#24Aii?YH`6 z4>U^In8*p7&FP#fVgZY7bXR-IyIg(iYaj>GWsQJbYZp9oKhLSN1%SpM;r71l#4-BP3aW?YJYFNI!l`ISF-!_{Lv zrwgb}<;c_JwkOCM!_#U7!Q8DL(+kNd{oOHLqsr07&~dHqpvKFBF;KTjzsWEQH=;2W z)U=E|hChA0Jp&gap_)uCq4ATALvIqV7e89QpUok4{fW!?zJ>&j%%;`LKoi{VYbQi% z-^M{RhRoa=e|-9@ONL^p!?vSuIvISmY13^82{yOyAywdG=|ZWoUFLg)y)q7mU7R4% z8#%O&1gA|9Y5OQkH}!fQd1zOqh7Dyd-PaMN`Jaz&xtL|?CMXi5>^GD)M}iN4P?JCq zTm|mSz&i^yl=sJvRmD8luW;#3HP=a<`&suVW!h?Ij_ZX_j0zEfLs@*#jQ;G}u%a^Q zi#qWp-V5pPmHE>d^L9krS*8p4c~x{$sD)cPbl3{YS5As1NQa-Yc%Pa=3rj)yxby>b zQA_YCCp<8Z>rZr{_}%FzdGTEj=e(g3z#?_98N|nxACv8zn!wcT`YMu#^QU#Q6SCu@ z>n@s0Ayn?9dUO+0*+q8rg?3}7YnfQvI0~eS^Gcg)gc=82XKl)1N=BK`~n!0b{c0pdO|yv9+RCRd~^Z3v6EsBwO!Ui1O^_7d54g$9nX z6JwZ^X=>a%z1{Jl!NTXqFoUP`c6B>w=R27X{ZAa`{)XanL`5nd){RPVC74Q!9-Z_7 zavQ3Pjp(PRTf>^V*+zd++g_!|-+uA@gOkeF%CdyRVM0c=Ps*TyTW0}+47d?=y>7QL z)%V@@YN6B^U71TI-h|x7(O88ku&pb8jLky*QiZ42}@ODIL?M zT|9dM!EpgIHdbxMtpLK;qq-GTwr9)|?Xv=qxe$)1-3PSVj?#R-Zo(-22r=mhzDRe+Xh(a)&RQeEHm~GS2j;8W87uh_UxC z?e#kyWfU(3kt`L6DmUOhh7~^eooVym7V2}J7p)GE#cjPWIH#JArpKIBTKUqUkm7ws zg!HbR_!&&Yq6YD$7nt>eD2q_j)0D2uW!Gr4&f|?uIohxU^0aBJ+QKA1GiSb`znOba zykw#eGYE&V6%@vP8J!_qp02&nGGUE0Lm@xyHg%AE=M&TavxpyX((b!`Oi-d*p?{96 zFRp&*{X-;I>RU6?xSzOsG4N>&C5p44n|on!e6lW%WB=5<-9z*j?%qCgn(ZV2(}fAv zDr+7f#wUo`u3=2zi;Dpy^&(+4!wQ%Cda5tcq7Pl3nwMo~MF{o~M?&|qPGFhgy{Z#1 zRnZGEW=@ND|KOahr7zbrGl#<`wip;Cwkg}Z#_W|EFMEc<`MlVH3an8V>1%Y6T~lz2 z+9%Hf0;wwXXfhy6Q-x<83}8pZ!Kvg__BNwwR1ys~{}YzWXIsLL8ahR^-=rfY4Sq86qd z*JBR zP(F?2h}PAXF%*@W8@2^(9|S32RF-lJwL-w`&Ymn~5K?oy`ncu=2a4(1W*6kUixM(; z{cD6dZLcHM4oxxFXXgiCOdb*D%^Vs>@?D|J?iy2uyrCUM*NC!4i20=)A6N3c08~aI zYN8GX5L0$xYZ6-~gq*%mJQeRg-{ZyAY-BG{hH1C5I(no!=Bbaf*1bN`9QC|X9`86d ztKHg1S?kKBm=ccu6J7)Lr!h3NYIj=wxan&9=%kJ)n276v%UnX%O%-K;HppB~(ej~{ ztfcvdT2<9ptbBQJXpqYkZv=Q4-WDzz5pG=ep!JjXGN6G+<=GODiVIiHq8A=ljXif@ zGKYIglR8(#`%rUf4jcU8=H|DTZ;-XalysjIT7l{G!xT+iap3n@?P zkHJLm8x7KSni@kka||ca^dzlf?jAY}D_ctHPVdeTLKhkrcp1jdY4`bFEH>NU`rvwn zp?MSf3AU^mIwiMr7^`<(0N~L@~%UT;<1=w5`jndwYVVXV-kN`CSF6ad@ClCMe58{eZ-?73U!>zft_>o0a6^*nj0zulcrBrE-WztvEo7KqW#zQ@! z_CY#2P0dDy%GgD0{=U@qqNxPwF&O&G>iT9Iat#0 z2LQ0|PLXAe)<8xu=A`!Y4t|jiGR5v_jLolp;@R3DgD%-pL1&NdR3TDl=(uiN%&8*f zA#KL|98jBV5lojc!I2hze*FF7SeaLdi7jtNl2DmgNpXMI_pl0%)>- z4R-nM@V^J2ALr2;_Jw!v1cJp&u8lQe=%k2{W|JG3RT#T$@Hw+=P*O&gVkO#4rO3?q z_h(y}nrO@B=}CnKhD=W;IcugOW){?;1q+YyG_r1(l6lcAoe~x8T%;}w@+CSOye&gu z|H`{`h4UhJcFWBG>NB}Wmj=n36Zzy2WmHT3$oMG?oEGu{;M(ZYzeko8OW^zSiG?sj zAQfPZZlVaM%i%sAd=uvmdQgI?GK?@oMC{qmDCm0-am8@7Mwovd4PAD|PkUXUSm zclt3EU%uF2k5@0QjTSe1MD`MqxY-FPbuoi*1zo66{J%=u)9X`Q!Q0+^N<3${2^1r; z#=`7_o|uZoSre{X0H4oB5JDSAL43&cB1R*}luWIAe1LOW2(kgPV|7QT)(Y=4Rn)64 z3NvT{sMIasE>*~F0+QBsu_9Sli$K~tZa;+v1(x>f|Xt<+w1uVHtd@b2?0`h2*<|$P=#;yPoQ`&I#Gq_odx0NjEMmU=_UEyjs=vgs{u{ z@Gj769;lg!^6RN?6yP=zGEa|Q?6gltx;ftI>&H+-2bu0KAP{2rduxXq z;xfervo?ReUvjD4+7q}w^DWS`0mxZ-_V$!_j@~C@5{nLLKrypSrM=kP)$ldC`d70W zNN$mwP?@5k#(QGSIvnA6L~hcHn4gaom;u3ip$s@!D0inAhazh{;;9x4NgPpZiif5Q zg?Cc3eHQCftP6qdoA;&ls|KV;)P+)ckDuo%o~_BI&mhc&Tum*MK|Rj-uG5&0#NtF^ zV%SC0Fm0b-V*B1{5X|-7CM*EjXV0t(%$hHENbJeW#Te7yFwJ6YI_OpHInQ5KUauWE zqZpeIkJ*Cw%EWe;%#r|+mQ&)wOr$iHNsrYZXGWdjl_(>$kp>)lHiO&}kJkXX#2yFq zRI>yNy1qS7>=dMlj9N9oU~FaqflDY=bop^~Y<848Lut0((UWB}CXz?=hxIrm;; zCesr%LIW~2XwMmSuVP*C^AVd>?EEgPsvb4fOG+J?My|kudG>;&KAEK_FNZwpYV!*s7&gE9uF{UV-{JlZe3RTtpG+ttHBF2a(vG7EAkFLu^) zuMx+T&MBaS3(56RBZ((!Ppg*_Y1bwJHvnZ5V^19&^E4OXnBSJZh zoW%orbSSkw8B|8(o@R+wNv^Ac$#R0oSvbui3lJO$&($z(?Lr>}_WC7e&bzcso1w@H zn2V|}36|zlV&J)l(E4{d{4f4jw5YPf(#p!p&Mu_%m1BN> z{_XY6|8;30l{doGQm)wI%1W}b1Sc=8jQ$8eYglM&WosK;dU&G=_}ll{Rj}8b=tXgt z4p*H1l{4J$hDSq~rquJTnALZy@ihNbNz8$dsvhTAqNR@|t{QNey z%*%T?L|ikiW27!(nBv}X$2Gg4V4?EaPT&NprcsfRcMN}TU03?P0fK$fOe?~}(FFyf zd;LmFOa1-*>+9?5B6t;y^#omAUBQcXR#tU=X`es;{e@ZK-ne|9T|laQ1*1wi4&3nU z>**ug23lZ%p zszJ5GJN53`*i7Ndy;wP}|0FhoZ&D|2Y;CV=_rMV#={x)OI;(>R4=RLmq-8R%;Oa*o zqBZpNs6abKg=)qvHD;8i~)%M#7gaiZ*+PH1J2mbc`sv;Tlt-Z>{$pBbcD5n(8huSaFA}tcGIB$Um%j42l zqNlE-tvzqCy}1qX{THyh!HWU{A+^H-0s=CKPdPbHr?99r?a4-w79eVQf6j*GZLS6} z@5z%Vg4e(ZV8ouz-qgv-NnqU<)Z>lr-|wDF1^>_dJmZRs{H4grTPL@_ z<_6h#57_9+Yc)_rD=2X7$}--=$`vQ;;|UgoRM*thDo*t>rFST!$X|^Kt{q0IS=!k27T9z>+qq{&!|b)mO>_UiVM@08?;Thb)P{Lgq2Kjq9W|_<;aTVEz7`60gct2>JbRzaN-{7Tl?7x$Ymnb8J5t zD+M%Fxv zR=_Q00c)tiJU9(>9}2|oyKzlI@Zv>)qaTFUg}cIWnKAw5c$bmKTu7G#u1sRmU}YlU zv{)m?5rZdzfN8EXiv@kn_{12+G0xat6YmZ{0fC|znN|zwg zjnduS-7PsNpmcXjcXxM}bR*r}{as@Bzu!Fj>?%9_=EgbaecyA=z0=r~C0CfE=yZrc z$6RfCW<2lb87CUb23}*!IDwhcT4NMwXJ$yFk=dAzp&t7*Gg5A z5Lh#gn@2g%E_p6OL$H}oe9l9a3r_6UM|k9g{WfN5uWM({OJ6Ljl<5uh_S=Li7Q7!1 zy!j1P(?DVEl^3N$`MP)c7&h{9&Gv&;n*RA1CL4#tqez2LmECpd<%n+PS_gED>K=k(RcZyQ6X45v&7z**R+&zBo) z(5*tKMXSuT-FkK!|JtAho8wjsWzNOgChg`HW#wK6@7mq$Om2b+EAUgm%8#Hin$&3O zeYed|s-yDO%^}Cr7BZDler!i=^L{Mm*L1@UyA|v2wgszf_m>E3ORsiYu~$$2gmmV{ z(i%u#fqrM_H0G-&iOsD^+jXG;$%hc6N7X@S$PN16vdr#gO++9Z{p}JiCKYX~dO7D5 zrRRM1C!8$>@%+l4lwyNnvS_GU>YoMNXF0N0GPV@A0TtHWlDd(T8C!%P$VKhuJOBjJ zPoZ3ul<8-^HEFi*qf&L+vQB3*9o-xF1NUV5>~Nnl`uH#1*1CQJSYFn{RgtB__cy;q zLZBc4*vu_z!J6YS= zD$oPn0Z2$b^!lo{e4g~)HY#EqHakLKByU5|OSqe+tG(2O1a$zOj`p8J_?y-9P1kQW zDc*DnEaqx`Kw|5R0n1yXkD_JB(9bg43x+Dy)k~?@7qz*SyGtL!$e!mrC-OvnzEEwH zG09z>y;wIX)0=DZz`F~GTz=E-FY!SLb94evcay!tDvnoz(e%5u)7Cr)geKz$g}|{+ z>1-SpvrDI8wT_pa&L%HjEFUu8Tou~v)!6m*#;xo8L2#pb#rFA$hM(e&hsAJ?oW+5zL>%1|u$FE*<=VMOQk$*GKl`aEB5|*cm$h$}3pEgg zUFEY-;heOzXVq_Resr^hJ3(=ZMJt8Xj%)QMlXTY&wl~gDim)|P3*C&Q1uJ+0_Urg) z48yo0xzz9Gm+GiK0lJQx%P$}RwnRWcpcluZSshFlM&^yEtTpCX?S9+$w43f+vgp11 zG=Y`knc8!0E`gbesRwlsz7{Vw<)h!cC9GBFLqVtmYIDf8|Pv_+0rMKv~60}+J2;PR{}%10bKiObiUm3|joxo01ADp#uXR;^Ua_}=$o zMn%2_A{FFc>jB=5Mljp%`C?U{i1Y%CL-vAGWMNkuvt6irVSmlCMgoaPbPE^0Dy^Wq zEXIL6`MsJPB9xd;i#i;BeXOW}Q)4!G>AiBGAU{!X0cB z-6?{r0iMqDT3(scd8eg77hKts2rpLZW;UK%OJf0WVmi2Q-F6Sf3-#W6qYb@^NLFu^ zBB5$lgSQ=Kw~Iu-rpB|NY$bQ=8S!kPWb|}vZz?R6rS$&urtmdBiG_lKf*Y*6n+W|j zmqseEEUULMWnl7zt;k=%83OP^0ym}qOa~IhXs;|G;T>D^%?}||c9N!J%M_j!p2A(% zO$&EY-I)^%lL~-2;D6?VM7O|Wn|UigokgHo=g>onUSy}G1hmDgfSdCVkd?>a*}0S1 z0Tw!8H_i%qHq~VIB~0ZA2!mZ#0pw_mJIW=hdQ<7+Cb$KXPoFbQUf~bA(Q_y58dt=`P#$orK^;5UsvM|p9|C15Rc~qf2uK*D4-OjT zsYZSqXMB%INl5lo?qqu+&*QjSbF)FIi+1RluI>Gj&jPAbmYJ1hXhV3bym&otXZtru z$Iq|A6?|eR<#{LCVoXu#%_2a|!O^@jfn@Qi>D#yAngnWi>nVG zn4oV_JcKW@{c7&Tuo^*T^>; zh|WUNaCsXi!KDgZ{z<#4D*3R`mv$;NKCBdJ>x_K~cq$TyE z`Zz9d)e;G!#I3pEaxP1Sd@VjKRw>h;0|#WRZ}#4q6CAPtH_(7Z|9&s=T)vtc{^`!V zVhqe)j%6Ybbi5gXs;qF)r9 ziSKQm0(I`b@cJa(W8U*kBG1&f^T=AqlaZ*aOFuZCiG-YIdq!7oL$=eqV4HgPec7kU z0OhEMIY;TK-HBY3xiD?~2@nIk4-Eb%!TpJcdV}55kb%_RZ?h=17iZV|JISQAyVsZM z*SE$3P9Q8Xx8yYx` zp5A);%@zoPwNKgvV9fpkC_?ahe{4Y?4fLZvE4HJU; z+17JE!818{)1pls{f3T+2bN*!&-2X>P8rTawS`O7|45?POLRxSVD}53sE~X4SC0wS zdURp}10(7x+$!J|$aBo&6jE%R?s?g}xoKaP^-#E+9j^0O*-xH)I#vsk#s?Gfrx@+- z@97ZSU&g}5lVHH%T1|DO3`LC1 z-ZqVbxo>3gus$`_{ZJd7H#Gk@YL-0Q9v-J(b93)9g7l2Vbx=~j(es4)+ z$(FSBH1JM=XHV@eO>B2;iz+G>od?;JR=*K*+faiX=cktHl3jUu#Fy0#Uli@(TyK#FP{0w< zyE96+pUckH)@W^($h=$2#ip_sPpV0~pUg{0!G8?t0A|EHOOa7vC{Y|9+g5KV zv@{6HXp^~RCXvec5T*~Jqmal@sFS9*Q^tpXSjue9~TrTU|ICuMr&eN!DT?snRBY~w(U*g)1&-oq2*osOH_1LLG&|k6i z$Oz&49psA+v_azM-@HK#hEhBjXzsGOb~0Hc?EE^c!qS(UAAMMNKl}sq|2KR-bwzd) z_-pgtk>1)fKQQ>S-H{aO*9sgDbbr)7E!E+3-OCo1@1WIil!WvlAR~w37+&d^d_7s) zCsznkhxNOR+if%q7Qcl9u=Ke9UHP~jOd)A9g~3h^YHG@h&6rKGeYT6wg%6X1IaEx$ z+cs7MvJjX$W&#dBK4AB267q?PqRI_(iDnI`xZM2E$`<`gyyJe*kN)dfb~-(eY)VMl zfO!anh}W3qz6B3FZvF|UZc_(bnwbaDy7dvHx^S;pD$83!QIR`DoPw#c`$X+Csm85V z2B8aI^FKM#6*Q(7i644JG|cL}yI%0Emyl2G%$U%SlEhjT&{IPyH^{t^DR?!_>U2_m z7SN+ZR?_|b{psjxI_I2u5H_c-jsklO<4uKpz{D12#!tLC>kj87> zN=8939$Q6smF!o7*;a0r8!}b@V3eA%$tC-DRn@mEY{e2F8>&l8chyT`1=vZ!yD!@- zCzL&iz!ZwsP^_QcTX~<>|BDE0iZryt4lGxf=}A@-$XS=$?WDARQKI~4mI5oUC=}3K z3sZT_yJgXyLk?nr1%hw`Y%=lJ(UrkeA+SI%CnlGFR=W=+T%QR7>3cp#XHh_*Gtf=T z*IA5u$9KSf5aC-svzh(T6zsw?_{r(cr*K`#6#eNLo526#@A{GR&DfaiaA_m?dE?VV zr&oYXP*$DHMMx0##GJ=Pw$z5(ZmBOZaJK#UkjwD2)zeUpV(9+q@l5~Ebyb>0j{eli z0ng%-FWuZ+i0hfk;3C%Qdpz&5Vb9hUJw_944nx`YfKjH-(uRtV zCq*Q)(VsfB`|bGDwPQdyGDNq4g8Z5jJ2+I#o+L9v!HrWts&kf}fzgy6laS|W>Ua3q ztsMCml2+NAv*lelkKMj}9+p=7jmL52RKbv9tiJ2>hle2BPm$o>E}fmsN@(R{iY)E- zl;NUD@%K5uErf^YiAE?=0Om@d-O|>S*Sy_ifphIgTioTHm4e&9vU9Es4VxhS#$bC zP8XMp%Q8&gCC-iXtj;mXQL96^W$MD{CyZb&D}Tc)Jeujg;zSg&nn&D^6k?}y^lfe7S`XQTP#h>^(YY7XX*jri%r~#IDF_yEj-dos03Z3iax>8Bx6yMJ7 z%1*;jX0o86!h#IOb8X>{*=1MU>=)Q#o`xzoNWEm&@duL(H+jR_6#71V5 zI~^0lAhY7^Nd<9nmWh^>)!K0?Fbw3@PrTK(8V3P<>-b@J@*l)EzZQhTaLl(60k#~Z zIy13VVe!G#x{UzHS)3;P5DIi?ks(w>H`YEqRr%>u@u9q#nb^m~VDn!J;Y%9#gIlR) zm0@BqP`Ht%LATzu7fkDUJth=uUO@`|~1L zHxeZ`Y7O+H>8g)sZApg#o&Tho`y>RGeTI!8lEjP27+2>;+FzQ3gg2kSI5zRtSoOjy zmf`;CX>gxX1-S@WS=pMBBdpC9_7HK_)8hzo2A*ztgJO((|8vf`CxnBUSqXa_dT3La z7|0~W7-5ZQOUna;gNmmse)8oa6BFf%zM1>DLfm8cFdLf}mnX=`moAr=3GZ4WBl*)^ zm1Jgi44fWJ1zVkx_~@a^I%uG_BoRlyYAh2})z`gw`A_!Fnm&QYOgsH{@Wt$MyBV(5 zfa#`cKuk~xH)8#aq*6|4hkG<_lL-8*Y0Qj_>**QMhV_T@l+oDPdX8#lE2Y!TR8HdB zY|_S_hS4Uw9iOQ3YVY4+vCOs?7Dw48BAP?bjJn8;HnRnVgo-d;qf!G-D(%b4rZXdc zSohW|rDAj*Q5f>}U%u&6fZaxFFDmJOooU_pZEs<>JB}tddVIOXsCY5bT7Lb&LgfL3 zo#w|B*=APJX&1T$d~Em)IrBU$A8+6L;tf}rUy=|tV!WXH5mjqcR>95Z*^+(XsjWX_ z%b*SH4637M|5=;XJ^la)VL+TL#^MZ{pNZp_FEv{Ic^z9NzF+nnK$+6lQ>F|%_b~7k z0ncQx>OpN4jdAs{(XYP6mEYA9Gs=O5(BhR+8lvR;O{+i{Yo9V@h>myuZCNNql$Dh+ ztj-*dzteJWZxG0oj*i;F^aS6yZ$i}ET!LST(?_FSo;a+xlVu|ro2GS;T}&Ym3o*q{>ADfFPq^_oNgTu^_1V)H?Tt!s#=< zH1=oH_xuI;3BtRFhE-LTyX`W>PyOBlf~vX+?Y#}&sxpA1hMf5=C}a}9flx8`%`$$0~9=nZ-x`4aO`63#A+z2r~}&}0S?*LZsBX|fgw7=xU^3BOg8?^WB16LM!SRDHCg z(#z)j9iLa0RFqY)CZ^;FQ#>#*HPkpIHS3-11g%Ia@*el~@O-v+oT$>#T`2&^YZWhD zKQI-tz1h5IilmaH*rAy6B(#7|;vUUGqd}RrW_M;USgVvx_9TG&cE>K7|AUfQ7=6`x zUYr+;Ou2U?-0{XRUYl*sFJ)gibjlk&eK!S2AE2$TIh7r(E+I3!?-Y~-lkSL_bIo&{ zt0P6QGQ%N;j3UA1wFMdSqBr2e)HXv&_K91qMUzi&th|eiaVT(_@6rSr53C%`9KkVb zeXv!Q;E$k0n3#V4&YB2|&9A<)*7UT7N8Ok;bd&`8Rq(>@)Je+dcu8O_l8VUI&89nP@S* z8i}PefrlsCFpPD7FHZgC=)}w_1$9fHGjhhFGD}9CI1{f-r7o z_LjaX&{CHaG;N|Gz*gH#SsM4fQS0D!#;8e1ic6{|p5>cGR&Hza*sb}a*!<}+m&f3cy z^sEhRk9RPM4N7zwV1LTV3(R~{#VPRxUMZ{_VXt-*ck$!Xb3S+}IjL?zp_2TPy~8Ej zvP$v!!J(lSuwG!`T6=a8Z?r|uH7;wwkbQrWcrU)NuX9; zZl>mzf9>~IKD=HWC1L}VnyhZ^e%3lb+SqD1TFpJPY&qEEiUI!zXo&rB!(?bO7rW@KQjDmszN-w-Ehr&TvZwMdn{)TR{!lS~8Q3Y$aUiTp#`jGyiIF*@T; zoX|)Lz>30<*+^-N>Dp#Yz8;e_0C4MT@6c}^7SGUI`^U7|b!baH<;NL|upY0VK@oDo z!m31!WeCZ?$QeUcTs*zJxU+?l4n0a>?ufW^&Ev6lC3&}oAf15-`}YR9)Dqa`m_1!( zy6LA)NHuhR5fpOb@&wXQnXGgP;x_XUdh1(NT3iFdZAH zL;x{%KMlTWi}(c(s0G(1rl^BN?{maNb!Di{GKPJQ!Y@kXu?$7qf6@wcf`I1cv~^cT zSusS(NrY~9Ba(h4m1egAgBbi#F9<|Jmv}LVEy>7b$*nT<@x$r%Z`|J$C%8QPN$o`! z7984+lSg+mbV)fWp=Hg9Tapku6KDJVL$cPM04=G6yn^9#;83s{s$aIl#IyfJ2MD7& zP+WiTumLY0hktZ10gR}m^P8TzC_zh%^&nh6wXf*|b;i$gIlr!%`W-I${1$C* z%rXDd(S^GI@NH2Dy`Vif)FqG}`@_eA? zHp#q;uwI}(1nCmD7jGosu>%~4jm6!U=E0Wad5C>%Y)CmchD9;kjMKlF-OX!d{!G!D zx==Ke4EQ{c+Y^B$V`*urfe8=|_=g#eEN!%qF_1IiF&4I41t)|U6mdQh2s(y1+lycY z;eJ*7pqj4{XDNca6#?ipl3g8d(4nZhSpdIO$nm=!szLr$+lWFb$H{vwE?a6$M z)L(!WVVkd+plB}s&YSRKn|U=sW4#fs99xlcLMSF+MER7M!o=?UQpBFYy`npU1>Y_@ zxAtk6LCU6RU7k1mE-wR7%|NFYU4JVl#w;XnDXMp7&=?X5Q$-&0Q=je$TxJf6){FtJ z>)^um3D8|dSiTP}mMN_e+*eFr;JdmPVci1*WYuM?eQ&qg7Fb?E!RH7!rDpw_j@boz z(P3Oye*nQh8s>)CY{06dIzh)<#z}}k&b>D7NybD5KUPru`9keSBz5H7x3F#*!v`U8 zUD*p!++@WvD%3VZj8=Dx42fsOa_Is@wKqb6i5uQWa&)tW^0B%-C#Ri4^x^jvYXc=E z%BN%YC&H9GqBxY4(;%sX_!Ggr*)T=5KvA!0$Gns4lP4 z_obQ);ZkPko~EbtFX(kP7mAY^p}ydU_8Xb%V7 zB;k<*Q-5K118K$fBuDLqXw|SqsZA8WrEuOfS!wq<17b{U{pvQLX@xieHu8v5Ll==V3*_Y z9MM6EjSV_+<<|Iw=i0ub0{@{P%-K!DHfh^FVscX1DFJZU|Kf$^SY*=T;8#b9^#SXc zG?|mKbc-3f)M6~RvLQYJo>M0M>NUaxEZ{v6-5|#pFHHwI@E!|F$Yq^L*d(gh-J28g z7O>p$GcL6J<8i%zp9sO_it7{}7E**KR5z3rt?L5>;zp~Jp-qq=#WF{|MjS$3*iLPJ z#^Gfck|PGEPW6u^^ra?gUFR?zViEFu0etM$YgHHZ_INdGkNQM|HQn$BWZz5vT_ko&B&lK( zkSX3IdWNUjT<~S~J4NH<&Mb|tkR(0jA}*fmH{0C{77#X{LJsfGK z{xT_Rc5>z4r@#B~Pn=~RmwX|>Q(6(tUFe0P% zRx?fk_C!NX*#%r;Z3@x{BP8U*gK))D`BBi@^SST0mL~kHsX@i0sei8cmi)D$`Sx2` zWxrerfPMZYe(FNba!g;@hGa|-`hZhBc7rl|ik(WT7WePGM}<)QYFso0WHtjJDcH=` zxf38_I=Tq=FB2&R;{-3;{7nw|InWk~Otwe$4HVQa`)(?EB~Sl8tuo!c*vssQG_ zN-#4akW6z%eKzpct5{$^NEH$uCYTykn7r_NuINzux2UKr87($e>hS*t^fLQh!RG$< zC#W(AB`w9d(X4s9loqGFLQj-v0!^w-Io^@j!muMqN=jZ>4XJ>X5rBqV@TIUzUSz*K zaz)esslS}PC=QbP3q)ai8s-fJ-0luiaXA8vwo6-9*PUNy!IVDZ32|ItvhQNw1z0h_ zJ9>I4h{+L=kaw%)&P7+peWC%^%b6_Y2XwCD;m5ZK3OX`$|HCe4wYIb5oHE(One|v2 z`>!CYr}^H6qOg$4P7hgSLJZ=pJYKv{0~cqub&(v4pTc|t%>{Jim=PYQyh=2y4S zTiUv_voeG)uZjjO+c%;ZK&o*i#iv-RX_TtnIDIBAG~}bAxV-h|SNN%e6}_*-G#K>f zEk+D_S^VmbZ_a+We^f%5CP7NUyrKZH@1i&@D+9QUsP;}^f5G6kh`=V;qUFJ{mvR9s zkN>m8HB8@1*kN=cK)UT>H?le^&i-@9*w`>Hj1J($eV$NN374ONuBOjZRK2U5}9GS4YMg_=n{w{Kv4re2!dOl(iloR>9Li<{{6?Ng zUnl9a`69ImvMOnZNdJn-v_mp5>59L)`fKGD*Ag=)fa`jgdB9)&F$$%?T4RE{UlMqB zYjY8@=;JP+^tF%j;`4Y#W#1PU1|@O{CLIKeR_L39@f~&hTA^S5(+hyv4j-(%bokTl z=QCKZRr$hfPCS~uSS>=tBZA-CAi*(jeiqYt5m1h7PT=!O94OD@rFI-^ZAHtD(it(0 z4m6+6S#EE*bu-^e>-7JrhJ&f;Mz&171yHXs3*!8GCTrR~XnBJVQ~iU3Wv4E+nR+{V zg>O#O27I18E{TdPO<(=z%s>Sw2C*O^zMWm&vRgGTku{Php!h{Y@`>J%J1^^o695e> zTo&9hFhxs1l0YY=YLt}?)SCdX-V4M-2x(AX>Q1#S_EruMY!Rn(=B8zy68+#k%JLV6 zAWfm2QWid4>s2I-^)LI59|3iT&bF$$vpmvJa##dQw56YZz7HVrCS%t_GR@7@nF$A@ z{|`_akG4@RS2vSNtx?apGY>7X96D2vYaeCNtqe;Fma&l3ySlPOl=Mim+}L} z))rQF`sZ{k_P1Dx$nC{tRKS~J8uV06ywHxF-khOR{6a*0`}*T&Z)F?({Pk> zpp&G~X~;gkugzNlX93tI1tp|$XTB@@dK$-DC!hVD6M09b^+FHqY{OA4vf z&1AtoRg22Xp7gXFlEKq|Bq5-mLqqh-14V(?Ui1Hy*q%4`3d3Xko^GfH5MIsa2Brl# zSkp}I)7A`2J>YB+S1eIE%EFuo!W9I1wtgZb^Famlk|x7S$Uu2cD+V`c3>{pFSrHF? zw1TLPdK*ljLx~ApB`>4}H_I;vXuspejW6vxa<%x($sd&Nn--WBZZF6gkc%p5DNawy z${wC@EY8nlilksCTK5RLmtriaF3)PNZjR3Ot5m*z2w~rzwH~woO1`=IMFgEcGgF`= zvooV7HTe&v7^3bxef%}V;02xioZ%lm2X(3r*BXx%4zWPp-5YlKw=Ag89%!jJ zgmw*!TIOqV@-iv7G{oscCxZ%>5tm|V<5b>6Ac$IFCO(z1uB!Ad=YeT9K8Gi}D|`6Y z_}^Yc>L@o)xyUqJO}Q=wrXyVa&UNRsMk1`c5OvWv8jsU`#m@H1O~LXjH6ply&kw)m3 zGQeKQM|#cs{XS#;ojaI}3; zV?UJafDbdZnVU4D#X`(lxo&)Q+>=A-U&4oVSJZ1H4RDr(dtsXSGFWC-gDCbQ^scv+WX8{EiFl6j=X^eUW6s zTCQwaebH1a(ZtUz?CE1Qk5IC2`p(ro(rxI&qI!hvujAw$XhrCWUlM%S6*^qltNFbp zd=r9!2N>e8xeru85tx3GBIJ+5YE9OU0UE@)?(7O)YJDA@3y>t=6{9w1d)^R+AwlAtNYpWa4LFTJ;C~bxNx-6 z^r#x%(c+X`mO?N;2ZMg5E*7sK=`s;mq)vtsyc!G?5#0)DJMCUIMjL6|Hnu(Of+fUY zCWSc9MRAOmFg2ebeP(4!B$Ag(TU+Ez;r1sEGb@h^jZS;S2Z~{ag;VusXZULM=eOe1 zsUFl(6??YX=oqKj4T4H+LhI?7y=l4j+A~nbVOIeMZX7BcqX2J@sU2j&O=u+dj+ZTH z!8+BZEB;7qw|06!Ggz`SORgccwm02d`HrD2sN?*Ib>s1PsoGu5()pEo)?K%MQEp?+ zjDJ{SXs*ha?bpxtqH;p?Kfdp#A<585A=p2yS-;-TUvDr?A8UzOBDf@cDLh)NZPpKK zM;H=ss5p`0VG0U2^QM(ayeR~^XD2bPN(P2=4vUh3Tc)cs(1yP|$FZBs+eufb59<82 zF2%z@ZSV97K&#XKX%wJLzu-Cafv-E41;acA>8#+54e+f&tvYjWVre@0}j*G};C?RWY_?P~Lq1Dbc7f86=eO6Q&5@BI31b`_+qvAPt& z@~art`zKm)QL6FT597Vl8jovU>LZz*_-bJb#1Xeybv^yZJWk>=!N4D2&h|C~U-dhz zveM8-^d38|kEVj@O4m4B;*in8LCEYT2T!-2ws#yvW4=A@J(khIwp$+~(uu`)+5;h* z*X;ag6Y6jfOU;tn%`badU&CO6RRXUQ)KspUw1>HN?p z0D_?LT%3EPQ_dG0+OzzsQlo?(Mz;;Z$5c{H7sz}gLgJ5oRm2tZoq%eaakyG~$~OAIlZ1+Lq@y$4`l9-QFJ1j z`G~+HSCVRME8n{!MOSqgzN1Bhe9B78xa?$6>9n&lmt3$nA&gIixrlDK)a)sb>g@sc71r(Yl2Kk(+Wn&AU&Bb=E+mkO4q*b9}{80Xmtz6m=#}L z2L3_eKi2{|j5)3I+bJ=9mXN`zORAx(E|Pk4maKGAff19v}Cn zCW|pGlgq6z4+^Ng_bc>@5IWXtWD53+f}Kvj-aE`(L0aC|(@Ru|9&ay1ULOYbRk*P5 zGwvE6D$8(5=jX(?h8K8FhkfCS)?Td?0Yanbgh9{@9md$<@`pc%dlmg_6&dImFvY>X zPFt53F^t`d$u@c4l&Z@=K_EV>QKbTj33g}joX_MAcbPU)2*Q#TS^O_P6n9@dr>sy` zwki#_(;I5tK8T}|9e!3Fr(?aX%gs`%yR#11Gb zi7SXnN}TREoJBM(haqxCKY3~z^Q%Ozf`tA^52Ro=BcIwX9&g8ruyJh)IyjYsEtbOn z{Zs#&Wo<^$&fqSWLygH!+H>h6VQXdlRk=+fUXd%)x5Y6B!|)n$x>{d9`)i$9WTgK| zJI%LQlB;+r^^Kw9<;3~h+oXRV$4M7Dd#|g{GkA>GSvQq%XVfq{6kwuV;t8Vd?7@rc zG7Q2865%g3B_*%-Wpq|BiD4}kYz2_*C}VL6B~nlOFKO)I2M*uAe=1k57b6s%o7Fgg z;MD6amrV9Ca-N&5AUX4tXt@T4GVSSnTGYNMrCpS8Dxwl4+wL|}{_~`;z~1AS3d7iF zL(nYf-|TN3=4ZY&FyT;>+e~yUeEK@Gt*4RC&`(Uje)hXSU?HJLv#mCYaV3Q8riTm^ zw$-=(r5@EWZUH3;5Bsn*mYjG^Or{U)G~+|gdaP!J8-EI2r$ov4)+ENLQ?E|6JaZc<;z2P*q zPt)T-2MB)-Cc|F0asFlMmG}2o1qa2Yn?IXLXv*Y_>azzbSE40hEq1_8R(`3TG}fm$ z-0}T!P{?D=e-$X;x3f3i9qlX!+vv|2%G^!Fs25-%pdJVp0?`ZfAc%G$uy3A{Kt1_a^S0?|@M49@D{R*3e(6|# zWRep?0{zo$x$n=(B6`&o?*D^sT+WvE-T z?J#80`hi`F6u0#j3kMzGtC(1GuR$Ygvp*Q{fy|dL%}f|01KlIaP<(Cv$+F$~V$?T8 ze6kYnN`9>~2Txz^LV4ymuOO7%{Q`PUrwcGR11Tpqx%Ubh`2Uyrcz zD(B+?dRtOmDR?DHE(9ko5hN5_!rV3aA;OVVdt?}nW@+K1OO}+hR<8ZGuR~!JbhAHe zge^ObC~&|>o3}Hm|AGkTz1LkLDgGWB`;zfI8{WS?k%x!FBZMw%VkCQ18ei2FTKzQ-!bO72L5M*e#t<88FBm-AehsE(T!;R;C zuKOQ562AzmR$KoRPE!~3>RlG`DWEwOumwO1e6y&}I6ktp;}yx-9FZ*v35aASw#yJ{ zdn6F{dr-9d(9h{&=Jj`66@B9z;Hy6*6q-9A6J_u;TO)C=_KNZ=n6F7e!Ic< z9L*=EatOeG@zJI=%}Y<_;!&`$u;N?t$W3Fcr}KkS*R>0+(ZjB;QuFm7#BDP<@xP;G z6T!$-SjYLe%(HYzieA!sZ%Om_*qp^71E1aTFKkaxKL&AsR zbg)>}OjRxEX>t#M40v-LFbIU9VNw6SO*ofWGy1C886x#@1n!?hb6>CQL8LSuo&9h> zj#Lp2AJvvZZ0de3qcqBxKUTP>oyAUD>d(Oyzmn7%D?+RvZP<_5BxOFm_IR%OqWTju z^%1Fyu6udSLW?xuGr*rJJ`-71N|sQ%1MWV-c4~&d~6o$A7cyqj>jg#eUge#*1LM8 zB!4)`+kKU{Yx%>1p|nx7?*rc_S86gt;ObzpqB}WAZ`As5W9NAU`*PH9$fZ6p{*C1N z+4D5!qfX7i!EmVjJ0mC$2P4h0RZBEbuF~T8qUD7xN30K6|1>tt2ck*Y_a2u&i8Z4y?KLjHaYlIrfY*`{Jn2>Cxfucv$$=6n1mRAYyGflzrxmV zshU})t1c(uvHf-u1Zev6vaa9H@H~1ck5OxRHCf~Ld)Mb)!p3f)(6BC_OpCC^6PD{7 zm_;CU`BfwQ^2hE%_$RW=gZ{*uQ0<&Um1CrlazZ97k2m%`Vv_3vuNVWn`k4r7)fF4g zfY5i`+P@1@?Z!_7Ym-V{kh%G~Uw+0|eMbvzOG}IO4UI7PV0)6`SGguM%^dJy_;+!7 z#B>S90xrXkJ;BWisrUMsMjPF_=S}lkD(mcr-eG^GDV(V;14#vVa;rFi4H^v0Pn{v)Rjv7-&0V&cpy{%A&2KR^()6 zy7G!Vl|aCX<+vu}*WhO>PpPBFR*lqpf224%F>o+LA|uI&8TE@Q=KmNh`Y};X>W!Xt zW1UVlX)ElAj<7{Sx?enhK6ch_okXxs9FVsjB$$Ctf#*uXAUJlu`V@4ZCt;I1eDj*t z9)2H-#3FUY*DbFf-kv2%oj;f*rxCY8cV*^(!}veQ`0`@WXo<+gDAlecZ>EUDR@>Nl z2M9*cW|GGvnyxlUr?(PR4;@CG#|ZEwE23x+tyM&8NDC;-RHm0}tyl=C*ek5L@oJ%V zCZ(LJnLWNG!In68z0%L{n$nV4Y_=JeuuJo~n$IMassv1cz~d0mSdc{je1uciWx-fQ z*_@VEGl5n~Cq=F%`)%t~R5{!b(a=sNsN@rr{ zxSukjB70zHc%XUq;YxKCA^q20YYe3!xX^7Q5iaVAT-sFrjRpU6yd_L#4y3yHL1`qu zEu^t?koU1HOuQ%=)PPpog-$P(!KIcyr7v%1Tb)-KSTSOq8L{c$Pj7DuKH{kFO6td- z+4!7E{%Re+gh$^zgABp=g59K*ASc)&D_`VO%pZH!OYin=2J@dF>^N#?g;*#@{bhjN zchUQqFQ^}hgDmsv#vj;^@A3)G?m1zpHB~-N8%%hb0B`d%oYa%wrBXx@7Bk}oH51t^ z@#G*-UK6Ainq|Y5R{_3aDZQICD(i;8g5V9GT59lEt0S)MFS$xBzgj}nC?m4gaykQ` zt5`!}CShHfpVxcEmIl9mIo!JgONmKXrtuikNiye1>e{(A!4 zwJinvt2$|$fD8(drwcr@9hW69X$7%Oj-BqaS#p*}CHyXW>qTNnQ!!OYe<(2W@U#735b z>s&%6cfovU0y;6);!5yu(xWjyZ_{ZjT#=Mh+ijV@5nX^xUhi2_aXg;L=G&&a?xUr_ zn>O0w&DX$y66<^>hd~+<+W15laUwYK)V=HJ03v5oe>uO%%sYMqvaE#C%a)%+8zvyz zWinHl>}L2rMyppwF)9h@bh~=P3R~(!)L3c+$WORZf&TRgt@`#%9P)2mJ#6BC-a}nM zdS`JERogL^7N%4Q;xfCj!A_X1eU;Ww`m6)Trr%1$1?Jnq6~GqcMi@XvDyeg<90xpl zkEg1PjRA)*j|h%ELjD@?T^b6tDynu1Sem0z{En?H*>D^dm!)v-5DzXfgEVT)GkQ;h zK<)urJM-b;jw@p`=jSklHFZ%uuTuydMmNJmwP{r%T*4!1223T69NrCcXl^$eN>85% z&xQvNd*-M}I&u;aZS=7@$!R^Gr#nHtMa2Z8w{6L-~aE8|Pqe%n_W+y-)3^0q+Nqm&tZmd|z8W zDspv`gKIJbb6~K1Vy1CifxC-G=B4-kGIZqd`v%DLg1iKPIyi6mQq)C?RP}e4(RTWR zK?!yr=6_Qa1`ss2#EJ+cmP8q>y=691qL|;))*fi+R*rc2elw7!U66oTLAx-!b+V9-Qb#I^Ki|>HXlbm&aTwpc2Lu-n*|?xN&sYxhwJJ@ej5=N081Qqv=;Z zrwxq(THT1!adQ(?E0(?kWp3U>WT=-^iZxXo;yp0h;xo3PYk<72ipcz{myJ`UCw=~x zFc#Yb-O`d;N?bTmm}khXST^GBeEl2c!a0 z{VG|!d)*B(&d1vM-zYp5v%rXjdjWa!vQ&T%Z~p5aL~$i?V=jlqW1Kzn!JlD?P1eTP zmw|ga!EtSwzP7_yz^il4sC~Y7){F65cR;(z5XJWP=dhqj6 zZ9X0oog>*%KS*Pr%$%|oUVYHG-iqLQD@69>@84BU6P)R=cM<%_RX_XnwF?`Q>DQPgU*BC zOQqp=cJrjaeSvM=xZESQpg=|prbR1f6ec{H!Jx_=g{Aj@z%=lyB zD%Yll_^=j+s7L{#}aUUiAfM9`^M4+lxm2xYQ{+X&E_1L1UZeNytps;-RB0waGW9#CM#npa9=H8gwf3l&_f{jE>Cb+j#{mA;#(%##e|oUU!N`?u?3bdxAd;b zJ=8j#??FV_-n>3j$iI{%!CN%R4CC=dO*6e{=s3#tQ%aN|C+-RWY;WVmK=q<#uyWZz z-uBoT@25uVuDhX#AOnNhS@vq1@$1d4x9|H9TH!~jpwu*O~+a^bKH-CKVK zPJE%QZ3Z@4sMbhY75B|X;7UE!45(O^t33E1>|C>?CRI3!U85lLr(#<~#nX@1-{PCG z*+@_p&l9*U4v6}ps2144shNGpks3y(J}&K+8K95W;I0GNgf%3*vV!Z8UyogL{nn&N z3_rfgr=fHjR#|%7!N(%0opz}LwO`EGUb37FTg zrkDW41=@-*zO+aWMWNK7Ge=0ebj`&NezT)D>n8FYjo?Cbdr~(V(@G^v`vUJQh~tK9uB2kk^QnZJMzxWtke^2} zWcVgyUMi);!leZ&=iuG|yR$O;oePO$Dpv9fPE{U81v2n8BZzxyt9!au1X7Bw6xG>T#plQ} z8v#eurd_xWwraB~V6DMrv@NnL;VFw#y2d>m-_yj^)P>Q-$!~^KjL9!RFtp+|x&Q?R zGtSKqg4&DJz_RHxo6d6J>l8ZW1s{;JOT6}w-wmcYP)SjI?{`G_1XxcoWUww2KxMBJY8Zv#DOav9Z$*kJ8F5J+!0a#;~O zf0FjTW^-@3x(E7=zgil^8#zFBsp___le2TEK(GgiHtmCfj}Q4pJ!;pM&F+8Q2M@{4 zwJ_=k$+4Rb8A8oObdCldT5a3AKmB?W?&ejV#f{*m#PaFBC&Zj##i~8COhQgqJ79fb zd-MP}idSk>$L@3Sy$t{u#A*f!#2zt&0BjOT5%exqMD1+Ro&iu9?+Sj zi`ZS$dMT#)*&1!#K5Bt>Iq>UBhG?_iOB7#f+l&_$w6lU==^(3Nt+y+&+ikt?SymxT zV3c3=j=!~Y-w;3}>?&N%9%q_gF+!J43oK4JU4WR%j92JBAluK3xwPXGH>)}3!lee% zAD@+9ge+r*G+u6MsFe+;%L}yISsyZIF65R3anvDQC*?13zO%JH%mJxW9sH#S#HKSV zhEpqs_lQlmchx1pPJ_VK*Te%adN}jU2rltJrB_p1P}25nVHa3McA*#yq_ z?Xk$u#|bv8ptpH_9;e7L!ZjK!IG##sx%>QNEG;yB6+5U)?LU3!vALt;?)7tj_VpIE z1(~M7j{QEqKiT8Zefab4Zq8ZOgLw@#RV!tMTE~>;rXgWneIvos9p16(g>5#Z%*PPh z)NzVQkFBOB*(IIVj%{C2bFv`Z`$n4IOA|(qDx55dt>`;do0$zbtgVffBvm3;;!i5! z4nM)jGvRZ1HQOLLQ595S0oOOGY9WODp%b=JIkZSrkW|-2_WO^^B1-?Hef0g%$RL!! z8YAOCLiXK5HD@@F88_r?zo*wxTQkrznUEFs&Ke0;UnN~&ky~B#(WpPG1sN-0L%DBU z)~sCbf?G6v5$tLO8olo51c7rT@k@P5=ksI(+u7X!PZ*++!ELjs<<}p4iAst&9h~Vz zQub0*Y3C-9Xr3dqbMqI9(I#~>4JmNc1uP-D+rjY`=V^xR3#|1ZIkfwV)*)*y2fyf$U5Ig<84%sQrS+uR3p(f0#3`!zMR>Y7Uq2teS90yM(dDlXvTaZ zr%(BszV#80=ucn&RyX<{-}>{t%A04m5xkW4l{o=BklpQx@giy(Cu@^kOKs_3t1+sB zK4Y)*`@|3Q&ZH*;Bh7soZcKe<+pLTBaf+dn_|vA8A~&#{>}rpS?{9YR_N42K8>)_A zUAsS+ZjpvYU5Uyt+>jgwrzL{4@O$a+1-$3q$H&znR6Obix8DE!W)mZJGx<|H`4VzK z?QP+Ium=l`k&>6cyPy-3N|H8n&7$6Hh#Q)xh&`*Q=-tmPz4HB!NN|WOrXviYAbTCn zZZLaz8t(b0zLv}6kFigME?{_?!mlV#lTi?xKBwDGPcxBBPv-CiiM10BwwE1l8Ntpf zv=Q;9W~ZhuFzZ`CqZ}TP*agA}8iSDvixYodk>k2fc&%-Qm|7uUgb%gJhNJo#54+8h z1vD{t5$kvze_2(n@K%Z$9(}J{kp%!$h^og5&x)hE@3D}zNg;Kq%D?> zgYwV2`z4x{v?Al%+@Ex{c|nL5(F1l<=I3la$yMnW6uP&(9#z0xGF+~H(LEwj3-0lP z;njV7iUWf3w!^w>F0ABHP?4c&Ga0b8q9Pn{%&H9Hc7dl)C5OWjZ_LrHG|7LkEBtp6 zd$zaPvKf5chzA_=YH9v<7wiv%-TN_}TCb>_1YONfS8m1|AI0JNsgVQ;Lg zk-FFQM)snZ7uZg=@9zRhcjD%1nw#| zg4X^;KcI1P7cLTQkiz=IP?X^${7KsuDs65FBKTtTE%Sp9&pTTf1GSXtW=zbilH|0xefmj62l@4;Xr|C$*0A$3bGekEwg5ICK+YyC zf*9<@@GkLa;eEA?LX~l`88wj9JTf3uGh57RuT*y zu*ZuoA65M%)8T)8U%h)|uBWqihAgIMUw<|aL7)@*d^d){_NR`!HdPZFUx{kJH%R^8 zkhfAb_8Qa`JN5Zv;M)e+AB_Cc))BJ8&T~aYN?QpaQ#l^j8&$)_z~lTXA+jzCITB^2 zqQbVV0}{I?J7nqc9pW{=1@_u*Wt0Je#6v+Xz{aPS@KccW;a^bZv8x5yw%5TG+zW|? zk=aVrT;^srwT`0OGgja@$sa)z+TYiXY4UnTpUK|>he+CH`%_(hXUUTcl=daIXBgWk za%Y- zOX2WWv(5Z6%U6TPFxBxmu-#9gDG=$z=N{`i^8y)ruESj;ARiaQd^uiu?>&-2q)oM- zkL71ZxS&G-Nvxc)7*w;Zz0zpPU-i+p^Wx4(3!Z3Z=!uMb~dOC0xnp3gLNB7nZfD>r)Gf`5Cwzt4oFOU;$~yF!wfeW zfBf3k)B|Hg|EE_bs_zu<120Z<1vb*M_B}!1sbs)6@ySn+_0-K;jc)DjwX4$9a^5u|=VnUc7iNL41xk#HQyB*P^r$f-M+YUe3P|}YDQMYQSAnHrZwyEi zeo}Ru5 z$VD2kxArbPHU@iquP;gG#c5iJb$oFFX|ZRO8R4xz|7HgdN%R&jvqst@O&v4WFT-e4%lA>Qw{+v4qb~7^eeb!+uq1O)7Y6!(HFhTa_ zh&%@~q+z7aslIAteh#==2SQ1EwkPC+0@EIOb8=*J1 zhJh1PbHxEb&X^MqOG~yQ9p7J^Vy(@Lvzd60;8Nku;OV@_ufVp@(~n;@HFT9aWTn&T zBjRLn9+NJBRNd3rNtHp6FT48`9M)KBw}a3H|^Zhe12N&2KbMzx?QU(T!U*K>>mL7$y&O*J?L#lo>SGNZL? zZE)}DyyPs4COBX`aWYgju=lm&Ko2bwm@39W1akXvJuWg_vnHjbwp;FZ>uz>iLL zBW$Z=)84x#^b|Tim$|-Fc=Op*BU`S5C@Y(A&(`Z7IpM>@ZVO5FY<0+jZ#y~5O#!09 zTbI@ghfEr!uNGP;z%UytWn&z#;60ITkF4)p9@%j=@(CBMnL;{_^s>Q?+L2{8Qmp$W z)|oSUR_<17u?)tzqeH?DZF2~?eqSSDTGDL;-FG^$RRv|94n>||g^w9Ft}W7UeXgKL zA23&c^2ILoFdfvcfl(^HtaaZ%cdLFgiprM(Rgr6qg~6TJN0wpn{Nyq z7~haw{vj%SlnZyqXj2{!wzMoh^H6HfL`j6KS`1YlUyF_C@9(I3Sh4A9v(Mz7-2r4IBW=mX^rWY5qQvmd>Rt$?he>O6JCo>1`)3K8iM**orf?>gwNb<| z>Cf?_`V(F4gOvvD=nQG;zOA(r%u4U=UC+g^{KIDPOBC5}`Q^m!=u}UqXnXAkpf{v& z_ufn=a?bTf{ccroq_7%uHm(dgMp8y9eByW&_74K^eG?pe>AyJVi88N3)%x4jyGW74 z2J$l9oi7b~Mciwa`>Jz3Yr?xaqRj{|rDrti?R!W0o|BX(a|7Muq1Ho%6({RGUvv)` zSy$FzZOvtRJIzujM^*5H-B^^zTE*O3uM~-0USSQpU)5qr{QYFS+Nz!9P_@oN3yZn2 zO+P$5jtDNNjrx)kzO|fp>!O{3JAZPaOLH|bp6H`^s2BG((yPND3lW}ejOJ9CU%K(4 zl*`+cU}vUqI*T|7w#Zg`T*tP3=#+@iE@aF>B`}bx7f0S#xKfSl8K2pdC8vLfsD+2zH|r$!p>T%)FOT;I82Akh!)j3d2lJy2R}?7m2w{ zDn5rd<#t`YCLH#a3L@Lf5emYvqwpn?afgMU0gW-+L_x52E(27JIhgkDM(VuU(UY2aIW7X0+9~Pw!I4M;xwE z*1WPdcHBGJ9}!)$n8SOtR_)p>5fZX=LTG`?e^V2EE;BYs!u+@@@3b9H*D1q)Z-|yU|jHui& zsMGYaO3sHlL@UIF4pnEV*SU52vSB8w6y%s!EPNlw$X9}TX4OY*`FRJ8aAH~IhVacj z?}JEa{NBVN!L?)5_FUb5o3{b-;2Bbu?zHgc9%1r&A6pa-pOKo zu+w||xD9$cg=HqwFD>)Zr`V-M(C7|6YEUKX5cL<5QjB9EhNY9c#OpitWA7F#O9%e}samo;vf zGiB7yxp3A+%}YPD9&PTrMDm3>G2JpDg)Yh6naE&=dbEeo-*1j!YzLVc)8{pNqIDFq zP?sRIdw4Twt)f`}M=W&$s-f;*#Wfc~+rP)t%$a!XnnQHaUlj9dP*aNC>=SfV`WD#5Ot- zunR+DV|(@fkH+!sDU@eg0%wQL8+WZGSqB7{&HUD196eAa)0+yBxK6Ex4|-3}k9|%62j$gx9K$G0mJA@^ywg z<@=oSa?IrH&mAk7dG`BTSIZ~6(JvQ98Z&%IV0vzg9Sa$Aw>;GQBbD#VFj;?cIl#q3 zxI3KyChEQkie}U_Y&N50*m6a{SBYdhG7t7RTjt=4vu?OCbtPs40iC%r>afX~7}=ae z{@HG+nqdCfM3kpdlzcmV9l$2pesi8MDRg`Q)4z*=v6k#KW4Fd-$-j59954MMMGh8i zZ1+lcCVZ$+R%oZEoF);64&cOGy;JeCR_Cgit$WA&SceCoPHT2$X&Lzl+_bY{;2qVx zbJwl6uk70c!#7VS8K9)tzoab@+Dduv-#luiLt>w3c&I&+9I! zQwGB`HyCDCt&zfQeaE+U-4IjlaTI?tyxv5LhUabOAnLIo!O*As_l^c%Iy3^ zK2Ld|*9+98Vs`>7Oq<*BY7ZKC`zhUFjbB`L(hYt9=Z8vN+{(Vc1xomNC0iiPm% zFtTDnI<6BV8xp}tD=c4asbl2yP$YBq86^X<_`Xp@dL6tzBX57=3%Mu^^r#|CDT&nN zcf+J=#stSIj`yX&9Yk-;awQVymRnB2M0PSUqyUQ;!>Bed7t9`hNPL3VK-W8)5K_~@ zZyi+NreqdyUGL}6C}_Ove0{!=&0&uNtx8+$%e!q=>$MG&)ium&_I-iP>g}J%F5_(z z=}UGcw0&`BF?MD63J5E!+))X7lT5!b3%DK5{5ZPJ~6gikQ?yY5Jg34Yu{%6#0@SD=DnRD zze`uURk~EDHTg0s>N2mMZpk`nlIKE<)wuiOhqh=ZP@CyEF$$`2)CAYoAT?G;`Jpg= zf8M98%PSu@As6BmRUJEhy^g-5bMiWmmzG&rJ2B^MIIRB&uoall+47Ts%89OuR*+u) z@q5?9a-CWMe&VlC4X>Zr6@9#sy!SgGy%P_s9bDp(YbP=ky7fjsax5C!D~)yTpcCA` z_iYP+>wJ9#dVz~UZJEd?!PSH_d<(xuJ{6FQbr%*Hdm#uO(>8sD%%L1Fj816y~4vC$U&HYebMyMGM13=6z{b@&Ro z-4RygH8g#g>50UFO}RY>(r`lcxl|XYp?pP$c0i<<4%OQDlXSerD;?;u z-eE6I_QtPkI=#;4`+ECV#!9c|{NYs*z}PlqeB_sZC_s^6!}ef|#wy$Qw%P-CSB8r6 z=Wh38BvlAHZ~3geV>Y%}Drn1?NxKBUR{O1VS=oifHFe>BEGafPK%-*scP<)@uw?M5 z3^3;?h+3PCiH3jic|@AQKsrb7(6%DDd)vOv>pcwfbU+0Ab9b%Q7GeRcii~U7b|#+gK4O8 z_a(;8YNcB5ep!vV2K({xL3CP@al?aF>9@nfoHv)FmC3T=Vk5dk284E=HBzls)LN~5 z=lv&Sn#%}9W<-&Mb!O}aJ9P@>8Ei3tSju~F*NVa}@gM)do-DEL2tT{F__G3eBHgvo z3~Os6%toH@3Rp#idAScI*!_wx+c_*k?sc<`T=kG?^qUCCu8Z@kM5kN$av2=eo76wx zgtm|^64qIgcYhm8fO_^N$l(d1zALL-@N(j5ipyxx$Tnuu_b zrc>xvi+DobhzWHOv0JhI$*KA#M$gL`fB$S)O5VbyM$Z+tv)zj)H0K|HR2897Hd8`FpATQAp6c9eY3 z#@M|4@*t5g?!YE#)b8P4zj6&adR3xB9;{`$-fGe;JbXvBhv7YO`i|P#23rXy5k9V% zr)6F}NHhv8s~oZoV)JLqH}7P$9)7zbwqD-{#m(NkTdLo2gomw1;q4G{R@nzaT{52q zrLiuv97WRCl!+6pW{ej&2s|6rG5 zU2+3`X_PiYh5Px($5FKn%Y1ha`^M`yCN{3`qH*VgE@eQ6Ic#N?KQ~@zK75rrUA}3X zQ3Y0OoJqG~#nyf+xw(x#x=PZ)@NZaPCdB_Of87I6@NOs<0HQM}rk!=k;-oOV2vO^> zr_$*O{MK=!$*O{==VqqK$>JJxfqSBSCrX@&0@H);S&GqdK_zDjyBx%4lv$08^jQdF z7n`LMD??s;(e;Gsr=#5oIocRjzr8))zYE3)lhb9ZcJ(MLEmSyK&qavWI839*g=(zY z4HVG4jd1@(t`Acmiw4D#E${b0H=KMxV%a*p_2U8&OCq+v}?BY)?kp77t^Hmo@ zXTbLc*t~Y>u3=hGwO~zQ(7DnfLIw6wHa?6b-T!Y0Y| z#6~uHc#^D4c%GGlB%R|2JF%TF+>6tAbp?yuJur9^f-8+mbm*{j1uo`!nq*yGxIE^g zFyLxI=T$whFuc#yDiEBw%;!8+x_g`daROL%VG$a84p5>Sv)u}EzIyfn8W@bxh)eFf^82oi`F;2?;OGRH;xSN5cWqOt%<_c6^=2n zj^@s-(VW+Z^;VED*B?1qh!OC9;mwH^JkQDIwl5UN9&F;C*foQm?zXL{13L7e2fv?R zddbb>t;+l2MnsaH-I~=}VkN-;r3b`Q3riA>eybLgw$WHS04g}(r>e*lBJBauz{#8q z>sN$Ql$&g+<lpHZC>%UtND z#eKY*y%KE67l*g4toVVyBm}Njm;k4HN>DeAasL=`75S|JY&c{eSi)f=unawwtqIY? ztxk*r!T8n}=ojy~A_{ z19nfcVYp6luxX-)EEMJ38IHjsc@H5&s3+w0J-C|xtB?#<3@%W(*HJy*@e&@d5s%_( zA42%x?JMif6@X!yToL;(aMKGnM(8L!xfkyNZtZ#|0KNbUeh|SWqL;Z5kfUQf!{lt4(|cktr4W)cEfWMA8CRJipA>9 z0z%n*KDhZlpy(5EIidXdI@&p8;a(9~iE3%>W=K~am1<{YsPxg&>he@se*a^xC6bUH zmXu7Q zkEhxP;Ar#Cl?aP;RnLj;QBe3P!DuZ^wASHye!dWTYQSFSw73a4okkC6=W{4IY;Ijt zXr~=9vQ~Z|t_o^*hK4j$57}V`n-L=cj8hp|(hg7sQOBC|0v_H7EL(XC74A1vZeuJ6 z>UJgYf~u^oSCvI|J8!Q{8ZlP)@(^4YtLp9unK~t z{Jn~ACy16ZrLBJSrj%mLoySQJy$|sx z2^dAJrB#$KJrR{|P&=z?%pM0&_Wh2|2__(ubMKorC}SObUhI=76FCx&4eZX_ zt*HMK^7tPqK*H`{gPsmsh?sI=%L=Z%@d^SzK0=NZv?t)7IKkgD==9LlgR-EISFirn ziAiKsa4csH^CF}71^h;T_c1++T?uf(=EMGj{Cj6H>glBZ*QbOpq5D@ZkkGo?uMOL8#= zfoHn=zE05S(Tcsw*A!;0oh}=T z4~*x#>A9xZJx&Sq<>2t}NR<_FwhIU358HVBDW~3oS_ax^0?g1GTCH5Gvg!hIm`_@3 zKShy`P1~nr&_FZ>d`yn(O38{auY4l5Ocz?>%NNMg|LxqF6J@h(+y>hSN^g^yzsZ%udXJYtgq}D*a zGYC8BOXtgeqD)sQW^9xNp^_!#wHC13d{!3ZU^4Ik}i%pI`(ES~#>_n%b`uukemeM3-uu(PA%2%r98d4CMZLE(q*2BJiU(mQId>87)0y>@R8#2l|<1vd0e9J2Z$XfRKRTta9J2AG`g>6Th49 zkMT6f$k=Ff-+7LGFYTEw?-V{Z@NbB!Kw%d-DN;typLYiFGHa5B91yaC>;C`Forxhh zDr9>cTbC}7BnWqa)>t>RVkXW-_pyuo!(@Aix1#JB0I8T7q8~K=71LFVW+&V_=Z)u? zjWK#U2T-JwQSmnDC(@?j6w!q<)rDXYDxi=cD|~c3Oj%q~Htzas+W@s8xdg=Qz52S~ z@%|35Ei!(fuG(NOj|!*ufUWa7JustCb)~N9 z^E`2?X2@YS*(Azo;dL1Ln!DnLC%?9Oi)f4T%-H7;TZj^baI#V_pW zKq+-twze$2AyVRVs!1B>nqrRkM(xYQB+ji9}IW(+q(m~!*NbSh4d6` zi2`m)(0l}++f;qh;j*8NXo(#vT}KV{_MM;g0V(GfA=bEC5W{zM`q&Xd3KlQf4VNO0#fX25E2-((}fsqjlod;}wpy1u-SLYZt90Q+M z_{6^2c(SqOwZm_>`5TOv*JeadPtEy9+d^MoA7^J0KMzHxW*F!WzuHyGPP5t&FwobV z7a%uc&*<<8>tT$GF2B=eDmeA5JGX&4T5~H-p(aoUHO#AXataGygX*DXQq8GSstcYS zbrWxwqi+K4)MsD;wiF=aZ-6aRj4yI7b+TANI=i((;*-roP*VmoU zW0$HqYL}q$$_pMxq#-6Sf3lp1^pPL%8yMd{)s)o#&lk7V?&7yRy{Xbs( zer~(Ix#$2$MMaCOhm9E0M04Krs9&Q@4ASGMbVacCI842ci+BOh=2)i>Z@5wo+D1@J1Sxd2H$=SNU1ldY!E z`Z&sItITSAW3ho{M9+p8$@gI+Y3W0O|L2zvl!&r%ZW#UZ-(E03>ijQKMHl%GK;gLq zD>iFm5xy3kzruaKfH7&{K%VUUotn*R!tYUjKLGzKt?|Lq8YA^3QtIXOv#2sG^eoxi zM7ZH<#+VK&q5gR1iySUH$@M%K_kx`ipc=t{aI6#w&n}O>L@(fpaqQ)W+)OtZc$RpBx=y=vE$;SzqfYp-76;^Hp#=Pp$o;hn7G#mB|j>&e6W z^K?fB2M3pAjuY#t_VKZlb8Cbi!+IA2>EQm$45u3XzY?wgZwi3_M*-jemx%ib+Ie}f z!0QMDiqeZ|YmW?5zW(a+!puzeuJl^u$nXh9cn|Nb@nqYR5*@?mp@abvD#Yn=Va#R z+nAgCm&bh>EHIGZh_wXG%q%lAGwcj&5J;gM@JO3K{Rx=fQkmM=KtYEO!-!aRgB7kJ z;^O1qo#=-Wd%D7aq(XOHV(SVJ}ML73?bVZ_qqxYqs6P6kQ-8Eq~xh3Wo7v~6@|66B0mG1 zl$DhM5{iuF^7H$9d%3u{rb{25^)x|7lXxq1Kpr79G&<_BKJnx0P2#YQj*cKwUJ5>2 zs>P=--qdm^h~3En<0~kz+uxiKbY5=Ke_q!OpJ4bCeAnAS+|$!jS63IB&%?_LCPEw0 zOa{#XWx?YmAF1VP^&yeS0ggpC2 z77h+uU&MVu7=O=+KjjG+akZ^T3@!NCFa1$yiy z!0oT~Jm}Adjt>umgJ;vt5e5Ysy#ztGFZuZX7o6s(aWs8bzH_-XngtkPoB3l%C|xug zR8LXy@q~4@T5eW;J{;X8QKa$$m@_a00I(YCvC0cB^0X2E>a+u^)2cQd8w-miP&{>a zWrWa5>Jo^5CK`fB!IdwF4kZPI5dU!ai!d=`gqD_;bU@gev0WJ=Glkw_~ zpE-p7(YxyPlH%e~hfZNE9S`K=m3d20dUAzHdMwC5Nv4mj?an3+nGSd4_)gCb3jCr` z08T3-Wj2G~CMSNpyBpmbqv96NVe248V+*P+wcXzuv| z`U|l|>R(1&Tp_x^xBKXxUwr@}-U17tBdJIChu1syXs;a7Xu7C>{N51Kc1AVW`EY5y^bE&<(9mo>kbxhB{{&md*1yR6&-Dxtu z=;)oDohT-CEOqEsITLZ-7F<^W`rVW7guG<;vD>!*)K+4y3aD+dzVcKbnYFcE?Qz`V ziN%01Vr6e{|6OQP1JA)OfVNCZ=myc<@bEA&t%>h%$YLV9hlVQbPz|}-WjlTK62)n!GCpTvDZUZfX2r;lVDTqN-Yt+NjlASzaCmlm?I%LLnSi z6b?Amd36+P^YeeccsT=&Xmv<4K590!ca6=U!a)Eo2F#nDo(>r5c-I57kO4f+w@V6d z;_ENj-X?7xyVRen%?sOE25_S2_Q{MLW0FCplW@EX=&Uu2u>pa0>5^tA50gE z``)%1{H8zGkq8tp#A-ZV>j|(6-)iSQ7|*T7HldMv{H!oTgwk$set!OVv6*tdAeo@E z<@B2jFk&zw{W@~Ui;^&%Ol5#cr@2Izo$bY$7-%i9wy?lD*Nv%X4fAGZX9t!XNK&9-`F*FE0ZauHG9Ue>|Le!QYvRnGi;5h8 zWnc}<9X0WkRvc)A_#ZHVJ4^<*Em z39;x^^My%11BL9Lv5AU*mx*C@N;}WVCxe^@dy6a>yQ|GI03#sYGcXEFbN~^8hmHdg z0{Zvi9s9PF8V{Z}W1F@BL` z){`D&`yM=`W`8!mrq*$~DGb~b;_T!UWa!Z~ZJVo6@Nn^7N4O0!GvuQhkQSh!Ue$!j zzc7C$1F(i>V8b@bNvaHmq*W)FsBqLZ1p$5?z>H2#PKxSwFKW}$E>PLKIoU=24WE*M z17>Fos`j+sIWyL;+4Nld5pG(Qj%E+TK33jgMhz+8blz_|%_SYl*pnHU+9<2;87jQ}JR+fS2#z_nv( z4t$aX`$;ga3E-D0^k=281A`hF8NH8bZ4%@?w+ZZGEzo+uM}(gu1T4w_0o_1VVl&RB zE17=PTk%oWM_T|#Fr!Dx=O1#U20c`&s;f)r{>*Pn;O7J|xUOh~C^oq4{X_E6y#PYC zj-%>-MSP4E@z|LI>Q%iACPUf6NBAtt&3|2F8|3Y#kCQb|S-?Sv;apfyEC6eoBj_Y_ zpT1O8B?zcb&YRK+JDB}=9&l`=LfEBQptaS&(Zq1lMo6ifLsXJ>IRBmnIDHNk96LLA zpxF&qp<$AAx%dZG7v>^QnIWQ;m>Yzs|1@vp-veG`#{T?{dGBLjO89S0N9bZsn}o)9 ze)<@@NkFy$010x}AXlhj)E9yKrMu^ceR%bT_zVGl zI!z{K)|j;n-0X1LHiH~Fp8WH%5v6z~5`qe19Fxe0NJtU470=2`olTO`F7K8F-0JA@q{`A8-Hb8r>uXh(Fs-i_i;s9qvg! z>`FBh3@rw}1NfI5`3sOM%-7TxpFIrgJJ-*tANgzxxGQbKcZKzeqkM`2{CT=b+usks|Fa&BoZB#Z`HAP;(Pa7E%GiS^i6tN`+Cw z6WEQb`GtiXv9dmVufROZFI@!Lv{80D@G}_c$4lpX8Sep2eul`!^RQ&2ED{oIezpr4 zp{}AKwyfE};b&*xwBQ2ErPE1!3#nswpyrZG#aEVi>*D$tkZyB{_Zve@%+{%Y_~pX1 z3c2`xISfcd3m*q@f4Swf4||Yzv=H)?_y$qX;+(D)f9=CXMn3hN@#-%te|~(;Zu)S7 zIzGYp9f(l0yo}LNos-55wTeQ~^>)Tno@S6i4q0mfNa9mVOKTz5=3rsLa|3^DC#CCS z0Z)nNTtvL!&(l;MLf+@>49vD8giWSV9-D8jO&Or5DbH<#3I>e%hO(v`Fmg4H-$pYt zLqyScwQTE+z8E5qTeZ8v9w0dwzc;wYQZ^>AX_u$t*w=LJ+!Zx30>gS66|@65Fo#Qz z1oQ3v6tAeq0FH#~xYJr4)nlf}*AQ=O5}R`C_tcMUYR00@`S$c{Bv-OMM%^Yu+z<`T z`%7^a`NWerb;qQUAkKdBX1^U4Dgs^Z(l+1-3&#IMUMMs}4G9tceMA zFA#27RfQrspeMwGT3FY&aY5Kl!Z0+R@b%+!sUv^TCK_||N5+yw~id^Cq*v1U8+$o$aUV=a&JvvUhX9l z=WxCF;_=%_8vMuae@FUXdRVN?{P{CAbC;S&m6h&%VQEQ}vxnx?%EZkMtBemypD>#* z>6LumQWtxxynl8h-8&lR;-chc4!Fzn(9T%CjLyb)`jKyFr^$X}?M_8U2^^NRBG9!h zT-V;rEKHqiF_71+wSrz9izvajn(h|6BoPx`vRw1dS2t`FOdLZy&YosuL#D{VQ4w`M z>EgRURuMYxWr3+V4vR7J!rL+#v_=fWy-{g2EUp9d-G$4wgtRq85UP%KCf~9NT@;<{ za$kmecfh%@O>Y7drK<>hlonBy=;f}||0S2;0YNGDjnEjhH0YHBW{Bjl*x9JHaIF7S zN`D?YeP#i~o-keMyyC9quEj*S08H22-Cb$%OKu6(R%CoUVFh1Z(BcKi6h1Dcz0MX` zMzfN0eGB@lWJv++z{eMItzik#i2j*KRw)J_XWQ!742%5u(EddnK}hIluS={Xx?0hD zht0gQW>v4x=Nv9CKs+(+qBU#=)2(2l=cx!^ zD1Y?|=rFFhD{=^<|o#PGSF)f6A$9#0yZ)sD?7+iU-Ew0MfvhivcA-yp})LX$74)+A z0$EwMlk7bo>kvSml$0xh%G>!X|-U)8}+FwYo*XkWbsAFhG7L zc4tBnM!GmHdAV!jiwjCV+TuEFnOsr61$jB%hpO#HzyF#1a|di%o;E5!>;S`hI_JG~ zwiIL(EW|#?-f!G%9^l?sjLhr-x-Zp!40)2!dX<+zq}Hh4a{O;LNCF(1{o|LKk>Rq? zO|!92OguK6M>H%pJ#{!bTHT;WF7R3d29B2emXcAZGFTmL&|@JHNfrJJJIMz?{qm`; z47ylhB#f3=44?y_(K)=925;Y~ypCJTRav|YOkkvf0$_JSU!AKQ?r5f2cY(0P;jhI@ z0bli}A^}+gd&}8VWmIfNQyg-ahMIH~4zw?*j@8Q8?$3?;wEg4o?ehF$_<#37Oq#O7 zQFo?aTU)5S2m^YtC;La6vc97J0U(u zuWfTGl(oer4pDQ`VDa;iaBgmP_QUSzV;5^+8Ck#tPMay%ZSa<-OVNH2!>SvHaB#nP z-B`e1<{EBbs}KP$Wq1~_a6a(Z0X^P-s!i6vF)6A31>X`Dd@qQ{IO1G^oboc#68o(I z-T@+LN`)(nbH=>`lmNNiF?rV9G`MqS^XcEfhCQ}BoY4Wu-w zemleps;L$J6Kmn_+Y8(P@bf!B?`fs~-RGQFFljv`E5Qj}asvB?5n!6pZX`VR8s{{xP=95DeHpG9c+7&4XD9U35=IyGzk%g1h&1Rb8Cev&aDyvp%`7PGH?;{ zyUOv;cYqXN?Gy3m4r6{E3&zYqYhtWno7Ocn(`A^>nqg(33+{mW23UX?kY68m&koy) z`!h3HA>NTvYtb7?NnQ_-rwqulQmoP^u6?lM>0+{5!;XD7ZgzR;!#9x$8AL?kxFecrtLL57Knk9w<3o(4p?e| z?B0n48b5ivQB}mQdwO-OO5(;<$E9ey<12H!BKZnOyjR6umUv1yD(tOi~l&);3N*jFkFg1J$mWXr==P?n~_Jv!a;1HkP3EMm>Ub zF;~uk>Wu<1-V;I1O2dtAngC^@!Q9bWhlS4Q9Ic9}a%9v9TUotCPFB`ohpvmn!+jSd zT)|817QrN1g`|P0voQPsI3$xWs{!4DX#j*6?89iYFZ2L#c zVXbCuSx@*KRZ~lc|H^2c3;fPy)e)EK3NO#{L|d+J+CU&%rP{+RC=FQ7YFU16;7!d2 z*{Y57b#|Tg-%=5ror_(+TSA0(P*jdnzIdL8`*V#vbtMd=-XO!e*}uT4cUa$PziF@K z@PJ%>l)zfndHfMHDGm=$$adhw-!rZ~J)*UR>F4CO^%zIEcBdbzJWqD6g88q-KKcMQ zqH>+uw^560fwXo35(ElK!YTF#04;e?^v|sVb@g1G0`nRFo$Jf}6xrH))0~s#;EU%* zGX&~UF*^Z=x<~KP=pjy^VbwL{7BYC3Bktzw2O*5N@eE9k+T$}=4hGUDm5+}v;R%B> zpa(92B6nqzgsEv7g`IPF5&~`df7{6V*W1#`$BmwZ2aKfW^$O-O^|-O#ge10f{gNoP zf$`$J%~}ymhW!*(40yKb8$#5T3){VEUszOFB(P%Bb~cmGMu3J)9rmvrZQaDgs06z0 zSH%33)2KW7E{-R<^NwfbvyNySncs9Lra$3la%;S+I=GjBy{uH z!~GuXSbo!{iH?04khH)yKD~_8N=10fMtOyLlGrbt*hfa-8h$T)s~yhv1*<-&uBz zL4-N0x|!wZI;yG~wfkNhE>_3h9U4p7(9+iQeInHvX~~5BCculT8Q#GAsfvu^bJB4>~^zAMfaz{`&R} zp|3CH^1)d*|6FjE%2DJ04%{Ev~_?d)cXQnb;btY zrNprvXuH1{1}5z_msgeY3n(UWty){d(ak=j5HNv8&lDAov8RRnfkXtbEum})*F9hv zai2WU>tQP+$T9UA-hMrIKp{1q!n=Uzz<3&2`mplbRb3l7@Y=q1APV^5IhV$L2BJS~ zn=XE6n>=B)vaLjyY-g2~tQ>#cW;0$SKKSF?*IH~FJq!#aT@yF9cN@1wM!z|WFPDOE z+_tB0+im^2k8s*hvo-lf z)M{UO?^)r&EP4s9IHgNuAtLlGd$AKRg2&E~Nr6vrmo^OtRW~pN(yBgfXQQ|pW?b{5 z_UgSfD6{LPA7;CkB73BIBLsZlS-!L5%!L?yF6SQ?K63-aJoelPba3Ad77k0v%Cg^T z5H0OW5j_Ls#5Bl3KDlv=goE#1a|rFtcT``86{FCOn`;AyFw3f(>W2$Ubm{;SdeEK4 zWI{y92&LDjy;0a2sipu&n1;#r>S9b1jDf5J;G}x5nA8S?3F76tJAnM={0r#6LF6+g zz+?A|uXJOuS!sBx>CwU?nNEj}U@J<2JpjRy#>M`8&D|QeEs`9TRYr1Q55u84)}Vt( zgI}5s)^*O^d$b)7<64f!TKeo_9x^&-1Ea#SE;IkwakvvFG&DjNZt~7$7LfHj8nMvt z+?TzhiMRSTt+Y!UYTptHSH1ijpv2iqXWfK+=9KP~B<0nAYDu&d8pjNL;dP0B8iVU- zE0)SM%B+dEUH%{T-ZLtyt!WpPdjrSxndOkT-qJ!`hh#0;Zp)P^3Z zMob91XB4Yc%Uf`je+{0ucTZfA?JlB4IXd5Pu-5O%l|imOG0qt&K8Wrz)gVDF*wLb7 z0XW4J8hZ277x3V*6miThWE;QJ^*S1sQrSGa0yx!iJs8I>ziOoi1e$(JE~&8-Go;Emk% zN|`srC*1v6M_0D-(vG?f98ji=9*g-pyf^wb?z}PVc|Pw(dfU&q+&5#N`!Vav=M*Of z-HGy&bzZ)BF&y&!5n(>>)UEw${7b=Gn&O13ja`+!hn9{sku( znv)wX=1KXT^`?4raIi*2B=RY0u|`+SqChE`$22|^)lo)8ae`eM>;^A!>QTEcn=In4 z<$}!AloOVaW76aGqI>4szQc>Y9Qzc(&JqjzP1$;QXa zmqh7%eBx6h{Sl6>2h2XYx>hXg@>#F!`uEQM^g|)<=q{QYny(h-6ML>^&~HmGP!-&S zh-+rxOp;34V}(svXh}NwN3b4`-zDyq2=1Pf#Dfi?WG#BfqBy}RZGsE4kF74RyhZuK z3b2zyG#eUMSgj^ev0VJT)*aJpF9TmJZjqJhAN!t|Wzz-f0|jcEM`AJ4+Vm=hogy^+ zGdDRcIDznxULbV3{)v=l?V+jwO`);Y$O{Cf)TUUD*1Ah+|KJ>1?>7g=Zh0H=iI89#;6>JBy!Z$3x7Ee-gqdX zJLcy+QSMpk=^q_0UY_4@{dY-2oZ-h#s^BaH`~q)(s~ttp zcB6i?^aD9AX9g%}B|pUJ&0kE}&#q*6p$2 zu7B_|ck!Anuov|7y>+#Bj5U)fi;1TaBPzgnl-ZESZY~cevIU3(Iz4D433U=aUpB2( zJ)WATnXl0j*g2Uo&OrHsJpW-5O&vg7&d9oSa)!xmsFEqs5EI-W`mH-cGWJiANmHGiOjq|}kkd0n4!Ql&s4 zrl81-%JN5&1KYNy3TQ*{YjD=`9cI1F6a@R^?GIjQG!riOX08Tow7tWmbfU8^u+!dL z3ptX)M({uVrzQcqnW8U}_!h+VC{j>T>fbi0cIqt!GrE`Jm_h1J$4H;}`G}fyyu#gi zGOvY`>+DHJ9BduW4+OM0IK=Y=nVxnWQs&mO`oIKYcYC-{{5m9g!D+pIsBOs6>qgmq zQE)pfKH_=es%3wiw~bp5gk zQ3Q09wTXz!4NWrEsd_OSkwh~F_N~n&?{%)sglk%5!CRl@%&;HNFj;Q^I};l@H`f1# z&t;a>n-^{=0rjn3IjdJ>D|*82IxesKVI8MqN548~3I492RH9xl!PC!Y6I%E#aV4BD zP&#v{5b~lLD}SDvFwFJRWz3!;uAQ(j?fQuK1*<3T9<#$cI%-;OU|GlPFbFhGZ+M~& zh~10f_(qM*rSYiCh!YP1jEm}rK;+-AeL@34FphTT=US>rRs*UDp-?kYe>y4KUV@LL zHGU27F+xN2kf6b8U70+)t{bL5V;hhsWp>gFG`_&?Q@cR=mcj2#StekP{ST<9*2n7P zCwpBG1ZW5^2K}e>Am%ccy)!qU?*28{gH5mKqwGY4jaggf?Gb&YHL(FfFU1!~H(g?i zySeRa^?_nd=?wB@lP9_^$8!d)7>*D7vdzD(RpKo!1~?acN~ByHVj?*;XUN}%6RfAC{3(FtcprrVd#iSjc6h5BPFqQa@QZDg7UpmO(F*ov&8 zd0Ss&l7y8bPwqwzF)u#-tKijb-HcG_1o|v~$H@|$Us3UT_v_Ifgfhqc%f;3Lw;UU* zs}!oS>9e18g*z8m8FEJ;*qlKQy}xlIu{|}v{V-Y6K%*9wSjK{@c68g4FuBq0J_1u{_08+(VP#f7s9(2A&*ka*I}fdV+#m`Z+FF$CpIipiOAx%l8i@WB!G zZ`zJdyxrW{I=~zci8{Sylk2$0z!y{#0@7xJ)ww*s}fJ zi|aja|4|=X*&~}r2mMH-6P@(B?rEFW&t1VBVZqT~776W8F~Kd=Iu{{6*;vS$XX-6y z<0B3ncxl#onI{mX8{9UpKUoVApyLKN-3(KbIx>_bUA;tKr4ypG_TLDILdvk}N{|_V zz!N|WwfcTr7ebD22?Cq9QCv)^aXp1>VC^Lm@n;#_6HNlSMu#hV9>nao`5<67v}svu zw|-~2GSLo1o#g33RCla~orCk_6Zrye9SB>B-7&BFrD{KYh>4X>_)G*k(+d$^Ya(5O zyGa~Mxgu@KSlkkvXg;PaqnP2mRIIC>y6t#I&pE>DWjr~3;~JzqkdK{$Lxn6IgV%DF zQ5z>hFuL8TYM}duP|#yIT0?kzMizmZ3js%zm`M zW{^Lg)kWp!jznnpulE=u;GTHvykZ@>p>7RQbs|?Lp{X5>j5rNfqn+T7~0* zzu!Vcv#M;94`B41^q)G)*MjHr;9+Z zzws<<_a8TWJ=~kS5RiG?wf)8NXxj=POF$6nYtZ@5o^-WI)>e1Xq3sSP1a-IZ%O3oy zR{5s$AQRKmnE~E{wqI$M=-?WXSA=%d+wPtIlk&U+JMQP|Fv>m$vl9(Vplo7(jxEqo z-pz_n98ATH2Y#DC>jiRXEr73J{F4RuUb~kvduzGkql%Pw`5Sc)u00Vd#f<1GFZZ;q05FqmmUKTl$asPn&uy-I zZoy8z!Vc^-GWg&lxcqDB-HEtIVpT3Dm@%dd4VuPHVb$rf&%k=4Z+g)%cYZ!kdF?$zgWvbIB z(JDS^smfn$k|ZvQH*M8eoQRc*@|ds}(BnXnhtbxl#nq>b<@|W>QEg(;RJl0pjgg1) zx8U$X5z+k-&Qb73VtT{%7FGW5HtLv&wdVrRi?w{ty6EakQG>#FwfyWnalEFt^@_ko z3Lxy5iballmWcY^hFNCDq@5w{H8mlpUZYoM#g+ha9wqKtY2 z+U(@V_%@u~XEpD4^~wPdlCxjoy*AxnX7h6{T0@2ZzzMroz&Pvs@zFQnYi11O*6bZJ z#8Dovc5?q;jJMNEL4?}uA5|_uA}+l|atjbwE0}yUN+jiOKf6Pno(C$C$(QWfE|WK_ zPycWMfoi3lzXrLvUe+mdq94sG%??0R`Uze^#^^1`sH@iKVo8XP1aq&plId|cxx)2 z4!qq~L1T3|b%A7`2mHwjv7+10E2aKaH>cP&$UtoMcy~REDkkbx)I*R0p7_f?=$fq# zFvHWPZoZXP(fm5Bh3fd9L0(OOKoutZNv;k8RGpZL^=d%~Za$&62KMC$q)cdLZcR{> zjH0N7`&O&dCf&_2(n@~bT~z`a@4DF&l=F48PWG%Wh&n6TXi4hn^#F~yaN)fA%ISQX z@`?)jHwB*St6>k0=hM$f9(>vUQtW9BB+bCsBUH+Cx>JYI+E{C_x+GtGHei@uS$hs) zRUJ8q_1az}f#)N9PVNEl&k`ogRYw0!NE+&8pVXmW=1Z)N)2}{0>jyiFT*#w(F`J;5 z^WjE9_?xHZncxYO5OE1f<$x(K=Y~j<@M^6s7-$Tsj-+V=mGKaz*m0Bpk zu(A|8xyUrzF|Ty?gSBQ2~%zunvZ5TPll3N z*Ko7v@-q_b9F$K(5w~sn3kVvT6LBkUekny3zwxgF);)mSW#{@BMDRGE=|u>9^aRju zK0iK+&)vvs;`!t7N>Czp;VYi)cQ!+EVzJwS(uvTQ@n!B@xyI$HL;A8gSIDOT&@O^W zA8ECMn=e-?$;>7wElm}*-2rpeD{4F5`a2zxh6Se6CXj&8ysC2fkRU!y%d*^LS)#glm=O-2 zwlFQWrKQ>Q57S|BmVW;GFny0cl+Z>D8l!73V$)bl{#lAA#vI~em10>MF5YVlkRhC& z%`DhC$>^goc#BV|6?Z~34Y@OoWghPI(Yf#L{J70F$jRi;#lCURc5{5VFq?}DhA`BT zYM>+vC2BB&Urz~l=z-zGxFuD{IO~k!GmGipT(`3LXM%Af>&r=gaBze7%(*p#FStyr z+|1I;C~Nb8Jb=O1g2On>*$R^~Px+k*yXP~3XwY&puJlVSXl*0M}&S3a|)5*$W6 z5I!{v2)p!v6EfJ=%^M^9>&0zV5J>?UEz8S8TUgtyFG=+ejhW44bDu3|%3Gh%PUdX;l6Yv(H4ynEtL&40lwJmw7g@!prTG@%DbeN1mJGsHzHh-ID?6pCtN zQ#QaR^Rc&uv^zdkF}wl$ycw0z8w{Z&K7n>fu*>=$(3iP`y<}cX^j=*7mqPNP45U#n zc&!hE&ajCFYHO*o97BC<<{P&eoJ#{qYFlR=PhEe6W#ri`4nW?d;EqfxmxSD75whGR z;7-3ev1NN7uoWPbnK+N5Z$wL^@oBiJTDolm)zkn-nA(D0ULjtlkU1xUlQZ+h&-FBh zSD(;b{`}$G1w||bPUet8S#FJvi8&SJGg%-93O_iZZkDSD){$>v(f{#@g4g&@2=^th zBduhyqj@-s=NOQ|ghP>v|L2bvU=WZMW@v-oNzp4ZQR4I=P$gC}7KzQllV(&pnDIk` zcan{V=qr8fC1|apxu0-B&tf2QiEER}D($@xqyYZOAUlBLXw+n-A<#3`N{i{4_a5i^ z9k|RAqti6jtXBWZ@EH#u(&qG`Fwx2cO7z#tBczcL8+nJy;$bHvAt^W&fCd(-Xt@?4 zhAhONEzTM2q3DMVCOCyp&jS+c;C|Uqf&bXf!G$X4_2$FS!XHmWfW}S0=?mnBqQYOi z#e*}7cd$fxQwNCtb!-BxKSS~H-Btzu89!1KJ$<6)8*zv;0QB;wgSq{WWwX*Zh9 zUUSEoj|9pOVlhA!yZeUNvhS5=g9H|d8zX6~t3g4s(eh?B{#@_YYLUzJ@7+D~`DpVp zmCG2gzNl6>Z_!zRTw_r|j~`?QtNA{K=0j4UEWH>>IW#o<(Sd&r>kdrZAa|!?USJZ^ z#=i_JD{AoB;9CBT+gw(VS~5U%gN*=Q65I7b{Y&jkGczP8XqjkP?OVLS^@1Nij=N)6 zo4^a3Oc58Y^>cM9pOY7{Ts7_6Y4=m4a)@-P0Ms$E>RYzBQE#c~4ew?s?fF|5|Al47XSECt0QuT*g`kFSP)42SdoRGDS7dFldY5&;=`1qicL zcO%FWpF4FdgN7f@^4fCVx>IQD6oObEXMtE7^?yB*iWEnzMLc?}Z1LZu?S_$IzH|l6 zO1JY4KGVv z{`Z@5-Jna=xeEr(FJ$5sbJDR`i^UP%)xHnYO5##B=$ziK-rg*$p17JPbuATUZdU8% zhIzwb2dTvJ)vd^yNxT9A%%)99p3psEMuaaYAMFrV_}3hcrs5UmqN#W(tFM=V!XuWB zD(<5w9O|Ayu%0bP;uG1cH1FY9Odm3=$Lw};PgBi{alsl#w~|Y+^VP^Dha^9MSu-1S zaOTiFXda#>%mr`f?ZZkQqRIJ|=7F1Z%H;ipsB3Gde~%lM`q{7fhC{7CLC7VFG2C@% z@2n99{VE6uD1;LE@@B02-V0ONWQw_;)sEnSP!W<}cp4Ny>E`tdP6_MTnV85alz=?A ziUo6M8GWe!8rIV}uVkzOG`U~kU7!dJazr>fX9wTWh!5G26|T)) zRd{Lfh~(W>k4+#B_#?}DSr&jZa0HM_58!LTpM=#*@oVXLfa7y#Qn-We+3;7Sr5jw* zb9}nPYY&0tK|Chx=@V=^Ns-aL5zpN@{Tbdaax>M2O1P=e{s-%XnLoOT#LDmxf)%Fx zc28v@A!v4b?-=o#$7cUEAyssB7Mz+qlsgBRTuK(zxf(P4Ip^#vv1+_yonfL+QxKlkxF6ho_Q%bVmOX@fnaT(PoR+4=Z`MU=-@nJD#GE zs$&mv1Td_V&W!riS05|vlnc96-h#R+_;Kqr>CNPO;a~$k@91m+(yF~}m><{NgT{Hr z;Pn9iBmNW|7!)<}v|BUff>@eb<{+q&qQw*!qj@t8G4dv9CeaK#Rik}}Ama`~bzoV^ z);4;#_)PK9Tpmyq(Jz|q9&Z%R})NcHC3@C!WSV%Jq_}ipu4;bEL{&*_L5x;JL06A z$YD988B@7i-uG@Rnjo8E~N(=m6iV~!|zPdM!i-{G{? zLm|}*5-dwFE~FO}U&=j`ef|w9?3&N-j7qcJX(2Usk9g?$vF2#5o{sn4zQWe4d}pt? zq9OZaz1TEP+>7ojUDj`IZi&d=YHtEHfHYezbwaMMuK-~5zI?ff|uVK zJH9zg*gZBOo38nVF^@cbFXzHIZM=f&>;{t4BdmO%j=c53PZWNP&u;7OD<-~0s~Azu zZ|b`*OpI=|gB1`?Gi~kwxj!*EuY3oxdKC?xP&o^9FgjtU9*O$!ww`{OcsqFkvsm<8 zW}Y2NK^0l7M4(PJVz+M3_Bm8w0*F3XNBR_`Yt+s>mpL;uG9s4$x&qD~w09?T8sccs z<}=gQI3`FhkMO^~javjw`1kS& z1dc93t9pD)xj|*N`Oz_qzVsnu4Zgw`7q)Yu@v&_Q(13+jlHy{5h%L*yvLK(e0+p~q z?mN|-b^Y7(^4KiP#+d^UtZ=qKiD_(^^>A{b{oYe);Pn+yG@`*Vk1*mMB$AtaY(HZ- zZE$-_=3pI;TWU{HI$2lyHn`+tNh8A;+Dd;z z3*8XVL99uArDN^3Ov`_I6tjr#;Hk*@?N$DZOPb-wC+R)>_VqN)J!K+vi6+!;!93q1&E1M_Ba z!}Dv4le4w|t6ckjZ&})}<9Hia>k5WSZMTGrVJ~;^{nv3Q^aq_Hsf6^7JUBOF?*D+7 zCVYDw{Lfa-6sou0H#N6lmK>lc>XorpI}|fN+R}JY6UpuC2xzwTisX;~SM7v6y`pVl z-r2)EgRX6vzkjYE@3GaP3V)+!mee!Foe}W=GVuKWqaJi?COc34e=g5;lal&tdcTgp z9vsPN)or^-R+Be9a_&N7c{OqZrP6uL+2PbBo3`h?KJ9pHj^>Iu0b{_wQeB0&j{BPe! z(~yx@%lQ~&drm=m!i+$5;aCk{UTrzgVpZT&oJc{}Qflgr9&9BNk!LxJ9W#Ad{^$K+ zj0%%(Xa1rVjH0sEsc4m zYe273#%mR0gu)}OaAhUqjWJr39zvt+y*m-*4^CNm8DFoU=BQRq4;u?>OOzDS;~?wN zSkq~~x%$Fu!u*`;ipIHQkp{(Sxw9)VVKfv>8EQRW0JEG8>YnX+5wLF8F z(y{Teu^nkq`1!sa*V2N~8V5Qin8+|oVchSMQy8mi-U@o8e)~%-b+#SZ*}9!(FdyOD zW0&wUVcE>qD=tm;WGWj-SyucObl&+)YfJMZ_H^CeEcip)Ppto=4@_kD#*%MTXosnh zG0%A(=r=ZMPUx;4(R8<2(7NppZF_#%9dM*d5We{YG2|ry#~AUkol9^G#(GHb-#jzq zau0@#y?|G>P7Ug={<#{lwiUm59z;X@xfj=m*IK)h4wdR9o9IPuF4```%a zjf=SM%(ZDTq!st(rRJ9AlDC!RHJ3T9L_WNp98_eZ%U;MPBpYNrqr21JZfm18f59)I zn^F5zDlAk+I*yTk4O!gn9FPu=jFd@;kCo4OJy;)x^8V`b)SxWglvp(To78XWrBr@m z{tX*VGVV*N2!F$C4$)DAu*S1b&t}vozXql1*Q@SKpVi^|k~bYhku(ijEKlO3m^Ok= zlKQ+g#Q0c*T8TbM?!9GS3fVe-D2li| z%LmH*BFD6hFAa2DCVmZ*>C|wDGzwqVySrxFBM;YyBcd?*nsaK~ihXVK8H>F_UIq@N zS7y1CAeW*y(v--ar+)ipV6cy=*dr~D>Oij`R?sGRv;vr#PBo~sx_U4t{OZgQe{X_cTmI|yb{EDlsqW%7+Wn5 z=%q9-x6PDb+l2F>E-02$E*eV}B;mj>2H&mI!2@2d=@ z$SL+s(CSwM2`1n+k_?5ZWb2S1+SryjXCm03o^)RNdA{D%Ups7kd+i*8)!)|Bu6$tB zzWvMJE9eDSLfaf*#izk2LMQP*AmB?<1ud^$nZX3L^V>R18>xET4%>BFv>$18)Rmd; z=zjQ_txJ{*6!}JHsfa_X4Dva{xF^y4_zkG%D?AA0(_dX&CR@ny-x{m< z*TYcwl!n{J5?>VdyNdQFdA!BPgZ*K&njzn$7DT3ShnFEfPE~cFzJD&6P{=DRRB*b@ z07P~plaFDW&TlV*12eDk9KJsd%TkOTg-xZMG?Z2(1tEkA))`6}3M3}28 zVBRL1%{~*6X_h8nDJREqjFJs@%TOc8V&sw;%U*|p*@ZKcvD?Ov(Qe<}TEUhK9!%WCqGuyV=%FBmYy__v!M!j}Km zEuYG)KK(o=GSQq*gty0fA3CwH(ULoe(TH{kRh9zuyBO$?=*~`Q8gzip_or8^#cKwV zpO>+~$P^b}`EW8omaeNL%fdalnRc54CZ zT(c|1P7cqb!(~j}*`#C17|4`yyq^wt8i{X)%%pEF4U(h}J6GJDBsbYb5V)0a%DIHE zEqmIl8<9TSb_xEcJ#C|nE_lAV=K{+_Kzg=}osVuy$N>y{ZdNpQSw5hbA=g-TGpf^U zN=G)mK6NDZv~vJ$w`QHuNlP^}Ps7z5Q>2ou-iBSg6O%yMo1`!bhfQpYuC8B3_1(JN zHW=`Hx#WoCiM)ylb%#T=;$i9Y`I+h3LzP6A&21iVTPWX7k4UDo5m@kHIwfAi8~IJr zDRIqowkO_IhSlG6^RdD-w~eV$C#lZMFsd&73S}a-m-oMKMany-rN7}8biM$2Jzw$3 z=|kN)K~|=y9zup5G+pdqXZdVNn%7Z64*vFjt|PtW&m;f7aWKAmHh-bx)9RJ9yktb6 zwe+k~JMX=F_iAPubFh6I@)_~#&CX}kT%Hze=6*6=@TrKgPV!im@`IL?S(622N6cnT zjS{CQJsyQWiu%Y>;uo3v7had*C9Etq^R+w7VD;xGA)~V_##a0%>zD)m^<`o0b^KVY zPIMe4O9;FaBR_DImiTF9VL42{%fQzZK&v!XE;Fety-zYrrKjuR?aCz1D--)$DNtcC zyv+0*S}El6_%#nvA4{KIy@}Pus1A6`rRTdTB))cAK+I1MWs)?AZ2sH-36~(v%EgQ= zEoI8YgawuP&M>=vdd5B>M8YtQkA$~>`c47{lPI$>kn`P+GlCagI?Ym}QJ1NxnXiRO zlCf%4rc>LnY>T07g@T*xZ8BzI@qVsWc@ulWr+jU6Fxv&>pmwjTp3Wxu@Tz>1opfz^ z)t}D=dAj|W1GQ{Vg_hSZXq>pd@g^yQt)O!*z1~&#`2lw-CTkj9PFfpZ z23-zRc>Q0Bm;b7_{+!#OcC_w%89Q5AHWpOcl|Ks3WuI53-?p(wXXt5<{V|<2U6^O0 z{0h52Am2*X)73PgFyWLoIoL}?_Utq+9WF=f(X!|2F4LwlUDy~T3y`a}2oI1L`g^~b z{=ia^o%d%KL95swQP9gH0snrho6BZnw6~;K}9uUYV{_XNx67Pke~) zyeyYH8llUY)l+x!Xjwu0Du$k+s|}V%h9kTL%3(#CrDUayw~`4NCQ7YBAAZ-?Fhip5CzRGrsL#efWm+5%K-ZFQbZWAoz@#%qIWH47N4<4Zcdc?>_=E$o zvuV2zA;rQ=4|XiPVrFi0(^+_UiZ2g7Iqr?uZFmq{Cq{RP0s@brBGG`Xqz^}yWN%Uib#uD4wD({3Q!rGtD?r2L-veDubW9v2VC^f@K2DGV_`>PQ|8I;y<- zXw%gdN7PhV^(Qk%RUxdflh8?sw3PT!0@F=&#f;&~%RJ_L%x^Z{%y$xAt}8&G_2S)z z@z$#O^tBc5`qx&r&3RWb>y4#^+LuU!))`(9SPYQe{gVNL54KD*Daz`X@E8C5EB6Uc3zDFO0SYp8nej46CZEKJ_z)B0kFu z1M&WdVwhcSeO#Bcb_E_h8>=Se66S)tqtGssHz;0IvkO+HKeD=>ksn7svwnsSo;DHQ zzg~of`K58WWrO<(P*-X#!bB^_faEZfY@eolQ8KtN{lV*({B#xlR8&lNQW2mHbuR06 z3jnOT(QzHvdJSehX6Ad~Nya*(%&ac44shu#s(7Sw!h!IXd15l&J^)9vm@Z6$ zDoSOWO?F11+clQ;(nkHO)Z~}(N|8&+7EXOe{^1W;EdVu`^v0{n^!3ETeAzgxc3rH7 zJM4g4jBAjehvAFzwrTDot;pz!oGC*7uxr-Qc&MF7h6kQxq5wZ+x#8vxASi`Oc|Grf zBkD5h5B}FUCN|cY3-W!xG=$tK@$LU2%c!j83LPjdZ;l({mE88+Fi!N4?NTyq`nI7{ zERIAjBnwZ%_DRQCM_^6B3Xm!zsUmL#COG~Easn+ayt25u66$yM_Nj6l`3oiq%0gi~ z6?4!{1v9XG*kR#-qtD*|CC^`yv9cQ#cty(aRph!|bmt2fmoNo>O4~owLE!O~EOd(j z_jEZLnD`SxNFP0@O*D5ZVDXowHp7m9uBm~N6AHt2+`PUyBj>V)q{dwdQr=|IBjE z`zYagOh(hr{f{hB{`G(O?wd(Y?JBzzorUJ@&A$}!D*tu9zZ}%{`WozaQr>8 zt-;^YBk2E|=@1nCO-%?s{*BN7=YjhS0KVq&|5c=6@Amfe?DY$s1uCOu@);Nl^h{pP z%G4V4h*jA@vs+n~-?3)c^b(9mQ-&@UyA(@GzwoZMrj}dd z*BU0&&C6+baki#cFLdHoa^!ouR%dh2Q@WLFs8S*tu4kFM55Pa>!STQV#0+$CbVCNQ zO?+eLEN@_Z*KwGr;m&{mQ&rq4^(1-t>ye-Tm`yZ||0dxIGA}w#8(0^O6;W&6fY&ml z3zT0%BX}950w@*!g~eo>aC3T3cO2c-ZtCgjp1jdCLVZ0Ovr0+D=GVxq;HO%?oYVgt z)%wQi{VPbEV}6xXE62^k%j@>^y(q;#YC`7!`lrB1__o}Lcnz$@vP4Hoa48cKghxU0 z1^NBet?ap+A;}xnp{)Vuk%8S zIf{~wUR*7|_0KeWlI)-^lc)W2o4M~izur9Ww;LmbqbRuf8FAg&?xr?fMVyLUX5-c) zmo%0tYN{)%tNw_{;a^wkh}A`6adLdG(ZP8ImPu~}a5mt*%-XJ0>>`MOfBR;QPg-Jb zPtl*D;3$-hUJvIes+Zp{8m~WSAyOjTt4Rm>jONYdMhSTi-NhXFbiIwm-}I##XbxVj z_Gf!I^+mh_nV|=NcUv0gwB9(iImT-A9M(eTW@SR zc$An0F*3u8P+o2Ab-P8**SBd?UVV{wPZ@ZBzu7>p4d6EV)BV-?r!C;KjGu_=@!Ldw zJUIoSu7S=qfbLpYaI~0FBx|Rn+jOrob|D+SI3OqZa&K!7CbeNvn1Kwc>CMb>VGz_M zoB2nh!2!OT&tZ+ms^Bl6MQGNmx?k+Q=8Jh1G3vFqkQUu7x~$g+g|2hTf84W|=dJfy z*Qx@Ug%sKDF<-m3hL;iaMyzsi5oMwXMxk&Mlem@ggl;j3Hc%PR71vwj!J9fBe>qhK z&S$KklZ?KnD4r>>NVDRPKmMp`paWUvV-^th*wH|2n%k%ieUoeLUtPJPpH~gxseZvfg1l zfTIMMFQ12P2_pn45{LyMZE&G?eND!@BF2S>3*J!P?x|jbkajM>ucPVJLiOGJUsXOw20Qm3Kfs}m_gGmctqcrss@@I_DjsY zAZvU&zVodoidJiHg-s@_2Hnc&v_;w;I4!GF3PR}h*neQuw6vP0Po(94`qxafXQPsS zT!SHhB|&CvEHK~tGR3CmXjwpS``O3AG<$yX+4HGi(7&EYI0%3K=2kh^Pl{^DlMnll zsB3=B^UmXtJp=q9p>j0T4K5-mqi4RR@_SBnz&)^;d$i&8gU|{u&7iQIUXeg7+unZw zDLmR5^8S~g?st7_nBI+ATm^Sjt^MH-wLD?MO^#S80#aVO5ireOa1Jly=gGSl*8Xr5lIK9SE2>?Amc5k`Oj`Q zcaV>*<zI<=Q6P)Im z*4VfBZt<7*LS&K52h&S3De${G5d?<*=ibck!(5%Y@Y_RE+@HO&Ci7}fVeQGey7-O? z1FsUe=FlT}bi%*8hQ?uG`Wg=iVI>?)x7RuCcwO zmTez6crpq<-o;NMTc@UF#Z&wFjQ`P~dsD>E=6}HA-2NlnwIxzrdxvWn`vU=hkSEQV zy{-Enj{3hp8U0IcPzcPPfh|!s#j$qKfS`WO-`Uk6yx9I<@^pdw-if!Av)(+?o$mSZ zf!w#FBTs@qE!;}XqDc_+i+2w(364vexBuzX&l!#+)5y=Zv2J?lRzL9~R><`tmcJG2 z?s@#Wqy~KZZ)p#Q2xuNkOSd9stV2QvB4QJ7=D+K=gQopINGR-~oxXU$J!mYf7nhLW zZ!p{}Sq8VJ?vX|~E|)Yk#5hAul@gEY+%+||v@}GRYg3HBzrVvwf&SEwGw07UHB()} z_2QteK_GS)cnNGD-nx17Cf#~&$Hv^iqcEXU%6V^JeDsj}S3bvV*y;SijZyx!-ztPh zM|-pH(9+Ttfv5eV^jGw!SsN)H&~xV_{?qdlF#-D7^P~Kjd0sT{zyJPw`t?ttidOH$ z)q3K=uoikcMn@WGRz2M|<;UJsz!Bf+8z$y?Onom#JpTONcRy48Mv!mj3H*bV3@ z>`4{v0W#nwWz2jnr^Vbn6gqI`ny`@P2?Bx!?_C@r_#*J~rQ&QB`n@{8<$`0`k(Jt= z9ioYfk&(|qdn6~riMkThC8W?o1q5%o2W(Zh*4~pHS))@^?IrM^kCwdl$v5$qgj}#C zy-eIi);Fug&ZKDu;wc|cAn*(OyX*KBg;M4k?zkZSBOxLCHT3<2GTN@pyT>iq^tw27 zD~4d_BeJt&>>FobUU6{=kN-eyKkc|bX9KS&h1Lm9;EWX9Z+~xZ8Ogb@$jFfz`;(<^ zmn9|VpT*LWo+qWnH*!o>*~M4_fui$DZ1>pN6B#u4a?R_1oGF$`kUgVk3#y2pa~nT$ zEjdD$v*5>%%#aZ3E~qf7JF`FW;m$N4|Qs;+Y!(f(b9p2@M3CdIzGsD^y!mbx> z-~-C37|-a&NQY!rpj9mU558CRjdSrwP2vyp@d z7oCYvmqYLOuTfP1l%Wdm=fY_oh>O=ualUh3i2*$&nnK~0q(t9pqbZy1p&zfi_g7a6 z);G&Bq;95-lL;sfn5JeT_=bP>0GwK@)Rn*V{cm(H0u8IKZ1v8V-~381t-$(v6Sj$> z)70yUsQdJNQ1Cs=7V!i_gRXaFrn)93&4i6l^z*e=pmVr9$8_`ZWR#en6)YEm0E$kb z2&shX+FJf}ZEz<0&$Jk+!i>x-27z?RJ=dz59tw{whD_occpG&EFIVDh@@mYZfx zm%h51i7OYB%Y@(EpG35ilW3@$!Ncz^rbh^D-Jb3*F9yuv!uj*UL7|sYMysmJ%N@7w zW#7NI{f2^tNz)nsyLwg=L=fuO8vg|wovQ=h0YQNQ0W$Xl@q@bg?klJcCnqPmYeS&v zR{krj9rqSPnid@W0eZakbI6_XWyjbbu;z!JheZ5C2L>ESnVh&vMxPl3LYJoSYbm=2 z6}HFD!O!`KCs)j|@h9II8HGZdWP<7a9Mfr6P&Z+Ue&$Cd*CmC)!T*&*`7Bia(R=I= zd?(HQBImt{bD+-R`|4c(r((jgHjnsW(A95vT*TkJvY!w6{1kAp>5Sd{tuOGz4#Iu0 z+&g^uFzmSNonO3YzAs*0B(Gsnni~5%cvCFcNbzG%RMDI|{6XTcKWv*HlV`lMlher) zC$6?bQ^XGX{h^-#8YSk~2+_z(0N8k1A0P;!`0I!)BrM>$+&Z9bd2fd5{l^RJhY4(l zYcZl>*UYK{$R2w>-1keLWo>M*Q=H{`DqZhp55llsxj?2<5&O!sRO%|Ra&ho+M8xBs zGf-^!m$g`4CwT&eyPoNaIZ0jn`q@rpkJp46ZmDzJG<&;|M9wpOr3t z%w9i%C>lTAA3NsaT_aUVNyGaY-*`3j#Kpz$!yC2#q19JN5^}k|Pr8#Sd)6(3_&zl5 zvA<`3RtFB%h(k3cz2BDWJpR{1zreKCG8muM4ZIt%VHTtZRbAfSxF#d9aqmO%JX%It zcG7^U6Z;+@IwB+_i{sEYSI~P%%ljrd(?2e#2 z!Y<^OX8h|s#ON6E;KR`C!R?dasle9@Q5+=@xw8N8FJGHYTEy6o3jVZeZy<~Os`T8T zuu+2H?vqQ;q_-&p_3y*9VCJ7=53H@NEh9y!lyWt}={H6`Rmyw&RkDIWV2@@PlY?HU z*ZRrhva_=%u!vd8Hh$dqjah^VW?l2cfoeKBMk2$s`R@rw4hhZ$S!6){YjZ&YKt8Y! za&U;?si1*={gHzNp%J^=ZA{Iq7uY=Z$4i38boqP<{;^qa>?JF{JUemXgp*TI^toC9 zIN0f%q6Y|*le24-4TLv6!2bYZWSjr#3()sh%#ZB4sYWpNZJ%6FTfp6T_X$_MHO>XF zb#n5xqyC1REYf}w1&Bh!QhF4rkfh&=BFR3SN=)K>qy^W`BkmiBN*XqEc1KcZqQ!YP z27;9@b*?Px!#lOr`pE93+VP1OOmRxf_u&=Jz^q>AyOUbaPy8chZ3%_bMI19cK&_)( z5H6!s^H?%UWY5$DmiGB$J;GX}hk<{ie6hLtMYYZP5Q#f4u%t(iN~EI1nEd|r{MyV~ zZ()1k)L4KYyg3ri|5KO6v}!DOilo@-5Q|Z*H8J_P@)__t-N@N)yf*`{Smw%f3+^1! zArPPu|ID?6u>#Lntxs7?0eS1TYIL=(omv)o*$(c@i{z9hU5ec)jAU_37^D~C4K(v>Eet`RC zRF+bb&tb1Gw2frk2w--5XYWi9XVeT#iQw@=!RPs&=bxPI6Pd}JoJkLq=6_=G3b#qc zyN0RZ?h!YpBcP_+Q&(YQSYRq%NZUAgYN}iG@ZF=Q3UndSfl^$G%<~m0`BsIw zoPLV;T@JEbqoo~%oZ0ivTI5P}nTc5deGbSzeud>xq#Gznrfbo7L`2h8%ln@)^ElvY$HK=ZDwaF zIn%Xec%)Xw>|)vC6;3~o=brD2>IakX+)G4`g}ANUU2@&oWZ==gSq6o%ldTRHPiao9 zH_VqAG|!(>JmMx@{?W7HRx9P=Fn*>^BGYDj{MCX0_yVp)lXie+@30M z4|AYxK=rshSgAafL zU)=s0%p3+20k)mdYg+jWyGGoNL`hbh&X!8ys{Y2e{DaZYykxA3@wn4Lmc)>dzF-8^ zF|}w?WZuO5hB|IxqxEvcDFUsi{WN*#bKJ#s*z;rBg|sO1sd8FM_~1q`m#!r&5cu!w z_)`>J*AH8xaPyLZ$oAeqkDs@Hov8*wsljiNpPfzT-3)n;7}TwkcF7G|@77P<=CNw| z`LEAm+dtL877sAajoH?m9W;)wb_q&dz5T+)bs;)BrR=pxvW-3P{FKjUEC4%4&aG}t zCJ}ts`fbgvptF~bYAON!+&padF@I_T#faFsISkzOPJ0aLnVcp;s@i zM^f&A=#Fg&<_H|U`}X%QwqT3Lg1sMa9FQ{@jC%=Y?ri~SO`4T=cGQeiHG97Bu-C-mLi1g(hGYQ2J z&BD#Y8MMZjW`4z$4><{)sYZqG%~~#k$oCJzs3rfy7R>8CeS20DtsQ%aI#95Q-J7n7 z8I~Q(5rbZ*VZ6^C*EDMV0>%_u;^WODr)q=?USz)OPEq8GezIgrAV9Wf5QhY>;thhy zW^K~KjF$^jgW4QfcE?HRDjKobuk;U`tkGEx^!OkydjD*Qni(|LXjoaFU!bK@G-!_e zdeSb&gqCuXMQh_9g6h5O)#}qw7*YfX_&@=2Wx>xGC6`xnQ%y50F}T@c>RUZS;2o9q zCYbYedLn~|Ks#}@1Iem0nR>bqP#Y}_i=j}QnmzG; zmLbb(WMEjEZ`GZcSm^x0XT6V<%efkaRmxl_jr7#-6%#N3*Ids)^ImM8!P}}$@079) zu4C6$p$GVw?XGzd@cE)psG+ht_T^&a`e=Y2eU5&4?0FobHUD6}`upeJ?bl`R=!>UN zxn90|r~I|8&sTB3XAn*vI|zV*-=Eph^DnTIA84&IuN2V`)EVw!x0T>?SohFyS^=^T zAzJ!$16$kD@_ZW7h2$a(fPU%b6kf%H|5JXnZz~py%f`)fA~(EH@D;kX zaK;Ia(|MkW=UKRn<_~KKdBQ~53*L#+@%U2r>=@=Y{$CFBK0vLoH^*ub4-n@wMaAV+ zPc<)nIfa$3NOr6?V3x5esr7aG{3#Cbv7k|$MLYs0jf{*&m@=mVeU*>j-;oI3~`8zkk`A zzp=C^M9FbIaarnsrgFZ`+J#9Kz&HrV$##jUt!XI0)qF2MVy&vAvejyiii*;Oi-@Ke zeCT1pJH`U0O@g+jn%x~vv=^*LeR~T`(Nw`34L$tA_(clshk&P(sj!XwxI4#6-7fJ0 zFgmZBaI?lrH91mC9$Bi+RUi0j(M~HwaY!>`58EpfgB$eQ&Ii?G_We8R6-soN;8yi+ zHq~||dP0I~bJ(juDCnQF^eLhSoy#A>#19xBOGB8JtXPqQG(`^XWsFkU!8U_gUjMPp z_w!Q>b^FJ06hTBIH=fF=p)6~42l49kA%{?+g9OogPB{bvR##JZpnZE<1Pw}nxS87O zCfxc}@2eV#geZ;>H0-Nz2O0Q~^41fK>rZ^HBoi2HK8dOxXZ|@i_p;cIn&Y&|MFJ6S zynYH?&YUkL)2Q}8zqQ@e?^|%4WUg)smg93Gp1%?OwEWmI4U`ktBYHh-X)9BHUsYo8 zux|lDJojP~32xXA5i0J{kR2S{o7TE^Ty8U=lQeg}l!_$P{3gV2LSLUw-+k4EP0*lp z<2pqU&V&>M1#9@lIU2|e72iLk@Ko{mQfViyeN049P>|;F<>%7Ukw&a|WQBxY?hoY* zfYwJrhpBZ{O^+`mOSo`7dcwUtH5IJ<_z&(-qEZ^&*VuAjW!{M1pY&WohK1j2Xs6xr zkJ`$eQ`_@kR|ip63y&KIM+4u9H{cWb1QgvV5)6)9_ZQWlqPRu|c#1s_h+KmR2seZ1 zb>(`rsBXQX2fw3Mz~+Mmgn#)Xd=&z4f+l)pseA}xen?pfg6P3H2@`Qu|5PPtsA&`p zj!8&>`~j)UWhs_Sg9b-yhfDCr-S@rNZ`BT;;<8yPhP(Ajm!f^oEl~h6L*lhh7M2Xj zFv+G{eC(5*W+mT7i1ZA;SVrxJp!>XY_&n9yXmBp48T9y-h*{@7QZInf!oD9&17e`J}dq1?cO=JBCDJFbP4<2*1e zQEWb#0^^!oA^5C&w=dbQs5aNiym+4Ly=g7Fr?dayH{`?~prS0+%aI}rZtTdx$*@mL zZ1~%vAfZ=YMkO}l297iANn|kJYQ;gnC<^hBQmCig6XPNHqN`HcTS(Sw$J0+D2-)p|5IhoLExwPvYx!ko~?OQhrzR-UiR2~KnFO+O^vbhg)eHs^7h zCO8ylC((7)=QEwlqcl242|U^$s|fL=&zRzb!*%q;woQBKtJ84`Nmsuw zQosjm@JYJx@(7>~f~T$K$|`FLl8-l(-4Os83qOlqySh5S|MPlHpw+>bo)dd$jyxWS$v+&q!6SKPkNZ>10HNXv!2AtEl-ra)y za!;@odWr{NHvu5{`` z69j~=J^ji|CRRc`puAFIyvyF&i2aHRkxz5kiz-3B|n!G zq5ZMNv+M(K0n`zJ|`RS3>_YX9xQWx>w6fbDSyB%(-p+R*g zIMH!IA#RSGvk%3Xu32jYv{A{)+KGhNp@StPELYvUhJs%5)2D}AyjBx+ot?6624?|0 zF49}eVs)CFnlkFHmRiA3!Dh3PfzH6&!aGq{fH#!flO|KWK5N%rwUANYLMIvX&>F=6 zlf<>f1Z>v}4nn1uu1p1kQvE4(bn=u-fE%?hs0OxV|6@!9hsvk98rhfn5l0ng@!cY$ zMDjqqk%fem)M9Yocd|dIU&fz;Q-dvBeX<%1;j+*yZl;I!1g9U)TP4x2Uh5-_e(; zt?=1BP^Yzx&_8&<%F4vld{FQgUP8bw=w8X#khy~^Xo;9Y$aQ+@DFmoT?j!&QT>R65 z&cF&FK9R8;dunUo1y8{Kt{pk9LyJ?x4*2U}@0oj2tKUPxKSprpgdbmTHYe8Sdoa6! ze-97MQ_t6y;y|J`z&`swn!{SGkznrDZm{g@8I#usgZ})g*8ThIaV7grXRVVL8_~HG z)2XC=KJiC=pnBej7-YI6)c@TlVedktpj2t67;PMI_+!kFU%=M*=SCrO8L4h$yvCtv zvmk&HU1GMN1r;oqi7+yflaq^!17vC`^25oVvb8!)T$BN$`^KqpXjbdzI^f8^YBZyJ zt{?a7__t-y?GtP7_ot63P88|Bi73=kv+6dV{jW;9U zIfbX5D8#cDKpMf|wrnBl+Z5`{O<{)Pd`fn2r=H zxXjer$6v%uOq)XJuQa4)X(`34RKr(3mA>g~CzQG=HL*yd^Gd9~sGB+{Ucl`B)CHPu z`H%zToa0&hE0|pTVkzswAjZMpFJseR zk#IA7pzVQ-dWaj(UFJPY=;rtVf86}_xpj7Zyxs=!HO{kICAXE-quex;Z`SZZbc}X9 zvP+69UhZ@!`d4C}iup#ax1O?Z!;gC9GqTthd3nd4Gf>yyR#UtBiU>5o?Nb_kZ*JSc zhGf}QR8fI}!NjGL^PkYRH(@&Zsq|6Ws64dyCG^eBAwHw~<}Q0r%MRl;cJpdA1gQ-J z@Ab*bIk+b#toju=FzXLFhDM&PxpFql~cRqq~FO-5rcvm8iK&_^{L|(2yitnVE_SpRnpMbXCVTug!M#kxQ_( zga?rj719zm&bQC}_jY%jwo|q^sDg?#0ZXfs%yr zq}yZ#6LZ=()V+Uuim$rCq@nKYg{wtV{TB_`VYd$Uoo$st(GD?d{WX(0xKyRP2d4*7 z&*#fZaWJEdCilI0b#C_ImQCzV#)T5TbeP7^q7u&OkhON|lEo=~F-_S*_;oV`pW+R3 z#cAk0Mmi3ck6P6q?WzK_b~+7R(uoK^=j5_&?|y3va&Z!;laVB0t-WTFo;XuH2@#px zCOtt^eb%t5OPn{SBCz8QtZP$5*Yj|#i@hk!{Hg9a)gmt?DfiKmL z!?ukpc!;Y7Yxf}}7p@ytX4}bv01+r5vU1P~ht9!ofvc1F!I(p82ftYmM;ONR5 zsT!Jb@#1aJA{{Dedi!)1fzUjdx#%cFk>RSrUAKtGry()s*;pnqjwZhn)V7yOn{1SA z&1l!|fT3VnZ?VU{&Cv4E6|lmy%YT?uzlpP}ob;iqO|1|V1ls!edfZaqxEVpAGU(;k zOm#5XYQQ$4IMn5Gx+osX4~6!E>I>;<%O!uGwrOaWNM2psz4KK*bWfQ-ZV`r2h~{(h zE8ZBYQkMI;mD;^@gZssvQIU>oL-zrZVUc zp}wc5Bz5QeE1FZ{YO%blCso-;A)B}MC6;FT=V;y&ZIoO>dAS~lI2zMgUJWNRq(5m)AFIhj zRS<>e2`=0mmPw z$d|gsKi)ea!x@KU8pL|H{aKa40KG)eRVz51HO%84NyM7OCV06R$K7k5>z9`JlrKTe z7Y$~apa>TYbA%T1wPZ|AcbP~?&wOvI!t{dXP$uQlP39VSOrMbQ0EfOM{tv(R~&YA zXS@|l0c-JPj|eBGY-*Q`FME99>b09_#`Qz;qx*Xn2(CWTShhBZR;c~T3;1W}2QD-3 z!2G8f$p394mxs0@2=o@iQa)|JNb~mVQrP^0?p^olFRX{qG{*s)PI|V@F^Fa>`d99fl5(B%evD* z_Y~6QEUeW=s(FwyHH){$@af;5^6#PF@Sz;oHO~o3?J72^xrTfNjU#VgM6ztry$8yB zEW<=*gRkna?ljctivZ&AQhK$Euy_4(jJ+;2$65JrAP^q1lED>~yPrk7OyPiR9`Sr$ zfBqSP-BgVSlKLdBGeqCIMOk+ARR&w&*`5ADlbek@s?M_wJq=eiwr=?r_@anxUKq@deyu;VfDiWfnOj( zW~4oqqYF+n%$PICouj1<=Egqa-t5fZodS$0&$kP%6T^>C=eSQm{=Dl*E zWqV=XII7p2`3^N1jVpmqxYo|MG5z4)w7%`WaMGzwAcd^>{P1*^3P60ru~t`z)8oUkm&u|{oygnl zQV%(zglwMFr4Q0+e971?&XFPRED(!-p7y-%f~W{=n~*F+s1W&C_ySHD&JezSG4=!X zf#8GtCsJuw(_-ZZdbR-gJXnS-I5zT+91$9{>n=Y4JGH?-6Gd8=0Ih6#z9zOi%B*Mi z9=twVfIp@}FyC~O&gQ;MHi^_N=*ZJMtTL*VPPj#t2fM&wa+n`iYakCp=B#b5pE*`& z;I}kGseau2$8Qu1)JF$*`P~!_f%55geQl|WPxljGk;QfjhtTwGvcP%X;*jma+`rI7Ny>e{*HDR*L zywxh3t77h5n|d>`@k~c;`4MKe=J%(vHTQO-Z$`vaMuw|ao2gdU<$ek~?}b#9-|7y$ z4tKgP%%b|JaWJFU)02?-c})>IaJVuD4L_W=AkQXNPb^>09E_As++xOdKn4x=up7_Q z!r)V3!tEv&gMazdu4E7-0taGv|%24M)5m=H}iV&Z@X*D*HHPW`m zx=bZXyXnl#ZF5@bd)q-RL1v^__rLyn^cN&A9%$u4!jj@=D-Dvk{Xxo>r zvYHQT;7z`ek;TQf!jzg~qm64wU1%IdJA!4abrdp$mBLN#gS6S9OXNb?#J#C7sxl`4 z-oLLy2;j9h>V6j&UUG3$^v|x>^b+= zO;bUfz2ydLjE$CI$xqE#52CaE=2<2S%};vU7LHyP<(tYm)OPnGn7n*;S8AyPeFEp0 zwiMt!+gm|_H!t(HJx>pyTZyQSJFqkc^q%|! zVZ&<5FCJT#5Hw(R-vu{Uo+oHId%FZHc$0i6xoq$5`_3JovJ{(U?#bN^_hGFlYnhL@TCE0nyT~v5dd6ZK0s5c~dpSEV=2L zi4e2Q75na&if$i0h=PgN=BB!yjM%O6g^y-(K>M2|GT4MGOct2R0}kwM#(^UX!wi<`T}T+Tg}wz+B?ud1_@7@&Vv7U^+ib*WS3f}EN| zGQ(_2usA@W_Ryft1i3Y;Me!w80LBn*LAz1t5({-f0LXS4=U_LZ-#s;TVaGVzt;IP? zmr1OSyk^i-0S;GyedPT0klS@KAv|Q(!K*=Pm0rI1^blyrFbRnoc$56lJSXYVXW;qn=3eNmz`4~2h+I6o?3ok1z6uH5xeJWIx9z(xoQVlyU{YzxegeXncZ+VKM=2(`~yZt^X!k4-P4b7DiUBzis)@= z&Lj_gp{;71-%D(*qURz@x}fs4qg^Sz#})V`Yx3H?vCllt`1?=@!BM9%+2egBkO~XE zC_T%ypBch-uxd9J=_Ztj$C(RPKkR-l3^_OHBFL{2D>>t1(roZC<Qf z@6@!7S#e|g)y*;XRF5{&#;(|>%;s3QF}(kf@(IFrkjmFdNpkHz9oy2!S8{4& zhqCkV+1#!31j+(*Yzcbt!dZVCnPJFqYA~POLzPjQi>FVccDB=rVu`dR)rTuWl{cJ} zOh(Eg*I3iAwc=7@t-x+4l_{V~^x8uWAp9D+&#)duY9(08tILLx)Nv$&x`o#YkV>y> zsv~iJwW1HLv{a@#yV1~HIZ%>6w5m?u!xBtY8f)3!OPx~PQ*XuRH=NE1hCUdVH5 z{5DFjYD8c`n&!_8E>#x`yPAG+HI0zhF+xpCrLGO~cK$N$*VV3QJBltu zRIbNa8{VH%7p&@7ePEX{@^;q&+H%1C%>PRi@j95=BroxbZVVddYfS$f&O0bZ218(T z?^DC$v)W;^kaZYP#_jp%CFnFPS0`BYI|cw%_Op3eB*LYtcJ{p2tv5O$@v=hz0jzR{ zbKC1ZAB_-q0`0&JR8+ookbPlQ*?JBmgJW~Wks<*QYJheN9aC=t@DU?q)Z8oxeHwG+ z>fOVGlA~0ikRl5c8~$PLDP9HN(~nRgOijZHXA^@QIO9Q1~pP zQr5_lr!kwgKo*@{Wg+YxjDOVsF6a&N%pX38MD7h$pZ;ea+v(SD86cDiV<`{zE4ptD zk7*fsd2W8;Uoz0rfDHk)&tC5sr+kBSJS}hzJG^n28cgSLp^dW#6|uj$bD! zpd`o#UpBuV@E@!?$(USP#+j|4`av=tqu1=B!NbDdLT@z}V4qbqE9}tiV=PWPkR!*5 z0vnRzyTupX%d-f3o2)tMtG>$(>4*yc_`a^%(BRuLac3X6`e9F>J}I!_=H$2g6wnUD z3x#fa`JLAx?^{h=@55nkVLu%D9_Afx@*@!+l%S~t&I)Fcbntnhi?T{^%BLCEMB#^( z7D@AnS3lU~047{bVPsG}&?&5%E9~9Ue6*9-y+n4H&`m&KR9sP+v@aaq9iH;(laF6i z%k4`v7{|t}yN-LCrdvQRv|hpuk;)mV`|J?KAsqg%7~xk%=pw)rsy2x9YKX~80$s@6 zfV~kv@gf*Nu1V_fir0SA^*|Jc3XL0hkTBG&K00t<7w35>(zmot#R+{bJbzEpTGx?P zN2lJcJi&e+ctFkLu@e?li#s(<_yBKT@`YN^yVEqGiqo!E#v1ht#l%(n%A@-?fpn8=hC%gy3fqm zZfEA8VS+FZK&nl{cU#Z4k#OYXRJ?NN?oiHTyC3tZ>bvNE z4bcQxSNp=z%?-@grJQg0`jbo=7iq5bn5B|=5CIFleqa zwo}`~wSn$?&KxoDyuiA{QmCjQ+eIy`R%I=sEZ49^LH*#%HDP}#*KcqF^djRco+W=I z?#Qoyu2RxxTUQi^fH^N@8FHNImP$SNk)Y3cssW?g5~A%=xBumLmCDTx z;6ajvsSz4vMKA(6>1{!^7~i#B;(jv1$B3QKX1*#YfyqHr7GMjHzCICczLsTFYSvn) z@1w!P3?sDP^p(?Cv3lm5UJzn+wGD{nL~=R0>ahz5w>DrLkv3mP64VB6r&c;O(zPVz zkT_^DVTCv@wrwcDH1r(0vn>&KuMY5O#q!-ZgFZ&F1gNe~9}Qt;6LY^)0N4`1tViX( z$Aqo0s8*~-z3Z4Z-S6jDh3HMk(Z{>A<$urp?Xa;K2#h6m?^fSIwb;_~_h9redPP_H z?4zYMoS3lP!GDR4CXJT2aiFDvgU%-(t}In+rt_IgVzFGM%&~MgsRu)yOyll4zNoAI zY|Sey_09LhVs_avK)1QHnc;fydoSa^r=;*+qYU?9*-kqZ`B4WC+cz1FlEp=mwaz9V zc5+T4_r1X#^n^ZO=u-=OgSio^EX+$92NsoQiFfv;hn(H>(K+v2I08nW z*sJIH+)oIGKT*vG;Q-SkQ%!L=29nr-^e^@voF~WyA&A~}<98_vhzvgOY+3fKfX*`X z8T*BV!nP&2O_DHGW|>KG?4_2NEYYm-;yl#EJ@|aKI-mM0F&(Kn9Ej*ej5LrCGIJK= z)8qS%RWVfBHGbs%Y6jS_&xMtI4@H^)?U6-Y2E6m<3T0^&V{;=0-U{xcEKLeSz{K#A zz2%aKjUpk61#nE<2{;!KoN@MFzNMGnLAb^5VKoub!dWes{cgDA-l%h1aJIwI=_(Y! z_KpINs#Q}kG;iz2f{cn30@z*IlYQ9U-I5*Bw@0c7(u(FjKueE8_=sJghNWgKMX!A{ z_?ROIU{-=MMnOIFgE_8P?%dbPk$D=ARFwBOJu)WB@7jFT`2J_4@zE0v!!{P$E#Nj% zxVrX!fJNQ*U}gszjbZ#70P~$(0q&cZibE8#%SS%tE>K^c_@P+)E_y$rFt1$GyP;FF z`=_Q`gm!39!O_|FCAtPmwIj3AvK27($+Gd$53)?q# zwmZ(v-wlNJFuQ=(3tKz)w7s|z9M(;3zLSxb7O1t=EmLB+{I*uC_H%}o5_=ZFh%eeb z+SO_euSNJurIsu?YdL3OHe)9yC|EDFG@E7@0j=$1GwR~irUlaD__0|iX7;mSZH~SwaaUMz8eNyD>X5PutUaEy~Jy5IPh#&B^3ub z^#snXR+N{QX^+@TqKwJ3FQL<7EBGsEWI}<~D1OxnP_ST%>;WK={YDG4Wt)C_v4zZJ zPe#>Dv3sPxhn7liFqP@xtZ^O)jXbHGj37MF`yDh)hygBXRr3Hb7p>6_nbb; z0QFpHXUlWapY|PRY9@C(x8*}QrwC!2_VpqeVm+BAVHqSFaRhw2*~K~oU|t3_3YZdw zy%UxK1Hh3nKX-d9HdxU{-oF`mz^mSI2uKNNKMu z>qV+@MMY5_>JPRMNH=7LyW~PIVJ5An*WuP@Rd^W#?}ROX6q% zNFpqJ{R}G@F?uex`3KeabA4=fKKGDHfQa#Y+&Hm5x=C4MVcV%_gd5IVT4x>?wot{t zM*IvSUmG93kQAOVfib7Ckwk*N%DRiNlNSppR@x9HU{sUG==yCH=idG{? z`^i_a2sVe6aKr=d422w=t*dpA5$tCbs((;|Q9w`0Fq^7!)z&mA_vUx>iUa=hs8fs8 zZDZW6Vu!k!bMpm!CgHu67NAKA)dC?WY!se-QRxN9 zhSq&Z#Mmbhft7lhK>{&fxkfeC42h(2)%eEU(KLrTT$XrKUyomd~`_6OD?QR#$ai0hc_nA~ih~529Kfja&H4Ocn#Bv%?nQm5Yal z*31sN=m8CFo(@dh&Jtd(LO;LeLF~rPxPN!Mpo^sW3weLOQDZTUYrVZ7nl_OJskW?l zY>5~hTK(q5-l6DrCUPt2ta)TqOXRzx5K;>{1gx(r2g=rSHmyTFfl{;DR{S6{KO2Y? zS;SGW3bZq3_LgcN;CXFR| zpIGPdeDZ%twEq}6k&LM!X26}H&K0$bNRM#?Y0Av5cd$E zc@Iolv>v;K=8@MKv6jq+Cx`YDHxU3*1C~L(ax*Q+6u2`?8Ge^mIFO4qPhN@Nc)d^@ z+tVP#91#j-H%W4Jj(^NPE)Mb_0O^pfnNWzDI-m0MCy|?msD<88gg8c@-LWZ^bHzK{ zjN*L6KwE(^bM2|zAFyzfy?1igd#-o_W*#7-!^%kyBEWcs?bZPo$8!2iEcBO;QL&G> z%Ur$J-{rpi>41zYJ1S3iB+%3QswzPSes_KeG<}6oLQ+fjwUv)E@VoY%RB}OdX)zy| zeBu4|yNIVvkU&)#yW#=^q) znyKa0`L1^ub`@J$`iuxHGjk#O-p2+i^__VIG;?@oS zuyks~nO8055X+JaHvP)AacXuDcmr;T-tGeD3{mu^N%@PwH( z1Ui0AU1MRgkQEI9W?y05{h{O_-?tU4E{wS(K!H+4JCfg^cXwQMQ_}J@43cfhF890H zGcJ32i=A2*X_koHvSKcKQ>sqxD^ISAi4$$&l!2Mn0VghG@kPf{YYoEilQV>^RL68R zWne00e{#$v%!NS*vD$57GQ)nfz!AbWfT19*wi(SUOK*@b>V?Ef_LlJTpCUpmbQIuv)cHC9kj5CU0-uB_KPlPZP6$P%56~GN6pZ(vLFutU<~NkaC(jQiHWA&Nih1CD9dMKMQ3|BJ!c9M)5l{ z`R*Z2tQE;Zi^DaCN3!%U%1JmU0Upg3+8KoPhryL)L!M=;eC|{MQC9|RmPaaguIX%#jG#z$oDuzA|0LM`JyNV?L0s+5|x5mR#UsJEV35tN_j&KvQ^#3YtvC8Xq?DOEs=8CIGVPW)>;XMj0Kni6Yb(d<}SI z{Q*k`EF&cbNNX}q$MWLZrkjpP^Rd#*!q_2c;RUl~5}pom^zS9c1D2S@$plS2Gta#8 zz9p^|xd5@gWj~A9%5E|e^5JR^w@0d%ELIyrNX>^_{JLnlP0d>;1o#{Z1N>O8+#I0Q zPIna>>Fp<_6rXxXFObqSD?gSsGc|KG5OuXJrp4l#H2pBQN+Am-=KSdD-GTwj^&kA==s_&)!x3)jyhR#Qp-K9n-|hP?-kUY#z%!Tn>0pl zm?Po`l7%i)hR&h9N2#)p%KeD$d>N}1cN&Ys>d(uh;c(LtnIJCAxY`6H-VQVyAg9#A zdyEYtKTBjJ-*p2R9&dkGI(#clCUb!bF&@go8|(ukj^W3c9;xgV59O$8#7E~Ga%7I4 zCg`?AKdRrnhID|E6QsGeU!VaXs0HWW;W#$b}8?3Y-4D_Du_5;-@WUO-<91Ry}_uc+R%E4#N-hvjAO3&X!jk zJ;-L}70s=ezWb%VGBW40O3u;^%eC4|TPbrikg!hfUtKwUtDDE(#iieJBeB=^WnCvD zrq*xJV(>+%<23bHrA~v)G@(~aqDLH@CI-`-M*2xupl_jK4(|Y)8qwFP@b($5zuRpERW?vhze^%ZN1cX~CQaL`_4D=Zo?W_zFoQEp@6&JG& z*Vwr!0kQ)YU##Qo4+wZ3wJnkKj!~MjWrGmWm&G+I43bui10=T%{pz%v|1RN|wcNfn zEMo?tjSOX>V^&+=$dlC|IR}0fjReptcLXH0O0#lTy2}`Ch^!+w*B3Q>q^_~N4d^=F z(P)qoRc4e`?GBgtgihT7zFausK;mB@2+!Ut6HTB*g2h20>i94hW!?f{kP9wYY3D{rCY=WJv!B_y_cEfCM!hAs)mm#(|$kuT0>=HdYAM7r(s^(0t>Bjc4o@ zh=+6BiIUc#Qm@23jd(L03-fdMg3bP31 z+P1~^=-Ugt&NC>AdJIW~69pHCAV_OiO|4p+-1sJ80Q9WO>R^9Gat^UoP=#Ci_D&#G zQ#;G|YJuO01ya2wQoTxtPu->$8&N-Bd2Iff^DZVH*qI3=Ki%E_>A9!~YV%0oBua4DC>MSL0&Ayoeo z^5Lr+!e&c{Af@!^Fz?Y38=t7JWXn6G-KU6aYAZTn6<1JdE&jCiEK&UTo){}(Qa8{I zB*%Jke!p&++7EyJW_lGpU|c-)9g*7_KE1Z9pS&CoHGJhdL`R-t?sg3ANkR=b0F##u z96SoU@?;ps`+Jh3yF2EF0x)BdoSrzFlziwFrQw8#yDV+~8=rmOPZg)6g$^!G6gdavrZ-Sh~ z5h7#(C^&Fr(2Kn5qgD|5h3Jlec{W{(afHf+qOv_s;D&?X*1X1Fl#CBp*EW`~a$0p^ zo7GmiWi41agNZ{PF3bauzg?zUZlNTAIUFYp7p{0^t@S>a(cs7uP2Y_J>15~JH|$uN z_UKTme7u&jNwioKzW9b)H>xLX`BV(IzPvNDs75v}wyx5XzSgD7eSD(&2XDx~nMw3W z-o{zcK9yCB!|E!W>0PD?Ys6@#&m|-7(@}t*o2z1mZ2y!%XH0;IlxhG?^Skl|S|zfs zOx^-&H`8x;6h&_*@9dAN^RTYfaixCAGqW~Q%i2BTXy(XYRGz;pCr}`K^Ze^c^oIGcn(c0#aSYe%0KZ3YvFG(a3JMIYfBn!#T-KHqgDg z_2+<2kJ4wG8!k#4p-%ptK%vp&{B{7au?ozlcDJtJscoP2a3OyFi}7F#U;2*cz*>5aN5qfi)Drrgl z(pE`cAQ(0v%GfDT1vVB&OgaX#;aRFnER?hIZFAg|$8YKI?56?ZEt<|%r%AJGcXJ}B1Nb_b+#z(gmct?pM&gu;YEXzo-KgN7Yy$DYt< zk!-mCqrWN0nqU@5flaxnK%G_Mx&eg;gGNu(=l2kDVhy`ml zl|zk*(DCj#Vv7bpL9$E$DKYjEVUv`cuODFrEO zo@eynL2d6w;Bx%6YGKGSK#cbs#z2 zV;QS?7z*98g!Hq357|*cPCmTz=>$c?tm#l&0XEOk>RA6SIehmB#cyv;;^270F!8Dp zI}>)pgcO;B!HBtA&0}EGaG+x1U3rEDC;u{p{k2E8?tg0;BgaNcVIRw2wZTxzUkP%~ z#rFWwRG=oS!VHpAwbVGZ%t8FCzI|ve&gxVlZ-JNBI-y-5gOf?c!P2b)&X#!fAD&ht zwVUji6F3yF1H{lpy*e1Y%-LctgEGJw1rq__vs#n!@U^*zoO-i)vThL+)glQ4Z-DBE za5S)k7lZkm%TD20T9mqKcYIuwEEANDM}f+;g0)j`oNk?5)ObtA!1pi%{B!eoA>&iQ zN1%jrD7=~d$N-mt_^QIS_&g{I#lAu^^9wV62} zp9eT`D**X~asm*RwLrC8!+7d3|H(Q>yf?_M)ZlWB^U`{H)X;WdoMk8|mcVUzozU&D zY1f0UVi2uwjsyv9P6Y8Pvo*Y@9wYy|2S|XFS|@535aoNaAqEn^Ie4L>BOsn(3Ov8p z9D6wc0`=10W7JP@)eJziD-`_o2L4A`8J>NFG}U{RhrFP?qhV?Qkn?d-*YNPnp1aG? z7yP17Pj9T@3VFEh;Tc-|Sv-W-`3%72LX_?=2i^5ZnX(JKnetWlSsAIwT*`J}s^>D8 zz3EQB;g>tE62}eR8)W-w`E6Gkpg%e92t5SJwLLvxZ#&kDe!isI%OKDyeD2^IF|o$% z{0`n@r>7_FDIPuL*iklx$W2aK%hpi?J6Cfuu&ctB%6_{8kAJtrkN0}~bf_JSq&eAT zyq9lJmKx#NQ(1#T(?aD~M0<|{*jTacf2SgoF+i}?o2!fLL)*U+n+ggUi8Y%-qLaW-x;0$Tzho#ABX_oANEZ3#J43pBdG@xx8 z=lEW45%vO04yxgm{yP=^Yq+<5pQ`?^p$C8c*Xj-LX&JT;6nc=+%|*#yul>)E&+Q}Z zh?I%??9Ik;n;9j|bu~=Sw*>CX-@7#!{xDdi$HU#qK>pq29ymU8yBs=k!~Y0fyYGDF??K`~ z0b_D}J-%#rqEega=}DblCwpQu2|SMGnwK9O|K2$GYk$@7sMxP^+=eNq*fP}h2?zUs z_d)-Q@BhE=YyKjb8ZoxN3lj@htU>-yzmKk~C?EiZ+nnO|C<^j3 z^MCpQ-D)bDHej-@oEfBtec9Y(q&`k#kvO%*hTuw-~257P?^yPfk-Blt(Km745LWZ*gJ?XgRn zozIV-L1b#@V6^^vdNpi?9n97njC#4P!}{xq_s37TJ=FXn!Fgk7gBC|JC*0w&7^N&P zRAXH}o-%LyT@Qt)5$xO+w#X4;HQY_tDEfK4*ph>4%M^~+(Dm`wwT^&W;7Hnn-!EcP zM-L1Pj!^OC2JSN^4rly5gl~L0=UL*&b`*-^wMI(q7U02x;E6;FV-dNRHHLD+?T;U* zI6b^OG`F%$?ILh^4|huz8tdw6r!)5&GzSZ3Zi>Sk%h4M#tC^iyPd1x^0)zf`+MBpl z{8k9Gq-#bi6oJ6&cmR<(;8cz>Pa{jvYwW(9(=pOa{xU{{~+^CBBr-_qyek+O&fERpp#QB>7 z#Rh>?6oOSNyY+A+*CB^a^05%mjSNc`Xl_m8&@peMQHd6EyGH?{?y~-Rg&v}*p()N~ zBp~qhZ}l0H%hJ-Wj)XER5aL9xajl?VQ$vgY;K!_uK|fo?YawhL2g7;yCz#`HD8_Qf zAVZ_`JHBAWy-^p~9xL8(#JWQcau|GhG~Kv1lC1vG)q_L~;4L5gyo{_dG?Sl?+h^Uq zOg(}|FK-3O|9a=qLWWcb{_zBUh^={PX`g1#APaWid3mRIp~xe$uP2i3pYgh_fUI;M z8GV8QM^E7WgbcMcfbO!ipq>WH9m``G-=oE`F*Jm4H5KP*&WGvoLeR!sm<%u4e_HW? zo9y!DCSm0>+)+z~6%Tf3{%JvFa&nFNa)Q0(BiriYyp_gk=hqY4E6ec$d0*~Vm)<{` zvw%Tijiq3N^f&XU^!^zG)eT41jSpg7FL3Jvcl{6pbGmP8Qamz@rCOxkq^?RaGFiw< zVlcNb8yOw)Js=%(U1%F1be@Z~AIqB1DWFgv*!NyMM|#t|-Q4oy_{{O2uh#D7Q>g2f z@*-=Vdq#uXe*IamXkpGn!I|U9=J1bp`E-qte7daWC7}E)JI5fP|7G#NR!YxjO~fy` z(G1tau!g)i);5x1`7G!*5#%7*WpFC+uQh)`7ST^$q?#;e!u70aO!%KW)ACtLs`fLJ z2;`%N-Pr=R`n!63`8q*|-X%V2BT z5e`n}ZoKnHM^8TFU)}%x>A?Q_KNH@QF=BqON(vb(t#Vj^sFhe)D8ZO;5>6QAUUPfn zU;8-Wy(CA;gJVPfxjz4+TyY=$`&R6K(fIxUuYpDLp8_NP|49D7K9Wag8*6aWAK literal 0 HcmV?d00001 diff --git a/notebooks/60_MoSeq.ipynb b/notebooks/60_MoSeq.ipynb index b22c0c015..6ea11af9e 100644 --- a/notebooks/60_MoSeq.ipynb +++ b/notebooks/60_MoSeq.ipynb @@ -8,7 +8,11 @@ "\n", "**NOTE: This notebook is a work in progress.**\n", "\n", - "This notebook provides a tutorial on how to use the MoSeq pipeline to analyze behavioral data. The pipeline is a tool for taking keypoint pose estimations and extracting behavioral syllables." + "This notebook provides a tutorial on how to use the MoSeq pipeline to analyze behavioral data. The pipeline is a tool for taking keypoint pose estimations and extracting behavioral syllables.\n", + "\n", + "Here is a schematic showing the tables used in this pipeline.\n", + "\n", + "![moseq_outline.png|2000x900](./../notebook-images/moseq_outline.png)\n" ] }, { From 2e9ea466ea96ac8bbdcaa70f989a94c78351ca2a Mon Sep 17 00:00:00 2001 From: Samuel Bray Date: Wed, 26 Jun 2024 09:53:43 -0700 Subject: [PATCH 08/42] get rid of PoseOutput and fetch pose data from PositionOutput --- src/spyglass/common/common_position.py | 6 ++++++ src/spyglass/position/position_merge.py | 20 ++++++++++++++++++ .../position/v1/position_dlc_selection.py | 21 +++++++++++++++++++ .../position/v1/position_trodes_position.py | 13 +++++++++++- 4 files changed, 59 insertions(+), 1 deletion(-) diff --git a/src/spyglass/common/common_position.py b/src/spyglass/common/common_position.py index ed91aa463..e1a551c82 100644 --- a/src/spyglass/common/common_position.py +++ b/src/spyglass/common/common_position.py @@ -510,6 +510,12 @@ def _data_to_df(data, prefix="head_", add_frame_ind=False): return df + def fetch_pose_datframe(self): + raise NotImplementedError("No Pose data available for this table") + + def fetch_video_name(self): + return self.fetch_nwb()[0]["head_position"].get_comments() + @schema class PositionVideo(SpyglassMixin, dj.Computed): diff --git a/src/spyglass/position/position_merge.py b/src/spyglass/position/position_merge.py index 1de935482..6bd3447c5 100644 --- a/src/spyglass/position/position_merge.py +++ b/src/spyglass/position/position_merge.py @@ -90,6 +90,26 @@ def fetch1_dataframe(self): ) return query.fetch1_dataframe() + def fetch_pose_dataframe(self): + key = self.merge_restrict(self.proj()).proj() + query = ( + source_class_dict[ + to_camel_case(self.merge_get_parent(self.proj()).table_name) + ] + & key + ) + return query.fetch_pose_dataframe() + + def fetch_video_name(self): + key = self.merge_restrict(self.proj()).proj() + query = ( + source_class_dict[ + to_camel_case(self.merge_get_parent(self.proj()).table_name) + ] + & key + ) + return query.fetch_video_name() + @schema class PositionVideoSelection(SpyglassMixin, dj.Manual): diff --git a/src/spyglass/position/v1/position_dlc_selection.py b/src/spyglass/position/v1/position_dlc_selection.py index 02692ce14..8236e7c4e 100644 --- a/src/spyglass/position/v1/position_dlc_selection.py +++ b/src/spyglass/position/v1/position_dlc_selection.py @@ -248,6 +248,27 @@ def evaluate_pose_estimation(cls, key): } return sub_thresh_percent_dict + def fetch_pose_dataframe(self): + """fetches the pose data from the pose estimation table + + Returns + ------- + pd.DataFrame + pose data + """ + key = self.fetch1("KEY") + return (DLCPoseEstimation & key).fetch_dataframe() + + def fetch_video_name(self): + """Return the video path for pose estimate + + Returns + ------- + str + absolute path to video file + """ + return (DLCPoseEstimationSelection & self).fetch1("video_path") + @schema class DLCPosVideoParams(SpyglassMixin, dj.Manual): diff --git a/src/spyglass/position/v1/position_trodes_position.py b/src/spyglass/position/v1/position_trodes_position.py index 86487ad23..38ef85b3c 100644 --- a/src/spyglass/position/v1/position_trodes_position.py +++ b/src/spyglass/position/v1/position_trodes_position.py @@ -7,6 +7,7 @@ from datajoint.utils import to_camel_case from tqdm import tqdm as tqdm +from spyglass.common import PositionIntervalMap, TaskEpoch from spyglass.common.common_behav import RawPosition from spyglass.common.common_nwbfile import AnalysisNwbfile from spyglass.common.common_position import IntervalPositionInfo @@ -232,6 +233,16 @@ def fetch1_dataframe(self, add_frame_ind=True): self.fetch_nwb()[0], prefix="", add_frame_ind=add_frame_ind ) + def fetch_pose_dataframe(self): + raise NotImplementedError("No pose data for TrodesPosV1") + + def fetch_video_path(self): + nwb_file_name = self.fetch1("nwb_file_name") + epoch = ( + TaskEpoch() * PositionIntervalMap() & self.fetch1("KEY") + ).fetch("epoch")[0] + return get_video_path(nwb_file_name) + @schema class TrodesPosVideo(SpyglassMixin, dj.Computed): @@ -267,7 +278,7 @@ def make(self, key): .replace(" valid times", "") ) + 1 - ) + ) # TODO: Fix this hack ( video_path, From 62c8eefdb907807169c47afeab60d89b16742cca Mon Sep 17 00:00:00 2001 From: Sam Bray Date: Tue, 6 Aug 2024 10:21:41 -0700 Subject: [PATCH 09/42] remove PoseOutput and corresponding references --- src/spyglass/behavior/core.py | 11 +++--- src/spyglass/position/position_merge.py | 48 ------------------------- 2 files changed, 6 insertions(+), 53 deletions(-) diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/core.py index 6b1ceaa43..413742e97 100644 --- a/src/spyglass/behavior/core.py +++ b/src/spyglass/behavior/core.py @@ -5,7 +5,7 @@ import numpy as np import pandas as pd -from spyglass.position.position_merge import PoseOutput +from spyglass.position.position_merge import PositionOutput from spyglass.utils import SpyglassMixin, SpyglassMixinPart schema = dj.schema("behavior_core_v1") @@ -22,7 +22,7 @@ class PoseGroup(SpyglassMixin, dj.Manual): class Pose(SpyglassMixinPart): definition = """ -> PoseGroup - -> PoseOutput.proj(pose_merge_id='merge_id') + -> PositionOutput.proj(pose_merge_id='merge_id') """ def create_group( @@ -85,9 +85,10 @@ def fetch_pose_datasets( datasets = {} for merge_key in (self.Pose & key).proj(merge_id="pose_merge_id"): video_name = ( - Path((PoseOutput & merge_key).fetch_video_name()).stem + ".mp4" + Path((PositionOutput & merge_key).fetch_video_name()).stem + + ".mp4" ) - bodyparts_df = (PoseOutput & merge_key).fetch_dataframe() + bodyparts_df = (PositionOutput & merge_key).fetch_dataframe() if bodyparts is None: bodyparts = ( bodyparts_df.keys().get_level_values(0).unique().values @@ -114,7 +115,7 @@ def fetch_video_paths(self, key: dict = None): if key is None: key = {} video_paths = [ - Path((PoseOutput & merge_key).fetch_video_name()) + Path((PositionOutput & merge_key).fetch_video_name()) for merge_key in (self.Pose & key).proj(merge_id="pose_merge_id") ] return video_paths diff --git a/src/spyglass/position/position_merge.py b/src/spyglass/position/position_merge.py index 6bd3447c5..6b007f876 100644 --- a/src/spyglass/position/position_merge.py +++ b/src/spyglass/position/position_merge.py @@ -282,51 +282,3 @@ def make(self, key): disable_progressbar=False, ) self.insert1(key) - - -@schema -class PoseOutput(_Merge, SpyglassMixin): - """ - Table to identify source of keypoint(s) tracking animal Pose from upstream options - (e.g. DLC, Sleap, etc...) To add another upstream option, a new Part table - should be added in the same syntax as DLCPos and TrodesPos. - """ - - definition = """ - merge_id: uuid - --- - source: varchar(32) - """ - - class DLCPoseEstimation(SpyglassMixin, dj.Part): - """ - Table to pass-through upstream DLC Pose Estimation information - """ - - definition = """ - -> PoseOutput - --- - -> DLCPoseEstimation - """ - - def fetch_dataframe(self): - # proj replaces operator restriction to enable - # (TableName & restriction).fetch1_dataframe() - key = self.merge_restrict(self.proj()).proj() - query = ( - source_class_dict[ - to_camel_case(self.merge_get_parent(self.proj()).table_name) - ] - & key - ) - return query.fetch_dataframe() - - def fetch_video_name(self): - key = self.merge_restrict(self.proj()).proj() - query = ( - source_class_dict[ - to_camel_case(self.merge_get_parent(self.proj()).table_name) - ] - & key - ) - return query.fetch_video_name() From 36ad01643fc35430d6937936753a17ab1365697a Mon Sep 17 00:00:00 2001 From: Sam Bray Date: Tue, 6 Aug 2024 12:00:16 -0700 Subject: [PATCH 10/42] allow passing of null entries from DLCPoseEstimation to PositionOutput for Pose-dependent analysis --- .../position/v1/position_dlc_centroid.py | 27 +++- .../position/v1/position_dlc_cohort.py | 6 +- .../position/v1/position_dlc_orient.py | 23 +-- .../position/v1/position_dlc_selection.py | 138 ++++++++++-------- 4 files changed, 123 insertions(+), 71 deletions(-) diff --git a/src/spyglass/position/v1/position_dlc_centroid.py b/src/spyglass/position/v1/position_dlc_centroid.py index 70a1c1252..82de82eb0 100644 --- a/src/spyglass/position/v1/position_dlc_centroid.py +++ b/src/spyglass/position/v1/position_dlc_centroid.py @@ -152,12 +152,31 @@ def make(self, key): cohort_entries = DLCSmoothInterpCohort.BodyPart & key params = (DLCCentroidParams() & key).fetch1("params") centroid_method = params.pop("centroid_method") - bodyparts_avail = cohort_entries.fetch("bodypart") - speed_smoothing_std_dev = params.pop("speed_smoothing_std_dev") - if not centroid_method: raise ValueError("Please specify a centroid method to use.") validate_option(option=centroid_method, options=_key_to_func_dict) + # Handle the null centroid case + if centroid_method == "null": + logger.logger.warning("Null centroid method selected") + null_obj_id = AnalysisNwbfile().add_nwb_object( + analysis_file_name, pd.DataFrame() + ) + key.update( + { + "analysis_file_name": analysis_file_name, + "dlc_position_object_id": null_obj_id, + "dlc_velocity_object_id": null_obj_id, + } + ) + AnalysisNwbfile().add( + nwb_file_name=key["nwb_file_name"], + analysis_file_name=key["analysis_file_name"], + ) + self.insert1(key) + return + + bodyparts_avail = cohort_entries.fetch("bodypart") + speed_smoothing_std_dev = params.pop("speed_smoothing_std_dev") points = params.get("points") required_points = _key_to_points.get(centroid_method) @@ -816,9 +835,11 @@ def one_pt_centroid(pos_df: pd.DataFrame, **params): "four_led_centroid": four_led_centroid, "two_pt_centroid": two_pt_centroid, "one_pt_centroid": one_pt_centroid, + "null": None, } _key_to_points = { "four_led_centroid": ["greenLED", "redLED_L", "redLED_C", "redLED_R"], "two_pt_centroid": ["point1", "point2"], "one_pt_centroid": ["point1"], + "null": [], } diff --git a/src/spyglass/position/v1/position_dlc_cohort.py b/src/spyglass/position/v1/position_dlc_cohort.py index 6cf1f0eee..2d226bcde 100644 --- a/src/spyglass/position/v1/position_dlc_cohort.py +++ b/src/spyglass/position/v1/position_dlc_cohort.py @@ -97,13 +97,17 @@ def make(self, key): ) as logger: logger.logger.info("-----------------------") logger.logger.info("Bodypart Cohort") - # from Jen Guidera self.insert1(key) cohort_selection = (DLCSmoothInterpCohortSelection & key).fetch1() table_entries = [] bodyparts_params_dict = cohort_selection.pop( "bodyparts_params_dict" ) + if len(bodyparts_params_dict) == 0: + logger.logger.warn( + "No bodyparts specified in bodyparts_params_dict" + ) + return temp_key = cohort_selection.copy() for bodypart, params in bodyparts_params_dict.items(): temp_key["bodypart"] = bodypart diff --git a/src/spyglass/position/v1/position_dlc_orient.py b/src/spyglass/position/v1/position_dlc_orient.py index f64802a59..4d590db3d 100644 --- a/src/spyglass/position/v1/position_dlc_orient.py +++ b/src/spyglass/position/v1/position_dlc_orient.py @@ -89,16 +89,21 @@ def make(self, key): # Get labels to smooth from Parameters table AnalysisNwbfile()._creation_times["pre_create_time"] = time() cohort_entries = DLCSmoothInterpCohort.BodyPart & key - pos_df = pd.concat( - { - bodypart: ( - DLCSmoothInterpCohort.BodyPart - & {**key, **{"bodypart": bodypart}} - ).fetch1_dataframe() - for bodypart in cohort_entries.fetch("bodypart") - }, - axis=1, + pos_df = ( + pd.concat( + { + bodypart: ( + DLCSmoothInterpCohort.BodyPart + & {**key, **{"bodypart": bodypart}} + ).fetch1_dataframe() + for bodypart in cohort_entries.fetch("bodypart") + }, + axis=1, + ) + if cohort_entries + else pd.DataFrame() ) + params = (DLCOrientationParams() & key).fetch1("params") orientation_smoothing_std_dev = params.pop( "orientation_smoothing_std_dev", None diff --git a/src/spyglass/position/v1/position_dlc_selection.py b/src/spyglass/position/v1/position_dlc_selection.py index 8236e7c4e..837daf078 100644 --- a/src/spyglass/position/v1/position_dlc_selection.py +++ b/src/spyglass/position/v1/position_dlc_selection.py @@ -65,69 +65,84 @@ def make(self, key): pos_nwb = (DLCCentroid & key).fetch_nwb()[0] ori_nwb = (DLCOrientation & key).fetch_nwb()[0] - pos_obj = pos_nwb["dlc_position"].spatial_series["position"] - vel_obj = pos_nwb["dlc_velocity"].time_series["velocity"] - vid_frame_obj = pos_nwb["dlc_velocity"].time_series["video_frame_ind"] - ori_obj = ori_nwb["dlc_orientation"].spatial_series["orientation"] - - position = pynwb.behavior.Position() - orientation = pynwb.behavior.CompassDirection() - velocity = pynwb.behavior.BehavioralTimeSeries() - - position.create_spatial_series( - name=pos_obj.name, - timestamps=np.asarray(pos_obj.timestamps), - conversion=pos_obj.conversion, - data=np.asarray(pos_obj.data), - reference_frame=pos_obj.reference_frame, - comments=pos_obj.comments, - description=pos_obj.description, - ) + if isinstance(pos_nwb["dlc_position"], pd.DataFrame): + # Null entry case + key["analysis_file_name"] = AnalysisNwbfile().create( + nwb_file_name=key["nwb_file_name"] + ) + obj_id = AnalysisNwbfile().add_nwb_object( + key["analysis_file_name"], pd.DataFrame() + ) + key["position_object_id"] = obj_id + key["orientation_object_id"] = obj_id + key["velocity_object_id"] = obj_id - orientation.create_spatial_series( - name=ori_obj.name, - timestamps=np.asarray(ori_obj.timestamps), - conversion=ori_obj.conversion, - data=np.asarray(ori_obj.data), - reference_frame=ori_obj.reference_frame, - comments=ori_obj.comments, - description=ori_obj.description, - ) + else: + pos_obj = pos_nwb["dlc_position"].spatial_series["position"] + vel_obj = pos_nwb["dlc_velocity"].time_series["velocity"] + vid_frame_obj = pos_nwb["dlc_velocity"].time_series[ + "video_frame_ind" + ] + ori_obj = ori_nwb["dlc_orientation"].spatial_series["orientation"] + + position = pynwb.behavior.Position() + orientation = pynwb.behavior.CompassDirection() + velocity = pynwb.behavior.BehavioralTimeSeries() + + position.create_spatial_series( + name=pos_obj.name, + timestamps=np.asarray(pos_obj.timestamps), + conversion=pos_obj.conversion, + data=np.asarray(pos_obj.data), + reference_frame=pos_obj.reference_frame, + comments=pos_obj.comments, + description=pos_obj.description, + ) - velocity.create_timeseries( - name=vel_obj.name, - timestamps=np.asarray(vel_obj.timestamps), - conversion=vel_obj.conversion, - unit=vel_obj.unit, - data=np.asarray(vel_obj.data), - comments=vel_obj.comments, - description=vel_obj.description, - ) + orientation.create_spatial_series( + name=ori_obj.name, + timestamps=np.asarray(ori_obj.timestamps), + conversion=ori_obj.conversion, + data=np.asarray(ori_obj.data), + reference_frame=ori_obj.reference_frame, + comments=ori_obj.comments, + description=ori_obj.description, + ) - velocity.create_timeseries( - name=vid_frame_obj.name, - unit=vid_frame_obj.unit, - timestamps=np.asarray(vid_frame_obj.timestamps), - data=np.asarray(vid_frame_obj.data), - description=vid_frame_obj.description, - comments=vid_frame_obj.comments, - ) + velocity.create_timeseries( + name=vel_obj.name, + timestamps=np.asarray(vel_obj.timestamps), + conversion=vel_obj.conversion, + unit=vel_obj.unit, + data=np.asarray(vel_obj.data), + comments=vel_obj.comments, + description=vel_obj.description, + ) - key["analysis_file_name"] = AnalysisNwbfile().create( - key["nwb_file_name"] - ) - nwb_analysis_file = AnalysisNwbfile() - key["orientation_object_id"] = nwb_analysis_file.add_nwb_object( - key["analysis_file_name"], orientation - ) - key["position_object_id"] = nwb_analysis_file.add_nwb_object( - key["analysis_file_name"], position - ) - key["velocity_object_id"] = nwb_analysis_file.add_nwb_object( - key["analysis_file_name"], velocity - ) + velocity.create_timeseries( + name=vid_frame_obj.name, + unit=vid_frame_obj.unit, + timestamps=np.asarray(vid_frame_obj.timestamps), + data=np.asarray(vid_frame_obj.data), + description=vid_frame_obj.description, + comments=vid_frame_obj.comments, + ) + + key["analysis_file_name"] = AnalysisNwbfile().create( + key["nwb_file_name"] + ) + nwb_analysis_file = AnalysisNwbfile() + key["orientation_object_id"] = nwb_analysis_file.add_nwb_object( + key["analysis_file_name"], orientation + ) + key["position_object_id"] = nwb_analysis_file.add_nwb_object( + key["analysis_file_name"], position + ) + key["velocity_object_id"] = nwb_analysis_file.add_nwb_object( + key["analysis_file_name"], velocity + ) - nwb_analysis_file.add( + AnalysisNwbfile().add( nwb_file_name=key["nwb_file_name"], analysis_file_name=key["analysis_file_name"], ) @@ -194,6 +209,13 @@ def evaluate_pose_estimation(cls, key): orientation_key["dlc_si_cohort_selection_name"] = key[ "dlc_si_cohort_orientation" ] + + # check for the null cohort case + if not (DLCSmoothInterpCohort.BodyPart & centroid_key) and not ( + DLCSmoothInterpCohort.BodyPart & orientation_key + ): + return {} + centroid_bodyparts, centroid_si_params = ( DLCSmoothInterpCohort.BodyPart & centroid_key ).fetch("bodypart", "dlc_si_params_name") From fe3c6d4329c769033eb954f2bb5dcd9efeed4cd1 Mon Sep 17 00:00:00 2001 From: Samuel Bray Date: Fri, 20 Dec 2024 09:38:37 -0800 Subject: [PATCH 11/42] Apply suggestions from code review Co-authored-by: Chris Broz --- src/spyglass/behavior/core.py | 11 +++++------ src/spyglass/behavior/moseq.py | 11 +++-------- 2 files changed, 8 insertions(+), 14 deletions(-) diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/core.py index 413742e97..ef35d1910 100644 --- a/src/spyglass/behavior/core.py +++ b/src/spyglass/behavior/core.py @@ -30,13 +30,13 @@ def create_group( group_name: str, merge_ids: list[str], bodyparts: list[str] = None, - ): - """create a group of pose information + ) -> None: + """Create a group of pose information Parameters ---------- group_name : str - name of the group + Name of the group keys : list[dict] list of keys from PoseOutput to include in the group bodyparts : list[str], optional @@ -114,11 +114,10 @@ def fetch_video_paths(self, key: dict = None): """ if key is None: key = {} - video_paths = [ + return [ Path((PositionOutput & merge_key).fetch_video_name()) for merge_key in (self.Pose & key).proj(merge_id="pose_merge_id") ] - return video_paths def format_dataset_for_moseq( @@ -184,7 +183,7 @@ def results_to_df(results): if "latent_state" in results[key].keys(): latent_dim = results[key]["latent_state"].shape[1] column_names.append( - [f"latent_state {i}" for i in range(latent_dim)] + [f"latent_state_{i}" for i in range(latent_dim)] ) data.append(results[key]["latent_state"]) diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index 336931528..6c0d9e38a 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -23,7 +23,7 @@ class MoseqModelParams(SpyglassMixin, dj.Manual): """ def make_training_extension_params( - self, model_key, num_epochs, new_name=None, skip_duplicates=False + self, model_key:dict, num_epochs:int, new_name:str=None, skip_duplicates:bool=False ): """Method to create a new set of model parameters for extending training @@ -37,6 +37,7 @@ def make_training_extension_params( name for the new model parameters, by default None skip_duplicates : bool, optional whether to skip duplicates, by default False + Returns ------- dict @@ -224,11 +225,6 @@ def analyze_pca(self, key: dict = None): ---------- key : dict key to a single MoseqModel table entry - - Raises - ------ - NotImplementedError - This method is not implemented yet. """ if key is None: key = {} @@ -254,11 +250,10 @@ def fetch_model(self, key: dict = None): """ if key is None: key = {} - model = kpms.load_checkpoint( + return kpms.load_checkpoint( (self & key).fetch1("project_dir"), (self & key).fetch1("model_name"), )[0] - return model @schema From b8dfd4245a983ac0fcd464d652b24c5bc00961e3 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 20 Dec 2024 11:17:53 -0800 Subject: [PATCH 12/42] lint --- src/spyglass/behavior/moseq.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index 6c0d9e38a..26d6e5805 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -23,7 +23,11 @@ class MoseqModelParams(SpyglassMixin, dj.Manual): """ def make_training_extension_params( - self, model_key:dict, num_epochs:int, new_name:str=None, skip_duplicates:bool=False + self, + model_key: dict, + num_epochs: int, + new_name: str = None, + skip_duplicates: bool = False, ): """Method to create a new set of model parameters for extending training @@ -37,7 +41,7 @@ def make_training_extension_params( name for the new model parameters, by default None skip_duplicates : bool, optional whether to skip duplicates, by default False - + Returns ------- dict From 310abf7583c8b2fc6ae8d72d40651a06b3e440eb Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 20 Dec 2024 12:48:21 -0800 Subject: [PATCH 13/42] implement changes from review --- src/spyglass/behavior/core.py | 44 +++++++++++------------- src/spyglass/behavior/moseq.py | 62 ++++++++++++++++++++-------------- 2 files changed, 56 insertions(+), 50 deletions(-) diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/core.py index ef35d1910..d2fb78306 100644 --- a/src/spyglass/behavior/core.py +++ b/src/spyglass/behavior/core.py @@ -1,5 +1,5 @@ from pathlib import Path -from uuid import uuid4 +from typing import List import datajoint as dj import numpy as np @@ -8,7 +8,7 @@ from spyglass.position.position_merge import PositionOutput from spyglass.utils import SpyglassMixin, SpyglassMixinPart -schema = dj.schema("behavior_core_v1") +schema = dj.schema("behavior_v1_core") @schema @@ -28,8 +28,8 @@ class Pose(SpyglassMixinPart): def create_group( self, group_name: str, - merge_ids: list[str], - bodyparts: list[str] = None, + merge_ids: List[str], + bodyparts: List[str] = None, ) -> None: """Create a group of pose information @@ -37,9 +37,9 @@ def create_group( ---------- group_name : str Name of the group - keys : list[dict] + keys : List[dict] list of keys from PoseOutput to include in the group - bodyparts : list[str], optional + bodyparts : List[str], optional body parts to include in the group, by default None includes all from every set """ group_key = { @@ -84,10 +84,9 @@ def fetch_pose_datasets( bodyparts = (self & key).fetch1("bodyparts") datasets = {} for merge_key in (self.Pose & key).proj(merge_id="pose_merge_id"): - video_name = ( - Path((PositionOutput & merge_key).fetch_video_name()).stem - + ".mp4" - ) + video_name = Path( + (PositionOutput & merge_key).fetch_video_name() + ).name bodyparts_df = (PositionOutput & merge_key).fetch_dataframe() if bodyparts is None: bodyparts = ( @@ -109,7 +108,7 @@ def fetch_video_paths(self, key: dict = None): Returns ------- - list[Path] + List[Path] list of video paths """ if key is None: @@ -122,8 +121,8 @@ def fetch_video_paths(self, key: dict = None): def format_dataset_for_moseq( datasets: dict[str, pd.DataFrame], - bodyparts: list[str], - coordinate_axes: list[str] = ["x", "y"], + bodyparts: List[str], + coordinate_axes: List[str] = ["x", "y"], ): """format pose datasets for MoSeq @@ -131,8 +130,10 @@ def format_dataset_for_moseq( ---------- datasets : dict[str, pd.DataFrame] dictionary of video name to pose dataset - bodyparts : list[str] + bodyparts : List[str] list of body parts to include in the pose + coordinate_axes : List[str], optional + list of coordinate axes to include, by default ["x", "y"] Returns ------- @@ -145,17 +146,12 @@ def format_dataset_for_moseq( confidences = {} for video_name, bodyparts_df in datasets.items(): - coordinates_i = None - confidences_i = None + num_frames = len(bodyparts_df[bodyparts[0]]) + coordinates_i = np.empty((num_frames, num_keypoints, num_dimensions)) + confidences_i = np.empty((num_frames, num_keypoints)) + for i, bodypart in enumerate(bodyparts): part_df = bodyparts_df[bodypart] - print(len(part_df)) - if coordinates_i is None: - num_frames = len(part_df) - coordinates_i = np.empty( - (num_frames, num_keypoints, num_dimensions) - ) - confidences_i = np.empty((num_frames, num_keypoints)) coordinates_i[:, i, :] = part_df[coordinate_axes].values confidences_i[:, i] = part_df["likelihood"].values coordinates[video_name] = coordinates_i @@ -164,7 +160,7 @@ def format_dataset_for_moseq( def results_to_df(results): - for key in results.keys(): + for key in results: column_names, data = [], [] if "syllable" in results[key].keys(): diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index 26d6e5805..a0f116870 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -6,7 +6,7 @@ import keypoint_moseq as kpms from spyglass.common import AnalysisNwbfile -from spyglass.position.position_merge import PoseOutput +from spyglass.position.position_merge import PositionOutput from spyglass.utils import SpyglassMixin from .core import PoseGroup, format_dataset_for_moseq, results_to_df @@ -155,28 +155,10 @@ def make(self, key): model_name = self._make_model_name(key) initial_model_key = model_params.get("initial_model", None) if initial_model_key is None: - # fit pca of data - pca = kpms.fit_pca(**data, **config()) - kpms.save_pca(pca, project_dir) - - # create the model - model = kpms.init_model(data, pca=pca, **config()) - # run the autoregressive fit on the model - num_ar_iters = model_params["num_ar_iters"] - model, model_name = kpms.fit_model( - model, - data, - metadata, - project_dir, - ar_only=True, - num_iters=num_ar_iters, - model_name=model_name + "_ar", + model, model_name = self._initialize_model( + data, metadata, project_dir, model_name, config, model_params ) - epochs_trained = num_ar_iters - # load model checkpoint - # model, data, metadata, current_iter = kpms.load_checkpoint( - # project_dir, model_name, iteration=num_ar_iters - # ) + epochs_trained = model_params["num_ar_iters"] else: # begin training from an existing model @@ -219,8 +201,36 @@ def _make_model_name(self, key: dict = None): if key is None: key = {} key = (MoseqModelSelection & key).fetch1("KEY") - key_string = "_".join(key.values()) - return hashlib.sha1(key_string.encode("utf-8")).hexdigest()[:10] + return dj.hash.key_hash(key) + + @staticmethod + def _initialize_model( + data, metadata, project_dir, model_name, config, model_params + ): + """Method to initialize a model. Creates model and runs initional ARHMM fit + + Returns + ------- + tuple + model, model_name + """ + # fit pca of data + pca = kpms.fit_pca(**data, **config()) + kpms.save_pca(pca, project_dir) + + # create the model + model = kpms.init_model(data, pca=pca, **config()) + # run the autoregressive fit on the model + num_ar_iters = model_params["num_ar_iters"] + return kpms.fit_model( + model, + data, + metadata, + project_dir, + ar_only=True, + num_iters=num_ar_iters, + model_name=model_name + "_ar", + ) def analyze_pca(self, key: dict = None): """Method to analyze the PCA of a model @@ -263,7 +273,7 @@ def fetch_model(self, key: dict = None): @schema class MoseqSyllableSelection(SpyglassMixin, dj.Manual): definition = """ - -> PoseOutput.proj(pose_merge_id='merge_id') + -> PositionOutput.proj(pose_merge_id='merge_id') -> MoseqModel --- num_iters = 500: int @@ -280,7 +290,7 @@ def validate_bodyparts(self, key): return model_bodyparts = (PoseGroup & key).fetch1("bodyparts") merge_key = {"merge_id": key["pose_merge_id"]} - bodyparts_df = (PoseOutput & merge_key).fetch_dataframe() + bodyparts_df = (PositionOutput & merge_key).fetch_dataframe() data_bodyparts = bodyparts_df.keys().get_level_values(0).unique().values for bodypart in model_bodyparts: if bodypart not in data_bodyparts: From 69335a821313e6b0c36943eadd2b4293b4c7d440 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 20 Dec 2024 12:54:25 -0800 Subject: [PATCH 14/42] rename fetch_video_name to fetch_video_path --- src/spyglass/behavior/core.py | 4 ++-- src/spyglass/behavior/moseq.py | 2 +- src/spyglass/common/common_position.py | 2 +- src/spyglass/position/position_merge.py | 4 ++-- src/spyglass/position/v1/position_dlc_pose_estimation.py | 2 +- src/spyglass/position/v1/position_dlc_selection.py | 2 +- 6 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/core.py index d2fb78306..6d6fc19d7 100644 --- a/src/spyglass/behavior/core.py +++ b/src/spyglass/behavior/core.py @@ -85,7 +85,7 @@ def fetch_pose_datasets( datasets = {} for merge_key in (self.Pose & key).proj(merge_id="pose_merge_id"): video_name = Path( - (PositionOutput & merge_key).fetch_video_name() + (PositionOutput & merge_key).fetch_video_path() ).name bodyparts_df = (PositionOutput & merge_key).fetch_dataframe() if bodyparts is None: @@ -114,7 +114,7 @@ def fetch_video_paths(self, key: dict = None): if key is None: key = {} return [ - Path((PositionOutput & merge_key).fetch_video_name()) + Path((PositionOutput & merge_key).fetch_video_path()) for merge_key in (self.Pose & key).proj(merge_id="pose_merge_id") ] diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index a0f116870..b9c96edf8 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -322,7 +322,7 @@ def make(self, key): num_iters = (MoseqSyllableSelection & key).fetch1("num_iters") # load data and format for moseq - video_path = (PoseOutput & merge_key).fetch_video_name() + video_path = (PoseOutput & merge_key).fetch_video_path() video_name = Path(video_path).stem + ".mp4" bodyparts_df = (PoseOutput & merge_key).fetch_dataframe() diff --git a/src/spyglass/common/common_position.py b/src/spyglass/common/common_position.py index 6c0769835..0a47a4d19 100644 --- a/src/spyglass/common/common_position.py +++ b/src/spyglass/common/common_position.py @@ -511,7 +511,7 @@ def _data_to_df( def fetch_pose_datframe(self): raise NotImplementedError("No Pose data available for this table") - def fetch_video_name(self): + def fetch_video_path(self): return self.fetch_nwb()[0]["head_position"].get_comments() diff --git a/src/spyglass/position/position_merge.py b/src/spyglass/position/position_merge.py index 60a85dd8f..7b25172ae 100644 --- a/src/spyglass/position/position_merge.py +++ b/src/spyglass/position/position_merge.py @@ -91,7 +91,7 @@ def fetch_pose_dataframe(self): ) return query.fetch_pose_dataframe() - def fetch_video_name(self): + def fetch_video_parh(self): key = self.merge_restrict(self.proj()).proj() query = ( source_class_dict[ @@ -99,4 +99,4 @@ def fetch_video_name(self): ] & key ) - return query.fetch_video_name() + return query.fetch_video_path() diff --git a/src/spyglass/position/v1/position_dlc_pose_estimation.py b/src/spyglass/position/v1/position_dlc_pose_estimation.py index e6b9c1abd..ba5bf63cc 100644 --- a/src/spyglass/position/v1/position_dlc_pose_estimation.py +++ b/src/spyglass/position/v1/position_dlc_pose_estimation.py @@ -409,7 +409,7 @@ def fetch_dataframe(self, *attrs, **kwargs) -> pd.DataFrame: axis=1, ) - def fetch_video_name(self): + def fetch_video_path(self): """Return the video path for pose estimate Returns diff --git a/src/spyglass/position/v1/position_dlc_selection.py b/src/spyglass/position/v1/position_dlc_selection.py index 6e24db22b..2dbfb2d40 100644 --- a/src/spyglass/position/v1/position_dlc_selection.py +++ b/src/spyglass/position/v1/position_dlc_selection.py @@ -305,7 +305,7 @@ def fetch_pose_dataframe(self): key = self.fetch1("KEY") return (DLCPoseEstimation & key).fetch_dataframe() - def fetch_video_name(self): + def fetch_video_path(self): """Return the video path for pose estimate Returns From fc46b370b49db1953844f4c65cd177648dfcb99c Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 20 Dec 2024 13:07:07 -0800 Subject: [PATCH 15/42] cleanup outdated usages of PoseOutput --- src/spyglass/behavior/core.py | 2 +- src/spyglass/behavior/moseq.py | 10 +++------- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/core.py index 6d6fc19d7..658080928 100644 --- a/src/spyglass/behavior/core.py +++ b/src/spyglass/behavior/core.py @@ -38,7 +38,7 @@ def create_group( group_name : str Name of the group keys : List[dict] - list of keys from PoseOutput to include in the group + list of keys from PositionOutput to include in the group bodyparts : List[str], optional body parts to include in the group, by default None includes all from every set """ diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index b9c96edf8..324095d69 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -1,4 +1,3 @@ -import hashlib import os from pathlib import Path @@ -322,9 +321,9 @@ def make(self, key): num_iters = (MoseqSyllableSelection & key).fetch1("num_iters") # load data and format for moseq - video_path = (PoseOutput & merge_key).fetch_video_path() + video_path = (PositionOutput & merge_key).fetch_video_path() video_name = Path(video_path).stem + ".mp4" - bodyparts_df = (PoseOutput & merge_key).fetch_dataframe() + bodyparts_df = (PositionOutput & merge_key).fetch_pose_dataframe() if bodyparts is None: bodyparts = bodyparts_df.keys().get_level_values(0).unique().values @@ -348,10 +347,7 @@ def make(self, key): results_df.index = bodyparts_df.index # save results into a nwbfile - nwb_file_name = PoseOutput.merge_get_parent(merge_key).fetch1( - "nwb_file_name" - ) - nwb_file_name = PoseOutput.merge_get_parent(merge_key).fetch1( + nwb_file_name = PositionOutput.merge_get_parent(merge_key).fetch1( "nwb_file_name" ) analysis_file_name = AnalysisNwbfile().create(nwb_file_name) From c3c7b84de0394beeee85dec5185a8fd33ae1762e Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 20 Dec 2024 14:53:17 -0800 Subject: [PATCH 16/42] Cleanup errors from removal of PoseOutput --- src/spyglass/behavior/core.py | 8 +++++++- src/spyglass/behavior/moseq.py | 8 ++++---- src/spyglass/position/position_merge.py | 7 ++----- 3 files changed, 13 insertions(+), 10 deletions(-) diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/core.py index 658080928..79b804c6c 100644 --- a/src/spyglass/behavior/core.py +++ b/src/spyglass/behavior/core.py @@ -1,3 +1,4 @@ +import warnings from pathlib import Path from typing import List @@ -45,6 +46,11 @@ def create_group( group_key = { "pose_group_name": group_name, } + if self & group_key: + warnings.warn( + f"Pose group {group_name} already exists. Skipping insertion." + ) + return self.insert1( { **group_key, @@ -87,7 +93,7 @@ def fetch_pose_datasets( video_name = Path( (PositionOutput & merge_key).fetch_video_path() ).name - bodyparts_df = (PositionOutput & merge_key).fetch_dataframe() + bodyparts_df = (PositionOutput & merge_key).fetch_pose_dataframe() if bodyparts is None: bodyparts = ( bodyparts_df.keys().get_level_values(0).unique().values diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index 324095d69..a20a76dfc 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -114,10 +114,10 @@ def make(self, key): # set up the project and config project_dir = ( - "/home/sambray/Documents/moseq_test_proj2" # TODO: make this better + "/home/sambray/Documents/moseq_test_proj3" # TODO: make this better ) video_dir = ( - "/home/sambray/Documents/moseq_test_vids2" # TODO: make this better + "/home/sambray/Documents/moseq_test_vids3" # TODO: make this better ) # make symlinks to the videos in a single directory os.makedirs(video_dir, exist_ok=True) @@ -289,12 +289,12 @@ def validate_bodyparts(self, key): return model_bodyparts = (PoseGroup & key).fetch1("bodyparts") merge_key = {"merge_id": key["pose_merge_id"]} - bodyparts_df = (PositionOutput & merge_key).fetch_dataframe() + bodyparts_df = (PositionOutput & merge_key).fetch_pose_dataframe() data_bodyparts = bodyparts_df.keys().get_level_values(0).unique().values for bodypart in model_bodyparts: if bodypart not in data_bodyparts: raise ValueError( - f"Error in row {row}: " + f"Bodypart {bodypart} not in data" + f"Error in row {key}: " + f"Bodypart {bodypart} not in data" ) diff --git a/src/spyglass/position/position_merge.py b/src/spyglass/position/position_merge.py index 7b25172ae..8a9d07a27 100644 --- a/src/spyglass/position/position_merge.py +++ b/src/spyglass/position/position_merge.py @@ -3,10 +3,7 @@ from pandas import DataFrame from spyglass.common.common_position import IntervalPositionInfo as CommonPos -from spyglass.position.v1.position_dlc_pose_estimation import ( - DLCPoseEstimation, - DLCPoseEstimationSelection, -) +from spyglass.position.v1.position_dlc_pose_estimation import DLCPoseEstimation from spyglass.position.v1.position_dlc_selection import DLCPosV1 from spyglass.position.v1.position_trodes_position import TrodesPosV1 from spyglass.utils import SpyglassMixin, _Merge @@ -91,7 +88,7 @@ def fetch_pose_dataframe(self): ) return query.fetch_pose_dataframe() - def fetch_video_parh(self): + def fetch_video_path(self): key = self.merge_restrict(self.proj()).proj() query = ( source_class_dict[ From e5b2c1bee83955719887694aca85df76844cbb88 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 20 Dec 2024 15:56:11 -0800 Subject: [PATCH 17/42] add get_position_interval_epoch --- src/spyglass/common/__init__.py | 6 ++--- src/spyglass/common/common_behav.py | 24 ++++++++++++++++++ src/spyglass/common/common_position.py | 16 ++++++------ .../position/v1/position_trodes_position.py | 25 ++++++++----------- 4 files changed, 44 insertions(+), 27 deletions(-) diff --git a/src/spyglass/common/__init__.py b/src/spyglass/common/__init__.py index 270acdf3a..ae144398b 100644 --- a/src/spyglass/common/__init__.py +++ b/src/spyglass/common/__init__.py @@ -7,6 +7,7 @@ StateScriptFile, VideoFile, convert_epoch_interval_name_to_position_interval_name, + get_position_interval_epoch, ) from spyglass.common.common_device import ( CameraDevice, @@ -40,10 +41,7 @@ intervals_by_length, ) from spyglass.common.common_lab import Institution, Lab, LabMember, LabTeam -from spyglass.common.common_nwbfile import ( - AnalysisNwbfile, - Nwbfile, -) +from spyglass.common.common_nwbfile import AnalysisNwbfile, Nwbfile from spyglass.common.common_position import ( IntervalLinearizationSelection, IntervalLinearizedPosition, diff --git a/src/spyglass/common/common_behav.py b/src/spyglass/common/common_behav.py index 53f8b7dcd..49b439278 100644 --- a/src/spyglass/common/common_behav.py +++ b/src/spyglass/common/common_behav.py @@ -686,6 +686,30 @@ def get_interval_list_name_from_epoch(nwb_file_name: str, epoch: int) -> str: return interval_names[0] +def get_position_interval_epoch( + nwb_file_name: str, position_interval_name: str +) -> int: + """Return the epoch number for a given position interval name.""" + # look up the epoch + key = dict( + nwb_file_name=nwb_file_name, + position_interval_name=position_interval_name, + ) + query = PositionIntervalMap * TaskEpoch & key + if query: + return query.fetch1("epoch") + # if no match, make sure all epoch interval names are mapped + for epoch_key in (TaskEpoch() & key).fetch( + "nwb_file_name", "interval_list_name", as_dict=True + ): + convert_epoch_interval_name_to_position_interval_name(epoch_key) + # try again + query = PositionIntervalMap * TaskEpoch & key + if query: + return query.fetch1("epoch") + return None + + def populate_position_interval_map_session(nwb_file_name: str): """Populate PositionIntervalMap for all epochs in a given NWB file.""" # 1. remove redundancy in interval names diff --git a/src/spyglass/common/common_position.py b/src/spyglass/common/common_position.py index 0a47a4d19..5216540de 100644 --- a/src/spyglass/common/common_position.py +++ b/src/spyglass/common/common_position.py @@ -1,6 +1,5 @@ import bottleneck import datajoint as dj -import matplotlib.pyplot as plt import numpy as np import pandas as pd import pynwb @@ -15,7 +14,11 @@ from position_tools.core import gaussian_smooth from tqdm import tqdm_notebook as tqdm -from spyglass.common.common_behav import RawPosition, VideoFile +from spyglass.common.common_behav import ( + RawPosition, + VideoFile, + get_position_interval_epoch, +) from spyglass.common.common_interval import IntervalList # noqa F401 from spyglass.common.common_nwbfile import AnalysisNwbfile from spyglass.settings import raw_dir, test_mode, video_dir @@ -553,13 +556,8 @@ def make(self, key): ).fetch1_dataframe() logger.info("Loading video data...") - epoch = ( - int( - key["interval_list_name"] - .replace("pos ", "") - .replace(" valid times", "") - ) - + 1 + epoch = get_position_interval_epoch( + key["nwb_file_name"], key["interval_list_name"] ) video_info = (VideoFile() & {**nwb_dict, "epoch": epoch}).fetch1() io = pynwb.NWBHDF5IO(raw_dir + "/" + video_info["nwb_file_name"], "r") diff --git a/src/spyglass/position/v1/position_trodes_position.py b/src/spyglass/position/v1/position_trodes_position.py index af047dc20..efaa611b0 100644 --- a/src/spyglass/position/v1/position_trodes_position.py +++ b/src/spyglass/position/v1/position_trodes_position.py @@ -7,7 +7,7 @@ from datajoint.utils import to_camel_case from pandas import DataFrame -from spyglass.common import PositionIntervalMap, TaskEpoch +from spyglass.common import get_position_interval_epoch from spyglass.common.common_behav import RawPosition from spyglass.common.common_nwbfile import AnalysisNwbfile from spyglass.common.common_position import IntervalPositionInfo, _fix_col_names @@ -255,11 +255,13 @@ def fetch_pose_dataframe(self): raise NotImplementedError("No pose data for TrodesPosV1") def fetch_video_path(self): - nwb_file_name = self.fetch1("nwb_file_name") - epoch = ( - TaskEpoch() * PositionIntervalMap() & self.fetch1("KEY") - ).fetch("epoch")[0] - return get_video_path(nwb_file_name) + nwb_file_name, interval_list_name = self.fetch1( + "nwb_file_name", "interval_list_name" + ) + epoch = get_position_interval_epoch(nwb_file_name, interval_list_name) + return get_video_info({"nwb_file_name": nwb_file_name, "epoch": epoch})[ + 0 + ] @schema @@ -298,14 +300,9 @@ def make(self, key): pos_df = (TrodesPosV1() & key).fetch1_dataframe() logger.info("Loading video data...") - epoch = ( - int( - key["interval_list_name"] - .replace("pos ", "") - .replace(" valid times", "") - ) - + 1 - ) # TODO: Fix this hack + epoch = get_position_interval_epoch( + key["nwb_file_name"], key["interval_list_name"] + ) ( video_path, From dc8435cbe4cbfb77ce70b4f0d882913bedcb7075 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 27 Dec 2024 10:51:55 -0800 Subject: [PATCH 18/42] Add method to get training results pdf --- src/spyglass/behavior/moseq.py | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index a20a76dfc..181ed4cac 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -125,7 +125,7 @@ def make(self, key): video_paths = (PoseGroup & key).fetch_video_paths() for video in video_paths: destination = os.path.join(video_dir, os.path.basename(video)) - if not os.path.exists(destination): + if not os.path.lexists(destination): os.symlink(video, destination) bodyparts = (PoseGroup & key).fetch1("bodyparts") skeleton = model_params["skeleton"] @@ -268,6 +268,25 @@ def fetch_model(self, key: dict = None): (self & key).fetch1("model_name"), )[0] + def get_training_progress_path(self, key: dict = None): + """Method to get the paths to the training progress plots + + Parameters + ---------- + key : dict + key to a single MoseqModel table entry + + Returns + ------- + List[str] + list of paths to the training progress plots + """ + if key is None: + key = {} + project_dir = (self & key).fetch1("project_dir") + model_name = (self & key).fetch1("model_name") + return f"{project_dir}/{model_name}/fitting_progress.pdf" + @schema class MoseqSyllableSelection(SpyglassMixin, dj.Manual): From f92320bf04ae206fb427758f74376689655c6d6e Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 27 Dec 2024 10:52:27 -0800 Subject: [PATCH 19/42] Add description and example of hyperparameter sweep --- notebooks/60_MoSeq.ipynb | 3111 ++++++++++++++++++++++++-------------- 1 file changed, 2010 insertions(+), 1101 deletions(-) diff --git a/notebooks/60_MoSeq.ipynb b/notebooks/60_MoSeq.ipynb index 6ea11af9e..aca3eb4cb 100644 --- a/notebooks/60_MoSeq.ipynb +++ b/notebooks/60_MoSeq.ipynb @@ -6,143 +6,523 @@ "source": [ "# MoSeq Pipeline Tutorial\n", "\n", - "**NOTE: This notebook is a work in progress.**\n", - "\n", "This notebook provides a tutorial on how to use the MoSeq pipeline to analyze behavioral data. The pipeline is a tool for taking keypoint pose estimations and extracting behavioral syllables.\n", "\n", - "Here is a schematic showing the tables used in this pipeline.\n", + "Here is a schematic showing the tables used in this pipeline. The Basic steps are:\n", + "> **Model Training**\n", + "> - Define training data in `PoseGroup`\n", + "> - Define Moseq model and training parameters in `MoseqModelParams`\n", + "> - Combine a set of training parmaters and training data in `MoseqModelSelection`\n", + "> - Populate `MoseqModel` to train\n", + "> \n", + "> **Convert pose data to behavioral syllables**\n", + "> - Combine a trained model from `MoseqModel` and a pose data from `PositionOutput` in \n", + "`MoseqSyllableSelection`\n", + "> - Populate `MoseqSyllable` to apply the trained model to the selected data\n", "\n", "![moseq_outline.png|2000x900](./../notebook-images/moseq_outline.png)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " # Accessing the keypoint (pose) data\n", + "\n", + "In the spyglass architecture, keypoint tracking is performed in the `Position` module,\n", + "and can be accesed through `PositionOutput.fetch_pose_dataframe()`. In this tutorial,\n", + "we are using a set of unpublished data from the Frank lab. For a tutorial on\n", + "running keypoint extraction in spyglass, see [the DLC tutorial notebook](21_DLC.ipynb).\n", + "\n", + "We can access an example set of keypoint pose data here:" + ] + }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2024-06-12 16:01:13,293][WARNING]: MySQL server has gone away. Reconnecting to the server.\n", - "WARNING:datajoint:MySQL server has gone away. Reconnecting to the server.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - }, { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
earLearRforelimbL...tailBasetailMidtailTip
video_frame_indxylikelihoodvideo_frame_indxylikelihoodvideo_frame_indx...ylikelihoodvideo_frame_indxylikelihoodvideo_frame_indxylikelihood
time
1.694621e+090.08072.6098493759.5255500.8255740.07883.0746923895.7904020.0288690.07656.537329...4283.3288000.9996630.04959.5990744041.6343480.8452900.04956.2572574052.0287500.008635
1.694621e+091.08261.9989883770.0950270.8637211.08225.1037323798.0360420.2165481.07601.948953...4330.0512340.9996861.05007.8661764112.7056980.9196891.04959.4882174086.4255800.011417
1.694621e+092.08439.1147773755.3940620.9046332.08147.3868403806.5490550.7102842.07613.715879...4325.5700840.9998762.05076.7858324131.3374360.9787902.05091.4584724159.7362840.019404
1.694621e+093.08076.6905483533.9756410.4966373.08238.1877523744.6319280.9769693.07688.181299...4370.0416880.9997693.05155.7582854173.9142200.9565843.05145.7841124157.7345150.022773
1.694621e+094.08093.6945973484.6864110.7422714.08284.1586063675.8375360.8897974.07745.837035...4458.6992070.9999164.05424.3127774266.9019870.9496164.05419.3471784256.7222170.042030
..................................................................
1.694622e+0923859.08323.3012754157.0220040.00299423859.08323.6821924137.9126540.00242523859.07615.597512...4085.4603460.00294023859.07892.2391714094.5566990.01952223859.07542.6005773850.6079980.037190
1.694622e+0923860.08322.5804624164.3961720.00073623860.08319.0232814144.9234850.00101823860.07612.563848...4092.4086670.00032623860.02442.091901833.3116610.00272423860.08329.4252524117.4080730.025406
1.694622e+0923861.08313.8789444136.1199010.00243023861.07611.0797364317.3608290.00312223861.07631.078869...4087.2789810.00191323861.07888.6702694099.4204750.01423623861.07535.5560493857.0313370.048863
1.694622e+0923862.08326.2353144170.7501650.00050023862.08321.1271164151.9992680.00190323862.07620.843915...4209.7756280.00024123862.07885.5408884096.4385770.00025623862.07531.8948483858.5733200.039602
1.694622e+0923863.07906.8068154096.0588800.00283323863.07560.7117283926.7970690.00234923863.07911.580490...4079.3021830.00301623863.07877.7726174084.1371460.02620023863.07535.1531563859.0443380.049477
\n", + "

23864 rows × 60 columns

\n", + "
" + ], "text/plain": [ - "PosixPath('/nimbus/deeplabcut/projects/sideHomeOfficial-sc_eb-2024-04-16/videos')" + " earL \\\n", + " video_frame_ind x y likelihood \n", + "time \n", + "1.694621e+09 0.0 8072.609849 3759.525550 0.825574 \n", + "1.694621e+09 1.0 8261.998988 3770.095027 0.863721 \n", + "1.694621e+09 2.0 8439.114777 3755.394062 0.904633 \n", + "1.694621e+09 3.0 8076.690548 3533.975641 0.496637 \n", + "1.694621e+09 4.0 8093.694597 3484.686411 0.742271 \n", + "... ... ... ... ... \n", + "1.694622e+09 23859.0 8323.301275 4157.022004 0.002994 \n", + "1.694622e+09 23860.0 8322.580462 4164.396172 0.000736 \n", + "1.694622e+09 23861.0 8313.878944 4136.119901 0.002430 \n", + "1.694622e+09 23862.0 8326.235314 4170.750165 0.000500 \n", + "1.694622e+09 23863.0 7906.806815 4096.058880 0.002833 \n", + "\n", + " earR \\\n", + " video_frame_ind x y likelihood \n", + "time \n", + "1.694621e+09 0.0 7883.074692 3895.790402 0.028869 \n", + "1.694621e+09 1.0 8225.103732 3798.036042 0.216548 \n", + "1.694621e+09 2.0 8147.386840 3806.549055 0.710284 \n", + "1.694621e+09 3.0 8238.187752 3744.631928 0.976969 \n", + "1.694621e+09 4.0 8284.158606 3675.837536 0.889797 \n", + "... ... ... ... ... \n", + "1.694622e+09 23859.0 8323.682192 4137.912654 0.002425 \n", + "1.694622e+09 23860.0 8319.023281 4144.923485 0.001018 \n", + "1.694622e+09 23861.0 7611.079736 4317.360829 0.003122 \n", + "1.694622e+09 23862.0 8321.127116 4151.999268 0.001903 \n", + "1.694622e+09 23863.0 7560.711728 3926.797069 0.002349 \n", + "\n", + " forelimbL ... tailBase \\\n", + " video_frame_ind x ... y likelihood \n", + "time ... \n", + "1.694621e+09 0.0 7656.537329 ... 4283.328800 0.999663 \n", + "1.694621e+09 1.0 7601.948953 ... 4330.051234 0.999686 \n", + "1.694621e+09 2.0 7613.715879 ... 4325.570084 0.999876 \n", + "1.694621e+09 3.0 7688.181299 ... 4370.041688 0.999769 \n", + "1.694621e+09 4.0 7745.837035 ... 4458.699207 0.999916 \n", + "... ... ... ... ... ... \n", + "1.694622e+09 23859.0 7615.597512 ... 4085.460346 0.002940 \n", + "1.694622e+09 23860.0 7612.563848 ... 4092.408667 0.000326 \n", + "1.694622e+09 23861.0 7631.078869 ... 4087.278981 0.001913 \n", + "1.694622e+09 23862.0 7620.843915 ... 4209.775628 0.000241 \n", + "1.694622e+09 23863.0 7911.580490 ... 4079.302183 0.003016 \n", + "\n", + " tailMid \\\n", + " video_frame_ind x y likelihood \n", + "time \n", + "1.694621e+09 0.0 4959.599074 4041.634348 0.845290 \n", + "1.694621e+09 1.0 5007.866176 4112.705698 0.919689 \n", + "1.694621e+09 2.0 5076.785832 4131.337436 0.978790 \n", + "1.694621e+09 3.0 5155.758285 4173.914220 0.956584 \n", + "1.694621e+09 4.0 5424.312777 4266.901987 0.949616 \n", + "... ... ... ... ... \n", + "1.694622e+09 23859.0 7892.239171 4094.556699 0.019522 \n", + "1.694622e+09 23860.0 2442.091901 833.311661 0.002724 \n", + "1.694622e+09 23861.0 7888.670269 4099.420475 0.014236 \n", + "1.694622e+09 23862.0 7885.540888 4096.438577 0.000256 \n", + "1.694622e+09 23863.0 7877.772617 4084.137146 0.026200 \n", + "\n", + " tailTip \n", + " video_frame_ind x y likelihood \n", + "time \n", + "1.694621e+09 0.0 4956.257257 4052.028750 0.008635 \n", + "1.694621e+09 1.0 4959.488217 4086.425580 0.011417 \n", + "1.694621e+09 2.0 5091.458472 4159.736284 0.019404 \n", + "1.694621e+09 3.0 5145.784112 4157.734515 0.022773 \n", + "1.694621e+09 4.0 5419.347178 4256.722217 0.042030 \n", + "... ... ... ... ... \n", + "1.694622e+09 23859.0 7542.600577 3850.607998 0.037190 \n", + "1.694622e+09 23860.0 8329.425252 4117.408073 0.025406 \n", + "1.694622e+09 23861.0 7535.556049 3857.031337 0.048863 \n", + "1.694622e+09 23862.0 7531.894848 3858.573320 0.039602 \n", + "1.694622e+09 23863.0 7535.153156 3859.044338 0.049477 \n", + "\n", + "[23864 rows x 60 columns]" ] }, - "execution_count": 4, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "import spyglass.position.v1 as sgp\n", - "from pathlib import Path\n", - "import numpy as np\n", - "\n", - "pose_estimation_key = {'nwb_file_name': 'SC100020230912_.nwb',\n", - " 'epoch': 9,\n", - " 'video_file_num': 14,\n", - " 'project_name': 'sideHomeOfficial',\n", - " 'dlc_model_name': 'sideHomeOfficial_tutorial_00',\n", - " 'dlc_model_params_name': 'default',\n", - " 'task_mode': 'trigger'}\n", + "# %load_ext autoreload\n", + "# %autoreload 2\n", + "from spyglass.position.position_merge import PositionOutput\n", "\n", + "# Key defining the DLC data we are using\n", + "pose_key = {\n", + " \"nwb_file_name\": \"SC100020230912_.nwb\",\n", + " \"epoch\": 9,\n", + " \"video_file_num\": 14,\n", + " \"project_name\": \"sideHomeOfficial\",\n", + " \"dlc_model_name\": \"sideHomeOfficial_tutorial_00\",\n", + " \"dlc_model_params_name\": \"default\",\n", + " \"task_mode\": \"trigger\",\n", + "}\n", "\n", - "(sgp.DLCPoseEstimation.BodyPart & pose_estimation_key).fetch('bodypart')\n", - "Path((sgp.DLCProject & pose_estimation_key).fetch1('config_path')).parents[0]/\"videos\"" + "# Fetch the pose data for demo purposes\n", + "merge_key = (PositionOutput.DLCPosV1 & pose_key).fetch1(\"KEY\")\n", + "pose_df = (PositionOutput & merge_key).fetch_pose_dataframe()\n", + "pose_df" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Add Pose data to merge table" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "\n", + "To train a moseq model, we first need to define the epochs of pose data we will train on\n", + "as well as the bodyparts to use within the model. We define this in the `PoseGroup`\n", + "table below.\n", "\n", - "# part_name = to_camel_case(self.table_name.split(\"__\")[-1])\n", - "\n", - "# TODO: The next line belongs in a merge table function\n", - "# PoseOutput._merge_insert(\n", - "# [insert_key], part_name=\"DLCPoseEstimation\", skip_duplicates=True\n", - "# )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Create Pose Group for training" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from spyglass.position.position_merge import PoseOutput\n", - "from spyglass.behavior.core import PoseGroup\n", - "merge_key = PoseOutput().fetch(\"merge_id\")\n", - "PoseGroup().create_group(\"sb_test_group\", merge_key, ['forelimbL', 'forelimbR', 'nose',\n", - " 'spine1', 'spine3', 'spine5',\n", - " 'tailBase'])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# test loading data from pose group\n", - "# %load_ext autoreload\n", - "# %autoreload 2\n", - "# from spyglass.behavior.core import PoseGroup\n", - "# PoseGroup().fetch_pose_datasets({'group_name': 'sb_test_group'}, format_for_moseq=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Make Moseq Model" + "Note that training can be run using data from multiple epochs by passing a list of\n", + "merge ids to `create_group`" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" + "/home/sambray/Documents/spyglass/src/spyglass/behavior/core.py:50: UserWarning: Pose group tutorial_group already exists. Skipping insertion.\n", + " warnings.warn(\n" ] }, { @@ -204,61 +584,77 @@ "
\n", " \n", " \n", - " \n", - "\n", - "\n", + " \n", "\n", "
\n", - "

model_params_name

\n", + "

pose_group_name

\n", " \n", "
\n", - "

model_params

\n", - " \n", + "

bodyparts

\n", + " list of body parts to include in the pose\n", "
sb_testing_kappa-4=BLOB=
sb_testing_kappa0_mini=BLOB=
sb_testing_kappa4_mini
tutorial_group=BLOB=
\n", " \n", - "

Total: 3

\n", + "

Total: 1

\n", " " ], "text/plain": [ - "*model_params_ model_para\n", + "*pose_group_na bodyparts \n", "+------------+ +--------+\n", - "sb_testing_kap =BLOB= \n", - "sb_testing_kap =BLOB= \n", - "sb_testing_kap =BLOB= \n", - " (Total: 3)" + "tutorial_group =BLOB= \n", + " (Total: 1)" ] }, - "execution_count": 42, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "from spyglass.behavior.moseq import MoseqModel, MoseqModelParams, MoseqModelSelection\n", + "from spyglass.behavior.core import PoseGroup\n", "\n", - "model_params_name = \"sb_testing_kappa4_mini\"\n", - "params = {}\n", - "params['skeleton'] = [['nose','spine1'],\n", - " ['spine1','forelimbL'],\n", - " ['spine1','forelimbR'],\n", - " ['spine1','spine3'],\n", - " ['spine3','spine5'],\n", - " ['spine5','tailBase']]\n", - "params['kappa'] = 1e4\n", - "params['num_ar_iters'] = 50\n", - "params['num_epochs'] = 50\n", - "params[\"anterior_bodyparts\"] = [\"nose\"]\n", - "params[\"posterior_bodyparts\"] = [\"tailBase\"]\n", - "# MoseqModelParams().update1({'model_params_name': model_params_name, 'model_params': params},)# skip_duplicates=True)\n", - "MoseqModelParams().insert1({'model_params_name': model_params_name, 'model_params': params}, skip_duplicates=True)\n", - "MoseqModelParams()" + "# Define the group name and bodyparts to include in the Moseq model\n", + "group_name = \"tutorial_group\"\n", + "merge_ids = [(PositionOutput & merge_key).fetch(\"merge_id\")[0]]\n", + "bodyparts = [\n", + " \"forelimbL\",\n", + " \"forelimbR\",\n", + " \"nose\",\n", + " \"spine1\",\n", + " \"spine3\",\n", + " \"spine5\",\n", + " \"tailBase\",\n", + "]\n", + "\n", + "# Create the group\n", + "PoseGroup().create_group(\n", + " group_name,\n", + " merge_ids,\n", + " bodyparts,\n", + ")\n", + "\n", + "# Look at the group in the database\n", + "group_key = {\"pose_group_name\": group_name}\n", + "PoseGroup() & group_key" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining the Moseq Model\n", + "\n", + "Next, we make an entry intpo the `MoseqModelParams` table. The information in this\n", + "is used to initialize the moseq model and includes hyperparameters for model training\n", + "as well as allows you to begin training from an existing model in the database \n", + "(discussed more below). Relevant parameters can be found in the [Moseq documentation](\n", + "https://keypoint-moseq.readthedocs.io/en/latest/modeling.html#model-fitting)\n", + "\n", + "** Note: All bodyparts in the `PoseGroup` entry will be used in the model" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -320,116 +716,235 @@ "
\n", " \n", " \n", - " \n", - "\n", - "\n", - "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "
\n", - "

pose_group_name

\n", + "

model_params_name

\n", " \n", "
\n", - "

model_params_name

\n", + "

model_params

\n", " \n", "
sb_test_groupsb_testing_kappa-4
sb_test_groupsb_testing_kappa0_mini
sb_test_groupsb_testing_kappa4_mini
sb_testing_kappa-4=BLOB=
sb_testing_kappa0_mini=BLOB=
sb_testing_kappa4_mini=BLOB=
sb_testing_kappa4_mini_20241220=BLOB=
sb_testing_model_sweep_kappa0_mini=BLOB=
sb_testing_model_sweep_kappa1_mini=BLOB=
sb_testing_model_sweep_kappa2_mini=BLOB=
sb_testing_model_sweep_kappa3_mini=BLOB=
sb_testing_model_sweep_kappa4_mini=BLOB=
sb_testing_model_sweep_kappa5_mini=BLOB=
sb_testing_model_sweep_kappa6_mini=BLOB=
sb_testing_model_sweep_kappa7_mini=BLOB=
\n", - " \n", - "

Total: 3

\n", + "

...

\n", + "

Total: 16

\n", " " ], "text/plain": [ - "*pose_group_na *model_params_\n", - "+------------+ +------------+\n", - "sb_test_group sb_testing_kap\n", - "sb_test_group sb_testing_kap\n", - "sb_test_group sb_testing_kap\n", - " (Total: 3)" + "*model_params_ model_para\n", + "+------------+ +--------+\n", + "sb_testing_kap =BLOB= \n", + "sb_testing_kap =BLOB= \n", + "sb_testing_kap =BLOB= \n", + "sb_testing_kap =BLOB= \n", + "sb_testing_mod =BLOB= \n", + "sb_testing_mod =BLOB= \n", + "sb_testing_mod =BLOB= \n", + "sb_testing_mod =BLOB= \n", + "sb_testing_mod =BLOB= \n", + "sb_testing_mod =BLOB= \n", + "sb_testing_mod =BLOB= \n", + "sb_testing_mod =BLOB= \n", + " ...\n", + " (Total: 16)" ] }, - "execution_count": 43, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "MoseqModelSelection().insert1({'model_params_name': model_params_name,\n", - " \"pose_group_name\":\"sb_test_group\"}, skip_duplicates=True)\n", + "from spyglass.behavior.moseq import (\n", + " MoseqModel,\n", + " MoseqModelParams,\n", + " MoseqModelSelection,\n", + ")\n", "\n", - "MoseqModelSelection()" - ] - }, + "model_params_name = \"tutorial_kappa4_mini\"\n", + "params = {}\n", + "# the skeleton list defines pairs of bodyparts that are linked by and edge\n", + "params[\"skeleton\"] = [\n", + " [\"nose\", \"spine1\"],\n", + " [\"spine1\", \"forelimbL\"],\n", + " [\"spine1\", \"forelimbR\"],\n", + " [\"spine1\", \"spine3\"],\n", + " [\"spine3\", \"spine5\"],\n", + " [\"spine5\", \"tailBase\"],\n", + "]\n", + "# kappa affects the distribution of syllable durations, likely needs tuning for each dataset\n", + "params[\"kappa\"] = 1e4\n", + "# num_ar_iters is the number of iterations of the autoregressive model for warm-up\n", + "params[\"num_ar_iters\"] = 50\n", + "# num_epochs is the number of epochs to train the model\n", + "params[\"num_epochs\"] = 50\n", + "# anteror and posterior bodyparts are used to define the orientation of the animal\n", + "params[\"anterior_bodyparts\"] = [\"nose\"]\n", + "params[\"posterior_bodyparts\"] = [\"tailBase\"]\n", + "\n", + "MoseqModelParams().insert1(\n", + " {\"model_params_name\": model_params_name, \"model_params\": params},\n", + " skip_duplicates=True,\n", + ")\n", + "\n", + "MoseqModelParams()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To train the model, we link a set of model params with training data in `PoseGroup` \n", + "using the `MoseqModelSelection` table." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "The directory `/home/sambray/Documents/moseq_test_proj2` already\n", - "exists. Use `overwrite=True` or pick a different name\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:06][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "[11:40:07][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`behavior_core_v1`.`pose_group`', '`moseq_v1`.`moseq_model_selection`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`moseq_v1`.`moseq_model_params`'}. Please submit a bug report with the snippet used.\n" - ] - }, + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "
\n", + "

pose_group_name

\n", + " \n", + "
\n", + "

model_params_name

\n", + " \n", + "
sb_test_groupsb_testing_kappa4_mini_20241220
tutorial_grouptutorial_kappa4_mini
\n", + " \n", + "

Total: 2

\n", + " " + ], + "text/plain": [ + "*pose_group_na *model_params_\n", + "+------------+ +------------+\n", + "sb_test_group sb_testing_kap\n", + "tutorial_group tutorial_kappa\n", + " (Total: 2)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MoseqModelSelection().insert1(\n", + " {\n", + " \"model_params_name\": model_params_name,\n", + " \"pose_group_name\": group_name,\n", + " },\n", + " skip_duplicates=True,\n", + ")\n", + "\n", + "MoseqModelSelection()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then train the model by populating the corresponding `MoseqModel` entry. This\n", + "will load the keypoint data, format it for moseq, and then train according to the\n", + "setting in the `MoseqModelParams` entry" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "Outputs will be saved to\n", - "/home/sambray/Documents/moseq_test_proj2/2024_06_12-11_40_09\n" + "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", + "exists. Use `overwrite=True` or pick a different name\n", + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/d9bb\n", + "baed42eca56d999882d9f65a62b8_ar\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [00:31<00:32, 1.23s/it]" + " 49%|█████████████████▏ | 25/51 [00:55<00:52, 2.03s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -441,12 +956,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [01:05<00:01, 1.24s/it]" + " 98%|██████████████████████████████████▎| 50/51 [01:48<00:02, 2.05s/it]" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAD6CAYAAABwKvR6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB/5UlEQVR4nO3dd1wURx8G8OfovYkUGyAqioo1Kliw915jVKyxK7YYNVFAjb3GRI0xdmNJLLHFjr1hFzFGjQhGFBUFRUGBef8gty/HHXAcByfwfD+fS7zZ2dnfzu1sGXZnZUIIASIiIiIiIiIiojykp+sAiIiIiIiIiIio8GGnFBERERERERER5Tl2ShERERERERERUZ5jpxQREREREREREeU5dkoREREREREREVGeY6cUERERERERERHlOXZKERERERERERFRnmOnFBERERERERER5Tl2ShERERERERERUZ5jpxQRERVKx48fx4ABA1C+fHmYm5ujePHi6NChA65cuaIy/9WrV9G0aVNYWFjAxsYGnTt3xj///KOQ5++//8aECRNQo0YN2NjYwM7ODnXr1sXvv/+eZTzffvstZDIZKlWqpNH6REdHo1+/frC3t4eZmRm8vb1x7NgxlXnj4+Mxbdo0lCtXDsbGxihSpAgaNWqEe/fuZWuZ+/btg5+fHypXrgxDQ0PIZDKV+a5cuYIRI0agcuXKsLS0hKOjI5o2bYrjx4+rvazHjx9jzJgx8PX1hY2NDWQyGdatW5ejuLLr/fv3KFeuHGQyGRYsWKA0/ePHjwgKCoKrqyuMjY1Rvnx5LFu2TKNlZaeszZs3o1q1ajAxMYG9vT2++OILREZGarRcOZlMhpEjR0rfnzx5gsDAQFy/fj1H5eZUZnEEBgZq7bfOroYNG0Imkyl9WrZsqZRXm9sJERFRfsdOKSIiKpRWrFiB8PBw+Pv748CBA1i6dCmio6NRp04dpc6Sv/76Cw0bNsSHDx+wfft2rFmzBn///Tfq16+P58+fS/kOHz6M/fv3o0uXLvjtt9+wefNmlC1bFt26dcP06dMzjOX69etYsGABHB0dNVqXxMRENGnSBMeOHcPSpUvxxx9/wNHRES1btsTJkycV8r59+xYNGzbEL7/8glGjRuHw4cNYu3YtateujXfv3mVrubt27cKFCxfg6emJKlWqZJhvy5YtuHTpEgYMGIA//vgDq1evhrGxMZo0aYINGzaotaz79+9j8+bNMDIyQuvWrbUSV3ZNnToV8fHxGU4fPnw4Zs+ejREjRuDQoUPo1KkT/P39MWvWrGwvS92yli1bht69e6NmzZr4448/MHfuXJw4cQL169fHq1evsr3cjDx58gRBQUGfRKdURnEMGjQI58+fz/ug/lO6dGmcP39e4bNkyRKlfNrcToiIiPI9QUREVAg9e/ZMKe3NmzfC0dFRNGnSRCG9W7duwt7eXsTGxkpp4eHhwtDQUEycOFFKe/78uUhJSVEqt02bNsLMzEwkJCQoTfv48aOoWrWqGD16tPD19RUVK1bM9rr8+OOPAoA4d+6cQrmenp6iVq1aCnn9/f2Fubm5ePDgQbaXk15ycrL07xEjRoiMTitU1XVSUpLw8vIS7u7u2V5WSEiIACDWrl2bo7iy4+LFi8LIyEj89ttvAoCYP3++wvTQ0FAhk8nErFmzFNK//PJLYWpqKl6+fKn2stQtKyEhQVhbW4t27dop5Dt37pwAIKZMmZKdVVQAQIwYMUL6nlWda+rdu3cq20xGciuOnFK37WpzOyEiIioIeKcUEREVSg4ODkppFhYW8PT0VHj0KSkpCfv27UOXLl1gZWUlpbu4uKBRo0bYtWuXlGZvb6/y8aFatWrh3bt3iImJUZo2Z84cxMTE4LvvvtN4XXbt2gUPDw94e3tLaQYGBujduzcuXbqEf//9FwDw7t07rF69Gt26dUPp0qU1Xp6cnp56pxGq6lpfXx81atRQ+zEzdZeV3bzq+PDhAwYMGIARI0agZs2aKvPs3r0bQgj0799fIb1///54//49Dh48qPby1C0rNDQUsbGxSneOeXt7w87ODjt27FB7mZk5ceIEPvvsMykG+aNpgYGBUp7Lly+jffv2sLOzg4mJCapVq4bt27crlLNu3TrIZDIcPnwYAwYMQNGiRWFmZobExETcv38f/fv3R9myZWFmZobixYujXbt2uHXrltpxqHp8LyUlBfPmzUP58uVhbGwMBwcH+Pn54fHjxwr5GjZsiEqVKiEkJAT169eHmZkZSpcujTlz5iAlJUUr9QhodzshIiIqCNgpRURE9J/Y2FhcvXoVFStWlNIePHiA9+/fw8vLSym/l5cX7t+/j4SEhEzLDQ4ORtGiRZU6Z8LCwjBz5kysWLECFhYWGscdGhqaYXwAcPv2bQCpYzvFx8ejbNmyGDZsGGxtbWFkZISaNWti//79Gi9fE0lJSTh9+rRCXX+qpk+fjvj4eMyYMSPDPKGhoShatCicnJwU0uW/QWhoqNrLU7esDx8+AACMjY2VyjA2Nsa9e/cUts1+/fpBJpMhPDxc7VgAoHr16li7di2A1LHP5I+mDRo0CEDq9l23bl28fv0aK1euxB9//IGqVauiR48eKsf9GjBgAAwNDbFx40b8/vvvMDQ0xJMnT1CkSBHMmTMHBw8exI8//ggDAwPUrl0bd+/eVSsOVYYNG4avv/4azZo1w549ezBjxgwcPHgQPj4+ePHihULep0+folevXujduzf27NmDVq1aYfLkydi0aZNa9fTgwQPY2dnBwMAA7u7u+Oabb/D+/XuFPNrcToiIiAoCA10HQERE9KkYMWIE4uPj8c0330hpL1++BADY2dkp5bezs4MQAq9evYKzs7PKMlevXo0TJ05g6dKl0NfXl9JTUlIwYMAAdO7cOcsxkrLy8uXLDONLuw7yO6bmzp2LypUrY8OGDdDT08PChQvRrl07/Pnnn2jRokWOYlFXYGAg7t+/j927d+fJ8jR1/fp1zJs3D3v37oW5ubnCGGJpZfQbmJubw8jISPoN1KFuWR4eHtDT08PZs2cV7rx58OABoqKiAEBh29TX14e+vn62BwO3srKSBuB3d3dHnTp1FKYPHz4cFStWxPHjx2FgkHpq2aJFC7x48QJTpkyBn5+fwt1rTZo0wU8//aRQRoMGDdCgQQPpe3JyMtq0aYOKFSvip59+wqJFi7KMI72//voLq1atwvDhwxUGEq9WrRpq166NxYsXK9yh+PLlSxw4cAC1atUCADRt2hQnTpzAr7/+Cj8/v0yXVa9ePfTo0QPly5fH+/fv8eeff2LevHk4c+YMgoODpfXX5nZCRERUEPBOKSIiIqQOYr1582YsXrwYNWrUUJqe2YV8RtP+/PNPjBgxAl27dsWoUaMUpi1atAj37t1TORCyJtSJT/4YkpGREf7880+0a9cObdq0wb59++Ds7JzpnUDatHr1anz33XcYP348OnToIKULIZCUlKTw0aWkpCQMGDAAPXr0UKuzTpNtJCdl2dnZoVevXtiwYQN++uknxMTE4ObNm+jVq5fUAZq2M+iXX35BUlISXFxcshVLZu7fv4+//voLvXr1AgCF365169aIioqS7nSS69Kli1I5SUlJmDVrFjw9PWFkZAQDAwMYGRnh3r17uHPnjkaxBQcHA0i9QyytWrVqoUKFCkpvp3RycpI6pOS8vLzw6NGjLJc1c+ZMDBs2DI0aNULr1q2xbNkyzJkzB6dOncIff/yhkFeb2wkREVF+x04pIiIq9IKCgjBz5kx89913GDlypMK0IkWKAIDKOxhiYmIgk8lgY2OjNO3QoUPo3LkzmjVrhs2bNytcbEZERGDatGkICAiAkZERXr9+jdevXyMpKQkpKSl4/fq10mM/mSlSpEiG8QH/v2NKvi4+Pj6wtLSU8pmZmcHX1xdXr15Ve5maWrt2LYYMGYLBgwdj/vz5CtPWr18PQ0NDhY8uLVmyBP/88w8CAgKk3yguLg4AkJCQgNevXyM5ORlAxr9BfHw8Pnz4oPLumIxkp6wVK1agR48eGD58OIoUKYJq1aqhfPnyaNOmDYyNjaXfPLc8e/YMADBhwgSl32748OEAoPSYnKq7CseNG4epU6eiY8eO2Lt3Ly5evIiQkBBUqVIlW20hLXkdqlpesWLFlOpYVV0ZGxtrvPzevXsDAC5cuKCwDG1tJ0RERAUBH98jIqJCLSgoCIGBgQgMDMSUKVOUpru7u8PU1FRhwGW5W7duoUyZMjAxMVFIP3ToEDp27AhfX1/s2LEDRkZGCtP/+ecfvH//Hv7+/vD391cq19bWFv7+/mrfRVW5cuUM4wMgPfKkatwpOSGE1gcIT2/t2rUYNGgQ+vbti5UrVyrdFdKuXTuEhITkagzZIR9IvGzZskrTpk6diqlTp+LatWuoWrUqKleujK1bt+Lp06cK4wWl/w3UkZ2yzM3NsXHjRnz//feIjIxEsWLFYG9vj/Lly8PHx0d6nC632NvbAwAmT56Mzp07q8zj4eGh8F3V3UCbNm2Cn58fZs2apZD+4sULlZ2+6pB3MkVFRaFEiRIK0548eSLFntvStittbidEREQFAe+UIiKiQmvGjBkIDAzEt99+i4CAAJV5DAwM0K5dO+zcuRNv3ryR0iMiIhAcHKx0IX748GF07NgR9erVw+7du1UOQl21alUEBwcrfapUqQJXV1cEBwcr3bGVmU6dOuGvv/7CxYsXpbSkpCRs2rQJtWvXRrFixQCk3jHi7e2Ns2fPSnf8AKlv5Tt58mSWY/TkxLp16zBo0CD07t0bq1evVtkxUaRIEdSsWVPho0uTJk1S+o22bNkCABg6dCiCg4NRpkwZAECHDh0gk8mwfv16hTLWrVsHU1NTtGzZUu3lalKWra0tvLy8YG9vjz179uDu3bsqOzw1Jd+O09815OHhgbJly+LGjRtKv538k/auvIzIZDKltrJ//35pHLSs4lClcePGAKA0UHlISAju3LmDJk2aZFlGTsh/v7TtSpvbCRERUUHAO6WIiKhQWrhwIaZNm4aWLVuiTZs2Co/YAIoXkkFBQfjss8/Qtm1bTJo0CQkJCZg2bRrs7e0xfvx4Kd+ZM2fQsWNHODk5YcqUKbh+/bpCmZ6enrCysoKNjQ0aNmyoFJONjQ2SkpJUTsvMgAED8OOPP6Jbt26YM2cOHBwcsHz5cty9exdHjx5VyLtgwQI0atQILVq0wNdffw2ZTIaFCxfixYsX2R5T6tGjR9KdTQ8ePAAA/P777wAAV1dXqVPpt99+w8CBA1G1alUMGTIEly5dUiinWrVqKjvv0pOX/c8//wAALl++LL21sGvXrtmOKyvly5dH+fLlFdLkb65zd3dX+J0qVqyIgQMHIiAgAPr6+vjss89w+PBhrFq1CjNnzszWY1nZKWvHjh148uQJKlSogISEBGlQ/aFDhyqM1wUAAwcOxPr16/HgwYNsjyslv2Nw8+bNqFChAiwsLFCsWDEUK1YMP/30E1q1aoUWLVqgX79+KF68OGJiYnDnzh1cvXoVv/32W5blt23bFuvWrUP58uXh5eWFK1euYP78+Up3OGUWR3oeHh4YPHgwli1bBj09PbRq1Qrh4eGYOnUqSpYsibFjx2arDjJy+vRpfPfdd+jUqRNKly6NhIQE/Pnnn1i1ahUaN26Mdu3aSXm1uZ0QEREVCIKIiKgQ8vX1FQAy/KR3+fJl0aRJE2FmZiasrKxEx44dxf379xXyBAQEZFpmcHBwljFVrFhRo/V5+vSp8PPzE3Z2dsLExETUqVNHHDlyRGXe06dPC19fX2FmZibMzMxE48aNxdmzZ7O9zLVr12a4rn379pXy9e3bN9N6efjwoVrLU/f3UjcuTTx8+FAAEPPnz1ea9uHDBxEQECBKlSoljIyMRLly5cT333+v0XLULWvXrl2iatWqwtzcXJiamoqaNWuKX375RaSkpCjllf8O6tQ3ADFixAiFtC1btojy5csLQ0NDAUAEBARI027cuCG6d+8uHBwchKGhoXBychKNGzcWK1eulPLIf5eQkBCl5b169UoMHDhQODg4CDMzM1GvXj1pO/X19VUrDnn7Sys5OVnMnTtXlCtXThgaGgp7e3vRu3dvERkZqZAvo7bXt29f4eLikmld3bt3T7Ru3VoUL15cGBsbCxMTE1G5cmXx3XffiYSEBKX82txOiIiI8juZEELkQl8XERERERERERFRhjimFBERERERERER5TmOKUVERPSJSklJQUpKSqZ5cuPtaklJSZlO19PTy/U39eU2XayjEALJycmZ5tHX11c5CDwRERFRQZS/zyiJiIgKsAEDBsDQ0DDTT27IapkDBgzIleXmJV2s4/r167Nc7smTJ7W+XCIiIqJPFceUIiIi+kSFh4fjxYsXmeZR901y2XH58uVMp9vb28PV1VXry81LuljHly9f4uHDh5nm8fDwgKWlpVaXS0RERPSpYqcUERERERERERHlOT6+R0REREREREREeY6dUkRERERERERElOfYKUVERERERERERHmOnVJERERERERERJTn2ClFRERERERERER5jp1SRERERERERESU59gpRUREREREREREeY6dUkRERERERERElOfYKUVERERERERERHmOnVJERERERERERJTn2ClFRERERERERER5jp1SRERERERERESU59gpRUREREREREREeY6dUkRERERERERElOfYKUVERERERERERHmOnVJERERERERERJTn2ClFRERERERERER5jp1SRERERERERESU59gpRUREREREREREeY6dUkRERERERERElOfYKUVERERERERERHmOnVJERERERERERJTn2ClFRERERERERER5TmudUuvWrYNMJlP5mTBhgrYWQ5kIDAyETCZTSHN1dUW/fv2yVc65c+cQGBiI169fZ2u+9Ms6ceIEZDIZfv/992yVk5l3794hMDAQJ06cUJom3wbDw8O1trz8LH2bNDExgZOTExo1aoTZs2cjOjpa1yFi1qxZ2L17t1K6fNtR9TvrSsOGDdGwYUPpe3h4OGQyGdatW5etcn799VcsWbIkW/OoWpa8vb948SJbZWUmLCwMgYGBKttQv3794OrqqrVlUdbStmFVbUEIgTJlykAmkylsm9qQ0f78U2qTut4mMztWpt9fEFH+d/HiRXTq1AmlSpWCsbExHB0d4e3tjfHjxyvkW758ebbPDdLL6PyIPj3ZOR/Ly+syovzEQNsFrl27FuXLl1dIK1asmLYXQ2ratWsXrKyssjXPuXPnEBQUhH79+sHGxiZXl5Vd7969Q1BQEAAonfC3adMG58+fh7Ozc67GkN/I2+THjx8RHR2NM2fOYO7cuViwYAG2bduGpk2b6iy2WbNmoWvXrujYsaNCevXq1XH+/Hl4enrqJjA1ODs74/z583B3d8/WfL/++itCQ0MxZsyYXF9WdoWFhSEoKAgNGzZUutifOnUq/P39c3X5pJqlpSV++eUXpX3eyZMn8eDBA1haWuZ6DPmhTea1zI6Vy5cv101QRJQr9u/fj/bt26Nhw4aYN28enJ2dERUVhcuXL2Pr1q1YuHChlHf58uWwt7fPdudDWhmdH1H+lpfXZUT5idY7pSpVqoSaNWuqlffjx4+QyWQwMNB6GPSfatWq5foy3r9/D1NT0zxZVmaKFi2KokWL6jSGT1H6NtmlSxeMHTsW9erVQ+fOnXHv3j04OjrmeDnJyclISkqCsbFxjsuysrJCnTp1clxObjI2Ns71GNPWqa7rI7c7xChjPXr0wObNm/Hjjz8qnMz+8ssv8Pb2RlxcXK7HkB/aZE69e/cOZmZmWimLnXdEBcu8efPg5uaGQ4cOKVy3fP7555g3b54OI6P8RNfXSmlp85hHlFN5NqaU/Nb/jRs3Yvz48ShevDiMjY1x//59AMDRo0fRpEkTWFlZwczMDHXr1sWxY8eUytm/fz+qVq0KY2NjuLm5YcGCBUqPrWX2WI1MJkNgYKBC2r179/DFF1/AwcEBxsbGqFChAn788UeV8W/ZsgXffPMNihUrBisrKzRt2hR3795VWs7BgwfRpEkTWFtbw8zMDBUqVMDs2bMBABs3boRMJsP58+eV5ps+fToMDQ3x5MmTTOtTVT2okv420ZSUFMycORMeHh4wNTWFjY0NvLy8sHTpUgCpt6B+9dVXAAA3NzelR0dcXV3Rtm1b7Ny5E9WqVYOJiYl051JGt6QmJCRg3LhxcHJygqmpKXx9fXHt2jWFPBk96pD28Yzw8HCp0ykoKEiKTb7MjB7fW7NmDapUqQITExPY2dmhU6dOuHPnjtJyLCwscP/+fbRu3RoWFhYoWbIkxo8fj8TERJV1m5+VKlUKCxcuxJs3b/DTTz9J6er8DsD/29i8efMwc+ZMuLm5wdjYGMHBwUhISMD48eNRtWpVWFtbw87ODt7e3vjjjz8UypTJZIiPj8f69eul31K+7IweFdqzZw+8vb1hZmYGS0tLNGvWTKkdyfcHt2/fRs+ePWFtbQ1HR0cMGDAAsbGxWdaNEALz5s2Di4sLTExMUL16dfz5559K+VTtZ54/f47BgwejZMmSMDY2RtGiRVG3bl0cPXpUqt/9+/fj0aNHCo9WZlWnme3TIiMj0blzZ1hZWcHa2hq9e/fG8+fPleo6/X4PUGyz69atQ7du3QAAjRo1kmKTL1PVo1IJCQmYPHky3NzcYGRkhOLFi2PEiBFKt5jL9xsHDx5E9erVYWpqivLly2PNmjUZ/AqUVs+ePQEAW7ZskdJiY2OxY8cODBgwQOU8Hz58wMyZM1G+fHlpW+zfv7/StvHx40dMnDgRTk5OMDMzQ7169XDp0iWl8lS1ycuXL+Pzzz+Hq6srTE1N4erqip49e+LRo0cK88r3zcHBwRg2bBjs7e1RpEgRdO7cOctjXdoyPDw8pGP0hg0b1IoRUN1W5fv8W7duoXnz5rC0tESTJk0AAEeOHEGHDh1QokQJmJiYoEyZMhgyZIjCoxlZHStV7UtjYmIwfPhwFC9eHEZGRihdujS++eYbpWOMTCbDyJEjsXHjRlSoUAFmZmaoUqUK9u3bp1ZdEZH2vXz5Evb29ir/kK6n9//LKVdXV9y+fRsnT56U9gvyY6c2zo8A4OnTpxgyZAhKlCgBIyMjuLm5ISgoCElJSVmux/Hjx9GwYUMUKVIEpqamKFWqFLp06YJ3795JeXJ6/Eh/PaBqeBEg4/P2bdu2wdvbG+bm5rCwsECLFi2Urhuyc96emJiI6dOno0KFCjAxMUGRIkXQqFEjnDt3TsojhMDy5ctRtWpVmJqawtbWFl27dsU///yTZZ3KPXv2LMvzTm1fl6WkpGDevHnSb+Xg4AA/Pz88fvxYYbkNGzZEpUqVcOrUKfj4+MDMzAwDBgzAwIEDYWdnp/D7yzVu3BgVK1ZUe/2JckLrtyjJ/7KvsJA0O/DJkyfD29sbK1euhJ6eHhwcHLBp0yb4+fmhQ4cOWL9+PQwNDfHTTz+hRYsWOHTokHSieOzYMXTo0AHe3t7YunUrkpOTMW/ePDx79kzjeMPCwuDj4yNdpDs5OeHQoUMYPXo0Xrx4gYCAAIX8U6ZMQd26dbF69WrExcXh66+/Rrt27XDnzh3o6+sDSP3r9ZdffglfX1+sXLkSDg4O+PvvvxEaGgog9a/eEydOxI8//ghvb2+p7KSkJPz000/o1KlTpo885qQe5s2bh8DAQHz77bdo0KABPn78iL/++ku6iBw0aBBiYmKwbNky7Ny5U3oULu1ffa9evYo7d+7g22+/hZubG8zNzTNd5pQpU1C9enWsXr0asbGxCAwMRMOGDXHt2jWULl06y5jlnJ2dcfDgQbRs2RIDBw7EoEGDACDTu6Nmz56NKVOmoGfPnpg9ezZevnyJwMBAeHt7IyQkBGXLlpXyfvz4Ee3bt8fAgQMxfvx4nDp1CjNmzIC1tTWmTZumdpz5RevWraGvr49Tp05pXMb333+PcuXKYcGCBbCyskLZsmWRmJiImJgYTJgwAcWLF8eHDx9w9OhRdO7cGWvXroWfnx8A4Pz582jcuDEaNWqEqVOnAkCmtzT/+uuv6NWrF5o3b44tW7YgMTER8+bNQ8OGDXHs2DHUq1dPIX+XLl3Qo0cPDBw4ELdu3cLkyZMBIMuOkKCgIAQFBWHgwIHo2rUrIiMj8eWXXyI5ORkeHh6ZztunTx9cvXoV3333HcqVK4fXr1/j6tWrePnyJYDUW/oHDx6MBw8eYNeuXWrXaWY6deqE7t27Y+jQobh9+zamTp2KsLAwXLx4EYaGhpnOm1abNm0wa9YsTJkyBT/++COqV68OIOM7pIQQ6NixI44dO4bJkyejfv36uHnzJgICAnD+/HmcP39e4a65GzduYPz48Zg0aRIcHR2xevVqDBw4EGXKlEGDBg3UjrMwsrKyQteuXbFmzRoMGTIEQGoHlZ6eHnr06KE0RllKSgo6dOiA06dPY+LEifDx8cGjR48QEBCAhg0b4vLlyzA1NQUAfPnll9iwYQMmTJiAZs2aITQ0FJ07d8abN2+yjCs8PBweHh74/PPPYWdnh6ioKKxYsQKfffYZwsLCYG9vr5B/0KBBaNOmDX799VdERkbiq6++Qu/evXH8+PFMl7Nu3Tr0798fHTp0wMKFC6XjSGJiosLFYHZ9+PAB7du3x5AhQzBp0iTp3OXBgwfw9vbGoEGDYG1tjfDwcCxatAj16tXDrVu3YGhoqNaxMq2EhAQ0atQIDx48QFBQELy8vHD69GnMnj0b169fx/79+xXy79+/HyEhIZg+fTosLCwwb948dOrUCXfv3s3WcZOItMPb2xurV6/G6NGj0atXL1SvXl3lMXbXrl3o2rUrrK2tpcd45cdCbZwfPX36FLVq1YKenh6mTZsGd3d3nD9/HjNnzkR4eDjWrl2b4TqEh4ejTZs2qF+/PtasWQMbGxv8+++/OHjwID58+AAzM7M8O35kZNasWfj222/Rv39/fPvtt/jw4QPmz5+P+vXr49KlSwr7WHXO25OSktCqVSucPn0aY8aMQePGjZGUlIQLFy4gIiICPj4+AIAhQ4Zg3bp1GD16NObOnYuYmBhMnz4dPj4+uHHjhlpPFGhy3pnT67Jhw4Zh1apVGDlyJNq2bYvw8HBMnToVJ06cwNWrVxWOw1FRUejduzcmTpyIWbNmQU9PDzY2NlizZg1+/fVX6boKSL0+Dg4OVrpJgyjXCC1Zu3atAKDy8/HjRxEcHCwAiAYNGijMFx8fL+zs7ES7du0U0pOTk0WVKlVErVq1pLTatWuLYsWKiffv30tpcXFxws7OTqRdlYcPHwoAYu3atUpxAhABAQHS9xYtWogSJUqI2NhYhXwjR44UJiYmIiYmRgghpPhbt26tkG/79u0CgDh//rwQQog3b94IKysrUa9ePZGSkpJhfQUEBAgjIyPx7NkzKW3btm0CgDh58mSG82WnHoQQwsXFRfTt21f63rZtW1G1atVMy58/f74AIB4+fKg0zcXFRejr64u7d++qnJZ2WfI6q169ukJdhIeHC0NDQzFo0CApzdfXV/j6+iqV2bdvX+Hi4iJ9f/78udJvKCffBuVxv3r1Spiamir9ZhEREcLY2Fh88cUXCssBILZv366Qt3Xr1sLDw0NpWfmBvD5CQkIyzOPo6CgqVKggfVf3d5C3MXd3d/Hhw4dM40hKShIfP34UAwcOFNWqVVOYZm5urrDNyMm3neDgYCFE6v6gWLFionLlyiI5OVnK9+bNG+Hg4CB8fHyktICAAAFAzJs3T6HM4cOHCxMTk0zb5atXr4SJiYno1KmTQvrZs2cFAIW6UbWfsbCwEGPGjMmwfCGEaNOmjUJdpi9PVZ2qWpZ8PceOHauQd/PmzQKA2LRpk5SWUZtJ32Z/++03hXpPK/02cPDgQZX1LN+PrVq1SmE5JiYm4tGjR1La+/fvhZ2dnRgyZIjSsihV2jYsbxOhoaFCCCE+++wz0a9fPyGEEBUrVlTYNrds2SIAiB07diiUFxISIgCI5cuXCyGEuHPnTqbbkKr9uaptQy4pKUm8fftWmJubi6VLlyqtx/DhwxXyz5s3TwAQUVFRGZYpb/sZHUfSbpMZxaiq/cj3+WvWrMlw2UIIkZKSIj5+/CgePXokAIg//vhDmpbZsTL9vnTlypUqjzFz584VAMThw4elNADC0dFRxMXFSWlPnz4Venp6Yvbs2ZnGS0S548WLF6JevXrStY2hoaHw8fERs2fPFm/evFHIm36fnBFNzo+GDBkiLCwsFI6nQgixYMECAUDcvn07w+X9/vvvAoC4fv16hnly4/ghP19JL/15e0REhDAwMBCjRo1SyPfmzRvh5OQkunfvLqWpe96+YcMGAUD8/PPPGa7z+fPnBQCxcOFChfTIyEhhamoqJk6cmOG8addPnfNObV6XyX+D9MfWixcvCgBiypQpUpqvr68AII4dO6ZUvq+vr1IMw4YNE1ZWVkrbNlFu0frjexs2bEBISIjCJ+2dUl26dFHIf+7cOcTExKBv375ISkqSPikpKWjZsiVCQkIQHx+P+Ph4hISEoHPnzjAxMZHmt7S0RLt27TSKNSEhAceOHUOnTp1gZmamsPzWrVsjISEBFy5cUJinffv2Ct+9vLwAQHpc4dy5c4iLi8Pw4cNV3qoqN2zYMADAzz//LKX98MMPqFy5cqZ3DeS0HmrVqoUbN25g+PDhOHTokEZjkXh5eaFcuXJq5//iiy8U6sLFxQU+Pj4IDg7O9rKz4/z583j//r3SI4UlS5ZE48aNlR4PlclkSnXo5eWl9ChKQSKEyNH87du3V/mXwt9++w1169aFhYUFDAwMYGhoiF9++UXpsUl13b17F0+ePEGfPn0U7oywsLBAly5dcOHCBaVbj1W11YSEhEzfOnj+/HkkJCSgV69eCuk+Pj5wcXHJMs5atWph3bp1mDlzJi5cuICPHz+qs3pKcWfnDqf0sXbv3h0GBga53r7kd7ekb1/dunWDubm5UvuqWrUqSpUqJX03MTFBuXLlCnT70iZfX1+4u7tjzZo1uHXrFkJCQjJ8dG/fvn2wsbFBu3btFI5rVatWhZOTk3Tbv3wbyWgbysrbt2/x9ddfo0yZMjAwMICBgQEsLCwQHx+vsq1ndfxURd72MzqO5FT6cxIAiI6OxtChQ1GyZElp/yVv/5ruw44fPw5zc3N07dpVIV3eftK3l0aNGikMYO/o6AgHBwe2FyIdKVKkCE6fPo2QkBDMmTMHHTp0wN9//43JkyejcuXKar8JN6fnR/v27UOjRo1QrFgxhf17q1atAKS+ACMjVatWhZGREQYPHoz169erfDQtr44fqhw6dAhJSUnw8/NTWLaJiQl8fX2VHs1W57z9zz//hImJSYbHS/k6y2Qy9O7dW2G5Tk5OqFKlitpvndXkvDMn12Xy3yD9eVitWrVQoUIFpeOKra0tGjdurFSOv78/rl+/jrNnzwIA4uLisHHjRvTt2xcWFhZqx0OUE1rvlKpQoQJq1qyp8Ekr/ZvR5I+cde3aFYaGhgqfuXPnQgiBmJgYvHr1CikpKXByclJapqo0dbx8+RJJSUlYtmyZ0rJbt24NAEoHmSJFiih8l9+S+/79ewCQnrcuUaJEpst2dHREjx498NNPPyE5ORk3b97E6dOnMXLkyEzny2k9TJ48GQsWLMCFCxfQqlUrFClSBE2aNMHly5eznFcuu2+3yyhW+SNNuUVevqp4ixUrprR8MzMzhY4+IPX3TUhIyL0gdSg+Ph4vX77M0dsxVdXtzp070b17dxQvXhybNm3C+fPnpQtoTesyq98yJSUFr169UkjPqq1mthxN29e2bdvQt29frF69Gt7e3rCzs4Ofnx+ePn2a5bxyOW1fBgYGKFKkSJ60LwMDA6XHZ2Uymcr2nf73AFJ/k8x+D/o/mUyG/v37Y9OmTVi5ciXKlSuH+vXrq8z77NkzvH79GkZGRkrHtqdPn0rHtYy2d/k2lJUvvvgCP/zwAwYNGoRDhw7h0qVLCAkJQdGiRVX+rrpok5kxMzNTemQ4JSUFzZs3x86dOzFx4kQcO3YMly5dkv5Apen2+vLlSzg5OSn9scrBwQEGBgZsL0T5RM2aNfH111/jt99+w5MnTzB27FiEh4erNdi5Ns6Pnj17hr179yrt2+Vj/2TWOebu7o6jR4/CwcEBI0aMgLu7O9zd3aXxi+Tl58XxI6N1A4DPPvtMadnbtm1TWjd1ztufP3+OYsWKZfqo97NnzyCEgKOjo9JyL1y4oHaHoybHuJxcl2X3Oiej88sOHTrA1dVVelRv3bp1iI+Px4gRI7KMgUhb8vy1d+lPyOTPui5btizDN/s4OjpKb+pTdXGXPk2+g0o/0F36xmlrawt9fX306dMnw4bn5uaWydook1+gpR9gThV/f39s3LgRf/zxBw4ePAgbGxulvzikZ2trq3Y9qGJgYIBx48Zh3LhxeP36NY4ePYopU6agRYsWiIyMVOstDJndAaZKRrGm3XmbmJioHIRa3QOBKvLyo6KilKY9efJEabyTwmb//v1ITk5WGDwzu7+Dqm1h06ZNcHNzw7Zt2xSm52TA+Kx+Sz09Pdja2mpcfvrlZLTNph/oOz17e3ssWbIES5YsQUREBPbs2YNJkyYhOjoaBw8eVCsGTdpX8eLFpe9JSUl4+fKlQvsyNjZWWf856bgqUqQIkpKS8Pz5c4WOKSEEnj59is8++0zjskm1fv36Ydq0aVi5ciW+++67DPPJBxLPaJuT34GTdntXtQ1lJjY2Fvv27UNAQAAmTZokpcvHTNGWrNpkWhkd+7Oz/woNDcWNGzewbt069O3bV0qXv5RFU0WKFMHFixchhFBYbnR0NJKSkgr98YgoPzI0NERAQAAWL14sjRubGW2cH9nb28PLyyvDY0BWf2isX78+6tevj+TkZFy+fBnLli3DmDFj4OjoiM8//zxXjh9p981px5pMv2+W7wd///13te5OV0fRokVx5swZpKSkZNgxZW9vD5lMhtOnT6t8g7Q23iqdkZxcl6U9N05/M4Sq65yMzi/19PQwYsQITJkyBQsXLsTy5cvRpEmTLMdRJdKmPHv7Xkbq1q0LGxsbhIWFKd1hJf8YGRnB3NwctWrVws6dOxV6wN+8eYO9e/cqlOno6AgTExPcvHlTIT392y3MzMzQqFEjXLt2DV5eXiqXnd3efh8fH1hbW2PlypVZPhpVo0YN+Pj4YO7cudi8eTP69euX5aDh2amHrNjY2KBr164YMWIEYmJipLdfqNOznx1btmxRqItHjx7h3LlzCp0hrq6u+PvvvxUOzC9fvlR4M0Z2Y/P29oapqSk2bdqkkP748WMcP35cGkC/MIqIiMCECRNgbW0tDZwMqP87ZEYmk8HIyEjh4Pf06VOl9geo/5d/Dw8PFC9eHL/++qvCthQfH48dO3ZIb+TLqTp16sDExASbN29WSD937ly2H5spVaoURo4ciWbNmuHq1atSurbvdkgf6/bt25GUlKTUvtLvD48fP463b98qpGWnfcnbT/r2tWPHDsTHxxfq9pVbihcvjq+++grt2rVT6DBJr23btnj58iWSk5NVHtfkJ5rybSSjbSgzMpkMQgilk/XVq1cjOTlZg7VTzcPDA87OzhkeR9KSdxqn39b37Nmj9vLk+63065X2LaVy2W0vb9++xe7duxXS5W8RZHsh+rSp+qMY8P9HetN2BmV0nNfG+VHbtm0RGhoKd3d3lft3de9+19fXR+3ataW7Y+TnKblx/Mho35z+uqVFixYwMDDAgwcPMrwmzK5WrVohISFB5duL5dq2bQshBP7991+Vy6xcuXK2l6uJ7F6XyR/FS38eFhISgjt37mTruDJo0CAYGRmhV69euHv3bpZP7hBpW57fKZWehYUFli1bhr59+yImJgZdu3aFg4MDnj9/jhs3buD58+dYsWIFAGDGjBlo2bIlmjVrhvHjxyM5ORlz586Fubm5wl9m5c8Fr1mzBu7u7qhSpQouXbqEX3/9VWn5S5cuRb169VC/fn0MGzYMrq6uePPmDe7fv4+9e/dm+VYgVeuzcOFCDBo0CE2bNsWXX34JR0dH3L9/Hzdu3MAPP/ygkN/f3x89evSATCbD8OHD1VqGuvWgSrt27VCpUiXUrFkTRYsWxaNHj7BkyRK4uLhIb/mS73yXLl2Kvn37wtDQEB4eHgrjW2RHdHQ0OnXqhC+//BKxsbEICAiAiYmJ9FYKIPWtZT/99BN69+6NL7/8Ei9fvsS8efOUHq2wtLSEi4sL/vjjDzRp0gR2dnawt7dXeQeLjY0Npk6diilTpsDPzw89e/bEy5cvERQUBBMTE6U3KxZUoaGh0vPx0dHROH36NNauXQt9fX3s2rVL4S4XdX+HzLRt2xY7d+7E8OHDpbfXzZgxA87Ozrh3755C3sqVK+PEiRPYu3cvnJ2dYWlpqfIvM3p6epg3bx569eqFtm3bYsiQIUhMTMT8+fPx+vVrzJkzR/MKSsPW1hYTJkzAzJkzMWjQIHTr1g2RkZEIDAzM8lGh2NhYNGrUCF988QXKly8PS0tLhISE4ODBg+jcubPCOu/cuRMrVqxAjRo1oKenp9GJltzOnTthYGCAZs2aSW/fq1KlCrp37y7l6dOnD6ZOnYpp06bB19cXYWFh+OGHH2Btba1QVqVKlQAAq1atgqWlJUxMTODm5qayc75Zs2Zo0aIFvv76a8TFxaFu3brS2/eqVauGPn36aLxOlDF1tvXPP/8cmzdvRuvWreHv749atWrB0NAQjx8/RnBwMDp06IBOnTqhQoUK6N27N5YsWQJDQ0M0bdoUoaGh0psfM2NlZYUGDRpg/vz50j745MmT+OWXX2BjY6OltU1t+zNmzMCgQYOk48jr169VtkknJyc0bdoUs2fPhq2tLVxcXHDs2DHs3LlT7eWVL18e7u7umDRpEoQQsLOzw969e3HkyBGlvNk5Vvr5+eHHH39E3759ER4ejsqVK+PMmTOYNWsWWrdujaZNm2azZogoL7Vo0QIlSpRAu3btUL58eaSkpOD69etYuHAhLCws4O/vL+WtXLkytm7dim3btqF06dIwMTFB5cqVtXJ+NH36dBw5cgQ+Pj4YPXo0PDw8kJCQgPDwcBw4cAArV67McAiRlStX4vjx42jTpg1KlSqFhIQE6c1w8n1Qbhw/WrduDTs7OwwcOBDTp0+HgYEB1q1bh8jISIV8rq6umD59Or755hv8888/aNmyJWxtbfHs2TNcunQJ5ubmCAoKytbv1rNnT6xduxZDhw7F3bt30ahRI6SkpODixYuoUKECPv/8c9StWxeDBw9G//79cfnyZTRo0ADm5uaIiorCmTNnULlyZWksYG3LyXWZh4cHBg8ejGXLlkFPTw+tWrWS3r5XsmRJjB07Vu04bGxs4OfnhxUrVsDFxUXj8ZqJNKatEdOzetOX/K04v/32m8rpJ0+eFG3atBF2dnbC0NBQFC9eXLRp00Yp/549e4SXl5cwMjISpUqVEnPmzFH5VofY2FgxaNAg4ejoKMzNzUW7du1EeHi4yrdQPXz4UAwYMEAUL15cGBoaiqJFiwofHx8xc+bMLOPP6E1/Bw4cEL6+vsLc3FyYmZkJT09PMXfuXKX1TkxMFMbGxqJly5Yq6yUj6tZD+rc8LFy4UPj4+Ah7e3tp3oEDB4rw8HCF+SZPniyKFSsm9PT0FN5m5OLiItq0aaMypozevrdx40YxevRoUbRoUWFsbCzq168vLl++rDT/+vXrRYUKFYSJiYnw9PQU27ZtU3rjlxBCHD16VFSrVk0YGxsrvOEj/Vs85FavXi3VlbW1tejQoYPS20n69u0rzM3NlWLK6I0h+UH6N2IaGRkJBwcH4evrK2bNmiWio6NVzqfO7yDf7ufPn6+yjDlz5ghXV1dhbGwsKlSoIH7++WeVdXn9+nVRt25dYWZmpvB2u4zeorV7925Ru3ZtYWJiIszNzUWTJk3E2bNnFfLIl/P8+XOV9aHqTVlppaSkiNmzZ4uSJUsKIyMj4eXlJfbu3av0Nq30bT8hIUEMHTpUeHl5CSsrK2Fqaio8PDxEQECAiI+Pl+aLiYkRXbt2FTY2NkImk0l1klmdZvb2vStXroh27doJCwsLYWlpKXr27KnwVk8hUvczEydOFCVLlhSmpqbC19dXXL9+XanNCiHEkiVLhJubm9DX11dYpqq2+P79e/H1118LFxcXYWhoKJydncWwYcPEq1evFPJltN/I6G2PlEqdN2gKofpNTx8/fhQLFiwQVapUESYmJsLCwkKUL19eDBkyRNy7d0/Kl5iYKMaPHy8cHByEiYmJqFOnjjh//nyG+/O0bfLx48eiS5cuwtbWVlhaWoqWLVuK0NBQpXkzWg913ugnt3r1alG2bFlhZGQkypUrJ9asWaNym4yKihJdu3YVdnZ2wtraWvTu3VtcvnxZ5dv3VO3zhRAiLCxMNGvWTFhaWgpbW1vRrVs3ERERofL8IaNjpapt++XLl2Lo0KHC2dlZGBgYCBcXFzF58mSRkJCgkA+AGDFihFJcqtorEeWNbdu2iS+++EKULVtWWFhYCENDQ1GqVCnRp08fERYWppA3PDxcNG/eXFhaWgoACvupnJ4fCZH6JurRo0cLNzc3YWhoKOzs7ESNGjXEN998I96+fZvhOpw/f1506tRJuLi4CGNjY1GkSBHh6+sr9uzZo5BP28cPIYS4dOmS8PHxEebm5qJ48eIiICBArF69WuV52e7du0WjRo2ElZWVMDY2Fi4uLqJr167i6NGjUp7snLe/f/9eTJs2TTqGFClSRDRu3FicO3dOId+aNWtE7dq1hbm5uTA1NRXu7u7Cz89P5TWLqmWqc96p7euy5ORkMXfuXFGuXDlhaGgo7O3tRe/evUVkZKTC/L6+vqJixYqZrseJEycEADFnzpxM8xHlBpkQOXz91icgMDAQQUFBOX6TmC7s3bsX7du3x/79+6XB1YmIiIiIiPIbV1dXNGzYMNNH5ujTM378eKxYsQKRkZEaD1ZPpCmdP75XWIWFheHRo0cYP348qlatKr3KlYiIiIiIiCi3XbhwAX///TeWL1+OIUOGsEOKdIKdUjoyfPhwnD17FtWrV8f69euz/cYtIiIiIiIiIk3JXxbUtm1bzJw5U9fhUCFVIB7fIyIiIiIiIiKi/EVP1wEQEREREREREVHhw04pIiIiIiIiIiLKc+yUIiIiIiIiIiKiPMdOKSIiIiIiIiIiynM6efteSkoKnjx5AktLS751jvKcEAJv3rxBsWLFoKdXePpl2e5I19j22PZIN9j22PaIiIjymrrnHzrplHry5AlKliypi0UTSSIjI1GiRAldh5Fn2O7oU8G2R6QbbHtERESU17I6/9BJp5SlpSWA1OCsrKx0EQIVYnFxcShZsqS0HRYWbHeka2x7bHukG4W97Z0FUBc3AACxq6topWzr97FaKSc/mOPnDwCoar0O3t8DWAZYd4xF4HxrrS9rXewF6d/XY+oAAGzcJgFoBwDYgLoAgPqxxgrzBSEo03KXPp6k8N26YpRSnuVwBgBsjd2GvQN7pObbm8HvfD0BrsUeSl8nWtfBcJzFDdRFFQQCc8YCR4EGOw5KeZ7CCX9bPwIA3IAfRsVuAwCcsm4JLANi6/y/Pq0NXgOr0tzdtwZAYjQexlaCm0N0atoAYPkKa7RKUxd2NxMR45X63e1WNBCRcZ2osq5Nd5XpZa0PZa8gAJP/Wz9VZlv3yDJPRvOos6yxWAwA6PTPQaDaEsQWD8STMFtU+OchECFDg4YHVRXzSTplXR27Yvug8eMLQPNMMu5WTnJ1v6PwPbxyBenfx8PqoJP1xv9PrOOQ+v9SGS8idpT223x6173KKXx/b/03AKDlsuztc3f5tUDjgan7EzEfkL1ITbd+8l85qxTzxxZRXDdr81g0mHMQezv1wOLjqWm/xp5UyPN3l6q4cdQao2K3oTX+RFXrdRj9X56/v6iaYWwb9lvD79s06zPzHQDg7H/7IG2oC+V9nNZ0N5P+OWm78jYxB2nbVzyALlmef+ikU0p+C7WVlRVP0ElnCtut/Gx39Klg2yPSjcLa9iwAAKknxFZmGWbPpsLTlk2sjAAA5gCsTAHoAzC2gkkuLEvPykL6t1WS/F/GkP+K8p/PykpxWzbKIhorpesh5d/P9L//G1iZwcrwvy+yDH5nSyOFWFPntfhvKzMBTKwAg9Sy5PRhIa2BJdJOswJMgTTFAYZWgHGadZQBwPvU9ZbHZJy63LR1YWUBJMm/W1j9v8LUZCatuCILlamZM8iksVmokSc7MaQvx1x+iWtpBcAEVnrAGytZ6ndzWbaWq3uWMLcySN2GM3v6WkUFydJt+FZp5je3MoB8vwgAMPhvuzLKeBFWmmwI2WRhpa/wXQrZNHv7XHMrA6kdCytAliBNSP1/uk3dKv16G1ul7gsMIO1d9NNXgIGV1JZNYATztHkMM47XDEjdR/y/IACatbOM5eIxyuj/7cdYZQZzpZSszj8Kz8ACRERERERERET0ydDJnVJEREREWUlOEbj0MAbRbxLgYGmCWm520NcrXHf7ZIV1RERERPmZTjulKgUcQsTibroMgajQqRRwCHrGZgif00bXoRARZehgaBSC9oYhKjZBSnO2NkFAO0+0rKS9cRfyM9YRERER5Xd8fI+IiIg+KQdDozBs01WFzhYAeBqbgGGbruJgaC4O4JlPsI6IiIioIGCnFBEREX0yklMEgvaGQaiYJk8L2huG5BRVOQoH1hEREREVFOyUIiIiok/GpYcxSnf/pCUARMUm4NLDmLwL6hPDOiIiIqKCgp1SRERE9MmIfpNxZ4sm+Qoi1hEREREVFOyUIiIiok+Gg6WJVvMVRKwjIiIiKijYKUVERESfjFpudnC2NoEsg+kypL5hrpabXV6G9UlhHREREVFBwU4pIiIi+mTo68kQ0M4TAJQ6XeTfA9p5Ql8voy6Zgo91RERERAUFO6WIiIjok9KykjNW9K4OJ2vFx8+crE2wond1tKzkrKPIPh2sIyIiIioIDHQdABEREVF6LSs5o5mnEy49jEH0mwQ4WKY+jsa7f/6PdURERET5HTuliIiI6JOkryeDt3sRXYfxSWMdERERUX7Gx/eIiIiI6JO0fPlyuLm5wcTEBDVq1MDp06d1HRIRERFpETuliIiIiOiTs23bNowZMwbffPMNrl27hvr166NVq1aIiIjQdWhERESkJeyUIiIiIqJPzqJFizBw4EAMGjQIFSpUwJIlS1CyZEmsWLFC16ERERGRlrBTioiIiIg+KR8+fMCVK1fQvHlzhfTmzZvj3LlzKudJTExEXFycwoeIiIg+beyUIiIiIqJPyosXL5CcnAxHR0eFdEdHRzx9+lTlPLNnz4a1tbX0KVmyZF6ESkRERDnATikiIiIi+iTJZDKF70IIpTS5yZMnIzY2VvpERkbmRYhERESUAwa6DoCIiIiIKC17e3vo6+sr3RUVHR2tdPeUnLGxMYyNjfMiPCIiItIS3ilFRESkA8kpAucfvMQf1//F+QcvkZwidB0S0SfDyMgINWrUwJEjRxTSjxw5Ah8fHx1FRURERNrGO6WIiIjUNHv2bEyZMgX+/v5YsmSJxuUcDI1C0N4wRMUmSGnO1iYIaOeJlpWctRApUf43btw49OnTBzVr1oS3tzdWrVqFiIgIDB06VNehERERkZawU4qIiEgNISEhWLVqFby8vHJUzsHQKAzbdBXp74t6GpuAYZuuYkXv6uyYIgLQo0cPvHz5EtOnT0dUVBQqVaqEAwcOwMXFRdehERERkZbw8T0iIqIsvH37Fr169cLPP/8MW1tbjctJThEI2hum1CEFQEoL2hvGR/mI/jN8+HCEh4cjMTERV65cQYMGDXQdEhEREWmRRp1S8fHx2o6DiNTAtkekGyNGjECbNm3QtGnTLPMmJiYiLi5O4SN36WGMwiN76QkAUbEJuPQwRhthExERERF90jTqlHJ0dMSAAQNw5swZbcdDRJlg2yPKe1u3bsXVq1cxe/ZstfLPnj0b1tbW0qdkyZLStOg3GXdIpaVuPiIiIiKi/EyjTqktW7YgNjYWTZo0Qbly5TBnzhw8efJE27ERUTpse0R5KzIyEv7+/ti0aRNMTEzUmmfy5MmIjY2VPpGRkdI0B0v1ylA3HxERERFRfqZRp1S7du2wY8cOPHnyBMOGDcOWLVvg4uKCtm3bYufOnUhKStJ2nEQEtj2ivHblyhVER0ejRo0aMDAwgIGBAU6ePInvv/8eBgYGSE5OVprH2NgYVlZWCh+5Wm52cLY2gSyD5cmQ+ha+Wm52ubNCRERERESfkBwNdF6kSBGMHTsWN27cwKJFi3D06FF07doVxYoVw7Rp0/Du3TttxUlEabDtEeWNJk2a4NatW7h+/br0qVmzJnr16oXr169DX18/W+Xp68kQ0M4TAJQ6puTfA9p5Ql8vo24rIiIiIqKCwyAnMz99+hQbNmzA2rVrERERga5du2LgwIF48uQJ5syZgwsXLuDw4cPaipWI/sO2R5Q3LC0tUalSJYU0c3NzFClSRCldXS0rOWNF7+oI2humMOi5k7UJAtp5omUl5xzFTJSb3r9/DyEEzMzMAACPHj3Crl274OnpiebNm+s4OiIiIspvNOqU2rlzJ9auXYtDhw7B09MTI0aMQO/evWFjYyPlqVq1KqpVq6atOIkIbHtEBUXLSs5o5umESw9jEP0mAQ6WqY/s8Q4p+tR16NABnTt3xtChQ/H69WvUrl0bhoaGePHiBRYtWoRhw4bpOkQiIiLKRzTqlOrfvz8+//xznD17Fp999pnKPKVLl8Y333yTo+CISBHbHpHunThxQivl6OvJ4O1eRCtlEeWVq1evYvHixQCA33//HY6Ojrh27Rp27NiBadOmsVOKiIiIskWjTqmoqCjptu2MmJqaIiAgQKOgiEg1bbY910n7pX+Hz2mT49iIPkV///03Tpw4gejoaKSkpChMmzZtmo6iIsq/3r17B0tLSwDA4cOH0blzZ+jp6aFOnTp49OiRjqMjIiKi/EajTilLS0tERUXBwcFBIf3ly5dwcHBQ+TYiIso5tj0i9f38888YNmwY7O3t4eTkBJns/4/GyWQydkoRaaBMmTLYvXs3OnXqhEOHDmHs2LEAgOjoaIU3TRIRERGpQ6NOKSGEyvTExEQYGRllqyz53Rq8U4Moa9pse0QF3cyZM/Hdd9/h66+/1nUoRAXGtGnT8MUXX2Ds2LFo0qQJvL29AaTeNcXxDImIiCi7stUp9f333wNI/Qvz6tWrYWFhIU1LTk7GqVOnUL58eY0CcZ20nx1TRBnIzbZHVFC9evUK3bp103UYRAVK165dUa9ePURFRaFKlSpSepMmTdCpUycdRkZERET5UbY6peQDWwohsHLlSujr60vTjIyM4OrqipUrV2o3QiJi2yPSQLdu3XD48GEMHTpU16EQFShOTk5wcnJSSKtVq5aOoiEiIqL8LFudUg8fPgQANGrUCDt37oStrW2uBEVEitj2iLKvTJkymDp1Ki5cuIDKlSvD0NBQYfro0aN1FBlR/hUfH485c+bg2LFjKl8g8M8//+goMiIiIsqPNBpTKjg4WNtxEJEa2PaI1Ldq1SpYWFjg5MmTOHnypMI0mUzGTikiDQwaNAgnT55Enz594OzsrPACgU9VFdyQ/i374h88ED45LvMBnHNcRn7gLjsEDEyTsFBx+npxBXdkypcTD0SL7C8HQGkV05aIKAA/AgAeYzDGyEYAMmCJ+DH13yoMFnl/vvQPqigmHLyJ47JSAIDGIiLL+WUV/ttO71fWdmgKtndol+157oq28JDt02h5i2UZLy+zaZo6LiuFSaqHYM0wvzpU/YbqzpuV9O0ltT04Zq+Q5um+HwZiDF4qppXMdmifjNODUo81Z9WdYWA91ek/qE6WvRAQ9pkfz/rKaih8n9QyGxtaGl1xA/j2plJ62mOVOpyEhVLaU9nb//51X5PQsr3MnzY+UM6jEM9TtcpVu1Nq3LhxmDFjBszNzTFu3LhM8y5atEjdYokoC2x7RJqR32FIRNrz559/Yv/+/ahbt66uQyEiIqICQO1OqWvXruHjx4/SvzOSH/5iRpSfsO0R5Zz8zZVsJ0Q5Y2trCzs7O12HQURERAWE2p1SaR8b4iNERHmHbY9Icxs2bMD8+fNx7949AEC5cuXw1VdfoU+fPjqOjCh/mjFjBqZNm4b169fDzMxM1+EQERFRPqfRmFJERESfukWLFmHq1KkYOXIk6tatCyEEzp49i6FDh+LFixcYO3asrkMkyncWLlyIBw8ewNHREa6urkovELh69aqOIiMiIqL8SO1Oqc6dO6td6M6dOzUKhoiUse0RaWbZsmVYsWIF/Pz8pLQOHTqgYsWKCAwMZKcUkQY6duyo6xCIiIioAFG7U8ra2jo34yCiDLDtEWkmKioKPj7Kb9ny8fFBVFSUDiIiyv8CAgJ0HQIREREVIGp3Sq1duzY34yCiDLDtEWmmTJky2L59O6ZMmaKQvm3bNpQtW1ZHUREVDFeuXMGdO3cgk8ng6emJatWq6TokIiIiyoc4phQRERVIQUFB6NGjB06dOoW6detCJpPhzJkzOHbsGLZv367r8IjypejoaHz++ec4ceIEbGxsIIRAbGwsGjVqhK1bt6Jo0aK6DpGIiIjyEbU7papXr45jx47B1tYW1apVy/S12hzkkkh72PaINNOlSxdcvHgRixcvxu7duyGEgKenJy5dusS7Oog0NGrUKMTFxeH27duoUKECACAsLAx9+/bF6NGjsWXLFh1HSERERPmJ2p1SHTp0gLGxMQAOckmUl9j2iDRXo0YNbNq0SddhEBUYBw8exNGjR6UOKQDw9PTEjz/+iObNm+swMiIiIsqP1O6USjuwJQe5JMo7bHtE6ouLi4OVlZX078zI8xGR+lJSUmBoaKiUbmhoiJSUFB1ERERERPlZjsaUunz5sjTIZYUKFVCjRg1txUVEmWDbI1LN1tYWUVFRcHBwgI2NjcrHXYUQkMlkSE5O1kGERPlb48aN4e/vjy1btqBYsWIAgH///Rdjx45FkyZNdBwdERER5TcadUo9fvwYPXv2xNmzZ2FjYwMAeP36NXx8fLBlyxaULFlSmzES0X/Y9ogyd/z4cdjZ2QEAgoODdRwNUcHzww8/oEOHDnB1dUXJkiUhk8kQERGBypUr81FZIiIiyjaNOqUGDBiAjx8/4s6dO/Dw8AAA3L17FwMGDMDAgQNx+PBhrQZJRKnY9ogy5+vrK/3bzc1NumhOSwiByMjIvA6NqEAoWbIkrl69iiNHjuCvv/6SXiDQtGlTXYdGRERE+ZBGnVKnT5/GuXPnpItiAPDw8MCyZctQt25drQVHRIrY9ojU5+bmJj3Kl1ZMTAzc3Nz4+B5RDjRr1gzNmjXTdRhERESUz2nUKVWqVCl8/PhRKT0pKQnFixfPcVBEpBrbHpH65GNHpff27VuYmJjoICKi/On777/H4MGDYWJigu+//z7TvKNHj86jqIiIiKgg0KhTat68eRg1ahR+/PFH1KhRAzKZDJcvX4a/vz8WLFig7RiJ6D+51fZcJ+2X/h0+p402QiXSmXHjxgEAZDIZpk6dCjMzM2lacnIyLl68iKpVq+ooOqL8Z/HixejVqxdMTEywePHiDPPJZDK1OqVatGiBM2fO4N27d5DJZHB0dMSaNWvQqlUrKU+ZMmXw4MEDhfnMzc3x9u1bzVeEiIiIPjlqd0rZ2toq/MU5Pj4etWvXhoFBahFJSUkwMDDAgAED0LFjR60HSlRYse0RZc+1a9cApN4pdevWLRgZGUnTjIyMUKVKFUyYMEFX4RHlOw8fPlT5b01duXIFPXv2RLt27ZCYmIhRo0ahXbt2ePLkicLjtvb29jh27Jj03dzcPMfLJiIiok+L2p1SS5YsycUwiCgjbHtE2SN/617//v2xdOlSWFlZ6TgiooJj+vTpmDBhgsIdiADw/v17zJ8/H9OmTcuyjBcvXih8r1y5Mjw9PbFt2zaMGjVKSjcwMICXl5d2AiciIqJPktqdUn379s3NOIgoA2x7RJpZu3atrkMgKnCCgoIwdOhQpU6pd+/eISgoSK1OqfSePHkCAChRooRC+tOnT6GnpwcDAwOULl0aO3bsQMWKFTMsJy4uDnFxcdL3N2/eZDsWIiIiylsajSmV1vv375UGXuZfpYlyH9seUdZCQkLw22+/ISIiAh8+fFCYtnPnziznnz17Nnbu3Im//voLpqam8PHxwdy5cxXegElUmGT0AoEbN27Azs4u2+WlpKSgV69esLKyQqdOnaT0Nm3awNbWFlWqVMHVq1exYMEC1KhRA9HR0Rke69q3b4+TJ09mOwYiIiLSHT1NZoqPj8fIkSPh4OAACwsL2NraKnyIKHew7RGpb+vWrahbty7CwsKwa9cufPz4EWFhYTh+/Disra3VKuPkyZMYMWIELly4gCNHjiApKQnNmzdHfHx8LkdP9GmxtbWFnZ0dZDIZypUrBzs7O+ljbW2NZs2aoXv37tkut0qVKnjx4gWOHj2qkL506VIEBgaiU6dOmDFjBs6fP4/ExETMnDkzw7L27NmDyMhI6RMWFpbteIiIiChvaXSn1MSJExEcHIzly5fDz88PP/74I/7991/89NNPmDNnjrZjJKL/sO0RqW/WrFlYvHgxRowYAUtLSyxduhRubm4YMmQInJ2d1Srj4MGDCt/Xrl0LBwcHXLlyBQ0aNMiNsIk+SUuWLIEQAgMGDEBQUJBCx66RkRFcXV3h7e2drTK9vLxw584dHD9+HJ999lmmeatWrQpDQ0PcunUrwzxWVlYKd1GlfZSPiIiIPk0adUrt3bsXGzZsQMOGDTFgwADUr18fZcqUgYuLCzZv3oxevXppO04iAtseUXY8ePAAbdq0AQAYGxsjPj4eMpkMY8eORePGjREUFJTtMmNjYwFAo8eUiPIz+fiGbm5u8PHxgaGhocZlpaSkoGrVqrh9+zYOHjyoVgfvvXv38PHjR5QsWVLj5RIREdGnR6PH92JiYuDm5gYg9a9SMTExAIB69erh1KlT2ouOiBSw7RGpz87OThrouHjx4ggNDQUAvH79Gu/evct2eUIIjBs3DvXq1UOlSpUyzJeYmCgNuJx+4GWi/M7X11fqkHr//r1G27qXlxdu3bqFRYsWwdHRETdv3sTNmzelY9rTp09Rs2ZNrFq1CmfOnMGSJUtQvXp16OnpITAwMLdWjYiIiHRAo06p0qVLIzw8HADg6emJ7du3A0i9i8PGxkZbsRFROmx7ROqrX78+jhw5AgDo3r07/P398eWXX6Jnz55o0qRJtssbOXIkbt68iS1btmSab/bs2bC2tpY+vLODCpJ3797leGzD27dvAwDGjBmDKlWqSJ+JEycCSH0cMDw8HEOHDkX9+vUxYcIEODo64ty5cyhWrFiurRsRERHlPY0e3+vfvz9u3LgBX19fTJ48GW3atMGyZcuQlJSERYsWaTtGIvpPXrQ910n7pX+Hz2mjlTKJdOGHH35AQkICAGDy5MkwNDTEmTNn0LlzZ0ydOjVbZY0aNQp79uzBqVOnlF5bn97kyZMxbtw46XtcXBw7pqjA+Oqrr3I8tqEQItPpdnZ2ePHihTbCJSIiok+cRp1SY8eOlf7dqFEj3LlzB1euXIG7uzuqVKmiteCISBHbHpF6kpKSsHfvXrRo0QIAoKenh4kTJ0p3YqhLCIFRo0Zh165dOHHihPT4bGaMjY1hbGysUdxEnzqObUhERETapFGnVHouLi5wcXHRRlFElA1se0SqGRgYYNiwYbhz506OyhkxYgR+/fVX/PHHH7C0tMTTp08BANbW1jA1NdVGqET5SmZjGw4bNkyXoREREVE+pNGYUgBw7NgxtG3bFu7u7ihTpgzatm2Lo0ePajM2IlKBbY9IPbVr18a1a9dyVMaKFSsQGxuLhg0bwtnZWfps27ZNS1ES5S8c25CIiIi0SaNOqR9++AEtW7aEpaUl/P39MXr0aFhZWaF169b44YcftB0jEf2HbY9IfcOHD8f48ePxww8/4Pz589IbvuQfdQghVH769euXu8ETfaLkYxsCqeOnLV++HMbGxhg7diy++uorHUdHRERE+Y1Gj+/Nnj0bixcvxsiRI6W00aNHo27duvjuu+8U0olIe9j2iNTXo0cPAKltRE4mk0EIAZlMhuTkZF2FRpRvpR/b8K+//sLly5c5tiERERFpRKNOqbi4OLRs2VIpvXnz5vj6669zHBQRqca2R6S+hw8f6joEogLl48ePaN68OX766SeUK1cOAFCqVCmUKlVKx5ERERFRfqXR43vt27fHrl27lNL/+OMPtGvXLsdBEZFqbHtE6pO/CCCjDxFlj6GhIUJDQyGTyXQdChERERUQat8p9f3330v/rlChAr777jucOHEC3t7eAIALFy7g7NmzGD9+vPajJCrE2PaINLNhw4ZMp/v5+eVRJEQFh5+fH3755RfMmTNH16EQERFRAaB2p9TixYsVvtva2iIsLAxhYWFSmo2NDdasWYNvv/1WexESFXJse0Sa8ff3V/j+8eNHvHv3DkZGRjAzM2OnFJEGPnz4gNWrV+PIkSOoWbMmzM3NFaYvWrRIR5ERERFRfqR2pxTH5iDSDbY9Is28evVKKe3evXsYNmwY3xJGpKHQ0FBUr14dAPD3338rTONjfURERJRdGg10npYQAgBPRIjyGtseUfaVLVsWc+bMQe/evfHXX3/pOhyifCc4OFjXIRAREVEBotFA50DqWB2VK1eGqakpTE1N4eXlhY0bN2ozNiJSgW2PKGf09fXx5MkTXYdBlK/dv38fhw4dwvv37wH8/w8lRERERNmh0Z1SixYtwtSpUzFy5EjUrVsXQgicPXsWQ4cOxYsXLzB27Fhtx0lEYNsjyo49e/YofBdCICoqCj/88APq1q2ro6iI8reXL1+ie/fuCA4Ohkwmw71791C6dGkMGjQINjY2WLhwoa5DJCIionxEo06pZcuWYcWKFQqDxHbo0AEVK1ZEYGCgxhfGrpP2AwDC57TRaH6igi632h5RQdSxY0eF7zKZDEWLFkXjxo154UykobFjx8LQ0BARERGoUKGClN6jRw+MHTuWbYuIiIiyRaNOqaioKPj4+Cil+/j4ICoqKsdBEZFqbHtE6ktJSdF1CEQFzuHDh3Ho0CGUKFFCIb1s2bJ49OiRjqKi3OAuO6R23iXiR4yRjcjFaLJnlayR9O/BovCMgxZT1UTh+/YO7bRW9l3RFh6yfVorj/4vO22NKDNOwgJPZW91HYbEIdYc0dZZ59OoU6pMmTLYvn07pkyZopC+bds2lC1bVpMiiUgNbHtEmRs3bpzaefnqeqLsi4+Ph5mZmVL6ixcvYGxsrIOIiIiIKD/TqFMqKCgIPXr0wKlTp1C3bl3IZDKcOXMGx44dw/bt27UdIxH9h22PKHPXrl1T+H7lyhUkJyfDw8MDQOor7PX19VGjRg1dhEeU7zVo0AAbNmzAjBkzAKQ+FpuSkoL58+ejUaNGWcxNREREpEijTqkuXbrg0qVLWLRoEXbv3g0hBDw9PXHp0iVUq1ZN2zES0X/Y9ogyl/Z19YsWLYKlpSXWr18PW1tbAMCrV6/Qv39/1K9fX1chEuVr8+fPR8OGDXH58mV8+PABEydOxO3btxETE4OzZ8/qOjwiIiLKZ7LdKfXx40cMHjwYU6dOxaZNm3IjJiJSgW2PKHsWLlyIw4cPSx1SAGBra4uZM2eiefPmGD9+vA6jI8qfPD09cfPmTaxYsQL6+vqIj49H586dMWLECDg7O+s6PCIiIspn9LI7g6GhIXbt2pUbsRBRJj6ltuc6ab/0tkyiT1VcXByePXumlB4dHY03b97oICKi/C8iIgKOjo4ICgrCvn37cODAAcycORPOzs6IiIjQdXhERESUz2S7UwoAOnXqhN27d2s5FCLKCtsekfo6deqE/v374/fff8fjx4/x+PFj/P777xg4cCA6d+6s6/CI8iU3Nzc8f/5cKf3ly5dwc3PTQURERESUn2n89r0ZM2bg3LlzqFGjBszNzRWmjx49WivBEZEitj0i9a1cuRITJkxA79698fHjRwCAgYEBBg4ciPnz5+s4OqL8SQgBmUymlP727VuYmJiomIOIiIgoYxp1Sq1evRo2Nja4cuUKrly5ojBNJpPl+MJY/lhQ+Jw2OSqHqKDJ7baXXtpH9NgeKb8xMzPD8uXLMX/+fDx48ABCCJQpU0apM5eIsjZu3DgAqceaqVOnwszMTJqWnJyMixcvomrVqjqKjoiIiPIrjTqlHj58KP1bCAEAKv9qRkTapcu2xzGkKL8yNzeHl5eXrsMgyteuXbsGIPXYc+vWLRgZGUnTjIyMUKVKFUyYMEFX4REREVE+pVGnFAD88ssvWLx4Me7duwcAKFu2LMaMGYNBgwZpLTgiUsa2R0REeS04OBgA0L9/f3z//fewtLTUcURERERUEGjUKTV16lQsXrwYo0aNgre3NwDg/PnzGDt2LMLDwzFz5kytBklEqdj2iIhIF9K+HKBv374Z5tu5c2dehENEREQFhEadUitWrMDPP/+Mnj17Smnt27eHl5cXRo0axQtjolzCtkdERLpgbW2t6xCIiIioANKoUyo5ORk1a9ZUSq9RowaSkpJyHBQRqca2R0REurB27Vpdh0BEREQFkJ4mM/Xu3RsrVqxQSl+1ahV69eqV46CISDW2PSIiIiIiIioocjTQ+eHDh1GnTh0AwIULFxAZGQk/Pz/ptcEAsGjRopxHSUQStj0iIiIiIiIqCDTqlAoNDUX16tUBAA8ePAAAFC1aFEWLFkVoaKiUL69eVU9UWLDtERFRftewYUOcPHlSIU1PTw/JyckAgJSUFDRu3BinT59GSkoKrK2tsX79enTo0EEX4RIREVEu0qhTSv5aYCLKW2x7RERUEBgbG+PSpUvSd0NDQ+nfbdq0wcmTJ/HVV1/B29sb/v7+6Ny5MyIjI1GsWDFdhEtERES5RKMxpfKK66T9cJ20X9dhEBFRIbd8+XK4ubnBxMQENWrUwOnTp3UdElG+JpPJ4OXlJX0qVKgAIPUuqcOHD6Nly5aYN28eOnXqhNDQUKSkpOCrr77ScdRERESkbZ90pxQREZGubdu2DWPGjME333yDa9euoX79+mjVqhUiIiJ0HRpRvpWQkAB9fX0YGhqiVKlSOHHiBADg1KlTSElJgZ+fn5TXysoKTk5OuHDhgo6iJSIiotyi8UDnREREhcGiRYswcOBADBo0CACwZMkSHDp0CCtWrMDs2bN1HB1R/tO4cWN89tlnqFOnDh48eIBZs2ahSZMm+Ouvv3D37l0AgIeHh8I8NjY2eP78eablxsXFIS4uTvr+5s0b7QdPREREWsVOKSLSWNrHa8PntNFhJES548OHD7hy5QomTZqkkN68eXOcO3dO5TyJiYlITEyUvqe9SCYiYNq0aQrf+/XrB2dnZ0yYMAGtW7cGkDrweVpCiCzLbd++vdIA6kRERPRp4+N7REREGXjx4gWSk5Ph6OiokO7o6IinT5+qnGf27NmwtraWPiVLlsyLUInyLQcHB9jY2OD+/fvSHVJ37txRyBMbGwtra+tMy9mzZw8iIyOlT1hYWK7FTERERNrBO6WISCsyeikB76CigkAmkyl8F0IopclNnjwZ48aNk77HxcWxY4ooE3FxcXj9+jWqVKmCBg0aQE9PDxs3bkTPnj0BAG/fvsXTp0/xxRdfZFqOlZUVrKysFMolIiKiT1u+uFOKb+AjIiJdsLe3h76+vtJdUdHR0Up3T8kZGxtLF8fpL5KJCKhZsyaWLl2KU6dO4ZdffkHZsmWRkpKCGTNmQE9PD82bN8eff/6Jr7/+Grt27UKlSpWgp6eH+fPn6zp0IiIi0jLeKUVERJQBIyMj1KhRA0eOHEGnTp2k9CNHjqBDhw46jIwo/4qOjsa4ceOQkpICPT09ODk54Y8//kDdunUBAPv370fjxo2xYMECpKSkwNraGr///juKFSum48iJiIhI29gpRURElIlx48ahT58+qFmzJry9vbFq1SpERERg6NChug6NKF+KiIjIdLqenh5OnDiRN8EQERGRTrFTioiIKBM9evTAy5cvMX36dERFRaFSpUo4cOAAXFxcdB0aEREREVG+lm86peTjSnHQZKL8Je2YcGy/lF8NHz4cw4cP13UYREREREQFSr7plJJj5xRR/sU39BEREREREZFcvnj7nip8Ix9RweE6aT/bNBERERERUSGTbzulAF7IEhERERERERHlV/m6U4qIiIiIiIiIiPKnfDemlCocSJmo4GG7JiIiIiIiKtgKRKdUWpk9zscLW6LChy9HICIiIiIi+jQVuE4pIip4tHHXFO+8IiIiIiIi+rQUqk6pnAyKzotYotynThvNKA87q4iIiIiIiPKXQtUplRN8LJCIiIiIiIiISHvYKaUFObkDK6fYIUaUStvtMK/uoOKdWkREREREVFixUyqf02WHWHbwYps+JRm1m+ymy7drdTqW2PlERERERESkiJ1SlCe03XnGi3r6FKjarnMyLpaqjqvstp28Glsrq/yq4k5JfKdRbEREREREVDDppFNKCAGAFyikuVJjf9NovtCgFoiLiwPw/+2wsGC7y1803cY1nS8teRsBgEoBh6R/hwa1kP6ddjtSd5nyeQpr20tbr0R5qbAf94C3Culv4lLyPph8KbXeEuI+AADiAcQl/zcpMQ4JAJLj3gIw+C/P/+s5+3WcOm9KnL6UIt9lJhh8yCSut8jKh7gExL1Jn6q8P37/3/+T4t4h7uN/X0QG++03CUiJ+/+y3wP4/yISgIQ4hdiS4t4hGW8BpB4H3/yXJsXyHv/P/+a/ZSbK/r88kTpXXJz4f0yJqbPFxWXQrt/G4Z20ItqRdW3/n3z9sjOPpv5fl6lLjI9LSv3nmzgACYhLAd7EidTv8TKl/NlfRvbm1YyZ9K/4uKTUbTg7zeqt9B9J2maZWkdpGkaSaer/0ze3tPPnwY/5VtrJpHqfbnqCmuXExyVJ7VjEATJ57B8zPheLS7vuiXGp+4KkTJaZFCe15QR8QDzk+8TMl6Ot7SYlo7aPeK2Un71lZpQ/dV2zOv+QCR2coTx+/BglS5bM68USKYiMjESJEiV0HUaeYbujTwXbHpFuFLa2988//8Dd3V3XYRARERVqWZ1/6KRTKiUlBXfv3oWnpyciIyNhZWWV1yEUSHFxcShZsiTrNAtCCLx58wbFihWDnp6ersPJMykpKXjy5AksLS0hk8myniGfKSzbf35eT7Y95baXn3/P7Cos6/oprmdhbXuvX7+Gra0tIiIiYG1tretw8qVPcXvOT1h/OcP6yznWYc6w/nJG3fMPnTy+p6enh+LFiwMArKys+ANrGes0a4Xx5FRPT69Q/IW8sGz/+XU92fZUy6+/pyYKy7p+autZWNsekLrun9JvkR99attzfsP6yxnWX86xDnOG9ac5dc4/Cs+fy4iIiIiIiIiI6JPBTikiIiIiIiIiIspzOuuUMjY2RkBAAIyNjXUVQoHDOqXCrLBs/4VlPQuLwvR7FpZ1LSzrmR/wt8g51mHOsP5yhvWXc6zDnGH95Q2dDHRORERERERERESFGx/fIyIiIiIiIiKiPMdOKSIiIiIiIiIiynPslCIiIiIiIiIiojyns06p5cuXw83NDSYmJqhRowZOnz6tq1DylcDAQMhkMoWPk5OTNF0IgcDAQBQrVgympqZo2LAhbt++rcOIibRn9uzZ+Oyzz2BpaQkHBwd07NgRd+/eVchTENvA7NmzIZPJMGbMGCmtIK5nYVTQjoVso2OktIK4nvlNQWtf2nLq1Cm0a9cOxYoVg0wmw+7duxWmq7PtJiYmYtSoUbC3t4e5uTnat2+Px48f5+Fa6I629nOFtQ5XrFgBLy8vWFlZwcrKCt7e3vjzzz+l6ay77NH0+FOY61Ab19OFuf5yhdCBrVu3CkNDQ/Hzzz+LsLAw4e/vL8zNzcWjR490EU6+EhAQICpWrCiioqKkT3R0tDR9zpw5wtLSUuzYsUPcunVL9OjRQzg7O4u4uDgdRk2kHS1atBBr164VoaGh4vr166JNmzaiVKlS4u3bt1KegtYGLl26JFxdXYWXl5fw9/eX0gvaehZGBfFYyDbqL6UXtPXMbwpi+9KWAwcOiG+++Ubs2LFDABC7du1SmK7Otjt06FBRvHhxceTIEXH16lXRqFEjUaVKFZGUlJTHa5P3tLWfK6x1uGfPHrF//35x9+5dcffuXTFlyhRhaGgoQkNDhRCsu+zIyfGnMNehNq6nC3P95QaddErVqlVLDB06VCGtfPnyYtKkSboIJ18JCAgQVapUUTktJSVFODk5iTlz5khpCQkJwtraWqxcuTKPIiTKO9HR0QKAOHnypBCi4LWBN2/eiLJly4ojR44IX19f6YSjoK1nYVUYjoVsowVjPfOjwtC+tCF9p5Q62+7r16+FoaGh2Lp1q5Tn33//FXp6euLgwYN5FvunQpP9HOtQka2trVi9ejXrLhtycvwp7HWY0+vpwl5/uSHPH9/78OEDrly5gubNmyukN2/eHOfOncvrcPKle/fuoVixYnBzc8Pnn3+Of/75BwDw8OFDPH36VKFujY2N4evry7qlAik2NhYAYGdnB6DgtYERI0agTZs2aNq0qUJ6QVvPwqiwHAvZRgvGeuY3haV95QZ1tt0rV67g48ePCnmKFSuGSpUqFcr61WQ/xzpMlZycjK1btyI+Ph7e3t6su2zIyfGHdZiz62nWn/YZ5PUCX7x4geTkZDg6OiqkOzo64unTp3kdTr5Tu3ZtbNiwAeXKlcOzZ88wc+ZM+Pj44Pbt21L9qarbR48e6SJcolwjhMC4ceNQr149VKpUCQAKVBvYunUrrl69ipCQEKVpBWk9C6vCcCxkGy0Y65kfFYb2lVvU2XafPn0KIyMj2NraKuUpbPWr6X6usNfhrVu34O3tjYSEBFhYWGDXrl3w9PSULuhZd5nL6fGnsNdhTq+nC3v95YY875SSk8lkCt+FEEpppKxVq1bSvytXrgxvb2+4u7tj/fr1qFOnDgDWLRUOI0eOxM2bN3HmzBmlafm9DURGRsLf3x+HDx+GiYlJhvny+3pSwf4N2Ubz/3rmd6x/zWlSd4WxfrW9nyssdejh4YHr16/j9evX2LFjB/r27YuTJ09K01l3GcvN409hqcPcup4uLPWXG/L88T17e3vo6+sr9SJGR0cr9UhS1szNzVG5cmXcu3dPemsA65YKulGjRmHPnj0IDg5GiRIlpPSC0gauXLmC6Oho1KhRAwYGBjAwMMDJkyfx/fffw8DAQFqX/L6ehVlBPxayjbKN6lJBb1+5SZ026uTkhA8fPuDVq1cZ5ikMcrKfK+x1aGRkhDJlyqBmzZqYPXs2qlSpgqVLl7Lu1KCN409hr8P0sns9zfrTvjzvlDIyMkKNGjVw5MgRhfQjR47Ax8cnr8PJ9xITE3Hnzh04OzvDzc0NTk5OCnX74cMHnDx5knVLBYIQAiNHjsTOnTtx/PhxuLm5KUwvKG2gSZMmuHXrFq5fvy59atasiV69euH69esoXbp0gVjPwqygHgvZRtlGPwUFtX3lBXXaaI0aNWBoaKiQJyoqCqGhoYWifrWxnyvsdZieEAKJiYmsOzVo4/hT2OswvexeT7P+ckGeDamehvw1vb/88osICwsTY8aMEebm5iI8PFwX4eQr48ePFydOnBD//POPuHDhgmjbtq2wtLSU6m7OnDnC2tpa7Ny5U9y6dUv07NmTr6CmAmPYsGHC2tpanDhxQuE1ru/evZPyFNQ2kPbNKkIU3PUsTArisZBt1F/6XlDXM78oiO1LW968eSOuXbsmrl27JgCIRYsWiWvXrolHjx4JIdTbdocOHSpKlCghjh49Kq5evSoaN25caF6Hrq39XGGtw8mTJ4tTp06Jhw8fips3b4opU6YIPT09cfjwYSEE604Tmhx/CnMdauN6ujDXX27QSaeUEEL8+OOPwsXFRRgZGYnq1atLr1GlzPXo0UM4OzsLQ0NDUaxYMdG5c2dx+/ZtaXpKSooICAgQTk5OwtjYWDRo0EDcunVLhxETaQ8AlZ+1a9dKeQpqG0h/wlFQ17OwKWjHQrZRf+l7QV3P/KSgtS9tCQ4OVtlO+/btK4RQb9t9//69GDlypLCzsxOmpqaibdu2IiIiQgdrk/e0tZ8rrHU4YMAAqV0WLVpUNGnSROqQEoJ1pwlNjj+FuQ61cT1dmOsvN8iEECLv7ssiIiIiIiIiIiLSwZhSRERERERERERE7JQiIiIiIiIiIqI8x04pIiIiIiIiIiLKc+yUIiIiIiIiIiKiPMdOKSIiIiIiIiIiynPslCIiIiIiIiIiojzHTikiIiIiIiIiIspz7JQiIiIiIiIiIqI8x04pLVm3bh1sbGyk74GBgahatWq2ypDJZNi9e3eG08PDwyGTyXD9+nWNYsxtJ06cgEwmw+vXr3UdCmkgP2/D6WPXBVdXVyxZsiRPltWnTx/MmjVL+v7u3Tt06dIFVlZW+bIN7tu3D9WqVUNKSoquQyE1NWzYEGPGjNF1GAqy2v8QEZEyTc73tGnq1KkYPHiw9F0IgcGDB8POzu6Tvu7JyK1bt1CiRAnEx8frOhSifIOdUkRE2ZBRB1hISIjCSVVuuXnzJvbv349Ro0ZJaevXr8fp06dx7tw5REVFwdraOtfj0Ka2bdtCJpPh119/1XUopKadO3dixowZAPK2QxbI+AIqKioKrVq1yrM4iIg+dTKZLNNPv379MGHCBBw7dkwn8T179gxLly7FlClTpLSDBw9i3bp12LdvH6KiolCpUiWdxKapypUro1atWli8eLGuQyHKN9gpVcglJyfz7gQiAB8+fMjR/EWLFoWZmZmWosnYDz/8gG7dusHS0lJKe/DgASpUqIBKlSrByckJMplMab6crl9u69+/P5YtW6brMEhNdnZ2CtugNuR0G3VycoKxsbGWoiEiyv+ioqKkz5IlS2BlZaWQtnTpUlhYWKBIkSI6ie+XX36Bt7c3XF1dpbQHDx7A2dkZPj4+cHJygoGBgdJ8+eGcZsWKFUhOTtZ1KET5Ajul0vj9999RuXJlmJqaokiRImjatCni4+Nx6tQpGBoa4unTpwr5x48fjwYNGqhVdkhICJo1awZ7e3tYW1vD19cXV69eVcon/0uvqakp3Nzc8Ntvv2VablhYGFq3bg0LCws4OjqiT58+ePHiRYb55Xd57Nu3D56enjA2NsajR4/Uik8mk2H16tXo1KkTzMzMULZsWezZsyfDZb1//x5t2rRBnTp1EBMTk0UNkTYUhm0YSN2OS5UqBTMzM3Tq1AkvX75UmN6vXz907NhRIW3MmDFo2LCh9L1hw4YYOXIkxo0bB3t7ezRr1gwAsGjRIlSuXBnm5uYoWbIkhg8fjrdv3wJIfUS1f//+iI2Nlf7KGBgYCED5bpGIiAh06NABFhYWsLKyQvfu3fHs2TNpuvxuj40bN8LV1RXW1tb4/PPP8ebNmwzXOyUlBb/99hvat2+vsB4LFy7EqVOnIJPJpHV0dXXFzJkz0a9fP1hbW+PLL78EAHz99dcoV64czMzMULp0aUydOhUfP35UimvNmjUoVaoULCwsMGzYMCQnJ2PevHlwcnKCg4MDvvvuO4XYYmNjMXjwYDg4OMDKygqNGzfGjRs3pOk3btxAo0aNYGlpCSsrK9SoUQOXL1+Wprdv3x6XLl3CP//8k+H606dD/vhew4YN8ejRI4wdO1ZqE3Lnzp1DgwYNYGpqipIlS2L06NEKjzNoso2uW7cOQUFBuHHjhrS8devWAVB+fO/WrVto3LixtD8cPHiw1JaB/+8nFixYAGdnZxQpUgQjRoxQaA9ERPmZk5OT9LG2toZMJlNKS3/3qXzfOGvWLDg6OsLGxgZBQUFISkrCV199BTs7O5QoUQJr1qxRWNa///6LHj16wNbWFkWKFEGHDh0QHh6eaXxbt25VOKfp168fRo0ahYiICMhkMqmzSpNzNkDxusfDwwNmZmbo2rUr4uPjsX79eri6usLW1hajRo1S6ED68OEDJk6ciOLFi8Pc3By1a9fGiRMnpOmPHj1Cu3btYGtrC3Nzc1SsWBEHDhyQprdo0QIvX77EyZMn1f2piAo1dkr9JyoqCj179sSAAQNw584dnDhxAp07d4YQAg0aNEDp0qWxceNGKX9SUhI2bdqE/v37q1X+mzdv0LdvX5w+fRoXLlxA2bJl0bp1a6UL0KlTp6JLly64ceMGevfujZ49e+LOnTsZxuzr64uqVavi8uXLOHjwIJ49e4bu3btnGsu7d+8we/ZsrF69Grdv34aDg4Pa8QUFBaF79+64efMmWrdujV69eqnscIqNjUXz5s3x4cMHHDt2DHZ2dmrVE2musGzDFy9exIABAzB8+HBcv34djRo1wsyZM9Vah/TWr18PAwMDnD17Fj/99BMAQE9PD99//z1CQ0Oxfv16HD9+HBMnTgQA+Pj4KP2lccKECUrlCiHQsWNHxMTE4OTJkzhy5AgePHiAHj16KOR78OABdu/ejX379mHfvn04efIk5syZk2G8N2/exOvXr1GzZk0pbefOnfjyyy/h7e2NqKgo7Ny5U5o2f/58VKpUCVeuXMHUqVMBAJaWlli3bh3CwsKwdOlS/Pzzz0q3mD948AB//vknDh48iC1btmDNmjVo06YNHj9+jJMnT2Lu3Ln49ttvceHCBWl927Rpg6dPn+LAgQO4cuUKqlevjiZNmkj7h169eqFEiRIICQnBlStXMGnSJBgaGkrLdHFxgYODA06fPp31D0efjJ07d6JEiRKYPn261CaA1A6hFi1aoHPnzrh58ya2bduGM2fOYOTIkQrzZ3cb7dGjB8aPH4+KFStKy0vfroDU41zLli1ha2uLkJAQ/Pbbbzh69KjS8oODg/HgwQMEBwdj/fr1WLdundTJRURUWB0/fhxPnjzBqVOnsGjRIgQGBqJt27awtbXFxYsXMXToUAwdOhSRkZEAUve5jRo1goWFBU6dOoUzZ87AwsICLVu2zPCuplevXiE0NFThnGbp0qWYPn06SpQogaioKISEhEjTsnvOJvfu3Tt8//332Lp1Kw4ePCidHx84cAAHDhzAxo0bsWrVKvz+++/SPP3798fZs2exdetW3Lx5E926dUPLli1x7949AMCIESOQmJiIU6dO4datW5g7dy4sLCyk+Y2MjFClShWe0xCpS5AQQogrV64IACI8PFzl9Llz54oKFSpI33fv3i0sLCzE27dvhRBCrF27VlhbW0vTAwICRJUqVTJcXlJSkrC0tBR79+6V0gCIoUOHKuSrXbu2GDZsmBBCiIcPHwoA4tq1a0IIIaZOnSqaN2+ukD8yMlIAEHfv3lW53LVr1woA4vr16xnGlll83377rfT97du3QiaTiT///FMIIURwcLAAIP766y9RpUoV0blzZ5GYmJjpckh7Css23LNnT9GyZUuFtB49eijE3rdvX9GhQweFPP7+/sLX11f67uvrK6pWrZrh+slt375dFClSRPqevp7kXFxcxOLFi4UQQhw+fFjo6+uLiIgIafrt27cFAHHp0iUhRGr9mpmZibi4OCnPV199JWrXrp1hLLt27RL6+voiJSUl03WTx9OxY8cs12/evHmiRo0a0ndVcbVo0UK4urqK5ORkKc3Dw0PMnj1bCCHEsWPHhJWVlUhISFAo293dXfz0009CCCEsLS3FunXrMo2lWrVqIjAwMMuYSfd8fX2Fv7+/EEJx25fr06ePGDx4sELa6dOnhZ6ennj//r00n6bbqKp9EwCxa9cuIYQQq1atEra2ttL+TQgh9u/fL/T09MTTp0+FEKn7CRcXF5GUlCTl6datm+jRo0eWMRER5TcZnb+k36fK943pj/n169eXviclJQlzc3OxZcsWIYQQv/zyi/Dw8FA4P0lMTBSmpqbi0KFDKuO5du2aAKBwriSEEIsXLxYuLi4KaTk5ZwMg7t+/L6UNGTJEmJmZiTdv3khpLVq0EEOGDBFCCHH//n0hk8nEv//+q1B2kyZNxOTJk4UQQlSuXDnL85VOnTqJfv36ZRkzEQnBO6X+U6VKFTRp0gSVK1dGt27d8PPPP+PVq1fS9H79+uH+/fvSnQFr1qxB9+7dYW5urlb50dHRGDp0KMqVKwdra2tYW1vj7du3iIiIUMjn7e2t9D2ju0yuXLmC4OBgWFhYSJ/y5csDSL3TISNGRkbw8vLSKL6085mbm8PS0hLR0dEKeZo2bYrSpUtj+/btMDIyyjAO0q7Csg3fuXNH5TI0kfavc3LBwcFo1qwZihcvDktLS/j5+eHly5fZeovKnTt3ULJkSZQsWVJK8/T0hI2NjUJduLq6KozL4+zsrNSe0nr//j2MjY1Vjhmliqr1+/3331GvXj04OTnBwsICU6dOVfoN08fl6OgIT09P6OnpKaTJY71y5Qrevn2LIkWKKPyWDx8+lH7HcePGYdCgQWjatCnmzJmj8vc1NTXFu3fv1Fo3+rRduXIF69atU9geWrRogZSUFDx8+FDKp+k2mpU7d+6gSpUqCvu3unXrIiUlBXfv3pXSKlasCH19fel7Vm2QiKgwqFixotIxv3LlytJ3fX19FClSROE84P79+7C0tJT2+XZ2dkhISMjwfO79+/cAABMTE7Vi0vSczczMDO7u7grr4urqqnBnU9pzmqtXr0IIgXLlyikcw06ePCmty+jRozFz5kzUrVsXAQEBuHnzplJsPKchUp/yyHGFlL6+Po4cOYJz587h8OHDWLZsGb755htcvHgRbm5ucHBwQLt27bB27VqULl0aBw4cUHi2OCv9+vXD8+fPsWTJEri4uMDY2Bje3t5qDdSX0QVoSkoK2rVrh7lz5ypNc3Z2zrA8U1NTpTLVjS/t4zby2NIPlN6mTRvs2LEDYWFhCgcwyl2FZRsWQmS5PD09PaV8qsaJSd8h9+jRI7Ru3RpDhw7FjBkzYGdnhzNnzmDgwIHZGmdGCKFyndOnq9Oe0rK3t8e7d+/w4cMHtTp806/fhQsX8PnnnyMoKAgtWrSAtbU1tm7dioULFyrkUxVXZrGmpKTA2dlZ5fYkf1NhYGAgvvjiC+zfvx9//vknAgICsHXrVnTq1EnKGxMTg6JFi2a5XvTpS0lJwZAhQzB69GilaaVKlZL+rek2mpWM2iCAHLVBIqLCQJPzgBo1amDz5s1KZWV0XLe3tweQ+hifOsd+Tc/ZNFkXfX19XLlyReGPFgCkjqxBgwahRYsW2L9/Pw4fPozZs2dj4cKFCm9GjomJUegMI6KMsVMqDZlMhrp166Ju3bqYNm0aXFxcsGvXLowbNw5A6g7o888/R4kSJeDu7o66deuqXfbp06exfPlytG7dGgAQGRmpcjDnCxcuwM/PT+F7tWrVVJZZvXp17NixA66urirfTJEd6sanjjlz5sDCwgJNmjTBiRMn4OnpmaPYSH2FYRv29PSU7vZKu4y0ihYtitDQUIW069evK52EpHf58mUkJSVh4cKF0l8It2/frpDHyMgoy7epeHp6IiIiApGRkdLdUmFhYYiNjUWFChUynTcz8oFIw8LCFAYlVdfZs2fh4uKCb775Rkp79OiRxvHIVa9eHU+fPoWBgYHCG3TSK1euHMqVK4exY8eiZ8+eWLt2rdQpJf9rakbbCn26VLWJ6tWr4/bt2yhTpky2ylJnG1W3Da5fvx7x8fHShczZs2ehp6eHcuXKZSsmIiLKXPXq1bFt2zbpZSfqcHd3h5WVFcLCwjTaL6tzzqaJatWqITk5GdHR0ahfv36G+UqWLCmNrTV58mT8/PPPCp1SoaGh6Nq1a47jISoM+Pjefy5evIhZs2bh8uXLiIiIwM6dO/H8+XOFC0j5X21nzpyp9uDQcmXKlMHGjRtx584dXLx4Eb169YKpqalSvt9++w1r1qzB33//jYCAAFy6dElpYFa5ESNGICYmBj179pTeWnX48GEMGDAg268gVTc+dS1YsAC9evVC48aN8ddff2lcDqmvsGzDo0ePxsGDBzFv3jz8/fff+OGHH3Dw4EGFPI0bN8bly5exYcMG3Lt3DwEBAUqdVKq4u7sjKSkJy5Ytwz///IONGzdi5cqVCnlcXV3x9u1bHDt2DC9evFB5a3bTpk3h5eWFXr164erVq7h06RL8/Pzg6+ur8vZzdRUtWhTVq1fHmTNnNJq/TJkyiIiIwNatW/HgwQN8//332LVrl8bxyDVt2hTe3t7o2LEjDh06hPDwcJw7dw7ffvstLl++jPfv32PkyJE4ceIEHj16hLNnzyIkJERh27xw4YJ09x3lL66urjh16hT+/fdfqaP666+/xvnz5zFixAhcv34d9+7dw549exRO2FVRZxt1dXXFw4cPcf36dbx48QKJiYlK5fTq1QsmJibo27cvQkNDERwcjFGjRqFPnz5wdHTU3soTERF69eoFe3t7dOjQAadPn8bDhw9x8uRJ+Pv74/Hjxyrn0dPTQ9OmTTU+p1HnnE0T5cqVQ69eveDn54edO3fi4cOHCAkJwdy5c6U37I0ZMwaHDh3Cw4cPcfXqVRw/flzhnCY8PBz//vsvmjZtmuN4iAoDdkr9x8rKCqdOnULr1q1Rrlw5fPvtt1i4cCFatWol5dHT00O/fv2QnJyscCeIOtasWYNXr16hWrVq6NOnD0aPHg0HBwelfEFBQdi6dSu8vLywfv16bN68OcM7jYoVK4azZ88iOTkZLVq0QKVKleDv7w9ra2uF58C1GV92LF68GN27d0fjxo3x999/56gsylph2Ybr1KmD1atXY9myZahatSoOHz6Mb7/9ViFPixYtMHXqVEycOBGfffYZ3rx5o9b6Vq1aFYsWLcLcuXNRqVIlbN68GbNnz1bI4+Pjg6FDh6JHjx4oWrQo5s2bp1SO/NX0tra2aNCggTTO2rZt27KMISuDBw9WeXu8Ojp06ICxY8di5MiRqFq1Ks6dOye98SwnZDIZDhw4gAYNGmDAgAEoV64cPv/8c4SHh8PR0RH6+vp4+fIl/Pz8UK5cOXTv3h2tWrVCUFCQVMaWLVvQq1cvmJmZ5TgeylvTp09HeHg43N3dpUcwvLy8cPLkSdy7dw/169dHtWrVMHXq1EwfLQfU20a7dOmCli1bolGjRihatCi2bNmiVI6ZmRkOHTqEmJgYfPbZZ+jatSuaNGmCH374QXsrTkREAFL3uadOnUKpUqXQuXNnVKhQAQMGDMD79+8zvXNq8ODB2Lp1q0aPTatzzqaptWvXws/PD+PHj4eHhwfat2+PixcvSne/JycnY8SIEahQoQJatmwJDw8PLF++XJp/y5YtaN68OVxcXLQSD1FBJxPqDNBCki+//BLPnj3Dnj17dB0KkUa4DedvCQkJ8PDwwNatWwvMXUXPnz9H+fLlcfnyZbi5uek6HCIiIsoDQgjUqVMHY8aMQc+ePXUdjlYkJiaibNmy2LJlS7aGySAqzDimlJpiY2MREhKCzZs3448//tB1OETZxm24YDAxMcGGDRs0HvPtU/Tw4UMsX76cHVJERESFiEwmw6pVq1S+vS6/evToEb755ht2SBFlA++UUlPDhg1x6dIlDBkyBIsXL9Z1OETZxm2YiIiIiIiIPiXslCIiIiIiIiIiojzHgc6JiIiIiIiIiCjPsVOKiIiIiIiIiIjyHDuliIiIiIiIiIgoz7FTioiIiIiIiIiI8hw7pYiIiIiIiIiIKM+xU4qIiIiIiIiIiPIcO6WIiIiIiIiIiCjPsVOKiIiIiIiIiIjyHDuliIiIiIiIiIgoz/0PNbSWJWCeb4oAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -458,27 +973,27 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [01:07<00:00, 1.32s/it]\n" + "100%|███████████████████████████████████| 51/51 [01:51<00:00, 2.19s/it]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Outputs will be saved to\n", - "/home/sambray/Documents/moseq_test_proj2/2024_06_12-11_40_09\n" + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/d9bb\n", + "baed42eca56d999882d9f65a62b8_ar\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [00:40<00:35, 1.37s/it]" + " 49%|█████████████████▏ | 25/51 [04:20<02:56, 6.78s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -490,12 +1005,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [01:15<00:01, 1.37s/it]" + " 98%|██████████████████████████████████▎| 50/51 [07:16<00:07, 7.96s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -507,18 +1022,591 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [01:17<00:00, 1.52s/it]\n", - "Reindexing: 100%|█████████████| 5/5 [00:00<00:00, 5.27model snapshot/s]\n" + "100%|███████████████████████████████████| 51/51 [07:25<00:00, 8.74s/it]\n", + "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.94model snapshot/s]\n" ] } ], "source": [ - "MoseqModel().populate()" + "model_key = {\n", + " \"model_params_name\": model_params_name,\n", + " \"pose_group_name\": group_name,\n", + "}\n", + "MoseqModel().populate(model_key)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model is now trained and accessible through the the `MoseqModel` table." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'hypparams': {'ar_hypparams': {'K_0': array([[10., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 10., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 10., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 10., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 10., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 10., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 10., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 10., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 10., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 10., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 10., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 10., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 10.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 10., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 10., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 10., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 10., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 10., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 10., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 10., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 10., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 10., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 10., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 10., 0., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 10., 0.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 10.,\n", + " 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 10., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 10., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 10., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 10., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 10.]]),\n", + " 'K_0_scale': 10.0,\n", + " 'M_0': array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.]]),\n", + " 'S_0': array([[0.01, 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0.01, 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0.01, 0. , 0. , 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0.01, 0. , 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0.01, 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. , 0.01, 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. , 0. , 0.01, 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0.01, 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0.01, 0. ],\n", + " [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0.01]]),\n", + " 'S_0_scale': 0.01,\n", + " 'latent_dim': 10,\n", + " 'nlags': 3,\n", + " 'nu_0': 12,\n", + " 'num_states': 100},\n", + " 'cen_hypparams': {'sigmasq_loc': 0.5},\n", + " 'obs_hypparams': {'nu_s': 5,\n", + " 'nu_sigma': 100000.0,\n", + " 'sigmasq_0': 0.1,\n", + " 'sigmasq_C': 0.1},\n", + " 'trans_hypparams': {'alpha': 5.7,\n", + " 'gamma': 1000.0,\n", + " 'kappa': 10000.0,\n", + " 'num_states': 100}},\n", + " 'noise_prior': array([[[ 85.09396632, 545.57184238, 3.26912788, ...,\n", + " 3.74473452, 3.16806043, 3.16017819],\n", + " [ 51.81106111, 230.71030275, 3.16274819, ...,\n", + " 4.15726905, 3.16711123, 3.16010703],\n", + " [ 9.51601252, 20.12595475, 3.16250782, ...,\n", + " 3.90254457, 3.16632719, 3.15950745],\n", + " ...,\n", + " [ 3.16452054, 3.17060538, 3.16077972, ...,\n", + " 3.1607654 , 785.3479052 , 3.15928394],\n", + " [ 3.16425008, 3.17144215, 3.16506481, ...,\n", + " 3.16049012, 655.20722205, 3.15939231],\n", + " [ 3.16317888, 3.17151249, 3.16149601, ...,\n", + " 3.16017743, 807.39627946, 3.15929523]],\n", + " \n", + " [[ 5.20974151, 3.31407256, 3.1595703 , ...,\n", + " 3.15975227, 708.58301097, 3.16154236],\n", + " [ 6.40493147, 3.40467013, 3.16134418, ...,\n", + " 3.15987271, 701.15784208, 3.16455056],\n", + " [ 4.25600686, 3.76226764, 3.16022562, ...,\n", + " 3.15967511, 890.53950356, 3.16566386],\n", + " ...,\n", + " [2767.0914515 , 402.89713042, 83.81455615, ...,\n", + " 2666.74427478, 1826.81322958, 1494.65445934],\n", + " [2521.47500505, 381.62513487, 17.9536452 , ...,\n", + " 2578.18433345, 1932.01796793, 1351.12016796],\n", + " [2754.9473198 , 190.44217276, 81.71405037, ...,\n", + " 2385.74517734, 2056.9868742 , 1693.76296152]],\n", + " \n", + " [[2190.08948711, 2940.58474568, 1753.14427333, ...,\n", + " 2643.83088435, 814.70096164, 3073.43228434],\n", + " [2388.36032373, 3033.67586441, 1896.94175212, ...,\n", + " 2646.92204068, 309.39586923, 3103.78751556],\n", + " [2306.57000661, 3006.92541804, 2555.19489222, ...,\n", + " 2604.64101735, 451.72114915, 3092.30964595],\n", + " ...,\n", + " [2598.07497597, 2618.88649289, 44.46441351, ...,\n", + " 2953.46512017, 2279.78258046, 787.20009603],\n", + " [2598.07497597, 2618.88649289, 44.46441351, ...,\n", + " 2953.46512017, 2279.78258046, 787.20009603],\n", + " [2598.07497597, 2618.88649289, 44.46441351, ...,\n", + " 2953.46512017, 2279.78258046, 787.20009603]]]),\n", + " 'params': {'Ab': array([[[-2.06924725e-02, 3.26656483e-03, 3.41935937e-03, ...,\n", + " -4.33700515e-03, 2.86403831e-03, 5.30708074e-03],\n", + " [ 4.87041717e-03, -2.38856265e-02, 1.69801945e-02, ...,\n", + " 1.59565726e-03, -7.91050276e-03, 9.16143312e-03],\n", + " [ 3.51079156e-02, -1.15464470e-02, 4.55003974e-03, ...,\n", + " 2.48087479e-02, 1.36917876e-02, -4.47039205e-03],\n", + " ...,\n", + " [-4.78286073e-02, 4.50328785e-02, -4.44880122e-03, ...,\n", + " -3.77905757e-02, -6.38014708e-02, -1.13437057e-04],\n", + " [-1.16375278e-02, -6.70554441e-02, 2.68830329e-02, ...,\n", + " 1.42859843e+00, 1.31460859e-01, -3.20771975e-02],\n", + " [ 4.72065490e-02, -1.12730690e-01, 6.62123942e-02, ...,\n", + " 2.55348505e-01, 1.36790121e+00, -2.05076673e-02]],\n", + " \n", + " [[ 8.59128673e-03, 1.57003959e-02, 3.86181509e-02, ...,\n", + " 4.95101932e-04, 2.21678319e-02, -3.25453766e-03],\n", + " [ 1.24879884e-02, 2.46692037e-02, 6.12346851e-02, ...,\n", + " -4.23795711e-02, 2.56036472e-02, -2.68575326e-03],\n", + " [ 2.47447430e-02, 1.32843773e-01, 4.57946137e-02, ...,\n", + " 5.30135768e-02, -4.94021011e-03, 2.48758216e-03],\n", + " ...,\n", + " [-1.44848974e-01, -2.09702276e-01, -4.10479695e-03, ...,\n", + " -5.91946215e-02, -5.13529206e-02, 3.96566720e-03],\n", + " [ 9.42507446e-02, 2.05316490e-01, -1.19311106e-02, ...,\n", + " 8.59730023e-01, 2.37201325e-01, 1.38694397e-03],\n", + " [ 7.34594226e-02, 3.08898094e-02, -3.64310469e-04, ...,\n", + " 3.69236518e-01, 9.41924427e-01, -4.81807223e-03]],\n", + " \n", + " [[ 1.20247093e-01, -3.47497571e-02, -4.57041937e-02, ...,\n", + " -7.11373466e-02, 3.08485114e-02, -1.38138492e-01],\n", + " [ 9.69638413e-03, 1.93293987e-01, 5.15327944e-02, ...,\n", + " -2.87064134e-02, 9.01911920e-02, -2.50920689e-02],\n", + " [-4.65368455e-02, 1.17400401e-01, -3.08392918e-02, ...,\n", + " 5.72640678e-04, 2.64770895e-01, -1.08044694e-01],\n", + " ...,\n", + " [-2.56076541e-01, -2.24732589e-01, -5.91430018e-02, ...,\n", + " 1.01973765e-02, -2.23141135e-01, -2.02668394e-02],\n", + " [ 3.68798062e-01, -4.57000355e-01, 2.16551628e-01, ...,\n", + " 1.83984137e+00, -3.57250155e-01, 1.13652046e-02],\n", + " [ 7.43054266e-02, 1.88195244e-01, -1.00637408e-02, ...,\n", + " -8.83422143e-03, 1.71646242e+00, -1.58296858e-01]],\n", + " \n", + " ...,\n", + " \n", + " [[-8.02561485e-02, -2.67345639e-01, 1.48784597e-01, ...,\n", + " -7.11595471e-02, -1.05404495e-01, -7.84388783e-02],\n", + " [-1.64050503e-01, -6.01442275e-05, -1.07962451e-01, ...,\n", + " 6.49584918e-02, 1.31110646e-01, -7.96326408e-02],\n", + " [ 4.26277307e-01, -1.04580158e-01, -1.34885972e-01, ...,\n", + " 4.18627675e-02, -3.83676982e-01, -1.21636669e-01],\n", + " ...,\n", + " [ 1.59293603e-01, -1.19962193e-01, -2.83428976e-01, ...,\n", + " 2.35207479e-01, -2.68481536e-01, -1.40153146e-01],\n", + " [ 8.80660088e-02, 1.28068566e-01, 2.80446483e-01, ...,\n", + " 9.98458292e-01, 1.17285168e-01, -3.84234863e-02],\n", + " [ 1.90753791e-01, -1.26091031e-01, -2.64217117e-02, ...,\n", + " -7.27183155e-02, 9.03012520e-01, 1.65364691e-01]],\n", + " \n", + " [[ 4.70936278e-01, -3.73363663e-01, -6.27976328e-01, ...,\n", + " 1.97817531e-01, 3.48288166e-01, -1.50810946e-02],\n", + " [ 7.40181830e-01, -5.35047475e-01, -6.89500955e-01, ...,\n", + " 2.30014162e-01, 3.10876289e-01, -4.61820252e-02],\n", + " [-5.03648399e-01, 6.38845037e-01, 5.52713249e-01, ...,\n", + " -2.20202488e-01, -4.90649244e-02, 4.05891991e-02],\n", + " ...,\n", + " [-8.64820793e-02, -7.50099635e-03, 1.28235092e-01, ...,\n", + " 6.18251558e-02, 1.16540078e-04, 4.17777752e-02],\n", + " [-2.32069912e-01, 1.55989631e-01, 4.52595076e-02, ...,\n", + " 9.98848697e-01, -3.35103530e-01, 6.73019754e-02],\n", + " [-6.18396455e-03, 2.68128667e-01, -7.17704673e-02, ...,\n", + " -2.66003192e-02, 9.16520943e-01, -3.87722276e-02]],\n", + " \n", + " [[ 1.16435416e-01, -1.05767856e-01, 9.07128903e-02, ...,\n", + " 1.48807047e-01, -1.21982307e-01, -2.08682039e-01],\n", + " [ 7.09840358e-02, 1.30842315e-01, -2.32619387e-01, ...,\n", + " -2.46463942e-01, 6.23797715e-02, -2.54863198e-01],\n", + " [ 1.99167804e-01, 5.10427781e-01, -3.74466457e-01, ...,\n", + " -2.11573130e-01, 7.89507500e-02, -1.54061013e-01],\n", + " ...,\n", + " [ 3.09856515e-01, 2.92091504e-01, -5.31511817e-01, ...,\n", + " -3.23454285e-01, -1.85420235e-01, -1.51935123e-01],\n", + " [ 3.55814756e-01, -1.34791254e-01, 2.44716123e-01, ...,\n", + " 1.22303042e+00, -1.35797757e-02, 5.98169070e-02],\n", + " [ 4.90314122e-01, -6.81795139e-01, 8.45362746e-01, ...,\n", + " 4.39627414e-01, 9.09066623e-01, 1.24151400e-02]]]),\n", + " 'Cd': array([[ 110.64499411, -48.48880982, -110.43777186, -42.27077634,\n", + " -27.59941271, -53.39617105, -26.58692662, 78.96872769,\n", + " -135.67742352, -108.2021351 , -25.92837902],\n", + " [-120.62114788, 108.77373127, -65.18103875, 44.93852059,\n", + " 26.81861306, -38.23900618, -29.08301544, -25.05192018,\n", + " -80.3229631 , -61.54389057, 67.3487427 ],\n", + " [ 70.57278269, 267.00773929, -274.52492836, -427.80684666,\n", + " 192.29009091, 102.05716918, 109.80810592, 9.47583701,\n", + " 7.96472237, -3.96139797, 801.93297589],\n", + " [-116.41351111, 428.36870447, -178.94771753, 230.22174574,\n", + " -26.56741164, 50.14114384, 26.73427954, 135.28722869,\n", + " -5.67661004, 30.86214191, -66.20402378],\n", + " [ 103.74515926, 131.29029353, -57.82323785, -255.31704534,\n", + " -161.4761854 , -291.79951192, -73.00194723, 74.14723944,\n", + " 2.45729135, 59.01470752, 40.30857056],\n", + " [ 263.93746687, 651.85449767, -39.65290304, 93.59593302,\n", + " 51.10567548, 14.08469862, -125.04989056, -127.36787445,\n", + " -33.16543299, 18.13639179, -38.31203593],\n", + " [ 219.36373645, 323.91007856, 488.34502598, -101.77846031,\n", + " -217.20491803, 73.62752918, 121.21685536, 22.48121804,\n", + " -30.28532501, -16.29945329, -387.26365973],\n", + " [ 817.05143567, -154.03019807, -213.70347546, 181.97021767,\n", + " -18.62114757, -13.33206236, 78.18665868, 38.29534826,\n", + " 23.44535667, 3.54476329, -570.94683802],\n", + " [-118.8506962 , -161.216072 , -295.09427823, -31.3343655 ,\n", + " -300.41686135, 104.61410218, 50.18727076, -97.79196887,\n", + " -95.8725502 , 61.41778056, -862.80818879],\n", + " [-261.72195702, 236.54049447, -153.29944656, 127.82960516,\n", + " -82.83406511, -190.90860945, 166.1224257 , -80.89427313,\n", + " 67.17248481, -58.01215574, 41.22468652],\n", + " [ 24.36618104, 61.28719726, -156.04636099, -94.81700361,\n", + " -251.84473859, 135.48930889, -123.1528153 , 20.33303598,\n", + " 122.07922354, -77.25957007, -938.6851994 ],\n", + " [-283.44722962, 141.50550006, -54.52091699, 89.73815536,\n", + " -15.88518548, 69.1682918 , 9.36421372, 142.05376604,\n", + " -11.63515125, 27.55444014, 71.42276528]]),\n", + " 'Q': array([[[ 1.28452154e-02, 2.37456578e-03, -2.00434488e-03, ...,\n", + " -4.68814081e-03, -6.66685797e-03, -5.56439994e-04],\n", + " [ 2.37456578e-03, 2.04699891e-02, -7.35085041e-03, ...,\n", + " 2.66319885e-02, -1.81669949e-02, -2.13159222e-03],\n", + " [-2.00434488e-03, -7.35085041e-03, 3.22755664e-02, ...,\n", + " -2.12146430e-02, 2.28406721e-02, 3.57655367e-02],\n", + " ...,\n", + " [-4.68814081e-03, 2.66319885e-02, -2.12146430e-02, ...,\n", + " 1.20790359e-01, -7.69935347e-02, -7.56233531e-02],\n", + " [-6.66685797e-03, -1.81669949e-02, 2.28406721e-02, ...,\n", + " -7.69935347e-02, 2.60108365e-01, 2.62080243e-01],\n", + " [-5.56439994e-04, -2.13159222e-03, 3.57655367e-02, ...,\n", + " -7.56233531e-02, 2.62080243e-01, 4.28017507e-01]],\n", + " \n", + " [[ 5.64066996e-03, -2.37317677e-04, 1.04042888e-03, ...,\n", + " -4.47157019e-03, -2.38255534e-03, 1.50448409e-03],\n", + " [-2.37317677e-04, 4.13796037e-03, -1.37542246e-03, ...,\n", + " 3.72734494e-03, -5.35572781e-04, 1.63514616e-04],\n", + " [ 1.04042888e-03, -1.37542246e-03, 6.79463545e-03, ...,\n", + " -8.08510577e-03, -1.09734598e-03, 3.44110002e-03],\n", + " ...,\n", + " [-4.47157019e-03, 3.72734494e-03, -8.08510577e-03, ...,\n", + " 2.89543885e-02, 1.26171821e-03, -8.39802402e-03],\n", + " [-2.38255534e-03, -5.35572781e-04, -1.09734598e-03, ...,\n", + " 1.26171821e-03, 2.75421032e-02, 2.02652404e-02],\n", + " [ 1.50448409e-03, 1.63514616e-04, 3.44110002e-03, ...,\n", + " -8.39802402e-03, 2.02652404e-02, 3.71371696e-02]],\n", + " \n", + " [[ 8.21234738e-01, 5.29164940e-03, -2.29852676e-01, ...,\n", + " 3.06463486e-01, 1.16187003e-01, 3.24706939e-01],\n", + " [ 5.29164940e-03, 5.20236529e-01, 2.76056267e-01, ...,\n", + " -4.92315344e-01, -5.17337637e-01, -1.86465458e-01],\n", + " [-2.29852676e-01, 2.76056267e-01, 1.44054923e+00, ...,\n", + " -1.37158990e-01, -5.90337265e-01, -1.40763224e-01],\n", + " ...,\n", + " [ 3.06463486e-01, -4.92315344e-01, -1.37158990e-01, ...,\n", + " 2.07970578e+00, 6.58779134e-01, 9.05127375e-01],\n", + " [ 1.16187003e-01, -5.17337637e-01, -5.90337265e-01, ...,\n", + " 6.58779134e-01, 1.44765674e+00, 4.59145906e-01],\n", + " [ 3.24706939e-01, -1.86465458e-01, -1.40763224e-01, ...,\n", + " 9.05127375e-01, 4.59145906e-01, 1.65692542e+00]],\n", + " \n", + " ...,\n", + " \n", + " [[ 2.18673955e-03, -5.09551099e-04, 2.18086905e-03, ...,\n", + " 1.77650348e-03, -3.07439898e-04, -1.25071895e-05],\n", + " [-5.09551099e-04, 7.60818465e-04, -3.37632955e-04, ...,\n", + " -5.27993245e-04, 6.76095127e-06, 2.07566290e-04],\n", + " [ 2.18086905e-03, -3.37632955e-04, 9.12556922e-03, ...,\n", + " 5.97871840e-03, -7.16710250e-04, -1.35580170e-04],\n", + " ...,\n", + " [ 1.77650348e-03, -5.27993245e-04, 5.97871840e-03, ...,\n", + " 6.60500936e-03, -1.16028387e-03, -8.60991571e-04],\n", + " [-3.07439898e-04, 6.76095127e-06, -7.16710250e-04, ...,\n", + " -1.16028387e-03, 2.14025144e-03, -6.59681225e-04],\n", + " [-1.25071895e-05, 2.07566290e-04, -1.35580170e-04, ...,\n", + " -8.60991571e-04, -6.59681225e-04, 1.70056021e-03]],\n", + " \n", + " [[ 4.97318159e-02, 5.40139383e-02, -3.03612818e-02, ...,\n", + " -1.62869882e-02, -1.98754622e-03, -5.62059726e-04],\n", + " [ 5.40139383e-02, 6.02049528e-02, -3.32407569e-02, ...,\n", + " -1.75693149e-02, -2.50555050e-03, -1.47042269e-04],\n", + " [-3.03612818e-02, -3.32407569e-02, 2.25677144e-02, ...,\n", + " 8.95849828e-03, 2.08314236e-03, 1.10147145e-03],\n", + " ...,\n", + " [-1.62869882e-02, -1.75693149e-02, 8.95849828e-03, ...,\n", + " 6.83894310e-03, -1.05094344e-04, -1.85184924e-05],\n", + " [-1.98754622e-03, -2.50555050e-03, 2.08314236e-03, ...,\n", + " -1.05094344e-04, 2.06637818e-03, -2.53423661e-06],\n", + " [-5.62059726e-04, -1.47042269e-04, 1.10147145e-03, ...,\n", + " -1.85184924e-05, -2.53423661e-06, 1.54085023e-03]],\n", + " \n", + " [[ 2.97722048e-03, 4.26279990e-04, 4.39543009e-04, ...,\n", + " 3.84255812e-04, 1.96584418e-03, 3.07634608e-03],\n", + " [ 4.26279990e-04, 6.81285550e-03, 4.79798832e-03, ...,\n", + " 5.84703006e-03, -1.29884540e-04, -6.07676947e-03],\n", + " [ 4.39543009e-04, 4.79798832e-03, 5.34630759e-03, ...,\n", + " 5.20138989e-03, 8.27506487e-05, -5.51552849e-03],\n", + " ...,\n", + " [ 3.84255812e-04, 5.84703006e-03, 5.20138989e-03, ...,\n", + " 6.89397960e-03, -1.65158183e-04, -6.78483441e-03],\n", + " [ 1.96584418e-03, -1.29884540e-04, 8.27506487e-05, ...,\n", + " -1.65158183e-04, 3.64178385e-03, 4.69067227e-03],\n", + " [ 3.07634608e-03, -6.07676947e-03, -5.51552849e-03, ...,\n", + " -6.78483441e-03, 4.69067227e-03, 1.59916795e-02]]]),\n", + " 'betas': array([0.05731398, 0.01778557, 0.01335879, 0.01792281, 0.01088127,\n", + " 0.01530972, 0.01136227, 0.01388199, 0.01896434, 0.01093483,\n", + " 0.01087605, 0.00835733, 0.00831102, 0.01239526, 0.01308674,\n", + " 0.01262108, 0.01116312, 0.0122615 , 0.01461413, 0.00741105,\n", + " 0.01136812, 0.00996195, 0.00961429, 0.00910406, 0.0133204 ,\n", + " 0.01187114, 0.01271353, 0.01088982, 0.01441224, 0.00671271,\n", + " 0.00841476, 0.01193657, 0.01291385, 0.0079062 , 0.01032601,\n", + " 0.0108425 , 0.00775068, 0.00942677, 0.01147935, 0.00885915,\n", + " 0.01023143, 0.00990454, 0.01051822, 0.00386523, 0.00698305,\n", + " 0.00862239, 0.00633716, 0.00643487, 0.0108656 , 0.0125964 ,\n", + " 0.00859221, 0.0108246 , 0.01284531, 0.00473315, 0.00805283,\n", + " 0.00604105, 0.00703535, 0.00471456, 0.0082079 , 0.00875534,\n", + " 0.01286313, 0.01225529, 0.00851792, 0.00866596, 0.00769813,\n", + " 0.01029309, 0.00827484, 0.00536362, 0.00511364, 0.00852089,\n", + " 0.00564264, 0.01157945, 0.00708679, 0.00986283, 0.00720775,\n", + " 0.00931133, 0.00760419, 0.00819804, 0.00750677, 0.00308144,\n", + " 0.00600542, 0.0089513 , 0.00969988, 0.01281015, 0.00634865,\n", + " 0.0048979 , 0.01052288, 0.00660107, 0.00560497, 0.00644623,\n", + " 0.00601456, 0.0056466 , 0.00836808, 0.00751447, 0.0127619 ,\n", + " 0.01263546, 0.01292155, 0.00645693, 0.00538398, 0.0049621 ]),\n", + " 'pi': array([[9.50845799e-01, 1.43410779e-02, 1.57574570e-02, ...,\n", + " 3.96715593e-25, 9.79570784e-06, 1.13452933e-06],\n", + " [9.42085162e-03, 9.77255268e-01, 1.86828531e-03, ...,\n", + " 2.47451451e-07, 9.30163536e-06, 3.34162444e-13],\n", + " [1.85760879e-02, 1.07615314e-03, 9.79067407e-01, ...,\n", + " 5.02978541e-22, 1.28154536e-38, 8.08360999e-19],\n", + " ...,\n", + " [1.42176422e-05, 4.34543038e-11, 8.26224568e-06, ...,\n", + " 9.99830456e-01, 3.26803257e-13, 5.05168046e-57],\n", + " [5.86223318e-05, 7.31662314e-11, 5.84107673e-07, ...,\n", + " 5.69891472e-11, 9.99431404e-01, 1.78612348e-58],\n", + " [6.26611959e-07, 2.81770368e-09, 1.66873245e-06, ...,\n", + " 1.44684916e-04, 6.23726547e-20, 9.99518165e-01]]),\n", + " 'sigmasq': array([1., 1., 1., 1., 1., 1., 1.])},\n", + " 'seed': array([1900188647, 357198569], dtype=uint32),\n", + " 'states': {'h': array([[-1.50061132, 1.93482084, -0.37980881, ..., -0.60917404,\n", + " -0.59343221, -0.58538017],\n", + " [-0.21438029, 1.84756507, -0.26370478, ..., 2.95397652,\n", + " 2.93513517, 2.93099418],\n", + " [-1.91567058, 0.07391241, -0.19551943, ..., 2.57196022,\n", + " 2.50976271, 2.51840594]]),\n", + " 's': array([[[1.84178597e+05, 9.65479190e+05, 3.14454241e+04, ...,\n", + " 1.60532611e+06, 5.76869439e+06, 2.39781476e+06],\n", + " [2.68582513e+05, 5.18951089e+03, 3.06599392e+03, ...,\n", + " 5.54029027e+03, 1.20564509e+07, 1.03075003e+06],\n", + " [4.47067166e+05, 6.60931206e+01, 7.47799654e+04, ...,\n", + " 1.19208022e+06, 3.73353659e+00, 1.40591325e+01],\n", + " ...,\n", + " [1.01838579e+02, 2.09586790e+00, 9.13743535e+01, ...,\n", + " 8.59873467e+02, 2.32974028e+05, 2.75521921e+02],\n", + " [3.97673952e+01, 1.88754871e+01, 1.51926103e+01, ...,\n", + " 1.49698149e+02, 2.86353388e+05, 1.93701490e+01],\n", + " [2.56321140e+00, 4.75439997e+01, 4.38902985e+00, ...,\n", + " 5.11994417e+00, 2.27166593e+05, 5.14813498e+00]],\n", + " \n", + " [[6.45921300e+05, 1.12338421e+04, 1.22462122e+05, ...,\n", + " 1.52183249e+06, 7.94943319e+04, 3.12904837e+05],\n", + " [5.65470155e+04, 1.14946072e+04, 8.98112259e+04, ...,\n", + " 1.04548310e+05, 4.92498751e+04, 5.56345086e+05],\n", + " [3.68808448e+00, 6.04713788e+00, 2.05180557e+01, ...,\n", + " 1.17227605e+04, 1.94122053e+03, 2.86645208e+00],\n", + " ...,\n", + " [6.45271005e+05, 3.85588589e+02, 1.51261573e+02, ...,\n", + " 9.41280302e+02, 1.21005574e+03, 1.95518593e+05],\n", + " [4.97851706e+05, 4.40083082e+02, 3.73157917e+01, ...,\n", + " 1.29070528e+03, 6.96373792e+02, 5.89741066e+02],\n", + " [5.95095284e+04, 4.96947105e+02, 9.65582976e+01, ...,\n", + " 2.06456265e+03, 2.45997583e+03, 1.57549998e+03]],\n", + " \n", + " [[4.34206131e+05, 8.19906785e+04, 3.87218157e+04, ...,\n", + " 5.22635837e+06, 1.50658963e+04, 1.57238279e+05],\n", + " [2.99328448e+04, 3.81443498e+04, 1.94583972e+06, ...,\n", + " 8.36252058e+06, 4.24981950e+04, 4.02053312e+05],\n", + " [1.52678050e+03, 1.55969695e+03, 5.53512261e+03, ...,\n", + " 3.05503953e+06, 4.31970912e+02, 5.56369162e+05],\n", + " ...,\n", + " [9.72913414e+02, 1.84504972e+03, 2.44080863e+01, ...,\n", + " 1.10914265e+03, 8.05232137e+03, 4.28575449e+02],\n", + " [2.72307030e+03, 3.59169613e+03, 1.03541077e+02, ...,\n", + " 3.15193513e+03, 2.32009582e+03, 3.13914477e+02],\n", + " [1.72251542e+03, 1.35246943e+03, 1.57423021e+01, ...,\n", + " 1.37790913e+03, 2.19923038e+03, 1.24330612e+03]]]),\n", + " 'v': array([[[8026.24657812, 3697.32296741],\n", + " [8026.37362914, 3698.55670213],\n", + " [8025.73317697, 3700.20093488],\n", + " ...,\n", + " [2865.30238923, 4420.85651395],\n", + " [2865.75487688, 4419.30536323],\n", + " [2866.58566922, 4417.54757887]],\n", + " \n", + " [[2996.92196117, 4320.71063133],\n", + " [2997.43179382, 4321.31267698],\n", + " [2997.69442081, 4320.99141055],\n", + " ...,\n", + " [7490.37932519, 3373.8249364 ],\n", + " [7490.75524213, 3374.45276973],\n", + " [7490.60749651, 3374.6025728 ]],\n", + " \n", + " [[6811.43101345, 3528.67558513],\n", + " [6811.42135035, 3528.58807986],\n", + " [6811.8057084 , 3528.04497755],\n", + " ...,\n", + " [7848.36226247, 4103.504873 ],\n", + " [7848.57917763, 4102.43613094],\n", + " [7847.27680934, 4107.74845551]]]),\n", + " 'x': array([[[-2.83144895, 5.47072645, 0.03235018, ..., -2.38199327,\n", + " -0.35826233, 0.69273339],\n", + " [ 2.30826123, -0.94204177, 1.177674 , ..., 2.43322765,\n", + " -1.80074765, -0.33016114],\n", + " [ 1.49987083, 0.15628778, 3.04282758, ..., 1.58397287,\n", + " -1.98836335, -1.71652419],\n", + " ...,\n", + " [-0.23969379, -0.51693544, 0.57945366, ..., 0.11099648,\n", + " 1.69500415, -0.98565025],\n", + " [-0.27669168, -0.51341797, 0.52133834, ..., 0.07328125,\n", + " 1.73136632, -1.0919636 ],\n", + " [-0.26968947, -0.545851 , 0.46828232, ..., 0.07061802,\n", + " 1.72419886, -1.05364915]],\n", + " \n", + " [[ 0.90877067, -1.47585247, -3.77789401, ..., -1.9912207 ,\n", + " -0.26005175, -1.58638555],\n", + " [ 1.53636323, 0.01714602, 0.44108273, ..., -2.94712004,\n", + " -0.16663191, 1.94340658],\n", + " [-0.66039338, -0.90144532, -0.12822923, ..., 0.0274604 ,\n", + " -2.07939582, 3.1828268 ],\n", + " ...,\n", + " [ 1.07785249, -0.56546964, 0.71176997, ..., -2.3197799 ,\n", + " 1.1585705 , 2.37756583],\n", + " [ 1.02984621, -0.62052006, 0.74523202, ..., -2.27465805,\n", + " 1.2316048 , 2.3470011 ],\n", + " [ 1.17146997, -0.59684397, 0.65561112, ..., -2.21102291,\n", + " 0.87360245, 2.38234237]],\n", + " \n", + " [[-6.9906762 , 1.09642782, 0.93850708, ..., -5.2162684 ,\n", + " -2.62948486, 2.19243255],\n", + " [-1.84125173, -2.9742889 , -6.83505597, ..., 1.6867402 ,\n", + " 4.07823474, 11.03732547],\n", + " [ 1.75401938, -3.26747355, -5.63211929, ..., -4.38939849,\n", + " 0.03374927, 5.48387379],\n", + " ...,\n", + " [ 0.4388598 , -0.24130453, -0.37537376, ..., -0.47608676,\n", + " 0.55814246, -0.83161472],\n", + " [ 0.44024749, -0.19777914, -0.41901244, ..., -0.40757775,\n", + " 0.65961333, -0.79460882],\n", + " [ 0.43190966, -0.19731401, -0.38574877, ..., -0.40863406,\n", + " 0.56386813, -0.74879204]]]),\n", + " 'z': array([[77, 77, 77, ..., 3, 3, 3],\n", + " [89, 89, 89, ..., 1, 1, 1],\n", + " [ 3, 3, 3, ..., 22, 22, 22]])}}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trained_model = MoseqModel().fetch_model(model_key)\n", + "trained_model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also analyze components of the trained model; \n", + "ie. the pca breakdown of the pose skeleton" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -530,7 +1618,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -540,7 +1628,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -550,18 +1638,19 @@ } ], "source": [ - "table = MoseqModel() & {'model_params_name': \"sb_testing_kappa4_mini\"}\n", - "# table.fetch_model()\n", + "table = MoseqModel() & model_key\n", "table.analyze_pca()" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "model_key = MoseqModel().fetch1()" + "## Run data through the trained model\n", + "\n", + "Now that we have a trained model, we can use it to convert pose data into behavioral \n", + "syllables. We do so by combining a trained model with an epoch of pose data, and then\n", + "applying the populate command" ] }, { @@ -570,35 +1659,44 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "{'skeleton': [['nose', 'spine1'],\n", - " ['spine1', 'forelimbL'],\n", - " ['spine1', 'forelimbR'],\n", - " ['spine1', 'spine3'],\n", - " ['spine3', 'spine5'],\n", - " ['spine5', 'tailBase']],\n", - " 'kappa': 1.0,\n", - " 'num_ar_iters': 50,\n", - " 'num_epochs': 50,\n", - " 'anterior_bodyparts': ['nose'],\n", - " 'posterior_bodparts': ['tailBase']}" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "MoseqModelParams.fetch(\"model_params\")[1]#[\"posterior_bodyparts\"]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Applying model: 100%|█████████████████████| 3/3 [00:19<00:00, 6.44s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved results to /home/sambray/Documents/moseq_test_proj3/d9bbbaed42ec\n", + "a56d999882d9f65a62b8_ar/results.h5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/hdmf/utils.py:668: UserWarning:\n", + "\n", + "Ignoring cached namespace 'hdmf-common' version 1.5.1 because version 1.8.0 is already loaded.\n", + "\n", + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/hdmf/utils.py:668: UserWarning:\n", + "\n", + "Ignoring cached namespace 'hdmf-experimental' version 0.2.0 because version 0.5.0 is already loaded.\n", + "\n", + "[08:51:21][INFO] Spyglass: Writing new NWB file SC100020230912_DSLA0Q15ME.nwb\n", + "INFO:spyglass:Writing new NWB file SC100020230912_DSLA0Q15ME.nwb\n" + ] + }, { "data": { "text/html": [ @@ -658,161 +1756,148 @@ "
\n", " \n", " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "
\n", - "

pose_group_name

\n", + "

pose_merge_id

\n", " \n", "
\n", - "

model_params_name

\n", + "

pose_group_name

\n", " \n", "
\n", - "

project_dir

\n", + "

model_params_name

\n", " \n", "
\n", - "

epochs_trained

\n", - " \n", + "

analysis_file_name

\n", + " name of the file\n", "
\n", - "

model_name

\n", + "

moseq_object_id

\n", " \n", "
sb_test_groupsb_testing_kappa-4/home/sambray/Documents/moseq_test_proj550
sb_test_groupsb_testing_kappa0_mini/home/sambray/Documents/moseq_test_proj21002024_06_12-11_23_06
1f3fdc6d-d8d5-c283-846a-4830e85dcb32sb_test_groupsb_testing_kappa4_mini_20241220SC100020230912_2MBYJA8JOI.nwba3ec9db6-f8c3-487a-a1d7-b1a91b1d8e47
1f3fdc6d-d8d5-c283-846a-4830e85dcb32tutorial_grouptutorial_kappa4_miniSC100020230912_DSLA0Q15ME.nwb82b3d777-9445-4370-8acf-3d4c2dec8f52
\n", " \n", "

Total: 2

\n", " " ], "text/plain": [ - "*pose_group_na *model_params_ project_dir epochs_trained model_name \n", + "*pose_merge_id *pose_group_na *model_params_ analysis_file_ moseq_object_i\n", "+------------+ +------------+ +------------+ +------------+ +------------+\n", - "sb_test_group sb_testing_kap /home/sambray/ 550 \n", - "sb_test_group sb_testing_kap /home/sambray/ 100 2024_06_12-11_\n", + "1f3fdc6d-d8d5- sb_test_group sb_testing_kap SC100020230912 a3ec9db6-f8c3-\n", + "1f3fdc6d-d8d5- tutorial_group tutorial_kappa SC100020230912 82b3d777-9445-\n", " (Total: 2)" ] }, - "execution_count": 38, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "from spyglass.behavior.moseq import MoseqSyllableSelection, MoseqSyllable\n", + "\n", + "# Make a selection table entry defining the pose data and moseq model to use\n", + "pose_key = PoseGroup().Pose().fetch(\"pose_merge_id\", as_dict=True)[0] # can also use data outside of the training epochs\n", + "key = {**model_key, **pose_key, \"num_iters\": 3}\n", + "MoseqSyllableSelection().insert1(key, skip_duplicates=True)\n", + "\n", + "# Run populate to apply the model to the pose data\n", + "MoseqSyllable().populate(key)\n", + "MoseqSyllable()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'time (s)')" + ] + }, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# key = MoseqModel().fetch(as_dict=True)[1]\n", - "# key[\"model_name\"] = \"2024_06_12-11_23_06\"\n", + "import matplotlib.pyplot as plt\n", "\n", - "# MoseqModel().update1(key)\n", - "MoseqModel()" + "moseq_df = (MoseqSyllable() & key).fetch1_dataframe()\n", + "moseq_df\n", + "ind = slice(1000, 3000)\n", + "\n", + "fig, ax = plt.subplots(2, 1, figsize=(8, 5), sharex=True)\n", + "t = moseq_df.index.values[ind]\n", + "ax[0].plot(t, moseq_df[\"centroid x\"].values[ind], label=\"x\")\n", + "ax[0].plot(t, moseq_df[\"centroid y\"].values[ind], label=\"y\")\n", + "ax[1].scatter(\n", + " t,\n", + " moseq_df.syllable.values[ind],\n", + " s=10,\n", + " c=moseq_df.syllable.values[ind],\n", + " cmap=\"tab20\",\n", + ")\n", + "ax[0].set_ylabel(\"centroid\")\n", + "ax[1].set_ylabel(\"syllable\")\n", + "ax[1].set_xlabel(\"time (s)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Run data through the trained model" + "This concludes the tutorial for basic usage of the Moseq pipeline. Next, we will \n", + "look at usage for extending training from a base model and leveraging spyglass's \n", + "relational database to easily sweep through model hyperparameters" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Define the entry" + "# Extend model training\n", + "\n", + "There are many cases where you may want to begin trining from an existing model\n", + "rather than begin from scratch. Examples include continuing training an incompletely \n", + "converged entry, or using a pre-trained base model and refining it to a particular set\n", + "of animals/ imaging conditions (ie. transfer learning).\n", + "\n", + "The spyglass moseq pipeline allows for this style of iterative training. To do so, \n", + "we will define a new entry in `MoseqModelParams` using the `make_training_extension_params`\n", + "method. This entry will have the same params as those used in model_key, except it\n", + "will point to the model_key entry for the `initial_model`" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[08:57:59][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:57:59][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:57:59][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:57:59][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:57:59][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "[08:58:00][WARNING] Spyglass: Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_syllable`'}. Please submit a bug report with the snippet used.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Applying model: 100%|█████████████████████| 3/3 [00:04<00:00, 1.34s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saved results to /home/sambray/Documents/moseq_test_proj2/2024_06_12-1\n", - "1_40_09/results.h5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/hdmf/utils.py:668: UserWarning:\n", - "\n", - "Ignoring cached namespace 'hdmf-common' version 1.5.1 because version 1.8.0 is already loaded.\n", - "\n", - "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/hdmf/utils.py:668: UserWarning:\n", - "\n", - "Ignoring cached namespace 'hdmf-experimental' version 0.2.0 because version 0.5.0 is already loaded.\n", - "\n", - "[08:58:07][INFO] Spyglass: Writing new NWB file SC100020230912_DYUAN3RMWT.nwb\n", - "INFO:spyglass:Writing new NWB file SC100020230912_DYUAN3RMWT.nwb\n" + "initial model: {'pose_group_name': 'tutorial_group', 'model_params_name': 'tutorial_kappa4_mini'}\n" ] }, { @@ -874,317 +1959,111 @@ "
\n", " \n", " \n", - " \n", - "\n", - "\n", - "\n", - "\n", + " \n", + "\n", + "\n", "
\n", - "

pose_merge_id

\n", - " \n", - "
\n", - "

pose_group_name

\n", - " \n", - "
\n", "

model_params_name

\n", " \n", "
\n", - "

analysis_file_name

\n", - " name of the file\n", - "
\n", - "

moseq_object_id

\n", + "

model_params

\n", " \n", "
8206d0ad-d91b-0e46-649b-7be9c2e8b28csb_test_groupsb_testing_kappa4_miniSC100020230912_DYUAN3RMWT.nwb771d5bd7-a495-43b6-ae7f-e3e2d8aa08e2
tutorial_grouptutorial_kappa4_mini_extension001=BLOB=
tutorial_kappa4_mini=BLOB=
\n", " \n", - "

Total: 1

\n", + "

Total: 2

\n", " " ], "text/plain": [ - "*pose_merge_id *pose_group_na *model_params_ analysis_file_ moseq_object_i\n", - "+------------+ +------------+ +------------+ +------------+ +------------+\n", - "8206d0ad-d91b- sb_test_group sb_testing_kap SC100020230912 771d5bd7-a495-\n", - " (Total: 1)" + "*model_params_ model_para\n", + "+------------+ +--------+\n", + "tutorial_group =BLOB= \n", + "tutorial_kappa =BLOB= \n", + " (Total: 2)" ] }, - "execution_count": 11, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "from pathlib import Path\n", - "from spyglass.behavior.moseq import MoseqModel, MoseqModelParams, MoseqModelSelection\n", - "from spyglass.behavior.moseq import MoseqSyllableSelection, MoseqSyllable\n", - "from spyglass.behavior.core import PoseGroup, format_dataset_for_moseq\n", - "from spyglass.position.position_merge import PoseOutput\n", - "import keypoint_moseq as kpms\n", - "\n", - "model_key = MoseqModel().fetch(\"KEY\")[-1]\n", - "pose_key = PoseGroup().Pose().fetch(\"pose_merge_id\",as_dict=True)[0]\n", - "key = {**model_key, **pose_key, \"num_iters\": 3}\n", - "# MoseqSyllableSelection().insert1(key, skip_duplicates=True)\n", - "# MoseqSyllableSelection().update1(key)\n", - "# MoseqSyllableSelection()\n", - "\n", - "MoseqSyllable().populate(key)\n", - "MoseqSyllable()#.drop()\n" + "# Insert a training extension model entry\n", + "extension_params = MoseqModelParams().make_training_extension_params(\n", + " model_key, num_epochs=100, skip_duplicates=True\n", + ")\n", + "print(\"initial model: \", extension_params[\"model_params\"][\"initial_model\"])\n", + "new_params_key = {\n", + " \"model_params_name\": extension_params[\"model_params_name\"],\n", + "}\n", + "MoseqModelParams() & \"model_params_name LIKE '%tutorial_kappa4%'\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Extend model training" + "This extension model can then be trained following the same steps as before" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 44, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "2024-06-13 12:17:24.739011: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/cv2/../../lib64:\n", - "2024-06-13 12:17:24.739171: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/cv2/../../lib64:\n", - "2024-06-13 12:17:24.739182: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n", - "2024-06-13 12:17:32.027555: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 0 and 9; status: INTERNAL: failed to enable peer access from 0x7f85d06252b0 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.036055: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 1 and 9; status: INTERNAL: failed to enable peer access from 0x7f85c0627dd0 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.043434: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 2 and 9; status: INTERNAL: failed to enable peer access from 0x7f85ec625450 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.049566: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 3 and 9; status: INTERNAL: failed to enable peer access from 0x7f85cc625460 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.054423: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 4 and 9; status: INTERNAL: failed to enable peer access from 0x7f85e0625440 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.058130: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 5 and 9; status: INTERNAL: failed to enable peer access from 0x7f85c86254e0 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.060741: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 6 and 9; status: INTERNAL: failed to enable peer access from 0x7f85bc625390 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062035: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 7 and 9; status: INTERNAL: failed to enable peer access from 0x7f85b86393f0 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062132: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 8 and 9; status: INTERNAL: failed to enable peer access from 0x7f85d8625380 to 0x7f85e47d6d30: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062218: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 0; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85d06252b0: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062302: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 1; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85c0627dd0: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062398: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 2; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85ec625450: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062482: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 3; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85cc625460: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062593: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 4; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85e0625440: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062679: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 5; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85c86254e0: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062761: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 6; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85bc625390: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062841: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 7; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85b86393f0: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "2024-06-13 12:17:32.062923: W external/org_tensorflow/tensorflow/compiler/xla/pjrt/gpu/gpu_helpers.cc:63] Unable to enable peer access between GPUs 9 and 8; status: INTERNAL: failed to enable peer access from 0x7f85e47d6d30 to 0x7f85d8625380: CUDA_ERROR_TOO_MANY_PEERS: peer mapping resources exhausted\n", - "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/analysis.py:20: UserWarning:\n", - "\n", - "Using Panel interactively in VSCode notebooks requires the jupyter_bokeh package to be installed. You can install it with:\n", - "\n", - " pip install jupyter_bokeh\n", - "\n", - "or:\n", - " conda install jupyter_bokeh\n", - "\n", - "and try again.\n", - "\n" + "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", + "exists. Use `overwrite=True` or pick a different name\n", + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/4552\n", + "2739aed0cce27667e45026e3e32c\n" ] }, { - "data": { - "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'plotly': 'https://cdn.plot.ly/plotly-2.31.1.min', 'tabulator': 'https://cdn.jsdelivr.net/npm/tabulator-tables@5.5.0/dist/js/tabulator.min', 'moment': 'https://cdn.jsdelivr.net/npm/luxon/build/global/luxon.min'}, 'shim': {}});\n require([\"plotly\"], function(Plotly) {\n\twindow.Plotly = Plotly\n\ton_load()\n })\n require([\"tabulator\"], function(Tabulator) {\n\twindow.Tabulator = Tabulator\n\ton_load()\n })\n require([\"moment\"], function(moment) {\n\twindow.moment = moment\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 3;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window.Plotly !== undefined) && (!(window.Plotly instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.4.4/dist/bundled/plotlyplot/plotly-2.31.1.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window.Tabulator !== undefined) && (!(window.Tabulator instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.4.4/dist/bundled/datatabulator/tabulator-tables@5.5.0/dist/js/tabulator.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window.moment !== undefined) && (!(window.moment instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.4.4/dist/bundled/datatabulator/luxon/build/global/luxon.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.holoviz.org/panel/1.4.4/dist/bundled/jquery/jquery.slim.min.js\", \"https://cdn.holoviz.org/panel/1.4.4/dist/bundled/plotlyplot/plotly-2.31.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.4/dist/bundled/datatabulator/tabulator-tables@5.5.0/dist/js/tabulator.min.js\", \"https://cdn.holoviz.org/panel/1.4.4/dist/bundled/datatabulator/luxon/build/global/luxon.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.4/dist/panel.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [\"https://cdn.holoviz.org/panel/1.4.4/dist/bundled/datatabulator/tabulator-tables@5.5.0/dist/css/tabulator_simple.min.css?v=1.4.4\"];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", - "application/vnd.holoviews_load.v0+json": "" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", - "application/vnd.holoviews_load.v0+json": "" - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|████████▍ | 25/101 [03:02<08:36, 6.80s/it]" + ] }, { "data": { - "text/html": [ - "" + "image/png": "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", + "text/plain": [ + "
" ] }, "metadata": {}, "output_type": "display_data" }, - { - "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
\n", - "
\n", - "
\n", - "" - ] - }, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "bb4f667b-ccf5-46e9-a34b-45ca7e4eb79e" - } - }, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2024-06-13 12:17:37,066][INFO]: Connecting sambray@lmf-db.cin.ucsf.edu:3306\n", - "INFO:datajoint:Connecting sambray@lmf-db.cin.ucsf.edu:3306\n", - "[2024-06-13 12:17:37,102][INFO]: Connected sambray@lmf-db.cin.ucsf.edu:3306\n", - "INFO:datajoint:Connected sambray@lmf-db.cin.ucsf.edu:3306\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The directory `/home/sambray/Documents/moseq_test_proj2` already\n", - "exists. Use `overwrite=True` or pick a different name\n" - ] - }, { "name": "stderr", "output_type": "stream", "text": [ - "[12:17:39][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:40][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:40][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:41][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:41][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:42][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:43][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:43][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:44][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:44][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:45][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:45][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:46][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:46][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[12:17:47][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_model`', '`behavior_core_v1`.`pose_group`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n" + " 50%|████████████████▊ | 50/101 [05:58<06:40, 7.86s/it]" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "Outputs will be saved to\n", - "/home/sambray/Documents/moseq_test_proj2/feeddb9ca2\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ - " 25%|████████▍ | 25/101 [01:09<01:47, 1.41s/it]" + " 74%|█████████████████████████▏ | 75/101 [08:57<02:55, 6.76s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1196,12 +2075,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 50%|████████████████▊ | 50/101 [01:47<01:11, 1.41s/it]" + " 99%|████████████████████████████████▋| 100/101 [12:00<00:08, 8.04s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1213,148 +2092,45 @@ "name": "stderr", "output_type": "stream", "text": [ - " 71%|████████████████████████▏ | 72/101 [02:21<00:56, 1.96s/it]\n", - "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:41: UserWarning:\n", - "\n", - "\n", - "Early termination of fitting: NaNs encountered\n", - " - 2924 NaNs found in states/h\n", - " - 70210 NaNs found in states/s\n", - " - 20060 NaNs found in states/v\n", - " - 29240 NaNs found in states/x\n", - "\n", - "For additional information, see https://keypoint-moseq.readthedocs.io/en/latest/troubleshooting.html#nans-during-fitting\n", - "\n", - "Reindexing: 100%|█████████████| 3/3 [00:00<00:00, 5.61model snapshot/s]\n" + "100%|█████████████████████████████████| 101/101 [12:09<00:00, 7.23s/it]\n", + "Reindexing: 100%|█████████████| 5/5 [00:00<00:00, 5.15model snapshot/s]\n" ] } ], "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "from spyglass.behavior.moseq import MoseqModel, MoseqModelSelection, MoseqModelParams\n", - "\n", - "model_key = (MoseqModel() & {\"model_params_name\": \"sb_testing_kappa4_mini\"}).fetch1(\"KEY\")\n", - "\n", - "extension_params = MoseqModelParams().make_training_extension_params(model_key,100,skip_duplicates=True)\n", - "extension_params\n", - "model_key\n", - "new_model_key = {\"model_params_name\":extension_params[\"model_params_name\"],\n", - " \"pose_group_name\":model_key[\"pose_group_name\"]}\n", - "MoseqModelSelection().insert1(new_model_key,skip_duplicates=True)\n", + "new_model_key = {\n", + " **new_params_key,\n", + " \"pose_group_name\": model_key[\"pose_group_name\"],\n", + "}\n", + "MoseqModelSelection().insert1(new_model_key, skip_duplicates=True)\n", "MoseqModel().populate(new_model_key)" ] }, { - "cell_type": "code", - "execution_count": 25, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[11:38:51][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:51][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:51][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:52][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "[11:38:53][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation__body_part`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`', '`position_merge`.`pose_output`', '`position_v1_dlc_pose_estimation`.`__d_l_c_pose_estimation`'}. Please submit a bug report with the snippet used.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n", - "23864\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Applying model: 80%|███████████████▏ | 24/30 [00:34<00:08, 1.43s/it]\n", - "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:41: UserWarning:\n", - "\n", - "\n", - "Early termination of fitting: NaNs encountered\n", - " - 2686 NaNs found in states/h\n", - " - 70210 NaNs found in states/s\n", - " - 20060 NaNs found in states/v\n", - " - 26860 NaNs found in states/x\n", - "\n", - "For additional information, see https://keypoint-moseq.readthedocs.io/en/latest/troubleshooting.html#nans-during-fitting\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saved results to /home/sambray/Documents/moseq_test_proj2/2024_06_12-1\n", - "1_40_09/results.h5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/hdmf/utils.py:668: UserWarning:\n", - "\n", - "Ignoring cached namespace 'hdmf-common' version 1.5.1 because version 1.8.0 is already loaded.\n", - "\n", - "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/hdmf/utils.py:668: UserWarning:\n", - "\n", - "Ignoring cached namespace 'hdmf-experimental' version 0.2.0 because version 0.5.0 is already loaded.\n", - "\n", - "[11:39:35][INFO] Spyglass: Writing new NWB file SC100020230912_WUAQVSMOGM.nwb\n", - "INFO:spyglass:Writing new NWB file SC100020230912_WUAQVSMOGM.nwb\n" - ] - } - ], "source": [ - "from spyglass.behavior.moseq import MoseqSyllableSelection, MoseqSyllable\n", - "MoseqModel() & new_model_key\n", - "selection_key = {\"pose_merge_id\":\"8206d0ad-d91b-0e46-649b-7be9c2e8b28c\",\n", - " \"num_iters\":30,\n", - " **new_model_key}\n", - "MoseqSyllableSelection().insert1(selection_key,skip_duplicates=True)\n", - "MoseqSyllable().populate(selection_key)\n" + "# Hyperparameter search (kappa)\n", + "\n", + "The relational database structure makes it relatively easy to train and organize \n", + "multiple models on the same data. Here we demonstrate leveraging this architecture to\n", + "test values of `kappa` in the moseq model. The `kappa` value determines the rate\n", + "of syllable transitions, with larger values corresponding to longer syllables \n", + "([moseq docs](https://keypoint-moseq.readthedocs.io/en/latest/advanced.html#automatic-kappa-scan)).\n", + "This value will likely need tuned for your specific data to achieve a syllable \n", + "distribution at appropriate timescales.\n", + "\n", + "To do so we will make a set of parameter entries with varying values of kappa and then\n", + "training an initial model for each. Looking at the results above, we see a shorter\n", + "median distribution (~3 frames = 100ms) than we would like \n", + "([recommended ~400ms](https://keypoint-moseq.readthedocs.io/en/latest/FAQs.html#modeling))\n", + ". We will therfore try several parameter sets with larger kappa values.\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -1416,407 +2192,540 @@ "
\n", " \n", " \n", - " \n", - "\n", - "\n", - "\n", - "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "
\n", - "

pose_group_name

\n", - " \n", - "
\n", "

model_params_name

\n", " \n", "
\n", - "

project_dir

\n", - " \n", - "
\n", - "

epochs_trained

\n", - " \n", - "
\n", - "

model_name

\n", + "

model_params

\n", " \n", "
sb_test_groupsb_test_groupsb_testing_kappa4_mini_extension001/home/sambray/Documents/moseq_test_proj2200feeddb9ca2
tutorial_grouptutorial_kappa4_mini_extension001=BLOB=
tutorial_kappa4_mini=BLOB=
tutorial_kappa5_mini=BLOB=
tutorial_kappa6_mini=BLOB=
tutorial_kappa7_mini=BLOB=
tutorial_kappa8_mini=BLOB=
\n", " \n", - "

Total: 1

\n", + "

Total: 6

\n", " " ], "text/plain": [ - "*pose_group_na *model_params_ project_dir epochs_trained model_name \n", - "+------------+ +------------+ +------------+ +------------+ +------------+\n", - "sb_test_group sb_test_groups /home/sambray/ 200 feeddb9ca2 \n", - " (Total: 1)" + "*model_params_ model_para\n", + "+------------+ +--------+\n", + "tutorial_group =BLOB= \n", + "tutorial_kappa =BLOB= \n", + "tutorial_kappa =BLOB= \n", + "tutorial_kappa =BLOB= \n", + "tutorial_kappa =BLOB= \n", + "tutorial_kappa =BLOB= \n", + " (Total: 6)" ] }, - "execution_count": 2, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# (MoseqSyllableSelection & selection_key).delete(selection_key)\n", - "(MoseqModel() & new_model_key)#.delete(new_model_key)" + "original_params = (MoseqModelParams() & model_key).fetch1(\"model_params\")\n", + "\n", + "new_params_key_list = []\n", + "for i in [5, 6, 7, 8]:\n", + " new_params = original_params.copy()\n", + " new_params[\"kappa\"] = 10**i\n", + " new_model_params_name = f\"tutorial_kappa{i}_mini\"\n", + " new_params_key = {\n", + " \"model_params_name\": new_model_params_name,\n", + " \"model_params\": new_params,\n", + " }\n", + " new_params_key_list.append(new_params_key)\n", + " MoseqModelParams().insert1(new_params_key, skip_duplicates=True)\n", + "\n", + "MoseqModelParams() & \"model_params_name LIKE '%tutorial_kappa%'\"" ] }, { - "cell_type": "code", - "execution_count": 46, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[12:06:55][WARNING] Spyglass: Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`'}. Please submit a bug report with the snippet used.\n", - "WARNING:spyglass:Multiple classes found in stack: {'`moseq_v1`.`__moseq_syllable`', '`moseq_v1`.`moseq_model_params`', '`moseq_v1`.`__moseq_model`', '`moseq_v1`.`moseq_syllable_selection`'}. Please submit a bug report with the snippet used.\n" - ] - } - ], "source": [ - "results = (MoseqSyllable & selection_key).fetch1_dataframe()" + "We can now train a model for each of these entries. We are training several different\n", + "models here, so depending on your hardware, now may be a good time for a coffee break." ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 55, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", + "exists. Use `overwrite=True` or pick a different name\n", + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/411c\n", + "8460ca6c2e53b6e62826b7e49bd7_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 49%|█████████████████▏ | 25/51 [00:45<00:51, 1.97s/it]" + ] + }, { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
syllablecentroid xcentroid yheadinglatent_state 0latent_state 1latent_state 2latent_state 3latent_state 4latent_state 5latent_state 6latent_state 7latent_state 8latent_state 9
time
1.694621e+0918050.84433697.37710.37610.3156-5.63792.36120.82332.49660.55984.4412-1.9404-3.85965.5380
1.694621e+0918052.63293697.3823-0.20970.06322.0453-2.620910.91644.15681.4786-5.30214.5947-0.88400.6200
1.694621e+0918054.46423697.6510-0.2156-0.7071-0.99330.67415.01103.8812-0.4811-2.2053-0.07533.25832.5587
1.694621e+0918055.35213698.3835-0.2828-0.6419-1.26131.01313.82454.0471-0.4889-1.6345-1.49504.37114.1248
1.694621e+0908056.80493697.1540-0.3571-0.6830-1.39180.92213.67343.8062-0.3035-1.6206-1.73404.36434.2387
.............................................
1.694622e+0917585.08874034.50342.72630.4718-0.90380.11010.9661-1.80750.7622-1.1263-0.4601-2.2455-5.3826
1.694622e+0947596.18104036.92172.79240.5502-0.82070.16041.1446-1.78950.8248-0.7973-0.8894-0.8934-3.6218
1.694622e+0917608.07224039.94652.71960.5995-0.66410.10431.1654-1.92160.8223-0.4043-0.8952-0.1921-2.8618
1.694622e+0907620.30544043.77152.83280.6144-0.56550.04340.9149-2.26970.9295-0.3872-0.90240.1956-3.3429
1.694622e+0967631.99604046.2695-2.11170.5553-0.35920.12730.2913-3.18370.7172-0.6188-0.68610.3468-0.6757
\n", - "

23864 rows × 14 columns

\n", - "
" - ], + "image/png": "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", "text/plain": [ - " syllable centroid x centroid y heading latent_state 0 \\\n", - "time \n", - "1.694621e+09 1 8050.8443 3697.3771 0.3761 0.3156 \n", - "1.694621e+09 1 8052.6329 3697.3823 -0.2097 0.0632 \n", - "1.694621e+09 1 8054.4642 3697.6510 -0.2156 -0.7071 \n", - "1.694621e+09 1 8055.3521 3698.3835 -0.2828 -0.6419 \n", - "1.694621e+09 0 8056.8049 3697.1540 -0.3571 -0.6830 \n", - "... ... ... ... ... ... \n", - "1.694622e+09 1 7585.0887 4034.5034 2.7263 0.4718 \n", - "1.694622e+09 4 7596.1810 4036.9217 2.7924 0.5502 \n", - "1.694622e+09 1 7608.0722 4039.9465 2.7196 0.5995 \n", - "1.694622e+09 0 7620.3054 4043.7715 2.8328 0.6144 \n", - "1.694622e+09 6 7631.9960 4046.2695 -2.1117 0.5553 \n", - "\n", - " latent_state 1 latent_state 2 latent_state 3 latent_state 4 \\\n", - "time \n", - "1.694621e+09 -5.6379 2.3612 0.8233 2.4966 \n", - "1.694621e+09 2.0453 -2.6209 10.9164 4.1568 \n", - "1.694621e+09 -0.9933 0.6741 5.0110 3.8812 \n", - "1.694621e+09 -1.2613 1.0131 3.8245 4.0471 \n", - "1.694621e+09 -1.3918 0.9221 3.6734 3.8062 \n", - "... ... ... ... ... \n", - "1.694622e+09 -0.9038 0.1101 0.9661 -1.8075 \n", - "1.694622e+09 -0.8207 0.1604 1.1446 -1.7895 \n", - "1.694622e+09 -0.6641 0.1043 1.1654 -1.9216 \n", - "1.694622e+09 -0.5655 0.0434 0.9149 -2.2697 \n", - "1.694622e+09 -0.3592 0.1273 0.2913 -3.1837 \n", - "\n", - " latent_state 5 latent_state 6 latent_state 7 latent_state 8 \\\n", - "time \n", - "1.694621e+09 0.5598 4.4412 -1.9404 -3.8596 \n", - "1.694621e+09 1.4786 -5.3021 4.5947 -0.8840 \n", - "1.694621e+09 -0.4811 -2.2053 -0.0753 3.2583 \n", - "1.694621e+09 -0.4889 -1.6345 -1.4950 4.3711 \n", - "1.694621e+09 -0.3035 -1.6206 -1.7340 4.3643 \n", - "... ... ... ... ... \n", - "1.694622e+09 0.7622 -1.1263 -0.4601 -2.2455 \n", - "1.694622e+09 0.8248 -0.7973 -0.8894 -0.8934 \n", - "1.694622e+09 0.8223 -0.4043 -0.8952 -0.1921 \n", - "1.694622e+09 0.9295 -0.3872 -0.9024 0.1956 \n", - "1.694622e+09 0.7172 -0.6188 -0.6861 0.3468 \n", - "\n", - " latent_state 9 \n", - "time \n", - "1.694621e+09 5.5380 \n", - "1.694621e+09 0.6200 \n", - "1.694621e+09 2.5587 \n", - "1.694621e+09 4.1248 \n", - "1.694621e+09 4.2387 \n", - "... ... \n", - "1.694622e+09 -5.3826 \n", - "1.694622e+09 -3.6218 \n", - "1.694622e+09 -2.8618 \n", - "1.694622e+09 -3.3429 \n", - "1.694622e+09 -0.6757 \n", - "\n", - "[23864 rows x 14 columns]" + "
" ] }, - "execution_count": 29, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 98%|██████████████████████████████████▎| 50/51 [01:36<00:02, 2.06s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████| 51/51 [01:39<00:00, 1.94s/it]\n", + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:589: UserWarning:\n", + "\n", + "'kappa' with will be cast to \n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/411c\n", + "8460ca6c2e53b6e62826b7e49bd7_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 49%|█████████████████▏ | 25/51 [02:48<02:55, 6.73s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 98%|██████████████████████████████████▎| 50/51 [05:54<00:06, 6.73s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████| 51/51 [06:02<00:00, 7.10s/it]\n", + "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.81model snapshot/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", + "exists. Use `overwrite=True` or pick a different name\n", + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/8b46\n", + "f4d1412b3b5343c7568134c8ecac_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 49%|█████████████████▏ | 25/51 [00:51<00:53, 2.05s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 98%|██████████████████████████████████▎| 50/51 [01:43<00:02, 2.04s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████| 51/51 [01:45<00:00, 2.08s/it]\n", + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:589: UserWarning:\n", + "\n", + "'kappa' with will be cast to \n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/8b46\n", + "f4d1412b3b5343c7568134c8ecac_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 49%|█████████████████▏ | 25/51 [03:03<02:55, 6.76s/it]" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAD6CAYAAABwKvR6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACICElEQVR4nO3dd1gUx/8H8PfRO1KkiQKiKKhYo4IFe+8aS+y9d2MsUUGNYtdo1Nh7jxp7V+y9IsYYI6IRLKiAKEiZ3x/+br8edwfHgZzI+/U89zzc7NzsZ+d2dveG3RmZEEKAiIiIiIiIiIgoB+npOgAiIiIiIiIiIsp72ClFREREREREREQ5jp1SRERERERERESU49gpRUREREREREREOY6dUkRERERERERElOPYKUVERERERERERDmOnVJERERERERERJTj2ClFREREREREREQ5jp1SRERERERERESU49gpRUSUy9y4cQMtWrSAi4sLzMzMULx4cUyePBnv379XyOfu7o4mTZpkuvywsDAYGxtDJpPh6tWrKvP8+eefCAgIgJWVFczNzVGiRAksW7ZMIc/r16/Rvn17ODg4QCaToUWLFkrlPH/+HHZ2dpDJZNixY4dG8QUGBkImkymk7du3D126dEGpUqVgaGiotFydY8eOQSaTQSaT4dWrVwrL7t69iwEDBsDPzw/m5uaQyWQ4deqUUhmRkZH4+eef4efnB3t7e1hZWaF8+fJYtmwZUlJSVMaedl2q/Prrr6hcuTLs7e1hbGyMQoUKoX379rh7965CvlOnTmlcf2vWrJG2N+0rKipKIe/48eNRtmxZ2NrawsTEBIULF0afPn3w+PHjdNeRXp1u3rwZ1atXh6OjI4yNjeHi4oKmTZvi/PnzGcaeVnh4uNptkclkaNCggUZ5t2zZolS2EAKrV69GxYoVYW5uDisrK5QrVw5//vmnQr7Y2FiMHz8eXl5eMDMzQ4ECBfD9998rfUdxcXEYPXo06tWrh/z580MmkyEwMFDldmn6vaelSbvNiKbHFtJcjRo1ULJkSYW0adOmYffu3boJSIM45McUVce7L83d3V1tWzUxMdEob79+/XI8biIi0p6BrgMgIiLNhYWFwd/fH8WKFcP8+fNhb2+P06dPY/Lkybh27ZrSj+bMSklJQY8ePWBvb49nz56pzBMcHIzx48ejX79+GDt2LAwNDfHXX3/h48ePCvmmTJmCXbt2YdWqVfD09IStra1SWQMHDlT6oaGNXbt24eLFiyhbtiyMjY1x7dq1DD/z7t079O7dGy4uLiq39erVq9i9ezfKli2L2rVrY+/evSrLuXbtGtatW4cuXbpgwoQJMDQ0xMGDB9G/f39cvHgRq1at0mqboqOj0bBhQ5QuXRo2Njb4999/ERwcjEqVKuHatWsoVqyYVuUCwOrVq1G8eHGFNDs7O4X3b9++RYcOHeDt7Q1LS0uEhYVh6tSp2LNnD+7evauUH8i4TqOjo1GlShUMHToU9vb2iIyMxNy5c1G9enUcP34cAQEBGm+Ds7MzLly4oJS+e/duzJgxAy1btlRaNnjwYPzwww8KaUWLFlXK179/f6xZswbDhw/H9OnTkZycjDt37ih1zjRt2hRXr15FYGAgKlSogKdPn2Ly5Mnw8/PDnTt34ObmJm33smXLULp0abRo0QIrVqxQu13afO+atNuMfOljC/3PtGnT0KZNG5Ud9V9DHOXKlcOFCxfg4+OT4zHt2rULiYmJCmkRERFo166dyjZdpUoVzJ49WyHN0dHxi8ZIRETZTBARUa4xfvx4AUD8888/Cul9+vQRAMTr16+lNDc3N9G4ceNMlT9r1ixRoEABsWDBAgFAXLlyRWH51atXhZ6enpgxY0aGZdWpU0d4e3urXb5jxw5hYWEh1q5dKwCI7du3axTjpEmTRNrTV0pKivT3wIEDlZarMnDgQFG2bFnx888/CwDi5cuXasvcvn27ACBOnjypVM7r16/Fx48fVZYPQERERCjFnnZdmgoLCxMAxIQJE6S0kydPalx/q1evVvm9aurAgQMCgFi5cqXK5RnVqSpv374VhoaGonPnzlrFlFaNGjWEmZmZiImJkdIePXokAIhZs2Zl+Pldu3YJAGLr1q3p5nvw4IEAIH7++WeF9PPnzwsAYu7cuVJaamqqSE1NFUII8fLlSwFATJo0SeNtUvW9fy6jdquJzBxb8qr4+PhMfyYgIECUKFFCIc3c3Fx07do1m6L6JDk5WSQkJGTqM18iji8hMDBQABDHjh1TSNfmHEdERF8fPr5HRJSLGBoaAgCsra0V0vPlywc9PT0YGRkpfWbXrl3w9fWVHsH69ddfVZb94MEDTJw4EYsXL4aVlZXKPIsWLYKxsTEGDx6sNkb5o1LHjh3DvXv3pEcqPn8U5PXr1xg4cCB++eUXFCpUSG1Z+/fvR5kyZWBsbAwPDw+l/4jL6ell7nR25swZLFu2DCtWrIC+vn6WyrSxsZG+l89VrFgRAPD06VOlZU+ePEGrVq1gZWUFa2trdOrUCS9fvsxwXfnz5wcAGBgo3+ickJCAESNGwMnJCaampggICMCNGzc02gZNpbd+TepUFUtLS5iYmCiVmZiYiMmTJ8Pb2xsmJiaws7NDzZo1033U7+HDhwgJCUHbtm3V7sMZWbBgAdzd3dG2bdt086XXFgEo3AEobwPaSq/eNWm3AHDp0iU0bdoUdnZ2MDExgaenJ4YNGyYtz+yxZevWrdKjrRYWFqhfv77K/S2j9f7zzz/o3r07ihYtKj0C2bRpU9y5c0eprLdv32LkyJEoXLgwjI2N4eDggEaNGuGvv/5Su91pHT16FM2bN4erqytMTExQpEgR9O3bV+lRU/mjttevX0ebNm1gY2MDT09PjdejjkwmQ3x8PNauXSvtFzVq1JCWR0VFoW/fvnB1dYWRkRE8PDwQFBSE5ORkKY/8GDtz5kxMnToVHh4eMDY2xsmTJ5GQkICRI0eiTJkysLa2hq2tLfz8/JTudEsvDnWP7+3Zswd+fn4wMzODpaUl6tatq3S3orze7t69iw4dOsDa2hqOjo7o0aMHYmJiMl1f4v8fpS1cuDBq1aqV6c8TEdHXj51SRES5SNeuXZEvXz70798f//77L+Li4rBv3z78/vvvGDhwIMzNzRXy37x5E8OGDcPw4cOxa9cu+Pv7Y+jQoUqdO0II9OrVC02aNEGzZs3Urv/06dPw9vbGH3/8gWLFikFfXx+urq4YM2aM9Pie/LGqsmXLonDhwrhw4QIuXLiAcuXKSeUMGTIEHh4eGDRokNp1HT9+HM2bN4elpSW2bNmCWbNmYdu2bVi9erU2VSf58OEDevbsiWHDhinElN1OnDgBAwMDeHl5KS1r2bIlihQpgh07diAwMBC7d+9G/fr1kZSUpJQ3JSUFiYmJ+Ouvv9CrVy84ODige/fuSvnGjRuHf//9FytWrMCKFSvw7Nkz1KhRA//++69S3iZNmkBfXx+2trZo1aoVQkND1W5HcnIyPnz4gBs3bmDYsGHw8vJCq1atFPJktk5TUlKQlJSE8PBw9O/fH0IIDBw4UGGdDRs2xJQpU9CkSRPs2rULa9asgb+/PyIiItSWu2rVKmlfViU4OBhGRkYwMzND1apVsWfPHqVtle+7c+fOhZubG/T19VG4cGHMnj0bQggpr5ubG5o3b4558+bh5MmTePfuHf766y8MGTJEGgcqKzT53jVtt4cPH0a1atUQERGBuXPn4uDBg/j555/x/PlzKU9mji3Tpk1Dhw4d4OPjg23btmH9+vWIi4tDtWrVEBYWlqn1Pnv2DHZ2dggODsahQ4fw22+/wcDAAJUqVcL9+/elfHFxcahatSp+//13dO/eHXv37sXSpUvh5eWFyMhIjev14cOH8PPzw5IlS3DkyBFMnDgRly5dQtWqVVW2v1atWqFIkSLYvn07li5dCuB/Y7OtWbNG4/XKXbhwAaampmjUqJF0bFy8eDGATx1SFStWxOHDhzFx4kQcPHgQPXv2xPTp09G7d2+lsn799VecOHECs2fPxsGDB1G8eHEkJibi9evXGDVqFHbv3o3NmzejatWqaNWqFdatW6dRHKps2rQJzZs3h5WVFTZv3oyVK1fizZs3qFGjBs6ePauUv3Xr1vDy8sIff/yBMWPGYNOmTRg+fHim6+vYsWN4/PgxevToobJj9/Tp07C0tIShoSF8fHwwZ84cpbH8iIjoK6fL27SIiCjz7t27J4oXLy4ASK8hQ4ZIjwfJubm5CZlMJm7evKmQXrduXWFlZaXwKMrChQuFjY2NiIqKEkKof8zL2NhYWFpaChsbG7Fo0SJx4sQJMX78eKGvry9++OEHhbyqHlsRQoh9+/YJQ0NDcefOHSGE+sfPKlWqJFxcXMSHDx+ktNjYWGFra5vu43kZPb43cuRIUbhwYfH+/XshhGaP1KX3+J4qhw8fFnp6emL48OEK6fJ1pU3fuHGjACA2bNigVJaxsbH0PXt5eYmwsDCF5fL6K1eunMI+EB4eLgwNDUWvXr2ktIMHD4rx48eLvXv3ipCQELFo0SLh6uoqzM3NlfYTIYSIjIxU2M8qVaok/vvvP6V8ma3TYsWKSWU6OzuLs2fPKixft26dACCWL1+u8vOqJCcniwIFCojixYsrLXv27Jno3bu32LZtmzhz5ozYuHGjqFy5stI65NtrZWUlXF1dxdq1a8Xx48dFv379BAAxbtw4hXI/fvwoevfurVBHvr6+4tGjR2rj1PTxvYy+dyE0b7eenp7C09NToS2posmxJSIiQhgYGIjBgwcrfDYuLk44OTmJtm3bZnq9n0tOThYfP34URYsWVWgnkydPFgDE0aNHNS4rI6mpqSIpKUk8fvxYABB//vmntEy+D0+cOFHpc2vXrhX6+vpi7dq1Ga4jM4/v9e3bV1hYWIjHjx8rpM+ePVsAEHfv3hVC/O9xVE9PT5WPDn8uOTlZJCUliZ49e4qyZctqFIf8mCI/3qWkpAgXFxdRqlQphcea4+LihIODg/D395fS5PU2c+ZMhTIHDBggTExMlM5TGWnXrp3Q19cXT58+VVo2YMAAsWrVKhESEiJ2794tOnbsKACITp06ZWodRESkW+yUIiLKRR49eiSKFCkiqlSpInbs2CFCQkLEzJkzhZWVlejRo4dCXjc3N1GyZEmlMuQ/XM+cOSOE+NR5YWFhIVasWKGUJ+2PW0NDQwFAbN68WSF92LBhAoB48OCBlKbqx9jbt29FgQIFFMbhUdUp9e7dO6GnpycGDRqkFH/Xrl217pS6dOmS0NfXV/hhm92dUteuXRPW1tbC399faYwX+bquXr2qkJ6UlCQMDAxEz549VZZ34cIFsWHDBlG+fHnh6OgoQkNDpeXy+ps9e7bSZwMCAoSnp2e68T569EhYWFiIZs2aKS1LSkoSV65cEWfPnhXLly8XRYsWFV5eXuLZs2dSHm3qNDQ0VFy6dEls375d1K5dW1haWirUbYcOHYSJiYnCD+CM7Nu3T+Nxo4T41KFUtmxZYWdnJ5KSkoQQQvz3339SZ8yFCxcU8rdo0UKYmJiIuLg4Ka1nz57C1tZWzJs3T4SEhIitW7eKChUqCA8PDxEeHq5yvZp2SmX0vWvabu/fvy8AiGnTpqW7Pk2PLcuXL5fWkZSUpPBq166dcHBwyNR6k5KSxC+//CK8vb2l44v81aBBAymfn5+f8PLySrcsTTx//lz07dtXuLq6Cj09PYX1BQcHS/nk+/CtW7eytL7MdEoVKFBANG3aVKle7969KwCIxYsXCyH+1ymVtnNbbtu2bcLf31+Ym5srbJ+JiYlGcaTtlJKPaZa2o0kIIfr37y/09PSkf3LI6+2vv/5SyLd06VIBQOpA1UR0dLQwNjbO1LhRgwYNEgDE9evXNf4MERHpFmffIyLKRcaMGYPY2FjcvHlTepymevXqsLe3R48ePdClSxeFGcycnJyUypCnRUdHA/g0A17JkiXRunVrvH37FgCkWcbevXuHmJgYaZwZOzs7REVFoX79+gplNmzYEPPnz8f169dRpEgRtfGPHz8ehoaGGDRokLSud+/eSet8+/YtrK2t8ebNG6SmpqYbvzZ69OiBVq1aoUKFCtL6ExISAACxsbEwNjaGpaWl1uXfuHEDdevWRdGiRXHgwAEYGxurzJd2GwwMDGBnZyd9J5+TPw5XuXJlNGvWDEWKFMG4ceOUxohRV1e3bt1KN2Z3d3dUrVoVFy9eVFpmYGCAChUqAPg0y1WDBg3g4eGB4OBgLFiwAIB2dVqiRAkAn8bdatGiBcqWLYuhQ4dKsb58+RIuLi6ZGits5cqVMDQ0RJcuXTTKb2hoiHbt2mHMmDF48OABvL29YWNjA5lMBktLS1SuXFkhf8OGDbF7926EhYWhYsWKOHToEFauXInt27ejTZs2Ur569erB3d0dgYGBWXrUNKPvXdN2Kx+rzNXVNd31aXpskT96991336ksR/6dabreESNG4LfffsNPP/2EgIAA2NjYQE9PD7169cKHDx+kfC9fvkx3/DlNpKamol69enj27BkmTJiAUqVKwdzcHKmpqahcubLC+uScnZ2ztM7MeP78Ofbu3atyjDoASuNeqYpt586daNu2Lb7//nv8+OOPcHJygoGBAZYsWZKlmUDVrc/FxQWpqal48+YNzMzMpPS0s3PKj4Wq6lidDRs2IDExUe3juKp06tQJixYtkmZjJSKirx87pYiIcpGbN2/Cx8dHaewo+Q/E0NBQhU6pqKgopTLkafIfDaGhoXj8+DFsbGyU8tasWRPW1tbSj15fX1+VZYr/H2sno06E0NBQhIeHq+xA6dq1KwDgzZs3UudAevFr4+7du7h79y62b9+utMzT0xOlS5fGzZs3tSr7xo0bqFOnDtzc3HDkyBGlAaM/FxUVhQIFCkjvk5OTER0drfRDLi1LS0sUL14cf//9t8oyVaVlVCbw6fvTpAPI1dUVLi4uCuvPap0aGBigXLly2LZtm5SWP39+nD17FqmpqRrF9eLFC+zbtw/NmjWDg4NDhvnl0u63pqamKFq0qEb7uHyb0nbO5MuXD0WKFEl3nK7MUvW9a9pu5YOkqxpw/3OaHlvs7e0BADt27ICbm5va8jRd74YNG9ClSxdMmzZNIf3Vq1fSoPHy8jIqKyOhoaG4desW1qxZIx1vgE+DrauTlQHqM8ve3h6+vr745ZdfVC53cXFReK8qtg0bNsDDwwNbt25VWJ6YmKh1XPJjiKqxu549ewY9PT2V+2FWrVy5Eo6OjmjSpInGn9H0XERERF8PHrGJiHIRFxcX3L17V7q7SE4+A1LauxLu3r2rdKfMpk2bYGlpKd2JsWXLFpw8eVLh9dNPPwEAli5din379kmfbd26NQDg4MGDCmUeOHAAenp6au+ekJs/f77SuubNmwfg06xNJ0+ehIWFBczNzVGxYkXs3LlTuusG+DTY8d69e9OvpHSkXffJkyelH6e7d+/GihUrtCr35s2bqFOnDlxdXXH06NEMf6Bt3LhR4f22bduQnJysMAuXKq9evcKdO3dU3o22efNmhYG4Hz9+jPPnz2dY5qNHj3Du3DmlO4NU+eeff/D06VOF9We1ThMSEnDx4kWFMhs2bIiEhASNB5Jet24dkpKS0LNnT43yA0BSUhK2bt0Ke3t7hXW3bt0asbGxSrP8HThwABYWFtJdXvIOgrR3mEVHR+Pvv//O8A6hzFD1vWvabr28vODp6YlVq1al2zGh6bGlfv36MDAwwMOHD1GhQgWVr8ysVyaTKd1RuH//fvz3338KaQ0bNsTff/+NEydOpFtX6ZF30qRd3++//651mdowNjZWecdQkyZNEBoaCk9PT5X1mrZTShWZTAYjIyOFDqmoqCilOyvTiyOtYsWKoUCBAti0aZPCMSY+Ph5//PGHNCNfdrp69Spu376Nrl27qpx1Uh35YO6aHM+IiOjrwDuliIhykWHDhqFFixaoW7cuhg8fDnt7e1y8eBHTp0+Hj48PGjZsqJDfxcUFzZo1Q2BgIJydnbFhwwYcPXoUM2bMkH5EqLp4Dw8PBwCUL19e+pEJAN27d8fvv/+OAQMG4NWrV/Dx8cGxY8fw22+/YcCAAeneOQEAZcqUUbusRIkSCh0oU6ZMQYMGDVC3bl2MHDkSKSkpmDFjBszNzfH69WuFzz5+/BhXrlwB8Gl2LeDTnRzAp8fT5NugqoNGPu15lSpVpLtAgE+PQh04cADA/zoeQkJC8OrVK5ibm0t1ff/+fdSpUwcA8Msvv+DBgwd48OCBVI6np6d014jczp07YWBggLp16+Lu3buYMGECSpcujbZt2wIAYmJiULduXfzwww8oWrQoTE1N8ffff2PBggVITEzEpEmTlLbjxYsXaNmyJXr37o2YmBhMmjQJJiYmGDt2rJSnTp06qF69Onx9fWFlZYU7d+5g5syZkMlkmDJlipTv9u3bGD58ONq0aYPChQtDT08Pd+7cwbx582BnZ4dRo0ZJeTNTp/7+/mjWrBm8vb1hbW2N8PBwLFmyBA8fPsSuXbukfB06dMDq1avRr18/3L9/HzVr1kRqaiouXboEb29vpZntVq5ciYIFCyo9Vio3YsQIJCUloUqVKnBycsKTJ0+wcOFC3Lx5E6tXr4a+vr6Ud9SoUdi4cSO+//57TJkyBa6urtixYwf27NmD2bNnw9TUFMCnWdkmTpyI/v374+nTpyhXrhwiIyMxa9YsvH//HkOHDlWI4eDBg4iPj0dcXBwAICwsTNpHGzVqBDMzs0x975lpt7/99huaNm2KypUrY/jw4ShUqBAiIiJw+PBhqYNU02OLu7s7Jk+ejPHjx+Pff/9FgwYNYGNjg+fPn+Py5cswNzdHUFCQxutt0qQJ1qxZg+LFi8PX1xfXrl3DrFmzlDr1hg0bhq1bt6J58+YYM2YMKlasiA8fPiAkJARNmjRBzZo1VX73nytevDg8PT0xZswYCCFga2uLvXv34ujRoxl+9nPr1q1Djx49sGrVKo0fF/1cqVKlcOrUKezduxfOzs6wtLREsWLFMHnyZBw9ehT+/v4YMmQIihUrhoSEBISHh+PAgQNYunRphp2dTZo0wc6dOzFgwAC0adMGT548wZQpU+Ds7KxwXEovjrT09PQwc+ZMdOzYEU2aNEHfvn2RmJiIWbNm4e3btwgODs50HWRk5cqVAKC2o3nTpk3YuXMnGjduDDc3N7x9+xbbt2/Hli1b0K1bN5QuXTrbYyIioi9Ed8NZERGRNk6cOCHq1asnnJychKmpqfDy8hIjR44Ur169Usjn5uYmGjduLHbs2CFKlCghjIyMhLu7u5g7d26G61A30LkQnwaf7du3r3B0dBSGhobCy8tLzJo1S2lQanWz76WlbvY9IYTYs2eP8PX1FUZGRqJQoUIiODhYGkhXVbyqXqoG8v2cukG55YMJq3q5ublptG4AYvXq1UrrunbtmmjatKmwsLAQlpaWokOHDuL58+dSvoSEBNGrVy/h7e0tLCwshIGBgXB1dRWdOnWSZuBKW3/r168XQ4YMEfnz5xfGxsaiWrVqSgOqDxs2TPj4+AhLS0thYGAgXFxcRKdOncT9+/cV8kVFRYlOnToJT09PYWZmJoyMjEThwoVFv379RERERLr1mV6djhw5UpQuXVpYW1sLAwMD4eTkJFq2bCnOnTunVMaHDx/ExIkTRdGiRYWRkZGws7MTtWrVEufPn1fId+7cObWzpMmtXLlSVKxYUdja2goDAwNhY2Mj6tevLw4fPqwyf0REhGjfvr2wsbERRkZGwtfXV6xatUopX2RkpBg0aJAoUqSIMDExES4uLqJx48ZKg6QL8ak9qttH5LP1ZeZ7VyW9dnvhwgXRsGFDYW1tLYyNjYWnp6fSQNmaHluEEGL37t2iZs2awsrKShgbGws3NzfRpk0bcezYsUyt982bN6Jnz57CwcFBmJmZiapVq4ozZ86IgIAAERAQoFDWmzdvxNChQ0WhQoWEoaGhcHBwEI0bN1YaVDs9YWFhom7dutIsot9//72IiIhQGnw+vcH65fX8edtWR9Vx8ObNm6JKlSrCzMxMAFDYzpcvX4ohQ4YIDw8PYWhoKGxtbUX58uXF+PHjxbt374QQ/zs2qRvUPzg4WLi7uwtjY2Ph7e0tli9frvK4qS6OtAOdy+3evVtUqlRJmJiYCHNzc1G7dm2ltquu3uR1lt7MlHLv378X1tbWonr16mrzXLhwQdSuXVs4OTkJQ0NDYWZmJr777juxePHiTE2QQEREuicT4rP7cImIiIiIiIiIiHIAx5QiIiIiIiIiIqIcxzGliIiIiChXS0lJQXo3/8tkMoWxw4iIiOjrwDuliIiIiChXq127NgwNDdW+PD09dR0iERERqcAxpYiIiIgoV7t//740s6EqxsbGKFWqVA5GRERERJpgpxQREREREREREeU4Pr5HREREREREREQ5jp1SRERERERERESU49gpRUREREREREREOY6dUkRERERERERElOPYKUVERERERERERDmOnVJERERERERERJTj2ClFREREREREREQ5jp1SRERERERERESU49gpRUREREREREREOY6dUkRERERERERElOPYKUVERERERERERDmOnVJERERERERERJTj2ClFREREREREREQ5jp1SRERERERERESU49gpRUREREREREREOY6dUkRERERERERElOPYKUVERERERERERDmOnVJERERERERERJTj2ClFREREREREREQ5jp1SRERERERERESU49gpRUREREREREREOY6dUkRERERERERElOPYKUVERERERERERDku2zql1qxZA5lMpvI1atSo7FoNpSMwMBAymUwhzd3dHd26dctUOefPn0dgYCDevn2bqc+lXdepU6cgk8mwY8eOTJWTnvfv3yMwMBCnTp1SWibfB8PDw7NtfblZ2jZpYmICJycn1KxZE9OnT8eLFy90HSKmTZuG3bt3K6XL9x1V37Ou1KhRAzVq1JDeh4eHQyaTYc2aNZkqZ9OmTZg/f36mPqNqXfL2/urVq0yVlZ6wsDAEBgaqbEPdunWDu7t7tq2LMvZ5G1bVFoQQKFKkCGQymcK+mR3UHc+/pjap630yvXNl2uMFEeV+ly5dQsuWLVGoUCEYGxvD0dERfn5+GDlypEK+xYsXZ/raIC1110f09cnM9VhO/i4jyk0MsrvA1atXo3jx4gppLi4u2b0a0tCuXbtgZWWVqc+cP38eQUFB6NatG/Lly/dF15VZ79+/R1BQEAAoXfA3btwYFy5cgLOz8xeNIbeRt8mkpCS8ePECZ8+exYwZMzB79mxs3boVderU0Vls06ZNQ5s2bdCiRQuF9HLlyuHChQvw8fHRTWAacHZ2xoULF+Dp6Zmpz23atAmhoaEYNmzYF19XZoWFhSEoKAg1atRQ+rE/YcIEDB069Iuun1SztLTEypUrlY55ISEhePjwISwtLb94DLmhTea09M6Vixcv1k1QRPRF7N+/H82aNUONGjUwc+ZMODs7IzIyElevXsWWLVswZ84cKe/ixYthb2+f6c6Hz6m7PqLcLSd/lxHlJtneKVWyZElUqFBBo7xJSUmQyWQwMMj2MOj/lS1b9ouv48OHDzA1Nc2RdaUnf/78yJ8/v05j+BqlbZOtW7fG8OHDUbVqVbRq1QoPHjyAo6NjlteTkpKC5ORkGBsbZ7ksKysrVK5cOcvlfEnGxsZfPMbP61TX9fGlO8RIvXbt2mHjxo347bffFC5mV65cCT8/P8TGxn7xGHJDm8yq9+/fw8zMLFvKYucd0bdl5syZ8PDwwOHDhxV+t7Rv3x4zZ87UYWSUm+j6t9LnsvOcR5RVOTamlPzW//Xr12PkyJEoUKAAjI2N8c8//wAAjh07htq1a8PKygpmZmaoUqUKjh8/rlTO/v37UaZMGRgbG8PDwwOzZ89WemwtvcdqZDIZAgMDFdIePHiAH374AQ4ODjA2Noa3tzd+++03lfFv3rwZ48ePh4uLC6ysrFCnTh3cv39faT2HDh1C7dq1YW1tDTMzM3h7e2P69OkAgPXr10Mmk+HChQtKn5s8eTIMDQ3x7NmzdOtTVT2okvY20dTUVEydOhXFihWDqakp8uXLB19fXyxYsADAp1tQf/zxRwCAh4eH0qMj7u7uaNKkCXbu3ImyZcvCxMREunNJ3S2pCQkJGDFiBJycnGBqaoqAgADcuHFDIY+6Rx0+fzwjPDxc6nQKCgqSYpOvU93je6tWrULp0qVhYmICW1tbtGzZEvfu3VNaj4WFBf755x80atQIFhYWKFiwIEaOHInExESVdZubFSpUCHPmzEFcXBx+//13KV2T7wH4XxubOXMmpk6dCg8PDxgbG+PkyZNISEjAyJEjUaZMGVhbW8PW1hZ+fn74888/FcqUyWSIj4/H2rVrpe9Svm51jwrt2bMHfn5+MDMzg6WlJerWravUjuTHg7t376JDhw6wtraGo6MjevTogZiYmAzrRgiBmTNnws3NDSYmJihXrhwOHjyolE/Vcebly5fo06cPChYsCGNjY+TPnx9VqlTBsWPHpPrdv38/Hj9+rPBoZUZ1mt4x7cmTJ2jVqhWsrKxgbW2NTp064eXLl0p1nfa4Byi22TVr1uD7778HANSsWVOKTb5OVY9KJSQkYOzYsfDw8ICRkREKFCiAgQMHKt1iLj9uHDp0COXKlYOpqSmKFy+OVatWqfkW6HMdOnQAAGzevFlKi4mJwR9//IEePXqo/MzHjx8xdepUFC9eXNoXu3fvrrRvJCUlYfTo0XBycoKZmRmqVq2Ky5cvK5Wnqk1evXoV7du3h7u7O0xNTeHu7o4OHTrg8ePHCp+VH5tPnjyJ/v37w97eHnZ2dmjVqlWG57rPyyhWrJh0jl63bp1GMQKq26r8mH/nzh3Uq1cPlpaWqF27NgDg6NGjaN68OVxdXWFiYoIiRYqgb9++Co9mZHSuVHUsff36NQYMGIACBQrAyMgIhQsXxvjx45XOMTKZDIMGDcL69evh7e0NMzMzlC5dGvv27dOorogo+0VHR8Pe3l7lP9L19P73c8rd3R13795FSEiIdFyQnzuz4/oIAKKiotC3b1+4urrCyMgIHh4eCAoKQnJycobbceLECdSoUQN2dnYwNTVFoUKF0Lp1a7x//17Kk9XzR9rfA6qGFwHUX7dv3boVfn5+MDc3h4WFBerXr6/0uyEz1+2JiYmYPHkyvL29YWJiAjs7O9SsWRPnz5+X8gghsHjxYpQpUwampqawsbFBmzZt8O+//2ZYp3LPnz/P8Lozu3+XpaamYubMmdJ35eDggC5duuDp06cK661RowZKliyJ06dPw9/fH2ZmZujRowd69uwJW1tbhe9frlatWihRooTG20+UFdl+i5L8P/sKK/nsAD527Fj4+flh6dKl0NPTg4ODAzZs2IAuXbqgefPmWLt2LQwNDfH777+jfv36OHz4sHShePz4cTRv3hx+fn7YsmULUlJSMHPmTDx//lzreMPCwuDv7y/9SHdycsLhw4cxZMgQvHr1CpMmTVLIP27cOFSpUgUrVqxAbGwsfvrpJzRt2hT37t2Dvr4+gE//ve7duzcCAgKwdOlSODg44O+//0ZoaCiAT//1Hj16NH777Tf4+flJZScnJ+P3339Hy5Yt033kMSv1MHPmTAQGBuLnn39G9erVkZSUhL/++kv6EdmrVy+8fv0aCxcuxM6dO6VH4T7/r+/169dx7949/Pzzz/Dw8IC5uXm66xw3bhzKlSuHFStWICYmBoGBgahRowZu3LiBwoULZxiznLOzMw4dOoQGDRqgZ8+e6NWrFwCke3fU9OnTMW7cOHTo0AHTp09HdHQ0AgMD4efnhytXrqBo0aJS3qSkJDRr1gw9e/bEyJEjcfr0aUyZMgXW1taYOHGixnHmFo0aNYK+vj5Onz6tdRm//vorvLy8MHv2bFhZWaFo0aJITEzE69evMWrUKBQoUAAfP37EsWPH0KpVK6xevRpdunQBAFy4cAG1atVCzZo1MWHCBABI95bmTZs2oWPHjqhXrx42b96MxMREzJw5EzVq1MDx48dRtWpVhfytW7dGu3bt0LNnT9y5cwdjx44FgAw7QoKCghAUFISePXuiTZs2ePLkCXr37o2UlBQUK1Ys3c927twZ169fxy+//AIvLy+8ffsW169fR3R0NIBPt/T36dMHDx8+xK5duzSu0/S0bNkSbdu2Rb9+/XD37l1MmDABYWFhuHTpEgwNDdP97OcaN26MadOmYdy4cfjtt99Qrlw5AOrvkBJCoEWLFjh+/DjGjh2LatWq4fbt25g0aRIuXLiACxcuKNw1d+vWLYwcORJjxoyBo6MjVqxYgZ49e6JIkSKoXr26xnHmRVZWVmjTpg1WrVqFvn37AvjUQaWnp4d27dopjVGWmpqK5s2b48yZMxg9ejT8/f3x+PFjTJo0CTVq1MDVq1dhamoKAOjduzfWrVuHUaNGoW7duggNDUWrVq0QFxeXYVzh4eEoVqwY2rdvD1tbW0RGRmLJkiX47rvvEBYWBnt7e4X8vXr1QuPGjbFp0yY8efIEP/74Izp16oQTJ06ku541a9age/fuaN68OebMmSOdRxITExV+DGbWx48f0axZM/Tt2xdjxoyRrl0ePnwIPz8/9OrVC9bW1ggPD8fcuXNRtWpV3LlzB4aGhhqdKz+XkJCAmjVr4uHDhwgKCoKvry/OnDmD6dOn4+bNm9i/f79C/v379+PKlSuYPHkyLCwsMHPmTLRs2RL379/P1HmTiLKHn58fVqxYgSFDhqBjx44oV66cynPsrl270KZNG1hbW0uP8crPhdlxfRQVFYWKFStCT08PEydOhKenJy5cuICpU6ciPDwcq1evVrsN4eHhaNy4MapVq4ZVq1YhX758+O+//3Do0CF8/PgRZmZmOXb+UGfatGn4+eef0b17d/z888/4+PEjZs2ahWrVquHy5csKx1hNrtuTk5PRsGFDnDlzBsOGDUOtWrWQnJyMixcvIiIiAv7+/gCAvn37Ys2aNRgyZAhmzJiB169fY/LkyfD398etW7c0eqJAm+vOrP4u69+/P5YtW4ZBgwahSZMmCA8Px4QJE3Dq1Clcv35d4TwcGRmJTp06YfTo0Zg2bRr09PSQL18+rFq1Cps2bZJ+VwGffh+fPHlS6SYNoi9GZJPVq1cLACpfSUlJ4uTJkwKAqF69usLn4uPjha2trWjatKlCekpKiihdurSoWLGilFapUiXh4uIiPnz4IKXFxsYKW1tb8fmmPHr0SAAQq1evVooTgJg0aZL0vn79+sLV1VXExMQo5Bs0aJAwMTERr1+/FkIIKf5GjRop5Nu2bZsAIC5cuCCEECIuLk5YWVmJqlWritTUVLX1NWnSJGFkZCSeP38upW3dulUAECEhIWo/l5l6EEIINzc30bVrV+l9kyZNRJkyZdItf9asWQKAePTokdIyNzc3oa+vL+7fv69y2efrktdZuXLlFOoiPDxcGBoail69eklpAQEBIiAgQKnMrl27Cjc3N+n9y5cvlb5DOfk+KI/7zZs3wtTUVOk7i4iIEMbGxuKHH35QWA8AsW3bNoW8jRo1EsWKFVNaV24gr48rV66ozePo6Ci8vb2l95p+D/I25unpKT5+/JhuHMnJySIpKUn07NlTlC1bVmGZubm5wj4jJ993Tp48KYT4dDxwcXERpUqVEikpKVK+uLg44eDgIPz9/aW0SZMmCQBi5syZCmUOGDBAmJiYpNsu37x5I0xMTETLli0V0s+dOycAKNSNquOMhYWFGDZsmNryhRCicePGCnWZtjxVdapqXfLtHD58uELejRs3CgBiw4YNUpq6NpO2zW7fvl2h3j+Xdh84dOiQynqWH8eWLVumsB4TExPx+PFjKe3Dhw/C1tZW9O3bV2ld9MnnbVjeJkJDQ4UQQnz33XeiW7duQgghSpQoobBvbt68WQAQf/zxh0J5V65cEQDE4sWLhRBC3Lt3L919SNXxXNW+IZecnCzevXsnzM3NxYIFC5S2Y8CAAQr5Z86cKQCIyMhItWXK276688jn+6S6GFW1H/kxf9WqVWrXLYQQqampIikpSTx+/FgAEH/++ae0LL1zZdpj6dKlS1WeY2bMmCEAiCNHjkhpAISjo6OIjY2V0qKiooSenp6YPn16uvES0Zfx6tUrUbVqVem3jaGhofD39xfTp08XcXFxCnnTHpPV0eb6qG/fvsLCwkLhfCqEELNnzxYAxN27d9Wub8eOHQKAuHnzpto8X+L8Ib9eSSvtdXtERIQwMDAQgwcPVsgXFxcnnJycRNu2baU0Ta/b161bJwCI5cuXq93mCxcuCABizpw5CulPnjwRpqamYvTo0Wo/+/n2aXLdmZ2/y+TfQdpz66VLlwQAMW7cOCktICBAABDHjx9XKj8gIEAphv79+wsrKyulfZvoS8n2x/fWrVuHK1euKLw+v1OqdevWCvnPnz+P169fo2vXrkhOTpZeqampaNCgAa5cuYL4+HjEx8fjypUraNWqFUxMTKTPW1paomnTplrFmpCQgOPHj6Nly5YwMzNTWH+jRo2QkJCAixcvKnymWbNmCu99fX0BQHpc4fz584iNjcWAAQNU3qoq179/fwDA8uXLpbRFixahVKlS6d41kNV6qFixIm7duoUBAwbg8OHDWo1F4uvrCy8vL43z//DDDwp14ebmBn9/f5w8eTLT686MCxcu4MOHD0qPFBYsWBC1atVSejxUJpMp1aGvr6/SoyjfEiFElj7frFkzlf8p3L59O6pUqQILCwsYGBjA0NAQK1euVHpsUlP379/Hs2fP0LlzZ4U7IywsLNC6dWtcvHhR6dZjVW01ISEh3VkHL1y4gISEBHTs2FEh3d/fH25ubhnGWbFiRaxZswZTp07FxYsXkZSUpMnmKcWdmTuc0sbatm1bGBgYfPH2Jb+7JW37+v7772Fubq7UvsqUKYNChQpJ701MTODl5fVNt6/sFBAQAE9PT6xatQp37tzBlStX1D66t2/fPuTLlw9NmzZVOK+VKVMGTk5O0m3/8n1E3T6UkXfv3uGnn35CkSJFYGBgAAMDA1hYWCA+Pl5lW8/o/KmKvO2rO49kVdprEgB48eIF+vXrh4IFC0rHL3n71/YYduLECZibm6NNmzYK6fL2k7a91KxZU2EAe0dHRzg4OLC9EOmInZ0dzpw5gytXriA4OBjNmzfH33//jbFjx6JUqVIaz4Sb1eujffv2oWbNmnBxcVE4vjds2BDApwkw1ClTpgyMjIzQp08frF27VuWjaTl1/lDl8OHDSE5ORpcuXRTWbWJigoCAAKVHszW5bj948CBMTEzUni/l2yyTydCpUyeF9To5OaF06dIazzqrzXVnVn6Xyb+DtNdhFStWhLe3t9J5xcbGBrVq1VIqZ+jQobh58ybOnTsHAIiNjcX69evRtWtXWFhYaBwPUVZke6eUt7c3KlSooPD6XNqZ0eSPnLVp0waGhoYKrxkzZkAIgdevX+PNmzdITU2Fk5OT0jpVpWkiOjoaycnJWLhwodK6GzVqBABKJxk7OzuF9/Jbcj98+AAA0vPWrq6u6a7b0dER7dq1w++//46UlBTcvn0bZ86cwaBBg9L9XFbrYezYsZg9ezYuXryIhg0bws7ODrVr18bVq1cz/KxcZme3Uxer/JGmL0Vevqp4XVxclNZvZmam0NEHfPp+ExISvlyQOhQfH4/o6OgszY6pqm537tyJtm3bokCBAtiwYQMuXLgg/YDWti4z+i5TU1Px5s0bhfSM2mp669G2fW3duhVdu3bFihUr4OfnB1tbW3Tp0gVRUVEZflYuq+3LwMAAdnZ2OdK+DAwMlB6flclkKtt32u8D+PSdpPd90P/IZDJ0794dGzZswNKlS+Hl5YVq1aqpzPv8+XO8ffsWRkZGSue2qKgo6bymbn+X70MZ+eGHH7Bo0SL06tULhw8fxuXLl3HlyhXkz59f5feqizaZHjMzM6VHhlNTU1GvXj3s3LkTo0ePxvHjx3H58mXpH1Ta7q/R0dFwcnJS+meVg4MDDAwM2F6IcokKFSrgp59+wvbt2/Hs2TMMHz4c4eHhGg12nh3XR8+fP8fevXuVju3ysX/S6xzz9PTEsWPH4ODggIEDB8LT0xOenp7S+EXy8nPi/KFu2wDgu+++U1r31q1blbZNk+v2ly9fwsXFJd1HvZ8/fw4hBBwdHZXWe/HiRY07HLU5x2Xld1lmf+eou75s3rw53N3dpUf11qxZg/j4eAwcODDDGIiyS45Pe5f2gkz+rOvChQvVzuzj6OgozdSn6sdd2jT5ASrtQHdpG6eNjQ309fXRuXNntQ3Pw8Mjna1RJv+BlnaAOVWGDh2K9evX488//8ShQ4eQL18+pf84pGVjY6NxPahiYGCAESNGYMSIEXj79i2OHTuGcePGoX79+njy5IlGszCkdweYKupi/fzgbWJionIQak1PBKrIy4+MjFRa9uzZM6XxTvKa/fv3IyUlRWHwzMx+D6r2hQ0bNsDDwwNbt25VWJ6VAeMz+i719PRgY2Ojdflp16Nun0070Hda9vb2mD9/PubPn4+IiAjs2bMHY8aMwYsXL3Do0CGNYtCmfRUoUEB6n5ycjOjoaIX2ZWxsrLL+s9JxZWdnh+TkZLx8+VKhY0oIgaioKHz33Xdal02qdevWDRMnTsTSpUvxyy+/qM0nH0hc3T4nvwPn8/1d1T6UnpiYGOzbtw+TJk3CmDFjpHT5mCnZJaM2+Tl15/7MHL9CQ0Nx69YtrFmzBl27dpXS5ZOyaMvOzg6XLl2CEEJhvS9evEBycnKePx8R5UaGhoaYNGkS5s2bJ40bm57suD6yt7eHr6+v2nNARv9orFatGqpVq4aUlBRcvXoVCxcuxLBhw+Do6Ij27dt/kfPH58fmz8eaTHtslh8Hd+zYodHd6ZrInz8/zp49i9TUVLUdU/b29pDJZDhz5ozKGaSzY1ZpdbLyu+zza+O0N0Oo+p2j7vpST08PAwcOxLhx4zBnzhwsXrwYtWvXznAcVaLslGOz76lTpUoV5MuXD2FhYUp3WMlfRkZGMDc3R8WKFbFz506FHvC4uDjs3btXoUxHR0eYmJjg9u3bCulpZ7cwMzNDzZo1cePGDfj6+qpcd2Z7+/39/WFtbY2lS5dm+GhU+fLl4e/vjxkzZmDjxo3o1q1bhoOGZ6YeMpIvXz60adMGAwcOxOvXr6XZLzTp2c+MzZs3K9TF48ePcf78eYXOEHd3d/z9998KJ+bo6GiFmTEyG5ufnx9MTU2xYcMGhfSnT5/ixIkT0gD6eVFERARGjRoFa2traeBkQPPvIT0ymQxGRkYKJ7+oqCil9gdo/p//YsWKoUCBAti0aZPCvhQfH48//vhDmpEvqypXrgwTExNs3LhRIf38+fOZfmymUKFCGDRoEOrWrYvr169L6dl9t0PaWLdt24bk5GSl9pX2eHjixAm8e/dOIS0z7UveftK2rz/++APx8fF5un19KQUKFMCPP/6Ipk2bKnSYpNWkSRNER0cjJSVF5XlNfqEp30fU7UPpkclkEEIoXayvWLECKSkpWmydasWKFYOzs7Pa88jn5J3Gaff1PXv2aLw++XEr7XZ9PkupXGbby7t377B7926FdPksgmwvRF83Vf8UA/73SO/nnUHqzvPZcX3UpEkThIaGwtPTU+XxXdO73/X19VGpUiXp7hj5dcqXOH+oOzan/d1Sv359GBgY4OHDh2p/E2ZWw4YNkZCQoHL2YrkmTZpACIH//vtP5TpLlSqV6fVqI7O/y+SP4qW9Drty5Qru3buXqfNKr169YGRkhI4dO+L+/fsZPrlDlN1y/E6ptCwsLLBw4UJ07doVr1+/Rps2beDg4ICXL1/i1q1bePnyJZYsWQIAmDJlCho0aIC6deti5MiRSElJwYwZM2Bubq7wn1n5c8GrVq2Cp6cnSpcujcuXL2PTpk1K61+wYAGqVq2KatWqoX///nB3d0dcXBz++ecf7N27N8NZgVRtz5w5c9CrVy/UqVMHvXv3hqOjI/755x/cunULixYtUsg/dOhQtGvXDjKZDAMGDNBoHZrWgypNmzZFyZIlUaFCBeTPnx+PHz/G/Pnz4ebmJs3yJT/4LliwAF27doWhoSGKFSumML5FZrx48QItW7ZE7969ERMTg0mTJsHExESalQL4NGvZ77//jk6dOqF3796Ijo7GzJkzlR6tsLS0hJubG/7880/Url0btra2sLe3V3kHS758+TBhwgSMGzcOXbp0QYcOHRAdHY2goCCYmJgozaz4rQoNDZWej3/x4gXOnDmD1atXQ19fH7t27VK4y0XT7yE9TZo0wc6dOzFgwABp9ropU6bA2dkZDx48UMhbqlQpnDp1Cnv37oWzszMsLS1V/mdGT08PM2fORMeOHdGkSRP07dsXiYmJmDVrFt6+fYvg4GDtK+gzNjY2GDVqFKZOnYpevXrh+++/x5MnTxAYGJjho0IxMTGoWbMmfvjhBxQvXhyWlpa4cuUKDh06hFatWils886dO7FkyRKUL18eenp6Wl1oye3cuRMGBgaoW7euNPte6dKl0bZtWylP586dMWHCBEycOBEBAQEICwvDokWLYG1trVBWyZIlAQDLli2DpaUlTExM4OHhobJzvm7duqhfvz5++uknxMbGokqVKtLse2XLlkXnzp213iZST5N9vX379ti4cSMaNWqEoUOHomLFijA0NMTTp09x8uRJNG/eHC1btoS3tzc6deqE+fPnw9DQEHXq1EFoaKg082N6rKysUL16dcyaNUs6BoeEhGDlypXIly9fNm3tp7Y/ZcoU9OrVSzqPvH37VmWbdHJyQp06dTB9+nTY2NjAzc0Nx48fx86dOzVeX/HixeHp6YkxY8ZACAFbW1vs3bsXR48eVcqbmXNlly5d8Ntvv6Fr164IDw9HqVKlcPbsWUybNg2NGjVCnTp1MlkzRJST6tevD1dXVzRt2hTFixdHamoqbt68iTlz5sDCwgJDhw6V8pYqVQpbtmzB1q1bUbhwYZiYmKBUqVLZcn00efJkHD16FP7+/hgyZAiKFSuGhIQEhIeH48CBA1i6dKnaIUSWLl2KEydOoHHjxihUqBASEhKkmeHkx6Avcf5o1KgRbG1t0bNnT0yePBkGBgZYs2YNnjx5opDP3d0dkydPxvjx4/Hvv/+iQYMGsLGxwfPnz3H58mWYm5sjKCgoU99bhw4dsHr1avTr1w/3799HzZo1kZqaikuXLsHb2xvt27dHlSpV0KdPH3Tv3h1Xr15F9erVYW5ujsjISJw9exalSpWSxgLObln5XVasWDH06dMHCxcuhJ6eHho2bCjNvlewYEEMHz5c4zjy5cuHLl26YMmSJXBzc9N6vGYirWXXiOkZzfQlnxVn+/btKpeHhISIxo0bC1tbW2FoaCgKFCggGjdurJR/z549wtfXVxgZGYlChQqJ4OBglbM6xMTEiF69eglHR0dhbm4umjZtKsLDw1XOQvXo0SPRo0cPUaBAAWFoaCjy588v/P39xdSpUzOMX91MfwcOHBABAQHC3NxcmJmZCR8fHzFjxgyl7U5MTBTGxsaiQYMGKutFHU3rIe0sD3PmzBH+/v7C3t5e+mzPnj1FeHi4wufGjh0rXFxchJ6ensJsRm5ubqJx48YqY1I3+9769evFkCFDRP78+YWxsbGoVq2auHr1qtLn165dK7y9vYWJiYnw8fERW7duVZrxSwghjh07JsqWLSuMjY0VZvhIO4uH3IoVK6S6sra2Fs2bN1eanaRr167C3NxcKSZ1M4bkBmlnxDQyMhIODg4iICBATJs2Tbx48ULl5zT5HuT7/axZs1SWERwcLNzd3YWxsbHw9vYWy5cvV1mXN2/eFFWqVBFmZmYKs9upm0Vr9+7dolKlSsLExESYm5uL2rVri3Pnzinkka/n5cuXKutD1UxZn0tNTRXTp08XBQsWFEZGRsLX11fs3btXaTattG0/ISFB9OvXT/j6+gorKythamoqihUrJiZNmiTi4+Olz71+/Vq0adNG5MuXT8hkMqlO0qvT9Gbfu3btmmjatKmwsLAQlpaWokOHDgqzegrx6TgzevRoUbBgQWFqaioCAgLEzZs3ldqsEELMnz9feHh4CH19fYV1qmqLHz58ED/99JNwc3MThoaGwtnZWfTv31+8efNGIZ+644a62R7pE01m0BRC9UxPSUlJYvbs2aJ06dLCxMREWFhYiOLFi4u+ffuKBw8eSPkSExPFyJEjhYODgzAxMRGVK1cWFy5cUHs8/7xNPn36VLRu3VrY2NgIS0tL0aBBAxEaGqr0WXXbocmMfnIrVqwQRYsWFUZGRsLLy0usWrVK5T4ZGRkp2rRpI2xtbYW1tbXo1KmTuHr1qsrZ91Qd84UQIiwsTNStW1dYWloKGxsb8f3334uIiAiV1w/qzpWq9u3o6GjRr18/4ezsLAwMDISbm5sYO3asSEhIUMgHQAwcOFApLlXtlYhyxtatW8UPP/wgihYtKiwsLIShoaEoVKiQ6Ny5swgLC1PIGx4eLurVqycsLS0FAIXjVFavj4T4NBP1kCFDhIeHhzA0NBS2traifPnyYvz48eLdu3dqt+HChQuiZcuWws3NTRgbGws7OzsREBAg9uzZo5Avu88fQghx+fJl4e/vL8zNzUWBAgXEpEmTxIoVK1Rel+3evVvUrFlTWFlZCWNjY+Hm5ibatGkjjh07JuXJzHX7hw8fxMSJE6VziJ2dnahVq5Y4f/68Qr5Vq1aJSpUqCXNzc2Fqaio8PT1Fly5dVP5mUbVOTa47s/t3WUpKipgxY4bw8vIShoaGwt7eXnTq1Ek8efJE4fMBAQGiRIkS6W7HqVOnBAARHBycbj6iL0EmRBan3/oKBAYGIigoKMszienC3r170axZM+zfv18aXJ2IiIiIiCi3cXd3R40aNdJ9ZI6+PiNHjsSSJUvw5MkTrQerJ9KWzh/fy6vCwsLw+PFjjBw5EmXKlJGmciUiIiIiIiL60i5evIi///4bixcvRt++fdkhRTrBTikdGTBgAM6dO4dy5cph7dq1mZ5xi4iIiIiIiEhb8smCmjRpgqlTp+o6HMqjvonH94iIiIiIiIiIKHfR03UARERERERERESU97BTioiIiIiIiIiIchw7pYiIiIiIiIiIKMexU4qIiIiIiIiIiHKcTmbfS01NxbNnz2BpaclZ5yjHCSEQFxcHFxcX6OnlnX5ZtjvSNbY9tj3SDbY9tj0iIqKcpun1h046pZ49e4aCBQvqYtVEkidPnsDV1VXXYeQYtjv6WrDtEekG2x4RERHltIyuP3TSKWVpaQngU3BWVla6CIHysNjYWBQsWFDaD/MKtjvSNbY9tj3Sjbze9oDhAIx1EsPMmP+U0k4hAACw0rmX2s85v5+D6xgJACiHQOxDIPbEBMEWrwEAwRETsiW+MaXsFd4H33mVLeXSN6zUWl1HkCeMiYnQdQiUi7S1XqDrEFR6B6A6kOH1h046peS3UFtZWfECnXQmr93Kz3ZHXwu2PSLdyKtt71OHlG46pUytjJTSDGEGALBK9+swhYX0twnMARhZmcBEvh2W2XMsUaqVbCqXvmWmug4gTzCx0s0xi3Ini4yz6FRG1x95Z2ABIiIiIiIiIiL6aujkTikiIiLK/VJSBS4/eo0XcQlwsDRBRQ9b6Ovlrrtxcvs25Pb4iYiIKG/TaadUyUmHETHve12GQJTnlJx0GHrGZtL78ODGOoyGiHKrQ6GRCNobhsiYBCnN2doEk5r6oEFJZx1Gprncvg25PX4iIiIiPr5HREREmXIoNBL9N1xX6AwBgKiYBPTfcB2HQiN1FJnmcvs25Pb4iYiIiAB2ShEREVEmpKQKBO0Ng1CxTJ4WtDcMKamqcnwdcvs25Pb4iYiIiOTYKUVEREQau/zotdLdOZ8TACJjEnD50eucCyqTcvs25Pb4iYiIiOTYKUVEREQaexGnvjNEm3y6kNu3IbfHT0RERCSn804p9zH74T5mv67DICIiIg04WJpkaz5dyO3bkNvjJyIiIpLTeacUERER5R4VPWzhbG0CmZrlMnyaAa6ih21OhpUpuX0bcnv8mbF48WJ4eHjAxMQE5cuXx5kzZ3QdEhEREWUjdkoRERGRxvT1ZJjU1AcAlDpF5O8nNfWBvp66LhPdy+3bkNvj19TWrVsxbNgwjB8/Hjdu3EC1atXQsGFDRERE6Do0IiIiyibslCIiIqJMaVDSGUs6lYOTteLjYU7WJljSqRwalHTWUWSay+3bkNvj18TcuXPRs2dP9OrVC97e3pg/fz4KFiyIJUuW6Do0IiIiyiYGug6AiIiIcp8GJZ1R18cJlx+9xou4BDhYfnpcLDfdnZPbtyG3x5+ejx8/4tq1axgzZoxCer169XD+/HmVn0lMTERiYqL0PjY29ovGSERERFnHTikiIiLSir6eDH6edroOI0ty+zbk9vjVefXqFVJSUuDo6KiQ7ujoiKioKJWfmT59OoKCgnIiPCIiIsomfHyPiIiIiL5KMpniXV9CCKU0ubFjxyImJkZ6PXnyJCdCJCIioizgnVJERERE9FWxt7eHvr6+0l1RL168ULp7Ss7Y2BjGxsY5ER4RERFlE94pRURERERfFSMjI5QvXx5Hjx5VSD969Cj8/f11FBURERFlN94pRURERERfnREjRqBz586oUKEC/Pz8sGzZMkRERKBfv366Do2IiIiyCTuliIiIiOir065dO0RHR2Py5MmIjIxEyZIlceDAAbi5uek6NCIiIsom7JQiIiIioq/SgAEDMGDAAF2HQURERF8Ix5QiIiIiIiIiIqIcxzuliIiIdCAlVeDyo9d4EZcAB0sTVPSwhb6e6qnuiYiIiIi+RbxTioiISEPTp0+HTCbDsGHDslTOodBIVJ1xAh2WX8TQLTfRYflFVJ1xAodCI7MnUCIiIiKiXICdUkRERBq4cuUKli1bBl9f3yyVcyg0Ev03XEdkTIJCelRMAvpvuM6OKSIiIiLKM9gpRURElIF3796hY8eOWL58OWxsbLQuJyVVIGhvGISKZfK0oL1hSElVlYOIiIiI6NuiVadUfHx8dsdBRBpg2yPSjYEDB6Jx48aoU6dOhnkTExMRGxur8JK7/Oi10h1SnxMAImMScPnR6+wIm4iIiIjoq6ZVp5SjoyN69OiBs2fPZnc8RJQOtj2inLdlyxZcv34d06dP1yj/9OnTYW1tLb0KFiwoLXsRp75D6nOa5iMiIiIiys206pTavHkzYmJiULt2bXh5eSE4OBjPnj3L7tiIKA22PaKc9eTJEwwdOhQbNmyAiYmJRp8ZO3YsYmJipNeTJ0+kZQ6WmpWhaT4iIiIiotzMQJsPNW3aFE2bNkV0dDTWrVuHNWvWYMKECahfvz569OiBZs2awcBAq6KJKB1se0Q569q1a3jx4gXKly8vpaWkpOD06dNYtGgREhMToa+vr/AZY2NjGBsbqyyvooctnK1NEBWToHJcKRkAJ2sTVPSwzcatIMrbYryDYaWfcb6sanFnk1LaMRRTm/+Hd8r5AeBP2dvsCilDQeEfAQCT3I3U5gl0+1k57fHUTOWnbwiHPCT66mwSo3UdgkoJsYmA9YIM82VpoHM7OzsMHz4ct27dwty5c3Hs2DG0adMGLi4umDhxIt6/f5+V4olIDbY9opxRu3Zt3LlzBzdv3pReFSpUQMeOHXHz5k2lDqmM6OvJMKmpD4BPHVCfk7+f1NQH+npplxIRERERfXuydEtFVFQU1q1bh9WrVyMiIgJt2rRBz5498ezZMwQHB+PixYs4cuRIdsVKRP+PbY8oZ1haWqJkyZIKaebm5rCzs1NK11SDks5Y0qkcgvaGKQx67mRtgklNfdCgpHOWYib6kj58+AAhBMzMzAAAjx8/xq5du+Dj44N69erpODoiIiLKbbTqlNq5cydWr16Nw4cPw8fHBwMHDkSnTp2QL18+KU+ZMmVQtmzZ7IqTiMC2R/StaFDSGXV9nHD50Wu8iEuAg+WnR/Z4hxR97Zo3b45WrVqhX79+ePv2LSpVqgRDQ0O8evUKc+fORf/+/XUdIhEREeUiWnVKde/eHe3bt8e5c+fw3XffqcxTuHBhjB8/PkvBEZEitj0i3Tt16lS2lKOvJ4Ofp122lEWUU65fv4558+YBAHbs2AFHR0fcuHEDf/zxByZOnMhOKSIiIsoUrTqlIiMjpdu21TE1NcWkSZO0CoqIVGPbI8qcv//+G6dOncKLFy+QmpqqsGzixIk6iooo93r//j0sLS0BAEeOHEGrVq2gp6eHypUr4/HjxzqOjoiIiHIbrTqlLC0tERkZCQcHB4X06OhoODg4ICUlJVuCIyJFbHtEmlu+fDn69+8Pe3t7ODk5QSb736NxMpmMnVJEWihSpAh2796Nli1b4vDhwxg+fDgA4MWLF7CystJxdERERJTbaNUpJYTquUATExNhZKR+Slkiyhq2PSLNTZ06Fb/88gt++uknXYdC9M2YOHEifvjhBwwfPhy1a9eGn58fgE93TXE8QyIiIsqsTHVK/frrrwA+/Yd5xYoVsLCwkJalpKTg9OnTKF68ePZGSERse0RaePPmDb7//ntdh0H0TWnTpg2qVq2KyMhIlC5dWkqvXbs2WrZsqcPIiIiIKDfKVKeUfGBLIQSWLl0KfX19aZmRkRHc3d2xdOlSrQJxH7Mf4cGNtfos0bfuS7Y9om/V999/jyNHjqBfv366DoXom+Lk5AQnJyeFtIoVK+ooGiIiIsrNMtUp9ejRIwBAzZo1sXPnTtjY2HyRoIhIEdseUeYVKVIEEyZMwMWLF1GqVCkYGhoqLB8yZIiOIiPKveLj4xEcHIzjx4+rnEDg33//1VFkRERElBtpNabUyZMnszsOItIA2x6R5pYtWwYLCwuEhIQgJCREYZlMJmOnFJEWevXqhZCQEHTu3BnOzs4KEwgQERERZZbGnVIjRozAlClTYG5ujhEjRqSbd+7cuVkOjIg+Ydsj0o78DkMiyj4HDx7E/v37UaVKFa3LqF+/Ps6ePYv3799DJpPB0dERq1atQsOGDaU8RYoUwcOHDxU+Z25ujnfv3mm9XiIiIvr6aNwpdePGDSQlJUl/q8P/mBFlL7Y9oqyTz1zJdkKUNTY2NrC1tc1SGdeuXUOHDh3QtGlTJCYmYvDgwWjatCmePXsGBwcHKZ+9vT2OHz8uvTc3N8/SeomIiOjro3Gn1OePDfERIqKcw7ZHpL1169Zh1qxZePDgAQDAy8sLP/74Izp37qzjyIhypylTpmDixIlYu3YtzMzMtCrj1atXCu9LlSoFHx8fbN26FYMHD5bSDQwM4Ovrm6V4iYiI6Oum1ZhSREREX7u5c+diwoQJGDRoEKpUqQIhBM6dO4d+/frh1atXGD58uK5DJMp15syZg4cPH8LR0RHu7u5KEwhcv34902U+e/YMAODq6qqQHhUVBT09PRgYGKBw4cL4448/UKJECbXlxMbGIjY2VnofFxeX6ViIiIgoZ2ncKdWqVSuNC925c6dWwRCRMrY9Iu0sXLgQS5YsQZcuXaS05s2bo0SJEggMDGSnFJEWWrRoka3lpaamomPHjrCyskLLli2l9MaNG8PGxgalS5fG9evXMXv2bJQvXx4vXryAlZWVyrKaNWumNKkBERERfd007pSytrb+knEQkRpse0TaiYyMhL+/v1K6v78/IiMjdRARUe43adKkbC2vdOnSePXqFS5cuKCQvmDBAunvli1bonXr1ihbtiymTp2KmTNnqixrz549SndK+fj4ZGu8RERElL007pRavXr1l4yDiNRg2yPSTpEiRbBt2zaMGzdOIX3r1q0oWrSojqIi+jZcu3YN9+7dg0wmg4+PD8qWLZvpMnx9fXHv3j2cOHEC3333Xbp5y5QpA0NDQ9y5c0dtHisrK4W7qD7voCIiIqKvE8eUIiKib1JQUBDatWuH06dPo0qVKpDJZDh79iyOHz+Obdu26To8olzpxYsXaN++PU6dOoV8+fJBCIGYmBjUrFkTW7ZsQf78+TMsIzU1FWXKlMHdu3dx6NAhVK9ePcPPPHjwAElJSShYsGB2bAYRERF9JTTulCpXrhyOHz8OGxsblC1bNt1ptbUZ5JKIVGPbI9JO69atcenSJcybNw+7d++GEAI+Pj64fPmyVnd1EBEwePBgxMbG4u7du/D29gYAhIWFoWvXrhgyZAg2b96cYRm+vr64e/cu5s+fD0dHR9y+fRvAp4HObW1tERUVhSZNmqBPnz7w8fHB1atXMWHCBOjp6SEwMPBLbh4RERHlMI07pZo3bw5jY2MA2T/IJRGpx7ZHpL3y5ctjw4YNug6D6Jtx6NAhHDt2TOqQAgAfHx/89ttvqFevnkZl3L17FwAwbNgwhfSePXtixYoVMDIyQnh4OPr16wchBPT19eHu7o6NGzfCxcUl27aFiIiIdE/jTqnPB7bM7kEuiUg9tj0izcXGxkpjymQ0noy6GbyISL3U1FQYGhoqpRsaGiI1NVWjMoQQ6S63tbXFq1evtIqPiIiIcpcsjSl19epVaZBLb29vlC9fPrviIqJ0sO0RqWZjY4PIyEg4ODggX758Kh93FUJAJpMhJSVFBxES5W61atXC0KFDsXnzZumupf/++w/Dhw9H7dq1dRwdERER5TZadUo9ffoUHTp0wLlz55AvXz4AwNu3b+Hv74/NmzdzEEqiL4Rtjyh9J06cgK2tLQDg5MmTOo6G6NuzaNEiNG/eHO7u7ihYsCBkMhkiIiJQqlQpPipLREREmaZVp1SPHj2QlJSEe/fuoVixYgCA+/fvo0ePHujZsyeOHDmSrUES0Sdse0TpCwgIkP728PCQfjR/TgiBJ0+e5HRoRN+EggUL4vr16zh69Cj++usvaQKBOnXq6Do0IiIiyoW06pQ6c+YMzp8/L/0oBoBixYph4cKFqFKlSrYFR0SK2PaINOfh4SE9yve5169fw8PDg4/vEWVB3bp1UbduXV2HQURERLmcVp1ShQoVQlJSklJ6cnIyChQokOWgiEg1tj0izcnHjkrr3bt3MDEx0UFERLnTr7/+ij59+sDExAS//vprunmHDBmSQ1ERERHRt0CrTqmZM2di8ODB+O2331C+fHnIZDJcvXoVQ4cOxezZs7M7RiL6f2x7RBkbMWIEAEAmk2HChAkwMzOTlqWkpODSpUsoU6aMjqIjyn3mzZuHjh07wsTEBPPmzVObTyaTsVOKiIiIMkXjTikbGxuF/zjHx8ejUqVKMDD4VERycjIMDAzQo0cPtGjRItsDJcqr2PaIMufGjRsAPt0pdefOHRgZGUnLjIyMULp0aYwaNUpX4RHlOo8ePVL5NxEREVFWadwpNX/+/C8YBhGpw7ZHlDnyWfe6d++OBQsWwMrKSscREX07Jk+ejFGjRincgQgAHz58wKxZszBx4kQdRUZERES5kcadUl27dv2ScRCRGmx7RNpZvXq1rkMg+uYEBQWhX79+Sp1S79+/R1BQEDuliIiIKFO0GlPqcx8+fFAaeJn/lSb68tj2iDJ25coVbN++HREREfj48aPCsp07d2b4+enTp2Pnzp3466+/YGpqCn9/f8yYMUNhBkyivETdBAK3bt2Cra2tDiIiIiKi3ExPmw/Fx8dj0KBBcHBwgIWFBWxsbBReRPRlsO0RaW7Lli2oUqUKwsLCsGvXLiQlJSEsLAwnTpyAtbW1RmWEhIRg4MCBuHjxIo4ePYrk5GTUq1cP8fHxXzh6oq+LjY0NbG1tIZPJ4OXlBVtbW+llbW2NunXrom3btroOk4iIiHIZre6UGj16NE6ePInFixejS5cu+O233/Dff//h999/R3BwcHbHSET/j22PSHPTpk3DvHnzMHDgQFhaWmLBggXw8PBA37594ezsrFEZhw4dUni/evVqODg44Nq1a6hevfqXCJvoqzR//nwIIdCjRw8EBQUpdOwaGRnB3d0dfn5+OoyQiIiIciOtOqX27t2LdevWoUaNGujRoweqVauGIkWKwM3NDRs3bkTHjh2zO04iAtseUWY8fPgQjRs3BgAYGxsjPj4eMpkMw4cPR61atRAUFJTpMmNiYgCAjylRniMf39DDwwP+/v4wNDTUcURERET0LdDq8b3Xr1/Dw8MDwKcxbF6/fg0AqFq1Kk6fPp190RGRArY9Is3Z2toiLi4OAFCgQAGEhoYCAN6+fYv3799nujwhBEaMGIGqVauiZMmSavMlJiYiNjZW4UX0rQgICJA6pD58+MB9nYiIiLJEq06pwoULIzw8HADg4+ODbdu2Afh0F0e+fPmyKzYiSoNtj0hz1apVw9GjRwEAbdu2xdChQ9G7d2906NABtWvXznR5gwYNwu3bt7F58+Z0802fPh3W1tbSq2DBglrFT/Q1ev/+Pcc2JCIiomyjVadU9+7dcevWLQDA2LFjsXjxYhgbG2P48OH48ccfszVAIvoftj0izS1atAjt27cH8Km9jBo1Cs+fP0erVq2wcuXKTJU1ePBg7NmzBydPnoSrq2u6eceOHYuYmBjp9eTJE623gehr8+OPP+LEiRPS+WfFihUICgqCi4sL1q1bp+vwiIiIKJfRakyp4cOHS3/XrFkT9+7dw7Vr1+Dp6YnSpUtnW3BEpIhtj0gzycnJ2Lt3L+rXrw8A0NPTw+jRozF69OhMlSOEwODBg7Fr1y6cOnVKenw2PcbGxjA2NtYqbqKvHcc2JCIiouykVadUWm5ubnBzc8uOoogoE9j2iFQzMDBA//79ce/evSyVM3DgQGzatAl//vknLC0tERUVBQCwtraGqalpdoRKlKukN7Zh//79dRkaERER5UJaPb4HAMePH0eTJk3g6emJIkWKoEmTJjh27Fh2xkZEKrDtEWmmUqVKuHHjRpbKWLJkCWJiYlCjRg04OztLr61bt2ZTlES5C8c2JCIiouykVafUokWL0KBBA1haWmLo0KEYMmQIrKys0KhRIyxatCi7YySi/8e2R6S5AQMGYOTIkVi0aBEuXLiA27dvK7w0IYRQ+erWrduXDZ7oK8WxDYmIiCg7afX43vTp0zFv3jwMGjRIShsyZAiqVKmCX375RSGdiLIP2x6R5tq1awfgUxuRk8lkEEJAJpMhJSVFV6ER5Vppxzb866+/cPXq1UyNbVijRg2EhIQopOnp6UltMjU1FbVq1cKZM2eQmpoKa2trrF27Fs2bN8++DSEiIqKvgladUrGxsWjQoIFSer169fDTTz9lOSgiUo1tj0hzjx490nUIRN+UpKQk1KtXD7///ju8vLwAAIUKFUKhQoUyXZaxsTEuX74svTc0NJT+bty4MUJCQvDjjz/Cz88PQ4cORatWrfDkyRO4uLhkfUOIiIjoq6FVp1SzZs2wa9cupdu0//zzTzRt2jRbAiMiZWx7RJrjJABE2cvQ0BChoaGQyWRZLksmk8HX11cpPTU1FUeOHEGDBg0wc+ZMAEDt2rVhbW2NH3/8ERs3bszyuomIiOjroXGn1K+//ir97e3tjV9++QWnTp2Cn58fAODixYs4d+4cRo4cmf1REuVhbHtE2lm3bl26y7t06ZJDkRB9O7p06YKVK1ciODg4S+UkJCRAX18fenp6cHZ2xrp161CjRg2cPn0aqampCu3TysoKTk5OuHjxYlbDJyIioq+Mxp1S8+bNU3hvY2ODsLAwhIWFSWn58uXDqlWr8PPPP2dfhER5HNsekXaGDh2q8D4pKQnv37+HkZERzMzM2ClFpIWPHz9ixYoVOHr0KCpUqABzc3OF5XPnzs2wjFq1auG7775D5cqV8fDhQ0ybNg21a9fGX3/9hfv37wMAihUrpvCZfPny4eXLl+mWGxsbi9jYWOl9XFycpptFREREOqJxpxTH5iDSDbY9Iu28efNGKe3Bgwfo378/Zwkj0lJoaCjKlSsHAPj7778Vlmn6WN/EiRMV3nfr1g3Ozs4YNWoUGjVqBODTwOefE0JkWG6zZs2UBlAnIiKir5tWY0p9Tn6RkB3jCxCR5tj2iDKvaNGiCA4ORqdOnfDXX3/pOhyiXOfkyZPZXqaDgwPy5cuHf/75R7pD6t69eyhTpoyUJyYmBtbW1umWs2fPHqU7pXx8fLI9XiIiIso+ehlnUW3dunUoVaoUTE1NYWpqCl9fX6xfvz47YyMiFdj2iLJGX18fz54903UYRLnaP//8g8OHD+PDhw8ANLuTSZ3Y2Fi8ffsWjo6OqF69OvT09BTOa+/evUNUVBQqV66cbjlWVlZwdXWVXgUKFNA6JiIiIsoZWt0pNXfuXEyYMAGDBg1ClSpVIITAuXPn0K9fP7x69QrDhw/P7jiJCGx7RJmxZ88ehfdCCERGRmLRokWoUqWKjqIiyt2io6PRtm1bnDx5EjKZDA8ePEDhwoXRq1cv5MuXD3PmzMmwjAoVKqBz584oW7YsHjx4gHHjxiE1NRVTpkyBnp4e6tWrh4MHD+Knn35C5cqVMXz4cOjp6WHWrFk5sIVERESUk7TqlFq4cCGWLFmiMEhs8+bNUaJECQQGBvKHMdEXwrZHpLkWLVoovJfJZMifPz9q1aql0Q9nIlI2fPhwGBoaIiIiAt7e3lJ6u3btMHz4cI3a1osXLzBixAikpqZCT08PTk5O+PPPP6XO4v3796NWrVqYPXs2UlNTYW1tjR07dsDFxeWLbRcRERHphladUpGRkfD391dK9/f3R2RkZJaDIiLV2PaINJeamqrrEIi+OUeOHMHhw4fh6uqqkF60aFE8fvxYozIiIiLSXa6np4dTp05pGyIRERHlIlp1ShUpUgTbtm3DuHHjFNK3bt2KokWLah2M+5j9AIDw4MZal0H0LftSbY/oWzFixAiN82oydT0RKYqPj4eZmZlS+qtXr2BsbKyDiIiIiCg306pTKigoCO3atcPp06dRpUoVyGQynD17FsePH8e2bduyO0Yi+n9se0Tpu3HjhsL7a9euISUlRZrR6++//4a+vj7Kly+vi/CIcr3q1atj3bp1mDJlCoBPj8WmpqZi1qxZqFmzpo6jIyIiotxGq06p1q1b4/Lly5g7dy52794NIQR8fHxw+fJllC1bNrtjJKL/x7ZHlL7Pp6ufO3cuLC0tsXbtWtjY2AAA3rx5g+7du6NatWq6CpEoV5s1axZq1KiBq1ev4uPHjxg9ejTu3r2L169f49y5c7oOj4iIiHKZTHdKJSUloU+fPpgwYQI2bNjwJWIiIhXY9ogyZ86cOThy5IjUIQUANjY2mDp1KurVq4eRI0fqMDqi3MnHxwe3b9/GkiVLoK+vj/j4eLRq1QoDBw6Es7OzrsMjIiKiXEYvsx8wNDTErl27vkQsRJQOtj2izImNjcXz58+V0l+8eIG4uDgdRESU+0VERMDR0RFBQUHYt28fDhw4gKlTp8LZ2TnDAcyJiIiI0sp0pxQAtGzZErt3787mUIgoI2x7RJpr2bIlunfvjh07duDp06d4+vQpduzYgZ49e6JVq1a6Do8oV/Lw8MDLly+V0qOjo+Hh4aGDiIiIiCg303r2vSlTpuD8+fMoX748zM3NFZYPGTIkW4IjIkVse0SaW7p0KUaNGoVOnTohKSkJAGBgYICePXti1qxZOo6OKHcSQkAmkymlv3v3DiYmJjqIiIiIiHIzrTqlVqxYgXz58uHatWu4du2awjKZTJblH8buY/YjPLhxlsog+hZ96bZH9C0xMzPD4sWLMWvWLDx8+BBCCBQpUkSpM5eIMjZixAgAn841EyZMgJmZmbQsJSUFly5dQpkyZXQUHREREeVWWnVKPXr0SPpbCAEAKv9rRkTZi22PKPPMzc3h6+ur6zCIcrUbN24A+HTuuXPnDoyMjKRlRkZGKF26NEaNGqWr8IiIiCiX0qpTCgBWrlyJefPm4cGDBwCAokWLYtiwYejVq1e2BOY+Zj8A8I4pojS+dNsjIiJK6+TJkwCA7t2749dff4WlpaWOIyKinDDpwUytPhdUdHQ2R0JE3yqtOqUmTJiAefPmYfDgwfDz8wMAXLhwAcOHD0d4eDimTp2arUES0Sdse0REpAufTw7QtWtXtfl27tyZE+EQERHRN0KrTqklS5Zg+fLl6NChg5TWrFkz+Pr6YvDgwfxhTPSFsO0REZEuWFtb6zoEIiIi+gZp1SmVkpKCChUqKKWXL18eycnJWQ6KiFT7Em1P/qhsWnx0loiI5FavXq3rEIiIiOgbpKfNhzp16oQlS5YopS9btgwdO3bMclBEpBrbHhEREREREX0rsjTQ+ZEjR1C5cmUAwMWLF/HkyRN06dJFmjYYAObOnZv1KIlIwrZHRERERERE3wKtOqVCQ0NRrlw5AMDDhw8BAPnz50f+/PkRGhoq5eNU9UTZi22PiIiIiIiIvhVadUrJpwUmopzFtkdERERERETfCq3GlCIiIspLFi9eDA8PD5iYmKB8+fI4c+aMrkMiIiIiIsr12ClFRESUjq1bt2LYsGEYP348bty4gWrVqqFhw4aIiIjQdWhERERERLnaV98p5T5mv9op64mIiL60uXPnomfPnujVqxe8vb0xf/58FCxYUOVMmEREREREpLmvvlOKiIhIVz5+/Ihr166hXr16Cun16tXD+fPnVX4mMTERsbGxCi8iIiIiIlKWazqleLcUERHltFevXiElJQWOjo4K6Y6OjoiKilL5menTp8Pa2lp6FSxYMCdCJco1DAwMIJPJlF6lSpUCABQpUkRpmYWFhY6jJiIioi9Bq9n3iOjbp6ojODy4sQ4iIdI9mUym8F4IoZQmN3bsWIwYMUJ6Hxsby44pos/cuXMHSUlJ0vtDhw7hp59+Qs+ePaU0e3t7HD9+XHpvbm6eozESERFRzmCnFBERkRr29vbQ19dXuivqxYsXSndPyRkbG8PY2DgnwiPKlby9vRXed+3aFQYGBhgyZIiUZmBgAF9f35wOjYiIiHJYrnl8j4iIKKcZGRmhfPnyOHr0qEL60aNH4e/vr6OoiL4d7969w61bt1CzZk3o6f3vsjQqKgp6enowMjJC8eLFcffu3QzLio2NxdOnT6XXf//99yVDJyIiomzAO6WIiIjSMWLECHTu3BkVKlSAn58fli1bhoiICPTr10/XoRHlehMmTIAQAsHBwVJa48aNYWNjg9KlS+P69euYPXs2ypcvjxcvXsDKykptWc2aNUNISEhOhE1ERETZhJ1SRERE6WjXrh2io6MxefJkREZGomTJkjhw4ADc3Nx0HRpRrrd+/Xo4ODigXLlyUtqCBQukv1u2bInWrVujbNmymDp1KmbOnKm2rD179ijMdhkXFwcfH58vEzgRERFli1zVKZV24GUOukyUszj4OeVVAwYMwIABA3QdBtE35dy5c4iOjsbYsWPTzVemTBkYGhrizp076eazsrJSuJPq8w4qIiIi+jpxTCkiIiIiynHjx4+Hnp4eJk6cmG6+Bw8eICkpibNYEhERfYPYKUVEREREOSo5ORlnz57Fd999BxMTEyk9KioKFSpUwLJly3D27FnMnz8f5cqVg56eHgIDA3UXMBEREX0RuerxvbTcx+zno0NEREREucysWbOQkpKCoKAghXQjIyOEh4ejX79+EEJAX18f7u7u2LhxI1xcXHQULREREX0pubpTClA9xo0q7LwiIiIi+jqMHTtW5VhStra2ePXqlQ4iIiIiIl3I9Z1SmtK08wpgBxYRERERERER0ZeWZzqlMoN3XxFlDWfpIyIiIiIiooywUyoLMuq84o9wov9R117YToiIiIiIiPImdkp9QZl5ZDC78Ac+EREREREREeUG7JT6xmRXRxg7t0hTuuh8JSIiIiIiotyPnVKkUnZ3NLCTizKDY1IRERERERF9+9gpRUQ6pWkHaFYnIGBHFxERERER0deFnVKUI7Lzzit2JFB6cupxwsx0crFDjIiIiIiISJlOOqWEEACA1MT3ulg95XKFhm/X+rOhQfURGxsL4H/7YV7BdqcsK/tSVsuT74cZKTnpsLbhqBUaVD9H1pOWfN/Lq21P0++cKLvl9fNebErOrC8pNrvOrx8AAO+k9wmIB/AxNgEJSPyUFJe9x5NE+R8qyk2ITVRKS2/9KvNTrhX7LuM8qnA/IKLE/z8OZHT9IRM6uEJ5+vQpChYsmNOrJVLw5MkTuLq66jqMHMN2R18Ltj0i3chrbe/ff/+Fp6enrsMgIiLK0zK6/tBJp1Rqairu378PHx8fPHnyBFZWVjkdwjchNjYWBQsWZB1mkhACcXFxcHFxgZ6enq7DyTGpqal49uwZLC0tIZPJdB1OjmJb+TrqgG1Pue19Dd8LffvfQ15te2/fvoWNjQ0iIiJgbW2t63BypW+9bXxprL+sYf1lHeswa1h/WaPp9YdOHt/T09NDgQIFAABWVlb8grOIdZh5efHiVE9PL0/9h1wVthXd1wHbnmq6/l7ok2/5e8irbQ/4tO3f6veaU77ltpETWH9Zw/rLOtZh1rD+tKfJ9Ufe+XcZERERERERERF9NdgpRUREREREREREOU5nnVLGxsaYNGkSjI2NdRVCrsc6JNIM2wrr4GvF7+XrwO/h28TvNetYh1nD+ssa1l/WsQ6zhvWXM3Qy0DkREREREREREeVtfHyPiIiIiIiIiIhyHDuliIiIiIiIiIgox7FTioiIiIiIiIiIcpzOOqUWL14MDw8PmJiYoHz58jhz5oyuQvnqBQYGQiaTKbycnJyk5UIIBAYGwsXFBaampqhRowbu3r2rw4iJdCOvtZXTp0+jadOmcHFxgUwmw+7duxWWa7K9iYmJGDx4MOzt7WFubo5mzZrh6dOnObgVeRvPhTknrx0fiO1LHZ47smb69On47rvvYGlpCQcHB7Ro0QL3799XyMM6VG/JkiXw9fWFlZUVrKys4Ofnh4MHD0rLWXeZM336dMhkMgwbNkxKYx2mLzuuB/Jy/X0JOumU2rp1K4YNG4bx48fjxo0bqFatGho2bIiIiAhdhJMrlChRApGRkdLrzp070rKZM2di7ty5WLRoEa5cuQInJyfUrVsXcXFxOoyYSDfyUluJj49H6dKlsWjRIpXLNdneYcOGYdeuXdiyZQvOnj2Ld+/eoUmTJkhJScmpzcizeC7MeXnp+JDXsX2px3NH1oSEhGDgwIG4ePEijh49iuTkZNSrVw/x8fFSHtaheq6urggODsbVq1dx9epV1KpVC82bN5d+9LPuNHflyhUsW7YMvr6+Cumsw4xl9Xogr9dfthM6ULFiRdGvXz+FtOLFi4sxY8boIpyv3qRJk0Tp0qVVLktNTRVOTk4iODhYSktISBDW1tZi6dKlORQh0dchL7cVAGLXrl3Se0229+3bt8LQ0FBs2bJFyvPff/8JPT09cejQoRyLPa/iuTBn5eXjQ17E9qUZnjuy7sWLFwKACAkJEUKwDrVhY2MjVqxYwbrLhLi4OFG0aFFx9OhRERAQIIYOHSqE4P6niaxeD+T1+vsScvxOqY8fP+LatWuoV6+eQnq9evVw/vz5nA4n13jw4AFcXFzg4eGB9u3b499//wUAPHr0CFFRUQr1aWxsjICAANYn5UlsK59osr3Xrl1DUlKSQh4XFxeULFnym6yTrwnPhbrB40PewPalPZ47Mi8mJgYAYGtrC4B1mBkpKSnYsmUL4uPj4efnx7rLhIEDB6Jx48aoU6eOQjrrUDNZuR5g/WW/HO+UevXqFVJSUuDo6KiQ7ujoiKioqJwOJ1eoVKkS1q1bh8OHD2P58uWIioqCv78/oqOjpTpjfRKxrXxOk+2NioqCkZERbGxs1OahL4PnwpzH40PewfalPZ47MkcIgREjRqBq1aooWbIkANahJu7cuQMLCwsYGxujX79+2LVrF3x8fFh3GtqyZQuuX7+O6dOnKy1jHWYsq9cDeb3+vgQDXa1YJpMpvBdCKKXRJw0bNpT+LlWqFPz8/ODp6Ym1a9eicuXKAFifRADbiirabO+3Xidfk7y2P+oSjw95D79P7fHcoZlBgwbh9u3bOHv2rNIy1qF6xYoVw82bN/H27Vv88ccf6Nq1K0JCQqTlrDv1njx5gqFDh+LIkSMwMTFRm491qN6Xuh7IK/X3JeT4nVL29vbQ19dX6kV88eKFUo8kqWZubo5SpUrhwYMH0kwBrE8iZXm5rWiyvU5OTvj48SPevHmjNg99GTwX6l5ePj5869i+tMdzh+YGDx6MPXv24OTJk3B1dZXSWYcZMzIyQpEiRVChQgVMnz4dpUuXxoIFC1h3Grh27RpevHiB8uXLw8DAAAYGBggJCcGvv/4KAwMDqQ5Yh5rL7PUA6y/75XinlJGREcqXL4+jR48qpB89ehT+/v45HU6ulJiYiHv37sHZ2RkeHh5wcnJSqM+PHz8iJCSE9Ul5Xl5uK5psb/ny5WFoaKiQJzIyEqGhod9knXxNeC7Uvbx8fPjWsX1pj+eOjAkhMGjQIOzcuRMnTpyAh4eHwnLWYeYJIZCYmMi600Dt2rVx584d3Lx5U3pVqFABHTt2xM2bN1G4cGHWYSZl9nqA9fcF5Oiw6v9vy5YtwtDQUKxcuVKEhYWJYcOGCXNzcxEeHq6LcL56I0eOFKdOnRL//vuvuHjxomjSpImwtLSU6is4OFhYW1uLnTt3ijt37ogOHToIZ2dnERsbq+PIiXJWXmsrcXFx4saNG+LGjRsCgJg7d664ceOGePz4sRBCs+3t16+fcHV1FceOHRPXr18XtWrVEqVLlxbJycm62qw8g+fCnJXXjg95HduXejx3ZE3//v2FtbW1OHXqlIiMjJRe79+/l/KwDtUbO3asOH36tHj06JG4ffu2GDdunNDT0xNHjhwRQrDutPH57HtCsA4zkh3XA3m5/r4EnXRKCSHEb7/9Jtzc3ISRkZEoV66cNI0qKWvXrp1wdnYWhoaGwsXFRbRq1UrcvXtXWp6amiomTZoknJychLGxsahevbq4c+eODiMm0o281lZOnjwpACi9unbtKoTQbHs/fPggBg0aJGxtbYWpqalo0qSJiIiI0MHW5E08F+acvHZ8ILYvdXjuyBpVdQdArF69WsrDOlSvR48eUrvMnz+/qF27ttQhJQTrThtpO6VYh+nLjuuBvFx/X4JMCCFy+u4sIiIiIiIiIiLK23J8TCkiIiIiIiIiIiJ2ShERERERERERUY5jpxQREREREREREeU4dkoREREREREREVGOY6cUERERERERERHlOHZKERERERERERFRjmOnFBERERERERER5Th2ShERERERERERUY5jp1Q2WbNmDfLlyye9DwwMRJkyZTJVhkwmw+7du9UuDw8Ph0wmw82bN7WK8Us7deoUZDIZ3r59q+tQSAu5eR9OG7suuLu7Y/78+Tmyrs6dO2PatGnS+/fv36N169awsrLKlW1w3759KFu2LFJTU3UdCmmoRo0aGDZsmK7DUJDR8YeIiJRpc72XnSZMmIA+ffpI74UQ6NOnD2xtbb/q3z3q3LlzB66uroiPj9d1KES5BjuliIgyQV0H2JUrVxQuqr6U27dvY//+/Rg8eLCUtnbtWpw5cwbnz59HZGQkrK2tv3gc2alJkyaQyWTYtGmTrkMhDe3cuRNTpkwBkLMdsoD6H1CRkZFo2LBhjsVBRPS1k8lk6b66deuGUaNG4fjx4zqJ7/nz51iwYAHGjRsnpR06dAhr1qzBvn37EBkZiZIlS+okNm2VKlUKFStWxLx583QdClGuwU6pPC4lJYV3JxAB+PjxY5Y+nz9/fpiZmWVTNOotWrQI33//PSwtLaW0hw8fwtvbGyVLloSTkxNkMpnS57K6fV9a9+7dsXDhQl2HQRqytbVV2AezQ1b3UScnJxgbG2dTNEREuV9kZKT0mj9/PqysrBTSFixYAAsLC9jZ2ekkvpUrV8LPzw/u7u5S2sOHD+Hs7Ax/f384OTnBwMBA6XO54ZpmyZIlSElJ0XUoRLkCO6U+s2PHDpQqVQqmpqaws7NDnTp1EB8fj9OnT8PQ0BBRUVEK+UeOHInq1atrVPaVK1dQt25d2Nvbw9raGgEBAbh+/bpSPvl/ek1NTeHh4YHt27enW25YWBgaNWoECwsLODo6onPnznj16pXa/PK7PPbt2wcfHx8YGxvj8ePHGsUnk8mwYsUKtGzZEmZmZihatCj27Nmjdl0fPnxA48aNUblyZbx+/TqDGqLskBf2YeDTflyoUCGYmZmhZcuWiI6OVljerVs3tGjRQiFt2LBhqFGjhvS+Ro0aGDRoEEaMGAF7e3vUrVsXADB37lyUKlUK5ubmKFiwIAYMGIB3794B+PSIavfu3RETEyP9lzEwMBCA8t0iERERaN68OSwsLGBlZYW2bdvi+fPn0nL53R7r16+Hu7s7rK2t0b59e8TFxand7tTUVGzfvh3NmjVT2I45c+bg9OnTkMlk0ja6u7tj6tSp6NatG6ytrdG7d28AwE8//QQvLy+YmZmhcOHCmDBhApKSkpTiWrVqFQoVKgQLCwv0798fKSkpmDlzJpycnODg4IBffvlFIbaYmBj06dMHDg4OsLKyQq1atXDr1i1p+a1bt1CzZk1YWlrCysoK5cuXx9WrV6XlzZo1w+XLl/Hvv/+q3X76esgf36tRowYeP36M4cOHS21C7vz586hevTpMTU1RsGBBDBkyROFxBm320TVr1iAoKAi3bt2S1rdmzRoAyo/v3blzB7Vq1ZKOh3369JHaMvC/48Ts2bPh7OwMOzs7DBw4UKE9EBHlZk5OTtLL2toaMplMKS3t3afyY+O0adPg6OiIfPnyISgoCMnJyfjxxx9ha2sLV1dXrFq1SmFd//33H9q1awcbGxvY2dmhefPmCA8PTze+LVu2KFzTdOvWDYMHD0ZERARkMpnUWaXNNRug+LunWLFiMDMzQ5s2bRAfH4+1a9fC3d0dNjY2GDx4sEIH0sePHzF69GgUKFAA5ubmqFSpEk6dOiUtf/z4MZo2bQobGxuYm5ujRIkSOHDggLS8fv36iI6ORkhIiKZfFVGexk6p/xcZGYkOHTqgR48euHfvHk6dOoVWrVpBCIHq1aujcOHCWL9+vZQ/OTkZGzZsQPfu3TUqPy4uDl27dsWZM2dw8eJFFC1aFI0aNVL6ATphwgS0bt0at27dQqdOndChQwfcu3dPbcwBAQEoU6YMrl69ikOHDuH58+do27ZturG8f/8e06dPx4oVK3D37l04ODhoHF9QUBDatm2L27dvo1GjRujYsaPKDqeYmBjUq1cPHz9+xPHjx2Fra6tRPZH28so+fOnSJfTo0QMDBgzAzZs3UbNmTUydOlWjbUhr7dq1MDAwwLlz5/D7778DAPT09PDrr78iNDQUa9euxYkTJzB69GgAgL+/v9J/GkeNGqVUrhACLVq0wOvXrxESEoKjR4/i4cOHaNeunUK+hw8fYvfu3di3bx/27duHkJAQBAcHq4339u3bePv2LSpUqCCl7dy5E71794afnx8iIyOxc+dOadmsWbNQsmRJXLt2DRMmTAAAWFpaYs2aNQgLC8OCBQuwfPlypVvMHz58iIMHD+LQoUPYvHkzVq1ahcaNG+Pp06cICQnBjBkz8PPPP+PixYvS9jZu3BhRUVE4cOAArl27hnLlyqF27drS8aFjx45wdXXFlStXcO3aNYwZMwaGhobSOt3c3ODg4IAzZ85k/MXRV2Pnzp1wdXXF5MmTpTYBfOoQql+/Plq1aoXbt29j69atOHv2LAYNGqTw+czuo+3atcPIkSNRokQJaX1p2xXw6TzXoEED2NjY4MqVK9i+fTuOHTumtP6TJ0/i4cOHOHnyJNauXYs1a9ZInVxERHnViRMn8OzZM5w+fRpz585FYGAgmjRpAhsbG1y6dAn9+vVDv3798OTJEwCfjrk1a9aEhYUFTp8+jbNnz8LCwgINGjRQe1fTmzdvEBoaqnBNs2DBAkyePBmurq6IjIzElStXpGWZvWaTe//+PX799Vds2bIFhw4dkq6PDxw4gAMHDmD9+vVYtmwZduzYIX2me/fuOHfuHLZs2YLbt2/j+++/R4MGDfDgwQMAwMCBA5GYmIjTp0/jzp07mDFjBiwsLKTPGxkZoXTp0rymIdKUICGEENeuXRMARHh4uMrlM2bMEN7e3tL73bt3CwsLC/Hu3TshhBCrV68W1tbW0vJJkyaJ0qVLq11fcnKysLS0FHv37pXSAIh+/fop5KtUqZLo37+/EEKIR48eCQDixo0bQgghJkyYIOrVq6eQ/8mTJwKAuH//vsr1rl69WgAQN2/eVBtbevH9/PPP0vt3794JmUwmDh48KIQQ4uTJkwKA+Ouvv0Tp0qVFq1atRGJiYrrroeyTV/bhDh06iAYNGiiktWvXTiH2rl27iubNmyvkGTp0qAgICJDeBwQEiDJlyqjdPrlt27YJOzs76X3aepJzc3MT8+bNE0IIceTIEaGvry8iIiKk5Xfv3hUAxOXLl4UQn+rXzMxMxMbGSnl+/PFHUalSJbWx7Nq1S+jr64vU1NR0t00eT4sWLTLcvpkzZ4ry5ctL71XFVb9+feHu7i5SUlKktGLFionp06cLIYQ4fvy4sLKyEgkJCQple3p6it9//10IIYSlpaVYs2ZNurGULVtWBAYGZhgz6V5AQIAYOnSoEEJx35fr3Lmz6NOnj0LamTNnhJ6envjw4YP0OW33UVXHJgBi165dQgghli1bJmxsbKTjmxBC7N+/X+jp6YmoqCghxKfjhJubm0hOTpbyfP/996Jdu3YZxkRElNuou35Je0yVHxvTnvOrVasmvU9OThbm5uZi8+bNQgghVq5cKYoVK6ZwfZKYmChMTU3F4cOHVcZz48YNAUDhWkkIIebNmyfc3NwU0rJyzQZA/PPPP1Ja3759hZmZmYiLi5PS6tevL/r27SuEEOKff/4RMplM/Pfffwpl165dW4wdO1YIIUSpUqUyvF5p2bKl6NatW4YxE5EQvFPq/5UuXRq1a9dGqVKl8P3332P58uV48+aNtLxbt274559/pDsDVq1ahbZt28Lc3Fyj8l+8eIF+/frBy8sL1tbWsLa2xrt37xAREaGQz8/PT+m9urtMrl27hpMnT8LCwkJ6FS9eHMCnOx3UMTIygq+vr1bxff45c3NzWFpa4sWLFwp56tSpg8KFC2Pbtm0wMjJSGwdlr7yyD9+7d0/lOrTx+X/n5E6ePIm6deuiQIECsLS0RJcuXRAdHZ2pWVTu3buHggULomDBglKaj48P8uXLp1AX7u7uCuPyODs7K7Wnz3348AHGxsYqx4xSRdX27dixA1WrVoWTkxMsLCwwYcIEpe8wbVyOjo7w8fGBnp6eQpo81mvXruHdu3ews7NT+C4fPXokfY8jRoxAr169UKdOHQQHB6v8fk1NTfH+/XuNto2+bteuXcOaNWsU9of69esjNTUVjx49kvJpu49m5N69eyhdurTC8a1KlSpITU3F/fv3pbQSJUpAX19fep9RGyQiygtKlCihdM4vVaqU9F5fXx92dnYK1wH//PMPLC0tpWO+ra0tEhIS1F7PffjwAQBgYmKiUUzaXrOZmZnB09NTYVvc3d0V7mz6/Jrm+vXrEELAy8tL4RwWEhIibcuQIUMwdepUVKlSBZMmTcLt27eVYuM1DZHmlEeOy6P09fVx9OhRnD9/HkeOHMHChQsxfvx4XLp0CR4eHnBwcEDTpk2xevVqFC5cGAcOHFB4tjgj3bp1w8uXLzF//ny4ubnB2NgYfn5+Gg3Up+4HaGpqKpo2bYoZM2YoLXN2dlZbnqmpqVKZmsb3+eM28tjSDpTeuHFj/PHHHwgLC1M4gdGXlVf2YSFEhuvT09NTyqdqnJi0HXKPHz9Go0aN0K9fP0yZMgW2trY4e/YsevbsmalxZoQQKrc5bbom7elz9vb2eP/+PT5+/KhRh2/a7bt48SLat2+PoKAg1K9fH9bW1tiyZQvmzJmjkE9VXOnFmpqaCmdnZ5X7k3ymwsDAQPzwww/Yv38/Dh48iEmTJmHLli1o2bKllPf169fInz9/httFX7/U1FT07dsXQ4YMUVpWqFAh6W9t99GMqGuDALLUBomI8gJtrgPKly+PjRs3KpWl7rxub28P4NNjfJqc+7W9ZtNmW/T19XHt2jWFf1oAkDqyevXqhfr162P//v04cuQIpk+fjjlz5ijMjPz69WuFzjAiUo+dUp+RyWSoUqUKqlSpgokTJ8LNzQ27du3CiBEjAHw6ALVv3x6urq7w9PRElSpVNC77zJkzWLx4MRo1agQAePLkicrBnC9evIguXboovC9btqzKMsuVK4c//vgD7u7uKmemyAxN49NEcHAwLCwsULt2bZw6dQo+Pj5Zio00lxf2YR8fH+lur8/X8bn8+fMjNDRUIe3mzZtKFyFpXb16FcnJyZgzZ470H8Jt27Yp5DEyMspwNhUfHx9ERETgyZMn0t1SYWFhiImJgbe3d7qfTY98INKwsDCFQUk1de7cObi5uWH8+PFS2uPHj7WOR65cuXKIioqCgYGBwgw6aXl5ecHLywvDhw9Hhw4dsHr1aqlTSv7fVHX7Cn29VLWJcuXK4e7duyhSpEimytJkH9W0Da5duxbx8fHSD5lz585BT08PXl5emYqJiIjSV65cOWzdulWa7EQTnp6esLKyQlhYmFbHZU2u2bRRtmxZpKSk4MWLF6hWrZrafAULFpTG1ho7diyWL1+u0CkVGhqKNm3aZDkeoryAj+/9v0uXLmHatGm4evUqIiIisHPnTrx8+VLhB6T8v7ZTp07VeHBouSJFimD9+vW4d+8eLl26hI4dO8LU1FQp3/bt27Fq1Sr8/fffmDRpEi5fvqw0MKvcwIED8fr1a3To0EGaterIkSPo0aNHpqcg1TQ+Tc2ePRsdO3ZErVq18Ndff2ldDmkur+zDQ4YMwaFDhzBz5kz8/fffWLRoEQ4dOqSQp1atWrh69SrWrVuHBw8eYNKkSUqdVKp4enoiOTkZCxcuxL///ov169dj6dKlCnnc3d3x7t07HD9+HK9evVJ5a3adOnXg6+uLjh074vr167h8+TK6dOmCgIAAlbefayp//vwoV64czp49q9XnixQpgoiICGzZsgUPHz7Er7/+il27dmkdj1ydOnXg5+eHFi1a4PDhwwgPD8f58+fx888/4+rVq/jw4QMGDRqEU6dO4fHjxzh37hyuXLmisG9evHhRuvuOchd3d3ecPn0a//33n9RR/dNPP+HChQsYOHAgbt68iQcPHmDPnj0KF+yqaLKPuru749GjR7h58yZevXqFxMREpXI6duwIExMTdO3aFaGhoTh58iQGDx6Mzp07w9HRMfs2noiI0LFjR9jb26N58+Y4c+YMHj16hJCQEAwdOhRPnz5V+Rk9PT3UqVNH62saTa7ZtOHl5YWOHTuiS5cu2LlzJx49eoQrV65gxowZ0gx7w4YNw+HDh/Ho0SNcv34dJ06cULimCQ8Px3///Yc6depkOR6ivICdUv/PysoKp0+fRqNGjeDl5YWff/4Zc+bMQcOGDaU8enp66NatG1JSUhTuBNHEqlWr8ObNG5QtWxadO3fGkCFD4ODgoJQvKCgIW7Zsga+vL9auXYuNGzeqvdPIxcUF586dQ0pKCurXr4+SJUti6NChsLa2VngOPDvjy4x58+ahbdu2qFWrFv7+++8slUUZyyv7cOXKlbFixQosXLgQZcqUwZEjR/Dzzz8r5Klfvz4mTJiA0aNH47vvvkNcXJxG21umTBnMnTsXM2bMQMmSJbFx40ZMnz5dIY+/vz/69euHdu3aIX/+/Jg5c6ZSOfKp6W1sbFC9enVpnLWtW7dmGENG+vTpo/L2eE00b94cw4cPx6BBg1CmTBmcP39emvEsK2QyGQ4cOIDq1aujR48e8PLyQvv27REeHg5HR0fo6+sjOjoaXbp0gZeXF9q2bYuGDRsiKChIKmPz5s3o2LEjzMzMshwP5azJkycjPDwcnp6e0iMYvr6+CAkJwYMHD1CtWjWULVsWEyZMSPfRckCzfbR169Zo0KABatasifz582Pz5s1K5ZiZmeHw4cN4/fo1vvvuO7Rp0wa1a9fGokWLsm/DiYgIwKdj7unTp1GoUCG0atUK3t7e6NGjBz58+JDunVN9+vTBli1btHpsWpNrNm2tXr0aXbp0wciRI1GsWDE0a9YMly5dku5+T0lJwcCBA+Ht7Y0GDRqgWLFiWLx4sfT5zZs3o169enBzc8uWeIi+dTKhyQAtJOnduzeeP3+OPXv26DoUIq1wH87dEhISUKxYMWzZsuWbuavo5cuXKF68OK5evQoPDw9dh0NEREQ5QAiBypUrY9iwYejQoYOuw8kWiYmJKFq0KDZv3pypYTKI8jKOKaWhmJgYXLlyBRs3bsSff/6p63CIMo378LfBxMQE69at03rMt6/Ro0ePsHjxYnZIERER5SEymQzLli1TOXtdbvX48WOMHz+eHVJEmcA7pTRUo0YNXL58GX379sW8efN0HQ5RpnEfJiIiIiIioq8JO6WIiIiIiIiIiCjHcaBzIiIiIiIiIiLKceyUIiIiIiIiIiKiHMdOKSIiIiIiIiIiynHslCIiIiIiIiIiohzHTikiIiIiIiIiIspx7JQiIiIiIiIiIqIcx04pIiIiIiIiIiLKceyUIiIiIiIiIiKiHMdOKSIiIiIiIiIiynH/B9CDdGqWFRAxAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 98%|██████████████████████████████████▎| 50/51 [05:53<00:06, 6.73s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████| 51/51 [06:01<00:00, 7.10s/it]\n", + "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.94model snapshot/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", + "exists. Use `overwrite=True` or pick a different name\n", + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/aef6\n", + "42d24bf39d00d34f4f187f20c545_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 49%|█████████████████▏ | 25/51 [00:39<00:42, 1.62s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 98%|██████████████████████████████████▎| 50/51 [01:20<00:01, 1.87s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████| 51/51 [01:23<00:00, 1.64s/it]\n", + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:589: UserWarning:\n", + "\n", + "'kappa' with will be cast to \n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/aef6\n", + "42d24bf39d00d34f4f187f20c545_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 49%|█████████████████▏ | 25/51 [02:50<02:56, 6.79s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 98%|██████████████████████████████████▎| 50/51 [05:53<00:06, 6.91s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████| 51/51 [06:01<00:00, 7.09s/it]\n", + "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.84model snapshot/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", + "exists. Use `overwrite=True` or pick a different name\n", + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/3230\n", + "c67ed1b7a904a173d32a721f8e4c_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 49%|█████████████████▏ | 25/51 [00:50<00:52, 2.03s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 98%|██████████████████████████████████▎| 50/51 [01:42<00:02, 2.03s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████| 51/51 [01:45<00:00, 2.07s/it]\n", + "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:589: UserWarning:\n", + "\n", + "'kappa' with will be cast to \n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/3230\n", + "c67ed1b7a904a173d32a721f8e4c_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 49%|█████████████████▏ | 25/51 [03:09<02:56, 6.78s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 98%|██████████████████████████████████▎| 50/51 [05:59<00:06, 6.75s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████| 51/51 [06:07<00:00, 7.21s/it]\n", + "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.77model snapshot/s]\n" + ] } ], "source": [ - "results" + "for new_params_key in new_params_key_list:\n", + " new_model_key = {\n", + " \"model_params_name\": new_params_key[\"model_params_name\"],\n", + " \"pose_group_name\": model_key[\"pose_group_name\"],\n", + " }\n", + " MoseqModelSelection().insert1(new_model_key, skip_duplicates=True)\n", + "MoseqModel().populate()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can then choose the model that best matches your syllable duration of interest and \n", + "continue training it using the training extension described above" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'439ee83193'" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "tutorial_kappa5_mini training results: /home/sambray/Documents/moseq_test_proj3/411c8460ca6c2e53b6e62826b7e49bd7_ar/fitting_progress.pdf\n", + "tutorial_kappa6_mini training results: /home/sambray/Documents/moseq_test_proj3/8b46f4d1412b3b5343c7568134c8ecac_ar/fitting_progress.pdf\n", + "tutorial_kappa7_mini training results: /home/sambray/Documents/moseq_test_proj3/aef642d24bf39d00d34f4f187f20c545_ar/fitting_progress.pdf\n", + "tutorial_kappa8_mini training results: /home/sambray/Documents/moseq_test_proj3/3230c67ed1b7a904a173d32a721f8e4c_ar/fitting_progress.pdf\n" + ] } ], "source": [ - "import hashlib\n", - "key_string = \"_\".join(model_key.values())\n", - "hashlib.sha1(key_string.encode(\"utf-8\")).hexdigest()[:10]" + "# print out link to the pdf of training results (includes syllable durations)\n", + "for new_params_key in new_params_key_list:\n", + " new_model_key = {\n", + " \"model_params_name\": new_params_key[\"model_params_name\"],\n", + " \"pose_group_name\": model_key[\"pose_group_name\"],\n", + " }\n", + " training_results_path = MoseqModel().get_training_progress_path(\n", + " new_model_key\n", + " )\n", + " print(\n", + " f\"{new_model_key['model_params_name']} training results: {training_results_path}\"\n", + " )" ] } ], From d663e0eacf4533137621e228db54f30ff0e2a055 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 27 Dec 2024 11:23:38 -0800 Subject: [PATCH 20/42] move moseq dir definition to spyglass config --- src/spyglass/behavior/moseq.py | 10 ++----- src/spyglass/settings.py | 51 +++++++++++++++++++++++++++++----- 2 files changed, 46 insertions(+), 15 deletions(-) diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index 181ed4cac..85e0573de 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -6,6 +6,7 @@ from spyglass.common import AnalysisNwbfile from spyglass.position.position_merge import PositionOutput +from spyglass.settings import moseq_project_dir, moseq_video_dir from spyglass.utils import SpyglassMixin from .core import PoseGroup, format_dataset_for_moseq, results_to_df @@ -113,15 +114,8 @@ def make(self, key): model_params = (MoseqModelParams & key).fetch1("model_params") # set up the project and config - project_dir = ( - "/home/sambray/Documents/moseq_test_proj3" # TODO: make this better - ) - video_dir = ( - "/home/sambray/Documents/moseq_test_vids3" # TODO: make this better - ) + project_dir, video_dir = moseq_project_dir, moseq_video_dir # make symlinks to the videos in a single directory - os.makedirs(video_dir, exist_ok=True) - # os.makedirs(project_dir, exist_ok=True) video_paths = (PoseGroup & key).fetch_video_paths() for video in video_paths: destination = os.path.join(video_dir, os.path.basename(video)) diff --git a/src/spyglass/settings.py b/src/spyglass/settings.py index 15bcf9d9c..068607386 100644 --- a/src/spyglass/settings.py +++ b/src/spyglass/settings.py @@ -82,6 +82,10 @@ def __init__(self, base_dir: str = None, **kwargs) -> None: "video": "video", "output": "output", }, + "moseq": { + "project": "projects", + "video": "video", + }, } self.dj_defaults = { "database.host": kwargs.get("database_host", "lmf-db.cin.ucsf.edu"), @@ -139,6 +143,7 @@ def load_config( dj_spyglass = dj_custom.get("spyglass_dirs", {}) dj_kachery = dj_custom.get("kachery_dirs", {}) dj_dlc = dj_custom.get("dlc_dirs", {}) + dj_moseq = dj_custom.get("moseq_dirs", {}) self._debug_mode = dj_custom.get("debug_mode", False) self._test_mode = kwargs.get("test_mode") or dj_custom.get( @@ -174,9 +179,20 @@ def load_config( ) Path(self._dlc_base).mkdir(exist_ok=True) + self._moseq_base = ( + dj_moseq.get("base") + or os.environ.get("MOSEQ_BASE_DIR") + or str(Path(resolved_base) / "moseq") + ) + Path(self._moseq_base).mkdir(exist_ok=True) + config_dirs = {"SPYGLASS_BASE_DIR": str(resolved_base)} for prefix, dirs in self.relative_dirs.items(): - this_base = self._dlc_base if prefix == "dlc" else resolved_base + this_base = ( + self._dlc_base + if prefix == "dlc" + else (self._moseq_base if prefix == "moseq" else resolved_base) + ) for dir, dir_str in dirs.items(): dir_env_fmt = self.dir_to_var(dir=dir, dir_type=prefix) @@ -185,12 +201,14 @@ def load_config( if not self.supplied_base_dir else None ) - - source_config = ( - dj_dlc - if prefix == "dlc" - else dj_kachery if prefix == "kachery" else dj_spyglass - ) + if prefix == "dlc": + source_config = dj_dlc + elif prefix == "moseq": + source_config = dj_moseq + elif prefix == "kachery": + source_config = dj_kachery + else: + source_config = dj_spyglass dir_location = ( source_config.get(dir) or env_loc @@ -482,6 +500,11 @@ def _dj_custom(self) -> dict: "video": self.dlc_video_dir, "output": self.dlc_output_dir, }, + "moseq_dirs": { + "base": self._moseq_base, + "project": self.moseq_project_dir, + "video": self.moseq_video_dir, + }, "kachery_zone": "franklab.default", } } @@ -567,6 +590,16 @@ def dlc_output_dir(self) -> str: """DLC output directory as a string.""" return self.config.get(self.dir_to_var("output", "dlc")) + @property + def moseq_project_dir(self) -> str: + """Moseq project directory as a string.""" + return self.config.get(self.dir_to_var("project", "moseq")) + + @property + def moseq_video_dir(self) -> str: + """Moseq video directory as a string.""" + return self.config.get(self.dir_to_var("video", "moseq")) + sg_config = SpyglassConfig() sg_config.load_config(on_startup=True) @@ -588,6 +621,8 @@ def dlc_output_dir(self) -> str: dlc_project_dir = None dlc_video_dir = None dlc_output_dir = None + moseq_project_dir = None + moseq_video_dir = None else: config = sg_config.config base_dir = sg_config.base_dir @@ -605,3 +640,5 @@ def dlc_output_dir(self) -> str: dlc_project_dir = sg_config.dlc_project_dir dlc_video_dir = sg_config.dlc_video_dir dlc_output_dir = sg_config.dlc_output_dir + moseq_project_dir = sg_config.moseq_project_dir + moseq_video_dir = sg_config.moseq_video_dir From 3a1c079d2c4642f0c48d7abe3c3cf344c388ef9d Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 27 Dec 2024 11:35:54 -0800 Subject: [PATCH 21/42] move moseq config function to method --- src/spyglass/behavior/moseq.py | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index 85e0573de..b5f2132f7 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -107,10 +107,6 @@ def make(self, key): key : dict key to a single MoseqModelSelection table entry """ - # TODO: make config a method - # TODO: set kappa during ARHMM - # TODO: make pca components settable - model_params = (MoseqModelParams & key).fetch1("model_params") # set up the project and config @@ -136,7 +132,7 @@ def make(self, key): posterior_bodyparts=posterior_bodyparts, ) - config = lambda: kpms.load_config(project_dir) + config = self._config_func(project_dir) # fetch the data and format it for moseq coordinates, confidences = PoseGroup().fetch_pose_datasets( @@ -189,6 +185,9 @@ def make(self, key): } ) + def _config_func(self, project_dir): + return lambda: kpms.load_config(project_dir) + def _make_model_name(self, key: dict = None): # make a unique model name based on the key if key is None: @@ -237,7 +236,7 @@ def analyze_pca(self, key: dict = None): key = {} project_dir = (self & key).fetch1("project_dir") pca = kpms.load_pca(project_dir) - config = lambda: kpms.load_config(project_dir) + config = self._config_func(project_dir) kpms.print_dims_to_explain_variance(pca, 0.9) kpms.plot_scree(pca, project_dir=project_dir) kpms.plot_pcs(pca, project_dir=project_dir, **config()) @@ -323,13 +322,10 @@ class MoseqSyllable(SpyglassMixin, dj.Computed): def make(self, key): model = MoseqModel().fetch_model(key) project_dir = (MoseqModel & key).fetch1("project_dir") - # video_dir = ( - # "/home/sambray/Documents/moseq_test_vids2" # TODO: make this better - # ) merge_key = {"merge_id": key["pose_merge_id"]} bodyparts = (PoseGroup & key).fetch1("bodyparts") - config = lambda: kpms.load_config(project_dir) + config = MoseqModel()._config_func(project_dir) model_name = (MoseqModel & key).fetch1("model_name") num_iters = (MoseqSyllableSelection & key).fetch1("num_iters") From 589bdb2c8f7c8e52c92caa43b0a8f8ca332b8af6 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 27 Dec 2024 11:46:43 -0800 Subject: [PATCH 22/42] Update changelog --- CHANGELOG.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4b85fda6b..813715052 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,16 @@ # Change Log +## [0.5.4] (Unreleased) + +### Infrastructure + +- Add common method `get_position_interval_epoch` #1056 + +### Pipelines + +- Behavior + - Implement pipeline for keypoint-moseq extraction of behavior syllables #1056 + ## [0.5.4] (December 20, 2024) ### Infrastructure From 7d30fc168ee9d3163b5b2953495a070857bd9492 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Mon, 30 Dec 2024 11:47:12 -0800 Subject: [PATCH 23/42] update pipeline diagram --- notebook-images/moseq_outline.png | Bin 106224 -> 61149 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/notebook-images/moseq_outline.png b/notebook-images/moseq_outline.png index c187c267fc45e71cb0a851b4a798e88422af91c0..44e648c21450afbfb53973c0ba5795cc4ca89ce0 100644 GIT binary patch literal 61149 zcmeFZcT|&Gv@aUBC|D>eh;$VJ0Rg4=A|g$i^covo2)#oPL6j;@q$3?dQ+kbnfOP4- z6FLdKhUBf_KIh&$#vNz8_wITBy^OI3G0C^SHQR6g=A7%>pVU?5NiWl0hCm>siV9Dj zLm(ve5Xku=l7GM_@)aZxz@JNY3i^%^2sbm~zjJPxQZ5k4ZHVF%87;TO^-0e}ZRa{E z9FY5UZh6yv( zlj!<)ITO)-T(5pYNU5pJd}&AyPrti#Y)r(B@_AlN?g@Alck zc}co1|M>>?M0ok7np9u;`!=>IzSn zva1N>vr_e$v2v6hDr}%gdrb9)qAb!AR+dWy6i5Z~3mu9DiVV0)mLzStFSk}ToUHRepp%j=OcCPCN;$EUM9 z%@hm3hP05^Ao3X=E8Kte<2&~FKOOAC8sW2?4aUT6w+QAnAzKcI&8$zlf$#kq8`=BK z{O3DLTFuIBsfZeYJo8NXhG5g%akFh(WlW2<RJCg`CJuzPT4-tkh=M+k3>W{uGA z-}fsr!WhQFYb><34cjh+fWNI|8}DzARB^)E`cPGd6-&0`j3(M>`RJ@)NAuRh1xGVY zq;x`5ls5%oL#3|+_kmt)rt&Sf1LUlJ1Kkc~YBpPcEHbW;H1F>=cAtG6!l+fjofPDy zP7_mPROTVuowcb!Ec55P>`CWPfk%pm(gkyp0`P@*ch*F~xC^@d3a1G8GE9GCL+rxm z>wm*2?0%b!f{e^d3L;192S!y^&Jq2WFJGB9sD9PfN7Wo&G+k+V+M)vEGJfRt$5$!i zT65IbfZ#8bN2$xqEul129}HuXk*URYXg_4jaA9!R`b12H!{BNRLWi7*S2z#pMp`vq z4g|#w^-(niCQ_~S<%XykA?^DoE?j9!WIb|hs?n>oX!FH+t74|J*Ga6vUBS(+u|93% zBitMO6R3ek+(J6;ASuTkZGEL_nX@YLaLjqDY)z-|xOMZ}d-4PKf7JcYaKd+t`)&Ru zzuW7smvH^t&m*jaHob`~2pkMt8 zXlA}8go8_h!$exRjZMro;L||ltK8@IKyKF-E~N}sjx3HY)6kvhR?U_%c)5He4n<|}76Ha6-lseb2XV>4%LJADLuVBqj7 za6d**hr4tegJ|+eoyvB>c&`$~3Q%6)(ytZ|c?Jx(RA0Wiz5YEWS*kO%@nY^p8XB-V zk5TEp%TbHmdLt(TnvEl@Lz(?R;f){f*Sk#81%G)G`h=&JAJ#ZrZ_tQUtkQTN64HNi zK=TKwwre}$K)DY=0sGB$6n#0AS5(C`Dn{zIjRPk}`vnk!g=->6HP|5?xZFi@T8axn zGJPozu3|a1Cn2f)>>tA}?=y9FjYId`eMR%!n_e66N6VgvK-B39jP}BBlkgf=RNF1M zH;ZX>GxDeY+K+z7pkHaBNI@j#ifSJA(OXe*YMi+5K3fR{sZ-lvTyxmgEJ?l;l`vs5 z4njt|u!22NYOIf)#1GuR#h8CJSHH*qQ#Thc|76bE~YA)Vmm0iLsqir~R9C<$oyg7~Pbk)NXSICgUim z$d!58lFjtJERrb#tZCVx=Ws*KGERj?;2xWFoti}EI&b9scVHx?#Ec25Bh?3WYxmnz zM9pG6R6j@WU(j~TfQ%#)GQ2Od4o#cV4*<0Q`hcG$*VuRhG}8W&c9)j_{#t*!E9c~0 z&3$a3fNTV9B-E^&y{wmQpjN*hIK(W=?4n{b8~baC>L)Cj*vz!d)%K)&BAFeN<#iKk zM5#~yML0baD<`lNAw~@1LVthA*zjxDV@CHoj+I{KOJ2xWvSVY{aJVV3(KfAXdmX~@ zuYxtKPu3DNZh-y%10&$x!rgBtttP%|4AQy{$bkTsYtu)UZ=kq^ zVrvAx%V=%4D6}PzZ%o7t*S6btR|Y@Tw!a8z*XEhLKyW*06+?j1rB}yhWX>--*1d?fZvbn==pqi2(wdZ4vPHi_<&!5jZ_pc5_#auUnS~3gX>9{$;zV{a>XIs!i zYYNw+qSO>rJt9*!juRc8ryP!vD~l&jw3L3URfOb-{Bg*DoDMZK1zviHdD`m%j7sN;jLybwQ0(U+87`=vdW#;bC>X(f)L$C?T?tTzl_OG9^2>qe&;>;jr;yrAq+ztdymU*_sZUSsBkk<6R&&phyG2PllJ?wog{u04fM#%B)hHaQ8pZe* zwo|xht@8tNU3857Y2WB+3DGyB@S;JK@aF&9@^W!y?T)>UVz>8G9Q?jN~rviP%U-L%2NV%Pvcf zPjHF!Y72QC4D~srPae7NEQ(8^zMV9-?)@HMYk3o{CO3F?XLZDb>zoTHlAljLtyiBD0r!VbhqJMmzx^w4GzCMZ z^rzqsm3XW=`b(l~ESGWVX4(A?_qp%6SExJjNE$U=d5==`=^);_IkWAZ{C;MvxBc&` zr0Nz?=MBd4;q~qw!vox^Gp1FS+fxj-)ZOP{8#LYPjXyy&!)gT&czWaycxSCgc{&Zh zwoIj~8rOv15;;c2;^>JQnxtwDJ}_a6@9Lf+FBCnUmr-QU{pRkNjBo0k_IEt1lz(dE zfI3<@(zLuw6qq84Rcg1fHh}qQ7#VrXyfyA5NO`ypDO#4IeNU)*HGa+HYsF?g{&eu` z`c~a>5~JLc&;(RtuM%Y`S5BKhIB-1h${Mln^N7S^OQBi&}QbMuf6-IA_u z{3h5IYg96H-^!U_C$MV`+i0)s|J2l=zsad8ev~KM9O|Ke$jb=bfs;?hHXgYyElr-_ zPj9z}+9KD`U}=sDrkv6*=|7AePY==p)=hj?dNACci0e@qN|+3)B^_>f_QXz6CGf=CGbH$@>cHLcGakrL(qxuc(}pmMpE1rN^*$_>-01{A{=wta~Rn9y_Yf7v*W1 zC$@9Try;xMa)GCmNkNKsIoMZtb9KP{DAM!C#7_F)>Z|Xz=YtD$hJnMcEAu1(rwAf~ z{T1ZNb%w!2;PgHlt7~bo@UKS+(a#cUSeA%|rYXWoc66!M(yF@p+PMoRcUNhGQ!cct^Rzkyw?XV1N)^urr>}XudtU*B}ReAJ*X=*zOAO?#n zuF0@IDv>VWObuQluNIc)RFr#H9ZQmNHXvrNXBYgoawh0Oy*xCb96Pr)UAw!wMki#W z=*k5dlpEGiv7X3S`52MjWS3bwIK_bm3VJfHnxbN#r?wqvmi&jCwkKf+>tAFVIIovK z{)-Mq6D1+Jl2?)J|Yn%Hye zXLF}a9Ri$TgIjEGS%_O~ilCkhlLc>-juvXJ>}Pv*D+8qL$xmTH9UQHNN)d87)Sn%C0@Pr>h!b${PtWm{&yv(IP}fQe#8hz_ zEZPnp+sFw%Z=Z~GeA>f3dzgH}#Qj<-<1UABPjA+LmaMcX8%qhmT3A&#SAfJ3k2kiNMo#sPlVMPmn|UHD>v6khOYi0DyY0m}a7$ z%24pz_BqXkR`}1md3B`;nQ(5E#&k?c=5KrKpX}lvQm5>cAO=ZA^5f1y6k=op{rtS~ z-P1KicE|}5NDksd;$Cx<+PXT@=k#tXHE5Hy^uxzubhr1XAkM*0-#G;}S7+AvM@oRK znMg{P7O>|a_?AS-JSYStn;|?VIj4$Eq(B6(4CVIRey3HdE20r0{oQgSjpO5odY|f!u$EfA{`E0KRalc?F0Mjpa_NaasZCYZ{L` zKw%2UN?c*PL**M{W>}os>!(Su1LoAie&^_mB6NcO?;B)4Xxrz3lDs3?1=u>F#A)8d~>-EhNGu$fP zp<*H0&}N=h1>p1p`X1b5R2vM0;3v^cLjJ1KJO}ygaNz`3m;HjEHsQ$K<=*)p$~+>D zKP}rB6ar56yFB)rwGqL%4m00skYoB?mX_ocpAEiG>AWF%%665IrGiT2K=uGBR@KKH zc;TcYzKOtfiXIp|V)gWjFiTz7Lvi#C-7q!leX7!1)}Ne6RTt7ajGbAe>s}s3wN4|y zPt=^ueRfPoM5_6?j`mr+1(@ke>$0p)QK%k^ehic-7tSbAFN&Vqw^37&JnTahDTn)t zs(}4W86R7=N77@pR2MI8q-|9nXzs&5UnHm5?}&qAm%{uuk-9evz5*yBz%j4jBc&LC zL;UcqZ4kcPM>99VRq8ft8_1^}bsao4ueGhsfE=RA?}L$=2WhaxfB_=i<+d_74E5OC z13or+;e?ES;4Kk^z6}(=+_&s;apzT)CGSi8v&!GA0SZxUzgD^~l1IzFJgUa!)M+te zD5W~>*JLu_K9ZK(vOCl~NWdbZ)ChS4xA_GVEvOB$mqk}K6^!Q+am~(7V^@@4Mma#j zJnci-w!FcurN!C@LjOR*u1k3A-cM$$447mZ#1e2nZxDZd+@Bi1 z0WK)$McF1{(q^LwfoMg!>eN!7o*yU2Rm~0_6=ha10&{4JOT_PW1_uP3^l6hzXMPH^ z8Yn3-1Ei{PE9Vh)_M7e<;*|(p8Sr8BZmg?!`3(9 z1Zb6C>BSpvT3NEOx!MO9(#uJhjK-RL85KmV_xuA%4Jx;t{ytL_92xFa>!@2DbPkf^ zF4vb1fIT^BM~QarTn>G&Mpqn2g-jD(vcimy9CiVLV~=zBGb$?|LeCJE;`Y{xMnze2!B~B&iV5~6CD=O( zT5d6gZPZ}y*S-poHUMFf?md1ZEmkC_)0>lq z1vM{yPG{|iFET=kYKE*5|^fp_jR1SfFy+4 z3HT=Xc&%pGB(Cuvk3F%|h+MU^TmXmKuQ-;NvC7K?PrGe^?`gP%Tu+Q$Q-oI2?nZeX zjBzq~?!LSGT@!E}LguQr`!n<7c?GB>(>BL1YkAg%2>^E%m_gMl0!p|bxRd3S7tF>%Om%mq*}O2d zmC<_!Ky|u8gv@th2Ot0xu>T;V8c;hmUEC)n5E76KF35Z?c_~}EY;@rYr%6-Z-Z-u9 z+q#;&X~f$gjGvbY4PMJV%e~@)liCo-%5HEg{Dz!7a2X~(kLWMVkeT}j2T1%WOnEBI zWFOP-xUB!aPmf%>`KU}tAaXu*?gvlZI+n+~$}LKzJ+zHc%5GDn=XCZ!?nhML+tcAM z1BDANU3=4OlLuE^r#xgSDGAAM;RXQw8?f5UU$@LAPqr-R0oiBtB>+FPP}--z24n6K zVta@#i0KFggQQe2C2Hf6&vx3l3xEtnQmbKy&iZu9q0j*Wca56ioHGEk?KBnFpbX|- z!@85Cp-RPm8FTW2w&lAeHbVl#a2Qso$auHKdTpr1vEr=~`tZ}`4)JfsMYwEj`Imrm zA9qe5xk34S@TIQAy}!loTNMCr>*0FY9v|radCNrL7(&yAHEy$OO!Z9R+*ik|JPyQc zW@a2YzB-VKds;jg;;J@944#8%Rg|sa;;=u|Ql>09h#;vhZC0L*fpmfwW&Y$VM)CD* zGE=FWgK=IC$CaUTKYR0w?WTFMPFX$Nw?8p-Gw2Lm?*en?@G@&Dz3uM4`a0E(;cVUa zJttd4Ieb_iFnvzl7PK8p#Qu2QN0thHS;cKE>blY=LgEK!68?%dfRM@7IZ*>*KJe18 z0`sv2Sdkn~e-3hc^xb=Ho z1ax##Rj(0Rw7K?kpBVa#36-@r3t<$^!OlFtv%(F&@}<1-e`84P-@_p4loO;$NuaA0 zQY?cIXN{c?t)&)jZ>vEm)@QkdZgh$Tl?Z~t^I2UB=_;sEeJ}SqpH;Px|J|^=9BdF` zr7%Uj)^GgJXH^w3*JrMmAdqM^f}8`N6SJ4HYKU$psaAPEu2u#b_qv%6<}2WJTW0ud zU@k2XFX;W0zut0g&@!JW^{&%@h+$)HQ}rKb0sh|6225^P?2&sm-r>J?FKDi#5_MCeqybraR+% zXY}sy6ZZA<+Fhz%jk=yPi?4p}pj8M(`taM@8(o=xM)@{JSsCL8J*CFrb3_ z4O27H!na&!N9>9nF#8Tg9_Uba8Hz-yw{C|Ht;yKc+`{smU5?r9{CXfK1@V6Fzm)&``Up18_w^_AI!pBz~w~Cf;H&Y?pLwo0j zmv~*?vQg2>FB93c2R6Nn2O||N z9cniZ?Sb3EW=<*ZX5G+p0V`Y=fd)RDStitB-)n69dRce$_f-QKyBFYU8H#7MuO2tO zUe$GUE=$UeeQZoyPC~qO7=JfG;T-VCm60?2R1eD`XRUwT;hW!iy~mvo?l`w_lPmrG zk!Q!zH{@;MO*7o$Ain)*e7jrJn>vYWZ zvea^{HFdxRap&=c?!EXgg0eQA9&HC@uZ*!VV90+Z{UqGMFP59sDfrkSU2~U&=znM!&ht3kc8eB3_-pOCUqYB%S``9tHR z4uG2ADZ5^{?JZ)d_+$0$tFyY+b5u84O!qh>@v}Y~=kC86+okC}1mTwb{km_^Su!i@ z4U;%(<6$#-bO+1sg__!E=KB=x*I3MMJ`wOb%JWJ4XDq^dB&s(Dx8%Cs1_uH0GIA^F zFgzH~iqlZPb?R$^%`;IMqdbaUV47$u4EsVuaKi2Vz^zdp@f+bqN4S*a`;Rv6laM`g zca?F|oHZw18FG-~J>d7Tw4!z!yPHnO&O_9P&$z)D!F?j3Ee7SJ z#4Lr?`?k0tJG-&A??KOS9=Mie-IJbs^eTQD^RIfz*D54DF!MtA9P`up^efbFjj3_I zl3PKSV$JtL3#;8G*fAUU90hbF_WcR7kZKTbLbpnMazCP}Ep7vyBFKUjzz3dhrOe$d z3&+!(#^XmXi-lC5Hb9Xl!#^~?02TP%KI~{^(mJls+ZIQ>+S=cneF2P+{=P20vQDM#5YdN~H zC%Q|&=BB2;!p#6-BiR3(1**f1FX z2M%Dgu#=IAsDX25iF-650Xrlw^Ro1--qz)Ca$eSbS_crYG692;*}4%Yps5q%LLK9i zto{9HCiy;_a@bH9Id94%Cn=2S8Q+IUE& zamW2xeDB#fX{%%ev(fCcdi_mkM@U{77E>2_Dtf69@R)+gl)ng|Sz5r|35lF1t;94M zYtK}tQ(#htN)lxs=x3?VW zb2%-PyUrg?kq&6j^exYF0PxZ;KFbFZz z$zm%xkm<8yK`&Og(2O<^w7O1~hEdD;ci;PeGx;Xl$!*I!Ma#rn01bUk_s@ZyeOACV zV>|1!<@hMCZDd6a<}5_t9rz~KVYm4by_l+!7Han7z-JZ(61&+j8r$oA@k=?XvqjD2 z-lC<0ktI_Ez1&;LN;WH^Px0c_f>!zw*1?D*HJ<7s-a;;$`NTZ&p359ucGd2UzwX$G zYQK?B0r0(k`u4~6R)crzFy~QY-{T*7Jw~r`+sLzLAMGjEK0L0WJX+JmT9ZS5Mw}fq z93Y*|vz}EO0SSp5UK=)KnBdmzAB3&M1401$C?@^9-61|tQ%)QCg!V**=mCGhcHLn8 zKsQ*+3r7R52dSf8WV^$h-%|Hphr5)yw{Yb#PK?vRRpa4jquJRHOr{Da{fNUdmb~4a z{L1AcA{jdn6B`C)D?X2Pidb#heR!4k7Z(@2OJ5m_UvA;ZnIJY?j-~Z%?L!U&ox|syU zkK9Ug#wMDt@GuPvDU5k!uh+q!BLIqelF{>3_xve zGR~#->1kr$z;?E-oB&>2c^9DaIAfgVWdSqI;YCu5*C=WT=A{7yFBUKBl$)j(-8}-@Bv7G@C`-;jxZ6qtRL&Cd9 zcNB#yc|E;8v0b(J>JFeXd>Wgsmv89yrX}*Ix8`M%3`J?@nLQow!QA47Q%jtBFRQEu z`w?^A+Q;rXf#41SE20Uv}RcgvIy9s7W>Knh8H4_TH!N^Gp{Q$-l%MYm+@Hk<@8zPJV;a_}W!m5mKT@;)ME9c9|now?d$ z!=U@b{QitBI`1=%K*tP?=~(Xi19I2ab^>ORKw289AM!L$Gt{!5c=6)vGBb_$0HSfX zQ4z_kS9bnDsMuaUI-IHhrHvnzSUxD~W+x$wmXN*HL`+6T+#y)Nxsk{lnP70T%i#dU zEW)_9+_aO;+q;ZwAJRuxI+(qcp#WsAfKVR5 z*^It(gC^tGk{+@Aw!qRAN-`6`aQ3jFEXg}-u6SB9;8nE~i{T4QyXmH*7x_D{CcK^7 z5^yYUAxAXIY={QF2k-%Mi6Pb>Br9m$?pw>);j!#kFDM~L9|l}#c-MzUaP;t@z*Vy^ zK@gBE#Xdklmf+hY#Ph#@n-&nj9DOaptk6sR37`^}#vNT!P}Vn8Xe^`5}ui3wGY zRw`%CM_>c7q8iZk+h4Ae+Ya}e`3a!0NyXRicIB&|#S5-@K*^eQgMuSNb^=MIKuQTy zqfcTW1Ec_zn}}lJUe%_cKb(2dJ2);nY)xx(jUUxh5|r^EfgF9bR|5~_{lGg=PT2c_ zlrF!-n3r8ov@12p>S@j!K{>lS&#EluGXt!rIr}aVf`duLJLhJ%5mn$GK@1W?Jq?n# zu()@8MJPDGRiQKI0gbp4wpQ!f`0FHF1rYFZd5i>nWb@smhajjr7(BOAJYSncw~IT> zXDnz}0iHbzJDBIDA7@_6u#-(a!f=uDeZ5V>ebhL!pholO;ZFAOw8wb*!9^JYH(-~s zGu=N#v%Lwxphu#RHp6Vdn)INiO7KWB%xF}u-o+cPZ-7!rynb=@1Vi}7E+Oq-I!Hm} zYU27D<>&7tQFnQ2_!lQ@>D!52d6o;WwcV3*1=2i`4;d2xiq^O+1y&%<@%7EtQ=X={ z37}ROXo5wj3`WLrZrCCBArSg=f2n-QR@8H$?Mt|lRfEHhJ>4D#?R_n{A#NWO1XNN! zfO^p4*u34r8q2Pme~y|yKp(x(i&%KQflHcAJ%k;AZ1yR=B)Ihz>*UrrlTgnzV~f8lH4(uup<(wQ~)36LeelS}%5OtRZ_6`mvI^9(;piSevxb$v_7IFuI&TpJ*ZSgFM* zLNVdGV;Bg=Nl@uD7<+J!mvVCysb%Y>=;*U#@kRi$dY1}WR7bo|4SiGB*TYxVZP_=Q zJI-1(l3en)Vtf7F7C=H6y3RD6b=LAMzhvY~>8NxYiNu@`=y$d^8qBO$3eP<^JKUUw zJutczhN+wnQ*@n(nDPJ&%#B>tU7S{}ay#gU8m?6>OWRRIKK4I*6sCcS>dJ`@C;p%r z_L;G*=J6E&)+)cwKkC<-aTf?3LGY62{CoZoJj3$$(BOZ4F5$pl7(HI!pPH|C*45%rAoL2PSL@2n zj@q5Keg&6&2nJ2d)WYHy41eYLf3o}4;sjO`2BL=U$$%AZu&(dGpZ}sa_+O}naDeRW z_VjI8Dk;}OVc;YN=$__~{5^;Vf&3poGxN9c^t1QwTHovn_q%va3<@eg-%}wm1!V%g zyvt|FK{nn6{S|#ZMw^VokPyYdK0TisXOkkMc z_22wxkaU2N>)Roxcj?HE%|-KWGzx5dOr= z&JHxwf4FPij#^q$gF8H(PM%CTna{u6y*aNabxSxE&*>Ok=<14!nSQ4737CcI?9nUX zt1N}=7498h5JgoUzy35}3iM1`%6d-ib-?v-91{7vr-x@-r>5Md)r&m1>oN&*^tcm5b&>uB!urn#MpU>`iLJSPNEcsjJljsPvW96!RdO!S$I_|`;n z*Hca~HnQZKjlLo(U~PzV*WS14{-G@c$MTjrh> zu~YJ*EUWUJ?saewYR0b1uzr58EG47n@@<>$mA<*!dai!s3(^~}&LV+qd}PNX!z!b6Vvr3 ze6IcX^OhN$K3i$->LSJYV;8YP%cn}Kphx_C?r*bj;H8jCttg3KQq7fqW0I9e+llr4 z_)RNqvr4zh!ByY|E@$%yX_in4a4hmEDW|u44?5}C$vUbL0K0GAU#C=T73jM4r@}Ck zhsojTWfx^&%;(Byo`=%*Xs&7rr8Ns*ju?COKdx~1t}a{gdalF5P0w4b+a3(Ily`R2 zUOL9ePSun)oSR{g4Fv`{5N$SsZ=@=HNExlNPyZ0;tOz!sYBgLNPmm+;Upb^FU5xre z?wt2Lb;m^pL3tNK(1W_sdTJglgKN&1s3Nx z;}-$>poiZQrIuB5*(x_`OaL=lr+Gn*(W`pmqk+{a9p63%Crp?#X2hLw?$2QiVmR!Q z6oxkV^blP$Tm(%)JLEWX)L)zokS)-W=PE| zW3fxhhGw+*Wz&IeeU*9m2nu@I?g&qeX=%(MZ8!de_7~*h5k@F?QJ# zQy#5E3T2s8pf=2{D<499-tnpel!BY0YwcsbQ2BiIsh3tP92@kF zRW15|{HpknJbF->MI&HDuGOs{JFUNe39pA++zH29>}P0TkXYo2E8K`r``o`H0J{gBW&Vsh?-(!;T`mpA&Hb-hpPs5-1uA6mU{$c~*baGHukt@{&|$u|im^;FLwP|4-5 z*N}^N%dw(*Pc*@Uyay2i>bJlVjk8{F%$9UqsC?V@&JO-?y@Y^tQc}nL`LTGD0&NXC zBOi@RbhJr-vQQxS1)x{84Bj3NlF|v}&a`pfMDDlB!;&Q|2abizEFS*@Sv`BSL!HL^ zc=u?iqTX3Awzk4!lE;T{$?uY;kK|4l+;&P|B_P6u5ab?ay}K3@7tAvKB_+jM6S$ zg5(6B#VSjgMekgGNubv8wovS;_cmTK!Mmvl4t5*9b6HcDdPS%bK6J^(;3*IB?gjxG zz^Rp(A=odfn0lA~WAaAUj7(&WBW8&FxgHfny6g;HV-A|{ER|VJR&(%St=Gb&uHeyJd0dL@lkn=3N;Z+Ue#uk%}t)5>7Em$lbt+nKJzE9v)EM)XL!XV5x7*9)X6c> zYepVHdS-(3d2c$KV>8|)597+Q#N=4XlMhh*D&8E^J)f7i9~jOftuAd!sYOY#m74Z~ zoh;_oW#M}n!U8kuGE>j`ZOzgTwiHj?Va~89_afbdfn)b1jspHhuf~gY1|k{`^w+g0 zuM<%zTyn#Ww07-3qwoGnb65+-eeZdRDMNZPjQl=EV+@#1pInQ)^7ZS4?$|QTD3>Jb zulfeamyby6unINLj&TufyEjY3MFrmCkMQ%c_kl-1!tz7w&IZScoue=xNzXqbI?G1| z{o&IWT*_D2>!%N(cb>!+zFZ3K(a&tSl4**u87o^U!CWN&*rxD_88uV;k7%h%warg7 zhAfOhrY#~$#Mr3H`{0pb>3YrUWUlx!b$4fDcju%n@9GZ+!tU!IwN-UBz4sCr=;}wm zf9vtRQ+NHTD-C}GM;F+P-nCo;UrKfFW)$Dr$V%D|YrHo-CI%_d)*fERp=ZEN_CwYM zU7i@V+eqlMx6+tq{5m~&Ap`!k!9Wtf)EU5;AUXazq1Qx7FWUpZcw_P#ik ztJJo?OIqyu1guZ{Oph>m{%M~i?(NcilG0;>z0+}9B>nK~=T@^&)(zrY8af`cV2e{n zJ2^YVlI5=8Oap{g>+jQCMoF@MEg`oaKC0qbA!ZZU53}$Lgb4G)QufcwhlE$#M7omf zxr5a;J`;Qb5}*CrLRt%d%Txa4b@(*dhD4o>N6-!n%j1t%mU^I74$akEY?FewkIJW- zU>jzWX6N{G(~ESGQyS$Kqy30Fpus<7qFX0Sq%8-zmAi)SD;L(1g*dX1R)2Cn{-PPO zxe0FNkO5Ky#CLH;%+zg~y=j9XK=En7ByZk0m!L%R^t6HZ^V5!TgpL8Cq5Fd3-I-G47{yauA@$#r(CY&X1j#m{@$m{%whvN#>dl3nDU{O zTJNy~Ixq7S4L){0AR1Zlz}ZQI;04gh=GeGem5KTNl4DWm{EUUqNM(N3aUN>JUv76D zE>COv6zp;9H zp&$G{-Hfu0xYmS=HdA~tWR;DoiiILQN)MlFv}InQu7FK()QRl9dxrdc8;Nd6eqTK% zB>wYe;+B~y^WKpuGS*lG-%%u>n}-tn`FmhsruefTK-EDU*6z&eyD=HcH!QPWe8FHR`?DcsCcLY;ygv z!ueKNldopeE(Tvc?f2q}!t#x`V3Ry;DX~gae1g__YOme|KfO5ewSO`{zq<~5oQcQ9 zpUkqgm&UCl66sMLBFZ<9LhZv$-Ddvb;NWoas_t5EI@t@Wc2vORrk@x*x(6vP^fsL4 zKN(5=+->)8pQD|eA?YH4!hlhKdcli zj*Xdjba3KDw!MG62xbju*B&UHDqNrmWidwj(bW};L z3zg8|@P8OB^XNN6;PWI`1M6L*%pe*&Pd|#exvJ;xGkOKw>O2PVf+Ec5`iz@7KP`SB z7^0#+kjBkV=jS6tF}q;`bbG9!yQ_aBMzXdbO3JZZh{8f!v_`$;lq=bWl#P)%@ECfd zms4Y!7vwvIANp84-<`2<_@1867fAm~ZhO-vu~6{+{o92#i8QP1zlty1 zC}QOLLL3X+(7;X@-VR+FWt_S?vp1;$LA(VqvmzLXjPxR$)`w zl7Bkb9yvHP-Y~DA|7=#OiMS#tQTJ*)kBzog;w|OZ6#)veX2qrt*T~#Teq64IuV#jA zM0ezsW~FOQ5rLmP(UMQe2|K;cd?F>9^(~WGZY?Gz#&j-uW4r=sGx8^p$>(0izGuP* zB8W}~&cRuK<-!eDG~Ww_BL80Fiz>yI3apXIQHIFH!3(k&A=Bq&!EF1S+st_Z9Mbi=Sy8{~k@hVZBqT#1GL$SqO1)Kdm$N3V*O4sB3&wteK{QAzLz)<#FmaXo-&HChaB6I0{h`Ia~1iQph zS6G&EnBQa30~$ATFa)WU^(dFtVx>(KR#npY%9|VC$|SHhT+89Fp8IO<#&!2Ud5Zrj zh@}Mj;|+{eIimZ^iSUs{{tbIX?#VI?*1;2a%HE|gr7&dEmm0C!-?u7HH*Ji6+b(U+ zBu)HmK}iTPcE0&JnI1`mph%P3*sbDVwwv7i^|Dq<+tKX(=w$vu1M>;*g?2vWsn6xH zJnj#2;l%UcNrpV{!>!n7)6?#~d`fIet7N$ys#Gy=N2^sl%olepuf3GX+YIad#_h>G z=~}y3;3|3J@dGG7`-7idQ?r#HPYq2T)yrxHdlz?#hJJ`~+H?(;38?*n^O zo&Y6Nv>^JH1WL*MlTDhV2SLm-`wCYGB+*ws8d>X|`w_oho|t!PzL4GbBPAX-*C z5^i$1)?Q|KF#breBk6wbi5H$l7JB;N;In~ost)z~7`%`r-Qgwmj_av|UCI=X`$?%< zr6V>ZGvPT7TR*=L>Q9lDWi<76I5WKTyH6LQJu%Rv`9eJB#vk_QK0D#o4_X}gs;MD= z+SP%FTDITmm`3d4nJOfa`9|J_KT4m)b19vn)fKWTD}aj9@ zucM}|?gy*6vJ|5-&-qZYfpKSEX5)ei&Izm4y!{kH-Xum&7U@vuXg!kEl=t67+j>pr zez{7g+WyT}N2!cBNI5)7#50|~xDDfOI_CCvNK5k{>$`88)#e-xr=z$3fL{dr-2cq| z1S5nT^){VVLlmzToG(|`(AZi`fUVX~OL6-gpC0tI$4~zA2>9N{w@au0c$4br4h#gv zAf{mN6zEle390D96=>227Bm!Hf4PuvU3;trMMxPsI5!O$%Mv$_h)M6X-9Ux%J=8FX z- zbNr&LbYsZbw=!bsz7#yq5qb0D0DEs8#COPd;F|BE$Z_w> zjVfy0j%?M0#NG+jW$$sw(WZ4ax5vdXa|`VX&b%E}j9!U`NNdGJCbOm{A?Sb2ar_h} z20=ir%Y?J5sC^SLq}b1D{%bNe<3s|!iahH3phPvF@Taa}(==YeU4s;fzvEwd*!$9* zLBROtehjM8S-28BGp?hf)6Vl=%sGh3u7m4*Ad$=EIDw82%z5VBx|i>msiy3o*1xxM zZuq9D8`@dwa_AIF@ff(L;G3T(Yq-}nIrQfwnEgjwYoE5$skAGkh?OBLvawX*m7Biy zm!hn#HmDOfRFqd}t_il*7$t)~p<<^bH?-|9c}Jl)Zi)O3(}+{e z47&FC$v(|}2Un6imv@kum%J&*V3Gu?JB(q!cDzaNLs98;P583*4)cB6eN(Obkmr9U%`{`(s=FMfBU+mSo^;2U| zB$tHu?jM}^3S7lt*!r&WF+F6aR)OK1MZBl|eA5ZwjO{#wjQ4#^(XUWqnoPebA1j3W zD`WDFwj)c`1E*wKKo-;@%To%3itBQa>W4j35qM;Jm*Ku`#+zTE#0x4SIy@abDrRp! z>J)H~?CxH!8%;;BDWNuU8oqahPD2OfrV7O!AB}jZp$z*5+Y1#E5@#nHAvtm0f6mJ=syz!AAS&`={|> zcMjK^x7z6Rx6tNXF160my8jnFLeZ?kA9% z|Nb*SV%m4Og+j78uIF0x2Yre9lsk5#uBlsbU1W4J>HrquV7M1rZLcdDc+#=2 zvKU6P<~3q`{kS$v7OU9xA?x?bbvU3)r4h>UN)zwRQyLY98YX(~WP~01iBpMp7B|9s z6-8$MtPDHe&A0<(9m|7}%A>qPq7_Z=(_brj>Ea*cj$qxJ{=E&*tkH^{aiQ^rh=dTR z$eX5RwWY+K%=6Ph!G>WET_KInCj(iOwnI?(4*qt~EAKxZC(p##CnyKc-j2vD8PSVk z)jVAtUeV)K7JQnN1vTy{ay|I5q<02S3~l=%d<*iN8(_eM%s#_%YzxmXN__R%%I%^3 z3F}cr3=Nxn0^M7qOVrwE>1$uXMDB0@N)xbF+Is)i-OuS3%{I-=B|0W2U-mxDU}bPoT`tmS~aL50Zm1$7lyp{B)7YiPQ?Vnyw*KLK?o zEcLP*FP3CjK+KV-?edjOw1Alf+h%!QGHzz9iJYJ1-uXb>i5=R$O4?{i$e-vSt9${0 z?j}y|mjxRW$MDrDBPzFDvB;vtX7Zp^tdYzT8}hg;H35n5q*B`+>?&eef-JaJ8^fx*zOup#h@Z~o{*b^xT+!3Bf-x2{ zF*K{UXkgN`ZW)sJ0l`;OlS)+X&72h4OsUT>C5+3Yi2v%7$)*8MfJzpAg+u3k*TSu! z6`98tr$gzhEejuvq$UN(u&?JW%8Nziy6XzjncfiO&yh=_L^Q0P_?*(n9u2@w%KUL1 z%tLVBjxh~}rrObaoQlrubp$EuD`h@OH|muckcs~i*==-hDXg-IUD3wp)DK$kB|xuu zyw*uNDssVfzBA^5Q}j>Vf+Ekkaa3>H@Z1N8I@8$~_lJF*#&>9g)>-{}v?)cBhOyuS z>=UqtH!*AY13=***vPPsX6&Hu(eE*=j@8#F{9UNcJAyk_a*<}_hYNqa(BV2Uh#V24 z_yBu&Dk6V&K6;D8>j8E2WaRM+wt{5sP&HP0+NCgn&)4~~^Y$i0KUM{-d@U3+q6;A{ z)3u(fuR#9%wq3$|7I2aotyO!NU{7Tp#hH%9mcq1U-mx=I3k2F^jXiN1DW1|JsABeC@g*?Yk!-VgmP@QOH2GDeB$A$7A=d^(;HDvmRT?K zt9-mYMJ?VHy&tpjyS5kl@FL=9CH-~u4zE2&*|AJf!juUik>Xtn^SQnw=ZqiNKbG9TA;fK4SAy{+MzJa|Vq%Sn4gt;$`<&{|p>zuk#f!(*K;0t7 zS1&Sg)CWg+jS`{5=%P7kD*$X5RF=CmqXrnTJ7Os{R;)jxXi~lF4TEiO6`0RWhcw2P zF+>QXYfU2%8H-Y;R5#^3BvWSPLrmr4lUj*H<|)*E3st;tSd7Xf8$5Fuky#5$;+)GL zNj57ycPmViihMiHZ@Y#=S)jkWo~w}(Nt?#$Z{$+6csy*~QH1W}-Qe*m)?%tkZ^sy^ zY6vh=p#b*_pvD!B_^6jgUuEc1MuCk(qhcO}@n(MxRxeiLKC~XeQv}AXl9KF3sOM2C zr@F^`#WQMLu|PM?fw^+lu($nlP|fXCEjSO4<|I6`Q6TS*fMa|0ddG<-kjP@~s3{D5 zCd`Z<{xJ5cb=#w9)LbrqJ&he?{`Abr{ogYNZcHo z83>@^HW{4*elyjw^i21yOS}g)`1lyrryN1Htfjo@bEY{V?iV-bJc4` zIZA42aeE5-)j;P%O8lgYPZXP9949n$XLt($^OIj0gy*%&M;gc9;XOM=~M35BsY?t zHr&o?Cxi48PeC9tWiDsc8dk&@n>@rAt7P%#fGCk$t-&k@SG0h&Iz|6`qBx#t(#6t5 zic2m#{O!IhzGyjeLd|x@SHo&Si7vrVnsHjXVyZLrJ8U9KHJ ztV=RX;Djz)@92IP6Y9w$2`9Wb9~Vf?8M{$*x*N3=Ld!s1l=BEX#yZl*IHx=9%XZ)v z#cvg_f^)a|j97i`vp!kvW3=V(i`xfV#07^)nQ)x-)r`=&uC)Y&hQ|yE=>cHJ0!?G; zsbYJ%x*4;0ipY)cqq=WQHaxlNIaP~IH2_nm6wv&B2TAW27-7-my)+^k*vID+eE`#w z`EfN-0guO-GBK+gw9nXAiPm=cCM)#GW118k#fwVGcBs* z)fkX_Z{Aw@mWyn`?X2uWKB;rciRxPy5wj9D>r-x05&GH3M|9?cY`g_zRjV%UdfYXO z^iNAuZ_|yoF%%8qN1gt1_EISya}G~+@Tn}<)>QKLeG;bRP;B4+Sd1N;%JbH&z|#4H zBk|g#?@)i-3=tm|+eEJhf&)HCGdEzcAN%0~;z0zZV{Z2*a8J4BwEEpUi}hlWjP8hR z{Xtt#dg0{(?NHv?M*W4)Z%Mv>12UCVSCr| z5hLE%@SjEx9cE_r7&^v&WZBOyM^xkO8RuBVvg4USt!n2NvR|93aKCG3x5Q80PtN|# z%5Q_}F13JQYiX??K#y5^@@2xG(Y#hB(4mL(i z&{4+YvQVOCP3h9@oB7I26<)2oP*Z?F>9bAph2X`S57!ZMy%*GEWV@_mf%jo0u~){# zXT4cRlR+5mF%&pGZ%9!7}(m(RO;?;CC2H}am|!Oio>1q@cL!RnbZPy0dyiMc`zt&w`AK@zoVQAOdz7mORb z>k7REvK}B}DFd7ZTx98WK47;mGTOybC@|V~27o4`0 z1`y11ES6QL+)La}CfujYLBP3YCtazfW02k!1A=*`j=pw15$2xc@vK5yB>XkW`+?IV|e zEXVDqy9W;)vkqdX^lR479AinM3g9nJi>acj}+lxB{=meKX~tYCIkSW1-BMA>W-OpN>sgb)CoZl4G&qM;H$Bya@ee((cFMDXOXdR7x6BR zX@+JMkp+8>IsEbcqB5Od7^@#$rB81{$5cM+wkYPr zCpyUGuIgES?pIFiWjviePX!=razcL4GdkA^K)J@9#r6k;l#4vGOr8pL0f6_37l9&c zSEbUd^qW8OgdtuIn5&$RYEy|0L#E^q`Y>3*W6 z`OT(pt9Fl_qRd`lxS_vRPfSAe(w-YXGbD#l`4QPcMF%HefsE8RD(ir3biby+mSV0^ zk?*h?EZpBS`<%U_9eu7AgSo#nShxBl^?FCR&YlbRi@cdiaCm2?DhlB zHhh%z}9d+A;KiWb~(|D+rb*#LIKf}edn|q@ROEq z+hu?q<|Dtw+`O|9>G(*d=hYaatir85c)iblc_u9_2o~^Hh*ek*jNU!q)bten4x^db zYgu<^z+Swz(p0>>-}LSk+t~WmeWpPyDooPP>z6LT{pBP%byIH?Pa~ur$Onyli3_s} z-md7`*ZK+2SnSJntQR3)Qp1#Uk?SLlE^tS4F&T97;c;3rYSh|N<5XblN4qyR(qfXR zKOGHcp2welE^U7vs}JRIoJY$B40a*5KFE<+*wd>c6~AicJC`LKzsL+Sh50B%J5I;% zl+B^Y*0aXGeRv;sSUz%ko4UU*6Oh+Jub;8LDO0f zt+&&dI=l3bz2{!KM<=9TxpG9jrd?^%+dUHKViPZdDPuIpx=gtqax%z*dW?k$YO_|!tEWTM7JvgpT ze0RXhr}HAQvT;8+7O$kWt&_B^9~(|45=ZC7O)prfr%1}9N-4Y<^oUPl&UR|=<$|aH zCOIkm2ACkXKmD@H^u17V= z8YF;dBZ3O1d`vnM!r*b62mRVL1BV!47#ljeR>^5}Hj#poVQKASu(UU!pZsoAC)bUB6`)J}#!oTAFhLDd4-8Usj#7_|d>|dg0Y{QfD6+Pj z*?bXO)kY0D-G_57v!@j$&4G0IjKfbjk@}3p~}s7H)n1M6jtGEB$fUOGE`xG zwCJ_lPJ1L^cb1^hsV_KZ^y6*AmRyYpqK(tTWi?$WI&1&AH(D$5;~s!>tbh=C7LcW= z?S8Tzq?}q9De2%in7Sbv8#3B42lzro@N0DmW;N)@%I!xTpGOMkj>D}c17u6R={?PvKoEnEJ(*^Abuz zvKo^LOS5N*0a=_1m(Qs^bB*qK+F|Dxi*;k841`W4!C}ZkUMK$Uv9xwnWvYVD6qD6+ z?vv^K+QS|J)$GAUf;D+h{Mz0$Hvr@HlU=7mB@=psy^Lp4)v;~K?X2N_R=+z+S&!Ds zL<8$Oxf`Cf_N^t*j3~f}PPe}_aajeXJQ}#>HS^`z_09f|#aF~@qF4ZQB1@Ryu}^+* zi8(K+-J{hD91X<%Jx!y6!(QkQ?btl*UuEL#8Yu-7K7rbqT8Y0+-3o1<>u=SDkR5Aqo}_h?MlFvtYJ7mv9rjPYRo2&z*Y zM{jv_W4l=aicWa$mrp4m$ydA&gUW?CxX1S5M__|ZiJkRXGupr433zfEsi4lHo2}_$ z!ewD0>r0vT{VpHrK2R0ln#;7Lax}3kyT_wkaS=L;-sfn@3**{QSE(}Umo(ST2v!=H zper%@X{YB>qsi?C?Tb4pE>8v(9NSA1iG=02Amjl-a1WcletG$gQYrOKro4-CEr$)? zjh%zqHANx@a@2Y41x$lmI-16zB`gLN+`-P_Uaha|G&vNs$hN<2{^z6zp(4ojEw!A5 z#@rA0<@r{67&!lmr0#)#wp~BNsOdiCTN#;-a10M(vKLJQtKc5z2LVM_vZu859|cQ3 zORuO_;u?2zMXAX`SxWPTylHY^X8uh}uk&{%&gMIq@EE&D73F35e6DKvNFBP#P%|sc z%-|JM&Z7258pc_#_J}v~^)QWoHSYKP>>xU$guV)CvKnZjbHly%Tl zIEpGRfF18ADtV+{%VoJkiI>d7CpLA?NN0*f^-EerfUKKB;Z%c5ds9X%U|3H(R^z>& zz8-si(h`9x~r~=4Fb~25#dTE5qf=bSydw-18SRc=IVYm8Kaw8X=&)??OnP7yg#7` z|0yWh0r?)QAGo`<$I&$*6~`kD)yIpuGpJkzpbMUR1vbWW#q;%>4rLaB>-4dAZRYBo zM?Oq|=WlpNfQo{#m003j`a3B^S*PB!fSVxXTu#=hsN+YLBXSZcs9f2awq4d8mK0L@9#@Myj&QLIYhsc1ctZF(V*yv$!n3P<6Co>2&6Lwhuj))P;(9#DL7Lv8K zCg$BKLD*nR*RO>5UCMHn$QFJANfeBOCRgQ<7=JP<-eJhD+X)2?2=GH8YtZWr>NvQnP4HA`Y8Z`D9Cxx>ycD~TA|U9m|)Vu8A?#qcRHs@ zC4Qi?`;o50oP1kP=S)o@y!>H3pj8UO?00l>>Yvw-YB`p1T=@v?LV)C(+I{==4udq= zGFArYBFKI!V841#yv{|{7FvVjn#k4FHG&p14U5K!6uFTBQf{un5f7O{Z;VeDrX0U8 z>5pFDO01F@y9v~wUf|H|2AgsH-LS7eX{@Rt0CAjlw7r`!OLcl@VPO|%;_tGQlR9}) zIos9B5zvQ&GgD%cR-aX%v0Dmc&L~pwpci;WcfbMY)U11%3kXlmwWVb~b!IwZ@d8W> z0L=mp<-gvaNV;MQ5&**X#zf}G1K=1J9+1$v=jA+#Dm}-P(lkInF}lVy@|W8#ET@wwx03F9h+G1W%LmNG$6=iq@R;7ifsenn4k_;j(RGij3OBs`RH)o zvDR6O5%|_lgNWmCIeOx((-10&#eR}P1(y-k+M#5t-$PmEsYFRRudXubekI^MmeBxY z0pOJ2G_J_sbT@PWvuV{mc2C>&6}w2yV{N^?u3$h~CTqG%_%yLe7O-|*h5#FY!9-D+ z%H-jY2@3&I)i^p1Xc*JQ>AQJq*OPMRqDJ*1HOb80`iKXGxn7GemU=UFFQaolSeFE~%~gtqAOZ`zwV}j?ZugppC+wai#vPqy$n2#6-AJ z*@AVZ@|qw=(j6aK$S$^SE4&60!Ws>zP~6`m5xm*n=M2U@NtH7;Is1*~JvtF07HtyF zThVjVP#UJWA{2&g73fH$j5A4<{8<+5tf0X^}$Nb7}OQ zVFJhjG77;9RW-H7^V>&QYPj+&L4Jl$zf5OsOq77L1FE=dS|$^+lofLZqhWY4Gfy>5#mQy7l;U2`mgE&zSoFFN*Lw8&<#% z;Dpnf9=c$22}Hb&u1i(()-ooT<^M%es6G~$IFTFKzBd&5E`v4#o=`5oc6t;dD&EW1 zAk;pcbA|wEwWe(mkUZv;EpO5Q7Aq^Fi?yR?zg@1Su6R^wL;sbaBA@mkJc0nY#=b|rn|2%T~IU@g<}ne%Z`FP?{Fu+Ldf zmcH8-^~@pA&i+Qzz~jv^mMM`&lKw3w-IX5h3VnxMxn2}a#F}*rN+oe3yebQWFVVsR zR9*sW>c;K4we9}AE)MX5WMQRt>86hq-lsHc{SDeFoD|XSlr%}nvvu#Q*`wo=oImHi zOXzLTKz-aziM6mC1;KjAZhIL2H?fmlSQDBu30)7cdvqr#CqS!h-;b;l3s%W(VqoIS zV@AgVO5BFOEl>aW<8E%b0zZel)$42%HHxL2m4+-KN0T@3%^fw3^idcn5IdKRnT_kb zShKx2+`YaKi|m?V;@t7TkOUEyYM-8zTw+d8IRufd>AWegx8JsZ`UP%e%BovUe{UUB z8Dg!Hk-_WgG_10}%?l2`)J;7(P1T4X&}U?f#DP(CBjH(6C*Hb1#rjB(_W&s~iK8!c zGQ$RSY>YVyf{afq6{}%UA4bG0QREcG=fugZwSCHas z!PC9=yLQ5L-yDTsCHvFv9ze2SAotu2wSJT@I_%c~x|Z)2HTgE-gT)DF_!3yfrLQ^`}NYR=eT6Hj<|M`c?$}#Z6lr>WP3?sT3)%pPM`{c)m^4vCn>|)pw%F(N~ zsh)+zdC{5moHWlkg=LY=jzzDCjf`2o_@0C?qvR{@?oI%e4ld*9Mxc&_rxnN* zOD!xOgWfrE_|=FID@(;hfNU2jnb+hejMsAveE8;oLNO^Lmu)1g@1DN-%_+AZI~gNp@3EfWLhs+ta3 z!ZM8SZU=2<2~Z}S@9I5wI+`BT=#gF22^zIFFMUHX+S7su2Ko{o9`30o4Qlwjod( z{qMga_x{@tVLS)-FRvQ%1NOAc^>Q>?*qF-^7%KhX{uSTd`SE%2^Yd{FcLB@sy8@D! zoh*>z|Gdj=Yq=rT7Ksai*geeu-@Nm`cIN;6hyQdR^hie&q;aeTr@avFQv$eh+!s#%O}#~e8NSYV`>8IfQh%`^rSXc( zU2q&9DcAtfOe+&XaK2LW2-Qp1sAt}30I9A|6`4VU%}8(;)r+_wrey>#*m4W0&SkL` zWUy8A*j)PcQ|a&hh6R}2OMjc$-`zi#fB4?K+}8BZ55?nnkY>K5vt?7MH!pf${`ltx zE5F?T&E5a?vH$gl@)A&g4O-Gq{0I|lD#pCRNibEQ`8tC_Wz0V=+kY3tIRDj6BLlml z?EAW#4bPnAoFbc)fhfAlfZqG|gy5>Bqhg#Ajn~p^CTi z%uB#-@X9+OewRvDEZ*CpWEL2m0Zkrg>d(%CWRFRK>j>1Qi^P$GD(@$ILxx*NnGTyFU z(-%Lm0p}h6vndH;*5Ki?vo_h@IjhvnAmM5gEBLr;RtW+z@VeYAh3Q1|r~fQ$jD~00 zVJg-CZFUd;a~;@`2AJr7e}Itu-+!>m$X*R?5Chw=fF6O1o0Ye1Y`|K=+-E@k_ntRB zGs%B9O;uz4XL%YhEg2hQE=&mc`$E3WT|%!zwxQ$F=KE4d) zqRm#cZ3q^8^XgDx&acyd9Diu2%ApmxxL8O$Fl-##ZZyXsrsivR3z2a-~ z*DN(Fqn=Ak7#k}M6W4VBgYt{s`*25UsdtqE?;!X(B*Fim(YGI{cO!1$P*#G0fn8?b zzkf$*v{Q3~FK1jcIY9We#*{Yd>+ z4tH!w1z*q3UW|ORoG6@R2fM%_C;axm(;cGID)scPEu0|ODIjJ9e`hfNg{GUTw)RPT zY|TN~Eilh|V8>O{3|fClp!Ft>6=J+sZwK-o1>3mA10@luq4-VPs+E?-gpiyRqSG>ui*^u={Z=~%$ zH+;AP+5Nlz4dn4VGF&!?^t|1F4H=pgf~}ne;)qIXsW7?VplybR(5-^Ex%`lUz`t{C zX@MBu*tXBHZXhB2a9*+6w;Umylby}w@DP{>%Re>}E>j0!~Ck zbG8PaB1hynuDm$&%WH;%8E+8od_9y>;rKyz=>~z~u?yl)$QZzLB%XTkDg5(-`vi9( zDUCO8Ryj;DV#T!PmPq~&Y1(x*x-v4sTgn3N?(Pk$xxvAANGp&s zz=ml(?vy0K@l6Nj^oGsAH25|+rj>sNHzl%rdCaB=<;KNj^u}nq-YqFEentZt_t@N= zh_LW%FiRbykI%&-3rf5)$qB*o5E~)WIg6XkQ}lAc{vjXm4-NxHo2B zIj7PZVKNgl=eaAdCf8THzmYW#n&eok zYBoB>dL{Ra#z7MXiulH;DSXNdBp18!DrI@;n zMA}xo(M{I5PV3i&C^P-@nM#pa$Lzqs#?WwnkwFEln~>n(bXSwt4%c5$2?^;oUKD9J z=_S;UZjL+oV83?$J3I`wN&2|$C%Q3Sq(~(AvyHtCd@dLW0ya9@8i2z)$q_n|dq=C} ztv@5}a=!^H!IMFP3a=9v>ac6R9BDe5n&z`f@g6?degOelSy|dFum2eW05=1MwT+=4 zf{X&eK08?=LAROX{aXFExlcIhLm*GVE>7%JPY%OB2KaOjR0jw$U@C5J9M+0=Bg*C*GY&%yDj+8R-*$2bOz0E}~#LEdzFh}ol48;4Rj z=}Q8?d(T5^@U01VcMzLuIo{;qk?qEVkoUNAL<8+mYHuS- zyH#_2a{Imb>L?jFTZMRjH9c{u*wj?Yg-^@ua9c!`Z7czGjmLg23aIKG^UCacA?O}O zSDzB(E;~nAHkax0lrty}5^-964c1EJ+*KIgWqbo6f_Kbbfn>_a$=$`l;r(*wf#^d* z!d^rN`eA;!&3mALYw__OD-am7b|v%Er{YK9jI&@GP1JKY+);5e(#s^Aur(XGNs%H zm4qd~YPh+%y?y)r(T~4fvXcNyNDe*%2M0vu!yl?V(v)VrTC8q4!pV7t$+3|@CX8k_ zIcPxehG~*uJ#+4$(TWpQZ)%C@`AU->b?PPN8(tmiIXXE}9PBGsxBSm&f!q~37_lGv z|J8?C1t!yi5)G5^s|MF4skQ#C1-N6m6vyz7aG!+(4V3fr^wiNw@(+8x@b=L-=*{*6 zb%>4{==2iWr={p`M|?9uPj*Y{{{&91=eMH`HO4-*q{alc2voiMXq1q;?_nI1wb0~YS$Ia@y02E*mUeJug9%X-(%C?Kcy zPM09Ol_M0p+3EcJJZ6+ZdHF9;HvqA!olHc0qAeBWZz?{|YK?p?-y!F|07CD+u1XH5W`%)_}M*hW!{=ezkq4C zoa?i9JHOja$l8Hk^%>2crE>fu1N;gQaoO27>DL{c?9W*bI~@D%U7Y;DHXTf2Kl^Mx zl6f1aDwrv{GBAsK7kjU1>j2Ssa!_YN-rhMZQ;y!TUT8s*Kuc%5e(J&L(nWUK@MGEZ zZN`;w1fPYF-q*@<(F1VN+7d~B*`)!$dBLCKN2Omz+WWhXp^vPNql(nWZK5BY!z9xWMh2Tc#^)KfFj{#~R>mT1C@UR12{Vz%jSU1HRSFcm zpsR2O>U6Kl6<|QnOn>+}+r2e{BRRZQva=~ls@f)5QP?t9h4Joj$)lf=u{kMyZ+UwMIr zNAZXl!8X2kmY8VqSK-b2rO8`r!lV^AjCu9-=LDp(e)7ku59~#1g1_pJ@oz^!OfERW zIrOg@b72FaR4vwZ__^G-cBp#)(Pkg}kL`OmEzXe;h-5^@)w{kK+l{8d3}~O1@zj_7 zdcldYBeLAzlIVB8Y4Su|6AhIoHSMwK*Gj(wxm$A7xGUbs^H+uiaqw$Wemu>#p*0yn7ku zoJiYlX-N6aPumy&zC8{^nmTQV-S}Q!UKO*UTZFx;5-fwS@!tFnocF$R&O(U;nc(q8 zi8mlgWf=bIe)Dr6N<8r6wOcc}`^!Je?Okr)^pLU&V}5l5VzP_glHk0l3MB_Xl@S%231R?wZg zVV0`~VBJ@y2`JM3D*_X+u$LAl6!_>?6C;oXPQ!m$(OfJOM9U>X4kKQ*H4k*b-D4!FvAFH}_{ero^T zB*%tK&>834x?dapuQX&a#EWmVzmx>4$F@0C>I#+3!z*nE5f$KY3N3$d)A#Qlum7C| zs@(8jAF}Q3$>MSP-!9WPX9C2gtgMVdRmc})Khh#VP2S%QK(H~@6k=dxVE8{_O-()? z9v&_(F4AVJ09FwY5KIX?fj+VQ>x>Qflz~xtUIo6d3yi#mx;i*wLi7>77~Ve`i@Qu2>|3&+S>#Z&a$Ql zU8a~Y!4_!G$uaM${=gmlgE~XEuF=EzsF#y&4&Acu%EYEtZm0V9GCO_@6=HV->=y!2 zd;Pbf7#(^|^!c&5c@*H?XrQ}|*4@p2Fa4#1iCTU=S?*8XSXnXkOsy|MGrJ$KVV>Ik zN&X?#U#Y*i3^H~60OnvSs(;&)LPIEXUh`WYXO?rpCq?_q#fYKyEx_+#8XZ{4V8;x* z(eYk&^>cjJ!ra`R6OTdsU5Zpr>W!#-iB=>SegL#2;1vK%*fS^3B&f{qyguPmcsP+h zyjIk3s63oA!h`h>SWD?&}S5w=X-f3^;r11Ey7@_3%4=S?2gwD-l z%zE`dfhXK--HlkjaBOcfQD{WY6*WlwBaj!CVwnDE;N#)3+s+DNlQPu2E_L1=4=@!h zKitW35J8wnH(z!S^6T(&ay}4sHAdhYEr@QGky`?f!kX)2#+XKj#ye;;gsj}g!d&PA^VI^>3s zl9G^Q1gY1`D(qr#cBWH8ZTW(-sowI1gzC1cDwh2Vr5CCXAJt#8eXT6k*HbRH5o@BU zWitoZ4@701wQL^Jo4dbGSEDq4Q-MpK`9ZI*sG&GG$4Wek)PLsy-5DRARb%8!JOC+L z(Vyr`a!elN6YHc{5t?wWab3%Ik@(xCV!H3t&FAm~FAcApYfGQ@H(;p)b+(PT z-(#Cn1F`~qzBWNM5>sl!N%>`Fy=K23-D4;^J@u#7lp2UlW?~Xzn#dfxDG^3C*=W?6 z(f~a^IM^cpW$Gj;;V%)Jo9l;bKIfe`vP6;`Ug=|(`t=2Jd-fhfpWdwZQo&X?BK?5y z1Z}3n9X^X^_8ztCb2k4A=l#o<;!>Fj<3jkCeQd@W#xw9y6xm6SR+NuQ|3igm7&(8R zRR*)&9s9t$rZXE7q!63uS$))mY|6TK`-{F7AGNV<(5tcsCJLOv$t3zsSE!y$4hrjBu-_NqAl(?ZFc@2*&@!`65#Ga85ILQi7G?^$~kO2+K~w^s4E zb(p6c5@n%titubC|No&i&~Jj3gQ3e5>Wxl!Aw)#Q9e zQ1&fS(_1|iOSUP2P*hb-t=k^#(uJZb!I)>=pw0_V4P)*SalN+LaB$)waD2KEI6Z#T zvfm~uK4oV+F%L#es`YhfXb7fTH(L0Ewl{`tu&1ZgD1hpk=-Uo)#l+-yox<8z>6%Rc zLD%5iJ+iLNMTcF2el`)GdGXnxP|EwgnggI`@W!(P{|P+@aSv6G+P%poMTTn;ZRwhL zkz$_ElVc|&?Y*L5jSX3aR0dY&aq{k*+}u*G<&M2j0+FLYRsr6vMB61tcdMON^fL80Ty05EM9 z8cKCxi9C}`yz3w&bn44SAd}jkrPW$I_@7gHXS&Yie#l*%kh_!u=BF`eo>%Yv6k<;{ zQCXWQ6vRuCyW5E(E^xOIQy7VcJQC70d&OJHNOCoA-&(( zMPJkz_w-$dj$%C@${owY#>U=gfCk(re=8}~)VLltae-!WpuT0F3#GkW0lp80@xF3| z<(ag6xwW)s2DGSe?=IB&d~5a^>Q|yMllpW1-9Qo{Wg9|50)f3ZG4ii2z zlPW;;mW`QLyv!7X)z?AkX!|`Dw#F*2+xo8GxpPOoP)D=L>)KTtuhsdBDw~at3-=v1 zs*j>u+C-tx2me`rFM?LFUZ-}bMLly&I7RJ7xK3ptP`iZc!sw(?1-XPVEFs-1?9WT;oF4ye;1jo{XdDWbDrj7doW%7*^58d?&Z zdl=`8E>P3*cvb=QPbFQ=HO)28im9*Jk<=AuA5Q`fT#;J6*EW8feyC5XkD|Mi?zKQG zw?2<(-2_CW`O*QK$eCc_iJPn!qiLSX_6;tH6EyN-Z$#00ZZ<1%&@aed#dP2?tA%If zG$*M;>qF-nQ<84E!J(y9l!G&TNUea!?6fUt%7BH6|FXv{SBCL^F@KkgfKhDSrV3wK z<`(4VKeSF54NQENvy-K1IaiXlmgs+ULwgqSbnqM9@S4NYSX_$x`B9{iRJ^X$EB%6t zr$-B}8VwnqDwAVU`dg~Px5qwR2SQUGl=A7OAhc!YFBR4%A1ePTyhv~2v{xNu-)bZ| z-pD{UxR)~dnKU!|L`X&5qm~P3s5^7!uswd13C#>=-TZ~2&=$_Q`+_FafIG z;?HSqbgn_m&b~U-nIcmpQ%y2W1uG8?mjvJsc7U~J61lB=H0>A!zG7ay_;MuRo2AB? z>=C`n6k2tMVT}t+CWqI}gl9&_8*EL?em_&{tp`5Tm{5M1;sAYA&DW}61ia2MkMNAA zWH<@mS|vlnBQ#m|j~=12_q=jSMbJ!Dcv)}i7o5mAt~{g8@SX)5#n}T#ljYt#y(;6r zzeeBeJ2;co^qc)yn|$0;q0ur9L}D12+HN4D#(SFu6u0*Opk8~Yd*00*yV*R@{P0gG=;Ms1H2P8ZC2WtMLMc z*HfHksqq@Ms5QT0GlOom-8`tO)S5I{9imDz>g-U6A2p+C;g?1C-JE?U;f0J}T4C#| zQF;r{_lqA{#LELFKoNnS`NWNU)f(YqbvCs3^-?RoPJ-_xBuV4UQ79X=9y_~uGOmm? zBsSERis~246)y|r6pY^n(Oap zv3X0@8k!WA0X1p0jr-n+?jzS0fjLr-w8#Og>E`Bs+5|<$-X{@$`oS6GNkB6z)XLL^ zKmvxyyCV@X>OYEsZ}i^E_33sb11q{vaP@tW%2EWyMJioC>lYvvX3$A>%QqHgtqJJ8 zF^?maqm|vM^Oj1D4Er&`@%geK9e=OMFxX>;6PV7${ev&t@zw{F_pPNrbL}MKipHjum6%?3a%d48 z+iHgERUvFW=NiHK=BY?dXyP*lm!9iOH{l<|L<50eoBI4%R@YpIdzWCAt-`r>Iw>_G z!6q%V&Fb5|@gD1u`_W}Q_lUTP6@;!S7$2dQ91t@zXY&D+<4en#>FIq9D-@6NJ}_*c zda9G^itn_GtfQhxJuUlss5xh+JLAY?hahK1jkE#|2On{8Df)%^* zH@cY$dw&x55O1*X znsF(~x#vDj4CKf`&URl;K5gNtn)H=Pg zaYc@`daP{g3RqUWgujzF&M;jTS8%_-6`X-|UhA+V=!deS#BG(eoQS)p>U{s*3_)0h%TRcEOMc}#Q)cZLyu1O z_cqMU-_k5Oy{Zh|3?kuE_IOZhcvcJ6cdtO>&cS*ofr!;AIB^kGv*L&Q4>Z^?CB)+s z4-Ryy)mh4T9_cDN`)P80C_Q6yYOKbQg`H9L-znTi_s#WqM=6jD4H7P)7E1!mVKPhb_LHXT>pj_(;(xO@==pvSW3E~<1@ zC)aQA6!R`QJglYW18b72xV6Ky_E(gvD-w)SF@=49sOpx;nOVS|Hk7KZE^n3*6wLuY z8n@L61miwXo7VI$B7~C7Z%AWfX)@`_lYr;zWRR~)ak^AR-snDebU*J&Bg2yIU#97W zBRD(y`3(SfMZN{X|g%qL|Ez)biMRAnj`xI{6qP;itNdOc8;NW z3mw4fDkijT3h{P_zamJ->*<8<&ZN|{JaGuj@RLg^vjIqi4|}=Rbt|82A%hHjTAH!+ zL&Y<6mlNj$1L2pI7xE-!I-7+c;JDcHfpZXTocjRZnuKLp<7 zGPt+3#Z-lXT&kRxFEsN8j$_|A(^MKe4x0)r#L|gHhn8z60J1-=;LX>MtwajcIcaP3 zunVcf$-4m-V6K85@8?%Ig29$;H_BSbE(9}M)9MF<#VQ(@pUROD+oyi3+5P$6CkEy@ zPOnt5Ldr^-PcKQKCx;HK@sW42uS=S7s~9 z>K!@`7OiVHb!4?;Qk#mcdz&&`ru|+`;d08l#wnjm&jlM&r=?5&ANKw;s;TY?1I6)G zK}7{cK|w%7M7q);6cMEgNbevby|*A86+xs)??rm=J&*`UZ&Cw<-diZ469{*s^1i?S zr~ijr*1Bum^MSQOa?aUj_RKub%$dDsQ0^38QdbWZoKN#2aXu+lQT6qLiZj_x#=d$> zDHfVIZFk&r%CCQd?#}Cg7?Oi&UFqI?Y?oq`;4!}2>{0&9`vQw*(R23$Fs4u*%bcC) zB)EoEGr1SBK7BwW>SQ0ql$IggNoBt^5`dYN-t0>sQ42Y0a9xpx5rLS*6x<(kO14IT zr}7$J#^Vk5o_O-Ib}hO=>{=)}zxLXE8HMCu+-L>jzP(s%Cybr!6DMO1S;!)JF0gg9 zH8b6;Ih^C3-tp>nx;O|F%$j~?wNg}oiFr&`3X~R18HhR~Yiv-$Dsa;YasYg_`^!uU zni=hG&;vyiEL>4&xZhv_r$3j2S(R*8$-U%vRdshGD7?UZw=P30=yiLyuEcny%s7*) zgjYB@Ah+#It}Vg?NPM#u4;8#gyuX;@La;9g#-rc@l=ZfBL>d~~#rdpPb;V)0%Cyt- zPpW}jT(gW2FQx>Tb3CKaz-eeFJ5n*xh9HRqdK30uH6&mrfIC;W0zmQ#ssm<)t9i-e zAuD8H_*_*k=$hGhDADm+c17-9q499TE@dDIm*G#)(?G}Lz<}m7jM*lU`#RyVWoa)H zk*D?)L<+VOfFCo!;9==eeWst1#R6|Vk7E>~ljEm%FgV=km#Ft&vOU)e0eU+;GmG~l zfgJGAYn4WUe$={dOCdcrfP;mc+*YJIUJ)f&ec$$56@O#_bPP;$RWf3HYBC5+tjv(= z8X1@2i<4hC0=R5=!sWs2qvus)Mz*o+9N(>k(ZaahuSc^zkI#c4%(K)8n|54Ep_EG$ zpsR4G*6LeDM=vB&^FfvJE^edue4dH{Wq2`@T~zCiXUw?+*Zb-{#*sE-dE!`n6cm}} z(I_Ps>Fl^yjyC^2m}exQy zU{E-MI+Ac}1G7Q6;rLo_C9fTrzuj@yWIPoh`}kP3$)~aiRtdFt`+y`1 zggB&T7D|juAJWu-%mR2w?sP4H{(0OIU|w?0Pj)Oj0-?c;OhrE?IB!P(goOlB4upp% zgrCraI&W<6E)T;ZJ(7e88-H`;U;bs)HZ$HMTuFS`9i=H>Mf!pKe>_d`FJ4<*owtn4 z-(8=e=F$6jq@b&)A88pYxYqEDaA6_^nJ4I+qYWCvbow+kzO>9(9l1?HlJfQ`NC`=p z0i8NKKyl6Qx|ZLcJwe29_66S6)8+$zk2k+Njr{#^{;U}d_{a%E*?b%4 zK>yW>{(P|l6y!HolY7)gR?uY>X}cY$>0{>u zDJw&RgJe&`QY~t05oKWI)M(wG)aq1kdH3E5B7piVjvvu>87^$B;jMK#In$JSz!Cecb!L6I5UPkyvHa3{C7 zvpr^HEy!f%RcH44hR90#ftPY#Jxj~U=`%49tXqwMsOaJF&?jalNJdg-W$HEMz}H z`BM1(hTb6UK6>p%3V#d(N9^~mMJ6t zvpfE&epy4?9yT<$_Z37IfFf}|_spIZ#oaVUk{i+ryJ_j^Y0}YN{Xw>uq@7;Q&0A1Q zo;SER<{QGjp>m)F2AXTG{@T7o(_%8Oocek3R*qmqzCs&ZDQiB=Ei0WNK2@yXWIIPt zOwwOL1=>XbD(E``{NW5VFAk?Vh=g#Xk4f3HU%+eHWM}>2+<6scM{*zYY3|lFC$-W{t097+n?D8J2qLWJ&97d(?i)E`SGsBn`f_- zQt!PCi(`?Nk&bLgh}T6|og_e*cl0A=JK`tv6e@b7?v&8Fqz0vyqwShoivwpR<|JuL zfpMh7fXDXs-VW_%Wq^U_hrJFMUyrcvbcqM+mU*nuKYfN+=bhQlZ!FVrbws`r@gwJ>Z?N94U zi{x^4Gu5aTg*;7*b7S4BJScgc5MLftrar^GnsB=Fnwi+_`c|VPS35^}xT=yAS95@` zY!t7KyDr6@Cq{!;58i=G%lNRiVz1C>amGaVO@~(n6W13+u6LO5WOQ1C<~)CT1O(B^ z2paYKVq~gF=6Ke|TV-SHh7jOdUJ|B zpsk;kJAHyVWIOV4@3)uYFBy#jO4x&ujv~U~^@*a<2*ziTKR89%FPHx-2i^nC>PlV@wGgTk>9zk9C#cAmdV58k^-24FB(Ry4sRXdFt! zP|3JQn>o!rgxSB9;@fDkzxN7Q`aPe=6}coOGYx44o^n1^(^$;_KLihL8v~EE zkzmth>f2LanP_yiR0^W_GT3E7;Ndz-9jd|z2&1&(D7^2b+mkp~bb7iOy6ea@*3MtKBKWFaIrl1*G3B%yj+9u6#{X&Zk=U2A0!6{vUk+Ul)0+f5Q z@#gD4+j8yOgkqaHy#s>&L#-MBEVJcl2hH1H+j~Xp;-SOmytWdwUK^VjTP^y*R#89G zZD(yAxWKGLOikD2iwsx#7-T1y$EfqWJEO!8=16Z1+&qx@9;4nC3^sY&IbZUhSi5p+ zl6w#Ffp4<3u=xzYvsp^m=em)U1zA8-TlRD4($6cv#%%)?UMn#hv7|Ez@Le{j14GVD z6`#8ujv256h<&vISizi#2Jj0j=e>)IgES6XUZw=YI@`LkcGd~f|L1Pfd<(I|9ghGq z?!Lbd{wi$H7Cd?Ab%*?hp@E?Qu;}>m?#>NSQ!noe5c^^{J~{v6SAYsb?gxb_WcREH zAKO;Ax&apz!2KFtatc>sjsTOnPzdHyk3!6sRB;E8e)&5S);hLd9(YN}NUL5KV<^Zx z0zjtHgcluN%*J(Woz5Qd8>;9N+mH8we;4yoA3`O>tLc&7Vkr1Tf?1iPpuEjcX10BJ zigSyH0N;76uo8i;&qY7V5XgV_zR;c$3CP4A_pxeKZ#Z%C-X#18@_?pU6&S0flz>!q-te| z6-4F-DM0~!Vn27~+T}nB5{vTCERtrAjm-sxdL^L#tI{&Vk)|V(qfy2T`$bBx?3LaH z=vXQFZ%5KvB(3Jr(CC)@{14w0WBF}r*m;2jPpQ{SE?};PvVN+8xvm+MsstIZ^1iX!P+d7)z=z7bO?&59d@uFQ%}KY$5!biz z=qT#DOFqoH1Fpu(hDgd(YYRx-OPdl00&%UW0WM7A;FC$T##p6|D4HDfHXOqpV?lKN zO?TPMREhaC&GM{0)y5_m#Q=jg{`{G#b`=j*i`ym7nnJca&RguniFdKa59QY++oIF+ z6d?SJA$JFUMMV|RU7eWASH08{r5jUp#&!(&&FklttvIYPKQ^3t{zNY`r+41@T z8mB(Yr+_Mmj81dI6F2)Gn*Z!p9J8#9G#j7hqgwkO<8;}31(uS=(f?ieb+m0EAQ(XI zd@KoB%Sl)MWeRvo^W#~eqr01!S5dcC0K;f>{`Ei3K8YQn1J5!6XWk{hL3;N_I+V}2 z=fCTA4i`5P#;1}n0k1*wC=iK{&%6EDljVP%DDkYA_09jD1MmOocvR#xiSzr&JPqAU z-Vn8uvY8*vWZS+DL>V{dQR6as^WBKD2W?^(Us{?p&jqzb2d&KB`Jbg)=f(cU+4QzE z-j&YBhoB0!KpO$N06>oq11O-21CL=S@zryrXtaRNO8OT8vXu0qf@-z+}O)89)#fPT*}m#qvO z=6Hz#=Ad5fj6NJNLxSO z02eB@vo~t*vXI3+Mq};E+QB!*<}PsVSwPZivrKM>hi6CVgV6l<$gL|^?`cB=W!=@) zT%{V{g8wOPYC3%$9n^&%HLh7HF*ltV#iSZI(?zjwHZp!}jAWWVON|J`28=hS=^dbs zk-DVu{PB?<&ueX&f45cz7Yf_~7ub$ulSV_)BaMNSDLuyhEa1g;(xwUUhx?MCel&Dq z*yVm_+pg*FUWnkF>-NR__Mol_(_V->=68fv6bqgf0j2jCKWYq&)KyVZVW8h}I5V6d zAK=m_@|G?x&R#@UREtharUnl7-}~&Y(<78{-65f8NuI#BoU@MwIF)`sVBCv$v%hxp z^A%vp#mnzDO;%7m?0*e^@^RZ`wHiS|=e@PG)4UX37p<+e*C@1{Z{UXgg>szT?Yd3zekl%PaA1%q;7nGyJDjh7){(av6Ri-?QbJ(CpHR{ zXEXTaYnxQnSeY5wZ6+|)*0N(YwQ1fMk2odqzeM3)a&obhrQ_;i`rFg0$gV7~08K&k zKv*{WcfUaJFL1oBW2qQThF&&2yEFLTzu7Zht@ZKRepYb#A4~iD?{l<2-u)ln#rVsZ z(=_r8{=YOE5AW*#GJ$7=Ws~Doz`oWddu7qjE&mljk@@CxnimHzYeznVyCq%!A0)v0 ze{ZrbDQ^ViIR74{ugxYV9&<&o=ww>b{i|lg1&CTPOSVeK{I4LW#rpyMFWG^I_kTk! z^OtRSL>Omm3RnU_b~bUwRh9@AT!DxCh|Mtqv8$WneGRI00+tS*DHfhaerl?E&bYdu z>Cj|Qg;j}FHx@B2Xk)$|%9OB;7??mcH^bx4<4yAZcgeMyg>lexbs2*p6)LnAt54Ns z=O7<9GLdW*-Rq8x4%=5$i6EYqlRK`Oa{CAGm+={9{<3w#?)!fsXDved#R z#vZ)KmdiKb7dRU^C@Y5_86JgYK_B11^AvmW*CISgSq!yuxu3i~=*sHL&~;t1B54*| zKXI;L5j+ZseoCv?TTeg=9wKbradl|3XO3xAoe4O!GlTMsU}Z3gSc(-kFz9?G6~_VT zX*+UAqoV_ZX15$&v_eR89NWJ&&lSwM0A4fxJJd86`-87QIx)w_s%>ji!8gF~-yZhF z7Ssyp9WCzhSd{jor^TsCG(l@?&WLhQR`ut|w0dj4x=RV^a0j(>6>=}FMyJChMldeWL=or%-wS?EM+EjB z7mqAZJHa`p_%1CQt-0;-)R5pklP>)KZ{-e8Xt>voWhf{{B(+w-pke)>AN!1c{h#U} zydOVUQ$B};tQo(j2V?zwHr6M1h)IQPUnq$>FZR@80b=iF6X1C^olOVcD5u4UzxQea zFKv$wu&4ic++?~7nZQtr%bxQ(Zn7b0=oBKzsn7h>2Eh&$A14j#;He@v0!VH-Q%6tX z%)OTHsi}}vO#oQ`1*-e!t*8?(+Y~vBNmJb6WwD8%1udbIo|Y-Y{!Z0^7ED1~TPGEI z+ghw|MjwQ3`F*Sva()GjkohF%$@>-~)s@gS1MKbsQ^ApnL!-?Op0%wufBDMtpe&m4 zUf|y+F4Y>Cd-+n>QW;lW!&-$KwxO8` z-U^$nbjIVY>iH0_-yjI8AgBIyrBC#G7p+k|fmex^r_*h;0H|^Pn-Kfqf4AruQtDV{ zGlQCWPN{JfJnO%SsV6CZv5(jVS|V5oE)aNKbb?faLJo3*GvU2S2+;R!x=IMOr~98v zdd9NbNe{4|lYPkC0t@nxTS3_yuk)L|J!#4!kdbZlr9K6bW&gjAIhjr!bgNsV+I=A6 z6TNJBjy7Rj{cKO!RRMAi*EcgtAJZ3G#!ps{G!^P_0jjLHbSMkn8>YWd?HN1YednQ< z1diEZ4a3!)Hy-a?DS`f)R9tz(jUPNxaUJERUVzHgn7F!<1U`@Q*>;wbqi&8qxGut9 zL;^47!r66%)!2DtO;?XuXO@uVU0^U{;=;!&S*jI`nQ4BpO>LFQ=jzVk1V<@Ks5n{B z{PuSRoU@6O4;7T>_gqf4de8UXe^|Ei&*Y0iIAYUd!sTSA0-34ZB4Ytw<^Mi7<=W`) z6RySQyrpxvP1$2Nl!PPj;D1mnpy<4IJS(_PzkV0;;Apq2m2o*p-K+wH8SSUTao`6@5|=Vnc$ z6N0_lowXAN%uenzZYL!UC{^)0Uj51Yd)Cy%_ud@3^H>G7ru;*JpyK4yH)P{*&Nx&U z`0fVb!SON7QE%Pxy6|K8%wgTxTAxbbq#IckZSMfT|{K^ykE{iG3 z5tzo|_H^1Z7-xqz+^~m`+7i1gp-+mh+z~T0vAs^Cmm4i``H5M7oKc>uGkC4}fvw!~ z$gUUXNX>uT5Ga;&<$taS^mHDcT2yAaD=mv#zLqGbv$5N5w#RWP%gK)#^5Vc2NF2=H z03*IkV2)#=e5et!dbr2`Q(~^u)FgPMGocm~19BlYFcIkSZKJ6rt?F9RQ6 z&Hg4%E<>)pfVlGP(i9m75?LUpy%&N{bG#63GEtzbVlz!3ehVK@>g;NR%<*Jnz@Z%P z3hws>XXv8%&6W-wsE@Zb)5hVSzi-M=-5%;hfkpJR<%p58q%3kF^vQr#^Rl#Z^u+pc zw=~gT%e?yhpZ_SppuJ7s&mhX)Z&Y1j2`<7;-K7Mof)&m@pT5OZFMdC64!pEJoh}a} z=2T9gnQ8D2vXCHZyx5Ew1#MsjIM5p&33;r7mId{A&j$ZZ9>5vJGQCa5<>z?Uo5fV~gdb$+J*wFjhvM{R@#7QX$ka*+k_1-~f;oUA-oM=Dmg=c-BmKM)g>h0UN z+gwn!pwj}YfJxvWThJHxx|EA)ahjtjX9H;6L#nSs<+g+cs zED$JbBPF01ML2{s)il zFPPw&!Fj*!Nz1y|I?Sp=ufNWR!pdrA7>^2T^LH9PbG@GdB3+ab7>WogcSH zhz&4{cxbTq-Nt~$zDAjuq-;D+d7pBGid$B;EbPL+x-UX^?)BJ5mxXeRzUoiXkTSw5 zP^*4A<#@b5LAvTQ@f_KXDVc%?0AdgL9s#O?8uCB@`oh}&gHuRTQyPqZ?ixkiz+-}+?0Z-YcOVP8 zf5=}J#HTM^`PJA%cg|D&%n=!;Qn8L;wY_&NfHHZY_D_YDIZ#wE&cMoRX>cC7OIZfC z(F>|A2|fAt|Lgko#|Q|R-GKk3bv8cnDysVp(+}}v`oUbKxm6AHW`L=x7n9kccAy7> zLl< zV>;6f+~nz8&DOR#0+K<=;W`Oe##N4gUaJnIH4~vxS+31M6A^X#r8b0j4ZWPz9IU?d zOH{k)RaB-q9QNBZTXe|&y7b@0PH-+8(`lwzg7Q65ynFu(ZS!4E zWZYC0bTx(mhy`YqrYH8>VPQFK&kc|B&^GZh#lxPNN~KBbSOegY z&$e#ZED)Ai^*;vnu<@*pTO&LX*Ab`)zLhr2bq2><&$Y4yP}Q;ee&!k)Wa+I{!73D> zCbA{X1<_9FmgYDTFPtu{`ubZuG%Ne)YmSez!9P19|Grk~)Oz=-CJb+w-AFq&XCM{{ zr}6q_`l;T#>CQFbkHpEH1Iyh!2*xr{f$Jr%qP@20qFz)N4mzJZqFu};hM)rrcWk{L z`J4qWvPSQx{S;=fXgL%HUVG^HQ^(XqW1#-Vh;m{mYE1~I&;Ukl8Q1oWJmt|N7v z)kObXxK?|Ad^;QSFm8&z7qYch)zFO;MZpx4%x-E-UKDtrdx&;OyiB9x%-&NW z%~aNIGML@nE)%(SoZ2*BW+fo>-g`%2MrlnXYifQDysuQ;8A`SHg$pj_I6Q`rY5Bt4N%=olRK!=K|p~Z|Oa1v4k{U z@WqTlH+>e1;rv4_Oazz0>HRlpKgt8J`cn(w;%|?$cds}X@Y7Ktq`-uFrK2X8? zTmRnVpsC$$Pqxo#L)7lk%e%dddUOsL~L(-rqwmffRV@^cR% zw<8sR=H=xym8ArT1EVNO-j|p=xXIuYGAN1JrA}JnYl)CV0iAg0ekJbZJ5X(OnXsZ!{Rm2JMr~zD`lPS^j^kxWrs~!SLfCw9obe#1d~J)gL_4~ zQ;!t0>6g|%k4;CkL8={gs??o!_$Z9hunx_-j%!1VWs!N~1_m)OZq=NVsyAQy6ZqYB z^ZHKArBBMg$yQ-jecQI^qJ4H(?5i+518al94qxj=wDRDXm5MZaclq5uT4S{ws;O&1 zedL(3K9lshahZsGLw#BiZRbFp{(!=2 z@O!KUQ8)SGh%7Eu#(14|Q`AVMgtbPQ<=~(38_4Ev$KV`k)Kpz3^i@LWuSBMAbJoUnSkITHV+V~;z#W9tg1TK7VGBNs_>iD zzmkBFvtr%bfzm#nP}<$yhhaNaT%?t4*47+s@95i)X7w2nGdTMPxs@KH=+#|nB z@&IWjcej>J_bFJ=go&d!?=S>z#SMO-JU4)?P2>XV>eDRzKFw_6aA5dH!ENZ7GkMe5 zD9xon3thDaPHO$bYSDQXSz0JBOl?GAJf|w83oKn#J;HmrY7;ulLu1xTR%qs7 zslmx~Efwsb-jNWsQr1`4<`TlN^@n4%uP@OAya*mY9hOXd!d+g6s^RU& zRtsiranDAMwIqYXr~>@r%^7$OxAW*QH0iR5=#e@Zr_p#w`EuY9=S~rqp(A2{#$zx~ zBg<8MSwv_J#U^w(iHT&6FH2vzUsY>4(AFsDqTU+)F3;HutbR~%0$ko>+7rcW;gtVG zvr08j5G4^!5v}tSOv&Er$258o~3ktJgTjR5z;`><6D!fdT{NI4s}P|^fi-I`CoZd3Qr34`aGy(EDh`P4WCgd z8tf`0sc1dpgqvAtFEGD=(D!WUm(ldc*SxI+s@(f$dk4Jr+0|GS2&Q4HPq9VCX1Fwb-N`Axg;C?12&dNz7N14m{eIfPlYikdpVS1 znbDu68b89$7=ngt51P8TnFC53SNe7+EEJDW0Ub558O-j&W=ti7jDHd9h|UAKCJ0s~ zp{yuwE(;3`<>fc_&$J<(&!KH^K~%7AvIbq7H%)M2G%u#n6&JU6gK_qIIIV+z-Ejp= zHa6#nUPDJ+iK)U?2QtzgN?`wI(PcCM$Ompn7mxf7KAi{g^0kO&!;TckFa3p_Mq@?( z#|mJ}^xe$|=FcE6oPxe-JX z2Q3B^lojon7q_$_fUxx%^FvZnI&?Aq_e8+uY0Gn?`Q4zv{V=6iR9|RpK^NDEYInR8 z2Me6|C-{E`mZ(Ze1}(iQ1~51i;5QZSd=?L54P&dB{BGTv&GA6pRHN;-w?c#XwcGEK(@IX&##@3Rqt{u0JJ5{c?1nMvFfq858ve;ew7&4d}v@;44}LCSoHeGPXyDrk_g$P;6>dWJuApQj&Nkt=FZmfYq(ej%al-$w5iz#Ex8Sia z9RY8?Tr?BeMX7?+%5!=wxarpev8c)IR7b8IJ$34OD$^}e_K1`$a5dzFYI;G~2zn3= zJPeq6B-MfB2s_}i%TwT{ zzqA39so)EDd2QUn z&F*1Sb0pGayI}RcPM=1#7GJY;X)WY34e(T!?hA6D4VfQ~)qNa#cfkBM&JG`H^jra@)R0cMdYXGY6xg*>uUg1jfWZ%$SyTo3v}ddXL}dbm*Q8*%b>3y*Dl#7Alx zuk{~A&vS2hyfO~6t5avw9R74W58EV!Tf-5GLm5{00`J1r2p&f%xhC_Q_2>4B+)(k#0IVX2hd!{skm4ZbL4tK22< zrXBpM;!u%S>Q(s)U^{{rz7?`O6+ zwf06R{cu%D%7H7@$@`K$jTN^&*iGt$oiW5-ULZ->4E>40;W%vYOHcE~x)c%ORoC^r zZTXGh&@M{`^;hsQk#?9V*FZE%Dzd$6`#0ehI)_ggL4BdFMUMcPE6sP`-Js)(y9n_; z$JN4(W(x>;D3Qx75u~1e=C++7i>|ZmaAp0p9$#aFZClfA9oQSG#yE8m;#`f|`8xWF zM~P)?d$FJHKW1P!K2&WApbl3RU^c=;9eq{w>0+UXb{%TUKHN}07?38_dEeAhsAc$C zWN`NBL4_OaL5J1g(LzpZ#^~`%r=Df$`<|Cb)~K6-Mn{=7;OuetzHq(qzE!VRRG|p) zogQ{%{bfjaCdM>Q%Ut^9RKsZ(LF!q9OUSJycKip zJ1HQdVw=ymGp=iwO;=l|#DK3#`D+s`tK5W1DrUkLsoaeXbSxY&dYZUf7WTIa%*ZZ? zOw@@tqHAJgY#>hZW%_cabQFsa4BPbXnq$R7ghSm&ruwE&M59%E2Z;--R>!i9!*Uqj z*f!j1-HE6n0#UY9sHq*s=2mzsr<+>q$x@Cg?%h}#aw4IIN8y3I6N+nr%UmPY)^+fU z@1~wr&9;3TtQ7^J>qgOR4C|#dh-qCJ%vCY_9^x}r3g~BiRh~WH?|i^BKT}~`+45!z zrhdV#TOhI;+t@ZBcR{2OOaX&3R~h!YC8K;v#ZxU`rmG(m5>giyF6y4NRc;)%M@)pq z@qO;@%aBbN+75envX1N~5V00J*iL`R{pm_EZoY=&)BVZ?xb9EY@$!_XIw|Is!!2Ps zGE|`+Gmh{ZrK|NEVmh@CM}A>9%jC4&J6U*+W~1qKhqO_%uth~#US@O7_=@*s)rAVF z`d{%4xdP%bTOUi>Q<~wM+)6Ua9ns1*%fC4Hroq|fxuynF`MX`NnP`%sXdQl!_>sfO z3}F{$^NOPEtn>Uw$Qzn9i^*ZrdC4DonlFcZMLC1UFr5Nwa_+f_aSGeRB`i95tY$xd zs<6QkmR6%(l$?ymbvp;2W(waqcJ9trc*_VdSxz`KJ5nFu4zM~}p&=%8(t!mb$O*IZ zzDjM?W3fKHJqmZ%L%j;=N{+s0WFFjg>FX@sQu72%0Jf}u@ax0qQL*|~1GEp1?Rw~Z z0-`WLy4K-Y7j7i3f@jsmrW1vzLhtzCHUkgz*Q12Fo#tve@j*u?oaf1?%G?3X@Xi*+Q8zn6FC7U@TUidyq=_xoB;*}9|^UhzI+jFvJVQ{*gsB9R?- z7`xSFzFWM>z>>x5u;>+Hwx)gTQ@CQyg-DN`yUN&drDE5~6-}}bC&+M+_bF$fY*3ZJ z>-HNF;(qr^M4En=z)q#1t{j{!c6{imyON*uxWk)yeT%psvb(*lD*{_>Ya2-HG94j| zf#(YUCh|tCyDbNkR=B^vP}jU_1-=MVH%!=V`tf6ROpF7p-0JSW{7y>(i+pR(MZ$dJ z_6KiT2OgS4kon2*I%(|tZBL$e)PWv`%-XT(R!{Fzka`I}x*6_EtwnL6Zgh)`if?H( zeSn2vw}!03s_LCa&N0+>i1ODH(`A1v!HokWsxR%vRJAAbcPE_hJE;%`9={zO$1W?n z$@;h5+cM3W`I>kmEtJT8CuwDNKqZ5@07*Iherd`_MTZ-^t|eD`BoL!%$ieU~Ji@Iz*oSJ=P$^*vf{u<7#ZJGS^L*&`R!RA=T$a)SqD zk)eLxe&drTD`mD=(uXH^*!rO-Uo~egPIKq!l5zL4kquIki^&|%3kwVF9er+P6Wad~ zU!le4(!8#c%B&Zu#oez@+0se%Rz+=TD9iw|D>?SEu)=*C?aK27V%UzVuk*CM`P!oA}=;e0r}1AO##lmQ6= zoYQD9d%&zdJB*_(BQl$3&jvT*E*vUTH?xA`u4Xqs1!Qd34aU=w)Cl@U9GF7ZKE zrcKn#oI3{=g3Oi*uXnhXxTPijU|mYnM=sS*gmMB0BceIGEi6#wKBo^^tcko781+q6 zlQQBlmkcvG{=MA6>>PJm2>KC^MQ}}&rn&A(GOesGrZdaVQ7IogrcdO(BMGnzF+CW) zUh7~_XuxC<#E-e+lREefikN07`4}Yi1&V;BP0o-&lI?AYNAF&!vqB2-!;j3S;8L5W z4jFNL746NT+B^1IV-6Yz>NDxesiP~TeoT<>!>D*2B1B%T*YDhC(n}lPrpa?|(`1T+ zxv27#q9s!YmVwPu?W0-FedCnKB0AcJ&NuaVS#P^?w+!R%kSV7UUDZG*O9Qh%1b}~$ z+M;WFmU=>FT!vo9!h9xTq*WjD>Hd4mnTY$B0FX9NLuOjZpeNf#K@JD>rhY(H(!HNHMdXPb1bmt!j*A>4!yHyYKHZ@DX~Q64ueHkF=`tr7=P87$*9=x(N;A z1gzU?krwYQ zc~nT~vQ)qF?ghc}9p~>&Zq%txdznRw4IiUqR*(ULHiP+S&3Yukt@vL}&6`zjMEJAR z@STj+r%TBxLN4WvA9QW!`*Y7%9SrNYoh(x{pDc?8j-VPNy?H zJ(eadQus|vUEsLP1rxH*?Ku`UdF`z7+-B~TMSbg3E*l+^x&h~FfcZNd2))`V5WYR} zF~nqR8OFiWHmpmrUJ@QRkk-=*m}d#{^i{(%te4r~MQU^xM&Yg5ukxdrs>?FLTdxB5q`6^Amng zd|^PDElqg;2h4X@M_Aow3RSMr123;tMX*{-Z|7^km_=)AHB}3G(ZX~Ov zzaVh2OQL0m$i%Ox&!S=#b20HX|MIdG4Aym(LF&$}&o?C0?%#}jkd`^@Wc_JxKg%t7 z`8b0A>jeMW5Gf)nK9TGQy-Lymy`y_k_yklL&_cf5Njvc0wEb+d_7VVyRm$w;)odMp z>-haWsAw_;)067uf=`BAEPBI8#9}F?q<*(6lA4Hu1zkXL!syQI-a>tEU2*a)t5C}pFRZm4sBs&S2sT1Z-E^8#V=K;!_3Mvgzp=9pwo9&M&6gz76=XWYJ!tI zwkC@UwG|X%xRPZ=tmv(nv}J$4V)&KJ8zt$>Go7^9DhvlS;O<;sbI_rh>C;S)?f$v= z9zI_#S+mS zj;Gn-H7kMZ-T@!dI#uPGPy?wyiNt03A(q0nNMTMGOaZXQpZe|7X}wJ{ImXVn}T<$kf1V>9cER>Ed32xdExrx8P~h3akoeJWbWZEd>TBSLmur8?pd zii}MsJ=S8hXj@QdH;WO2h!Ec*YF7sg`~D@sZakb88^Z|p%694y0^4u*f16$W9hK+`hB42ZI=rEMI+Ze}rD;7ztrmZz8PYS^*eRvF&=&?0C#? z?x9z|kxt5d@KC=9-NYhaMzqODfirt zx4hyEGh=Y3>;B+pz?SHVAO(hfr!hc21RiUsnx}eFxeLf_js1!8X}AGyyT4u7SK(oY zLh~?xAxhxYmzPGG0BB2#YzV|@NfS7VVGO7Nk)5^8u`Zuk%~qaT9dmE^7={`%>Mpk) zuctQZN{Bq}xvp$+>YVj;wd{4amakA4@K544IxC=C*p1E>++4_ z1UAz62-t9Qcl(;|acyw8m3+FtpOpXI8R^q)F^Z|$OlfbTd}Y=ZYx7pE%nqkFJ%T$rZOE4vP7$q4FNfa0#0tK+7z&TEbxssSxx;pQ-k?*acpEV3%V^Ee zcHPqu(PXlJ;io#8ZaGidL|SadYF}gK@eCvwZ}R}h0S3$wWMK~km!^gxr^wvX~+I$Niac;Q&%hT*VPKT zn0+Fps)?YY495bI3U*owTGj685Z`JRp8u07z+F5z1?v~dm=Ulw@;whQ7447QS6lbf zE0#Z{vd61QN-m|5CB`ebZ|)TMQ*ghVES}qYcr%=bUV)A3g2>57yHMH>$sg2nRJ0t? zd#ZFd!*f&$)XNShgF(KkQy8|NfQ>nLjWSJM_+axsV!CPFH6;yCACLr)x6;$$n)^x9 zN!7<{Fmt8h3zLD6w3L*U8U~4QI^5x0nBQx!-PF9@t}28wf3EV>Xb_2D&kvYVff>RZ zNQTC-D7utuAMXpZslm77U>>!6ahd6J#`@A?fz%Egd*!RCGzew}peZE2Z3x&jcFM0i zw_4~plYav#LXKTY?yR1kn~x#qu+ccGM4T*2Vl`lfJG*(}oK8h=dQ~Gw?dxeBk42AO z33t%H)qB)qey$A{lU+%Pt53aGxR_0`6$GgrzVKkxab^TN9rR1#Yag)Wu#ee*$Te~l zR8MY9ZSFp2Xb{Rf%0)!Ey^LYc<$WTp4+1W6nRt{bi)!7MnVH>6liSypg4Vo}i(lG> z3K?STKPT=zLx^lL0f+|q4b5sLzj1Lhh;O(}Sb2^d+)LPXdLWpZh@gP{oF1E)HWfRjsf?(}}K<4vYZX!iEIgztB- zZU`dzLPUvizJpwo-L~zr4_AqAPi76us=64nv)ox=89*dt*k4#2>dh(0E6i58;UBCU zWi129P2^3@88^?a$B9C&`%}%7kldw5PhXxdiC`04Xx)KK&oo@g;Jo}|voKD4t=6)^ z%w^owOjRIz|K}-!mn5hGK(CDC4Az8cvBUOLi&XQm$MYL)Kv~=@j}{r4Zv(ybO|BCm zK23v28twCkYa;s(j6 z2n8QI|C8gZkhg& z*0;OEW@=U2)7&)di;_}pH8o$&&qJSPw8mF`goXBZ&=Agy#BPB2NNUi>_E_m4HYx*KQFW*7{(^+bhZxD`v2_xnpF7-dJ}5 z*z7g!Dn8JHttxuI8?J=_gW;;A=heKKzS&6jD{U_C>V|sX{#3=PJLKR4oek-zv*2WP z7njv5LlYeNq$M|PB_a=B=jt0oLLq_*$E?csbx3oywj(mp@t^|UA>0Sj+exn-t_yD| zW~hYc&tykp!x!hKk1In(-poBn9mX5Gr3<;hS^y>wcq6$M4fM5euTjLt3%-zQ(ptMn8OO1+L(^jyWEuy*#Yj&OuyR2A{*iB7aXG z*%p>m$1t4xNv`1o?^nHix>4FN`5y(adA42aM|jB%L8qtCc>kc#MNTvgHYmdOv(;)# zJ7rBm1Q}-y4{zt2bpKkfSog~*5z}#BKv>znNk%m5^dyMv-w?LO79vaCHa^~QAV*v@V$j?=jJKaK)Y@zRoOq`Jp1He>5>hQ20g<0Nq6T)~-w|Qr| za=-?em8y`iP4Hk)0;W)&e#lW;75o^Zyz6WBA}x{_lr7s zLRyXkFbk)n?PsT1FwqsVnu4AF$HJ4z$t?sW7TX+G+WFL;>=jG0mM%B@V%0-rN^+E( z;4vYdo%JQes^Ev)n>!3m@o)buv<#M%C?pyy@V=|p$0$oDfs}u#wtD(JEk~B59cX&B z71S*hD4FOO&0w1|-zjjaZI)PE85YcUN^_b9sd7q=2TW{PNF99zw97I3mC6=pYsryO zM0$eB?^?Ws9|^P<3)aI}!{nDXD6jRgYWZC*kLMOo0`G|Pp)l{()?#8%>kgdIr6HG@ zwQE`ZqXPzj0*rVf!#fRJ@~ApQV0K@sWE^ZgJv(bD4Ea&HkvQ&WWVys7KeIZ!KsPh+ z+*KIety+e@z~8vj+MK*PBcJ^+_pKJK-izNW%&DsbcStVk_l?bvkvOXYmVY@yB zee1$4e!?+z{&r(7F>_lMut<<%ak(>0U+GlM%JX+od{A8*DFJ7M>m*qS$dOMUl7DLF zi#RFc;vVP7V;+r@twv)bUbhz@me>)DZB5sz*Q|AbShGvG+)#a2O1o5=?w_^Dv!>{F z$b56MU=8^k5}$d9L)ldH_xDRNV<;MpmSb-X-OtD4@grQEk;2|A zj|WbG8IBOx>ALRJElKo1+%mso#Z@~)NF-9>Ba=UAX3}VS=7*LCn~C`g3)DuK>^ZZt~~gIs-W>vb&qy)BP@aNrm^} zkjdO-)qBB?;WdKYMA}4pn`&VhM(eIUnKLH7!}Nb>(3T*%%AmL+ograF#>K?c>l+&y z8lE(P$5;>(eGz89sp5bYsO(ZVxy=n?o@9eXtGcLCN%$1;N$)bWN0c{Y(r56LfsXnk z74??8tKq1A9|-#=0H;o2ZaxdZG@p&|*$D7aVE;Q$7@nBcJesj~C?mDp6vKg=cLeY@ HhO>VMbw?k! literal 106224 zcmeFZcT`hb*DfAkJvLN4HWX>c28w`)fYgWukSZOiDoSrsLQfDC4$?#fL=t)LJJTQ?h4KG-aE!OzVF`qyMO$~w}(g1&R%=1x#pVlna`YSC4u+U z6b|lZ-w%O64&GI~tqFk~!b2c`#P9tV_(Y~v|jJi3N4;(RzD=cp}AVHUzNXg(mK-9W)Cc>_hbfISgc|}HMX>u9qsew zM?|?tl*O{tVz;cJ(J}o`mTrGuQ*=9ha$z?P^{>=>)_*y5xpC^~gyVnN@kAL6soNBB4eRt#P ze-F5=jsI5Zwkjb1Z8ZPwhnv>$AG(EnDgF<~o^J-uIUEb<{g7W(wilyYmK0LAENS54 z1<0 z$?e|&xqKVt)pSnYA(zqS42#HbYhLM@EcXNn8Ij!XKp?MA{-afA0W}L>>chL&Z`N}Z z>6R@Zh?+;Afj|_4w~_wJy%W*8S@`1RDh&N8hNZh}4>$Z6ri@0oiMg}`;`=?BwjF71 zTm?o@3WnjK_i!ZEm`; zBRR;FU?vRYyZlf2l7rY7bhlK553PAgpVC&%LKoZvfxJ1l9i$w4l+3DuemcmPzz`m{ z=z`lCgg{On{`a8N_WS98K4VB|ExnfJP`*r@n{y^MV7zD+MfUh^dMB8n3l(>BDkCG? zq-1thnRD*4AgYh;|&ap_Vdm|*h2l(@Z#7ul0Gy9d99 zBMH+wPsq1|j^^viUsfkaUU_9O6_2ndff?k9Xc?c7xmT7>E~6+!3z}H^2xjZaE{!AZ z8<|+4+~IJ0n5Q*n6sXd^zap==Z1zi;iAi?;ZYUJW23_Qe?Bd5%_*gu(N-nFwNseIm zwKS{Han&rzIYS@JS&}BO#4s|>(6TA2Wz^gvCDf>wWW^R8)i4!_Z35G5X=&m7pa}8( z%CoIO=_JsuXWu~7l~)V~F`>V_=*#$$?$xE|2u3vQkf=QvDYB`25x3A~N_!3~6;JE& z<0*y@j|t&1-TTkGWqQ$Tnv~gu${0P|F0Ary!dyXZvPRjvCzW8^#loL z$b2g@+O!l{^df!3;9NP3y=FdG8yXpuECx-X6K<})F!dgsjnu2anytD~OI~VpWD!?a z`#K$rByJXZwbcH(3hU~^p>a=dLm(}Cw;719(CP#))Q)-+M+7bcU7AVS$-6IUf{bHy zPi5suuN?`lOasFtD+BS%VuA)TQiie3NkYE{DDYNfQfQS-a)F z6z9(-C9Jx*sZsY9xL%9GwJ>dBYO!`tN+r6s$q-CN-)Mzk=m4ix-eDEBJG=|L41D5S zc*0&trIyk*YjQ6wa83?t;HNy8B9&QD8O5O8^pTo_egmtkMp8&`IGnV+T+&TQTWmuW zRuI3E%e+w6bfuxtt~uFKkMaJ5qP#E5Mp@T`qLiOPdTN<5R z>GxuxRJ3w?FSSlL&V%k?*CY}eWT4QZ@d03ZrWJ@hFQGvS!LoINmk4S0ln&$q03B4Txn{w zl5*^rIHEdF*QpWo}3jhWTVI1iIn>^JuA@fM^4 z!yxI?tJwq*GlL4uC2{qbT12wS#wn+Vi$N+Q96sa!*n*jPybylv%z)QICqH757tuHA z?*)fvoo!qh$J5&ZFy)(8ECK_b%BIWFa?4BzxZn~6)Lr0mj8!zE=T9fQ(MT!wBX0TJ zvVOYSRIsK@KniU#@mNk?asn%op*{nk8%{6Cpjgh5zRDe5mBgBqnpL}xxx>t@scl4w zVbtGMe5FkH2>{OfGu##D{0&TE#YWF7>`-lLzsUQ(w*A&cLfM$L46gA#kdu(@g@edt z(8x@e1iCTycm3qxhIXOcl+N;`w!gex-!Sf!jmQ(B^-HE*z-4X)an z?EDpso=*DiTGo*WFE4IIX-sU(XvJJjQ7Oj)!0e%JJk#Y#?-!$U;BBar6nNera*jYn zwDZkq721NHNe__f2!anx@C@r8kb$({cyxG|+-uMmL#fEpDXbYP-o+?0JxTpy0(>}{ z$M*0pAqGQlI2zqvs-T~vEL)t^J;OwcC+Pr#T!b>qfEh?IR`_YKR9tphD6Ewj+DzPs zuC1RdF{<4`vI1x(V`r85OXdfcG~-_A+P@nzM9%RZSCLzCn?7x>YIcRfdw`2|iDU&^ z$(eRKc89n0k$0Hf;kbl^UWdnDG74uslg%o#xyk&iUVH4s_WF4Xx)Fx-dZIazfnir3 z3YiTdzj&SE#utNFIy3z{%i8P5<6dF&z0i$Pfk8(UE3}tCb^5~3y*l%23TB#ap zTZ=3pD%lDNqP};@e0e$>-(E9}QF!+yT9~5ttGrBrvOmHTq@?lQ1UTE49nRdoeq~4B zU%?;MNdnSF*&t%w)|mfNCiu+r8bz&zGb9TA4jF@Ucr&|_1aToB<>KS=4gEOrh4>mo ziwWFgcF2P(ztcj1-XqQ>Tne~SpYg6DXoV}SIS@NH{dcXma&itAqO+BF9VaM>lPaO^ zL$jC>#(DNKNW_HmR|O!I1L520| z6p666hnZiBZa^j^*z}iqISeX5m#q@4N9si5@3C1xe0k%x8A;_=5F3YDN4jIuGVsN1 zYUi9el5-w;l((%I31(B5G8WYh%u`cCB?dpN4$$yYfmS;pyDRTuShh6fzTb#eZPq$c zgj+4NbkZDBeaTb-MUV3=z@GS{f`Zu`*`-1N603!za$6yg{JYz{g(DHzm&LKuk+DdNg2SrE7uM*$TIMD(_fFLf1>Ij%DeDWh-lp){m2 z@9wt#PO8Wh4iN9SzpH#IEvhU8@MP#28E_CmL6pl{9f%XsaF5Z*>}nw)<1#?R3WX5M zj3$!$mEeyc9?Vrrf{%YPys0=p->ZHbAJW66lxJ}IOH*UbKI;pofHE?Pr; zEnaUg+?DG?7dx4#eNQF~J@G@v6qDm7gablX%#jLi>w05>XQ7X<@BzDLM)Q7vJWqcB zUIXI6G}qz~OSFYWisXepP7VyPj{wBnF!m;=x`(qArHe<3L)lAKKX)5vF`zF(cKN1+Jt1i*_a;7zas!0IFqm7Gs# zV8$F*mqL3ldaT~CYPjK!QDCccEls1dC49j{4dozSXIWV3K-NFL%+-w1>wEs_Nwqb4VZo zp=Jge51(>Q^MgqfDXXH2UzmH^$a=I%!Iy7hdRIm8qM zF=t&SH%r>V3_$KTB=-6N^3dN+VKXgW1+l~p+9bmi+*^>=jE06`%#9~)1w27;H@UzJ zDgPkeJi5yQ6G08hiw$MLjppzV;s_f>j!CY;IP=*bHdDEEs#_@sr`8o@c@$F7C(k zxyz=&y1+G0H-tSz-b)2u3}W3SWWD(uLFGaOx2(w9NuNN}Y){Xm6U~YAE%~w18VY;D zV8Km0zG1ZGz`=uT^8T8)2)2UACNksU;a$Cku_!4@LaJt(ida{V>xJl+k$?yRTG~&_ zwC7uHL6vwf(z!`Ot6H9hiE&S+c3X^!)sQVbzoYh1JfE8Rm!>GExNO5r0T(;UmqUT2eOFQpB{BO_L6qc(x)>E;bbnxRXbfl zl}~E@h1(BDPibEg6@wR&4O7@63p$&W0JHK$6_(~-NAtg9G&=oGRn@N&9>*I4lBrS5 zn32Q$3*CtdDd-&aM8Q6rKAC%YHv5<5HLPxQ7q{$nDVbP-U@i}?&?J+C8NI!Rrz6u! z#?c2d-g4Inf&1skuSANzp9T5xma9YJ1>5QlBtEi|Mm7T`Q72P>8T;|dUOytL$w1Wl z8at7Os6OH*BUBqIWOy8<+C1$NE7 zxZaVotK~P(f=Gvaia2${EJ6hBQ23_!W!vq;yTGKCmLC?EcQOi1G6di&b%b3oxA!5P zG!{y+z zYqJEmU=q5{xn;qIfE-gJpXv*&BaF5{ZG4&m>U<@-`g}Iq7oWUcAb_~D-{qaVTz^8I zmnEsdk@j_VoN^&EBPc-?87tL#s2-hEm!@s)?Q{uhFgcqcax2aD;We+|V`KLuMLb9) z3!TZZsxkSb9OL_BMUlCYA1CBnWY!`bozEicIL2F9xwa!FWagYyA}jxaFDh_%bJBA7 zqa2^qR?AF59JKWgzYXBDPJ+=1$TcUbrIX*QqY+@zJ|&EquY}Bo)&t2RFWX)~NcP)= z0x}SI9@!{DY`kaf4T3%O^L?js-QG*t$e&I?nXsuLp1n>bt0N^PK;EMU_C?^IpU}$WQP)pWK8 zVW;{syS_DrSc_)r*=QWwEeE`*y<0^rwk0eWrqXHbYLmqNQsX3cs=yN!#Vxo??uyaL zxFyVNU<&bR8~f)`Sa}c15mM2wFl)0@CgV%L>LKiDxpgt>(0p{ zawj{#l$9Q_cW~_s`*`Kmx2D7+nSyM}!%4}3JI#=rM)(+Zco!AVUI-gOl zV-f^KE}a9teJM41e_cvaxRXW-B`irPDM`*v%uE#+i0y^F4{4e;@F2=5*nxK7-* zb^i!WU9C>bk~w+tgmQ$4F|2j}m@bwZ#&M^CEn6x1jS?yj8E?m%s&0Bl$XP5Ff8Y|Q zIMrLkuszD_`i-rb`91^XCb`4AEc`WJwmwQ;{o-13KP^~2LD`XEUXCSQJiSW};HqB) zckMlEOKMXnE}xe6mfPM=yL69wRmkjQ+asz6?0pmcNSstt>v++BuoC-iGxX3RUOq zocel~%vk7~&YXI+yc|!&UyKx2zHAvwu~+~Va)&ptr9XyT*rb$ff^wDUtnaa=3B?Gq zht$lDC#W_zE}joh7-;Cz4f^IH<~0!OF|dQVWwm}CI7fKAbW8Cde+f- zIHzFtd45%ADct;g5u4n=G7`dG=asoFqr~%D5Y3`%`!vBqL6p z5*YJWFqrF@Dgbzu)XEopf_mB24O^(s-onaeaKA;qy!3ur{_qElV^Mn1Z<^kcVfma* z-c}V0A5Ofae6po6lJ?~x!-ntGXDAbgtz`;4%L~g3PLb`5E3wPDP^$s`KFPpjt`5kw0Yh&kV5HJHPt7XS7j&%i4bfrK>I43_t(Aw)BaFa z+5x9(rfFZGRpVtOXX{hv47TSlt??;hkcCsCAK;;1MAuZUT#T#D`G9K-QtSEs%b54S@}iAfx_f7{+| z^d%ZBfs{?GQgTXjQ+4!@T~z=9$|5M{$!~zgT0X}m5kC*VW-UWpBPQCxi?0aF^un#p zB9Qdw4K}Q81SS6WMwdg_crWy#e>ppT(C?WGX*waVmBxgW)gP9%zU!>uY&E5`x}}F0 z!+jYcE43E6^iD?nO-If-+Eu97oP6?vd5UHlr7mrWzo^~THmVC)Q;(Y%e`NTOdu|K+ z*7^_Jy?{JmI`KCvh<{&iJVY7TA=Ics?*SwYc{Bka9`1El$vf+FT8~fllSm9RRv3%1 z1ADC>DH)gauQnVHRd1P==!8EUGAQmBbalHX!I%q_&ohR35WhYnjG*+t6$jn4dPHp+ zo}Tzr@UiY}^$VK@0#!;}VhvjOc(u3!P92doOOND52zhd%J{H7szHiXYE<*-N1WG=0j-MioNC zLK29xb2qI%_KOvpWat!$<-Tkc6sa{!GM;W8=5kg@<%v{^ge8XAnl10ZR5xgoT$-fY++;Ls#R+K59rnJZaD zoSzkaz#eN;u4f3adQo@ESu&zqh`m>r!|Pa{{o2eYPHTl!GndSc^UtLu7xlHq+rD=T zY8{v7Ug(q^3m;>7xi}60dRV11DFPk?hT-IQ4ZB~9uX~`E&$%Vi1K+#6RX4gXWdkKx z55lIPgYq6`c26j{THs=o7cPR)WXs&s_V(X}=Fax_uolIgQmPiojEz)U?G44|P1*35 zlRuWy`RXN(7(Rl=^d-ej)Qy^k6- zFv>bD+6x@)du#{x8`1qmkv_Wv0)0QNBcq^g#6_XTO`Y=MslEG1C50j}Rj_k5+nG&} z^ZFn>v<%2p9_w%k8Da`UeCLd{?wFFPIMUxGGebBxbk1b#P=A=@FIV3M0|7Mt-j+M{itZcQCL#SkWLD-XL|5b1FK zoWoY)U4eXepr{Bq;nDgpYRoJnMJCrp3@SohHTOW3EhY|UC@l|S_?(o7qP97acOAdwr14c`UE7HzXj$Bt&Al11lcICV#C!{xt?G(`wgaG?a|`5M#T5OTYfvLa7{ln{wY?{Lqa$al>Ub|B4(5Ex)$4>HQIqWa!+kn&*`4JC@W^?;ktZIS0Z=tnok&JKP;3AlTBj8uk!=mywbe-{ z0s98LSL$Qk(TMhbbS0OTWGr_=+$%gFcY*@mnk+@?_N}-ORh1ecZb3I?wSd#3?s~(I zti1V<5*767bIR#zQWINx2~ zNlWlQJxVXF0eLLQfIwQdP%Bk-fj@#Qh=(ouGt3lWTFv5Wb!}CmKn4}s zFXV2_QUvmAOVdMa@{+sXJ`yH@Y;K9bYdBg!@=2NMocVd^o2SlpR2*pM7~V;~lnX zG2&oRA)watWbcb!_quv<3H^#W?*PygBt-$Y@p@dYYgk5&{RVn%z7`u|p6BtARb1{C zp;0mCS2I;XqZlk!l38-!jN;Gz?X|cFBSG#vd-5w}1I_Nv{6kf4%mM`%m}`A{l)S3y zoT{-u4et(_1dF=C@Qq({F zMxnSJ+x6Ab>XA*-5xmCg=Y%L1kg+D$#dsEAn;A?7*z^2BSI&sjGDuHYPmtZ9i$^7+ zKAAA_#r-P1+LY0GSBUbQj39rCzW&m9*Yn))ufOhG;X8dQc>PA}pEny%C~p0@gEfMF za@{{3OrJUVHe}w1t)&UsV3F6}9wDN|{9|TT9g(#MlE?xqU*l}`BY5#^{@}$7b!*Ak z1Zk=ffN@hpqKr^%15)0_$=2xt)JWgZ7}sx6iaI_m`1Zo$>DOu&AP*>m&f6~!e)~Q@ z{gcrj3e2s0c@Xe*>C&F+pLb=OZo{s<1)B}Ah9#Jv4Y2sf0MYi;gz{cUbyHZg8H9n% zLU?v0^nCc1D-P_V628%S_Sz%7i(F$G%*V%@jmu_6mrI=A)I%x>5ujf7*oj%x&{#Xu zrJo^B2{x0AxSI+xx5v5NASl<3x&@r2osZy-2Xn|X$?!MqH^YgcoOxpw{_9{m_I6=na;#EjLvl%F)B|~zij*N`1Ep5k0mh!`OuDNS$yRU_bK8N zDIhwa*VTb_i`vAq)~b<8skz;&7p1YEU~ikpEXFZq#`p2Kp3E+r1p^fQt$IG=JMxrL z!I8z@*huS>g)4kTCU1aAOGn4mnfKNfwD(CNyq#*DR<~zPIHHpQc7A&I^Q)_?R?N1M zO~J&C1bfM)pr-%Q(i( zICM;fSo@F>d;SDw&jI#3`d4O>41v*lE!6YRIghUxAA(%@vAJ)u;$UF`UU|{Ea#36n z5T}8dSztC`UjPpkcO&8Ht=yp@$7#$r-Zf88PtT)wtLf<52u3Br^>#qK-U*D(#(ZG@ zFT}CueG~GFL6G%9gaO#Ex)CN@?v_pWaCJo)WC#cfKrd%^O%~vImutYDZTW2dKJ7ga z>8Vc<2@*hd=^Umsz7|c*&CR;{LDma!HjoNe`sy1PRIGK=TcV?(=rs?a;ndU%_$4fN zvx;iG%R@+|$Q{Y$7_d84c~qIXx#XT=t5ER8fXbT><{kF}Y)MtjQ51?8n1IoRoqG^- zlj0^G1giRnOOSz6e<4>J!EPV3C3F?LA!(ur1%OR6@BIW@Vsiw6l{` zWm4=-2yvhf65j5D94G^fe?8W^`-9PlpRvrtI}mqWX>sUU-|FhKQ=`d|JBJz|kn)I) z9Ps)L%1EBknd#KMl^$@WR(HwCuGEV9?p=Kvt0s@nJEL8oxNVhg8WANO&hQK`{SfKBWx{i zcx;W{K*iH**D{0_Ku47iLF>~Y=IgEPw_3Z?xEaFfx^8%czF-0z9MXa~?qV(o(Gu7_ z9^^ji!W$=Xe0TL#%*FO{cGHgxP}#K3SpKKS{hXn;4(}( zRAPHO!Qp47_ee)>x?|`QpYqwDDRCG+AwJHVU?UX2(bgNtZ1@m`*8u{b-xS!)!y((! z=>oE3We@&3{SoMr=b{D*XL*gr9DaUtGy8h!!a_a3fF7SUDx;GerIg&B&CKtQo>RIIa&kOocPmW41W7mUS0$+-}z*wdK8TcaF$|j>*~3-CEv$hH+UXx zOi##Ea^WUuG_dQAC^2G(@2$;a2iITmrQ;Y&_O(slX1>%gPih}H2{bTpZ%bv5T59T| z*E*}UgqWFc6`=$;$w!83Rp}OH$XZ4yB;O9Xj$F_X+-4IXSjomoMV_*|)s#wH? zoj+2^=OXYqh?=%4*q2GP*fgVn!U~i7*|siyWsWAp%>A0(T1l;a-Q5JY!`#__((9*>^$PI^0K@ZuvNlHXCH#VwJlTU)j*Z%;$-w4}&>QN$s zlr~|XQeKx(62K`u8ekLWRs(@dT`5u=l5ZjT2=i^ukQ5wvUw!Mbof~;1{F|aFINAvD zZEyW4bqX>Ovf<{HAMT(%dDYd_<~LuJl41_M^(yEMyz)OCt=~G(>6@x@OowSGU_S9{ zgzUBPP$}jq&K1plkQr^}DB$AR(bCjHMQ>!P6VOcqt*RT%W!eSviodt1%JsV&SGUeH z`hvQa#!YxCQu4vglQvS5;vb4ODoj;xhuTK68@^?+$aIG2#6iZ?J z&`26GQ=T8uEZiSGG|&SFn)kZNq(#dxz(Lmv#S33%K3s zJ@<;`nX^Qa5yt7xxybclDic5c^Ca~Dt;PP2W?cK@GYb#C`J}|hp`Db^87D6vDi@!8 z?3_7F&j}329k~^cN9_I}BERAV;`zpP@7Je@0OX%{zD{W5nj+e;p1Gs$&b2g);8z~X z2Rz_w8$J%&?nSO{mjeFpS?+%{ng35*<$rs?vq`_<;A9yWVkiyfMk-rKQ3R;G-w)vR z_I2aG>bcA}_qQO6aBsOdBs^Ekv0AMsHV!~M5BNXs7~*M%6Sr>)<}M>=BfCfCA?Hy6YBS*Za27hOHs`pi+LDQFO;*4 z{(+W9KH!qt`>06EDoz&zU$#x>Jj~To$bC zh=nSe;NVYsdbjxHl2yMqcawS_d88d;b~9^nyJKB`$h|8j{r7u&6%PHu+vB?UBvB&e zYjz>5w;ylf+`!6!Pu2Nv7Qjpe_PVsd(tK)%wh2inzf6HmSlVvKBzVql-ev5FX?>y?n=wD*`+Zy^>XLt zZ`}Af)Kr#9xXfGy!T?eBSu|ae*&C0`CL+3+X{JjbHSl>lMfPG0R1}V>r2cX?*M36c zmVsaXKC9@g^2bAO#~OjWF_ei;L<}ft-zc^+V^lX3)dqt62M{ z-u4_wD{R&A>x=c-D&gawTkUfG=;UrO!eZ^GJl=CKN8K&48P+6Q9n;T?FdRqU<{eFI z9Bt?=Tzvcz#e3S?rs#?8N$$AteI!%lq=N5i`PB%4c zrLpRYj(i%)A^UFFrkkOSVU`?PuNTtWGm`Nw`TIt7xcSJ7ypymd2Dd3+579ky;dZSA zt>-;n+F-5bnT%@f`*sJ>rMV!~`zw^`+tx0ImupX`le)`DfeLHaDrnCdGrUHBeFcIM z!b(>B39C1RFV62JbQJs(@Q>kn-@(vKs%Sd^9z|@O|$CeHw9V}f={e+JZk{(0$uD2 zliUpx3G${ZyBWQSi$MoxMWv(qqe{w1lgIU%R=zI{1dl}^zw4lNe%8Ll5^47(=i+ek z%D1E|q_3NFte|UrgzV`)X#B7I#voMs`|_1s8AjROtx(o4Fm zB(Z%uYB{|(EP8zK9uus}(VcNV8lh!o>QM%3^IDiR&xL3F4t+XnY9!9*A6!-Bgz)O% zun}cxcgMS5go#D}0-7RPA>h6_FUq zRxpNJsUSH?n^dm*#^3rAYtH^?KRZ;T!J+t!PJB4b1Rz#24Aii?YH`6 z4>U^In8*p7&FP#fVgZY7bXR-IyIg(iYaj>GWsQJbYZp9oKhLSN1%SpM;r71l#4-BP3aW?YJYFNI!l`ISF-!_{Lv zrwgb}<;c_JwkOCM!_#U7!Q8DL(+kNd{oOHLqsr07&~dHqpvKFBF;KTjzsWEQH=;2W z)U=E|hChA0Jp&gap_)uCq4ATALvIqV7e89QpUok4{fW!?zJ>&j%%;`LKoi{VYbQi% z-^M{RhRoa=e|-9@ONL^p!?vSuIvISmY13^82{yOyAywdG=|ZWoUFLg)y)q7mU7R4% z8#%O&1gA|9Y5OQkH}!fQd1zOqh7Dyd-PaMN`Jaz&xtL|?CMXi5>^GD)M}iN4P?JCq zTm|mSz&i^yl=sJvRmD8luW;#3HP=a<`&suVW!h?Ij_ZX_j0zEfLs@*#jQ;G}u%a^Q zi#qWp-V5pPmHE>d^L9krS*8p4c~x{$sD)cPbl3{YS5As1NQa-Yc%Pa=3rj)yxby>b zQA_YCCp<8Z>rZr{_}%FzdGTEj=e(g3z#?_98N|nxACv8zn!wcT`YMu#^QU#Q6SCu@ z>n@s0Ayn?9dUO+0*+q8rg?3}7YnfQvI0~eS^Gcg)gc=82XKl)1N=BK`~n!0b{c0pdO|yv9+RCRd~^Z3v6EsBwO!Ui1O^_7d54g$9nX z6JwZ^X=>a%z1{Jl!NTXqFoUP`c6B>w=R27X{ZAa`{)XanL`5nd){RPVC74Q!9-Z_7 zavQ3Pjp(PRTf>^V*+zd++g_!|-+uA@gOkeF%CdyRVM0c=Ps*TyTW0}+47d?=y>7QL z)%V@@YN6B^U71TI-h|x7(O88ku&pb8jLky*QiZ42}@ODIL?M zT|9dM!EpgIHdbxMtpLK;qq-GTwr9)|?Xv=qxe$)1-3PSVj?#R-Zo(-22r=mhzDRe+Xh(a)&RQeEHm~GS2j;8W87uh_UxC z?e#kyWfU(3kt`L6DmUOhh7~^eooVym7V2}J7p)GE#cjPWIH#JArpKIBTKUqUkm7ws zg!HbR_!&&Yq6YD$7nt>eD2q_j)0D2uW!Gr4&f|?uIohxU^0aBJ+QKA1GiSb`znOba zykw#eGYE&V6%@vP8J!_qp02&nGGUE0Lm@xyHg%AE=M&TavxpyX((b!`Oi-d*p?{96 zFRp&*{X-;I>RU6?xSzOsG4N>&C5p44n|on!e6lW%WB=5<-9z*j?%qCgn(ZV2(}fAv zDr+7f#wUo`u3=2zi;Dpy^&(+4!wQ%Cda5tcq7Pl3nwMo~MF{o~M?&|qPGFhgy{Z#1 zRnZGEW=@ND|KOahr7zbrGl#<`wip;Cwkg}Z#_W|EFMEc<`MlVH3an8V>1%Y6T~lz2 z+9%Hf0;wwXXfhy6Q-x<83}8pZ!Kvg__BNwwR1ys~{}YzWXIsLL8ahR^-=rfY4Sq86qd z*JBR zP(F?2h}PAXF%*@W8@2^(9|S32RF-lJwL-w`&Ymn~5K?oy`ncu=2a4(1W*6kUixM(; z{cD6dZLcHM4oxxFXXgiCOdb*D%^Vs>@?D|J?iy2uyrCUM*NC!4i20=)A6N3c08~aI zYN8GX5L0$xYZ6-~gq*%mJQeRg-{ZyAY-BG{hH1C5I(no!=Bbaf*1bN`9QC|X9`86d ztKHg1S?kKBm=ccu6J7)Lr!h3NYIj=wxan&9=%kJ)n276v%UnX%O%-K;HppB~(ej~{ ztfcvdT2<9ptbBQJXpqYkZv=Q4-WDzz5pG=ep!JjXGN6G+<=GODiVIiHq8A=ljXif@ zGKYIglR8(#`%rUf4jcU8=H|DTZ;-XalysjIT7l{G!xT+iap3n@?P zkHJLm8x7KSni@kka||ca^dzlf?jAY}D_ctHPVdeTLKhkrcp1jdY4`bFEH>NU`rvwn zp?MSf3AU^mIwiMr7^`<(0N~L@~%UT;<1=w5`jndwYVVXV-kN`CSF6ad@ClCMe58{eZ-?73U!>zft_>o0a6^*nj0zulcrBrE-WztvEo7KqW#zQ@! z_CY#2P0dDy%GgD0{=U@qqNxPwF&O&G>iT9Iat#0 z2LQ0|PLXAe)<8xu=A`!Y4t|jiGR5v_jLolp;@R3DgD%-pL1&NdR3TDl=(uiN%&8*f zA#KL|98jBV5lojc!I2hze*FF7SeaLdi7jtNl2DmgNpXMI_pl0%)>- z4R-nM@V^J2ALr2;_Jw!v1cJp&u8lQe=%k2{W|JG3RT#T$@Hw+=P*O&gVkO#4rO3?q z_h(y}nrO@B=}CnKhD=W;IcugOW){?;1q+YyG_r1(l6lcAoe~x8T%;}w@+CSOye&gu z|H`{`h4UhJcFWBG>NB}Wmj=n36Zzy2WmHT3$oMG?oEGu{;M(ZYzeko8OW^zSiG?sj zAQfPZZlVaM%i%sAd=uvmdQgI?GK?@oMC{qmDCm0-am8@7Mwovd4PAD|PkUXUSm zclt3EU%uF2k5@0QjTSe1MD`MqxY-FPbuoi*1zo66{J%=u)9X`Q!Q0+^N<3${2^1r; z#=`7_o|uZoSre{X0H4oB5JDSAL43&cB1R*}luWIAe1LOW2(kgPV|7QT)(Y=4Rn)64 z3NvT{sMIasE>*~F0+QBsu_9Sli$K~tZa;+v1(x>f|Xt<+w1uVHtd@b2?0`h2*<|$P=#;yPoQ`&I#Gq_odx0NjEMmU=_UEyjs=vgs{u{ z@Gj769;lg!^6RN?6yP=zGEa|Q?6gltx;ftI>&H+-2bu0KAP{2rduxXq z;xfervo?ReUvjD4+7q}w^DWS`0mxZ-_V$!_j@~C@5{nLLKrypSrM=kP)$ldC`d70W zNN$mwP?@5k#(QGSIvnA6L~hcHn4gaom;u3ip$s@!D0inAhazh{;;9x4NgPpZiif5Q zg?Cc3eHQCftP6qdoA;&ls|KV;)P+)ckDuo%o~_BI&mhc&Tum*MK|Rj-uG5&0#NtF^ zV%SC0Fm0b-V*B1{5X|-7CM*EjXV0t(%$hHENbJeW#Te7yFwJ6YI_OpHInQ5KUauWE zqZpeIkJ*Cw%EWe;%#r|+mQ&)wOr$iHNsrYZXGWdjl_(>$kp>)lHiO&}kJkXX#2yFq zRI>yNy1qS7>=dMlj9N9oU~FaqflDY=bop^~Y<848Lut0((UWB}CXz?=hxIrm;; zCesr%LIW~2XwMmSuVP*C^AVd>?EEgPsvb4fOG+J?My|kudG>;&KAEK_FNZwpYV!*s7&gE9uF{UV-{JlZe3RTtpG+ttHBF2a(vG7EAkFLu^) zuMx+T&MBaS3(56RBZ((!Ppg*_Y1bwJHvnZ5V^19&^E4OXnBSJZh zoW%orbSSkw8B|8(o@R+wNv^Ac$#R0oSvbui3lJO$&($z(?Lr>}_WC7e&bzcso1w@H zn2V|}36|zlV&J)l(E4{d{4f4jw5YPf(#p!p&Mu_%m1BN> z{_XY6|8;30l{doGQm)wI%1W}b1Sc=8jQ$8eYglM&WosK;dU&G=_}ll{Rj}8b=tXgt z4p*H1l{4J$hDSq~rquJTnALZy@ihNbNz8$dsvhTAqNR@|t{QNey z%*%T?L|ikiW27!(nBv}X$2Gg4V4?EaPT&NprcsfRcMN}TU03?P0fK$fOe?~}(FFyf zd;LmFOa1-*>+9?5B6t;y^#omAUBQcXR#tU=X`es;{e@ZK-ne|9T|laQ1*1wi4&3nU z>**ug23lZ%p zszJ5GJN53`*i7Ndy;wP}|0FhoZ&D|2Y;CV=_rMV#={x)OI;(>R4=RLmq-8R%;Oa*o zqBZpNs6abKg=)qvHD;8i~)%M#7gaiZ*+PH1J2mbc`sv;Tlt-Z>{$pBbcD5n(8huSaFA}tcGIB$Um%j42l zqNlE-tvzqCy}1qX{THyh!HWU{A+^H-0s=CKPdPbHr?99r?a4-w79eVQf6j*GZLS6} z@5z%Vg4e(ZV8ouz-qgv-NnqU<)Z>lr-|wDF1^>_dJmZRs{H4grTPL@_ z<_6h#57_9+Yc)_rD=2X7$}--=$`vQ;;|UgoRM*thDo*t>rFST!$X|^Kt{q0IS=!k27T9z>+qq{&!|b)mO>_UiVM@08?;Thb)P{Lgq2Kjq9W|_<;aTVEz7`60gct2>JbRzaN-{7Tl?7x$Ymnb8J5t zD+M%Fxv zR=_Q00c)tiJU9(>9}2|oyKzlI@Zv>)qaTFUg}cIWnKAw5c$bmKTu7G#u1sRmU}YlU zv{)m?5rZdzfN8EXiv@kn_{12+G0xat6YmZ{0fC|znN|zwg zjnduS-7PsNpmcXjcXxM}bR*r}{as@Bzu!Fj>?%9_=EgbaecyA=z0=r~C0CfE=yZrc z$6RfCW<2lb87CUb23}*!IDwhcT4NMwXJ$yFk=dAzp&t7*Gg5A z5Lh#gn@2g%E_p6OL$H}oe9l9a3r_6UM|k9g{WfN5uWM({OJ6Ljl<5uh_S=Li7Q7!1 zy!j1P(?DVEl^3N$`MP)c7&h{9&Gv&;n*RA1CL4#tqez2LmECpd<%n+PS_gED>K=k(RcZyQ6X45v&7z**R+&zBo) z(5*tKMXSuT-FkK!|JtAho8wjsWzNOgChg`HW#wK6@7mq$Om2b+EAUgm%8#Hin$&3O zeYed|s-yDO%^}Cr7BZDler!i=^L{Mm*L1@UyA|v2wgszf_m>E3ORsiYu~$$2gmmV{ z(i%u#fqrM_H0G-&iOsD^+jXG;$%hc6N7X@S$PN16vdr#gO++9Z{p}JiCKYX~dO7D5 zrRRM1C!8$>@%+l4lwyNnvS_GU>YoMNXF0N0GPV@A0TtHWlDd(T8C!%P$VKhuJOBjJ zPoZ3ul<8-^HEFi*qf&L+vQB3*9o-xF1NUV5>~Nnl`uH#1*1CQJSYFn{RgtB__cy;q zLZBc4*vu_z!J6YS= zD$oPn0Z2$b^!lo{e4g~)HY#EqHakLKByU5|OSqe+tG(2O1a$zOj`p8J_?y-9P1kQW zDc*DnEaqx`Kw|5R0n1yXkD_JB(9bg43x+Dy)k~?@7qz*SyGtL!$e!mrC-OvnzEEwH zG09z>y;wIX)0=DZz`F~GTz=E-FY!SLb94evcay!tDvnoz(e%5u)7Cr)geKz$g}|{+ z>1-SpvrDI8wT_pa&L%HjEFUu8Tou~v)!6m*#;xo8L2#pb#rFA$hM(e&hsAJ?oW+5zL>%1|u$FE*<=VMOQk$*GKl`aEB5|*cm$h$}3pEgg zUFEY-;heOzXVq_Resr^hJ3(=ZMJt8Xj%)QMlXTY&wl~gDim)|P3*C&Q1uJ+0_Urg) z48yo0xzz9Gm+GiK0lJQx%P$}RwnRWcpcluZSshFlM&^yEtTpCX?S9+$w43f+vgp11 zG=Y`knc8!0E`gbesRwlsz7{Vw<)h!cC9GBFLqVtmYIDf8|Pv_+0rMKv~60}+J2;PR{}%10bKiObiUm3|joxo01ADp#uXR;^Ua_}=$o zMn%2_A{FFc>jB=5Mljp%`C?U{i1Y%CL-vAGWMNkuvt6irVSmlCMgoaPbPE^0Dy^Wq zEXIL6`MsJPB9xd;i#i;BeXOW}Q)4!G>AiBGAU{!X0cB z-6?{r0iMqDT3(scd8eg77hKts2rpLZW;UK%OJf0WVmi2Q-F6Sf3-#W6qYb@^NLFu^ zBB5$lgSQ=Kw~Iu-rpB|NY$bQ=8S!kPWb|}vZz?R6rS$&urtmdBiG_lKf*Y*6n+W|j zmqseEEUULMWnl7zt;k=%83OP^0ym}qOa~IhXs;|G;T>D^%?}||c9N!J%M_j!p2A(% zO$&EY-I)^%lL~-2;D6?VM7O|Wn|UigokgHo=g>onUSy}G1hmDgfSdCVkd?>a*}0S1 z0Tw!8H_i%qHq~VIB~0ZA2!mZ#0pw_mJIW=hdQ<7+Cb$KXPoFbQUf~bA(Q_y58dt=`P#$orK^;5UsvM|p9|C15Rc~qf2uK*D4-OjT zsYZSqXMB%INl5lo?qqu+&*QjSbF)FIi+1RluI>Gj&jPAbmYJ1hXhV3bym&otXZtru z$Iq|A6?|eR<#{LCVoXu#%_2a|!O^@jfn@Qi>D#yAngnWi>nVG zn4oV_JcKW@{c7&Tuo^*T^>; zh|WUNaCsXi!KDgZ{z<#4D*3R`mv$;NKCBdJ>x_K~cq$TyE z`Zz9d)e;G!#I3pEaxP1Sd@VjKRw>h;0|#WRZ}#4q6CAPtH_(7Z|9&s=T)vtc{^`!V zVhqe)j%6Ybbi5gXs;qF)r9 ziSKQm0(I`b@cJa(W8U*kBG1&f^T=AqlaZ*aOFuZCiG-YIdq!7oL$=eqV4HgPec7kU z0OhEMIY;TK-HBY3xiD?~2@nIk4-Eb%!TpJcdV}55kb%_RZ?h=17iZV|JISQAyVsZM z*SE$3P9Q8Xx8yYx` zp5A);%@zoPwNKgvV9fpkC_?ahe{4Y?4fLZvE4HJU; z+17JE!818{)1pls{f3T+2bN*!&-2X>P8rTawS`O7|45?POLRxSVD}53sE~X4SC0wS zdURp}10(7x+$!J|$aBo&6jE%R?s?g}xoKaP^-#E+9j^0O*-xH)I#vsk#s?Gfrx@+- z@97ZSU&g}5lVHH%T1|DO3`LC1 z-ZqVbxo>3gus$`_{ZJd7H#Gk@YL-0Q9v-J(b93)9g7l2Vbx=~j(es4)+ z$(FSBH1JM=XHV@eO>B2;iz+G>od?;JR=*K*+faiX=cktHl3jUu#Fy0#Uli@(TyK#FP{0w< zyE96+pUckH)@W^($h=$2#ip_sPpV0~pUg{0!G8?t0A|EHOOa7vC{Y|9+g5KV zv@{6HXp^~RCXvec5T*~Jqmal@sFS9*Q^tpXSjue9~TrTU|ICuMr&eN!DT?snRBY~w(U*g)1&-oq2*osOH_1LLG&|k6i z$Oz&49psA+v_azM-@HK#hEhBjXzsGOb~0Hc?EE^c!qS(UAAMMNKl}sq|2KR-bwzd) z_-pgtk>1)fKQQ>S-H{aO*9sgDbbr)7E!E+3-OCo1@1WIil!WvlAR~w37+&d^d_7s) zCsznkhxNOR+if%q7Qcl9u=Ke9UHP~jOd)A9g~3h^YHG@h&6rKGeYT6wg%6X1IaEx$ z+cs7MvJjX$W&#dBK4AB267q?PqRI_(iDnI`xZM2E$`<`gyyJe*kN)dfb~-(eY)VMl zfO!anh}W3qz6B3FZvF|UZc_(bnwbaDy7dvHx^S;pD$83!QIR`DoPw#c`$X+Csm85V z2B8aI^FKM#6*Q(7i644JG|cL}yI%0Emyl2G%$U%SlEhjT&{IPyH^{t^DR?!_>U2_m z7SN+ZR?_|b{psjxI_I2u5H_c-jsklO<4uKpz{D12#!tLC>kj87> zN=8939$Q6smF!o7*;a0r8!}b@V3eA%$tC-DRn@mEY{e2F8>&l8chyT`1=vZ!yD!@- zCzL&iz!ZwsP^_QcTX~<>|BDE0iZryt4lGxf=}A@-$XS=$?WDARQKI~4mI5oUC=}3K z3sZT_yJgXyLk?nr1%hw`Y%=lJ(UrkeA+SI%CnlGFR=W=+T%QR7>3cp#XHh_*Gtf=T z*IA5u$9KSf5aC-svzh(T6zsw?_{r(cr*K`#6#eNLo526#@A{GR&DfaiaA_m?dE?VV zr&oYXP*$DHMMx0##GJ=Pw$z5(ZmBOZaJK#UkjwD2)zeUpV(9+q@l5~Ebyb>0j{eli z0ng%-FWuZ+i0hfk;3C%Qdpz&5Vb9hUJw_944nx`YfKjH-(uRtV zCq*Q)(VsfB`|bGDwPQdyGDNq4g8Z5jJ2+I#o+L9v!HrWts&kf}fzgy6laS|W>Ua3q ztsMCml2+NAv*lelkKMj}9+p=7jmL52RKbv9tiJ2>hle2BPm$o>E}fmsN@(R{iY)E- zl;NUD@%K5uErf^YiAE?=0Om@d-O|>S*Sy_ifphIgTioTHm4e&9vU9Es4VxhS#$bC zP8XMp%Q8&gCC-iXtj;mXQL96^W$MD{CyZb&D}Tc)Jeujg;zSg&nn&D^6k?}y^lfe7S`XQTP#h>^(YY7XX*jri%r~#IDF_yEj-dos03Z3iax>8Bx6yMJ7 z%1*;jX0o86!h#IOb8X>{*=1MU>=)Q#o`xzoNWEm&@duL(H+jR_6#71V5 zI~^0lAhY7^Nd<9nmWh^>)!K0?Fbw3@PrTK(8V3P<>-b@J@*l)EzZQhTaLl(60k#~Z zIy13VVe!G#x{UzHS)3;P5DIi?ks(w>H`YEqRr%>u@u9q#nb^m~VDn!J;Y%9#gIlR) zm0@BqP`Ht%LATzu7fkDUJth=uUO@`|~1L zHxeZ`Y7O+H>8g)sZApg#o&Tho`y>RGeTI!8lEjP27+2>;+FzQ3gg2kSI5zRtSoOjy zmf`;CX>gxX1-S@WS=pMBBdpC9_7HK_)8hzo2A*ztgJO((|8vf`CxnBUSqXa_dT3La z7|0~W7-5ZQOUna;gNmmse)8oa6BFf%zM1>DLfm8cFdLf}mnX=`moAr=3GZ4WBl*)^ zm1Jgi44fWJ1zVkx_~@a^I%uG_BoRlyYAh2})z`gw`A_!Fnm&QYOgsH{@Wt$MyBV(5 zfa#`cKuk~xH)8#aq*6|4hkG<_lL-8*Y0Qj_>**QMhV_T@l+oDPdX8#lE2Y!TR8HdB zY|_S_hS4Uw9iOQ3YVY4+vCOs?7Dw48BAP?bjJn8;HnRnVgo-d;qf!G-D(%b4rZXdc zSohW|rDAj*Q5f>}U%u&6fZaxFFDmJOooU_pZEs<>JB}tddVIOXsCY5bT7Lb&LgfL3 zo#w|B*=APJX&1T$d~Em)IrBU$A8+6L;tf}rUy=|tV!WXH5mjqcR>95Z*^+(XsjWX_ z%b*SH4637M|5=;XJ^la)VL+TL#^MZ{pNZp_FEv{Ic^z9NzF+nnK$+6lQ>F|%_b~7k z0ncQx>OpN4jdAs{(XYP6mEYA9Gs=O5(BhR+8lvR;O{+i{Yo9V@h>myuZCNNql$Dh+ ztj-*dzteJWZxG0oj*i;F^aS6yZ$i}ET!LST(?_FSo;a+xlVu|ro2GS;T}&Ym3o*q{>ADfFPq^_oNgTu^_1V)H?Tt!s#=< zH1=oH_xuI;3BtRFhE-LTyX`W>PyOBlf~vX+?Y#}&sxpA1hMf5=C}a}9flx8`%`$$0~9=nZ-x`4aO`63#A+z2r~}&}0S?*LZsBX|fgw7=xU^3BOg8?^WB16LM!SRDHCg z(#z)j9iLa0RFqY)CZ^;FQ#>#*HPkpIHS3-11g%Ia@*el~@O-v+oT$>#T`2&^YZWhD zKQI-tz1h5IilmaH*rAy6B(#7|;vUUGqd}RrW_M;USgVvx_9TG&cE>K7|AUfQ7=6`x zUYr+;Ou2U?-0{XRUYl*sFJ)gibjlk&eK!S2AE2$TIh7r(E+I3!?-Y~-lkSL_bIo&{ zt0P6QGQ%N;j3UA1wFMdSqBr2e)HXv&_K91qMUzi&th|eiaVT(_@6rSr53C%`9KkVb zeXv!Q;E$k0n3#V4&YB2|&9A<)*7UT7N8Ok;bd&`8Rq(>@)Je+dcu8O_l8VUI&89nP@S* z8i}PefrlsCFpPD7FHZgC=)}w_1$9fHGjhhFGD}9CI1{f-r7o z_LjaX&{CHaG;N|Gz*gH#SsM4fQS0D!#;8e1ic6{|p5>cGR&Hza*sb}a*!<}+m&f3cy z^sEhRk9RPM4N7zwV1LTV3(R~{#VPRxUMZ{_VXt-*ck$!Xb3S+}IjL?zp_2TPy~8Ej zvP$v!!J(lSuwG!`T6=a8Z?r|uH7;wwkbQrWcrU)NuX9; zZl>mzf9>~IKD=HWC1L}VnyhZ^e%3lb+SqD1TFpJPY&qEEiUI!zXo&rB!(?bO7rW@KQjDmszN-w-Ehr&TvZwMdn{)TR{!lS~8Q3Y$aUiTp#`jGyiIF*@T; zoX|)Lz>30<*+^-N>Dp#Yz8;e_0C4MT@6c}^7SGUI`^U7|b!baH<;NL|upY0VK@oDo z!m31!WeCZ?$QeUcTs*zJxU+?l4n0a>?ufW^&Ev6lC3&}oAf15-`}YR9)Dqa`m_1!( zy6LA)NHuhR5fpOb@&wXQnXGgP;x_XUdh1(NT3iFdZAH zL;x{%KMlTWi}(c(s0G(1rl^BN?{maNb!Di{GKPJQ!Y@kXu?$7qf6@wcf`I1cv~^cT zSusS(NrY~9Ba(h4m1egAgBbi#F9<|Jmv}LVEy>7b$*nT<@x$r%Z`|J$C%8QPN$o`! z7984+lSg+mbV)fWp=Hg9Tapku6KDJVL$cPM04=G6yn^9#;83s{s$aIl#IyfJ2MD7& zP+WiTumLY0hktZ10gR}m^P8TzC_zh%^&nh6wXf*|b;i$gIlr!%`W-I${1$C* z%rXDd(S^GI@NH2Dy`Vif)FqG}`@_eA? zHp#q;uwI}(1nCmD7jGosu>%~4jm6!U=E0Wad5C>%Y)CmchD9;kjMKlF-OX!d{!G!D zx==Ke4EQ{c+Y^B$V`*urfe8=|_=g#eEN!%qF_1IiF&4I41t)|U6mdQh2s(y1+lycY z;eJ*7pqj4{XDNca6#?ipl3g8d(4nZhSpdIO$nm=!szLr$+lWFb$H{vwE?a6$M z)L(!WVVkd+plB}s&YSRKn|U=sW4#fs99xlcLMSF+MER7M!o=?UQpBFYy`npU1>Y_@ zxAtk6LCU6RU7k1mE-wR7%|NFYU4JVl#w;XnDXMp7&=?X5Q$-&0Q=je$TxJf6){FtJ z>)^um3D8|dSiTP}mMN_e+*eFr;JdmPVci1*WYuM?eQ&qg7Fb?E!RH7!rDpw_j@boz z(P3Oye*nQh8s>)CY{06dIzh)<#z}}k&b>D7NybD5KUPru`9keSBz5H7x3F#*!v`U8 zUD*p!++@WvD%3VZj8=Dx42fsOa_Is@wKqb6i5uQWa&)tW^0B%-C#Ri4^x^jvYXc=E z%BN%YC&H9GqBxY4(;%sX_!Ggr*)T=5KvA!0$Gns4lP4 z_obQ);ZkPko~EbtFX(kP7mAY^p}ydU_8Xb%V7 zB;k<*Q-5K118K$fBuDLqXw|SqsZA8WrEuOfS!wq<17b{U{pvQLX@xieHu8v5Ll==V3*_Y z9MM6EjSV_+<<|Iw=i0ub0{@{P%-K!DHfh^FVscX1DFJZU|Kf$^SY*=T;8#b9^#SXc zG?|mKbc-3f)M6~RvLQYJo>M0M>NUaxEZ{v6-5|#pFHHwI@E!|F$Yq^L*d(gh-J28g z7O>p$GcL6J<8i%zp9sO_it7{}7E**KR5z3rt?L5>;zp~Jp-qq=#WF{|MjS$3*iLPJ z#^Gfck|PGEPW6u^^ra?gUFR?zViEFu0etM$YgHHZ_INdGkNQM|HQn$BWZz5vT_ko&B&lK( zkSX3IdWNUjT<~S~J4NH<&Mb|tkR(0jA}*fmH{0C{77#X{LJsfGK z{xT_Rc5>z4r@#B~Pn=~RmwX|>Q(6(tUFe0P% zRx?fk_C!NX*#%r;Z3@x{BP8U*gK))D`BBi@^SST0mL~kHsX@i0sei8cmi)D$`Sx2` zWxrerfPMZYe(FNba!g;@hGa|-`hZhBc7rl|ik(WT7WePGM}<)QYFso0WHtjJDcH=` zxf38_I=Tq=FB2&R;{-3;{7nw|InWk~Otwe$4HVQa`)(?EB~Sl8tuo!c*vssQG_ zN-#4akW6z%eKzpct5{$^NEH$uCYTykn7r_NuINzux2UKr87($e>hS*t^fLQh!RG$< zC#W(AB`w9d(X4s9loqGFLQj-v0!^w-Io^@j!muMqN=jZ>4XJ>X5rBqV@TIUzUSz*K zaz)esslS}PC=QbP3q)ai8s-fJ-0luiaXA8vwo6-9*PUNy!IVDZ32|ItvhQNw1z0h_ zJ9>I4h{+L=kaw%)&P7+peWC%^%b6_Y2XwCD;m5ZK3OX`$|HCe4wYIb5oHE(One|v2 z`>!CYr}^H6qOg$4P7hgSLJZ=pJYKv{0~cqub&(v4pTc|t%>{Jim=PYQyh=2y4S zTiUv_voeG)uZjjO+c%;ZK&o*i#iv-RX_TtnIDIBAG~}bAxV-h|SNN%e6}_*-G#K>f zEk+D_S^VmbZ_a+We^f%5CP7NUyrKZH@1i&@D+9QUsP;}^f5G6kh`=V;qUFJ{mvR9s zkN>m8HB8@1*kN=cK)UT>H?le^&i-@9*w`>Hj1J($eV$NN374ONuBOjZRK2U5}9GS4YMg_=n{w{Kv4re2!dOl(iloR>9Li<{{6?Ng zUnl9a`69ImvMOnZNdJn-v_mp5>59L)`fKGD*Ag=)fa`jgdB9)&F$$%?T4RE{UlMqB zYjY8@=;JP+^tF%j;`4Y#W#1PU1|@O{CLIKeR_L39@f~&hTA^S5(+hyv4j-(%bokTl z=QCKZRr$hfPCS~uSS>=tBZA-CAi*(jeiqYt5m1h7PT=!O94OD@rFI-^ZAHtD(it(0 z4m6+6S#EE*bu-^e>-7JrhJ&f;Mz&171yHXs3*!8GCTrR~XnBJVQ~iU3Wv4E+nR+{V zg>O#O27I18E{TdPO<(=z%s>Sw2C*O^zMWm&vRgGTku{Php!h{Y@`>J%J1^^o695e> zTo&9hFhxs1l0YY=YLt}?)SCdX-V4M-2x(AX>Q1#S_EruMY!Rn(=B8zy68+#k%JLV6 zAWfm2QWid4>s2I-^)LI59|3iT&bF$$vpmvJa##dQw56YZz7HVrCS%t_GR@7@nF$A@ z{|`_akG4@RS2vSNtx?apGY>7X96D2vYaeCNtqe;Fma&l3ySlPOl=Mim+}L} z))rQF`sZ{k_P1Dx$nC{tRKS~J8uV06ywHxF-khOR{6a*0`}*T&Z)F?({Pk> zpp&G~X~;gkugzNlX93tI1tp|$XTB@@dK$-DC!hVD6M09b^+FHqY{OA4vf z&1AtoRg22Xp7gXFlEKq|Bq5-mLqqh-14V(?Ui1Hy*q%4`3d3Xko^GfH5MIsa2Brl# zSkp}I)7A`2J>YB+S1eIE%EFuo!W9I1wtgZb^Famlk|x7S$Uu2cD+V`c3>{pFSrHF? zw1TLPdK*ljLx~ApB`>4}H_I;vXuspejW6vxa<%x($sd&Nn--WBZZF6gkc%p5DNawy z${wC@EY8nlilksCTK5RLmtriaF3)PNZjR3Ot5m*z2w~rzwH~woO1`=IMFgEcGgF`= zvooV7HTe&v7^3bxef%}V;02xioZ%lm2X(3r*BXx%4zWPp-5YlKw=Ag89%!jJ zgmw*!TIOqV@-iv7G{oscCxZ%>5tm|V<5b>6Ac$IFCO(z1uB!Ad=YeT9K8Gi}D|`6Y z_}^Yc>L@o)xyUqJO}Q=wrXyVa&UNRsMk1`c5OvWv8jsU`#m@H1O~LXjH6ply&kw)m3 zGQeKQM|#cs{XS#;ojaI}3; zV?UJafDbdZnVU4D#X`(lxo&)Q+>=A-U&4oVSJZ1H4RDr(dtsXSGFWC-gDCbQ^scv+WX8{EiFl6j=X^eUW6s zTCQwaebH1a(ZtUz?CE1Qk5IC2`p(ro(rxI&qI!hvujAw$XhrCWUlM%S6*^qltNFbp zd=r9!2N>e8xeru85tx3GBIJ+5YE9OU0UE@)?(7O)YJDA@3y>t=6{9w1d)^R+AwlAtNYpWa4LFTJ;C~bxNx-6 z^r#x%(c+X`mO?N;2ZMg5E*7sK=`s;mq)vtsyc!G?5#0)DJMCUIMjL6|Hnu(Of+fUY zCWSc9MRAOmFg2ebeP(4!B$Ag(TU+Ez;r1sEGb@h^jZS;S2Z~{ag;VusXZULM=eOe1 zsUFl(6??YX=oqKj4T4H+LhI?7y=l4j+A~nbVOIeMZX7BcqX2J@sU2j&O=u+dj+ZTH z!8+BZEB;7qw|06!Ggz`SORgccwm02d`HrD2sN?*Ib>s1PsoGu5()pEo)?K%MQEp?+ zjDJ{SXs*ha?bpxtqH;p?Kfdp#A<585A=p2yS-;-TUvDr?A8UzOBDf@cDLh)NZPpKK zM;H=ss5p`0VG0U2^QM(ayeR~^XD2bPN(P2=4vUh3Tc)cs(1yP|$FZBs+eufb59<82 zF2%z@ZSV97K&#XKX%wJLzu-Cafv-E41;acA>8#+54e+f&tvYjWVre@0}j*G};C?RWY_?P~Lq1Dbc7f86=eO6Q&5@BI31b`_+qvAPt& z@~art`zKm)QL6FT597Vl8jovU>LZz*_-bJb#1Xeybv^yZJWk>=!N4D2&h|C~U-dhz zveM8-^d38|kEVj@O4m4B;*in8LCEYT2T!-2ws#yvW4=A@J(khIwp$+~(uu`)+5;h* z*X;ag6Y6jfOU;tn%`badU&CO6RRXUQ)KspUw1>HN?p z0D_?LT%3EPQ_dG0+OzzsQlo?(Mz;;Z$5c{H7sz}gLgJ5oRm2tZoq%eaakyG~$~OAIlZ1+Lq@y$4`l9-QFJ1j z`G~+HSCVRME8n{!MOSqgzN1Bhe9B78xa?$6>9n&lmt3$nA&gIixrlDK)a)sb>g@sc71r(Yl2Kk(+Wn&AU&Bb=E+mkO4q*b9}{80Xmtz6m=#}L z2L3_eKi2{|j5)3I+bJ=9mXN`zORAx(E|Pk4maKGAff19v}Cn zCW|pGlgq6z4+^Ng_bc>@5IWXtWD53+f}Kvj-aE`(L0aC|(@Ru|9&ay1ULOYbRk*P5 zGwvE6D$8(5=jX(?h8K8FhkfCS)?Td?0Yanbgh9{@9md$<@`pc%dlmg_6&dImFvY>X zPFt53F^t`d$u@c4l&Z@=K_EV>QKbTj33g}joX_MAcbPU)2*Q#TS^O_P6n9@dr>sy` zwki#_(;I5tK8T}|9e!3Fr(?aX%gs`%yR#11Gb zi7SXnN}TREoJBM(haqxCKY3~z^Q%Ozf`tA^52Ro=BcIwX9&g8ruyJh)IyjYsEtbOn z{Zs#&Wo<^$&fqSWLygH!+H>h6VQXdlRk=+fUXd%)x5Y6B!|)n$x>{d9`)i$9WTgK| zJI%LQlB;+r^^Kw9<;3~h+oXRV$4M7Dd#|g{GkA>GSvQq%XVfq{6kwuV;t8Vd?7@rc zG7Q2865%g3B_*%-Wpq|BiD4}kYz2_*C}VL6B~nlOFKO)I2M*uAe=1k57b6s%o7Fgg z;MD6amrV9Ca-N&5AUX4tXt@T4GVSSnTGYNMrCpS8Dxwl4+wL|}{_~`;z~1AS3d7iF zL(nYf-|TN3=4ZY&FyT;>+e~yUeEK@Gt*4RC&`(Uje)hXSU?HJLv#mCYaV3Q8riTm^ zw$-=(r5@EWZUH3;5Bsn*mYjG^Or{U)G~+|gdaP!J8-EI2r$ov4)+ENLQ?E|6JaZc<;z2P*q zPt)T-2MB)-Cc|F0asFlMmG}2o1qa2Yn?IXLXv*Y_>azzbSE40hEq1_8R(`3TG}fm$ z-0}T!P{?D=e-$X;x3f3i9qlX!+vv|2%G^!Fs25-%pdJVp0?`ZfAc%G$uy3A{Kt1_a^S0?|@M49@D{R*3e(6|# zWRep?0{zo$x$n=(B6`&o?*D^sT+WvE-T z?J#80`hi`F6u0#j3kMzGtC(1GuR$Ygvp*Q{fy|dL%}f|01KlIaP<(Cv$+F$~V$?T8 ze6kYnN`9>~2Txz^LV4ymuOO7%{Q`PUrwcGR11Tpqx%Ubh`2Uyrcz zD(B+?dRtOmDR?DHE(9ko5hN5_!rV3aA;OVVdt?}nW@+K1OO}+hR<8ZGuR~!JbhAHe zge^ObC~&|>o3}Hm|AGkTz1LkLDgGWB`;zfI8{WS?k%x!FBZMw%VkCQ18ei2FTKzQ-!bO72L5M*e#t<88FBm-AehsE(T!;R;C zuKOQ562AzmR$KoRPE!~3>RlG`DWEwOumwO1e6y&}I6ktp;}yx-9FZ*v35aASw#yJ{ zdn6F{dr-9d(9h{&=Jj`66@B9z;Hy6*6q-9A6J_u;TO)C=_KNZ=n6F7e!Ic< z9L*=EatOeG@zJI=%}Y<_;!&`$u;N?t$W3Fcr}KkS*R>0+(ZjB;QuFm7#BDP<@xP;G z6T!$-SjYLe%(HYzieA!sZ%Om_*qp^71E1aTFKkaxKL&AsR zbg)>}OjRxEX>t#M40v-LFbIU9VNw6SO*ofWGy1C886x#@1n!?hb6>CQL8LSuo&9h> zj#Lp2AJvvZZ0de3qcqBxKUTP>oyAUD>d(Oyzmn7%D?+RvZP<_5BxOFm_IR%OqWTju z^%1Fyu6udSLW?xuGr*rJJ`-71N|sQ%1MWV-c4~&d~6o$A7cyqj>jg#eUge#*1LM8 zB!4)`+kKU{Yx%>1p|nx7?*rc_S86gt;ObzpqB}WAZ`As5W9NAU`*PH9$fZ6p{*C1N z+4D5!qfX7i!EmVjJ0mC$2P4h0RZBEbuF~T8qUD7xN30K6|1>tt2ck*Y_a2u&i8Z4y?KLjHaYlIrfY*`{Jn2>Cxfucv$$=6n1mRAYyGflzrxmV zshU})t1c(uvHf-u1Zev6vaa9H@H~1ck5OxRHCf~Ld)Mb)!p3f)(6BC_OpCC^6PD{7 zm_;CU`BfwQ^2hE%_$RW=gZ{*uQ0<&Um1CrlazZ97k2m%`Vv_3vuNVWn`k4r7)fF4g zfY5i`+P@1@?Z!_7Ym-V{kh%G~Uw+0|eMbvzOG}IO4UI7PV0)6`SGguM%^dJy_;+!7 z#B>S90xrXkJ;BWisrUMsMjPF_=S}lkD(mcr-eG^GDV(V;14#vVa;rFi4H^v0Pn{v)Rjv7-&0V&cpy{%A&2KR^()6 zy7G!Vl|aCX<+vu}*WhO>PpPBFR*lqpf224%F>o+LA|uI&8TE@Q=KmNh`Y};X>W!Xt zW1UVlX)ElAj<7{Sx?enhK6ch_okXxs9FVsjB$$Ctf#*uXAUJlu`V@4ZCt;I1eDj*t z9)2H-#3FUY*DbFf-kv2%oj;f*rxCY8cV*^(!}veQ`0`@WXo<+gDAlecZ>EUDR@>Nl z2M9*cW|GGvnyxlUr?(PR4;@CG#|ZEwE23x+tyM&8NDC;-RHm0}tyl=C*ek5L@oJ%V zCZ(LJnLWNG!In68z0%L{n$nV4Y_=JeuuJo~n$IMassv1cz~d0mSdc{je1uciWx-fQ z*_@VEGl5n~Cq=F%`)%t~R5{!b(a=sNsN@rr{ zxSukjB70zHc%XUq;YxKCA^q20YYe3!xX^7Q5iaVAT-sFrjRpU6yd_L#4y3yHL1`qu zEu^t?koU1HOuQ%=)PPpog-$P(!KIcyr7v%1Tb)-KSTSOq8L{c$Pj7DuKH{kFO6td- z+4!7E{%Re+gh$^zgABp=g59K*ASc)&D_`VO%pZH!OYin=2J@dF>^N#?g;*#@{bhjN zchUQqFQ^}hgDmsv#vj;^@A3)G?m1zpHB~-N8%%hb0B`d%oYa%wrBXx@7Bk}oH51t^ z@#G*-UK6Ainq|Y5R{_3aDZQICD(i;8g5V9GT59lEt0S)MFS$xBzgj}nC?m4gaykQ` zt5`!}CShHfpVxcEmIl9mIo!JgONmKXrtuikNiye1>e{(A!4 zwJinvt2$|$fD8(drwcr@9hW69X$7%Oj-BqaS#p*}CHyXW>qTNnQ!!OYe<(2W@U#735b z>s&%6cfovU0y;6);!5yu(xWjyZ_{ZjT#=Mh+ijV@5nX^xUhi2_aXg;L=G&&a?xUr_ zn>O0w&DX$y66<^>hd~+<+W15laUwYK)V=HJ03v5oe>uO%%sYMqvaE#C%a)%+8zvyz zWinHl>}L2rMyppwF)9h@bh~=P3R~(!)L3c+$WORZf&TRgt@`#%9P)2mJ#6BC-a}nM zdS`JERogL^7N%4Q;xfCj!A_X1eU;Ww`m6)Trr%1$1?Jnq6~GqcMi@XvDyeg<90xpl zkEg1PjRA)*j|h%ELjD@?T^b6tDynu1Sem0z{En?H*>D^dm!)v-5DzXfgEVT)GkQ;h zK<)urJM-b;jw@p`=jSklHFZ%uuTuydMmNJmwP{r%T*4!1223T69NrCcXl^$eN>85% z&xQvNd*-M}I&u;aZS=7@$!R^Gr#nHtMa2Z8w{6L-~aE8|Pqe%n_W+y-)3^0q+Nqm&tZmd|z8W zDspv`gKIJbb6~K1Vy1CifxC-G=B4-kGIZqd`v%DLg1iKPIyi6mQq)C?RP}e4(RTWR zK?!yr=6_Qa1`ss2#EJ+cmP8q>y=691qL|;))*fi+R*rc2elw7!U66oTLAx-!b+V9-Qb#I^Ki|>HXlbm&aTwpc2Lu-n*|?xN&sYxhwJJ@ej5=N081Qqv=;Z zrwxq(THT1!adQ(?E0(?kWp3U>WT=-^iZxXo;yp0h;xo3PYk<72ipcz{myJ`UCw=~x zFc#Yb-O`d;N?bTmm}khXST^GBeEl2c!a0 z{VG|!d)*B(&d1vM-zYp5v%rXjdjWa!vQ&T%Z~p5aL~$i?V=jlqW1Kzn!JlD?P1eTP zmw|ga!EtSwzP7_yz^il4sC~Y7){F65cR;(z5XJWP=dhqj6 zZ9X0oog>*%KS*Pr%$%|oUVYHG-iqLQD@69>@84BU6P)R=cM<%_RX_XnwF?`Q>DQPgU*BC zOQqp=cJrjaeSvM=xZESQpg=|prbR1f6ec{H!Jx_=g{Aj@z%=lyB zD%Yll_^=j+s7L{#}aUUiAfM9`^M4+lxm2xYQ{+X&E_1L1UZeNytps;-RB0waGW9#CM#npa9=H8gwf3l&_f{jE>Cb+j#{mA;#(%##e|oUU!N`?u?3bdxAd;b zJ=8j#??FV_-n>3j$iI{%!CN%R4CC=dO*6e{=s3#tQ%aN|C+-RWY;WVmK=q<#uyWZz z-uBoT@25uVuDhX#AOnNhS@vq1@$1d4x9|H9TH!~jpwu*O~+a^bKH-CKVK zPJE%QZ3Z@4sMbhY75B|X;7UE!45(O^t33E1>|C>?CRI3!U85lLr(#<~#nX@1-{PCG z*+@_p&l9*U4v6}ps2144shNGpks3y(J}&K+8K95W;I0GNgf%3*vV!Z8UyogL{nn&N z3_rfgr=fHjR#|%7!N(%0opz}LwO`EGUb37FTg zrkDW41=@-*zO+aWMWNK7Ge=0ebj`&NezT)D>n8FYjo?Cbdr~(V(@G^v`vUJQh~tK9uB2kk^QnZJMzxWtke^2} zWcVgyUMi);!leZ&=iuG|yR$O;oePO$Dpv9fPE{U81v2n8BZzxyt9!au1X7Bw6xG>T#plQ} z8v#eurd_xWwraB~V6DMrv@NnL;VFw#y2d>m-_yj^)P>Q-$!~^KjL9!RFtp+|x&Q?R zGtSKqg4&DJz_RHxo6d6J>l8ZW1s{;JOT6}w-wmcYP)SjI?{`G_1XxcoWUww2KxMBJY8Zv#DOav9Z$*kJ8F5J+!0a#;~O zf0FjTW^-@3x(E7=zgil^8#zFBsp___le2TEK(GgiHtmCfj}Q4pJ!;pM&F+8Q2M@{4 zwJ_=k$+4Rb8A8oObdCldT5a3AKmB?W?&ejV#f{*m#PaFBC&Zj##i~8COhQgqJ79fb zd-MP}idSk>$L@3Sy$t{u#A*f!#2zt&0BjOT5%exqMD1+Ro&iu9?+Sj zi`ZS$dMT#)*&1!#K5Bt>Iq>UBhG?_iOB7#f+l&_$w6lU==^(3Nt+y+&+ikt?SymxT zV3c3=j=!~Y-w;3}>?&N%9%q_gF+!J43oK4JU4WR%j92JBAluK3xwPXGH>)}3!lee% zAD@+9ge+r*G+u6MsFe+;%L}yISsyZIF65R3anvDQC*?13zO%JH%mJxW9sH#S#HKSV zhEpqs_lQlmchx1pPJ_VK*Te%adN}jU2rltJrB_p1P}25nVHa3McA*#yq_ z?Xk$u#|bv8ptpH_9;e7L!ZjK!IG##sx%>QNEG;yB6+5U)?LU3!vALt;?)7tj_VpIE z1(~M7j{QEqKiT8Zefab4Zq8ZOgLw@#RV!tMTE~>;rXgWneIvos9p16(g>5#Z%*PPh z)NzVQkFBOB*(IIVj%{C2bFv`Z`$n4IOA|(qDx55dt>`;do0$zbtgVffBvm3;;!i5! z4nM)jGvRZ1HQOLLQ595S0oOOGY9WODp%b=JIkZSrkW|-2_WO^^B1-?Hef0g%$RL!! z8YAOCLiXK5HD@@F88_r?zo*wxTQkrznUEFs&Ke0;UnN~&ky~B#(WpPG1sN-0L%DBU z)~sCbf?G6v5$tLO8olo51c7rT@k@P5=ksI(+u7X!PZ*++!ELjs<<}p4iAst&9h~Vz zQub0*Y3C-9Xr3dqbMqI9(I#~>4JmNc1uP-D+rjY`=V^xR3#|1ZIkfwV)*)*y2fyf$U5Ig<84%sQrS+uR3p(f0#3`!zMR>Y7Uq2teS90yM(dDlXvTaZ zr%(BszV#80=ucn&RyX<{-}>{t%A04m5xkW4l{o=BklpQx@giy(Cu@^kOKs_3t1+sB zK4Y)*`@|3Q&ZH*;Bh7soZcKe<+pLTBaf+dn_|vA8A~&#{>}rpS?{9YR_N42K8>)_A zUAsS+ZjpvYU5Uyt+>jgwrzL{4@O$a+1-$3q$H&znR6Obix8DE!W)mZJGx<|H`4VzK z?QP+Ium=l`k&>6cyPy-3N|H8n&7$6Hh#Q)xh&`*Q=-tmPz4HB!NN|WOrXviYAbTCn zZZLaz8t(b0zLv}6kFigME?{_?!mlV#lTi?xKBwDGPcxBBPv-CiiM10BwwE1l8Ntpf zv=Q;9W~ZhuFzZ`CqZ}TP*agA}8iSDvixYodk>k2fc&%-Qm|7uUgb%gJhNJo#54+8h z1vD{t5$kvze_2(n@K%Z$9(}J{kp%!$h^og5&x)hE@3D}zNg;Kq%D?> zgYwV2`z4x{v?Al%+@Ex{c|nL5(F1l<=I3la$yMnW6uP&(9#z0xGF+~H(LEwj3-0lP z;njV7iUWf3w!^w>F0ABHP?4c&Ga0b8q9Pn{%&H9Hc7dl)C5OWjZ_LrHG|7LkEBtp6 zd$zaPvKf5chzA_=YH9v<7wiv%-TN_}TCb>_1YONfS8m1|AI0JNsgVQ;Lg zk-FFQM)snZ7uZg=@9zRhcjD%1nw#| zg4X^;KcI1P7cLTQkiz=IP?X^${7KsuDs65FBKTtTE%Sp9&pTTf1GSXtW=zbilH|0xefmj62l@4;Xr|C$*0A$3bGekEwg5ICK+YyC zf*9<@@GkLa;eEA?LX~l`88wj9JTf3uGh57RuT*y zu*ZuoA65M%)8T)8U%h)|uBWqihAgIMUw<|aL7)@*d^d){_NR`!HdPZFUx{kJH%R^8 zkhfAb_8Qa`JN5Zv;M)e+AB_Cc))BJ8&T~aYN?QpaQ#l^j8&$)_z~lTXA+jzCITB^2 zqQbVV0}{I?J7nqc9pW{=1@_u*Wt0Je#6v+Xz{aPS@KccW;a^bZv8x5yw%5TG+zW|? zk=aVrT;^srwT`0OGgja@$sa)z+TYiXY4UnTpUK|>he+CH`%_(hXUUTcl=daIXBgWk za%Y- zOX2WWv(5Z6%U6TPFxBxmu-#9gDG=$z=N{`i^8y)ruESj;ARiaQd^uiu?>&-2q)oM- zkL71ZxS&G-Nvxc)7*w;Zz0zpPU-i+p^Wx4(3!Z3Z=!uMb~dOC0xnp3gLNB7nZfD>r)Gf`5Cwzt4oFOU;$~yF!wfeW zfBf3k)B|Hg|EE_bs_zu<120Z<1vb*M_B}!1sbs)6@ySn+_0-K;jc)DjwX4$9a^5u|=VnUc7iNL41xk#HQyB*P^r$f-M+YUe3P|}YDQMYQSAnHrZwyEi zeo}Ru5 z$VD2kxArbPHU@iquP;gG#c5iJb$oFFX|ZRO8R4xz|7HgdN%R&jvqst@O&v4WFT-e4%lA>Qw{+v4qb~7^eeb!+uq1O)7Y6!(HFhTa_ zh&%@~q+z7aslIAteh#==2SQ1EwkPC+0@EIOb8=*J1 zhJh1PbHxEb&X^MqOG~yQ9p7J^Vy(@Lvzd60;8Nku;OV@_ufVp@(~n;@HFT9aWTn&T zBjRLn9+NJBRNd3rNtHp6FT48`9M)KBw}a3H|^Zhe12N&2KbMzx?QU(T!U*K>>mL7$y&O*J?L#lo>SGNZL? zZE)}DyyPs4COBX`aWYgju=lm&Ko2bwm@39W1akXvJuWg_vnHjbwp;FZ>uz>iLL zBW$Z=)84x#^b|Tim$|-Fc=Op*BU`S5C@Y(A&(`Z7IpM>@ZVO5FY<0+jZ#y~5O#!09 zTbI@ghfEr!uNGP;z%UytWn&z#;60ITkF4)p9@%j=@(CBMnL;{_^s>Q?+L2{8Qmp$W z)|oSUR_<17u?)tzqeH?DZF2~?eqSSDTGDL;-FG^$RRv|94n>||g^w9Ft}W7UeXgKL zA23&c^2ILoFdfvcfl(^HtaaZ%cdLFgiprM(Rgr6qg~6TJN0wpn{Nyq z7~haw{vj%SlnZyqXj2{!wzMoh^H6HfL`j6KS`1YlUyF_C@9(I3Sh4A9v(Mz7-2r4IBW=mX^rWY5qQvmd>Rt$?he>O6JCo>1`)3K8iM**orf?>gwNb<| z>Cf?_`V(F4gOvvD=nQG;zOA(r%u4U=UC+g^{KIDPOBC5}`Q^m!=u}UqXnXAkpf{v& z_ufn=a?bTf{ccroq_7%uHm(dgMp8y9eByW&_74K^eG?pe>AyJVi88N3)%x4jyGW74 z2J$l9oi7b~Mciwa`>Jz3Yr?xaqRj{|rDrti?R!W0o|BX(a|7Muq1Ho%6({RGUvv)` zSy$FzZOvtRJIzujM^*5H-B^^zTE*O3uM~-0USSQpU)5qr{QYFS+Nz!9P_@oN3yZn2 zO+P$5jtDNNjrx)kzO|fp>!O{3JAZPaOLH|bp6H`^s2BG((yPND3lW}ejOJ9CU%K(4 zl*`+cU}vUqI*T|7w#Zg`T*tP3=#+@iE@aF>B`}bx7f0S#xKfSl8K2pdC8vLfsD+2zH|r$!p>T%)FOT;I82Akh!)j3d2lJy2R}?7m2w{ zDn5rd<#t`YCLH#a3L@Lf5emYvqwpn?afgMU0gW-+L_x52E(27JIhgkDM(VuU(UY2aIW7X0+9~Pw!I4M;xwE z*1WPdcHBGJ9}!)$n8SOtR_)p>5fZX=LTG`?e^V2EE;BYs!u+@@@3b9H*D1q)Z-|yU|jHui& zsMGYaO3sHlL@UIF4pnEV*SU52vSB8w6y%s!EPNlw$X9}TX4OY*`FRJ8aAH~IhVacj z?}JEa{NBVN!L?)5_FUb5o3{b-;2Bbu?zHgc9%1r&A6pa-pOKo zu+w||xD9$cg=HqwFD>)Zr`V-M(C7|6YEUKX5cL<5QjB9EhNY9c#OpitWA7F#O9%e}samo;vf zGiB7yxp3A+%}YPD9&PTrMDm3>G2JpDg)Yh6naE&=dbEeo-*1j!YzLVc)8{pNqIDFq zP?sRIdw4Twt)f`}M=W&$s-f;*#Wfc~+rP)t%$a!XnnQHaUlj9dP*aNC>=SfV`WD#5Ot- zunR+DV|(@fkH+!sDU@eg0%wQL8+WZGSqB7{&HUD196eAa)0+yBxK6Ex4|-3}k9|%62j$gx9K$G0mJA@^ywg z<@=oSa?IrH&mAk7dG`BTSIZ~6(JvQ98Z&%IV0vzg9Sa$Aw>;GQBbD#VFj;?cIl#q3 zxI3KyChEQkie}U_Y&N50*m6a{SBYdhG7t7RTjt=4vu?OCbtPs40iC%r>afX~7}=ae z{@HG+nqdCfM3kpdlzcmV9l$2pesi8MDRg`Q)4z*=v6k#KW4Fd-$-j59954MMMGh8i zZ1+lcCVZ$+R%oZEoF);64&cOGy;JeCR_Cgit$WA&SceCoPHT2$X&Lzl+_bY{;2qVx zbJwl6uk70c!#7VS8K9)tzoab@+Dduv-#luiLt>w3c&I&+9I! zQwGB`HyCDCt&zfQeaE+U-4IjlaTI?tyxv5LhUabOAnLIo!O*As_l^c%Iy3^ zK2Ld|*9+98Vs`>7Oq<*BY7ZKC`zhUFjbB`L(hYt9=Z8vN+{(Vc1xomNC0iiPm% zFtTDnI<6BV8xp}tD=c4asbl2yP$YBq86^X<_`Xp@dL6tzBX57=3%Mu^^r#|CDT&nN zcf+J=#stSIj`yX&9Yk-;awQVymRnB2M0PSUqyUQ;!>Bed7t9`hNPL3VK-W8)5K_~@ zZyi+NreqdyUGL}6C}_Ove0{!=&0&uNtx8+$%e!q=>$MG&)ium&_I-iP>g}J%F5_(z z=}UGcw0&`BF?MD63J5E!+))X7lT5!b3%DK5{5ZPJ~6gikQ?yY5Jg34Yu{%6#0@SD=DnRD zze`uURk~EDHTg0s>N2mMZpk`nlIKE<)wuiOhqh=ZP@CyEF$$`2)CAYoAT?G;`Jpg= zf8M98%PSu@As6BmRUJEhy^g-5bMiWmmzG&rJ2B^MIIRB&uoall+47Ts%89OuR*+u) z@q5?9a-CWMe&VlC4X>Zr6@9#sy!SgGy%P_s9bDp(YbP=ky7fjsax5C!D~)yTpcCA` z_iYP+>wJ9#dVz~UZJEd?!PSH_d<(xuJ{6FQbr%*Hdm#uO(>8sD%%L1Fj816y~4vC$U&HYebMyMGM13=6z{b@&Ro z-4RygH8g#g>50UFO}RY>(r`lcxl|XYp?pP$c0i<<4%OQDlXSerD;?;u z-eE6I_QtPkI=#;4`+ECV#!9c|{NYs*z}PlqeB_sZC_s^6!}ef|#wy$Qw%P-CSB8r6 z=Wh38BvlAHZ~3geV>Y%}Drn1?NxKBUR{O1VS=oifHFe>BEGafPK%-*scP<)@uw?M5 z3^3;?h+3PCiH3jic|@AQKsrb7(6%DDd)vOv>pcwfbU+0Ab9b%Q7GeRcii~U7b|#+gK4O8 z_a(;8YNcB5ep!vV2K({xL3CP@al?aF>9@nfoHv)FmC3T=Vk5dk284E=HBzls)LN~5 z=lv&Sn#%}9W<-&Mb!O}aJ9P@>8Ei3tSju~F*NVa}@gM)do-DEL2tT{F__G3eBHgvo z3~Os6%toH@3Rp#idAScI*!_wx+c_*k?sc<`T=kG?^qUCCu8Z@kM5kN$av2=eo76wx zgtm|^64qIgcYhm8fO_^N$l(d1zALL-@N(j5ipyxx$Tnuu_b zrc>xvi+DobhzWHOv0JhI$*KA#M$gL`fB$S)O5VbyM$Z+tv)zj)H0K|HR2897Hd8`FpATQAp6c9eY3 z#@M|4@*t5g?!YE#)b8P4zj6&adR3xB9;{`$-fGe;JbXvBhv7YO`i|P#23rXy5k9V% zr)6F}NHhv8s~oZoV)JLqH}7P$9)7zbwqD-{#m(NkTdLo2gomw1;q4G{R@nzaT{52q zrLiuv97WRCl!+6pW{ej&2s|6rG5 zU2+3`X_PiYh5Px($5FKn%Y1ha`^M`yCN{3`qH*VgE@eQ6Ic#N?KQ~@zK75rrUA}3X zQ3Y0OoJqG~#nyf+xw(x#x=PZ)@NZaPCdB_Of87I6@NOs<0HQM}rk!=k;-oOV2vO^> zr_$*O{MK=!$*O{==VqqK$>JJxfqSBSCrX@&0@H);S&GqdK_zDjyBx%4lv$08^jQdF z7n`LMD??s;(e;Gsr=#5oIocRjzr8))zYE3)lhb9ZcJ(MLEmSyK&qavWI839*g=(zY z4HVG4jd1@(t`Acmiw4D#E${b0H=KMxV%a*p_2U8&OCq+v}?BY)?kp77t^Hmo@ zXTbLc*t~Y>u3=hGwO~zQ(7DnfLIw6wHa?6b-T!Y0Y| z#6~uHc#^D4c%GGlB%R|2JF%TF+>6tAbp?yuJur9^f-8+mbm*{j1uo`!nq*yGxIE^g zFyLxI=T$whFuc#yDiEBw%;!8+x_g`daROL%VG$a84p5>Sv)u}EzIyfn8W@bxh)eFf^82oi`F;2?;OGRH;xSN5cWqOt%<_c6^=2n zj^@s-(VW+Z^;VED*B?1qh!OC9;mwH^JkQDIwl5UN9&F;C*foQm?zXL{13L7e2fv?R zddbb>t;+l2MnsaH-I~=}VkN-;r3b`Q3riA>eybLgw$WHS04g}(r>e*lBJBauz{#8q z>sN$Ql$&g+<lpHZC>%UtND z#eKY*y%KE67l*g4toVVyBm}Njm;k4HN>DeAasL=`75S|JY&c{eSi)f=unawwtqIY? ztxk*r!T8n}=ojy~A_{ z19nfcVYp6luxX-)EEMJ38IHjsc@H5&s3+w0J-C|xtB?#<3@%W(*HJy*@e&@d5s%_( zA42%x?JMif6@X!yToL;(aMKGnM(8L!xfkyNZtZ#|0KNbUeh|SWqL;Z5kfUQf!{lt4(|cktr4W)cEfWMA8CRJipA>9 z0z%n*KDhZlpy(5EIidXdI@&p8;a(9~iE3%>W=K~am1<{YsPxg&>he@se*a^xC6bUH zmXu7Q zkEhxP;Ar#Cl?aP;RnLj;QBe3P!DuZ^wASHye!dWTYQSFSw73a4okkC6=W{4IY;Ijt zXr~=9vQ~Z|t_o^*hK4j$57}V`n-L=cj8hp|(hg7sQOBC|0v_H7EL(XC74A1vZeuJ6 z>UJgYf~u^oSCvI|J8!Q{8ZlP)@(^4YtLp9unK~t z{Jn~ACy16ZrLBJSrj%mLoySQJy$|sx z2^dAJrB#$KJrR{|P&=z?%pM0&_Wh2|2__(ubMKorC}SObUhI=76FCx&4eZX_ zt*HMK^7tPqK*H`{gPsmsh?sI=%L=Z%@d^SzK0=NZv?t)7IKkgD==9LlgR-EISFirn ziAiKsa4csH^CF}71^h;T_c1++T?uf(=EMGj{Cj6H>glBZ*QbOpq5D@ZkkGo?uMOL8#= zfoHn=zE05S(Tcsw*A!;0oh}=T z4~*x#>A9xZJx&Sq<>2t}NR<_FwhIU358HVBDW~3oS_ax^0?g1GTCH5Gvg!hIm`_@3 zKShy`P1~nr&_FZ>d`yn(O38{auY4l5Ocz?>%NNMg|LxqF6J@h(+y>hSN^g^yzsZ%udXJYtgq}D*a zGYC8BOXtgeqD)sQW^9xNp^_!#wHC13d{!3ZU^4Ik}i%pI`(ES~#>_n%b`uukemeM3-uu(PA%2%r98d4CMZLE(q*2BJiU(mQId>87)0y>@R8#2l|<1vd0e9J2Z$XfRKRTta9J2AG`g>6Th49 zkMT6f$k=Ff-+7LGFYTEw?-V{Z@NbB!Kw%d-DN;typLYiFGHa5B91yaC>;C`Forxhh zDr9>cTbC}7BnWqa)>t>RVkXW-_pyuo!(@Aix1#JB0I8T7q8~K=71LFVW+&V_=Z)u? zjWK#U2T-JwQSmnDC(@?j6w!q<)rDXYDxi=cD|~c3Oj%q~Htzas+W@s8xdg=Qz52S~ z@%|35Ei!(fuG(NOj|!*ufUWa7JustCb)~N9 z^E`2?X2@YS*(Azo;dL1Ln!DnLC%?9Oi)f4T%-H7;TZj^baI#V_pW zKq+-twze$2AyVRVs!1B>nqrRkM(xYQB+ji9}IW(+q(m~!*NbSh4d6` zi2`m)(0l}++f;qh;j*8NXo(#vT}KV{_MM;g0V(GfA=bEC5W{zM`q&Xd3KlQf4VNO0#fX25E2-((}fsqjlod;}wpy1u-SLYZt90Q+M z_{6^2c(SqOwZm_>`5TOv*JeadPtEy9+d^MoA7^J0KMzHxW*F!WzuHyGPP5t&FwobV z7a%uc&*<<8>tT$GF2B=eDmeA5JGX&4T5~H-p(aoUHO#AXataGygX*DXQq8GSstcYS zbrWxwqi+K4)MsD;wiF=aZ-6aRj4yI7b+TANI=i((;*-roP*VmoU zW0$HqYL}q$$_pMxq#-6Sf3lp1^pPL%8yMd{)s)o#&lk7V?&7yRy{Xbs( zer~(Ix#$2$MMaCOhm9E0M04Krs9&Q@4ASGMbVacCI842ci+BOh=2)i>Z@5wo+D1@J1Sxd2H$=SNU1ldY!E z`Z&sItITSAW3ho{M9+p8$@gI+Y3W0O|L2zvl!&r%ZW#UZ-(E03>ijQKMHl%GK;gLq zD>iFm5xy3kzruaKfH7&{K%VUUotn*R!tYUjKLGzKt?|Lq8YA^3QtIXOv#2sG^eoxi zM7ZH<#+VK&q5gR1iySUH$@M%K_kx`ipc=t{aI6#w&n}O>L@(fpaqQ)W+)OtZc$RpBx=y=vE$;SzqfYp-76;^Hp#=Pp$o;hn7G#mB|j>&e6W z^K?fB2M3pAjuY#t_VKZlb8Cbi!+IA2>EQm$45u3XzY?wgZwi3_M*-jemx%ib+Ie}f z!0QMDiqeZ|YmW?5zW(a+!puzeuJl^u$nXh9cn|Nb@nqYR5*@?mp@abvD#Yn=Va#R z+nAgCm&bh>EHIGZh_wXG%q%lAGwcj&5J;gM@JO3K{Rx=fQkmM=KtYEO!-!aRgB7kJ z;^O1qo#=-Wd%D7aq(XOHV(SVJ}ML73?bVZ_qqxYqs6P6kQ-8Eq~xh3Wo7v~6@|66B0mG1 zl$DhM5{iuF^7H$9d%3u{rb{25^)x|7lXxq1Kpr79G&<_BKJnx0P2#YQj*cKwUJ5>2 zs>P=--qdm^h~3En<0~kz+uxiKbY5=Ke_q!OpJ4bCeAnAS+|$!jS63IB&%?_LCPEw0 zOa{#XWx?YmAF1VP^&yeS0ggpC2 z77h+uU&MVu7=O=+KjjG+akZ^T3@!NCFa1$yiy z!0oT~Jm}Adjt>umgJ;vt5e5Ysy#ztGFZuZX7o6s(aWs8bzH_-XngtkPoB3l%C|xug zR8LXy@q~4@T5eW;J{;X8QKa$$m@_a00I(YCvC0cB^0X2E>a+u^)2cQd8w-miP&{>a zWrWa5>Jo^5CK`fB!IdwF4kZPI5dU!ai!d=`gqD_;bU@gev0WJ=Glkw_~ zpE-p7(YxyPlH%e~hfZNE9S`K=m3d20dUAzHdMwC5Nv4mj?an3+nGSd4_)gCb3jCr` z08T3-Wj2G~CMSNpyBpmbqv96NVe248V+*P+wcXzuv| z`U|l|>R(1&Tp_x^xBKXxUwr@}-U17tBdJIChu1syXs;a7Xu7C>{N51Kc1AVW`EY5y^bE&<(9mo>kbxhB{{&md*1yR6&-Dxtu z=;)oDohT-CEOqEsITLZ-7F<^W`rVW7guG<;vD>!*)K+4y3aD+dzVcKbnYFcE?Qz`V ziN%01Vr6e{|6OQP1JA)OfVNCZ=myc<@bEA&t%>h%$YLV9hlVQbPz|}-WjlTK62)n!GCpTvDZUZfX2r;lVDTqN-Yt+NjlASzaCmlm?I%LLnSi z6b?Amd36+P^YeeccsT=&Xmv<4K590!ca6=U!a)Eo2F#nDo(>r5c-I57kO4f+w@V6d z;_ENj-X?7xyVRen%?sOE25_S2_Q{MLW0FCplW@EX=&Uu2u>pa0>5^tA50gE z``)%1{H8zGkq8tp#A-ZV>j|(6-)iSQ7|*T7HldMv{H!oTgwk$set!OVv6*tdAeo@E z<@B2jFk&zw{W@~Ui;^&%Ol5#cr@2Izo$bY$7-%i9wy?lD*Nv%X4fAGZX9t!XNK&9-`F*FE0ZauHG9Ue>|Le!QYvRnGi;5h8 zWnc}<9X0WkRvc)A_#ZHVJ4^<*Em z39;x^^My%11BL9Lv5AU*mx*C@N;}WVCxe^@dy6a>yQ|GI03#sYGcXEFbN~^8hmHdg z0{Zvi9s9PF8V{Z}W1F@BL` z){`D&`yM=`W`8!mrq*$~DGb~b;_T!UWa!Z~ZJVo6@Nn^7N4O0!GvuQhkQSh!Ue$!j zzc7C$1F(i>V8b@bNvaHmq*W)FsBqLZ1p$5?z>H2#PKxSwFKW}$E>PLKIoU=24WE*M z17>Fos`j+sIWyL;+4Nld5pG(Qj%E+TK33jgMhz+8blz_|%_SYl*pnHU+9<2;87jQ}JR+fS2#z_nv( z4t$aX`$;ga3E-D0^k=281A`hF8NH8bZ4%@?w+ZZGEzo+uM}(gu1T4w_0o_1VVl&RB zE17=PTk%oWM_T|#Fr!Dx=O1#U20c`&s;f)r{>*Pn;O7J|xUOh~C^oq4{X_E6y#PYC zj-%>-MSP4E@z|LI>Q%iACPUf6NBAtt&3|2F8|3Y#kCQb|S-?Sv;apfyEC6eoBj_Y_ zpT1O8B?zcb&YRK+JDB}=9&l`=LfEBQptaS&(Zq1lMo6ifLsXJ>IRBmnIDHNk96LLA zpxF&qp<$AAx%dZG7v>^QnIWQ;m>Yzs|1@vp-veG`#{T?{dGBLjO89S0N9bZsn}o)9 ze)<@@NkFy$010x}AXlhj)E9yKrMu^ceR%bT_zVGl zI!z{K)|j;n-0X1LHiH~Fp8WH%5v6z~5`qe19Fxe0NJtU470=2`olTO`F7K8F-0JA@q{`A8-Hb8r>uXh(Fs-i_i;s9qvg! z>`FBh3@rw}1NfI5`3sOM%-7TxpFIrgJJ-*tANgzxxGQbKcZKzeqkM`2{CT=b+usks|Fa&BoZB#Z`HAP;(Pa7E%GiS^i6tN`+Cw z6WEQb`GtiXv9dmVufROZFI@!Lv{80D@G}_c$4lpX8Sep2eul`!^RQ&2ED{oIezpr4 zp{}AKwyfE};b&*xwBQ2ErPE1!3#nswpyrZG#aEVi>*D$tkZyB{_Zve@%+{%Y_~pX1 z3c2`xISfcd3m*q@f4Swf4||Yzv=H)?_y$qX;+(D)f9=CXMn3hN@#-%te|~(;Zu)S7 zIzGYp9f(l0yo}LNos-55wTeQ~^>)Tno@S6i4q0mfNa9mVOKTz5=3rsLa|3^DC#CCS z0Z)nNTtvL!&(l;MLf+@>49vD8giWSV9-D8jO&Or5DbH<#3I>e%hO(v`Fmg4H-$pYt zLqyScwQTE+z8E5qTeZ8v9w0dwzc;wYQZ^>AX_u$t*w=LJ+!Zx30>gS66|@65Fo#Qz z1oQ3v6tAeq0FH#~xYJr4)nlf}*AQ=O5}R`C_tcMUYR00@`S$c{Bv-OMM%^Yu+z<`T z`%7^a`NWerb;qQUAkKdBX1^U4Dgs^Z(l+1-3&#IMUMMs}4G9tceMA zFA#27RfQrspeMwGT3FY&aY5Kl!Z0+R@b%+!sUv^TCK_||N5+yw~id^Cq*v1U8+$o$aUV=a&JvvUhX9l z=WxCF;_=%_8vMuae@FUXdRVN?{P{CAbC;S&m6h&%VQEQ}vxnx?%EZkMtBemypD>#* z>6LumQWtxxynl8h-8&lR;-chc4!Fzn(9T%CjLyb)`jKyFr^$X}?M_8U2^^NRBG9!h zT-V;rEKHqiF_71+wSrz9izvajn(h|6BoPx`vRw1dS2t`FOdLZy&YosuL#D{VQ4w`M z>EgRURuMYxWr3+V4vR7J!rL+#v_=fWy-{g2EUp9d-G$4wgtRq85UP%KCf~9NT@;<{ za$kmecfh%@O>Y7drK<>hlonBy=;f}||0S2;0YNGDjnEjhH0YHBW{Bjl*x9JHaIF7S zN`D?YeP#i~o-keMyyC9quEj*S08H22-Cb$%OKu6(R%CoUVFh1Z(BcKi6h1Dcz0MX` zMzfN0eGB@lWJv++z{eMItzik#i2j*KRw)J_XWQ!742%5u(EddnK}hIluS={Xx?0hD zht0gQW>v4x=Nv9CKs+(+qBU#=)2(2l=cx!^ zD1Y?|=rFFhD{=^<|o#PGSF)f6A$9#0yZ)sD?7+iU-Ew0MfvhivcA-yp})LX$74)+A z0$EwMlk7bo>kvSml$0xh%G>!X|-U)8}+FwYo*XkWbsAFhG7L zc4tBnM!GmHdAV!jiwjCV+TuEFnOsr61$jB%hpO#HzyF#1a|di%o;E5!>;S`hI_JG~ zwiIL(EW|#?-f!G%9^l?sjLhr-x-Zp!40)2!dX<+zq}Hh4a{O;LNCF(1{o|LKk>Rq? zO|!92OguK6M>H%pJ#{!bTHT;WF7R3d29B2emXcAZGFTmL&|@JHNfrJJJIMz?{qm`; z47ylhB#f3=44?y_(K)=925;Y~ypCJTRav|YOkkvf0$_JSU!AKQ?r5f2cY(0P;jhI@ z0bli}A^}+gd&}8VWmIfNQyg-ahMIH~4zw?*j@8Q8?$3?;wEg4o?ehF$_<#37Oq#O7 zQFo?aTU)5S2m^YtC;La6vc97J0U(u zuWfTGl(oer4pDQ`VDa;iaBgmP_QUSzV;5^+8Ck#tPMay%ZSa<-OVNH2!>SvHaB#nP z-B`e1<{EBbs}KP$Wq1~_a6a(Z0X^P-s!i6vF)6A31>X`Dd@qQ{IO1G^oboc#68o(I z-T@+LN`)(nbH=>`lmNNiF?rV9G`MqS^XcEfhCQ}BoY4Wu-w zemleps;L$J6Kmn_+Y8(P@bf!B?`fs~-RGQFFljv`E5Qj}asvB?5n!6pZX`VR8s{{xP=95DeHpG9c+7&4XD9U35=IyGzk%g1h&1Rb8Cev&aDyvp%`7PGH?;{ zyUOv;cYqXN?Gy3m4r6{E3&zYqYhtWno7Ocn(`A^>nqg(33+{mW23UX?kY68m&koy) z`!h3HA>NTvYtb7?NnQ_-rwqulQmoP^u6?lM>0+{5!;XD7ZgzR;!#9x$8AL?kxFecrtLL57Knk9w<3o(4p?e| z?B0n48b5ivQB}mQdwO-OO5(;<$E9ey<12H!BKZnOyjR6umUv1yD(tOi~l&);3N*jFkFg1J$mWXr==P?n~_Jv!a;1HkP3EMm>Ub zF;~uk>Wu<1-V;I1O2dtAngC^@!Q9bWhlS4Q9Ic9}a%9v9TUotCPFB`ohpvmn!+jSd zT)|817QrN1g`|P0voQPsI3$xWs{!4DX#j*6?89iYFZ2L#c zVXbCuSx@*KRZ~lc|H^2c3;fPy)e)EK3NO#{L|d+J+CU&%rP{+RC=FQ7YFU16;7!d2 z*{Y57b#|Tg-%=5ror_(+TSA0(P*jdnzIdL8`*V#vbtMd=-XO!e*}uT4cUa$PziF@K z@PJ%>l)zfndHfMHDGm=$$adhw-!rZ~J)*UR>F4CO^%zIEcBdbzJWqD6g88q-KKcMQ zqH>+uw^560fwXo35(ElK!YTF#04;e?^v|sVb@g1G0`nRFo$Jf}6xrH))0~s#;EU%* zGX&~UF*^Z=x<~KP=pjy^VbwL{7BYC3Bktzw2O*5N@eE9k+T$}=4hGUDm5+}v;R%B> zpa(92B6nqzgsEv7g`IPF5&~`df7{6V*W1#`$BmwZ2aKfW^$O-O^|-O#ge10f{gNoP zf$`$J%~}ymhW!*(40yKb8$#5T3){VEUszOFB(P%Bb~cmGMu3J)9rmvrZQaDgs06z0 zSH%33)2KW7E{-R<^NwfbvyNySncs9Lra$3la%;S+I=GjBy{uH z!~GuXSbo!{iH?04khH)yKD~_8N=10fMtOyLlGrbt*hfa-8h$T)s~yhv1*<-&uBz zL4-N0x|!wZI;yG~wfkNhE>_3h9U4p7(9+iQeInHvX~~5BCculT8Q#GAsfvu^bJB4>~^zAMfaz{`&R} zp|3CH^1)d*|6FjE%2DJ04%{Ev~_?d)cXQnb;btY zrNprvXuH1{1}5z_msgeY3n(UWty){d(ak=j5HNv8&lDAov8RRnfkXtbEum})*F9hv zai2WU>tQP+$T9UA-hMrIKp{1q!n=Uzz<3&2`mplbRb3l7@Y=q1APV^5IhV$L2BJS~ zn=XE6n>=B)vaLjyY-g2~tQ>#cW;0$SKKSF?*IH~FJq!#aT@yF9cN@1wM!z|WFPDOE z+_tB0+im^2k8s*hvo-lf z)M{UO?^)r&EP4s9IHgNuAtLlGd$AKRg2&E~Nr6vrmo^OtRW~pN(yBgfXQQ|pW?b{5 z_UgSfD6{LPA7;CkB73BIBLsZlS-!L5%!L?yF6SQ?K63-aJoelPba3Ad77k0v%Cg^T z5H0OW5j_Ls#5Bl3KDlv=goE#1a|rFtcT``86{FCOn`;AyFw3f(>W2$Ubm{;SdeEK4 zWI{y92&LDjy;0a2sipu&n1;#r>S9b1jDf5J;G}x5nA8S?3F76tJAnM={0r#6LF6+g zz+?A|uXJOuS!sBx>CwU?nNEj}U@J<2JpjRy#>M`8&D|QeEs`9TRYr1Q55u84)}Vt( zgI}5s)^*O^d$b)7<64f!TKeo_9x^&-1Ea#SE;IkwakvvFG&DjNZt~7$7LfHj8nMvt z+?TzhiMRSTt+Y!UYTptHSH1ijpv2iqXWfK+=9KP~B<0nAYDu&d8pjNL;dP0B8iVU- zE0)SM%B+dEUH%{T-ZLtyt!WpPdjrSxndOkT-qJ!`hh#0;Zp)P^3Z zMob91XB4Yc%Uf`je+{0ucTZfA?JlB4IXd5Pu-5O%l|imOG0qt&K8Wrz)gVDF*wLb7 z0XW4J8hZ277x3V*6miThWE;QJ^*S1sQrSGa0yx!iJs8I>ziOoi1e$(JE~&8-Go;Emk% zN|`srC*1v6M_0D-(vG?f98ji=9*g-pyf^wb?z}PVc|Pw(dfU&q+&5#N`!Vav=M*Of z-HGy&bzZ)BF&y&!5n(>>)UEw${7b=Gn&O13ja`+!hn9{sku( znv)wX=1KXT^`?4raIi*2B=RY0u|`+SqChE`$22|^)lo)8ae`eM>;^A!>QTEcn=In4 z<$}!AloOVaW76aGqI>4szQc>Y9Qzc(&JqjzP1$;QXa zmqh7%eBx6h{Sl6>2h2XYx>hXg@>#F!`uEQM^g|)<=q{QYny(h-6ML>^&~HmGP!-&S zh-+rxOp;34V}(svXh}NwN3b4`-zDyq2=1Pf#Dfi?WG#BfqBy}RZGsE4kF74RyhZuK z3b2zyG#eUMSgj^ev0VJT)*aJpF9TmJZjqJhAN!t|Wzz-f0|jcEM`AJ4+Vm=hogy^+ zGdDRcIDznxULbV3{)v=l?V+jwO`);Y$O{Cf)TUUD*1Ah+|KJ>1?>7g=Zh0H=iI89#;6>JBy!Z$3x7Ee-gqdX zJLcy+QSMpk=^q_0UY_4@{dY-2oZ-h#s^BaH`~q)(s~ttp zcB6i?^aD9AX9g%}B|pUJ&0kE}&#q*6p$2 zu7B_|ck!Anuov|7y>+#Bj5U)fi;1TaBPzgnl-ZESZY~cevIU3(Iz4D433U=aUpB2( zJ)WATnXl0j*g2Uo&OrHsJpW-5O&vg7&d9oSa)!xmsFEqs5EI-W`mH-cGWJiANmHGiOjq|}kkd0n4!Ql&s4 zrl81-%JN5&1KYNy3TQ*{YjD=`9cI1F6a@R^?GIjQG!riOX08Tow7tWmbfU8^u+!dL z3ptX)M({uVrzQcqnW8U}_!h+VC{j>T>fbi0cIqt!GrE`Jm_h1J$4H;}`G}fyyu#gi zGOvY`>+DHJ9BduW4+OM0IK=Y=nVxnWQs&mO`oIKYcYC-{{5m9g!D+pIsBOs6>qgmq zQE)pfKH_=es%3wiw~bp5gk zQ3Q09wTXz!4NWrEsd_OSkwh~F_N~n&?{%)sglk%5!CRl@%&;HNFj;Q^I};l@H`f1# z&t;a>n-^{=0rjn3IjdJ>D|*82IxesKVI8MqN548~3I492RH9xl!PC!Y6I%E#aV4BD zP&#v{5b~lLD}SDvFwFJRWz3!;uAQ(j?fQuK1*<3T9<#$cI%-;OU|GlPFbFhGZ+M~& zh~10f_(qM*rSYiCh!YP1jEm}rK;+-AeL@34FphTT=US>rRs*UDp-?kYe>y4KUV@LL zHGU27F+xN2kf6b8U70+)t{bL5V;hhsWp>gFG`_&?Q@cR=mcj2#StekP{ST<9*2n7P zCwpBG1ZW5^2K}e>Am%ccy)!qU?*28{gH5mKqwGY4jaggf?Gb&YHL(FfFU1!~H(g?i zySeRa^?_nd=?wB@lP9_^$8!d)7>*D7vdzD(RpKo!1~?acN~ByHVj?*;XUN}%6RfAC{3(FtcprrVd#iSjc6h5BPFqQa@QZDg7UpmO(F*ov&8 zd0Ss&l7y8bPwqwzF)u#-tKijb-HcG_1o|v~$H@|$Us3UT_v_Ifgfhqc%f;3Lw;UU* zs}!oS>9e18g*z8m8FEJ;*qlKQy}xlIu{|}v{V-Y6K%*9wSjK{@c68g4FuBq0J_1u{_08+(VP#f7s9(2A&*ka*I}fdV+#m`Z+FF$CpIipiOAx%l8i@WB!G zZ`zJdyxrW{I=~zci8{Sylk2$0z!y{#0@7xJ)ww*s}fJ zi|aja|4|=X*&~}r2mMH-6P@(B?rEFW&t1VBVZqT~776W8F~Kd=Iu{{6*;vS$XX-6y z<0B3ncxl#onI{mX8{9UpKUoVApyLKN-3(KbIx>_bUA;tKr4ypG_TLDILdvk}N{|_V zz!N|WwfcTr7ebD22?Cq9QCv)^aXp1>VC^Lm@n;#_6HNlSMu#hV9>nao`5<67v}svu zw|-~2GSLo1o#g33RCla~orCk_6Zrye9SB>B-7&BFrD{KYh>4X>_)G*k(+d$^Ya(5O zyGa~Mxgu@KSlkkvXg;PaqnP2mRIIC>y6t#I&pE>DWjr~3;~JzqkdK{$Lxn6IgV%DF zQ5z>hFuL8TYM}duP|#yIT0?kzMizmZ3js%zm`M zW{^Lg)kWp!jznnpulE=u;GTHvykZ@>p>7RQbs|?Lp{X5>j5rNfqn+T7~0* zzu!Vcv#M;94`B41^q)G)*MjHr;9+Z zzws<<_a8TWJ=~kS5RiG?wf)8NXxj=POF$6nYtZ@5o^-WI)>e1Xq3sSP1a-IZ%O3oy zR{5s$AQRKmnE~E{wqI$M=-?WXSA=%d+wPtIlk&U+JMQP|Fv>m$vl9(Vplo7(jxEqo z-pz_n98ATH2Y#DC>jiRXEr73J{F4RuUb~kvduzGkql%Pw`5Sc)u00Vd#f<1GFZZ;q05FqmmUKTl$asPn&uy-I zZoy8z!Vc^-GWg&lxcqDB-HEtIVpT3Dm@%dd4VuPHVb$rf&%k=4Z+g)%cYZ!kdF?$zgWvbIB z(JDS^smfn$k|ZvQH*M8eoQRc*@|ds}(BnXnhtbxl#nq>b<@|W>QEg(;RJl0pjgg1) zx8U$X5z+k-&Qb73VtT{%7FGW5HtLv&wdVrRi?w{ty6EakQG>#FwfyWnalEFt^@_ko z3Lxy5iballmWcY^hFNCDq@5w{H8mlpUZYoM#g+ha9wqKtY2 z+U(@V_%@u~XEpD4^~wPdlCxjoy*AxnX7h6{T0@2ZzzMroz&Pvs@zFQnYi11O*6bZJ z#8Dovc5?q;jJMNEL4?}uA5|_uA}+l|atjbwE0}yUN+jiOKf6Pno(C$C$(QWfE|WK_ zPycWMfoi3lzXrLvUe+mdq94sG%??0R`Uze^#^^1`sH@iKVo8XP1aq&plId|cxx)2 z4!qq~L1T3|b%A7`2mHwjv7+10E2aKaH>cP&$UtoMcy~REDkkbx)I*R0p7_f?=$fq# zFvHWPZoZXP(fm5Bh3fd9L0(OOKoutZNv;k8RGpZL^=d%~Za$&62KMC$q)cdLZcR{> zjH0N7`&O&dCf&_2(n@~bT~z`a@4DF&l=F48PWG%Wh&n6TXi4hn^#F~yaN)fA%ISQX z@`?)jHwB*St6>k0=hM$f9(>vUQtW9BB+bCsBUH+Cx>JYI+E{C_x+GtGHei@uS$hs) zRUJ8q_1az}f#)N9PVNEl&k`ogRYw0!NE+&8pVXmW=1Z)N)2}{0>jyiFT*#w(F`J;5 z^WjE9_?xHZncxYO5OE1f<$x(K=Y~j<@M^6s7-$Tsj-+V=mGKaz*m0Bpk zu(A|8xyUrzF|Ty?gSBQ2~%zunvZ5TPll3N z*Ko7v@-q_b9F$K(5w~sn3kVvT6LBkUekny3zwxgF);)mSW#{@BMDRGE=|u>9^aRju zK0iK+&)vvs;`!t7N>Czp;VYi)cQ!+EVzJwS(uvTQ@n!B@xyI$HL;A8gSIDOT&@O^W zA8ECMn=e-?$;>7wElm}*-2rpeD{4F5`a2zxh6Se6CXj&8ysC2fkRU!y%d*^LS)#glm=O-2 zwlFQWrKQ>Q57S|BmVW;GFny0cl+Z>D8l!73V$)bl{#lAA#vI~em10>MF5YVlkRhC& z%`DhC$>^goc#BV|6?Z~34Y@OoWghPI(Yf#L{J70F$jRi;#lCURc5{5VFq?}DhA`BT zYM>+vC2BB&Urz~l=z-zGxFuD{IO~k!GmGipT(`3LXM%Af>&r=gaBze7%(*p#FStyr z+|1I;C~Nb8Jb=O1g2On>*$R^~Px+k*yXP~3XwY&puJlVSXl*0M}&S3a|)5*$W6 z5I!{v2)p!v6EfJ=%^M^9>&0zV5J>?UEz8S8TUgtyFG=+ejhW44bDu3|%3Gh%PUdX;l6Yv(H4ynEtL&40lwJmw7g@!prTG@%DbeN1mJGsHzHh-ID?6pCtN zQ#QaR^Rc&uv^zdkF}wl$ycw0z8w{Z&K7n>fu*>=$(3iP`y<}cX^j=*7mqPNP45U#n zc&!hE&ajCFYHO*o97BC<<{P&eoJ#{qYFlR=PhEe6W#ri`4nW?d;EqfxmxSD75whGR z;7-3ev1NN7uoWPbnK+N5Z$wL^@oBiJTDolm)zkn-nA(D0ULjtlkU1xUlQZ+h&-FBh zSD(;b{`}$G1w||bPUet8S#FJvi8&SJGg%-93O_iZZkDSD){$>v(f{#@g4g&@2=^th zBduhyqj@-s=NOQ|ghP>v|L2bvU=WZMW@v-oNzp4ZQR4I=P$gC}7KzQllV(&pnDIk` zcan{V=qr8fC1|apxu0-B&tf2QiEER}D($@xqyYZOAUlBLXw+n-A<#3`N{i{4_a5i^ z9k|RAqti6jtXBWZ@EH#u(&qG`Fwx2cO7z#tBczcL8+nJy;$bHvAt^W&fCd(-Xt@?4 zhAhONEzTM2q3DMVCOCyp&jS+c;C|Uqf&bXf!G$X4_2$FS!XHmWfW}S0=?mnBqQYOi z#e*}7cd$fxQwNCtb!-BxKSS~H-Btzu89!1KJ$<6)8*zv;0QB;wgSq{WWwX*Zh9 zUUSEoj|9pOVlhA!yZeUNvhS5=g9H|d8zX6~t3g4s(eh?B{#@_YYLUzJ@7+D~`DpVp zmCG2gzNl6>Z_!zRTw_r|j~`?QtNA{K=0j4UEWH>>IW#o<(Sd&r>kdrZAa|!?USJZ^ z#=i_JD{AoB;9CBT+gw(VS~5U%gN*=Q65I7b{Y&jkGczP8XqjkP?OVLS^@1Nij=N)6 zo4^a3Oc58Y^>cM9pOY7{Ts7_6Y4=m4a)@-P0Ms$E>RYzBQE#c~4ew?s?fF|5|Al47XSECt0QuT*g`kFSP)42SdoRGDS7dFldY5&;=`1qicL zcO%FWpF4FdgN7f@^4fCVx>IQD6oObEXMtE7^?yB*iWEnzMLc?}Z1LZu?S_$IzH|l6 zO1JY4KGVv z{`Z@5-Jna=xeEr(FJ$5sbJDR`i^UP%)xHnYO5##B=$ziK-rg*$p17JPbuATUZdU8% zhIzwb2dTvJ)vd^yNxT9A%%)99p3psEMuaaYAMFrV_}3hcrs5UmqN#W(tFM=V!XuWB zD(<5w9O|Ayu%0bP;uG1cH1FY9Odm3=$Lw};PgBi{alsl#w~|Y+^VP^Dha^9MSu-1S zaOTiFXda#>%mr`f?ZZkQqRIJ|=7F1Z%H;ipsB3Gde~%lM`q{7fhC{7CLC7VFG2C@% z@2n99{VE6uD1;LE@@B02-V0ONWQw_;)sEnSP!W<}cp4Ny>E`tdP6_MTnV85alz=?A ziUo6M8GWe!8rIV}uVkzOG`U~kU7!dJazr>fX9wTWh!5G26|T)) zRd{Lfh~(W>k4+#B_#?}DSr&jZa0HM_58!LTpM=#*@oVXLfa7y#Qn-We+3;7Sr5jw* zb9}nPYY&0tK|Chx=@V=^Ns-aL5zpN@{Tbdaax>M2O1P=e{s-%XnLoOT#LDmxf)%Fx zc28v@A!v4b?-=o#$7cUEAyssB7Mz+qlsgBRTuK(zxf(P4Ip^#vv1+_yonfL+QxKlkxF6ho_Q%bVmOX@fnaT(PoR+4=Z`MU=-@nJD#GE zs$&mv1Td_V&W!riS05|vlnc96-h#R+_;Kqr>CNPO;a~$k@91m+(yF~}m><{NgT{Hr z;Pn9iBmNW|7!)<}v|BUff>@eb<{+q&qQw*!qj@t8G4dv9CeaK#Rik}}Ama`~bzoV^ z);4;#_)PK9Tpmyq(Jz|q9&Z%R})NcHC3@C!WSV%Jq_}ipu4;bEL{&*_L5x;JL06A z$YD988B@7i-uG@Rnjo8E~N(=m6iV~!|zPdM!i-{G{? zLm|}*5-dwFE~FO}U&=j`ef|w9?3&N-j7qcJX(2Usk9g?$vF2#5o{sn4zQWe4d}pt? zq9OZaz1TEP+>7ojUDj`IZi&d=YHtEHfHYezbwaMMuK-~5zI?ff|uVK zJH9zg*gZBOo38nVF^@cbFXzHIZM=f&>;{t4BdmO%j=c53PZWNP&u;7OD<-~0s~Azu zZ|b`*OpI=|gB1`?Gi~kwxj!*EuY3oxdKC?xP&o^9FgjtU9*O$!ww`{OcsqFkvsm<8 zW}Y2NK^0l7M4(PJVz+M3_Bm8w0*F3XNBR_`Yt+s>mpL;uG9s4$x&qD~w09?T8sccs z<}=gQI3`FhkMO^~javjw`1kS& z1dc93t9pD)xj|*N`Oz_qzVsnu4Zgw`7q)Yu@v&_Q(13+jlHy{5h%L*yvLK(e0+p~q z?mN|-b^Y7(^4KiP#+d^UtZ=qKiD_(^^>A{b{oYe);Pn+yG@`*Vk1*mMB$AtaY(HZ- zZE$-_=3pI;TWU{HI$2lyHn`+tNh8A;+Dd;z z3*8XVL99uArDN^3Ov`_I6tjr#;Hk*@?N$DZOPb-wC+R)>_VqN)J!K+vi6+!;!93q1&E1M_Ba z!}Dv4le4w|t6ckjZ&})}<9Hia>k5WSZMTGrVJ~;^{nv3Q^aq_Hsf6^7JUBOF?*D+7 zCVYDw{Lfa-6sou0H#N6lmK>lc>XorpI}|fN+R}JY6UpuC2xzwTisX;~SM7v6y`pVl z-r2)EgRX6vzkjYE@3GaP3V)+!mee!Foe}W=GVuKWqaJi?COc34e=g5;lal&tdcTgp z9vsPN)or^-R+Be9a_&N7c{OqZrP6uL+2PbBo3`h?KJ9pHj^>Iu0b{_wQeB0&j{BPe! z(~yx@%lQ~&drm=m!i+$5;aCk{UTrzgVpZT&oJc{}Qflgr9&9BNk!LxJ9W#Ad{^$K+ zj0%%(Xa1rVjH0sEsc4m zYe273#%mR0gu)}OaAhUqjWJr39zvt+y*m-*4^CNm8DFoU=BQRq4;u?>OOzDS;~?wN zSkq~~x%$Fu!u*`;ipIHQkp{(Sxw9)VVKfv>8EQRW0JEG8>YnX+5wLF8F z(y{Teu^nkq`1!sa*V2N~8V5Qin8+|oVchSMQy8mi-U@o8e)~%-b+#SZ*}9!(FdyOD zW0&wUVcE>qD=tm;WGWj-SyucObl&+)YfJMZ_H^CeEcip)Ppto=4@_kD#*%MTXosnh zG0%A(=r=ZMPUx;4(R8<2(7NppZF_#%9dM*d5We{YG2|ry#~AUkol9^G#(GHb-#jzq zau0@#y?|G>P7Ug={<#{lwiUm59z;X@xfj=m*IK)h4wdR9o9IPuF4```%a zjf=SM%(ZDTq!st(rRJ9AlDC!RHJ3T9L_WNp98_eZ%U;MPBpYNrqr21JZfm18f59)I zn^F5zDlAk+I*yTk4O!gn9FPu=jFd@;kCo4OJy;)x^8V`b)SxWglvp(To78XWrBr@m z{tX*VGVV*N2!F$C4$)DAu*S1b&t}vozXql1*Q@SKpVi^|k~bYhku(ijEKlO3m^Ok= zlKQ+g#Q0c*T8TbM?!9GS3fVe-D2li| z%LmH*BFD6hFAa2DCVmZ*>C|wDGzwqVySrxFBM;YyBcd?*nsaK~ihXVK8H>F_UIq@N zS7y1CAeW*y(v--ar+)ipV6cy=*dr~D>Oij`R?sGRv;vr#PBo~sx_U4t{OZgQe{X_cTmI|yb{EDlsqW%7+Wn5 z=%q9-x6PDb+l2F>E-02$E*eV}B;mj>2H&mI!2@2d=@ z$SL+s(CSwM2`1n+k_?5ZWb2S1+SryjXCm03o^)RNdA{D%Ups7kd+i*8)!)|Bu6$tB zzWvMJE9eDSLfaf*#izk2LMQP*AmB?<1ud^$nZX3L^V>R18>xET4%>BFv>$18)Rmd; z=zjQ_txJ{*6!}JHsfa_X4Dva{xF^y4_zkG%D?AA0(_dX&CR@ny-x{m< z*TYcwl!n{J5?>VdyNdQFdA!BPgZ*K&njzn$7DT3ShnFEfPE~cFzJD&6P{=DRRB*b@ z07P~plaFDW&TlV*12eDk9KJsd%TkOTg-xZMG?Z2(1tEkA))`6}3M3}28 zVBRL1%{~*6X_h8nDJREqjFJs@%TOc8V&sw;%U*|p*@ZKcvD?Ov(Qe<}TEUhK9!%WCqGuyV=%FBmYy__v!M!j}Km zEuYG)KK(o=GSQq*gty0fA3CwH(ULoe(TH{kRh9zuyBO$?=*~`Q8gzip_or8^#cKwV zpO>+~$P^b}`EW8omaeNL%fdalnRc54CZ zT(c|1P7cqb!(~j}*`#C17|4`yyq^wt8i{X)%%pEF4U(h}J6GJDBsbYb5V)0a%DIHE zEqmIl8<9TSb_xEcJ#C|nE_lAV=K{+_Kzg=}osVuy$N>y{ZdNpQSw5hbA=g-TGpf^U zN=G)mK6NDZv~vJ$w`QHuNlP^}Ps7z5Q>2ou-iBSg6O%yMo1`!bhfQpYuC8B3_1(JN zHW=`Hx#WoCiM)ylb%#T=;$i9Y`I+h3LzP6A&21iVTPWX7k4UDo5m@kHIwfAi8~IJr zDRIqowkO_IhSlG6^RdD-w~eV$C#lZMFsd&73S}a-m-oMKMany-rN7}8biM$2Jzw$3 z=|kN)K~|=y9zup5G+pdqXZdVNn%7Z64*vFjt|PtW&m;f7aWKAmHh-bx)9RJ9yktb6 zwe+k~JMX=F_iAPubFh6I@)_~#&CX}kT%Hze=6*6=@TrKgPV!im@`IL?S(622N6cnT zjS{CQJsyQWiu%Y>;uo3v7had*C9Etq^R+w7VD;xGA)~V_##a0%>zD)m^<`o0b^KVY zPIMe4O9;FaBR_DImiTF9VL42{%fQzZK&v!XE;Fety-zYrrKjuR?aCz1D--)$DNtcC zyv+0*S}El6_%#nvA4{KIy@}Pus1A6`rRTdTB))cAK+I1MWs)?AZ2sH-36~(v%EgQ= zEoI8YgawuP&M>=vdd5B>M8YtQkA$~>`c47{lPI$>kn`P+GlCagI?Ym}QJ1NxnXiRO zlCf%4rc>LnY>T07g@T*xZ8BzI@qVsWc@ulWr+jU6Fxv&>pmwjTp3Wxu@Tz>1opfz^ z)t}D=dAj|W1GQ{Vg_hSZXq>pd@g^yQt)O!*z1~&#`2lw-CTkj9PFfpZ z23-zRc>Q0Bm;b7_{+!#OcC_w%89Q5AHWpOcl|Ks3WuI53-?p(wXXt5<{V|<2U6^O0 z{0h52Am2*X)73PgFyWLoIoL}?_Utq+9WF=f(X!|2F4LwlUDy~T3y`a}2oI1L`g^~b z{=ia^o%d%KL95swQP9gH0snrho6BZnw6~;K}9uUYV{_XNx67Pke~) zyeyYH8llUY)l+x!Xjwu0Du$k+s|}V%h9kTL%3(#CrDUayw~`4NCQ7YBAAZ-?Fhip5CzRGrsL#efWm+5%K-ZFQbZWAoz@#%qIWH47N4<4Zcdc?>_=E$o zvuV2zA;rQ=4|XiPVrFi0(^+_UiZ2g7Iqr?uZFmq{Cq{RP0s@brBGG`Xqz^}yWN%Uib#uD4wD({3Q!rGtD?r2L-veDubW9v2VC^f@K2DGV_`>PQ|8I;y<- zXw%gdN7PhV^(Qk%RUxdflh8?sw3PT!0@F=&#f;&~%RJ_L%x^Z{%y$xAt}8&G_2S)z z@z$#O^tBc5`qx&r&3RWb>y4#^+LuU!))`(9SPYQe{gVNL54KD*Daz`X@E8C5EB6Uc3zDFO0SYp8nej46CZEKJ_z)B0kFu z1M&WdVwhcSeO#Bcb_E_h8>=Se66S)tqtGssHz;0IvkO+HKeD=>ksn7svwnsSo;DHQ zzg~of`K58WWrO<(P*-X#!bB^_faEZfY@eolQ8KtN{lV*({B#xlR8&lNQW2mHbuR06 z3jnOT(QzHvdJSehX6Ad~Nya*(%&ac44shu#s(7Sw!h!IXd15l&J^)9vm@Z6$ zDoSOWO?F11+clQ;(nkHO)Z~}(N|8&+7EXOe{^1W;EdVu`^v0{n^!3ETeAzgxc3rH7 zJM4g4jBAjehvAFzwrTDot;pz!oGC*7uxr-Qc&MF7h6kQxq5wZ+x#8vxASi`Oc|Grf zBkD5h5B}FUCN|cY3-W!xG=$tK@$LU2%c!j83LPjdZ;l({mE88+Fi!N4?NTyq`nI7{ zERIAjBnwZ%_DRQCM_^6B3Xm!zsUmL#COG~Easn+ayt25u66$yM_Nj6l`3oiq%0gi~ z6?4!{1v9XG*kR#-qtD*|CC^`yv9cQ#cty(aRph!|bmt2fmoNo>O4~owLE!O~EOd(j z_jEZLnD`SxNFP0@O*D5ZVDXowHp7m9uBm~N6AHt2+`PUyBj>V)q{dwdQr=|IBjE z`zYagOh(hr{f{hB{`G(O?wd(Y?JBzzorUJ@&A$}!D*tu9zZ}%{`WozaQr>8 zt-;^YBk2E|=@1nCO-%?s{*BN7=YjhS0KVq&|5c=6@Amfe?DY$s1uCOu@);Nl^h{pP z%G4V4h*jA@vs+n~-?3)c^b(9mQ-&@UyA(@GzwoZMrj}dd z*BU0&&C6+baki#cFLdHoa^!ouR%dh2Q@WLFs8S*tu4kFM55Pa>!STQV#0+$CbVCNQ zO?+eLEN@_Z*KwGr;m&{mQ&rq4^(1-t>ye-Tm`yZ||0dxIGA}w#8(0^O6;W&6fY&ml z3zT0%BX}950w@*!g~eo>aC3T3cO2c-ZtCgjp1jdCLVZ0Ovr0+D=GVxq;HO%?oYVgt z)%wQi{VPbEV}6xXE62^k%j@>^y(q;#YC`7!`lrB1__o}Lcnz$@vP4Hoa48cKghxU0 z1^NBet?ap+A;}xnp{)Vuk%8S zIf{~wUR*7|_0KeWlI)-^lc)W2o4M~izur9Ww;LmbqbRuf8FAg&?xr?fMVyLUX5-c) zmo%0tYN{)%tNw_{;a^wkh}A`6adLdG(ZP8ImPu~}a5mt*%-XJ0>>`MOfBR;QPg-Jb zPtl*D;3$-hUJvIes+Zp{8m~WSAyOjTt4Rm>jONYdMhSTi-NhXFbiIwm-}I##XbxVj z_Gf!I^+mh_nV|=NcUv0gwB9(iImT-A9M(eTW@SR zc$An0F*3u8P+o2Ab-P8**SBd?UVV{wPZ@ZBzu7>p4d6EV)BV-?r!C;KjGu_=@!Ldw zJUIoSu7S=qfbLpYaI~0FBx|Rn+jOrob|D+SI3OqZa&K!7CbeNvn1Kwc>CMb>VGz_M zoB2nh!2!OT&tZ+ms^Bl6MQGNmx?k+Q=8Jh1G3vFqkQUu7x~$g+g|2hTf84W|=dJfy z*Qx@Ug%sKDF<-m3hL;iaMyzsi5oMwXMxk&Mlem@ggl;j3Hc%PR71vwj!J9fBe>qhK z&S$KklZ?KnD4r>>NVDRPKmMp`paWUvV-^th*wH|2n%k%ieUoeLUtPJPpH~gxseZvfg1l zfTIMMFQ12P2_pn45{LyMZE&G?eND!@BF2S>3*J!P?x|jbkajM>ucPVJLiOGJUsXOw20Qm3Kfs}m_gGmctqcrss@@I_DjsY zAZvU&zVodoidJiHg-s@_2Hnc&v_;w;I4!GF3PR}h*neQuw6vP0Po(94`qxafXQPsS zT!SHhB|&CvEHK~tGR3CmXjwpS``O3AG<$yX+4HGi(7&EYI0%3K=2kh^Pl{^DlMnll zsB3=B^UmXtJp=q9p>j0T4K5-mqi4RR@_SBnz&)^;d$i&8gU|{u&7iQIUXeg7+unZw zDLmR5^8S~g?st7_nBI+ATm^Sjt^MH-wLD?MO^#S80#aVO5ireOa1Jly=gGSl*8Xr5lIK9SE2>?Amc5k`Oj`Q zcaV>*<zI<=Q6P)Im z*4VfBZt<7*LS&K52h&S3De${G5d?<*=ibck!(5%Y@Y_RE+@HO&Ci7}fVeQGey7-O? z1FsUe=FlT}bi%*8hQ?uG`Wg=iVI>?)x7RuCcwO zmTez6crpq<-o;NMTc@UF#Z&wFjQ`P~dsD>E=6}HA-2NlnwIxzrdxvWn`vU=hkSEQV zy{-Enj{3hp8U0IcPzcPPfh|!s#j$qKfS`WO-`Uk6yx9I<@^pdw-if!Av)(+?o$mSZ zf!w#FBTs@qE!;}XqDc_+i+2w(364vexBuzX&l!#+)5y=Zv2J?lRzL9~R><`tmcJG2 z?s@#Wqy~KZZ)p#Q2xuNkOSd9stV2QvB4QJ7=D+K=gQopINGR-~oxXU$J!mYf7nhLW zZ!p{}Sq8VJ?vX|~E|)Yk#5hAul@gEY+%+||v@}GRYg3HBzrVvwf&SEwGw07UHB()} z_2QteK_GS)cnNGD-nx17Cf#~&$Hv^iqcEXU%6V^JeDsj}S3bvV*y;SijZyx!-ztPh zM|-pH(9+Ttfv5eV^jGw!SsN)H&~xV_{?qdlF#-D7^P~Kjd0sT{zyJPw`t?ttidOH$ z)q3K=uoikcMn@WGRz2M|<;UJsz!Bf+8z$y?Onom#JpTONcRy48Mv!mj3H*bV3@ z>`4{v0W#nwWz2jnr^Vbn6gqI`ny`@P2?Bx!?_C@r_#*J~rQ&QB`n@{8<$`0`k(Jt= z9ioYfk&(|qdn6~riMkThC8W?o1q5%o2W(Zh*4~pHS))@^?IrM^kCwdl$v5$qgj}#C zy-eIi);Fug&ZKDu;wc|cAn*(OyX*KBg;M4k?zkZSBOxLCHT3<2GTN@pyT>iq^tw27 zD~4d_BeJt&>>FobUU6{=kN-eyKkc|bX9KS&h1Lm9;EWX9Z+~xZ8Ogb@$jFfz`;(<^ zmn9|VpT*LWo+qWnH*!o>*~M4_fui$DZ1>pN6B#u4a?R_1oGF$`kUgVk3#y2pa~nT$ zEjdD$v*5>%%#aZ3E~qf7JF`FW;m$N4|Qs;+Y!(f(b9p2@M3CdIzGsD^y!mbx> z-~-C37|-a&NQY!rpj9mU558CRjdSrwP2vyp@d z7oCYvmqYLOuTfP1l%Wdm=fY_oh>O=ualUh3i2*$&nnK~0q(t9pqbZy1p&zfi_g7a6 z);G&Bq;95-lL;sfn5JeT_=bP>0GwK@)Rn*V{cm(H0u8IKZ1v8V-~381t-$(v6Sj$> z)70yUsQdJNQ1Cs=7V!i_gRXaFrn)93&4i6l^z*e=pmVr9$8_`ZWR#en6)YEm0E$kb z2&shX+FJf}ZEz<0&$Jk+!i>x-27z?RJ=dz59tw{whD_occpG&EFIVDh@@mYZfx zm%h51i7OYB%Y@(EpG35ilW3@$!Ncz^rbh^D-Jb3*F9yuv!uj*UL7|sYMysmJ%N@7w zW#7NI{f2^tNz)nsyLwg=L=fuO8vg|wovQ=h0YQNQ0W$Xl@q@bg?klJcCnqPmYeS&v zR{krj9rqSPnid@W0eZakbI6_XWyjbbu;z!JheZ5C2L>ESnVh&vMxPl3LYJoSYbm=2 z6}HFD!O!`KCs)j|@h9II8HGZdWP<7a9Mfr6P&Z+Ue&$Cd*CmC)!T*&*`7Bia(R=I= zd?(HQBImt{bD+-R`|4c(r((jgHjnsW(A95vT*TkJvY!w6{1kAp>5Sd{tuOGz4#Iu0 z+&g^uFzmSNonO3YzAs*0B(Gsnni~5%cvCFcNbzG%RMDI|{6XTcKWv*HlV`lMlher) zC$6?bQ^XGX{h^-#8YSk~2+_z(0N8k1A0P;!`0I!)BrM>$+&Z9bd2fd5{l^RJhY4(l zYcZl>*UYK{$R2w>-1keLWo>M*Q=H{`DqZhp55llsxj?2<5&O!sRO%|Ra&ho+M8xBs zGf-^!m$g`4CwT&eyPoNaIZ0jn`q@rpkJp46ZmDzJG<&;|M9wpOr3t z%w9i%C>lTAA3NsaT_aUVNyGaY-*`3j#Kpz$!yC2#q19JN5^}k|Pr8#Sd)6(3_&zl5 zvA<`3RtFB%h(k3cz2BDWJpR{1zreKCG8muM4ZIt%VHTtZRbAfSxF#d9aqmO%JX%It zcG7^U6Z;+@IwB+_i{sEYSI~P%%ljrd(?2e#2 z!Y<^OX8h|s#ON6E;KR`C!R?dasle9@Q5+=@xw8N8FJGHYTEy6o3jVZeZy<~Os`T8T zuu+2H?vqQ;q_-&p_3y*9VCJ7=53H@NEh9y!lyWt}={H6`Rmyw&RkDIWV2@@PlY?HU z*ZRrhva_=%u!vd8Hh$dqjah^VW?l2cfoeKBMk2$s`R@rw4hhZ$S!6){YjZ&YKt8Y! za&U;?si1*={gHzNp%J^=ZA{Iq7uY=Z$4i38boqP<{;^qa>?JF{JUemXgp*TI^toC9 zIN0f%q6Y|*le24-4TLv6!2bYZWSjr#3()sh%#ZB4sYWpNZJ%6FTfp6T_X$_MHO>XF zb#n5xqyC1REYf}w1&Bh!QhF4rkfh&=BFR3SN=)K>qy^W`BkmiBN*XqEc1KcZqQ!YP z27;9@b*?Px!#lOr`pE93+VP1OOmRxf_u&=Jz^q>AyOUbaPy8chZ3%_bMI19cK&_)( z5H6!s^H?%UWY5$DmiGB$J;GX}hk<{ie6hLtMYYZP5Q#f4u%t(iN~EI1nEd|r{MyV~ zZ()1k)L4KYyg3ri|5KO6v}!DOilo@-5Q|Z*H8J_P@)__t-N@N)yf*`{Smw%f3+^1! zArPPu|ID?6u>#Lntxs7?0eS1TYIL=(omv)o*$(c@i{z9hU5ec)jAU_37^D~C4K(v>Eet`RC zRF+bb&tb1Gw2frk2w--5XYWi9XVeT#iQw@=!RPs&=bxPI6Pd}JoJkLq=6_=G3b#qc zyN0RZ?h!YpBcP_+Q&(YQSYRq%NZUAgYN}iG@ZF=Q3UndSfl^$G%<~m0`BsIw zoPLV;T@JEbqoo~%oZ0ivTI5P}nTc5deGbSzeud>xq#Gznrfbo7L`2h8%ln@)^ElvY$HK=ZDwaF zIn%Xec%)Xw>|)vC6;3~o=brD2>IakX+)G4`g}ANUU2@&oWZ==gSq6o%ldTRHPiao9 zH_VqAG|!(>JmMx@{?W7HRx9P=Fn*>^BGYDj{MCX0_yVp)lXie+@30M z4|AYxK=rshSgAafL zU)=s0%p3+20k)mdYg+jWyGGoNL`hbh&X!8ys{Y2e{DaZYykxA3@wn4Lmc)>dzF-8^ zF|}w?WZuO5hB|IxqxEvcDFUsi{WN*#bKJ#s*z;rBg|sO1sd8FM_~1q`m#!r&5cu!w z_)`>J*AH8xaPyLZ$oAeqkDs@Hov8*wsljiNpPfzT-3)n;7}TwkcF7G|@77P<=CNw| z`LEAm+dtL877sAajoH?m9W;)wb_q&dz5T+)bs;)BrR=pxvW-3P{FKjUEC4%4&aG}t zCJ}ts`fbgvptF~bYAON!+&padF@I_T#faFsISkzOPJ0aLnVcp;s@i zM^f&A=#Fg&<_H|U`}X%QwqT3Lg1sMa9FQ{@jC%=Y?ri~SO`4T=cGQeiHG97Bu-C-mLi1g(hGYQ2J z&BD#Y8MMZjW`4z$4><{)sYZqG%~~#k$oCJzs3rfy7R>8CeS20DtsQ%aI#95Q-J7n7 z8I~Q(5rbZ*VZ6^C*EDMV0>%_u;^WODr)q=?USz)OPEq8GezIgrAV9Wf5QhY>;thhy zW^K~KjF$^jgW4QfcE?HRDjKobuk;U`tkGEx^!OkydjD*Qni(|LXjoaFU!bK@G-!_e zdeSb&gqCuXMQh_9g6h5O)#}qw7*YfX_&@=2Wx>xGC6`xnQ%y50F}T@c>RUZS;2o9q zCYbYedLn~|Ks#}@1Iem0nR>bqP#Y}_i=j}QnmzG; zmLbb(WMEjEZ`GZcSm^x0XT6V<%efkaRmxl_jr7#-6%#N3*Ids)^ImM8!P}}$@079) zu4C6$p$GVw?XGzd@cE)psG+ht_T^&a`e=Y2eU5&4?0FobHUD6}`upeJ?bl`R=!>UN zxn90|r~I|8&sTB3XAn*vI|zV*-=Eph^DnTIA84&IuN2V`)EVw!x0T>?SohFyS^=^T zAzJ!$16$kD@_ZW7h2$a(fPU%b6kf%H|5JXnZz~py%f`)fA~(EH@D;kX zaK;Ia(|MkW=UKRn<_~KKdBQ~53*L#+@%U2r>=@=Y{$CFBK0vLoH^*ub4-n@wMaAV+ zPc<)nIfa$3NOr6?V3x5esr7aG{3#Cbv7k|$MLYs0jf{*&m@=mVeU*>j-;oI3~`8zkk`A zzp=C^M9FbIaarnsrgFZ`+J#9Kz&HrV$##jUt!XI0)qF2MVy&vAvejyiii*;Oi-@Ke zeCT1pJH`U0O@g+jn%x~vv=^*LeR~T`(Nw`34L$tA_(clshk&P(sj!XwxI4#6-7fJ0 zFgmZBaI?lrH91mC9$Bi+RUi0j(M~HwaY!>`58EpfgB$eQ&Ii?G_We8R6-soN;8yi+ zHq~||dP0I~bJ(juDCnQF^eLhSoy#A>#19xBOGB8JtXPqQG(`^XWsFkU!8U_gUjMPp z_w!Q>b^FJ06hTBIH=fF=p)6~42l49kA%{?+g9OogPB{bvR##JZpnZE<1Pw}nxS87O zCfxc}@2eV#geZ;>H0-Nz2O0Q~^41fK>rZ^HBoi2HK8dOxXZ|@i_p;cIn&Y&|MFJ6S zynYH?&YUkL)2Q}8zqQ@e?^|%4WUg)smg93Gp1%?OwEWmI4U`ktBYHh-X)9BHUsYo8 zux|lDJojP~32xXA5i0J{kR2S{o7TE^Ty8U=lQeg}l!_$P{3gV2LSLUw-+k4EP0*lp z<2pqU&V&>M1#9@lIU2|e72iLk@Ko{mQfViyeN049P>|;F<>%7Ukw&a|WQBxY?hoY* zfYwJrhpBZ{O^+`mOSo`7dcwUtH5IJ<_z&(-qEZ^&*VuAjW!{M1pY&WohK1j2Xs6xr zkJ`$eQ`_@kR|ip63y&KIM+4u9H{cWb1QgvV5)6)9_ZQWlqPRu|c#1s_h+KmR2seZ1 zb>(`rsBXQX2fw3Mz~+Mmgn#)Xd=&z4f+l)pseA}xen?pfg6P3H2@`Qu|5PPtsA&`p zj!8&>`~j)UWhs_Sg9b-yhfDCr-S@rNZ`BT;;<8yPhP(Ajm!f^oEl~h6L*lhh7M2Xj zFv+G{eC(5*W+mT7i1ZA;SVrxJp!>XY_&n9yXmBp48T9y-h*{@7QZInf!oD9&17e`J}dq1?cO=JBCDJFbP4<2*1e zQEWb#0^^!oA^5C&w=dbQs5aNiym+4Ly=g7Fr?dayH{`?~prS0+%aI}rZtTdx$*@mL zZ1~%vAfZ=YMkO}l297iANn|kJYQ;gnC<^hBQmCig6XPNHqN`HcTS(Sw$J0+D2-)p|5IhoLExwPvYx!ko~?OQhrzR-UiR2~KnFO+O^vbhg)eHs^7h zCO8ylC((7)=QEwlqcl242|U^$s|fL=&zRzb!*%q;woQBKtJ84`Nmsuw zQosjm@JYJx@(7>~f~T$K$|`FLl8-l(-4Os83qOlqySh5S|MPlHpw+>bo)dd$jyxWS$v+&q!6SKPkNZ>10HNXv!2AtEl-ra)y za!;@odWr{NHvu5{`` z69j~=J^ji|CRRc`puAFIyvyF&i2aHRkxz5kiz-3B|n!G zq5ZMNv+M(K0n`zJ|`RS3>_YX9xQWx>w6fbDSyB%(-p+R*g zIMH!IA#RSGvk%3Xu32jYv{A{)+KGhNp@StPELYvUhJs%5)2D}AyjBx+ot?6624?|0 zF49}eVs)CFnlkFHmRiA3!Dh3PfzH6&!aGq{fH#!flO|KWK5N%rwUANYLMIvX&>F=6 zlf<>f1Z>v}4nn1uu1p1kQvE4(bn=u-fE%?hs0OxV|6@!9hsvk98rhfn5l0ng@!cY$ zMDjqqk%fem)M9Yocd|dIU&fz;Q-dvBeX<%1;j+*yZl;I!1g9U)TP4x2Uh5-_e(; zt?=1BP^Yzx&_8&<%F4vld{FQgUP8bw=w8X#khy~^Xo;9Y$aQ+@DFmoT?j!&QT>R65 z&cF&FK9R8;dunUo1y8{Kt{pk9LyJ?x4*2U}@0oj2tKUPxKSprpgdbmTHYe8Sdoa6! ze-97MQ_t6y;y|J`z&`swn!{SGkznrDZm{g@8I#usgZ})g*8ThIaV7grXRVVL8_~HG z)2XC=KJiC=pnBej7-YI6)c@TlVedktpj2t67;PMI_+!kFU%=M*=SCrO8L4h$yvCtv zvmk&HU1GMN1r;oqi7+yflaq^!17vC`^25oVvb8!)T$BN$`^KqpXjbdzI^f8^YBZyJ zt{?a7__t-y?GtP7_ot63P88|Bi73=kv+6dV{jW;9U zIfbX5D8#cDKpMf|wrnBl+Z5`{O<{)Pd`fn2r=H zxXjer$6v%uOq)XJuQa4)X(`34RKr(3mA>g~CzQG=HL*yd^Gd9~sGB+{Ucl`B)CHPu z`H%zToa0&hE0|pTVkzswAjZMpFJseR zk#IA7pzVQ-dWaj(UFJPY=;rtVf86}_xpj7Zyxs=!HO{kICAXE-quex;Z`SZZbc}X9 zvP+69UhZ@!`d4C}iup#ax1O?Z!;gC9GqTthd3nd4Gf>yyR#UtBiU>5o?Nb_kZ*JSc zhGf}QR8fI}!NjGL^PkYRH(@&Zsq|6Ws64dyCG^eBAwHw~<}Q0r%MRl;cJpdA1gQ-J z@Ab*bIk+b#toju=FzXLFhDM&PxpFql~cRqq~FO-5rcvm8iK&_^{L|(2yitnVE_SpRnpMbXCVTug!M#kxQ_( zga?rj719zm&bQC}_jY%jwo|q^sDg?#0ZXfs%yr zq}yZ#6LZ=()V+Uuim$rCq@nKYg{wtV{TB_`VYd$Uoo$st(GD?d{WX(0xKyRP2d4*7 z&*#fZaWJEdCilI0b#C_ImQCzV#)T5TbeP7^q7u&OkhON|lEo=~F-_S*_;oV`pW+R3 z#cAk0Mmi3ck6P6q?WzK_b~+7R(uoK^=j5_&?|y3va&Z!;laVB0t-WTFo;XuH2@#px zCOtt^eb%t5OPn{SBCz8QtZP$5*Yj|#i@hk!{Hg9a)gmt?DfiKmL z!?ukpc!;Y7Yxf}}7p@ytX4}bv01+r5vU1P~ht9!ofvc1F!I(p82ftYmM;ONR5 zsT!Jb@#1aJA{{Dedi!)1fzUjdx#%cFk>RSrUAKtGry()s*;pnqjwZhn)V7yOn{1SA z&1l!|fT3VnZ?VU{&Cv4E6|lmy%YT?uzlpP}ob;iqO|1|V1ls!edfZaqxEVpAGU(;k zOm#5XYQQ$4IMn5Gx+osX4~6!E>I>;<%O!uGwrOaWNM2psz4KK*bWfQ-ZV`r2h~{(h zE8ZBYQkMI;mD;^@gZssvQIU>oL-zrZVUc zp}wc5Bz5QeE1FZ{YO%blCso-;A)B}MC6;FT=V;y&ZIoO>dAS~lI2zMgUJWNRq(5m)AFIhj zRS<>e2`=0mmPw z$d|gsKi)ea!x@KU8pL|H{aKa40KG)eRVz51HO%84NyM7OCV06R$K7k5>z9`JlrKTe z7Y$~apa>TYbA%T1wPZ|AcbP~?&wOvI!t{dXP$uQlP39VSOrMbQ0EfOM{tv(R~&YA zXS@|l0c-JPj|eBGY-*Q`FME99>b09_#`Qz;qx*Xn2(CWTShhBZR;c~T3;1W}2QD-3 z!2G8f$p394mxs0@2=o@iQa)|JNb~mVQrP^0?p^olFRX{qG{*s)PI|V@F^Fa>`d99fl5(B%evD* z_Y~6QEUeW=s(FwyHH){$@af;5^6#PF@Sz;oHO~o3?J72^xrTfNjU#VgM6ztry$8yB zEW<=*gRkna?ljctivZ&AQhK$Euy_4(jJ+;2$65JrAP^q1lED>~yPrk7OyPiR9`Sr$ zfBqSP-BgVSlKLdBGeqCIMOk+ARR&w&*`5ADlbek@s?M_wJq=eiwr=?r_@anxUKq@deyu;VfDiWfnOj( zW~4oqqYF+n%$PICouj1<=Egqa-t5fZodS$0&$kP%6T^>C=eSQm{=Dl*E zWqV=XII7p2`3^N1jVpmqxYo|MG5z4)w7%`WaMGzwAcd^>{P1*^3P60ru~t`z)8oUkm&u|{oygnl zQV%(zglwMFr4Q0+e971?&XFPRED(!-p7y-%f~W{=n~*F+s1W&C_ySHD&JezSG4=!X zf#8GtCsJuw(_-ZZdbR-gJXnS-I5zT+91$9{>n=Y4JGH?-6Gd8=0Ih6#z9zOi%B*Mi z9=twVfIp@}FyC~O&gQ;MHi^_N=*ZJMtTL*VPPj#t2fM&wa+n`iYakCp=B#b5pE*`& z;I}kGseau2$8Qu1)JF$*`P~!_f%55geQl|WPxljGk;QfjhtTwGvcP%X;*jma+`rI7Ny>e{*HDR*L zywxh3t77h5n|d>`@k~c;`4MKe=J%(vHTQO-Z$`vaMuw|ao2gdU<$ek~?}b#9-|7y$ z4tKgP%%b|JaWJFU)02?-c})>IaJVuD4L_W=AkQXNPb^>09E_As++xOdKn4x=up7_Q z!r)V3!tEv&gMazdu4E7-0taGv|%24M)5m=H}iV&Z@X*D*HHPW`m zx=bZXyXnl#ZF5@bd)q-RL1v^__rLyn^cN&A9%$u4!jj@=D-Dvk{Xxo>r zvYHQT;7z`ek;TQf!jzg~qm64wU1%IdJA!4abrdp$mBLN#gS6S9OXNb?#J#C7sxl`4 z-oLLy2;j9h>V6j&UUG3$^v|x>^b+= zO;bUfz2ydLjE$CI$xqE#52CaE=2<2S%};vU7LHyP<(tYm)OPnGn7n*;S8AyPeFEp0 zwiMt!+gm|_H!t(HJx>pyTZyQSJFqkc^q%|! zVZ&<5FCJT#5Hw(R-vu{Uo+oHId%FZHc$0i6xoq$5`_3JovJ{(U?#bN^_hGFlYnhL@TCE0nyT~v5dd6ZK0s5c~dpSEV=2L zi4e2Q75na&if$i0h=PgN=BB!yjM%O6g^y-(K>M2|GT4MGOct2R0}kwM#(^UX!wi<`T}T+Tg}wz+B?ud1_@7@&Vv7U^+ib*WS3f}EN| zGQ(_2usA@W_Ryft1i3Y;Me!w80LBn*LAz1t5({-f0LXS4=U_LZ-#s;TVaGVzt;IP? zmr1OSyk^i-0S;GyedPT0klS@KAv|Q(!K*=Pm0rI1^blyrFbRnoc$56lJSXYVXW;qn=3eNmz`4~2h+I6o?3ok1z6uH5xeJWIx9z(xoQVlyU{YzxegeXncZ+VKM=2(`~yZt^X!k4-P4b7DiUBzis)@= z&Lj_gp{;71-%D(*qURz@x}fs4qg^Sz#})V`Yx3H?vCllt`1?=@!BM9%+2egBkO~XE zC_T%ypBch-uxd9J=_Ztj$C(RPKkR-l3^_OHBFL{2D>>t1(roZC<Qf z@6@!7S#e|g)y*;XRF5{&#;(|>%;s3QF}(kf@(IFrkjmFdNpkHz9oy2!S8{4& zhqCkV+1#!31j+(*Yzcbt!dZVCnPJFqYA~POLzPjQi>FVccDB=rVu`dR)rTuWl{cJ} zOh(Eg*I3iAwc=7@t-x+4l_{V~^x8uWAp9D+&#)duY9(08tILLx)Nv$&x`o#YkV>y> zsv~iJwW1HLv{a@#yV1~HIZ%>6w5m?u!xBtY8f)3!OPx~PQ*XuRH=NE1hCUdVH5 z{5DFjYD8c`n&!_8E>#x`yPAG+HI0zhF+xpCrLGO~cK$N$*VV3QJBltu zRIbNa8{VH%7p&@7ePEX{@^;q&+H%1C%>PRi@j95=BroxbZVVddYfS$f&O0bZ218(T z?^DC$v)W;^kaZYP#_jp%CFnFPS0`BYI|cw%_Op3eB*LYtcJ{p2tv5O$@v=hz0jzR{ zbKC1ZAB_-q0`0&JR8+ookbPlQ*?JBmgJW~Wks<*QYJheN9aC=t@DU?q)Z8oxeHwG+ z>fOVGlA~0ikRl5c8~$PLDP9HN(~nRgOijZHXA^@QIO9Q1~pP zQr5_lr!kwgKo*@{Wg+YxjDOVsF6a&N%pX38MD7h$pZ;ea+v(SD86cDiV<`{zE4ptD zk7*fsd2W8;Uoz0rfDHk)&tC5sr+kBSJS}hzJG^n28cgSLp^dW#6|uj$bD! zpd`o#UpBuV@E@!?$(USP#+j|4`av=tqu1=B!NbDdLT@z}V4qbqE9}tiV=PWPkR!*5 z0vnRzyTupX%d-f3o2)tMtG>$(>4*yc_`a^%(BRuLac3X6`e9F>J}I!_=H$2g6wnUD z3x#fa`JLAx?^{h=@55nkVLu%D9_Afx@*@!+l%S~t&I)Fcbntnhi?T{^%BLCEMB#^( z7D@AnS3lU~047{bVPsG}&?&5%E9~9Ue6*9-y+n4H&`m&KR9sP+v@aaq9iH;(laF6i z%k4`v7{|t}yN-LCrdvQRv|hpuk;)mV`|J?KAsqg%7~xk%=pw)rsy2x9YKX~80$s@6 zfV~kv@gf*Nu1V_fir0SA^*|Jc3XL0hkTBG&K00t<7w35>(zmot#R+{bJbzEpTGx?P zN2lJcJi&e+ctFkLu@e?li#s(<_yBKT@`YN^yVEqGiqo!E#v1ht#l%(n%A@-?fpn8=hC%gy3fqm zZfEA8VS+FZK&nl{cU#Z4k#OYXRJ?NN?oiHTyC3tZ>bvNE z4bcQxSNp=z%?-@grJQg0`jbo=7iq5bn5B|=5CIFleqa zwo}`~wSn$?&KxoDyuiA{QmCjQ+eIy`R%I=sEZ49^LH*#%HDP}#*KcqF^djRco+W=I z?#Qoyu2RxxTUQi^fH^N@8FHNImP$SNk)Y3cssW?g5~A%=xBumLmCDTx z;6ajvsSz4vMKA(6>1{!^7~i#B;(jv1$B3QKX1*#YfyqHr7GMjHzCICczLsTFYSvn) z@1w!P3?sDP^p(?Cv3lm5UJzn+wGD{nL~=R0>ahz5w>DrLkv3mP64VB6r&c;O(zPVz zkT_^DVTCv@wrwcDH1r(0vn>&KuMY5O#q!-ZgFZ&F1gNe~9}Qt;6LY^)0N4`1tViX( z$Aqo0s8*~-z3Z4Z-S6jDh3HMk(Z{>A<$urp?Xa;K2#h6m?^fSIwb;_~_h9redPP_H z?4zYMoS3lP!GDR4CXJT2aiFDvgU%-(t}In+rt_IgVzFGM%&~MgsRu)yOyll4zNoAI zY|Sey_09LhVs_avK)1QHnc;fydoSa^r=;*+qYU?9*-kqZ`B4WC+cz1FlEp=mwaz9V zc5+T4_r1X#^n^ZO=u-=OgSio^EX+$92NsoQiFfv;hn(H>(K+v2I08nW z*sJIH+)oIGKT*vG;Q-SkQ%!L=29nr-^e^@voF~WyA&A~}<98_vhzvgOY+3fKfX*`X z8T*BV!nP&2O_DHGW|>KG?4_2NEYYm-;yl#EJ@|aKI-mM0F&(Kn9Ej*ej5LrCGIJK= z)8qS%RWVfBHGbs%Y6jS_&xMtI4@H^)?U6-Y2E6m<3T0^&V{;=0-U{xcEKLeSz{K#A zz2%aKjUpk61#nE<2{;!KoN@MFzNMGnLAb^5VKoub!dWes{cgDA-l%h1aJIwI=_(Y! z_KpINs#Q}kG;iz2f{cn30@z*IlYQ9U-I5*Bw@0c7(u(FjKueE8_=sJghNWgKMX!A{ z_?ROIU{-=MMnOIFgE_8P?%dbPk$D=ARFwBOJu)WB@7jFT`2J_4@zE0v!!{P$E#Nj% zxVrX!fJNQ*U}gszjbZ#70P~$(0q&cZibE8#%SS%tE>K^c_@P+)E_y$rFt1$GyP;FF z`=_Q`gm!39!O_|FCAtPmwIj3AvK27($+Gd$53)?q# zwmZ(v-wlNJFuQ=(3tKz)w7s|z9M(;3zLSxb7O1t=EmLB+{I*uC_H%}o5_=ZFh%eeb z+SO_euSNJurIsu?YdL3OHe)9yC|EDFG@E7@0j=$1GwR~irUlaD__0|iX7;mSZH~SwaaUMz8eNyD>X5PutUaEy~Jy5IPh#&B^3ub z^#snXR+N{QX^+@TqKwJ3FQL<7EBGsEWI}<~D1OxnP_ST%>;WK={YDG4Wt)C_v4zZJ zPe#>Dv3sPxhn7liFqP@xtZ^O)jXbHGj37MF`yDh)hygBXRr3Hb7p>6_nbb; z0QFpHXUlWapY|PRY9@C(x8*}QrwC!2_VpqeVm+BAVHqSFaRhw2*~K~oU|t3_3YZdw zy%UxK1Hh3nKX-d9HdxU{-oF`mz^mSI2uKNNKMu z>qV+@MMY5_>JPRMNH=7LyW~PIVJ5An*WuP@Rd^W#?}ROX6q% zNFpqJ{R}G@F?uex`3KeabA4=fKKGDHfQa#Y+&Hm5x=C4MVcV%_gd5IVT4x>?wot{t zM*IvSUmG93kQAOVfib7Ckwk*N%DRiNlNSppR@x9HU{sUG==yCH=idG{? z`^i_a2sVe6aKr=d422w=t*dpA5$tCbs((;|Q9w`0Fq^7!)z&mA_vUx>iUa=hs8fs8 zZDZW6Vu!k!bMpm!CgHu67NAKA)dC?WY!se-QRxN9 zhSq&Z#Mmbhft7lhK>{&fxkfeC42h(2)%eEU(KLrTT$XrKUyomd~`_6OD?QR#$ai0hc_nA~ih~529Kfja&H4Ocn#Bv%?nQm5Yal z*31sN=m8CFo(@dh&Jtd(LO;LeLF~rPxPN!Mpo^sW3weLOQDZTUYrVZ7nl_OJskW?l zY>5~hTK(q5-l6DrCUPt2ta)TqOXRzx5K;>{1gx(r2g=rSHmyTFfl{;DR{S6{KO2Y? zS;SGW3bZq3_LgcN;CXFR| zpIGPdeDZ%twEq}6k&LM!X26}H&K0$bNRM#?Y0Av5cd$E zc@Iolv>v;K=8@MKv6jq+Cx`YDHxU3*1C~L(ax*Q+6u2`?8Ge^mIFO4qPhN@Nc)d^@ z+tVP#91#j-H%W4Jj(^NPE)Mb_0O^pfnNWzDI-m0MCy|?msD<88gg8c@-LWZ^bHzK{ zjN*L6KwE(^bM2|zAFyzfy?1igd#-o_W*#7-!^%kyBEWcs?bZPo$8!2iEcBO;QL&G> z%Ur$J-{rpi>41zYJ1S3iB+%3QswzPSes_KeG<}6oLQ+fjwUv)E@VoY%RB}OdX)zy| zeBu4|yNIVvkU&)#yW#=^q) znyKa0`L1^ub`@J$`iuxHGjk#O-p2+i^__VIG;?@oS zuyks~nO8055X+JaHvP)AacXuDcmr;T-tGeD3{mu^N%@PwH( z1Ui0AU1MRgkQEI9W?y05{h{O_-?tU4E{wS(K!H+4JCfg^cXwQMQ_}J@43cfhF890H zGcJ32i=A2*X_koHvSKcKQ>sqxD^ISAi4$$&l!2Mn0VghG@kPf{YYoEilQV>^RL68R zWne00e{#$v%!NS*vD$57GQ)nfz!AbWfT19*wi(SUOK*@b>V?Ef_LlJTpCUpmbQIuv)cHC9kj5CU0-uB_KPlPZP6$P%56~GN6pZ(vLFutU<~NkaC(jQiHWA&Nih1CD9dMKMQ3|BJ!c9M)5l{ z`R*Z2tQE;Zi^DaCN3!%U%1JmU0Upg3+8KoPhryL)L!M=;eC|{MQC9|RmPaaguIX%#jG#z$oDuzA|0LM`JyNV?L0s+5|x5mR#UsJEV35tN_j&KvQ^#3YtvC8Xq?DOEs=8CIGVPW)>;XMj0Kni6Yb(d<}SI z{Q*k`EF&cbNNX}q$MWLZrkjpP^Rd#*!q_2c;RUl~5}pom^zS9c1D2S@$plS2Gta#8 zz9p^|xd5@gWj~A9%5E|e^5JR^w@0d%ELIyrNX>^_{JLnlP0d>;1o#{Z1N>O8+#I0Q zPIna>>Fp<_6rXxXFObqSD?gSsGc|KG5OuXJrp4l#H2pBQN+Am-=KSdD-GTwj^&kA==s_&)!x3)jyhR#Qp-K9n-|hP?-kUY#z%!Tn>0pl zm?Po`l7%i)hR&h9N2#)p%KeD$d>N}1cN&Ys>d(uh;c(LtnIJCAxY`6H-VQVyAg9#A zdyEYtKTBjJ-*p2R9&dkGI(#clCUb!bF&@go8|(ukj^W3c9;xgV59O$8#7E~Ga%7I4 zCg`?AKdRrnhID|E6QsGeU!VaXs0HWW;W#$b}8?3Y-4D_Du_5;-@WUO-<91Ry}_uc+R%E4#N-hvjAO3&X!jk zJ;-L}70s=ezWb%VGBW40O3u;^%eC4|TPbrikg!hfUtKwUtDDE(#iieJBeB=^WnCvD zrq*xJV(>+%<23bHrA~v)G@(~aqDLH@CI-`-M*2xupl_jK4(|Y)8qwFP@b($5zuRpERW?vhze^%ZN1cX~CQaL`_4D=Zo?W_zFoQEp@6&JG& z*Vwr!0kQ)YU##Qo4+wZ3wJnkKj!~MjWrGmWm&G+I43bui10=T%{pz%v|1RN|wcNfn zEMo?tjSOX>V^&+=$dlC|IR}0fjReptcLXH0O0#lTy2}`Ch^!+w*B3Q>q^_~N4d^=F z(P)qoRc4e`?GBgtgihT7zFausK;mB@2+!Ut6HTB*g2h20>i94hW!?f{kP9wYY3D{rCY=WJv!B_y_cEfCM!hAs)mm#(|$kuT0>=HdYAM7r(s^(0t>Bjc4o@ zh=+6BiIUc#Qm@23jd(L03-fdMg3bP31 z+P1~^=-Ugt&NC>AdJIW~69pHCAV_OiO|4p+-1sJ80Q9WO>R^9Gat^UoP=#Ci_D&#G zQ#;G|YJuO01ya2wQoTxtPu->$8&N-Bd2Iff^DZVH*qI3=Ki%E_>A9!~YV%0oBua4DC>MSL0&Ayoeo z^5Lr+!e&c{Af@!^Fz?Y38=t7JWXn6G-KU6aYAZTn6<1JdE&jCiEK&UTo){}(Qa8{I zB*%Jke!p&++7EyJW_lGpU|c-)9g*7_KE1Z9pS&CoHGJhdL`R-t?sg3ANkR=b0F##u z96SoU@?;ps`+Jh3yF2EF0x)BdoSrzFlziwFrQw8#yDV+~8=rmOPZg)6g$^!G6gdavrZ-Sh~ z5h7#(C^&Fr(2Kn5qgD|5h3Jlec{W{(afHf+qOv_s;D&?X*1X1Fl#CBp*EW`~a$0p^ zo7GmiWi41agNZ{PF3bauzg?zUZlNTAIUFYp7p{0^t@S>a(cs7uP2Y_J>15~JH|$uN z_UKTme7u&jNwioKzW9b)H>xLX`BV(IzPvNDs75v}wyx5XzSgD7eSD(&2XDx~nMw3W z-o{zcK9yCB!|E!W>0PD?Ys6@#&m|-7(@}t*o2z1mZ2y!%XH0;IlxhG?^Skl|S|zfs zOx^-&H`8x;6h&_*@9dAN^RTYfaixCAGqW~Q%i2BTXy(XYRGz;pCr}`K^Ze^c^oIGcn(c0#aSYe%0KZ3YvFG(a3JMIYfBn!#T-KHqgDg z_2+<2kJ4wG8!k#4p-%ptK%vp&{B{7au?ozlcDJtJscoP2a3OyFi}7F#U;2*cz*>5aN5qfi)Drrgl z(pE`cAQ(0v%GfDT1vVB&OgaX#;aRFnER?hIZFAg|$8YKI?56?ZEt<|%r%AJGcXJ}B1Nb_b+#z(gmct?pM&gu;YEXzo-KgN7Yy$DYt< zk!-mCqrWN0nqU@5flaxnK%G_Mx&eg;gGNu(=l2kDVhy`ml zl|zk*(DCj#Vv7bpL9$E$DKYjEVUv`cuODFrEO zo@eynL2d6w;Bx%6YGKGSK#cbs#z2 zV;QS?7z*98g!Hq357|*cPCmTz=>$c?tm#l&0XEOk>RA6SIehmB#cyv;;^270F!8Dp zI}>)pgcO;B!HBtA&0}EGaG+x1U3rEDC;u{p{k2E8?tg0;BgaNcVIRw2wZTxzUkP%~ z#rFWwRG=oS!VHpAwbVGZ%t8FCzI|ve&gxVlZ-JNBI-y-5gOf?c!P2b)&X#!fAD&ht zwVUji6F3yF1H{lpy*e1Y%-LctgEGJw1rq__vs#n!@U^*zoO-i)vThL+)glQ4Z-DBE za5S)k7lZkm%TD20T9mqKcYIuwEEANDM}f+;g0)j`oNk?5)ObtA!1pi%{B!eoA>&iQ zN1%jrD7=~d$N-mt_^QIS_&g{I#lAu^^9wV62} zp9eT`D**X~asm*RwLrC8!+7d3|H(Q>yf?_M)ZlWB^U`{H)X;WdoMk8|mcVUzozU&D zY1f0UVi2uwjsyv9P6Y8Pvo*Y@9wYy|2S|XFS|@535aoNaAqEn^Ie4L>BOsn(3Ov8p z9D6wc0`=10W7JP@)eJziD-`_o2L4A`8J>NFG}U{RhrFP?qhV?Qkn?d-*YNPnp1aG? z7yP17Pj9T@3VFEh;Tc-|Sv-W-`3%72LX_?=2i^5ZnX(JKnetWlSsAIwT*`J}s^>D8 zz3EQB;g>tE62}eR8)W-w`E6Gkpg%e92t5SJwLLvxZ#&kDe!isI%OKDyeD2^IF|o$% z{0`n@r>7_FDIPuL*iklx$W2aK%hpi?J6Cfuu&ctB%6_{8kAJtrkN0}~bf_JSq&eAT zyq9lJmKx#NQ(1#T(?aD~M0<|{*jTacf2SgoF+i}?o2!fLL)*U+n+ggUi8Y%-qLaW-x;0$Tzho#ABX_oANEZ3#J43pBdG@xx8 z=lEW45%vO04yxgm{yP=^Yq+<5pQ`?^p$C8c*Xj-LX&JT;6nc=+%|*#yul>)E&+Q}Z zh?I%??9Ik;n;9j|bu~=Sw*>CX-@7#!{xDdi$HU#qK>pq29ymU8yBs=k!~Y0fyYGDF??K`~ z0b_D}J-%#rqEega=}DblCwpQu2|SMGnwK9O|K2$GYk$@7sMxP^+=eNq*fP}h2?zUs z_d)-Q@BhE=YyKjb8ZoxN3lj@htU>-yzmKk~C?EiZ+nnO|C<^j3 z^MCpQ-D)bDHej-@oEfBtec9Y(q&`k#kvO%*hTuw-~257P?^yPfk-Blt(Km745LWZ*gJ?XgRn zozIV-L1b#@V6^^vdNpi?9n97njC#4P!}{xq_s37TJ=FXn!Fgk7gBC|JC*0w&7^N&P zRAXH}o-%LyT@Qt)5$xO+w#X4;HQY_tDEfK4*ph>4%M^~+(Dm`wwT^&W;7Hnn-!EcP zM-L1Pj!^OC2JSN^4rly5gl~L0=UL*&b`*-^wMI(q7U02x;E6;FV-dNRHHLD+?T;U* zI6b^OG`F%$?ILh^4|huz8tdw6r!)5&GzSZ3Zi>Sk%h4M#tC^iyPd1x^0)zf`+MBpl z{8k9Gq-#bi6oJ6&cmR<(;8cz>Pa{jvYwW(9(=pOa{xU{{~+^CBBr-_qyek+O&fERpp#QB>7 z#Rh>?6oOSNyY+A+*CB^a^05%mjSNc`Xl_m8&@peMQHd6EyGH?{?y~-Rg&v}*p()N~ zBp~qhZ}l0H%hJ-Wj)XER5aL9xajl?VQ$vgY;K!_uK|fo?YawhL2g7;yCz#`HD8_Qf zAVZ_`JHBAWy-^p~9xL8(#JWQcau|GhG~Kv1lC1vG)q_L~;4L5gyo{_dG?Sl?+h^Uq zOg(}|FK-3O|9a=qLWWcb{_zBUh^={PX`g1#APaWid3mRIp~xe$uP2i3pYgh_fUI;M z8GV8QM^E7WgbcMcfbO!ipq>WH9m``G-=oE`F*Jm4H5KP*&WGvoLeR!sm<%u4e_HW? zo9y!DCSm0>+)+z~6%Tf3{%JvFa&nFNa)Q0(BiriYyp_gk=hqY4E6ec$d0*~Vm)<{` zvw%Tijiq3N^f&XU^!^zG)eT41jSpg7FL3Jvcl{6pbGmP8Qamz@rCOxkq^?RaGFiw< zVlcNb8yOw)Js=%(U1%F1be@Z~AIqB1DWFgv*!NyMM|#t|-Q4oy_{{O2uh#D7Q>g2f z@*-=Vdq#uXe*IamXkpGn!I|U9=J1bp`E-qte7daWC7}E)JI5fP|7G#NR!YxjO~fy` z(G1tau!g)i);5x1`7G!*5#%7*WpFC+uQh)`7ST^$q?#;e!u70aO!%KW)ACtLs`fLJ z2;`%N-Pr=R`n!63`8q*|-X%V2BT z5e`n}ZoKnHM^8TFU)}%x>A?Q_KNH@QF=BqON(vb(t#Vj^sFhe)D8ZO;5>6QAUUPfn zU;8-Wy(CA;gJVPfxjz4+TyY=$`&R6K(fIxUuYpDLp8_NP|49D7K9Wag8*6aWAK From 81f3dfa81568e6eec4502ac30cf7934b3a7f9c02 Mon Sep 17 00:00:00 2001 From: Samuel Bray Date: Thu, 2 Jan 2025 10:49:31 -0800 Subject: [PATCH 24/42] Apply suggestions from code review Co-authored-by: Chris Broz --- src/spyglass/behavior/core.py | 8 +++----- src/spyglass/behavior/moseq.py | 28 ++++++++++++++-------------- 2 files changed, 17 insertions(+), 19 deletions(-) diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/core.py index 79b804c6c..0ab674122 100644 --- a/src/spyglass/behavior/core.py +++ b/src/spyglass/behavior/core.py @@ -44,7 +44,7 @@ def create_group( body parts to include in the group, by default None includes all from every set """ group_key = { - "pose_group_name": group_name, + "pose_group_name": group_name } if self & group_key: warnings.warn( @@ -55,16 +55,14 @@ def create_group( { **group_key, "bodyparts": bodyparts, - }, - skip_duplicates=True, + } ) for merge_id in merge_ids: self.Pose.insert1( { **group_key, "pose_merge_id": merge_id, - }, - skip_duplicates=True, + } ) def fetch_pose_datasets( diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/moseq.py index b5f2132f7..9c5f3e6bb 100644 --- a/src/spyglass/behavior/moseq.py +++ b/src/spyglass/behavior/moseq.py @@ -15,7 +15,7 @@ @schema -class MoseqModelParams(SpyglassMixin, dj.Manual): +class MoseqModelParams(SpyglassMixin, dj.Lookup): definition = """ model_params_name: varchar(80) --- @@ -49,8 +49,7 @@ def make_training_extension_params( """ model_key = (MoseqModel & model_key).fetch1("KEY") model_params = (self & model_key).fetch1("model_params") - model_params["num_epochs"] = num_epochs - model_params["initial_model"] = model_key + model_params.update({"num_epochs":num_epochs, "initial_model":model_key}) # increment param name if new_name is None: # increment the extension number @@ -76,6 +75,7 @@ def make_training_extension_params( @schema class MoseqModelSelection(SpyglassMixin, dj.Manual): + """Pairing of PoseGroup and moseq model params for training""" definition = """ -> PoseGroup -> MoseqModelParams @@ -257,8 +257,7 @@ def fetch_model(self, key: dict = None): if key is None: key = {} return kpms.load_checkpoint( - (self & key).fetch1("project_dir"), - (self & key).fetch1("model_name"), + *(self & key).fetch1("project_dir", "model_name") )[0] def get_training_progress_path(self, key: dict = None): @@ -303,11 +302,12 @@ def validate_bodyparts(self, key): merge_key = {"merge_id": key["pose_merge_id"]} bodyparts_df = (PositionOutput & merge_key).fetch_pose_dataframe() data_bodyparts = bodyparts_df.keys().get_level_values(0).unique().values - for bodypart in model_bodyparts: - if bodypart not in data_bodyparts: - raise ValueError( - f"Error in row {key}: " + f"Bodypart {bodypart} not in data" - ) + + missing = [bp for bp in model_bodyparts if bp not in data_bodyparts] + if missing: + raise ValueError( + f"PositionOutput missing bodypart(s) for {key}: {missing}" + ) @schema @@ -321,18 +321,18 @@ class MoseqSyllable(SpyglassMixin, dj.Computed): def make(self, key): model = MoseqModel().fetch_model(key) - project_dir = (MoseqModel & key).fetch1("project_dir") + project_dir, model_name = (MoseqModel & key).fetch1("project_dir", "model_name") merge_key = {"merge_id": key["pose_merge_id"]} bodyparts = (PoseGroup & key).fetch1("bodyparts") config = MoseqModel()._config_func(project_dir) - model_name = (MoseqModel & key).fetch1("model_name") num_iters = (MoseqSyllableSelection & key).fetch1("num_iters") # load data and format for moseq - video_path = (PositionOutput & merge_key).fetch_video_path() + merge_query = PositionOutput & merge_key + video_path = merge_query.fetch_video_path() video_name = Path(video_path).stem + ".mp4" - bodyparts_df = (PositionOutput & merge_key).fetch_pose_dataframe() + bodyparts_df = merge_query.fetch_pose_dataframe() if bodyparts is None: bodyparts = bodyparts_df.keys().get_level_values(0).unique().values From 3bfcb9ff780143833dc2533da61bed49d15afac6 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 2 Jan 2025 14:32:03 -0800 Subject: [PATCH 25/42] move moseq into v1 folder --- src/spyglass/behavior/v1/__init__.py | 0 src/spyglass/behavior/{ => v1}/core.py | 0 src/spyglass/behavior/{ => v1}/moseq.py | 0 3 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 src/spyglass/behavior/v1/__init__.py rename src/spyglass/behavior/{ => v1}/core.py (100%) rename src/spyglass/behavior/{ => v1}/moseq.py (100%) diff --git a/src/spyglass/behavior/v1/__init__.py b/src/spyglass/behavior/v1/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/src/spyglass/behavior/core.py b/src/spyglass/behavior/v1/core.py similarity index 100% rename from src/spyglass/behavior/core.py rename to src/spyglass/behavior/v1/core.py diff --git a/src/spyglass/behavior/moseq.py b/src/spyglass/behavior/v1/moseq.py similarity index 100% rename from src/spyglass/behavior/moseq.py rename to src/spyglass/behavior/v1/moseq.py From 8fd900b9c442b3e198c5ab0a2a841eb4dfb28262 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 2 Jan 2025 14:59:38 -0800 Subject: [PATCH 26/42] add docstrings --- src/spyglass/behavior/v1/core.py | 6 +++--- src/spyglass/behavior/v1/moseq.py | 30 ++++++++++++++++++++---------- 2 files changed, 23 insertions(+), 13 deletions(-) diff --git a/src/spyglass/behavior/v1/core.py b/src/spyglass/behavior/v1/core.py index 0ab674122..ad3c09eb3 100644 --- a/src/spyglass/behavior/v1/core.py +++ b/src/spyglass/behavior/v1/core.py @@ -14,6 +14,8 @@ @schema class PoseGroup(SpyglassMixin, dj.Manual): + """Groups one or more entries of keypoint pose information""" + definition = """ pose_group_name: varchar(80) ---- @@ -43,9 +45,7 @@ def create_group( bodyparts : List[str], optional body parts to include in the group, by default None includes all from every set """ - group_key = { - "pose_group_name": group_name - } + group_key = {"pose_group_name": group_name} if self & group_key: warnings.warn( f"Pose group {group_name} already exists. Skipping insertion." diff --git a/src/spyglass/behavior/v1/moseq.py b/src/spyglass/behavior/v1/moseq.py index 9c5f3e6bb..7b1c61578 100644 --- a/src/spyglass/behavior/v1/moseq.py +++ b/src/spyglass/behavior/v1/moseq.py @@ -16,6 +16,16 @@ @schema class MoseqModelParams(SpyglassMixin, dj.Lookup): + """Parameters for training a moseq model + Relevant parameters (keys in model_params): + - skeleton: list of tuples of bodyparts to connect + - num_ar_iters: number of iterations to run the autoregressive model + - kappa: moseq hyperparameter, higher value = longer syllables + - num_epochs: number of epochs to train the model + - anterior_bodyparts: used to define orientation + - posterior_bodyparts: used to define orientation + """ + definition = """ model_params_name: varchar(80) --- @@ -49,7 +59,9 @@ def make_training_extension_params( """ model_key = (MoseqModel & model_key).fetch1("KEY") model_params = (self & model_key).fetch1("model_params") - model_params.update({"num_epochs":num_epochs, "initial_model":model_key}) + model_params.update( + {"num_epochs": num_epochs, "initial_model": model_key} + ) # increment param name if new_name is None: # increment the extension number @@ -76,21 +88,17 @@ def make_training_extension_params( @schema class MoseqModelSelection(SpyglassMixin, dj.Manual): """Pairing of PoseGroup and moseq model params for training""" + definition = """ -> PoseGroup -> MoseqModelParams """ - # relevant parameters: - # - skeleton - # - num_ar_iters - # - kappa - # - num_epochs - # - anterior_bodyparts - # - posterior_bodyparts @schema class MoseqModel(SpyglassMixin, dj.Computed): + """Table to train and store moseq models""" + definition = """ -> MoseqModelSelection --- @@ -302,7 +310,7 @@ def validate_bodyparts(self, key): merge_key = {"merge_id": key["pose_merge_id"]} bodyparts_df = (PositionOutput & merge_key).fetch_pose_dataframe() data_bodyparts = bodyparts_df.keys().get_level_values(0).unique().values - + missing = [bp for bp in model_bodyparts if bp not in data_bodyparts] if missing: raise ValueError( @@ -321,7 +329,9 @@ class MoseqSyllable(SpyglassMixin, dj.Computed): def make(self, key): model = MoseqModel().fetch_model(key) - project_dir, model_name = (MoseqModel & key).fetch1("project_dir", "model_name") + project_dir, model_name = (MoseqModel & key).fetch1( + "project_dir", "model_name" + ) merge_key = {"merge_id": key["pose_merge_id"]} bodyparts = (PoseGroup & key).fetch1("bodyparts") From 5a3309043b462b3d201c92a5c541bef2d9dfaa9d Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 2 Jan 2025 16:33:15 -0800 Subject: [PATCH 27/42] make video symlink more robust --- src/spyglass/behavior/v1/moseq.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/spyglass/behavior/v1/moseq.py b/src/spyglass/behavior/v1/moseq.py index 7b1c61578..8c64c50a9 100644 --- a/src/spyglass/behavior/v1/moseq.py +++ b/src/spyglass/behavior/v1/moseq.py @@ -123,8 +123,11 @@ def make(self, key): video_paths = (PoseGroup & key).fetch_video_paths() for video in video_paths: destination = os.path.join(video_dir, os.path.basename(video)) - if not os.path.lexists(destination): - os.symlink(video, destination) + if os.path.exists(destination): + continue # skip if the symlink already exists + if os.path.lexists(destination): + os.remove(destination) # remove if it's a broken symlink + os.symlink(video, destination) bodyparts = (PoseGroup & key).fetch1("bodyparts") skeleton = model_params["skeleton"] anterior_bodyparts = model_params.get("anterior_bodyparts", None) From bd29c7636d62e81d57930ee546e6fe68b983a239 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 2 Jan 2025 16:36:37 -0800 Subject: [PATCH 28/42] cleanup setup_project call --- src/spyglass/behavior/v1/moseq.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/spyglass/behavior/v1/moseq.py b/src/spyglass/behavior/v1/moseq.py index 8c64c50a9..c712e57da 100644 --- a/src/spyglass/behavior/v1/moseq.py +++ b/src/spyglass/behavior/v1/moseq.py @@ -128,19 +128,16 @@ def make(self, key): if os.path.lexists(destination): os.remove(destination) # remove if it's a broken symlink os.symlink(video, destination) - bodyparts = (PoseGroup & key).fetch1("bodyparts") - skeleton = model_params["skeleton"] - anterior_bodyparts = model_params.get("anterior_bodyparts", None) - posterior_bodyparts = model_params.get("posterior_bodyparts", None) + bodyparts = (PoseGroup & key).fetch1("bodyparts") kpms.setup_project( str(project_dir), video_dir=str(video_dir), bodyparts=bodyparts, - skeleton=skeleton, + skeleton=model_params["skeleton"], use_bodyparts=bodyparts, - anterior_bodyparts=anterior_bodyparts, - posterior_bodyparts=posterior_bodyparts, + anterior_bodyparts=model_params.get("anterior_bodyparts", None), + posterior_bodyparts=model_params.get("posterior_bodyparts", None), ) config = self._config_func(project_dir) From c7ea1f5c1d2b506c294a7eef022c94ea7363bb1f Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 2 Jan 2025 16:44:08 -0800 Subject: [PATCH 29/42] cleanup config method --- src/spyglass/behavior/v1/moseq.py | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/src/spyglass/behavior/v1/moseq.py b/src/spyglass/behavior/v1/moseq.py index c712e57da..f838976ce 100644 --- a/src/spyglass/behavior/v1/moseq.py +++ b/src/spyglass/behavior/v1/moseq.py @@ -140,13 +140,13 @@ def make(self, key): posterior_bodyparts=model_params.get("posterior_bodyparts", None), ) - config = self._config_func(project_dir) + config = kpms.load_config(project_dir) # fetch the data and format it for moseq coordinates, confidences = PoseGroup().fetch_pose_datasets( key, format_for_moseq=True ) - data, metadata = kpms.format_data(coordinates, confidences, **config()) + data, metadata = kpms.format_data(coordinates, confidences, **config) # either initialize a new model or load an existing one model_name = self._make_model_name(key) @@ -193,9 +193,6 @@ def make(self, key): } ) - def _config_func(self, project_dir): - return lambda: kpms.load_config(project_dir) - def _make_model_name(self, key: dict = None): # make a unique model name based on the key if key is None: @@ -215,11 +212,11 @@ def _initialize_model( model, model_name """ # fit pca of data - pca = kpms.fit_pca(**data, **config()) + pca = kpms.fit_pca(**data, **config) kpms.save_pca(pca, project_dir) # create the model - model = kpms.init_model(data, pca=pca, **config()) + model = kpms.init_model(data, pca=pca, **config) # run the autoregressive fit on the model num_ar_iters = model_params["num_ar_iters"] return kpms.fit_model( @@ -244,10 +241,10 @@ def analyze_pca(self, key: dict = None): key = {} project_dir = (self & key).fetch1("project_dir") pca = kpms.load_pca(project_dir) - config = self._config_func(project_dir) + config = kpms.load_config(project_dir) kpms.print_dims_to_explain_variance(pca, 0.9) kpms.plot_scree(pca, project_dir=project_dir) - kpms.plot_pcs(pca, project_dir=project_dir, **config()) + kpms.plot_pcs(pca, project_dir=project_dir, **config) def fetch_model(self, key: dict = None): """Method to fetch the model from the MoseqModel table @@ -335,7 +332,7 @@ def make(self, key): merge_key = {"merge_id": key["pose_merge_id"]} bodyparts = (PoseGroup & key).fetch1("bodyparts") - config = MoseqModel()._config_func(project_dir) + config = kpms.load_config(project_dir) num_iters = (MoseqSyllableSelection & key).fetch1("num_iters") # load data and format for moseq @@ -348,7 +345,7 @@ def make(self, key): bodyparts = bodyparts_df.keys().get_level_values(0).unique().values datasets = {video_name: bodyparts_df[bodyparts]} coordinates, confidences = format_dataset_for_moseq(datasets, bodyparts) - data, metadata = kpms.format_data(coordinates, confidences, **config()) + data, metadata = kpms.format_data(coordinates, confidences, **config) # apply model results = kpms.apply_model( @@ -357,7 +354,7 @@ def make(self, key): metadata, project_dir, model_name, - **config(), + **config, num_iters=num_iters, ) From 5901edced486c81f849cf15f1406d47a7ba92e93 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 2 Jan 2025 17:03:27 -0800 Subject: [PATCH 30/42] Implement suggestions from code review --- src/spyglass/behavior/v1/moseq.py | 63 ++++++++++++++++++++++++------- 1 file changed, 50 insertions(+), 13 deletions(-) diff --git a/src/spyglass/behavior/v1/moseq.py b/src/spyglass/behavior/v1/moseq.py index f838976ce..e683596a5 100644 --- a/src/spyglass/behavior/v1/moseq.py +++ b/src/spyglass/behavior/v1/moseq.py @@ -193,19 +193,37 @@ def make(self, key): } ) - def _make_model_name(self, key: dict = None): + def _make_model_name(self, key: dict): # make a unique model name based on the key - if key is None: - key = {} key = (MoseqModelSelection & key).fetch1("KEY") return dj.hash.key_hash(key) @staticmethod def _initialize_model( - data, metadata, project_dir, model_name, config, model_params + data: dict, + metadata: tuple, + project_dir: str, + model_name: str, + config: dict, + model_params: dict, ): """Method to initialize a model. Creates model and runs initional ARHMM fit + Parameters + ---------- + data : dict + data dictionary (get from kpms.format_data) + metadata : tuple + metadata tuple (get from kpms.format_data) + project_dir : str + path to the project directory + model_name : str + name of the model + config : dict + keypoint moseq config + model_params : dict + params dictionary fetched from spyglass parameter table entry + Returns ------- tuple @@ -229,20 +247,20 @@ def _initialize_model( model_name=model_name + "_ar", ) - def analyze_pca(self, key: dict = None): + def analyze_pca(self, key: dict, explained_variace: float = 0.9): """Method to analyze the PCA of a model Parameters ---------- key : dict key to a single MoseqModel table entry + explained_variace : float, optional + minimum explained variance to print, by default 0.9 """ - if key is None: - key = {} project_dir = (self & key).fetch1("project_dir") pca = kpms.load_pca(project_dir) config = kpms.load_config(project_dir) - kpms.print_dims_to_explain_variance(pca, 0.9) + kpms.print_dims_to_explain_variance(pca, explained_variace) kpms.plot_scree(pca, project_dir=project_dir) kpms.plot_pcs(pca, project_dir=project_dir, **config) @@ -280,8 +298,9 @@ def get_training_progress_path(self, key: dict = None): """ if key is None: key = {} - project_dir = (self & key).fetch1("project_dir") - model_name = (self & key).fetch1("model_name") + project_dir, model_name = (self & key).fetch1( + "project_dir", "model_name" + ) return f"{project_dir}/{model_name}/fitting_progress.pdf" @@ -306,7 +325,9 @@ def validate_bodyparts(self, key): model_bodyparts = (PoseGroup & key).fetch1("bodyparts") merge_key = {"merge_id": key["pose_merge_id"]} bodyparts_df = (PositionOutput & merge_key).fetch_pose_dataframe() - data_bodyparts = bodyparts_df.keys().get_level_values(0).unique().values + data_bodyparts = MoseqSyllable.get_bodyparts_from_dataframe( + bodyparts_df + ) missing = [bp for bp in model_bodyparts if bp not in data_bodyparts] if missing: @@ -338,11 +359,11 @@ def make(self, key): # load data and format for moseq merge_query = PositionOutput & merge_key video_path = merge_query.fetch_video_path() - video_name = Path(video_path).stem + ".mp4" + video_name = Path(video_path).name bodyparts_df = merge_query.fetch_pose_dataframe() if bodyparts is None: - bodyparts = bodyparts_df.keys().get_level_values(0).unique().values + bodyparts = self.get_bodyparts_from_dataframe(bodyparts_df) datasets = {video_name: bodyparts_df[bodyparts]} coordinates, confidences = format_dataset_for_moseq(datasets, bodyparts) data, metadata = kpms.format_data(coordinates, confidences, **config) @@ -379,3 +400,19 @@ def fetch1_dataframe(self): dataframe = self.fetch_nwb()[0]["moseq"] dataframe.set_index("time", inplace=True) return dataframe + + @staticmethod + def get_bodyparts_from_dataframe(dataframe): + """Method to get the list of bodyparts from a dataframe + + Parameters + ---------- + dataframe : pd.DataFrame + dataframe with bodypart data from PositionOutput + + Returns + ------- + List[str] + list of bodyparts + """ + return dataframe.keys().get_level_values(0).unique().values From e5af455737b5ec9fcc670025254a28d16c6e5efc Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 3 Jan 2025 09:58:56 -0800 Subject: [PATCH 31/42] cleanup readability of DLCPosV1 make conditions --- .../position/v1/position_dlc_selection.py | 174 +++++++++--------- 1 file changed, 90 insertions(+), 84 deletions(-) diff --git a/src/spyglass/position/v1/position_dlc_selection.py b/src/spyglass/position/v1/position_dlc_selection.py index 2dbfb2d40..3cbd4d52f 100644 --- a/src/spyglass/position/v1/position_dlc_selection.py +++ b/src/spyglass/position/v1/position_dlc_selection.py @@ -69,93 +69,15 @@ def make(self, key): pos_nwb = (DLCCentroid & key).fetch_nwb()[0] ori_nwb = (DLCOrientation & key).fetch_nwb()[0] - - if isinstance(pos_nwb["dlc_position"], pd.DataFrame): - # Null entry case - key["analysis_file_name"] = AnalysisNwbfile().create( - nwb_file_name=key["nwb_file_name"] - ) - obj_id = AnalysisNwbfile().add_nwb_object( - key["analysis_file_name"], pd.DataFrame() - ) - key["position_object_id"] = obj_id - key["orientation_object_id"] = obj_id - key["velocity_object_id"] = obj_id - - else: - pos_obj = pos_nwb["dlc_position"].spatial_series["position"] - vel_obj = pos_nwb["dlc_velocity"].time_series["velocity"] - vid_frame_obj = pos_nwb["dlc_velocity"].time_series[ - "video_frame_ind" - ] - ori_obj = ori_nwb["dlc_orientation"].spatial_series["orientation"] - - position = pynwb.behavior.Position() - orientation = pynwb.behavior.CompassDirection() - velocity = pynwb.behavior.BehavioralTimeSeries() - - position.create_spatial_series( - name=pos_obj.name, - timestamps=np.asarray(pos_obj.timestamps), - conversion=pos_obj.conversion, - data=np.asarray(pos_obj.data), - reference_frame=pos_obj.reference_frame, - comments=pos_obj.comments, - description=pos_obj.description, - ) - - orientation.create_spatial_series( - name=ori_obj.name, - timestamps=np.asarray(ori_obj.timestamps), - conversion=ori_obj.conversion, - data=np.asarray(ori_obj.data), - reference_frame=ori_obj.reference_frame, - comments=ori_obj.comments, - description=ori_obj.description, - ) - - velocity.create_timeseries( - name=vel_obj.name, - timestamps=np.asarray(vel_obj.timestamps), - conversion=vel_obj.conversion, - unit=vel_obj.unit, - data=np.asarray(vel_obj.data), - comments=vel_obj.comments, - description=vel_obj.description, - ) - - velocity.create_timeseries( - name=vid_frame_obj.name, - timestamps=np.asarray(vid_frame_obj.timestamps), - unit=vid_frame_obj.unit, - data=np.asarray(vid_frame_obj.data), - description=vid_frame_obj.description, - comments=vid_frame_obj.comments, - ) - - # Add to Analysis NWB file - analysis_file_name = AnalysisNwbfile().create(key["nwb_file_name"]) - key["analysis_file_name"] = analysis_file_name - nwb_analysis_file = AnalysisNwbfile() - - key.update( - { - "analysis_file_name": analysis_file_name, - "position_object_id": nwb_analysis_file.add_nwb_object( - analysis_file_name, position - ), - "orientation_object_id": nwb_analysis_file.add_nwb_object( - analysis_file_name, orientation - ), - "velocity_object_id": nwb_analysis_file.add_nwb_object( - analysis_file_name, velocity - ), - } - ) + key = ( + self.make_null_position_nwb(key) + if isinstance(pos_nwb["dlc_position"], pd.DataFrame) # null case + else self.make_dlc_pos_nwb(key, pos_nwb, ori_nwb) # normal case + ) AnalysisNwbfile().add( nwb_file_name=key["nwb_file_name"], - analysis_file_name=analysis_file_name, + analysis_file_name=key["analysis_file_name"], ) self.insert1(key) @@ -169,6 +91,90 @@ def make(self, key): ) AnalysisNwbfile().log(key, table=self.full_table_name) + @staticmethod + def make_null_position_nwb(key): + key["analysis_file_name"] = AnalysisNwbfile().create( + nwb_file_name=key["nwb_file_name"] + ) + obj_id = AnalysisNwbfile().add_nwb_object( + key["analysis_file_name"], pd.DataFrame() + ) + key["position_object_id"] = obj_id + key["orientation_object_id"] = obj_id + key["velocity_object_id"] = obj_id + return key + + @staticmethod + def make_dlc_pos_nwb(key, pos_nwb, ori_nwb): + pos_obj = pos_nwb["dlc_position"].spatial_series["position"] + vel_obj = pos_nwb["dlc_velocity"].time_series["velocity"] + vid_frame_obj = pos_nwb["dlc_velocity"].time_series["video_frame_ind"] + ori_obj = ori_nwb["dlc_orientation"].spatial_series["orientation"] + + position = pynwb.behavior.Position() + orientation = pynwb.behavior.CompassDirection() + velocity = pynwb.behavior.BehavioralTimeSeries() + + position.create_spatial_series( + name=pos_obj.name, + timestamps=np.asarray(pos_obj.timestamps), + conversion=pos_obj.conversion, + data=np.asarray(pos_obj.data), + reference_frame=pos_obj.reference_frame, + comments=pos_obj.comments, + description=pos_obj.description, + ) + + orientation.create_spatial_series( + name=ori_obj.name, + timestamps=np.asarray(ori_obj.timestamps), + conversion=ori_obj.conversion, + data=np.asarray(ori_obj.data), + reference_frame=ori_obj.reference_frame, + comments=ori_obj.comments, + description=ori_obj.description, + ) + + velocity.create_timeseries( + name=vel_obj.name, + timestamps=np.asarray(vel_obj.timestamps), + conversion=vel_obj.conversion, + unit=vel_obj.unit, + data=np.asarray(vel_obj.data), + comments=vel_obj.comments, + description=vel_obj.description, + ) + + velocity.create_timeseries( + name=vid_frame_obj.name, + timestamps=np.asarray(vid_frame_obj.timestamps), + unit=vid_frame_obj.unit, + data=np.asarray(vid_frame_obj.data), + description=vid_frame_obj.description, + comments=vid_frame_obj.comments, + ) + + # Add to Analysis NWB file + analysis_file_name = AnalysisNwbfile().create(key["nwb_file_name"]) + key["analysis_file_name"] = analysis_file_name + nwb_analysis_file = AnalysisNwbfile() + + key.update( + { + "analysis_file_name": analysis_file_name, + "position_object_id": nwb_analysis_file.add_nwb_object( + analysis_file_name, position + ), + "orientation_object_id": nwb_analysis_file.add_nwb_object( + analysis_file_name, orientation + ), + "velocity_object_id": nwb_analysis_file.add_nwb_object( + analysis_file_name, velocity + ), + } + ) + return key + def fetch1_dataframe(self) -> pd.DataFrame: """Return the position data as a DataFrame.""" nwb_data = self.fetch_nwb()[0] From 04c2a37133d5fb801f31f3f39dfcbc551987c80a Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Fri, 3 Jan 2025 10:13:19 -0800 Subject: [PATCH 32/42] allow key argument when fetching video path --- src/spyglass/position/v1/position_dlc_pose_estimation.py | 9 +++++++-- src/spyglass/position/v1/position_dlc_selection.py | 9 +++++++-- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/spyglass/position/v1/position_dlc_pose_estimation.py b/src/spyglass/position/v1/position_dlc_pose_estimation.py index ba5bf63cc..c90925c71 100644 --- a/src/spyglass/position/v1/position_dlc_pose_estimation.py +++ b/src/spyglass/position/v1/position_dlc_pose_estimation.py @@ -409,15 +409,20 @@ def fetch_dataframe(self, *attrs, **kwargs) -> pd.DataFrame: axis=1, ) - def fetch_video_path(self): + def fetch_video_path(self, key: dict = dict()) -> str: """Return the video path for pose estimate + Parameters + ---------- + key : dict, optional + DataJoint key, by default dict() Returns ------- str absolute path to video file """ - return (DLCPoseEstimationSelection & self).fetch1("video_path") + key = (self & key).fetch1("KEY") + return (DLCPoseEstimationSelection & key).fetch1("video_path") def convert_to_cm(df, meters_to_pixels): diff --git a/src/spyglass/position/v1/position_dlc_selection.py b/src/spyglass/position/v1/position_dlc_selection.py index 3cbd4d52f..7c561671a 100644 --- a/src/spyglass/position/v1/position_dlc_selection.py +++ b/src/spyglass/position/v1/position_dlc_selection.py @@ -311,15 +311,20 @@ def fetch_pose_dataframe(self): key = self.fetch1("KEY") return (DLCPoseEstimation & key).fetch_dataframe() - def fetch_video_path(self): + def fetch_video_path(self, key: dict = dict()) -> str: """Return the video path for pose estimate + Parameters + ---------- + key : dict, optional + key of entry within the table instance, by default dict() Returns ------- str absolute path to video file """ - return (DLCPoseEstimationSelection & self).fetch1("video_path") + key = (self & key).fetch1("KEY") + return (DLCPoseEstimationSelection & key).fetch1("video_path") @schema From 8106929ef00fb034edffeb72f28ddd113f428f62 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 16 Jan 2025 09:39:54 -0800 Subject: [PATCH 33/42] add moseq dependencies --- environment_moseq_cpu.yml | 42 +++++++++++++++++++++++++++++++++++++++ environment_moseq_gpu.yml | 42 +++++++++++++++++++++++++++++++++++++++ pyproject.toml | 11 ++++++++++ 3 files changed, 95 insertions(+) create mode 100644 environment_moseq_cpu.yml create mode 100644 environment_moseq_gpu.yml diff --git a/environment_moseq_cpu.yml b/environment_moseq_cpu.yml new file mode 100644 index 000000000..b40dfb646 --- /dev/null +++ b/environment_moseq_cpu.yml @@ -0,0 +1,42 @@ +# 1. Install a conda distribution. +# https://mamba.readthedocs.io/en/latest/installation/mamba-installation.html +# 2. Run: `mamba env create -f environment.yml` +# 3. Activate: `conda activate spyglass` +# +# (lines intentionally left blank) +# +# +name: spyglass-moseq-cpu +channels: + - conda-forge + # - defaults # deprecated + - franklab + - edeno + # - pytorch # dlc-only + # - anaconda # dlc-only, for cudatoolkit +dependencies: + - bottleneck + # - cudatoolkit=11.3 # dlc-only + # - ffmpeg # dlc-only + - ipympl + - jupyterlab>=3.* + # - libgcc # dlc-only + - matplotlib + - non_local_detector + - numpy + - pip + - position_tools + - pybind11 # req by mountainsort4 -> isosplit5 + - pydotplus + - pyfftw<=0.12.0 # ghostipy req. install from conda-forge for Mac ARM + - python>=3.9,<3.13 + - pytorch<1.12.0 + - ripple_detection + - seaborn + # - torchaudio # dlc-only + # - torchvision # dlc-only + - track_linearization>=2.3 + - pip: + - ghostipy # for common_filter + - mountainsort4 + - .[moseq-cpu] diff --git a/environment_moseq_gpu.yml b/environment_moseq_gpu.yml new file mode 100644 index 000000000..3d80f42a8 --- /dev/null +++ b/environment_moseq_gpu.yml @@ -0,0 +1,42 @@ +# 1. Install a conda distribution. +# https://mamba.readthedocs.io/en/latest/installation/mamba-installation.html +# 2. Run: `mamba env create -f environment.yml` +# 3. Activate: `conda activate spyglass` +# +# (lines intentionally left blank) +# +# +name: spyglass-moseq-gpu +channels: + - conda-forge + # - defaults # deprecated + - franklab + - edeno + # - pytorch # dlc-only + # - anaconda # dlc-only, for cudatoolkit +dependencies: + - bottleneck + # - cudatoolkit=11.3 # dlc-only + # - ffmpeg # dlc-only + - ipympl + - jupyterlab>=3.* + # - libgcc # dlc-only + - matplotlib + - non_local_detector + - numpy + - pip + - position_tools + - pybind11 # req by mountainsort4 -> isosplit5 + - pydotplus + - pyfftw<=0.12.0 # ghostipy req. install from conda-forge for Mac ARM + - python>=3.9,<3.13 + - pytorch<1.12.0 + - ripple_detection + - seaborn + # - torchaudio # dlc-only + # - torchvision # dlc-only + - track_linearization>=2.3 + - pip: + - ghostipy # for common_filter + - mountainsort4 + - .[moseq-gpu] diff --git a/pyproject.toml b/pyproject.toml index 0a1cd627f..adf76af6c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -65,6 +65,17 @@ dlc = [ "ffmpeg", "deeplabcut[tf]", # removing dlc pin removes need to pin tf/numba ] +moseq-gpu = [ + "jax[cuda12]==0.3.22", + "jax-moseq[cuda12]", + "keypoint-moseq", +] +moseq-cpu = [ + "jax[cpu]==0.3.22", + "jax-moseq", + "keypoint-moseq", +] + test = [ "click", # for CLI subpackage only "docker", # for tests in a container From 2bff705a7eb90e775825e73569716edbaf29036f Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 16 Jan 2025 10:02:57 -0800 Subject: [PATCH 34/42] Add moseq install instructions to tutorials --- notebooks/00_Setup.ipynb | 46 ++++- notebooks/60_MoSeq.ipynb | 7 +- notebooks/py_scripts/00_Setup.py | 44 ++++- notebooks/py_scripts/60_MoSeq.py | 326 +++++++++++++++++++++++++++++++ 4 files changed, 417 insertions(+), 6 deletions(-) create mode 100644 notebooks/py_scripts/60_MoSeq.py diff --git a/notebooks/00_Setup.ipynb b/notebooks/00_Setup.ipynb index 9188bafa0..94fb20967 100644 --- a/notebooks/00_Setup.ipynb +++ b/notebooks/00_Setup.ipynb @@ -285,7 +285,47 @@ "The Decoding pipeline relies on `jax` to process data with GPUs. Please see\n", "their conda installation steps\n", "[here](https://jax.readthedocs.io/en/latest/installation.html#conda-installation).\n", - "\n" + "\n", + "#### Deep Lab Cut (DLC)\n", + "\n", + "Spyglass provides an environment build for using the DLC pipeline. To create an \n", + "environment with these features, please:\n", + "1. navigate to your cloned spyglass repo.\n", + "2. build the environment from the dlc version\n", + "3. activate the environment to use\n", + "\n", + "```bash\n", + "cd /path/to/spyglass # 1\n", + "mamba env create -f environment_dlc.yml # 2\n", + "mamba activate spyglass-dlc # 3\n", + "```\n", + "\n", + "Alternatively, you can pip install using\n", + "```bash\n", + "pip install spyglass[dlc]\n", + "```\n", + "\n", + "#### Keypoint-Moseq\n", + "\n", + "Spyglass provides an environment build for using the Moseq pipeline. To create an \n", + "environment with these features, please:\n", + "1. navigate to your cloned spyglass repo.\n", + "2. build the environment from one of the moseq versions\n", + "3. activate the environment to use\n", + "\n", + "```bash\n", + "cd /path/to/spyglass # 1\n", + "mamba env create -f environment_moseq_cpu.yml # 2\n", + "mamba activate spyglass-moseq-cpu # 3\n", + "```\n", + "\n", + "Alternatively, you can pip install using\n", + "```bash\n", + "pip install spyglass[moseq-cpu]\n", + "```\n", + "\n", + "To use a GPU enabled version of the package, replace `cpu` with `gpu` in the above \n", + "commands\n" ] }, { @@ -593,7 +633,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "spyglass", "language": "python", "name": "python3" }, @@ -607,7 +647,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.19" + "version": "3.9.18" } }, "nbformat": 4, diff --git a/notebooks/60_MoSeq.ipynb b/notebooks/60_MoSeq.ipynb index aca3eb4cb..ef902b8e9 100644 --- a/notebooks/60_MoSeq.ipynb +++ b/notebooks/60_MoSeq.ipynb @@ -8,6 +8,9 @@ "\n", "This notebook provides a tutorial on how to use the MoSeq pipeline to analyze behavioral data. The pipeline is a tool for taking keypoint pose estimations and extracting behavioral syllables.\n", "\n", + "*Note: Moseq is an optional dependency within the spyglass package. For installation\n", + "instructions, see the [setup tutorial](./00_Setup.ipynb)\n", + "\n", "Here is a schematic showing the tables used in this pipeline. The Basic steps are:\n", "> **Model Training**\n", "> - Define training data in `PoseGroup`\n", @@ -1804,7 +1807,9 @@ "from spyglass.behavior.moseq import MoseqSyllableSelection, MoseqSyllable\n", "\n", "# Make a selection table entry defining the pose data and moseq model to use\n", - "pose_key = PoseGroup().Pose().fetch(\"pose_merge_id\", as_dict=True)[0] # can also use data outside of the training epochs\n", + "pose_key = (\n", + " PoseGroup().Pose().fetch(\"pose_merge_id\", as_dict=True)[0]\n", + ") # can also use data outside of the training epochs\n", "key = {**model_key, **pose_key, \"num_iters\": 3}\n", "MoseqSyllableSelection().insert1(key, skip_duplicates=True)\n", "\n", diff --git a/notebooks/py_scripts/00_Setup.py b/notebooks/py_scripts/00_Setup.py index 1169999a4..0462b5a97 100644 --- a/notebooks/py_scripts/00_Setup.py +++ b/notebooks/py_scripts/00_Setup.py @@ -5,9 +5,9 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.16.0 +# jupytext_version: 1.15.2 # kernelspec: -# display_name: Python 3 (ipykernel) +# display_name: spyglass # language: python # name: python3 # --- @@ -257,6 +257,46 @@ # their conda installation steps # [here](https://jax.readthedocs.io/en/latest/installation.html#conda-installation). # +# #### Deep Lab Cut (DLC) +# +# Spyglass provides an environment build for using the DLC pipeline. To create an +# environment with these features, please: +# 1. navigate to your cloned spyglass repo. +# 2. build the environment from the dlc version +# 3. activate the environment to use +# +# ```bash +# # cd /path/to/spyglass # 1 +# mamba env create -f environment_dlc.yml # 2 +# mamba activate spyglass-dlc # 3 +# ``` +# +# Alternatively, you can pip install using +# ```bash +# pip install spyglass[dlc] +# ``` +# +# #### Keypoint-Moseq +# +# Spyglass provides an environment build for using the Moseq pipeline. To create an +# environment with these features, please: +# 1. navigate to your cloned spyglass repo. +# 2. build the environment from one of the moseq versions +# 3. activate the environment to use +# +# ```bash +# # cd /path/to/spyglass # 1 +# mamba env create -f environment_moseq_cpu.yml # 2 +# mamba activate spyglass-moseq-cpu # 3 +# ``` +# +# Alternatively, you can pip install using +# ```bash +# pip install spyglass[moseq-cpu] +# ``` +# +# To use a GPU enabled version of the package, replace `cpu` with `gpu` in the above +# commands # # ## Database diff --git a/notebooks/py_scripts/60_MoSeq.py b/notebooks/py_scripts/60_MoSeq.py new file mode 100644 index 000000000..8c0e749b8 --- /dev/null +++ b/notebooks/py_scripts/60_MoSeq.py @@ -0,0 +1,326 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: light +# format_version: '1.5' +# jupytext_version: 1.15.2 +# kernelspec: +# display_name: spyglass-moseq-1 +# language: python +# name: python3 +# --- + +# # MoSeq Pipeline Tutorial +# +# This notebook provides a tutorial on how to use the MoSeq pipeline to analyze behavioral data. The pipeline is a tool for taking keypoint pose estimations and extracting behavioral syllables. +# +# *Note: Moseq is an optional dependency within the spyglass package. For installation +# instructions, see the [setup tutorial](./00_Setup.ipynb) +# +# Here is a schematic showing the tables used in this pipeline. The Basic steps are: +# > **Model Training** +# > - Define training data in `PoseGroup` +# > - Define Moseq model and training parameters in `MoseqModelParams` +# > - Combine a set of training parmaters and training data in `MoseqModelSelection` +# > - Populate `MoseqModel` to train +# > +# > **Convert pose data to behavioral syllables** +# > - Combine a trained model from `MoseqModel` and a pose data from `PositionOutput` in +# `MoseqSyllableSelection` +# > - Populate `MoseqSyllable` to apply the trained model to the selected data +# +# ![moseq_outline.png|2000x900](./../notebook-images/moseq_outline.png) +# + +# # Accessing the keypoint (pose) data +# +# In the spyglass architecture, keypoint tracking is performed in the `Position` module, +# and can be accesed through `PositionOutput.fetch_pose_dataframe()`. In this tutorial, +# we are using a set of unpublished data from the Frank lab. For a tutorial on +# running keypoint extraction in spyglass, see [the DLC tutorial notebook](21_DLC.ipynb). +# +# We can access an example set of keypoint pose data here: + +# + +# # %load_ext autoreload +# # %autoreload 2 +from spyglass.position.position_merge import PositionOutput + +# Key defining the DLC data we are using +pose_key = { + "nwb_file_name": "SC100020230912_.nwb", + "epoch": 9, + "video_file_num": 14, + "project_name": "sideHomeOfficial", + "dlc_model_name": "sideHomeOfficial_tutorial_00", + "dlc_model_params_name": "default", + "task_mode": "trigger", +} + +# Fetch the pose data for demo purposes +merge_key = (PositionOutput.DLCPosV1 & pose_key).fetch1("KEY") +pose_df = (PositionOutput & merge_key).fetch_pose_dataframe() +pose_df +# - + +# To train a moseq model, we first need to define the epochs of pose data we will train on +# as well as the bodyparts to use within the model. We define this in the `PoseGroup` +# table below. +# +# Note that training can be run using data from multiple epochs by passing a list of +# merge ids to `create_group` + +# + +from spyglass.behavior.core import PoseGroup + +# Define the group name and bodyparts to include in the Moseq model +group_name = "tutorial_group" +merge_ids = [(PositionOutput & merge_key).fetch("merge_id")[0]] +bodyparts = [ + "forelimbL", + "forelimbR", + "nose", + "spine1", + "spine3", + "spine5", + "tailBase", +] + +# Create the group +PoseGroup().create_group( + group_name, + merge_ids, + bodyparts, +) + +# Look at the group in the database +group_key = {"pose_group_name": group_name} +PoseGroup() & group_key +# - + +# ## Defining the Moseq Model +# +# Next, we make an entry intpo the `MoseqModelParams` table. The information in this +# is used to initialize the moseq model and includes hyperparameters for model training +# as well as allows you to begin training from an existing model in the database +# (discussed more below). Relevant parameters can be found in the [Moseq documentation]( +# https://keypoint-moseq.readthedocs.io/en/latest/modeling.html#model-fitting) +# +# ** Note: All bodyparts in the `PoseGroup` entry will be used in the model + +# + +from spyglass.behavior.moseq import ( + MoseqModel, + MoseqModelParams, + MoseqModelSelection, +) + +model_params_name = "tutorial_kappa4_mini" +params = {} +# the skeleton list defines pairs of bodyparts that are linked by and edge +params["skeleton"] = [ + ["nose", "spine1"], + ["spine1", "forelimbL"], + ["spine1", "forelimbR"], + ["spine1", "spine3"], + ["spine3", "spine5"], + ["spine5", "tailBase"], +] +# kappa affects the distribution of syllable durations, likely needs tuning for each dataset +params["kappa"] = 1e4 +# num_ar_iters is the number of iterations of the autoregressive model for warm-up +params["num_ar_iters"] = 50 +# num_epochs is the number of epochs to train the model +params["num_epochs"] = 50 +# anteror and posterior bodyparts are used to define the orientation of the animal +params["anterior_bodyparts"] = ["nose"] +params["posterior_bodyparts"] = ["tailBase"] + +MoseqModelParams().insert1( + {"model_params_name": model_params_name, "model_params": params}, + skip_duplicates=True, +) + +MoseqModelParams() +# - + +# To train the model, we link a set of model params with training data in `PoseGroup` +# using the `MoseqModelSelection` table. + +# + +MoseqModelSelection().insert1( + { + "model_params_name": model_params_name, + "pose_group_name": group_name, + }, + skip_duplicates=True, +) + +MoseqModelSelection() +# - + +# We can then train the model by populating the corresponding `MoseqModel` entry. This +# will load the keypoint data, format it for moseq, and then train according to the +# setting in the `MoseqModelParams` entry + +model_key = { + "model_params_name": model_params_name, + "pose_group_name": group_name, +} +MoseqModel().populate(model_key) + +# The model is now trained and accessible through the the `MoseqModel` table. + +trained_model = MoseqModel().fetch_model(model_key) +trained_model + +# We can also analyze components of the trained model; +# ie. the pca breakdown of the pose skeleton + +table = MoseqModel() & model_key +table.analyze_pca() + +# ## Run data through the trained model +# +# Now that we have a trained model, we can use it to convert pose data into behavioral +# syllables. We do so by combining a trained model with an epoch of pose data, and then +# applying the populate command + +# + +# %load_ext autoreload +# %autoreload 2 +from spyglass.behavior.moseq import MoseqSyllableSelection, MoseqSyllable + +# Make a selection table entry defining the pose data and moseq model to use +pose_key = ( + PoseGroup().Pose().fetch("pose_merge_id", as_dict=True)[0] +) # can also use data outside of the training epochs +key = {**model_key, **pose_key, "num_iters": 3} +MoseqSyllableSelection().insert1(key, skip_duplicates=True) + +# Run populate to apply the model to the pose data +MoseqSyllable().populate(key) +MoseqSyllable() + +# + +import matplotlib.pyplot as plt + +moseq_df = (MoseqSyllable() & key).fetch1_dataframe() +moseq_df +ind = slice(1000, 3000) + +fig, ax = plt.subplots(2, 1, figsize=(8, 5), sharex=True) +t = moseq_df.index.values[ind] +ax[0].plot(t, moseq_df["centroid x"].values[ind], label="x") +ax[0].plot(t, moseq_df["centroid y"].values[ind], label="y") +ax[1].scatter( + t, + moseq_df.syllable.values[ind], + s=10, + c=moseq_df.syllable.values[ind], + cmap="tab20", +) +ax[0].set_ylabel("centroid") +ax[1].set_ylabel("syllable") +ax[1].set_xlabel("time (s)") +# - + +# This concludes the tutorial for basic usage of the Moseq pipeline. Next, we will +# look at usage for extending training from a base model and leveraging spyglass's +# relational database to easily sweep through model hyperparameters + +# # Extend model training +# +# There are many cases where you may want to begin trining from an existing model +# rather than begin from scratch. Examples include continuing training an incompletely +# converged entry, or using a pre-trained base model and refining it to a particular set +# of animals/ imaging conditions (ie. transfer learning). +# +# The spyglass moseq pipeline allows for this style of iterative training. To do so, +# we will define a new entry in `MoseqModelParams` using the `make_training_extension_params` +# method. This entry will have the same params as those used in model_key, except it +# will point to the model_key entry for the `initial_model` + +# Insert a training extension model entry +extension_params = MoseqModelParams().make_training_extension_params( + model_key, num_epochs=100, skip_duplicates=True +) +print("initial model: ", extension_params["model_params"]["initial_model"]) +new_params_key = { + "model_params_name": extension_params["model_params_name"], +} +MoseqModelParams() & "model_params_name LIKE '%tutorial_kappa4%'" + +# This extension model can then be trained following the same steps as before + +new_model_key = { + **new_params_key, + "pose_group_name": model_key["pose_group_name"], +} +MoseqModelSelection().insert1(new_model_key, skip_duplicates=True) +MoseqModel().populate(new_model_key) + +# # Hyperparameter search (kappa) +# +# The relational database structure makes it relatively easy to train and organize +# multiple models on the same data. Here we demonstrate leveraging this architecture to +# test values of `kappa` in the moseq model. The `kappa` value determines the rate +# of syllable transitions, with larger values corresponding to longer syllables +# ([moseq docs](https://keypoint-moseq.readthedocs.io/en/latest/advanced.html#automatic-kappa-scan)). +# This value will likely need tuned for your specific data to achieve a syllable +# distribution at appropriate timescales. +# +# To do so we will make a set of parameter entries with varying values of kappa and then +# training an initial model for each. Looking at the results above, we see a shorter +# median distribution (~3 frames = 100ms) than we would like +# ([recommended ~400ms](https://keypoint-moseq.readthedocs.io/en/latest/FAQs.html#modeling)) +# . We will therfore try several parameter sets with larger kappa values. +# +# + +# + +original_params = (MoseqModelParams() & model_key).fetch1("model_params") + +new_params_key_list = [] +for i in [5, 6, 7, 8]: + new_params = original_params.copy() + new_params["kappa"] = 10**i + new_model_params_name = f"tutorial_kappa{i}_mini" + new_params_key = { + "model_params_name": new_model_params_name, + "model_params": new_params, + } + new_params_key_list.append(new_params_key) + MoseqModelParams().insert1(new_params_key, skip_duplicates=True) + +MoseqModelParams() & "model_params_name LIKE '%tutorial_kappa%'" +# - + +# We can now train a model for each of these entries. We are training several different +# models here, so depending on your hardware, now may be a good time for a coffee break. + +for new_params_key in new_params_key_list: + new_model_key = { + "model_params_name": new_params_key["model_params_name"], + "pose_group_name": model_key["pose_group_name"], + } + MoseqModelSelection().insert1(new_model_key, skip_duplicates=True) +MoseqModel().populate() + +# You can then choose the model that best matches your syllable duration of interest and +# continue training it using the training extension described above + +# print out link to the pdf of training results (includes syllable durations) +for new_params_key in new_params_key_list: + new_model_key = { + "model_params_name": new_params_key["model_params_name"], + "pose_group_name": model_key["pose_group_name"], + } + training_results_path = MoseqModel().get_training_progress_path( + new_model_key + ) + print( + f"{new_model_key['model_params_name']} training results: {training_results_path}" + ) From 31014f97e97246bc9db19adab8b2d1f0594784f8 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 16 Jan 2025 10:10:59 -0800 Subject: [PATCH 35/42] accept key in all get video path functions --- src/spyglass/common/common_position.py | 5 +++-- src/spyglass/position/position_merge.py | 4 ++-- src/spyglass/position/v1/position_trodes_position.py | 4 +++- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/spyglass/common/common_position.py b/src/spyglass/common/common_position.py index 5216540de..f57e7e718 100644 --- a/src/spyglass/common/common_position.py +++ b/src/spyglass/common/common_position.py @@ -514,8 +514,9 @@ def _data_to_df( def fetch_pose_datframe(self): raise NotImplementedError("No Pose data available for this table") - def fetch_video_path(self): - return self.fetch_nwb()[0]["head_position"].get_comments() + def fetch_video_path(self, key=dict()): + key = (self & key).fetch1("KEY") + return (self & key).fetch_nwb()[0]["head_position"].get_comments() @schema diff --git a/src/spyglass/position/position_merge.py b/src/spyglass/position/position_merge.py index 8a9d07a27..7582c5999 100644 --- a/src/spyglass/position/position_merge.py +++ b/src/spyglass/position/position_merge.py @@ -88,8 +88,8 @@ def fetch_pose_dataframe(self): ) return query.fetch_pose_dataframe() - def fetch_video_path(self): - key = self.merge_restrict(self.proj()).proj() + def fetch_video_path(self, key=dict()): + key = self.merge_restrict((self & key).proj()).proj() query = ( source_class_dict[ to_camel_case(self.merge_get_parent(self.proj()).table_name) diff --git a/src/spyglass/position/v1/position_trodes_position.py b/src/spyglass/position/v1/position_trodes_position.py index efaa611b0..9fdab0e4a 100644 --- a/src/spyglass/position/v1/position_trodes_position.py +++ b/src/spyglass/position/v1/position_trodes_position.py @@ -254,7 +254,9 @@ def fetch1_dataframe(self, add_frame_ind=True) -> DataFrame: def fetch_pose_dataframe(self): raise NotImplementedError("No pose data for TrodesPosV1") - def fetch_video_path(self): + def fetch_video_path(self, key=dict()): + """Fetch the video path for the position data.""" + key = (self & key).fetch1("KEY") nwb_file_name, interval_list_name = self.fetch1( "nwb_file_name", "interval_list_name" ) From f61f10c731c859af6dd075a543520899d479c6ff Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 16 Jan 2025 10:18:53 -0800 Subject: [PATCH 36/42] fix spelling --- notebooks/60_MoSeq.ipynb | 6 +++--- notebooks/py_scripts/60_MoSeq.py | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/notebooks/60_MoSeq.ipynb b/notebooks/60_MoSeq.ipynb index ef902b8e9..dda138f63 100644 --- a/notebooks/60_MoSeq.ipynb +++ b/notebooks/60_MoSeq.ipynb @@ -15,7 +15,7 @@ "> **Model Training**\n", "> - Define training data in `PoseGroup`\n", "> - Define Moseq model and training parameters in `MoseqModelParams`\n", - "> - Combine a set of training parmaters and training data in `MoseqModelSelection`\n", + "> - Combine a set of training paramaters and training data in `MoseqModelSelection`\n", "> - Populate `MoseqModel` to train\n", "> \n", "> **Convert pose data to behavioral syllables**\n", @@ -33,7 +33,7 @@ " # Accessing the keypoint (pose) data\n", "\n", "In the spyglass architecture, keypoint tracking is performed in the `Position` module,\n", - "and can be accesed through `PositionOutput.fetch_pose_dataframe()`. In this tutorial,\n", + "and can be accessed through `PositionOutput.fetch_pose_dataframe()`. In this tutorial,\n", "we are using a set of unpublished data from the Frank lab. For a tutorial on\n", "running keypoint extraction in spyglass, see [the DLC tutorial notebook](21_DLC.ipynb).\n", "\n", @@ -2129,7 +2129,7 @@ "training an initial model for each. Looking at the results above, we see a shorter\n", "median distribution (~3 frames = 100ms) than we would like \n", "([recommended ~400ms](https://keypoint-moseq.readthedocs.io/en/latest/FAQs.html#modeling))\n", - ". We will therfore try several parameter sets with larger kappa values.\n", + ". We will therefore try several parameter sets with larger kappa values.\n", "\n" ] }, diff --git a/notebooks/py_scripts/60_MoSeq.py b/notebooks/py_scripts/60_MoSeq.py index 8c0e749b8..4bf94e0c3 100644 --- a/notebooks/py_scripts/60_MoSeq.py +++ b/notebooks/py_scripts/60_MoSeq.py @@ -23,7 +23,7 @@ # > **Model Training** # > - Define training data in `PoseGroup` # > - Define Moseq model and training parameters in `MoseqModelParams` -# > - Combine a set of training parmaters and training data in `MoseqModelSelection` +# > - Combine a set of training paramaters and training data in `MoseqModelSelection` # > - Populate `MoseqModel` to train # > # > **Convert pose data to behavioral syllables** @@ -37,7 +37,7 @@ # # Accessing the keypoint (pose) data # # In the spyglass architecture, keypoint tracking is performed in the `Position` module, -# and can be accesed through `PositionOutput.fetch_pose_dataframe()`. In this tutorial, +# and can be accessed through `PositionOutput.fetch_pose_dataframe()`. In this tutorial, # we are using a set of unpublished data from the Frank lab. For a tutorial on # running keypoint extraction in spyglass, see [the DLC tutorial notebook](21_DLC.ipynb). # @@ -276,7 +276,7 @@ # training an initial model for each. Looking at the results above, we see a shorter # median distribution (~3 frames = 100ms) than we would like # ([recommended ~400ms](https://keypoint-moseq.readthedocs.io/en/latest/FAQs.html#modeling)) -# . We will therfore try several parameter sets with larger kappa values. +# . We will therefore try several parameter sets with larger kappa values. # # From 24e1150152c4976bb9ad74679d777e4568070a0e Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Thu, 16 Jan 2025 10:25:43 -0800 Subject: [PATCH 37/42] fix spelling --- notebooks/60_MoSeq.ipynb | 2 +- notebooks/py_scripts/60_MoSeq.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/notebooks/60_MoSeq.ipynb b/notebooks/60_MoSeq.ipynb index dda138f63..8b458b7f9 100644 --- a/notebooks/60_MoSeq.ipynb +++ b/notebooks/60_MoSeq.ipynb @@ -15,7 +15,7 @@ "> **Model Training**\n", "> - Define training data in `PoseGroup`\n", "> - Define Moseq model and training parameters in `MoseqModelParams`\n", - "> - Combine a set of training paramaters and training data in `MoseqModelSelection`\n", + "> - Combine a set of training parameters and training data in `MoseqModelSelection`\n", "> - Populate `MoseqModel` to train\n", "> \n", "> **Convert pose data to behavioral syllables**\n", diff --git a/notebooks/py_scripts/60_MoSeq.py b/notebooks/py_scripts/60_MoSeq.py index 4bf94e0c3..600fda126 100644 --- a/notebooks/py_scripts/60_MoSeq.py +++ b/notebooks/py_scripts/60_MoSeq.py @@ -23,7 +23,7 @@ # > **Model Training** # > - Define training data in `PoseGroup` # > - Define Moseq model and training parameters in `MoseqModelParams` -# > - Combine a set of training paramaters and training data in `MoseqModelSelection` +# > - Combine a set of training parameters and training data in `MoseqModelSelection` # > - Populate `MoseqModel` to train # > # > **Convert pose data to behavioral syllables** From ec34e9c36d77d90e8b30f060a1035d2983758ed2 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Mon, 27 Jan 2025 15:03:17 -0800 Subject: [PATCH 38/42] make model project dir unique --- src/spyglass/behavior/v1/moseq.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/spyglass/behavior/v1/moseq.py b/src/spyglass/behavior/v1/moseq.py index e683596a5..35c7cba62 100644 --- a/src/spyglass/behavior/v1/moseq.py +++ b/src/spyglass/behavior/v1/moseq.py @@ -116,9 +116,14 @@ def make(self, key): key to a single MoseqModelSelection table entry """ model_params = (MoseqModelParams & key).fetch1("model_params") + model_name = self._make_model_name(key) # set up the project and config project_dir, video_dir = moseq_project_dir, moseq_video_dir + project_dir = os.path.join(project_dir, model_name) + video_dir = os.path.join(video_dir, model_name) + # os.makedirs(project_dir, exist_ok=True) + os.makedirs(video_dir, exist_ok=True) # make symlinks to the videos in a single directory video_paths = (PoseGroup & key).fetch_video_paths() for video in video_paths: @@ -149,7 +154,6 @@ def make(self, key): data, metadata = kpms.format_data(coordinates, confidences, **config) # either initialize a new model or load an existing one - model_name = self._make_model_name(key) initial_model_key = model_params.get("initial_model", None) if initial_model_key is None: model, model_name = self._initialize_model( From efeaf0dd48b56bf4e23a8b9759f948decb5c9600 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Mon, 27 Jan 2025 15:18:19 -0800 Subject: [PATCH 39/42] add default empty restriction --- src/spyglass/behavior/v1/moseq.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/spyglass/behavior/v1/moseq.py b/src/spyglass/behavior/v1/moseq.py index 35c7cba62..ca4732a23 100644 --- a/src/spyglass/behavior/v1/moseq.py +++ b/src/spyglass/behavior/v1/moseq.py @@ -251,7 +251,7 @@ def _initialize_model( model_name=model_name + "_ar", ) - def analyze_pca(self, key: dict, explained_variace: float = 0.9): + def analyze_pca(self, key: dict = dict(), explained_variace: float = 0.9): """Method to analyze the PCA of a model Parameters From 27640cb6aa48e89f12bb76036e7f168b0471f9bf Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Mon, 27 Jan 2025 15:21:12 -0800 Subject: [PATCH 40/42] add moseq to omitted tests --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index adf76af6c..cb31fa3ef 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -188,6 +188,7 @@ omit = [ # which submodules have no tests # "*/spikesorting/*", # "*/utils/*", "settings.py", + "*/moseq/*", ] [tool.ruff] # CB: Propose replacing flake8 with ruff to delete setup.cfg From 0d92d5a2099c7736c0e8b223d2990c347aab2501 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Mon, 27 Jan 2025 15:32:47 -0800 Subject: [PATCH 41/42] tutorial error cleanup --- notebooks/60_MoSeq.ipynb | 1084 ++++++++++++++++-------------- notebooks/py_scripts/60_MoSeq.py | 11 +- 2 files changed, 604 insertions(+), 491 deletions(-) diff --git a/notebooks/60_MoSeq.ipynb b/notebooks/60_MoSeq.ipynb index 8b458b7f9..db043bda5 100644 --- a/notebooks/60_MoSeq.ipynb +++ b/notebooks/60_MoSeq.ipynb @@ -482,8 +482,8 @@ } ], "source": [ - "# %load_ext autoreload\n", - "# %autoreload 2\n", + "%load_ext autoreload\n", + "%autoreload 2\n", "from spyglass.position.position_merge import PositionOutput\n", "\n", "# Key defining the DLC data we are using\n", @@ -524,7 +524,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/sambray/Documents/spyglass/src/spyglass/behavior/core.py:50: UserWarning: Pose group tutorial_group already exists. Skipping insertion.\n", + "/home/sambray/Documents/spyglass/src/spyglass/behavior/v1/core.py:50: UserWarning: Pose group tutorial_group already exists. Skipping insertion.\n", " warnings.warn(\n" ] }, @@ -613,7 +613,7 @@ } ], "source": [ - "from spyglass.behavior.core import PoseGroup\n", + "from spyglass.behavior.v1.core import PoseGroup\n", "\n", "# Define the group name and bodyparts to include in the Moseq model\n", "group_name = \"tutorial_group\"\n", @@ -725,41 +725,28 @@ "

model_params

\n", " \n", " \n", - " sb_testing_kappa-4\n", - "=BLOB=sb_testing_kappa0_mini\n", - "=BLOB=sb_testing_kappa4_mini\n", - "=BLOB=sb_testing_kappa4_mini_20241220\n", - "=BLOB=sb_testing_model_sweep_kappa0_mini\n", - "=BLOB=sb_testing_model_sweep_kappa1_mini\n", - "=BLOB=sb_testing_model_sweep_kappa2_mini\n", - "=BLOB=sb_testing_model_sweep_kappa3_mini\n", - "=BLOB=sb_testing_model_sweep_kappa4_mini\n", - "=BLOB=sb_testing_model_sweep_kappa5_mini\n", - "=BLOB=sb_testing_model_sweep_kappa6_mini\n", - "=BLOB=sb_testing_model_sweep_kappa7_mini\n", + " tutorial_grouptutorial_kappa4_mini_extension001\n", + "=BLOB=tutorial_kappa4_mini\n", + "=BLOB=tutorial_kappa5_mini\n", + "=BLOB=tutorial_kappa6_mini\n", + "=BLOB=tutorial_kappa7_mini\n", + "=BLOB=tutorial_kappa8_mini\n", "=BLOB= \n", " \n", - "

...

\n", - "

Total: 16

\n", + " \n", + "

Total: 6

\n", " " ], "text/plain": [ "*model_params_ model_para\n", "+------------+ +--------+\n", - "sb_testing_kap =BLOB= \n", - "sb_testing_kap =BLOB= \n", - "sb_testing_kap =BLOB= \n", - "sb_testing_kap =BLOB= \n", - "sb_testing_mod =BLOB= \n", - "sb_testing_mod =BLOB= \n", - "sb_testing_mod =BLOB= \n", - "sb_testing_mod =BLOB= \n", - "sb_testing_mod =BLOB= \n", - "sb_testing_mod =BLOB= \n", - "sb_testing_mod =BLOB= \n", - "sb_testing_mod =BLOB= \n", - " ...\n", - " (Total: 16)" + "tutorial_group =BLOB= \n", + "tutorial_kappa =BLOB= \n", + "tutorial_kappa =BLOB= \n", + "tutorial_kappa =BLOB= \n", + "tutorial_kappa =BLOB= \n", + "tutorial_kappa =BLOB= \n", + " (Total: 6)" ] }, "execution_count": 5, @@ -768,7 +755,7 @@ } ], "source": [ - "from spyglass.behavior.moseq import (\n", + "from spyglass.behavior.v1.moseq import (\n", " MoseqModel,\n", " MoseqModelParams,\n", " MoseqModelSelection,\n", @@ -881,20 +868,18 @@ "

model_params_name

\n", " \n", " \n", - " sb_test_group\n", - "sb_testing_kappa4_mini_20241220tutorial_group\n", + " tutorial_group\n", "tutorial_kappa4_mini \n", " \n", " \n", - "

Total: 2

\n", + "

Total: 1

\n", " " ], "text/plain": [ "*pose_group_na *model_params_\n", "+------------+ +------------+\n", - "sb_test_group sb_testing_kap\n", "tutorial_group tutorial_kappa\n", - " (Total: 2)" + " (Total: 1)" ] }, "execution_count": 6, @@ -925,29 +910,27 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", - "exists. Use `overwrite=True` or pick a different name\n", - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/d9bb\n", - "baed42eca56d999882d9f65a62b8_ar\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/d9bbbaed42eca56d99\n", + "9882d9f65a62b8/d9bbbaed42eca56d999882d9f65a62b8_ar\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [00:55<00:52, 2.03s/it]" + " 49%|█████████████████▏ | 25/51 [00:38<00:33, 1.27s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -959,12 +942,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [01:48<00:02, 2.05s/it]" + " 98%|██████████████████████████████████▎| 50/51 [01:14<00:01, 1.27s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -976,27 +959,27 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [01:51<00:00, 2.19s/it]\n" + "100%|███████████████████████████████████| 51/51 [01:16<00:00, 1.50s/it]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/d9bb\n", - "baed42eca56d999882d9f65a62b8_ar\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/d9bbbaed42eca56d99\n", + "9882d9f65a62b8/d9bbbaed42eca56d999882d9f65a62b8_ar\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [04:20<02:56, 6.78s/it]" + " 49%|█████████████████▏ | 25/51 [00:56<00:34, 1.32s/it]" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAD6CAYAAABwKvR6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACReUlEQVR4nOzdd1gURx8H8O8dvTeliQJ2ULEXQAV770Zj7CWxd2MssaDGXhOjJrF3TeyxF8SGsXdjjBHRCKKogKhImfcP39u43B0cRU7g+3mee/RmZ2d/O7uzuzfsziqEEAJEREREREREREQ5SKnvAIiIiIiIiIiIKP9hpxQREREREREREeU4dkoREREREREREVGOY6cUERERERERERHlOHZKERERERERERFRjmOnFBERERERERER5Th2ShERERERERERUY5jpxQREREREREREeU4dkoREREREREREVGOY6cUEVEuNnnyZCgUClnau3fvMHHiRHh6esLY2Bju7u4YO3Ys3rx5I8u3evVqKBQKXLhwId3lBAYGomzZsunmCwsLg0KhwNy5czO2Ih+ZQqHA5MmTtU5fvnw5FAoFLC0tZenJycmYP38+GjduDDc3N5ibm8PLywtjxozBy5cvP27QOlJtR02fyMhItfzx8fGYOHEiSpYsCRMTEzg4OKBOnTq4e/euzssKCwuT0oQQ+P7771G6dGmYmJjAxcUF/fv3x4sXL9Tmj4iIQI8ePeDo6AhTU1P4+PhgxYoVGpd18OBB+Pv7w8zMDDY2NmjRogVu3rypli8hIQFz5sxB2bJlYWFhAScnJzRp0gRnzpxRy/v333+ja9euKFKkCMzMzFCsWDGMGDEC0dHRsnzLly9H69at4eHhATMzMxQvXhz9+/dHREREunUE/NcOVq9enal1ev78OT7//HM4OjpCoVCgdevW0rRnz55h6NCh8PDwgImJibS+z58/l/IcP35c6z5x9uxZndZBm127diEgIADW1tawsLBAmTJl8PPPP0vTY2Nj8d133yEwMBDOzs6wtLREuXLlMGvWLLx9+1ZWVkaOQQCwbds2+Pv7w97eHra2tqhWrRrWrVuXpfXJCZqOn9OnT8fOnTv1E5AOcaj2oePHj+d4TB4eHlr3X1NTU53y9uvXL8fjJiKizDHUdwBERJS9OnXqhH379mHixImoWrUqQkNDMW3aNNy8eRO7d+/Wd3ifnH///RejRo2Cq6srYmJiZNPevHmDyZMno1OnTujTpw8KFCiAS5cuYdq0adizZw8uXLgAMzMzPUUut2rVKpQuXVqW5uDgIPv+6tUr1KlTB48fP8aYMWPg4+ODmJgYnDlzBq9fv87UckeNGoWFCxdi1KhRqF+/Pm7duoWJEyfi/PnzCA0NhZGREQAgJiYGNWvWxLt37zB79my4uLhg06ZN6NOnD2JiYjBixAipzF27dqFNmzZo1aoVtm3bhpiYGAQFBaFWrVo4f/48ihUrJuX98ssvsWHDBowdOxZ169bF8+fPMXPmTAQEBOD06dOoVq0aAODp06eoUaMGrK2tMXXqVBQpUgSXL1/GpEmTEBwcjIsXL0KpfP+3ukmTJqFOnTqYPn06ChUqhDt37mDq1KnYtWsXLl++DCcnpwzXU0bWaerUqdixYwdWrlyJYsWKwd7eHgDw+PFj1KpVC4aGhpgwYQJKlCiBZ8+eITg4GO/evVNb5vTp01GnTh1Zmi6dy9rMnDkT48ePR79+/TB27FgYGRnhzz//lC07PDwcCxcuRNeuXTFixAhYWlri5MmTmDx5Mg4fPozDhw+rdaTrYuXKlejduzfatWuHb7/9FgqFAmvWrEG3bt3w7NkzDB8+PNPrpQ/Tp09H+/btZR2On1IclSpVQmhoKLy9vXM8ph07diAhIUGWFh4ejo4dO6JNmzZq+f39/dX+EJKZNkpERHoiiIgo15o0aZL48FAeGhoqAIh58+bJ8k2fPl0AEIcOHZLSVq1aJQCI8+fPp7ucgIAAUaZMmXTz3b9/XwAQc+bMycBafHwAxKRJkzROa968uWjRooXo3r27sLCwkE1LSkoSz549U5vn119/FQDEunXrPka4GZKR7Th06FBhYWEh7t27l6Vl3b9/XwghxKNHj4SBgYEYPHiwLN/GjRsFAPHzzz9LaTNmzBAAxIULF2R5GzZsKCwsLMSLFy+ktFKlSgkfHx+RkpIipYWFhQljY2PxxRdfSGlv374VBgYGokuXLrIyHz9+LACIIUOGSGm//PKLACCOHDkiy6tqG5cuXZLSnjx5orbu58+fFwDE1KlTtVWPRNUOVq1aleF1EkKI+vXrCy8vL7VyW7VqJQoVKiSeP3+e5vKDg4MFAPHrr7+mG6uuLly4IJRKpZg1a1aa+V69eiVevXqllj5nzhwBQJw8eVJKy8i+6+/vL9zd3UVycrKUlpKSIkqXLi18fHwysCZZEx8fn+F5NB0/LSwsRPfu3bMpqveSkpLE27dvMzTPx4jjY5g8ebLG9uvu7i6aNWump6iIiCg78PE9IqJcYu/evahQoQJMTEzg6emp8RG506dPAwCaNm0qS2/evDmA94+/pPbixQv07NkT9vb2sLCwQIsWLfDPP/9ojOHkyZOoUaMGzMzMUKhQIUyYMAHJyclq+VJSUvDdd9+hSJEiMDU1RZUqVXD06FFZnr///hs9e/ZEiRIlYG5ujkKFCqFFixa4fv26WnmxsbEYNWqU9EhioUKFMGzYMMTHx6vl+/LLL+Hg4ABLS0s0btwYf/31l8Z1AYD169cjJCQES5Ys0TjdwMBA7W4jANLdNw8fPsxUnCkpKfjhhx9QoUIFmJmZwdbWFjVq1JDdybZlyxY0bNgQLi4uMDMzkx4bTF2Wrl6/fo3ly5fjs88+Q9GiRdPNf/bsWfj7+8PU1BSurq4YO3YsEhMT1fIkJyfrtL+dPn0aTk5OqFy5slre+Ph4HDhwAAAQHR2NO3fuoEmTJrI7atzd3VG2bFns3LlT2ueUSiWUSiVsbGxkZVpbW0OpVMoe9VHdsZU6r62tLQDI8jo6OqrVR+XKlWFgYKC2zR8/fowOHTrAysoKNjY26Nixo9pjk7quk+qxvyNHjuD27dvSo0jHjx9HWFgYdu/ejS+//BJ2dnZq8WWWrvvZ4sWLYWJigsGDB6dZnoWFBSwsLNTStbUZQLdjkJGRESwtLaW72YD3j+VaW1urPdKVnsOHD6NVq1Zwc3ODqakpihcvjr59++LZs2eyfKrHoy9duoT27dvDzs5OdkdbZikUCsTHx2PNmjXSNg4MDJSmR0ZGom/fvnBzc4OxsTE8PT0RFBSEpKQkKY9qX5k9ezamTZsGT09PmJiYIDg4GG/fvsXIkSNRoUIF2NjYwN7eHr6+vti1a5fOcWh7fG/37t3w9fWFubk5rKys0KBBA4SGhmqst5s3b6JTp06wsbGBk5MTevXqpXY3qi6EEFi1ahWKFi2KunXrZnh+IiL6tLFTiogoFzh69ChatWoFKysrbN68GXPmzMHWrVuxatUqWT7VYzQmJiaydNX3a9euqZXdu3dvKJVKbNy4EQsXLsS5c+cQGBioNmZSZGQkPv/8c3Tu3Bm7du1C+/btMW3aNAwdOlStzMWLF+PAgQNYuHAh1q9fD6VSiSZNmsh+vDx+/BgODg6YOXMmDhw4gB9//BGGhoaoXr067ty5I+V7/fo1AgICsGbNGgwZMgT79+/HN998g9WrV6Nly5YQQgB4/8OldevWWLduHUaOHIkdO3agRo0aaNKkicY6jYqKwrBhwzBz5ky4ublpq3qNjh07BgAoU6ZMhuMEgB49emDo0KGoWrUqtmzZgs2bN6Nly5aysZru3r2Lpk2bYsWKFThw4ACGDRuGrVu3okWLFhpjat68OQwMDGBvb4+2bdvixo0bsukXL15EfHw8SpQogf79+8POzg7GxsaoUqUK9u7dK8t769Yt1KtXDy9fvsTq1auxbNkyXL58GdOmTZPl07a/GRkZQaFQyPa3d+/eqeX7cF5VXm1lqtJev36Ne/fuScsZMGAA1qxZg507dyI2NhZhYWH48ssvYWNjgy+//FKat3Xr1ihSpAhGjhyJmzdv4tWrVzhx4gRmzpyJFi1awMvLS2O9qoSEhCA5OVm2zd+8eYP69evj0KFDmDFjBn799Vc4OzujY8eOOtVT6nVycXFBaGgoKlasiKJFiyI0NBShoaGoVKkSTp48CSEEXF1d0alTJ1haWsLU1BSBgYFqnQIqAwcOhKGhIaytrdGoUSOcOnVKLY+u+9mJEyfg5eWFbdu2oVSpUjAwMICbmxvGjBmj8dHB1DS1GRVdjkGDBw/G7du38d133+Hp06d49uwZ5s6di4sXL2LUqFHpLv9D9+7dg6+vL5YuXYpDhw5h4sSJ+OOPP1CzZk21jlcAaNu2LYoXL45ff/0Vy5YtA/DfeFipxw3TRWhoKMzMzNC0aVNpG6s6xiMjI1GtWjUcPHgQEydOxP79+9G7d2/MmDFDtj+rfP/99zh27Bjmzp2L/fv3o3Tp0khISMDz588xatQo7Ny5E5s2bULNmjXRtm1brF27Vqc4NNm4cSNatWoFa2trbNq0CStWrMCLFy8QGBiocd9q164dSpYsiW3btmHMmDHYuHFjph6zPHLkCB48eIBevXppfPTzxIkTsLKygpGREby9vTFv3jyNfywhIqJPlF7v0yIiIp1Ur15duLq6ijdv3khpsbGxwt7eXvb43s6dOzU+VrZixQoBQJQsWVJKUz0606ZNG1ne06dPCwBi2rRpUlpAQIAAIHbt2iXL++WXXwqlUikePHgghPjvsSVtsdavX1/rOiYlJYl3796JEiVKiOHDh0vpM2bMEEqlUu0Rn99++00AEPv27RNCCLF//34BQCxatEiW77vvvtP4+F67du2En5+f9DiVpsf3NHn06JFwcnISVapUkT1KpGucJ06cEADE+PHj012WSkpKikhMTBQhISECgLh69ao0bf/+/WL8+PFiz549IiQkRCxevFi4ubkJCwsLceXKFSnfpk2bBABhbW0t/P39xe7du8Xvv/8u6tSpIxQKhThw4ICUt2PHjsLMzExERkZKaUlJSaJ06dKyx/euXLmi8ZG2o0ePCgDC2NhYShs2bJhsX1Hp2rWrACC++uorIYQQycnJwt7eXtSrV0+W78WLF8LKykoAEGfOnJHVzcSJE4VSqRQABABRpEgRcfnyZbV6fPz4sfD19ZXyARCfffZZuo88xcbGCi8vL1G4cGERFxcnpS9dulRru8AHj+9ldJ00Pe6levzR2tpatGrVShw4cEBs27ZN+Pj4CFNTU9k+cenSJTF06FCxY8cOceLECbFy5Urh5eUlDAwMZNs5tbT2MxMTE2FlZSXs7OzE4sWLxbFjx8T48eOFgYGB2uOHqV29elWYmZmpHWsycgwS4v3xzcbGRtp2ZmZmYv369WkuOz2qdX7w4IHatlQ9Hj1x4kS1+dasWSMMDAzEmjVr0l1GRh7f69u3r7C0tFRrJ3PnzhUAxM2bN4UQ/x1rixUrJt69e5fm8pOSkkRiYqLo3bu3qFixok5xqB4BDQ4OFkK834ddXV1FuXLlZMe9uLg44ejoKPz8/KQ0Vb3Nnj1bVuaAAQOEqamp7BFWXXTs2FEYGBiIR48eqU0bMGCAWLlypQgJCRE7d+4UnTt3FgDUHuklIqJPFzuliIg+ca9evRJKpVIMGjRIbVr37t1lnVIJCQmiePHiwtXVVRw6dEi8ePFC7N+/Xzg5OQkDAwNRunRpKa/qB+Fvv/2mVq67u7vsB3RAQICwsrJSy6f64aLqBFP9UNIWq7GxsUhKShJCCJGYmCi+++474eXlJYyMjGQdBY0bN5bm8/f3Fz4+PiIxMVH2iYuLEwqFQowePVoIIcTo0aMFALUxoFQxfdgp9dtvvwljY2PpB54qvvQ6paKjo4WPj49wdHRUG5dJ1zjHjh0rAIjHjx+nuax79+6JTp06CScnJ6FQKGT1s3nz5jTnvX//vrC0tBQtW7aU0jZs2CAAiAIFCojY2FgpPT4+Xri6ugp/f38pzdHRUTRv3lytXNWPTVWnlBBC1K5dW1hbW4utW7eKFy9eiNOnT4sSJUoIAwMDYWpqKuW7deuWMDExETVr1hQ3btwQz549E4sXLxbGxsYCgOjXr5+Ud8KECQKAmDJlinjy5Im4e/euaNasmTAwMBAAxNmzZ6W8U6dOFebm5mLKlCkiODhY7Nq1SzRo0EAUKFBANk7U8+fPRdWqVUWZMmXEhg0bxIkTJ8SSJUuEi4uLaNiwoUhMTNRYl2/evBH169cX5ubmsuUKIUSHDh3SbBcfjimVkXXS1Imh6lz19vaW2pAQ7zvazM3NRefOnTXGr/LixQvh5uamNv6SrvuZqo1u2rRJNv+wYcMEAHH37l2Ny71//74oXLiwKFmypIiOjpZNy8gxaP/+/cLS0lL07NlT7N+/Xxw+fFgMHjxYGBoaipUrV6a57qk9efJE9O3bV7i5uck6MwGImTNnSvlU+/uHnXOZkZFOqUKFCokWLVqoHUdu3rwpAIglS5YIIf47rn3Ygf+hrVu3Cj8/P2FhYSFbvw/bZFpxpO6UunXrlsaOJiGE6N+/v1AqldJ4W6p6+/PPP2X5li1bJgDIOrvTEx0dLUxMTDI0btSgQYPUxokjIqJPFx/fIyL6xL148QIpKSlwdnZWm5Y6zdjYGPv370eRIkXQsGFD2NnZoX379hg3bhzs7OxQqFChdMtQpUVHR8vSNL3NSDVv6rzaynz37h1evXoFABgxYgQmTJiA1q1bY8+ePfjjjz9w/vx5lC9fHm/evJHme/LkCa5duwYjIyPZx8rKCkIIaRyY6OhoGBoaqo0BlTqWV69eYeDAgRg8eDBcXV3x8uVLvHz5UnoE6eXLlxrHbXrx4gUaNGiAf//9F4cPH1Ybl0nXOJ8+fQoDAwONdfRhjLVq1cIff/yBadOm4fjx4zh//jy2b98OALL60cTDwwM1a9bE2bNnpTRVvfj5+cHKykpKNzc3R0BAAC5duiSlRUdH67S/AcCvv/4Kf39/dOjQAXZ2dqhTpw7atm2LChUqyPY3Ly8v7NixAw8ePEDZsmVRoEABzJo1C/PmzQMAWd6JEydi+PDhmDZtGpycnFCiRAkAQM+ePWV5b9++jYkTJyIoKAgTJkxAYGAgWrZsib1798LW1lb2Rr9Zs2bhypUrOHz4ML744gvUqlUL/fv3x4YNG3Do0CFs2LBBbd0SEhLQpk0bnDp1Crt370b16tVl06Ojo9NsFx/SdZ20UW2/+vXrw8DAQEp3cXFB+fLlZdtPE1tbWzRv3hzXrl2T9p+M7Geq5Tdq1EhWrurxWE3Lf/DgAerUqQNDQ0McPXpUeotgaukdg4QQ6NWrF2rXro2VK1eicePGqF+/Pr7//nt88cUXGDx4sM5jraWkpKBhw4bYvn07Ro8ejaNHj+LcuXNSW9HUtlxcXHQqOzs8efIEe/bsUTuOqB57TD3ulabYtm/fjg4dOqBQoUJYv349QkNDcf78efTq1Qtv377NVFyqbaFpea6urkhJScGLFy9k6amPxarHV9M7fn1o/fr1SEhIQJ8+fXSep0uXLgAgO/4REdGny1DfARARUdrs7OygUCjUBk8GoDGtePHiCA0Nxb///ovnz5+jWLFiiImJwdChQ1G7dm2dyoiMjETx4sVlaU+ePNE6b+ofH9rKNDY2hqWlJYD3Pza6deuG6dOny/I9e/ZMGnwaAAoUKAAzMzOsXLlSrUzVdFUMSUlJiI6OlsWTOpZnz57hyZMnmDdvntQh8iE7Ozu0atUKO3fulNJevHiB+vXr4/79+zh69Ch8fHw0xqFLnAULFkRycjIiIyO1/tg9duwYHj9+jOPHjyMgIEBKTz3OV1qEELJBoTXFrC2vg4ODzvubo6Mj9u3bh6ioKERGRsLd3R1mZmZYsmQJ2rdvL8vbpEkTPHjwAH///TeSkpJQsmRJbN26FQBk+6ahoSHmz5+PKVOm4P79+yhQoABcXFzQqFEjeHp6SmOAXb16FUIIVK1aVbYcIyMjlC9fHiEhIVLalStXUKhQIbU6V82begyuhIQEtG7dGsHBwdi1axfq1auntu4ODg44d+6cTvWk6zppk5Htl1Y+ANK4PBnZz3x8fDSul6rM1Mt/8OABAgMDIYTA8ePH01y/9I5BT548QUREBPr27auWr2rVqli7di3CwsI0jleV2o0bN3D16lWsXr0a3bt3l9L//vtvrfNoGsfoYylQoAB8fHzw3XffaZzu6uoq+64ptvXr18PT0xNbtmyRTU9ISMh0XKpjakREhNq0x48fQ6lUZusA/CorVqyAk5OT9PIEXWjbJ4mI6NPEozUR0SfOwsIC1apVw/bt22V/5Y6Li8OePXu0zleoUCGUK1cO5ubmmDNnDiwsLNC7d2+1fKnvEDlz5oz0g/JDcXFxsrfDAe8HvlUqlWqdXdpirVWrlnSXh0KhUBv4ee/evfj3339lac2bN8e9e/fg4OCAKlWqqH08PDwAAHXq1NG4Phs3bpR9d3Z2RnBwsNqnUaNGMDU1RXBwsGxAb1WH1D///INDhw6hYsWKanWYkThVd5YsXbpUYzmqugHUB8b+6aeftM7zofv37+P06dOoUaOGlObi4gJfX1+cPn0asbGxUvrr168REhIiy1unTh0cPXpU1hGZnJyMLVu2aF2mo6MjfHx8YGNjg2XLliE+Ph6DBg3SuG4lSpSAl5cXkpOTsWjRIlSoUEFjh6mlpSXKlSsHFxcXXLp0CUePHpUNrK/6gZ76joiEhARcunRJ1hHi6uqKR48eqe1fqkHCP8yrukPq2LFj2LZtm9rdQR/Wk7Z2oU1666RN9erV4ebmhkOHDskGcX78+DGuXr0q236avHjxAr///jsqVKggva0uI/tZu3btAAD79++Xpe/btw9KpVLWMRgeHo7AwEAkJyfj2LFjcHd3TzO29I5BdnZ2MDU11XjnS2hoKJRKpc53M2W1bWUXExMTjXcMNW/eHDdu3ECxYsU0HkdSd0ppolAoYGxsLOuQioyMVHv7XlpxpFaqVCkUKlQIGzdulL20IT4+Htu2bZPeyJedLly4gGvXrqF79+4wNNT97+iqwdzTaxNERPRp4J1SRES5wNSpU9G4cWM0aNAAI0eORHJyMmbNmgULCws8f/5clnf27NlwdnZGkSJF8OTJE2zduhU7d+7EunXrND4idOHCBfTp0wefffYZHj58iPHjx6NQoUIYMGCALJ+DgwP69++P8PBwlCxZEvv27cMvv/yC/v37o0iRIrK8BgYGaNCgAUaMGIGUlBTMmjULsbGxCAoKkvI0b94cq1evRunSpeHj44OLFy9izpw5andUDBs2DNu2bUPt2rUxfPhw+Pj4ICUlBeHh4Th06BBGjhyJ6tWro2HDhqhduzZGjx6N+Ph4VKlSBadPn8a6detk5aneWJba6tWrYWBgIJv25s0bNGrUCJcvX8bChQuRlJQk+2FcsGBB6RXxusZZq1YtdO3aFdOmTcOTJ0/QvHlzmJiY4PLlyzA3N8fgwYPh5+cHOzs79OvXD5MmTYKRkRE2bNiAq1evqsVdv3591K5dGz4+PrC2tsb169cxe/ZsKBQKTJ06VZZ37ty5qFOnDho1aoRvvvkGCoUC8+bNw7Nnz2R5v/32W+zevRt169bFxIkTYW5ujh9//FHjI1K//PILAKBYsWJ4+fIl9u/fjxUrVmD69OmoVKmSLO/gwYMRGBgIBwcH/PPPP/j+++/x6NEj2R1NAKTHyHx8fCCEwLlz5zBr1iw0btxY1tFVs2ZNVK1aFZMnT8br169Ru3ZtxMTE4IcffsD9+/dl237gwIHYsGEDGjRogDFjxqBw4cK4ceOG9Dhd586dpbzt27fH/v37MX78eDg4OMi2ubW1Nby9vQEA3bp1w4IFC9CtWzd89913KFGiBPbt24eDBw+q1ZOu66SNUqnEggUL0KFDB7Rq1Qr9+/dHfHw8pk6dCmNjY4wdO1bK+8UXX6BIkSKoUqUKChQogLt372LevHl48uSJ7G1xGdnPevbsiZ9++gkDBgzAs2fP4O3tjSNHjuDHH3/EgAEDpI6nqKgo1KlTBxEREVixYgWioqIQFRUllePm5qbWxtM7BpmYmGDAgAGYP38+unXrho4dO8LAwAA7d+7Exo0b0bt3b62PBqZWunRpFCtWDGPGjIEQAvb29tizZw8OHz6s0/wqa9euRa9evbBy5Up069YtQ/MCQLly5XD8+HHs2bMHLi4usLKyQqlSpTBlyhQcPnwYfn5+GDJkCEqVKoW3b98iLCwM+/btw7Jly9K9q6558+bYvn07BgwYgPbt2+Phw4eYOnUqXFxccPfuXZ3iSE2pVGL27Nno3Lkzmjdvjr59+yIhIQFz5szBy5cvMXPmzAzXQXpWrFgBABr/mAK87/zdvn07mjVrBnd3d7x8+RK//vorNm/ejB49eqB8+fLZHhMREX0EehjHioiIMmH37t3Cx8dHGBsbiyJFioiZM2dKA8p+KCgoSBQrVkyYmJgIW1tb0bhxY3HixAm18lSDDB86dEh07dpV2NraCjMzM9G0aVO1QYtVA/UeP35cVKlSRZiYmAgXFxcxbtw42QDRqsF3Z82aJYKCgoSbm5swNjYWFStWFAcPHpSV+eLFC9G7d2/h6OgozM3NRc2aNcXJkydFQECACAgIkOV99eqV+Pbbb0WpUqWEsbGxsLGxEeXKlRPDhw+XDZr78uVL0atXL2FrayvMzc1FgwYNxJ9//qnx7XupaRroXLU+2j6pBwjWNc7k5GSxYMECUbZsWSmfr6+v2LNnj5TnzJkzwtfXV5ibm4uCBQuKPn36iEuXLqkNoD1s2DDh7e0trKyshKGhoXB1dRVdunQRd+7c0bieqjo2NzcX5ubmom7duuL06dNq+U6fPi1q1KghTExMhLOzs/j666/Fzz//rDbQ+U8//SS8vLyEubm5sLS0FLVq1RI7d+7UuOxWrVoJFxcXYWRkJJydnUWPHj1EWFiYxmVXr15dWFtbCxMTE1G2bFkxd+5cjW8Ze/nypRg/frwUg6OjowgMDJTedvihS5cuiTZt2gg3NzdhYmIiihYtKvr06SPCw8Nl+dLa5qn3zUePHol27doJS0tLYWVlJdq1ayfOnDmjtp0ysk6aBsZW2blzp6hataowNTUVNjY2omXLlrIB+4V4/6a+ChUqCBsbG2FgYCAKFiwo2rRpI86dO6dWnq77mRDvB53u27evcHJyEkZGRqJkyZJizpw5srexqQbI1vb5sB1m5BiUnJwsfvnlF1GlShVha2srrK2tRcWKFcXixYvTfftcardu3RINGjSQ3ib42WefifDwcLX4VMfXp0+fqpWhij11HWmiaXteuXJF+Pv7C3Nzc7X96unTp2LIkCHC09NTGBkZCXt7e1G5cmUxfvx48erVKyHEf8emOXPmaFzmzJkzhYeHhzAxMRFeXl7il19+0Xi+0BZH6oHOVXbu3CmqV68uTE1NhYWFhahXr57a8UNbvanq7MPjhzavX78WNjY2onbt2lrzhIaGinr16glnZ2dhZGQkzM3NRdWqVcWSJUtk+yQREX3aFEJ8cA8uERERERERERFRDuCYUkRERERERERElOM4phQRERER5XrJyclI6wEAhUIhvWiBiIiIPg28U4qIiIiIcr169erByMhI60f1UgIiIiL6dHBMKSIiIiLK9e7cuYO4uDit001MTFCuXLkcjIiIiIjSw04pIiIiIiIiIiLKcXx8j4iIiIiIiIiIchw7pYiIiIiIiIiIKMexU4qIiIiIiIiIiHIcO6WIiIiIiIiIiCjHsVOKiIiIiIiIiIhyHDuliIiIiIiIiIgox7FTioiIiIiIiIiIchw7pYiIiIiIiIiIKMexU4qIiIiIiIiIiHIcO6WIiIiIiIiIiCjHsVOKiIiIiIiIiIhyHDuliIiIiIiIiIgox7FTioiIiIiIiIiIchw7pYiIiIiIiIiIKMexU4qIiIiIiIiIiHIcO6WIiIiIiIiIiCjHsVOKiIiIiIiIiIhyHDuliIiIiIiIiIgox7FTioiIiIiIiIiIchw7pYiIiIiIiIiIKMexU4qIiIiIiIiIiHIcO6WIiIiIiIiIiCjHsVOKiIiIiIiIiIhyXLZ1Sq1evRoKhULjZ9SoUdm1GErD5MmToVAoZGkeHh7o0aNHhso5c+YMJk+ejJcvX2ZovtTLOn78OBQKBX777bcMlZOW169fY/LkyTh+/LjaNNU+GBYWlm3Ly81St0lTU1M4OzujTp06mDFjBqKiovQdIqZPn46dO3eqpav2HU3bWV8CAwMRGBgofQ8LC4NCocDq1aszVM7GjRuxcOHCDM2jaVmq9v7s2bMMlZWWW7duYfLkyRrbUI8ePeDh4ZFty6L0fdiGNbUFIQSKFy8OhUIh2zezg7bj+afUJvW9T6Z1rkx9vCCi3O+PP/5AmzZtUKRIEZiYmMDJyQm+vr4YOXKkLN+SJUsyfG2QmrbrI/r0ZOR6LCd/lxHlJobZXeCqVatQunRpWZqrq2t2L4Z0tGPHDlhbW2donjNnziAoKAg9evSAra3tR11WRr1+/RpBQUEAoHbB36xZM4SGhsLFxeWjxpDbqNpkYmIioqKicOrUKcyaNQtz587Fli1bUL9+fb3FNn36dLRv3x6tW7eWpVeqVAmhoaHw9vbWT2A6cHFxQWhoKIoVK5ah+TZu3IgbN25g2LBhH31ZGXXr1i0EBQUhMDBQ7cf+hAkTMHTo0I+6fNLMysoKK1asUDvmhYSE4N69e7CysvroMeSGNpnT0jpXLlmyRD9BEdFHsXfvXrRs2RKBgYGYPXs2XFxcEBERgQsXLmDz5s2YN2+elHfJkiUoUKBAhjsfPqTt+ohyt5z8XUaUm2R7p1TZsmVRpUoVnfImJiZCoVDA0DDbw6D/q1ix4kdfxps3b2BmZpYjy0pLwYIFUbBgQb3G8ClK3SbbtWuH4cOHo2bNmmjbti3u3r0LJyenLC8nOTkZSUlJMDExyXJZ1tbWqFGjRpbL+ZhMTEw+eowf1qm+6+Njd4iRdh07dsSGDRvw448/yi5mV6xYAV9fX8TGxn70GHJDm8yq169fw9zcPFvKYucdUd4ye/ZseHp64uDBg7LfLZ9//jlmz56tx8goN9H3b6UPZec5jyircmxMKdWt/+vWrcPIkSNRqFAhmJiY4O+//wYAHDlyBPXq1YO1tTXMzc3h7++Po0ePqpWzd+9eVKhQASYmJvD09MTcuXPVHltL67EahUKByZMny9Lu3r2LL774Ao6OjjAxMYGXlxd+/PFHjfFv2rQJ48ePh6urK6ytrVG/fn3cuXNHbTkHDhxAvXr1YGNjA3Nzc3h5eWHGjBkAgHXr1kGhUCA0NFRtvilTpsDIyAiPHz9Osz411YMmqW8TTUlJwbRp01CqVCmYmZnB1tYWPj4+WLRoEYD3t6B+/fXXAABPT0+1R0c8PDzQvHlzbN++HRUrVoSpqal055K2W1Lfvn2LESNGwNnZGWZmZggICMDly5dlebQ96vDh4xlhYWFSp1NQUJAUm2qZ2h7fW7lyJcqXLw9TU1PY29ujTZs2uH37ttpyLC0t8ffff6Np06awtLRE4cKFMXLkSCQkJGis29ysSJEimDdvHuLi4vDTTz9J6bpsB+C/NjZ79mxMmzYNnp6eMDExQXBwMN6+fYuRI0eiQoUKsLGxgb29PXx9fbFr1y5ZmQqFAvHx8VizZo20LVXL1vao0O7du+Hr6wtzc3NYWVmhQYMGau1IdTy4efMmOnXqBBsbGzg5OaFXr16IiYlJt26EEJg9ezbc3d1hamqKSpUqYf/+/Wr5NB1nnj59iq+++gqFCxeGiYkJChYsCH9/fxw5ckSq37179+LBgweyRyvTq9O0jmkPHz5E27ZtYW1tDRsbG3Tp0gVPnz5Vq+vUxz1A3mZXr16Nzz77DABQp04dKTbVMjU9KvX27VuMHTsWnp6eMDY2RqFChTBw4EC1W8xVx40DBw6gUqVKMDMzQ+nSpbFy5UotW4E+1KlTJwDApk2bpLSYmBhs27YNvXr10jjPu3fvMG3aNJQuXVraF3v27Km2byQmJmL06NFwdnaGubk5atasiXPnzqmVp6lNXrhwAZ9//jk8PDxgZmYGDw8PdOrUCQ8ePJDNqzo2BwcHo3///ihQoAAcHBzQtm3bdM91H5ZRqlQp6Ry9du1anWIENLdV1TH/+vXraNiwIaysrFCvXj0AwOHDh9GqVSu4ubnB1NQUxYsXR9++fWWPZqR3rtR0LH3+/DkGDBiAQoUKwdjYGEWLFsX48ePVzjEKhQKDBg3CunXr4OXlBXNzc5QvXx6///67TnVFRNkvOjoaBQoU0PiHdKXyv59THh4euHnzJkJCQqTjgurcmR3XRwAQGRmJvn37ws3NDcbGxvD09ERQUBCSkpLSXY9jx44hMDAQDg4OMDMzQ5EiRdCuXTu8fv1aypPV80fq3wOahhcBtF+3b9myBb6+vrCwsIClpSUaNWqk9rshI9ftCQkJmDJlCry8vGBqagoHBwfUqVMHZ86ckfIIIbBkyRJUqFABZmZmsLOzQ/v27fHPP/+kW6cqT548Sfe6M7t/l6WkpGD27NnStnJ0dES3bt3w6NEj2XIDAwNRtmxZnDhxAn5+fjA3N0evXr3Qu3dv2Nvby7a/St26dVGmTBmd158oK7L9FiXVX/ZlC/ngAD527Fj4+vpi2bJlUCqVcHR0xPr169GtWze0atUKa9asgZGREX766Sc0atQIBw8elC4Ujx49ilatWsHX1xebN29GcnIyZs+ejSdPnmQ63lu3bsHPz0/6ke7s7IyDBw9iyJAhePbsGSZNmiTLP27cOPj7+2P58uWIjY3FN998gxYtWuD27dswMDAA8P6v119++SUCAgKwbNkyODo64q+//sKNGzcAvP+r9+jRo/Hjjz/C19dXKjspKQk//fQT2rRpk+Yjj1mph9mzZ2Py5Mn49ttvUbt2bSQmJuLPP/+UfkT26dMHz58/xw8//IDt27dLj8J9+FffS5cu4fbt2/j222/h6ekJCwuLNJc5btw4VKpUCcuXL0dMTAwmT56MwMBAXL58GUWLFk03ZhUXFxccOHAAjRs3Ru/evdGnTx8ASPPuqBkzZmDcuHHo1KkTZsyYgejoaEyePBm+vr44f/48SpQoIeVNTExEy5Yt0bt3b4wcORInTpzA1KlTYWNjg4kTJ+ocZ27RtGlTGBgY4MSJE5ku4/vvv0fJkiUxd+5cWFtbo0SJEkhISMDz588xatQoFCpUCO/evcORI0fQtm1brFq1Ct26dQMAhIaGom7duqhTpw4mTJgAAGne0rxx40Z07twZDRs2xKZNm5CQkIDZs2cjMDAQR48eRc2aNWX527Vrh44dO6J37964fv06xo4dCwDpdoQEBQUhKCgIvXv3Rvv27fHw4UN8+eWXSE5ORqlSpdKct2vXrrh06RK+++47lCxZEi9fvsSlS5cQHR0N4P0t/V999RXu3buHHTt26FynaWnTpg06dOiAfv364ebNm5gwYQJu3bqFP/74A0ZGRmnO+6FmzZph+vTpGDduHH788UdUqlQJgPY7pIQQaN26NY4ePYqxY8eiVq1auHbtGiZNmoTQ0FCEhobK7pq7evUqRo4ciTFjxsDJyQnLly9H7969Ubx4cdSuXVvnOPMja2trtG/fHitXrkTfvn0BvO+gUiqV6Nixo9oYZSkpKWjVqhVOnjyJ0aNHw8/PDw8ePMCkSZMQGBiICxcuwMzMDADw5ZdfYu3atRg1ahQaNGiAGzduoG3btoiLi0s3rrCwMJQqVQqff/457O3tERERgaVLl6Jq1aq4desWChQoIMvfp08fNGvWDBs3bsTDhw/x9ddfo0uXLjh27Fiay1m9ejV69uyJVq1aYd68edJ5JCEhQfZjMKPevXuHli1bom/fvhgzZox07XLv3j34+vqiT58+sLGxQVhYGObPn4+aNWvi+vXrMDIy0ulc+aG3b9+iTp06uHfvHoKCguDj44OTJ09ixowZuHLlCvbu3SvLv3fvXpw/fx5TpkyBpaUlZs+ejTZt2uDOnTsZOm8SUfbw9fXF8uXLMWTIEHTu3BmVKlXSeI7dsWMH2rdvDxsbG+kxXtW5MDuujyIjI1GtWjUolUpMnDgRxYoVQ2hoKKZNm4awsDCsWrVK6zqEhYWhWbNmqFWrFlauXAlbW1v8+++/OHDgAN69ewdzc/McO39oM336dHz77bfo2bMnvv32W7x79w5z5sxBrVq1cO7cOdkxVpfr9qSkJDRp0gQnT57EsGHDULduXSQlJeHs2bMIDw+Hn58fAKBv375YvXo1hgwZglmzZuH58+eYMmUK/Pz8cPXqVZ2eKMjMdWdWf5f1798fP//8MwYNGoTmzZsjLCwMEyZMwPHjx3Hp0iXZeTgiIgJdunTB6NGjMX36dCiVStja2mLlypXYuHGj9LsKeP/7ODg4WO0mDaKPRmSTVatWCQAaP4mJiSI4OFgAELVr15bNFx8fL+zt7UWLFi1k6cnJyaJ8+fKiWrVqUlr16tWFq6urePPmjZQWGxsr7O3txYercv/+fQFArFq1Si1OAGLSpEnS90aNGgk3NzcRExMjyzdo0CBhamoqnj9/LoQQUvxNmzaV5du6dasAIEJDQ4UQQsTFxQlra2tRs2ZNkZKSorW+Jk2aJIyNjcWTJ0+ktC1btggAIiQkROt8GakHIYRwd3cX3bt3l743b95cVKhQIc3y58yZIwCI+/fvq01zd3cXBgYG4s6dOxqnfbgsVZ1VqlRJVhdhYWHCyMhI9OnTR0oLCAgQAQEBamV2795duLu7S9+fPn2qtg1VVPugKu4XL14IMzMztW0WHh4uTExMxBdffCFbDgCxdetWWd6mTZuKUqVKqS0rN1DVx/nz57XmcXJyEl5eXtJ3XbeDqo0VK1ZMvHv3Ls04kpKSRGJioujdu7eoWLGibJqFhYVsn1FR7TvBwcFCiPfHA1dXV1GuXDmRnJws5YuLixOOjo7Cz89PSps0aZIAIGbPni0rc8CAAcLU1DTNdvnixQthamoq2rRpI0s/ffq0ACCrG03HGUtLSzFs2DCt5QshRLNmzWR1mbo8TXWqaVmq9Rw+fLgs74YNGwQAsX79eilNW5tJ3WZ//fVXWb1/KPU+cODAAY31rDqO/fzzz7LlmJqaigcPHkhpb968Efb29qJv375qy6L3PmzDqjZx48YNIYQQVatWFT169BBCCFGmTBnZvrlp0yYBQGzbtk1W3vnz5wUAsWTJEiGEELdv305zH9J0PNe0b6gkJSWJV69eCQsLC7Fo0SK19RgwYIAs/+zZswUAERERobVMVdvXdh75cJ/UFqOm9qM65q9cuVLrsoUQIiUlRSQmJooHDx4IAGLXrl3StLTOlamPpcuWLdN4jpk1a5YAIA4dOiSlARBOTk4iNjZWSouMjBRKpVLMmDEjzXiJ6ON49uyZqFmzpvTbxsjISPj5+YkZM2aIuLg4Wd7Ux2RtMnN91LdvX2FpaSk7nwohxNy5cwUAcfPmTa3L++233wQAceXKFa15Psb5Q3W9klrq6/bw8HBhaGgoBg8eLMsXFxcnnJ2dRYcOHaQ0Xa/b165dKwCIX375Res6h4aGCgBi3rx5svSHDx8KMzMzMXr0aK3zfrh+ulx3ZufvMtU2SH1u/eOPPwQAMW7cOCktICBAABBHjx5VKz8gIEAthv79+wtra2u1fZvoY8n2x/fWrl2L8+fPyz4f3inVrl07Wf4zZ87g+fPn6N69O5KSkqRPSkoKGjdujPPnzyM+Ph7x8fE4f/482rZtC1NTU2l+KysrtGjRIlOxvn37FkePHkWbNm1gbm4uW37Tpk3x9u1bnD17VjZPy5YtZd99fHwAQHpc4cyZM4iNjcWAAQM03qqq0r9/fwDAL7/8IqUtXrwY5cqVS/OugazWQ7Vq1XD16lUMGDAABw8ezNRYJD4+PihZsqTO+b/44gtZXbi7u8PPzw/BwcEZXnZGhIaG4s2bN2qPFBYuXBh169ZVezxUoVCo1aGPj4/aoyh5iRAiS/O3bNlS418Kf/31V/j7+8PS0hKGhoYwMjLCihUr1B6b1NWdO3fw+PFjdO3aVXZnhKWlJdq1a4ezZ8+q3Xqsqa2+ffs2zbcOhoaG4u3bt+jcubMs3c/PD+7u7unGWa1aNaxevRrTpk3D2bNnkZiYqMvqqcWdkTucUsfaoUMHGBoafvT2pbq7JXX7+uyzz2BhYaHWvipUqIAiRYpI301NTVGyZMk83b6yU0BAAIoVK4aVK1fi+vXrOH/+vNZH937//XfY2tqiRYsWsvNahQoV4OzsLN32r9pHtO1D6Xn16hW++eYbFC9eHIaGhjA0NISlpSXi4+M1tvX0zp+aqNq+tvNIVqW+JgGAqKgo9OvXD4ULF5aOX6r2n9lj2LFjx2BhYYH27dvL0lXtJ3V7qVOnjmwAeycnJzg6OrK9EOmJg4MDTp48ifPnz2PmzJlo1aoV/vrrL4wdOxblypXT+U24Wb0++v3331GnTh24urrKju9NmjQB8P4FGNpUqFABxsbG+Oqrr7BmzRqNj6bl1PlDk4MHDyIpKQndunWTLdvU1BQBAQFqj2brct2+f/9+mJqaaj1fqtZZoVCgS5cusuU6OzujfPnyOr91NjPXnVn5XabaBqmvw6pVqwYvLy+184qdnR3q1q2rVs7QoUNx5coVnD59GgAQGxuLdevWoXv37rC0tNQ5HqKsyPZOKS8vL1SpUkX2+VDqN6OpHjlr3749jIyMZJ9Zs2ZBCIHnz5/jxYsXSElJgbOzs9oyNaXpIjo6GklJSfjhhx/Ult20aVMAUDvJODg4yL6rbsl98+YNAEjPW7u5uaW5bCcnJ3Ts2BE//fQTkpOTce3aNZw8eRKDBg1Kc76s1sPYsWMxd+5cnD17Fk2aNIGDgwPq1auHCxcupDuvSkbfbqctVtUjTR+LqnxN8bq6uqot39zcXNbRB7zfvm/fvv14QepRfHw8oqOjs/R2TE11u337dnTo0AGFChXC+vXrERoaKv2AzmxdprctU1JS8OLFC1l6em01reVktn1t2bIF3bt3x/Lly+Hr6wt7e3t069YNkZGR6c6rktX2ZWhoCAcHhxxpX4aGhmqPzyoUCo3tO/X2AN5vk7S2B/1HoVCgZ8+eWL9+PZYtW4aSJUuiVq1aGvM+efIEL1++hLGxsdq5LTIyUjqvadvfVftQer744gssXrwYffr0wcGDB3Hu3DmcP38eBQsW1Lhd9dEm02Jubq72yHBKSgoaNmyI7du3Y/To0Th69CjOnTsn/YEqs/trdHQ0nJ2d1f5Y5ejoCENDQ7YXolyiSpUq+Oabb/Drr7/i8ePHGD58OMLCwnQa7Dw7ro+ePHmCPXv2qB3bVWP/pNU5VqxYMRw5cgSOjo4YOHAgihUrhmLFiknjF6nKz4nzh7Z1A4CqVauqLXvLli1q66bLdfvTp0/h6uqa5qPeT548gRACTk5Oass9e/aszh2OmTnHZeV3WUZ/52i7vmzVqhU8PDykR/VWr16N+Ph4DBw4MN0YiLJLjr/2LvUFmepZ1x9++EHrm32cnJykN/Vp+nGXOk11gEo90F3qxmlnZwcDAwN07dpVa8Pz9PRMY23UqX6gpR5gTpOhQ4di3bp12LVrFw4cOABbW1u1vzikZmdnp3M9aGJoaIgRI0ZgxIgRePnyJY4cOYJx48ahUaNGePjwoU5vYUjrDjBNtMX64cHb1NRU4yDUup4INFGVHxERoTbt8ePHauOd5Dd79+5FcnKybPDMjG4HTfvC+vXr4enpiS1btsimZ2XA+PS2pVKphJ2dXabLT70cbfts6oG+UytQoAAWLlyIhQsXIjw8HLt378aYMWMQFRWFAwcO6BRDZtpXoUKFpO9JSUmIjo6WtS8TExON9Z+VjisHBwckJSXh6dOnso4pIQQiIyNRtWrVTJdNmvXo0QMTJ07EsmXL8N1332nNpxpIXNs+p7oD58P9XdM+lJaYmBj8/vvvmDRpEsaMGSOlq8ZMyS7ptckPaTv3Z+T4dePGDVy9ehWrV69G9+7dpXTVS1kyy8HBAX/88QeEELLlRkVFISkpKd+fj4hyIyMjI0yaNAkLFiyQxo1NS3ZcHxUoUAA+Pj5azwHp/aGxVq1aqFWrFpKTk3HhwgX88MMPGDZsGJycnPD5559/lPPHh8fmD8eaTH1sVh0Hf/vtN53uTtdFwYIFcerUKaSkpGjtmCpQoAAUCgVOnjyp8Q3S2fFWaW2y8rvsw2vj1DdDaPqdo+36UqlUYuDAgRg3bhzmzZuHJUuWoF69eumOo0qUnXLs7Xva+Pv7w9bWFrdu3VK7w0r1MTY2hoWFBapVq4bt27fLesDj4uKwZ88eWZlOTk4wNTXFtWvXZOmp325hbm6OOnXq4PLly/Dx8dG47Iz29vv5+cHGxgbLli1L99GoypUrw8/PD7NmzcKGDRvQo0ePdAcNz0g9pMfW1hbt27fHwIED8fz5c+ntF7r07GfEpk2bZHXx4MEDnDlzRtYZ4uHhgb/++kt2Yo6Ojpa9GSOjsfn6+sLMzAzr16+XpT969AjHjh2TBtDPj8LDwzFq1CjY2NhIAycDum+HtCgUChgbG8tOfpGRkWrtD9D9L/+lSpVCoUKFsHHjRtm+FB8fj23btklv5MuqGjVqwNTUFBs2bJClnzlzJsOPzRQpUgSDBg1CgwYNcOnSJSk9u+92SB3r1q1bkZSUpNa+Uh8Pjx07hlevXsnSMtK+VO0ndfvatm0b4uPj83X7+lgKFSqEr7/+Gi1atJB1mKTWvHlzREdHIzk5WeN5TXWhqdpHtO1DaVEoFBBCqF2sL1++HMnJyZlYO81KlSoFFxcXreeRD6k6jVPv67t379Z5earjVur1+vAtpSoZbS+vXr3Czp07ZemqtwiyvRB92jT9UQz475HeDzuDtJ3ns+P6qHnz5rhx4waKFSum8fiu693vBgYGqF69unR3jOo65WOcP7Qdm1P/bmnUqBEMDQ1x7949rb8JM6pJkyZ4+/atxrcXqzRv3hxCCPz7778al1muXLkMLzczMvq7TPUoXurrsPPnz+P27dsZOq/06dMHxsbG6Ny5M+7cuZPukztE2S3H75RKzdLSEj/88AO6d++O58+fo3379nB0dMTTp09x9epVPH36FEuXLgUATJ06FY0bN0aDBg0wcuRIJCcnY9asWbCwsJD9ZVb1XPDKlStRrFgxlC9fHufOncPGjRvVlr9o0SLUrFkTtWrVQv/+/eHh4YG4uDj8/fff2LNnT7pvBdK0PvPmzUOfPn1Qv359fPnll3BycsLff/+Nq1evYvHixbL8Q4cORceOHaFQKDBgwACdlqFrPWjSokULlC1bFlWqVEHBggXx4MEDLFy4EO7u7tJbvlQH30WLFqF79+4wMjJCqVKlZONbZERUVBTatGmDL7/8EjExMZg0aRJMTU2lt1IA799a9tNPP6FLly748ssvER0djdmzZ6s9WmFlZQV3d3fs2rUL9erVg729PQoUKKDxDhZbW1tMmDAB48aNQ7du3dCpUydER0cjKCgIpqamam9WzKtu3LghPR8fFRWFkydPYtWqVTAwMMCOHTtkd7nouh3S0rx5c2zfvh0DBgyQ3l43depUuLi44O7du7K85cqVw/Hjx7Fnzx64uLjAyspK419mlEolZs+ejc6dO6N58+bo27cvEhISMGfOHLx8+RIzZ87MfAV9wM7ODqNGjcK0adPQp08ffPbZZ3j48CEmT56c7qNCMTExqFOnDr744guULl0aVlZWOH/+PA4cOIC2bdvK1nn79u1YunQpKleuDKVSmakLLZXt27fD0NAQDRo0kN6+V758eXTo0EHK07VrV0yYMAETJ05EQEAAbt26hcWLF8PGxkZWVtmyZQEAP//8M6ysrGBqagpPT0+NnfMNGjRAo0aN8M033yA2Nhb+/v7S2/cqVqyIrl27ZnqdSDtd9vXPP/8cGzZsQNOmTTF06FBUq1YNRkZGePToEYKDg9GqVSu0adMGXl5e6NKlCxYuXAgjIyPUr18fN27ckN78mBZra2vUrl0bc+bMkY7BISEhWLFiBWxtbbNpbd+3/alTp6JPnz7SeeTly5ca26SzszPq16+PGTNmwM7ODu7u7jh69Ci2b9+u8/JKly6NYsWKYcyYMRBCwN7eHnv27MHhw4fV8mbkXNmtWzf8+OOP6N69O8LCwlCuXDmcOnUK06dPR9OmTVG/fv0M1gwR5aRGjRrBzc0NLVq0QOnSpZGSkoIrV65g3rx5sLS0xNChQ6W85cqVw+bNm7FlyxYULVoUpqamKFeuXLZcH02ZMgWHDx+Gn58fhgwZglKlSuHt27cICwvDvn37sGzZMq1DiCxbtgzHjh1Ds2bNUKRIEbx9+1Z6M5zqGPQxzh9NmzaFvb09evfujSlTpsDQ0BCrV6/Gw4cPZfk8PDwwZcoUjB8/Hv/88w8aN24MOzs7PHnyBOfOnYOFhQWCgoIytN06deqEVatWoV+/frhz5w7q1KmDlJQU/PHHH/Dy8sLnn38Of39/fPXVV+jZsycuXLiA2rVrw8LCAhERETh16hTKlSsnjQWc3bLyu6xUqVL46quv8MMPP0CpVKJJkybS2/cKFy6M4cOH6xyHra0tunXrhqVLl8Ld3T3T4zUTZVp2jZie3pu+VG/F+fXXXzVODwkJEc2aNRP29vbCyMhIFCpUSDRr1kwt/+7du4WPj48wNjYWRYoUETNnztT4VoeYmBjRp08f4eTkJCwsLESLFi1EWFiYxrdQ3b9/X/Tq1UsUKlRIGBkZiYIFCwo/Pz8xbdq0dOPX9qa/ffv2iYCAAGFhYSHMzc2Ft7e3mDVrltp6JyQkCBMTE9G4cWON9aKNrvWQ+i0P8+bNE35+fqJAgQLSvL179xZhYWGy+caOHStcXV2FUqmUvc3I3d1dNGvWTGNM2t6+t27dOjFkyBBRsGBBYWJiImrVqiUuXLigNv+aNWuEl5eXMDU1Fd7e3mLLli1qb/wSQogjR46IihUrChMTE9kbPlK/xUNl+fLlUl3Z2NiIVq1aqb2dpHv37sLCwkItJm1vDMkNUr8R09jYWDg6OoqAgAAxffp0ERUVpXE+XbaDar+fM2eOxjJmzpwpPDw8hImJifDy8hK//PKLxrq8cuWK8Pf3F+bm5rK322l7i9bOnTtF9erVhampqbCwsBD16tUTp0+fluVRLefp06ca60PTm7I+lJKSImbMmCEKFy4sjI2NhY+Pj9izZ4/a27RSt/23b9+Kfv36CR8fH2FtbS3MzMxEqVKlxKRJk0R8fLw03/Pnz0X79u2Fra2tUCgUUp2kVadpvX3v4sWLokWLFsLS0lJYWVmJTp06yd7qKcT748zo0aNF4cKFhZmZmQgICBBXrlxRa7NCCLFw4ULh6ekpDAwMZMvU1BbfvHkjvvnmG+Hu7i6MjIyEi4uL6N+/v3jx4oUsn7bjhra3PdJ7urxBUwjNb3pKTEwUc+fOFeXLlxempqbC0tJSlC5dWvTt21fcvXtXypeQkCBGjhwpHB0dhampqahRo4YIDQ3Vejz/sE0+evRItGvXTtjZ2QkrKyvRuHFjcePGDbV5ta2HLm/0U1m+fLkoUaKEMDY2FiVLlhQrV67UuE9GRESI9u3bC3t7e2FjYyO6dOkiLly4oPHte5qO+UIIcevWLdGgQQNhZWUl7OzsxGeffSbCw8M1Xj9oO1dq2rejo6NFv379hIuLizA0NBTu7u5i7Nix4u3bt7J8AMTAgQPV4tLUXokoZ2zZskV88cUXokSJEsLS0lIYGRmJIkWKiK5du4pbt27J8oaFhYmGDRsKKysrAUB2nMrq9ZEQ799EPWTIEOHp6SmMjIyEvb29qFy5shg/frx49eqV1nUIDQ0Vbdq0Ee7u7sLExEQ4ODiIgIAAsXv3blm+7D5/CCHEuXPnhJ+fn7CwsBCFChUSkyZNEsuXL9d4XbZz505Rp04dYW1tLUxMTIS7u7to3769OHLkiJQnI9ftb968ERMnTpTOIQ4ODqJu3brizJkzsnwrV64U1atXFxYWFsLMzEwUK1ZMdOvWTeNvFk3L1OW6M7t/lyUnJ4tZs2aJkiVLCiMjI1GgQAHRpUsX8fDhQ9n8AQEBokyZMmmux/HjxwUAMXPmzDTzEX0MCiGy+PqtT8DkyZMRFBSU5TeJ6cOePXvQsmVL7N27VxpcnYiIiIiIKLfx8PBAYGBgmo/M0adn5MiRWLp0KR4+fJjpweqJMkvvj+/lV7du3cKDBw8wcuRIVKhQQXqVKxEREREREdHHdvbsWfz1119YsmQJ+vbtyw4p0gt2SunJgAEDcPr0aVSqVAlr1qzJ8Bu3iIiIiIiIiDJL9bKg5s2bY9q0afoOh/KpPPH4HhERERERERER5S5KfQdARERERERERET5DzuliIiIiIiIiIgox7FTioiIiIiIiIiIchw7pYiIiIiIiIiIKMfp5e17KSkpePz4MaysrPjWOcpxQgjExcXB1dUVSmX+6ZdluyN9Y9tj2yP9YNtj2yMiIsppul5/6KVT6vHjxyhcuLA+Fk0kefjwIdzc3PQdRo5hu6NPBdsekX6w7REREVFOS+/6Qy+dUlZWVgDeB2dtba2PECgfi42NReHChaX9ML9guyN9Y9tj2yP9yPdtzwOwzqEbxJpe/i3D8yxDX43p/fBTVsMBAITDXeu0fWgMACjSPxoAUHHpKa15L1+qKf1/XaX2AIAABGdHiLlKucv/AADaV1yn50jUTcIk2fcit6Jl3218XwIArscUy5bllbv7T6bnjUm0ydKyw70d1NIKe0RryAkomsi/i/2ay1TYaV+ezT8vZd8Xx/RJKzw1g2yKZyi/vg2KMQAAfLfmOwBA2e7nAQBHUQ9OC2PfZzLRMKMbENv0fRfDVvskAECfmcDyMe//lXn0/38tgCfj3l8flbRZDAC4i24wff5fV8WP/y9rbChQ0VvzceqfXeWAbjdQNEbotI4xsAUARF8uDIz5L73+wd1qebfd6oqi3jek7xVxGU1sugIARk6LkeV1GPwQ/+wpCwAI7fI+7feY8QCAxRVHY/I/Npg8LQYxS21g8+r/88bMQMyg1BWUMTaLL0n/XxczGgDQ1Wa2Wr6YopXU5/3nktr03Zfro2uvbe8TWwEIB1SHmBj3VO233vt/is59X0db8DkaP98PEReHZB/vdK8/9NIppbqF2tramhfopDf57VZ+tjv6VLDtEelHvm17SsDaIGeWaWhtkeF5rLQM8WqIjJeliRKW6S7b2vj9dwNr7Xk/nGRmbSSbP1+xfH8cN7I203Mg6lJvD/XN+T52q+zqpbXM/DnNOjFri9a0DtZaDnEKY/l3oS1fmscJ+bqq2oDuNPXgfLpMrN93E6h2c+X/dyYrKGBtqsqkYUZzSBtC1UKsTd//X5pPWsh//76WNp75/5cDmH2wQVVZrS3TOE6ZWwOwhIG1bp1SSvy/o8TSWtYrYmRtrpbX2hJQWv/XsWIEc2n9YCrfN5TWVlAVoTqKm6hWXmkN0//PY60EoFDNawLrLO8i/9WLubR/qteV5vOhpdp0c2sjwOj/8ZkDMAWg0FLG/9uYqo4sYABF4n/1kt71Rz48kxARERERERERkb7p5U4pIiIiyv2SUwTO3X+OqLi3cLQyRTVPexgoc9fdOHlhHYiIiIhyK712SpWddBDhCz7TZwhE+U7ZSQehNDFH2Mxm+g6FiHKxAzciELTnFiJi3kppLjammNTCG43LuugxMt3lhXUgIiIiys34+B4RERFlyIEbEei//pKsMwcAImPeov/6SzhwI0JPkekuL6wDERERUW7HTikiIiLSWXKKQNCeW9A0jKgqLWjPLSSn6DbQqD7khXUgIiIiygvYKUVEREQ6O3f/udrdRR8SACJi3uLc/ec5F1QG5YV1ICIiIsoL2ClFREREOouK096Zk5l8+pAX1oGIiIgoL2CnFBEREenM0co0W/PpQ15YByIiIqK8gJ1SREREpLNqnvZwsTGFQst0Bd6/wa6ap31OhpUheWEd8oslS5bA09MTpqamqFy5Mk6ePKnvkIiIiCgbsVOKiIiIdGagVGBSC28AUOvUUX2f1MIbBkptXT76lxfWIT/YsmULhg0bhvHjx+Py5cuoVasWmjRpgvDwcH2HRkRERNmEnVJERESUIY3LumBpl0pwtpE/3uZsY4qlXSqhcVkXPUWmu7ywDnnd/Pnz0bt3b/Tp0wdeXl5YuHAhChcujKVLl+o7NCIiIsomhvoOgIiIiHKfxmVd0MDbGefuP0dU3Fs4Wr1/3C033V2UF9Yhr3r37h0uXryIMWPGyNIbNmyIM2fOaJwnISEBCQkJ0vfY2NiPGiMRERFlHTuliIiIKFMMlAr4FnPQdxhZkhfWIS969uwZkpOT4eTkJEt3cnJCZGSkxnlmzJiBoKCgnAiPiIiIsgkf3yMiIiKiT5JCIb9rTQihlqYyduxYxMTESJ+HDx/mRIhERESUBXq/U8pjzF4AQNjMZnqOhIiIiIg+BQUKFICBgYHaXVFRUVFqd0+pmJiYwMTEJCfCIyIiomzCO6WIiIiI6JNibGyMypUr4/Dhw7L0w4cPw8/PT09RERERUXbT+51SRERERESpjRgxAl27dkWVKlXg6+uLn3/+GeHh4ejXr5++QyMiIqJswk4pIiIiIvrkdOzYEdHR0ZgyZQoiIiJQtmxZ7Nu3D+7u7voOjYiIiLIJO6WIiIiI6JM0YMAADBgwQN9hEBER0UfCMaWIiIiIiIiIiCjH8U4pIiIiPUhOETh3/zmi4t7C0coU1TztYaDU/Kp7Im24HxEREVFuxk4pIiIiHc2YMQPjxo3D0KFDsXDhwkyXc+BGBIL23EJEzFspzcXGFJNaeKNxWZdsiJTyA+5HRERElNvx8T0iIiIdnD9/Hj///DN8fHyyVM6BGxHov/6SrCMBACJj3qL/+ks4cCMiS+VT/sD9iIiIiPICdkoRERGl49WrV+jcuTN++eUX2NnZZbqc5BSBoD23IDRMU6UF7bmF5BRNOYje435EREREeUWmOqXi4+OzOw4i0gHbHpF+DBw4EM2aNUP9+vXTzZuQkIDY2FjZR+Xc/edqd7Z8SACIiHmLc/efZ0fYlEdxPyIiIqK8IlOdUk5OTujVqxdOnTqV3fEQURrY9ohy3ubNm3Hp0iXMmDFDp/wzZsyAjY2N9ClcuLA0LSpOe0fCh3TNR/kT9yMiIiLKKzLVKbVp0ybExMSgXr16KFmyJGbOnInHjx9nd2xElArbHlHOevjwIYYOHYr169fD1NRUp3nGjh2LmJgY6fPw4UNpmqOVbmXomo/yJ+5HRERElFdk6u17LVq0QIsWLRAdHY21a9di9erVmDBhAho1aoRevXqhZcuWMDTki/2IshvbHlHOunjxIqKiolC5cmUpLTk5GSdOnMDixYuRkJAAAwMD2TwmJiYwMTHRWF41T3u42JgiMuatxvGAFACcbUxRzdM+G9eC8hruRxnT9PJvMLS2+OjLCWnTGGjz/y8770rp7iIZAOCBMI3zdcfa9MtWFAMABIh7GY5L23Jly171/2Ws1l6OAn+ppQWIbmkuWxW3fJ6Mr0Na1kAegy71mRUBlQ8AAB7DVWsMukgrzjB4aExPa1tqLLOs/GuAOCjLpy1uXeswoNQBnfJpEoj9mZ4X0FxHD2qXBgAE7HgfV4iiWLbsbyFtGgNlNE9bq+O2DxBp76uZ2YcyQ9O2Td1OR4otanlGYW6mljcAf2HAsP//f1gaGaeo/nNNSrIxvCn9v6B4f101+YY7XsIO51FFmlYVF6T/i+vl4YgHsunauJd8Cse/Hqil7/uinXrmcf/9N6qkO5beVc+CUe8Tn44CsD3dxadp8dzeaU4frPgmzentFIu0TlPcVT+W/yBmpVumLqJKugMAzv5VPkPzZWmgcwcHBwwfPhxXr17F/PnzceTIEbRv3x6urq6YOHEiXr9+nZXiiUgLtj2inFGvXj1cv34dV65ckT5VqlRB586dceXKFbUOqfQYKBWY1MIbwPuOgw+pvk9q4Q0DZeqpRP/hfkRERER5RZZuqYiMjMTatWuxatUqhIeHo3379ujduzceP36MmTNn4uzZszh06FB2xUpE/8e2R5QzrKysULas/E/NFhYWcHBwUEvXVeOyLljapRKC9tySDVbtbGOKSS280bisS5ZipvxBX/vRmzdvIISAubk5AODBgwfYsWMHvL290bBhw4+yTCIiIsq7MtUptX37dqxatQoHDx6Et7c3Bg4ciC5dusDW1lbKU6FCBVSsWDG74iQisO0R5RWNy7qggbczzt1/jqi4t3C0ev+oFe9soYzQx37UqlUrtG3bFv369cPLly9RvXp1GBkZ4dmzZ5g/fz769+//0ZZNREREeU+mOqV69uyJzz//HKdPn0bVqlU15ilatCjGjx+fpeCISI5tj0j/jh8/ni3lGCgV8C3mkC1lUf6V0/vRpUuXsGDBAgDAb7/9BicnJ1y+fBnbtm3DxIkT2SlFREREGZKpTqmIiAjptm1tzMzMMGnSpEwFRUSase0RZcxff/2F48ePIyoqCikpKbJpEydO1FNURLnX69evYWVlBQA4dOgQ2rZtC6VSiRo1auDBA/UBY4mIiIjSkqlOKSsrK0RERMDR0VGWHh0dDUdHRyQnJ2dLcEQkx7ZHpLtffvkF/fv3R4ECBeDs7AyF4r9HmhQKBTuliDKhePHi2LlzJ9q0aYODBw9i+PDhAICoqChYW1vrOToiIiLKbTLVKSWEphcQAwkJCTA2Ns5SQESkHdseke6mTZuG7777Dt98k/VX3BLRexMnTsQXX3yB4cOHo169evD19QXw/q4pjmdIREREGZWhTqnvv/8ewPu/MC9fvhyWlpbStOTkZJw4cQKlS5fO3giJiG2PKBNevHiBzz77TN9hEOUp7du3R82aNREREYHy5ctL6fXq1UObNm30GBkRERHlRhnqlFINbCmEwLJly2BgYCBNMzY2hoeHB5YtW5a9ERIR2x5RJnz22Wc4dOgQ+vXrp+9QiPIUZ2dnODs7y9KqVaump2iIiIgoN8tQp9T9+/cBAHXq1MH27dthZ2f3UYIiIjm2PaKMK168OCZMmICzZ8+iXLlyMDIykk0fMmSIniIjyr3i4+Mxc+ZMHD16VOMLBP755x89RUZERES5UabGlAoODs7uOIhIB2x7RLr7+eefYWlpiZCQEISEhMimKRQKdkoRZUKfPn0QEhKCrl27wsXFRfYCASIiIqKM0rlTasSIEZg6dSosLCwwYsSINPPOnz8/y4ER0Xtse0SZo7rDkIiyz/79+7F37174+/tnuoxGjRrh1KlTeP36NRQKBZycnLBy5Uo0adJEylO8eHHcu3dPNp+FhQVevXqV6eUSERHRp0fnTqnLly8jMTFR+r82/IsZUfZi2yPKOtWbK9lOiLLGzs4O9vb2WSrj4sWL6NSpE1q0aIGEhAQMHjwYLVq0wOPHj+Ho6CjlK1CgAI4ePSp9t7CwyNJyiYiI6NOjc6fUh48N8REiopzDtkeUeWvXrsWcOXNw9+5dAEDJkiXx9ddfo2vXrnqOjCh3mjp1KiZOnIg1a9bA3Nw8U2U8e/ZM9r1cuXLw9vbGli1bMHjwYCnd0NAQPj4+WYqXiIiIPm2ZGlOKiIjoUzd//nxMmDABgwYNgr+/P4QQOH36NPr164dnz55h+PDh+g6RKNeZN28e7t27BycnJ3h4eKi9QODSpUsZLvPx48cAADc3N1l6ZGQklEolDA0NUbRoUWzbtg1lypTRWk5sbCxiY2Ol73FxcRmOhYiIiHKWzp1Sbdu21bnQ7du3ZyoYIlLHtkeUOT/88AOWLl2Kbt26SWmtWrVCmTJlMHnyZHZKEWVC69ats7W8lJQUdO7cGdbW1mjTpo2U3qxZM9jZ2aF8+fK4dOkS5s6di8qVKyMqKgrW1tYay2rZsqXaSw2IiIjo06Zzp5SNjc3HjIOItGDbI8qciIgI+Pn5qaX7+fkhIiJCDxER5X6TJk3K1vLKly+PZ8+eITQ0VJa+aNEi6f9t2rRBu3btULFiRUybNg2zZ8/WWNbu3bvV7pTy9vbO1niJiIgoe+ncKbVq1aqPGQcRacG2R5Q5xYsXx9atWzFu3DhZ+pYtW1CiRAk9RUWUN1y8eBG3b9+GQqGAt7c3KlasmOEyfHx8cPv2bRw7dgxVq1ZNM2+FChVgZGSE69eva81jbW0tu4vqww4qIiIi+jRxTCmifMpjzF7p/2Ezm+kxEqKPIygoCB07dsSJEyfg7+8PhUKBU6dO4ejRo9i6dau+wyPKlaKiovD555/j+PHjsLW1hRACMTExqFOnDjZv3oyCBQumW0ZKSgoqVKiAmzdv4sCBA6hdu3a689y9exeJiYkoXLhwdqwGERERfSJ07pSqVKkSjh49Cjs7O1SsWDHN12pnZpBLItKMbY8oc9q1a4c//vgDCxYswM6dOyGEgLe3N86dO5epuzqICBg8eDBiY2Nx8+ZNeHl5AQBu3bqF7t27Y8iQIdi0aVO6Zfj4+ODmzZtYuHAhnJyccO3aNQDvBzq3t7dHZGQkmjdvjq+++gre3t64cOECJkyYAKVSicmTJ3/M1SMiIqIcpnOnVKtWrWBiYgIg+we5JCLt2PaIMq9y5cpYv369vsMgyjMOHDiAI0eOSB1SAODt7Y0ff/wRDRs21KmMmzdvAgCGDRsmS+/duzeWL18OY2NjhIWFoV+/fhBCwMDAAB4eHtiwYQNcXV2zbV2IiIhI/3TulPpwYMvsHuSSiLRj2yPSXWxsrDSmTHrjyWh7gxcRaZeSkgIjIyO1dCMjI6SkpOhUhhAizen29vZ49uxZpuIjIiKi3CVLY0pduHBBGuTSy8sLlStXzq64iCgNbHtEmtnZ2SEiIgKOjo6wtbXV+LirEAIKhQLJycl6iJAod6tbty6GDh2KTZs2SXct/fvvvxg+fDjq1aun5+iIiIgot8lUp9SjR4/QqVMnnD59Gra2tgCAly9fws/PD5s2beIglEQfCdseUdqOHTsGe3t7AEBwcLCeoyHKexYvXoxWrVrBw8MDhQsXhkKhQHh4OMqVK8dHZYmIiCjDMtUp1atXLyQmJuL27dsoVaoUAODOnTvo1asXevfujUOHDmVrkET0HtseUdoCAgKk/3t6eko/mj8khMDDhw9zOjSiPKFw4cK4dOkSDh8+jD///FN6gUD9+vX1HRoRERHlQpnqlDp58iTOnDkj/SgGgFKlSuGHH36Av79/tgVHRHJse0S68/T0lB7l+9Dz58/h6enJx/eIsqBBgwZo0KCBvsMgIiKiXC5TnVJFihRBYmKiWnpSUhIKFSqU5aCISDO2PSLdqcaOSu3Vq1cwNTXVQ0REudP333+Pr776Cqampvj+++/TzDtkyJAcioqIiIjygkx1Ss2ePRuDBw/Gjz/+iMqVK0OhUODChQsYOnQo5s6dm90xEtH/se0RpW/EiBEAAIVCgQkTJsDc3FyalpycjD/++AMVKlTQU3REuc+CBQvQuXNnmJqaYsGCBVrzKRQKdkoRERFRhujcKWVnZyf7i3N8fDyqV68OQ8P3RSQlJcHQ0BC9evVC69atsz1QovyKbY8oYy5fvgzg/Z1S169fh7GxsTTN2NgY5cuXx6hRo/QVHlGuc//+fY3/JyIiIsoqnTulFi5c+BHDICJt2PaIMkb11r2ePXti0aJFsLa21nNERHnHlClTMGrUKNkdiADw5s0bzJkzBxMnTtRTZERERJQb6dwp1b17948ZBxFpwbZHlDmrVq3SdwhEeU5QUBD69eun1in1+vVrBAUFsVOKiIiIMiRTY0p96M2bN2oDL/Ov0kQfH9seUfrOnz+PX3/9FeHh4Xj37p1s2vbt29Odf8aMGdi+fTv+/PNPmJmZwc/PD7NmzZK9AZMoP9H2AoGrV6/C3t5eDxHpT4iimDyhtV7C0KsQRTEEiHtap6m4i4/3ttPuWKt12dpiyws+rN/MrqemustLQsVnAIAxmJlmvrT2Y5mdd6X/9lYEZTwgoX1SdmyLNeiW5vSc3t6dk4wwIMu9Dek7jyoAAPdST6U0Xdb1OJpon+ia5bAybfHc3jm+zEElV2Awvsnx5aooMzNTfHw8Bg0aBEdHR1haWsLOzk72IaKPg22PSHebN2+Gv78/bt26hR07diAxMRG3bt3CsWPHYGNjo1MZISEhGDhwIM6ePYvDhw8jKSkJDRs2RHx8/EeOnujTYmdnB3t7eygUCpQsWRL29vbSx8bGBg0aNECHDh30HSYRERHlMpnquxw9ejSCg4OxZMkSdOvWDT/++CP+/fdf/PTTT5g5M+2eaCLKPLY9It1Nnz4dCxYswMCBA2FlZYVFixbB09MTffv2hYuLi05lHDhwQPZ91apVcHR0xMWLF1G7du2PETbRJ2nhwoUQQqBXr14ICgqSdewaGxvDw8MDvr6+eoyQiIiIcqNMdUrt2bMHa9euRWBgIHr16oVatWqhePHicHd3x4YNG9C5c+fsjpOIwLZHlBH37t1Ds2bNAAAmJiaIj4+HQqHA8OHDUbduXQQFZfzW+5iYGADId48pEanGN/T09ISfnx+MjIz0HBERERHlBZl6fO/58+fw9PQE8H4Mm+fPnwMAatasiRMnTmQqEI8xe+ExZm+m5iXKLz5G2yPKq+zt7REXFwcAKFSoEG7cuAEAePnyJV6/fp3h8oQQGDFiBGrWrImyZctqzZeQkIDY2FjZhyivCAgIkDqk3rx5w32diIiIsiRTnVJFixZFWFgYAMDb2xtbt24F8P4uDltb2+yKjYhSYdsj0l2tWrVw+PBhAECHDh0wdOhQfPnll+jUqRPq1auX4fIGDRqEa9euYdOmTWnmmzFjBmxsbKRP4cKFMxU/0afo9evXHNuQiIiIsk2mOqV69uyJq1evAgDGjh2LJUuWwMTEBMOHD8fXX3+drQES0X/Y9oh0t3jxYnz++ecA3reXUaNG4cmTJ2jbti1WrFiRobIGDx6M3bt3Izg4GG5ubmnmHTt2LGJiYqTPw4cPM70ORJ+ar7/+GseOHZPOP8uXL0dQUBBcXV2xdm3efpMXERERZb9MjSk1fPhw6f916tTB7du3cfHiRRQrVgzly5fPtuCISI5tj0g3SUlJ2LNnDxo1agQAUCqVGD16NEaPHp2hcoQQGDx4MHbs2IHjx49Lj8+mxcTEBCYmJpmKm+hTx7ENiYiIKDtlqlMqNXd3d7i7u2dHUUSUAWx7RJoZGhqif//+uH37dpbKGThwIDZu3Ihdu3bBysoKkZGRAAAbGxuYmZllR6hEuUpaYxv2799fn6ERERFRLpSpx/cA4OjRo2jevDmKFSuG4sWLo3nz5jhy5Eh2xkZEGnyMtscXDVBeVL16dVy+fDlLZSxduhQxMTEIDAyEi4uL9NmyZUs2RUmUu3BsQyIiIspOmeqUWrx4MRo3bgwrKysMHToUQ4YMgbW1NZo2bYrFixdnd4xE9H9se0S6GzBgAEaOHInFixcjNDQU165dk310IYTQ+OnRo8fHDZ7oE8WxDYmIiCg7ZerxvRkzZmDBggUYNGiQlDZkyBD4+/vju+++k6UTUfZh2yPSXceOHQG8byMqCoUCQggoFAokJyfrKzSiXCv12IZ//vknLly4kKGxDQMDAxESEiJLUyqVUptMSUlB3bp1cfLkSaSkpMDGxgZr1qxBq1atsm9FiIiI6JOQqU6p2NhYNG7cWC29YcOG+Oabb7IcFBFpxrZHpLv79+/rOwSiPCUxMRENGzbETz/9hJIlSwIAihQpgiJFimS4LBMTE5w7d076bmRkJP2/WbNmCAkJwddffw1fX18MHToUbdu2xcOHD+Hq6pr1FSEiIqJPRqY6pVq2bIkdO3ao3aa9a9cutGjRIlsCIyJ1bHtEuuNLAIiyl5GREW7cuAGFQpHlshQKBXx8fNTSU1JScOjQITRu3BizZ88GANSrVw82Njb4+uuvsWHDhiwvm4iIiD4dOndKff/999L/vby88N133+H48ePw9fUFAJw9exanT5/GyJEjsz9KonyMbY8oc9auXZvm9G7duuVQJER5R7du3bBixQrMnDkzS+W8ffsWBgYGUCqVcHFxwdq1axEYGIgTJ04gJSVF1j6tra3h7OyMs2fPZjV8IiIi+sTo3Cm1YMEC2Xc7OzvcunULt27dktJsbW2xcuVKfPvtt9kXIVE+x7ZHlDlDhw6VfU9MTMTr169hbGwMc3NzdkoRZcK7d++wfPlyHD58GFWqVIGFhYVs+vz589Mto27duqhatSpq1KiBe/fuYfr06ahXrx7+/PNP3LlzBwBQqlQp2Ty2trZ4+vRpmuXGxsYiNjZW+h4XF6frahEREZGe6NwpxbE5iPSDbY8oc168eKGWdvfuXfTv359vCSPKpBs3bqBSpUoAgL/++ks2TdfH+iZOnCj73qNHD7i4uGDUqFFo2rQpgPcDn39ICJFuuS1btlQbQJ2IiIg+bZkaU+pDqouE7BhfgIh0x7ZHlHElSpTAzJkz0aVLF/z555/6Doco1wkODs72Mh0dHWFra4u///5bukPq9u3bqFChgpQnJiYGNjY2aZaze/dutTulvL29sz1eIiIiyj7K9LNotnbtWpQrVw5mZmYwMzODj48P1q1bl52xEZEGbHtEWWNgYIDHjx/rOwyiXO3vv//GwYMH8ebNGwC63cmkTWxsLF6+fAknJyfUrl0bSqVSdl579eoVIiMjUaNGjTTLsba2hpubm/QpVKhQpmMiIiKinJGpO6Xmz5+PCRMmYNCgQfD394cQAqdPn0a/fv3w7NkzDB8+PLvjJCKw7RFlxO7du2XfhRCIiIjA4sWL4e/vr6eoiHK36OhodOjQAcHBwVAoFLh79y6KFi2KPn36wNbWFvPmzUu3jCpVqqBr166oWLEi7t69i3HjxiElJQVTp06FUqlEw4YNsX//fnzzzTeoUaMGhg8fDqVSiTlz5uTAGhIREVFOylSn1A8//IClS5fKBolt1aoVypQpg8mTJ/OHMdFHwrZHpLvWrVvLvisUChQsWBB169bV6YczEakbPnw4jIyMEB4eDi8vLym9Y8eOGD58uE5tKyoqCiNGjEBKSgqUSiWcnZ2xa9cuqbN47969qFu3LubOnYuUlBTY2Njgt99+g6ur60dbLyIiItKPTHVKRUREwM/PTy3dz88PERERWQ6KiDRj2yPSXUpKir5DIMpzDh06hIMHD8LNzU2WXqJECTx48ECnMsLDw9OcrlQqcfz48cyGSERERLlIpjqlihcvjq1bt2LcuHGy9C1btqBEiRLZEhgRqWPbI0rbiBEjdM6ry6vriUguPj4e5ubmaunPnj2DiYmJHiIiIiKi3CxTnVJBQUHo2LEjTpw4AX9/fygUCpw6dQpHjx7F1q1bsztGIvo/tj2itF2+fFn2/eLFi0hOTpbe6PXXX3/BwMAAlStX1kd4RLle7dq1sXbtWkydOhXA+8diU1JSMGfOHNSpU0fP0REREVFuk6lOqXbt2uHcuXOYP38+du7cCSEEvL29ce7cOVSsWDG7YySi/2PbI0rbh6+rnz9/PqysrLBmzRrY2dkBAF68eIGePXuiVq1a+gqRKFebM2cOAgMDceHCBbx79w6jR4/GzZs38fz5c5w+fVrf4REREVEuk+FOqcTERHz11VeYMGEC1q9f/zFiIiIN2PaIMmbevHk4dOiQ1CEFAHZ2dpg2bRoaNmyIkSNH6jE6otzJ29sb165dw9KlS2FgYID4+Hi0bdsWAwcOhIuLi77DIyIiolxGmdEZjIyMsGPHjo8RCxGlgW2PKGNiY2Px5MkTtfSoqCjExcXpISKi3C88PBxOTk4ICgrC77//jn379mHatGlwcXFJdwBzIiIiotQy3CkFAG3atMHOnTuzORQiSg/bHpHu2rRpg549e+K3337Do0eP8OjRI/z222/o3bs32rZtq+/wiHIlT09PPH36VC09Ojoanp6eeoiIiIiIcrNMv31v6tSpOHPmDCpXrgwLCwvZ9CFDhmRLcEQk97HbnseYvdL/w2Y2y1JZRPq2bNkyjBo1Cl26dEFiYiIAwNDQEL1798acOXP0HB1R7iSEgEKhUEt/9eoVTE1N9RARERER5WaZ6pRavnw5bG1tcfHiRVy8eFE2TaFQsFOK6CNh2yPSnbm5OZYsWYI5c+bg3r17EEKgePHiap25RJS+ESNGAHh/rpkwYQLMzc2lacnJyfjjjz9QoUIFPUVHREREuVWmOqXu378v/V8IAQAa/2pGRNmLbY8o4ywsLODj46PvMIhytcuXLwN4f+65fv06jI2NpWnGxsYoX748Ro0apa/wiIiIKJfKVKcUAKxYsQILFizA3bt3AQAlSpTAsGHD0KdPn2wLjojUse0REVFOCw4OBgD07NkT33//PaysrPQcke6WoS+sdBxGtTvW6lxugLgn+x7SpoTGfA8UBu//RTG1edagm24LE+nHpktZqcuQzSMAD8VpjfOljlun5QrNy0xzHi35M7Tc/y87I9syS8v6CGXqErumbfIx4swMXeLPrlg/XJbHjjDZtDGYqVMZae3fAICddzM3XyrdsVa23jm9vbQtzwPydj9P0fG//+P//zd7f3xr3/m3DC2zoDDJUP6nWv7W/lSRIKvvqriAp4oEWR5xvaT0/1vwTndZjn89yFBsKoq7f2EJSqafMTNlz/sLP8ydlbVC1v//XNRF836rcbl3/8raMrMoU51SEyZMwIIFCzB48GD4+voCAEJDQzF8+HCEhYVh2rRp2RokEb3HtkdERPrw4csBunfvrjXf9u3bcyIcIiIiyiMy1Sm1dOlS/PLLL+jUqZOU1rJlS/j4+GDw4MH8YUz0kbDtERGRPtjY2Og7BCIiIsqDMtUplZycjCpVqqilV65cGUlJSVkOiog001fb41v5iIjyt1WrVuk7BCIiIsqDdHvAPpUuXbpg6dKlauk///wzOnfunOWgiEgztj0iIiIiIiLKK7I00PmhQ4dQo0YNAMDZs2fx8OFDdOvWTXptMADMnz8/61ESkYRtj4iIiIiIiPKCTHVK3bhxA5UqVQIA3Lv3fhT8ggULomDBgrhx44aUj6+qJ8peOdn2Pnxkj4iIiIiIiCi7ZapTSvVaYCLKWWx7RERERERElFdkakypj4l3ZxAR0admyZIl8PT0hKmpKSpXroyTJ0/qOyQiIiIiolzvk+uUIiIi+pRs2bIFw4YNw/jx43H58mXUqlULTZo0QXh4uL5DIyIiIiLK1T7JTimPMXt5xxQREX0S5s+fj969e6NPnz7w8vLCwoULUbhwYY1vwiQiIiIiIt19kp1SREREn4J3797h4sWLaNiwoSy9YcOGOHPmjMZ5EhISEBsbK/sQEREREZE6dkoRERFp8ezZMyQnJ8PJyUmW7uTkhMjISI3zzJgxAzY2NtKncOHCOREqUa5haGgIhUKh9ilXrhwAoHjx4mrTLC0t9Rw1ERERfQyZevseERFRfqJQKGTfhRBqaSpjx47FiBEjpO+xsbHsmCL6wPXr15GYmCh9P3DgAL755hv07t1bSitQoACOHj0qfbewsMjRGImIiChnsFOKiDJE03hvYTOb6SESoo+vQIECMDAwULsrKioqSu3uKRUTExOYmJjkRHhEuZKXl5fse/fu3WFoaIghQ4ZIaYaGhvDx8cnp0IiIiCiHfdKP73HAcyIi0idjY2NUrlwZhw8flqUfPnwYfn5+eoqKKO949eoVrl69ijp16kCp/O+yNDIyEkqlEsbGxihdujRu3ryZblmxsbF49OiR9Pn3338/ZuhERESUDXLFnVKqjinejUFERDltxIgR6Nq1K6pUqQJfX1/8/PPPCA8PR79+/fQdGlGuN2HCBAghMHPmTCmtWbNmsLOzQ/ny5XHp0iXMnTsXlStXRlRUFKytrbWW1bJlS4SEhORE2ERERJRNckWnFBF92j68o5Gdx5TXdOzYEdHR0ZgyZQoiIiJQtmxZ7Nu3D+7u7voOjSjXW7duHRwdHVGpUiUpbdGiRdL/27Rpg3bt2qFixYqYNm0aZs+erbWs3bt3y952GRcXB29v748TOBEREWULdkoRERGlY8CAARgwYIC+wyDKU06fPo3o6GiMHTs2zXwVKlSAkZERrl+/nmY+a2tr2Z1UH3ZQERER0afpkx5TioiIiIjypvHjx0OpVGLixIlp5rt79y4SExP5FksiIqI8KFd1SnHQc6LcSfXSArZhIiICgKSkJJw6dQpVq1aFqamplB4ZGYkqVarg559/xqlTp7Bw4UJUqlQJSqUSkydP1l/ARERE9FHkusf3OOg5ERERUe42Z84cJCcnIygoSJZubGyMsLAw9OvXD0IIGBgYwMPDAxs2bICrq6ueoiUiIqKPJdd1ShHRp42DnhMRUXrGjh2rcSwpe3t7PHv2TA8RERERkT6wU4qIPho+rkdERERERETasFOKiHJUVu+k4p1YREREREREeUOuGuiciPIWDn5ORERERESUf+XaO6U0/ZDlXRNERERERERERLlDru2U0iStOy7YYUWU9/BRPiIiIiIiotwrT3VKpSWrjwjxBy/Rx5Pdj/ClV56qPbNTi4iIiIiISH/yTadUVul73Bv+YCZKm77b6Ie0xcJ2TERERERE9B92SuUSn9IP7pzCH/D0saTXnjTdQaXtripVui77a3pj4WXnnVufUlmq+VMSXmcpDiIiIiIiylv00iklhADAHyiUtiLDf832Mm8ENUJsbCyA//bD/ILtLm3a9jdN6bqmZcdybwQ1ktLKTjoo/V+V/mFaRpaR2XKz0i5V+15+bXuqYw9RTsvv571XsSk6z5OE+MwvMPHDNv5Kc/mx8vLjkH2x6VJW6jLU59Et7owsV1Pcac2j6zbIzHIzKyPbKTtkNvacjlMbXeLPrlizcztrl/F2oc2nso3kNK+fzOv3x7e4WAHzt/9P03RKeQ3Exv43IcUgLoOxvL9WjNMQV1JsPGJfASmxqjLfyabH/j/7f9N19CoWSPqgnEQACanzyJf75sNpb2P/y6Qq4/8/t1R7SELsW1VwePv/eWJTAAjVvAmITXhfxptY+XppCVr7pNfq8WREbLKqmMT/zmuvAbyFtM1VeSSqkP+fHh+bDBEXCxH3vs7Su/5QCD1coTx69AiFCxfO6cUSyTx8+BBubm76DiPHsN3Rp4Jtj0g/8lvb++eff1CsWDF9h0FERJSvpXf9oZdOqZSUFNy5cwfe3t54+PAhrK2tczqEPC82NhaFCxdm/WoghEBcXBxcXV2hVCr1HU6OSUlJwePHj2FlZQWFQqHvcLJFXt7P8+K6se2pt728uJ1zo7y+HfJr23v58iXs7OwQHh4OGxsbfYeTK+X1tvGxsf6yhvWXdazDrGH9ZY2u1x96eXxPqVSiUKFCAABra2tu4I+I9atZfrw4VSqVefYv5Hl5P89r68a2p1le2865VV7eDvm17QHv1z2vbteckpfbRk5g/WUN6y/rWIdZw/rLPF2uP/LPn8uIiIiIiIiIiOiTwU4pIiIiIiIiIiLKcXrrlDIxMcGkSZNgYmKirxDyNNYv5Qd5eT/Py+tG/+F2/jRwO+RN3K5ZxzrMGtZf1rD+so51mDWsv5yhl4HOiYiIiIiIiIgof+Pje0RERERERERElOPYKUVERERERERERDmOnVJERERERERERJTj9NYptWTJEnh6esLU1BSVK1fGyZMn9RVKrjV58mQoFArZx9nZWZouhMDkyZPh6uoKMzMzBAYG4ubNm3qMmCjjZsyYgapVq8LKygqOjo5o3bo17ty5I8uTV/b1GTNmQKFQYNiwYVJaXlk30oznwpzDc2b+w/al2YkTJ9CiRQu4urpCoVBg586dsum6tIWEhAQMHjwYBQoUgIWFBVq2bIlHjx7l4FroT3Zdl+TXOly6dCl8fHxgbW0Na2tr+Pr6Yv/+/dJ01l3GZPbaMT/XYXZcD+Tn+vsY9NIptWXLFgwbNgzjx4/H5cuXUatWLTRp0gTh4eH6CCdXK1OmDCIiIqTP9evXpWmzZ8/G/PnzsXjxYpw/fx7Ozs5o0KAB4uLi9BgxUcaEhIRg4MCBOHv2LA4fPoykpCQ0bNgQ8fHxUp68sK+fP38eP//8M3x8fGTpeWHdSDOeC3Mez5n5B9uXdvHx8ShfvjwWL16scboubWHYsGHYsWMHNm/ejFOnTuHVq1do3rw5kpOTc2o19Ca7rkvyax26ublh5syZuHDhAi5cuIC6deuiVatW0o9+1p3usnLtmN/rMKvXA/m9/rKd0INq1aqJfv36ydJKly4txowZo49wcq1JkyaJ8uXLa5yWkpIinJ2dxcyZM6W0t2/fChsbG7Fs2bIcipAo+0VFRQkAIiQkRAiRN/b1uLg4UaJECXH48GEREBAghg4dKoTIG+tG2vFcmLN4zsxf2L50A0Ds2LFD+q5LW3j58qUwMjISmzdvlvL8+++/QqlUigMHDuRY7J+KzFyXsA7l7OzsxPLly1l3GZCVa8f8XodZvR7I7/X3MeT4nVLv3r3DxYsX0bBhQ1l6w4YNcebMmZwOJ9e7e/cuXF1d4enpic8//xz//PMPAOD+/fuIjIyU1bOJiQkCAgJYz5SrxcTEAADs7e0B5I19feDAgWjWrBnq168vS88L60aa8VyoHzxn5g9sX5mnS1u4ePEiEhMTZXlcXV1RtmzZfFm/mbkuYR2+l5ycjM2bNyM+Ph6+vr6suwzIyrUj6zBr1wOsv+xnmNMLfPbsGZKTk+Hk5CRLd3JyQmRkZE6Hk6tVr14da9euRcmSJfHkyRNMmzYNfn5+uHnzplSXmur5wYMH+giXKMuEEBgxYgRq1qyJsmXLAkCu39c3b96MS5cu4fz582rTcvu6kXY8F+Y8njPzD7avzNOlLURGRsLY2Bh2dnZqefJb/Wb2uiS/1+H169fh6+uLt2/fwtLSEjt27IC3t7f0g551l7asXjvm9zrM6vVAfq+/jyHHO6VUFAqF7LsQQi2N0takSRPp/+XKlYOvry+KFSuGNWvWoEaNGgBYz5S3DBo0CNeuXcOpU6fUpuXGff3hw4cYOnQoDh06BFNTU635cuO6kW64bXMOz5n5D7dn5mWm7vJj/Wb3dUl+qcNSpUrhypUrePnyJbZt24bu3bsjJCREms660+5jXjvmlzr8WNcD+aX+PoYcf3yvQIECMDAwUOtFjIqKUuuRpIyxsLBAuXLlcPfuXekNAqxnyisGDx6M3bt3Izg4GG5ublJ6bt7XL168iKioKFSuXBmGhoYwNDRESEgIvv/+exgaGkrx58Z1o7TxXKh/PGfmXWxfmadLW3B2dsa7d+/w4sULrXnyg6xcl+T3OjQ2Nkbx4sVRpUoVzJgxA+XLl8eiRYtYdzrIjmvH/F6HqWX0eoD1l/1yvFPK2NgYlStXxuHDh2Xphw8fhp+fX06Hk6ckJCTg9u3bcHFxgaenJ5ydnWX1/O7dO4SEhLCeKVcRQmDQoEHYvn07jh07Bk9PT9n03Lyv16tXD9evX8eVK1ekT5UqVdC5c2dcuXIFRYsWzbXrRmnjuVD/eM7Mu9i+Mk+XtlC5cmUYGRnJ8kRERODGjRv5on6z47okv9dhakIIJCQksO50kB3Xjvm9DlPL6PUA6+8jyMlR1VU2b94sjIyMxIoVK8StW7fEsGHDhIWFhQgLC9NHOLnWyJEjxfHjx8U///wjzp49K5o3by6srKykepw5c6awsbER27dvF9evXxedOnUSLi4uIjY2Vs+RE+muf//+wsbGRhw/flxERERIn9evX0t58tK+/uEbVITIW+tGcjwX5iyeM/MXti/t4uLixOXLl8Xly5cFADF//nxx+fJl8eDBAyGEbm2hX79+ws3NTRw5ckRcunRJ1K1bV5QvX14kJSXpa7VyTHZdl+TXOhw7dqw4ceKEuH//vrh27ZoYN26cUCqV4tChQ0II1l1mZObaMT/XYXZcD+Tn+vsY9NIpJYQQP/74o3B3dxfGxsaiUqVK0mtUSXcdO3YULi4uwsjISLi6uoq2bduKmzdvStNTUlLEpEmThLOzszAxMRG1a9cW169f12PERBkHQONn1apVUp68tK+nvrDIS+tG6nguzDk8Z+Y/bF+aBQcHazyvdu/eXQihW1t48+aNGDRokLC3txdmZmaiefPmIjw8XA9rk/Oy67okv9Zhr169pHZZsGBBUa9ePalDSgjWXWZk5toxP9dhdlwP5Of6+xgUQgiR03dnERERERERERFR/pbjY0oRERERERERERGxU4qIiIiIiIiIiHIcO6WIiIiIiIiIiCjHsVOKiIiIiIiIiIhyHDuliIiIiIiIiIgox7FTioiIiIiIiIiIchw7pYiIiIiIiIiIKMexU4qIiIiIiIiIiHIcO6WyyerVq2Frayt9nzx5MipUqJChMhQKBXbu3Kl1elhYGBQKBa5cuZKpGD+248ePQ6FQ4OXLl/oOhTIhN+/DqWPXBw8PDyxcuDBHltW1a1dMnz5d+v769Wu0a9cO1tbWubIN/v7776hYsSJSUlL0HQrpKDAwEMOGDdN3GDLpHX+IiEhdZq73stOECRPw1VdfSd+FEPjqq69gb2//Sf/u0eb69etwc3NDfHy8vkMhyjXYKUVElAHaOsDOnz8vu6j6WK5du4a9e/di8ODBUtqaNWtw8uRJnDlzBhEREbCxsfnocWSn5s2bQ6FQYOPGjfoOhXS0fft2TJ06FUDOdsgC2n9ARUREoEmTJjkWBxHRp06hUKT56dGjB0aNGoWjR4/qJb4nT55g0aJFGDdunJR24MABrF69Gr///jsiIiJQtmxZvcSWWeXKlUO1atWwYMECfYdClGuwUyqfS05O5t0JRADevXuXpfkLFiwIc3PzbIpGu8WLF+Ozzz6DlZWVlHbv3j14eXmhbNmycHZ2hkKhUJsvq+v3sfXs2RM//PCDvsMgHdnb28v2weyQ1X3U2dkZJiYm2RQNEVHuFxERIX0WLlwIa2trWdqiRYtgaWkJBwcHvcS3YsUK+Pr6wsPDQ0q7d+8eXFxc4OfnB2dnZxgaGqrNlxuuaZYuXYrk5GR9h0KUK7BT6gO//fYbypUrBzMzMzg4OKB+/fqIj4/HiRMnYGRkhMjISFn+kSNHonbt2jqVff78eTRo0AAFChSAjY0NAgICcOnSJbV8qr/0mpmZwdPTE7/++mua5d66dQtNmzaFpaUlnJyc0LVrVzx79kxrftVdHr///ju8vb1hYmKCBw8e6BSfQqHA8uXL0aZNG5ibm6NEiRLYvXu31mW9efMGzZo1Q40aNfD8+fN0aoiyQ37Yh4H3+3GRIkVgbm6ONm3aIDo6Wja9R48eaN26tSxt2LBhCAwMlL4HBgZi0KBBGDFiBAoUKIAGDRoAAObPn49y5crBwsIChQsXxoABA/Dq1SsA7x9R7dmzJ2JiYqS/Mk6ePBmA+t0i4eHhaNWqFSwtLWFtbY0OHTrgyZMn0nTV3R7r1q2Dh4cHbGxs8PnnnyMuLk7reqekpODXX39Fy5YtZesxb948nDhxAgqFQlpHDw8PTJs2DT169ICNjQ2+/PJLAMA333yDkiVLwtzcHEWLFsWECROQmJioFtfKlStRpEgRWFpaon///khOTsbs2bPh7OwMR0dHfPfdd7LYYmJi8NVXX8HR0RHW1taoW7curl69Kk2/evUq6tSpAysrK1hbW6Ny5cq4cOGCNL1ly5Y4d+4c/vnnH63rT58O1eN7gYGBePDgAYYPHy61CZUzZ86gdu3aMDMzQ+HChTFkyBDZ4wyZ2UdXr16NoKAgXL16VVre6tWrAag/vnf9+nXUrVtXOh5+9dVXUlsG/jtOzJ07Fy4uLnBwcMDAgQNl7YGIKDdzdnaWPjY2NlAoFGppqe8+VR0bp0+fDicnJ9ja2iIoKAhJSUn4+uuvYW9vDzc3N6xcuVK2rH///RcdO3aEnZ0dHBwc0KpVK4SFhaUZ3+bNm2XXND169MDgwYMRHh4OhUIhdVZl5poNkP/uKVWqFMzNzdG+fXvEx8djzZo18PDwgJ2dHQYPHizrQHr37h1Gjx6NQoUKwcLCAtWrV8fx48el6Q8ePECLFi1gZ2cHCwsLlClTBvv27ZOmN2rUCNHR0QgJCdF1UxHla+yU+r+IiAh06tQJvXr1wu3bt3H8+HG0bdsWQgjUrl0bRYsWxbp166T8SUlJWL9+PXr27KlT+XFxcejevTtOnjyJs2fPokSJEmjatKnaD9AJEyagXbt2uHr1Krp06YJOnTrh9u3bWmMOCAhAhQoVcOHCBRw4cABPnjxBhw4d0ozl9evXmDFjBpYvX46bN2/C0dFR5/iCgoLQoUMHXLt2DU2bNkXnzp01djjFxMSgYcOGePfuHY4ePQp7e3ud6okyL7/sw3/88Qd69eqFAQMG4MqVK6hTpw6mTZum0zqktmbNGhgaGuL06dP46aefAABKpRLff/89bty4gTVr1uDYsWMYPXo0AMDPz0/tL42jRo1SK1cIgdatW+P58+cICQnB4cOHce/ePXTs2FGW7969e9i5cyd+//13/P777wgJCcHMmTO1xnvt2jW8fPkSVapUkdK2b9+OL7/8Er6+voiIiMD27dulaXPmzEHZsmVx8eJFTJgwAQBgZWWF1atX49atW1i0aBF++eUXtVvM7927h/379+PAgQPYtGkTVq5ciWbNmuHRo0cICQnBrFmz8O233+Ls2bPS+jZr1gyRkZHYt28fLl68iEqVKqFevXrS8aFz585wc3PD+fPncfHiRYwZMwZGRkbSMt3d3eHo6IiTJ0+mv+Hok7F9+3a4ublhypQpUpsA3ncINWrUCG3btsW1a9ewZcsWnDp1CoMGDZLNn9F9tGPHjhg5ciTKlCkjLS91uwLen+caN24MOzs7nD9/Hr/++iuOHDmitvzg4GDcu3cPwcHBWLNmDVavXi11chER5VfHjh3D48ePceLECcyfPx+TJ09G8+bNYWdnhz/++AP9+vVDv3798PDhQwDvj7l16tSBpaUlTpw4gVOnTsHS0hKNGzfWelfTixcvcOPGDdk1zaJFizBlyhS4ubkhIiIC58+fl6Zl9JpN5fXr1/j++++xefNmHDhwQLo+3rdvH/bt24d169bh559/xm+//SbN07NnT5w+fRqbN2/GtWvX8Nlnn6Fx48a4e/cuAGDgwIFISEjAiRMncP36dcyaNQuWlpbS/MbGxihfvjyvaYh0JUgIIcTFixcFABEWFqZx+qxZs4SXl5f0fefOncLS0lK8evVKCCHEqlWrhI2NjTR90qRJonz58lqXl5SUJKysrMSePXukNACiX79+snzVq1cX/fv3F0IIcf/+fQFAXL58WQghxIQJE0TDhg1l+R8+fCgAiDt37mhc7qpVqwQAceXKFa2xpRXft99+K31/9eqVUCgUYv/+/UIIIYKDgwUA8eeff4ry5cuLtm3bioSEhDSXQ9knv+zDnTp1Eo0bN5aldezYURZ79+7dRatWrWR5hg4dKgICAqTvAQEBokKFClrXT2Xr1q3CwcFB+p66nlTc3d3FggULhBBCHDp0SBgYGIjw8HBp+s2bNwUAce7cOSHE+/o1NzcXsbGxUp6vv/5aVK9eXWssO3bsEAYGBiIlJSXNdVPF07p163TXb/bs2aJy5crSd01xNWrUSHh4eIjk5GQprVSpUmLGjBlCCCGOHj0qrK2txdu3b2VlFytWTPz0009CCCGsrKzE6tWr04ylYsWKYvLkyenGTPoXEBAghg4dKoSQ7/sqXbt2FV999ZUs7eTJk0KpVIo3b95I82V2H9V0bAIgduzYIYQQ4ueffxZ2dnbS8U0IIfbu3SuUSqWIjIwUQrw/Tri7u4ukpCQpz2effSY6duyYbkxERLmNtuuX1MdU1bEx9Tm/Vq1a0vekpCRhYWEhNm3aJIQQYsWKFaJUqVKy65OEhARhZmYmDh48qDGey5cvCwCyayUhhFiwYIFwd3eXpWXlmg2A+Pvvv6W0vn37CnNzcxEXFyelNWrUSPTt21cIIcTff/8tFAqF+Pfff2Vl16tXT4wdO1YIIUS5cuXSvV5p06aN6NGjR7oxE5EQvFPq/8qXL4969eqhXLly+Oyzz/DLL7/gxYsX0vQePXrg77//lu4MWLlyJTp06AALCwudyo+KikK/fv1QsmRJ2NjYwMbGBq9evUJ4eLgsn6+vr9p3bXeZXLx4EcHBwbC0tJQ+pUuXBvD+TgdtjI2N4ePjk6n4PpzPwsICVlZWiIqKkuWpX78+ihYtiq1bt8LY2FhrHJS98ss+fPv2bY3LyIwP/zqnEhwcjAYNGqBQoUKwsrJCt27dEB0dnaG3qNy+fRuFCxdG4cKFpTRvb2/Y2trK6sLDw0M2Lo+Li4tae/rQmzdvYGJionHMKE00rd9vv/2GmjVrwtnZGZaWlpgwYYLaNkwdl5OTE7y9vaFUKmVpqlgvXryIV69ewcHBQbYt79+/L23HESNGoE+fPqhfvz5mzpypcfuamZnh9evXOq0bfdouXryI1atXy/aHRo0aISUlBffv35fyZXYfTc/t27dRvnx52fHN398fKSkpuHPnjpRWpkwZGBgYSN/Ta4NERPlBmTJl1M755cqVk74bGBjAwcFBdh3w999/w8rKSjrm29vb4+3bt1qv5968eQMAMDU11SmmzF6zmZubo1ixYrJ18fDwkN3Z9OE1zaVLlyCEQMmSJWXnsJCQEGldhgwZgmnTpsHf3x+TJk3CtWvX1GLjNQ2R7tRHjsunDAwMcPjwYZw5cwaHDh3CDz/8gPHjx+OPP/6Ap6cnHB0d0aJFC6xatQpFixbFvn37ZM8Wp6dHjx54+vQpFi5cCHd3d5iYmMDX11engfq0/QBNSUlBixYtMGvWLLVpLi4uWsszMzNTK1PX+D583EYVW+qB0ps1a4Zt27bh1q1bshMYfVz5ZR8WQqS7PKVSqZZP0zgxqTvkHjx4gKZNm6Jfv36YOnUq7O3tcerUKfTu3TtD48wIITSuc+p0XdrThwoUKIDXr1/j3bt3OnX4pl6/s2fP4vPPP0dQUBAaNWoEGxsbbN68GfPmzZPl0xRXWrGmpKTAxcVF4/6kelPh5MmT8cUXX2Dv3r3Yv38/Jk2ahM2bN6NNmzZS3ufPn6NgwYLprhd9+lJSUtC3b18MGTJEbVqRIkWk/2d2H02PtjYIIEttkIgoP8jMdUDlypWxYcMGtbK0ndcLFCgA4P1jfLqc+zN7zZaZdTEwMMDFixdlf7QAIHVk9enTB40aNcLevXtx6NAhzJgxA/PmzZO9Gfn58+eyzjAi0o6dUh9QKBTw9/eHv78/Jk6ciP+1d7chTbVhHMD/WoRJGEFLiMrF7Jgi4gaCFVrpyJcPGSWmHFwhZIHmS0ERKmJEpWRCikSFoiKbRUp+CBUqX5r5MsQPZqHUpiZUmiEVJjh6PpSH9rjsOGVW/n/fHPe5vQb3xr3rXOe6vby8UFdXhzNnzgD4/gUUHx+PLVu2QKVSYc+ePbLnbmtrQ2lpKaKjowEAIyMjdps5d3R0QKfT2fytVqvtzqnRaHD//n0olUq7J1MshNz45Lh69SrWrVuH8PBwNDc3w8/Pb1GxkXwrYQ37+flJ1V4//4+fKRQK9PX12bzW29s7ZxPyfyaTCTMzMygsLJTuEN69e9dmzJo1a357moqfnx+Gh4cxMjIiVUv19/djcnISvr6+8147n9lGpP39/TZNSeUyGo3w8vJCVlaW9NrQ0JDD8czSaDR4+/YtVq9ebXOCzv8JggBBEJCZmYmEhASUl5dLSanZu6m/Wiv057L3mdBoNHj+/Dm8vb0XNJecNSr3M1hRUYEvX75IP2SMRiNcXV0hCMKCYiIiovlpNBrU1NRIh53IoVKp4OHhgf7+foe+l+Xs2RyhVqthtVrx/v17hISE/HLc1q1bpd5aFy5cwO3bt22SUn19fYiNjV10PEQrAR/f+6GzsxOXL1+GyWTC8PAwamtrMTY2ZvMDcvau7aVLl2Q3h57l7e2NqqoqvHjxAp2dnRBFEWvXrp0z7t69eygrK8PAwAByc3PR1dU1pzHrrJSUFExMTCAhIUE6taqpqQlJSUkLPoJUbnxyXbt2DaIoIiwsDC9fvnR4HpJvpazhtLQ0NDQ0oKCgAAMDAygpKUFDQ4PNmLCwMJhMJlRWVmJwcBC5ublzklT2qFQqzMzMoLi4GK9fv0ZVVRVu3rxpM0apVOLz58949OgRxsfH7ZZma7VaBAQEQBRF9PT0oKurCzqdDnv37rVbfi6XQqGARqPB06dPHbre29sbw8PDMBgMePXqFW7cuIG6ujqH45ml1Wqxa9cuHDp0CI2NjbBYLGhvb0d2djZMJhOmpqaQmpqK5uZmDA0NwWg0oru722ZtdnR0SNV39HdRKpVobW3F6OiolKg+f/48nj17hpSUFPT29mJwcBD19fU2G3Z75KxRpVIJs9mM3t5ejI+PY3p6es48oijCzc0Nx44dQ19fH548eYLTp08jMTERnp6eS/fmiYgIoihi48aNiImJQVtbG8xmM1paWpCeno43b97YvcbV1RVardbhPY2cPZsjBEGAKIrQ6XSora2F2WxGd3c38vPzpRP2MjIy0NjYCLPZjJ6eHjx+/NhmT2OxWDA6OgqtVrvoeIhWAialfvDw8EBrayuio6MhCAKys7NRWFiIqKgoaYyrqyuOHz8Oq9VqUwkiR1lZGT5+/Ai1Wo3ExESkpaVh06ZNc8bl5eXBYDAgICAAFRUVqK6u/mWl0ebNm2E0GmG1WhEREQF/f3+kp6dj/fr1Ns+BL2V8C1FUVIS4uDiEhYVhYGBgUXPR762UNRwcHIw7d+6guLgYgYGBaGpqQnZ2ts2YiIgI5OTk4Ny5cwgKCsKnT59kvd/AwEBcv34d+fn58Pf3R3V1Na5cuWIzZvfu3Th16hSOHj0KhUKBgoKCOfPMHk2/YcMGhIaGSn3WampqfhvD7yQnJ9stj5cjJiYGmZmZSE1NRWBgINrb26UTzxbDxcUFDx8+RGhoKJKSkiAIAuLj42GxWODp6YlVq1bhw4cP0Ol0EAQBcXFxiIqKQl5enjSHXq+HKIpwd3dfdDzkXBcvXoTFYoFKpZIewQgICEBLSwsGBwcREhICtVqNnJyceR8tB+St0SNHjiAyMhL79++HQqGAXq+fM4+7uzsaGxsxMTGBoKAgxMbGIjw8HCUlJUv3xomICMD379zW1lZs27YNhw8fhq+vL5KSkjA1NTVv5VRycjIMBoNDj03L2bM5qry8HDqdDmfPnoWPjw8OHjyIzs5OqfrdarUiJSUFvr6+iIyMhI+PD0pLS6Xr9Xo9Dhw4AC8vryWJh+hf5/JNToMWkpw4cQLv3r1DfX39codC5BCu4b/b169f4ePjA4PB8M9UFY2NjWHnzp0wmUzYvn37codDRERETvDt2zcEBwcjIyMDCQkJyx3OkpiensaOHTug1+sX1CaDaCVjTymZJicn0d3djerqajx48GC5wyFaMK7hf4ObmxsqKysd7vn2JzKbzSgtLWVCioiIaAVxcXHBrVu37J5e97caGhpCVlYWE1JEC8BKKZn27duHrq4unDx5EkVFRcsdDtGCcQ0TERERERHRn4RJKSIiIiIiIiIicjo2OiciIiIiIiIiIqdjUoqIiIiIiIiIiJyOSSkiIiIiIiIiInI6JqWIiIiIiIiIiMjpmJQiIiIiIiIiIiKnY1KKiIiIiIiIiIicjkkpIiIiIiIiIiJyOialiIiIiIiIiIjI6ZiUIiIiIiIiIiIip/sP2YaiCdqSJmoAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -1008,12 +991,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [07:16<00:07, 7.96s/it]" + " 98%|██████████████████████████████████▎| 50/51 [01:29<00:01, 1.32s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1025,8 +1008,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [07:25<00:00, 8.74s/it]\n", - "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.94model snapshot/s]\n" + "100%|███████████████████████████████████| 51/51 [01:31<00:00, 1.80s/it]\n", + "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.98model snapshot/s]\n" ] } ], @@ -1047,7 +1030,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -1232,364 +1215,364 @@ " 2953.46512017, 2279.78258046, 787.20009603],\n", " [2598.07497597, 2618.88649289, 44.46441351, ...,\n", " 2953.46512017, 2279.78258046, 787.20009603]]]),\n", - " 'params': {'Ab': array([[[-2.06924725e-02, 3.26656483e-03, 3.41935937e-03, ...,\n", - " -4.33700515e-03, 2.86403831e-03, 5.30708074e-03],\n", - " [ 4.87041717e-03, -2.38856265e-02, 1.69801945e-02, ...,\n", - " 1.59565726e-03, -7.91050276e-03, 9.16143312e-03],\n", - " [ 3.51079156e-02, -1.15464470e-02, 4.55003974e-03, ...,\n", - " 2.48087479e-02, 1.36917876e-02, -4.47039205e-03],\n", + " 'params': {'Ab': array([[[-1.53982911e-01, 4.12819775e-02, 3.56983417e-02, ...,\n", + " 2.53831787e-03, 3.05872584e-03, -3.23288053e-03],\n", + " [-5.32403886e-02, -5.58307467e-02, 5.14922451e-02, ...,\n", + " 2.27857129e-02, 1.23434474e-02, -7.58818310e-03],\n", + " [-2.69712238e-02, 7.20406725e-02, -5.03851790e-02, ...,\n", + " 2.35022169e-02, -6.98251376e-03, 3.47913149e-03],\n", " ...,\n", - " [-4.78286073e-02, 4.50328785e-02, -4.44880122e-03, ...,\n", - " -3.77905757e-02, -6.38014708e-02, -1.13437057e-04],\n", - " [-1.16375278e-02, -6.70554441e-02, 2.68830329e-02, ...,\n", - " 1.42859843e+00, 1.31460859e-01, -3.20771975e-02],\n", - " [ 4.72065490e-02, -1.12730690e-01, 6.62123942e-02, ...,\n", - " 2.55348505e-01, 1.36790121e+00, -2.05076673e-02]],\n", + " [ 6.10201844e-02, 5.41944685e-02, -5.94599980e-03, ...,\n", + " -1.00846820e-02, 1.31702812e-02, -1.09856151e-02],\n", + " [-5.19486896e-02, -7.37736563e-02, 7.82923160e-03, ...,\n", + " 1.42422307e+00, -1.59709408e-02, 2.78850164e-02],\n", + " [-1.96882946e-01, -4.40956017e-02, 5.16001984e-04, ...,\n", + " 3.31056494e-01, 1.18267950e+00, 2.05256518e-02]],\n", " \n", - " [[ 8.59128673e-03, 1.57003959e-02, 3.86181509e-02, ...,\n", - " 4.95101932e-04, 2.21678319e-02, -3.25453766e-03],\n", - " [ 1.24879884e-02, 2.46692037e-02, 6.12346851e-02, ...,\n", - " -4.23795711e-02, 2.56036472e-02, -2.68575326e-03],\n", - " [ 2.47447430e-02, 1.32843773e-01, 4.57946137e-02, ...,\n", - " 5.30135768e-02, -4.94021011e-03, 2.48758216e-03],\n", + " [[-2.67757859e-03, -8.94875791e-03, -1.77744347e-02, ...,\n", + " 3.30149536e-03, -7.32868484e-03, 2.61470999e-03],\n", + " [ 5.19549179e-02, 2.78960660e-02, 6.96562016e-03, ...,\n", + " -2.86768299e-04, 6.12163778e-03, 3.81435713e-03],\n", + " [ 1.77247937e-02, -3.46097764e-02, 2.69590827e-02, ...,\n", + " 3.70983872e-02, -3.91340293e-03, -7.88998187e-03],\n", " ...,\n", - " [-1.44848974e-01, -2.09702276e-01, -4.10479695e-03, ...,\n", - " -5.91946215e-02, -5.13529206e-02, 3.96566720e-03],\n", - " [ 9.42507446e-02, 2.05316490e-01, -1.19311106e-02, ...,\n", - " 8.59730023e-01, 2.37201325e-01, 1.38694397e-03],\n", - " [ 7.34594226e-02, 3.08898094e-02, -3.64310469e-04, ...,\n", - " 3.69236518e-01, 9.41924427e-01, -4.81807223e-03]],\n", + " [ 1.11224083e-02, 3.87726578e-03, -1.60222746e-02, ...,\n", + " -2.47435607e-02, -5.99516591e-02, 4.75697615e-03],\n", + " [ 9.62379092e-02, 9.00531392e-02, 7.80090976e-02, ...,\n", + " 1.61611017e+00, 9.11222622e-02, -3.22457786e-02],\n", + " [ 3.29463503e-02, 7.96100982e-02, -2.71320564e-03, ...,\n", + " 1.34819604e-01, 1.60765458e+00, -3.25276779e-02]],\n", " \n", - " [[ 1.20247093e-01, -3.47497571e-02, -4.57041937e-02, ...,\n", - " -7.11373466e-02, 3.08485114e-02, -1.38138492e-01],\n", - " [ 9.69638413e-03, 1.93293987e-01, 5.15327944e-02, ...,\n", - " -2.87064134e-02, 9.01911920e-02, -2.50920689e-02],\n", - " [-4.65368455e-02, 1.17400401e-01, -3.08392918e-02, ...,\n", - " 5.72640678e-04, 2.64770895e-01, -1.08044694e-01],\n", + " [[-2.11660192e-02, -8.16096503e-03, 8.60036392e-04, ...,\n", + " -3.27516434e-03, 2.91684078e-04, 7.37119596e-04],\n", + " [-9.53523814e-03, -2.10091701e-02, 6.50371854e-03, ...,\n", + " -1.04974534e-02, 2.80573352e-03, -2.12771196e-04],\n", + " [-2.74390191e-02, 2.47451106e-02, -7.82006842e-03, ...,\n", + " 9.47158778e-03, -2.44782352e-03, 8.02208089e-04],\n", " ...,\n", - " [-2.56076541e-01, -2.24732589e-01, -5.91430018e-02, ...,\n", - " 1.01973765e-02, -2.23141135e-01, -2.02668394e-02],\n", - " [ 3.68798062e-01, -4.57000355e-01, 2.16551628e-01, ...,\n", - " 1.83984137e+00, -3.57250155e-01, 1.13652046e-02],\n", - " [ 7.43054266e-02, 1.88195244e-01, -1.00637408e-02, ...,\n", - " -8.83422143e-03, 1.71646242e+00, -1.58296858e-01]],\n", + " [ 6.50509867e-02, 2.67159203e-02, 4.27947032e-02, ...,\n", + " 7.71938153e-03, 7.26048228e-03, -7.91492055e-04],\n", + " [ 2.91493426e-02, 8.20116786e-03, 2.39890283e-02, ...,\n", + " 9.11086517e-01, 4.90024624e-02, -4.36949329e-03],\n", + " [-1.06627059e-01, -3.07508734e-02, 2.95842939e-02, ...,\n", + " 3.48882247e-02, 9.33338591e-01, 3.42781590e-03]],\n", " \n", " ...,\n", " \n", - " [[-8.02561485e-02, -2.67345639e-01, 1.48784597e-01, ...,\n", - " -7.11595471e-02, -1.05404495e-01, -7.84388783e-02],\n", - " [-1.64050503e-01, -6.01442275e-05, -1.07962451e-01, ...,\n", - " 6.49584918e-02, 1.31110646e-01, -7.96326408e-02],\n", - " [ 4.26277307e-01, -1.04580158e-01, -1.34885972e-01, ...,\n", - " 4.18627675e-02, -3.83676982e-01, -1.21636669e-01],\n", + " [[-2.52851868e-02, 3.02564509e-01, 9.37405271e-02, ...,\n", + " -2.76997326e-01, 1.00700387e-01, 1.06151580e-01],\n", + " [-1.81025526e-02, 3.52783919e-01, 7.07889623e-02, ...,\n", + " -1.89341665e-01, 4.42822877e-02, 1.26335278e-01],\n", + " [ 2.46946981e-01, 6.48685838e-01, -2.40493770e-01, ...,\n", + " -4.51563240e-01, 2.86181080e-01, 5.17544148e-01],\n", " ...,\n", - " [ 1.59293603e-01, -1.19962193e-01, -2.83428976e-01, ...,\n", - " 2.35207479e-01, -2.68481536e-01, -1.40153146e-01],\n", - " [ 8.80660088e-02, 1.28068566e-01, 2.80446483e-01, ...,\n", - " 9.98458292e-01, 1.17285168e-01, -3.84234863e-02],\n", - " [ 1.90753791e-01, -1.26091031e-01, -2.64217117e-02, ...,\n", - " -7.27183155e-02, 9.03012520e-01, 1.65364691e-01]],\n", + " [-2.68289113e-02, -2.00968257e-02, 1.40764107e-01, ...,\n", + " 1.54506987e-03, -1.02680015e-01, -6.09485840e-02],\n", + " [-4.54119240e-02, -4.31943332e-01, -9.77005719e-02, ...,\n", + " 1.25194883e+00, -3.54109987e-01, -2.02682804e-01],\n", + " [-3.62363871e-01, -8.82059477e-01, 1.77577308e-01, ...,\n", + " 4.91258728e-01, 2.73743967e-01, -4.92892928e-01]],\n", " \n", - " [[ 4.70936278e-01, -3.73363663e-01, -6.27976328e-01, ...,\n", - " 1.97817531e-01, 3.48288166e-01, -1.50810946e-02],\n", - " [ 7.40181830e-01, -5.35047475e-01, -6.89500955e-01, ...,\n", - " 2.30014162e-01, 3.10876289e-01, -4.61820252e-02],\n", - " [-5.03648399e-01, 6.38845037e-01, 5.52713249e-01, ...,\n", - " -2.20202488e-01, -4.90649244e-02, 4.05891991e-02],\n", + " [[ 3.78174003e-01, -1.17290685e+00, 1.31728614e+00, ...,\n", + " -8.73662968e-02, -8.97270675e-01, 1.22156055e-01],\n", + " [-1.60161708e-01, -5.19275752e-01, 6.90602233e-01, ...,\n", + " -3.06730307e-01, -8.69668297e-01, -1.37971599e-01],\n", + " [-3.86963034e-01, 5.23597990e-01, -4.57357642e-01, ...,\n", + " 1.76539881e-01, 6.83824932e-01, 6.60977648e-03],\n", " ...,\n", - " [-8.64820793e-02, -7.50099635e-03, 1.28235092e-01, ...,\n", - " 6.18251558e-02, 1.16540078e-04, 4.17777752e-02],\n", - " [-2.32069912e-01, 1.55989631e-01, 4.52595076e-02, ...,\n", - " 9.98848697e-01, -3.35103530e-01, 6.73019754e-02],\n", - " [-6.18396455e-03, 2.68128667e-01, -7.17704673e-02, ...,\n", - " -2.66003192e-02, 9.16520943e-01, -3.87722276e-02]],\n", + " [ 2.98990226e-01, -4.71568105e-02, 1.55554889e-01, ...,\n", + " 7.81191695e-02, 3.08185085e-02, 1.51320373e-01],\n", + " [ 4.54635886e-01, -2.05036195e-01, 5.37310505e-01, ...,\n", + " 6.00947706e-01, -8.68004092e-01, 2.19251247e-03],\n", + " [ 9.23118237e-02, -7.15071778e-01, 8.18364068e-01, ...,\n", + " -4.15252472e-01, -2.37205401e-02, -2.97563409e-01]],\n", " \n", - " [[ 1.16435416e-01, -1.05767856e-01, 9.07128903e-02, ...,\n", - " 1.48807047e-01, -1.21982307e-01, -2.08682039e-01],\n", - " [ 7.09840358e-02, 1.30842315e-01, -2.32619387e-01, ...,\n", - " -2.46463942e-01, 6.23797715e-02, -2.54863198e-01],\n", - " [ 1.99167804e-01, 5.10427781e-01, -3.74466457e-01, ...,\n", - " -2.11573130e-01, 7.89507500e-02, -1.54061013e-01],\n", + " [[ 2.74380751e-01, -8.50727326e-02, 5.83458661e-02, ...,\n", + " 2.35797034e-01, 6.87540054e-04, 2.65161251e-02],\n", + " [ 3.11856850e-01, -2.38377931e-01, 4.17693250e-01, ...,\n", + " 4.21450537e-01, -1.19961012e-01, -2.77376901e-01],\n", + " [ 1.28404250e-01, -7.04360072e-02, 8.77799600e-02, ...,\n", + " 1.72907958e-01, -2.23022598e-01, 5.98242213e-02],\n", " ...,\n", - " [ 3.09856515e-01, 2.92091504e-01, -5.31511817e-01, ...,\n", - " -3.23454285e-01, -1.85420235e-01, -1.51935123e-01],\n", - " [ 3.55814756e-01, -1.34791254e-01, 2.44716123e-01, ...,\n", - " 1.22303042e+00, -1.35797757e-02, 5.98169070e-02],\n", - " [ 4.90314122e-01, -6.81795139e-01, 8.45362746e-01, ...,\n", - " 4.39627414e-01, 9.09066623e-01, 1.24151400e-02]]]),\n", - " 'Cd': array([[ 110.64499411, -48.48880982, -110.43777186, -42.27077634,\n", - " -27.59941271, -53.39617105, -26.58692662, 78.96872769,\n", - " -135.67742352, -108.2021351 , -25.92837902],\n", - " [-120.62114788, 108.77373127, -65.18103875, 44.93852059,\n", - " 26.81861306, -38.23900618, -29.08301544, -25.05192018,\n", - " -80.3229631 , -61.54389057, 67.3487427 ],\n", - " [ 70.57278269, 267.00773929, -274.52492836, -427.80684666,\n", - " 192.29009091, 102.05716918, 109.80810592, 9.47583701,\n", - " 7.96472237, -3.96139797, 801.93297589],\n", - " [-116.41351111, 428.36870447, -178.94771753, 230.22174574,\n", - " -26.56741164, 50.14114384, 26.73427954, 135.28722869,\n", - " -5.67661004, 30.86214191, -66.20402378],\n", - " [ 103.74515926, 131.29029353, -57.82323785, -255.31704534,\n", - " -161.4761854 , -291.79951192, -73.00194723, 74.14723944,\n", - " 2.45729135, 59.01470752, 40.30857056],\n", - " [ 263.93746687, 651.85449767, -39.65290304, 93.59593302,\n", - " 51.10567548, 14.08469862, -125.04989056, -127.36787445,\n", - " -33.16543299, 18.13639179, -38.31203593],\n", - " [ 219.36373645, 323.91007856, 488.34502598, -101.77846031,\n", - " -217.20491803, 73.62752918, 121.21685536, 22.48121804,\n", - " -30.28532501, -16.29945329, -387.26365973],\n", - " [ 817.05143567, -154.03019807, -213.70347546, 181.97021767,\n", - " -18.62114757, -13.33206236, 78.18665868, 38.29534826,\n", - " 23.44535667, 3.54476329, -570.94683802],\n", - " [-118.8506962 , -161.216072 , -295.09427823, -31.3343655 ,\n", - " -300.41686135, 104.61410218, 50.18727076, -97.79196887,\n", - " -95.8725502 , 61.41778056, -862.80818879],\n", - " [-261.72195702, 236.54049447, -153.29944656, 127.82960516,\n", - " -82.83406511, -190.90860945, 166.1224257 , -80.89427313,\n", - " 67.17248481, -58.01215574, 41.22468652],\n", - " [ 24.36618104, 61.28719726, -156.04636099, -94.81700361,\n", - " -251.84473859, 135.48930889, -123.1528153 , 20.33303598,\n", - " 122.07922354, -77.25957007, -938.6851994 ],\n", - " [-283.44722962, 141.50550006, -54.52091699, 89.73815536,\n", - " -15.88518548, 69.1682918 , 9.36421372, 142.05376604,\n", - " -11.63515125, 27.55444014, 71.42276528]]),\n", - " 'Q': array([[[ 1.28452154e-02, 2.37456578e-03, -2.00434488e-03, ...,\n", - " -4.68814081e-03, -6.66685797e-03, -5.56439994e-04],\n", - " [ 2.37456578e-03, 2.04699891e-02, -7.35085041e-03, ...,\n", - " 2.66319885e-02, -1.81669949e-02, -2.13159222e-03],\n", - " [-2.00434488e-03, -7.35085041e-03, 3.22755664e-02, ...,\n", - " -2.12146430e-02, 2.28406721e-02, 3.57655367e-02],\n", + " [ 5.11590780e-01, -5.62293033e-01, -9.37912053e-03, ...,\n", + " 5.48884681e-01, -5.26296606e-02, 4.31876179e-01],\n", + " [-2.29349233e-02, 8.53693258e-02, -4.79658071e-02, ...,\n", + " 6.25244746e-01, -5.11758670e-02, -3.63983406e-02],\n", + " [-3.15001731e-03, 1.93619402e-01, -3.79002803e-01, ...,\n", + " -3.68621898e-01, 9.22691602e-01, 4.83443478e-01]]]),\n", + " 'Cd': array([[ 110.63572795, -48.43469013, -110.44580328, -42.30711089,\n", + " -27.61043564, -53.41275935, -26.56659453, 78.95204464,\n", + " -135.66759282, -108.19262702, -25.88678152],\n", + " [-120.63411549, 108.79089869, -65.15097651, 44.95294272,\n", + " 26.79606583, -38.2370362 , -29.08732566, -25.0497386 ,\n", + " -80.33461248, -61.55718275, 67.37299256],\n", + " [ 70.52902305, 266.99247268, -274.56925694, -427.77816173,\n", + " 192.33836808, 102.03992325, 109.81217519, 9.46681025,\n", + " 7.97160079, -3.95816505, 801.94080799],\n", + " [-116.46307164, 428.35422372, -178.96021317, 230.23781952,\n", + " -26.57098073, 50.150056 , 26.73128045, 135.28804417,\n", + " -5.67223566, 30.85331495, -66.19968229],\n", + " [ 103.71688033, 131.31025776, -57.83967533, -255.34052863,\n", + " -161.52158714, -291.76867218, -72.99208007, 74.1548364 ,\n", + " 2.45415172, 59.01729908, 40.31607747],\n", + " [ 263.85146163, 651.89682807, -39.68148436, 93.60128668,\n", + " 51.10591505, 14.06448304, -125.03545746, -127.37638656,\n", + " -33.16161369, 18.14543614, -38.30607549],\n", + " [ 219.34747192, 323.97987245, 488.31898763, -101.81881896,\n", + " -217.18991718, 73.67485092, 121.212364 , 22.48326725,\n", + " -30.27383794, -16.29731026, -387.26401531],\n", + " [ 817.0735574 , -153.96971394, -213.68734949, 181.98731009,\n", + " -18.62617105, -13.33377667, 78.17666016, 38.29995768,\n", + " 23.43631685, 3.53951243, -570.94464425],\n", + " [-118.84699514, -161.25889607, -295.0820195 , -31.3221567 ,\n", + " -300.39283984, 104.64342636, 50.20237529, -97.79307495,\n", + " -95.87304611, 61.41678197, -862.80309528],\n", + " [-261.74014193, 236.48584091, -153.26907434, 127.83500869,\n", + " -82.87582192, -190.90683346, 166.12507984, -80.89421782,\n", + " 67.18844241, -58.00038259, 41.23963174],\n", + " [ 24.38080831, 61.26506477, -156.08532192, -94.83950548,\n", + " -251.82380581, 135.51257471, -123.1591259 , 20.315145 ,\n", + " 122.07210555, -77.25494092, -938.69171507],\n", + " [-283.46321382, 141.4799571 , -54.53119636, 89.74442335,\n", + " -15.87984934, 69.1804863 , 9.35971047, 142.05569386,\n", + " -11.63369119, 27.54444739, 71.42147379]]),\n", + " 'Q': array([[[ 2.09331300e-04, 1.10351159e-04, -5.38361595e-07, ...,\n", + " -1.51578744e-04, -4.21206677e-04, -1.00991120e-04],\n", + " [ 1.10351159e-04, 6.19736278e-04, -4.33802784e-04, ...,\n", + " 6.26071950e-04, 6.40520240e-05, 4.72561992e-04],\n", + " [-5.38361595e-07, -4.33802784e-04, 8.21826861e-04, ...,\n", + " -1.08260534e-03, 8.94406356e-04, 1.51844611e-03],\n", " ...,\n", - " [-4.68814081e-03, 2.66319885e-02, -2.12146430e-02, ...,\n", - " 1.20790359e-01, -7.69935347e-02, -7.56233531e-02],\n", - " [-6.66685797e-03, -1.81669949e-02, 2.28406721e-02, ...,\n", - " -7.69935347e-02, 2.60108365e-01, 2.62080243e-01],\n", - " [-5.56439994e-04, -2.13159222e-03, 3.57655367e-02, ...,\n", - " -7.56233531e-02, 2.62080243e-01, 4.28017507e-01]],\n", + " [-1.51578744e-04, 6.26071950e-04, -1.08260534e-03, ...,\n", + " 3.72380670e-03, -3.39573583e-03, -4.85771395e-03],\n", + " [-4.21206677e-04, 6.40520240e-05, 8.94406356e-04, ...,\n", + " -3.39573583e-03, 1.78747423e-02, 2.14321141e-02],\n", + " [-1.00991120e-04, 4.72561992e-04, 1.51844611e-03, ...,\n", + " -4.85771395e-03, 2.14321141e-02, 2.96499026e-02]],\n", " \n", - " [[ 5.64066996e-03, -2.37317677e-04, 1.04042888e-03, ...,\n", - " -4.47157019e-03, -2.38255534e-03, 1.50448409e-03],\n", - " [-2.37317677e-04, 4.13796037e-03, -1.37542246e-03, ...,\n", - " 3.72734494e-03, -5.35572781e-04, 1.63514616e-04],\n", - " [ 1.04042888e-03, -1.37542246e-03, 6.79463545e-03, ...,\n", - " -8.08510577e-03, -1.09734598e-03, 3.44110002e-03],\n", + " [[ 2.96455185e-03, 2.01443293e-03, -1.49553577e-03, ...,\n", + " -1.02788358e-03, -2.00996844e-03, -7.18834111e-04],\n", + " [ 2.01443293e-03, 8.55639167e-03, -3.92319196e-03, ...,\n", + " 5.41649280e-03, -3.02551403e-04, 4.12406346e-03],\n", + " [-1.49553577e-03, -3.92319196e-03, 1.32078147e-02, ...,\n", + " -5.43353460e-03, 6.14751301e-03, 9.51386584e-03],\n", " ...,\n", - " [-4.47157019e-03, 3.72734494e-03, -8.08510577e-03, ...,\n", - " 2.89543885e-02, 1.26171821e-03, -8.39802402e-03],\n", - " [-2.38255534e-03, -5.35572781e-04, -1.09734598e-03, ...,\n", - " 1.26171821e-03, 2.75421032e-02, 2.02652404e-02],\n", - " [ 1.50448409e-03, 1.63514616e-04, 3.44110002e-03, ...,\n", - " -8.39802402e-03, 2.02652404e-02, 3.71371696e-02]],\n", + " [-1.02788358e-03, 5.41649280e-03, -5.43353460e-03, ...,\n", + " 3.87073587e-02, -2.84682338e-02, -3.45563568e-02],\n", + " [-2.00996844e-03, -3.02551403e-04, 6.14751301e-03, ...,\n", + " -2.84682338e-02, 1.55382028e-01, 1.60619517e-01],\n", + " [-7.18834111e-04, 4.12406346e-03, 9.51386584e-03, ...,\n", + " -3.45563568e-02, 1.60619517e-01, 2.56029624e-01]],\n", " \n", - " [[ 8.21234738e-01, 5.29164940e-03, -2.29852676e-01, ...,\n", - " 3.06463486e-01, 1.16187003e-01, 3.24706939e-01],\n", - " [ 5.29164940e-03, 5.20236529e-01, 2.76056267e-01, ...,\n", - " -4.92315344e-01, -5.17337637e-01, -1.86465458e-01],\n", - " [-2.29852676e-01, 2.76056267e-01, 1.44054923e+00, ...,\n", - " -1.37158990e-01, -5.90337265e-01, -1.40763224e-01],\n", + " [[ 2.21745389e-05, 6.97821109e-06, 9.96328709e-06, ...,\n", + " -2.59390940e-05, -6.57161565e-06, 3.21410359e-05],\n", + " [ 6.97821109e-06, 5.64856907e-05, -2.60206625e-05, ...,\n", + " 2.06986330e-05, 1.01886061e-04, 1.58393704e-04],\n", + " [ 9.96328709e-06, -2.60206625e-05, 7.56030108e-05, ...,\n", + " -3.02946853e-05, -9.75842081e-05, -1.04062373e-04],\n", " ...,\n", - " [ 3.06463486e-01, -4.92315344e-01, -1.37158990e-01, ...,\n", - " 2.07970578e+00, 6.58779134e-01, 9.05127375e-01],\n", - " [ 1.16187003e-01, -5.17337637e-01, -5.90337265e-01, ...,\n", - " 6.58779134e-01, 1.44765674e+00, 4.59145906e-01],\n", - " [ 3.24706939e-01, -1.86465458e-01, -1.40763224e-01, ...,\n", - " 9.05127375e-01, 4.59145906e-01, 1.65692542e+00]],\n", + " [-2.59390940e-05, 2.06986330e-05, -3.02946853e-05, ...,\n", + " 3.12136392e-04, 5.27565597e-05, -1.41126409e-04],\n", + " [-6.57161565e-06, 1.01886061e-04, -9.75842081e-05, ...,\n", + " 5.27565597e-05, 7.47971827e-04, 6.48942389e-04],\n", + " [ 3.21410359e-05, 1.58393704e-04, -1.04062373e-04, ...,\n", + " -1.41126409e-04, 6.48942389e-04, 1.70168696e-03]],\n", " \n", " ...,\n", " \n", - " [[ 2.18673955e-03, -5.09551099e-04, 2.18086905e-03, ...,\n", - " 1.77650348e-03, -3.07439898e-04, -1.25071895e-05],\n", - " [-5.09551099e-04, 7.60818465e-04, -3.37632955e-04, ...,\n", - " -5.27993245e-04, 6.76095127e-06, 2.07566290e-04],\n", - " [ 2.18086905e-03, -3.37632955e-04, 9.12556922e-03, ...,\n", - " 5.97871840e-03, -7.16710250e-04, -1.35580170e-04],\n", + " [[ 1.93866634e-03, 7.30807522e-04, 1.36585884e-03, ...,\n", + " -1.46488373e-05, -1.36598782e-03, -2.79823554e-03],\n", + " [ 7.30807522e-04, 2.08623681e-03, 2.18251767e-03, ...,\n", + " 7.67293221e-04, -1.79855339e-03, -2.49330318e-03],\n", + " [ 1.36585884e-03, 2.18251767e-03, 7.45311378e-03, ...,\n", + " -9.29027473e-04, -4.81703413e-03, -9.76595280e-03],\n", " ...,\n", - " [ 1.77650348e-03, -5.27993245e-04, 5.97871840e-03, ...,\n", - " 6.60500936e-03, -1.16028387e-03, -8.60991571e-04],\n", - " [-3.07439898e-04, 6.76095127e-06, -7.16710250e-04, ...,\n", - " -1.16028387e-03, 2.14025144e-03, -6.59681225e-04],\n", - " [-1.25071895e-05, 2.07566290e-04, -1.35580170e-04, ...,\n", - " -8.60991571e-04, -6.59681225e-04, 1.70056021e-03]],\n", + " [-1.46488373e-05, 7.67293221e-04, -9.29027473e-04, ...,\n", + " 3.64520790e-03, -9.70011547e-04, 4.23110913e-05],\n", + " [-1.36598782e-03, -1.79855339e-03, -4.81703413e-03, ...,\n", + " -9.70011547e-04, 5.33991417e-03, 8.84058172e-03],\n", + " [-2.79823554e-03, -2.49330318e-03, -9.76595280e-03, ...,\n", + " 4.23110913e-05, 8.84058172e-03, 1.97851566e-02]],\n", " \n", - " [[ 4.97318159e-02, 5.40139383e-02, -3.03612818e-02, ...,\n", - " -1.62869882e-02, -1.98754622e-03, -5.62059726e-04],\n", - " [ 5.40139383e-02, 6.02049528e-02, -3.32407569e-02, ...,\n", - " -1.75693149e-02, -2.50555050e-03, -1.47042269e-04],\n", - " [-3.03612818e-02, -3.32407569e-02, 2.25677144e-02, ...,\n", - " 8.95849828e-03, 2.08314236e-03, 1.10147145e-03],\n", + " [[ 4.83643736e-02, 3.02049175e-02, -2.38328503e-02, ...,\n", + " 5.35681952e-03, 2.65779041e-02, 3.37207291e-02],\n", + " [ 3.02049175e-02, 3.39415008e-02, -1.75435768e-02, ...,\n", + " -3.79772484e-03, 2.28600861e-02, 3.54828167e-02],\n", + " [-2.38328503e-02, -1.75435768e-02, 1.58165878e-02, ...,\n", + " -6.45339391e-04, -1.46618042e-02, -2.06563499e-02],\n", " ...,\n", - " [-1.62869882e-02, -1.75693149e-02, 8.95849828e-03, ...,\n", - " 6.83894310e-03, -1.05094344e-04, -1.85184924e-05],\n", - " [-1.98754622e-03, -2.50555050e-03, 2.08314236e-03, ...,\n", - " -1.05094344e-04, 2.06637818e-03, -2.53423661e-06],\n", - " [-5.62059726e-04, -1.47042269e-04, 1.10147145e-03, ...,\n", - " -1.85184924e-05, -2.53423661e-06, 1.54085023e-03]],\n", + " [ 5.35681952e-03, -3.79772484e-03, -6.45339391e-04, ...,\n", + " 6.51866048e-03, 1.28205561e-03, -4.28451410e-03],\n", + " [ 2.65779041e-02, 2.28600861e-02, -1.46618042e-02, ...,\n", + " 1.28205561e-03, 1.98335590e-02, 2.38836371e-02],\n", + " [ 3.37207291e-02, 3.54828167e-02, -2.06563499e-02, ...,\n", + " -4.28451410e-03, 2.38836371e-02, 3.98071491e-02]],\n", " \n", - " [[ 2.97722048e-03, 4.26279990e-04, 4.39543009e-04, ...,\n", - " 3.84255812e-04, 1.96584418e-03, 3.07634608e-03],\n", - " [ 4.26279990e-04, 6.81285550e-03, 4.79798832e-03, ...,\n", - " 5.84703006e-03, -1.29884540e-04, -6.07676947e-03],\n", - " [ 4.39543009e-04, 4.79798832e-03, 5.34630759e-03, ...,\n", - " 5.20138989e-03, 8.27506487e-05, -5.51552849e-03],\n", + " [[ 1.92486192e-03, 2.02852510e-03, 4.96675344e-04, ...,\n", + " 1.55398111e-03, -6.63426238e-04, -1.57747047e-03],\n", + " [ 2.02852510e-03, 5.72044594e-03, 1.29772574e-04, ...,\n", + " -1.23931664e-03, -7.84200416e-04, -6.68117174e-03],\n", + " [ 4.96675344e-04, 1.29772574e-04, 1.32088780e-03, ...,\n", + " 1.49804233e-03, -2.15756594e-04, 2.97024414e-04],\n", " ...,\n", - " [ 3.84255812e-04, 5.84703006e-03, 5.20138989e-03, ...,\n", - " 6.89397960e-03, -1.65158183e-04, -6.78483441e-03],\n", - " [ 1.96584418e-03, -1.29884540e-04, 8.27506487e-05, ...,\n", - " -1.65158183e-04, 3.64178385e-03, 4.69067227e-03],\n", - " [ 3.07634608e-03, -6.07676947e-03, -5.51552849e-03, ...,\n", - " -6.78483441e-03, 4.69067227e-03, 1.59916795e-02]]]),\n", - " 'betas': array([0.05731398, 0.01778557, 0.01335879, 0.01792281, 0.01088127,\n", - " 0.01530972, 0.01136227, 0.01388199, 0.01896434, 0.01093483,\n", - " 0.01087605, 0.00835733, 0.00831102, 0.01239526, 0.01308674,\n", - " 0.01262108, 0.01116312, 0.0122615 , 0.01461413, 0.00741105,\n", - " 0.01136812, 0.00996195, 0.00961429, 0.00910406, 0.0133204 ,\n", - " 0.01187114, 0.01271353, 0.01088982, 0.01441224, 0.00671271,\n", - " 0.00841476, 0.01193657, 0.01291385, 0.0079062 , 0.01032601,\n", - " 0.0108425 , 0.00775068, 0.00942677, 0.01147935, 0.00885915,\n", - " 0.01023143, 0.00990454, 0.01051822, 0.00386523, 0.00698305,\n", - " 0.00862239, 0.00633716, 0.00643487, 0.0108656 , 0.0125964 ,\n", - " 0.00859221, 0.0108246 , 0.01284531, 0.00473315, 0.00805283,\n", - " 0.00604105, 0.00703535, 0.00471456, 0.0082079 , 0.00875534,\n", - " 0.01286313, 0.01225529, 0.00851792, 0.00866596, 0.00769813,\n", - " 0.01029309, 0.00827484, 0.00536362, 0.00511364, 0.00852089,\n", - " 0.00564264, 0.01157945, 0.00708679, 0.00986283, 0.00720775,\n", - " 0.00931133, 0.00760419, 0.00819804, 0.00750677, 0.00308144,\n", - " 0.00600542, 0.0089513 , 0.00969988, 0.01281015, 0.00634865,\n", - " 0.0048979 , 0.01052288, 0.00660107, 0.00560497, 0.00644623,\n", - " 0.00601456, 0.0056466 , 0.00836808, 0.00751447, 0.0127619 ,\n", - " 0.01263546, 0.01292155, 0.00645693, 0.00538398, 0.0049621 ]),\n", - " 'pi': array([[9.50845799e-01, 1.43410779e-02, 1.57574570e-02, ...,\n", - " 3.96715593e-25, 9.79570784e-06, 1.13452933e-06],\n", - " [9.42085162e-03, 9.77255268e-01, 1.86828531e-03, ...,\n", - " 2.47451451e-07, 9.30163536e-06, 3.34162444e-13],\n", - " [1.85760879e-02, 1.07615314e-03, 9.79067407e-01, ...,\n", - " 5.02978541e-22, 1.28154536e-38, 8.08360999e-19],\n", + " [ 1.55398111e-03, -1.23931664e-03, 1.49804233e-03, ...,\n", + " 1.52577980e-02, -3.80001609e-03, 4.06658065e-03],\n", + " [-6.63426238e-04, -7.84200416e-04, -2.15756594e-04, ...,\n", + " -3.80001609e-03, 2.07300515e-03, 9.95363252e-04],\n", + " [-1.57747047e-03, -6.68117174e-03, 2.97024414e-04, ...,\n", + " 4.06658065e-03, 9.95363252e-04, 1.17668485e-02]]]),\n", + " 'betas': array([0.02093027, 0.04433044, 0.03257723, 0.01452891, 0.01059643,\n", + " 0.01415354, 0.01509698, 0.01932865, 0.01386115, 0.01831441,\n", + " 0.01352736, 0.00970667, 0.01048739, 0.00914973, 0.01161798,\n", + " 0.0148406 , 0.01129494, 0.01077487, 0.00839195, 0.01457234,\n", + " 0.01093394, 0.01121382, 0.01294141, 0.00957725, 0.01107044,\n", + " 0.00805891, 0.01333567, 0.00926428, 0.01361277, 0.01092364,\n", + " 0.01276688, 0.00636241, 0.01379085, 0.01153766, 0.00898057,\n", + " 0.01027668, 0.00839683, 0.01367743, 0.00978715, 0.01045105,\n", + " 0.01004573, 0.00996932, 0.01125164, 0.0073462 , 0.00493763,\n", + " 0.01000278, 0.00583131, 0.01029857, 0.01193905, 0.01021769,\n", + " 0.01180029, 0.0090723 , 0.00366352, 0.0087079 , 0.00800139,\n", + " 0.0088301 , 0.00608881, 0.00846854, 0.00572579, 0.00829844,\n", + " 0.00548423, 0.00696303, 0.00560783, 0.00724517, 0.01002927,\n", + " 0.00622434, 0.00706113, 0.00559207, 0.01293964, 0.00807623,\n", + " 0.00534817, 0.00671696, 0.00671181, 0.00777022, 0.00816161,\n", + " 0.00669397, 0.00694471, 0.00255705, 0.00683904, 0.00711503,\n", + " 0.01070357, 0.01097518, 0.00720736, 0.00581634, 0.00531247,\n", + " 0.00848417, 0.00729274, 0.00861479, 0.0046423 , 0.00626163,\n", + " 0.00400566, 0.00601735, 0.00919368, 0.00675236, 0.00712233,\n", + " 0.01224724, 0.00570069, 0.01209591, 0.00479184, 0.01114241]),\n", + " 'pi': array([[9.64073828e-01, 1.01989876e-02, 1.72021961e-02, ...,\n", + " 1.30926346e-04, 1.85744203e-38, 2.12978742e-06],\n", + " [1.29896281e-02, 9.62927552e-01, 1.90791029e-03, ...,\n", + " 2.31838650e-14, 1.62216172e-08, 9.74354383e-12],\n", + " [1.36231564e-02, 1.65077520e-03, 9.79113906e-01, ...,\n", + " 4.96543726e-05, 4.27582328e-34, 2.61608867e-06],\n", " ...,\n", - " [1.42176422e-05, 4.34543038e-11, 8.26224568e-06, ...,\n", - " 9.99830456e-01, 3.26803257e-13, 5.05168046e-57],\n", - " [5.86223318e-05, 7.31662314e-11, 5.84107673e-07, ...,\n", - " 5.69891472e-11, 9.99431404e-01, 1.78612348e-58],\n", - " [6.26611959e-07, 2.81770368e-09, 1.66873245e-06, ...,\n", - " 1.44684916e-04, 6.23726547e-20, 9.99518165e-01]]),\n", + " [2.21837265e-05, 1.38136979e-06, 2.62219359e-05, ...,\n", + " 9.98981928e-01, 4.94045071e-26, 1.50796609e-18],\n", + " [5.16992671e-13, 4.49291664e-08, 1.77835430e-05, ...,\n", + " 9.38591218e-10, 9.99427961e-01, 3.40220673e-11],\n", + " [5.61871792e-05, 4.73287984e-05, 3.25998056e-06, ...,\n", + " 4.61823289e-15, 1.80377792e-13, 9.99207911e-01]]),\n", " 'sigmasq': array([1., 1., 1., 1., 1., 1., 1.])},\n", " 'seed': array([1900188647, 357198569], dtype=uint32),\n", - " 'states': {'h': array([[-1.50061132, 1.93482084, -0.37980881, ..., -0.60917404,\n", - " -0.59343221, -0.58538017],\n", - " [-0.21438029, 1.84756507, -0.26370478, ..., 2.95397652,\n", - " 2.93513517, 2.93099418],\n", - " [-1.91567058, 0.07391241, -0.19551943, ..., 2.57196022,\n", - " 2.50976271, 2.51840594]]),\n", - " 's': array([[[1.84178597e+05, 9.65479190e+05, 3.14454241e+04, ...,\n", - " 1.60532611e+06, 5.76869439e+06, 2.39781476e+06],\n", - " [2.68582513e+05, 5.18951089e+03, 3.06599392e+03, ...,\n", - " 5.54029027e+03, 1.20564509e+07, 1.03075003e+06],\n", - " [4.47067166e+05, 6.60931206e+01, 7.47799654e+04, ...,\n", - " 1.19208022e+06, 3.73353659e+00, 1.40591325e+01],\n", + " 'states': {'h': array([[ 0.99484833, -1.7092855 , -0.58182683, ..., -0.60159786,\n", + " -0.59517311, -0.5875055 ],\n", + " [-0.25297213, -0.39526738, -0.2599679 , ..., 2.99117381,\n", + " 2.99701769, 3.0479003 ],\n", + " [ 0.20464304, -0.27165794, -0.37575905, ..., 2.53880967,\n", + " 2.52519411, 2.53579212]]),\n", + " 's': array([[[3.84799616e+04, 1.75324574e+05, 7.02235336e+05, ...,\n", + " 1.71877174e+06, 1.89225911e+06, 1.70550580e+05],\n", + " [6.30220864e+05, 9.50225057e+04, 1.37999884e+05, ...,\n", + " 1.25273367e+06, 2.49383095e+07, 2.38410350e+05],\n", + " [2.88667319e+06, 9.49283118e+00, 3.09327654e+00, ...,\n", + " 1.30216168e+05, 2.00260187e+00, 1.35936358e+05],\n", " ...,\n", - " [1.01838579e+02, 2.09586790e+00, 9.13743535e+01, ...,\n", - " 8.59873467e+02, 2.32974028e+05, 2.75521921e+02],\n", - " [3.97673952e+01, 1.88754871e+01, 1.51926103e+01, ...,\n", - " 1.49698149e+02, 2.86353388e+05, 1.93701490e+01],\n", - " [2.56321140e+00, 4.75439997e+01, 4.38902985e+00, ...,\n", - " 5.11994417e+00, 2.27166593e+05, 5.14813498e+00]],\n", + " [6.14326571e+00, 2.49589860e+02, 5.58494190e+00, ...,\n", + " 1.64765321e+01, 2.17999544e+05, 3.07383574e+00],\n", + " [1.37291987e+01, 5.54838046e+02, 2.42849246e+00, ...,\n", + " 7.19300789e+00, 2.60080992e+05, 4.37602915e+00],\n", + " [1.53003753e+00, 6.54871707e+02, 1.52440449e+00, ...,\n", + " 2.10359514e+00, 2.12800332e+05, 6.91514473e+00]],\n", " \n", - " [[6.45921300e+05, 1.12338421e+04, 1.22462122e+05, ...,\n", - " 1.52183249e+06, 7.94943319e+04, 3.12904837e+05],\n", - " [5.65470155e+04, 1.14946072e+04, 8.98112259e+04, ...,\n", - " 1.04548310e+05, 4.92498751e+04, 5.56345086e+05],\n", - " [3.68808448e+00, 6.04713788e+00, 2.05180557e+01, ...,\n", - " 1.17227605e+04, 1.94122053e+03, 2.86645208e+00],\n", + " [[4.12711457e+05, 5.49727631e+04, 7.85461018e+04, ...,\n", + " 4.89087727e+05, 4.31801591e+04, 1.99221939e+05],\n", + " [2.76844150e+03, 1.99408425e+04, 1.36571170e+04, ...,\n", + " 3.38289159e+05, 1.03153683e+04, 2.91155786e+04],\n", + " [3.07799894e+00, 6.38422471e+01, 3.02877234e+00, ...,\n", + " 2.91485622e+00, 2.94812076e+03, 3.28529796e+00],\n", " ...,\n", - " [6.45271005e+05, 3.85588589e+02, 1.51261573e+02, ...,\n", - " 9.41280302e+02, 1.21005574e+03, 1.95518593e+05],\n", - " [4.97851706e+05, 4.40083082e+02, 3.73157917e+01, ...,\n", - " 1.29070528e+03, 6.96373792e+02, 5.89741066e+02],\n", - " [5.95095284e+04, 4.96947105e+02, 9.65582976e+01, ...,\n", - " 2.06456265e+03, 2.45997583e+03, 1.57549998e+03]],\n", + " [5.12824536e+05, 2.49638679e+02, 9.83244575e+01, ...,\n", + " 1.11050492e+03, 1.23819881e+03, 2.02802622e+05],\n", + " [2.67238310e+05, 2.17675804e+02, 1.76306466e+01, ...,\n", + " 1.31268597e+03, 8.45966912e+02, 9.31457651e+02],\n", + " [1.65308201e+03, 5.14142424e+02, 1.16536406e+02, ...,\n", + " 1.09036416e+03, 1.95002823e+03, 4.62451818e+03]],\n", " \n", - " [[4.34206131e+05, 8.19906785e+04, 3.87218157e+04, ...,\n", - " 5.22635837e+06, 1.50658963e+04, 1.57238279e+05],\n", - " [2.99328448e+04, 3.81443498e+04, 1.94583972e+06, ...,\n", - " 8.36252058e+06, 4.24981950e+04, 4.02053312e+05],\n", - " [1.52678050e+03, 1.55969695e+03, 5.53512261e+03, ...,\n", - " 3.05503953e+06, 4.31970912e+02, 5.56369162e+05],\n", + " [[1.25540708e+05, 7.05493615e+04, 6.96139179e+05, ...,\n", + " 1.35601847e+05, 2.64889887e+06, 3.29041459e+05],\n", + " [3.84398612e+05, 3.49005473e+05, 1.32136949e+06, ...,\n", + " 8.19485940e+05, 1.67386939e+04, 7.58741000e+05],\n", + " [2.08200814e+06, 1.48003519e+05, 2.05479336e+05, ...,\n", + " 1.00245113e+03, 2.97232106e+02, 3.71181882e+05],\n", " ...,\n", - " [9.72913414e+02, 1.84504972e+03, 2.44080863e+01, ...,\n", - " 1.10914265e+03, 8.05232137e+03, 4.28575449e+02],\n", - " [2.72307030e+03, 3.59169613e+03, 1.03541077e+02, ...,\n", - " 3.15193513e+03, 2.32009582e+03, 3.13914477e+02],\n", - " [1.72251542e+03, 1.35246943e+03, 1.57423021e+01, ...,\n", - " 1.37790913e+03, 2.19923038e+03, 1.24330612e+03]]]),\n", - " 'v': array([[[8026.24657812, 3697.32296741],\n", - " [8026.37362914, 3698.55670213],\n", - " [8025.73317697, 3700.20093488],\n", + " [8.78457952e+02, 1.96442522e+03, 2.29832789e+01, ...,\n", + " 1.07200314e+03, 8.02971807e+03, 3.82331687e+02],\n", + " [2.44480960e+03, 3.57062342e+03, 6.26085371e+01, ...,\n", + " 3.11684439e+03, 2.20024183e+03, 2.92227268e+02],\n", + " [1.74215638e+03, 1.34556678e+03, 1.81966195e+01, ...,\n", + " 1.37836841e+03, 2.18950585e+03, 1.24011380e+03]]]),\n", + " 'v': array([[[8050.03559675, 3702.83806187],\n", + " [8050.42619232, 3703.40988091],\n", + " [8050.03557475, 3704.48351231],\n", " ...,\n", - " [2865.30238923, 4420.85651395],\n", - " [2865.75487688, 4419.30536323],\n", - " [2866.58566922, 4417.54757887]],\n", + " [2843.03420255, 4382.24777495],\n", + " [2842.80015709, 4381.04864993],\n", + " [2842.96471318, 4379.79813072]],\n", " \n", - " [[2996.92196117, 4320.71063133],\n", - " [2997.43179382, 4321.31267698],\n", - " [2997.69442081, 4320.99141055],\n", + " [[3022.09911392, 4376.61196051],\n", + " [3022.60909437, 4377.23664184],\n", + " [3022.89694819, 4376.95510555],\n", " ...,\n", - " [7490.37932519, 3373.8249364 ],\n", - " [7490.75524213, 3374.45276973],\n", - " [7490.60749651, 3374.6025728 ]],\n", + " [7458.24743252, 3397.73082149],\n", + " [7458.93717117, 3398.11112289],\n", + " [7458.98875566, 3398.22611581]],\n", " \n", - " [[6811.43101345, 3528.67558513],\n", - " [6811.42135035, 3528.58807986],\n", - " [6811.8057084 , 3528.04497755],\n", + " [[6809.42460033, 3516.23637868],\n", + " [6809.41483751, 3516.15087834],\n", + " [6809.78202029, 3515.61736752],\n", " ...,\n", - " [7848.36226247, 4103.504873 ],\n", - " [7848.57917763, 4102.43613094],\n", - " [7847.27680934, 4107.74845551]]]),\n", - " 'x': array([[[-2.83144895, 5.47072645, 0.03235018, ..., -2.38199327,\n", - " -0.35826233, 0.69273339],\n", - " [ 2.30826123, -0.94204177, 1.177674 , ..., 2.43322765,\n", - " -1.80074765, -0.33016114],\n", - " [ 1.49987083, 0.15628778, 3.04282758, ..., 1.58397287,\n", - " -1.98836335, -1.71652419],\n", + " [7845.95385727, 4106.84237137],\n", + " [7842.92726718, 4107.45442275],\n", + " [7844.36823497, 4110.94782574]]]),\n", + " 'x': array([[[-2.59643612e+00, -4.02905609e-01, -7.75981239e-01, ...,\n", + " 4.09290801e+00, 2.05372062e+00, -1.28954330e+00],\n", + " [ 1.92305263e+00, 2.60480419e+00, 3.78150378e+00, ...,\n", + " -1.05387636e+00, 7.89952574e+00, -1.18404788e+00],\n", + " [-1.31972055e+00, -8.12064718e-01, 2.47874017e+00, ...,\n", + " 9.51891933e-01, 2.90801115e+00, 4.88621710e+00],\n", " ...,\n", - " [-0.23969379, -0.51693544, 0.57945366, ..., 0.11099648,\n", - " 1.69500415, -0.98565025],\n", - " [-0.27669168, -0.51341797, 0.52133834, ..., 0.07328125,\n", - " 1.73136632, -1.0919636 ],\n", - " [-0.26968947, -0.545851 , 0.46828232, ..., 0.07061802,\n", - " 1.72419886, -1.05364915]],\n", + " [-1.97378642e-01, -5.59520224e-01, 5.86221465e-01, ...,\n", + " 4.52656468e-01, 1.53051045e+00, -7.90372406e-01],\n", + " [-2.05148646e-01, -5.62910104e-01, 5.55893335e-01, ...,\n", + " 4.15947754e-01, 1.54183789e+00, -6.28873535e-01],\n", + " [-2.00205585e-01, -5.88130193e-01, 5.52535006e-01, ...,\n", + " 4.56458187e-01, 1.47855009e+00, -7.08370912e-01]],\n", " \n", - " [[ 0.90877067, -1.47585247, -3.77789401, ..., -1.9912207 ,\n", - " -0.26005175, -1.58638555],\n", - " [ 1.53636323, 0.01714602, 0.44108273, ..., -2.94712004,\n", - " -0.16663191, 1.94340658],\n", - " [-0.66039338, -0.90144532, -0.12822923, ..., 0.0274604 ,\n", - " -2.07939582, 3.1828268 ],\n", + " [[-9.82717412e-01, 5.76942832e-02, -2.02981080e+00, ...,\n", + " 1.44629823e+00, 9.54894070e-01, -1.18600764e-01],\n", + " [-1.54938883e+00, -3.61961759e-01, 1.98749466e-01, ...,\n", + " 7.59491448e-01, -2.36944873e+00, 3.57700296e+00],\n", + " [-4.52241236e-01, -8.74698715e-01, -1.57956156e-01, ...,\n", + " -8.74180338e-03, -1.81352420e+00, 2.86648400e+00],\n", " ...,\n", - " [ 1.07785249, -0.56546964, 0.71176997, ..., -2.3197799 ,\n", - " 1.1585705 , 2.37756583],\n", - " [ 1.02984621, -0.62052006, 0.74523202, ..., -2.27465805,\n", - " 1.2316048 , 2.3470011 ],\n", - " [ 1.17146997, -0.59684397, 0.65561112, ..., -2.21102291,\n", - " 0.87360245, 2.38234237]],\n", + " [ 1.10649457e+00, -3.94102871e-01, 5.89117352e-01, ...,\n", + " -1.51478293e+00, 8.12980589e-01, 2.83451014e+00],\n", + " [ 1.23347114e+00, -2.62398490e-01, 3.87767237e-01, ...,\n", + " -1.08039528e+00, 2.56912951e-01, 2.46048225e+00],\n", + " [ 1.24092248e+00, -1.07630601e-01, 2.72237514e-01, ...,\n", + " -6.37083682e-01, -2.54402576e-01, 1.94827560e+00]],\n", " \n", - " [[-6.9906762 , 1.09642782, 0.93850708, ..., -5.2162684 ,\n", - " -2.62948486, 2.19243255],\n", - " [-1.84125173, -2.9742889 , -6.83505597, ..., 1.6867402 ,\n", - " 4.07823474, 11.03732547],\n", - " [ 1.75401938, -3.26747355, -5.63211929, ..., -4.38939849,\n", - " 0.03374927, 5.48387379],\n", + " [[ 1.13565152e+00, -1.92124063e-01, 2.29239851e+00, ...,\n", + " 2.20572696e+00, 3.83609912e+00, 4.57282000e+00],\n", + " [-8.86127818e-01, -2.58494906e-01, 3.61405553e+00, ...,\n", + " -1.30140805e+00, -4.92545572e+00, 1.97588978e+00],\n", + " [ 5.70642449e-01, 6.06114982e-01, -9.40399547e-01, ...,\n", + " 2.40914680e+00, -9.82384794e+00, -3.29730532e+00],\n", " ...,\n", - " [ 0.4388598 , -0.24130453, -0.37537376, ..., -0.47608676,\n", - " 0.55814246, -0.83161472],\n", - " [ 0.44024749, -0.19777914, -0.41901244, ..., -0.40757775,\n", - " 0.65961333, -0.79460882],\n", - " [ 0.43190966, -0.19731401, -0.38574877, ..., -0.40863406,\n", - " 0.56386813, -0.74879204]]]),\n", - " 'z': array([[77, 77, 77, ..., 3, 3, 3],\n", - " [89, 89, 89, ..., 1, 1, 1],\n", - " [ 3, 3, 3, ..., 22, 22, 22]])}}" + " [ 4.44793866e-01, -2.05755161e-01, -3.66605102e-01, ...,\n", + " -4.48468295e-01, 5.72179706e-01, -8.01766072e-01],\n", + " [ 4.37840849e-01, -2.06890099e-01, -3.72656615e-01, ...,\n", + " -4.40305930e-01, 5.60456893e-01, -7.99919827e-01],\n", + " [ 4.33628223e-01, -2.03240260e-01, -3.76444819e-01, ...,\n", + " -4.09758966e-01, 5.66955809e-01, -7.81493027e-01]]]),\n", + " 'z': array([[73, 73, 73, ..., 4, 4, 4],\n", + " [72, 72, 72, ..., 1, 1, 1],\n", + " [ 2, 2, 2, ..., 38, 38, 38]])}}" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -1609,7 +1592,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -1621,7 +1604,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAARMAAAC+CAYAAAAWXOs8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAnD0lEQVR4nO3deVxTV/o/8E/CEgg7sisgi9YNXEARrGsrVFu1tVXcqS2tlGmtolIZxwXrUm0Ffq3FfZfOMK3aqQ5W+NaqoGhdQFAUFZA1QMO+JyT39weSKQY0FwIh8Lxfr7xMTu7y5Jo8nHvuuedwGIZhQAghHcRVdQCEkJ6BkgkhRCkomRBClIKSCSFEKSiZEEKUgpIJIUQpKJkQQpSiQ8mkvr5eWXEQQtScJtsVpFIptm7dir1796KoqAiPHj2Co6Mj1q9fj/79++PDDz/sjDiVRiqVoqCgAAYGBuBwOKoOh5BujWEYVFVVwcbGBlzuS+oeDEuhoaGMo6Mjc/LkSUZXV5fJyMhgGIZhoqOjmbFjx7LdXJfLzc1lANCDHvRg8cjNzX3pb4vDMOy60zs7O2Pfvn147bXXYGBggLt378LR0REPHz6Ep6cnysrKFN7WlStX8PXXX+P27dsQCAQ4c+YM3n777Reuc/nyZQQFBeH+/fuwsbFBcHAwAgICFN5nRUUFjI2NkZubC0NDQ4XX683EYjFiY2Ph7e0NLS0tVYej9tTpeFZWVsLW1hbl5eUwMjJ64bKsT3Py8/Ph7OwsVy6VSiEWi1ltq6amBsOHD8fSpUvx7rvvvnT5rKwsTJ8+HR999BFOnjyJq1evIjAwEObm5gqtD0B2amNoaEjJREFisRh8Ph+Ghobd/suvDtTxeCrSJMA6mQwdOhTx8fGwt7dvUf7jjz9i5MiRrLY1bdo0TJs2TeHl9+7dCzs7O0RERAAABg8ejFu3buGbb75ROJkQQjoH62SyceNGLF68GPn5+ZBKpTh9+jTS09Nx/PhxnDt3rjNilElMTIS3t3eLMh8fHxw6dAhisVhtsjwhihJLpKgTS1AvkqBO/Ozx7LmoUaqUfYy0NYERv+O/HdbJZMaMGYiOjsa2bdvA4XCwYcMGjBo1CmfPnsXUqVM7HNCLFBYWwtLSskWZpaUlGhsbIRQKYW1tLbdOQ0MDGhoaZK8rKysBNFU12Z6W9VbNx4mOFztiiRQlNSKUVIsgrG6AsFoEYbUIf1bWIS2Di3NRSRBJmKZk0ZwoxFLZ83qxFBIpqybNdon+aAxG2Rm3/hlY/J+zTiZAU23Ax8enPat22PPnbs3tx22d023fvh2hoaFy5bGxseDz+coPsAeLi4tTdQgqJ2WAchFQJQKqxBxUifHswXnuX6C28UXtDFxA+KfC++WAgTYX0NIAtLlND00ldTm9feMaCu+1/l5tba3C22GdTG7evAmpVAoPD48W5Tdu3ICGhgbc3d3ZblJhVlZWKCwsbFFWXFwMTU1N9OnTp9V1QkJCEBQUJHvd3Drt7e1NDbAKEovFiIuLw9SpU3vFqSTDMCiqakB2SS2eltQiS1gje55TVsfq9EKDy4EpXwt99Hkw09eGmZ42TPiaKMl/iuFDB0NPRwu6WhrQ0daArhYXOloa0H320NHiQldLAzwtDWhrcFTSL6q5Jq8I1snkb3/7G4KDg+WSSX5+Pnbs2IEbN26w3aTCPD09cfbs2RZlsbGxcHd3b/NLzuPxwOPx5Mq1tLR6xQ9DmXrSMWMYBqU1ImQJa5AlrMHTkppnz2uRXVKDWpGkzXW1NDgw1+fBzIAHs2dJoilZND3/63vGulrgclsmAbFYjJiYLEz36t/tjyeb+Fgnk7S0NIwaNUqufOTIkUhLS2O1rerqajx58kT2OisrC8nJyTA1NYWdnR1CQkKQn5+P48ePAwACAgKwe/duBAUF4aOPPkJiYiIOHTqEf/7zn2w/BulFxBIpHgqqcCenDMm55cj4sxpZwhpU1Te2uY4Gl4N+JrpwMNND/z56cDD738PGWBcaXOo9/TzWyYTH46GoqAiOjo4tygUCATQ12W3u1q1bmDx5sux18+mIn58fjh49CoFAgJycHNn7Dg4OiImJwcqVK/H999/DxsYG3377LV0WJi38WdWAOzlluJNThqSccqTklaNeLH9qwuEANka66G/Gl0sa/Uz40FZWo0QvwTqZTJ06FSEhIfjPf/4j6xFXXl6Ov//976yv5kyaNAkv6oB79OhRubKJEyfizp07rPZDei6xRIoHgkok5ZTLEkhuaZ3ccoY6mhhpZ4KRdsYYZGUIBzM92PfhQ0dLQwVR90ysk8muXbswYcIE2NvbyzqpJScnw9LSEidOnFB6gIT8VYtaR3Y5UvLlax0cDjDAQh+j7EyaHvbGcDTTl2u7IMrFOpn07dsXKSkpiIqKwt27d6Grq4ulS5di/vz53b4xiaifkuoGXMsowbUMIa5llCC7RP5SZXOtozlxDLc1hqEOfRe7Wrv6mejp6eHjjz9WdiyEoKahEX88LcXVx0JczSjBA0HLS5McDjDQwgCj7I1lCcTRTI9qHd1Au5LJo0ePcOnSJRQXF0MqbVnF3LBhg1ICI72DWCJFcm45Eh4LcS1DiKSccjQ+1+tzkJUBxjmbYZxzH7j3N6VaRzfFOpkcOHAAn3zyCczMzGBlZdWiI01z93pC2iKVMnhYWIVrGUIkPBHij6xSuT4d/Ux08aqzGbyczeDl1Adm+vL9hEj3wzqZbNmyBVu3bsUXX3zRGfGQHkgskSImVYC4tCJcyyhBaY2oxfumetrwdOqDV53NMM7JDHZ96DYHdcQ6mZSVlWHOnDmdEQvpYWoaGvGvm7k4FJ+Jgor/jRfM19bAGAdTjHMywzhnMwyyMqA2jx6AdTKZM2cOYmNjWY1uRnoXYXUDjl17iuOJ2aioa7rr1Eyfh3mjbTFhoDlG2BpTh7AeiHUycXZ2xvr163H9+nW4uLjIXQ5evny50oIj6iW7pAYH4jPx4608NDy7Gc7BTA8fjXfE7FF9qYNYD8c6mezfvx/6+vq4fPkyLl++3OI9DodDyaQXSs2rwN4rGTifKkDzhZjh/YwQMNEJ3kOt6D6WXoJ1MsnKyuqMOIiaYRgGCU+E2Hs5A1eflMjKJw40R8BEJ4x1NKWpRHqZdvUzIb1Xo0SKmHuF2Hc5A/cLmjqUaXA5mOFqjWUTnTDYmsaI6a3alUzy8vLwyy+/ICcnByJRy8t8YWFhSgmMdC8iCXDyRg4OX8uW3Uinq6UB39G28B/vgH4mdDm3t2OdTH777TfMnDkTDg4OSE9Px7Bhw/D06VMwDNPqOCdEvUmlDI5cy8b/u6OBmsaHAJr6hfh59scST3uY6GmrOELSXbBOJiEhIVi1ahU2b94MAwMDnDp1ChYWFli4cCHeeOONzoiRqIigog5B0XeRmFkCgIN+xjr4eKIT5rjZQlebrsyQllgnkwcPHshGNtPU1ERdXR309fWxefNmzJo1C5988onSgyRd79d7AnxxKhUVdWLoanExw1aM0CWvQleHuraT1rHuOaSnpyebOsLGxgYZGRmy94RCofIiIypRK2pEyOkUBJy8g4o6MVz6GuE/gZ4YZ8lAU4M6mpG2sa6ZjB07FlevXsWQIUPw5ptvYtWqVUhNTcXp06cxduzYzoiRdJF7+RVY/q8kZP5ZAw4H+HiCI1ZNfQUcRoIHqg6OdHusk0lYWBiqq6sBAJs2bUJ1dTWio6Ph7OyM8PBwpQdIOp9UyuBgQia+vpAOsYSBpSEP4XNHwMvZDAAgFrc9UjshzVgnk78OJM3n8xEZGanUgEjXKqqsx6p/30XCk6ZTVJ+hlvhqtitdpSGsUae1Xiz2fiG+OJWCsloxdLS42PDWUMwfY0s9V0m7KNSiZmpqKmtcNTExgampaZsPtiIjI+Hg4AAdHR24ubkhPj7+hctHRUVh+PDh4PP5sLa2xtKlS1FSUvLCdUhLdSIJ1p1JxccnbqOsVoyhNoY499l4LPCwo0RC2k2hmkl4eDgMDAwAABEREUrbeXR0NFasWIHIyEiMGzcO+/btw7Rp05CWlgY7Ozu55RMSErBkyRKEh4djxowZyM/PR0BAAPz9/XHmzBmlxdWT3S+owOf/SsaT4qZ2r48nOGKV90DwNKnfCOkYhZKJn58fAKCxsWkGNB8fH1hZWXV452FhYfjwww/h7+8PoClRXbhwAXv27MH27dvllr9+/Tr69+8vuzPZwcEBy5Ytw86dOzscS08nlTI4fDULO39Nh0gihYUBD7vmDsf4AeaqDo30EKw6DmhqauKTTz6R9TPpCJFIhNu3b8Pb27tFube3N65du9bqOl5eXsjLy0NMTEzT5NJFRfjpp5/w5ptvdjienqy4qh5+R/7Alv8+gEgixeuDLfHrigmUSIhSsW6A9fDwQFJSEuzt7Tu0Y6FQCIlEAktLyxbllpaWKCwsbHUdLy8vREVFwdfXF/X19WhsbMTMmTPx3XfftbmfhoaGFsmveVZ3sVgMsVjcoc+gDhKelGDVTykorWlqZA154xXMH90PHA5H4c/fvFxvOF5dQZ2OJ5sYWSeTwMBArFq1Cnl5eXBzc4Oenl6L911dXVlt7/kGP4Zh2mwETEtLw/Lly7Fhwwb4+PhAIBBgzZo1CAgIwKFDh1pdZ/v27QgNDZUrj42NBZ/fs+90vV/GwaF0LiQMB335DJYMEMFYmIrz51Pbtb24uDglR9i7qcPxrK2Vn/SsLRzmRZP9toLLlT8z4nA4siQgkSjWwUkkEoHP5+PHH3/EO++8Iyv//PPPkZycLDeKGwAsXrwY9fX1+PHHH2VlCQkJGD9+PAoKCmBtbS23Tms1E1tbWwiFQhga9tyxN+IfCxHwQzJEjVL4DLHArjmu4LVz3FWxWIy4uDhMnTqVZm1UAnU6npWVlTAzM0NFRcVLfy8qG2lNW1sbbm5uiIuLa5FM4uLiMGvWrFbXqa2thaZmy5A1NJquQrSVE3k8Hng8+ZvTtLS0uv1/ZHslPBbik+ZEMtQSuxeMgpYS7qvpycdMFdTheLKJj3Uy6WhbyV8FBQVh8eLFcHd3h6enJ/bv34+cnBzZyPchISHIz8/H8ePHAQAzZszARx99hD179shOc1asWIExY8bAxsZGaXGps2sZQvgfv4mGRileH2yB7+YrJ5EQ8jLt7gGblpbW6khrM2fOVHgbvr6+KCkpwebNmyEQCDBs2DDExMTIEpZAIEBOTo5s+ffffx9VVVXYvXs3Vq1aBWNjY0yZMgU7duxo78foUW5kluDDo7dQL5Zi8ivm+H7hKJpSgnQZ1m0mmZmZeOedd5CamiprKwH+15CqaJuJqlRWVsLIyEihc0B1cvNpKfwO/4FakQQTBppj/2I3pU0tIRaLERMTg+nTp3f7ark6UKfjyeb3wvrP1ueffw4HBwcUFRWBz+fj/v37uHLlCtzd3XHp0qX2xkw64HZ2Gd5/lkhedTZTaiIhRFGsT3MSExNx8eJFmJubg8vlgsvl4tVXX8X27duxfPlyJCUldUacpA1JOWXwO/wHakQSeDn1wYEl7pRIiEqwrplIJBLo6+sDAMzMzFBQUACgqWE2PT1dudGRF0rJK8eSw3+guqERHg6mOOjnTmOzEpVhXTMZNmwYUlJS4OjoCA8PD+zcuRPa2trYv39/i7FOSOe6l1+BRQdvoKq+EaP7m+Dw+6PB16YRJYjqsP72/eMf/0BNTQ0AYMuWLXjrrbcwfvx49OnTB9HR0UoPkMhLK6jEokM3UFnfiFF2xjiydAz0eJRIiGqx/gb6+PjInjs6OiItLQ2lpaUwMTGhsTC6wMPCSiw8eB3ltWKMsDXGsQ/GQJ8SCekGWLeZHDt2TFYzaWZqSvPKdoVHRVVYeOAGymrFcO1nhGMfjIGBTve+tEh6D9bJZPXq1bCwsMC8efNw7tw52RgnpHM9Ka7CggPXUVIjwrC+hjjxgQeMdCmRkO6DdTIRCASIjo6GhoYG5s2bB2trawQGBrY5BgnpuIw/qzH/wA0Iq0UYYm2Ikx96wIhPiYR0L6yTiaamJt566y1ERUWhuLgYERERyM7OxuTJk+Hk5NQZMfZqWcIaLDhwHX9WNWCQlQFO+nvAmE8jx5Pup0Mtd3w+Hz4+PigrK0N2djYePKCpmpQpp6QWCw5cR1FlAwZa6iPK3wOmNAUF6abadRdYbW0toqKiMH36dNjY2CA8PBxvv/027t27p+z4ei1RoxQBJ29DUFEPJ3M9RPmPRR99mueXdF+saybz58/H2bNnwefzMWfOHFy6dAleXl6dEVuvFv5/j5AmqIQJXwtR/mNhbkCJhHRvrJMJh8NBdHQ0fHx85AYqIsrxR1Yp9l5umhB++2wXWBnpqDgiQl6OdTb44YcfOiMO8kxlvRgro5PBMMAct354Y5j8UJSEdEc0ck43s+mX+8gvr4OtqS42zhyq6nAIURglk27kvykCnL6TDy4HCJ87grrJE7VCyaSbKKyox9/PNE1BETjJGe792c/bTIgqUTLpBqRSBmt+uouKOjFc+hrh89cHqDokQlhTqB7dPAueInrSuKpd5VjiU8Q/FkJHi4tw3xE0mjxRSwolE2NjY4XvCu7uA0p3N4+KqrD9/EMAwLrpg+Fsoa/iiAhpH4X+BP7++++4ePEiLl68iMOHD8PCwgLBwcE4c+YMzpw5g+DgYFhaWuLw4cOsA4iMjISDgwN0dHTg5uaG+Pj4Fy7f0NCAdevWwd7eHjweD05OTu3ab3cgapRixb+aJsua9Io5Fo1V3pxEhHQ1hWomEydOlD3fvHkzwsLCMH/+fFnZzJkz4eLigv3798PPz0/hnUdHR2PFihWIjIzEuHHjsG/fPkybNg1paWmws7NrdZ25c+eiqKgIhw4dgrOzM4qLi9V2GISwuKZerqZ62tj5niuNCUPUG8OSrq4u8+jRI7ny9PR0RldXl9W2xowZwwQEBLQoGzRoELN27dpWlz9//jxjZGTElJSUsNrPX1VUVDAAmIqKinZvQxkSM4RM/7XnGPsvzjG/3hOoNJaXEYlEzM8//8yIRCJVh9IjqNPxZPN7Yd2RwdbWFnv37sWuXbtalO/btw+2trYKb0ckEuH27dtYu3Zti3Jvb+82x0b55Zdf4O7ujp07d+LEiRPQ09PDzJkz8eWXX0JXV7fVdVqbuBxomghJLBYrHK8yVdWLEfSsl+t7o/piysA+KotFEc2xdecY1Yk6HU82MbJOJuHh4Xj33Xdx4cIFjB07FgBw/fp1ZGRk4NSpUwpvRygUQiKRwNLSskW5paUlCgsLW10nMzMTCQkJ0NHRwZkzZyAUChEYGIjS0tI22022b9+O0NBQufLY2Fjw+XyF41WmE4+5KKjgog+PwWjNbMTEZKskDrbi4uJUHUKPog7Hs7a2VuFlWSeT6dOn49GjR9izZw8ePnwIhmEwa9YsBAQEsKqZNHu+nYBhmDbbDqRSKTgcDqKiomBkZAQACAsLw3vvvYfvv/++1dpJSEgIgoKCZK8rKytha2sLb29vlVzGjkktxK3EFHA5wJ4lHhhpZ9zlMbAlFosRFxeHqVOndvvpLNWBOh1PNt1C2tVf29bWFtu2bWvPqjJmZmbQ0NCQq4UUFxfL1VaaWVtbo2/fvrJEAgCDBw8GwzDIy8vDgAHynb14PB54PPnb97W0tLr8P1JQUYcNZ5sGkPrbZGeMcTLv0v13lCqOWU+mDseTTXzt6h0VHx+PRYsWwcvLC/n5+QCAEydOICEhQeFtaGtrw83NTa6qFxcX1+b4KOPGjUNBQQGqq6tlZY8ePQKXy0W/fv3a8Um6jlTKYPWPTb1cXfsZYflr1MuV9Cysk8mpU6fg4+MDXV1d3LlzR9a4WVVVxbq2EhQUhIMHD+Lw4cN48OABVq5ciZycHAQEBABoOkVZsmSJbPkFCxagT58+WLp0KdLS0nDlyhWsWbMGH3zwQZsNsN3FkWtPcfVJCfVyJT0W62/0li1bsHfvXhw4cKBFFcjLywt37txhtS1fX19ERERg8+bNGDFiBK5cuYKYmBjY2zd13hIIBMjJyZEtr6+vj7i4OJSXl8Pd3R0LFy7EjBkz8O2337L9GF0qvbAKO3591sv1zSFwMqderqTnYd1mkp6ejgkTJsiVGxoaory8nHUAgYGBCAwMbPW9o0ePypUNGjRILVrBmzU0SvD5v5IgapRi8ivmWOTRemc8QtQd65qJtbU1njx5IleekJBAE5e3Iiz2ER4WVsFUTxs7qJcr6cFYJ5Nly5bh888/x40bN8DhcFBQUICoqCisXr26zRpGb5WYUYL98ZkAgK9mu8DCgMZyJT0X69Oc4OBgVFRUYPLkyaivr8eECRPA4/GwevVqfPrpp50Ro1qqqBNj1b+bernOG20L76FWqg6JkE7Vrn4mW7duxbp165CWlgapVIohQ4ZAX58aFf9q7+UMFFTUw74PH+vfGqLqcAjpdO0eZJTP58Pd3V2ZsfQYDY0SRN/MBQCETBsMPRrLlfQCrL/lNTU1+Oqrr/Dbb7+huLgYUqm0xfuZmZlKC05d/XqvEKU1IlgZ6uD1wRaqDoeQLsE6mfj7++Py5ctYvHgxrK2t6epEK6JuNPWNmTfGFprUOY30EqyTyfnz5/Hf//4X48aN64x41N6joir8kVUKDS4H80ZTnxLSe7D+s2liYgJTU5qGoS0/PKuVvD7Ygqb1JL0K62Ty5ZdfYsOGDazGOegtakWNOHU7DwCw0IPGcyW9C+vTnF27diEjIwOWlpbo37+/3C3KbO/P6UnO3i1AVUMj7Pvw8aqzmarDIaRLsU4mb7/9dieE0TOcvN50irNgjB24XGqYJr0L62SycePGzohD7aXklSM1vwLaGlzMcWc/4hwh6o6uWyrJyetN47hOd7GCqZ62iqMhpOspVDMxNTXFo0ePYGZmBhMTkxf2LSktLVVacOqiok6MX+4WAABNpEV6LYWSSXh4OAwMDAAAERERnRmPWjp9Jw/1YilesTSAm72JqsMhRCUUSiZ/naWPzYx9vQHDMLIer4vG2lGPYNJrdegOtLq6OrlJelQxfYQq3cgqxZPiavC1NfD2yL6qDocQlWHdAFtTU4NPP/0UFhYW0NfXh4mJSYtHb9NcK5k1wgYGOt172gJCOhPrZBIcHIyLFy8iMjISPB4PBw8eRGhoKGxsbHD8+PHOiLHbElY34Nd7AgDU45UQ1qc5Z8+exfHjxzFp0iR88MEHGD9+PJydnWFvb4+oqCgsXLiwM+Lslv59KxdiCYPhtsYY1tfo5SsQ0oOxrpmUlpbCwcEBQFP7SPOl4FdffRVXrlxhHUBkZCQcHBygo6MDNzc3xMfHK7Te1atXoampiREjRrDepzJIpYzspj4acZ6QdiQTR0dHPH36FAAwZMgQ/Pvf/wbQVGMxNjZmta3o6GisWLEC69atQ1JSEsaPH49p06a1mCunNRUVFViyZAlee+01tuErzeXHfyKvrA6GOpp4y9VGZXEQ0l2wTiZLly7F3bt3ATTNuNfcdrJy5UqsWbOG1bbCwsLw4Ycfwt/fH4MHD0ZERARsbW2xZ8+eF663bNkyLFiwAJ6enmzDV5qoZ/fhvOdmC11tDZXFQUh3wbrNZOXKlbLnkydPxsOHD3Hr1i04OTlh+PDhCm9HJBLh9u3bWLt2bYtyb29vXLt2rc31jhw5goyMDJw8eRJbtmx56X4aGhpkU5gC/5vVXSwWy13WVlRBeR0uPiwCAMx1s2n3dtRF8+fr6Z+zq6jT8WQTY4dHOrazs4OdHfs2A6FQCIlEAktLyxbllpaWKCwsbHWdx48fY+3atYiPj4empmKhb9++HaGhoXLlsbGx4PP5rOMGgJgcLqQMFwMMpUi/eRnp7dqK+lGnmRTVgTocTzbjFin0i2Qzl+/y5csVXhaAXI9RhmFa7UUqkUiwYMEChIaGYuDAgQpvPyQkBEFBQbLXlZWVsLW1hbe3d7s62IklUmzdFQ+gAZ++MQLTXXr+fDhisRhxcXGYOnWq3Pg1hD11Op7NNXlFKHxvjiI4HI7CycTMzAwaGhpytZDi4mK52goAVFVV4datW0hKSpJN9iWVSsEwDDQ1NREbG4spU6bIrcfj8cDj8eTKtbS02vUf+X8PBSiuaoCZPg/TXPtCS7P33Hjd3mNGWqcOx5NNfAolk6ysrHYH0xZtbW24ubkhLi4O77zzjqw8Li4Os2bNklve0NAQqampLcoiIyNx8eJF/PTTT7LL1Z3t5I2moQZ8R/eDdi9KJIS8TIfaTBiGASB/qqKooKAgLF68GO7u7vD09MT+/fuRk5ODgIAAAE2nKPn5+Th+/Di4XC6GDRvWYn0LCwvo6OjIlXeWzD+rcfVJCTgc0MjzhDynXX9aDx06hGHDhkFHR0f2Yz548CDr7fj6+iIiIgKbN2/GiBEjcOXKFcTExMDevqlrukAgeGmfk67U3Elt8isWsDVtX+MtIT0V65rJ+vXrER4ejs8++0zWzyMxMRErV67E06dPFbpc+1eBgYEIDAxs9b2jR4++cN1NmzZh06ZNrPbXXvViCX660zzyPNVKCHke62SyZ88eHDhwAPPnz5eVzZw5E66urvjss89YJxN1EZMqQHmtGH2NdTHpFZryk5DnsT7NkUgkrU5Y7ubmhsbGRqUE1R01j/E6f4wtNGjkeULksE4mixYtarW7+/79+3vsHcNpBZW4k1MOTS4Hc0fTyPOEtKZdV3MOHTqE2NhYjB07FgBw/fp15ObmYsmSJS06iIWFhSknShWLenY52GeoFSwMaMpPQlrDOpncu3cPo0aNAgBkZGQAAMzNzWFubo579+7JluspY6FWNzTi56R8AMDCsdTwSkhbWCeT33//vTPi6LZ+TspHjUgCRzM9eDr2UXU4hHRbrNtMioqK2nwvJSWlQ8F0N38deX6BB408T8iLsE4mLi4u+OWXX+TKv/nmG3h4eCglqO7iTk45HggqwdPk4j23fqoOh5BujXUy+eKLL+Dr64uAgADU1dUhPz8fU6ZMwddff43o6OjOiFFlmhte33K1gTGfpvwk5EVYJ5NVq1bh+vXruHr1KlxdXeHq6gpdXV2kpKRg5syZnRGjSpTViHAupWnk+UXU8ErIS7Xr3hxHR0cMHToUT58+RWVlJebOndvqsAHq7NSdPIgapRhibYgRtsaqDoeQbo91MmmukTx58gQpKSnYs2cPPvvsM8ydOxdlZWWdEWOXk0r/OuWnPTW8EqIA1slkypQp8PX1RWJiIgYPHgx/f38kJSUhLy8PLi4unRFjl0vMLEGWsAb6PE3MGkEjzxOiCNb9TGJjYzFx4sQWZU5OTkhISMDWrVuVFpgqZZfUQldLA++M7As9XoeHySWkV2D9S3k+kTTjcrlYv359hwPqDhZ42OGt4dZoEEtVHQohakPh05zp06ejoqJC9nrr1q0oLy+XvS4pKcGQIUOUGpwqGepowdxAfuxYQkjrFE4mFy5caDH/zI4dO2RTgwJAY2Mj0tN7y6QPhJDnKZxMmsd7bes1IaR363Wti81JkM18IL2dWCxGbW0tKisru/3UDOpAnY5n8+9EkcqDwsmEw+HI9bdQx/4XVVVVAABbWxrkiBBFVVVVwcjI6IXLKJxMGIbB+++/L5vQqr6+HgEBAdDT0wOAFu0p3ZmNjQ1yc3NhYGCglslQFZpnQczNzW3XLIikJXU6ngzDoKqqCjY2L+9vxWEUbPxYunSpQjs/cuSIQssR9VFZWQkjIyNUVFR0+y+/Ouipx1PhmgklCULIi9D8loQQpaBkQl6Kx+Nh48aNrU4AT9jrqcdT4TYTQgh5EaqZEEKUgpIJIUQpKJkQQpSCkglp06ZNm2Q9n5sfVlZWqg5LbVy5cgUzZsyAjY0NOBwOfv755xbvMwyDTZs2wcbGBrq6upg0aRLu37+vmmCVgJIJeaGhQ4dCIBDIHqmpqaoOSW3U1NRg+PDh2L17d6vv79y5E2FhYdi9ezdu3rwJKysrTJ06VXbLh7rpdTf6EXY0NTWpNtJO06ZNw7Rp01p9j2EYREREYN26dZg9ezYA4NixY7C0tMQPP/yAZcuWdWWoSkE1E/JCjx8/ho2NDRwcHDBv3jxkZmaqOqQeISsrC4WFhfD29paV8Xg8TJw4EdeuXVNhZO1HyYS0ycPDA8ePH8eFCxdw4MABFBYWwsvLCyUlJaoOTe0VFhYCgNwUMZaWlrL31A2d5pA2/bWK7uLiAk9PTzg5OeHYsWMICgpSYWQ9x/N3rjMMo7Z3s1PNhChMT08PLi4uePz4sapDUXvN7VDP10KKi4vVdkI7SiZEYQ0NDXjw4AGsra1VHYrac3BwgJWVFeLi4mRlIpEIly9fhpeXlwojaz86zSFtWr16NWbMmAE7OzsUFxdjy5YtqKyshJ+fn6pDUwvV1dV48uSJ7HVWVhaSk5NhamoKOzs7rFixAtu2bcOAAQMwYMAAbNu2DXw+HwsWLFBh1B3AENIGX19fxtramtHS0mJsbGyY2bNnM/fv31d1WGrj999/ZwDIPfz8/BiGYRipVMps3LiRsbKyYng8HjNhwgQmNTVVtUF3AN01TAhRCmozIYQoBSUTQohSUDIhhCgFJRNCiFJQMiGEKAUlE0KIUlAyIYQoBSUTQohSUDIhhCgFJRPSqd5//33Z+LFaWlpwdHTE6tWrUVNTI1vm1KlTmDRpEoyMjKCvrw9XV1ds3rwZpaWlKoycsEXJhHS6N954AwKBAJmZmdiyZQsiIyOxevVqAMC6devg6+uL0aNH4/z587h37x527dqFu3fv4sSJEyqOnLCi6puDSM/m5+fHzJo1q0WZv78/Y2Vlxdy4cYMBwERERLS6bllZGcMwDJOcnMxMmjSJ0dfXZwwMDJhRo0YxN2/e7OTICVs0BAHpcrq6uhCLxYiKioK+vj4CAwNbXc7Y2BgAsHDhQowcORJ79uyBhoYGkpOToaWl1YURE0VQMiFd6o8//sAPP/yA1157DY8fP4ajo+NLE0NOTg7WrFmDQYMGAQAGDBjQFaESlqjNhHS6c+fOQV9fHzo6OvD09MSECRPw3XffKTzeaVBQEPz9/fH666/jq6++QkZGRhdETdiiZEI63eTJk5GcnIz09HTU19fj9OnTsLCwwMCBA5GRkQGxWPzC9Tdt2oT79+/jzTffxMWLFzFkyBCcOXOmi6IniqJkQjqdnp4enJ2dYW9v3+KUZsGCBaiurkZkZGSr65WXl8ueDxw4ECtXrkRsbCxmz56NI0eOdHbYhCVKJkRlPDw8EBwcjFWrViE4OBiJiYnIzs7Gb7/9hjlz5uDYsWOoq6vDp59+ikuXLiE7OxtXr17FzZs3MXjwYFWHT55DDbBEpXbs2AE3Nzd8//332Lt3L6RSKZycnPDee+/Bz88PGhoaKCkpwZIlS1BUVAQzMzPMnj0boaGhqg6dPIfGgCWEKAWd5hBClIKSCSFEKSiZEEKUgpIJIUQpKJkQQpSCkgkhRCkomRBClIKSCSFEKSiZEEKUgpIJIUQpKJkQQpSCkgkhRCn+P6+guJuhsUWrAAAAAElFTkSuQmCC", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARMAAAC9CAYAAACQyJmSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAm60lEQVR4nO3deVyU1f4H8M/MMAwM+yKbArJouYALKIq5FhCuZSmukElJ3DLFJclySyW9CfzKwNyX8F4qtZtdSriZiIrkAqLiCgiILAGyLzPMPL8/kCkc0HlgYGbg+3695hVz5lm+PDLfznPOec7hMAzDgBBCOoir6gAIId0DJRNCiFJQMiGEKAUlE0KIUlAyIYQoBSUTQohSUDIhhCiFVkd2rq+vh46OjrJi6RJSqRSPHj2CgYEBOByOqsMhRK0xDIOqqirY2NiAy31O3YNhSSKRMJs2bWJsbGwYHo/HZGZmMgzDMJ988gmzd+9etofrcnl5eQwAetGLXixeeXl5z/1usa6ZbN68GYcOHcL27dvxzjvvyMpdXFwQERGBxYsXsz1klzIwMAAA5OXlwdDQUMXRaAaxWIz4+Hh4e3uDz+erOhyNp0nXs7KyEra2trLvzTOx/T+7k5MT87///Y9hGIbR19eX1Uxu3brFGBsbszpWYmIiM3XqVMba2poBwJw4ceK5+5w5c4YZPnw4IxAIGAcHByY6OprVOSsqKhgATEVFBav9ejKRSMT8+OOPjEgkUnUo3YImXU823xfWDbD5+flwdnaWK5dKpRCLxayOVVNTgyFDhmDnzp0KbZ+dnY3Jkydj7NixSE1Nxccff4ylS5fi2LFjrM5LCFE+1rc5gwYNQlJSEuzt7VuUf//99xg2bBirY/n6+sLX11fh7Xft2gU7OztERkYCAAYMGIDLly/jiy++wBtvvMHq3IRoArFEijqxBPUiCerET15PfhY1SpVyjmG2JjASdvx2i3UyWb9+PRYuXIj8/HxIpVIcP34cd+7cweHDh/Hzzz93OKBnSU5Ohre3d4syHx8f7Nu3D2KxuNX7z4aGBjQ0NMjeV1ZWAmi6b2Vbk+qpmq8TXS92xBIpSmtEKK0WoaS6ASXVIpRUi/BnZR0yMrn4OSYVIgnTlCyaE4VYKvu5XiyFRMp0epyx74zEcDvj1n8HFv/mrJPJtGnTEBsbi61bt4LD4WDdunUYPnw4Tp48CS8vL7aHY6WwsBCWlpYtyiwtLdHY2IiSkhJYW1vL7RMWFoaNGzfKlcfHx0MoFHZarN1RQkKCqkNQOSkDlIuAKhFQJeagSownL85T/wVqG5819IALlPyp8Hk5YKDNBfg8QJvb9NJS0iixKykXUHij9c9qa2sVPk67xpn4+PjAx8enPbt22NNjQ5gn07G0NWYkNDQUISEhsvfNrdPe3t7Um6MgsViMhIQEeHl5qX3vgzIwDIOiqgbklNbiQWktsktqZD/nPq5jdXvB43JgKuTDTF8Ac31tmOtpw0SohdL8BxgyaAD0dPjQ5fOgo82DLp8LHT4Puk9eOnwudPk8CPg8aPM4KhkX1VyTVwTrZHLp0iVIpVJ4eHi0KE9JSQGPx4O7uzvbQyrMysoKhYWFLcqKi4uhpaUFMzOzVvcRCAQQCARy5Xw+v0d8MZSpO10zhmFQViNCdkkNsktq8KC05snPtcgprUGtSNLmvnweB730BTA3EMD8SZJoShZNP//9M2NdPrjclklALBYjLi4bkz37qv31ZBMf62Tyj3/8A6tXr5ZLJvn5+di2bRtSUlLYHlJho0ePxsmTJ1uUxcfHw93dXe3/UYjqiCVS3C6owtXcx0jLK0fmn9XILqlBVX1jm/vwuBz0MdGFg7ke+prpwcH8r5eNsS54XBo9/TTWySQjIwPDhw+XKx82bBgyMjJYHau6uhr379+Xvc/OzkZaWhpMTU1hZ2eH0NBQ5Ofn4/DhwwCAoKAg7Ny5EyEhIXjnnXeQnJyMffv24V//+hfbX4N0Y39WNeBq7mNczX2M1NxypD8sR71Y/taEwwFsjHTR11wolzT6mAihraxGiR6CdTIRCAQoKiqCo6Nji/KCggJoabE73OXLlzFx4kTZ++a2jYCAABw8eBAFBQXIzc2Vfe7g4IC4uDgsX74cX3/9NWxsbPDll19St3APJpZIcaugEqm55bIEkldWJ7edoY4WhtmZYJidMV60MoSDuR7szYTQ4fNUEHX3xDqZeHl5ITQ0FP/5z39gZGQEACgvL8fHH3/MujdnwoQJsgbU1hw8eFCubPz48bh69Sqr85Duo0WtI6cc6fnytQ4OB+hnoY/hdiZNL3tjOJrry7VdEOVinUx27NiBcePGwd7eXjZILS0tDZaWljhy5IjSAyQ9W2l1Ay5kluJCZgkuZJYip1S+q7K51tGcOIbYGsNQh9rQuhrrZNK7d2+kp6cjJiYG165dg66uLhYtWoS5c+dSIyjpsJqGRvzxoAzn75XgfGYpbhW07JrkcID+FgYYbm8sSyCO5npU61AD7Rpnoqenh3fffVfZsZAeSCyRIi2vHOfuleBCZglSc8vR+NSozxetDDDG2RxjnM3g3teUah1qql3J5O7duzhz5gyKi4shlba8X123bp1SAiPdk1TK4HZhFS5kluDc/RL8kV0mN6ajj4kuXnI2h6ezOTydzGCuLz9OiKgf1slkz549eO+992Bubg4rK6sWo/Kah9cT8ndiiRRx1wuQkFGEC5mlKKsRtfjcVE8bo53M8JKzOcY4mcPOjB5z0ETtmhxpy5Yt+OijjzojHtKN1DQ04t+X8rAvKQuPKupl5UJtHkY6mGKMkznGOJvjRSsDavPoBlgnk8ePH2PWrFmdEQvpJkqqG3DowgMcTs5BRV3TU6fm+gLMGWGLcf17YaitMQ0I64ZYJ5NZs2YhPj4eQUFBnREP0WA5pTXYk5SF7y8/RMOTh+EczPXwzlhHzBzemwaIdXOsk4mzszM+/fRTXLx4ES4uLnLdwUuXLlVacEQzXH9YgV1nM/HL9QI0d8QM6WOEoPFO8B5kRc+x9BCsk8nu3buhr6+PxMREJCYmtviMw+FQMukhGIbBufsl2JWYifP3S2XlE17ohSXjnDDK0ZSWEulhWCeT7OzszoiDaIhGiRRxNwrxTWImbj5qGlDG43IwfYgN3h3niAHWNEdMT9WhRbhIzyGSAN+m5GL/hRzZg3S6fB7mjLTF4pcc0MeEunN7unYlk4cPH+Knn35Cbm4uRKKWYwbCw8OVEhhRD1IpgwMXcvB/V3moabwNoGlcyFuefbFwlD1M9LRVHCFRF6yTyW+//Ybp06fDwcEBd+7cweDBg/HgwQMwDNPqPCdEcxVU1CEk9hqSs0oBNE0W9O44R8xys4WuNvXMkJZYd/aHhoZixYoVuHHjBnR0dHDs2DHk5eVh/PjxNP6kG/n1RgFejUxCclYphNo8+DlKkPDhGPiP7kuJhLSKdTK5desWAgICAABaWlqoq6uDvr4+Nm3ahG3btik9QNK1akWNCD2ejqBvr6KiTgzXPkb4T/AoeFoy0OLRQDPSNta3OXp6erJ1aGxsbJCZmYlBgwYBAEpKSpQbHelSN/IrsPTfqcj6swYcDrBknBNCvPqDw0jAbkJO0hOxTiajRo3C+fPnMXDgQEyZMgUrVqzA9evXcfz4cYwaNaozYiSdTCplsCcpC1/E34FYwsDKUAfhfkPg6WQOABCL256pnZBmrJNJeHg4qqurAQAbNmxAdXU1YmNj4ezsjIiICKUHSDpXUWU9Qr5Lkw088xlkic9nulIvDWGNdTL5+0TSQqEQUVFRSg2IdJ34m4X46Fg6HteKocvnYd20gZgzwpZGrpJ2oUFrPVCdSILP/puBoylNM/8PsjHE/80ZBmcLfRVHRjSZQs3zpqamssZVExMTmJqatvliKyoqCg4ODtDR0YGbmxuSkpKeuX1MTAyGDBkCoVAIa2trLFq0CKWlpc/ch/zl5qMKTP0qSZZI3h3niOPBnpRISIcpVDOJiIiAgYEBACAyMlJpJ4+NjcWyZcsQFRWFMWPG4JtvvoGvry8yMjJgZ2cnt/25c+fg7++PiIgITJs2Dfn5+QgKCkJgYCBOnDihtLi6I6mUwf7z2dj+6x2IJFJYGAgQPnsoXupnrurQSDehUDJpHlfS2Ni0nKKPjw+srKw6fPLw8HAsXrwYgYGBAJoS1alTpxAdHY2wsDC57S9evIi+ffvKnkx2cHDAkiVLsH379g7H0p0VV9ZjxffXkHSvqXb5ygBLbH/TFabUyEqUiFWbiZaWFt577z3cunWrwycWiUS4cuUK1qxZ06Lc29sbFy5caHUfT09PrF27FnFxcfD19UVxcTF++OEHTJkypc3zNDQ0yMbFAH+t6i4WiyEWizv8e6i7c/dLEfJ9UyOrDp+L0FdfwNwRfcDhcBT+/Zu36wnXqyto0vVkEyPrBlgPDw+kpqbC3t6e7a4tlJSUQCKRwNLSskW5paUlCgsLW93H09MTMTEx8PPzQ319PRobGzF9+nR89dVXbZ4nLCwMGzdulCuPj4+HUNi9n3S9+ZiDfXe4kDAc9BYy8O8ngnHJdfzyy/V2HS8hIUHJEfZsmnA9a2vlFz1rC+tkEhwcjBUrVuDhw4dwc3ODnp5ei89dXV1ZHe/pbkiGYdrsmszIyMDSpUuxbt06+Pj4oKCgAKtWrUJQUBD27dvX6j6hoaGyNYyBppqJra0tvL29YWjYfefeSLpXgoNH0yBhpPAZaIEds1whaOe8q2KxGAkJCfDy8qKF1pRAk65nc01eEayTiZ+fH4CW0zNyOBxZEpBIFBstaW5uDh6PJ1cLKS4ulqutNAsLC8OYMWOwatUqAE2JS09PD2PHjsXmzZthbW0tt49AIIBAIL/uCp/PV/t/yPY6d68E7x1Ng6hRCp9Bltg5bzj4SniupjtfM1XQhOvJJj6VzbSmra0NNzc3JCQk4PXXX5eVJyQkYMaMGa3uU1tbCy2tliHzeE1PsD5rAfSe5EJmCQIPX0JDoxSvDLDAV3OVk0gIeR7WyaSjbSV/FxISgoULF8Ld3R2jR4/G7t27kZubK5v5PjQ0FPn5+Th8+DAAYNq0aXjnnXcQHR0tu81ZtmwZRo4cCRsbG6XFpalSskqx+OBl1IulmPhCL3w9fzgtKUG6TLtHwGZkZLQ609r06dMVPoafnx9KS0uxadMmFBQUYPDgwYiLi5MlrIKCAuTm5sq2f+utt1BVVYWdO3dixYoVMDY2xqRJk2jqAwCXHpRh0cFLqBNLMK5/L0QvcINAi+YdIV2Hw7C8P8jKysLrr7+O69evy9pKgL8aUhVtM1GVyspKGBkZoaKiots0wF7JeQz/fSmoEUnwkrM59ga4K3WNGrFYjLi4OEyePFnt7/E1gSZdTzbfF9Z14A8//BAODg4oKiqCUCjEzZs3cfbsWbi7u+PMmTPtjZm0U2ruYwTs/wM1Igk8ncywx1+5iYQQRbG+zUlOTsbp06fRq1cvcLlccLlcvPTSSwgLC8PSpUuRmpraGXGSVqQ/LIf//j9Q3dAIDwdT7A1wpykVicqwrplIJBLo6zc9FGZubo5Hjx4BaGqYvXPnjnKjI226kV+BBXtTUFXfiBF9TbD/rREQatND4ER1WP/1DR48GOnp6XB0dISHhwe2b98ObW1t7N69u8VcJ6TzZDyqxIJ9Kaisb8RwO2McWDQSegJKJES1WP8FfvLJJ6ipqQEAbN68GVOnTsXYsWNhZmaG2NhYpQdIWrpdWIn5ey+ivFaMobbGOPT2SOhTIiFqgPVfoY+Pj+xnR0dHZGRkoKysDCYmJjRDVye7W1SF+XtS8Li2adb4Q2+PhIGOevcGkJ6DdZvJoUOHZDWTZqamtEh1Z7tfXIV5ey6itEaEwb0NceRtDxjpUiIh6oN1Mlm5ciUsLCwwZ84c/Pzzz7I5TkjnyfyzGnP3pKCkWoSB1ob4drEHjISUSIh6YZ1MCgoKEBsbCx6Phzlz5sDa2hrBwcFtzkFCOia7pAbz9lzEn1UNeNHKAN8GesBYSJMaEfXDOploaWlh6tSpiImJQXFxMSIjI5GTk4OJEyfCycmpM2LssXJLazFvz0UUVTagv6U+YgI9aHY0orY61A0gFArh4+ODx48fIycnRykzsJEmokYpgr69goKKejj10kNM4CiY6ctPpUCIumjXI6W1tbWIiYnB5MmTYWNjg4iICLz22mu4ceOGsuPrsSL+dxcZBZUwEfIREzgKvQwokRD1xrpmMnfuXJw8eRJCoRCzZs3CmTNn4Onp2Rmx9Vh/ZJdhV2ImACBspgusjHRUHBEhz8c6mXA4HMTGxsLHx0duoiLScZX1YiyPTQPDALPc+uDVwfKzxxGijlhng6NHj3ZGHOSJDT/dRH55HWxNdbF++iBVh0OIwmgaLjXy3/QCHL+aDy4HiJg9lIbJE41CyURNFFbU4+MTTUtQBE9whntf9kutEqJKlEzUgFTKYNUP11BRJ4ZLbyN8+Eo/VYdECGuUTNTAoeQHSLpXAh0+FxF+Q2k2eaKRFLopZ7MQT3eZV7Wr3C2qQtgvtwEAaycPgLOFvoojIqR9FEomxsbGCj8VrO4TSqsTUaMUy/7dtFjWhBd6YcEo5S0jQkhXU6g+/fvvv+P06dM4ffo09u/fDwsLC6xevRonTpzAiRMnsHr1alhaWmL//v2sA4iKioKDgwN0dHTg5uaGpKSkZ27f0NCAtWvXwt7eHgKBAE5OTu06rzoIT2ga5Wqqp43tb7rSNA5EoylUMxk/frzs502bNiE8PBxz586VlU2fPh0uLi7YvXs3AgICFD55bGwsli1bhqioKIwZMwbffPMNfH19kZGRATs7u1b3mT17NoqKirBv3z44OzujuLhYI6dBuJhVim/O/jXK1cKARrkSzdau2el37dolV+7u7o7AwEBWxwoPD8fixYtl+0VGRuLUqVOIjo5GWFiY3Pa//vorEhMTkZWVBVPTpq7Tvn37PvMcDQ0NaGhokL1vbv8Ri8UQi8Ws4lWWqnoxQmSjXHtjUn8zlcWiiObY1DlGTaJJ15NNjKyTia2tLXbt2oUdO3a0KP/mm29ga2ur8HFEIhGuXLmCNWvWtCj39vZuc26Un376Ce7u7ti+fTuOHDkCPT09TJ8+HZ999hl0dXVb3ScsLAwbN26UK4+Pj4dQKFQ4XmU6co+LRxVcmAkYuPNyEBeXo5I42EpISFB1CN2KJlzP2tpahbdlnUwiIiLwxhtv4NSpUxg1ahQA4OLFi8jMzMSxY8cUPk5JSQkkEgksLS1blFtaWqKwsLDVfbKysnDu3Dno6OjgxIkTKCkpQXBwMMrKytpsNwkNDUVISIjsfWVlJWxtbeHt7a2Snqe464W4nJwOLgeI9vfAMDvjLo+BLbFYjISEBHh5ean9CnSaQJOuJ5ueXNbJZPLkybh79y6io6Nx+/ZtMAyDGTNmICgoiFXNpNnTjY4Mw7TZECmVSsHhcBATEwMjIyMATbdKb775Jr7++utWaycCgQACgfzj+3w+v8v/IQsq6rDuZNOcL+9PdMZIp15dev6OUsU168404Xqyia9dD3/Y2tpi69at7dlVxtzcHDweT64WUlxcLFdbaWZtbY3evXvLEgkADBgwAAzD4OHDh+jXT31HjkqlDFZ+3zTKdUgfI3zwsvrGSkh7tGuoZVJSEhYsWABPT0/k5+cDAI4cOYJz584pfAxtbW24ubnJ3TcmJCS0OT/KmDFj8OjRI1RXV8vK7t69Cy6Xiz59+rTjN+k6By48wPn7pdDhcxFOo1xJN8T6L/rYsWPw8fGBrq4url69KuspqaqqYl1bCQkJwd69e7F//37cunULy5cvR25uLoKCggA0tXf4+/vLtp83bx7MzMywaNEiZGRk4OzZs1i1ahXefvvtNhtg1cGdwips+7VplOsnUwbCqReNciXdD+tksnnzZuzatQt79uxpcT/l6emJq1evsjqWn58fIiMjsWnTJgwdOhRnz55FXFwc7O2bRoIWFBQgNzdXtr2+vj4SEhJQXl4Od3d3zJ8/H9OmTcOXX37J9tfoMg2NEnz471SIGqWY9KIF5nu0Pn6GEE3Hus3kzp07GDdunFy5oaEhysvLWQcQHByM4ODgVj87ePCgXNmLL76oEV1qzcLj7+J2YRXM9LSx7Q0a5Uq6L9Y1E2tra9y/f1+u/Ny5c7Rw+VOSM0uxOykLAPD5G640KTTp1lgnkyVLluDDDz9ESkoKOBwOHj16hJiYGKxcubLNGkZPVFEnxorvmka5zhlhC6+BrfdQEdJdsL7NWb16NSoqKjBx4kTU19dj3LhxEAgEWLlyJd5///3OiFEj7UrMxKOKetibCfHp1IGqDoeQTteucSZbtmzB2rVrkZGRAalUioEDB0Jfn3oomjU0ShB7KQ8AEOo7AHo0lyvpAdr9Vy4UCuHu7q7MWLqNX28UoqxGBGsjHbwywELV4RDSJVgnk5qaGnz++ef47bffUFxcDKlU2uLzrKwspQWnqWJSmrqz54ywgxYNTiM9BOtkEhgYiMTERCxcuBDW1tbU1fmUu0VV+CO7DDwuB34j2D+rRIimYp1MfvnlF/z3v//FmDFjOiMejXf0Sa3klQEWtKwn6VFY18FNTExkExORlmpFjTh25SEA0HyupMdhnUw+++wzrFu3jtWkKT3FyWuPUNXQCHszIcY4mas6HEK6FOvbnB07diAzMxOWlpbo27ev3HwHbJ/P6U6+vdh0izPfww5cLrUlkZ6FdTJ57bXXOiEMzZf+sBzX8yugrcXFm27U8Ep6HtbJZP369Z0Rh8b79mLTPK5TXKxhqqet4mgI6Xo0CEIJKurE+OnaIwCgKQZIj6VQzcTU1BR3796Fubk5TExMnjm2pKysTGnBaYrjVx+iXizFC5YGcLM3UXU4hKiEQskkIiICBgYGAJrWtiF/YRhGNuJ1wSg7GsRHeiyFksnfV+ljs2JfT5CSXYb7xdUQavPw2rDeqg6HEJXp0OOsdXV1cit+qWItGlVqrpXMGNobBjrqvWwBIZ2JdQNsTU0N3n//fVhYWEBfXx8mJiYtXj1JSXUDfr1RAIAaXglhnUxWr16N06dPIyoqCgKBAHv37sXGjRthY2ODw4cPd0aMauu7y3kQSxgMtTXG4N5Gz9+BkG6M9W3OyZMncfjwYUyYMAFvv/02xo4dC2dnZ9jb2yMmJgbz58/vjDjVjlTKyB7qo1oJIe2omZSVlcHBwQFAU/tIc1fwSy+9hLNnz7IOICoqCg4ODtDR0YGbmxuSkpIU2u/8+fPQ0tLC0KFDWZ9TGRLv/YmHj+tgqKOFaUNsVBIDIeqEdTJxdHTEgwcPAAADBw7Ed999B6CpxmJsbMzqWLGxsVi2bBnWrl2L1NRUjB07Fr6+vi3WymlNRUUF/P398fLLL7MNX2linjyH86abLXT4PJXFQYi6YH2bs2jRIly7dg3jx49HaGgopkyZgq+++gqNjY0IDw9ndazw8HAsXrwYgYGBAJrGsJw6dQrR0dEICwtrc78lS5Zg3rx54PF4+PHHH595joaGBtmqg8Bfq7qLxWK5nihFPSqvw+nbRQCA2W427T6Opmj+/br779lVNOl6somRdTJZvny57OeJEyfi9u3buHz5MpycnDBkyBCFjyMSiXDlyhWsWbOmRbm3tzcuXLjQ5n4HDhxAZmYmvv32W2zevPm55wkLC8PGjRvlyuPj4yEUChWO9+/icrmQMlz0M5TizqVE3GnXUTSPJi1+pgk04XqymWqkw9Om29nZwc6OfQNkSUkJJBIJLC1bridjaWmJwsLCVve5d+8e1qxZg6SkJGhpKRZ6aGgoQkJCZO8rKytha2sLb2/vdo2JEUuk2LIjCUAD3n91KCa7WLE+hqYRi8VISEiAl5eX3JQThD1Nup7NNXlFKPSNZLOW79KlSxXeFoDc8HOGYVodki6RSDBv3jxs3LgR/fv3V/j4AoEAAoH8Snp8Pr9d/5D/u12A4qoGmOsL4OvaG3ytnvOsZHuvGWmdJlxPNvEp/GyOIjgcjsLJxNzcHDweT64WUlxcLFdbAYCqqipcvnwZqampssW+pFIpGIaBlpYW4uPjMWnSJIXO3RHfpjRNNeA3og+0e1AiIeR5FEom2dnZSj+xtrY23NzckJCQgNdff11WnpCQgBkzZshtb2hoiOvXr7coi4qKwunTp/HDDz/Iuqs7U9af1Th/vxQcDjB3JI0tIeTvOtRmwjAMAPlbFUWFhIRg4cKFcHd3x+jRo7F7927k5uYiKCgIQFN7R35+Pg4fPgwul4vBgwe32N/CwgI6Ojpy5Z2leZDaxBcs0MekfY23hHRX7aqn79u3D4MHD4aOjo7sy7x3717Wx/Hz80NkZCQ2bdqEoUOH4uzZs4iLi4O9fdPM7gUFBc8dc9JV6sUS/HC1aeZ5GvFKiDzWNZNPP/0UERER+OCDDzB69GgAQHJyMpYvX44HDx4o1F37d8HBwQgODm71s4MHDz5z3w0bNmDDhg2sztdecdcLUF4rRm9jXUx4gZb8JORprJNJdHQ09uzZg7lz58rKpk+fDldXV3zwwQesk4mmaJ7jde5IW/Bo5nlC5LC+zZFIJK0uWO7m5obGxkalBKVuMh5V4mpuObS4HMymJT8JaRXrZLJgwQJER0fLle/evbvbPjEc86Q72GeQFSwMaMlPQlrTrt6cffv2IT4+HqNGjQIAXLx4EXl5efD3928x2pTtszrqqLqhET+m5gMA5o+ihldC2sI6mdy4cQPDhw8HAGRmZgIAevXqhV69euHGjRuy7brLxMo/puajRiSBYy89jHY0U3U4hKgt1snk999/74w41NLfZ56f72HfbRIkIZ2BdZtJUVFRm5+lp6d3KBh1czW3HLcKKiHQ4uKN4TTzPCHPwjqZuLi44KeffpIr/+KLL+Dh4aGUoNRFc8PrVFcbGAtpyU9CnoV1Mvnoo4/g5+eHoKAg1NXVIT8/H5MmTcI///lPxMbGdkaMKvG4RoSf05tmnl9ADa+EPBfrZLJixQpcvHgR58+fh6urK1xdXaGrq4v09HRMnz69M2JUiWNXH0LUKMVAa0MMtTVWdTiEqL12PZvj6OiIQYMG4cGDB6isrMTs2bNbnTZAU0mlf1/ykxpeCVEE62TSXCO5f/8+0tPTER0djQ8++ACzZ8/G48ePOyPGLpecVYrskhroC7QwYyjNPE+IIlgnk0mTJsHPzw/JyckYMGAAAgMDkZqaiocPH8LFxaUzYuxyOaW10OXz8Pqw3tATdHhmS0J6BNbflPj4eIwfP75FmZOTE86dO4ctW7YoLTBVmudhh6lDrNEglqo6FEI0Butk8nQiacblcvHpp592OCB1YajDB+gxHEIUpvBtzuTJk1FRUSF7v2XLFpSXl8vel5aWYuDAgUoNjhCiORROJqdOnWqxmNW2bdtkS4MCQGNjI+7c6SkryBBCnqbwbU7zfK9tvdcUzXGzWQ+kpxOLxaitrUVlZaXaL82gCTTpejZ/TxT5vve4roqqqioAgK0tTXJEiKKqqqpgZGT0zG0UTiYcDkdu8JYmDuaysbFBXl4eDAwMNDJ+VWheBTEvL69dqyCSljTpejIMg6qqKtjYPH+8FavbnLfeeku2Ol59fT2CgoKgp6cHAC3aU9QZl8tFnz59VB2GRjI0NFT7P35NoinX83k1kmYKJ5OAgIAW7xcsWCC3jb+/v6KHI4R0MwonkwMHDnRmHIQQDUeL5ZLnEggEWL9+fasLwBP2uuv15DCa2sdLCFErVDMhhCgFJRNCiFJQMiGEKAUlE0KIUlAyIW3asGGDbORz88vKykrVYWmMs2fPYtq0abCxsQGHw8GPP/7Y4nOGYbBhwwbY2NhAV1cXEyZMwM2bN1UTrBJQMiHPNGjQIBQUFMhe169fV3VIGqOmpgZDhgzBzp07W/18+/btCA8Px86dO3Hp0iVYWVnBy8tL9vyYpulxD/oRdrS0tKg20k6+vr7w9fVt9TOGYRAZGYm1a9di5syZAIBDhw7B0tISR48exZIlS7oyVKWgmgl5pnv37sHGxgYODg6YM2cOsrKyVB1St5CdnY3CwkJ4e3vLygQCAcaPH48LFy6oMLL2o2RC2uTh4YHDhw/j1KlT2LNnDwoLC+Hp6YnS0lJVh6bxCgsLAUBuiRhLS0vZZ5qGbnNIm/5eRXdxccHo0aPh5OSEQ4cOISQkRIWRdR9PT4PBMIzGTo1BNROiMD09Pbi4uODevXuqDkXjNbdDPV0LKS4u1tgF7SiZEIU1NDTg1q1bsLa2VnUoGs/BwQFWVlZISEiQlYlEIiQmJsLT01OFkbUf3eaQNq1cuRLTpk2DnZ0diouLsXnzZlRWVsrNbUNaV11djfv378veZ2dnIy0tDaamprCzs8OyZcuwdetW9OvXD/369cPWrVshFAoxb948FUbdAQwhbfDz82Osra0ZPp/P2NjYMDNnzmRu3ryp6rA0xu+//84AkHsFBAQwDMMwUqmUWb9+PWNlZcUIBAJm3LhxzPXr11UbdAfQFASEEKWgNhNCiFJQMiGEKAUlE0KIUlAyIYQoBSUTQohSUDIhhCgFJRNCiFJQMiGEKAUlE0KIUlAyIZ3qrbfeks0fy+fz4ejoiJUrV6Kmpka2zbFjxzBhwgQYGRlBX18frq6u2LRpE8rKylQYOWGLkgnpdK+++ioKCgqQlZWFzZs3IyoqCitXrgQArF27Fn5+fhgxYgR++eUX3LhxAzt27MC1a9dw5MgRFUdOWFH1w0GkewsICGBmzJjRoiwwMJCxsrJiUlJSGABMZGRkq/s+fvyYYRiGSUtLYyZMmMDo6+szBgYGzPDhw5lLly51cuSELZqCgHQ5XV1diMVixMTEQF9fH8HBwa1uZ2xsDACYP38+hg0bhujoaPB4PKSlpYHP53dhxEQRlExIl/rjjz9w9OhRvPzyy7h37x4cHR2fmxhyc3OxatUqvPjiiwCAfv36dUWohCVqMyGd7ueff4a+vj50dHQwevRojBs3Dl999ZXC852GhIQgMDAQr7zyCj7//HNkZmZ2QdSELUompNNNnDgRaWlpuHPnDurr63H8+HFYWFigf//+yMzMhFgsfub+GzZswM2bNzFlyhScPn0aAwcOxIkTJ7ooeqIoSiak0+np6cHZ2Rn29vYtbmnmzZuH6upqREVFtbpfeXm57Of+/ftj+fLliI+Px8yZM3HgwIHODpuwRMmEqIyHhwdWr16NFStWYPXq1UhOTkZOTg5+++03zJo1C4cOHUJdXR3ef/99nDlzBjk5OTh//jwuXbqEAQMGqDp88hRqgCUqtW3bNri5ueHrr7/Grl27IJVK4eTkhDfffBMBAQHg8XgoLS2Fv78/ioqKYG5ujpkzZ2Ljxo2qDp08heaAJYQoBd3mEEKUgpIJIUQpKJkQQpSCkgkhRCkomRBClIKSCSFEKSiZEEKUgpIJIUQpKJkQQpSCkgkhRCkomRBClOL/AV7reTv+zlIaAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1631,7 +1614,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1658,7 +1641,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -1673,15 +1656,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "Applying model: 100%|█████████████████████| 3/3 [00:19<00:00, 6.44s/it]\n" + "Applying model: 100%|█████████████████████| 3/3 [00:04<00:00, 1.37s/it]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Saved results to /home/sambray/Documents/moseq_test_proj3/d9bbbaed42ec\n", - "a56d999882d9f65a62b8_ar/results.h5\n" + "Saved results to /stelmo/nwb/moseq/projects/d9bbbaed42eca56d999882d9f6\n", + "5a62b8/d9bbbaed42eca56d999882d9f65a62b8_ar/results.h5\n" ] }, { @@ -1696,8 +1679,8 @@ "\n", "Ignoring cached namespace 'hdmf-experimental' version 0.2.0 because version 0.5.0 is already loaded.\n", "\n", - "[08:51:21][INFO] Spyglass: Writing new NWB file SC100020230912_DSLA0Q15ME.nwb\n", - "INFO:spyglass:Writing new NWB file SC100020230912_DSLA0Q15ME.nwb\n" + "[15:05:48][INFO] Spyglass: Writing new NWB file SC100020230912_LKNI5NCTIH.nwb\n", + "INFO:spyglass:Writing new NWB file SC100020230912_LKNI5NCTIH.nwb\n" ] }, { @@ -1775,28 +1758,23 @@ " \n", " \n", " 1f3fdc6d-d8d5-c283-846a-4830e85dcb32\n", - "sb_test_group\n", - "sb_testing_kappa4_mini_20241220\n", - "SC100020230912_2MBYJA8JOI.nwb\n", - "a3ec9db6-f8c3-487a-a1d7-b1a91b1d8e471f3fdc6d-d8d5-c283-846a-4830e85dcb32\n", "tutorial_group\n", "tutorial_kappa4_mini\n", - "SC100020230912_DSLA0Q15ME.nwb\n", - "82b3d777-9445-4370-8acf-3d4c2dec8f52 \n", + "SC100020230912_LKNI5NCTIH.nwb\n", + "e550ee2f-4744-46ac-a6f9-f9c87315c0ed \n", " \n", " \n", - "

Total: 2

\n", + "

Total: 1

\n", " " ], "text/plain": [ "*pose_merge_id *pose_group_na *model_params_ analysis_file_ moseq_object_i\n", "+------------+ +------------+ +------------+ +------------+ +------------+\n", - "1f3fdc6d-d8d5- sb_test_group sb_testing_kap SC100020230912 a3ec9db6-f8c3-\n", - "1f3fdc6d-d8d5- tutorial_group tutorial_kappa SC100020230912 82b3d777-9445-\n", - " (Total: 2)" + "1f3fdc6d-d8d5- tutorial_group tutorial_kappa SC100020230912 e550ee2f-4744-\n", + " (Total: 1)" ] }, - "execution_count": 14, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -1804,7 +1782,7 @@ "source": [ "%load_ext autoreload\n", "%autoreload 2\n", - "from spyglass.behavior.moseq import MoseqSyllableSelection, MoseqSyllable\n", + "from spyglass.behavior.v1.moseq import MoseqSyllableSelection, MoseqSyllable\n", "\n", "# Make a selection table entry defining the pose data and moseq model to use\n", "pose_key = (\n", @@ -1820,7 +1798,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1829,13 +1807,13 @@ "Text(0.5, 0, 'time (s)')" ] }, - "execution_count": 36, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsAAAAHACAYAAACsx95yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACL5UlEQVR4nOzdd3hb5eH28a+2t7ztOHb2TiCEQAYrYQUoEEYLFAgF+jILhFFmSwv8GAHaMlrKbMssUCijbAgjgRBCdiCD7O0Z7ynJ0nn/OLETx3YsO7YlW/fnunQlPnrOOY90ZPnWo2dYDMMwEBERERGJENZQV0BEREREpDspAIuIiIhIRFEAFhEREZGIogAsIiIiIhFFAVhEREREIooCsIiIiIhEFAVgEREREYkoCsAiIiIiElHsoa5ATxEIBMjNzSU+Ph6LxRLq6oiIiIjIPgzDoLKykqysLKzW1tt5FYCDlJubS05OTqirISIiIiJt2L59O9nZ2a3erwAcpPj4eMB8QhMSEkJcGxERERHZV0VFBTk5OY25rTUKwEFq6PaQkJCgACwiIiISxtrqrqpBcCIiIiISURSARURERCSiKACLiIiISERRH+BeIL+8jnUFldT6/AAcNSSVWJcurYiIiEhLlJJ6qHp/gM/XFPDC/C0s2FTS5L7UOCfXHTeU8yf0w2lXI7+IiIjI3iyGYRihrkRPUFFRgdvtpry8PKSzQNR6/Xz0Yx6Pfr6OHaW1AFgsMCQtjvgoOwUVHnaWmdtzkqO5esoQThmTSVKsM2R1FhEREekOweY1BeAghSoAr82v5IMfcvl+Uwl5FbXkl9fh85uXLDnWyfkTcrhwYn+yEqMB8PkD/GfRdh7/Yj1FlR4A4qPsPHbeIRw/MqPb6i0iIiLS3RSAO1l3BuCiSg+vLdzG+ytyWV9Y1ez+vonRXDipH5ceMZBop63FY9R463llwVZeX7SdTUXV2K0WnrzwUKaNzuzSuouIiIiEigJwJ+vOALytuIZj/vQVAE6blWOGpXHS6AwGpsaS6Y6ib2J0mxM8N/D5A9zy5greXZ6L02blmYvGc+yI9K6sfrcxDIOiSg/ltT489QEq6+rZUFjJgk0lFFd7SIhyMDYnkbPG9W1sIRcREZHeSwG4k3V3F4i731vF6KwEpo3OxB3tOKBj1fsDXPfaMj5emY/DZuHnh2bjtFv5cWc56/Ir6ZMYzUF93RwxOIWDst0MTovDYQvd4Lk6n59VueXkltWxtbiagGFuS4pxkp7gotbrZ31hFZ+tzmd7SW2bx7Na4Njh6Zw/oR9Th6dhD+FjExERka6jANzJwmUQXEf5/AFuemMF76/IbbNsYoyDiyb15+xDsxmYGtvhc9Z6/WwtqWZXpZeKOh+lNV5qvX5inHbS4134DYPNu6oprPDg8wcor/WRV17LmrxKqjz1QZ3DZrXgjnbgtFmJdtronxLDuJwkBqXFUlTpYfbqAr7bVNxYPinGwcHZiRyc7WZsdiKH9EskNc7VrN67qjxUe+vJiI/SAEIREZEeokcE4Pr6eu6++27+/e9/k5+fT58+fbjkkku48847sVrNVjrDMLjnnnt49tlnKS0tZeLEifz9739n9OjRjcfxeDzcfPPNvPbaa9TW1nL88cfz5JNPkp2d3VimtLSUmTNn8t577wEwffp0/va3v5GYmBhUXXt6AAbzuZyzrojvN5VgscDwjHhG9kkgt7yWxVtKWLS5lDV5FVTuFT7H9E0gIcqBtz6A1x+g2lOPP2DgtFuJdtrJSYrGabPiCxi4dk+5tr2khi3F1RRUeDpc19Q4FwNSYuiXEkOUw4YFyC2rxVMfwGW3kpMcw4SByRw3Ip0Y5/5n89tUVMVrC7fx3yU7KK3xNbu/b2I0GQkuLBYLhZV17CitpeG3wma1cMkRA7jz1JFBdzsRERGR0OgRAfj+++/n0Ucf5cUXX2T06NEsXryYSy+9lPvuu4/rr78egIceeoj777+fF154gWHDhnHffffx9ddfs3btWuLj4wG4+uqref/993nhhRdISUnht7/9LSUlJSxZsgSbzRwkdsopp7Bjxw6effZZAK644goGDBjA+++/H1Rde0MADoY/YPDxyjzeXLyDb9YXETjAV0dijIOM+ChiXTZS4lxEOWzUeOrJr6jDMGBIehx9EqNw2azERdnpmxhDv+QYRmclYLV2buD01gdYk1fBDzvKWLGjnBXby9hQVEVLvwEuu5Uoh43yWjMw//2CQzn14D6dWh8REelclXU+HDbz/VsiU48IwKeddhoZGRn885//bNz285//nJiYGF5++WUMwyArK4sbbriB2267DTBbezMyMnjooYe48sorKS8vJy0tjZdffpnzzjsPgNzcXHJycvjoo4846aSTWLNmDaNGjWLBggVMnDgRgAULFjB58mR++uknhg8f3mZdIyUA762wso7vNprdB5w2K067lViXHZvVgnf3oLMdpTUEDAO71dq4El3fxGgGpMYyICWGxJjw7j5QUefjp7xKSmu8GAa4ox0My4gjZXe3iHs/WM0/523mhJEZ/OPiw0JcW+kutV4/q/PKWV9QRa3Pj7c+QEGFB4vF/HYiMcZBlMOKP2B2L3LYrEQ7bEQ7rVgsFhKi7KTHR5Ea5yLaaaOsxktxtZeBKbGd/sFOwl8gYFBX76fW68frD+C0WRvfYyR4hRV1vLcil5/yK3HYrGQnRZMQ7WBjYRUbCqtYX1hJQYUHu9XCxEHJ3HLSCA7JSQx1taWbBZvXQroS3FFHHcXTTz/NunXrGDZsGCtWrGDevHk89thjAGzevJn8/HymTZvWuI/L5WLKlCnMnz+fK6+8kiVLluDz+ZqUycrKYsyYMcyfP5+TTjqJ7777Drfb3Rh+ASZNmoTb7Wb+/PktBmCPx4PHs+cr/IqKii54BsJbenwUZxzSN9TV6FIJUQ4mDExu9f5zDsvmn/M28/X6Iup8frUqhJBhGHy/uYR563dRXO3FZbficljND2c2Kw67lazEaHKSogkYBt56M3RgQEK0HU+9GVSTYpxEOaw4bFYq63xs3lXD2vwK1hZUsTa/gp2ltVR7/Z1W7yiHlTpfADAXpzl7XDa/nJBDH7dmJulu+eV1LN9eRnKsk/H9k7B10YeRokoP8zfuYt76XXy7YRe55XXNyozsk8CZh2QxbXTmAY21iBSfrcrn5jdXUFHX9viQ+oDBtxuKWbBpPr/72Uh+feQAdWGTZkIagG+77TbKy8sZMWIENpsNv9/P/fffz/nnnw9Afn4+ABkZTRdwyMjIYOvWrY1lnE4nSUlJzco07J+fn096evOpv9LT0xvL7GvWrFncc889B/YApccbnhFPeryLwkoPK7aXMXFQSqirFJF2VXm49PlF/LizvNvOmRrnYnRWAvFRdpw2K6nxZotdcZWXshovXn8Aq8WCw2bF6w9Q5/Pj8fmpDxiU1fgoqvTs3m6GX6fNyvaSWh7/Yj1PzdnIzOOHcMUxgxuXKy+v9fHlTwV8t7GYGKedcf0SGZ4ZT43XbIH21gfYUVqLzQr9kmMZkBpDZkJUp/9hN3YPTt1RWovPH8BmtRDlsO1+Lto3I40/YLCjtIbCSg+O3R9UXA4rNouF8lofme4oPL4AFXU+Knb/PDA1FovFQr0/QJWnnl1VHnLL6sgrr6Witp7kWCd93FHkJMdQ6/NTWVdPnc9PlaeekmovNV4/mQlRJMU6iHc52FXt4buNxcxdW8TagsrGuuUkR3PZUYM469C+JLTzcbX0nC3dVsqr329n6bZSNu+qbrWsw2bB5zdYk1fBmrwKZn38ExMGJHPR5P6cNDpTy9e34N1lO7npjeUEDPODwyljMjEMWJVbjj9gMDg9jiFpcQzJiGNwWhyl1V7+9NlaPvwhj3s/WM1PeRU8/IuDFYKliZAG4P/85z+88sorvPrqq4wePZrly5dzww03kJWVxcUXX9xYbt8XrWEYbb6Q9y3TUvn9HeeOO+7gpptuavy5oqKCnJycoB6X9B4Wi4Uxfd18+VMh6wqrFIBD5M+fruXHneVEO2ycMiaT/imxeP1+PL4APn8Ar9/AU+9nXUElxVVenHbr7n6AVgIBqPbW49wdVMtqfNTtDqqxThtZidGMyIxneGYCIzLjGZAaS1KM44C77xiGQaWnnpIqL6nxLmwWC5+tzuffC7axcEsJf/5sHU/O2UjfxGgMYOM+/dFfmN/2OeJddoZlxpOR4CIxxkmcy068y05CtINohw2r1YJhGNisFmKcNnx+g1iXjeykGLKTohsHkFZ76pm/sZg5awuZs7aocTn1vdmtFkZnJTR2herjjt49CNVGQUUdJdVeAEprvGwsrGbTriq27KrB6w+063lLjHHg8QUau1R1pobBv7lltWwvqeWu91bx4Mc/cdiAJFx2KzarBbu14V8Lzt1jARKizOfUUx+g1uunzufHbxiU1/gorvayvaSGTfuE3tFZCRw1JJUjh6QyKiuBGKcNl92GzWqhrMbLhz/m8dGPeXy3sZiFW0pYuKWEWKeNfimx9E2MIi3eRUqsiz6JUQxOi2NoehwJ0Q7WFVSydFsZuWW12K0WEmOcJEY7SIp1MCAllpzkmE6fxrLGW09xlZcYp43EGGeXtZy35L0VuY3h97zDcrjvrDFtPj53tIMnzh/H4f2TuO/DNby5ZAcDUmO55tgh3VRr6QlCGoBvueUWbr/9dn75y18CcNBBB7F161ZmzZrFxRdfTGamuWpZwwwRDQoLCxtbhTMzM/F6vZSWljZpBS4sLOSII45oLFNQUNDs/EVFRc1alxu4XC5cLvXREhiaHseXPxWyYa/WI+k+20tq+O+SHQC8+OsJ++2yEk7MvsCOJq2LZxzSl+ljs3h3+U7u/WANJdXeJqs9Dk2P4/iRGXjq/SzbVsbmXdUkRJst0A6blUx3FAEDthWbLbSVnnqWbC3tcB0Touw47TbKa72NS6wDOO1WBqXG4rJb8Rtmi/aO0lpW7GjaAv/awm1tnsNpt9LHHUW938DrD+Dx+fH5DWKcNoqrvUQ7bCRE24lz2dleUkvZPjO1xEfZyXJH0ycxCne0g5JqLzvLatleUkOM005CtJ1oh40Yp52UWCdRThuFFXWU1vioqqsnLsrO2OxEpgxP4+ghqSTFOqn1+nlj8XZeWbCV9YVVfLN+V4efwwZRDivTx2Zx2sFZjOnrJnk/0ycmxji5cGJ/LpzYn/zyOl5buI1XF26jqNLT2DLcEpvVgr+Nkcl2q4Xx/ZOYNjqTaaMyyEmO2W95wzBYnVfB/A3FFFTUYbdZcdos5JXXsSa/gi27appNSxntsBHlsDY+luykaAakxDaO/eifEkvfxGiiHNYOt7pW1vn417wtPPbFOozd4XfW2QcF3YfeYrFwyZEDcTls3PH2j/z5s7UckpPIkUNSO1Qf6X1CGoBramoapztrYLPZCATMFoOBAweSmZnJ7NmzGTduHABer5e5c+fy0EMPATB+/HgcDgezZ8/m3HPPBSAvL4+VK1fy8MMPAzB58mTKy8tZuHAhEyZMAOD777+nvLy8MSSLtGZIehwA6wqaL0stXe+V77dSHzA4ckhKjwm/+2OxWDhrXDanHpTFjtIadpbVUu83OCjb3WxO6v3x+QNsLDIH/+yq9FBW66PW66esxkeVp55anx9/wMBiMcvW+QI4bBYqas3BqxV19bv7U5rhJic5mmOHpzN1eBqTB6U2W2Z9e0kNP+wox2KBqjozeH/xUyEJUXayEqNJjnVisUCcy86gtDgGp8UyOC2OrMToVlsMAwGjSaCp9tSzraSGWKed+Cg7sS57q10CgvkmsDXRThsXHzGAX03uz9JtZWwsqiIQMKgPGPh33+oDZreTGq+f8loflXX1RDmsu8Of2bqeGO0gOdZJSpyT8f2Scce0vytFpjuKG08cxrXHDWHLrmp2lNWSW1ZLcZWXwso6csvq2FBYxfbSGvwBg3iXnUP6JTI4LY6AYVBa46OsxsuuKi9bdlVT6/Pz/eYSvt9cwr0frCYpxkHfpGj6JkZzcHZiYzCv9fopq/Xx+eoCVrcSuPfmtFvx1pt/m2t9/sYW+tIaH5t3Vbf4IcJutZAe78JmsxDrtNPHHUVeeR1VnnoMw/zQ4LLbcNqtWC1Q4zWPu6vS06Qf/kWT+nP39NEdGkB6/oR+/LCjjNcWbufW//7A5zdNafbalsgU0lkgLrnkEj7//HOeeeYZRo8ezbJly7jiiiv49a9/3RhwH3roIWbNmsXzzz/P0KFDeeCBB5gzZ06zadA++OADXnjhBZKTk7n55pspLi5uNg1abm4uzzzzDGBOg9a/f39NgyZtWrG9jDP+/i2pcS4W33lCqKsTUQIBg0mzvqCw0sPTM8Zz8pjMUFep1yiv9VFUWYe33iAh2t6uJdal+9V6/ZTWeMlMiGo1CBqGwbaSGmavLmD26gIWbSkJaipLp93K0UNSGZIeh89v4PMHSI1zMTQjjuGZ8WQkRBHnsuPzB6io9VHt8eOp92Ng9olvmPt9S3E1W3aZ/6/phIGkOcnRXHvsEM47vN8BHafaU8+0R79mZ1ktd546ksuOHnTAdZPw1SOmQausrOQPf/gD77zzDoWFhWRlZXH++efzxz/+EafT/JTasBDGM88802QhjDFjxjQep66ujltuuYVXX321yUIYe/fZLSkpabYQxhNPPBFRC2FIx1R56hlz16cALPvDiVoZrhut3FnOaX+bR6zTxrI/TtMAIZF2qPLUs72khp2ltWwprmZVbgWVdT7AQrTTRpzLxojMBM44JKtTp6w0DIMqTz2VdfUUVNQRMAwqauvZvKualDgn/ZJjsFosjVMMeuoD+AMGcS47LoeV1DgXqXHOdg+63J/XFm7jjrd/ZEh6HJ/fNKXTjivhp0cE4J5EATiyHfngl+wsq+XNqyZz+ICe/zV8T/H3rzbwp0/XcuKoDJ77leZhFpGOKa/1Mf7e2dQHDObcPJUBmnqu1wo2r6k5RSQIe/oBayBcd5q7tgiAKcPSQlwTEenJ3NEOxvc3B8p/v7k4xLWRcKAALBKEYRlmAF6vgXDdpspTz5Jt5gwHCsAicqAaVoXrzvnEJXwpAIsEYWi6OeByQ6ECcHdZtdOc5D5r96IHIiIHYkxfNwA/7lAAFgVgkaAMaWgBLlQXiO6yKtecmmn07j9aIiIHYmQfsz/ohsIqNPxJFIBFgtDQB7igwkN5ra+N0tIZGgNwlgadisiBy0mOxmqBaq+foipPqKsjIaYALBKEhCgHfdxRAGxQK3C3WJVrfk05OkstwCJy4Fx2c+lzgK3FNSGujYSaArBIkBpagTUQruvV+fyN/a3VAiwinWXg7unPNu+qDnFNJNQUgEWC1DAQbr0GwnW5dQWV1AcMkmL2tLyLiByo/inmgNqtxQrAkU4BWCRIQzM0F3B3aej/O6avW8vzikinGZBitgBv2aUuEJFOAVgkSA1dIDYVqeWgqzX0/x2l7g8i0okaA7BagCOeArBIkAbt7ju2s6yWOp8/xLXp3fbMAKEBcCLSeQakml0gtuyq1lRoEU4BWCRIybFOEqLsgAZQdCV/wGBNnqZAE5HOl51kBuBqr5/SGk1pGckUgEWCZLFYGJRmdoNQAO46m4qqqPMFiHHaGLj760oRkc4Q5bCRGucCYGdpbYhrI6GkACzSDoPSzEC2qUgzQXSV1btbf0f2ScBq1QA4EelcfZPMuYB3lmkgXCRTABZph4Z+wJvUAtxl1uSZs2yM7BMf4pqISG+UvTsA71ALcERTABZph4YuEJoJouuszTdbgIdnqv+viHS+7MSGFmAF4EimACzSDg2rCG0qqtII4i6yNt9sAR6RqRZgEel8jV0g1AIc0RSARdphYGosFgtU1NVTUu0NdXV6nfJaH7nldQAMy1AAFpHO11ctwIICsEi7RDlsZLnNN0/NBNH5GlbZy3JH4Y52hLg2ItIb7RkEpwAcyRSARdppz0wQCsCd7afd3R+Gq/uDiHSRhhbgshof1Z76ENdGQkUBWKSdGmaC2LhLU6F1Ng2AE5GuFh/laFzUSK3AkUsBWKSd9gyEUwtwZ9MAOBHpDg0rwu0o1VzAkUoBWKSdtBpc1zAMQ10gRKRbaCYIUQAWaafB6WYA3lpcTb0/EOLa9B655XVU1tVjt1oYvPtDhohIV2joB7xDXSAilgKwSDv1SYgi2mHD5zfYrtaDTtPQ/3dwWhxOu96aRKTrZKsFOOLpr4xIO1mtlsZ+wBsLNRCus6j7g4h0F80FLArAIh3Q0A1iY5ECcGdZqwAsIt1EfYBFAVikAwZpJohOpxkgRKS7NLQAF1Z68NT7Q1wbCQUFYJEOUAtw5/L5A43PpVqARaSrJcc6iXbYAMgrqwtxbSQUFIBFOmDw7tXgFIA7x6aianx+g3iXvbFlRkSkq1gsFi2JHOEUgEU6oGEQXGmNj5Jqb4hr0/P9tHsGiGGZ8VgslhDXRkQiQeNAOPUDjkgKwCIdEOO00y/ZXEnohx1loa1ML6ABcCLS3RpagDUXcGRSABbpoIkDkwH4bmNxiGvS82kAnIh0t8bFMLQcckRSABbpoCOGpADw3SYF4APVOAdwhgKwiHQPLYYR2RSARTpo8qBUAFbuLFc/4ANQUedrHIQyIjMhxLURkUjR0AKcW64AHIkUgEU6KNMdxcg+CQQM+PKnwlBXp8dat7v1t487CneMI8S1EZFI0Wd3AM4vryMQMEJcG+luCsAiB+DEURkAzF6dH+Ka9FxaAllEQiEj3oXVAj6/wa5qT6irI93MHmzBcePGBT090dKlSztcIZGeZNqoDP76xXq+XreLOp+fqN0Tq0vwNAOEiISC3WYlPT6K/Io68srqSI+PCnWVpBsF3QJ85plncsYZZ3DGGWdw0kknsXHjRlwuF1OnTmXq1KlERUWxceNGTjrppK6sr0hYGZ2VQJY7ilqfn2837Ap1dXokzQAhIqHSJ9EMvXnqBxxxgm4Bvuuuuxr/f9lllzFz5kzuvffeZmW2b9/eebUTCXMWi4UTRmXw0ndbmb26gONHZoS6Sj2KYRiNi2AMz9AAOBHpXlnuaJZRRq6WQ444HeoD/Oabb/KrX/2q2fYZM2bw1ltvHXClRHqShn7An68pwK+BFO2SV15HRV09dquFwemxoa6OiESYPm61AEeqDgXg6Oho5s2b12z7vHnziIpSHxqJLBMHppAQZWdXlZclW0tDXZ0epaH1d3BaHC67+k+LSPfq0zgVmlqAI03QXSD2dsMNN3D11VezZMkSJk2aBMCCBQv417/+xR//+MdOraBIuHParZw4KpO3lu7gox/zmLB7hThp25o8s//vyD7q/ysi3S+roQVYyyFHnA4F4Ntvv51Bgwbx+OOP8+qrrwIwcuRIXnjhBc4999xOraBIT3DKGDMAf7oqnz+eNgqrNbgZUyJdwxRoI/qo/6+IdL/Mxi4QagGONB0KwADnnnuuwq7IbkcNTSXOZSevvI7lO8o4tF9SqKvUI6zJM7tAaAYIEQmFrN1dIAoq6qj3B7DbtDxCpNCVFukEUQ4bx49MB+DjH/NCXJueoc7nZ1NRFQAj1QIsIiGQGufCbrUQMKCwUothRJKgA3BycjK7dpnznCYlJZGcnNzqrT127tzJjBkzSElJISYmhkMOOYQlS5Y03m8YBnfffTdZWVlER0czdepUVq1a1eQYHo+H6667jtTUVGJjY5k+fTo7duxoUqa0tJSLLroIt9uN2+3moosuoqysrF11FdmfU8ZkAvDxynwMQ7NBtGVDYRUBA5JiHKTHu0JdHRGJQDarhYwEzQQRiYLuAvHoo48SH29+TfnYY491yslLS0s58sgjOfbYY/n4449JT09n48aNJCYmNpZ5+OGHeeSRR3jhhRcYNmwY9913HyeeeCJr165trM8NN9zA+++/z+uvv05KSgq//e1vOe2001iyZAk2mzmy/IILLmDHjh188sknAFxxxRVcdNFFvP/++53yWESmDEsn2mFjR2ktK3dWcFC2O9RVCmt7uj8kBL3KpIhIZ8tKjGJnWS25ZXWM7x/q2kh3CToAX3zxxS3+/0A89NBD5OTk8PzzzzduGzBgQOP/DcPgscce4/e//z1nn302AC+++CIZGRm8+uqrXHnllZSXl/PPf/6Tl19+mRNOOAGAV155hZycHD7//HNOOukk1qxZwyeffMKCBQuYOHEiAM899xyTJ09m7dq1DB8+vFMej0S2aKeN40ak8+GPeXy0Mk8BuA17BsCp/6+IhE4fdzRQqhbgCNPhPsB+v5+33nqL++67j/vvv5933nkHv9/frmO89957HHbYYZxzzjmkp6czbtw4nnvuucb7N2/eTH5+PtOmTWvc5nK5mDJlCvPnzwdgyZIl+Hy+JmWysrIYM2ZMY5nvvvsOt9vdGH4BJk2ahNvtbiyzL4/HQ0VFRZObSFtObugG8WOeukG0oWEO4JGZ6v8rIqHTsByyVoOLLB0KwBs2bGDkyJH86le/4u233+a///0vM2bMYPTo0WzcuDHo42zatImnnnqKoUOH8umnn3LVVVcxc+ZMXnrpJQDy8/MByMhourxsRkZG4335+fk4nU6SkpL2WyY9Pb3Z+dPT0xvL7GvWrFmN/YXdbjc5OTlBPy6JXMeOSMdlt7KluKaxhVOaMwyjcQ5gtQCLSChluXcvhqG5gCNKhwLwzJkzGTx4MNu3b2fp0qUsW7aMbdu2MXDgQGbOnBn0cQKBAIceeigPPPAA48aN48orr+Tyyy/nqaeealJu3/6BhmG02Wdw3zItld/fce644w7Ky8sbb9u3bw/2YUkEi3PZmTIsDdBsEPtTVOWhpNqL1QJD0xWARSR0GpZDzq9QC3Ak6VAAnjt3Lg8//HCTGR9SUlJ48MEHmTt3btDH6dOnD6NGjWqybeTIkWzbtg2AzEzz6+R9W2kLCwsbW4UzMzPxer2Ulpbut0xBQUGz8xcVFTVrXW7gcrlISEhochMJxs8O6gPABz+oG0Rrftrd+jsgNZZop5ZAFpHQaVgMo0ABOKJ0KAC7XC4qK5t/vVtVVYXT6Qz6OEceeSRr165tsm3dunX0728Owxw4cCCZmZnMnj278X6v18vcuXM54ogjABg/fjwOh6NJmby8PFauXNlYZvLkyZSXl7Nw4cLGMt9//z3l5eWNZUQ6ywmjMnDZrWzaVc2qXPUdb4kWwBCRcNEwDVpRpQd/QI0WkaJDAfi0007jiiuu4Pvvv8cwDAzDYMGCBVx11VVMnz496OPceOONLFiwgAceeIANGzbw6quv8uyzz3LNNdcAZreFG264gQceeIB33nmHlStXcskllxATE8MFF1wAgNvt5v/9v//Hb3/7W7744guWLVvGjBkzOOiggxpnhRg5ciQnn3wyl19+OQsWLGDBggVcfvnlnHbaaZoBQjpdnMveuCjG+ytyQ1yb8LR6dwAenaWZMkQktFJinVgsEDCguFqLYUSKDgXgv/71rwwePJjJkycTFRVFVFQURx55JEOGDOHxxx8P+jiHH34477zzDq+99hpjxozh3nvv5bHHHuPCCy9sLHPrrbdyww038Jvf/IbDDjuMnTt38tlnnzXOAQzmHMVnnnkm5557LkceeSQxMTG8//77jXMAA/z73//moIMOYtq0aUybNo2DDz6Yl19+uSMPX6RN08dmAWY3iIBaFJpZvbtlfJRWgBORELPbrKTGmYvxFFYoAEcKi9HOToqGYbBt2zbS0tLIzc1lzZo1GIbBqFGjGDJkSFfVM+QqKipwu92Ul5erP7C0qc7n57D7PqfKU89/r5rMYQPat0Jib1br9TP6rk8IGPD9745v/PpRRCRUTvvbN6zcWcE/Lz6M40e2PDZIeoZg81rQC2E0MAyDoUOHsmrVKoYOHdqrQ69IR0U5bEwbncHbS3fy/opcBeC9rC2oJGBAapxTSyCLSFjIiI9iJRUUVqoFOFK0uwuE1Wpl6NChFBcXd0V9RHqN03d3g/jwxzzq/YEQ1yZ8NHR/GNlHSyCLSHhITzA/jGsmiMjRoT7ADz/8MLfccgsrV67s7PqI9BpHDUklKcbBriovCzaVhLo6YWN1XjkAo7LUlUhEwkN6fMNUaGoBjhQdCsAzZsxg4cKFjB07lujoaJKTk5vcRAQcNiun7J4T+L0VO0Ncm/ChAXAiEm4axiIUqgU4YrS7DzCYsy7oq0uRtp1+cBavfr+NT1bmc++ZY3DZI3vRB39gzxLIo9UCLCJhImN3Fwj1AY4cHQrAl1xySSdXQ6R3mjAwmYwEFwUVHr5et4sTR0X26OItxdXU+vxEOawMTI0LdXVERIC9u0CoBThSdKgLhM1mo7CwsNn24uLiJnPvikQ6m9XCqQeZg+G0KMae7g8jMhOwWfUtkoiEh4YW4F1VHg1ajhAdCsCtTR3s8XjatRSySCSYfogZgGevLqDGWx/i2oRWwwpwGgAnIuEkJc6FtXE1OG+oqyPdoF1dIP76178C5hLF//jHP4iL2/MVpt/v5+uvv2bEiBGdW0ORHm5stpv+KTFsLa7hox/z+cX47FBXKWRWaQCciIQhm9VCWrzZXa2gok4L9ESAdgXgRx99FDBbgJ9++ukm3R2cTicDBgzg6aef7twaivRwFouFcw/L4U+fruU/i7ZFdABunAFCLcAiEmbS46MoqPBoOeQI0a4AvHnzZgCOPfZY3n77bZKSkrqkUiK9zS/GZ/OXz9ayaEspGwqrGJIeeQPACivr2FXlwWqBkZkKwCISXhpWptRMEJGhQ32Av/rqK4VfkXbISIjiuBHpALyxeHuIaxMaP+4wF8AYmBpLtFODZUUkvKQnaCaISNKhadD8fj8vvPACX3zxBYWFhQQCTUdMfvnll51SOZHe5LzD+/H5mkJeX7iN30wdTGJMZA0YXbatDIBx/fThWUTCj1qAI0uHAvD111/PCy+8wKmnnsqYMWO0KIZIEI4bkc7wjHjWFlTy5JyN/O5nI0NdpW61dFspAIcqAItIGNJqcJGlQwH49ddf54033uBnP/tZZ9dHpNeyWS3cfsoILn1hEf+at5nDByRHzMIY/oDBiu1lAIzrlxjSuoiItEQtwJGlQ32AnU4nQ4YM6ey6iPR6U4enMX1sFvUBg8tfWsyF/1jAv+Zt5qf8Cup8/lBXr8ss2lJCtdePO9rBsIz4UFdHRKSZ9MblkNUCHAk61AL829/+lscff5wnnnhC3R9E2sFisfCncw4mJc7Ji/O38O2GYr7dUNx4f3Kskz7uKLISo+mXHMPB2W4yE8yfM91ROGwtf2b1+QMUVZrzV5bWeHHZbUQ5rKTHR9E3MRpriFdd+99ycxW840emawU4EQlLDV0giio9+AOG3qt6uQ4F4Hnz5vHVV1/x8ccfM3r0aBwOR5P733777U6pnEhv5LLbuOv00Vx6xEA+XpnHvA27WLq1lGqvn5JqLyXV3sYFI/ZmsUBGfBT9UmJIiLJjt1rx1PvZUlzDtpIa/IGWV2iMdtg4qK+bo4amcv6EfqTt/pqvu8xZW8h/Fm0D4JzxOd16bhGRYKXEOrE0rgbnIT1ei2H0Zh0KwImJiZx11lmdXReRiNIvJYYrpwzmyimDMQyDitp6cstryS2rJbe8jvUFlazJq6Co0kNuWR1ef4D8ijryWxmgYd+9klFqnAtvfYAaXz355XXU+vws3FLCwi0l/P2rDZx7WA5XTR1M38ToLn18hmHw9NxN/OnTnwgYcOYhWUwenNKl5xQR6Si7zUpqnIuiSnMxDAXg3q1DAfj555/v7HqIRDSLxYI7xoE7xsHIFpYJDgQMiqu97CitYXtpLTWeenz+ADarlQEpMQxMiyUjPqpZV4d6f4AtxdUs3FzKG4u3s3x7GS8v2Mobi7dzxTGDuGrKYGJdHXob2K8abz03/WcFn6zKB8yFQO47c0ynn0dEpDOlx+8OwJV1gDvU1ZEu1OG/fPX19cyZM4eNGzdywQUXEB8fT25uLgkJCcTFRd4qVyJdybq7dTct3tWueXTtNitD0uMZkh7P+RNy+G5TMY9/vp7vN5fwty838Mbi7dxy0gjOHte30/oJV9b5+PULi1i0pRSnzcrd00dz/oQcjRcQkbCXHu9iFWg55AjQoQC8detWTj75ZLZt24bH4+HEE08kPj6ehx9+mLq6Op5++unOrqeIHCCLxcIRg1OZPCiFT1cV8MBHa9hWUsPNb67gpe+2cPspI5g8KOWAgmpZjZeL/7WQFTvKiY+y88KlhzO+f3InPgoRka6T0bganAJwb9ehadCuv/56DjvsMEpLS4mO3tOP8KyzzuKLL77otMqJSOezWCycPCaT2Tcdw+2njCDOZeeHHeVc8Nz3nPnkfN5eugNPffunZNtV5eH8575nxY5ykmIcvHb5JIVfEelR9swFrKnQersOzwLx7bff4nQ2Xcq1f//+7Ny5s1MqJiJdy2W3cdWUwfz80Gz++sV6/rN4Oyu2l3HT9jLu/3AN5x2ew4WT+gc1WK6goo4LnlvAxqJqUuNc/PuyiQzP1Hy/ItKzpKsFOGJ0qAU4EAjg9zdvIdqxYwfx8fqjJ9KTpMW7uPfMMXx723H89sRh9HFHUVzt5ck5Gzn6oS+5/KXFzFlbSGFlXbOp1gIBg/kbdvHzp+azsaiaPu4o3rhyksKviPRIDS3ARWoB7vU61AJ84okn8thjj/Hss88C5leqVVVV3HXXXVoeWaSHSot3cd3xQ7l66mA+X1PAS99tZf7GYmavLmD26oImZWOdNhJjnBRXe6jzBQDolxzDvy+bSE5yTCiqLyJywBpagLUccu/XoQD86KOPcuyxxzJq1Cjq6uq44IILWL9+PSkpKbz22mudXUcR6UZ2m5WTx/Th5DF92FBYycvfbeWz1QXkV9Rh7G4Arvb6qfbWAuZCG6eP7cOdp40iIcqxnyOLiIS3jISGFmAPgYAR8lU0petYDMNoefmoNtTW1vL666+zZMkSAoEAhx56KBdeeGGTQXG9SUVFBW63m/LychISms/TKtLb1fsDVNTVUx8IUFVXT3mtj6QYJ9lJ0dhbWaJZRKQn8fkDDLvzYwwDFt95Aqlx3btyphy4YPNah1qAZ82aRUZGBr/+9a+59NJLG7f/61//oqioiNtuu60jhxWRMGa3WUmONQe+pquLr4j0Qg6blZRYJ7uqvBRU1CkA92IdarZ55plnGDFiRLPto0eP1hzAIiIi0mOlxasfcCToUADOz8+nT58+zbanpaWRl5d3wJUSERERCYXGmSA0FVqv1qEAnJOTw7ffftts+7fffktWVtYBV0pEREQkFBoGwhVUaCq03qxDfYAvu+wybrjhBnw+H8cddxwAX3zxBbfeeiu//e1vO7WCIiIiIt0lXV0gIkKHAvCtt95KSUkJv/nNb/B6vQBERUVx2223cccdd3RqBUVERES6i1qAI0OHArDFYuGhhx7iD3/4A2vWrCE6OpqhQ4ficmm0pIiIiPRcGgQXGToUgBvExcVx+OGHd1ZdREREREIqfa/FMKT30uz1IiIiIrtlNC6HXEcH1wqTHkABWERERGS3tN2LX/j8BqU1vhDXRrqKArCIiIjIbk77nlUvu30gXG0p+BW6u8MB9QEWERER6W3S412UVJvLIY/sk9C1J/NUwtpPYMnzsPVbsFghdRj0PxIyRkHiAEgaAPEZ4NI69J1FAVhERERkL+kJUfyUX0lhR1eDq/dAdRHUlEBNsXmrLYWKXKgqhLKt5s91FVCZB4G9Wn2NABT9ZN72lTIU4jPBYgGLzQzL9XXgSoDYFIhJhdhUiE2D5MHQ52Cwa4auligAi4iIiOwlc/dMEPnt6QJRXQyL/gEbv4SdS5qG2rYkD4KDfwnjZpihdsdC2LEIdm2Asm1Qsgnqa6F4vXkLls0JmQdD9mHgzjGDsSsOAn5I7Ge2NDtjgj/e3gK7g/q27yBvuRnm6+sgyg0xKRDfB5L6m/8m9jODexhRABYRERHZS+bumSCCDsBLXoRPfw/eyj3brA6ISTbDYEyK+f/YdIjLMANhbKrZchuTbAZgi2XPvqPOMG97qymBHYvBUwGGAYbfbC22u6Cu3AzgNbugepfZ+lywyvx552Lz1iILpA03u1sMPhbSR5mh2WoHmwOsNvNxWO3g95rnrsyH5a/CqrfNVuxgjDwdznsluLLdRAFYREREZC8ZbjMAF5S3EYANA756AL5+2Pw582A4/DIYeDQkDWwaag9UTDIMmxZ8ecOA0i1maM5bbgbX6iLw1ey+b7PZNaOhu8Xif7a/To4Ys3U5Z6IZ7G1OM4zX7DJbrst3mudN7N/+Y3cxBWARERGRvfRxB9EC7K2Gj2+FZbtbNqfeAcfcCtYwmWDLYoHkgebt4HNaLlNZYHa12Pw1bJht9k8O1JszURj+5uWtDohKgH6TzaA/4CizpbgHUgAWERER2UvDYhitToO2cwm8fQUUbwAscMrDMPGK7qtgZ4nPgJGnmbd9BQJmCPb7zP7MNifYozq3VTuEwuRjCsyaNQuLxcINN9zQuM0wDO6++26ysrKIjo5m6tSprFq1qsl+Ho+H6667jtTUVGJjY5k+fTo7duxoUqa0tJSLLroIt9uN2+3moosuoqysrBselYiIiPQ0DX2Ad1V58dYH9txRWQDvXgPPHW+G3/gsuPi9nhl+22K1mq27zhhzYJsjuteEXwiTALxo0SKeffZZDj744CbbH374YR555BGeeOIJFi1aRGZmJieeeCKVlXs6md9www288847vP7668ybN4+qqipOO+00/P49TfcXXHABy5cv55NPPuGTTz5h+fLlXHTRRd32+ERERKTnSI514rSZEamwsg7qvTD/b/C38bD8FcCAg86Fq7+FgceEtrLSISHvAlFVVcWFF17Ic889x3333de43TAMHnvsMX7/+99z9tlnA/Diiy+SkZHBq6++ypVXXkl5eTn//Oc/efnllznhhBMAeOWVV8jJyeHzzz/npJNOYs2aNXzyyScsWLCAiRMnAvDcc88xefJk1q5dy/Dhw7v/QXe3ugpY+V/w1cKwkyFlcKhr1DUa1mzvRZ9QRUSk+1ksFtITXOworaF29Sew9IE9049ljTO7PORMCG0l5YCEPABfc801nHrqqZxwwglNAvDmzZvJz89n2rQ9Ix5dLhdTpkxh/vz5XHnllSxZsgSfz9ekTFZWFmPGjGH+/PmcdNJJfPfdd7jd7sbwCzBp0iTcbjfz589vNQB7PB48nj0TYFdUVHTmw+4enipY+CzM/+ueqUpm3wXH/wGOmNl7gmLpFlj6kjktS1UBRCWao1IzD4JDf2WuoCMiIpGpsgB2rYVd681BXq44c1aC5EHmADFnbNPy/nrYNp/bLS9ykHM+/WcXmttj0+CEu2HsBeEz0E06LKQB+PXXX2fp0qUsWrSo2X35+fkAZGRkNNmekZHB1q1bG8s4nU6SkpKalWnYPz8/n/T09GbHT09PbyzTklmzZnHPPfe07wF1p0AAdq2D/B8BAwZOMTuzgxl8Fz1nfl1TU2xuSx5sTlGybT7M/qM5P+DpfwVHVMgeQlBqSszpW3y15hyEVrs5CrV4PRSugYKVkLei6T61JbD+M/M27zEY8TNzZG6fg1s6g4hIaHkqzcUTCn8CX7X5Hu6pNGcZyDoEJlwO0UltHkYw/zbmLd+9GMVSc4aD6sL97xOXaYbhmGSo2AnFG8FTwWkAVqi3OrFPvAKm3Gr2hZVeIWQBePv27Vx//fV89tlnREW1HsIs+7RSGobRbNu+9i3TUvm2jnPHHXdw0003Nf5cUVFBTk7Ofs/baWpK4G+HAhZzRRirHRKyzHn2otzm3H2b5pitnXvLOtR8s1z1rhkCwWz9nHI7HHSOOaH1on/Ax7fBD/8xf8l/+e/gV2fx1e0JniWbzJbXks3mG7XVZtbTFQ/DTjL7RsWltXycQACq8ncH2FVQuNp8zNFJ5idxZ6w5T+G2782Ai9FGxSzmBN7jL4HsCVCZCzuWwLqPzTfBNe/D2o9h0m/MPySJ/YJ7vCIiXam2FD67E354w/yA35K1H8KCJ8338cN+DXZn99axp6jIg28fh5VvNQ+8FqvZ4ps6zPxb6qnY/fdrk3kNqvLN295iUlgePYmn8oYxZPLp3HLS+G57KNI9QhaAlyxZQmFhIePH73lR+f1+vv76a5544gnWrl0LmC24ffr0aSxTWFjY2CqcmZmJ1+ultLS0SStwYWEhRxxxRGOZgoJ9giJQVFTUrHV5by6XC5crROtnB/zNV1epyofcpU23OWLMr/nrPeYn3tyle8okD4JjbjGDqG2vyzzhckgdCm9cbK4M8/TRcOI95hKMe3+lU1cBGz6HjV9A0Vpz/fKKXNoOo8DmuWZXi5wJ5i02zQy0u9ZD7nLzjcffjvXVU4aY4djqMKdiqa8zH1/6aMgYZfbHcmfvKZ/QB/qON0flFqyCObPMEDz/r2ar+MCjYdCx5ptiwGcef9DUpi0shmF+Vbb+U/jpI/Mrs5NmtR7qRUSC5a+Hn96Hj2/fE7ySB5mrcbkSzIYEV7z5HrX0RXORgk9ug4XPwAn3mKtq9ZYubAeqMt/8pm/J8+bfBgBnnPmenjPBnK82Y0zry/3WlpoNOSWbzIYYd18zLKePZNG8rXy6cw2uKnV36I0shmEEkWg6X2VlZWNXhgaXXnopI0aM4LbbbmP06NFkZWVx4403cuuttwLg9XpJT0/noYceahwEl5aWxiuvvMK5554LQF5eHtnZ2Xz00UeNg+BGjRrF999/z4QJZof177//nkmTJvHTTz8FPQiuoqICt9tNeXk5CQkJnfhMtMBfDyUbdy91GDBbBoo3mF/l1HvMT7DZh0P/I8wlEMHs47T2Q/MrtJwJMOrMpsF3X8Ub4fULzDdWMKdySRtmvhlU5LX+lVGU2wyeqUPMN4mkAeYSjwG/OXl22VazdXnnkv0/RovV7JaRMcp8c4pLh9oyMyh7q80y2Yebb17xrX9QCYphwNqP4PtnzHDeEnsUjDjN7A9WvgPWzzZXstlbYj+44A1IH3lg9RGJNIZhrg7VMIeo32e+X3irzA/WhmF+AE0Z0vl9K+sqzLEQBavMkDn0RPO9xWrrvHMEAuY3c8UboXy7+Z5tc5oh1ltt/tzwXr5jsfk+VFdu7psyBKb/zXyvaynU+uth2UvmamPVRea2vofBzx42P+h3FsMwb93Rt9Vfb3b18NaYjRAWm3k9LFbzG8XqXVC4CvJ+ML8FLFprfjAYchz0P8p8rVQVmI04K17fE3xzJsHRN5nh137gDVjvrchl5mvLmDAwmTeunHzAx5PuEWxeC1kAbsnUqVM55JBDeOyxxwB46KGHmDVrFs8//zxDhw7lgQceYM6cOaxdu5b4+HgArr76aj744ANeeOEFkpOTufnmmykuLmbJkiXYbOYb3CmnnEJubi7PPPMMAFdccQX9+/fn/fffD7pu3RqAu0u9BxY8Bd/8xfxKaF9JA2DkdHNAWcLuT8WxqcG1POxaD9u+M0O7r9acPzAu0+zGkTLYbLENxeoxpVvhxzdg1wbzzRbMsL5rbQuFLWY4H3I8rHrHDPeuBDj3RRh8XLdWW3qBqiKzX3rBqt1LkQbM16A72/wWI2eCGZj25a0x+/sXrjZvVYXm63Dwceb0S664lvep2WX+7gX8ZqjwVJihy1tlDhRNHWaGj7qKPfdV5O7p4hTwmYHVEW0GlOpd5qT4Vhu4c8wPhKnDzIDnrTJb3TwV5gfZ2lKoK9vz/8o88zG3JWkgTLzS/JBfW2a+R1Xmmn1iY1PNcQzxmbs/eKeaz190ohmAitaaH+gLVkH+D2adY1Jg63zzGHuLz4LRZ5ofvC0283wBv7l0a9nW3fUvN49bV2E+f+wOiPv+64yB6mIz0LVHVKL5jdzRNwc3FsNTabZ0Lnhy93NpMVfiOuaWpo0EhmE+jopcs3W5YLX5zWBVgVlP2NM4YnOa39D5febz56s2n7PYtD2DxCwW81p6qszr7K3ZMy9sVKL5OqnMN69x5e7W7JhU83o5os1ttWXmB576OvOa7du4cKCyJ8Cxd+z+Zq/zWsYXbi7h3Ge+o39KDHNvObbTjitdq1cEYMMwuOeee3jmmWcoLS1l4sSJ/P3vf2fMmDGN+9TV1XHLLbfw6quvUltby/HHH8+TTz7ZpL9uSUkJM2fO5L333gNg+vTpPPHEEyQmJgZdt14ZgBv46mDHQnPN7phk849C8qDI6exvGGYIXvepOWgwJtkMFn0P2/O1WU0JvH6hOYjQ6oAL31AIDlZ1sdmas2ud+VVjbRl4K/cM8vFWm3+AU4earfAHn9f5rVA1JbDmPfODmRHYHcxKzJATm7r7G5Ujoc9Y84OZYZiDYUq3mCHSV2P+4a8uMvez2s1w2BBYy7ebZSvy9vTbh6aBsK2AZLGagcIZa+4fk2xu27nErHNLrA7zG4mGfu0NX+XW1x7wU9YtGsKn1W4GqIaWvM6WNBDGX2wOGt7whRnoOpvNZX4gcGebgbbea77OnXFma6TFaj7elMEw5ATzQ09HWqErC2D2H8xv2hq4Esz37YDffK17yjvvcXUli838fQv4zde44Td/r2JSzW8kMw82u/mljzI/xKz71Az03krzdyVjDAw9odODb4NtxTUc86evcNmt/HTvyW2OP5Lw0CMDcDjr1QFYglPvgbcvh9X/A0csXPJ+534F2Zv4ffDd383+iyWb2rdvvyPg9MfNP4DB8FabrVu+OjP4+erM4Fm8Yc9MIQWrzZaqtjhizNbNyvyuCRF9xppf4Ua59/RBL9kE2783W+1aE50MGaPNIJCYY5Zd98n+97G5zBY4q213n9KE3bc4M8gXbwB7NETt3h6VYAaPjFHm1/KOmN3hv9asZ1y6GVTrPWbgL1prhnN3jhnWvdXmcaITza+ooxLN/0clmq22CVnmvhaLGdytdjP8NIQKbzUs+qfZSu73mvvZnWZrrSverHNVgXltijeYrZF7i0k1PwykjzSDk9VufvBwxcNBvzCfCzDr8NOHsH2h+Trx+8zn0eYwP0gkDTQfT8PKV87YPdcLy+76WprWOzoZkvp377dam+bCZ7/fPRPQPqwO83USk2p+sOx7KCQOgNgU83H4d/8u+GrND/0WqxnMo5PN1tmqwj3dOcB8/A2vHUe0+WGwoYXfajfHXcT3MVvoG1p4K/PN5zo+0zyubfeHRr/P3BblNlug9w2VhhE2/ZvrfH5G/OETAJb/8UQSYzQAsSdQAO5kCsACmG/or55rzsIRnQy//gTSImAxlfaoLTUHWe7d3zppAKQON/8YxyTvGejjjNvTyr7te3OQoq/a/MN41E1w1I3Nvx4u3mh2rSlcbf7x3zKv9RH0e8sYY/YNtDnMP77RSWY9KnbC1u/M1v29B59a7ebXwK44Mww6os2vh2NSzZYqX63Zim34wd3PDE/ubPOPd6DebNFqCIRRiWZL8/6+VakqMsOIr9p8nVUXmccfcLQZrvZlGGarc+Eas/XUCJghM32kWUdXfNgEiU7X8GcrUG9eM7srcr6x2penyrz+VQXmazY62XwdtjboS9rl0HtnU1Lt5ZMbjmZEpv729wQKwJ1MAVgaeSrhxelmv7qEvmYI1tRqppLN8O9fmC10zjg4eZbZjzw6Mbj9y7bDhzeZrYBgtsZNuxeGnWLOyDHnQbN/577s0eYffHv07la7GLMbT+pwyBxjht/kgfs/dyBg9iGtyjf7q6cM7pSBNCLSc53y+Desyavg+UsP59jhzdcUkPATbF4L+UpwIj2OKx4u/C88f4o5eO6lM80QHBfhb47Vu+Dls8zR8O4cOP91M3y2R2KOOdPGqnfg09+Zx/rPDMBC4xR8Vrs56CVjtNna2W+y+e+BtnZarbtnJRl1YMcRkV4jM8HFmjwoKO+i/ukSMgrAIh0RmwIXvQP/Otmcsu5fJ8OMt9puZeytvDVm15DSzWZr+K8/M/sFdoTFAmPONqer+uYRWPKCOfDMEWPOEHDETLMbhYhIF8t0m12w8isUgHsbBWCRjnL3hV+9a7YAl2yEf06DGf81BzpFkoAf3vp/5oCo6CSY8XbHw+/eXPFwwl0w5Tazr2tiP/VrFJFu1TfRHDy5rTiIafykR9HyJiIHImUw/L/PzD6m1YXw/Knm6OxIYBjmpP7//oW50IjNZXZ7SB3auedxREH6CIVfEel2wzLMqQ7XFlSGuCbS2dQCLHKgEvrApR+Z8wRv+QZe+Tmc/QyM+Xmoa9a5fHXm7As7F5utvTsWm6PPwZy14ef/gH6TQltHEZFONDzTDMDrC6uo9wew29Ru2FsoAIt0hii3OTDunSvMeYL/+//Maa0mXRXqmh2Y7Ytg0T+geL25wta+CxU4YmHEz2DqHWZruIhIL5KTFEO0w0atz8/WkhoGp7Ww8qL0SArAIp3FEQW/eB4+vg0WPQef3GZOqXX8XT1vPtZAAObMgq8fbro9LtNcsjf7MHMRkL7j9ywwICLSy1itFoZlxLFiRzk/5VUqAPciCsAinclqg5/9yVzp6Mt7Yd6j5opI0//WvatEHYjaMnj7CnPeXTCXJh55+p6FLHpamBcROQBj+rpZsaOcRVtKOPXgThjgK2FBAViks1kscMzNZgh+byaseM2cI/fcF81lVcNZ4Rp4/QJzeV57lLkk8dhfhrpWIiIhc9SQVP79/Ta+WV8U6qpIJ1JvbpGuMm4G/PJVc3WyDbPhxdOhujjUtWrdqnfhuePN8OvOgV9/qvArIhHviCGpOO1WNhZVs3Rbads7SI+gACzSlYafDBe/Z86Pu3MJ/GuauVxwOKkrN/stv3kx+Kph4BS4Yi5kHRLqmomIhJw72sEZY7MA+Oc3Yfb+LR2mACzS1XImmK2p7hwo3gB/nwgf3ARbvgV/fejqFfDDkhfhr4fC90+b2464zlzIIjYldPUSEQkzvz5qIBYLfPhjHsvUCtwrWAzDMEJdiZ6goqICt9tNeXk5CQkJoa6O9EQVueb0aNvm79kWnQRDToD0kRCbBn4vOOMgNhVi080+wxU7zX99teCpAm8V+H0Q8Jnl/T5z1bRhpwQXXA0D1n5szvKQ/4O5LWUonPwgDD2hax67iEgPd/ObK/jvkh2MzUnk7auPwGbVgOBwFGxeUwAOkgKwdArDgM1fw/JXzVkWajuxJcFqh6HT4KBzYOiJZijem78e1rwH3/wFClaa21xumHo7TLi858xSISISAoUVdRz3l7lUeeq589SRXHb0oFBXSVqgANzJFICl0/nrYfsCsytE6WaoKTZXVPNWQ3WReaurgPgMs5XXEQOuOLOF2OY0A6vNAVYHlGyEvBV7jm1zQvbhEJMCNSVQswvKd4J393Kezngz9E6+xmxtFhGRNr2+cBu3v/0jLruVj64/WvMChyEF4E6mACxhr/An+OF1cyW6kk0tl4lJgQlXmLeY5O6tn4hID2cYBr/610K+Wb+L8f2TeOPKyeoKEWYUgDuZArD0GIYBRWshb7nZghyTvKdPcdpwc7EOERHpkJ1ltZz06NfqChGmgs1rWghDpLexWCB9hHkTEZFO1Tcxmt+fOpI73v6RP326luNGpDMoDLpCeOr9bNlVQ3ZSNLEuxbu26BkSERERaYdfHp7DRz/m8c36Xdz0xgr+e9Vk7Lb2zyybW1bLuoJKEqIdDE6Lwx0d/GDkijofK3eWs2RLKV+vL2LF9nK8/gBOu5WRfRIY1SeByYNTOGJwCqlxrnbXbW/e+gBbi6spqvSQGu8iJdZJcqwTi6Xndv9QF4ggqQuEiIiINNhZVsvJj31NZV09N54wjOtPGBrUfvX+AO+tyOW/S3bw3aZi9k5hGQkuxmYncsTgFGKcdlbsKOP7zSWUVHvJTIiib1I0UQ4bq3aWs2lXdbNjRzts1Pr8zbYnxzrJSoyi3m9QXuujxutneGY8o/okMDwznoGpsUQ7bHjqA0Q7bCTFOthYVM3X64qYt34XG4qq8AeaxsX0eBenHZzFb44dfMABuzOpD3AnUwAWERGRvb27bCc3/Gc5NquFt68+grE5ifstv3JnObe//QMrd1Y0bhuWEUdFbT35FXXtPn92UrQZmIekcNSQVPolx7BpVzVr8ytZsrWUeet3sbagst3HbUms00aGO4riKi/ltb7G7fEuO384bRTnHJYdFi3CCsCdTAFYRERE9mYYBte+towPf8gjI8HFw78YyzFDU5sEwUDAYF1hJc99vZl3lu0gYEBClJ3Ljh7E2Yf2JTspBjC7NKzLr+S7jcUs215GrdfPQdluxvdPIjspmoKKOnaW1lLpqWdknwTGZieSHOtss4413no2FZndF2xWC4kxDmxWC6tzK1hXUMnagiq2FVfjrQ/gctio8tRTXusjNdbJ0UPTmDI8jXH9EslMiGp8XHU+P/M37uKR2esaw/yZh2Rx/1kHhbz/sQJwJ1MAFhERkX2V1Xg55+nvWF9YBUCM00YfdxQuuw2b1cLmXdVUefYse3/62Cz+cNpI0uOjQlXlTuMPGDz79Sb+/Nla/AGDoelxPPjzgxnfPylkdVIA7mQKwCIiItKSijofj3y2jjcXb6fa27wPbpTDyhGDU5l5/FAOaaObRE+0cHMJ1766lMJKDwDnjM/mtlNGhKRvsAJwJ1MAFhERkf3x1gfYXlpDQUUd9X4Dnz9AdlIMg9NiOzRLRE9SXOXhoU9+4o3FOwCzm8fPx2czcWAyh+QkkenunhZvBeBOpgAsIiIisn9Ltpbyh3dXsjpvz0C/KcPSePHXE7rl/FoIQ0RERES61fj+Sbx/3VF8vqaAOWuLWL69jEP7ha5PcGsUgEVERESk09isFk4anclJozNDXZVW9e4OKSIiIiIi+1AAFhEREZGIogAsIiIiIhFFAVhEREREIooCsIiIiIhEFM0CEaSG6ZIrKiraKCkiIiIiodCQ09pa5kIBOEiVlZUA5OTkhLgmIiIiIrI/lZWVuN3uVu/XSnBBCgQC5ObmEh8fj8ViCXV1ul1FRQU5OTls375dK+GFIV2f8KbrE750bcKbrk94C8frYxgGlZWVZGVlYbW23tNXLcBBslqtZGdnh7oaIZeQkBA2L3JpTtcnvOn6hC9dm/Cm6xPewu367K/lt4EGwYmIiIhIRFEAFhEREZGIogAsQXG5XNx11124XK5QV0VaoOsT3nR9wpeuTXjT9QlvPfn6aBCciIiIiEQUtQCLiIiISERRABYRERGRiKIALCIiIiIRRQFYRERERCKKArCIiIiIRBQFYBERERGJKArAIiIiIhJRFIBFREREJKIoAIuIiIhIRFEAFhEREZGIogAsIiIiIhFFAVhEREREIooCsIiIiIhEFAVgEREREYkoCsAiIiIiElEUgEVEREQkoigAi4iIiEhEUQAWERERkYiiACwiIiIiEUUBWEREREQiigKwiIiIiEQUBWARERERiSgKwCIiIiISURSARURERCSiKACLiIiISERRABYRERGRiKIALCIiIiIRxR7qCvQUgUCA3Nxc4uPjsVgsoa6OiIiIiOzDMAwqKyvJysrCam29nVcBOEi5ubnk5OSEuhoiIiIi0obt27eTnZ3d6v0KwEGKj48HzCc0ISEhxLURERERkX1VVFSQk5PTmNtaowAcpIZuDwkJCQrAIiIiImGsre6qETEIrr6+njvvvJOBAwcSHR3NoEGD+L//+z8CgUCoqyYiIiIi3SwiWoAfeughnn76aV588UVGjx7N4sWLufTSS3G73Vx//fWhrl6LDMOg0ucnYBgkOO1YNfBOREREpFNERAD+7rvvOOOMMzj11FMBGDBgAK+99hqLFy8Occ1aVh8I8EVuKbm1HgDcDjsn9U0h1mELcc1EREREer6I6AJx1FFH8cUXX7Bu3ToAVqxYwbx58/jZz34W4pq1bGlxJXm7wy9Aha+ebwpKQ1gjERERkd4jIlqAb7vtNsrLyxkxYgQ2mw2/38/999/P+eef3+o+Ho8Hj2evEFpR0R1VBaCg1oux188GUFjn67bzi4iIiPRmEdEC/J///IdXXnmFV199laVLl/Liiy/y5z//mRdffLHVfWbNmoXb7W68deccwDF2K/v2+I22RcSlEhEREelyFsMwjLaL9Ww5OTncfvvtXHPNNY3b7rvvPl555RV++umnFvdpqQU4JyeH8vLyLp8GrcTj48Ptu/DvdWmO65NMv7ioLj2viIiISE9WUVGB2+1uM69FRBeImpqaZsvh2Wy2/U6D5nK5cLlcXV21FiW7HJzZP40NFbUEDIN+cVGkRTlDUhcRERGR3iYiAvDpp5/O/fffT79+/Rg9ejTLli3jkUce4de//nWoq9aqeIedcSn7X8VERERERNovIrpAVFZW8oc//IF33nmHwsJCsrKyOP/88/njH/+I0xlcy2qwTeoiIiIiEhrB5rWICMCdQQFYREREJLwFm9c0tYCIiIiIRBQFYBERERGJKArAIiIiIhJRFIBFREREJKIoAIuIiIhIRFEAFhEREZGIogAsIiIiIhFFAVhEREREIooCsIiIiIhEFAVgEREREYko9lBXQJrz+z0UF3+L11tMbOwAEhPHAxYqKlZRWrqY+vpqwMBqtRMV1YeUlGNwuZLaPK5hGJSWLqO8fDl+fw1gw2JxAgEMw7NvacCy+192/7/ZEfcqs/e/LZ69nWUbtF7WYrHicCSSlDSR+PjBrRyrdYYRoKRkMRUVK3c/Hy3X12p1Eh3dl5SUo3E63e0+j4iIiIQXi2EYRtvFJNi1pQ+U11vMtm0vNtlmsURhtUbh95e1ul96+skkJIxq9X7D8LNp03MYxr5Br3eIiRlIVtZZQZcPBHxs2vQssG/w37/MzDOIi2t/2BYREZGuF2xeUxeIMLNjx3+bbTOMuv2GX4DCwk8wDH+r9xcVze214RegpmYzNTVbgy5fWPgF7Q2/APn576PPjCIiIj2bAnCYCQSqO7xvfX1Vq/d5PAUdPm5PUVeXG3RZjye/g2cJEAjUdXBfERERCQcKwGHGYnF1eF+bLabV+xyOtvsI93ROZ2rQZQ/k+bBaO36NREREJPQUgMNMnz7TW9hqBZz73S8paTJWq6PV+9PSptKbL7fDkUJs7JCgy6enn0jrg/Bal5o6FYul9z6PIiIikUCD4ILUXYPgAOrqSigq+oz6+gqiorJITz8Rq9VOYeGXVFb+BPh2l7RgtyeQlnYcsbED2zyu3++lsHA21dUbgIb+wlYg0DUPpBtYrVG43YeQnDwZi6V9gdbv95Cf/ym1tZvY/3NgwW53k55+IjExOQdUXxEREek6weY1BeAgdWcAFhEREZH20ywQIiIiIiItUAAWERERkYiiACwiIiIiEUUBWEREREQiigKwiIiIiEQUBWARERERiSgKwCIiIiISURSARURERCSiKACLiIiISERRABYRERGRiKIALCIiIiIRJWIC8M6dO5kxYwYpKSnExMRwyCGHsGTJklBXS0RERES6mT3UFegOpaWlHHnkkRx77LF8/PHHpKens3HjRhITE0NdNREREYlANTU1bN68mdraWgDq6+sb77NarSQkJOB0OikpKcFisZCZmUlWVhaGYbB582Z27dqFYRjY7XYyMjLIzs7GYrF0ah1zc3PZuXMnfr8fu91OVlYWffr06fTzhILFMAwj1JXoarfffjvffvst33zzTYePUVFRgdvtpry8nISEhE6snYiIiESS0tJS1q5d2+79YmJiqK2tpaXoFh0dzcEHH9xp4XTVqlVUVlY22x4XF8eYMWM65RxdIdi8FhFdIN577z0OO+wwzjnnHNLT0xk3bhzPPffcfvfxeDxUVFQ0uYmIiIgcqPXr13dov5qamhbDL0BtbS0lJSUHUq1GlZWVLYZfgKqqql6RiSIiAG/atImnnnqKoUOH8umnn3LVVVcxc+ZMXnrppVb3mTVrFm63u/GWk5PTjTUWERGR3ioQCHTJcWtqarrlOJ11nlCKiC4QTqeTww47jPnz5zdumzlzJosWLeK7775rcR+Px4PH42n8uaKigpycHHWBEBERkQOycOHCLgnBI0aM6JTxTVVVVaxcubLV+8eMGUNcXNwBn6crqAvEXvr06cOoUaOabBs5ciTbtm1rdR+Xy0VCQkKTm4iIiMiB2jeTBCspKQmXy9XifQkJCZ02uD8uLo6UlJQW70tJSQnb8NseETELxJFHHtmss/m6devo379/iGokIiIikSouLo7x48ezdetWamtrsdls1NbWNs4E4XQ6SUlJwel0UlhYiNVqJSsri+TkZAzDoKCggNzcXPx+Py6Xi759+7YaWDtq6NChpKamsmPHDjweD06nk5ycHJKSkjr1PKESEQH4xhtv5IgjjuCBBx7g3HPPZeHChTz77LM8++yzoa6aiIiIRCCHw8GQIUPaLJeZmdnk54Yp0fbd3hWSkpJ6TeDdV0R0gTj88MN55513eO211xgzZgz33nsvjz32GBdeeGGoqyYiIiIi3SwiBsF1Bs0DLCIiIhLeNAhORERERKQFCsAiIiIiElEUgEVEREQkoigAi4iIiEhEUQAWERERkYiiACwiIiIiEUUBWEREREQiigKwiIiIiEQUBWARERERiSg9IgBv2LCBTz/9lNraWgC0eJ2IiIiIdJQ91BXYn+LiYs477zy+/PJLLBYL69evZ9CgQVx22WUkJibyl7/8JdRV7DJ+Tz3Fr6zGu768yXZrgoPkX47ANcBN6f82ULMoHwK773RYiTuqL+5p/bFYLPs9vmEYVM7ZTt1PJVijHbhPHYAjLbaLHk3X8nvqKf73arzrytsuvDe7heiD00j+xTAs1pafL8NvUPrOejzrS7G4bLinDyZ6SFIn1FpERERCJaxbgG+88Ubsdjvbtm0jJiamcft5553HJ598EsKadS3D5yfvvgXNwi9AoMLHrmd/JPeh76n5fq/wC+ALUPXVdor++WOb59j1wioqPt2Kd2sldT+VUPDIUrw7qzrxUXQPw+cn7/4F7Q+/APUGtUsLyf/LYoxA828VjIBB/l8WU7O4AH+5l/rCWor/sZLq5YWdUHMREREJlbAOwJ999hkPPfQQ2dnZTbYPHTqUrVu3hqhWXa/y253g2383D6Pc1+p93g3l1BfXtnq/r6gGz9rSfQ4IpW+vb1c9w0HltzvBe2BdYvzFdXg2lDXbXre2BH9JXbPtZe9sOKDziYiISGiFdQCurq5u0vLbYNeuXbhcrhDUqHv4i5uHrnYfo6r1gByobPm+QJX3gM/b3TrjuQKobyHotrQNzFZnERER6bnCOgAfc8wxvPTSS40/WywWAoEAf/rTnzj22GNDWLOu5RqefMDHcKRFt3qfPaP5hwoAZ7+EAz5vd+uM5wrAObD5Y3cNdrdY1pYY1SnnFBERkdAI60Fwf/rTn5g6dSqLFy/G6/Vy6623smrVKkpKSvj2229DXb0uEzMmlepRSXhWl7ZcwG4h9ogsqr/e2eLdib8YhjXG0erxbbEOEn8xlLL/7unyYEuOIumcYQdU71Bo87kKQvyx2Tgzmg8AdGbGEXdMX6r2fp4dVtKuOKjD5xIREZHQsxhhPqdYfn4+Tz31FEuWLCEQCHDooYdyzTXX0KdPn26tR0VFBW63m/LychISuqel1JtfTeW3O/AW1gAGthgnsQelEXNIOharhfryOiq+3YlnewVWqxVXfzfxR2Zhi3UGdXx/tRfPhnJsCU6cAxLanDkinHkLqqmct+e5MrBgAQzAYjFnvbBYLI3/Wq1WnFlxxB+VhT2x9dZyAF9pHbU/FGJLiiJmdBoWW899nkRERHqzYPNa2AfgcBGKACwiIiIiwQs2r4VdF4gffvgh6LIHH3xwF9ZERERERHqjsAvAhxxySONX1ftjsVjw+zUaX0RERETaJ+wC8ObNm0NdBRERERHpxcIuAPfv3z/UVRARERGRXizsAvC+1q5dy9/+9jfWrFmDxWJhxIgRXHfddQwfPjzUVRMRERGRHiisF8L473//y5gxY1iyZAljx47l4IMPZunSpYwZM4Y333wz1NUTERERkR4orKdBGzRoEDNmzOD//u//mmy/6667ePnll9m0aVO31UXToImIiIiEt2DzWli3AOfn5/OrX/2q2fYZM2aQn58fghqJiIiISE8X1gF46tSpfPPNN822z5s3j6OPPjoENRIRERGRni7sBsG99957jf+fPn06t912G0uWLGHSpEkALFiwgDfffJN77rknVFUUERERkR4s7PoAW63BNUp390IY6gMsIiIiEt56bB/gQCAQ1O1Awu+sWbOwWCzccMMNnVdxEREREekRwq4LRFdbtGgRzz77LAcffHCoqyIhYhgG89/8Nz99+zVWm43Dp/+cMVNPCHW1eoWK4iI+fuIRKooKSczow89m/pZYd1Kr5T011bzxf3dQtGULYJCcncN5f3yQaH3LIiJdyFtby5v33Un+hrWN22KTkvnFnfeRmt2vU89V7/Px6VOPkbf+J1yx8Rx66hl89+a/qSkrI8btZvpNvyd94KBOPWd3WPzBOyx87y3qKiqw2mykDxrM2bffQ1RsbKirFpSw6wKxr+rqaubOncu2bdvwer1N7ps5c2a7jlVVVcWhhx7Kk08+yX333cchhxzCY489FtS+6gLRe3z0xJ9Z882cJtumXnQZ4087MxTV6TWqy8t47ppL8ft8jdscUVFc8eQLRMXGNStf7/Xy98svoL6ursl2m8PJb557BWd0TJfXWUQij7/ex5OXz8BbU93i/b9+/FmSMrM65VyBgJ8XbvoNpXk791vuV396grR+AzrlnN1h7sv/ZPEH7zTb7oyO4apnX8bhdIWgVqYe2wVib8uWLWPIkCGcf/75XHvttdx3333ccMMN/O53vws6uO7tmmuu4dRTT+WEE9pu7fN4PFRUVDS5Sc/n83qahV+A+f99tdvr0tsseu+tJuEXwFdXx7JP3m+x/Nrvvm4WfgH8Pi8/fPFpl9RRRGTjkkWthl+Ab157sdPOlbtubZvhF8xA2VMYhsGSj/7X4n3e2hp++vbrbq5Rx4R1AL7xxhs5/fTTKSkpITo6mgULFrB161bGjx/Pn//853Yd6/XXX2fp0qXMmjUrqPKzZs3C7XY33nJycjryECTM+FoIXAD1Pm+L2yV4teXlLW6vaWV7dVnL2/e3j4jIgaotL9vv/XWd2OBVVxXcseqqKjvtnF3NMAIYgUCr99eUl3ZjbTourAPw8uXL+e1vf4vNZsNms+HxeMjJyeHhhx/md7/7XdDH2b59O9dffz2vvPIKUVFRQe1zxx13UF5e3njbvn17Rx+GhJHo+ASi4pt/JZI+oOf1vwo3wyYd1eL2oZOObHH7oEMPa/VYQydM6pQ6iYjsq9/B4/Z7f2vvZR2RNXQEFoulzXJDJxzRaefsalarDXd6Zqv3Dxo/oRtr03FhHYAdDkfjCycjI4Nt27YB4Ha7G/8fjCVLllBYWMj48eOx2+3Y7Xbmzp3LX//6V+x2e4szSrhcLhISEprcpOezWCycf89DTfqXutMzOPsOzSt9oAYfNoHDTju7ybbJvziffqMOarF8ak5/pvzqsmbbJ//iAvoMHdEldRQRScrswwmX/abF+4ZMmMzYaT/rtHPFuBM57YbbsOw1xWvUPnliwNhDmXDmOZ12zu5w3j0PtdiYdMyMS0nLGdD9FeqAsB4EN23aNC655BIuuOACrrrqKpYtW8bMmTN5+eWXKS0t5fvvvw/qOJWVlWzdurXJtksvvZQRI0Zw2223MWbMmDaPoUFwvYthGFTuKsLmcBCb2PosBdJ+9V4P5UWFuNMzsTscbZb319eTt24tAQv0HTocmz3iJqcRkRDw++sp2LCO8l2FRMUmkDViJK6o6C45V8Dvp6wgj7ikZJzRMXhqa9i1fSupOf1x9dABv4ZhUFlSTG1FGUYgQFr/QWHx/h1sXgvrALx48WIqKys59thjKSoq4uKLL2bevHkMGTKE559/nrFjx3b42FOnTtUsECIiIiK9SLB5LfRRfT8OO2xPH8G0tDQ++uijENZGRERERHqDsA7AXWnOnDmhroKIiIiIhEDYBeBx48YFNWISYOnSpV1cGxERERHpbcIuAJ955pmhroKIiIiI9GJhPQgunGgQnIiIiEh46xVLIYuIiIiIdLaw6wKRlJQUdB/gkpKSLq6NiIiIiPQ2YReAg52XV0RERESkI8IuAF988cWhroKIiIiI9GJh3Qd46tSpvPTSS9TW1oa6KiIiIiLSS4R1AB4/fjy33normZmZXH755SxYsCDUVRIRERGRHi6sA/Bf/vIXdu7cyUsvvURRURHHHHMMo0aN4s9//jMFBQWhrp6IiIiI9EA9ah7goqIinnnmGe6//378fj8/+9nPmDlzJscdd1yXn1vzAEu7GAZ8+Tls2NDy/U4neL3BHSspGc48y9ynrXN+PRd+WtP8vkPGwcRJwZ2vJX4/fPgB5OW2Xmb4cJhyLFgskJ8PH7xn7teSpCQ44yxwuYI7v2HA3Dmw9qd2V10iXFwcnPVziIlpfl+4vK5SUuCMM8HhNOv06SewdUvTMiNHwtFTzN+vujp45y2oqAhFbbuP1QrHHgdDhpo/L10CixY2Lzd4CBx/gvnc9AZrVpvv5cGIT4DKDr4OrFbzeRs0GCrK4e23wONpuWzfvnDKqWCzdexc3ajXzQO8cOFC/vjHP/LnP/+Z9PR07rjjDtLT0zn99NO5+eabQ109kaY+n916+IXgwy9AaQm8/ioEAvsv11r4BVi+rOU/HMF65639h1+AtWvhqy+hrAz+907r4RegtDS4x9Tgqy9DH1KkZ6qqgtf+DfX1ze+bEyavq+Ji+M/rZvj9+KPm4RdgzRr4eo75e/Xvl3t/+AXz/eGLz2HbVvjhh9bfwzZugNmfdW/dusqGDcGHX+h4+AXz+Z39GWzZDK+92nr4Bdi503xf70XCOgAXFhbyl7/8hTFjxnD00UdTVFTE66+/zpYtW7jnnnt49tln+d///sfTTz8d6qqK7GEYsGlj5x6zthZKivdfprXw2+DHHzp2bo/H/AMdjA3rYdmS4MrW1QV/3PXrgisn0pL6evMP+L7WhdHrqroaSkpg+7bWy6xdCwX5LYf53mzRIrP1d382bzLfe3u6xQfQUNFR334bXLmiov2H5B4m7KZB21t2djaDBw/m17/+NZdccglpaWnNykyYMIHDDz88BLUT6Wb1+2lRDUawra372l9L7r4Mo31/nP0R9odcQqfeF+oatK2t3wfDaN/vY29RXw9GEO9fhtHzu0GE4voG2nHO9pQNc2HdAvz555+zePFibrnlFtLS0ti6dSuPPfYYn376aWOZhIQEvvrqqxDWUmQfFovZx7UzWa1mP8H9SUvf//05OR07d3R08H11U1NhxKjgylqtkJIaXNlgy4m0Jqtv822pYfS6stnM13n8fsaYpGeYt0gzfAQMHLT/MolJ5ntKTzdsePefc2SQ79lRURAV3bV16UZh/Wq57777ePnllwEoKytjwoQJ/OUvf+HMM8/kqaeeCnHtRPbjjLMgNrZzjmW1moN4HI79lzt9OsTHt3xfSiqcMK1j57dY4Bfngr2NL4zi42H6mWbQPnzC/starXDW2W0/pgZnnGkOZhJpL4sFTptufpDb1/Qzw+N1ZbPB2b/Y/e/PzaCxr4QEOO1088PoGWd1fx1DZchQGDsWjpkCmX1aLhMbaw4U7g0OOxwGDOy+840YYZ7z+BP3X87pNP8O9PQW9r2E9SwQqampzJ07l9GjR/OPf/yDv/3tbyxbtoy33nqLP/7xj6xZ00afx06kWSBEREREwluvmAWipqaG+N0tWp999hlnn302VquVSZMmsXXr1hDXTkRERER6orAOwEOGDOHdd99l+/btfPrpp0ybZn6FW1hYqFZYEREREemQsA7Af/zjH7n55psZMGAAEydOZPLkyYDZGjxu3LgQ105EREREeqKw7gMMkJ+fT15eHmPHjsW6e4TnwoULSUhIYMSIEd1WD/UBFhEREQlvwea1sJ4HGCAzM5PMzMwm2yZMaGOEuYiIiIhIK8K6C4SIiIiISGdTABYRERGRiKIALCIiIiIRRQFYRERERCKKArCIiIiIRBQFYBERERGJKArAIiIiIhJRIiIAz5o1i8MPP5z4+HjS09M588wzWbt2bairJSIiIiIhEPYLYXSGuXPncs0113D44YdTX1/P73//e6ZNm8bq1auJjY0NdfUOWK2/mm+KPyevbjvegBeDADaLjcExIzkq5XjsVkeoqygdYBgGC0rmsKpyGQECuO1JnJZ5HrH2uFBXrUW+gJf5JV+xo3YzLmsUhyUdxYCYIc3KBYwAS8rms756NVZsHJwwnpHxY7FYLCGotYhI5/MGPHxb/CU767YSZYtmQuLR9IsZFOpqdZmV5UuZX/oVBgEsWJiQeAyHJIb3omVhvxRyVygqKiI9PZ25c+dyzDHHBLVPuC6FHDACvJ37EsW+ohbvHxwzghPST+/mWklnWFL2HYvL5jXZFmWN4aKcq7Fawu/Lm08K3mZb7SYM9rylnJ75S7KicpqUW1AylxUVC5tsm5JyMiPiD+qWeoqIdCXDMPio4E121m1rfD+0YGF65vlkRvUNce0637aaTXxc+Faz7SekTWdw7PBur0+weS38/op2g/LycgCSk5NbLePxeKioqGhyC0elvl2thl+AjTU/4Tfqu7FG0lnWVK5otq0uUEOpb1cIarN/noCHrbUbm4RfCxbWV61uVvanqh+C2iYi0hPVBWrYUbe1yfshwIbqNSGqUdf6oXxRu7aHi4gLwIZhcNNNN3HUUUcxZsyYVsvNmjULt9vdeMvJyWm1rEhXiKwOAZH1aEVEJLQiLgBfe+21/PDDD7z22mv7LXfHHXdQXl7eeNu+fXs31bB9khyppDjSW71/cMwIbJaI6Ord64yMP6TZtmhrDEmO1O6vTBtcVhf9o4dg2SvIGhgMixvdrOzI+LHNto2IU/cHEekdoqwxZEcNbPJ+CDA0blSIatS1xroPb3H7IW71AQ4b1113He+++y5ff/01AwcObNe+4doHGKDWX8O3xZ+TW7cdb8BDAAObxcaQ2JEcmXw8dqsCcE9kGAbfl85lZcUyAvhJdCRzasa5YT0IbkHJHLbXbTEHwSUeSf+Ywc3KBYwAS8u+Y331amwWG2MSxjOqhVAsItJTeQNeviv5kh21W4m2RXN40tHkRLcvd/QkqyqW8W3JlxgEsGJlQtIxrQbjrhZsXouIAGwYBtdddx3vvPMOc+bMYejQoe0+RjgHYBEREREJPq9FRNPgNddcw6uvvsr//vc/4uPjyc/PB8DtdhMdHR3i2omIiIhId4qIFuDW5hd9/vnnueSSS4I6hlqARURERMKbWoD3EgEZX0RERESCFHGzQIiIiIhIZFMAFhEREZGIogAsIiIiIhFFAVhEREREIooCsIiIiIhEFAVgEREREYkoCsAiIiIiElEUgEVEREQkoigAi4iIiEhEiYiV4CJKfT3YbGCxgGGA37/nPsMwtzfc3xsEAubNajVv7dWwSmBHno+Gc4N5br/fPE7DsRrqZbM13c/vN+9r2G4YzcvsXb+GOvr9TR9jwz4Nx2u45vue0+/fc5yGMvv7t+G8Ld3X8PrZV8PrbO/7Guq073MbCJjl7fb9P+8Nz+/edWjp+QxGw3PXW173Epy9f0cbtPTa7ujrat9zQfvfhxpe4zbbnt9Tq3XP+8feZfb9PbbZOva+1xM0/P1q6f3Jvld02d/7377vIdD07+O+7wd7n2/v10N9/Z46tbZvw7kb/t/We2Z3aum12drzG8zf0n3/9vXQ16ACcG/x/vWw5IW9NliBQCuFgf5HwsXvgzXEv5gdVVMCT0yEmsI921xu+M134O7b9v7eanj/Blj9LticMPkamHJ7cL/IW76DF37Gfp/fJixwxhNQ74EPb2q9zKmPwOG/Nn/01cJL02H7wiDP0YJBx8OmLzq+f2ssNpjxNgyeCoufhw9u2Os+K5z6GHz9EFTsNLf1PwIuehdKt8CTR4Hh3VM+eRBc9S04Y/Zsqy6GJyZA7a7W63Dqo3ueq/1Z8Tq8czWN16rv4fDrj8HmCOaRSk9VvsN8f/BVtW+/Ux+Bw/9f+/ap3gVPHQlV+ebP9mj4f59Cn7H73y/vR/jHceD3tl7G6jBv9TWtl3HEmr9DKQPbV+9wZRjw2gWw7qP9lxt0HGz6svX7rQ4I+Fq5zwZYYMBRcPZz5t/Or+7fp5AFBk2FTV8FX/fWWGzme+CgYw78WO1Rug2eORrqysyfXQlw+Vfw8a2wcT9/G2LT4ZqFEJPUdHv5zt2/V5VNt/fQ16DFMBqal2R/KioqcLvdlJeXk5CQEOrqNLXoX/Dhje3f75AZcObfO78+3eGxsVC2pfn26GS4dVPbLX1vXwk/vgHGXiH25Adh0tX736+2FB4a0N7aBu/Kb6DPwfDyWbBxP2/uIWeBX/3PDOnBGHYKbPwK/HXN78ueAJfN3vPzI2OgYnvbx2x4rlpTtA7+fnjz7aPOgHNfavv40jMZhvk72vBHv72u+Bqy2give3t0DJTv83q1OeG2rU0/2O3NVwsPZINR37E67ssZB7dv67kNGnv7/B6Y90j3nMtqg8RBULK+G05mgVs2QmxKN5wLs4X24YHNfw8sNjD8Le7SRNJAuH75np8NwzxebWnL5cPoNRhsXuuZ7dbS1LJ/d2y/nz7o3Hp0l3pvy+EXoLbEbJFpy5r3moZfgNX/a3u/A2mRDcYP/zH/3TKva89zwAz4rh0fnja1En4Bdi7Z839fXXDhF8zW3f1Z9XbL29fPbnm79A5VBR0Pv7DndzAYvtrm4RfMVt2Cla3vV7Cq88IvgLcKyrZ23vFC6cc3u+9cAX83hV8AA7Z8003nAirzWv49CCb8ApRuNv/WNqguaj38wu7X4LZ2VTHUFIB7A0d0x/brqV8Dt/UJ0+5s+xh21z4bLME9jx19roPl2N1iZO0BvZOcccGXteznmln2ehtqT+uBM7Zj9/eE51Y6zhbE7//+tPW62tv+XkvN3mOCvK+j7FGdf8xQ6IrnJlw42vHaOlCd8Tzu/X4czO9VD3sNKgD3Bsff2bH9ptzWufXoLlYbDD255fv6HgZR7raPceT1e/2wu7vEpGva3q/fZHDGt12umSAGX1msMOFy8/+HX96Bc3QjZyyccHcrd7bwWCdfA+5+LRc/9OI9/7c5YPCJbZ9/7+eqNeNmtBxQjm6tH7b0CjHJ0Gdcx/YN5nW1t9Zer3GZkHFQ6/uljzbLdJbUEZCQ1XnHC6Xj/tCNJ7PAiCC7cR0oZxwMPLp7zgUQmwqZLXTliQ3ydTf8Z00DcHQiZB3aevm0kZDQp11VDDUF4N6g3yQ4/829Pl3aIHVk6+Wtdpj2QPve6MPN+a/B6J833TbkBPj1p8Htf+QNcPrj5iCHYSfBjP/C0BPa3s/mgBt/hOQhwdc1Jg2uWwq/+R6iElsuE5tmDjqISzd/PvEec1BeVDKthmd7DDhaaYWNToaznuuaFoekAXD9j5DUD65dbJ6rQUJfuP4HGPMLiE4yB1Mc90c47vdw7SLoM36vA1lhwpVw6p+bHv/CN2DEGa2fPzql6XPVarkkuG4JuHPMFmh7NBx3JxzVgf7y0rNcNhsGHtu+faJTzN/Rtl5X+7rwDRh9ttlCZrVD1njzdbe/AbVWq1km82DM32+L+XsUk2b+TjtizAFL6WOg/1Hs9091/yPhqm78ar2rjT4TzniK/Y7Rt8fAmU9DTGrL97vc0HdCKztbzbA24Gjz/eCc5+Gyr5p/oxWbDmc+A7ZOaNVMGmS+Zzq6uYX08i/MD2gNgykHHgM3/gCnPQq09m2bxXz/Pq+FrpX/b7Y5+HBf/Y+EK7/uzJp3Cw2CC1JYD4ITEREREQ2CExERERFpiQKwiIiIiEQUBWARERERiSgKwCIiIiISURSARURERCSiKACLiIiISERRABYRERGRiKIALCIiIiIRRQFYRERERCKKArCIiIiIRBQFYBERERGJKArAIiIiIhJR7KGuQHd68skn+dOf/kReXh6jR4/mscce4+ijjw51tTqFYRiU1/rAMNhZVsvW4mpinHYmDUolymkLdfW6lK/ezw87ykmNd9IvORaLxRLUfrXeejYXVzMwJZZo5/5/Fao9PuZvLGJXhRfDMLDarIzJcjMqy015rY+iKg+DUmOxWS1sLa7BZbeS6Y4Kui4tCQQM8ipqKK7yMjAljrgoO7llddT46gkEAqzNrcAXMBjXP4mBqXEHdK4DZRgGP+VXsHpnOfFRdlLjXGCxcFBfNw5789dfrbeeH3eWsaO4moABB/dNxGa3sHRrKfWBAIYBOcmxTByUgrOF/UV6C8MwWJNbweq8MqLtdmKjbJRW+5g0KIU+STF46v3sLKuhzhtgaHpci79PYjIMg+2l1SzaVEy93yA7OZYJA5Mbn7PKWi/frt9FldeL027FUw8HZbkZ3ieBSk89RgASou1sLKpk2ZZS6o0A0U4bkwalkumOafPc+RV11Pn8DEjZ83cor6yGBZuK8dQHyE6MZlellxqfl5goB0PT4qjyBEiPc7BxVw2HZCeSmhDV5c9TRzS8x6/aUU5WUjSHD0jGarWSW1ZDSbUXK7CtpIb+KdFsKqqhyuPDChhYyHRHMXlwWthlkYgJwP/5z3+44YYbePLJJznyyCN55plnOOWUU1i9ejX9+vULdfUOSFmNl6tfWcp3m4pbvP+aqYO55eQR3Vyr7vH6oq3c/tbKxp8TYxx8cdMUUuJc+93vvg9W8495mxt/vvbYIdx80vAWy97x1gpeW7SjzbpYAafdSl19AIDspGg+vO4o3DHOIB5JUz/uKOeC5xZQ6alv3Oa0WfD6jRbLxzptfPnbqWS4u//Nc1NRFdMemUt9y1XjT784mHMOy2n8+cGPV/P03M0tF27B7342giuOGXyg1RQJOz/lVfCzx78h0Mr9CS4blR4/Db9aFmDW2Qfxywk9+29WVyir9nLMn76ioq6+2X0P/fwg5qwt5OOVBS3uawFaeftqlJMUzeybphDlaB7iymq8nP63eWwvrQUg1mXj1csmctUrS8gr97TrcQzLiOPDmUfjsIXPF/QbCqqY9thcAvs8SXYr1Lf24m1BuGURi2EYbV33XmHixIkceuihPPXUU43bRo4cyZlnnsmsWbPa3L+iogK32015eTkJCQldWdV2u/LlxcxeVdDqmyjAf6+ezGH9k7utTt1hZ1ktRz74ZbPtg1Jj+fLmqa3uN3t1Ppe/tKTZ9lcvm8gRQ1KDKhusQ3LcvHvNUe3ap9brZ9IDn1Pewhv5/mQnRTPvtuPatU9nOOjuT6is8++3zHd3HEcfdzRfryviV/9a2O5zfHbDMQzLjO9oFUXCTiBgMPqPH1Pb2ifH/Zh7y1T6p8R2Qa16rmmPzGFdYXWXnuP4Een885LDm20/8+/zWL69vMk2mwVaaa9o0zmHZfOnX4zt2M6dzDAMxtz1CdXediTd/eiOLBJsXgufjxhdyOv1smTJEqZNm9Zk+7Rp05g/f36L+3g8HioqKprcwtW3G4r3G34BPlvV8iffnuz7Vlq8txTv/03wkx/zW96+svn2j1spG6zVuZXt3mdjUVW7wy/AjtJauvvzbGWdr83wC7BwcwkAH/+Y16HzfLW2sEP7iYSrXVWeDoVfgG837Ork2vR8G7o4/AIs3FLS4vbVuc3zQUfDL8DctUUd37mTldX4Oi38QnhlkYgIwLt27cLv95ORkdFke0ZGBvn5LQecWbNm4Xa7G285OTktlgsHCVFt92RJa6NLQE+UEtvyY7Jb9/+yTo5ruUtCanzz47VWNlguR/t/xdzRjg6dy2a1dHs/4Ja+DmxJw7VK6eDzmXqA10Ek3MS6Ot4DMbUXvp8fKLut69/7Ylrpw+oK8n0wWPHR4dM7NbqT++2GUxaJiADcYN9wYBhGq4HhjjvuoLy8vPG2ffv27qhih9zaRp+aKLuVCyb2vj5jRw5JIS2+eTC69rgh+93v6imDibI3fenHOm1ccuSAZmV/M2XwAf2S/PbEYe3eJyc5hrPGZbV7vyuPGdTufQ6Uw2bl7EP2X9eMBBeTB6cAcNnRg2jv+2m8y86pB7f/+RAJZ7EuO9NGpbV7v8yEKI4dkd4FNerZbp7W8hgOgKQgAmUw8fnu00e3cu7m7/Pj+7mDOGLL7p0+psP7drYoh43TDsrslGO5wiyLREQfYK/XS0xMDG+++SZnnXVW4/brr7+e5cuXM3fu3DaPEc59gAG+XlfEBz/ksnhzCVtLavAbYLHA8Ix4Xr98EomxvbMFrc7n54qXFrN0Wxkuu5XrTxjKryYPaHO/gopabvrPCraX1jAgJZZHzzuk1YFz+RW1nPf0d2wtqW2y3W61MGVYGgWVdVTV1TNpUDLpCVF8sCIPu83C1VMHc9a47A49Ln/A4IVvN/Gvb7dSWeejf0oMxw5P5/0VuRRW1FHjCzQO2nDZrdxy0nAuO7r7A3CDhz/5iWfnbmwcCGfBbP2eNDCFpy8a36SluKjSw+UvLmL5jqZ95vYdiGIBxuYk8sr/m0BcVMdaxUXCmWEY3PvBKl74dmuzbmyxTht3Tx/N4i0lzF5TgGHA5EEp/OXcsW3OWhOpXvt+C3e/twrP7l5ZFgtMGpjC85ceTn55HRc8+x25FU0HpTlsFk47uA/RDhsGZt/st5fuwLfXBYl32Xnsl4dw/Mim3yLv7d1lO3lqzgZ8foPph2Rx/fFD+XR1Pje9vowaX8sxy4LZVziA2UCXGO3g7xeMY9Lg1BbLh4phGMz6eA3//GYzfgOsFjh8QDITBiTx5pIdFFd5mjxf+7IAwzO7L4sEm9ciIgCDOQhu/PjxPPnkk43bRo0axRlnnNHjB8GJiIiISPB5LWI+Rt50001cdNFFHHbYYUyePJlnn32Wbdu2cdVVV4W6aiIiIiLSjSImAJ933nkUFxfzf//3f+Tl5TFmzBg++ugj+vfvH+qqiYiIiEg3ipguEAdKXSBEREREwpu6QHSyhs8J4TwfsIiIiEgka8hpbbXvKgAHqbLSXNAgnOcDFhEREREzt7ndrU9Hpy4QQQoEAuTm5hIfH9/tiw2Eg4qKCnJycti+fbu6gIQhXZ/wpusTvnRtwpuuT3gLx+tjGAaVlZVkZWVh3c/CWGoBDpLVaiU7u2NzuvYmCQkJYfMil+Z0fcKbrk/40rUJb7o+4S3crs/+Wn4bRNRKcCIiIiIiCsAiIiIiElEUgCUoLpeLu+66C5er5eWCJbR0fcKbrk/40rUJb7o+4a0nXx8NghMRERGRiKIWYBERERGJKArAIiIiIhJRFIBFREREJKIoAIuIiIhIRFEAjmBff/01p59+OllZWVgsFt59990m91dVVXHttdeSnZ1NdHQ0I0eO5KmnnmpSxuPxcN1115GamkpsbCzTp09nx44d3fgoeq9Zs2Zx+OGHEx8fT3p6OmeeeSZr165tUsYwDO6++26ysrKIjo5m6tSprFq1qkkZXaPO19a18fl83HbbbRx00EHExsaSlZXFr371K3Jzc5scR9emawTzu7O3K6+8EovFwmOPPdZku65P1wj2+qxZs4bp06fjdruJj49n0qRJbNu2rfF+XZ+uEcz16Q35QAE4glVXVzN27FieeOKJFu+/8cYb+eSTT3jllVdYs2YNN954I9dddx3/+9//GsvccMMNvPPOO7z++uvMmzePqqoqTjvtNPx+f3c9jF5r7ty5XHPNNSxYsIDZs2dTX1/PtGnTqK6ubizz8MMP88gjj/DEE0+waNEiMjMzOfHEE6msrGwso2vU+dq6NjU1NSxdupQ//OEPLF26lLfffpt169Yxffr0JsfRtekawfzuNHj33Xf5/vvvycrKanafrk/XCOb6bNy4kaOOOooRI0YwZ84cVqxYwR/+8AeioqIay+j6dI1grk+vyAeGiGEYgPHOO+802TZ69Gjj//7v/5psO/TQQ40777zTMAzDKCsrMxwOh/H666833r9z507DarUan3zySZfXOdIUFhYagDF37lzDMAwjEAgYmZmZxoMPPthYpq6uznC73cbTTz9tGIauUXfZ99q0ZOHChQZgbN261TAMXZvu1Nr12bFjh9G3b19j5cqVRv/+/Y1HH3208T5dn+7T0vU577zzjBkzZrS6j65P92np+vSGfKAWYGnVUUcdxXvvvcfOnTsxDIOvvvqKdevWcdJJJwGwZMkSfD4f06ZNa9wnKyuLMWPGMH/+/FBVu9cqLy8HIDk5GYDNmzeTn5/f5Pl3uVxMmTKl8fnXNeoe+16b1spYLBYSExMBXZvu1NL1CQQCXHTRRdxyyy2MHj262T66Pt1n3+sTCAT48MMPGTZsGCeddBLp6elMnDixSTc9XZ/u09LvT2/IBwrA0qq//vWvjBo1iuzsbJxOJyeffDJPPvkkRx11FAD5+fk4nU6SkpKa7JeRkUF+fn4oqtxrGYbBTTfdxFFHHcWYMWMAGp/jjIyMJmX3fv51jbpeS9dmX3V1ddx+++1ccMEFJCQkALo23aW16/PQQw9ht9uZOXNmi/vp+nSPlq5PYWEhVVVVPPjgg5x88sl89tlnnHXWWZx99tnMnTsX0PXpLq39/vSGfGAPdQUkfP31r39lwYIFvPfee/Tv35+vv/6a3/zmN/Tp04cTTjih1f0Mw8BisXRjTXu/a6+9lh9++IF58+Y1u2/f5zqY51/XqPPs79qAOSDul7/8JYFAgCeffLLN4+nadK6Wrs+SJUt4/PHHWbp0abufa12fztXS9QkEAgCcccYZ3HjjjQAccsghzJ8/n6effpopU6a0ejxdn87V2vtbb8gHagGWFtXW1vK73/2ORx55hNNPP52DDz6Ya6+9lvPOO48///nPAGRmZuL1eiktLW2yb2FhYbNWSem46667jvfee4+vvvqK7Ozsxu2ZmZkAzT5N7/386xp1rdauTQOfz8e5557L5s2bmT17dmPrL+jadIfWrs8333xDYWEh/fr1w263Y7fb2bp1K7/97W8ZMGAAoOvTHVq7PqmpqdjtdkaNGtWk/MiRIxtngdD16XqtXZ/ekg8UgKVFPp8Pn8+H1dr0JWKz2Ro/nY8fPx6Hw8Hs2bMb78/Ly2PlypUcccQR3Vrf3sgwDK699lrefvttvvzySwYOHNjk/oEDB5KZmdnk+fd6vcydO7fx+dc16hptXRvYE37Xr1/P559/TkpKSpP7dW26TlvX56KLLuKHH35g+fLljbesrCxuueUWPv30U0DXpyu1dX2cTieHH354s6m31q1bR//+/QFdn67U1vXpNfmgmwfdSRiprKw0li1bZixbtswAjEceecRYtmxZ4yj1KVOmGKNHjza++uorY9OmTcbzzz9vREVFGU8++WTjMa666iojOzvb+Pzzz42lS5caxx13nDF27Fijvr4+VA+r17j66qsNt9ttzJkzx8jLy2u81dTUNJZ58MEHDbfbbbz99tvGjz/+aJx//vlGnz59jIqKisYyukadr61r4/P5jOnTpxvZ2dnG8uXLm5TxeDyNx9G16RrB/O7sa99ZIAxD16erBHN93n77bcPhcBjPPvussX79euNvf/ubYbPZjG+++aaxjK5P1wjm+vSGfKAAHMG++uorA2h2u/jiiw3DMIy8vDzjkksuMbKysoyoqChj+PDhxl/+8hcjEAg0HqO2tta49tprjeTkZCM6Oto47bTTjG3btoXoEfUuLV0bwHj++ecbywQCAeOuu+4yMjMzDZfLZRxzzDHGjz/+2OQ4ukadr61rs3nz5lbLfPXVV43H0bXpGsH87uyrpQCs69M1gr0+//znP40hQ4YYUVFRxtixY4133323yf26Pl0jmOvTG/KBxTAMo6tal0VEREREwo36AIuIiIhIRFEAFhEREZGIogAsIiIiIhFFAVhEREREIooCsIiIiIhEFAVgEREREYkoCsAiIiIiElEUgEVERERC7Nlnn2Xq1KkkJCRgsVgoKysLar+dO3cyY8YMUlJSiImJ4ZBDDmHJkiWN9xcUFHDJJZeQlZVFTEwMJ598MuvXr2/xWIZhcMopp2CxWHj33Xeb3f/hhx8yceJEoqOjSU1N5eyzz268b8WKFZx//vnk5OQQHR3NyJEjefzxx5vsX1dXxyWXXMJBBx2E3W7nzDPPDOox7mvjxo2cddZZpKWlkZCQwLnnnktBQUG7jqEALCLSQ8yZM6ddfxg725dffsmIESMIBAJtlv3ggw8YN25cUGVFIsXUqVN54YUXWryvpqaGk08+md/97ndBH6+0tJQjjzwSh8PBxx9/zOrVq/nLX/5CYmIiYAbaM888k02bNvG///2PZcuW0b9/f0444QSqq6ubHe+xxx7DYrG0eK633nqLiy66iEsvvZQVK1bw7bffcsEFFzTev2TJEtLS0njllVdYtWoVv//977njjjt44oknGsv4/X6io6OZOXMmJ5xwQtCPc2/V1dVMmzYNi8XCl19+ybfffovX6+X0009v3/tNaBeiExGRlkyZMsW4/vrrm2zzeDxGXl5ek+VGu9P48eONl156Kejy48aNM15++eUurJFIzzJlypT9LsltGIbx1VdfGYBRWlra5vFuu+0246ijjmr1/rVr1xqAsXLlysZt9fX1RnJysvHcc881Kbt8+XIjOzvbyMvLMwDjnXfeabzP5/MZffv2Nf7xj3+0Wae9/eY3vzGOPfbYFu+7+OKLjTPOOKPF+9577z3j0EMPNVwulzFw4EDj7rvvNnw+n2EYhvHpp58aVqvVKC8vbyxfUlJiAMbs2bODrptagEVEegin00lmZmarLTRdaf78+axfv55zzjkn6H0uvfRS/va3v3VhrUQi23vvvcdhhx3GOeecQ3p6OuPGjeO5555rvN/j8QAQFRXVuM1ms+F0Opk3b17jtpqaGs4//3yeeOIJMjMzm51n6dKl7Ny5E6vVyrhx4+jTpw+nnHIKq1at2m/9ysvLSU5Obtdj+vTTT5kxYwYzZ85k9erVPPPMM7zwwgvcf//9jY/JYrHgcrka94mKisJqtTZ5TG1RABYRCTOXXHIJc+fO5fHHH8disWCxWNiyZUuzLhAvvPACiYmJfPDBBwwfPpyYmBh+8YtfUF1dzYsvvsiAAQNISkriuuuuw+/3Nx7f6/Vy66230rdvX2JjY5k4cSJz5szZb51ef/11pk2b1uQP6YoVKzj22GOJj48nISGB8ePHs3jx4sb7p0+fzsKFC9m0aVOnPj8iYtq0aRNPPfUUQ4cO5dNPP+Wqq65i5syZvPTSSwCMGDGC/v37c8cdd1BaWorX6+XBBx8kPz+fvLy8xuPceOONHHHEEZxxxhmtngfg7rvv5s477+SDDz4gKSmJKVOmUFJS0uI+3333HW+88QZXXnllux7T/fffz+23387FF1/MoEGDOPHEE7n33nt55plnAJg0aRKxsbHcdttt1NTUUF1dzS233EIgEGjymNoUfEO2iIh0h7KyMmPy5MnG5ZdfbuTl5Rl5eXlGfX19s69Gn3/+ecPhcBgnnniisXTpUmPu3LlGSkqKMW3aNOPcc881Vq1aZbz//vuG0+k0Xn/99cbjX3DBBcYRRxxhfP3118aGDRuMP/3pT4bL5TLWrVvXap3Gjh1rPPjgg022jR492pgxY4axZs0aY926dcYbb7xhLF++vEmZ9PR044UXXui8J0ekB7n//vuN2NjYxpvVajVcLleTbV9//XWTfdrTBcLhcBiTJ09usu26664zJk2a1Pjz4sWLjbFjxxqAYbPZjJNOOsk45ZRTjFNOOcUwDMP43//+ZwwZMsSorKxs3Id9ukD8+9//NgDjmWeeadxWV1dnpKamGk8//XSzeq1cudJIS0sz7r333lbr3loXiJiYGCMqKqrJcxQVFWUARnV1tWEYZjeIQYMGGRaLxbDZbMaMGTOMQw891Lj66qv3/4Ttxd6uWC4iIl3O7XbjdDqJiYlp8evIvfl8Pp566ikGDx4MwC9+8QtefvllCgoKiIuLY9SoURx77LF89dVXnHfeeWzcuJHXXnuNHTt2kJWVBcDNN9/MJ598wvPPP88DDzzQ4nm2bNnSWL7Btm3buOWWWxgxYgQAQ4cObbZf37592bJlS3ufApFe4aqrruLcc89t/PnCCy/k5z//eZPZE/r27dvh4/fp04dRo0Y12TZy5Ejeeuutxp/Hjx/P8uXLKS8vx+v1kpaWxsSJEznssMMAc3Drxo0bGwfONfj5z3/O0UcfzZw5c+jTpw9Ak3O5XC4GDRrEtm3bmuy3evVqjjvuOC6//HLuvPPOdj+mQCDAPffc0+Q5atDwDdS0adPYuHEju3btwm63k5iYSGZmJgMHDgz6PArAIiI9WExMTGP4BcjIyGDAgAHExcU12VZYWAiYffkMw2DYsGFNjuPxeEhJSWn1PLW1tU26PwDcdNNNXHbZZbz88succMIJnHPOOU3qAhAdHU1NTU2HH59IT5acnNykD2x0dDTp6ekMGTKkU45/5JFHsnbt2ibb1q1bR//+/ZuVdbvdAKxfv57Fixdz7733AnD77bdz2WWXNSl70EEH8eijj3L66acDZoh2uVysXbuWo446CjA/fG/ZsqXJuVatWsVxxx3HxRdf3Nhnt70OPfRQ1q5dG9RzlJqaCpghvrCwkOnTpwd9HgVgEZEezOFwNPnZYrG0uK1heqBAIIDNZmPJkiXYbLYm5fYOzftKTU2ltLS0yba7776bCy64gA8//JCPP/6Yu+66i9dff52zzjqrsUxJSQlpaWkdemwikSQ/P5/8/Hz+f3v3EgrvHsdx/H3+Lgsh1BSLmTGbcSllFrKipIgQuZQwrGShGLea5DZJIaWUNJthMSkWLKwtlEQWMplSJKXcb1mQ0jkLec7R/39OnPM/J535vHbP9Pye+T3P4unT9/ldDg4OAAgEAsTExGCxWIwQnZ+fT0VFBa2trcDvY3dHRkaoqalha2sLr9eL1+s1rru4uIjJZMJisRAIBGhra6O8vJyCggIAEhMTf/ilyWKxGBXV2NhYWlpaGBgYwGw2Y7VaGR8fBzAmxu7t7ZGXl0dBQQEdHR2cnZ0Br5Pu/vgOCAaDPD8/c3Nzw8PDAzs7OwBkZmYC0N/fT0lJCWazmerqar59+8bu7i6BQIDh4WEAfD4faWlpmEwmNjY2aGtrw+VykZKS8uHnrQAsIvIFRUZGvpu49rM4HA5eXl64uLggJyfnU+2CweB3v9vtdux2Oy6Xi9raWnw+nxGAn56eODw8xOFw/LT+i/xfzczMMDQ0ZBzn5uYCr2GvqakJwPjs/yYrK4ulpSXcbjcejwebzcbk5CR1dXXGOaenp3R0dHB+fk5SUhJOp5O+vr5P9298fJzw8HAaGhp4fHwkOzub1dVV4uPjgdegfXl5id/vx+/3G+2sVuu7YVDFxcUcHx8bx2/vh9ehx1BYWMjKygoej4exsTEiIiJITU19V6Xe39/H7XZzc3NDcnIyvb29uFyuT93PL7++/aOIiHwZzc3N7OzssLCwQHR0NAkJCaytrZGXl8ft7S1xcXHMzs7S3t7+bmOMwcFBlpeXjaoKvK4qcXd3Z+zsVF9fz/r6OhMTEzgcDq6urlhdXSUjI4Pi4uIf9mdqaoq5uTljlYfHx0e6u7upqqrCZrNxcnJCY2MjlZWVjI6OAq8bd5SWlnJ+fk5UVNS/8pxERP4OLYMmIvIFdXV1ERYWRnp6OiaT6buJJv+Ez+fD6XTS2dlJSkoKZWVlbG5uYjab/7RNfX09wWDQGG8YFhbG9fU1TqcTu91OTU0NRUVF7ypY8/Pz1NXVKfyKyJejCrCIiHxIT08P9/f3xnqcf+Xy8pLU1FS2t7c/NTNbROS/oAqwiIh8SG9vL1ar9UNjk4+Ojpienlb4FZEvSRVgEREREQkpqgCLiIiISEhRABYRERGRkKIALCIiIiIhRQFYREREREKKArCIiIiIhBQFYBEREREJKQrAIiIiIhJSFIBFREREJKQoAIuIiIhISPkN1yg+qZl2IBUAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -1895,7 +1873,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1986,7 +1964,7 @@ " (Total: 2)" ] }, - "execution_count": 43, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -2012,29 +1990,27 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", - "exists. Use `overwrite=True` or pick a different name\n", - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/4552\n", - "2739aed0cce27667e45026e3e32c\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/45522739aed0cce276\n", + "67e45026e3e32c/45522739aed0cce27667e45026e3e32c\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 25%|████████▍ | 25/101 [03:02<08:36, 6.80s/it]" + " 25%|████████▍ | 25/101 [00:34<01:42, 1.35s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2046,12 +2022,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 50%|████████████████▊ | 50/101 [05:58<06:40, 7.86s/it]" + " 50%|████████████████▊ | 50/101 [01:09<01:09, 1.35s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAD6CAYAAABwKvR6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACODElEQVR4nOzdd1gUx/8H8PfRe1VAFAERCwq2RAMW7L3E3sUWe8ESa4ygRiyxJBo1iQqWWBNrTOzYG/aCiRXRCKKgoghImd8f/m6/HHcHR5EDeb+eh0dvdnb2M3M7e3tzu7MyIYQAERERERERERFRAdLRdgBERERERERERFT8cFCKiIiIiIiIiIgKHAeliIiIiIiIiIiowHFQioiIiIiIiIiIChwHpYiIiIiIiIiIqMBxUIqIiIiIiIiIiAocB6WIiIiIiIiIiKjAcVCKiIiIiIiIiIgKHAeliIiIiIiIiIiowHFQiojoE7N69WrIZDKYmZkpLevfvz9kMpnSX6VKlZTyqsonk8kwb948hXw7duxAz549Ub58eRgbG8PFxQW9e/fG3bt3FfLFx8fju+++Q8OGDeHg4AAzMzN4enpi/vz5SEpKUsgbEBCgdvsymQxbtmyR8m7evBkNGjSAvb09DA0N4ejoiHbt2uHMmTNKdXrz5g3GjBmD0qVLw9DQEBUqVMCCBQuQlpaWozbOTzKZDAEBAQppb9++hb+/PxwdHWFkZITq1asr1FlbLl26hJEjR8LT0xPm5uawt7dH06ZNcfToUaW8Li4uat8/IyMjpfwvXrzA2LFj4eLiAkNDQ9jb26NVq1aIi4tTynvq1Cm0bt0a1tbWMDY2hru7O2bPnq2QJ6v9R9X+nlOJiYmoUKECZDIZvv/+e4VlERERGu27cg8ePECnTp1gZWUFMzMzNGvWDJcvX1bIExUVhW+++Qbe3t4oUaIELCwsUKtWLfzyyy9q919N2klThw8fRrNmzeDo6AhDQ0PY2dmhcePG+Ouvv3JVHqB5381N3fPLsWPHIJPJ8Pvvv0tpZ86cQUBAAF69evVRt52drOJo2LAhGjZsWOAxAcDSpUvRqVMnuLq6QiaTqY0jJCREbT+Jjo5Wyn/48GF4e3vDxMQEJUqUQP/+/RETE/ORa0NERB+bnrYDICKi/PPff/9h4sSJcHR0xOvXr1XmMTY2VhpEMDY2Vpm3S5cumDBhgkJa2bJlFV7Pnz8fDg4OmD59OsqVK4fHjx9j7ty5qFmzJs6dO4cqVaoAACIjI7F06VL07dsX48ePh5mZGU6ePImAgAAcOnQIhw4dgkwmAwAMHjwYLVu2VIrnq6++wv379xWWxcbGom7duhg7dixKlCiBqKgoLF68GA0aNMCRI0fg6+sLAEhNTUWzZs1w584dzJ49GxUqVMD+/fsxZcoUPHnyBD/++GNWTVugOnXqhLCwMMybNw8VKlTApk2b0LNnT6Snp6NXr15ai2vz5s24cOECBg4ciGrVqiEhIQGrVq1CkyZNsG7dOvTr10/Ku3PnTiQnJyusHxkZie7du6Njx44K6U+fPkX9+vWhp6eHGTNmwN3dHS9evEBoaCjev3+vkHfTpk3o27cvunXrhvXr18PMzAz379/H06dPFfKdPXtWKf7z58/D399fafu5MWPGDCQkJGSZZ/To0Urvl7u7u8Lr58+fo379+rC2tsbatWthZGSEoKAgNGzYEGFhYahYsSKADwOC69evR79+/TBjxgzo6+vj77//xvDhw3Hu3DmsXbtWoVxN20lTsbGxqFKlCgYPHgwHBwfExcVh1apVaNOmDTZs2IA+ffrkqkxN+m5O6/6xnTlzBoGBgejfvz+srKwKdNuaxrFixQrtBAVg1apVMDU1RePGjbF3795s8wcHBysNFNva2iq8Pn78OFq1aoU2bdpg9+7diImJweTJk9GkSRNcvHgRhoaG+VoHIiIqQIKIiD4Zbdu2Fe3atRN+fn7C1NRUabm6dFUAiJEjR2ab79mzZ0pp//33n9DX1xeDBg2S0t6+fSvevn2rlHfhwoUCgDh58mSW23n48KGQyWSiT58+2cb06tUroa+vL/r27Sulbd68WQAQf/zxh0LeIUOGCB0dHfHPP/9kW+7HAEDMnDlTer1v3z4BQGzatEkhX7NmzYSjo6NITU0t4Aj/R9V7nZqaKry8vISbm1u26wcEBAgA4vDhwwrpHTp0EKVLlxZxcXFZrv/kyRNhamoqhg8fnrPA/1///v2FTCYTd+/ezdX6cufPnxcGBgZi+/btAoBYuHChwvKHDx+qTFfl66+/Fvr6+iIiIkJKe/36tShRooTo1q2blBYXFyfev3+vtP7IkSMFABEZGSml5bWdNPX+/XtRunRpUb9+/XwrU1XfzUnd81toaKgAILZv3y6lyY9ZDx8+zNdtJSQk5Cj/x4ojr9LS0qT/V6lSRfj6+qrMFxwcLACIsLCwbMv8/PPPhYeHh0hJSZHSTp8+LQCIFStW5DlmIiLSHt6+R0T0idi4cSOOHz9e4L+Q29nZKaU5OjqiTJkyePz4sZRmamoKU1NTpby1a9cGAIW8qqxduxZCCAwePDjbmMzNzWFkZAQ9vf9dEHz69GnIZDK0atVKIW/btm2Rnp6OnTt3Smn37t3DgAED4O7uDhMTE5QuXRrt2rXDjRs3lLYVHx+PiRMnwtXVFQYGBihdujT8/f2VrqKJj4/HV199BVtbW5iZmaFly5a4c+eOUnk7d+6EmZkZunbtqpA+YMAAPH36FOfPn1dI37RpE7y9vWFmZgYzMzNUr14da9asUcizf/9+NGnSBJaWljAxMUHlypURFBSkkOfixYto3749bGxsYGRkhBo1amDbtm0KeVS917q6uqhVq1a2758QAsHBwShXrhwaN24spUdERGDPnj346quvYG1tnWUZq1evRkJCAiZPnpxlPlXevHmD7du3w9fXF+XLl1dYpul7CADv37/HwIEDMXLkSHz22Wc5jiOznTt3onHjxnB2dpbSLCws0KlTJ+zduxepqakAAGtra+jr6yutL+8/T548kdJy2k5bt26Ft7c3TE1NYWZmhhYtWuDKlSvZrqevrw8rKyuFfgZ8eK9XrFiB6tWrw9jYGNbW1ujSpQsePHiQbZmq+m5O6g4A//zzD3r27CndFli2bFn069dP6cq93AgICMDXX38NANLtaTKZDMeOHZPyaNKe/fv3h5mZGW7cuIHmzZvD3NwcTZo0AQAcOnQIHTp0QJkyZWBkZITy5ctj6NChePHihcZxqLp9Ly4uDiNGjEDp0qVhYGCAcuXKYfr06UrtIpPJMGrUKGzYsAGVK1eGiYkJqlWrhj///FOjNtLRyd+vF//99x/CwsLQt29fhf3Cx8cHFSpUUDh2ExFR0cNBKSKiT0BMTAz8/f0xb948lClTJsu8iYmJcHBwgK6uLsqUKYNRo0apnLcH+DDgYWxsDENDQ9SqVQvBwcEaxfPgwQM8evRIunUvK/JbCbPKm56ejpCQEJQvX166pSeztLQ0pKSkICIiAsOHD4cQAiNHjpSWv3//Hjo6OkpfbuW3fVy/fl1Ke/r0KWxtbTFv3jzs378fP/30E/T09FCnTh38+++/Ur53797B19cX69atw5gxY/D3339j8uTJCAkJQfv27SGEAPDhS/qXX36JDRs2YMKECdi5cye++OILpQEyALh58yYqV66s9EXfy8tLWi737bffonfv3nB0dERISAh27twJPz8/PHr0SMqzZs0atG7dGunp6Vi1ahX27t2LMWPGKHyRDw0NRd26dfHq1SusWrUKu3fvRvXq1dG9e3eEhISoflP+X2pqKk6ePJnte3348GE8evQIAwcOlG7TBICTJ09CCAFHR0f07NkTZmZmMDIyQsOGDZVuwTtx4gRsbGzwzz//oHr16tDT04OdnR2GDRuG+Pj4LLe/ZcsWJCQkKA1qavoeys2aNQsJCQkazc00b948GBgYwMTEBPXq1cOePXsUlicmJuL+/fvSe5uRl5cXEhMTsx3IOXr0KPT09FChQgUpLSftNHfuXPTs2RMeHh7Ytm0bNmzYgDdv3qB+/foIDw9X2l56ejpSU1Px9OlTzJw5E3fu3FG6xXfo0KHw9/dH06ZNsWvXLqxYsQK3bt2Cj48Pnj17plRmdn03J3W/du0aPv/8c5w7dw6zZs3C33//jaCgICQnJyvcCuri4gIXF5dst5HZ4MGDMXr0aAAf5tM7e/Yszp49i5o1awLIWXu+f/8e7du3R+PGjbF7924EBgYCAO7fvw9vb2+sXLkSBw8exLfffovz58+jXr16SElJ0SiOzJKSktCoUSOsX78e48ePx759+9CnTx8sWLAAnTp1Usq/b98+LF++HLNmzcIff/wBGxsbdOzYUaOBxZxq27YtdHV1YWNjg06dOikc44D/HfPU9ZPM+YmIqIjR2jVaRESUbzp37ix8fHxEenq6EEL9bXqLFy8WixcvFgcPHhQHDx4U06dPFyYmJqJSpUrizZs3Cnl79eolfvvtN3HixAnx+++/i1atWgkA4ptvvskylpSUFNGwYUNhYWGR7W01165dE8bGxqJjx45Z5vv7778FABEUFKQ2T8WKFQUAAUCUKlVKnDp1SmH50qVLVd4mOGPGDAFANG/eXG3Zqamp4v3798Ld3V2MGzdOSg8KChI6OjpKt5/8/vvvAoD466+/FOL/4YcfFPJ99913Srfvubu7ixYtWijF8PTpUwFAzJ07VwghxIMHD4Surq7o3bu32rjfvHkjLCwsRL169aR9Q5VKlSqJGjVqKNwaI8SH20FLlSqlcDtOZtOnTxcAxK5du9TmEUKI7t27C11dXfHkyROF9KCgIAFAWFhYiA4dOoj9+/eLP/74Q3h5eQkjIyNx7do1KW/FihWFkZGRMDc3F3PnzhWhoaFiwYIFwtjYWNStWzfLOtapU0dYWVmJxMREpe1r8h4KIcSVK1eEvr6+2L9/vxBC/W16T58+FV999ZXYtm2bOHnypPjtt9/EF198IQCIX3/9Vcr333//qd2vN23aJACIM2fOqK3TgQMHhI6OjsI+mZN2ioyMFHp6emL06NEK679580Y4ODgo3D4o16JFC6mfWVhYiB07digsP3v2rAAgFi1apJD++PFjYWxsLCZNmqRUZnZ9Nyd1b9y4sbCyshIxMTFZru/m5qbRLac5uX0vJ+3p5+cnAIi1a9dmuf309HSRkpIiHj16JACI3bt3ZxuHEEL4+voq3Da3atUqAUBs27ZNId/8+fMFAHHw4EEpDYCwt7cX8fHxUlp0dLTQ0dHJ8hisSla37/39999i+vTpYu/eveL48eNi+fLlokyZMsLU1FRcvXpVyvfbb78JAOLs2bNKZQwZMkQYGBjkKCYiIipcOChFRFTE/f7778LAwEDcunVLSsvJ3FHyL9+LFy/ONm/btm2Fnp6e2i986enpol+/fkJXVzfbQYqHDx8KJycnUaFCBREbG5tl3i5dugg9PT0RFRWlNs/NmzfF+fPnxfbt20WTJk2Eubm5CA0NlZY/f/5c2NjYiMqVK4tz586Jly9fik2bNglLS0sBQLRs2VLKm5KSIr777jtRuXJloa+vL31hzpyvbt26wsvLS6SkpCj8vXnzRshkMukL+KRJkwQA8eLFC6U2UDUolXEbcvJBKfmXwp9//lmjQQuomJ8qo7t37woA4vvvv1eqx4oVKwQAER4ernLdX3/9VQAQEyZMUFu+EELExsYKQ0ND0aZNG6Vl8oE5Dw8Phfmynj59KkxMTBQG3dzd3VUO4sgHHA8dOqRy+zdv3lQ7R5qm72FKSoqoUaOGwpxmOZk76v3796JGjRrC1tZWGvyTD0rNmzdPKb98UErVF3EhhLh06ZKwtLQUPj4+IikpSWGZpu0kf//CwsKU6t+9e3dhZ2entN07d+6ICxcuiN27d4uuXbsKfX19hf1r+vTpQiaTiWfPnimV+cUXX4jatWsrlZld39W07gkJCUJXV1cMGTJE7bo5lZNBqZy0p3xQ6vXr10rbfPbsmRg6dKgoU6aM0NHRUTj+ZNxXcjIo1a1bN2Fqaqo0cPvs2TMBQEyePFlKAyB69OihVKaDg4MYNmyY2rZSJatBKVUePnwozMzMRPv27aU0+aDUuXPnlPIPGTJEGBoa5igmIiIqXHj7HhFREfb27VuMHDkSo0ePhqOjI169eoVXr15Jt6m8evUq2yeEdezYEaampjh37ly22+vTpw9SU1Nx8eJFpWXi/+d72rhxI0JCQtChQwe15Tx69AiNGjWCnp4ejhw5AhsbG7V5X7x4gT179qBNmzZwcHBQm69KlSqoXbs2unTpgv3798PZ2Rljx46VlpcoUQL79+8HAHzxxRewtrbG6NGjsXjxYgBA6dKlpbzjx4/HjBkz8OWXX2Lv3r04f/48wsLCUK1aNSQmJkr5nj17huvXr0NfX1/hz9zcHEIIaQ6Y2NhY6OnpKT1RSlV9bG1tERsbq5Quv8VS3lbPnz8HgCxv19Qkj/x2qokTJyrVY8SIEQCgMJeNXHBwMIYOHYohQ4Zg4cKFassHPsx3lpycrHI+MHmbNG3aFLq6ulJ6qVKlUK1aNVy+fFkpb4sWLRTKkN8GmTFvRvI5tlRtX9P3cOnSpXjw4AFmzpwp9TP5rXBJSUl49eoV0tLS1LaBvr4+unfvjtjYWNy9exfAh7mSZDKZRu93RleuXEGzZs3g7u6Ov/76S+nJY5q2k/y9//zzz5Xqv3XrVpXvu7u7Oz7//HO0b98e27ZtQ5MmTTBy5Eikp6dLZQohYG9vr1TmuXPnVJaZXd/VtO4vX75EWlpatrcwfyw5bU8TExNYWFgopKWnp6N58+bYsWMHJk2ahCNHjuDChQvS8Tnj8ScnYmNj4eDgoHDrLPBhnjg9PT2lfTDzsQr4cKtzbrevKRcXF9SrV0/h80gei7p+ktXnBxERFX562WchIqLC6sWLF3j27BkWLVqERYsWKS23trZGhw4dsGvXrizLEUJoNDmt+P/5dTLnlQ9IBQcHY82aNVk+Hv7Ro0do2LAhhBA4duxYtl8gN2zYgPfv32s0wbmcnp4eatasqTRR9+eff47w8HBEREQgISEB7u7uuHTpEgCgQYMGUr6NGzeiX79+mDt3rsL6L168UHj0eokSJWBsbKz2kfQlSpQA8OFLVWpqKmJjYxW+7EVHRyut4+npic2bNyM1NVVhXin5JOtVq1YFAJQsWRLAh0menZycVG4/Yx515DFOnTpV5dwyAFCxYkWF18HBwRg8eDD8/PywatUqpS+6ma1Zswb29vZo27at0jJV88TIZd4vvby8VA6eqtsvgQ/z9mzYsAG1atVC9erVlZZr+h7evHkTr1+/hru7u1KeGTNmYMaMGbhy5YrKbaiL09jYGOXLl1c5gf6NGzdgbGyMcuXKKaRfuXIFTZs2hbOzMw4ePAhLS0uldTVtJ3ndfv/9d4WJ1nOidu3a2L9/P54/fw57e3uUKFECMpkMJ0+eVBosA6AyLSN1fRfIvu42NjbQ1dXNcn//mHLanqr6zc2bN3Ht2jWEhITAz89PSr93716eYrO1tcX58+chhFDYbkxMDFJTU6XYC4PM/V5+zLtx4wZat26tkPfGjRvSciIiKqK0cXkWERHlj8TERBEaGqr016JFC2FkZCRCQ0PFjRs3sixj69atAoBYunRptttr3bq10NfXF8+fP5fS0tPTxaBBg4RMJhO//PJLlus/evRIuLi4CCcnJ3H//n2N6lilShXh6OiocGtXdhITE0WFChVE1apVs8yXnp4uOnfuLBwdHcW7d++kdBsbGzF06FCFvH/++acAoHArypw5c4SJiYl48OBBltvJyZxSf/31lwAgtmzZopC3ZcuWCu3w8OFDoaurK/r27at2u2/evBGWlpaiQYMGWc635O7uLlq3bp1lHeSCg4OFjo6O6NevX5ZzTcmFhYUJACrnEhLiw+Pjy5QpIypVqqTwHv/333/C2NhYDBo0SEqT34743XffKZSxePFilfOFCSHE9u3bs3xsvKbv4e3bt5X62ebNmwUAMWzYMBEaGqo0L1tG79+/F9WrVxclSpRQqOekSZOEgYGBwvxr8fHxomTJkqJ79+4KZVy5ckXY2NgILy8vpVtBM9K0nR4+fCj09PTE/Pnzs6y7Ounp6cLX11dYWVlJtySeOnVKABBbt27NVZnq+q6mdW/cuLGwtrZWOEblharb93788UeVt7XmpD3V3WJ9/fp1AUBs3rxZIX3ixIlKxwp1cQihfPue/HbfzHOAyW8BzHjrK9Tc6urs7Cz8/PyyrVtGOb1978GDB8LMzEx8+eWXCum1a9cWVatWVeg78vnLVq5cmaOYiIiocOGVUkRERZj8KWWZhYSEQFdXV2HZo0eP0KtXL/To0QPly5eHTCbD8ePHsXTpUlSpUkXhSqSFCxciPDwcTZo0QZkyZRATE4M1a9bg4MGDCAgIUPhVfcyYMVizZg0GDhwIT09PhSs0DA0NUaNGDQAffpFv1KgRoqKisGbNGsTExCAmJkbKW6ZMGaWrps6fP49bt25h2rRpCrd2ZeTj44P27dujcuXKsLS0REREBFauXIn79+8rPSp8+vTp8PT0RKlSpRAZGYm1a9fi/Pnz2LdvH4yNjaV8bdu2RUhICCpVqgQvLy9cunQJCxcuVIrP398ff/zxBxo0aIBx48bBy8sL6enpiIyMxMGDBzFhwgTUqVMHzZs3R4MGDTBp0iQkJCTgs88+w+nTp7Fhwwal+rRq1QrNmjXD8OHDER8fj/Lly2Pz5s3Yv38/Nm7cKLWDi4sLpk2bhtmzZyMxMRE9e/aEpaUlwsPD8eLFCwQGBsLMzAyLFi3C4MGD0bRpU3z11Vewt7fHvXv3cO3aNSxfvhwA8PPPP6NVq1Zo0aIF+vfvj9KlSyMuLg63b9/G5cuXsX37dgDA9u3bMWjQIFSvXh1Dhw7FhQsXFGKvUaOG0pUw8lvnBg0apPL909HRwZIlS9CtWzd06NABw4cPl55uZ2BggKlTp0p5mzdvjnbt2mHWrFlIT0/HF198gYsXLyIwMBBt27ZFvXr1lMpfs2YNjI2N0atXL5Xb1/Q9rFSpEipVqqSwbkREBADAzc1Noa+NHz8eKSkpqFu3LhwcHPD48WMsW7YMV69eRXBwsMK+PHHiRGzYsAFt2rTBrFmzYGhoiHnz5iEpKQkBAQFSvn///RdNmzYFAHz33Xe4e/eudBugPAb5lXGatpOLiwtmzZqF6dOn48GDB2jZsiWsra3x7NkzXLhwAaamptIT4Tp06IBq1aqhevXqsLW1xdOnTxESEoLjx49LT6cEgLp162LIkCEYMGAALl68iAYNGsDU1BRRUVE4deoUPD09MXz4cACa992c1H3x4sWoV68e6tSpgylTpqB8+fJ49uwZ9uzZg59//hnm5uYAgPLlywPI3RVInp6eAIAffvgBfn5+0NfXR8WKFXPUnupUqlQJbm5umDJlCoQQsLGxwd69e3Ho0CGN45DXMaN+/frhp59+gp+fHyIiIuDp6YlTp05h7ty5aN26tdS++eHixYtS34iPj4cQAr///juAD1eryq8ia9q0KRo0aAAvLy9YWFjgxo0bWLBgAWQymdLTLefPn49mzZqha9euGDFiBGJiYjBlyhRUrVoVAwYMyLfYiYhIC7Q9KkZERPlP1a/wcXFxomPHjsLFxUUYGxsLAwMD4e7uLiZNmiRevXqlkHfPnj2iXr16omTJkkJPT0+Ym5uL+vXrK/16L8SHX8+RYSLejH/Ozs5SPvkVB+r+Ml4BIPfVV18JmUyW5VVVEyZMENWqVROWlpZCT09PODg4iI4dO4rTp08r5R0+fLgoW7asMDAwECVKlBCdO3cW169fV8r38uVLMWjQIGFnZydMTExEvXr1xMmTJ5WuPhBCiLdv34pvvvlGVKxYURgYGAhLS0vh6ekpxo0bJ6Kjo6V8r169EgMHDhRWVlbCxMRENGvWTPzzzz8q6/7mzRsxZswY4eDgIAwMDISXl5fKthdCiPXr14vPP/9cGBkZCTMzM1GjRg0RHByskOevv/4Svr6+wtTUVJiYmAgPDw+lqzmuXbsmunXrJuzs7IS+vr5wcHAQjRs3FqtWrZLyyCdnVveXecLld+/eSVdqZWfXrl1SPSwtLUX79u0VJu/PWObkyZOFk5OT0NPTE2XLlhVTp05VmuxbiA9PQ5Nf1ZUVTd/DzNRNdL5mzRpRu3ZtYWNjI/T09IS1tbVo0aKFOHDggMpy7t27J7788kthYWEhTExMRJMmTcSlS5cU8gQHB2fZ9pnf85y0065du0SjRo2EhYWFMDQ0FM7OzqJLly7i8OHDUp758+eLzz//XFhbWwtdXV1ha2srWrRoIf7880+VdVq7dq2oU6eOMDU1FcbGxsLNzU3069dPXLx4Ucqjad/Nad3Dw8NF165dha2trTAwMBBly5YV/fv3V6i7s7OzwvFJHVVXSgkhxNSpU4Wjo6M0EXnGidk1ac+sHkYRHh4umjVrJszNzYW1tbXo2rWriIyMVHmsUBeHqmNVbGysGDZsmChVqpTQ09MTzs7OKvcJ5PFKqayOExnfK39/f+Hh4SHMzc2Fnp6ecHR0FH369BH//vuvynIPHjwovvjiC2FkZCRsbGxEv379xLNnz7KNh4iICjeZEP8/wQAREREREREREVEB4dP3iIiIiIiIiIiowHFQioiIiIiIiIiIChwHpYiIiIiIiIiIqMBxUIqIiIiIiIiIiAocB6WIiIiIiIiIiKjAcVCKiIiIiIiIiIgKHAeliIiIiIiIiIiowHFQioiIiIiIiIiIChwHpYiIiIiIiIiIqMBxUIqIiIiIiIiIiAocB6WIiIiIiIiIiKjAcVCKiIiIiIiIiIgKHAeliIiIiIiIiIiowHFQioiIiIiIiIiIChwHpYiIiIiIiIiIqMBxUIqIiIiIiIiIiAocB6WIiIiIiIiIiKjAcVCKiIiIiIiIiIgKHAeliIiIiIiIiIiowHFQioiIiIiIiIiIChwHpYiIiIiIiIiIqMBxUIqIiIiIiIiIiAocB6WIiIiIiIiIiKjAcVCKiIiIiIiIiIgKHAeliIiIiIiIiIiowHFQioiIiIiIiIiIChwHpYiIiIiIiIiIqMDleVAqJCQEMplM5d/EiRPzI0bKRkBAAGQymUKai4sL+vfvn6Nyzpw5g4CAALx69SpH62Xe1rFjxyCTyfD777/nqJysvHv3DgEBATh27JjSMvk+GBERkW/b+5Rk7qNGRkZwcHBAo0aNEBQUhJiYGG2HiLlz52LXrl1K6fJ9SdX7ri0NGzZEw4YNpdcRERGQyWQICQnJUTmbNm3C0qVLc7SOqm3J+/+LFy9yVFZWwsPDERAQoLJP9e/fHy4uLvm2LcqdjP1aVf8QQqB8+fKQyWQK+2t+UHfML0z9VNv7aVafp5mPIURUtJ0/fx4dO3ZE2bJlYWhoCHt7e3h7e2PChAkK+VasWJHjc4XM1J0vUeGTk/OzgvzeRlQY6eVXQcHBwahUqZJCmqOjY34VTzm0c+dOWFhY5GidM2fOIDAwEP3794eVldVH3VZOvXv3DoGBgQCgdDLfpk0bnD17FqVKlfqoMRR18j6akpKCmJgYnDp1CvPnz8f333+PrVu3omnTplqLbe7cuejSpQu+/PJLhfSaNWvi7Nmz8PDw0E5gGihVqhTOnj0LNze3HK23adMm3Lx5E/7+/h99WzkVHh6OwMBANGzYUOmL/YwZMzB27NiPun3SnLm5OdasWaN0XDx+/Dju378Pc3Pzjx5DUeinBS2rz9MVK1ZoJygiynf79u1D+/bt0bBhQyxYsAClSpVCVFQULl68iC1btmDRokVS3hUrVqBEiRI5HnzISN35EhVtBfm9jagwyrdBqapVq+Kzzz7TKG9KSgpkMhn09PJt85RJjRo1Pvo2EhMTYWxsXCDbykrJkiVRsmRJrcZQFGTuo507d8a4ceNQr149dOrUCXfv3oW9vX2et5OWlobU1FQYGhrmuSwLCwt88cUXeS7nYzI0NPzoMWZsU223x8ceEKOc6d69O3777Tf89NNPCie0a9asgbe3N+Lj4z96DEWhn+bVu3fvYGJiki9lcfCO6NOxYMECuLq64sCBAwrfa3r06IEFCxZoMTIqSrT9XSqj/Py8I9LUR59TSn5Z/4YNGzBhwgSULl0ahoaGuHfvHgDg8OHDaNKkCSwsLGBiYoK6deviyJEjSuXs27cP1atXh6GhIVxdXfH9998r3baW1W00MpkMAQEBCml3795Fr169YGdnB0NDQ1SuXBk//fSTyvg3b96M6dOnw9HRERYWFmjatCn+/fdfpe3s378fTZo0gaWlJUxMTFC5cmUEBQUBADZs2ACZTIazZ88qrTdr1izo6+vj6dOnWbanqnZQJfNloOnp6ZgzZw4qVqwIY2NjWFlZwcvLCz/88AOAD5eYfv311wAAV1dXpdtCXFxc0LZtW+zYsQM1atSAkZGRdOWSuktOk5KSMH78eDg4OMDY2Bi+vr64cuWKQh51tzFkvPUiIiJCGnQKDAyUYpNvU93te2vXrkW1atVgZGQEGxsbdOzYEbdv31bajpmZGe7du4fWrVvDzMwMTk5OmDBhApKTk1W27aekbNmyWLRoEd68eYOff/5ZStfkfQH+1+cWLFiAOXPmwNXVFYaGhggNDUVSUhImTJiA6tWrw9LSEjY2NvD29sbu3bsVypTJZEhISMC6deuk91a+bXW3Be3Zswfe3t4wMTGBubk5mjVrptSv5MeHW7duoWfPnrC0tIS9vT0GDhyI169fZ9s2QggsWLAAzs7OMDIyQs2aNfH3338r5VN13Hn+/DmGDBkCJycnGBoaomTJkqhbty4OHz4ste++ffvw6NEjhVsrs2vTrI5xjx8/RqdOnWBhYQFLS0v06dMHz58/V2rrzMdBQLEPh4SEoGvXrgCARo0aSbHJt6nqtqikpCRMnToVrq6uMDAwQOnSpTFy5EilS8rlx5H9+/ejZs2aMDY2RqVKlbB27Vo17wJlp2fPngCAzZs3S2mvX7/GH3/8gYEDB6pc5/3795gzZw4qVaok7Z8DBgxQ2l9SUlIwadIkODg4wMTEBPXq1cOFCxeUylPVTy9evIgePXrAxcUFxsbGcHFxQc+ePfHo0SOFdeXH79DQUAwfPhwlSpSAra0tOnXqlO3nYcYyKlasKH2Or1+/XqMYAdX9V/65cOPGDTRv3hzm5uZo0qQJAODQoUPo0KEDypQpAyMjI5QvXx5Dhw5VuD0ju89TVcfXuLg4jBgxAqVLl4aBgQHKlSuH6dOnK30OyWQyjBo1Chs2bEDlypVhYmKCatWq4c8//9SorYgof8XGxqJEiRIqf2jX0fnf1ywXFxfcunULx48fl44J8s/S/DhfAoDo6GgMHToUZcqUgYGBAVxdXREYGIjU1NRs63H06FE0bNgQtra2MDY2RtmyZdG5c2e8e/dOypPXz47M3xdUTT8CqD+v37p1K7y9vWFqagozMzO0aNFC6XtFTs7rk5OTMWvWLFSuXBlGRkawtbVFo0aNcObMGSmPEAIrVqxA9erVYWxsDGtra3Tp0gUPHjzItk3lnj17lu15aH5/b0tPT8eCBQuk98rOzg79+vXDkydPFLbbsGFDVK1aFSdOnICPjw9MTEwwcOBADBo0CDY2Ngrvv1zjxo1RpUoVjetPpIl8u1RJ/ku+QuEZDtBTp06Ft7c3Vq1aBR0dHdjZ2WHjxo3o168fOnTogHXr1kFfXx8///wzWrRogQMHDkgngUeOHEGHDh3g7e2NLVu2IC0tDQsWLMCzZ89yHW94eDh8fHykL+UODg44cOAAxowZgxcvXmDmzJkK+adNm4a6deti9erViI+Px+TJk9GuXTvcvn0burq6AD78Mv3VV1/B19cXq1atgp2dHe7cuYObN28C+PCL9qRJk/DTTz/B29tbKjs1NRU///wzOnbsmOUtj3lphwULFiAgIADffPMNGjRogJSUFPzzzz/Sl8bBgwcjLi4Oy5Ytw44dO6Rb4TL+onv58mXcvn0b33zzDVxdXWFqaprlNqdNm4aaNWti9erVeP36NQICAtCwYUNcuXIF5cqVyzZmuVKlSmH//v1o2bIlBg0ahMGDBwNAlldHBQUFYdq0aejZsyeCgoIQGxuLgIAAeHt7IywsDO7u7lLelJQUtG/fHoMGDcKECRNw4sQJzJ49G5aWlvj22281jrOoat26NXR1dXHixIlcl/Hjjz+iQoUK+P7772FhYQF3d3ckJycjLi4OEydOROnSpfH+/XscPnwYnTp1QnBwMPr16wcAOHv2LBo3boxGjRphxowZAJDlJcybNm1C79690bx5c2zevBnJyclYsGABGjZsiCNHjqBevXoK+Tt37ozu3btj0KBBuHHjBqZOnQoA2Q6EBAYGIjAwEIMGDUKXLl3w+PFjfPXVV0hLS0PFihWzXLdv3764fPkyvvvuO1SoUAGvXr3C5cuXERsbC+DDJfxDhgzB/fv3sXPnTo3bNCsdO3ZEt27dMGzYMNy6dQszZsxAeHg4zp8/D319/SzXzahNmzaYO3cupk2bhp9++gk1a9YEoP4KKSEEvvzySxw5cgRTp05F/fr1cf36dcycORNnz57F2bNnFa6au3btGiZMmIApU6bA3t4eq1evxqBBg1C+fHk0aNBA4zjpAwsLC3Tp0gVr167F0KFDAXwYoNLR0UH37t2V5i1LT09Hhw4dcPLkSUyaNAk+Pj549OgRZs6ciYYNG+LixYswNjYGAHz11VdYv349Jk6ciGbNmuHmzZvo1KkT3rx5k21cERERqFixInr06AEbGxtERUVh5cqV+PzzzxEeHo4SJUoo5B88eDDatGmDTZs24fHjx/j666/Rp08fHD16NMvthISEYMCAAejQoQMWLVokfdYkJycrfCHMqffv36N9+/YYOnQopkyZIp3f3L9/H97e3hg8eDAsLS0RERGBxYsXo169erhx4wb09fU1+jzNKCkpCY0aNcL9+/cRGBgILy8vnDx5EkFBQbh69Sr27dunkH/fvn0ICwvDrFmzYGZmhgULFqBjx474999/c/TZSkR55+3tjdWrV2PMmDHo3bs3atasqfIzd+fOnejSpQssLS2lW3jln435cb4UHR2N2rVrQ0dHB99++y3c3Nxw9uxZzJkzBxEREQgODlZbh4iICLRp0wb169fH2rVrYWVlhf/++w/79+/H+/fvYWJiUmCfHerMnTsX33zzDQYMGIBvvvkG79+/x8KFC1G/fn1cuHBB4fiqyXl9amoqWrVqhZMnT8Lf3x+NGzdGamoqzp07h8jISPj4+AAAhg4dipCQEIwZMwbz589HXFwcZs2aBR8fH1y7dk2jOwxycx6a1+9tw4cPxy+//IJRo0ahbdu2iIiIwIwZM3Ds2DFcvnxZ4TM4KioKffr0waRJkzB37lzo6OjAysoKa9euxaZNm6TvXcCH78+hoaFKF3EQ5ZnIo+DgYAFA5V9KSooIDQ0VAESDBg0U1ktISBA2NjaiXbt2CulpaWmiWrVqonbt2lJanTp1hKOjo0hMTJTS4uPjhY2NjchYhYcPHwoAIjg4WClOAGLmzJnS6xYtWogyZcqI169fK+QbNWqUMDIyEnFxcUIIIcXfunVrhXzbtm0TAMTZs2eFEEK8efNGWFhYiHr16on09HS17TVz5kxhYGAgnj17JqVt3bpVABDHjx9Xu15O2kEIIZydnYWfn5/0um3btqJ69epZlr9w4UIBQDx8+FBpmbOzs9DV1RX//vuvymUZtyVvs5o1ayq0RUREhNDX1xeDBw+W0nx9fYWvr69SmX5+fsLZ2Vl6/fz5c6X3UE6+D8rjfvnypTA2NlZ6zyIjI4WhoaHo1auXwnYAiG3btinkbd26tahYsaLStooiefuEhYWpzWNvby8qV64svdb0fZH3OTc3N/H+/fss40hNTRUpKSli0KBBokaNGgrLTE1NFfYhOfm+FBoaKoT4cHxwdHQUnp6eIi0tTcr35s0bYWdnJ3x8fKS0mTNnCgBiwYIFCmWOGDFCGBkZZdlPX758KYyMjETHjh0V0k+fPi0AKLSNquOOmZmZ8Pf3V1u+EEK0adNGoS0zl6eqTVVtS17PcePGKeT97bffBACxceNGKU1dH8rch7dv367Q7hll3gf279+vsp3lx7VffvlFYTtGRkbi0aNHUlpiYqKwsbERQ4cOVdoWqZexX8v7yc2bN4UQQnz++eeif//+QgghqlSporC/bt68WQAQf/zxh0J5YWFhAoBYsWKFEEKI27dvZ7lfqTrmq9pf5FJTU8Xbt2+Fqamp+OGHH5TqMWLECIX8CxYsEABEVFSU2jLlxwN1nzUZ91N1MarqU/LPhbVr16rdthBCpKeni5SUFPHo0SMBQOzevVtaltXnaebj66pVq1R+Ds2fP18AEAcPHpTSAAh7e3sRHx8vpUVHRwsdHR0RFBSUZbxElP9evHgh6tWrJ3330dfXFz4+PiIoKEi8efNGIW/m47E6uTlfGjp0qDAzM1P4fBVCiO+//14AELdu3VK7vd9//10AEFevXlWb52N8dsjPXzLLfF4fGRkp9PT0xOjRoxXyvXnzRjg4OIhu3bpJaZqe169fv14AEL/++qvaOp89e1YAEIsWLVJIf/z4sTA2NhaTJk1Su27G+mlyHpqf39vk70Hmz9Xz588LAGLatGlSmq+vrwAgjhw5olS+r6+vUgzDhw8XFhYWSvs2UV7l2+1769evR1hYmMJfxiulOnfurJD/zJkziIuLg5+fH1JTU6W/9PR0tGzZEmFhYUhISEBCQgLCwsLQqVMnGBkZSeubm5ujXbt2uYo1KSkJR44cQceOHWFiYqKw/datWyMpKQnnzp1TWKd9+/YKr728vABAuhXhzJkziI+Px4gRI1Reiio3fPhwAMCvv/4qpS1fvhyenp5ZXiWQ13aoXbs2rl27hhEjRuDAgQO5mmfEy8sLFSpU0Dh/r169FNrC2dkZPj4+CA0NzfG2c+Ls2bNITExUuqXQyckJjRs3Vro9VCaTKbWhl5eX0m0mnzIhRJ7Wb9++vcpfBrdv3466devCzMwMenp60NfXx5o1a5Ruo9TUv//+i6dPn6Jv374KV0GYmZmhc+fOOHfunNKlxqr6blJSUpZPHTx79iySkpLQu3dvhXQfHx84OztnG2ft2rUREhKCOXPm4Ny5c0hJSdGkekpx5+QKp8yxduvWDXp6eh+9v8mvZMnc37p27QpTU1Ol/la9enWULVtWem1kZIQKFSoUq/6W33x9feHm5oa1a9fixo0bCAsLU3vr3p9//gkrKyu0a9dO4bOvevXqcHBwkC79l+836var7Lx9+xaTJ09G+fLloaenBz09PZiZmSEhIUFl/8/uM1YV+fFA3WdNXmU+bwGAmJgYDBs2DE5OTtIxTX5MyO1x7ejRozA1NUWXLl0U0uV9KnMfatSokcIE9vb29rCzs2MfItICW1tbnDx5EmFhYZg3bx46dOiAO3fuYOrUqfD09NT4ybh5PV/6888/0ahRIzg6Oioc21u1agXgw8Mv1KlevToMDAwwZMgQrFu3TuWtaQX12aHKgQMHkJqain79+ils28jICL6+vkq3ZWtyXv/333/DyMhI7WelvM4ymQx9+vRR2K6DgwOqVaum8RNnc3MempfvbfL3IPN5We3atVG5cmWlzxRra2s0btxYqZyxY8fi6tWrOH36NAAgPj4eGzZsgJ+fH8zMzDSOh0gT+TYoVblyZXz22WcKfxllfjKa/JazLl26QF9fX+Fv/vz5EEIgLi4OL1++RHp6OhwcHJS2qSpNE7GxsUhNTcWyZcuUtt26dWsAUPoQsbW1VXgtv+Q2MTERAKT7qcuUKZPltu3t7dG9e3f8/PPPSEtLw/Xr13Hy5EmMGjUqy/Xy2g5Tp07F999/j3PnzqFVq1awtbVFkyZNcPHixWzXlcvp0+3UxSq/heljkZevKl5HR0el7ZuYmCgM9AEf3t+kpKSPF2QhkpCQgNjY2Dw9LVNVW+/YsQPdunVD6dKlsXHjRpw9e1b6spzbts3uvU1PT8fLly8V0rPru1ltJ7f9bevWrfDz88Pq1avh7e0NGxsb9OvXD9HR0dmuK5fX/qanpwdbW9sC6W96enpKt9PKZDKV/T3z+wF8eE+yej8oazKZDAMGDMDGjRuxatUqVKhQAfXr11eZ99mzZ3j16hUMDAyUPv+io6Olzz51fUC+X2WnV69eWL58OQYPHowDBw7gwoULCAsLQ8mSJVW+19rop1kxMTFRuo04PT0dzZs3x44dOzBp0iQcOXIEFy5ckH7Eyu0+HBsbCwcHB6UftOzs7KCnp8c+RFQEfPbZZ5g8eTK2b9+Op0+fYty4cYiIiNBosvP8OF969uwZ9u7dq3Rcl8/9k9XgmJubGw4fPgw7OzuMHDkSbm5ucHNzk+YvkpdfEJ8d6uoGAJ9//rnStrdu3apUN03O658/fw5HR8csb/N+9uwZhBCwt7dX2u65c+c0HnDMzedbXr635fR7kLrzzQ4dOsDFxUW6VS8kJAQJCQkYOXJktjEQ5VSBPf4u88mW/F7WZcuWqX1qj729vfSkPlVf5jKnyQ9AmSeyy9z5rK2toauri759+6rtWK6urlnURpn8C1nmCeRUGTt2LDZs2IDdu3dj//79sLKyUvpFITNra2uN20EVPT09jB8/HuPHj8erV69w+PBhTJs2DS1atMDjx481espCVleAqaIu1owHZyMjI5WTTmt6oFdFXn5UVJTSsqdPnyrNZVLc7du3D2lpaQqTZeb0fVG1b2zcuBGurq7YunWrwvK8TCCf3Xuro6MDa2vrXJefeTvq9uHME31nVqJECSxduhRLly5FZGQk9uzZgylTpiAmJgb79+/XKIbc9LfSpUtLr1NTUxEbG6vQ3wwNDVW2f14GrmxtbZGamornz58rDEwJIRAdHY3PP/8812WT5vr3749vv/0Wq1atwnfffac2n3wicXX7ofwKnIx9QNV+lZXXr1/jzz//xMyZMzFlyhQpXT5vSn7Jrp9mpO78ICfHtJs3b+LatWsICQmBn5+flC5/cEtu2dra4vz58xBCKGw3JiYGqamp/MwiKmL09fUxc+ZMLFmyRJpXNiv5cb5UokQJeHl5qT3+Z/fDY/369VG/fn2kpaXh4sWLWLZsGfz9/WFvb48ePXp8lM+OjMfljHNPZj4uy4+Bv//+u0ZXq2uiZMmSOHXqFNLT09UOTJUoUQIymQwnT55U+UTp/HjKtDp5+d6W8Vw588USqr4HqTvf1NHRwciRIzFt2jQsWrQIK1asQJMmTbKdV5UoNz760/fUqVu3LqysrBAeHq50hZX8z8DAAKampqhduzZ27NihMML95s0b7N27V6FMe3t7GBkZ4fr16wrpmZ9eYWJigkaNGuHKlSvw8vJSue2cjub7+PjA0tISq1atyvZWqFq1asHHxwfz58/Hb7/9hv79+2c7aXhO2iE7VlZW6NKlC0aOHIm4uDjp6RaajNznxObNmxXa4tGjRzhz5ozC4IeLiwvu3Lmj8MEbGxur8OSLnMbm7e0NY2NjbNy4USH9yZMnOHr0qDSBPgGRkZGYOHEiLC0tpUmSAc3fl6zIZDIYGBgofNhFR0cr9UdA81/5K1asiNKlS2PTpk0K+1ZCQgL++OMP6Yl8efXFF1/AyMgIv/32m0L6mTNncnyLTNmyZTFq1Cg0a9YMly9fltLz+8qGzLFu27YNqampSv0t8/Hx6NGjePv2rUJaTvqbvD9l7m9//PEHEhIS2N8KSOnSpfH111+jXbt2CgMmmbVt2xaxsbFIS0tT+dknP9mU7zfq9qusyGQyCCGUTthXr16NtLS0XNROtYoVK6JUqVJqP2sykg8kZ97/9+zZo/H25MeyzPXK+ORSuZz2obdv32LXrl0K6fKnCLIPERVeqn4kA/53O2/GwSB1n/v5cb7Utm1b3Lx5E25ubiqP7ZpeDa+rq4s6depIV8fIz1s+xmeHuuNy5u81LVq0gJ6eHu7fv6/2O2NOtWrVCklJSSqfZizXtm1bCCHw33//qdymp6dnjrebGzn93ia/FS/zeVlYWBhu376do8+UwYMHw8DAAL1798a///6b7Z09RLlVYFdKZWZmZoZly5bBz88PcXFx6NKlC+zs7PD8+XNcu3YNz58/x8qVKwEAs2fPRsuWLdGsWTNMmDABaWlpmD9/PkxNTRV+dZXf97t27Vq4ubmhWrVquHDhAjZt2qS0/R9++AH16tVD/fr1MXz4cLi4uODNmze4d+8e9u7dm+0Tf1TVZ9GiRRg8eDCaNm2Kr776Cvb29rh37x6uXbuG5cuXK+QfO3YsunfvDplMhhEjRmi0DU3bQZV27dqhatWq+Oyzz1CyZEk8evQIS5cuhbOzs/RUL/nB9YcffoCfnx/09fVRsWJFhbkrciImJgYdO3bEV199hdevX2PmzJkwMjKSnjoBfHhK2c8//4w+ffrgq6++QmxsLBYsWKB024S5uTmcnZ2xe/duNGnSBDY2NihRooTKK1asrKwwY8YMTJs2Df369UPPnj0RGxuLwMBAGBkZKT1Zsbi4efOmdD98TEwMTp48ieDgYOjq6mLnzp0KV7lo+r5kpW3bttixYwdGjBghPb1u9uzZKFWqFO7evauQ19PTE8eOHcPevXtRqlQpmJubq/wlRkdHBwsWLEDv3r3Rtm1bDB06FMnJyVi4cCFevXqFefPm5b6BMrC2tsbEiRMxZ84cDB48GF27dsXjx48REBCQ7W1Br1+/RqNGjdCrVy9UqlQJ5ubmCAsLw/79+9GpUyeFOu/YsQMrV65ErVq1oKOjk6sTK7kdO3ZAT08PzZo1k56+V61aNXTr1k3K07dvX8yYMQPffvstfH19ER4ejuXLl8PS0lKhrKpVqwIAfvnlF5ibm8PIyAiurq4qB+ubNWuGFi1aYPLkyYiPj0fdunWlp+/VqFEDffv2zXWdKGc02f979OiB3377Da1bt8bYsWNRu3Zt6Ovr48mTJwgNDUWHDh3QsWNHVK5cGX369MHSpUuhr6+Ppk2b4ubNm9LTILNiYWGBBg0aYOHChdJx+vjx41izZg2srKzyqbYfjgezZ8/G4MGDpc+aV69eqeynDg4OaNq0KYKCgmBtbQ1nZ2ccOXIEO3bs0Hh7lSpVgpubG6ZMmQIhBGxsbLB3714cOnRIKW9OPk/79euHn376CX5+foiIiICnpydOnTqFuXPnonXr1mjatGkOW4aICkqLFi1QpkwZtGvXDpUqVUJ6ejquXr2KRYsWwczMDGPHjpXyenp6YsuWLdi6dSvKlSsHIyMjeHp65sv50qxZs3Do0CH4+PhgzJgxqFixIpKSkhAREYG//voLq1atUjvFyKpVq3D06FG0adMGZcuWRVJSkvRkOPnx52N8drRu3Ro2NjYYNGgQZs2aBT09PYSEhODx48cK+VxcXDBr1ixMnz4dDx48QMuWLWFtbY1nz57hwoULMDU1RWBgYI7et549eyI4OBjDhg3Dv//+i0aNGiE9PR3nz59H5cqV0aNHD9StWxdDhgzBgAEDcPHiRTRo0ACmpqaIiorCqVOn4OnpKc0VnN/y8r2tYsWKGDJkCJYtWwYdHR20atVKevqek5MTxo0bp3EcVlZW6NevH1auXAlnZ+dcz+dMlK28zpSe3ZO95E+82b59u8rlx48fF23atBE2NjZCX19flC5dWrRp00Yp/549e4SXl5cwMDAQZcuWFfPmzVP51IbXr1+LwYMHC3t7e2FqairatWsnIiIiVD516uHDh2LgwIGidOnSQl9fX5QsWVL4+PiIOXPmZBu/uif9/fXXX8LX11eYmpoKExMT4eHhIebPn69U7+TkZGFoaChatmypsl3U0bQdMj/FYdGiRcLHx0eUKFFCWnfQoEEiIiJCYb2pU6cKR0dHoaOjo/CkImdnZ9GmTRuVMal7+t6GDRvEmDFjRMmSJYWhoaGoX7++uHjxotL669atE5UrVxZGRkbCw8NDbN26VekJX0IIcfjwYVGjRg1haGio8ASPzE/pkFu9erXUVpaWlqJDhw5KTx/x8/MTpqamSjGpeyJIUZT5CZkGBgbCzs5O+Pr6irlz54qYmBiV62nyvsj7wcKFC1WWMW/ePOHi4iIMDQ1F5cqVxa+//qqyba9evSrq1q0rTExMFJ5up+6JWbt27RJ16tQRRkZGwtTUVDRp0kScPn1aIY98O8+fP1fZHqqeipVRenq6CAoKEk5OTsLAwEB4eXmJvXv3Kj05K/OxICkpSQwbNkx4eXkJCwsLYWxsLCpWrChmzpwpEhISpPXi4uJEly5dhJWVlZDJZFKbZNWmWT1979KlS6Jdu3bCzMxMmJubi549eyo85VOID8edSZMmCScnJ2FsbCx8fX3F1atXlfqwEEIsXbpUuLq6Cl1dXYVtquqbiYmJYvLkycLZ2Vno6+uLUqVKieHDh4uXL18q5FN3HFH3tEdST5Onagqh+mlPKSkp4vvvvxfVqlUTRkZGwszMTFSqVEkMHTpU3L17V8qXnJwsJkyYIOzs7ISRkZH44osvxNmzZ9Ue8zP20ydPnojOnTsLa2trYW5uLlq2bClu3ryptK66emjyRD+51atXC3d3d2FgYCAqVKgg1q5dq3I/jYqKEl26dBE2NjbC0tJS9OnTR1y8eFHl0/dUfS4IIUR4eLho1qyZMDc3F9bW1qJr164iMjJS5TmGus9TVft7bGysGDZsmChVqpTQ09MTzs7OYurUqSIpKUkhHwAxcuRIpbhU9WEi+vi2bt0qevXqJdzd3YWZmZnQ19cXZcuWFX379hXh4eEKeSMiIkTz5s2Fubm5AKBwjMrr+ZIQH55UPWbMGOHq6ir09fWFjY2NqFWrlpg+fbp4+/at2jqcPXtWdOzYUTg7OwtDQ0Nha2srfH19xZ49exTy5fdnhxBCXLhwQfj4+AhTU1NRunRpMXPmTLF69WqV52m7du0SjRo1EhYWFsLQ0FA4OzuLLl26iMOHD0t5cnJen5iYKL799lvp88PW1lY0btxYnDlzRiHf2rVrRZ06dYSpqakwNjYWbm5uol+/fiq/06japibnofn9vS0tLU3Mnz9fVKhQQejr64sSJUqIPn36iMePHyus7+vrK6pUqZJlPY4dOyYAiHnz5mWZjygvZELk8bFbWhQQEIDAwMA8PzlMG/bu3Yv27dtj37590uTqREREREREnxoXFxc0bNgwy1vmqPCZMGECVq5cicePH+d6snqi7Gjt9r3iKjw8HI8ePcKECRNQvXp16VGtRERERERERNp27tw53LlzBytWrMDQoUM5IEUfFQelCtiIESNw+vRp1KxZE+vWrcvxE7aIiIiIiIiIPhb5w4Patm2LOXPmaDsc+sQV6dv3iIiIiIiIiIioaNLRdgBERERERERERFT8cFCKiIiIiIiIiIgKHAeliIiIiIiIiIiowGllovP09HQ8ffoU5ubmnOibPjohBN68eQNHR0fo6HAcNiP2RSpI7IvqsS9SQWJfVI99kYiIKH9oer6hlUGpp0+fwsnJSRubpmLs8ePHKFOmjLbDKFTYF0kb2BeVsS+SNrAvKmNfJCIiyl/ZnW9oZVDK3NwcwIfgLCwstBECFSPx8fFwcnKS9jv6H/ZFKkjsi+qxL1JBYl9U739t8gMAY0C3e94KTNua15AKyIP//7ecVqOgLGTeFzPvW6P/f/myVdkU9FLDDVpDdrcvhPuP+N9+8UBappmstmWtQR5A9T75QIM8mspYlrUG8aiq+4d17rxeIaVUsByRi1hUlN1wGHAs6P+XuQG4n+HfnJmCyfjtdRgA4PHoCsD6zPtKxrpr+v5klHGd7PYRdeWqWm/o//87L5u86srMvP9mJ/P+9EBNmiay2qfky9SVnTHunO7j6uLLqm6a1iknkgEsyfZ8QyuDUvLLoS0sLHjyTQWGl+ErY18kbWBfVMa+SNrAvqjsf21i/OFPltf+aJzH9QuK4f//W1TiLYaU9sVM75WhfLlRNgUZZrNczggycwsIGGbYlqG0TDNZbctIgzyA6n0y8zp52W8zlmWkQTyq6v5hHXMLmVJazqgoW8/i/8syAmCS6d+cMQSgY2H24YWBhYoyMrdF5rTsZFwnt/uhqvXk+3bmdbKKP6PM+292Mu9PhmrSNJHVPiVfpq7sjHHndB/Pri0y5stp++RcducbnEiAiIiIiIiIiIgKHAeliIiIiIiIiIiowHFQioiIKB8FBQVBJpPB398/z2WlpQucvR+L3Vf/w9n7sUhLF3kP8BPBtiEiIiIq+rQyp5Rc1ZkHELmkqzZDICJ86Is6hiYAgIh5bbQcDVHRFRYWhl9++QVeXl55Lmv/zSgE7g1H1OskKa2UpRFmtvNAy6ql8lx+Uca2ISIiIvo08EopIiKifPD27Vv07t0bv/76K6ytNX0ykWr7b0Zh+MbLCoMuABD9OgnDN17G/ptReSq/KGPbEBEREX06OChFRESUD0aOHIk2bdqgadOmeSonLV0gcG84VN2MJk8L3BteLG9XY9sQERERfVq0evseERHRp2DLli24fPkywsLCNMqfnJyM5ORk6XV8fLz0/wsP45SuAspIAIh6nYQLD+Pg7Wab65iLIrYNERER0aeFV0oRERHlwePHjzF27Fhs3LgRRkZGGq0TFBQES0tL6c/JyUlaFvNG/aBLRprm+5SwbYiIiIg+LRyUIiIiyoNLly4hJiYGtWrVgp6eHvT09HD8+HH8+OOP0NPTQ1pamtI6U6dOxevXr6W/x48fS8vszDUb2NI036eEbUNERET0aeHte0RERHnQpEkT3LhxQyFtwIABqFSpEiZPngxdXV2ldQwNDWFoaKiyvNquNihlaYTo10kq506SAXCwNEJtV5t8iL5oYdsQERERfVp4pRQREVEemJubo2rVqgp/pqamsLW1RdWqVXNcnq6ODDPbeQD4MMiSkfz1zHYe0NXJvPTTx7YhIiIi+rRwUIqIiKiQaVm1FFb2qQkHS8Xb0BwsjbCyT020rFpKS5FpH9uGiIiI6NPB2/eIiIjy2bFjx/JcRsuqpdDMwwEXHsYh5k0S7Mw/3JbGq4DYNkRERESfCg5KERERFVK6OjJ4u9lqO4xCiW1DREREVPTx9j0iIiIi0qoTJ06gXbt2cHR0hEwmw65duxSWCyEQEBAAR0dHGBsbo2HDhrh165ZCnuTkZIwePRolSpSAqakp2rdvjydPnhRgLYiIiCinOChFRERERFqVkJCAatWqYfny5SqXL1iwAIsXL8by5csRFhYGBwcHNGvWDG/evJHy+Pv7Y+fOndiyZQtOnTqFt2/fom3btkhLSyuoahAREVEO8fY9IiIiItKqVq1aoVWrViqXCSGwdOlSTJ8+HZ06dQIArFu3Dvb29ti0aROGDh2K169fY82aNdiwYQOaNm0KANi4cSOcnJxw+PBhtGjRosDqQkRERJrjlVJEREREVGg9fPgQ0dHRaN68uZRmaGgIX19fnDlzBgBw6dIlpKSkKORxdHRE1apVpTyqJCcnIz4+XuGPiIiICg4HpYiIiIio0IqOjgYA2NvbK6Tb29tLy6Kjo2FgYABra2u1eVQJCgqCpaWl9Ofk5JTP0RMREVFWOChFRERERIWeTCZTeC2EUErLLLs8U6dOxevXr6W/x48f50usREREpBkOShERERFRoeXg4AAASlc8xcTESFdPOTg44P3793j58qXaPKoYGhrCwsJC4Y+IiIgKDgeliIiIiKjQcnV1hYODAw4dOiSlvX//HsePH4ePjw8AoFatWtDX11fIExUVhZs3b0p5iIiIqPDh0/eIiIiISKvevn2Le/fuSa8fPnyIq1evwsbGBmXLloW/vz/mzp0Ld3d3uLu7Y+7cuTAxMUGvXr0AAJaWlhg0aBAmTJgAW1tb2NjYYOLEifD09JSexkdERESFDweliIiIiEirLl68iEaNGkmvx48fDwDw8/NDSEgIJk2ahMTERIwYMQIvX75EnTp1cPDgQZibm0vrLFmyBHp6eujWrRsSExPRpEkThISEQFdXt8DrQ0RERJrhoBQRERERaVXDhg0hhFC7XCaTISAgAAEBAWrzGBkZYdmyZVi2bNlHiJCIiIg+Bg5KEREREX1C0tIFLjyMQ8ybJNiZG6G2qw10dbJ+Sh0RERGRNuRqUCohIQGmpqb5HQsR5RD7IhERZbT/ZhQC94Yj6nWSlFbK0ggz23mgZdVSWoyMiIiISFmunr5nb2+PgQMH4tSpU/kdDxHlAPsiERHJ7b8ZheEbLysMSAFA9OskDN94GftvRmkpMiIiIiLVcjUotXnzZrx+/RpNmjRBhQoVMG/ePDx9+jS/YyOibLAvEhER8OGWvcC94VA1K5M8LXBvONLS1c/bRERERFTQcjUo1a5dO/zxxx94+vQphg8fjs2bN8PZ2Rlt27bFjh07kJqamt9xEpEK7ItERAQAFx7GKV0hlZEAEPU6CRcexhVcUERERETZyNWglJytrS3GjRuHa9euYfHixTh8+DC6dOkCR0dHfPvtt3j37l1+xUlEWWBfJCIq3mLeqB+Qyk0+IiIiooKQp6fvRUdHY/369QgODkZkZCS6dOmCQYMG4enTp5g3bx7OnTuHgwcP5lesRKQG+yIRUfFmZ26Ur/lyIjExEUIImJiYAAAePXqEnTt3wsPDA82bN8/37REREdGnI1eDUjt27EBwcDAOHDgADw8PjBw5En369IGVlZWUp3r16qhRo0Z+xUlEKrAvEhERANR2tUEpSyNEv05SOa+UDICDpRFqu9og4e2bfN12hw4d0KlTJwwbNgyvXr1CnTp1oK+vjxcvXmDx4sUYPnx4vm6PiIiIPh25un1vwIABcHR0xOnTp3H16lWMGjVK4UswAJQrVw7Tp0/PjxiJSA32RSIiAgBdHRlmtvMA8GEAKiP565ntPKCrk3lp3l2+fBn169cHAPz++++wt7fHo0ePsH79evz444/5vj0iIiL6dOTqSqmoqCjpEm11jI2NMXPmzFwFRUSaYV8kyrs7d+7g2LFjiImJQXp6usKyb7/9VktREeVcy6qlsLJPTQTuDVeY9NzB0ggz23mgZdVSH2W77969g7m5OQDg4MGD6NSpE3R0dPDFF1/g0aNHH2WbRERE9GnI1aCUubk5oqKiYGdnp5AeGxsLOzs7pKWl5UtwRJQ19kWivPn1118xfPhwlChRAg4ODpDJ/ncViUwm46AUFTktq5ZCMw8HXHgYh5g3SbAz/3DL3se4QkqufPny2LVrFzp27IgDBw5g3LhxAICYmBhYWFh8tO0SERFR0ZerQSkhVM1WACQnJ8PAwCBHZblM2QcAiJjXJjehEBVr+dkXiYqjOXPm4LvvvsPkyZO1HQpRvtHVkcHbzbbAtvftt9+iV69eGDduHJo0aQJvb28AH66a4pyGRERElJUcDUrJ5wWQyWRYvXo1zMzMpGVpaWk4ceIEKlWqlL8REpES9kWi/PHy5Ut07dpV22EQFWldunRBvXr1EBUVhWrVqknpTZo0QceOHbUYGRERERV2ORqUWrJkCYAPV2esWrUKurq60jIDAwO4uLhg1apV+RshESlhXyTKH127dsXBgwcxbNgwbYdCVKQ5ODjAwcFBIa127dpaioaIiIiKihwNSj18+BAA0KhRI+zYsQPW1tYfJSgiyhr7IlH+KF++PGbMmIFz587B09MT+vr6CsvHjBmjpciIio6EhATMmzcPR44cUfnAgAcPHmgpMtKYXsD//p+6UWthUB59n59Pu4xTkWaTT2XbqPm/qu3e+/9/y2daJy5TnozLtauUzL8AtuIO4G4BbEcTOd0vegNYlsvtqNovC0J+72MZ20xd2ar2/cIsY5zy2MtptGau5pQKDQ3NzWpElM/YF4ny5pdffoGZmRmOHz+O48ePKyyTyWQclCLSwODBg3H8+HH07dsXpUqVUnhgABEREVFWNB6UGj9+PGbPng1TU1OMHz8+y7yLFy/Oc2BEpBr7IlH+kV91SES59/fff2Pfvn2oW7eutkMhIiKiIkbjQakrV64gJSVF+r86/HWM6ONiXyT6OORPs2TfIcoZa2tr2Njk1209REREVJxoPCiV8TYh3jJEpD0fuy+6TNmnlBYxr02+b4eosFi/fj0WLlyIu3c/zM1QoUIFfP311+jbt6+WIyMqGmbPno1vv/0W69atg4mJibbDISIioiIkV3NKERERfQoWL16MGTNmYNSoUahbty6EEDh9+jSGDRuGFy9eYNy4cdoOkajQW7RoEe7fvw97e3u4uLgoPTDg8uXLWoqMiIiICjuNB6U6deqkcaE7duzIVTBElD32RaL8s2zZMqxcuRL9+vWT0jp06IAqVaogICCAg1JEGvjyyy+1HQIREREVURoPSllaWn7MOIhIQ+yLRPknKioKPj4+Suk+Pj6IiorSQkRERc/MmTO1HQIREREVURoPSgUHB3/MOIhIQ+yLRPmnfPny2LZtG6ZNm6aQvnXrVri7u2spKqKi6dKlS7h9+zZkMhk8PDxQo0YNbYdEREREhRznlCIiomIrMDAQ3bt3x4kTJ1C3bl3IZDKcOnUKR44cwbZt27QdHlGREBMTgx49euDYsWOwsrKCEAKvX79Go0aNsGXLFpQsWVLbIRIREVEhpfGgVM2aNXHkyBFYW1ujRo0aWT4ymxNaEn087ItE+adz5844f/48lixZgl27dkEIAQ8PD1y4cEHjqzyCgoKwY8cO/PPPPzA2NoaPjw/mz5+PihUrfuToiQqH0aNHIz4+Hrdu3ULlypUBAOHh4fDz88OYMWOwefNmLUdIREREhZXGg1IdOnSAoaEhAE5oSaRN7ItE+atWrVrYuHFjrtc/fvw4Ro4cic8//xypqamYPn06mjdvjvDwcJiamuZjpESF0/79+3H48GFpQAoAPDw88NNPP6F58+ZajIyIiIgKO40HpTJOYvkxJrR0mbIPABAxr02+l030KfnYfZHoUxcfHw8LCwvp/1mR58vK/v37FV4HBwfDzs4Oly5dQoMGDXIfKFERkZ6eDn19faV0fX19pKenayEiIiIiKiryNKfUxYsXpQktK1eujFq1auVXXESUA+yLRJqztrZGVFQU7OzsYGVlpfIWWCEEZDIZ0tLSclz+69evAQA2NjZ5jpWoKGjcuDHGjh2LzZs3w9HREQDw33//Ydy4cWjSpImWoyMiIqLCLFeDUk+ePEHPnj1x+vRpWFlZAQBevXoFHx8fbN68GU5OTvkZIxGpwb5IlHNHjx6VBoxCQ0PztWwhBMaPH4969eqhatWqavMlJycjOTlZep3dFVtEhdny5cvRoUMHuLi4wMnJCTKZDJGRkfD09MzTrbFERET06cvVoNTAgQORkpKC27dvSxO5/vvvvxg4cCAGDRqEgwcP5muQRKQa+yJRzvn6+kr/d3V1lb5EZySEwOPHj3Nc9qhRo3D9+nWcOnUqy3xBQUEIDAzMcflEhZGTkxMuX76MQ4cO4Z9//pEeGNC0aVNth0ZERESFXK4GpU6ePIkzZ84oPFmoYsWKWLZsGerWrZtvwRFR1tgXifLG1dVVupUvo7i4OLi6uubo9r3Ro0djz549OHHiBMqUKZNl3qlTp2L8+PHS6/j4eF7ZSEVes2bN0KxZM22HQUREREVIrgalypYti5SUFKX01NRUlC5dOs9BEZFm2BeJ8kY+d1Rmb9++hZGRkcZljB49Gjt37sSxY8fg6uqa7TqGhobSUzSJiqIff/wRQ4YMgZGREX788ccs844ZMybb8pYtW4Y5c+bgxYsXSE9Px5QpUxAUFAQAePfuHRo1aoRr164hOTkZOjo6cHFxwfbt21GzZk2pDCsrK2lONzknJydERkbmooZERERUEHI1KLVgwQKMHj0aP/30E2rVqgWZTIaLFy9i7Nix+P777/M7RiJSg32RKHfkVynJZDLMmDEDJiYm0rK0tDScP38e1atX16iskSNHYtOmTdi9ezfMzc0RHR0NALC0tISxsXG+x05UGCxZsgS9e/eGkZERlixZojafTCbTaFDq5cuXcHd3h5+fHxYuXKiw7MWLF7h37x6GDx+O5s2b47///oO/vz/q16+PhIQEhbyVKlXC1q1bpdfy+RaJiIiocNJ4UMra2lrh1+SEhATUqVMHenofikhNTYWenh4GDhyIL7/8Mt8DJaIP2BeJ8u7KlSsAPlzldOPGDRgYGEjLDAwMUK1aNUycOFGjslauXAkAaNiwoUJ6cHAw+vfvny/xEhU2Dx8+VPn/3Pr222/x7bffAoDSoFTZsmURGxurkKavr4/+/fvj7Nmz8Pb2ltKNjIzg5eWV53iIiIioYGg8KLV06dKPGAYRaYp9kSjv5E/dGzBgAH744QdYWFjkuiwhRH6FRVQkzZo1CxMnTlS44hAAEhMTsXDhQmmwKT89e/YMAJTmYrt27Rp0dHRgYGCAqlWrYs+ePXB0dMz37RMREVH+0HhQys/P72PGQUQaYl8kyj/BwcHaDoGoyAsMDMSwYcOUBqXevXuHwMDAfB+UevXqFQIDA+Hi4qLwUIH27dujatWqcHd3R2hoKFauXAlPT0+lq6wyio+PR3x8vPT6zZs3+RorERERZS1Xc0pllJiYqDTRcl5+cSai3GFfJMqdsLAwbN++HZGRkXj//r3Csh07dmgpKqKiQ90DA65duwYbG5t83da7d+9QuXJlCCFw8uRJhWXr16+X/t+xY0fUrl0bffv2xW+//YbevXurLK99+/Y4fvx4vsZIREREmtPJzUoJCQkYNWoU7OzsYGZmBmtra4U/IioY7ItEebNlyxbUrVsX4eHh2LlzJ1JSUhAeHo6jR4/C0tJS2+ERFWrW1tawsbGBTCZDhQoVYGNjI/1ZWlqiWbNm6NatW75t7927dyhfvjxevXqFa9euKVwlpUqvXr0AABcuXFCbZ8+ePXj8+LH0Fx4enm/xEhERUfZydaXUpEmTEBoaihUrVqBfv3746aef8N9//+Hnn3/GvHnz8jtGIlKDfZEob+bOnYslS5Zg5MiRMDc3xw8//ABXV1cMHToUpUqV0nZ4RIXa0qVLIYTAwIEDERgYqDCQa2BgABcXF4VJyPNCPiAVFxeHK1euwN3dPdt1du/eDQAoX7682jwWFhYKVxVnvJWPiIiIPr5cDUrt3bsX69evR8OGDTFw4EDUr18f5cuXh7Ozc5aXSBNR/mJfJMqb+/fvo02bNgAAQ0NDJCQkQCaTYdy4cWjcuDECAwO1HCFR4SWf49DV1RU+Pj7Q19fPdVnR0dEKt9Hdvn0bW7duRdmyZVGjRg24ubnh+fPn2LRpE1JSUnD9+nUAQLly5WBmZoajR49izpw56N+/P8qVK4cjR45g7ty5MDY2xtChQ/NWUSIiIvpocjUoFRcXB1dXVwAffmGKi4sDANSrVw/Dhw/Pv+iIKEvsi0R5Y2NjI01sXLp0ady8eROenp549eoV3r17p+XoiIoGX19f6f+5nd9wy5YtGDdunPR69+7d2L17N9zc3BASEoLo6GgAQPfu3RXWW7JkCfz9/WFqaorLly/j2LFjEEJAT08PVapUwR9//AEDA4O8VI+IiIg+olwNSpUrVw4RERFwdnaGh4cHtm3bhtq1a2Pv3r2wsrLK5xCJSB32RaK8qV+/Pg4dOgRPT09069YNY8eOxdGjR3Ho0CE0adJE2+ERFQnv3r3DpEmTsG3bNpVPuktLS8u2DH9/f/j7+6tdLoTIcv06derg1atX2W6HiIiICpdcTXQ+YMAAXLt2DQAwdepUrFixAoaGhhg3bhy+/vrrfA2QiNRjXyTKm+XLl6NHjx4APvShiRMn4tmzZ+jUqRPWrFmj5eiIioavv/4aR48elT6DVq9ejcDAQDg6Oio8EY+IiIgos1xdKZXx8upGjRrh9u3buHTpEtzc3FCtWrV8C46Issa+SJR7qamp2Lt3L1q0aAEA0NHRwaRJkzBp0iQtR0ZUtHB+QyIiIsqtXA1KZebs7AxnZ+f8KIqI8oB9kUhzenp6GD58OG7fvq3tUIiKNM5vSERERLmVq9v3AODIkSNo27Yt3NzcUL58ebRt2xaHDx/Oc0AuU/bBZcq+PJdDVFx8rL5IVBzUqVMHV65c0XYYREWafH5DANL8hgA4vyERERFlK1eDUsuXL0fLli1hbm6OsWPHYsyYMbCwsEDr1q2xfPny/I6RiNRgXyTKmxEjRmDChAlYvnw5zp49i+vXryv8EVH2OL8hERER5Vaubt8LCgrCkiVLMGrUKCltzJgxqFu3Lr777juFdCL6eNgXifJG/nj5MWPGSGkymQxCCMhkMo2eGkZU3GWe3/Cff/7BxYsXOb8hERERZStXg1Lx8fFo2bKlUnrz5s0xefLkPAdFRJphXyTKm4cPH2o7BKIiLSUlBc2bN8fPP/+MChUqAADKli2LsmXLajkyIiIiKgpydfte+/btsXPnTqX03bt3o127dnkOiog0w75IlDfyhwOo+yOirOnr6+PmzZuQyWTaDoWIiIiKII2vlPrxxx+l/1euXBnfffcdjh07Bm9vbwDAuXPncPr0aUyYMCH/oyQiCfsiUf5Zv359lsv79etXQJEQFV39+vXDmjVrMG/ePG2HQkREREWMxoNSS5YsUXhtbW2N8PBwhIeHS2lWVlZYu3Ytvvnmm/yLkIgUsC8S5Z+xY8cqvE5JScG7d+9gYGAAExMTDkoRaeD9+/dYvXo1Dh06hM8++wympqYKyxcvXqylyIiIiKiw03hQivNuEBUO2uiLLlP2KaVFzGtT4HEQ5beXL18qpd29exfDhw/nU8OINHTz5k3UrFkTAHDnzh2FZbytj4iIiLKSq4nOMxJCAOBJB5G2sS8S5Q93d3fMmzcPffr0wT///KPtcIgKvdDQUG2HQEREREVUriY6Bz7Mw+Hp6QljY2MYGxvDy8sLGzZsyM/YiEgD7ItE+U9XVxdPnz7VdhhERcq9e/dw4MABJCYmAvjfjyVERERE6uTqSqnFixdjxowZGDVqFOrWrQshBE6fPo1hw4bhxYsXGDduXH7HSUQqsC8S5c2ePXsUXgshEBUVheXLl6Nu3bpaioqoaImNjUW3bt0QGhoKmUyGu3fvoly5chg8eDCsrKywaNEibYdIREREhVSuBqWWLVuGlStXKkwA26FDB1SpUgUBAQH8IkxUQNgXifLmyy+/VHgtk8lQsmRJNG7cmF+kiTQ0btw46OvrIzIyEpUrV5bSu3fvjnHjxrEvERERkVq5GpSKioqCj4+PUrqPjw+ioqLyHBQRaYZ9kShv0tPTtR0CUZF38OBBHDhwAGXKlFFId3d3x6NHj7QUFeWaXh8gdaO2o6DMUgMyvCifh4JsAMTlYr17/79uQctLXSln8uv9zW052ti/NJV5P+wN4HyG1/fUrKdJX8tuH7+nQZ7cbENdzEDujhOZyysPIFGjNXM1KFW+fHls27YN06ZNU0jfunUr3N3dc1MkEeUC+yJRzo0fP17jvHyUPVH2EhISYGJiopT+4sULGBoaaiEiIiIiKipyNSgVGBiI7t2748SJE6hbty5kMhlOnTqFI0eOYNu2bfkdIxGpwb5IlHNXrlxReH3p0iWkpaWhYsWKAD480l5XVxe1atXSRnhERU6DBg2wfv16zJ49G8CH22DT09OxcOFCNGrUSMvRERERUWGWq0Gpzp0748KFC1i8eDF27doFIQQ8PDxw4cIF1KhRI79jJCI12BeJci7j4+sXL14Mc3NzrFu3DtbW1gCAly9fYsCAAahfv762QiQqUhYuXIiGDRvi4sWLeP/+PSZNmoRbt24hLi4Op0+f1nZ4REREVIjleFAqJSUFQ4YMwYwZM7BxI+83J9IW9kWivFu0aBEOHjwoDUgBgLW1NebMmYPmzZtjwoQJWoyOqGjw8PDA9evXsXLlSujq6iIhIQGdOnXCyJEjUapUKW2HR0RERIVYjgel9PX1sXPnTsyYMeNjxENEGtJ2X3SZsk8pLWJeGy1EQpR78fHxePbsGapUqaKQHhMTgzdv3mgpKqKiJTIyEk5OTggMDFS5rGzZslqIioiIiIoCndys1LFjR+zatSufQyGinGJfJMqbjh07YsCAAfj999/x5MkTPHnyBL///jsGDRqETp06aTs8oiLB1dUVz58/V0qPjY2Fq6urFiIiIiKioiLXT9+bPXs2zpw5g1q1asHU1FRh+ZgxY/IlOCLKGvsiUd6sWrUKEydORJ8+fZCSkgIA0NPTw6BBg7Bw4UItR0dUNAghIJPJlNLfvn0LIyMjLURERERERUWuBqVWr14NKysrXLp0CZcuXVJYJpPJ+EWYqICwLxLljYmJCVasWIGFCxfi/v37EEKgfPnySgO8RKRs/PjxAD583syYMQMmJibSsrS0NJw/fx7Vq1fXUnRERERUFORqUOrhw4fS/4UQAKDyFzIi+rjYF4nyh6mpKby8vLQdBlGRcuXKFQAfPn9u3LgBAwMDaZmBgQGqVauGiRMnais8IiIiKgJyNSgFAGvWrMGSJUtw9+5dAIC7uzv8/f0xePDgfAuOiLLHvkhERNoQGhoKABgwYAB+/PFHmJubazkiIiIiKmpyNSg1Y8YMLFmyBKNHj4a3tzcA4OzZsxg3bhwiIiIwZ86cfA2SiFRjXyQiIm3J+DAAPz8/tfl27NhREOEQERFREZSrQamVK1fi119/Rc+ePaW09u3bw8vLC6NHj+YXYaICwr5IRETaYmlpqe0QiIiIqIjL1aBUWloaPvvsM6X0WrVqITU1Nc9BEZFmCltfdJmyT+F1xLw2BR4DEREVjODgYG2HQEREREWcTm5W6tOnD1auXKmU/ssvv6B37955DoqINMO+SFR4rFixAq6urjAyMkKtWrVw8uRJbYdERERERFSo5Wmi84MHD+KLL74AAJw7dw6PHz9Gv379pEcEA8DixYvzHiURqcW+SKR9W7duhb+/P1asWIG6devi559/RqtWrRAeHo6yZctqOzwiIiIiokIpV4NSN2/eRM2aNQEA9+/fBwCULFkSJUuWxM2bN6V8fDQ90cdV2Pti5tv5AN7SR5+mxYsXY9CgQdJTL5cuXYoDBw5g5cqVCAoK0nJ0RIXfsmXLMGfOHLx48QLp6emYMmWKQt8pX7689DknZ2pqirdv30qv4+PjUa9ePdy8eRNCCNjb22Pv3r34/PPPC6weRERElDO5GpSSPwKYiLSLfZFI+96/f49Lly5hypQpCunNmzfHmTNnVK6TnJyM5ORk6XV8fPxHjZGosHv58iXc3d3h5+eHhQsXqsxTokQJHDlyRHptamqqsNzb2xv//PMP5s2bBycnJ4wYMQINGjTA69evYWBg8FHjJyIiotzJ1ZxSRERE9MGLFy+QlpYGe3t7hXR7e3tER0erXCcoKAiWlpbSn5OTU0GESlRoffvttzh16hQWLFigNo+enh68vLykPzc3N2lZZGQkwsPDMWrUKEyaNAk9e/bEkSNHkJSUpHaQi4iIiLSPg1JERET5IPNtskIItbfOTp06Fa9fv5b+Hj9+XBAhEhVp0dHR0NHRgYGBASpVqoRbt25Jy7Zv3w4A8Pf3l9Jq1qwJIyMjHDx4sKBDJSIiIg3leqJzIiIi+nBLka6urtJVUTExMUpXT8kZGhrC0NCwIMIj+iS0adMG1tbWqFatGi5fvozvv/8etWrVQkxMDCwsLPDgwQMAgKurq8J6JiYmiImJUVtufHy8wu2zb968+TgVICIiIpU4KEVERJQHBgYGqFWrFg4dOoSOHTtK6YcOHUKHDh20GBnRp+OHH36Q/t+xY0d07twZNWrUwJw5c7K85Q/I+mEf7du3x/Hjx/MtTiIiIsqZQjsoJX9qF5/URUREhd348ePRt29ffPbZZ/D29sYvv/yCyMhIDBs2TNuhEX2SqlevDn19fdy4cQMAUK5cOQDAw4cPFa6WevfuHUqWLKm2nD179ihdKeXh4fGRoiYiIqLMCu2gFBF9muQDzhlx8JmKuu7duyM2NhazZs1CVFQUqlatir/++gvOzs7aDo3ok3T37l2kpKRIDwno2rUrJk6ciB9//BFLliwBAFy9ehVJSUlo3ry52nIsLCxgYWEhveaTMImIiAoWB6WIiIjywYgRIzBixAhth0FUJEVHRyvcRnf79m1s3boVZcuWhaurK9q2bYshQ4bAw8MDFy9exIwZM6Cjo4OAgAAAQNmyZeHh4YFly5bB0dERZcqUwciRI2FkZISvv/5aS7UiIiKi7HBQioi0jldPEREVb1u2bMG4ceOk17t378bu3bvh5uaGCxcuICIiAsOGDYMQArq6unBxccFvv/0GR0dHaZ3Tp0+jQYMGmDx5MoQQsLOzw99//w0DAwNtVImIiIg0wEEpIiIiItIqf39/+Pv7q13+4sWLbMuwsrLC9evX8zEqIiIi+tgK/aBU5isoePUEEREREREREVHRp6PtAIiIiIiIiIiIqPjhoBQRERERERERERU4DkoREREREREREVGBK/RzShFR8cT55IiIiIiIiD5tHJQioiIh8yAVwIEqIiIiIiKioqzI3b6n6ospEREREREREREVLbxSioiKLF49RUREREREVHQVyUEpzjVDROpwoIqIiIiIiKhoKJKDUpmpu6WPX0SJCNDstl8eL4iIiIiIiArWJzEoRUSUV5rOV5d58IpXZhEREREREeXOJz0oxS+LRJTf+LAFIiIiIiKi/PFJD0qpkturIYiI8iK3c+FpMrjO4xoRERERERVFxW5QSlOF/WoIfrkkKrw0OX7k5RiT23Xzc4BLFR6XiIiIiIgoJ7QyKCWEAACkJ7/TxuY/CWXHbdd2CIXezcAWAID4+HgA/9vv6H/YF0neP+Tysi9kd1ySl82+qEzeJpnfD6KPgZ+L6v2vTRL/PyGvfTIxj+sXEKV6FpG4i5XkDP9X8f4kxwNIykVZ6ok38f+fN/H//9W0/Oy2k1U5mddRtS8maZhPExnLUVWuqm2rLuNNvFB4nXMqyk6VvwdJAN5l+FddLOolA0iPf/vhxXtN9xdN6pLT/eKNmnLVlROfYXnm9ysjdbEmZrNcXf6M5WZOe5spLafvuTx2VWWrKiun+7cm/SM507Kc9oXsJEplZ3e+IRNaOCN58uQJnJycCnqzVMw9fvwYZcqU0XYYhQr7ImkD+6Iy9kXSBvZFZeyLRERE+Su78w2tDEqlp6fj33//hYeHBx4/fgwLC4uCDqFYio+Ph5OTU7FrcyEE3rx5A0dHR+jo6Gg7nEIlPT0dT58+hbm5OWQymbbDydansA8X9TrkJX72RfWy6otFfZ/RBOtYsNgX1eM5au4Vpn28KGG75Q7bLXfYbrnDdssdTc83tHL7no6ODkqXLg0AsLCw4BtbwIpjm1taWmo7hEJJR0enSP5K/insw0W9DrmNn31RNU36YlHfZzTBOhYc9kXVeI6ad2y33GG75Q7bLXfYbrnDdss5Tc43+PMYEREREREREREVOA5KERERERERERFRgdPaoJShoSFmzpwJQ0NDbYVQ7LDNqaj7FPbhol6Hoh5/UVQc2px1pMKE71XusN1yh+2WO2y33GG75Q7b7ePSykTnRERERERERERUvPH2PSIiIiIiIiIiKnAclCIiIiIiIiIiogLHQSkiIiIiIiIiIipwWhuUWrFiBVxdXWFkZIRatWrh5MmT2grlkxMQEACZTKbw5+DgIC0XQiAgIACOjo4wNjZGw4YNcevWLS1GTPQ/J06cQLt27eDo6AiZTIZdu3YpLC8K+29QUBA+//xzmJubw87ODl9++SX+/fdfhTyFvR4rV66El5cXLCwsYGFhAW9vb/z999/S8sIef2GXH/t5cnIyRo8ejRIlSsDU1BTt27fHkydPCrAWWcuqjikpKZg8eTI8PT1hamoKR0dH9OvXD0+fPlUooyjXMbOhQ4dCJpNh6dKlCumFvY7FDc9PFRWHY1V+y69zgOLWbkD+nHsUx3bLKCgoCDKZDP7+/lIa2021/PjOXBzb7WPQyqDU1q1b4e/vj+nTp+PKlSuoX78+WrVqhcjISG2E80mqUqUKoqKipL8bN25IyxYsWIDFixdj+fLlCAsLg4ODA5o1a4Y3b95oMWKiDxISElCtWjUsX75c5fKisP8eP34cI0eOxLlz53Do0CGkpqaiefPmSEhIkPIU9nqUKVMG8+bNw8WLF3Hx4kU0btwYHTp0kD6MC3v8hV1+7Of+/v7YuXMntmzZglOnTuHt27do27Yt0tLSCqoaWcqqju/evcPly5cxY8YMXL58GTt27MCdO3fQvn17hXxFuY4Z7dq1C+fPn4ejo6PSssJex+KE56fKisOxKr/l1zlAcWs3IH/OPYpju8mFhYXhl19+gZeXl0I62029vH5nLq7tlu+EFtSuXVsMGzZMIa1SpUpiypQp2gjnkzNz5kxRrVo1lcvS09OFg4ODmDdvnpSWlJQkLC0txapVqwooQiLNABA7d+6UXhfV/TcmJkYAEMePHxdCFN16WFtbi9WrVxfZ+Aur3Oznr169Evr6+mLLli1Snv/++0/o6OiI/fv3F1jsmspcR1UuXLggAIhHjx4JIT6dOj558kSULl1a3Lx5Uzg7O4slS5ZIy4paHT91PD/NWnE4Vn0MuTkHYLv9T07OPYpzu71580a4u7uLQ4cOCV9fXzF27FghBPe3rOT1O3NxbbePocCvlHr//j0uXbqE5s2bK6Q3b94cZ86cKehwPll3796Fo6MjXF1d0aNHDzx48AAA8PDhQ0RHRyu0v6GhIXx9fdn+VOgV1f339evXAAAbGxsARa8eaWlp2LJlCxISEuDt7V3k4i9qNGnfS5cuISUlRSGPo6MjqlatWmTfg9evX0Mmk8HKygrAp1HH9PR09O3bF19//TWqVKmitPxTqOOnguenOVdcj1U5lZtzALZb7s49inO7jRw5Em3atEHTpk0V0tluWcvLd+bi3G75rcAHpV68eIG0tDTY29srpNvb2yM6Orqgw/kk1alTB+vXr8eBAwfw66+/Ijo6Gj4+PoiNjZXamO1PRVFR3H+FEBg/fjzq1auHqlWrAig69bhx4wbMzMxgaGiIYcOGYefOnfDw8Cgy8RdVmrRvdHQ0DAwMYG1trTZPUZKUlIQpU6agV69esLCwAPBp1HH+/PnQ09PDmDFjVC7/FOr4qeD5ac4Vx2NVTuX2HKA4t1tezj2Ka7tt2bIFly9fRlBQkNIytpt6ef3OXFzb7WPQ09aGZTKZwmshhFIa5U6rVq2k/3t6esLb2xtubm5Yt24dvvjiCwBsfyraitL+O2rUKFy/fh2nTp1SWlbY61GxYkVcvXoVr169wh9//AE/Pz8cP35cWl7Y4y/qctO+RfE9SElJQY8ePZCeno4VK1Zkm7+o1PHSpUv44YcfcPny5RzHW1Tq+CnicS3nisuxKjfy+xygOLTbxzj3+JTb7fHjxxg7diwOHjwIIyMjtfnYbso+1nfmT73dPoYCv1KqRIkS0NXVVRo9jImJURqJpPxhamoKT09P3L17V3qiANufiqKitv+OHj0ae/bsQWhoKMqUKSOlF5V6GBgYoHz58vjss88QFBSEatWq4Ycffigy8RdVmrSvg4MD3r9/j5cvX6rNUxSkpKSgW7duePjwIQ4dOiRdJQUU/TqePHkSMTExKFu2LPT09KCnp4dHjx5hwoQJcHFxAVD06/gp4flpzhWnY1Vu5OUcoDi3W17OPYpju126dAkxMTGoVauW9Flz/Phx/Pjjj9DT05PqzXbLXk6/M7Pd8k+BD0oZGBigVq1aOHTokEL6oUOH4OPjU9DhFAvJycm4ffs2SpUqBVdXVzg4OCi0//v373H8+HG2PxV6RWX/FUJg1KhR2LFjB44ePQpXV1eF5UWlHpkJIZCcnFxk4y8qNGnfWrVqQV9fXyFPVFQUbt68WWTeA/mA1N27d3H48GHY2toqLC/qdezbty+uX7+Oq1evSn+Ojo74+uuvceDAAQBFv46fEp6f5lxxOVblVH6cAxTHdlMnJ+cexbHdmjRpghs3bih81nz22Wfo3bs3rl69inLlyrHdNJTT78xst3xUUDOqZ7Rlyxahr68v1qxZI8LDw4W/v78wNTUVERER2gjnkzNhwgRx7Ngx8eDBA3Hu3DnRtm1bYW5uLrXvvHnzhKWlpdixY4e4ceOG6NmzpyhVqpSIj4/XcuREH54ecuXKFXHlyhUBQCxevFhcuXJFeiJXUdh/hw8fLiwtLcWxY8dEVFSU9Pfu3TspT2Gvx9SpU8WJEyfEw4cPxfXr18W0adOEjo6OOHjwoBCi8Mdf2OXHfj5s2DBRpkwZcfjwYXH58mXRuHFjUa1aNZGamqqtainIqo4pKSmiffv2okyZMuLq1asK/SQ5OVkqoyjXUZXMT98TovDXsTjh+amy4nCsym/5dQ5Q3NpNiPw59yiO7ZZZxqfvCcF2Uyc/vjMXx3b7GLQyKCWEED/99JNwdnYWBgYGombNmtJjUinvunfvLkqVKiX09fWFo6Oj6NSpk7h165a0PD09XcycOVM4ODgIQ0ND0aBBA3Hjxg0tRkz0P6GhoQKA0p+fn58Qomjsv6riByCCg4OlPIW9HgMHDpSO0SVLlhRNmjSRTgqFKPzxF3b5sZ8nJiaKUaNGCRsbG2FsbCzatm0rIiMjtVAb1bKq48OHD9X2k9DQUKmMolxHVVQNShX2OhY3PD9VVByOVfktv84Bilu7CZE/5x7Fsd0yyzwoxXZTLT++MxfHdvsYZEIIkf/XXxEREREREREREalX4HNKERERERERERERcVCKiIiIiIiIiIgKHAeliIiIiIiIiIiowHFQioiIiIiIiIiIChwHpYiIiIiIiIiIqMBxUIqIiIiIiIiIiAocB6WIiIiIiIiIiKjAcVCKiIiIiIiIiIgKHAel8iAkJARWVlbS64CAAFSvXj1HZchkMuzatUvt8oiICMhkMly9ejVXMX5sx44dg0wmw6tXr7QdCuWTorxfZ45dG1xcXLB06dIC2Vbfvn0xd+5c6fW7d+/QuXNnWFhYFMl++eeff6JGjRpIT0/XdiiUBw0bNoS/v7+2w1CQ3TGJiIiIiLSDg1JERLmgbgAsLCwMQ4YM+ejbv379Ovbt24fRo0dLaevWrcPJkydx5swZREVFwdLS8qPHkZ/atm0LmUyGTZs2aTsUyoMdO3Zg9uzZAAp2kBZQP4geFRWFVq1aFVgcRESfgtz8MJmfZsyYoXBOJYTAkCFDYGNjU6h/tFfnxo0bKFOmDBISErQdClGhwkGpYigtLY1XIhCp8f79+zytX7JkSZiYmORTNOotX74cXbt2hbm5uZR2//59VK5cGVWrVoWDgwNkMpnSenmt38c2YMAALFu2TNthUB7Y2Ngo7Jf5Ia/7rYODAwwNDfMpGiKiok8mk2X5179/f0ycOBFHjhzRSnzPnj3DDz/8gGnTpklp+/fvR0hICP78809ERUWhatWqWokttzw9PVG7dm0sWbJE26EQFSrFflDq999/h6enJ4yNjWFra4umTZsiISEBJ06cgL6+PqKjoxXyT5gwAQ0aNNCo7LCwMDRr1gwlSpSApaUlfH19cfnyZaV88l9wjY2N4erqiu3bt2dZbnh4OFq3bg0zMzPY29ujb9++ePHihdr88is6/vzzT3h4eMDQ0BCPHj3SKD6ZTIbVq1ejY8eOMDExgbu7O/bs2aN2W4mJiWjTpg2++OILxMXFZdNC9LEUh/0a+LBvly1bFiYmJujYsSNiY2MVlvfv3x9ffvmlQpq/vz8aNmwovW7YsCFGjRqF8ePHo0SJEmjWrBkAYPHixfD09ISpqSmcnJwwYsQIvH37FsCH21YHDBiA169fSydvAQEBAJSvDImMjESHDh1gZmYGCwsLdOvWDc+ePZOWy3+F3LBhA1xcXGBpaYkePXrgzZs3auudnp6O7du3o3379gr1WLRoEU6cOAGZTCbV0cXFBXPmzEH//v1haWmJr776CgAwefJkVKhQASYmJihXrhxmzJiBlJQUpbjWrl2LsmXLwszMDMOHD0daWhoWLFgABwcH2NnZ4bvvvlOI7fXr1xgyZAjs7OxgYWGBxo0b49q1a9Lya9euoVGjRjA3N4eFhQVq1aqFixcvSsvbt2+PCxcu4MGDB2rrT4Wb/Pa9hg0b4tGjRxg3bpzUT+TOnDmDBg0awNjYGE5OThgzZozCL8e52W9DQkIQGBiIa9euSdsLCQkBoHz73o0bN9C4cWPpGDlkyBCpfwP/O3Z8//33KFWqFGxtbTFy5EiFPkJEVJRFRUVJf0uXLoWFhYVC2g8//AAzMzPY2tpqJb41a9bA29sbLi4uUtr9+/dRqlQp+Pj4wMHBAXp6ekrrFYUf31auXIm0tDRth0JUaBTrQamoqCj07NkTAwcOxO3bt3Hs2DF06tQJQgg0aNAA5cqVw4YNG6T8qamp2LhxIwYMGKBR+W/evIGfnx9OnjyJc+fOwd3dHa1bt1b6sjljxgx07twZ165dQ58+fdCzZ0/cvn1bbcy+vr6oXr06Ll68iP379+PZs2fo1q1blrG8e/cOQUFBWL16NW7dugU7OzuN4wsMDES3bt1w/fp1tG7dGr1791Y54PT69Ws0b94c79+/x5EjR2BjY6NRO1H+Ki779fnz5zFw4ECMGDECV69eRaNGjTBnzhyN6pDZunXroKenh9OnT+Pnn38GAOjo6ODHH3/EzZs3sW7dOhw9ehSTJk0CAPj4+CidwE2cOFGpXCEEvvzyS8TFxeH48eM4dOgQ7t+/j+7duyvku3//Pnbt2oU///wTf/75J44fP4558+apjff69et49eoVPvvsMyltx44d+Oqrr+Dt7Y2oqCjs2LFDWrZw4UJUrVoVly5dwowZMwAA5ubmCAkJQXh4OH744Qf8+uuvSr/c3b9/H3///Tf279+PzZs3Y+3atWjTpg2ePHmC48ePY/78+fjmm29w7tw5qb5t2rRBdHQ0/vrrL1y6dAk1a9ZEkyZNpGNG7969UaZMGYSFheHSpUuYMmUK9PX1pW06OzvDzs4OJ0+ezP6No0Jtx44dKFOmDGbNmiX1E+DDgFCLFi3QqVMnXL9+HVu3bsWpU6cwatQohfVzut92794dEyZMQJUqVaTtZe5rwIfPw5YtW8La2hphYWHYvn07Dh8+rLT90NBQ3L9/H6GhoVi3bh1CQkKkQS4ioqLOwcFB+rO0tIRMJlNKy3z7nnzAfu7cubC3t4eVlRUCAwORmpqKr7/+GjY2NihTpgzWrl2rsK3//vsP3bt3h7W1NWxtbdGhQwdERERkGd+WLVsUfnzr378/Ro8ejcjISMhkMmmwKjc/LgKKP9pXrFgRJiYm6NKlCxISErBu3Tq4uLjA2toao0ePVhhAev/+PSZNmoTSpUvD1NQUderUwbFjx6Tljx49Qrt27WBtbQ1TU1NUqVIFf/31l7S8RYsWiI2NxfHjxzV9q4g+faIYu3TpkgAgIiIiVC6fP3++qFy5svR6165dwszMTLx9+1YIIURwcLCwtLSUls+cOVNUq1ZN7fZSU1OFubm52Lt3r5QGQAwbNkwhX506dcTw4cOFEEI8fPhQABBXrlwRQggxY8YM0bx5c4X8jx8/FgDEv//+q3K7wcHBAoC4evWq2tiyiu+bb76RXr99+1bIZDLx999/CyGECA0NFQDEP//8I6pVqyY6deokkpOTs9wOfVzFZb/u2bOnaNmypUJa9+7dFWL38/MTHTp0UMgzduxY4evrK7329fUV1atXV1s/uW3btglbW1vpdeZ2knN2dhZLliwRQghx8OBBoaurKyIjI6Xlt27dEgDEhQsXhBAf2tfExETEx8dLeb7++mtRp04dtbHs3LlT6OrqivT09CzrJo/nyy+/zLZ+CxYsELVq1ZJeq4qrRYsWwsXFRaSlpUlpFStWFEFBQUIIIY4cOSIsLCxEUlKSQtlubm7i559/FkIIYW5uLkJCQrKMpUaNGiIgICDbmKlw8vX1FWPHjhVCKPYHub59+4ohQ4YopJ08eVLo6OiIxMREab3c7reqjlcAxM6dO4UQQvzyyy/C2tpaOuYJIcS+ffuEjo6OiI6OFkJ8OHY4OzuL1NRUKU/Xrl1F9+7ds42JiKioUXdOk/mY6ufnJ8zNzcXIkSPFP//8I9asWSMAiBYtWojvvvtO3LlzR8yePVvo6+tL5z4JCQnC3d1dDBw4UFy/fl2Eh4eLXr16iYoVK6r9zhAXFydkMpk4d+6clPbq1Ssxa9YsUaZMGREVFSViYmKEEB8+c8zMzMTXX38t/vnnH3H79m0hhBBLliwRR48eFQ8ePBBHjhwRFStWlM5D5XXW19cXzZo1E5cvXxbHjx8Xtra2onnz5qJbt27i1q1bYu/evcLAwEBs2bJFWq9Xr17Cx8dHnDhxQty7d08sXLhQGBoaijt37gghhGjTpo1o1qyZuH79urh//77Yu3evOH78uEL9ateuzfMcogyK9ZVS1apVQ5MmTeDp6YmuXbvi119/xcuXL6Xl/fv3x71796SrANauXYtu3brB1NRUo/JjYmIwbNgwVKhQAZaWlrC0tMTbt28RGRmpkM/b21vptborSi5duoTQ0FCYmZlJf5UqVQLw4aoGdQwMDODl5ZWr+DKuZ2pqCnNzc8TExCjkadq0KcqVK4dt27bBwMBAbRz08RWX/fr27dsqt5EbGa84kgsNDUWzZs1QunRpmJubo1+/foiNjc3R5JS3b9+Gk5MTnJycpDQPDw9YWVkptIWLi4vCHDylSpVS6mMZJSYmwtDQUOWcUaqoqt/vv/+OevXqwcHBAWZmZpgxY4bSe5g5Lnt7e3h4eEBHR0chTR7rpUuX8PbtW9ja2iq8lw8fPpTex/Hjx2Pw4MFo2rQp5s2bp/L9NTY2xrt37zSqGxU9ly5dQkhIiMI+0qJFC6Snp+Phw4dSvtzut9m5ffs2qlWrpnDMq1u3LtLT0/Hvv/9KaVWqVIGurq70Ort+SURUHNjY2ODHH39ExYoVMXDgQFSsWBHv3r3DtGnT4O7ujqlTp8LAwACnT58G8OGKJx0dHaxevRqenp6oXLkygoODERkZqXCFUUaPHj2CEAKOjo5SmqWlJczNzaGrqwsHBweULFlSWla+fHksWLAAFStWlM4f/f390ahRI7i6uqJx48aYPXs2tm3bprCdlJQUrFy5EjVq1ECDBg3QpUsXnDp1CmvWrIGHhwfatm2LRo0aITQ0FMCHc9LNmzdj+/btqF+/Ptzc3DBx4kTUq1cPwcHBAD5M21C3bl14enqiXLlyaNu2rdIUGaVLl872SjGi4kT5RtxiRFdXF4cOHcKZM2dw8OBBLFu2DNOnT8f58+fh6uoKOzs7tGvXDsHBwShXrhz++usvtQdPVfr374/nz59j6dKlcHZ2hqGhIby9vTW611ndl8309HS0a9cO8+fPV1pWqlQpteUZGxsrlalpfBlvrZHHlnmi9DZt2uCPP/5AeHg4PD09s6wbfVzFZb8WQmS7PR0dHaV8quaEyTwg9+jRI7Ru3RrDhg3D7NmzYWNjg1OnTmHQoEE5mlNGCKGyzpnTNeljGZUoUQLv3r3D+/fvNRoEzly/c+fOoUePHggMDESLFi1gaWmJLVu2YNGiRQr5VMWVVazp6ekoVaqUyv1J/qTCgIAA9OrVC/v27cPff/+NmTNnYsuWLejYsaOUNy4uTuFkkz4t6enpGDp0KMaMGaO0rGzZstL/c7vfZkddvwSQp35JRFQcVKlSRenHqYwTjuvq6sLW1lbhB6t79+4pPQAjKSlJ7Q+PiYmJAAAjIyONYlL34+LcuXMRHh6O+Ph4pKamIikpCQkJCdLni4mJCdzc3BTq4uLiAjMzM4U0eV0uX74MIQQqVKigsK3k5GRp7q0xY8Zg+PDhOHjwIJo2bYrOnTsrXRjAH9+IFBXrQSngw0lm3bp1UbduXXz77bdwdnbGzp07MX78eADA4MGD0aNHD5QpUwZubm6oW7euxmWfPHkSK1asQOvWrQEAjx8/Vjlx87lz59CvXz+F1zVq1FBZZs2aNfHHH3/AxcVF5eR+OaFpfJqYN28ezMzM0KRJExw7dgweHh55io3ypjjs1x4eHtLVXhm3kVHJkiVx8+ZNhbSrV68qfdnM7OLFi0hNTcWiRYukE6/Mv64ZGBhkO0mlh4cHIiMj8fjxY+lqqfDwcLx+/RqVK1fOct2syOd3CA8Pz9Wjmk+fPg1nZ2dMnz5dSnv06FGu45GrWbMmoqOjoaenpzAxaWYVKlRAhQoVMG7cOPTs2RPBwcHSoJT8JFXdvkJFi6p+UrNmTdy6dQvly5fPUVma7Lea9st169YpfDE5ffo0dHR0lL5oEBGRotz8YFWrVi389ttvSmWp+wGqRIkSAICXL19q9CNVbn9czE1ddHV1cenSJYUraQFIA1mDBw9GixYtsG/fPhw8eBBBQUFYtGgRRo8eLeWNi4tTGAwjKu6K9e1758+fx9y5c3Hx4kVERkZix44deP78ucKXRfmvsXPmzNF4Imi58uXLY8OGDbh9+zbOnz+P3r17w9jYWCnf9u3bsXbtWty5cwczZ87EhQsXlCZclRs5ciTi4uLQs2dP6QlVBw8exMCBA3P8FAdN49PU999/j969e6Nx48b4559/cl0O5U1x2a/HjBmD/fv3Y8GCBbhz5w6WL1+O/fv3K+Rp3LgxLl68iPXr1+Pu3buYOXOm0iCVKm5ubkhNTcWyZcvw4MEDbNiwAatWrVLI4+Ligrdv3+LIkSN48eKFyl+8mjZtCi8vL/Tu3RuXL1/GhQsX0K9fP/j6+qr8VU9TJUuWRM2aNXHq1KlcrV++fHlERkZiy5YtuH//Pn788Ufs3Lkz1/HINW3aFN7e3vjyyy9x4MABRERE4MyZM/jmm29w8eJFJCYmYtSoUTh27BgePXqE06dPIywsTGHfPHfunHT1HRV9Li4uOHHiBP777z9p8Hry5Mk4e/YsRo4ciatXr+Lu3bvYs2ePwgm7Kprsty4uLnj48CGuXr2KFy9eIDk5Wamc3r17w8jICH5+frh58yZCQ0MxevRo9O3bF/b29vlXeSIiQs2aNXH37l3Y2dmhfPnyCn+WlpYq13Fzc4OFhQXCw8Nztc2MPy5+8cUXqFChAp4+fZqXagAAatSogbS0NMTExCjVxcHBQcrn5OSEYcOGYceOHZgwYQJ+/fVXhXJu3rzJH9+IMijWg1IWFhY4ceIEWrdujQoVKuCbb77BokWL0KpVKymPjo4O+vfvj7S0NIWrPjSxdu1avHz5EjVq1EDfvn0xZswY2NnZKeULDAzE/7V3PyFN/3Ecx18qMdxFEkf/oKLhTjLmYTACh6axOqwhihZjO4i6DoPppVMKdjDmwR3y2EVhrC5Bl2gdihF62EBwR4O2QyFIGdohFOTzO/xI0rQsx76Vz8f5+/3s9YHP6f3+7vN+9OiR3G63ZmdnlU6nD/zS6OzZs5qfn9f29rYCgYBaWlqUSCTU0NCw61PaSub7FalUSn19fbpy5YqWl5ePtBZ+z3E51z6fTw8fPtSDBw/k8Xj04sUL3b17d9czgUBAY2NjunPnjrxerz5//nyo/Xo8Hk1PTyuZTKqlpUXpdFr379/f9czly5d1+/Zt9ff3y+FwaGpq6rt1vo6hP3nypPx+/87da48fP/5php8ZHh7et+t4GKFQSKOjo4rH4/J4PFpYWNiZbnYUNTU1evbsmfx+vwYGBuRyuXTz5k2Vy2WdOnVKdXV1+vjxo6LRqFwul/r6+nT9+nVNTEzsrJHJZBQOh2W324+cB9a7d++eyuWynE7nTrfb7XYrl8vpzZs3amtrU2trq8bGxn74F3TpcOe2p6dH165dU0dHhxwOhzKZzHfr2O12ZbNZra2tyev1qre3V52dnZqZmancxgEAkv5vBDQ1NSkUCun169cqlUrK5XJKJBJ69+7dvu/U1taqq6vrt5tvh2ku/g6Xy6VwOKxoNKonT56oVCqpUCgomUzuTNgbGRlRNptVqVTS4uKiXr58uav5Vi6X9f79e3V1dR05D/DPsPCS9b/G4OCgCQaDVscAKopz/Xf78uWLOX/+vFlYWLA6SsWsrq6axsZG8/btW6ujAABwbPzK9L29U42/nbj61d7JqysrKyYajZqmpiZjs9nMpUuXzNDQkFlfXz8w0/Pnz825c+d2TfxNpVLmwoULP/19Y4yZnp42Z86cMfX19SYQCJi5uTkjyXz69OnAPe83wXXvnre2tsz4+Li5ePGiOXHihDl9+rTp7u42xWLRGGNMPB43TqfT2Gw243A4TCQSMR8+fNh5f3Jy0gQCgQP3DRxHNcYc4rbgY2p9fV2FQkE3btzQ06dPdfXqVasjAUfGuf535HI5bWxsKBgMWh2lIvL5vEqlkvr7+62OAgAALGSMkc/n08jIiG7dumV1nIrY3NxUc3OzMpnML93nCvzrKEr9QHt7u/L5vGKxmFKplNVxgIrgXAMAAOBPt7S0pGKxqEgkYnWUilheXtarV68Ui8WsjgL8UShKAQAAAAAAoOqO9UXnAAAAAAAAsAZFKQAAAAAAAFQdRSkAAAAAAABUHUUpAAAAAAAAVB1FKQAAAAAAAFQdRSkAAAAAAABUHUUpAAAAAAAAVB1FKQAAAAAAAFQdRSkAAAAAAABU3X8JHohoU9o6dgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -2063,12 +2039,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 74%|█████████████████████████▏ | 75/101 [08:57<02:55, 6.76s/it]" + " 74%|█████████████████████████▏ | 75/101 [01:44<00:35, 1.35s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2080,12 +2056,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 99%|████████████████████████████████▋| 100/101 [12:00<00:08, 8.04s/it]" + " 99%|████████████████████████████████▋| 100/101 [02:18<00:01, 1.36s/it]" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAD6CAYAAABwKvR6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACRw0lEQVR4nOzdd1gURx8H8O/Re5emCKjYsUcDqGDvvVfsvWuMJSqYRCyxJBo1iV1jTdRoTOzYO3YxxqhYIoqiAqJS5/3D9zYsdwd3cIDl+3keHr3Z2Z3fzu7s7c7t7CqEEAJERERERERERET5yKCgAyAiIiIiIiIioo8PO6WIiIiIiIiIiCjfsVOKiIiIiIiIiIjyHTuliIiIiIiIiIgo37FTioiIiIiIiIiI8h07pYiIiIiIiIiIKN+xU4qIiIiIiIiIiPIdO6WIiIiIiIiIiCjfsVOKiIiIiIiIiIjyHTuliIg+MMuWLYNCoYCVlZXKtF69ekGhUKj8lS5dWiWvunwKhQIzZ86U5du6dSu6dOmCEiVKwNzcHF5eXujWrRtu3rwpyxcfH4+vv/4aQUFBcHV1hZWVFXx9fTFr1iy8efNGljckJERj+QqFAhs3bpTybtiwAbVr14aLiwtMTU3h7u6OFi1a4MSJEyrrlJCQgBEjRqBw4cIwNTVFyZIlMXv2bKSlpelUx/qkUCgQEhIiS3v58iVGjRoFd3d3mJmZoVKlSrJ1LigREREYOnQofH19YW1tDRcXF9SvXx8HDx5Uyevl5aVx+5mZmankf/r0KUaOHAkvLy+YmprCxcUFTZo0wbNnz1TyHjt2DE2bNoW9vT3Mzc3h4+ODL7/8UpYnq/1H3f6uq9evX6NkyZJQKBT45ptvZNOioqK02neVbt++jbZt28LOzg5WVlZo0KABzp8/L8sTHR2NL774An5+fnBycoKNjQ2qVq2KH3/8UeP+q009aWv//v1o0KAB3N3dYWpqCmdnZ9StWxd//PFHjpYHaN92c7Lu+nLo0CEoFAr88ssvUtqJEycQEhKCFy9e5GnZ2ckqjqCgIAQFBeV7TH///TfGjRuHqlWrws7ODg4ODggICJDVX0YxMTHo1asXnJycYGFhAT8/Pxw4cEBt3v3798PPzw8WFhZwcnJCr169EBMTk5erQ0RE+cCooAMgIiL9+ffffzFu3Di4u7sjLi5ObR5zc3OVTgRzc3O1edu3b4+xY8fK0ooWLSr7PGvWLLi6umLy5MkoVqwY7t+/jxkzZqBKlSo4deoUypUrBwC4d+8eFixYgB49emDMmDGwsrLC0aNHERISgn379mHfvn1QKBQAgH79+qFx48Yq8fTv3x+3bt2STYuNjUVAQABGjhwJJycnREdHY968eahduzYOHDiAwMBAAEBqaioaNGiAv//+G19++SVKliyJ3bt3Y8KECXjw4AG+++67rKo2X7Vt2xZnz57FzJkzUbJkSaxfvx5dunRBeno6unbtWmBxbdiwAWfOnEGfPn1QsWJFJCYmYunSpahXrx5Wr16Nnj17Snm3bduGpKQk2fz37t1Dp06d0KZNG1n6w4cPUatWLRgZGWHKlCnw8fHB06dPER4ejuTkZFne9evXo0ePHujYsSPWrFkDKysr3Lp1Cw8fPpTlO3nypEr8p0+fxqhRo1TKz4kpU6YgMTExyzzDhw9X2V4+Pj6yz0+ePEGtWrVgb2+PFStWwMzMDGFhYQgKCsLZs2dRqlQpAG87BNesWYOePXtiypQpMDY2xp9//onBgwfj1KlTWLFihWy52taTtmJjY1GuXDn069cPrq6uePbsGZYuXYpmzZph7dq16N69e46WqU3b1XXd89qJEycQGhqKXr16wc7OLl/L1jaOxYsXF0hMe/fuxa5du9CjRw988sknSE1NxaZNm9ChQweEhoZi6tSpUt6kpCTUq1cPL168wLfffgtnZ2d8//33aNy4Mfbv3y9tfwA4fPgwmjRpgmbNmuG3335DTEwMPv/8c9SrVw/nzp2DqalpQawuERHpgyAiog9G8+bNRYsWLURwcLCwtLRUma4pXR0AYujQodnme/z4sUrav//+K4yNjUXfvn2ltJcvX4qXL1+q5J0zZ44AII4ePZplOXfu3BEKhUJ0794925hevHghjI2NRY8ePaS0DRs2CADi119/leUdMGCAMDAwEH/99Ve2y80LAMS0adOkz7t27RIAxPr162X5GjRoINzd3UVqamo+R/gfdds6NTVVVKhQQRQvXjzb+UNCQgQAsX//fll6q1atROHChcWzZ8+ynP/BgwfC0tJSDB48WLfA/69Xr15CoVCImzdv5mh+pdOnTwsTExOxZcsWAUDMmTNHNv3OnTtq09X57LPPhLGxsYiKipLS4uLihJOTk+jYsaOU9uzZM5GcnKwy/9ChQwUAce/ePSktt/WkreTkZFG4cGFRq1YtvS1TXdvVZd31LTw8XAAQW7ZskdKUx6w7d+7otazExESd8udVHLnx5MkTkZ6erpLerFkzYWFhId68eSOlff/99wKAOHHihJSWkpIiypYtK6pXry6b/5NPPhFly5YVKSkpUtrx48cFALF48eI8WBMiIsovHL5HRPSBWLduHQ4fPpzvv5A7OzurpLm7u6NIkSK4f/++lGZpaQlLS0uVvNWrVwcAWV51VqxYASEE+vXrl21M1tbWMDMzg5HRfzcEHz9+HAqFAk2aNJHlbd68OdLT07Ft2zYp7Z9//kHv3r3h4+MDCwsLFC5cGC1atMCVK1dUyoqPj8e4cePg7e0NExMTFC5cGKNGjVK5iyY+Ph79+/eHo6MjrKys0LhxY/z9998qy9u2bRusrKzQoUMHWXrv3r3x8OFDnD59Wpa+fv16+Pn5wcrKClZWVqhUqRKWL18uy7N7927Uq1cPtra2sLCwQJkyZRAWFibLc+7cObRs2RIODg4wMzND5cqVsXnzZlkeddva0NAQVatWzXb7CSGwcuVKFCtWDHXr1pXSo6KisGPHDvTv3x/29vZZLmPZsmVITEzE559/nmU+dRISErBlyxYEBgaiRIkSsmnabkMASE5ORp8+fTB06FBUq1ZN5zgy27ZtG+rWrQtPT08pzcbGBm3btsXOnTuRmpoKALC3t4exsbHK/Mr28+DBAylN13ratGkT/Pz8YGlpCSsrKzRq1AgXLlzIdj5jY2PY2dnJ2hnwdlsvXrwYlSpVgrm5Oezt7dG+fXvcvn0722Wqa7u6rDsA/PXXX+jSpYs0LLBo0aLo2bOnyp17ORESEoLPPvsMAODt7S0Nyzx06JCUR5v67NWrF6ysrHDlyhU0bNgQ1tbWqFevHgBg3759aNWqFYoUKQIzMzOUKFECAwcOxNOnT7WOQ93wvWfPnmHIkCEoXLgwTExMUKxYMUyePFmlXhQKBYYNG4a1a9eiTJkysLCwQMWKFfH7779nWz9OTk7SHa8ZVa9eHa9evZINx922bRtKlSoFPz8/Kc3IyAjdu3fHmTNn8O+//wJ4ewfw2bNn0aNHD9l+4e/vj5IlS8qO3URE9P5hpxQR0QcgJiYGo0aNwsyZM1GkSJEs875+/Rqurq4wNDREkSJFMGzYMLXP7QHedniYm5vD1NQUVatWxcqVK7WK5/bt27h79640dC8ryqGEWeVNT0/HqlWrUKJECdmQjozS0tKQkpKCqKgoDB48GEIIDB06VJqenJwMAwMDlYtb5bCPy5cvS2kPHz6Eo6MjZs6cid27d+P777+HkZERatSogRs3bkj5Xr16hcDAQKxevRojRozAn3/+ic8//xyrVq1Cy5YtIYQA8PYivXXr1li7di3Gjh2Lbdu24dNPP1XpIAOAq1evokyZMioX+hUqVJCmK02dOhXdunWDu7s7Vq1ahW3btiE4OBh3796V8ixfvhxNmzZFeno6li5dip07d2LEiBGyC/nw8HAEBATgxYsXWLp0KX777TdUqlQJnTp1wqpVq9RvlP9LTU3F0aNHs93W+/fvx927d9GnTx/ZRevRo0chhIC7uzu6dOkCKysrmJmZISgoSGUI3pEjR+Dg4IC//voLlSpVgpGREZydnTFo0CDEx8dnWf7GjRuRmJio0qmp7TZUmj59OhITE7V6NtPMmTNhYmICCwsL1KxZEzt27JBNf/36NW7duiVt24wqVKiA169fZ9uRc/DgQRgZGaFkyZJSmi71NGPGDHTp0gVly5bF5s2bsXbtWiQkJKBWrVqIjIxUKS89PR2pqal4+PAhpk2bhr///ltliO/AgQMxatQo1K9fH9u3b8fixYtx7do1+Pv74/HjxyrLzK7t6rLuly5dwieffIJTp05h+vTp+PPPPxEWFoakpCTZUFAvLy94eXllW0Zm/fr1w/DhwwG8fZ7eyZMncfLkSVSpUgWAbvWZnJyMli1bom7duvjtt98QGhoKALh16xb8/PywZMkS7N27F1OnTsXp06dRs2ZNpKSkaBVHZm/evEGdOnWwZs0ajBkzBrt27UL37t0xe/ZstG3bViX/rl27sGjRIkyfPh2//vorHBwc0KZNG606FtUJDw9HoUKFZB3bV69e1bjvA8C1a9ekfBnTM+fNeEwkIqL3UIHdo0VERHrTrl074e/vLw2b0DRMb968eWLevHli7969Yu/evWLy5MnCwsJClC5dWiQkJMjydu3aVfz888/iyJEj4pdffhFNmjQRAMQXX3yRZSwpKSkiKChI2NjYZDus5tKlS8Lc3Fy0adMmy3x//vmnACDCwsI05ilVqpQAIAAINzc3cezYMdn0BQsWqB0mOGXKFAFANGzYUOOyU1NTRXJysvDx8RGjR4+W0sPCwoSBgYE4e/asLP8vv/wiAIg//vhDFv+3334ry/f111+rDN/z8fERjRo1Uonh4cOHAoCYMWOGEEKI27dvC0NDQ9GtWzeNcSckJAgbGxtRs2ZNtUNqlEqXLi0qV64sGxojxNvhoG5ubiItLU3jvJMnTxYAxPbt2zXmEUKITp06CUNDQ/HgwQNZelhYmAAgbGxsRKtWrcTu3bvFr7/+KipUqCDMzMzEpUuXpLylSpUSZmZmwtraWsyYMUOEh4eL2bNnC3NzcxEQEJDlOtaoUUPY2dmJ169fq5SvzTYUQogLFy4IY2NjsXv3biGE5mF6Dx8+FP379xebN28WR48eFT///LP49NNPBQDx008/Sfn+/fdfjfv1+vXrVYY2ZbZnzx5hYGAg2yd1qad79+4JIyMjMXz4cNn8CQkJwtXVVTZ8UKlRo0ZSO7OxsRFbt26VTT958qQAIObOnStLv3//vjA3Nxfjx49XWWZ2bVeXda9bt66ws7MTMTExWc5fvHhxrYac6jJ8T5f6DA4OFgDEihUrsiw/PT1dpKSkiLt37woA4rfffss2DiGECAwMFIGBgdLnpUuXCgBi8+bNsnyzZs0SAMTevXulNADCxcVFxMfHS2mPHj0SBgYGWR6DNfnpp5/UHv+MjY3FwIEDVfKfOHFCNoT5559/FgDEyZMnVfIOGDBAmJiY6BwTERG9O9gpRUT0nvvll1+EiYmJuHbtmpSmy7OjlBff8+bNyzZv8+bNhZGRkcYLvvT0dNGzZ09haGiYbSfFnTt3hIeHhyhZsqSIjY3NMm/79u2FkZGRiI6O1pjn6tWr4vTp02LLli2iXr16wtraWoSHh0vTnzx5IhwcHESZMmXEqVOnxPPnz8X69euFra2tACAaN24s5U1JSRFff/21KFOmjDA2NpYumDPnCwgIEBUqVBApKSmyv4SEBKFQKKQL8PHjxwsA4unTpyp1oK5TKmMZSspOKeVF4Q8//KBVp0XGizt1bt68KQCIb775RmU9Fi9eLACIyMhItfMqLzbHjh2rcflCCBEbGytMTU1Fs2bNVKYpO+bKli0re17Ww4cPhYWFhazTzcfHR20njrLDcd++fWrLv3r1qsZnpGm7DVNSUkTlypVlzzTT5dlRycnJonLlysLR0VHq/FN2Ss2cOVMlv7JTSt2FuBBCRERECFtbW+Hv7y97To8Q2teTcvudPXtWZf07deoknJ2dVcr9+++/xZkzZ8Rvv/0mOnToIIyNjWX71+TJk4VCoRCPHz9WWeann36q8qwgIbJvu9que2JiojA0NBQDBgzQOK+udOmU0qU+lZ1ScXFxKmU+fvxYDBw4UBQpUkQYGBjIjj8Z9xVdOqU6duwoLC0tVTpuHz9+LACIzz//XEoDIDp37qyyTFdXVzFo0CCNdaXOH3/8IUxMTET79u1VyjY2Nla7PGWn1IYNG4QQ/3VKnTp1SiXvgAEDhKmpqU4xERHRu4XD94iI3mMvX77E0KFDMXz4cLi7u+PFixd48eKFNEzlxYsX2b4hrE2bNrC0tMSpU6eyLa979+5ITU3FuXPnVKaJ/z/vad26dVi1ahVatWqlcTl3795FnTp1YGRkhAMHDsDBwUFj3qdPn2LHjh1o1qwZXF1dNeYrV64cqlevjvbt22P37t3w9PTEyJEjpelOTk7YvXs3AODTTz+Fvb09hg8fjnnz5gEAChcuLOUdM2YMpkyZgtatW2Pnzp04ffo0zp49i4oVK+L169dSvsePH+Py5cswNjaW/VlbW0MIIT0DJjY2FkZGRnB0dJTFrG59HB0dERsbq5KuHGKprKsnT54AQJbDNbXJoxxONW7cOJX1GDJkCADInmWjtHLlSgwcOBADBgzAnDlzNC4fePu8s6SkJLXPA1PWSf369WFoaCilu7m5oWLFijh//rxK3kaNGsmWoRwGmTFvRspnbKkrX9ttuGDBAty+fRvTpk2T2plyKNybN2/w4sULpKWlaawDY2NjdOrUCbGxsbh58yaAt89KUigUWm3vjC5cuIAGDRrAx8cHf/zxh8qbx7StJ+W2/+STT1TWf9OmTWq3u4+PDz755BO0bNkSmzdvRr169TB06FCkp6dLyxRCwMXFRWWZp06dUrvM7Nqutuv+/PlzpKWlZTuEOa/oWp8WFhawsbGRpaWnp6Nhw4bYunUrxo8fjwMHDuDMmTPS8Tnj8UcXsbGxcHV1VXnek7OzM4yMjFT2wczHKuDtUGddyt+zZw/atm2LBg0a4Oeff1YpW9tjnTIWTXmz+v4gIqJ3n1H2WYiI6F319OlTPH78GHPnzsXcuXNVptvb26NVq1bYvn17lssRQsDAIPvfKcT/n6+TOa+yQ2rlypVYvnx5lq+Hv3v3LoKCgiCEwKFDh7K9gFy7di2Sk5O1esC5kpGREapUqaLyoO5PPvkEkZGRiIqKQmJiInx8fBAREQEAqF27tpRv3bp16NmzJ2bMmCGb/+nTp7JXrzs5OcHc3FzjK+mdnJwAvL2oSk1NRWxsrOxi79GjRyrz+Pr6YsOGDUhNTZU9V0r5kPXy5csDAAoVKgTg7UOePTw81JafMY8myhgnTpyo9tkyAFCqVCnZ55UrV6Jfv34IDg7G0qVL1T7YOKPly5fDxcUFzZs3V5mm7jkxSpn3ywoVKqjtPNW0XwJvn9uzdu1aVK1aFZUqVVKZru02vHr1KuLi4uDj46OSZ8qUKZgyZQouXLigtgxNcZqbm6NEiRJqH6B/5coVmJubo1ixYrL0CxcuoH79+vD09MTevXtha2urMq+29aRct19++UX2oHVdVK9eHbt378aTJ0/g4uIiPej66NGjKp1lANSmZaSp7QLZr7uDgwMMDQ2z3N/zkq71qa7dXL16FZcuXcKqVasQHBwspf/zzz+5is3R0RGnT5+GEEJWbkxMDFJTU6XY9WXPnj1o3bo1AgMD8euvv8LExEQlj6+vr8Z9H/jvWKf898qVK2jatKlKXuV0IiJ6TxXI/VlERKQXr1+/FuHh4Sp/jRo1EmZmZiI8PFxcuXIly2Vs2rRJABALFizItrymTZsKY2Nj8eTJEyktPT1d9O3bVygUCvHjjz9mOf/du3eFl5eX8PDwELdu3dJqHcuVKyfc3d1lQ7uy8/r1a1GyZElRvnz5LPOlp6eLdu3aCXd3d/Hq1Ssp3cHBQeVZJ7///rsAIBsS89VXXwkLCwtx+/btLMvR5ZlSf/zxhwAgNm7cKMvbuHFjWT3cuXNHGBoaih49emgsNyEhQdja2oratWtn+bwlHx8f0bRp0yzXQWnlypXCwMBA9OzZM8tnTSmdPXtWAFD7LCEhhEhLSxNFihQRpUuXlm3jf//9V5ibm4u+fftKacrhiF9//bVsGfPmzVP7vDAhhNiyZUuWr43Xdhtev35dpZ1t2LBBABCDBg0S4eHhKs9lyyg5OVlUqlRJODk5ydZz/PjxwsTERPb8tfj4eFGoUCHRqVMn2TIuXLggHBwcRIUKFVSGgmakbT3duXNHGBkZiVmzZmW57pqkp6eLwMBAYWdnJw1JPHbsmAAgNm3alKNlamq72q573bp1hb29vewYlRvqhu999913aoe16lKfmoZYX758WTZ0TWncuHEqxwpNcQihOnxPOdw38zPAlEMAMw59hYahrp6eniI4ODjbdduzZ48wMzMT9evXV3mGW0bK4cEZh+WlpKSIcuXKiRo1asjyVq9eXZQvX17WdpTPL1uyZEm2MRER0buLd0oREb3HlG8py2zVqlUwNDSUTbt79y66du2Kzp07o0SJElAoFDh8+DAWLFiAcuXKye5EmjNnDiIjI1GvXj0UKVIEMTExWL58Ofbu3YuQkBDZr+ojRozA8uXL0adPH/j6+sru0DA1NUXlypUBvP1Fvk6dOoiOjsby5csRExODmJgYKW+RIkVU7po6ffo0rl27hkmTJsmGdmXk7++Pli1bokyZMrC1tUVUVBSWLFmCW7duqbwqfPLkyfD19YWbmxvu3buHFStW4PTp09i1axfMzc2lfM2bN8eqVatQunRpVKhQAREREZgzZ45KfKNGjcKvv/6K2rVrY/To0ahQoQLS09Nx79497N27F2PHjkWNGjXQsGFD1K5dG+PHj0diYiKqVauG48ePY+3atSrr06RJEzRo0ACDBw9GfHw8SpQogQ0bNmD37t1Yt26dVA9eXl6YNGkSvvzyS7x+/RpdunSBra0tIiMj8fTpU4SGhsLKygpz585Fv379UL9+ffTv3x8uLi74559/cOnSJSxatAgA8MMPP6BJkyZo1KgRevXqhcKFC+PZs2e4fv06zp8/jy1btgAAtmzZgr59+6JSpUoYOHAgzpw5I4u9cuXKKnfCKIfO9e3bV+32MzAwwPz589GxY0e0atUKgwcPlt5uZ2JigokTJ0p5GzZsiBYtWmD69OlIT0/Hp59+inPnziE0NBTNmzdHzZo1VZa/fPlymJubo2vXrmrL13Ybli5dGqVLl5bNGxUVBQAoXry4rK2NGTMGKSkpCAgIgKurK+7fv4+FCxfi4sWLWLlypWxfHjduHNauXYtmzZph+vTpMDU1xcyZM/HmzRuEhIRI+W7cuIH69esDAL7++mvcvHlTGgaojEF5Z5y29eTl5YXp06dj8uTJuH37Nho3bgx7e3s8fvwYZ86cgaWlpfRGuFatWqFixYqoVKkSHB0d8fDhQ6xatQqHDx+W3k4JAAEBARgwYAB69+6Nc+fOoXbt2rC0tER0dDSOHTsGX19fDB48GID2bVeXdZ83bx5q1qyJGjVqYMKECShRogQeP36MHTt24IcffoC1tTUAoESJEgBydgeSr68vAODbb79FcHAwjI2NUapUKZ3qU5PSpUujePHimDBhAoQQcHBwwM6dO7Fv3z6t41CuY0Y9e/bE999/j+DgYERFRcHX1xfHjh3DjBkz0LRpU6l+c+vYsWNo3bo1XF1dMWnSJFy8eFE2vWzZstKQxT59+uD7779Hhw4dMHPmTDg7O2Px4sW4ceMG9u/fL5tv1qxZaNCgATp06IAhQ4YgJiYGEyZMQPny5dG7d2+9xE5ERAWkoHvFiIhI/9T9Cv/s2TPRpk0b4eXlJczNzYWJiYnw8fER48ePFy9evJDl3bFjh6hZs6YoVKiQMDIyEtbW1qJWrVoqv94L8fbXc2R4EG/GP09PTymf8o4DTX8Z7wBQ6t+/v1AoFFneVTV27FhRsWJFYWtrK4yMjISrq6to06aNOH78uErewYMHi6JFiwoTExPh5OQk2rVrJy5fvqyS7/nz56Jv377C2dlZWFhYiJo1a4qjR4+q3H0ghBAvX74UX3zxhShVqpQwMTERtra2wtfXV4wePVo8evRIyvfixQvRp08fYWdnJywsLESDBg3EX3/9pXbdExISxIgRI4Srq6swMTERFSpUUFv3QgixZs0a8cknnwgzMzNhZWUlKleuLFauXCnL88cff4jAwEBhaWkpLCwsRNmyZVXu5rh06ZLo2LGjcHZ2FsbGxsLV1VXUrVtXLF26VMqjfDizpr/MD1x+9eqVdKdWdrZv3y6th62trWjZsqXs4f0Zl/n5558LDw8PYWRkJIoWLSomTpyo8rBvId6+DU15V1dWtN2GmWl60Pny5ctF9erVhYODgzAyMhL29vaiUaNGYs+ePWqX888//4jWrVsLGxsbYWFhIerVqyciIiJkeVauXJll3Wfe5rrU0/bt20WdOnWEjY2NMDU1FZ6enqJ9+/Zi//79Up5Zs2aJTz75RNjb2wtDQ0Ph6OgoGjVqJH7//Xe167RixQpRo0YNYWlpKczNzUXx4sVFz549xblz56Q82rZdXdc9MjJSdOjQQTg6OgoTExNRtGhR0atXL9m6e3p6yo5Pmqi7U0oIISZOnCjc3d2lB5FnfDC7NvWZ1csoIiMjRYMGDYS1tbWwt7cXHTp0EPfu3VN7rNAUh7pjVWxsrBg0aJBwc3MTRkZGwtPTU+0+gVzcKTVt2rQst1XmB9g/evRI9OzZUzg4OAgzMzPx6aefanxhwd69e8Wnn34qzMzMhIODg+jZs6d4/PhxlvEQEdG7TyHE/x8wQERERERERERElE/49j0iIiIiIiIiIsp37JQiIiIiIiIiIqJ8x04pIiIiIiIiIiLKd+yUIiIiIiIiIiKifMdOKSIiIiIiIiIiynfslCIiIiIiIiIionzHTikiIiIiIiIiIsp37JQiIiIiIiIiIqJ8x04pIiIiIiIiIiLKd+yUIiIiIiIiIiKifMdOKSIiIiIiIiIiynfslCIiIiIiIiIionzHTikiIiIiIiIiIsp37JQiIiIiIiIiIqJ8x04pIiIiIiIiIiLKd+yUIiIiIiIiIiKifMdOKSIiIiIiIiIiynfslCIiIiIiIiIionzHTikiIiIiIiIiIsp37JQiIiIiIiIiIqJ8x04pIiIiIiIiIiLKd+yUIiIiIiIiIiKifMdOKSIiIiIiIiIiynfslCIiIiIiIiIionzHTikiIiIiIiIiIsp37JQiIiIiIiIiIqJ8x04pIiIiIiIiIiLKdznulFq1ahUUCoXav3HjxukzRtIgJCQECoVClubl5YVevXrptJwTJ04gJCQEL1680Gm+zGUdOnQICoUCv/zyi07LycqrV68QEhKCQ4cOqUxT7oNRUVF6K+9DlrnNmpmZwdXVFXXq1EFYWBhiYmIKOkTMmDED27dvV0lX7lvq9oOCEhQUhKCgIOlzVFQUFAoFVq1apdNy1q9fjwULFug0j7qylMeDp0+f6rSsrERGRiIkJERtG+vVqxe8vLz0VhblXsY2rq6tCCFQokQJKBQK2b6rD5q+D96lNlvQ+2xW37WZjydE9P47ffo02rRpg6JFi8LU1BQuLi7w8/PD2LFjZfkWL16s87lDZprOn+jdo8v5Wn5e1xEVJKPcLmDlypUoXbq0LM3d3T23i6Uc2rZtG2xsbHSa58SJEwgNDUWvXr1gZ2eXp2Xp6tWrVwgNDQUAlRP2Zs2a4eTJk3Bzc8vTGD40yjabkpKCmJgYHDt2DLNmzcI333yDTZs2oX79+gUW24wZM9C+fXu0bt1all6lShWcPHkSZcuWLZjAtODm5oaTJ0+iePHiOs23fv16XL16FaNGjcrzsnQVGRmJ0NBQBAUFqVzMT5kyBSNHjszT8ilnrK2tsXz5cpVj5uHDh3Hr1i1YW1vneQzvQ5vNb1l91y5evLhggiKiPLFr1y60bNkSQUFBmD17Ntzc3BAdHY1z585h48aNmDt3rpR38eLFcHJy0rnzISNN50/0fsvP6zqigpTrTqny5cujWrVqWuVNSUmBQqGAkVGuiyUNKleunOdlvH79Gubm5vlSVlYKFSqEQoUKFWgM76PMbbZdu3YYPXo0atasibZt2+LmzZtwcXHJdTlpaWlITU2FqalprpdlY2ODTz/9NNfLyUumpqZ5HmPGOi3o+sjrDjHKuU6dOuHnn3/G999/LzuZXb58Ofz8/BAfH5/nMbwPbTa3Xr16BQsLC70si513RB+W2bNnw9vbG3v27JFd93Tu3BmzZ88uwMjofVLQ11oZ6fM7jyizPHumlPLW/bVr12Ls2LEoXLgwTE1N8c8//wAA9u/fj3r16sHGxgYWFhYICAjAgQMHVJaza9cuVKpUCaampvD29sY333yjMmwtq2EzCoUCISEhsrSbN2+ia9eucHZ2hqmpKcqUKYPvv/9ebfwbNmzA5MmT4e7uDhsbG9SvXx83btxQKWf37t2oV68ebG1tYWFhgTJlyiAsLAwAsHbtWigUCpw8eVJlvunTp8PY2BgPHz7Msj7V1YM6mW/zTE9Px1dffYVSpUrB3NwcdnZ2qFChAr799lsAb28h/eyzzwAA3t7eKkM/vLy80Lx5c2zduhWVK1eGmZmZdOeSpltK37x5gzFjxsDV1RXm5uYIDAzEhQsXZHk0DVXIOLwiKipK6nQKDQ2VYlOWqWn43ooVK1CxYkWYmZnBwcEBbdq0wfXr11XKsbKywj///IOmTZvCysoKHh4eGDt2LJKSktTW7YesaNGimDt3LhISEvDDDz9I6dpsJ+C/Njh79mx89dVX8Pb2hqmpKcLDw/HmzRuMHTsWlSpVgq2tLRwcHODn54fffvtNtkyFQoHExESsXr1a2tbKsjUNBdqxYwf8/PxgYWEBa2trNGjQQKWdKY8X165dQ5cuXWBrawsXFxf06dMHcXFx2daNEAKzZ8+Gp6cnzMzMUKVKFfz5558q+dQdh548eYIBAwbAw8MDpqamKFSoEAICArB//36pfnft2oW7d+/KhlZmV6dZHfPu37+Ptm3bwsbGBra2tujevTuePHmiUteZj4uAvE2vWrUKHTp0AADUqVNHik1ZprqhUG/evMHEiRPh7e0NExMTFC5cGEOHDlW5hVx5XNm9ezeqVKkCc3NzlC5dGitWrNCwFUgXXbp0AQBs2LBBSouLi8Ovv/6KPn36qJ0nOTkZX331FUqXLi3tq71791bZd1JSUjB+/Hi4urrCwsICNWvWxJkzZ1SWp67Nnjt3Dp07d4aXlxfMzc3h5eWFLl264O7du7J5lcf28PBwDB48GE5OTnB0dETbtm2z/a7MuIxSpUpJ3/Fr1qzRKkZAfVtWfmdcuXIFDRs2hLW1NerVqwcA2LdvH1q1aoUiRYrAzMwMJUqUwMCBA2VDM7L7rlV3rH327BmGDBmCwoULw8TEBMWKFcPkyZNVvqMUCgWGDRuGtWvXokyZMrCwsEDFihXx+++/a1VXRKR/sbGxcHJyUvtDvIHBf5dfXl5euHbtGg4fPiwdF5Tfrfo4fwKAR48eYeDAgShSpAhMTEzg7e2N0NBQpKamZrseBw8eRFBQEBwdHWFubo6iRYuiXbt2ePXqlZQnt98fma8n1D2eBNB83r9p0yb4+fnB0tISVlZWaNSokcp1hy7n/UlJSZg+fTrKlCkDMzMzODo6ok6dOjhx4oSURwiBxYsXo1KlSjA3N4e9vT3at2+P27dvZ1unSo8fP872vFTf13Xp6emYPXu2tK2cnZ3Rs2dPPHjwQFZuUFAQypcvjyNHjsDf3x8WFhbo06cP+vbtCwcHB9n2V6pbty7KlSun9foTZZTrW5aUv9zLFprhADxx4kT4+flh6dKlMDAwgLOzM9atW4eePXuiVatWWL16NYyNjfHDDz+gUaNG2LNnj3Sid+DAAbRq1Qp+fn7YuHEj0tLSMHv2bDx+/DjH8UZGRsLf31+6CHd1dcWePXswYsQIPH36FNOmTZPlnzRpEgICArBs2TLEx8fj888/R4sWLXD9+nUYGhoCePvrc//+/REYGIilS5fC2dkZf//9N65evQrg7a/W48ePx/fffw8/Pz9p2ampqfjhhx/Qpk2bLIc85qYeZs+ejZCQEHzxxReoXbs2UlJS8Ndff0kXif369cOzZ8+wcOFCbN26VRoKl/FX2/Pnz+P69ev44osv4O3tDUtLyyzLnDRpEqpUqYJly5YhLi4OISEhCAoKwoULF1CsWLFsY1Zyc3PD7t270bhxY/Tt2xf9+vUDgCzvjgoLC8OkSZPQpUsXhIWFITY2FiEhIfDz88PZs2fh4+Mj5U1JSUHLli3Rt29fjB07FkeOHMGXX34JW1tbTJ06Ves4PxRNmzaFoaEhjhw5kuNlfPfddyhZsiS++eYb2NjYwMfHB0lJSXj27BnGjRuHwoULIzk5Gfv370fbtm2xcuVK9OzZEwBw8uRJ1K1bF3Xq1MGUKVMAIMtbltevX49u3bqhYcOG2LBhA5KSkjB79mwEBQXhwIEDqFmzpix/u3bt0KlTJ/Tt2xdXrlzBxIkTASDbjpDQ0FCEhoaib9++aN++Pe7fv4/+/fsjLS0NpUqVynLeHj164Pz58/j6669RsmRJvHjxAufPn0dsbCyAt7fsDxgwALdu3cK2bdu0rtOstGnTBh07dsSgQYNw7do1TJkyBZGRkTh9+jSMjY2znDejZs2aYcaMGZg0aRK+//57VKlSBYDmO6SEEGjdujUOHDiAiRMnolatWrh8+TKmTZuGkydP4uTJk7K75i5duoSxY8diwoQJcHFxwbJly9C3b1+UKFECtWvX1jpOUmVjY4P27dtjxYoVGDhwIIC3HVQGBgbo1KmTyjPM0tPT0apVKxw9ehTjx4+Hv78/7t69i2nTpiEoKAjnzp2Dubk5AKB///5Ys2YNxo0bhwYNGuDq1ato27YtEhISso0rKioKpUqVQufOneHg4IDo6GgsWbIEn3zyCSIjI+Hk5CTL369fPzRr1gzr16/H/fv38dlnn6F79+44ePBgluWsWrUKvXv3RqtWrTB37lzpeygpKUl2Mair5ORktGzZEgMHDsSECROkc59bt27Bz88P/fr1g62tLaKiojBv3jzUrFkTV65cgbGxsVbftRm9efMGderUwa1btxAaGooKFSrg6NGjCAsLw8WLF7Fr1y5Z/l27duHs2bOYPn06rKysMHv2bLRp0wY3btzQ6XuXiPTDz88Py5Ytw4gRI9CtWzdUqVJF7Xfwtm3b0L59e9ja2krDeJXflfo4f3r06BGqV68OAwMDTJ06FcWLF8fJkyfx1VdfISoqCitXrtS4DlFRUWjWrBlq1aqFFStWwM7ODv/++y92796N5ORkWFhY5Nv3hyYzZszAF198gd69e+OLL75AcnIy5syZg1q1auHMmTOyY6w25/2pqalo0qQJjh49ilGjRqFu3bpITU3FqVOncO/ePfj7+wMABg4ciFWrVmHEiBGYNWsWnj17hunTp8Pf3x+XLl3SasRBTs5Lc3tdN3jwYPz4448YNmwYmjdvjqioKEyZMgWHDh3C+fPnZd/D0dHR6N69O8aPH48ZM2bAwMAAdnZ2WLFiBdavXy9dlwFvr6/Dw8NVbvIg0prIoZUrVwoAav9SUlJEeHi4ACBq164tmy8xMVE4ODiIFi1ayNLT0tJExYoVRfXq1aW0GjVqCHd3d/H69WspLT4+Xjg4OIiMod+5c0cAECtXrlSJE4CYNm2a9LlRo0aiSJEiIi4uTpZv2LBhwszMTDx79kwIIaT4mzZtKsu3efNmAUCcPHlSCCFEQkKCsLGxETVr1hTp6eka62vatGnCxMREPH78WErbtGmTACAOHz6scT5d6kEIITw9PUVwcLD0uXnz5qJSpUpZLn/OnDkCgLhz547KNE9PT2FoaChu3LihdlrGspR1VqVKFVldREVFCWNjY9GvXz8pLTAwUAQGBqosMzg4WHh6ekqfnzx5orINlZT7oDLu58+fC3Nzc5Vtdu/ePWFqaiq6du0qKweA2Lx5syxv06ZNRalSpVTK+hAo6+vs2bMa87i4uIgyZcpIn7XdTso2WLx4cZGcnJxlHKmpqSIlJUX07dtXVK5cWTbN0tJStk8pKfet8PBwIcTb44W7u7vw9fUVaWlpUr6EhATh7Ows/P39pbRp06YJAGL27NmyZQ4ZMkSYmZll2W6fP38uzMzMRJs2bWTpx48fFwBkdaPuOGRlZSVGjRqlcflCCNGsWTNZXWZenro6VVeWcj1Hjx4ty/vzzz8LAGLdunVSmqY2lblNb9myRVbvGWXeB3bv3q22npXHuR9//FFWjpmZmbh7966U9vr1a+Hg4CAGDhyoUhZpJ2MbV7aZq1evCiGE+OSTT0SvXr2EEEKUK1dOtu9u2LBBABC//vqrbHlnz54VAMTixYuFEEJcv349y31M3feBun1HKTU1Vbx8+VJYWlqKb7/9VmU9hgwZIss/e/ZsAUBER0drXKby2KDpeyjjPqspRnXtS/mdsWLFCo1lCyFEenq6SElJEXfv3hUAxG+//SZNy+q7NvOxdunSpWq/o2bNmiUAiL1790ppAISLi4uIj4+X0h49eiQMDAxEWFhYlvESUd54+vSpqFmzpnRtZGxsLPz9/UVYWJhISEiQ5c18TNYkJ+dPAwcOFFZWVrLvWyGE+OabbwQAce3aNY3l/fLLLwKAuHjxosY8efH9oTyfySzzef+9e/eEkZGRGD58uCxfQkKCcHV1FR07dpTStD3vX7NmjQAgfvrpJ43rfPLkSQFAzJ07V5Z+//59YW5uLsaPH69x3ozrp815qT6v65TbIPN36+nTpwUAMWnSJCktMDBQABAHDhxQWX5gYKBKDIMHDxY2NjYq+zaRtnI9fG/NmjU4e/as7C/jnVLt2rWT5T9x4gSePXuG4OBgpKamSn/p6elo3Lgxzp49i8TERCQmJuLs2bNo27YtzMzMpPmtra3RokWLHMX65s0bHDhwAG3atIGFhYWs/KZNm+LNmzc4deqUbJ6WLVvKPleoUAEApOEGJ06cQHx8PIYMGaL2VlOlwYMHAwB++uknKW3RokXw9fXN8q6A3NZD9erVcenSJQwZMgR79uzJ0bNEKlSogJIlS2qdv2vXrrK68PT0hL+/P8LDw3UuWxcnT57E69evVYYUenh4oG7duirDQxUKhUodVqhQQWUoycdECJGr+Vu2bKn2l8AtW7YgICAAVlZWMDIygrGxMZYvX64yrFJbN27cwMOHD9GjRw/ZnQ9WVlZo164dTp06pXJrsbq2/ObNmyzfOnjy5Em8efMG3bp1k6X7+/vD09Mz2zirV6+OVatW4auvvsKpU6eQkpKizeqpxK3LHU6ZY+3YsSOMjIzyvP0p717J3P46dOgAS0tLlfZXqVIlFC1aVPpsZmaGkiVLftTtT58CAwNRvHhxrFixAleuXMHZs2c1Dt37/fffYWdnhxYtWsi+FytVqgRXV1fptn/lPqRpH8vOy5cv8fnnn6NEiRIwMjKCkZERrKyskJiYqPZYkN33rzrKY4Om76HcynxOAwAxMTEYNGgQPDw8pOOb8viQ02PcwYMHYWlpifbt28vSle0rc3uqU6eO7AH2Li4ucHZ2ZnsiKiCOjo44evQozp49i5kzZ6JVq1b4+++/MXHiRPj6+mr9ptzcnj/9/vvvqFOnDtzd3WXH9yZNmgB4+wIMTSpVqgQTExMMGDAAq1evVjs0Lb++P9TZs2cPUlNT0bNnT1nZZmZmCAwMVBmarc15/59//gkzMzON35fKdVYoFOjevbusXFdXV1SsWFHrt87m5Lw0N9d1ym2Q+TytevXqKFOmjMr3ir29PerWrauynJEjR+LixYs4fvw4ACA+Ph5r165FcHAwrKystI6HKKNcd0qVKVMG1apVk/1llPnNaMohZ+3bt4exsbHsb9asWRBC4NmzZ3j+/DnS09Ph6uqqUqa6NG3ExsYiNTUVCxcuVCm7adOmAKDyJeHo6Cj7rLyl9vXr1wAgjZcuUqRIlmW7uLigU6dO+OGHH5CWlobLly/j6NGjGDZsWJbz5bYeJk6ciG+++QanTp1CkyZN4OjoiHr16uHcuXPZzquk69vtNMWqHLKUV5TLVxevu7u7SvkWFhayjj7g7fZ98+ZN3gX5DktMTERsbGyu3p6pru63bt2Kjh07onDhwli3bh1OnjwpXSDntK6z29bp6el4/vy5LD27tpxVOTltf5s2bUJwcDCWLVsGPz8/ODg4oGfPnnj06FG28yrltv0ZGRnB0dExX9qfkZGRyvBahUKhtv1n3h7A222S1fYg7SkUCvTu3Rvr1q3D0qVLUbJkSdSqVUtt3sePH+PFixcwMTFR+W589OiR9L2oqT0o97HsdO3aFYsWLUK/fv2wZ88enDlzBmfPnkWhQoXUbveCaLNZsbCwUBlSnJ6ejoYNG2Lr1q0YP348Dhw4gDNnzkg/cOV0f46NjYWrq6vKj13Ozs4wMjJieyJ6T1SrVg2ff/45tmzZgocPH2L06NGIiorS6mHn+jh/evz4MXbu3KlybFc++yerzrHixYtj//79cHZ2xtChQ1G8eHEUL15cen6Rcvn58f2had0A4JNPPlEpe9OmTSrrps15/5MnT+Du7p7lUO/Hjx9DCAEXFxeVck+dOqV1h2NOvuNyc12n63WSpvPPVq1awcvLSxqqt2rVKiQmJmLo0KHZxkCkSZ6/Bi/zCZVyrOrChQs1vpnHxcVFelOfuou3zGnKA0zmB9Vlblz29vYwNDREjx49NDYcb2/vLNZGlfICLPMD4tQZOXIk1q5di99++w27d++GnZ2dyi8Gmdnb22tdD+oYGRlhzJgxGDNmDF68eIH9+/dj0qRJaNSoEe7fv6/VWxSyugNMHU2xZjz4mpmZqX3ItLYHcnWUy4+OjlaZ9vDhQ5XnlZDcrl27kJaWJns4pq7bSd2+sm7dOnh7e2PTpk2y6bl5oHx229rAwAD29vY5Xn7mcjTt05kf9J2Zk5MTFixYgAULFuDevXvYsWMHJkyYgJiYGOzevVurGHLS/goXLix9Tk1NRWxsrKz9mZqaqq3/3HRcOTo6IjU1FU+ePJF1TAkh8OjRI3zyySc5XjblTK9evTB16lQsXboUX3/9tcZ8ygeJa9onlXfgZGwP6vaxrMTFxeH333/HtGnTMGHCBCld+cwUfcmuzWak6dxBl+Pb1atXcenSJaxatQrBwcFSuvKlLjnl6OiI06dPQwghKzcmJgapqan8PiN6DxkbG2PatGmYP3++9NzZrOjj/MnJyQkVKlTQ+B2Q3Q+RtWrVQq1atZCWloZz585h4cKFGDVqFFxcXNC5c+c8+f7IeGzO+CzKzMdm5XHwl19+0erudW0UKlQIx44dQ3p6usaOKScnJygUChw9elTtG6b18dZpTXJzXZfx3DnzzRTqrpM0nX8aGBhg6NChmDRpEubOnYvFixejXr162T5nlSgrefb2PU0CAgJgZ2eHyMhIlTuslH8mJiawtLRE9erVsXXrVlkPdkJCAnbu3ClbpouLC8zMzHD58mVZeua3U1hYWKBOnTq4cOECKlSooLZsXXvr/f39YWtri6VLl2Y79Klq1arw9/fHrFmz8PPPP6NXr17ZPjRcl3rIjp2dHdq3b4+hQ4fi2bNn0tsrtOmZ18WGDRtkdXH37l2cOHFC1tnh5eWFv//+W/bFGhsbK3uzha6x+fn5wdzcHOvWrZOlP3jwAAcPHpQeoE+q7t27h3HjxsHW1lZ6MDKg/XbKikKhgImJiezL7dGjRyrtE9D+l/1SpUqhcOHCWL9+vWxfS0xMxK+//iq9kS+3Pv30U5iZmeHnn3+WpZ84cULnYTFFixbFsGHD0KBBA5w/f15K1/fdDJlj3bx5M1JTU1XaX+bj5cGDB/Hy5UtZmi7tT9m+Mre/X3/9FYmJiWx/BaBw4cL47LPP0KJFC1mHSWbNmzdHbGws0tLS1H4vKk80lfuQpn0sKwqFAkIIlZP1ZcuWIS0tLQdrp16pUqXg5uam8XsoI2Wncua2sGPHDq3LUx7XMq9XxreYKunanl6+fInt27fL0pVvEWR7Inq3qfvRDPhvSG/GziBN5wH6OH9q3rw5rl69iuLFi6s9vmt7d7yhoSFq1Kgh3R2jPI/Ji+8PTcfmzNc9jRo1gpGREW7duqXxmlJXTZo0wZs3b9S+3VipefPmEELg33//VVumr6+vzuXmhK7XdcqheJnP086ePYvr16/r9L3Sr18/mJiYoFu3brhx40a2I3+IspPnd0plZmVlhYULFyI4OBjPnj1D+/bt4ezsjCdPnuDSpUt48uQJlixZAgD48ssv0bhxYzRo0ABjx45FWloaZs2aBUtLS9kvq8pxvStWrEDx4sVRsWJFnDlzBuvXr1cp/9tvv0XNmjVRq1YtDB48GF5eXkhISMA///yDnTt3ZvtWH3XrM3fuXPTr1w/169dH//794eLign/++QeXLl3CokWLZPlHjhyJTp06QaFQYMiQIVqVoW09qNOiRQuUL18e1apVQ6FChXD37l0sWLAAnp6e0lu8lAfPb7/9FsHBwTA2NkapUqVkz6fQRUxMDNq0aYP+/fsjLi4O06ZNg5mZmfRWCeDtW8l++OEHdO/eHf3790dsbCxmz56tMjTC2toanp6e+O2331CvXj04ODjAyclJ7R0qdnZ2mDJlCiZNmoSePXuiS5cuiI2NRWhoKMzMzFTerPixunr1qjT+PSYmBkePHsXKlSthaGiIbdu2ye5y0XY7ZaV58+bYunUrhgwZIr297ssvv4Sbmxtu3rwpy+vr64tDhw5h586dcHNzg7W1tdpfXgwMDDB79mx069YNzZs3x8CBA5GUlIQ5c+bgxYsXmDlzZs4rKAN7e3uMGzcOX331Ffr164cOHTrg/v37CAkJyXYoUFxcHOrUqYOuXbuidOnSsLa2xtmzZ7F79260bdtWts5bt27FkiVLULVqVRgYGOToREpp69atMDIyQoMGDaS371WsWBEdO3aU8vTo0QNTpkzB1KlTERgYiMjISCxatAi2trayZZUvXx4A8OOPP8La2hpmZmbw9vZW23nfoEEDNGrUCJ9//jni4+MREBAgvX2vcuXK6NGjR47XiXJOm7bQuXNn/Pzzz2jatClGjhyJ6tWrw9jYGA8ePEB4eDhatWqFNm3aoEyZMujevTsWLFgAY2Nj1K9fH1evXpXeDJkVGxsb1K5dG3PmzJGO4YcPH8by5cthZ2enp7V9e2z48ssv0a9fP+l76MWLF2rbrKurK+rXr4+wsDDY29vD09MTBw4cwNatW7Uur3Tp0ihevDgmTJgAIQQcHBywc+dO7Nu3TyWvLt+1PXv2xPfff4/g4GBERUXB19cXx44dw4wZM9C0aVPUr19fx5ohovzUqFEjFClSBC1atEDp0qWRnp6OixcvYu7cubCyssLIkSOlvL6+vti4cSM2bdqEYsWKwczMDL6+vno5f5o+fTr27dsHf39/jBgxAqVKlcKbN28QFRWFP/74A0uXLtX4CJKlS5fi4MGDaNasGYoWLYo3b95Ib4ZTHoPy4vujadOmcHBwQN++fTF9+nQYGRlh1apVuH//viyfl5cXpk+fjsmTJ+P27dto3Lgx7O3t8fjxY5w5cwaWlpYIDQ3Vabt16dIFK1euxKBBg3Djxg3UqVMH6enpOH36NMqUKYPOnTsjICAAAwYMQO/evXHu3DnUrl0blpaWiI6OxrFjx+Dr6ys9S1jfcnNdV6pUKQwYMAALFy6EgYEBmjRpIr19z8PDA6NHj9Y6Djs7O/Ts2RNLliyBp6dnjp/3TCTJ6RPSs3uTl/KtNlu2bFE7/fDhw6JZs2bCwcFBGBsbi8KFC4tmzZqp5N+xY4eoUKGCMDExEUWLFhUzZ85U+1aGuLg40a9fP+Hi4iIsLS1FixYtRFRUlNq3TN25c0f06dNHFC5cWBgbG4tChQoJf39/8dVXX2Ubv6Y3/f3xxx8iMDBQWFpaCgsLC1G2bFkxa9YslfVOSkoSpqamonHjxmrrRRNt6yHzWxrmzp0r/P39hZOTkzRv3759RVRUlGy+iRMnCnd3d2FgYCB7G5Gnp6do1qyZ2pg0vX1v7dq1YsSIEaJQoULC1NRU1KpVS5w7d05l/tWrV4syZcoIMzMzUbZsWbFp0yaVN3oJIcT+/ftF5cqVhampqewNHZnfwqG0bNkyqa5sbW1Fq1atVN4uEhwcLCwtLVVi0vTGjw9B5jdmmpiYCGdnZxEYGChmzJghYmJi1M6nzXZStos5c+aoXcbMmTOFl5eXMDU1FWXKlBE//fST2rq+ePGiCAgIEBYWFrK322l6S9b27dtFjRo1hJmZmbC0tBT16tUTx48fl+VRlvPkyRO19aHuTVgZpaeni7CwMOHh4SFMTExEhQoVxM6dO1XelpX52PDmzRsxaNAgUaFCBWFjYyPMzc1FqVKlxLRp00RiYqI037Nnz0T79u2FnZ2dUCgUUp1kVadZvX0vIiJCtGjRQlhZWQlra2vRpUsX2Vs/hXh7HBo/frzw8PAQ5ubmIjAwUFy8eFGlTQshxIIFC4S3t7cwNDSUlamurb5+/Vp8/vnnwtPTUxgbGws3NzcxePBg8fz5c1k+TccVTW97JO1o84ZNIdS/6SklJUV88803omLFisLMzExYWVmJ0qVLi4EDB4qbN29K+ZKSksTYsWOFs7OzMDMzE59++qk4efKkxu+DjG32wYMHol27dsLe3l5YW1uLxo0bi6tXr6rMq2k9tHmjn9KyZcuEj4+PMDExESVLlhQrVqxQu89GR0eL9u3bCwcHB2Frayu6d+8uzp07p/bte+q+M4QQIjIyUjRo0EBYW1sLe3t70aFDB3Hv3j215x+avmvV7fuxsbFi0KBBws3NTRgZGQlPT08xceJE8ebNG1k+AGLo0KEqcalrz0SUPzZt2iS6du0qfHx8hJWVlTA2NhZFixYVPXr0EJGRkbK8UVFRomHDhsLa2loAkB2ncnv+JMTbN1mPGDFCeHt7C2NjY+Hg4CCqVq0qJk+eLF6+fKlxHU6ePCnatGkjPD09hampqXB0dBSBgYFix44dsnz6/v4QQogzZ84If39/YWlpKQoXLiymTZsmli1bpva8bfv27aJOnTrCxsZGmJqaCk9PT9G+fXuxf/9+KY8u5/2vX78WU6dOlb5DHB0dRd26dcWJEydk+VasWCFq1KghLC0thbm5uShevLjo2bOn2msedWVqc16q7+u6tLQ0MWvWLFGyZElhbGwsnJycRPfu3cX9+/dl8wcGBopy5cpluR6HDh0SAMTMmTOzzEekDYUQuXzdVgEICQlBaGhort8UVhB27tyJli1bYteuXdLD1YmIiIiIiD42Xl5eCAoKynLIHL17xo4diyVLluD+/fs5flg9kVK+D9/7WEVGRuLu3bsYO3YsKlWqJL2KlYiIiIiIiOhdd+rUKfz9999YvHgxBg4cyA4p0gt2SuWTIUOG4Pjx46hSpQpWr16t8xu1iIiIiIiIiAqK8mVCzZs3x1dffVXQ4dAH4r0cvkdERERERERERO83g4IOgIiIiIiIiIiIPj7slCIiIiIiIiIionzHTikiIiIiIiIiIsp3BfKg8/T0dDx8+BDW1tZ84DfpnRACCQkJcHd3h4EB+121xXZJeY1tM2fYNimvsW3mDNsmERGRZtqeXxRIp9TDhw/h4eFREEXTR+T+/fsoUqRIQYfx3mC7pPzCtqkbtk3KL2ybumHbJCIiyl525xcF0illbW0N4G1wNjY2BRECfcDi4+Ph4eEh7WekHbZLymtsmznDtkl5jW0zZ/6rr9EATDNMaaHlEtzlH39zAADEmdlKSbZfxkn/X7urHQCgh201Dcsb+Hb+Gt6yVNvTdwD88P9PbgCi/59XmVYNwDmtIt6NmRqnNcaETCm67k8JOs6bkClf5s/qlpuTuOTL2hW3T5bSzLZtpnK0Xb6meIG32+fQ//9/Dv9tt7d+jIvEbdsdAICZ+FrL8rKKIyN5WZlNjXu7Tz5BIbXTg7FGq1I/tf0G2u13A+Uf/99Ovm71tp2UigvAv7bHUSPOC2XaRMG2VFzmBeSPJWEaJii3ceZ6zjgtIysALzP8P1pNvgQAJZHVdnq7HbWVeTnazptV+ZlpWma0FuWpK8ct07Sslq8vuh6j8oq6Y4e6/Qtq8uWkrMzefgfdf9YZHuVjgVaQ7/89J/73/+R4YGP25xcF0imlvMXZxsaGJ9iUZ3grvW7YLim/sG3qhm2T8gvbpm7+qy9TyDulrLRcQqaTdMu37dvGLEOa0X9t3sLGOEN5mpdno3J2b51hHvP//z9jmkUWy8wUYpZTMy/DTG0uzZJ1nDc5U77Mn9UtNydxyZdlaWOoYXnJmT5nvyzNeW3wdrsAb+tVud3eMrcxzvApN+ujjCMjeVmZmdmY/j8q9eVaaf3IYm33O/XtxEz6aARzAFY2Bm/3fdOC+p7UtC6Z9w910zIyB5Ca4f+mavIl4239ZbXtLbKYll0c2s6ry76naZlmWpSnrhyLTNOyWr6+6HqMyivqjh3q9i+oyZeTsjJ7W9c2NgrAwOb/u36G/d9EtQ1md37BBwcQEREREREREVG+Y6cUERERERERERHlO3ZKERER5ZOwsDAoFAqMGjUq18tKSxc4eSsWv138FydvxSItXeQ+QCIiIiKifFQgz5RSKj9tD+7N71CQIRBRJuWn7YGBqXxcdtTMZgUUDdGH4+zZs/jxxx9RoUKFXC9r99VohO6MRHTcGynNzdYM01qURePyujzclIiIiIio4PBOKSIiojz28uVLdOvWDT/99BPs7e1ztazdV6MxeN15WYcUADyKe4PB685j91V9vmmGiIiIiCjvsFOKiIgojw0dOhTNmjVD/fr1c7WctHSB0J2RUDdQT5kWujOSQ/mIiIiI6L1QoMP3iIiIPnQbN27E+fPncfbsWa3yJyUlISkpSfocHx8v/f/MnWcqd0hlJABEx73BmTvP4FfcMccxExERERHlB94pRURElEfu37+PkSNHYt26dTAzM9NqnrCwMNja2kp/Hh4e0rSYBM0dUhlpm4+IiIiIqCCxU4qIiCiPREREICYmBlWrVoWRkRGMjIxw+PBhfPfddzAyMkJaWprKPBMnTkRcXJz0d//+fWmas7V2HVva5iMiIiIiKkgcvkdERJRH6tWrhytXrsjSevfujdKlS+Pzzz+HoaGhyjympqYwNTVVu7zq3g5wszXDo7g3ap8rpQDgamuG6t4OeoieiIiIiChvsVOKiIgoj1hbW6N8+fKyNEtLSzg6Oqqka8PQQIFpLcpi8LrzUACyjinF//+d1qIsDA0UauYmIiIiInq3cPgeERHRe6RxeTcs6V4FrrbyIXqutmZY0r0KGpd3K6DIiIiIiIh0wzuliIiI8tGhQ4dyvYzG5d3QoKwrztx5hpiEN3C2fjtkj3dIEREREdH7hJ1SRERE7yFDAwX8ijsWdBhERERERDnG4XtERERERERERJTv2ClFRERERERERET5jp1SRERERERERESU79gpRURERERERERE+Y6dUkRERERERERElO/YKUVERERERERERPmOnVJERERERERERJTv2ClFRERERERERET5zqigAyAiIiIien9ZAzADEF+AMRQGsDWH8z7QYwz/ZvgcD8BGT8vWVuYyM24T/cQSpOikYYoN9LcPfI239amNgqhn0p5yn7DR8DknbCBva+r8i5zvG9ktOyeyWmZuytPUTrJaZm7bTG7mzW3ZuhxjdCknq2OnjpaF/Pf/nmO0moV3ShERERERERERUb5jpxQREREREREREeU7Dt8jIiKiXElLFzhz5xliEt7A2doM1b0dYGig+GjjYCxERERE2slRp1RiYiIsLS31HQsR5RLbJhHlt91XoxG6MxLRcW+kNDdbM0xrURaNy7t9dHEwFiIiIiLt5Wj4nouLC/r06YNjx47pOx4iygW2TSLKT7uvRmPwuvOyDg8AeBT3BoPXncfuq9EfVRyMhYiIiEg3OeqU2rBhA+Li4lCvXj2ULFkSM2fOxMOHD/UdGxHpiG2TiPJLWrpA6M5ICDXTlGmhOyORlq4ux4cXB2MhIiIi0l2OOqVatGiBX3/9FQ8fPsTgwYOxYcMGeHp6onnz5ti6dStSU1P1HScRaYFtk4jyy5k7z1TuwMlIAIiOe4Mzd559FHEwFiIiIiLd5erte46Ojhg9ejQuXbqEefPmYf/+/Wjfvj3c3d0xdepUvHr1Sl9xEpEO2DaJKK/FJGju8MhJvvc9Dl3K+NhiISIiItIkV51Sjx49wuzZs1GmTBlMmDAB7du3x4EDBzB//nxs27YNrVu31lOYRKQLtk0iymvO1mZ6zfe+x6FLGR9bLEqvX7+W/Shy9+5dLFiwAHv37tVpOUeOHEGLFi3g7u4OhUKB7du3S9NSUlLw+eefw9fXF5aWlnB3d0fPnj1VhrIHBQVBoVDI/jp37pyr9SMiIiLd5ejte1u3bsXKlSuxZ88elC1bFkOHDkX37t1hZ2cn5alUqRIqV66srziJSAtsm0SUX6p7O8DN1gyP4t6ofW6RAoCrrRmqezt8FHG8z7EkvkzI83gAoFWrVmjbti0GDRqEFy9eoEaNGjA2NsbTp08xb948DB48WKvlJCYmomLFiujduzfatWsnm/bq1SucP38eU6ZMQcWKFfH8+XOMGjUKLVu2xLlz52R5+/fvj+nTp0ufzc3Nc7+SREREpJMc3SnVu3dvuLu74/jx47h48SKGDRsmu+gFgGLFimHy5Mn6iJGItMS2SUT5xdBAgWktygJ428GRkfLztBZlYWiQeeqHGQdjyd758+dRq1YtAMAvv/wCFxcX3L17F2vWrMF3332n9XKaNGmCr776Cm3btlWZZmtri3379qFjx44oVaoUPv30UyxcuBARERG4d++eLK+FhQVcXV2lP1tb29ytIBEREeksR3dKRUdHw8LCIss85ubmmDZtWo6CIqKcYdsk0q+///4bhw4dQkxMDNLT02XTpk6dWkBRvTsal3fDku5VELozUvZQbVdbM0xrURaNy7t9VHEwlqy9evUK1tbWAIC9e/eibdu2MDAwwKeffoq7d+/mWblxcXFQKBQqP9L8/PPPWLduHVxcXNCkSRNMmzZNik+dpKQkJCUlSZ/j4+PzKmQiIqKPRo46paytrREdHQ1nZ2dZemxsLJydnZGWlqaX4IhIN2ybRPrz008/YfDgwXBycoKrqysUiv/uKFEoFOyU+r/G5d3QoKwrztx5hpiEN3C2fjskLD/vwHmX4mAsmpUoUQLbt29HmzZtsGfPHowePRoAEBMTAxsbmzwp882bN5gwYQK6du0qK6Nbt27w9vaGq6srrl69iokTJ+LSpUvYt2+fxmWFhYUhNDQ0T+IkIiL6WOWoU0oIdU8nePsLkomJSa4CIqKcY9sk0p+vvvoKX3/9NT7//POCDuWdZ2iggF9xx4IO452JA2As6kydOhVdu3bF6NGjUa9ePfj5+QF4e9dUXjzrMCUlBZ07d0Z6ejoWL14sm9a/f3/p/+XLl4ePjw+qVauG8+fPo0qVKmqXN3HiRIwZM0b6HB8fDw8PD73HTURE9DHRqVNKOd5foVBg2bJlsLKykqalpaXhyJEjKF26tH4jJKJssW0S6d/z58/RoUOHgg6D6IPRvn171KxZE9HR0ahYsaKUXq9ePbRp00avZaWkpKBjx464c+cODh48mO2dWFWqVIGxsTFu3rypsVPK1NQUpqameo2TiIjoY6dTp9T8+fMBvL0bY+nSpTA0NJSmmZiYwMvLC0uXLtVvhESULbZNIv3r0KED9u7di0GDBhV0KEQfDOVDxTOqXr26XstQdkjdvHkT4eHhcHTM/i6xa9euISUlBW5u+fucLSIioo+dTp1Sd+7cAQDUqVMHW7duhb29fZ4ERUS6Ydsk0r8SJUpgypQpOHXqFHx9fWFsbCybPmLEiAKKjOj9lJiYiJkzZ+LAgQNqXx5w+/ZtrZbz8uVL/PPPP9LnO3fu4OLFi3BwcIC7uzvat2+P8+fP4/fff0daWhoePXoEAHBwcICJiQlu3bqFn3/+GU2bNoWTkxMiIyMxduxYVK5cGQEBAfpbYSIiIspWjp4pFR4eru84iEgP2DaJ9OfHH3+ElZUVDh8+jMOHD8umKRQKdkoR6ahfv344fPgwevToATc3N9nLA3Rx7tw51KlTR/qsfM5TcHAwQkJCsGPHDgBApUqVZPOFh4cjKCgIJiYmOHDgAL799lu8fPkSHh4eaNasGaZNmya705iIiIjyntadUmPGjMGXX34JS0tL2UMe1Zk3b16uAyMi7bBtEuUN5R2IRKQff/75J3bt2pXru5GCgoI0vtgD0PzSDyUPDw+VjmYiIiIqGFp3Sl24cAEpKSnS/zXJ6a9eRJQzbJtEeU95kct2RJRz9vb2cHBwKOgwiIiI6B2idadUxmFBHCJE9O5g2yTKO2vWrMGcOXNw8+ZNAEDJkiXx2WefoUePHgUcGdH758svv8TUqVOxevVqWFhYFHQ4RERE9A7I0TOliIiIPnTz5s3DlClTMGzYMAQEBEAIgePHj2PQoEF4+vQpRo8eXdAhEr1X5s6di1u3bsHFxQVeXl4qLw84f/58AUVGREREBUXrTqm2bdtqvdCtW7fmKBgi0h3bJlHeWLhwIZYsWYKePXtKaa1atUK5cuUQEhLCTikiHbVu3bqgQyAiIqJ3jNadUra2tnkZBxHlENsmUd6Ijo6Gv7+/Srq/vz+io6MLICKi99u0adMKOgQiIiJ6x2jdKbVy5cq8jIOIcohtkyhvlChRAps3b8akSZNk6Zs2bYKPj08BRUX0/ouIiMD169ehUChQtmxZVK5cuaBDIiIiogLCZ0oRERGpERoaik6dOuHIkSMICAiAQqHAsWPHcODAAWzevLmgwyN678TExKBz5844dOgQ7OzsIIRAXFwc6tSpg40bN6JQoUIFHWIOJQBI1iF/xqH0w/Ucy796Xp6uCv//34QCKt9Gzed4Nen5IT5THLrOk9OydCkzp+VRzuX3vlhQ+39GhbPPkq1/tVyOtsdA5b6vS93oox51WUZW7VObtps5T1Zlazp25g+tO6WqVKmCAwcOwN7eHpUrV87ytdh8UCVR/mHbJMob7dq1w+nTpzF//nxs374dQgiULVsWZ86c0enOjrCwMGzduhV//fUXzM3N4e/vj1mzZqFUqVJ5GD3Ru2f48OGIj4/HtWvXUKZMGQBAZGQkgoODMWLECGzYsKGAIyQiIqL8pnWnVKtWrWBqagqAD6okepewbRLlnapVq2LdunW5Wsbhw4cxdOhQfPLJJ0hNTcXkyZPRsGFDREZGwtLSUk+REr37du/ejf3790sdUgBQtmxZfP/992jYsGEBRkZEREQFRetOqYwPp+SDKoneHWybRPoTHx8PGxsb6f9ZUebLzu7du2WfV65cCWdnZ0RERKB27do5C5ToPZSeng5jY2OVdGNjY6SnpxdARERERFTQcvVMqXPnzkkPqixTpgyqVq2qr7iIKBfYNolyxt7eHtHR0XB2doadnZ3a4bBCCCgUCqSlpeWojLi4OACAg4NDrmIlet/UrVsXI0eOxIYNG+Du7g4A+PfffzF69GjUq1evgKMjIiKigpCjTqkHDx6gS5cuOH78OOzs7AAAL168gL+/PzZs2AAPDw99xkhEWmLbJMqdgwcPSp1F4eHhel++EAJjxoxBzZo1Ub58ebV5kpKSkJSUJH3O7o4tovfFokWL0KpVK3h5ecHDwwMKhQL37t2Dr69vrofJEhER0fspR51Sffr0QUpKCq5fvy49qPXGjRvo06cP+vbti7179+o1SCLSDtsmUe4EBgZK//f29pYunDMSQuD+/fs5Wv6wYcNw+fJlHDt2TGOesLAwhIaG5mj5RO8yDw8PnD9/Hvv27cNff/0lvTygfv36BR0aERERFZAcdUodPXoUJ06ckL05qFSpUli4cCECAgL0FhwR6YZtk0h/vL29paF8GT179gze3t46D98bPnw4duzYgSNHjqBIkSIa802cOBFjxoyRPsfHx/MuR/qgNGjQAA0aNCjoMIiIiOgdkKNOqaJFiyIlJUUlPTU1FYULF851UESUM2ybRPqjfHZUZi9fvoSZmZlOyxk+fDi2bduGQ4cOwdvbO8v8pqam0hs1id533333HQYMGAAzMzN89913WeYdMWKEVss8cuQI5syZg4iICERHR2Pbtm2yt8/26tULq1evls1To0YNnDp1SvqclJSEcePGYcOGDXj9+jXq1auHxYsXZ9lhTERERPqXo06p2bNnY/jw4fj+++9RtWpVKBQKnDt3DiNHjsQ333yj7xiJSEtsm0S5p7xLSaFQYMqUKbCwsJCmpaWl4fTp06hUqZLWyxs6dCjWr1+P3377DdbW1nj06BEAwNbWFubm5nqNnehdM3/+fHTr1g1mZmaYP3++xnwKhULrTqnExERUrFgRvXv3Rrt27dTmady4MVauXCl9NjExkU0fNWoUdu7ciY0bN8LR0RFjx45F8+bNERERAUNDQ63iICIiotzTulPK3t5e9otxYmIiatSoASOjt4tITU2FkZER+vTpI/u1iojyVn60Ta8Ju1TSomY2y9GyiN51Fy5cAPD2DqcrV67ILmZNTExQsWJFjBs3TuvlLVmyBAAQFBQkS1+5ciV69eqV63iJ3mV37txR+//caNKkCZo0aZJlHlNTU7i6uqqdFhcXh+XLl2Pt2rXS86zWrVsHDw8P7N+/H40aNdJLnERERJQ9rTulFixYkIdhEFFOsW0S6ZfyrXu9e/fGt99+Cxsbm1wtTwihj7CI3nvTp0/HuHHjZHcfAsDr168xZ84cTJ06VW9lHTp0CM7OzrCzs0NgYCC+/vpr6flwERERSElJQcOGDaX87u7uKF++PE6cOMFOKSIionykdadUcHBwXsZBRDnEtkmUNzIO/SGi3AsNDcWgQYNUOqVevXqF0NBQvXVKNWnSBB06dICnpyfu3LmDKVOmoG7duoiIiICpqSkePXoEExMT2Nvby+ZzcXGRhteqk5SUhKSkJOlzfHy8XuIlIiL6mOXomVIZvX79WuXByrn9VZmIco9tkyj3zp49iy1btuDevXtITk6WTdu6dWsBRUX0ftL08oBLly7BwcFBb+V06tRJ+n/58uVRrVo1eHp6YteuXWjbtq3O8SmFhYUhNDRUb3ESERERYJCTmRITEzFs2DA4OzvDysoK9vb2sj8iKhhsm0T6s3HjRgQEBCAyMhLbtm1DSkoKIiMjcfDgQdja2hZ0eETvDXt7ezg4OEChUKBkyZJwcHCQ/mxtbdGgQQN07Ngxz8p3c3ODp6cnbt68CQBwdXVFcnIynj9/LssXExMDFxcXjcuZOHEi4uLipL/79+/nWcxEREQfixzdKTV+/HiEh4dj8eLF6NmzJ77//nv8+++/+OGHHzBz5kx9x0hEWmLbJNKfGTNmYP78+Rg6dCisra3x7bffwtvbGwMHDoSbm1tBh0f03liwYAGEEOjTpw9CQ0NlnbomJibw8vKCn59fnpUfGxuL+/fvS+22atWqMDY2xr59+6TOsOjoaFy9ehWzZ8/WuBxTU1OYmprmWZxEREQfoxx1Su3cuRNr1qxBUFAQ+vTpg1q1aqFEiRLw9PTEzz//jG7duuk7TiLSAtsmkf7cunULzZq9fcukqakpEhMToVAoMHr0aNStW5fDeIi0pHz2obe3N/z9/WFsbJyr5b18+RL//POP9PnOnTu4ePGidPdVSEgI2rVrBzc3N0RFRWHSpElwcnJCmzZtAAC2trbo27cvxo4dC0dHRzg4OGDcuHHw9fWV3sZHRERE+SNHw/eePXsGb29vAG+fUfPs2TMAQM2aNXHkyBH9RUdEOmHbJNIfBwcHJCQkAAAKFy6Mq1evAgBevHiBV69eFWRoRO+lwMBAqUPq9evXiI+Pl/1p69y5c6hcuTIqV64MABgzZgwqV66MqVOnwtDQEFeuXEGrVq1QsmRJBAcHo2TJkjh58iSsra2lZcyfPx+tW7dGx44dERAQAAsLC+zcuROGhob6XWkiIiLKUo7ulCpWrBiioqLg6emJsmXLYvPmzahevTp27twJOzs7PYdIRNpi2yTSn1q1amHfvn3w9fVFx44dMXLkSBw8eBD79u1DvXr1Cjo8ovfOq1evMH78eGzevBmxsbEq09PS0rRaTlBQEIQQGqfv2bMn22WYmZlh4cKFWLhwoVZlEhERUd7I0Z1SvXv3xqVLlwC8fejj4sWLYWpqitGjR+Ozzz7Ta4BEpD22TSL9WbRoETp37gzgbXsaN24cHj9+jLZt22L58uUFHB3R++ezzz7DwYMHpe+mZcuWITQ0FO7u7lizZk1Bh0dEREQFIEd3So0ePVr6f506dXD9+nVERESgePHiqFixot6CIyLdsG0S6Udqaip27tyJRo0aAQAMDAwwfvx4jB8/voAjI3p/8bmHRERElFmOOqUy8/T0hKenpz4WRUR6xLZJlDNGRkYYPHgwrl+/XtChEH0wsnru4eDBgwsyNCIiIiogORq+BwAHDhxA8+bNUbx4cZQoUQLNmzfH/v379RkbEeUA2yaRftSoUQMXLlwo6DCIPhjK5x4CkJ57CIDPPSQiIvqI5ahTatGiRWjcuDGsra0xcuRIjBgxAjY2NmjatCkWLVqk7xiJSEtsm0T6M2TIEIwdOxaLFi3CyZMncfnyZdkfEemGzz0kIiKizHI0fC8sLAzz58/HsGHDpLQRI0YgICAAX3/9tSydiPIP2yaR/nTq1AnA2zakpFAoIISAQqHQ+k1hRPRW5uce/vXXXzh37hyfe0hERPQRy9GdUvHx8WjcuLFKesOGDREfH5/roIgoZ9g2ifTnzp07Kn+3b9+W/iUi7aWkpKBOnTr4+++/pbSiRYuibdu2H2GHVFsAZXIx//D//+W07Pyg7TlHfIa/nJaTm/nzgjIWm6yzrQvJkF/f65BN2VK56vyrxziyYNQkf8p5J2izPfKqXH2VXVjNn7b0sU9pKu/fTH/KvFn9qaPvY0hulqfL8UCXbVwAx8k1YVply1GnVMuWLbFt2zaV9N9++w0tWrTIySKJSA/YNon0R/miAE1/RKQ9Y2NjXL16FQqFoqBDISIioneI1sP3vvvuO+n/ZcqUwddff41Dhw7Bz88PAHDq1CkcP34cY8eO1X+URKQR2yZR3lizZk2W03v27JlPkRB9GHr27Inly5dj5syZBR0KERERvSO07pSaP3++7LO9vT0iIyMRGRkppdnZ2WHFihX44osv9BchEWWJbZMob4wcOVL2OSUlBa9evYKJiQksLCzYKUWko+TkZCxbtgz79u1DtWrVYGlpKZs+b968AoqMiIiICorWnVJ37tzJyziIKIfYNonyxvPnz1XSbt68icGDB/NNYUQ5cPXqVVSpUgUAZM+WAsBhfURERB+pHL19LyMhBACeTBC9a9g2ifTPx8cHM2fORPfu3fHXX38VdDhE75Xw8PCCDoGIiIjeMTl60Dnw9lkbvr6+MDc3h7m5OSpUqIC1a9fqMzYiygG2TaK8ZWhoiIcPHxZ0GETvrX/++Qd79uzB69evAfz3IwoRERF9fHJ0p9S8efMwZcoUDBs2DAEBARBC4Pjx4xg0aBCePn2K0aNH6ztOItIC2yaR/uzYsUP2WQiB6OhoLFq0CAEBAQUUFdH7KzY2Fh07dkR4eDgUCgVu3ryJYsWKoV+/frCzs8PcuXMLOkQiIiLKZznqlFq4cCGWLFkie8hrq1atUK5cOYSEhPDCl6iAsG0S6U/r1q1lnxUKBQoVKoS6devy4pkoB0aPHg1jY2Pcu3cPZcqUkdI7deqE0aNHa92ujhw5gjlz5iAiIgLR0dHYtm2brL1qGrY+e/Zs6XlwQUFBOHz4sGx6p06dsHHjRh3XioiIiHIjR51S0dHR8Pf3V0n39/dHdHR0roMiopxh2yTSn/T09IIOgeiDsnfvXuzZswdFihSRpfv4+ODu3btaLycxMREVK1ZE79690a5dO5Xpmb/v/vzzT/Tt21clb//+/TF9+nTps7m5udYxEBERkX7kqFOqRIkS2Lx5MyZNmiRL37RpE3x8fHRalteEXQCAqJnNchIKEWWgz7ZJ9DEaM2aM1nn5+noi3SQmJsLCwkIl/enTpzA1NdV6OU2aNEGTJk00Tnd1dZV9/u2331CnTh0UK1ZMlm5hYaGSl4iIiPJXjjqlQkND0alTJxw5cgQBAQFQKBQ4duwYDhw4gM2bN+s7RiLSEtsmUe5cuHBB9jkiIgJpaWkoVaoUgLevsTc0NETVqlULIjyi91rt2rWxZs0afPnllwDeDrNLT0/HnDlzUKdOnTwp8/Hjx9i1axdWr16tMu3nn3/GunXr4OLigiZNmmDatGmwtrbOkziIiIhIvRx1SrVr1w5nzpzBvHnzsH37dgghULZsWZw5cwaVK1fWd4xEpCW2TaLcyfjK+nnz5sHa2hqrV6+Gvb09AOD58+fo3bs3atWqVVAhEr235syZg6CgIJw7dw7JyckYP348rl27hmfPnuH48eN5Uubq1athbW2Ntm3bytK7desGb29vuLq64urVq5g4cSIuXbqEffv2aVxWUlISkpKSpM/x8fF5EjMREdHHROdOqZSUFAwYMABTpkzBunXr8iImIsoBtk0i/Zo7dy727t0rdUgBgL29Pb766is0bNgQY8eOLcDoiN4/ZcuWxeXLl7FkyRIYGhoiMTERbdu2xdChQ+Hm5pYnZa5YsQLdunWDmZmZLL1///7S/8uXLw8fHx9Uq1YN58+fR5UqVdQuKywsDKGhoXkSJxER0cdK504pY2NjbNu2DVOmTNFrIHy2FFHu5FXb1ETZZjNjG6YPRXx8PB4/foxy5crJ0mNiYpCQkFBAURG9v+7duwcPDw+1HTv37t1D0aJF9Vre0aNHcePGDWzatCnbvFWqVIGxsTFu3rypsVNq4sSJsufOxcfHw8PDQ2/xEhERfYwMcjJTmzZtsH37dj2HQkS5xbZJpD9t2rRB79698csvv+DBgwd48OABfvnlF/Tt21dlKBARZc/b2xtPnjxRSY+NjYW3t7fey1u+fDmqVq2KihUrZpv32rVrSElJyfKOLVNTU9jY2Mj+iIiIKHdy/Pa9L7/8EidOnEDVqlVhaWkpmz5ixAi9BEdEumHbJNKfpUuXYty4cejevTtSUlIAAEZGRujbty/mzJlTwNERvX+EEFAoFCrpL1++VBlel5WXL1/in3/+kT7fuXMHFy9ehIODg3S3VXx8PLZs2YK5c+eqzH/r1i38/PPPaNq0KZycnBAZGYmxY8eicuXKCAgIyMGaERERUU7lqFNq2bJlsLOzQ0REBCIiImTTFAoFL3yJCgjbJpH+WFhYYPHixZgzZw5u3boFIQRKlCih0tlLRFlTDnlTKBSYMmUKLCwspGlpaWk4ffo0KlWqpPXyzp07J3tbn3L5wcHBWLVqFQBg48aNEEKgS5cuKvObmJjgwIED+Pbbb/Hy5Ut4eHigWbNmmDZtGgwNDXOwhkRERJRTOeqUunPnjvR/IQQAqP3li4jyF9smkf5ZWlqiQoUKBR0G0XvrwoULAN5+L125cgUmJibSNBMTE1SsWBHjxo3TenlBQUHSd5wmAwYMwIABA9RO8/DwwOHDh7Uuj4iIiPJOjjqlgLfj9OfPn4+bN28CAHx8fDBq1Cj069cvVwHxgedEuZNXbZOIiCgnwsPDAQC9e/fGd999B2tr6wKOiIiIiN4VOeqUmjJlCubPn4/hw4fDz88PAHDy5EmMHj0aUVFR+Oqrr/QaJBFph22TiIjeNRlfDBAcHKwx39atW/MjHCIiInqH5KhTasmSJfjpp59k4/RbtmyJChUqYPjw4bzwJSogbJtERPSusbW1LegQiIiI6B2Vo06ptLQ0VKtWTSW9atWqSE1NzXVQRJQzbJtERPSuWblyZUGHQERERO8og5zM1L17dyxZskQl/ccff0S3bt1yHRQR5QzbJtG7afHixfD29oaZmRmqVq2Ko0ePFnRIREREREQFLlcPOt+7dy8+/fRTAMCpU6dw//599OzZU3o1LwDMmzcv91ESkdbYNoneLZs2bcKoUaOwePFiBAQE4IcffkCTJk0QGRmJokWLFnR4REREREQFJkedUlevXkWVKlUAALdu3QIAFCpUCIUKFcLVq1elfHwVPVH+YtskevfMmzcPffv2ld6AuWDBAuzZswdLlixBWFhYAUdHRERERFRwctQppXy1LxG9W9g2id4tycnJiIiIwIQJE2TpDRs2xIkTJ9TOk5SUhKSkJOlzfHx8nsZIRPq2FUDbLKZf11M5wwEszOF8SoW1nMcmB+XEazFfxuk5OdZpM39WMWgToy7Lyi6WrObJrMj///33////V8tl0sdH23acWW72KV3mzWl8+bHsvDrHyskxM+O8+jiG5EZWy32g99JyPHyPiEgdrwm7VNKiZjYrgEiICt7Tp0+RlpYGFxcXWbqLiwsePXqkdp6wsDCEhobmR3hERERERAUqRw86JyIiIu1lHjIrhNA4jHbixImIi4uT/u7fv58fIRIRERER5TveKUVERJRHnJycYGhoqHJXVExMjMrdU0qmpqYwNTXNj/CIiIiIiAoU75QiIiLKIyYmJqhatSr27dsnS9+3bx/8/f0LKCoiIiIioncD75QiIiLKQ2PGjEGPHj1QrVo1+Pn54ccff8S9e/cwaNCggg6NiIiIiKhAsVOKiIgoD3Xq1AmxsbGYPn06oqOjUb58efzxxx/w9PQs6NCIiIiIiAoUO6WIKM+peyMfwLfy0cdjyJAhGDJkSEGHQURERET0TuEzpYiIiIjovREWFoZPPvkE1tbWcHZ2RuvWrXHjxg1ZHiEEQkJC4O7uDnNzcwQFBeHatWuyPElJSRg+fDicnJxgaWmJli1b4sGDB/m5KkRERB89dkoRERER0Xvj8OHDGDp0KE6dOoV9+/YhNTUVDRs2RGJiopRn9uzZmDdvHhYtWoSzZ8/C1dUVDRo0QEJCgpRn1KhR2LZtGzZu3Ihjx47h5cuXaN68OdLS0gpitYiIiD5K7+zwPeVwHw7vIfpwqRvWxzZPRERZ2b17t+zzypUr4ezsjIiICNSuXRtCCCxYsACTJ09G27ZtAQCrV6+Gi4sL1q9fj4EDByIuLg7Lly/H2rVrUb9+fQDAunXr4OHhgf3796NRo0b5vl5EREQfI94pRURERETvrbi4OACAg4MDAODOnTt49OgRGjZsKOUxNTVFYGAgTpw4AQCIiIhASkqKLI+7uzvKly8v5cksKSkJ8fHxsj8iIiLKHXZKEREREdF7SQiBMWPGoGbNmihfvjwA4NGjRwAAFxcXWV4XFxdp2qNHj2BiYgJ7e3uNeTILCwuDra2t9Ofh4aHv1SEiIvrovLPD94jo48Q39RERkbaGDRuGy5cv49ixYyrTFAqF7LMQQiUts6zyTJw4EWPGjJE+x8fHs2OKiIgol9gpRUTvBT5/ioiIMho+fDh27NiBI0eOoEiRIlK6q6srgLd3Q7m5uUnpMTEx0t1Trq6uSE5OxvPnz2V3S8XExMDf319teaampjA1Nc2LVSEiIvpocfgeEREREb03hBAYNmwYtm7dioMHD8Lb21s23dvbG66urti3b5+UlpycjMOHD0sdTlWrVoWxsbEsT3R0NK5evaqxU4qIiIj0752/U4pv4SMiIiIipaFDh2L9+vX47bffYG1tLT0DytbWFubm5lAoFBg1ahRmzJgBHx8f+Pj4YMaMGbCwsEDXrl2lvH379sXYsWPh6OgIBwcHjBs3Dr6+vtLb+IiIiCjvvfOdUkqZh+6wk4qIOKSPiOjjs2TJEgBAUFCQLH3lypXo1asXAGD8+PF4/fo1hgwZgufPn6NGjRrYu3cvrK2tpfzz58+HkZEROnbsiNevX6NevXpYtWoVDA0N82tViIiIPnrvTadUZryDioh0wQ4sIqIPgxAi2zwKhQIhISEICQnRmMfMzAwLFy7EwoUL9RgdERER6eK97ZRSYucUEWWk6e19uuTl8YSIiIiIiCjvvfedUkrsnCIifeFdVURERERERHnvg+mUUsp4McmLSCLKa+zAIiIiIiIiypkPrlOKiCgv6GNYYF5gBxgREREREb2vPuhOqewuDHkxR0TvO12ei5XfeTNLT3qlVT4iIiIiIvo4FEinlPKtKQV9gVJ09JYCLZ/062poIwBAfHw8AO3ezkP/eVfaJemHLse3vMqbmXLfYtvUjbK+lMc2In3j92bO/FdfSWqmvsxiTuX3bBKAhP+SE40BAPFpGbKm/tfuX8Wn/P9/GeaRyn4tfY5PzVxeQoZ8med9neH/WXnzNsQs87zO8H/l8t5ks9yMMsagzXxJmfJl/qxtmbrOk9WyNFFTxqv4bObJuJ+8kuV9HZ+S4ZO6ZWhbf7p7E5/0/7nVl/ES6dotSGS3/koJ8o//byfK0hPjU/EawMv49Lf7flJBfVfquP01MsqQ3wja7aM5PXfXJa7MZeRm3oKmaVvp61igDzlrn9nTdh2zKv/tsT4+XgDp8f/Pqin/2/Tszi8UogDOQB48eAAPD4/8LpY+Mvfv30eRIkUKOoz3Btsl5Re2Td2wbVJ+YdvUze3bt1G8ePGCDoOIiOidlt35RYF0SqWnp+PGjRsoW7Ys7t+/Dxsbm/wO4aMXHx8PDw+PD7L+hRBISEiAu7s7DAwMCjqc90Z6ejoePnwIa2trKBSKgg4nVz7k/VvpfVxHts2cyaptvo/7QV5jnaiXVb2wbebMixcvYG9vj3v37sHW1ragw3kvsH3qhvWlG9aX7lhnumF96Ubb84sCGb5nYGCAwoULAwBsbGy4QQvQh1r/PDnUnYGBwQf3C/mHun9n9L6tI9um7rRpm+/bfpAfWCfqaaoXtk3dKU+wbW1tua/piO1TN6wv3bC+dMc60w3rS3vanF/w5zAiIiIiIiIiIsp37JQiIiIiIiIiIqJ8V2CdUqamppg2bRpMTU0LKoSPGuufPmQfw/79MawjZY/7gSrWiXqsF/1jneqOdaYb1pduWF+6Y53phvWVNwrkQedERERERERERPRx4/A9IiIiIiIiIiLKd+yUIiIiIiIiIiKifMdOKSIiIiIiIiIiyncF1im1ePFieHt7w8zMDFWrVsXRo0cLKpQPVkhICBQKhezP1dVVmi6EQEhICNzd3WFubo6goCBcu3atACMm0s2RI0fQokULuLu7Q6FQYPv27bLp7/s+HhYWhk8++QTW1tZwdnZG69atcePGDVme930dSZU+9uukpCQMHz4cTk5OsLS0RMuWLfHgwYN8XAv9y65eevXqpfKd9+mnn8ryfGj1oq9jxIdWL/mF57Jv8ZilG7Zb3SxZsgQVKlSAjY0NbGxs4Ofnhz///FOazrrKWlhYGBQKBUaNGiWlsc7k9HHN/DHVV14okE6pTZs2YdSoUZg8eTIuXLiAWrVqoUmTJrh3715BhPNBK1euHKKjo6W/K1euSNNmz56NefPmYdGiRTh79ixcXV3RoEEDJCQkFGDERNpLTExExYoVsWjRIrXT3/d9/PDhwxg6dChOnTqFffv2ITU1FQ0bNkRiYqKU531fR1Klj/161KhR2LZtGzZu3Ihjx47h5cuXaN68OdLS0vJrNfQuu3oBgMaNG8u+8/744w/Z9A+tXvR1jPjQ6iU/8Fz2Pzxm6YbtVjdFihTBzJkzce7cOZw7dw5169ZFq1atpE4B1pVmZ8+exY8//ogKFSrI0llnqnJ7zfyx1ZfeiQJQvXp1MWjQIFla6dKlxYQJEwoinA/WtGnTRMWKFdVOS09PF66urmLmzJlS2ps3b4Stra1YunRpPkVIpD8AxLZt26TPH+I+HhMTIwCIw4cPCyE+zHUkuZzs1y9evBDGxsZi48aNUp5///1XGBgYiN27d+db7Hkpc70IIURwcLBo1aqVxnk+hnrJyTHiY6iXvMBzWfV4zNId263u7O3txbJly1hXWUhISBA+Pj5i3759IjAwUIwcOVIIwf1LndxeM39s9ZUX8v1OqeTkZERERKBhw4ay9IYNG+LEiRP5Hc4H7+bNm3B3d4e3tzc6d+6M27dvAwDu3LmDR48eybaDqakpAgMDuR3og/Ah7uNxcXEAAAcHBwAf5jpS1rTZ5hEREUhJSZHlcXd3R/ny5T/4/eLQoUNwdnZGyZIl0b9/f8TExEjTPoZ6yckx4mOoF33juaz2uA9mj+1We2lpadi4cSMSExPh5+fHusrC0KFD0axZM9SvX1+WzjpTLzfXzB9jfelbvndKPX36FGlpaXBxcZGlu7i44NGjR/kdzgetRo0aWLNmDfbs2YOffvoJjx49gr+/P2JjY6W65nagD9WHto8LITBmzBjUrFkT5cuXB/DhrSNlT5tt/ujRI5iYmMDe3l5jng9RkyZN8PPPP+PgwYOYO3cuzp49i7p16yIpKQnAh18vOT1GfOj1khd4Lqs97oNZY7vVzpUrV2BlZQVTU1MMGjQI27ZtQ9myZVlXGmzcuBHnz59HWFiYyjTWmarcXjN/bPWVF4wKqmCFQiH7LIRQSaPcadKkifR/X19f+Pn5oXjx4li9erX08FduB/rQfSj7+LBhw3D58mUcO3ZMZdqHso6kvZxs8w99v+jUqZP0//Lly6NatWrw9PTErl270LZtW43zfSj1ou9jxIdSL3mJx17tcR9Uj+1WO6VKlcLFixfx4sUL/PrrrwgODsbhw4el6ayr/9y/fx8jR47E3r17YWZmpjEf6+w/eXXN/KHWV17I9zulnJycYGhoqNJrGBMTo9IDSfplaWkJX19f3Lx5U3qjALcDfag+pH18+PDh2LFjB8LDw1GkSBEp/UNaR9KONtvc1dUVycnJeP78ucY8HwM3Nzd4enri5s2bAD7sesnNMeJDrpe8wnNZ7XEf1IztVnsmJiYoUaIEqlWrhrCwMFSsWBHffvst60qNiIgIxMTEoGrVqjAyMoKRkREOHz6M7777DkZGRtI6s8400/Wa+WOvL33I904pExMTVK1aFfv27ZOl79u3D/7+/vkdzkclKSkJ169fh5ubG7y9veHq6irbDsnJyTh8+DC3A30QPoR9XAiBYcOGYevWrTh48CC8vb1l0z+EdSTdaLPNq1atCmNjY1me6OhoXL169aPaL2JjY3H//n24ubkB+DDrRR/HiA+xXvIaz2W1x31QFdtt7gkhkJSUxLpSo169erhy5QouXrwo/VWrVg3dunXDxYsXUaxYMdZZNnS9Zv7Y60sv8umB6jIbN24UxsbGYvny5SIyMlKMGjVKWFpaiqioqIII54M1duxYcejQIXH79m1x6tQp0bx5c2FtbS3V88yZM4Wtra3YunWruHLliujSpYtwc3MT8fHxBRw5kXYSEhLEhQsXxIULFwQAMW/ePHHhwgVx9+5dIcT7v48PHjxY2NraikOHDono6Gjp79WrV1Ke930dSZU+9utBgwaJIkWKiP3794vz58+LunXriooVK4rU1NSCWq1cy6peEhISxNixY8WJEyfEnTt3RHh4uPDz8xOFCxf+oOtFX8eID61e8gPPZf/DY5Zu2G51M3HiRHHkyBFx584dcfnyZTFp0iRhYGAg9u7dK4RgXWkj49v3hGCdZaaPa+aPqb7yQoF0SgkhxPfffy88PT2FiYmJqFKlivQaVNKfTp06CTc3N2FsbCzc3d1F27ZtxbVr16Tp6enpYtq0acLV1VWYmpqK2rVriytXrhRgxES6CQ8PFwBU/oKDg4UQ7/8+rm7dAIiVK1dKed73dSRV+tivX79+LYYNGyYcHByEubm5aN68ubh3714BrI3+ZFUvr169Eg0bNhSFChUSxsbGomjRoiI4OFhlnT+0etHXMeJDq5f8wnPZt3jM0g3brW769OkjtbNChQqJevXqSR1SQrCutJG5U4p1JqePa+aPqb7ygkIIIfLqLiwiIiIiIiIiIiJ18v2ZUkREREREREREROyUIiIiIiIiIiKifMdOKSIiIiIiIiIiynfslCIiIiIiIiIionzHTikiIiIiIiIiIsp37JQiIiIiIiIiIqJ8x04pIiIiIiIiIiLKd+yUIiIiIiIiIiKifMdOqRxatWoV7OzspM8hISGoVKmSTstQKBTYvn27xulRUVFQKBS4ePFijmLMa4cOHYJCocCLFy8KOhTKA+/zPp459oLg5eWFBQsW5EtZPXr0wIwZM6TPr169Qrt27WBjY/NettHff/8dlStXRnp6ekGHQnoSFBSEUaNGFXQYMtkdn4iIiIgo77FTiogoFzR1gJ09exYDBgzI8/IvX76MXbt2Yfjw4VLa6tWrcfToUZw4cQLR0dGwtbXN8zj0qXnz5lAoFFi/fn1Bh0J6snXrVnz55ZcA8rfDFtDcoR4dHY0mTZrkWxxERB+CnPxIqU9TpkyRnV8JITBgwAA4ODi80z/ma3LlyhUUKVIEiYmJBR0KUYFhp9RHJi0tjXcfEGkhOTk5V/MXKlQIFhYWeopGs0WLFqFDhw6wtraW0m7duoUyZcqgfPnycHV1hUKhUJkvt+uX13r37o2FCxcWdBikJw4ODrJ9VB9yuw+7urrC1NRUT9EQEb3/FApFln+9evXCuHHjcODAgQKJ7/Hjx/j2228xadIkKW337t1YtWoVfv/9d0RHR6N8+fIFEltO+fr6onr16pg/f35Bh0JUYD7qTqlffvkFvr6+MDc3h6OjI+rXr4/ExEQcOXIExsbGePTokSz/2LFjUbt2ba2WffbsWTRo0ABOTk6wtbVFYGAgzp8/r5JP+Uutubk5vL29sWXLliyXGxkZiaZNm8LKygouLi7o0aMHnj59qjG/8i6O33//HWXLloWpqSnu3r2rVXwKhQLLli1DmzZtYGFhAR8fH+zYsUNjWa9fv0azZs3w6aef4tmzZ9nUEOWHj2EfB97u50WLFoWFhQXatGmD2NhY2fRevXqhdevWsrRRo0YhKChI+hwUFIRhw4ZhzJgxcHJyQoMGDQAA8+bNg6+vLywtLeHh4YEhQ4bg5cuXAN4OYe3duzfi4uKkE7aQkBAAqneD3Lt3D61atYKVlRVsbGzQsWNHPH78WJqu/OVx7dq18PLygq2tLTp37oyEhASN652eno4tW7agZcuWsvWYO3cujhw5AoVCIa2jl5cXvvrqK/Tq1Qu2trbo378/AODzzz9HyZIlYWFhgWLFimHKlClISUlRiWvFihUoWrQorKysMHjwYKSlpWH27NlwdXWFs7Mzvv76a1lscXFxGDBgAJydnWFjY4O6devi0qVL0vRLly6hTp06sLa2ho2NDapWrYpz585J01u2bIkzZ87g9u3bGtef3h/K4XtBQUG4e/cuRo8eLbUZpRMnTqB27dowNzeHh4cHRowYIfvlOCf78KpVqxAaGopLly5J5a1atQqA6vC9K1euoG7dutLxcsCAAVJbB/47jnzzzTdwc3ODo6Mjhg4dKmsvRETvs+joaOlvwYIFsLGxkaV9++23sLKygqOjY4HEt3z5cvj5+cHLy0tKu3XrFtzc3ODv7w9XV1cYGRmpzPc+/BC3ZMkSpKWlFXQoRAXio+2Uio6ORpcuXdCnTx9cv34dhw4dQtu2bSGEQO3atVGsWDGsXbtWyp+amop169ahd+/eWi0/ISEBwcHBOHr0KE6dOgUfHx80bdpU5QJzypQpaNeuHS5duoTu3bujS5cuuH79usaYAwMDUalSJZw7dw67d+/G48eP0bFjxyxjefXqFcLCwrBs2TJcu3YNzs7OWscXGhqKjh074vLly2jatCm6deumtsMpLi4ODRs2RHJyMg4cOAAHBwet6onyzseyj58+fRp9+vTBkCFDcPHiRdSpUwdfffWVVuuQ2erVq2FkZITjx4/jhx9+AAAYGBjgu+++w9WrV7F69WocPHgQ48ePBwD4+/urnLSNGzdOZblCCLRu3RrPnj3D4cOHsW/fPty6dQudOnWS5bt16xa2b9+O33//Hb///jsOHz6MmTNnaoz38uXLePHiBapVqyalbd26Ff3794efnx+io6OxdetWadqcOXNQvnx5REREYMqUKQAAa2trrFq1CpGRkfj222/x008/qfxad+vWLfz555/YvXs3NmzYgBUrVqBZs2Z48OABDh8+jFmzZuGLL77AqVOnpPVt1qwZHj16hD/++AMRERGoUqUK6tWrJx0/unXrhiJFiuDs2bOIiIjAhAkTYGxsLJXp6ekJZ2dnHD16NPsNR++NrVu3okiRIpg+fbrUZoC3HUKNGjVC27ZtcfnyZWzatAnHjh3DsGHDZPPrug936tQJY8eORbly5aTyMrc74O33ZOPGjWFvb4+zZ89iy5Yt2L9/v0r54eHhuHXrFsLDw7F69WqsWrVK6uQiInrfubq6Sn+2trZQKBQqaZmH7yk77GfMmAEXFxfY2dkhNDQUqamp+Oyzz+Dg4IAiRYpgxYoVsrL+/fdfdOrUCfb29nB0dESrVq0QFRWVZXwbN26U/RDXq1cvDB8+HPfu3YNCoZA6q3LyQyMg/zG/VKlSsLCwQPv27ZGYmIjVq1fDy8sL9vb2GD58uKwDKTk5GePHj0fhwoVhaWmJGjVq4NChQ9L0u3fvokWLFrC3t4elpSXKlSuHP/74Q5reqFEjxMbG4vDhw9puKqIPi/hIRURECAAiKipK7fRZs2aJMmXKSJ+3b98urKysxMuXL4UQQqxcuVLY2tpK06dNmyYqVqyosbzU1FRhbW0tdu7cKaUBEIMGDZLlq1Gjhhg8eLAQQog7d+4IAOLChQtCCCGmTJkiGjZsKMt///59AUDcuHFDbbkrV64UAMTFixc1xpZVfF988YX0+eXLl0KhUIg///xTCCFEeHi4ACD++usvUbFiRdG2bVuRlJSUZTmUfz6WfbxLly6icePGsrROnTrJYg8ODhatWrWS5Rk5cqQIDAyUPgcGBopKlSppXD+lzZs3C0dHR+lz5npS8vT0FPPnzxdCCLF3715haGgo7t27J02/du2aACDOnDkjhHhbvxYWFiI+Pl7K89lnn4kaNWpojGXbtm3C0NBQpKenZ7luynhat26d7frNnj1bVK1aVfqsLq5GjRoJLy8vkZaWJqWVKlVKhIWFCSGEOHDggLCxsRFv3ryRLbt48eLihx9+EEIIYW1tLVatWpVlLJUrVxYhISHZxkzvvsDAQDFy5EghhLxtKPXo0UMMGDBAlnb06FFhYGAgXr9+Lc2X031Y3bELgNi2bZsQQogff/xR2NvbS8c/IYTYtWuXMDAwEI8ePRJCvD2OeHp6itTUVClPhw4dRKdOnbKNiYjofaPp/CbzMTU4OFhYW1uLoUOHir/++kssX75cABCNGjUSX3/9tfj777/Fl19+KYyNjaXzoMTEROHj4yP69OkjLl++LCIjI0XXrl1FqVKlNF5LPHv2TCgUCnHq1Ckp7cWLF2L69OmiSJEiIjo6WsTExAgh3n7nWFlZic8++0z89ddf4vr160IIIebPny8OHjwobt++LQ4cOCBKlSolnZMq19nY2Fg0aNBAnD9/Xhw+fFg4OjqKhg0bio4dO4pr166JnTt3ChMTE7Fx40Zpvq5duwp/f39x5MgR8c8//4g5c+YIU1NT8ffffwshhGjWrJlo0KCBuHz5srh165bYuXOnOHz4sGz9qlevznMe+mh9tHdKVaxYEfXq1YOvry86dOiAn376Cc+fP5em9+rVC//884/0y/+KFSvQsWNHWFpaarX8mJgYDBo0CCVLloStrS1sbW3x8uVL3Lt3T5bPz89P5bOmu0giIiIQHh4OKysr6a906dIA3t7JoImJiQkqVKiQo/gyzmdpaQlra2vExMTI8tSvXx/FihXD5s2bYWJiojEOyl8fyz5+/fp1tWXkRMY7jpTCw8PRoEEDFC5cGNbW1ujZsydiY2N1eiDl9evX4eHhAQ8PDymtbNmysLOzk9WFl5eX7Lk7bm5uKu0to9evX8PU1FTtM6PUUbd+v/zyC2rWrAlXV1dYWVlhypQpKtswc1wuLi4oW7YsDAwMZGnKWCMiIvDy5Us4OjrKtuWdO3ek7ThmzBj069cP9evXx8yZM9VuX3Nzc7x69UqrdaP3W0REBFatWiXbXxo1aoT09HTcuXNHypfTfTg7169fR8WKFWXHv4CAAKSnp+PGjRtSWrly5WBoaCh9zq6NEhF9DBwcHPDdd9+hVKlS6NOnD0qVKoVXr15h0qRJ8PHxwcSJE2FiYoLjx48DeHvHk4GBAZYtWwZfX1+UKVMGK1euxL1792R3GGV09+5dCCHg7u4updna2sLa2hqGhoZwdXVFoUKFpGklSpTA7NmzUapUKelcctSoUahTpw68vb1Rt25dfPnll9i8ebOsnJSUFCxZsgSVK1dG7dq10b59exw7dgzLly9H2bJl0bx5c9SpUwfh4eEA3p6fbtiwAVu2bEGtWrVQvHhxjBs3DjVr1sTKlSsBvH2EQ0BAAHx9fVGsWDE0b95c5XEZhQsXzvZOMaIPleqg24+EoaEh9u3bhxMnTmDv3r1YuHAhJk+ejNOnT8Pb2xvOzs5o0aIFVq5ciWLFiuGPP/7QeJBUp1evXnjy5AkWLFgAT09PmJqaws/PT6sxzZouMNPT09GiRQvMmjVLZZqbm5vG5Zmbm6ssU9v4Mg6nUcaW+UHpzZo1w6+//orIyEj4+vpmuW6Ufz6WfVwIkW15BgYGKvnUPQcmc4fc3bt30bRpUwwaNAhffvklHBwccOzYMfTt21en58gIIdSuc+Z0bdpbRk5OTnj16hWSk5O16hDOvH6nTp1C586dERoaikaNGsHW1hYbN27E3LlzZfnUxZVVrOnp6XBzc1O7PynfVBgSEoKuXbti165d+PPPPzFt2jRs3LgRbdq0kfI+e/ZMdoJJH6709HQMHDgQI0aMUJlWtGhR6f853Yezo6mNAshVGyUi+hiUK1dO5YeqjA8cNzQ0hKOjo+zHq3/++UflBRhv3rzR+CPk69evAQBmZmZaxaTph8YZM2YgMjIS8fHxSE1NxZs3b5CYmCh9v1hYWKB48eKydfHy8oKVlZUsTbku58+fhxACJUuWlJWVlJQkPXtrxIgRGDx4MPbu3Yv69eujXbt2KjcM8Ic4+ph9tJ1SwNuTyYCAAAQEBGDq1Knw9PTEtm3bMGbMGABAv3790LlzZxQpUgTFixdHQECA1ss+evQoFi9ejKZNmwIA7t+/r/ZhzadOnULPnj1lnytXrqx2mVWqVMGvv/4KLy8vtQ/x04W28Wlj5syZsLKyQr169XDo0CGULVs2V7GR/nwM+3jZsmWlu70ylpFRoUKFcPXqVVnaxYsXVS4wMzt37hxSU1Mxd+5c6WQr8y9qJiYm2T6YsmzZsrh37x7u378v3S0V+b/27jekye6NA/g3LUxfKIVTK8rR1g2BiC4EC7KyxTIwi0KTsRViKfifoF6kiRGKkgrpi6AwVEQjMAoKFcq0ZjlNTMxiIzclK8wUKxAjOc+LH45nTWtOf+4pvx/Ym3Hus+vAGey+rnvnGhjA5OQktm/f/strf2X2TIeBgQGX2jMbDAYEBwfjwoULtveGhoZcjmeWSqXCx48fsXr1arvDSH8mSRIkSUJOTg4SExNx8+ZNW1Jq9ofpfHuF/lxzfWdUKhVevXoFpVK5oLmc2cPOfkerq6vtbkwMBgM8PDwcbjSIiMieK8WrHTt2oK6uzmGu+YpR/v7+AICJiQmnClauFhpdWYunpydevHhh9yQtAFsiKzk5GRqNBvfv30dLSwuKiopQWlqKjIwM29jx8XG7ZBjRSrJi/77X2dmJwsJCdHd3Y3h4GI2Njfj06ZPdDeJs1fXy5ctOH/48S6lUora2Fq9fv0ZnZye0Wi28vb0dxt2+fRtVVVUwmUzIz8+H0Wh0OFh1VlpaGsbHx5GYmGjrStXS0oKkpKQFd2twNj5nXblyBVqtFtHR0Xjz5o3L89DSWSl7PDMzE01NTSgpKYHJZEJlZSWamprsxkRHR6O7uxs1NTUwm83Iz893SFLNRaFQ4MePH6ioqMDg4CBqa2tx7do1uzFyuRzfvn3Dw4cPMTY2NmeVS61WIzQ0FFqtFj09PTAajdDr9dizZ8+clTxnyWQyqFQqPH361KXrlUolhoeH0dDQgLdv3+Lq1au4c+eOy/HMUqvV2LlzJ44cOYLm5mZYrVZ0dHQgNzcX3d3dmJqaQnp6Oh4/foyhoSEYDAZ0dXXZ7c3nz5/bnr6jv4tcLkd7eztGRkZsiezz58/j2bNnSEtLQ29vL8xmM+7du2f3g30uzuxhuVwOi8WC3t5ejI2NYXp62mEerVaLtWvX4uTJk+jv70draysyMjKg0+kQGBi4dIsnIiKoVCqYzWYEBARAqVTavfz8/Oa8RqFQwNfXFwMDAy595r8LjZGRkZAkCe/fv1/MMgAA4eHhmJmZwejoqMNagoKCbOM2b96M1NRUNDY24uzZs7h+/brdPP39/SzE0Yq1YpNSvr6+aG9vx6FDhyBJEnJzc1FaWoqYmBjbGA8PD5w6dQozMzN2T3o4o6qqChMTEwgPD4dOp0NmZiYCAgIcxhUUFKChoQGhoaGorq5GXV3dvE8abdy4EQaDATMzM9BoNAgJCUFWVhb8/PzsHpldyvgWory8HPHx8YiOjobJZFrUXLR4K2WPR0ZG4saNG6ioqEBYWBhaWlqQm5trN0aj0SAvLw/nzp1DREQEvn796tR6w8LCUFZWhuLiYoSEhKCurg5FRUV2Y3bt2oXU1FQkJCRAJpOhpKTEYZ7Z1vPr1q1DVFSU7Ry2W7du/TaG3zlz5syclUZnxMXFIScnB+np6QgLC0NHR4eto9lirFq1Cg8ePEBUVBSSkpIgSRJOnDgBq9WKwMBAeHp64vPnz9Dr9ZAkCfHx8YiJiUFBQYFtjvr6emi1Wvj4+Cw6HvpvuXTpEqxWKxQKha3aHRoaira2NpjNZuzevRvh4eHIy8v75V/TAef28LFjx3Dw4EHs27cPMpkM9fX1DvP4+PigubkZ4+PjiIiIwPHjx7F//35UVlYu3cKJiAjA/woB/v7+iIuLw5MnT2CxWNDW1oasrCy8e/duzms8PDygVqtdLsQ5U2h0hSRJ0Gq10Ov1aGxshMViQVdXF4qLi20d9rKzs9Hc3AyLxYKenh48evTIrhBntVoxMjICtVq96HiI/khuPGT9j5CcnCxiY2PdHQbR/w33+J9tampKbNmyRXR0dLg7lCUzOjoq1q9fLwYHB90dChER0Yq0kO57P3c4/nfH1Vk/d1798OGD0Ov1wt/fX3h5eYmtW7eK06dPi8nJyXljampqEps2bbLr/lteXi6Cg4N/+/lCCFFWViY2bNggvL29hUajETU1NQKAmJiYmHfNc3Vw/XnN379/FxcvXhRyuVysWbNGBAUFiaNHj4q+vj4hhBDp6elCoVAILy8vIZPJhE6nE2NjY7brCwsLhUajmXfdRH+7VUI4cUrwCjQ5OYmuri4cPnwYd+/exYEDB9wdEtGS4h7/e7S1teHLly+IjY11dyhLwmg0wmKxICEhwd2hEBER0X+EEAKRkZHIzs5GYmKiu8NZEtPT09i2bRvq6+sXdLYr0d+ESal57N27F0ajESkpKSgvL3d3OERLjnuciIiIiP4kL1++RF9fH3Q6nbtDWRImkwmtra1ISUlxdyhEbsOkFBERERERERERLbsVe9A5ERERERERERG5D5NSRERERERERES07JiUIiIiIiIiIiKiZcekFBERERERERERLTsmpYiIiIiIiIiIaNkxKUVERERERERERMuOSSkiIiIiIiIiIlp2TEoREREREREREdGyY1KKiIiIiIiIiIiW3T88Y3XRiyeJhAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -2097,8 +2073,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|█████████████████████████████████| 101/101 [12:09<00:00, 7.23s/it]\n", - "Reindexing: 100%|█████████████| 5/5 [00:00<00:00, 5.15model snapshot/s]\n" + "100%|█████████████████████████████████| 101/101 [02:20<00:00, 1.40s/it]\n", + "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.67model snapshot/s]\n" ] } ], @@ -2135,7 +2111,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -2227,7 +2203,7 @@ " (Total: 6)" ] }, - "execution_count": 53, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -2239,6 +2215,7 @@ "for i in [5, 6, 7, 8]:\n", " new_params = original_params.copy()\n", " new_params[\"kappa\"] = 10**i\n", + " new_params[\"num_epochs\"] = 100\n", " new_model_params_name = f\"tutorial_kappa{i}_mini\"\n", " new_params_key = {\n", " \"model_params_name\": new_model_params_name,\n", @@ -2260,29 +2237,27 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", - "exists. Use `overwrite=True` or pick a different name\n", - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/411c\n", - "8460ca6c2e53b6e62826b7e49bd7_ar\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/411c8460ca6c2e53b6\n", + "e62826b7e49bd7/411c8460ca6c2e53b6e62826b7e49bd7_ar\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [00:45<00:51, 1.97s/it]" + " 49%|█████████████████▏ | 25/51 [00:32<00:33, 1.27s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2294,12 +2269,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [01:36<00:02, 2.06s/it]" + " 98%|██████████████████████████████████▎| 50/51 [01:05<00:01, 1.27s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2311,7 +2286,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [01:39<00:00, 1.94s/it]\n", + "100%|███████████████████████████████████| 51/51 [01:07<00:00, 1.32s/it]\n", "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:589: UserWarning:\n", "\n", "'kappa' with will be cast to \n", @@ -2322,20 +2297,54 @@ "name": "stdout", "output_type": "stream", "text": [ - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/411c\n", - "8460ca6c2e53b6e62826b7e49bd7_ar\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/411c8460ca6c2e53b6\n", + "e62826b7e49bd7/411c8460ca6c2e53b6e62826b7e49bd7_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|████████▍ | 25/101 [00:33<01:40, 1.32s/it]" ] }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|████████████████▊ | 50/101 [01:06<01:07, 1.32s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [02:48<02:55, 6.73s/it]" + " 74%|█████████████████████████▏ | 75/101 [01:40<00:34, 1.32s/it]" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAD6CAYAAABwKvR6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACN4klEQVR4nOzdd1gUx/8H8PcdvVfpCoixEMFuBAv2XmLX2HvvJmqMBTX2Gmtib7HEqNHYC/beRYwxRoRE0CgKiIqU+f3h7/brcndwHMiJvl/Pc4/e7OzsZ2d3dveG3VmFEEKAiIiIiIiIiIgoDykNHQAREREREREREX162ClFRERERERERER5jp1SRERERERERESU59gpRUREREREREREeY6dUkRERERERERElOfYKUVERERERERERHmOnVJERERERERERJTn2ClFRERERERERER5jp1SRERERERERESU59gpRUSUz6xYsQIKhQLW1tZq006dOoWePXuiXLlyMDMzg0KhQGRkpMZy5s+fjxYtWsDX1xcKhQLVq1fPUVxXr17Fl19+CQ8PD1haWqJ48eKYNGkSXr58qXUeIQSqVasGhUKBgQMHaszz4MEDdO/eHR4eHjAzM4OnpyeaN2+ulu/x48fo2rUrnJ2dYWlpiaCgIBw5ciRH66Sr3377DSEhIbC1tYWVlRU+//xz/PTTT9kqIy0tDXPnzkX9+vXh5eUFS0tLlChRAqNHj8bz58/1jq169epQKBRqn/r168vyRUdHo3nz5ihcuDCsrKxgZ2eHMmXKYNGiRUhNTVUrs2TJkjrH8OTJEwwZMgQ+Pj4wMzODq6srGjRogLi4OL3XS5f9Yvv27Wjfvj2KFCkCCwsL+Pj4oEOHDrh7965aecnJyZg1axZKliwJKysrKcYzZ87I8l2+fBkDBgxAQEAAbGxs4Orqitq1a+Po0aMa4xRCYPXq1ahYsSKsrKxga2uLsmXL4rfffpPyREZGQqFQYPbs2Vmud9euXTVuT9Xn3LlzulRfpr777jsoFAqN2/jNmzcYP348fH19YWpqCm9vb4wZMwavXr2S5VuzZg0UCgUuXbqkdxzVq1eXHZdUZWr7TJ8+Xe9lvW/Hjh2DQqHAtm3bpLQzZ85g4sSJOWrfuSGzODJug7ySnW2dWd7Y2Ng8j52IiLLH2NABEBGR7v7991+MHDkSHh4eiI+PV5t+5MgRHD58GGXKlIGtrS2OHTumtaxly5bBysoKNWvWxO7du3MUV0REBIKDg1GsWDHMnz8fzs7OOHHiBCZNmoTLly/LfoC/a/Hixfjrr7+0lhseHo7q1aujcOHCmD17Nry8vBATE4MDBw7I8iUnJ6NWrVp4/vw5FixYABcXFyxevBj169fH4cOHERISkqP1y8z06dMxduxY9O3bF2PGjIGJiQn++OMPvHnzJlvlvHr1ChMnTkT79u3Rs2dPODs748qVK5gyZQp2796NS5cuwcLCQq8YCxcujI0bN8rS7O3tZd+TkpJga2uLcePGoVChQnjz5g327t2LQYMG4dq1a1ixYoVey3748CGqVq0KY2NjjBs3Dp999hmePHmCsLCwbNeRiq77xYwZM+Dm5oaxY8eicOHCiI6OxtSpU1G2bFmcO3cOn3/+uZS3V69e2LhxI8aMGYOaNWsiLi4O06dPR0hICE6fPo2KFSsCADZt2oQLFy6ge/fuKFWqFJKSkrBs2TLUqlULa9euRefOnWUx9OvXD2vWrMGwYcMwbdo0pKam4ubNm5l21mZm3Lhx6Nu3r1p6kyZNYGZmhgoVKuhVrsq1a9cwe/ZsuLq6apzevn177N27F+PHj0eFChVw9uxZTJkyBbdu3cKuXbtytOysNGrUCGfPnlVLHz9+PA4dOqSxs/pDdubMGYSGhqJr165q7fFDiWPJkiUGiUmfbb169WoUL15clubk5PTeYiQiolwiiIgo32jcuLFo0qSJ6NKli7CyslKbnpaWJv1/1qxZAoC4f/++xrLezfv555+LkJAQveMaO3asACD++usvWXrv3r0FABEXF6c2z/3794W1tbXYvn27ACAGDBggm56eni5Kly4tSpcuLV6/fp3p8hcvXiwAiDNnzkhpKSkpwt/fX1SsWFHv9crKpUuXhFKpFDNmzMhxWampqeLJkydq6b/88osAINavX69XuSEhIeLzzz/XO642bdoIY2Nj2TbITpnNmjUTnp6eGvcBfWRnv3j06JFa2r///itMTExEjx49pLTXr18LIyMj0bFjR1nehw8fCgBi8ODBmZaZmpoqAgMDhZ+fnyx9x44dAoDYsmVLpnHev39fABCzZs3KNJ82x44dEwDEd999p9f8KikpKaJ06dJi8ODBGrfx2bNnBQAxZ84cWfrUqVMFAHHw4EEpbfXq1QKAuHjxot7xhISEZHlcevHihbC2thZVqlTReznZlZ6eLl6+fJmtecLCwgQA8csvv0hpWR2j9ZWUlJSt/O8rjtymbVvnxr5GRESGw8f3iIjyiQ0bNuD48eOZ/uVaqdT9sJ6dvOfPn0eTJk3g5OQEc3Nz+Pn5YejQodJ0ExMTAICdnZ1sPnt7eyiVSpiamqqV2bt3b9SpU0fr3Q0nTpzAtWvXMHToUJiZmWUa344dO1CsWDEEBQVJacbGxujYsSMuXLiAf//9V0pPT0/HwoULUbp0aVhYWMDe3h6VKlWS3eWxZcsW1K1bF+7u7rCwsJAeo0tKSpItd9GiRTAzM8OgQYMyjU+X5RoZGWn8q77qDp3o6GhZekJCAkaOHCk9RuXp6YmhQ4eqxZhTBQoUgFKphJGRkdq0kydPolKlSrCwsICnpyfGjRuHtLQ0aXpkZCR27dqFXr16wcHBIctl3b17F1999RVcXFxgZmaGEiVKYPHixbI82dkvXFxc1NI8PDzg5eUlq0+lUgmlUqm2/9ra2kKpVMLc3DzTMo2MjFCuXDm1bbRgwQL4+PigTZs2mcapkp6eju+//x6FChWCubk5ypcvr9MjqCtXroRCoUD37t3Vpm3ZsgVBQUGwsrKCtbU16tWrh6tXr2osZ/r06YiLi8P333+vcfrp06cBAA0bNpSlN27cGADw66+/qs3z7NkzdOvWDY6OjrCyskKTJk3w999/y/IIITBz5kx4e3vD3NwcZcuWxb59+7Jcb9X6vXjxAj179tQpv8rr168xYsQIlC5dGnZ2dnB0dERQUJDGuzpVjxcvW7YMJUqUgJmZGdauXZut5WU0ceJEfP311wAgPUKtUChkd7fqsu26du0Ka2tr3Lx5E3Xr1oWNjQ1q1aoFADh06BCaNWsGLy8vmJubo0iRIujTpw+ePHmicxyaHt+Li4tD//794enpCVNTUxQuXBhjx45FcnKyxnpbv349SpQoAUtLS5QqVQq///67XnWm77YmIqIPGzuliIjygcePH2Po0KGYPn06vLy88nTZBw4cQNWqVREVFYW5c+di3759+O677/Do0SMpT5cuXWBvb49+/frh77//RmJiIn7//Xf8+OOPGDBgAKysrGRlrlixAhcuXMCiRYu0LvfEiRMAABsbGzRs2BDm5uawtrZG48aN8ccff8jyhoeHIzAwUK0MVdqtW7ektK5du2LIkCGoUKECtmzZgs2bN6Np06aysbfu3r2Lhg0bYuXKldi/fz+GDh2KrVu3okmTJmoxlihRAr/++iuKFSsGIyMjeHl5YfTo0WqPpumyXE1UYxW9+6jZy5cvERISgrVr12Lw4MHYt28fRo0ahTVr1qBp06YQQsjKuHfvHhwdHWFsbAw/Pz+MHTtWbQwgFSEEUlNT8ezZM2zZsgVr1qzBiBEjYGwsf+I/NjYW7dq1Q4cOHfDbb7+hVatWmDJlCoYMGSLlOXnyJIQQ8PDwQPv27WFtbQ1zc3NUr15d7dGciIgIVKhQAeHh4ZgzZw5+//13NGrUCIMHD0ZoaKiszgHd9gtN/v77bzx48EBWnyYmJujfvz/Wrl2LnTt3IiEhAZGRkejVqxfs7OzQq1evTMtMTU3FyZMnZWWmpqbi7NmzKFOmDObOnQtvb28YGRlJjxxm3EbA207O/fv3Y/78+diwYQOUSiUaNGig8TEmlfj4eGzbtg21atWCr6+vbNrUqVPRvn17+Pv7Y+vWrVi/fj0SExNRtWpVREREyPJGRERgypQpWLp0qcbx6gBI+3TGzkDV9xs3bqjN06NHDyiVSvz888+YP38+Lly4gOrVq8vGLwoNDcWoUaNQp04d7Ny5E/369UOvXr1w584dreutsnLlStja2qJ169ZZ5n1XcnIy4uLiMHLkSOzcuRObNm1ClSpV0KJFC6xbt04t/86dO7F06VKMHz9eOiYCgI+PD3x8fLK1bADo2bOn1Jm9fft2nD17FmfPnkXZsmUBZG/bvXnzBk2bNkXNmjXx22+/Se3l3r17CAoKwtKlS3Hw4EGMHz8e58+fR5UqVZCSkqJTHBm9fv0aNWrUwLp16zB8+HDs2bMHHTt2xMyZM9GiRQu1/Hv27MGiRYswadIk/Prrr3B0dETz5s3VOiZ1kdW2bty4MYyMjODo6IgWLVogPDw828sgIiIDMOh9WkREpJOWLVuK4OBgkZ6eLoQQWh/fe1d2HsnI7PE9Pz8/4efnJ169epVpGbdv3xbFixcXAKTP4MGDpZhV/vnnH2FnZyd+/PFHKQ0aHt/r06ePACBsbW1Fjx49xOHDh8X69euFt7e3cHZ2Fg8fPpTympiYiD59+qjFdObMGQFA/Pzzz0IIIU6cOCEAiLFjx2a6Lu9KT08XKSkp4vjx4wKAuH79ujTNzMxM2NjYCAcHB7Fo0SJx9OhRMXbsWGFkZCS++uorKZ8+yxXibV25urqK8uXLyx63nDZtmlAqlWqPq2zbtk0AEHv37pXSxo4dK5YsWSKOHj0q9uzZIwYOHCiMjY1FtWrVZGW+W7Zq+ykUCo0xh4SECADit99+k6X36tVLKJVK8eDBA1lZtra2olmzZmL//v3i119/FYGBgcLc3FxWl/Xq1RNeXl4iPj5eVubAgQOFubm59PhfdvaLjFJSUkT16tWFra2tiIqKkk1LT08X48ePF0qlUlr/QoUKiatXr2otT0X1+OrOnTultJiYGClOLy8vsXbtWnHkyBHRt29fAUB8++23Ul7V43seHh6ydpaQkCAcHR1F7dq1tS576dKlAoDYtGmTLD0qKkoYGxuLQYMGydITExOFm5ubaNOmjZSWlpYmvvjiC9G+fXspTdPjezt37tT4KOnKlSsFAFG0aFEpTfVIVfPmzWV5T58+LQCIKVOmCCGEePbsmTA3N9eaL7PH927fvi0AaGz72ZWamipSUlJEjx49RJkyZWTTAAg7OzuNj6Cqjo9Zyc7je9nZdl26dBEAxKpVqzJdvuo49uDBA7W2m9m5IuMjlMuWLRMAxNatW2X5ZsyYofYIJwDh6uoqEhISpLTY2FihVCrFtGnTMo03o8y29b59+8TYsWPF7t27xfHjx8WiRYuEl5eXsLKyEteuXcvWcoiIKO+xU4qI6AO3bds2YWpqKm7duiWl5VWn1J07dwQAMXXq1Eznv3//vihSpIioXLmy2LZtmzh+/LiYOXOmsLW1Fd27d5flbdy4sahWrZqss0pTp1SvXr0EAFGvXj1Z+tWrV9U6eExMTETfvn3V4lJ1Sql+sI8ZM0YAyLTjQggh7t27J9q3by9cXV2FQqGQdbRt3rxZtlxNHQJDhw4VAMTdu3eztdx3PX36VAQGBgoXFxdx79492bTKlSuLwMBAkZKSIvskJiYKhUIhvvnmm0zLnj17tgAgtm/frjYtJiZGXLx4URw4cECMGjVKmJqaioEDB8ryhISECBsbG7V5VT+8VZ0W33//vQAg/P39RWpqqpTv4cOHwtLSUnTo0EEIIcSrV6+kH+EZ12nv3r2yjrbs7BfvSk9PF507dxZGRkayziOVyZMnC0tLSzFp0iQRFhYmfvvtN1GnTh3h7Owsrly5orUuly9fLgCIESNGyNL//fdfaZ85e/asbNqXX34pzM3NRWJiohDif51SGetZiLdt3dTUVFZ/7ypfvrxwcnJSG19LFdfFixfV6rRt27bCxcVFyjtr1izh6OgoGy9LU6dUcnKyKFKkiPDw8BAHDx4Uz549E/v27ROurq7CyMhIFC9eXMqr6pTatm2bWsze3t6iVq1aQgghbV9t+TLrlBo5cmSOxhLaunWrCA4OFlZWVrI2bm5uLsunqXMtu7LTKZWdbafqlMrYmSvE2/HP+vTpI7y8vGSdrQDE9OnTs4xDCPVOqTZt2ggrKyu1PzY8evRIABCjRo2S0gCIdu3aqZXp5uam8Xidmexua9WYhU2bNs3WcoiIKO/x7XtERB+wFy9eYMCAARg0aBA8PDykR15Uj9E8f/4cJiYmao/H5Zb//vsPALJ8ZHD06NFISEjAtWvXpFiqVasGZ2dndO/eHZ07d0ZISAi2bduG/fv349SpU2pvD3zz5g2eP38OKysrmJiYSOMr1atXT5avdOnScHd3x5UrV6Q0JycnPH36VC2uuLg4AICjo6O0PkZGRnBzc9O6Li9evEDVqlVhbm6OKVOmoGjRorC0tER0dDRatGghe+zNyckJsbGxajE2aNAA8+fPx5UrV1CkSBGdlvuuZ8+eoU6dOvj3339x9OhRFC5cWDb90aNH+Ouvv6SxvDJ6d8wYTTp27IiRI0fi3LlzamN6ubm5SXHWrVsXDg4OGD16NLp3744yZcpI+TS9nU01n2pbqLZh7dq1ZWNSubu7o1SpUtI2fPr0KVJTU7Fw4UIsXLgw03XKzn6hIoRAz549sWHDBqxduxbNmjWTTb99+zbGjx+PmTNnYuTIkVJ6gwYN4O/vj+HDhyMsLEyt3NWrV6NPnz7o3bs3Zs2aJZvm4OAAhUIBGxsbVKpUSTatQYMG2LlzJyIiIqQxwwBo3D/c3Nzw5s0bvHjxQm3Mqxs3buDSpUsYMmSI2iN1qsdrtb2NTzWmXFRUFMaPH4/p06fD1NRUOsakpqYiPT0dz58/h5mZGSwsLGBqaop9+/ahU6dOqFu3LgDAysoKU6dOxeTJk+Hp6akxfk1pqn1E9a+2fNqkpKRg3bp1KFWqFMqXL681nzbbt29HmzZt0Lp1a3z99ddwc3ODsbExli5dilWrVqnld3d3z/Yy9KXrtlOxtLSEra2tLC09PR1169bFw4cPMW7cOAQEBMDKygrp6emoVKmS1sd3s/L06VO4ublBoVDI0l1cXGBsbKx2HNY0Tp6ZmVm2lq/Ptvbx8UGVKlVw7tw5nZdDRESGwU4pIqIP2JMnT/Do0SPMmTMHc+bMUZvu4OCAZs2aYefOne9l+QUKFAAA/PPPP5nmu3btGvz9/dU6x1Q/qsLDwxESEoLw8HCkpqaq/UgHgOXLl2P58uXYsWMHvvzyS41jRKkIIWQ/zAICAnDz5k21fKq0kiVLSuuTlpaG2NhYrT8yjx49iocPH+LYsWMICQmR0t8dA0clMDAQsbGxGuMD/vfjUZflqjx79gy1a9fG/fv3ceTIEY314OzsDAsLC40/nlXTdaHLYPeqTpM///xT1in17phiKqq6UP0Q1XUbOjg4wMjICJ06dcKAAQM05leNl5Sd/UKV1rNnT6xevRorV65Ex44d1ea7fv06hBBqnQAmJiYoVaoUjh8/rjbP6tWr0bNnT3Tp0gXLli1T+5FuYWGBzz77TKf9Q0VT3tjYWJiammoc52nlypUAoHHgZ9U+sG3bNnh7e6tNV/n777/x6tUrDBkyRDYemIqDgwOGDBmC+fPnAwCKFCmCs2fP4t9//0VcXBz8/PwQHx+PIUOGoFq1ahrj15RWpEgRAP/bV7Tl0zZe0++//47Hjx9j3LhxWtctMxs2bICvry+2bNki23YZB+tWybh93yddt52KptjCw8Nx/fp1rFmzBl26dJHS//rrrxzF5uTkhPPnz0MIIVvu48ePkZqaqvOxJzv03daajgdERPTh4ZGaiOgD5ubmhrCwMLVPvXr1YG5ujrCwMEyZMuW9Lb9o0aLw8/PDqlWrtP5YA96+0ezWrVt48eKFLF01QLPqTquuXbtqXB8A+PLLLxEWFoYqVaoAeHs3iaWlpdpbuK5cuYLY2FhZx1bz5s3xxx9/4Pz581JaamoqNmzYgC+++AIeHh5SmQCwdOlSreui+qGV8c6TH3/8US1vy5YtAUAtxr1790KpVEqdHLosF/hfh9Tff/+NgwcPyjqB3tW4cWPcu3cPTk5OKF++vNonq4GXVW8O09Q5mJFq+6g6EVQSExNlbywEgJ9//hlKpVLqnPjiiy/g5eWFgwcPyt7K9/DhQ1y/fl1avqWlJWrUqIGrV68iMDBQ4zqpOi+ys18IIdCrVy+sXr0aP/74I7p166ZxHVX7R8a7KpKTk3HlyhW1OwXXrFmDnj17omPHjlixYoXWDouWLVsiISEBZ86ckaXv3bsX1tbWsoHRgbd377x+/Vr6npiYiN27d6Nq1apqbz9MTk7Ghg0bULFiRanT9V316tWDsbEx7t27p7E+VXeclC5dWmObLFWqFHx8fBAWFoaBAweqle/p6YmAgABYWlpi1qxZsLKyQo8ePdTybdy4Ufb9zJkzePDggfRGt0qVKsHc3FxrPm1WrlwJc3NzdOjQQWuezCgUCpiamsq2XWxsrMa3770vqmNMxruGdN12mcnOcUxbHJrUqlULL168UPtDiGpweNWb/3KTPtv6/v37OH36tE7HOCIiMizeKUVE9AFTvaksozVr1sDIyEht2n///Sfd1aG6S2jfvn0oUKAAChQoILvz59KlS9Kb3xISEiCEwLZt2wC8vcNJ9Rf6xYsXo0mTJqhUqRKGDRuGQoUKISoqCgcOHJB+SA4dOhRffvkl6tSpg2HDhsHZ2Rnnzp3DtGnT4O/vL3XKZPamKk9PT9n62NvbY9KkSRg5ciS6du2K9u3bIzY2FuPGjUOhQoXQv39/KW/37t2xePFitG7dGtOnT4eLiwuWLFmCO3fu4PDhw1K+qlWrolOnTpgyZQoePXqExo0bw8zMDFevXoWlpSUGDRqE4OBgODg4oG/fvpgwYQJMTEywceNGXL9+XS3mbt264ccff0T//v3x5MkT+Pv74/Dhw1i8eDH69+8v1aEuy3316pX0yvf58+cjNTVV1klSoEAB+Pn5SfX966+/olq1ahg2bBgCAwORnp6OqKgoHDx4ECNGjMAXX3yBkydP4vvvv0fz5s1RuHBhvH79Gvv27cNPP/2EmjVryt4mOGHCBDx69AjVqlWDp6cnnj9/jv3792P58uVo3bo1ypUrJ1t3Jycn9OvXD1FRUShatCj27t2L5cuXo1+/fihUqBCAt3cCzZs3D23atEGzZs3Qr18/JCUlYfLkyTA1NcWYMWOk8hYsWIAqVaqgatWq6NevH3x8fJCYmIi//voLu3fvlt5CmJ39YvDgwVi5ciW6d++OgIAAWX2amZlJnX5VqlRBhQoVMHHiRLx8+RLVqlVDfHw8Fi5ciPv372P9+vXSfL/88gt69OiB0qVLo0+fPrhw4YKsXsqUKSP9yB85ciQ2btyI1q1bY/LkyfDy8sK2bduwa9cuzJ49GxYWFrJ5jYyMUKdOHQwfPhzp6emYMWMGEhISZG8fVNm5cyfi4uI03iUFvG1rkyZNwtixY/H333+jfv36cHBwwKNHj3DhwgVYWVkhNDQU9vb2Go8x9vb2SE1NVZs2c+ZMuLm5oVChQnj06BG2bt2KnTt3Yv369Rof37t06RJ69uyJ1q1bIzo6GmPHjoWnp6e0nRwcHDBy5EhMmTJFlm/ixIlaH997+PAh9u/fj7Zt28LBwUFjnqw0btwY27dvR//+/dGqVStER0dj8uTJcHd3x927d3UuR9VZq88dSAEBAQDe7vtdunSBiYkJihUrpvO2y0zx4sXh5+eH0aNHQwgBR0dH7N69G4cOHdI5DhsbG7W8nTt3xuLFi9GlSxdERkYiICAAp06dwtSpU9GwYUPUrl072/WQGV22de3atVGtWjUEBgbC1tYWN2/exMyZM6FQKDB58uRcjYeIiN4Dg4xkRUREOaJtoHPVYLqaPhkHDFYNkKvps3r1alnes2fPigYNGgg7OzthZmYm/Pz8xLBhw2R5jh49KurWrSvc3NyEhYWFKFq0qBgxYoR48uRJlusDDQOdqyxfvlyULFlSmJqaCicnJ9GhQwcRHR2tli82NlZ07txZODo6CnNzc1GpUiVx6NAhtXxpaWli3rx5Upl2dnYiKChI7N69W8pz5swZERQUJCwtLUWBAgVEz549xZUrVzTWzdOnT0WfPn2Eq6urMDExEUWLFhWzZs1Se7NdVstVDXat7dOlSxdZeS9evBDfffedKFasmFReQECAGDZsmIiNjRVCCHH37l3RsGFD4enpKczMzIS5ubkICAgQ33//vdrA2Lt27RK1a9cWrq6uwtjYWFhbW4uKFSuKH374QaSkpMjyqgbBPnbsmChfvrwwMzMT7u7u4ttvv1XLK8Tbt7ZVqFBBmJubCzs7O9G0aVPZwP0q9+/fF927dxeenp7CxMREFChQQAQHB0tvanuXLvuFt7e31vr09vaW5X3+/LkYO3asKFGihLC0tBQuLi6ievXqsjcZCpF5u4GWN6m1a9dOODg4CFNTUxEYGKj2pjTVtp8xY4YIDQ0VXl5ewtTUVJQpU0YcOHBAbd2FEKJOnTrCyspK9mYzTXbu3Clq1KghbG1thZmZmfD29hatWrUShw8fznQ+TQOdCyFEaGio8PPzE2ZmZsLe3l7Ur19fnDhxQi2faqDzgwcPik6dOgl7e3thYWEhGjZsKL0AQCU9PV1MmzZNFCxYUKqj3bt3qw2yraIaQP/o0aOZrkNWpk+fLnx8fISZmZkoUaKEWL58uZgwYYLIeHmc2fHJ29tbbV/SRNNA50K8fQmCh4eHNBB5WFiYNE2XbZfZSy8iIiJEnTp1pDeEtm7dWkRFRQkAYsKECTrFoWkbPH36VPTt21e4u7sLY2Nj4e3tLcaMGaN2TNFWb97e3mrHM2102dZDhw4V/v7+wsbGRhgbGwsPDw/RsWNHcefOHZ2WQUREhqUQ4v8HNiAiIiIiIiIiIsojHFOKiIiIiIiIiIjyHMeUIiIiIqKPghBCNqi+JkZGRnn6Nj0iIiLSjndKEREREdFH4fjx4zAxMcn0o3r7JBERERkex5QiIiIioo9CYmIi7ty5k2keX19fODk55VFERERElBl2ShERERERERERUZ7j43tERERERERERJTn2ClFRERERERERER5jp1SRERERERERESU59gpRUREREREREREeY6dUkRERERERERElOfYKUVERERERERERHmOnVJERERERERERJTn2ClFRERERERERER5jp1SRERERERERESU59gpRUREREREREREeY6dUkRERERERERElOfYKUVERERERERERHmOnVJERERERERERJTn2ClFRERERERERER5jp1SRERERERERESU59gpRUREREREREREeY6dUkRERERERERElOfYKUVERERERERERHmOnVJERERERERERJTn2ClFRERERERERER5jp1SRERERERERESU59gpRUREREREREREeY6dUkRERERERERElOdyrVNqzZo1UCgUGj8jR47MrcVQJiZOnAiFQiFL8/HxQdeuXbNVzpkzZzBx4kQ8f/48W/NlXNaxY8egUCiwbdu2bJWTmZcvX2LixIk4duyY2jTVPhgZGZlry8vPMrZJc3NzuLm5oUaNGpg2bRoeP35s6BAxdepU7Ny5Uy1dte9o2s6GUr16dVSvXl36HhkZCYVCgTVr1mSrnJ9//hnz58/P1jyalqVq70+ePMlWWZmJiIjAxIkTNbahrl27wsfHJ9eWRVl7tw1ragtCCBQpUgQKhUK2b+YGbcfzD6lNGnqfzOxcmfF4QUT53/nz59G8eXMUKlQIZmZmcHV1RVBQEEaMGCHLt2TJkmxfG2Sk7fqIPjzZuR7Ly99lRPmJcW4XuHr1ahQvXlyW5uHhkduLIR3t2LEDtra22ZrnzJkzCA0NRdeuXWFvb/9el5VdL1++RGhoKACoXfA3atQIZ8+ehbu7+3uNIb9RtcmUlBQ8fvwYp06dwowZMzB79mxs2bIFtWvXNlhsU6dORatWrfDll1/K0suWLYuzZ8/C39/fMIHpwN3dHWfPnoWfn1+25vv5558RHh6OoUOHvvdlZVdERARCQ0NRvXp1tR/748aNw5AhQ97r8kkzGxsbrFy5Uu2Yd/z4cdy7dw82NjbvPYb80CbzWmbnyiVLlhgmKCJ6L/bs2YOmTZuievXqmDlzJtzd3RETE4NLly5h8+bNmDNnjpR3yZIlcHZ2znbnw7u0XR9R/paXv8uI8pNc75QqWbIkypcvr1PelJQUKBQKGBvnehj0/8qUKfPel/Hq1StYWFjkybIyU6BAARQoUMCgMXyIMrbJli1bYtiwYahSpQpatGiBu3fvwtXVNcfLSUtLQ2pqKszMzHJclq2tLSpVqpTjct4nMzOz9x7ju3Vq6Pp43x1ipF3btm2xceNGLF68WHYxu3LlSgQFBSEhIeG9x5Af2mROvXz5EpaWlrlSFjvviD4uM2fOhK+vLw4cOCD73dKuXTvMnDnTgJFRfmLo30rvys1zHlFO5dmYUqpb/9evX48RI0bA09MTZmZm+OuvvwAAhw8fRq1atWBrawtLS0tUrlwZR44cUStnz549KF26NMzMzODr64vZs2erPbaW2WM1CoUCEydOlKXdvXsXX331FVxcXGBmZoYSJUpg8eLFGuPftGkTxo4dCw8PD9ja2qJ27dq4c+eO2nL279+PWrVqwc7ODpaWlihRogSmTZsGAFi/fj0UCgXOnj2rNt+kSZNgYmKChw8fZlqfmupBk4y3iaanp2PKlCkoVqwYLCwsYG9vj8DAQCxYsADA21tQv/76awCAr6+v2qMjPj4+aNy4MbZv344yZcrA3NxcunNJ2y2pr1+/xvDhw+Hm5gYLCwuEhITg6tWrsjzaHnV49/GMyMhIqdMpNDRUik21TG2P761atQqlSpWCubk5HB0d0bx5c9y+fVttOdbW1vjrr7/QsGFDWFtbo2DBghgxYgSSk5M11m1+VqhQIcyZMweJiYn48ccfpXRdtgPwvzY2c+ZMTJkyBb6+vjAzM0NYWBhev36NESNGoHTp0rCzs4OjoyOCgoLw22+/ycpUKBRISkrC2rVrpW2pWra2R4V27dqFoKAgWFpawsbGBnXq1FFrR6rjwa1bt9C+fXvY2dnB1dUV3bt3R3x8fJZ1I4TAzJkz4e3tDXNzc5QtWxb79u1Ty6fpOPPff/+hd+/eKFiwIMzMzFCgQAFUrlwZhw8flup3z549ePDggezRyqzqNLNjWnR0NFq0aAFbW1vY2dmhY8eO+O+//9TqOuNxD5C32TVr1qB169YAgBo1akixqZap6VGp169fY8yYMfD19YWpqSk8PT0xYMAAtVvMVceN/fv3o2zZsrCwsEDx4sWxatUqLVuB3tW+fXsAwKZNm6S0+Ph4/Prrr+jevbvGed68eYMpU6agePHi0r7YrVs3tX0jJSUF33zzDdzc3GBpaYkqVargwoULauVpapOXLl1Cu3bt4OPjAwsLC/j4+KB9+/Z48OCBbF7VsTksLAz9+vWDs7MznJyc0KJFiyzPde+WUaxYMekcvW7dOp1iBDS3VdUx/+bNm6hbty5sbGxQq1YtAMChQ4fQrFkzeHl5wdzcHEWKFEGfPn1kj2Zkda7UdCyNi4tD//794enpCVNTUxQuXBhjx45VO8coFAoMHDgQ69evR4kSJWBpaYlSpUrh999/16muiCj3PX36FM7Ozhr/kK5U/u/nlI+PD27duoXjx49LxwXVuTM3ro8AIDY2Fn369IGXlxdMTU3h6+uL0NBQpKamZrkeR48eRfXq1eHk5AQLCwsUKlQILVu2xMuXL6U8OT1/ZPw9oGl4EUD7dfuWLVsQFBQEKysrWFtbo169emq/G7Jz3Z6cnIxJkyahRIkSMDc3h5OTE2rUqIEzZ85IeYQQWLJkCUqXLg0LCws4ODigVatW+Pvvv7OsU5VHjx5led2Z27/L0tPTMXPmTGlbubi4oHPnzvjnn39ky61evTpKliyJEydOIDg4GJaWlujevTt69OgBR0dH2fZXqVmzJj7//HOd158oJ3L9FiXVX/ZlC3nnAD5mzBgEBQVh2bJlUCqVcHFxwYYNG9C5c2c0a9YMa9euhYmJCX788UfUq1cPBw4ckC4Ujxw5gmbNmiEoKAibN29GWloaZs6ciUePHukdb0REBIKDg6Uf6W5ubjhw4AAGDx6MJ0+eYMKECbL83377LSpXrowVK1YgISEBo0aNQpMmTXD79m0YGRkBePvX6169eiEkJATLli2Di4sL/vzzT4SHhwN4+1fvb775BosXL0ZQUJBUdmpqKn788Uc0b94800cec1IPM2fOxMSJE/Hdd9+hWrVqSElJwR9//CH9iOzZsyfi4uKwcOFCbN++XXoU7t2/+l65cgW3b9/Gd999B19fX1hZWWW6zG+//RZly5bFihUrEB8fj4kTJ6J69eq4evUqChcunGXMKu7u7ti/fz/q16+PHj16oGfPngCQ6d1R06ZNw7fffov27dtj2rRpePr0KSZOnIigoCBcvHgRn332mZQ3JSUFTZs2RY8ePTBixAicOHECkydPhp2dHcaPH69znPlFw4YNYWRkhBMnTuhdxg8//ICiRYti9uzZsLW1xWeffYbk5GTExcVh5MiR8PT0xJs3b3D48GG0aNECq1evRufOnQEAZ8+eRc2aNVGjRg2MGzcOADK9pfnnn39Ghw4dULduXWzatAnJycmYOXMmqlevjiNHjqBKlSqy/C1btkTbtm3Ro0cP3Lx5E2PGjAGALDtCQkNDERoaih49eqBVq1aIjo5Gr169kJaWhmLFimU6b6dOnXDlyhV8//33KFq0KJ4/f44rV67g6dOnAN7e0t+7d2/cu3cPO3bs0LlOM9O8eXO0adMGffv2xa1btzBu3DhERETg/PnzMDExyXTedzVq1AhTp07Ft99+i8WLF6Ns2bIAtN8hJYTAl19+iSNHjmDMmDGoWrUqbty4gQkTJuDs2bM4e/as7K6569evY8SIERg9ejRcXV2xYsUK9OjRA0WKFEG1atV0jvNTZGtri1atWmHVqlXo06cPgLcdVEqlEm3btlUboyw9PR3NmjXDyZMn8c033yA4OBgPHjzAhAkTUL16dVy6dAkWFhYAgF69emHdunUYOXIk6tSpg/DwcLRo0QKJiYlZxhUZGYlixYqhXbt2cHR0RExMDJYuXYoKFSogIiICzs7Osvw9e/ZEo0aN8PPPPyM6Ohpff/01OnbsiKNHj2a6nDVr1qBbt25o1qwZ5syZI51HkpOTZT8Gs+vNmzdo2rQp+vTpg9GjR0vXLvfu3UNQUBB69uwJOzs7REZGYu7cuahSpQpu3rwJExMTnc6V73r9+jVq1KiBe/fuITQ0FIGBgTh58iSmTZuGa9euYc+ePbL8e/bswcWLFzFp0iRYW1tj5syZaN68Oe7cuZOt8yYR5Y6goCCsWLECgwcPRocOHVC2bFmN59gdO3agVatWsLOzkx7jVZ0Lc+P6KDY2FhUrVoRSqcT48ePh5+eHs2fPYsqUKYiMjMTq1au1rkNkZCQaNWqEqlWrYtWqVbC3t8e///6L/fv3482bN7C0tMyz84c2U6dOxXfffYdu3brhu+++w5s3bzBr1ixUrVoVFy5ckB1jdbluT01NRYMGDXDy5EkMHToUNWvWRGpqKs6dO4eoqCgEBwcDAPr06YM1a9Zg8ODBmDFjBuLi4jBp0iQEBwfj+vXrOj1RoM91Z05/l/Xr1w8//fQTBg4ciMaNGyMyMhLjxo3DsWPHcOXKFdl5OCYmBh07dsQ333yDqVOnQqlUwt7eHqtWrcLPP/8s/a4C3v4+DgsLU7tJg+i9Eblk9erVAoDGT0pKiggLCxMARLVq1WTzJSUlCUdHR9GkSRNZelpamihVqpSoWLGilPbFF18IDw8P8erVKyktISFBODo6indX5f79+wKAWL16tVqcAMSECROk7/Xq1RNeXl4iPj5elm/gwIHC3NxcxMXFCSGEFH/Dhg1l+bZu3SoAiLNnzwohhEhMTBS2traiSpUqIj09XWt9TZgwQZiamopHjx5JaVu2bBEAxPHjx7XOl516EEIIb29v0aVLF+l748aNRenSpTMtf9asWQKAuH//vto0b29vYWRkJO7cuaNx2rvLUtVZ2bJlZXURGRkpTExMRM+ePaW0kJAQERISolZmly5dhLe3t/T9v//+U9uGKqp9UBX3s2fPhIWFhdo2i4qKEmZmZuKrr76SLQeA2Lp1qyxvw4YNRbFixdSWlR+o6uPixYta87i6uooSJUpI33XdDqo25ufnJ968eZNpHKmpqSIlJUX06NFDlClTRjbNyspKts+oqPadsLAwIcTb44GHh4cICAgQaWlpUr7ExETh4uIigoODpbQJEyYIAGLmzJmyMvv37y/Mzc0zbZfPnj0T5ubmonnz5rL006dPCwCyutF0nLG2thZDhw7VWr4QQjRq1EhWlxnL01SnmpalWs9hw4bJ8m7cuFEAEBs2bJDStLWZjG32l19+kdX7uzLuA/v379dYz6rj2E8//SRbjrm5uXjw4IGU9urVK+Ho6Cj69Omjtix66902rGoT4eHhQgghKlSoILp27SqEEOLzzz+X7ZubNm0SAMSvv/4qK+/ixYsCgFiyZIkQQojbt29nug9pOp5r2jdUUlNTxYsXL4SVlZVYsGCB2nr0799fln/mzJkCgIiJidFapqrtazuPvLtPaotRU/tRHfNXrVqlddlCCJGeni5SUlLEgwcPBADx22+/SdMyO1dmPJYuW7ZM4zlmxowZAoA4ePCglAZAuLq6ioSEBCktNjZWKJVKMW3atEzjJaL348mTJ6JKlSrSbxsTExMRHBwspk2bJhITE2V5Mx6TtdHn+qhPnz7C2tpadj4VQojZs2cLAOLWrVtal7dt2zYBQFy7dk1rnvdx/lBdr2SU8bo9KipKGBsbi0GDBsnyJSYmCjc3N9GmTRspTdfr9nXr1gkAYvny5VrX+ezZswKAmDNnjiw9OjpaWFhYiG+++UbrvO+uny7Xnbn5u0y1DTKeW8+fPy8AiG+//VZKCwkJEQDEkSNH1MoPCQlRi6Ffv37C1tZWbd8mel9y/fG9devW4eLFi7LPu3dKtWzZUpb/zJkziIuLQ5cuXZCamip90tPTUb9+fVy8eBFJSUlISkrCxYsX0aJFC5ibm0vz29jYoEmTJnrF+vr1axw5cgTNmzeHpaWlbPkNGzbE69evce7cOdk8TZs2lX0PDAwEAOlxhTNnziAhIQH9+/fXeKuqSr9+/QAAy5cvl9IWLVqEgICATO8ayGk9VKxYEdevX0f//v1x4MABvcYiCQwMRNGiRXXO/9VXX8nqwtvbG8HBwQgLC8v2srPj7NmzePXqldojhQULFkTNmjXVHg9VKBRqdRgYGKj2KMrHRAiRo/mbNm2q8S+Fv/zyCypXrgxra2sYGxvDxMQEK1euVHtsUld37tzBw4cP0alTJ9mdEdbW1mjZsiXOnTunduuxprb6+vXrTN86ePbsWbx+/RodOnSQpQcHB8Pb2zvLOCtWrIg1a9ZgypQpOHfuHFJSUnRZPbW4s3OHU8ZY27RpA2Nj4/fevlR3t2RsX61bt4aVlZVa+ypdujQKFSokfTc3N0fRokU/6vaVm0JCQuDn54dVq1bh5s2buHjxotZH937//XfY29ujSZMmsvNa6dKl4ebmJt32r9pHtO1DWXnx4gVGjRqFIkWKwNjYGMbGxrC2tkZSUpLGtp7V+VMTVdvXdh7JqYzXJADw+PFj9O3bFwULFpSOX6r2r+8x7OjRo7CyskKrVq1k6ar2k7G91KhRQzaAvaurK1xcXNheiAzEyckJJ0+exMWLFzF9+nQ0a9YMf/75J8aMGYOAgACd34Sb0+uj33//HTVq1ICHh4fs+N6gQQMAb1+AoU3p0qVhamqK3r17Y+3atRofTcur84cmBw4cQGpqKjp37ixbtrm5OUJCQtQezdblun3fvn0wNzfXer5UrbNCoUDHjh1ly3Vzc0OpUqV0fuusPtedOfldptoGGa/DKlasiBIlSqidVxwcHFCzZk21coYMGYJr167h9OnTAICEhASsX78eXbp0gbW1tc7xEOVErndKlShRAuXLl5d93pXxzWiqR85atWoFExMT2WfGjBkQQiAuLg7Pnj1Deno63Nzc1JapKU0XT58+RWpqKhYuXKi27IYNGwKA2knGyclJ9l11S+6rV68AQHre2svLK9Nlu7q6om3btvjxxx+RlpaGGzdu4OTJkxg4cGCm8+W0HsaMGYPZs2fj3LlzaNCgAZycnFCrVi1cunQpy3lVsvt2O22xqh5pel9U5WuK18PDQ235lpaWso4+4O32ff369fsL0oCSkpLw9OnTHL0dU1Pdbt++HW3atIGnpyc2bNiAs2fPSj+g9a3LrLZleno6nj17JkvPqq1mthx929eWLVvQpUsXrFixAkFBQXB0dETnzp0RGxub5bwqOW1fxsbGcHJyypP2ZWxsrPb4rEKh0Ni+M24P4O02yWx70P8oFAp069YNGzZswLJly1C0aFFUrVpVY95Hjx7h+fPnMDU1VTu3xcbGSuc1bfu7ah/KyldffYVFixahZ8+eOHDgAC5cuICLFy+iQIECGrerIdpkZiwtLdUeGU5PT0fdunWxfft2fPPNNzhy5AguXLgg/YFK3/316dOncHNzU/tjlYuLC4yNjdleiPKJ8uXLY9SoUfjll1/w8OFDDBs2DJGRkToNdp4b10ePHj3C7t271Y7tqrF/Musc8/Pzw+HDh+Hi4oIBAwbAz88Pfn5+0vhFqvLz4vyhbd0AoEKFCmrL3rJli9q66XLd/t9//8HDwyPTR70fPXoEIQRcXV3Vlnvu3DmdOxz1Ocfl5HdZdn/naLu+bNasGXx8fKRH9dasWYOkpCQMGDAgyxiIckuev/Yu4wWZ6lnXhQsXan2zj6urq/SmPk0/7jKmqQ5QGQe6y9g4HRwcYGRkhE6dOmlteL6+vpmsjTrVD7SMA8xpMmTIEKxfvx6//fYb9u/fD3t7e7W/OGTk4OCgcz1oYmxsjOHDh2P48OF4/vw5Dh8+jG+//Rb16tVDdHS0Tm9hyOwOME20xfruwdvc3FzjINS6ngg0UZUfExOjNu3hw4dq4518avbs2YO0tDTZ4JnZ3Q6a9oUNGzbA19cXW7ZskU3PyYDxWW1LpVIJBwcHvcvPuBxt+2zGgb4zcnZ2xvz58zF//nxERUVh165dGD16NB4/foz9+/frFIM+7cvT01P6npqaiqdPn8ral5mZmcb6z0nHlZOTE1JTU/Hff//JOqaEEIiNjUWFChX0Lps069q1K8aPH49ly5bh+++/15pPNZC4tn1OdQfOu/u7pn0oM/Hx8fj9998xYcIEjB49WkpXjZmSW7Jqk+/Sdu7PzvErPDwc169fx5o1a9ClSxcpXfVSFn05OTnh/PnzEELIlvv48WOkpqZ+8ucjovzIxMQEEyZMwLx586RxYzOTG9dHzs7OCAwM1HoOyOoPjVWrVkXVqlWRlpaGS5cuYeHChRg6dChcXV3Rrl2793L+ePfY/O5YkxmPzarj4LZt23S6O10XBQoUwKlTp5Cenq61Y8rZ2RkKhQInT57U+Abp3HirtDY5+V327rVxxpshNP3O0XZ9qVQqMWDAAHz77beYM2cOlixZglq1amU5jipRbsqzt+9pU7lyZdjb2yMiIkLtDivVx9TUFFZWVqhYsSK2b98u6wFPTEzE7t27ZWW6urrC3NwcN27ckKVnfLuFpaUlatSogatXryIwMFDjsrPb2x8cHAw7OzssW7Ysy0ejypUrh+DgYMyYMQMbN25E165dsxw0PDv1kBV7e3u0atUKAwYMQFxcnPT2C1169rNj06ZNsrp48OABzpw5I+sM8fHxwZ9//ik7MT99+lT2ZozsxhYUFAQLCwts2LBBlv7PP//g6NGj0gD6n6KoqCiMHDkSdnZ20sDJgO7bITMKhQKmpqayk19sbKxa+wN0/8t/sWLF4OnpiZ9//lm2LyUlJeHXX3+V3siXU5UqVYK5uTk2btwoSz9z5ky2H5spVKgQBg4ciDp16uDKlStSem7f7ZAx1q1btyI1NVWtfWU8Hh49ehQvXryQpWWnfanaT8b29euvvyIpKemTbl/vi6enJ77++ms0adJE1mGSUePGjfH06VOkpaVpPK+pLjRV+4i2fSgzCoUCQgi1i/UVK1YgLS1Nj7XTrFixYnB3d9d6HnmXqtM4476+a9cunZenOm5lXK9331Kqkt328uLFC+zcuVOWrnqLINsL0YdN0x/FgP890vtuZ5C283xuXB81btwY4eHh8PPz03h81/XudyMjI3zxxRfS3TGq65T3cf7QdmzO+LulXr16MDY2xr1797T+JsyuBg0a4PXr1xrfXqzSuHFjCCHw77//alxmQEBAtperj+z+LlM9ipfxOuzixYu4fft2ts4rPXv2hKmpKTp06IA7d+5k+eQOUW7L8zulMrK2tsbChQvRpUsXxMXFoVWrVnBxccF///2H69ev47///sPSpUsBAJMnT0b9+vVRp04djBgxAmlpaZgxYwasrKxkf5lVPRe8atUq+Pn5oVSpUrhw4QJ+/vlnteUvWLAAVapUQdWqVdGvXz/4+PggMTERf/31F3bv3p3lW4E0rc+cOXPQs2dP1K5dG7169YKrqyv++usvXL9+HYsWLZLlHzJkCNq2bQuFQoH+/fvrtAxd60GTJk2aoGTJkihfvjwKFCiABw8eYP78+fD29pbe8qU6+C5YsABdunSBiYkJihUrJhvfIjseP36M5s2bo1evXoiPj8eECRNgbm4uvZUCePvWsh9//BEdO3ZEr1698PTpU8ycOVPt0QobGxt4e3vjt99+Q61ateDo6AhnZ2eNd7DY29tj3Lhx+Pbbb9G5c2e0b98eT58+RWhoKMzNzdXerPixCg8Pl56Pf/z4MU6ePInVq1fDyMgIO3bskN3lout2yEzjxo2xfft29O/fX3p73eTJk+Hu7o67d+/K8gYEBODYsWPYvXs33N3dYWNjo/EvM0qlEjNnzkSHDh3QuHFj9OnTB8nJyZg1axaeP3+O6dOn619B73BwcMDIkSMxZcoU9OzZE61bt0Z0dDQmTpyY5aNC8fHxqFGjBr766isUL14cNjY2uHjxIvbv348WLVrI1nn79u1YunQpypUrB6VSqdeFlsr27dthbGyMOnXqSG/fK1WqFNq0aSPl6dSpE8aNG4fx48cjJCQEERERWLRoEezs7GRllSxZEgDw008/wcbGBubm5vD19dXYOV+nTh3Uq1cPo0aNQkJCAipXriy9fa9MmTLo1KmT3utE2umyr7dr1w4bN25Ew4YNMWTIEFSsWBEmJib4559/EBYWhmbNmqF58+YoUaIEOnbsiPnz58PExAS1a9dGeHi49ObHzNja2qJatWqYNWuWdAw+fvw4Vq5cCXt7+1xa27dtf/LkyejZs6d0Hnn+/LnGNunm5obatWtj2rRpcHBwgLe3N44cOYLt27frvLzixYvDz88Po0ePhhACjo6O2L17Nw4dOqSWNzvnys6dO2Px4sXo0qULIiMjERAQgFOnTmHq1Klo2LAhateunc2aIaK8VK9ePXh5eaFJkyYoXrw40tPTce3aNcyZMwfW1tYYMmSIlDcgIACbN2/Gli1bULhwYZibmyMgICBXro8mTZqEQ4cOITg4GIMHD0axYsXw+vVrREZGYu/evVi2bJnWIUSWLVuGo0ePolGjRihUqBBev34tvRlOdQx6H+ePhg0bwtHRET169MCkSZNgbGyMNWvWIDo6WpbPx8cHkyZNwtixY/H333+jfv36cHBwwKNHj3DhwgVYWVkhNDQ0W9utffv2WL16Nfr27Ys7d+6gRo0aSE9Px/nz51GiRAm0a9cOlStXRu/evdGtWzdcunQJ1apVg5WVFWJiYnDq1CkEBARIYwHntpz8LitWrBh69+6NhQsXQqlUokGDBtLb9woWLIhhw4bpHIe9vT06d+6MpUuXwtvbW+/xmon0llsjpmf1pi/VW3F++eUXjdOPHz8uGjVqJBwdHYWJiYnw9PQUjRo1Usu/a9cuERgYKExNTUWhQoXE9OnTNb7VIT4+XvTs2VO4uroKKysr0aRJExEZGanxLVT3798X3bt3F56ensLExEQUKFBABAcHiylTpmQZv7Y3/e3du1eEhIQIKysrYWlpKfz9/cWMGTPU1js5OVmYmZmJ+vXra6wXbXSth4xveZgzZ44IDg4Wzs7O0rw9evQQkZGRsvnGjBkjPDw8hFKplL3NyNvbWzRq1EhjTNrevrd+/XoxePBgUaBAAWFmZiaqVq0qLl26pDb/2rVrRYkSJYS5ubnw9/cXW7ZsUXvjlxBCHD58WJQpU0aYmZnJ3vCR8S0eKitWrJDqys7OTjRr1kzt7SRdunQRVlZWajFpe2NIfpDxjZimpqbCxcVFhISEiKlTp4rHjx9rnE+X7aDa72fNmqWxjOnTpwsfHx9hZmYmSpQoIZYvX66xLq9duyYqV64sLC0tZW+30/YWrZ07d4ovvvhCmJubCysrK1GrVi1x+vRpWR7Vcv777z+N9aHpTVnvSk9PF9OmTRMFCxYUpqamIjAwUOzevVvtbVoZ2/7r169F3759RWBgoLC1tRUWFhaiWLFiYsKECSIpKUmaLy4uTrRq1UrY29sLhUIh1UlmdZrZ2/cuX74smjRpIqytrYWNjY1o37697K2eQrw9znzzzTeiYMGCwsLCQoSEhIhr166ptVkhhJg/f77w9fUVRkZGsmVqaouvXr0So0aNEt7e3sLExES4u7uLfv36iWfPnsnyaTtuaHvbI72lyxs0hdD8pqeUlBQxe/ZsUapUKWFubi6sra1F8eLFRZ8+fcTdu3elfMnJyWLEiBHCxcVFmJubi0qVKomzZ89qPZ6/2yb/+ecf0bJlS+Hg4CBsbGxE/fr1RXh4uNq82tZDlzf6qaxYsUJ89tlnwtTUVBQtWlSsWrVK4z4ZExMjWrVqJRwdHYWdnZ3o2LGjuHTpksa372k65gshREREhKhTp46wsbERDg4OonXr1iIqKkrj9YO2c6Wmffvp06eib9++wt3dXRgbGwtvb28xZswY8fr1a1k+AGLAgAFqcWlqr0SUN7Zs2SK++uor8dlnnwlra2thYmIiChUqJDp16iQiIiJkeSMjI0XdunWFjY2NACA7TuX0+kiIt2+iHjx4sPD19RUmJibC0dFRlCtXTowdO1a8ePFC6zqcPXtWNG/eXHh7ewszMzPh5OQkQkJCxK5du2T5cvv8IYQQFy5cEMHBwcLKykp4enqKCRMmiBUrVmi8Ltu5c6eoUaOGsLW1FWZmZsLb21u0atVKHD58WMqTnev2V69eifHjx0vnECcnJ1GzZk1x5swZWb5Vq1aJL774QlhZWQkLCwvh5+cnOnfurPE3i6Zl6nLdmdu/y9LS0sSMGTNE0aJFhYmJiXB2dhYdO3YU0dHRsvlDQkLE559/nul6HDt2TAAQ06dPzzQf0fugECKHr9/6AEycOBGhoaE5fpOYIezevRtNmzbFnj17pMHViYiIiIiI8hsfHx9Ur14900fm6MMzYsQILF26FNHR0XoPVk+kL4M/vvepioiIwIMHDzBixAiULl1aepUrERERERER0ft27tw5/Pnnn1iyZAn69OnDDikyCHZKGUj//v1x+vRplC1bFmvXrs32G7eIiIiIiIiI9KV6WVDjxo0xZcoUQ4dDn6iP4vE9IiIiIiIiIiLKX5SGDoCIiIiIiIiIiD497JQiIiIiIiIiIqI8x04pIiIiIiIiIiLKc+yUIiIiIiIiIiKiPGeQt++lp6fj4cOHsLGx4VvnKM8JIZCYmAgPDw8olZ9OvyzbHRka2x7bHhkG2x7bHhERUV7T9frDIJ1SDx8+RMGCBQ2xaCJJdHQ0vLy8DB1GnmG7ow8F2x6RYbDtERERUV7L6vrDIJ1SNjY2AN4GZ2tra4gQ6BOWkJCAggULSvvhp4LtjgyNbY9tjwzjU297ntFhUNpaZ5o32u4fxNdvjo37gf5Ygvj6/VFyy8W8CDNf6mFXAVXiS6JF8nbYmcUDAMKPVEDJWh9PnYVfqaD3vCXLvr96CMB1bGrb873sn+Hz5etccqj6MsK3qNdLybaaY4lPtpP2j+zoYKe+jI3xebdv9fj/5U+cEo/4NLu3ie5ASv08CyFTzoVGv98FtByT+fRfp2Uvv67lGEJ2Y/8QYv5Q6FJ3KQnArqyvPwzSKaW6hdrW1pYX6GQwn9qt/Gx39KFg2yMyjE+17SltrbPslAKsYGsCWAAALGBrAh3m+XSZA7CyNYIi2QZKszQAgK3Vx1VnOVmV91kPJrB8b/unrbn8u6Zl2Fqoz6ctlnf3j+ww05CWl/uWVA3mtrBVhW8BpHwwp3BNNZSLTLJa0QzLzzK/juUYQrZj/wBi/lBko+6yuv74dAYWICIiIiIiIiKiD4ZB7pQiIiKi/C8tXeDC/Tg8TnwNFxtzVPR1hJEyf92Nk9/XIb/HT0RERJ82g3ZKlZxwAFHzWhsyBKJPTskJB6A0swQARE5vZOBoiCi/2h8eg9DdEYiJfy2luduZY0ITf9Qv6W7AyHSX39chv8dPRERExMf3iIiIKFv2h8eg34Yrss4QAIiNf41+G65gf3iMgSLTXX5fh/wePxERERHATikiIiLKhrR0gdDdERAapqnSQndHIC1dU44PQ35fh/wePxEREZEKO6WIiIhIZxfux6ndnfMuASAm/jUu3I/Lu6CyKb+vQ36Pn4iIiEiFnVJERESks8eJ2jtD9MlnCPl9HfJ7/EREREQq7JQiIiIinbnYmOdqPkPI7+uQ3+MnIiIiUmGnFBEREemsoq8j3O3ModAyXYG3b4Cr6OuYl2FlS35fh/wef3YsWbIEvr6+MDc3R7ly5XDy5ElDh0RERES5iJ1SREREpDMjpQITmvgDgFqniOr7hCb+MFJq6zIxvPy+Dvk9fl1t2bIFQ4cOxdixY3H16lVUrVoVDRo0QFRUlKFDIyIiolzCTikiIiLKlvol3bG0Y1m42ckfD3OzM8fSjmVRv6S7gSLTXX5fh/wevy7mzp2LHj16oGfPnihRogTmz5+PggULYunSpYYOjYiIiHKJsaEDICIiovynfkl31PF3w4X7cXic+BouNm8fF8tPd+fk93XI7/Fn5s2bN7h8+TJGjx4tS69bty7OnDmjcZ7k5GQkJydL3xMSEt5rjERERJRz7JQiIiIivRgpFQjyczJ0GDmS39chv8evzZMnT5CWlgZXV1dZuqurK2JjYzXOM23aNISGhuZFeERERJRL+PgeEREREX2QFAr5XV9CCLU0lTFjxiA+Pl76REdH50WIRERElAO8U4qIiIiIPijOzs4wMjJSuyvq8ePHandPqZiZmcHMzCwvwiMiIqJcwjuliIiIiOiDYmpqinLlyuHQoUOy9EOHDiE4ONhAUREREVFu451SRERERPTBGT58ODp16oTy5csjKCgIP/30E6KiotC3b19Dh0ZERES5hJ1SRERERPTBadu2LZ4+fYpJkyYhJiYGJUuWxN69e+Ht7W3o0IiIiCiXsFOKiIiIiD5I/fv3R//+/Q0dBhEREb0nHFOKiIiIiIiIiIjyHO+UIiIiMoC0dIEL9+PwOPE1XGzMUdHXEUZKza+6JyIiIiL6GPFOKSIiIh1NmzYNCoUCQ4cOzVE5+8NjUGXGUbRffg5DNl9D++XnUGXGUewPj8mdQImIiIiI8gF2ShEREeng4sWL+OmnnxAYGJijcvaHx6DfhiuIiX8tS4+Nf41+G66wY4qIiIiIPhnslCIiIsrCixcv0KFDByxfvhwODg56l5OWLhC6OwJCwzRVWujuCKSla8pBRERERPRx0atTKikpKbfjICIdsO0RGcaAAQPQqFEj1K5dO8u8ycnJSEhIkH1ULtyPU7tD6l0CQEz8a1y4H5cbYRMRERERfdD06pRydXVF9+7dcerUqdyOh4gywbZHlPc2b96MK1euYNq0aTrlnzZtGuzs7KRPwYIFpWmPE7V3SL1L13xERERERPmZXp1SmzZtQnx8PGrVqoWiRYti+vTpePjwYW7HRkQZsO0R5a3o6GgMGTIEGzZsgLm5uU7zjBkzBvHx8dInOjpamuZio1sZuuYjIiIiIsrPFEIIvQeuePr0KdatW4c1a9YgIiIC9erVQ/fu3dG0aVMYGxtrnS8hIeHtX4+HbkXUvNb6Lp5IL6r9Lz4+Hra2toYORy/6tL13253SzBIAEDm9UV6GTZ+4/Nj2du7ciebNm8PIyEhKS0tLg0KhgFKpRHJysmyaJu+ut5W1DarMOIrY+Ncax5VSAHCzM8epUTVhpFTk7srQJys/tr3cIK13L8DWNPO8PotuAwAeKP7XiSwG1H0vcSkWx+ZqeWKAm1qaan0AIHJgCa3zvpsvN2W2TG20xaJPWbqUmx05jSGn3l2HBweKQzgp4FP+drbjkpWjUB8f0Vs80zotK6p5M3o3Rn22hWp+TbGvFMN0KqOHYp7Oy/MWz9BP8XaZw5+rTzcZq3m+lO+zzhe7yE7nODLjNjAeisUT1NLFgNAcL9NtYLzecemzPEPStq75aR0+dIkJAkXtErK8/sjRQOdOTk4YNmwYrl+/jrlz5+Lw4cNo1aoVPDw8MH78eLx8+TInxRORFmx7RHmjVq1auHnzJq5duyZ9ypcvjw4dOuDatWtZdkhlZKRUYEITfwBvO6Depfo+oYk/O6SIiIiI6JOg/XYmHcTGxmLdunVYvXo1oqKi0KpVK/To0QMPHz7E9OnTce7cORw8eDC3YiWi/8e2R5Q3bGxsULJkSVmalZUVnJyc1NJ1Vb+kO5Z2LIvQ3RGyQc/d7MwxoYk/6pd0z1HMRO/Tq1evIISApeXbO24fPHiAHTt2wN/fH3Xrvp87i4iIiOjjpVen1Pbt27F69WocOHAA/v7+GDBgADp27Ah7e3spT+nSpVGmTJncipOIwLZH9LGoX9IddfzdcOF+HB4nvoaLjTkq+jryDin64DVr1gwtWrRA37598fz5c3zxxRcwMTHBkydPMHfuXPTr18/QIRIREVE+olenVLdu3dCuXTucPn0aFSpU0JincOHCGDtWy0O3RKQXtj0iwzt27FiulGOkVCDIzylXyiLKK1euXMG8eW/HZ9m2bRtcXV1x9epV/Prrrxg/fjw7pYiIiChb9OqUiomJkW7b1sbCwgITJqgPwEZE+mPbI8qeP//8E8eOHcPjx4+Rnp4umzZ+/HgDRUWUf718+RI2NjYAgIMHD6JFixZQKpWoVKkSHjx4YODoiIiIKL/Rq1PKxsYGMTExcHFxkaU/ffoULi4uSEtLy5XgiEiObY9Id8uXL0e/fv3g7OwMNzc3KBT/ezROoVCwU4pID0WKFJHeSnngwAEMG/b27VePHz/+pN7sR0RERLlDr04pITS9yBpITk6GqWkW79wlIr2x7RHpbsqUKfj+++8xatQoQ4dC9NEYP348vvrqKwwbNgy1atVCUFAQgLd3TXE8QyIiIsqubHVK/fDDDwDe/oV5xYoVsLa2lqalpaXhxIkTKF68eO5GSERse0R6ePbsGVq3bm3oMIg+Kq1atUKVKlUQExODUqVKSem1atVC8+bNDRgZERER5UfZ6pRSDWwphMCyZctgZGQkTTM1NYWPjw+WLVuWuxESEdsekR5at26NgwcPom/fvoYOheij4ubmBjc3N1laxYoVDRQNERER5WfZ6pS6f/8+AKBGjRrYvn07HBwc3ktQRCTHtkeUfUWKFMG4ceNw7tw5BAQEwMTERDZ98ODBBoqMKP9KSkrC9OnTceTIEY0vEPj7778NFBkRERHlR3qNKRUWFpbbcRCRDtj2iHT3008/wdraGsePH8fx48dl0xQKBTuliPTQs2dPHD9+HJ06dYK7u7vsBQJERERE2aVzp9Tw4cMxefJkWFlZYfjw4ZnmnTt3bo4DI6K32PaI9KO6w5CIcs++ffuwZ88eVK5cWe8y6tWrh1OnTuHly5dQKBRwdXXFqlWr0KBBAylPkSJFcO/ePdl8VlZWePHihd7LJSIiog+Pzp1SV69eRUpKivR/bfgXM6LcxbZHlHOqN1eynRDljIODAxwdHXNUxuXLl9G+fXs0adIEycnJGDRoEJo0aYKHDx/CxcVFyufs7IwjR45I362srHK0XCIiIvrw6Nwp9e5jQ3yEiCjvsO0R6W/dunWYNWsW7t69CwAoWrQovv76a3Tq1MnAkRHlT5MnT8b48eOxdu1aWFpa6lXGkydPZN8DAgLg7++PLVu2YNCgQVK6sbExAgMDcxQvERERfdj0GlMqN/mM3gMAiJzeyMCREBHRx2Tu3LkYN24cBg4ciMqVK0MIgdOnT6Nv37548uQJhg0bZugQifKdOXPm4N69e3B1dYWPj4/aCwSuXLmS7TIfPnwIAPDy8pKlx8bGQqlUwtjYGIULF8avv/6Kzz//XGs5CQkJSEhIkL4nJiZmOxYiIiLKWzp3SrVo0ULnQrdv365XMESkjm2PSD8LFy7E0qVL0blzZymtWbNm+PzzzzFx4kR2ShHp4csvv8zV8tLT09GhQwfY2tqiefPmUnqjRo3g4OCAUqVK4cqVK5g9ezbKlSuHx48fw9bWVmNZTZs2VXupAREREX3YdO6UsrOze59xEJEWbHtE+omJiUFwcLBaenBwMGJiYgwQEVH+N2HChFwtr1SpUnjy5AnOnj0rS1+wYIH0/+bNm6Nly5YoU6YMpkyZgpkzZ2osa9euXWp3Svn7++dqvERERJS7dO6UWr169fuMg4i0YNsj0k+RIkWwdetWfPvtt7L0LVu24LPPPjNQVEQfh8uXL+P27dtQKBTw9/dHmTJlsl1GYGAgbt++jaNHj6JChQqZ5i1dujRMTExw8+ZNrXlsbW1ld1G920FFREREHyaDjylFRET0PoSGhqJt27Y4ceIEKleuDIVCgVOnTuHIkSPYunWrocMjypceP36Mdu3a4dixY7C3t4cQAvHx8ahRowY2b96MAgUKZFlGeno6SpcujVu3bmH//v2oVq1alvPcvXsXKSkpKFiwYG6sBhEREX0gdO6UKlu2LI4cOQIHBweUKVMm09dq6zPIJRFpxrZHpJ+WLVvi/PnzmDdvHnbu3AkhBPz9/XHhwgW97uogImDQoEFISEjArVu3UKJECQBAREQEunTpgsGDB2PTpk1ZlhEYGIhbt25h/vz5cHV1xY0bNwC8Hejc0dERsbGxaNy4MXr37g1/f39cunQJ48aNg1KpxMSJE9/n6hEREVEe07lTqlmzZjAzMwOQ+4NcEpF2bHtE+itXrhw2bNhg6DCIPhr79+/H4cOHpQ4pAPD398fixYtRt25dncq4desWAGDo0KGy9B49emDFihUwNTVFZGQk+vbtCyEEjIyM4OPjg40bN8LDwyPX1oWIiIgMT+dOqXcHtsztQS4BwGf0HkROb5Tr5RLld++77RF9TBISEqQxZbIaT0bbG7yISLv09HSYmJiopZuYmCA9PV2nMoQQmU53dHTEkydP9IqPiIiI8pccjSl16dIlaZDLEiVKoFy5crkVFxFlgm2PSDMHBwfExMTAxcUF9vb2Gh93FUJAoVAgLS3NABES5W81a9bEkCFDsGnTJumupX///RfDhg1DrVq1DBwdERER5Td6dUr9888/aN++PU6fPg17e3sAwPPnzxEcHIxNmzZxEEqi94RtjyhzR48ehaOjIwAgLCzMwNEQfXwWLVqEZs2awcfHBwULFoRCoUBUVBQCAgL4qCwRERFlm16dUt27d0dKSgpu376NYsWKAQDu3LmD7t27o0ePHjh48GCuBklEb7HtEWUuJCRE+r+vr6/0o/ldQghER0fndWhEH4WCBQviypUrOHToEP744w/pBQK1a9c2dGhERESUD+nVKXXy5EmcOXNG+lEMAMWKFcPChQtRuXLlXAuOiOTY9oh05+vrKz3K9664uDj4+vry8T2iHKhTpw7q1Klj6DCIiIgon9OrU6pQoUJISUlRS09NTYWnp2eOgyIizdj2iHSnGjsqoxcvXsDc3NwAERHlTz/88AN69+4Nc3Nz/PDDD5nmHTx4cB5FRURERB8DvTqlZs6ciUGDBmHx4sUoV64cFAoFLl26hCFDhmD27Nm5HSMR/T+2PaKsDR8+HACgUCgwbtw4WFpaStPS0tJw/vx5lC5d2kDREeU/8+bNQ4cOHWBubo558+ZpzadQKNgpRURERNmic6eUg4OD7C/OSUlJ+OKLL2Bs/LaI1NRUGBsbo3v37vjyyy9zPVCiTxXbHlH2XL16FcDbO6Vu3rwJU1NTaZqpqSlKlSqFkSNHGio8onzn/v37Gv9PRERElFM6d0rNnz//PYZBRNqw7RFlj+qte926dcOCBQtga2tr4IiIPh6TJk3CyJEjZXcgAsCrV68wa9YsjB8/3kCRERERUX6kc6dUly5d3mccRKQF2x6RflavXm3oEIg+OqGhoejbt69ap9TLly8RGhrKTikiIiLKFr3GlHrXq1ev1AZe5l+lid4/tj2irF28eBG//PILoqKi8ObNG9m07du3Zzn/tGnTsH37dvzxxx+wsLBAcHAwZsyYIXsDJtGnRNsLBK5fvw5HR0cDRJT/iAFuuVaWz6LbwMBcKw6RA0toX44BaIvnU+Zd7w/4wDDbI6cybs+s9qucbP8eCu3j3xlC7CI7gyzXbWC8zjG8m5coLyn1mSkpKQkDBw6Ei4sLrK2t4eDgIPsQ0fvBtkeku82bN6Ny5cqIiIjAjh07kJKSgoiICBw9ehR2drpdHB4/fhwDBgzAuXPncOjQIaSmpqJu3bpISkp6z9ETfVgcHBzg6OgIhUKBokWLwtHRUfrY2dmhTp06aNOmjaHDJCIionxGrzulvvnmG4SFhWHJkiXo3LkzFi9ejH///Rc//vgjpk+fntsxEtH/Y9sj0t3UqVMxb948DBgwADY2NliwYAF8fX3Rp08fuLu761TG/v37Zd9Xr14NFxcXXL58GdWqVXsfYRN9kObPnw8hBLp3747Q0FBZx66pqSl8fHwQFBRkwAiJiIgoP9KrU2r37t1Yt24dqlevju7du6Nq1aooUqQIvL29sXHjRnTo0CG34yQisO0RZce9e/fQqFEjAICZmRmSkpKgUCgwbNgw1KxZE6GhodkuMz7+7a3tfEyJPjWq8Q19fX0RHBwMExMTA0dEREREHwO9Ht+Li4uDr68vgLdj2MTFxQEAqlSpghMnTuRedEQkw7ZHpDtHR0ckJiYCADw9PREeHg4AeP78OV6+fJnt8oQQGD58OKpUqYKSJUtqzZecnIyEhATZh+hjERISInVIvXr1ivs6ERER5YhenVKFCxdGZGQkAMDf3x9bt24F8PYuDnt7+9yKjYgyYNsj0l3VqlVx6NAhAECbNm0wZMgQ9OrVC+3bt0etWrWyXd7AgQNx48YNbNq0KdN806ZNg52dnfQpWLCgXvETfYhevnzJsQ2JiIgo1+jVKdWtWzdcv34dADBmzBgsWbIEZmZmGDZsGL7++utcDZCI/odtj0h3ixYtQrt27QC8bS8jR47Eo0eP0KJFC6xcuTJbZQ0aNAi7du1CWFgYvLy8Ms07ZswYxMfHS5/o6Gi914HoQ/P111/j6NGj0vlnxYoVCA0NhYeHB9atW2fo8IiIiCif0WtMqWHDhkn/r1GjBm7fvo3Lly/Dz88PpUqVyrXgiEiObY9IN6mpqdi9ezfq1asHAFAqlfjmm2/wzTffZKscIQQGDRqEHTt24NixY9Ljs5kxMzODmZmZXnETfeg4tiERERHlJr06pTLy9vaGt7d3bhRFRNmQ07bnM3qPWlrk9EY5CYnog2BsbIx+/frh9u3bOSpnwIAB+Pnnn/Hbb7/BxsYGsbGxAAA7OztYWFjkRqhE+UpmYxv269fPkKERERFRPqTX43sAcOTIETRu3Bh+fn4oUqQIGjdujMOHD+dmbESkAdsekW6++OILXL16NUdlLF26FPHx8ahevTrc3d2lz5YtW3IpSqL8hWMbEhERUW7Sq1Nq0aJFqF+/PmxsbDBkyBAMHjwYtra2aNiwIRYtWpTbMRLR/2PbI9Jd//79MWLECCxatAhnz57FjRs3ZB9dCCE0frp27fp+gyf6QHFsQyIiIspNej2+N23aNMybNw8DBw6U0gYPHozKlSvj+++/l6UTUe5h2yPSXdu2bQG8bSMqCoUCQggoFAqkpaUZKjSifCvj2IZ//PEHLl26lK2xDatXr47jx4/L0pRKpdQm09PTUbNmTZw8eRLp6emws7PD2rVr0axZs9xbESIiIvog6NUplZCQgPr166ul161bF6NGjcpxUESkGdseke7u379v6BCIPiopKSmoW7cufvzxRxQtWhQAUKhQIRQqVCjbZZmZmeHChQvSdxMTE+n/jRo1wvHjx/H1118jKCgIQ4YMQYsWLRAdHQ0PD4+crwgRERF9MPTqlGratCl27Nihdpv2b7/9hiZNmuRKYESkjm2PSHd8AQdR7jIxMUF4eDgUCkWOy1IoFAgMDFRLT09Px8GDB1G/fn3MnDkTAFCrVi3Y2dnh66+/xsaNG3O8bCIiIvpw6Nwp9cMPP0j/L1GiBL7//nscO3YMQUFBAIBz587h9OnTGDFiRO5HSfQJY9sj0s+6desynd65c+c8ioTo49G5c2esXLkS06dPz1E5r1+/hpGREZRKJdzd3bFu3TpUr14dJ06cQHp6uqx92traws3NDefOnctp+ERERPSB0blTat68ebLvDg4OiIiIQEREhJRmb2+PVatW4bvvvsu9CIk+cWx7RPoZMmSI7HtKSgpevnwJU1NTWFpaslOKSA9v3rzBihUrcOjQIZQvXx5WVlay6XPnzs2yjJo1a6JChQqoVKkS7t27h6lTp6JWrVr4448/cOfOHQBAsWLFZPPY29vjv//+y7TchIQEJCQkSN8TExN1XS0iIiIyEJ07pTg2B5FhsO0R6efZs2dqaXfv3kW/fv34ljAiPYWHh6Ns2bIAgD///FM2TdfH+saPHy/73rVrV7i7u2PkyJFo2LAhgLcDn79LCJFluU2bNlUbQJ2IiIg+bHqNKfUu1UVCbowvQES6Y9sjyr7PPvsM06dPR8eOHfHHH38YOhyifCcsLCzXy3RxcYG9vT3++usv6Q6p27dvo3Tp0lKe+Ph42NnZZVrOrl271O6U8vf3z/V4iYiIKPcos86i2bp16xAQEAALCwtYWFggMDAQ69evz83YiEgDtj2inDEyMsLDhw8NHQZRvvbXX3/hwIEDePXqFQDd7mTSJiEhAc+fP4erqyuqVasGpVIpO6+9ePECsbGxqFSpUqbl2NrawsvLS/p4enrqHRMRERHlDb3ulJo7dy7GjRuHgQMHonLlyhBC4PTp0+jbty+ePHmCYcOG5XacRAS2PaLs2LVrl+y7EAIxMTFYtGgRKleubKCoiPK3p0+fok2bNggLC4NCocDdu3dRuHBh9OzZE/b29pgzZ06WZZQvXx6dOnVCmTJlcPfuXXz77bdIT0/H5MmToVQqUbduXezbtw+jRo1CpUqVMGzYMCiVSsyaNSsP1pCIiIjykl6dUgsXLsTSpUtlg8Q2a9YMn3/+OSZOnMgfxkTvCdseke6+/PJL2XeFQoECBQqgZs2aOv1wJiJ1w4YNg4mJCaKiolCiRAkpvW3bthg2bJhObevx48cYPnw40tPToVQq4ebmht9++03qLN6zZw9q1qyJ2bNnIz09HXZ2dti2bRs8PDze23oRERGRYejVKRUTE4Pg4GC19ODgYMTExOQ4KCLSjG2PSHfp6emGDoHoo3Pw4EEcOHAAXl5esvTPPvsMDx480KmMqKioTKcrlUocO3ZM3xCJiIgoH9GrU6pIkSLYunUrvv32W1n6li1b8Nlnn+VKYESkjm2PKHPDhw/XOa8ur64nIrmkpCRYWlqqpT958gRmZmYGiIiIiIjyM706pUJDQ9G2bVucOHEClStXhkKhwKlTp3DkyBFs3bo1t2Mkov/HtkeUuatXr8q+X758GWlpadIbvf78808YGRmhXLlyhgiPKN+rVq0a1q1bh8mTJwN4+1hseno6Zs2ahRo1ahg4OiIiIspv9OqUatmyJS5cuIC5c+di586dEELA398fFy5cQJkyZXI7RiL6f2x7RJl793X1c+fOhY2NDdauXQsHBwcAwLNnz9CtWzdUrVrVUCES5WuzZs1C9erVcenSJbx58wbffPMNbt26hbi4OJw+fdrQ4REREVE+k+1OqZSUFPTu3Rvjxo3Dhg0b3kdMRKQB2x5R9syZMwcHDx6UOqQAwMHBAVOmTEHdunUxYsQIA0ZHlD/5+/vjxo0bWLp0KYyMjJCUlIQWLVpgwIABcHd3N3R4RERElM8oszuDiYkJduzY8T5iIaJMsO0RZU9CQgIePXqklv748WMkJiYaICKi/C8qKgqurq4IDQ3F77//jr1792LKlClwd3fPcgBzIiIiooyy3SkFAM2bN8fOnTtzORQiygrbHpHumjdvjm7dumHbtm34559/8M8//2Dbtm3o0aMHWrRoYejwiPIlX19f/Pfff2rpT58+ha+vrwEiIiIiovxM77fvTZ48GWfOnEG5cuVgZWUlmz548OBcCY6I5Nj2iHS3bNkyjBw5Eh07dkRKSgoAwNjYGD169MCsWbMMHB1R/iSEgEKhUEt/8eIFzM3NDRARERER5Wd6dUqtWLEC9vb2uHz5Mi5fviybplAo+MOY6D1h2yPSnaWlJZYsWYJZs2bh3r17EEKgSJEiap25RJS14cOHA3h7rhk3bhwsLS2laWlpaTh//jxKly5toOiIiIgov9KrU+r+/fvS/4UQAKDxr2bZ5TN6DwAgcnqjHJdF9DF6X22P6GNmZWWFwMBAQ4dBlK9dvXoVwNtzz82bN2FqaipNMzU1RalSpTBy5EhDhUdERET5lF6dUgCwcuVKzJs3D3fv3gUAfPbZZxg6dCh69uyZa8ERkTq2PSIiymthYWEAgG7duuGHH36AjY2NgSPKXZEDS8Bn0W1Dh5FtkQNLZCv9fefLife9DE3l67rNfRbdzpM6yLjMjHIag2z+ARoyDMxkWlYG/u+/qtizilc1Xdt20FoHqvgGqk2WdB+wKdNlazUQmKHfnJlyGxj/HkrNfzF8SGIX2Rk6BPp/enVKjRs3DvPmzcOgQYMQFBQEADh79iyGDRuGyMhITJkyJUdB+Yzew7uliDR4320P+N8diypsi0RE9O7LAbp06aI13/bt2/MiHCIiIvpI6NUptXTpUixfvhzt27eX0po2bYrAwEAMGjQoV34YE5E6tj0iIjIEOzv+RZmIiIhyn16dUmlpaShfvrxaerly5ZCamprjoIhIM7Y9IiIyhNWrVxs6BCIiIvoIKfWZqWPHjli6dKla+k8//YQOHTrkOCgi0oxtj4iIiIiIiD4WORro/ODBg6hUqRIA4Ny5c4iOjkbnzp2l1wYDwNy5c3MeJRFJ2PaIiIiIiIjoY6BXp1R4eDjKli0LALh37x4AoECBAihQoADCw8OlfHxVPVHuYtsjIiIiIiKij4VenVKq1wITUd5i2yMiIiIiIqKPhV5jShEREX1KlixZAl9fX5ibm6NcuXI4efKkoUMiIiIiIsr32ClFRESUiS1btmDo0KEYO3Ysrl69iqpVq6JBgwaIiooydGhERERERPkaO6WIiIgyMXfuXPTo0QM9e/ZEiRIlMH/+fBQsWFDjmzCJiIiIiEh3er99733zGb0HABA5vZGBIyH6tKnaogrbJH1K3rx5g8uXL2P06NGy9Lp16+LMmTMa50lOTkZycrL0PSEh4b3GSERERESUX/FOKSIiIi2ePHmCtLQ0uLq6ytJdXV0RGxurcZ5p06bBzs5O+hQsWDAvQiXKN4yNjaFQKNQ+AQEBAIAiRYqoTbO2tjZw1ERERPQ+fLB3ShHRh4l3TtGnSKFQyL4LIdTSVMaMGYPhw4dL3xMSEtgxRfSOmzdvIiUlRfq+f/9+jBo1Cj169JDSnJ2dceTIEem7lZVVnsZIREREeeOD75TiY3xERGQozs7OMDIyUrsr6vHjx2p3T6mYmZnBzMwsL8IjypdKlCgh+96lSxcYGxtj8ODBUpqxsTECAwPzOjQiIiLKY3x8j4iISAtTU1OUK1cOhw4dkqUfOnQIwcHBBoqK6OPx4sULXL9+HTVq1IBS+b/L0tjYWCiVSpiamqJ48eK4detWlmUlJCTgn3/+kT7//vvv+wydiIiIcsEHf6cUERGRIQ0fPhydOnVC+fLlERQUhJ9++glRUVHo27evoUMjyvfGjRsHIQSmT58upTVq1AgODg4oVaoUrly5gtmzZ6NcuXJ4/PgxbG1ttZbVtGlTHD9+PC/CJiIiolzCTikiIqJMtG3bFk+fPsWkSZMQExODkiVLYu/evfD29jZ0aET53vr16+Hi4oKyZctKaQsWLJD+37x5c7Rs2RJlypTBlClTMHPmTK1l7dq1S/a2y8TERPj7+7+fwImIiChXsFOKiHKEA5/Tp6B///7o37+/ocMg+qicPn0aT58+xZgxYzLNV7p0aZiYmODmzZuZ5rO1tZXdSfVuBxURERF9mDimFBERERHlubFjx0KpVGL8+PGZ5rt79y5SUlL4FksiIqKPEO+UIqJcxTuniIgoK6mpqTh16hQqVKgAc3NzKT02NhaNGzdG79694e/vj0uXLmHcuHFQKpWYOHGi4QImIiKi9yLfdEq9+0OXP3KJiIiI8q9Zs2YhLS0NoaGhsnRTU1NERkaib9++EELAyMgIPj4+2LhxIzw8PAwULREREb0v+aZTioiIiIg+DmPGjNE4lpSjoyOePHligIiIiIjIEPJlp5TqrineMUX04ePjfERERERERKRJvuyUUuEjfURERERERERE+VO+7pR6V8a7MTJipxVR/sG7q4iIiIiIiD5+H02nVFay6rTKCn8UE70fOW2bRERERERElD99Mp1SOcU7sYhyx4fQCcU7sYiIiIiIiAyPnVK55EP4of0u/simj0lOO5Gyap+G6KRixxgREREREX3q2Cn1keLjivQxYycSERERERFR/sdOKdLoQ7vzSxN2CpBKbu+vupSXVSdVdmPSpdMrt+8Yy2p+TevAdkdERERERLnFIJ1SQggAQHryS0Msnj4ShYb9ku15wkPrISEhAcD/9sNPBdvd+6XP/pgZ1X76rozbLqtlhofWy3T+jMsoOeFAlnFlXGbGZWT0bpmq5X+qbU/TNiXKC5/6eS/hjW750xNeAEiSvus6H33Y3m5XzdtTNU0Xeb0/aIotv+yTmdV5Zvl1kRd18Fq1LA2nbRMty09J0C1f7klWS/kQ9o/EhE/rPEOZe/H/+0NW1x8KYYArlH/++QcFCxbM68USyURHR8PLy8vQYeQZtjv6ULDtERnGp9b2/v77b/j5+Rk6DCIiok9aVtcfBumUSk9Px507d+Dv74/o6GjY2trmdQgfhYSEBBQsWJB1mE1CCCQmJsLDwwNKpdLQ4eSZ9PR0PHz4EDY2NlAoFIYOR28f037/Ma0LkPX6sO2pt72PbR/Irz727fCptr3nz5/DwcEBUVFRsLOzM3Q4+dLH3jbeN9ZfzrD+co51mDOsv5zR9frDII/vKZVKeHp6AgBsbW25gXOIdZh9n+LFqVKp/Kj+Qv4x7fcf07oAma8P255mH9s+kF99zNvhU217wNt1/1i3a175mNtGXmD95QzrL+dYhznD+tOfLtcfn86fy4iIiIiIiIiI6IPBTikiIiIiIiIiIspzBuuUMjMzw4QJE2BmZmaoEPI91iF9ij6m/f5jWhfg41ufvMA6+zBwO3ycuF1zjnWYM6y/nGH95RzrMGdYf3nDIAOdExERERERERHRp42P7xERERERERERUZ5jpxQREREREREREeU5dkoREREREREREVGeM1in1JIlS+Dr6wtzc3OUK1cOJ0+eNFQoH7yJEydCoVDIPm5ubtJ0IQQmTpwIDw8PWFhYoHr16rh165YBIybKmWnTpqFChQqwsbGBi4sLvvzyS9y5c0eWp2vXrmrtolKlSgaKWLuPrf36+PiorY9CocCAAQMA5J/t8qHguTDvfGxtkbLG9qXZiRMn0KRJE3h4eEChUGDnzp2y6bq0heTkZAwaNAjOzs6wsrJC06ZN8c8//+ThWhiOLtcorEPtli5disDAQNja2sLW1hZBQUHYt2+fNJ11lz3Tpk2DQqHA0KFDpTTWYeZy43rgU66/98EgnVJbtmzB0KFDMXbsWFy9ehVVq1ZFgwYNEBUVZYhw8oXPP/8cMTEx0ufmzZvStJkzZ2Lu3LlYtGgRLl68CDc3N9SpUweJiYkGjJhIf8ePH8eAAQNw7tw5HDp0CKmpqahbty6SkpJk+erXry9rF3v37jVQxJn7mNrvxYsXZety6NAhAEDr1q2lPPlluxgaz4V572Nqi5Q5ti/tkpKSUKpUKSxatEjjdF3awtChQ7Fjxw5s3rwZp06dwosXL9C4cWOkpaXl1WoYjC7XKKxD7by8vDB9+nRcunQJly5dQs2aNdGsWTPpRz/rTncXL17ETz/9hMDAQFk66zBrOb0e+NTrL9cJA6hYsaLo27evLK148eJi9OjRhgjngzdhwgRRqlQpjdPS09OFm5ubmD59upT2+vVrYWdnJ5YtW5ZHERK9X48fPxYAxPHjx6W0Ll26iGbNmhkuKB197O13yJAhws/PT6Snpwsh8s92+RDwXJi3Pva2SHJsX7oBIHbs2CF916UtPH/+XJiYmIjNmzdLef7991+hVCrF/v378yz2D0XGaxTWYfY5ODiIFStWsO6yITExUXz22Wfi0KFDIiQkRAwZMkQIwf1PFzm9HvjU6+99yPM7pd68eYPLly+jbt26svS6devizJkzeR1OvnH37l14eHjA19cX7dq1w99//w0AuH//PmJjY2X1aWZmhpCQENYnfTTi4+MBAI6OjrL0Y8eOwcXFBUWLFkWvXr3w+PFjQ4SXpY+1/b558wYbNmxA9+7doVAopPT8sl0MiedCw/hY2yLJsX3pT5e2cPnyZaSkpMjyeHh4oGTJkp9k/Wa8RmEd6i4tLQ2bN29GUlISgoKCWHfZMGDAADRq1Ai1a9eWpbMOdZOT6wHWX+7L806pJ0+eIC0tDa6urrJ0V1dXxMbG5nU4+cIXX3yBdevW4cCBA1i+fDliY2MRHByMp0+fSnXG+qSPlRACw4cPR5UqVVCyZEkpvUGDBti4cSOOHj2KOXPm4OLFi6hZsyaSk5MNGK26j7n97ty5E8+fP0fXrl2ltPyyXQyN58K89zG3RZJj+9KfLm0hNjYWpqamcHBw0JrnU6HpGoV1mLWbN2/C2toaZmZm6Nu3L3bs2AF/f3/WnY42b96MK1euYNq0aWrTWIdZy+n1wKdef++DsaEW/O5f1YG3B/WMafRWgwYNpP8HBAQgKCgIfn5+WLt2rTSAMOuTPlYDBw7EjRs3cOrUKVl627Ztpf+XLFkS5cuXh7e3N/bs2YMWLVrkdZhafcztd+XKlWjQoAE8PDyktPyyXT4U+XXb50cfc1skzbg99adP3X2K9avtGgVgHWamWLFiuHbtGp4/f45ff/0VXbp0wfHjx6XprDvtoqOjMWTIEBw8eBDm5uZa87EOtXtf1wOfSv29D3l+p5SzszOMjIzUehEfP36s1iNJmllZWSEgIAB3796V3hTA+qSP0aBBg7Br1y6EhYXBy8sr07zu7u7w9vbG3bt38yg6/Xws7ffBgwc4fPgwevbsmWm+/LJd8hrPhYb3sbRFUsf2pT9d2oKbmxvevHmDZ8+eac3zKdB2jcI6zJqpqSmKFCmC8uXLY9q0aShVqhQWLFjAutPB5cuX8fjxY5QrVw7GxsYwNjbG8ePH8cMPP8DY2FiqA9ah7rJ7PcD6y3153illamqKcuXKSW9sUjl06BCCg4PzOpx8KTk5Gbdv34a7uzt8fX3h5uYmq883b97g+PHjrE/Kt4QQGDhwILZv346jR4/C19c3y3mePn2K6OhouLu750GE+vtY2u/q1avh4uKCRo0aZZovv2yXvMZzoeF9LG2R1LF96U+XtlCuXDmYmJjI8sTExCA8PPyTqN+srlFYh9knhEBycjLrTge1atXCzZs3ce3aNelTvnx5dOjQAdeuXUPhwoVZh9mU3esB1t97kKfDqv+/zZs3CxMTE7Fy5UoREREhhg4dKqysrERkZKQhwvngjRgxQhw7dkz8/fff4ty5c6Jx48bCxsZGqq/p06cLOzs7sX37dnHz5k3Rvn174e7uLhISEgwcOZF++vXrJ+zs7MSxY8dETEyM9Hn58qUQ4u0bR0aMGCHOnDkj7t+/L8LCwkRQUJDw9PT84Pb7j7H9pqWliUKFColRo0bJ0vPTdvkQ8FyYtz7GtkjasX1pl5iYKK5evSquXr0qAIi5c+eKq1evigcPHgghdGsLffv2FV5eXuLw4cPiypUrombNmqJUqVIiNTXVUKuVZ7K6RhGCdZiZMWPGiBMnToj79++LGzduiG+//VYolUpx8OBBIQTrTh/vvn1PCNZhVnLjeuBTrr/3wSCdUkIIsXjxYuHt7S1MTU1F2bJlZa96J7m2bdsKd3d3YWJiIjw8PESLFi3ErVu3pOnp6eliwoQJws3NTZiZmYlq1aqJmzdvGjBiopwBoPGzevVqIYQQL1++FHXr1hUFChQQJiYmolChQqJLly4iKirKsIFr8DG23wMHDggA4s6dO7L0/LRdPhQ8F+adj7EtUubYvjQLCwvTeI7t0qWLEEK3tvDq1SsxcOBA4ejoKCwsLETjxo0/mWN9VtcoQrAOM9O9e3epXRYoUEDUqlVL6pASgnWnj4ydUqzDzOXG9cCnXH/vg0IIIfL45iwiIiIiIiIiIvrE5fmYUkREREREREREROyUIiIiIiIiIiKiPMdOKSIiIiIiIiIiynPslCIiIiIiIiIiojzHTikiIiIiIiIiIspz7JQiIiIiIiIiIqI8x04pIiIiIiIiIiLKc+yUIiIiIiIiIiKiPMdOqVyyZs0a2NvbS98nTpyI0qVLZ6sMhUKBnTt3ap0eGRkJhUKBa9eu6RXj+3bs2DEoFAo8f/7c0KGQHvLzPpwxdkPw8fHB/Pnz82RZnTp1wtSpU6XvL1++RMuWLWFra5sv2+Dvv/+OMmXKID093dChkI6qV6+OoUOHGjoMmayOP0REpE6f673cNG7cOPTu3Vv6LoRA79694ejo+EH/7tHm5s2b8PLyQlJSkqFDIco32ClFRJQN2jrALl68KLuoel9u3LiBPXv2YNCgQVLa2rVrcfLkSZw5cwYxMTGws7N773HkpsaNG0OhUODnn382dCiko+3bt2Py5MkA8rZDFtD+AyomJgYNGjTIsziIiD50CoUi00/Xrl0xcuRIHDlyxCDxPXr0CAsWLMC3334rpe3fvx9r1qzB77//jpiYGJQsWdIgsekrICAAFStWxLx58wwdClG+wU6pT1xaWhrvTiAC8ObNmxzNX6BAAVhaWuZSNNotWrQIrVu3ho2NjZR27949lChRAiVLloSbmxsUCoXafDldv/etW7duWLhwoaHDIB05OjrK9sHckNN91M3NDWZmZrkUDRFR/hcTEyN95s+fD1tbW1naggULYG1tDScnJ4PEt3LlSgQFBcHHx0dKu3fvHtzd3REcHAw3NzcYGxurzZcfrmmWLl2KtLQ0Q4dClC+wU+od27ZtQ0BAACwsLODk5ITatWsjKSkJJ06cgImJCWJjY2X5R4wYgWrVqulU9sWLF1GnTh04OzvDzs4OISEhuHLlilo+1V96LSws4Ovri19++SXTciMiItCwYUNYW1vD1dUVnTp1wpMnT7TmV93l8fvvv8Pf3x9mZmZ48OCBTvEpFAqsWLECzZs3h6WlJT777DPs2rVL67JevXqFRo0aoVKlSoiLi8uihig3fAr7MPB2Py5UqBAsLS3RvHlzPH36VDa9a9eu+PLLL2VpQ4cORfXq1aXv1atXx8CBAzF8+HA4OzujTp06AIC5c+ciICAAVlZWKFiwIPr3748XL14AePuIardu3RAfHy/9lXHixIkA1O8WiYqKQrNmzWBtbQ1bW1u0adMGjx49kqar7vZYv349fHx8YGdnh3bt2iExMVHreqenp+OXX35B06ZNZesxZ84cnDhxAgqFQlpHHx8fTJkyBV27doWdnR169eoFABg1ahSKFi0KS0tLFC5cGOPGjUNKSopaXKtWrUKhQoVgbW2Nfv36IS0tDTNnzoSbmxtcXFzw/fffy2KLj49H79694eLiAltbW9SsWRPXr1+Xpl+/fh01atSAjY0NbG1tUa5cOVy6dEma3rRpU1y4cAF///231vWnD4fq8b3q1avjwYMHGDZsmNQmVM6cOYNq1arBwsICBQsWxODBg2WPM+izj65ZswahoaG4fv26tLw1a9YAUH987+bNm6hZs6Z0POzdu7fUloH/HSdmz54Nd3d3ODk5YcCAAbL2QESUn7m5uUkfOzs7KBQKtbSMd5+qjo1Tp06Fq6sr7O3tERoaitTUVHz99ddwdHSEl5cXVq1aJVvWv//+i7Zt28LBwQFOTk5o1qwZIiMjM41v8+bNsmuarl27YtCgQYiKioJCoZA6q/S5ZgPkv3uKFSsGS0tLtGrVCklJSVi7di18fHzg4OCAQYMGyTqQ3rx5g2+++Qaenp6wsrLCF198gWPHjknTHzx4gCZNmsDBwQFWVlb4/PPPsXfvXml6vXr18PTpUxw/flzXTUX0SWOn1P+LiYlB+/bt0b17d9y+fRvHjh1DixYtIIRAtWrVULhwYaxfv17Kn5qaig0bNqBbt246lZ+YmIguXbrg5MmTOHfuHD777DM0bNhQ7QfouHHj0LJlS1y/fh0dO3ZE+/btcfv2ba0xh4SEoHTp0rh06RL279+PR48eoU2bNpnG8vLlS0ybNg0rVqzArVu34OLionN8oaGhaNOmDW7cuIGGDRuiQ4cOGjuc4uPjUbduXbx58wZHjhyBo6OjTvVE+vtU9uHz58+je/fu6N+/P65du4YaNWpgypQpOq1DRmvXroWxsTFOnz6NH3/8EQCgVCrxww8/IDw8HGvXrsXRo0fxzTffAACCg4PV/tI4cuRItXKFEPjyyy8RFxeH48eP49ChQ7h37x7atm0ry3fv3j3s3LkTv//+O37//XccP34c06dP1xrvjRs38Pz5c5QvX15K2759O3r16oWgoCDExMRg+/bt0rRZs2ahZMmSuHz5MsaNGwcAsLGxwZo1axAREYEFCxZg+fLlareY37t3D/v27cP+/fuxadMmrFq1Co0aNcI///yD48ePY8aMGfjuu+9w7tw5aX0bNWqE2NhY7N27F5cvX0bZsmVRq1Yt6fjQoUMHeHl54eLFi7h8+TJGjx4NExMTaZne3t5wcXHByZMns95w9MHYvn07vLy8MGnSJKlNAG87hOrVq4cWLVrgxo0b2LJlC06dOoWBAwfK5s/uPtq2bVuMGDECn3/+ubS8jO0KeHueq1+/PhwcHHDx4kX88ssvOHz4sNryw8LCcO/ePYSFhWHt2rVYs2aN1MlFRPSpOnr0KB4+fIgTJ05g7ty5mDhxIho3bgwHBwecP38effv2Rd++fREdHQ3g7TG3Ro0asLa2xokTJ3Dq1ClYW1ujfv36Wu9qevbsGcLDw2XXNAsWLMCkSZPg5eWFmJgYXLx4UZqW3Ws2lZcvX+KHH37A5s2bsX//fun6eO/evdi7dy/Wr1+Pn376Cdu2bZPm6datG06fPo3Nmzfjxo0baN26NerXr4+7d+8CAAYMGIDk5GScOHECN2/exIwZM2BtbS3Nb2pqilKlSvGahkhXgoQQQly+fFkAEJGRkRqnz5gxQ5QoUUL6vnPnTmFtbS1evHghhBBi9erVws7OTpo+YcIEUapUKa3LS01NFTY2NmL37t1SGgDRt29fWb4vvvhC9OvXTwghxP379wUAcfXqVSGEEOPGjRN169aV5Y+OjhYAxJ07dzQud/Xq1QKAuHbtmtbYMovvu+++k76/ePFCKBQKsW/fPiGEEGFhYQKA+OOPP0SpUqVEixYtRHJycqbLodzzqezD7du3F/Xr15eltW3bVhZ7ly5dRLNmzWR5hgwZIkJCQqTvISEhonTp0lrXT2Xr1q3CyclJ+p6xnlS8vb3FvHnzhBBCHDx4UBgZGYmoqChp+q1btwQAceHCBSHE2/q1tLQUCQkJUp6vv/5afPHFF1pj2bFjhzAyMhLp6emZrpsqni+//DLL9Zs5c6YoV66c9F1TXPXq1RM+Pj4iLS1NSitWrJiYNm2aEEKII0eOCFtbW/H69WtZ2X5+fuLHH38UQghhY2Mj1qxZk2ksZcqUERMnTswyZjK8kJAQMWTIECGEfN9X6dSpk+jdu7cs7eTJk0KpVIpXr15J8+m7j2o6NgEQO3bsEEII8dNPPwkHBwfp+CaEEHv27BFKpVLExsYKId4eJ7y9vUVqaqqUp3Xr1qJt27ZZxkRElN9ou37JeExVHRsznvOrVq0qfU9NTRVWVlZi06ZNQgghVq5cKYoVKya7PklOThYWFhbiwIEDGuO5evWqACC7VhJCiHnz5glvb29ZWk6u2QCIv/76S0rr06ePsLS0FImJiVJavXr1RJ8+fYQQQvz1119CoVCIf//9V1Z2rVq1xJgxY4QQQgQEBGR5vdK8eXPRtWvXLGMmIiF4p9T/K1WqFGrVqoWAgAC0bt0ay5cvx7Nnz6TpXbt2xV9//SXdGbBq1Sq0adMGVlZWOpX/+PFj9O3bF0WLFoWdnR3s7Ozw4sULREVFyfIFBQWpfdd2l8nly5cRFhYGa2tr6VO8eHEAb+900MbU1BSBgYF6xffufFZWVrCxscHjx49leWrXro3ChQtj69atMDU11RoH5a5PZR++ffu2xmXo492/zqmEhYWhTp068PT0hI2NDTp37oynT59m6y0qt2/fRsGCBVGwYEEpzd/fH/b29rK68PHxkY3L4+7urtae3vXq1SuYmZlpHDNKE03rt23bNlSpUgVubm6wtrbGuHHj1LZhxrhcXV3h7+8PpVIpS1PFevnyZbx48QJOTk6ybXn//n1pOw4fPhw9e/ZE7dq1MX36dI3b18LCAi9fvtRp3ejDdvnyZaxZs0a2P9SrVw/p6em4f/++lE/ffTQrt2/fRqlSpWTHt8qVKyM9PR137tyR0j7//HMYGRlJ37Nqg0REn4LPP/9c7ZwfEBAgfTcyMoKTk5PsOuCvv/6CjY2NdMx3dHTE69evtV7PvXr1CgBgbm6uU0z6XrNZWlrCz89Pti4+Pj6yO5vevaa5cuUKhBAoWrSo7Bx2/PhxaV0GDx6MKVOmoHLlypgwYQJu3LihFhuvaYh0pz5y3CfKyMgIhw4dwpkzZ3Dw4EEsXLgQY8eOxfnz5+Hr6wsXFxc0adIEq1evRuHChbF3717Zs8VZ6dq1K/777z/Mnz8f3t7eMDMzQ1BQkE4D9Wn7AZqeno4mTZpgxowZatPc3d21lmdhYaFWpq7xvfu4jSq2jAOlN2rUCL/++isiIiJkJzB6vz6VfVgIkeXylEqlWj5N48Rk7JB78OABGjZsiL59+2Ly5MlwdHTEqVOn0KNHj2yNMyOE0LjOGdN1aU/vcnZ2xsuXL/HmzRudOnwzrt+5c+fQrl07hIaGol69erCzs8PmzZsxZ84cWT5NcWUWa3p6Otzd3TXuT6o3FU6cOBFfffUV9uzZg3379mHChAnYvHkzmjdvLuWNi4tDgQIFslwv+vClp6ejT58+GDx4sNq0QoUKSf/Xdx/NirY2CCBHbZCI6FOgz3VAuXLlsHHjRrWytJ3XnZ2dAbx9jE+Xc7++12z6rIuRkREuX74s+6MFAKkjq2fPnqhXrx727NmDgwcPYtq0aZgzZ47szchxcXGyzjAi0o6dUu9QKBSoXLkyKleujPHjx8Pb2xs7duzA8OHDAbw9ALVr1w5eXl7w8/ND5cqVdS775MmTWLJkCRo2bAgAiI6O1jiY87lz59C5c2fZ9zJlymgss2zZsvj111/h4+Oj8c0U2aFrfLqYPn06rK2tUatWLRw7dgz+/v45io109ynsw/7+/tLdXu8u410FChRAeHi4LO3atWtqFyEZXbp0CampqZgzZ470F8KtW7fK8piammb5NhV/f39ERUUhOjpaulsqIiIC8fHxKFGiRKbzZkY1EGlERIRsUFJdnT59Gt7e3hg7dqyU9uDBA73jUSlbtixiY2NhbGwse4NORkWLFkXRokUxbNgwtG/fHqtXr5Y6pVR/TdW2r9CHS1ObKFu2LG7duoUiRYpkqyxd9lFd2+DatWuRlJQk/ZA5ffo0lEolihYtmq2YiIgoc2XLlsWWLVukl53ows/PD7a2toiIiNDruKzLNZs+ypQpg7S0NDx+/BhVq1bVmq9gwYLS2FpjxozB8uXLZZ1S4eHhaNWqVY7jIfoU8PG9/3f+/HlMnToVly5dQlRUFLZv347//vtP9gNS9VfbKVOm6Dw4tEqRIkWwfv163L59G+fPn0eHDh1gYWGhlu+XX37BqlWr8Oeff2LChAm4cOGC2sCsKgMGDEBcXBzat28vvbXq4MGD6N69e7ZfQaprfLqaPXs2OnTogJo1a+KPP/7QuxzS3aeyDw8ePBj79+/HzJkz8eeff2LRokXYv3+/LE/NmjVx6dIlrFu3Dnfv3sWECRPUOqk08fPzQ2pqKhYuXIi///4b69evx7Jly2R5fHx88OLFCxw5cgRPnjzReGt27dq1ERgYiA4dOuDKlSu4cOECOnfujJCQEI23n+uqQIECKFu2LE6dOqXX/EWKFEFUVBQ2b96Me/fu4YcffsCOHTv0jkeldu3aCAoKwpdffokDBw4gMjISZ86cwXfffYdLly7h1atXGDhwII4dO4YHDx7g9OnTuHjxomzfPHfunHT3HeUvPj4+OHHiBP7991+po3rUqFE4e/YsBgwYgGvXruHu3bvYtWuX7IJdE132UR8fH9y/fx/Xrl3DkydPkJycrFZOhw4dYG5uji5duiA8PBxhYWEYNGgQOnXqBFdX19xbeSIiQocOHeDs7IxmzZrh5MmTuH//Po4fP44hQ4bgn3/+0TiPUqlE7dq19b6m0eWaTR9FixZFhw4d0LlzZ2zfvh3379/HxYsXMWPGDOkNe0OHDsWBAwdw//59XLnyf+3dzSv0axzH8c/cNpoFWaAsSDJDSTOLqUmRp5ixoJCHZNKUhyIPKRss2IhiFjQLiahpxpKFYqEoykPnD2BhLCwkJAssJmdxzpmS+9zGQ+O+eb/W11x9f3U1/fr0vb6/v7S5ufnknSYYDOrs7EylpaXvrgf4Dgil/hUXF6ft7W1VVFTIZDJpaGhIk5OTcjqd4TU/fvxQS0uLQqHQk06QSMzPz+v6+lpWq1XNzc3q7u5WUlLSs3UjIyMKBALKzc3V4uKifD7f/3YapaSkaGdnR6FQSOXl5crJyVFPT4/i4+Of3AP/yPpew+PxqK6uTsXFxTo6OnrXXnjZdznDdrtdc3Nzmp6elsVi0cbGhoaGhp6sKS8v1/DwsAYGBmSz2XR7exvR81osFk1NTWl8fFw5OTny+XwaGxt7siYvL08dHR2qr69XYmKiJiYmnu3z36fpExISVFBQEJ6ztry8/GINL2lra/tpe3wkqqqq1NfXp66uLlksFu3u7oa/ePYeBoNBa2trKigokNvtlslkUkNDg4LBoJKTkxUTE6PLy0u5XC6ZTCbV1dXJ6XRqZGQkvIff71dTU5OMRuO760F0jY6OKhgMKiMjI3wFIzc3V1tbWzo+PlZ+fr6sVquGh4d/ebVciuyM1tTUyOFwqKioSImJifL7/c/2MRqNWl9f19XVlWw2m2pra1VSUqKZmZmPe3AAgKR//nO3t7eVmpqq6upqZWdny+126+7u7pedU21tbQoEAm+6Nh3JO9tbLSwsyOVyqb+/X2azWZWVldrb2wt3v4dCIXV2dio7O1sOh0Nms1lerzf8e7/fr7KyMqWlpX1IPcBXZ3iMZEALwlpbW3V+fq7V1dXPLgV4E87wn+3+/l5ms1mBQODLdBVdXFwoKytLh4eHSk9P/+xyAABAFDw+Psput6u3t1eNjY2fXc6HeHh4UGZmpvx+/6vGZADfGTOlInRzc6ODgwP5fD6trKx8djnAq3GGv4bY2FgtLS29eebb7+jk5ERer5dACgCAb8RgMGh2dvanX6/7U52enmpwcJBACngFOqUiVFhYqP39fbW3t8vj8Xx2OcCrcYYBAAAAAL8TQikAAAAAAABEHYPOAQAAAAAAEHWEUgAAAAAAAIg6QikAAAAAAABEHaEUAAAAAAAAoo5QCgAAAAAAAFFHKAUAAAAAAICoI5QCAAAAAABA1BFKAQAAAAAAIOoIpQAAAAAAABB1fwN7BLxVr34c4wAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -2347,12 +2356,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [05:54<00:06, 6.73s/it]" + " 99%|████████████████████████████████▋| 100/101 [02:14<00:01, 1.32s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2364,30 +2373,28 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [06:02<00:00, 7.10s/it]\n", - "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.81model snapshot/s]\n" + "100%|█████████████████████████████████| 101/101 [02:16<00:00, 1.35s/it]\n", + "Reindexing: 100%|█████████████| 7/7 [00:01<00:00, 4.74model snapshot/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", - "exists. Use `overwrite=True` or pick a different name\n", - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/8b46\n", - "f4d1412b3b5343c7568134c8ecac_ar\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/8b46f4d1412b3b5343\n", + "c7568134c8ecac/8b46f4d1412b3b5343c7568134c8ecac_ar\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [00:51<00:53, 2.05s/it]" + " 49%|█████████████████▏ | 25/51 [00:31<00:33, 1.27s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2399,12 +2406,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [01:43<00:02, 2.04s/it]" + " 98%|██████████████████████████████████▎| 50/51 [01:04<00:01, 1.27s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2416,7 +2423,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [01:45<00:00, 2.08s/it]\n", + "100%|███████████████████████████████████| 51/51 [01:06<00:00, 1.30s/it]\n", "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:589: UserWarning:\n", "\n", "'kappa' with will be cast to \n", @@ -2427,20 +2434,54 @@ "name": "stdout", "output_type": "stream", "text": [ - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/8b46\n", - "f4d1412b3b5343c7568134c8ecac_ar\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/8b46f4d1412b3b5343\n", + "c7568134c8ecac/8b46f4d1412b3b5343c7568134c8ecac_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|████████▍ | 25/101 [00:33<01:40, 1.32s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|████████████████▊ | 50/101 [01:07<01:07, 1.32s/it]" ] }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [03:03<02:55, 6.76s/it]" + " 74%|█████████████████████████▏ | 75/101 [01:40<00:34, 1.32s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAD6CAYAAABwKvR6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACN9UlEQVR4nOzdd1gUx/8H8PfRjo4UaYqAKIq9RQU12HvvLXZj78ZYooAaa2zRqDF2jS1Gjb0jdsUaEWOMEdEIYgVFQcr8/vB3+/W4Ozjg4ADfr+e5R292buezczu7e8PujEwIIUBERERERERERJSLDPQdABERERERERERfX7YKUVERERERERERLmOnVJERERERERERJTr2ClFRERERERERES5jp1SRERERERERESU69gpRUREREREREREuY6dUkRERERERERElOvYKUVERERERERERLmOnVJERERERERERJTr2ClFRJSHXb9+HW3btoWrqyvMzc1RunRpTJ8+He/evVPK5+HhgZYtW2Z6/eHh4ZDL5ZDJZLhy5YraPH/88Qf8/f1hbW0NCwsLlC1bFqtWrVLK8/LlS3Tt2hWOjo6QyWRo27atynqePn0Ke3t7yGQy7Ny5U6v4AgMDIZPJlNL279+PXr16oXz58jA2NlZZrsnx48chk8kgk8nw/PlzpWW3b9/G0KFD4evrCwsLC8hkMpw6dUplHVFRUfjuu+/g6+sLBwcHWFtbo2rVqli1ahVSUlLUxp62LHV+/PFH1KxZEw4ODpDL5ShWrBi6du2K27dvK+U7deqU1vW3fv16aXvTvqKjo5XyTpkyBZUrV4adnR1MTU1RvHhxfP3113j48GG6ZaRXp1u3bsWXX34JJycnyOVyuLq6olWrVjh//nyGsacVERGhcVtkMhmaNm2qVd5t27aprFsIgXXr1qF69eqwsLCAtbU1qlSpgj/++EMpX1xcHKZMmQJvb2+Ym5ujSJEi6NSpk8p39ObNG0yYMAGNGzdG4cKFIZPJEBgYqHa7tP3e09Km3WZE22MLaa9u3booV66cUtqsWbOwZ88e/QSkRRyKY4q6411Oy4njrmJ71L0uXryYS1tGRESZYaTvAIiISL3w8HD4+fmhVKlSWLx4MRwcHHD69GlMnz4dV69eVfnRnFkpKSno168fHBwc8OTJE7V55syZgylTpmDw4MGYNGkSjI2N8ddff+HDhw9K+WbMmIHdu3dj7dq18PLygp2dncq6hg0bBlNT02zFDAC7d+/GxYsXUblyZcjlcly9ejXDz7x9+xYDBw6Eq6ur2m29cuUK9uzZg8qVK6NBgwbYt2+f2vVcvXoVGzduRK9evTB16lQYGxvj0KFDGDJkCC5evIi1a9dmaZtevHiBZs2aoWLFirC1tcW///6LOXPmoEaNGrh69SpKlSqVpfUCwLp161C6dGmlNHt7e6X3r1+/Rrdu3eDj4wMrKyuEh4dj5syZ2Lt3L27fvq2SH8i4Tl+8eIFatWph1KhRcHBwQFRUFBYuXIgvv/wSJ06cgL+/v9bb4OLiggsXLqik79mzB3PnzkW7du1Ulo0YMQLdu3dXSitZsqRKviFDhmD9+vUYM2YMZs+ejeTkZNy6dUulc6ZVq1a4cuUKAgMDUa1aNTx+/BjTp0+Hr68vbt26BXd3d2m7V61ahYoVK6Jt27ZYvXq1xu3KyveuTbvNSE4fW+h/Zs2ahY4dO6rtqM8LcVSpUgUXLlxAmTJlcj2mnDzuzpo1C/Xq1VNKS9thSEREeYQgIqI8acqUKQKA+Oeff5TSv/76awFAvHz5Ukpzd3cXLVq0yNT658+fL4oUKSKWLFkiAIjQ0FCl5VeuXBEGBgZi7ty5Ga6rYcOGwsfHR+PynTt3CktLS7FhwwYBQPz2229axRgQECDSnqpSUlKk/w8bNkxluTrDhg0TlStXFt99950AIJ49e6Zxnb/99psAIIKDg1XW8/LlS/Hhwwe16wcgIiMjVWJPW5a2wsPDBQAxdepUKS04OFjr+lu3bp3a71VbBw8eFADEmjVr1C7PqE7Vef36tTA2NhZfffVVlmJKq27dusLc3FzExsZKaQ8ePBAAxPz58zP8/O7duwUAsX379nTz3bt3TwAQ3333nVL6+fPnBQCxcOFCKS01NVWkpqYKIYR49uyZACACAgK03iZ13/unMmq32sjMseVzFR8fn+nP+Pv7i7JlyyqlWVhYiN69e+soqo+Sk5NFQkJCpj6TE3FkV04cdzNzjCQioryBj+8REeVRxsbGAAAbGxul9EKFCsHAwAAmJiYqn9m9ezcqVKggPYL1448/ql33vXv3MG3aNCxfvhzW1tZq8yxbtgxyuRwjRozQGKPiUanjx4/jzp070mMSnz6C8fLlSwwbNgzff/89ihUrpnFdBw4cQKVKlSCXy+Hp6YkffvhBbT4Dg8ydus6cOYNVq1Zh9erVMDQ0zNY6bW1tpe/lU9WrVwcAPH78WGXZo0eP0L59e1hbW8PGxgY9e/bEs2fPMiyrcOHCAAAjI9WbmhMSEjB27Fg4OzvDzMwM/v7+uH79ulbboK30ytemTtWxsrKCqampyjoTExMxffp0+Pj4wNTUFPb29qhXr166j/rdv38fISEh6Ny5s8Z9OCNLliyBh4cHOnfunG6+9NoiAKU7ABVtIKvSq3dt2i0AXLp0Ca1atYK9vT1MTU3h5eWF0aNHS8sze2zZvn279IiVpaUlmjRponZ/y6jcf/75B3379kXJkiWlRyBbtWqFW7duqazr9evXGDduHIoXLw65XA5HR0c0b94cf/31l8btTuvYsWNo06YNihYtClNTU5QoUQKDBg1SedRU8ajttWvX0LFjR9ja2sLLy0vrcjSRyWSIj4/Hhg0bpP2ibt260vLo6GgMGjQIRYsWhYmJCTw9PREUFITk5GQpj+IYO2/ePMycOROenp6Qy+UIDg5GQkICxo0bh0qVKsHGxgZ2dnbw9fVVudMtvTg0Pb63d+9e+Pr6wtzcHFZWVmjUqJHK3YqKert9+za6desGGxsbODk5oV+/foiNjc2wfnLyuEtERPkHO6WIiPKo3r17o1ChQhgyZAj+/fdfvHnzBvv378fPP/+MYcOGwcLCQin/jRs3MHr0aIwZMwa7d++Gn58fRo0apdK5I4TAgAED0LJlS7Ru3Vpj+adPn4aPjw9+//13lCpVCoaGhihatCgmTpwoPb6neKyqcuXKKF68OC5cuIALFy6gSpUq0npGjhwJT09PDB8+XGNZJ06cQJs2bWBlZYVt27Zh/vz52LFjB9atW5eVqpO8f/8e/fv3x+jRo5Vi0rWTJ0/CyMgI3t7eKsvatWuHEiVKYOfOnQgMDMSePXvQpEkTJCUlqeRNSUlBYmIi/vrrLwwYMACOjo7o27evSr7Jkyfj33//xerVq7F69Wo8efIEdevWxb///quSt2XLljA0NISdnR3at2+PsLAwjduRnJyM9+/f4/r16xg9ejS8vb3Rvn17pTyZrdOUlBQkJSUhIiICQ4YMgRACw4YNUyqzWbNmmDFjBlq2bIndu3dj/fr18PPzQ2RkpMb1rl27VtqX1ZkzZw5MTExgbm6O2rVrY+/evSrbqth3Fy5cCHd3dxgaGqJ48eL44YcfIISQ8rq7u6NNmzZYtGgRgoOD8fbtW/z1118YOXKkNA5UdmjzvWvbbo8cOYI6deogMjISCxcuxKFDh/Ddd9/h6dOnUp7MHFtmzZqFbt26oUyZMtixYwc2bdqEN2/eoE6dOggPD89UuU+ePIG9vT3mzJmDw4cP46effoKRkRFq1KiBu3fvSvnevHmD2rVr4+eff0bfvn2xb98+rFy5Et7e3oiKitK6Xu/fvw9fX1+sWLECR48exbRp03Dp0iXUrl1bbftr3749SpQogd9++w0rV64E8L+x2davX691uQoXLlyAmZkZmjdvLh0bly9fDuBjh1T16tVx5MgRTJs2DYcOHUL//v0xe/ZsDBw4UGVdP/74I06ePIkffvgBhw4dQunSpZGYmIiXL19i/Pjx2LNnD7Zu3YratWujffv22Lhxo1ZxqLNlyxa0adMG1tbW2Lp1K9asWYNXr16hbt26OHv2rEr+Dh06wNvbG7///jsmTpyILVu2YMyYMZmur8xK77g7bNgwGBkZwdraGk2aNFEbNxER5RF6vU+LiIjSdefOHVG6dGkBQHqNHDlSejxIwd3dXchkMnHjxg2l9EaNGglra2ulR1GWLl0qbG1tRXR0tBBC82NecrlcWFlZCVtbW7Fs2TJx8uRJMWXKFGFoaCi6d++ulFfdYytCCLF//35hbGwsbt26JYTQ/GhFjRo1hKurq3j//r2UFhcXJ+zs7NJ9PC+jx/fGjRsnihcvLt69eyeE0O6RuvQeI1HnyJEjwsDAQIwZM0YpXVFW2vRff/1VABCbN29WWZdcLpe+Z29vbxEeHq60XFF/VapUUdoHIiIihLGxsRgwYICUdujQITFlyhSxb98+ERISIpYtWyaKFi0qLCwsVPYTIYSIiopS2s9q1Kgh/vvvP5V8ma3TUqVKSet0cXERZ8+eVVq+ceNGAUD88ssvaj+vTnJysihSpIgoXbq0yrInT56IgQMHih07dogzZ86IX3/9VdSsWVOlDMX2Wltbi6JFi4oNGzaIEydOiMGDBwsAYvLkyUrr/fDhgxg4cKBSHVWoUEE8ePBAY5zaPr6X0fcuhPbt1svLS3h5eSm1JXW0ObZERkYKIyMjMWLECKXPvnnzRjg7O4vOnTtnutxPJScniw8fPoiSJUsqtZPp06cLAOLYsWNarysjqampIikpSTx8+FAAEH/88Ye0TLEPT5s2TeVzGzZsEIaGhmLDhg0ZlpGZx/cGDRokLC0txcOHD5XSf/jhBwFA3L59Wwjxv8dRvby81D7C9qnk5GSRlJQk+vfvLypXrqxVHIpjiuJ4l5KSIlxdXUX58uWVHq978+aNcHR0FH5+flKaot7mzZuntM6hQ4cKU1NTlfNUenR13L127ZoYNWqU2L17tzh9+rRYu3at8PHxEYaGhuLw4cNax0NERLmHnVJERHnUgwcPRIkSJUStWrXEzp07RUhIiJg3b56wtrYW/fr1U8rr7u4uypUrp7IOxQ/XM2fOCCE+dl5YWlqK1atXq+RJ++PW2NhYABBbt25VSh89erQAIO7duyelqfsx9vr1a1GkSBGlcXjUdUq9fftWGBgYiOHDh6vE37t37yx3Sl26dEkYGhoq/bDVdafU1atXhY2NjfDz81MZ40VR1pUrV5TSk5KShJGRkejfv7/a9V24cEFs3rxZVK1aVTg5OYmwsDBpuaL+fvjhB5XP+vv7Cy8vr3TjffDggbC0tBStW7dWWZaUlCRCQ0PF2bNnxS+//CJKliwpvL29xZMnT6Q8WanTsLAwcenSJfHbb7+JBg0aCCsrK6W67datmzA1NVX6AZyR/fv3az1ulBAfO5QqV64s7O3tRVJSkhBCiP/++0/qjLlw4YJS/rZt2wpTU1Px5s0bKa1///7Czs5OLFq0SISEhIjt27eLatWqCU9PTxEREaG2XG07pTL63rVtt3fv3hUAxKxZs9ItT9tjyy+//CKVkZSUpPTq0qWLcHR0zFS5SUlJ4vvvvxc+Pj7S8UXxatq0qZTP19dXeHt7p7subTx9+lQMGjRIFC1aVBgYGCiVN2fOHCmfYh++efNmtsrLTKdUkSJFRKtWrVTq9fbt2wKAWL58uRDif51SaTtfFHbs2CH8/PyEhYWF0vaZmppqFUfaTinFmGZpO5qEEGLIkCHCwMBA+iOHot7++usvpXwrV64UAKQOVG3o6rirzqtXr0TRokVFhQoVtI6HiIhyD2ffIyLKoyZOnIi4uDjcuHFDepzmyy+/hIODA/r164devXopzWDm7Oyssg5F2osXLwB8fKShXLly6NChA16/fg0A0ixjb9++RWxsrDTOjL29PaKjo9GkSROldTZr1gyLFy/GtWvXUKJECY3xT5kyBcbGxhg+fLhU1tu3b6UyX79+DRsbG7x69Qqpqanpxp8V/fr1Q/v27VGtWjWp/ISEBABAXFwc5HI5rKyssrz+69evo1GjRihZsiQOHjwIuVyuNl/abTAyMoK9vb30nXxK8ThczZo10bp1a5QoUQKTJ09WGSNGU13dvHkz3Zg9PDxQu3ZttVOjGxkZoVq1agCAWrVqoWnTpvD09MScOXOwZMkSAFmr07JlywL4OP5L27ZtUblyZYwaNUqK9dmzZ3B1dc3UWGFr1qyBsbExevXqpVV+Y2NjdOnSBRMnTsS9e/fg4+MDW1tbyGQyWFlZoWbNmkr5mzVrhj179iA8PBzVq1fH4cOHsWbNGvz222/o2LGjlK9x48bw8PBAYGBgth41zeh717bdKsYqK1q0aLrlaXtsUTx698UXX6hdj+I707bcsWPH4qeffsK3334Lf39/2NrawsDAAAMGDMD79++lfM+ePUt3/DltpKamonHjxnjy5AmmTp2K8uXLw8LCAqmpqahZs6ZSeQouLi7ZKjMznj59in379qkdKwmAyrhX6mLbtWsXOnfujE6dOuGbb76Bs7MzjIyMsGLFimzNBKqpPFdXV6SmpuLVq1cwNzeX0tPOzqk4Fqqr4+zS9rj7qUKFCqFly5ZYuXIl3r9/DzMzM53HRUREWcdOKSKiPOrGjRsoU6aMythRih+IYWFhSp1S0dHRKutQpCl+NISFheHhw4ewtbVVyVuvXj3Y2NhIP3orVKigdp3i/8fayagTISwsDBEREWo7UHr37g0AePXqldQ5kF78WXH79m3cvn0bv/32m8oyLy8vVKxYETdu3MjSuq9fv46GDRvC3d0dR48eVRkw+lPR0dEoUqSI9D45ORkvXrxQ+SGXlpWVFUqXLo2///5b7TrVpWW0TuDj96dNB1DRokXh6uqqVH5269TIyAhVqlTBjh07pLTChQvj7NmzSE1N1SqumJgY7N+/H61bt4ajo2OG+RXS7rdmZmYoWbKkVvu4YpvSds4UKlQIJUqUSHecrsxS971r224Vg6RnNPCztscWBwcHAMDOnTvh7u6ucX3alrt582b06tULs2bNUkp//vy5NGi8Yn3ZHbw6LCwMN2/exPr166XjDfBxsHVNsjNAfWY5ODigQoUK+P7779Uud3V1VXqvLrbNmzfD09MT27dvV1qemJiY5bgUxxB1Y3c9efIEBgYGavfD3JCZ425aijadm98xERFphwOdExHlUa6urrh9+7Z0d5GCYgaktHcl3L59W+VOmS1btsDKykq6E2Pbtm0IDg5Wen377bcAgJUrV2L//v3SZzt06AAAOHTokNI6Dx48CAMDA413TygsXrxYpaxFixYB+DhrU3BwMCwtLWFhYYHq1atj165d0l03wMfBjvft25d+JaUjbdnBwcHSj9M9e/Zg9erVWVrvjRs30LBhQxQtWhTHjh3L8Afar7/+qvR+x44dSE5OVpqFS53nz5/j1q1bau9G27p1q9JA3A8fPsT58+czXOeDBw9w7tw5lTuD1Pnnn3/w+PFjpfKzW6cJCQm4ePGi0jqbNWuGhIQErQeS3rhxI5KSktC/f3+t8gNAUlIStm/fDgcHB6WyO3TogLi4OJVZ/g4ePAhLS0vpLi9FB0HaO8xevHiBv//+O8M7hDJD3feubbv19vaGl5cX1q5dm27HhLbHliZNmsDIyAj3799HtWrV1L4yU65MJlO5s+XAgQP477//lNKaNWuGv//+GydPnky3rtKj6HxIW97PP/+c5XVmhVwuV3vHUMuWLREWFgYvLy+19Zq2U0odmUwGExMTpY6W6OholTsr04sjrVKlSqFIkSLYsmWL0jEmPj4ev//+uzQjX27L7HH3U69evcL+/ftRqVIlpZkyiYgob+CdUkREedTo0aPRtm1bNGrUCGPGjIGDgwMuXryI2bNno0yZMmjWrJlSfldXV7Ru3RqBgYFwcXHB5s2bcezYMcydO1f6EaGuMyIiIgIAULVqVelHJgD07dsXP//8M4YOHYrnz5+jTJkyOH78OH766ScMHTo03TsnAKBSpUoal5UtW1apA2XGjBlo2rQpGjVqhHHjxiElJQVz586FhYUFXr58qfTZhw8fIjQ0FMDH2bWAj3dyAB8fT1Nsg7oOGsW057Vq1ZLuAgE+Pgp18OBBAP/reAgJCcHz589hYWEh1fXdu3fRsGFDAMD333+Pe/fu4d69e9J6vLy8pLtGFHbt2gUjIyM0atQIt2/fxtSpU1GxYkV07twZABAbG4tGjRqhe/fuKFmyJMzMzPD3339jyZIlSExMREBAgMp2xMTEoF27dhg4cCBiY2MREBAAU1NTTJo0ScrTsGFDfPnll6hQoQKsra1x69YtzJs3DzKZDDNmzJDy/fnnnxgzZgw6duyI4sWLw8DAALdu3cKiRYtgb2+P8ePHS3kzU6d+fn5o3bo1fHx8YGNjg4iICKxYsQL379/H7t27pXzdunXDunXrMHjwYNy9exf16tVDamoqLl26BB8fH5WZ7dasWQM3NzeVx0oVxo4di6SkJNSqVQvOzs549OgRli5dihs3bmDdunUwNDSU8o4fPx6//vorOnXqhBkzZqBo0aLYuXMn9u7dix9++EF6zKd9+/aYNm0ahgwZgsePH6NKlSqIiorC/Pnz8e7dO4waNUophkOHDiE+Ph5v3rwBAISHh0v7aPPmzWFubp6p7z0z7fann35Cq1atULNmTYwZMwbFihVDZGQkjhw5InWQants8fDwwPTp0zFlyhT8+++/aNq0KWxtbfH06VNcvnwZFhYWCAoK0rrcli1bYv369ShdujQqVKiAq1evYv78+SqdeqNHj8b27dvRpk0bTJw4EdWrV8f79+8REhKCli1bol69emq/+0+VLl0aXl5emDhxIoQQsLOzw759+3Ds2LEMP/upjRs3ol+/fli7dq3Wj4t+qnz58jh16hT27dsHFxcXWFlZoVSpUpg+fTqOHTsGPz8/jBw5EqVKlUJCQgIiIiJw8OBBrFy5MsPOzpYtW2LXrl0YOnQoOnbsiEePHmHGjBlwcXFROi6lF0daBgYGmDdvHnr06IGWLVti0KBBSExMxPz58/H69WvMmTMn03WgSU4cd7t3745ixYqhWrVqcHBwwL1797BgwQI8ffo0SzMoEhFRLtDfcFZERJSRkydPisaNGwtnZ2dhZmYmvL29xbhx48Tz58+V8rm7u4sWLVqInTt3irJlywoTExPh4eEhFi5cmGEZmgY6F0KIFy9eiEGDBgknJydhbGwsvL29xfz581UGpdY0+15ammbfE0KIvXv3igoVKggTExNRrFgxMWfOHGkgXXXxqnupG8j3U5oG5VYMJqzu5e7urlXZAMS6detUyrp69apo1aqVsLS0FFZWVqJbt27i6dOnUr6EhAQxYMAA4ePjIywtLYWRkZEoWrSo6NmzpzQDV9r627Rpkxg5cqQoXLiwkMvlok6dOioDqo8ePVqUKVNGWFlZCSMjI+Hq6ip69uwp7t69q5QvOjpa9OzZU3h5eQlzc3NhYmIiihcvLgYPHiwiIyPTrc/06nTcuHGiYsWKwsbGRhgZGQlnZ2fRrl07ce7cOZV1vH//XkybNk2ULFlSmJiYCHt7e1G/fn1x/vx5pXznzp3TOEuawpo1a0T16tWFnZ2dMDIyEra2tqJJkybiyJEjavNHRkaKrl27CltbW2FiYiIqVKgg1q5dq5IvKipKDB8+XJQoUUKYmpoKV1dX0aJFC5VB0oX42B417SOK2foy872rk167vXDhgmjWrJmwsbERcrlceHl5qQyUre2xRQgh9uzZI+rVqyesra2FXC4X7u7uomPHjuL48eOZKvfVq1eif//+wtHRUZibm4vatWuLM2fOCH9/f+Hv76+0rlevXolRo0aJYsWKCWNjY+Ho6ChatGihMqh2esLDw0WjRo2kWUQ7deokIiMjVQafT2+wfkU9f9q2NVF3HLxx44aoVauWMDc3FwCUtvPZs2di5MiRwtPTUxgbGws7OztRtWpVMWXKFPH27VshxP+OTZoG9Z8zZ47w8PAQcrlc+Pj4iF9++UXtcVNTHGkHOlfYs2ePqFGjhjA1NRUWFhaiQYMGKm1XU70p6iy9mSk/3TZdHndnz54tKlWqJGxsbIShoaEoXLiwaNeunbh8+XK6sRARkf7IhPjk3lwiIiIiIiIiIqJcwDGliIiIiIiIiIgo13FMKSIiIiLKN1JSUpDejf4ymUxp7DAiIiLKu3inFBERERHlGw0aNICxsbHGl5eXl75DJCIiIi1xTCkiIiIiyjfu3r0rzWyojlwuR/ny5XMxIiIiIsoqdkoREREREREREVGu4+N7RERERERERESU69gpRUREREREREREuY6dUkRERERERERElOvYKUVERERERERERLmOnVJERERERERERJTr2ClFRERERERERES5jp1SRERERERERESU69gpRUREREREREREuY6dUkRERERERERElOvYKUVERERERERERLmOnVJERERERERERJTr2ClFRERERERERES5jp1SRERERERERESU69gpRUREREREREREuY6dUkRERERERERElOvYKUVERERERERERLmOnVJERERERERERJTr2ClFRERERERERES5jp1SRERERERERESU69gpRUREREREREREuY6dUkRERERERERElOvYKUVERERERERERLmOnVJERERERERERJTrst0ptX79eshkMrWv8ePH6yJGykBgYCBkMplSmoeHB/r06ZOp9Zw/fx6BgYF4/fp1pj6XtqxTp05BJpNh586dmVpPet69e4fAwECcOnVKZZliH4yIiNBZeQVJ2jZqamoKZ2dn1KtXD7Nnz0ZMTIy+Q8SsWbOwZ88elXTFvqTue9eXunXrom7dutL7iIgIyGQyrF+/PlPr2bJlCxYvXpypz6grS9H+nz9/nql1pSc8PByBgYFq21SfPn3g4eGhs7Ioaz5t1+rahxACJUqUgEwmU9pfdUHTMT8vtVN976fpnU/THkOIKH+7dOkS2rVrh2LFikEul8PJyQm+vr4YN26cUr7ly5dn+lohLU3XS5T3ZOb6LDd/txHlRUa6WtG6detQunRppTRXV1ddrZ4yaffu3bC2ts7UZ86fP4+goCD06dMHhQoVytGyMuvdu3cICgoCAJWL+RYtWuDChQtwcXHJ0RjyO0UbTUpKQkxMDM6ePYu5c+fihx9+wPbt29GwYUO9xTZr1ix07NgRbdu2VUqvUqUKLly4gDJlyugnMC24uLjgwoUL8PLyytTntmzZgrCwMIwePTrHy8qs8PBwBAUFoW7duio/7KdOnYpRo0blaPmkPSsrK6xZs0bluBgSEoL79+/Dysoqx2PID+00t6V3Pl2+fLl+giIinTtw4ABat26NunXrYt68eXBxcUFUVBSuXLmCbdu2YcGCBVLe5cuXw8HBIdOdD5/SdL1E+Vtu/m4jyot01ilVrlw5VKtWTau8SUlJkMlkMDLSWfGURuXKlXO8jPfv38PMzCxXykpP4cKFUbhwYb3GkB+kbaMdOnTAmDFjULt2bbRv3x737t2Dk5NTtstJSUlBcnIy5HJ5ttdlbW2NmjVrZns9OUkul+d4jJ/Wqb7rI6c7xChzunTpgl9//RU//fST0gXtmjVr4Ovri7i4uByPIT+00+x69+4dzM3NdbIudt4RFRzz5s2Dp6cnjhw5ovS7pmvXrpg3b54eI6P8RN+/pT6ly/MdkbZyfEwpxW39mzZtwrhx41CkSBHI5XL8888/AIDjx4+jQYMGsLa2hrm5OWrVqoUTJ06orOfAgQOoVKkS5HI5PD098cMPP6g8tpbeYzQymQyBgYFKaffu3UP37t3h6OgIuVwOHx8f/PTTT2rj37p1K6ZMmQJXV1dYW1ujYcOGuHv3rko5hw8fRoMGDWBjYwNzc3P4+Phg9uzZAIBNmzZBJpPhwoULKp+bPn06jI2N8eTJk3TrU109qJP2NtDU1FTMnDkTpUqVgpmZGQoVKoQKFSpgyZIlAD7eYvrNN98AADw9PVUeC/Hw8EDLli2xa9cuVK5cGaamptKdS5puOU1ISMDYsWPh7OwMMzMz+Pv74/r160p5ND3G8OmjFxEREVKnU1BQkBSbokxNj++tXbsWFStWhKmpKezs7NCuXTvcuXNHpRxLS0v8888/aN68OSwtLeHm5oZx48YhMTFRbd0WJMWKFcOCBQvw5s0b/Pzzz1K6Nt8L8L82N2/ePMycOROenp6Qy+UIDg5GQkICxo0bh0qVKsHGxgZ2dnbw9fXFH3/8obROmUyG+Ph4bNiwQfpuFWVreixo79698PX1hbm5OaysrNCoUSOVdqU4Pty+fRvdunWDjY0NnJyc0K9fP8TGxmZYN0IIzJs3D+7u7jA1NUWVKlVw6NAhlXzqjjvPnj3D119/DTc3N8jlchQuXBi1atXC8ePHpfo9cOAAHj58qPRoZUZ1mt4x7tGjR2jfvj2sra1hY2ODnj174tmzZyp1nfY4CCi34fXr16NTp04AgHr16kmxKcpU91hUQkICJk2aBE9PT5iYmKBIkSIYNmyYyi3liuPI4cOHUaVKFZiZmaF06dJYu3athm+BMtKtWzcAwNatW6W02NhY/P777+jXr5/az3z48AEzZ85E6dKlpf2zb9++KvtLUlISJkyYAGdnZ5ibm6N27dq4fPmyyvrUtdMrV66ga9eu8PDwgJmZGTw8PNCtWzc8fPhQ6bOK43dwcDCGDBkCBwcH2Nvbo3379hmeDz9dR6lSpaTz+MaNG7WKEVDffhXnhVu3bqFx48awsrJCgwYNAADHjh1DmzZtULRoUZiamqJEiRIYNGiQ0uMZGZ1P1R1fX758iaFDh6JIkSIwMTFB8eLFMWXKFJXzkEwmw/Dhw7Fp0yb4+PjA3NwcFStWxP79+7WqKyLSrRcvXsDBwUHtH9oNDP73M8vDwwO3b99GSEiIdExQnEt1cb0EANHR0Rg0aBCKFi0KExMTeHp6IigoCMnJyRlux8mTJ1G3bl3Y29vDzMwMxYoVQ4cOHfDu3TspT3bPHWl/L6gbfgTQfF2/fft2+Pr6wsLCApaWlmjSpInK74rMXNcnJiZi+vTp8PHxgampKezt7VGvXj2cP39eyiOEwPLly1GpUiWYmZnB1tYWHTt2xL///pthnSo8ffo0w+tQXf9uS01Nxbx586TvytHREb169cLjx4+Vyq1bty7KlSuH06dPw8/PD+bm5ujXrx/69+8POzs7pe9foX79+ihbtqzW20+kDZ3dqqT4S77Syj85QE+aNAm+vr5YuXIlDAwM4OjoiM2bN6NXr15o06YNNmzYAGNjY/z8889o0qQJjhw5Il0EnjhxAm3atIGvry+2bduGlJQUzJs3D0+fPs1yvOHh4fDz85N+lDs7O+PIkSMYOXIknj9/joCAAKX8kydPRq1atbB69WrExcXh22+/RatWrXDnzh0YGhoC+PiX6YEDB8Lf3x8rV66Eo6Mj/v77b4SFhQH4+BftCRMm4KeffoKvr6+07uTkZPz8889o165duo88Zqce5s2bh8DAQHz33Xf48ssvkZSUhL/++kv60ThgwAC8fPkSS5cuxa5du6RH4T79i+61a9dw584dfPfdd/D09ISFhUW6ZU6ePBlVqlTB6tWrERsbi8DAQNStWxfXr19H8eLFM4xZwcXFBYcPH0bTpk3Rv39/DBgwAADSvTtq9uzZmDx5Mrp164bZs2fjxYsXCAwMhK+vL0JDQ1GyZEkpb1JSElq3bo3+/ftj3LhxOH36NGbMmAEbGxtMmzZN6zjzq+bNm8PQ0BCnT5/O8jp+/PFHeHt744cffoC1tTVKliyJxMREvHz5EuPHj0eRIkXw4cMHHD9+HO3bt8e6devQq1cvAMCFCxdQv3591KtXD1OnTgWAdG9h3rJlC3r06IHGjRtj69atSExMxLx581C3bl2cOHECtWvXVsrfoUMHdOnSBf3798etW7cwadIkAMiwIyQoKAhBQUHo378/OnbsiEePHmHgwIFISUlBqVKl0v3sV199hWvXruH777+Ht7c3Xr9+jWvXruHFixcAPt7C//XXX+P+/fvYvXu31nWannbt2qFz584YPHgwbt++jalTpyI8PByXLl2CsbFxup/9VIsWLTBr1ixMnjwZP/30E6pUqQJA8x1SQgi0bdsWJ06cwKRJk1CnTh38+eefCAgIwIULF3DhwgWlu+Zu3ryJcePGYeLEiXBycsLq1avRv39/lChRAl9++aXWcdJH1tbW6NixI9auXYtBgwYB+NhBZWBggC5duqiMW5aamoo2bdrgzJkzmDBhAvz8/PDw4UMEBASgbt26uHLlCszMzAAAAwcOxMaNGzF+/Hg0atQIYWFhaN++Pd68eZNhXBEREShVqhS6du0KOzs7REVFYcWKFfjiiy8QHh4OBwcHpfwDBgxAixYtsGXLFjx69AjffPMNevbsiZMnT6Zbzvr169G3b1+0adMGCxYskM41iYmJSj8IM+vDhw9o3bo1Bg0ahIkTJ0rXN/fv34evry8GDBgAGxsbREREYOHChahduzZu3boFY2Njrc6nn0pISEC9evVw//59BAUFoUKFCjhz5gxmz56NGzdu4MCBA0r5Dxw4gNDQUEyfPh2WlpaYN28e2rVrh7t372bq3EpE2efr64vVq1dj5MiR6NGjB6pUqaL2nLt792507NgRNjY20iO8inOjLq6XoqOjUb16dRgYGGDatGnw8vLChQsXMHPmTERERGDdunUatyEiIgItWrRAnTp1sHbtWhQqVAj//fcfDh8+jA8fPsDc3DzXzh2azJo1C9999x369u2L7777Dh8+fMD8+fNRp04dXL58Wen4qs11fXJyMpo1a4YzZ85g9OjRqF+/PpKTk3Hx4kVERkbCz88PADBo0CCsX78eI0eOxNy5c/Hy5UtMnz4dfn5+uHnzplZPGGTlOjS7v9uGDBmCVatWYfjw4WjZsiUiIiIwdepUnDp1CteuXVM6B0dFRaFnz56YMGECZs2aBQMDAxQqVAhr167Fli1bpN9dwMffz8HBwSo3cRBlm8imdevWCQBqX0lJSSI4OFgAEF9++aXS5+Lj44WdnZ1o1aqVUnpKSoqoWLGiqF69upRWo0YN4erqKt6/fy+lxcXFCTs7O/HpJjx48EAAEOvWrVOJE4AICAiQ3jdp0kQULVpUxMbGKuUbPny4MDU1FS9fvhRCCCn+5s2bK+XbsWOHACAuXLgghBDizZs3wtraWtSuXVukpqZqrK+AgABhYmIinj59KqVt375dABAhISEaP5eZehBCCHd3d9G7d2/pfcuWLUWlSpXSXf/8+fMFAPHgwQOVZe7u7sLQ0FDcvXtX7bJPy1LUWZUqVZTqIiIiQhgbG4sBAwZIaf7+/sLf319lnb179xbu7u7S+2fPnql8hwqKfVAR96tXr4SZmZnKdxYZGSnkcrno3r27UjkAxI4dO5TyNm/eXJQqVUqlrPxIUT+hoaEa8zg5OQkfHx/pvbbfi6LNeXl5iQ8fPqQbR3JyskhKShL9+/cXlStXVlpmYWGhtA8pKPal4OBgIcTH44Orq6soX768SElJkfK9efNGODo6Cj8/PyktICBAABDz5s1TWufQoUOFqalpuu301atXwtTUVLRr104p/dy5cwKAUt2oO+5YWlqK0aNHa1y/EEK0aNFCqS7Trk9dnaorS7GdY8aMUcr766+/CgBi8+bNUpqmNpS2Df/2229K9f6ptPvA4cOH1daz4ri2atUqpXJMTU3Fw4cPpbT3798LOzs7MWjQIJWySLNP27WinYSFhQkhhPjiiy9Enz59hBBClC1bVml/3bp1qwAgfv/9d6X1hYaGCgBi+fLlQggh7ty5k+5+pe6Yr25/UUhOThZv374VFhYWYsmSJSrbMXToUKX88+bNEwBEVFSUxnUqjgeazjWf7qeaYlTXphTnhbVr12osWwghUlNTRVJSknj48KEAIP744w9pWXrn07TH15UrV6o9D82dO1cAEEePHpXSAAgnJycRFxcnpUVHRwsDAwMxe/bsdOMlIt17/vy5qF27tvTbx9jYWPj5+YnZs2eLN2/eKOVNezzWJCvXS4MGDRKWlpZK51chhPjhhx8EAHH79m2N5e3cuVMAEDdu3NCYJyfOHYrrl7TSXtdHRkYKIyMjMWLECKV8b968Ec7OzqJz585SmrbX9Rs3bhQAxC+//KJxmy9cuCAAiAULFiilP3r0SJiZmYkJEyZo/Oyn26fNdaguf7cpvoO059VLly4JAGLy5MlSmr+/vwAgTpw4obJ+f39/lRiGDBkirK2tVfZtouzS2eN7GzduRGhoqNLr0zulOnTooJT//PnzePnyJXr37o3k5GTplZqaiqZNmyI0NBTx8fGIj49HaGgo2rdvD1NTU+nzVlZWaNWqVZZiTUhIwIkTJ9CuXTuYm5srld+8eXMkJCTg4sWLSp9p3bq10vsKFSoAgPQowvnz5xEXF4ehQ4eqvRVVYciQIQCAX375RUpbtmwZypcvn+5dAtmth+rVq+PmzZsYOnQojhw5kqVxRipUqABvb2+t83fv3l2pLtzd3eHn54fg4OBMl50ZFy5cwPv371UeKXRzc0P9+vVVHg+VyWQqdVihQgWVx0wKMiFEtj7funVrtX8Z/O2331CrVi1YWlrCyMgIxsbGWLNmjcpjlNq6e/cunjx5gq+++krpLghLS0t06NABFy9eVLnVWF3bTUhISHfWwQsXLiAhIQE9evRQSvfz84O7u3uGcVavXh3r16/HzJkzcfHiRSQlJWmzeSpxZ+YOp7Sxdu7cGUZGRjne3hR3sqRtb506dYKFhYVKe6tUqRKKFSsmvTc1NYW3t/dn1d50zd/fH15eXli7di1u3bqF0NBQjY/u7d+/H4UKFUKrVq2Uzn2VKlWCs7OzdOu/Yr/RtF9l5O3bt/j2229RokQJGBkZwcjICJaWloiPj1fb/jM6x6qjOB5oOtdkV9rrFgCIiYnB4MGD4ebmJh3TFMeErB7XTp48CQsLC3Ts2FEpXdGm0rahevXqKQ1g7+TkBEdHR7YhIj2wt7fHmTNnEBoaijlz5qBNmzb4+++/MWnSJJQvX17rmXGze720f/9+1KtXD66urkrH9mbNmgH4OPmFJpUqVYKJiQm+/vprbNiwQe2jabl17lDnyJEjSE5ORq9evZTKNjU1hb+/v8pj2dpc1x86dAimpqYaz5WKbZbJZOjZs6dSuc7OzqhYsaLWM85m5To0O7/bFN9B2uuy6tWrw8fHR+WcYmtri/r166usZ9SoUbhx4wbOnTsHAIiLi8OmTZvQu3dvWFpaah0PkTZ01inl4+ODatWqKb0+lXZmNMUjZx07doSxsbHSa+7cuRBC4OXLl3j16hVSU1Ph7OysUqa6NG28ePECycnJWLp0qUrZzZs3BwCVk4i9vb3Se8Utt+/fvwcA6XnqokWLplu2k5MTunTpgp9//hkpKSn4888/cebMGQwfPjzdz2W3HiZNmoQffvgBFy9eRLNmzWBvb48GDRrgypUrGX5WIbOz22mKVfEIU05RrF9dvK6urirlm5ubK3X0AR+/34SEhJwLMg+Jj4/HixcvsjVbprq63rVrFzp37owiRYpg8+bNuHDhgvRjOat1m9F3m5qailevXimlZ9R20ysnq+1t+/bt6N27N1avXg1fX1/Y2dmhV69eiI6OzvCzCtltb0ZGRrC3t8+V9mZkZKTyOK1MJlPb3tN+H8DH7yS974PSJ5PJ0LdvX2zevBkrV66Et7c36tSpozbv06dP8fr1a5iYmKic/6Kjo6Vzn6Y2oNivMtK9e3csW7YMAwYMwJEjR3D58mWEhoaicOHCar9rfbTT9Jibm6s8RpyamorGjRtj165dmDBhAk6cOIHLly9Lf8TK6j784sULODs7q/xBy9HREUZGRmxDRPlAtWrV8O233+K3337DkydPMGbMGERERGg12LkurpeePn2Kffv2qRzXFWP/pNc55uXlhePHj8PR0RHDhg2Dl5cXvLy8pPGLFOvPjXOHpm0DgC+++EKl7O3bt6tsmzbX9c+ePYOrq2u6j3k/ffoUQgg4OTmplHvx4kWtOxyzcn7Lzu+2zP4O0nS92aZNG3h4eEiP6q1fvx7x8fEYNmxYhjEQZVauTX+X9mJL8Szr0qVLNc7a4+TkJM3Up+7HXNo0xQEo7UB2aRufra0tDA0N8dVXX2lsWJ6enulsjSrFD7K0A8ipM2rUKGzatAl//PEHDh8+jEKFCqn8RSEtW1tbretBHSMjI4wdOxZjx47F69evcfz4cUyePBlNmjTBo0ePtJplIb07wNTRFOunB2dTU1O1g05re6BXR7H+qKgolWVPnjxRGcvkc3fgwAGkpKQoDZaZ2e9F3b6xefNmeHp6Yvv27UrLszOAfEbfrYGBAWxtbbO8/rTlaNqH0w70nZaDgwMWL16MxYsXIzIyEnv37sXEiRMRExODw4cPaxVDVtpbkSJFpPfJycl48eKFUnuTy+Vq6z87HVf29vZITk7Gs2fPlDqmhBCIjo7GF198keV1k/b69OmDadOmYeXKlfj+++815lMMJK5pP1TcgfNpG1C3X6UnNjYW+/fvR0BAACZOnCilK8ZN0ZWM2umnNF0fZOaYFhYWhps3b2L9+vXo3bu3lK6YuCWr7O3tcenSJQghlMqNiYlBcnIyz1lE+YyxsTECAgKwaNEiaVzZ9OjiesnBwQEVKlTQePzP6A+PderUQZ06dZCSkoIrV65g6dKlGD16NJycnNC1a9ccOXd8elz+dOzJtMdlxTFw586dWt2tro3ChQvj7NmzSE1N1dgx5eDgAJlMhjNnzqidUVoXs0xrkp3fbZ9eK6e9WULd7yBN15sGBgYYNmwYJk+ejAULFmD58uVo0KBBhuOqEmVFjs++p0mtWrVQqFAhhIeHq9xhpXiZmJjAwsIC1atXx65du5R6uN+8eYN9+/YprdPJyQmmpqb4888/ldLTzl5hbm6OevXq4fr166hQoYLasjPbm+/n5wcbGxusXLkyw0ehqlatCj8/P8ydOxe//vor+vTpk+Gg4Zmph4wUKlQIHTt2xLBhw/Dy5Utpdgtteu4zY+vWrUp18fDhQ5w/f16p88PDwwN///230on3xYsXSjNfZDY2X19fmJmZYfPmzUrpjx8/xsmTJ6UB9AmIjIzE+PHjYWNjIw2SDGj/vaRHJpPBxMRE6WQXHR2t0h4B7f/KX6pUKRQpUgRbtmxR2rfi4+Px+++/SzPyZVfNmjVhamqKX3/9VSn9/PnzmX5EplixYhg+fDgaNWqEa9euSem6vrMhbaw7duxAcnKySntLe3w8efIk3r59q5SWmfamaE9p29vvv/+O+Ph4trdcUqRIEXzzzTdo1aqVUodJWi1btsSLFy+QkpKi9tynuNhU7Dea9qv0yGQyCCFULthXr16NlJSULGydeqVKlYKLi4vGc82nFB3Jaff/vXv3al2e4liWdrs+nblUIbNt6O3bt9izZ49SumIWQbYhorxL3R/JgP89zvtpZ5Cm874urpdatmyJsLAweHl5qT22a3s3vKGhIWrUqCHdHaO4bsmJc4em43La3zVNmjSBkZER7t+/r/E3Y2Y1a9YMCQkJamczVmjZsiWEEPjvv//Ullm+fPlMl5sVmf3dpngUL+11WWhoKO7cuZOpc8qAAQNgYmKCHj164O7duxk+2UOUVbl2p1RalpaWWLp0KXr37o2XL1+iY8eOcHR0xLNnz3Dz5k08e/YMK1asAADMmDEDTZs2RaNGjTBu3DikpKRg7ty5sLCwUPqrq+K537Vr18LLywsVK1bE5cuXsWXLFpXylyxZgtq1a6NOnToYMmQIPDw88ObNG/zzzz/Yt29fhjP+qNueBQsWYMCAAWjYsCEGDhwIJycn/PPPP7h58yaWLVumlH/UqFHo0qULZDIZhg4dqlUZ2taDOq1atUK5cuVQrVo1FC5cGA8fPsTixYvh7u4uzeqlOLguWbIEvXv3hrGxMUqVKqU0dkVmxMTEoF27dhg4cCBiY2MREBAAU1NTadYJ4OMsZT///DN69uyJgQMH4sWLF5g3b57KYxNWVlZwd3fHH3/8gQYNGsDOzg4ODg5q71gpVKgQpk6dismTJ6NXr17o1q0bXrx4gaCgIJiamqrMrPi5CAsLk56Hj4mJwZkzZ7Bu3ToYGhpi9+7dSne5aPu9pKdly5bYtWsXhg4dKs1eN2PGDLi4uODevXtKecuXL49Tp05h3759cHFxgZWVldq/xBgYGGDevHno0aMHWrZsiUGDBiExMRHz58/H69evMWfOnKxX0CdsbW0xfvx4zJw5EwMGDECnTp3w6NEjBAYGZvhYUGxsLOrVq4fu3bujdOnSsLKyQmhoKA4fPoz27dsrbfOuXbuwYsUKVK1aFQYGBlm6sFLYtWsXjIyM0KhRI2n2vYoVK6Jz585Snq+++gpTp07FtGnT4O/vj/DwcCxbtgw2NjZK6ypXrhwAYNWqVbCysoKpqSk8PT3VdtY3atQITZo0wbfffou4uDjUqlVLmn2vcuXK+Oqrr7K8TZQ52uz/Xbt2xa+//ormzZtj1KhRqF69OoyNjfH48WMEBwejTZs2aNeuHXx8fNCzZ08sXrwYxsbGaNiwIcLCwqTZINNjbW2NL7/8EvPnz5eO0yEhIVizZg0KFSqko639eDyYMWMGBgwYIJ1rXr9+rbadOjs7o2HDhpg9ezZsbW3h7u6OEydOYNeuXVqXV7p0aXh5eWHixIkQQsDOzg779u3DsWPHVPJm5nzaq1cv/PTTT+jduzciIiJQvnx5nD17FrNmzULz5s3RsGHDTNYMEeWWJk2aoGjRomjVqhVKly6N1NRU3LhxAwsWLIClpSVGjRol5S1fvjy2bduG7du3o3jx4jA1NUX58uV1cr00ffp0HDt2DH5+fhg5ciRKlSqFhIQERERE4ODBg1i5cqXGIUZWrlyJkydPokWLFihWrBgSEhKkmeEUx5+cOHc0b94cdnZ26N+/P6ZPnw4jIyOsX78ejx49Usrn4eGB6dOnY8qUKfj333/RtGlT2Nra4unTp7h8+TIsLCwQFBSUqe+tW7duWLduHQYPHoy7d++iXr16SE1NxaVLl+Dj44OuXbuiVq1a+Prrr9G3b19cuXIFX375JSwsLBAVFYWzZ8+ifPny0ljBupad322lSpXC119/jaVLl8LAwADNmjWTZt9zc3PDmDFjtI6jUKFC6NWrF1asWAF3d/csj+dMlKHsjpSe0cxeihlvfvvtN7XLQ0JCRIsWLYSdnZ0wNjYWRYoUES1atFDJv3fvXlGhQgVhYmIiihUrJubMmaN21obY2FgxYMAA4eTkJCwsLESrVq1ERESE2lmnHjx4IPr16yeKFCkijI2NReHChYWfn5+YOXNmhvFrmunv4MGDwt/fX1hYWAhzc3NRpkwZMXfuXJXtTkxMFHK5XDRt2lRtvWiibT2kncVhwYIFws/PTzg4OEif7d+/v4iIiFD63KRJk4Srq6swMDBQmqnI3d1dtGjRQm1Mmmbf27Rpkxg5cqQoXLiwkMvlok6dOuLKlSsqn9+wYYPw8fERpqamokyZMmL79u0qM3wJIcTx48dF5cqVhVwuV5rBI+0sHQqrV6+W6srGxka0adNGZfaR3r17CwsLC5WYNM0Ikh+lnSHTxMREODo6Cn9/fzFr1iwRExOj9nPafC+KdjB//ny165gzZ47w8PAQcrlc+Pj4iF9++UVt3d64cUPUqlVLmJubK81up2nGrD179ogaNWoIU1NTYWFhIRo0aCDOnTunlEdRzrNnz9TWh7pZsT6VmpoqZs+eLdzc3ISJiYmoUKGC2Ldvn8rMWWmPBQkJCWLw4MGiQoUKwtraWpiZmYlSpUqJgIAAER8fL33u5cuXomPHjqJQoUJCJpNJdZJenaY3+97Vq1dFq1athKWlpbCyshLdunVTmuVTiI/HnQkTJgg3NzdhZmYm/P39xY0bN1TasBBCLF68WHh6egpDQ0OlMtW1zffv34tvv/1WuLu7C2NjY+Hi4iKGDBkiXr16pZRP03FE02yPpJk2s2oKoX62p6SkJPHDDz+IihUrClNTU2FpaSlKly4tBg0aJO7duyflS0xMFOPGjROOjo7C1NRU1KxZU1y4cEHjMf/Tdvr48WPRoUMHYWtrK6ysrETTpk1FWFiYymc1bYc2M/oprF69WpQsWVKYmJgIb29vsXbtWrX7aVRUlOjYsaOws7MTNjY2omfPnuLKlStqZ99Td14QQojw8HDRqFEjYWVlJWxtbUWnTp1EZGSk2msMTedTdfv7ixcvxODBg4WLi4swMjIS7u7uYtKkSSIhIUEpHwAxbNgwlbjUtWEiynnbt28X3bt3FyVLlhSWlpbC2NhYFCtWTHz11VciPDxcKW9ERIRo3LixsLKyEgCUjlHZvV4S4uNM1SNHjhSenp7C2NhY2NnZiapVq4opU6aIt2/fatyGCxcuiHbt2gl3d3chl8uFvb298Pf3F3v37lXKp+tzhxBCXL58Wfj5+QkLCwtRpEgRERAQIFavXq32Om3Pnj2iXr16wtraWsjlcuHu7i46duwojh8/LuXJzHX9+/fvxbRp06Tzh729vahfv744f/68Ur61a9eKGjVqCAsLC2FmZia8vLxEr1691P6mUVemNtehuv7dlpKSIubOnSu8vb2FsbGxcHBwED179hSPHj1S+ry/v78oW7Zsuttx6tQpAUDMmTMn3XxE2SETIpvTbulRYGAggoKCsj1zmD7s27cPrVu3xoEDB6TB1YmIiIiIiAoaDw8P1K1bN91H5ijvGTduHFasWIFHjx5lebB6oozo7fG9z1V4eDgePnyIcePGoVKlStJUrURERERERET6dvHiRfz9999Yvnw5Bg0axA4pylHslMplQ4cOxblz51ClShVs2LAh0zNsEREREREREeUUxeRBLVu2xMyZM/UdDhVw+frxPSIiIiIiIiIiyp8M9B0AERERERERERF9ftgpRUREREREREREuY6dUkRERERERERElOvYKUVERERERERERLlOL7Pvpaam4smTJ7CysuLsc5TjhBB48+YNXF1dYWDAfthPsS1SbmJb1IxtkXIT26JmbItERES6oe31hl46pZ48eQI3Nzd9FE2fsUePHqFo0aL6DiNPYVskfWBbVMW2SPrAtqiKbZGIiEi3Mrre0EunlJWVFYCPwVlbW+sjBPqMxMXFwc3NTdrv6H/YFik3sS1qxrZIuYltUbP/1ckYAHJ9hkJElCfE7p2T/ZVEZ38VujT7a92s55/YZbpZUQGVFPcef7h9k+H1hl46pRS3Q1tbW/Pim3INb8NXxbZI+sC2qIptkfSBbVHV/+pEDnZKEREB1hY6WImZDtahQ7o6uhtb57ENy6Myut7gQAJERERERERERJTr9HKnFBEREdHnIiVV4PKDl4h5kwBHK1NU97SDoUHO3aWU2+URERERZZVeO6XKBRxB5KJO+gyBiP6fx8QD0v8j5rTQYyRE+c9///2Hb7/9FocOHcL79+/h7e2NNWvWoGrVqvoOjfTscFgUgvaFIyo2QUpzsTFFQKsyaFrOJd+XR0RERJQdfHyPiIgoG169eoVatWrB2NgYhw4dQnh4OBYsWIBChQrpOzTSs8NhURiy+ZpSBxEARMcmYMjmazgcFpWvyyMiIiLKLj6+R0RElA1z586Fm5sb1q1bJ6V5eHjoLyDKE1JSBYL2hUOoWSYAyAAE7QtHozLOOnm0LjPlEREREeUVvFOKiIgoG/bu3Ytq1aqhU6dOcHR0ROXKlfHLL7+k+5nExETExcUpvahgufzgpcodS58SAKJiE3D5wct8WR4RERGRLrBTioiIKBv+/fdfrFixAiVLlsSRI0cwePBgjBw5Ehs3btT4mdmzZ8PGxkZ6ubm55WLElBti3mjuIMpKvrxWHhEREZEusFOKiIgoG1JTU1GlShXMmjULlStXxqBBgzBw4ECsWLFC42cmTZqE2NhY6fXo0aNcjJhyg6OVqU7z5bXyiIiIiHSBnVJERETZ4OLigjJlyiil+fj4IDIyUuNn5HI5rK2tlV5UsFT3tIOLjSk0jRYlw8dZ8ap72uXL8oiIiIh0gZ1SRERE2VCrVi3cvXtXKe3vv/+Gu7u7niKivMDQQIaAVh87K9N2FCneB7Qqo5NBzvVRHhEREZEusFOKiIgoG8aMGYOLFy9i1qxZ+Oeff7BlyxasWrUKw4YN03dopGdNy7lgRc8qcLZRfmTO2cYUK3pWQdNyLvm6PCIiIqLsMtJ3AERERPnZF198gd27d2PSpEmYPn06PD09sXjxYvTo0UPfoVEe0LScCxqVccblBy8R8yYBjlYfH6HLqTuWcrs8IiIiouzQe6eUx8QDAICIOS30HAkREVHWtGzZEi1bttR3GJRHGRrI4OtlX2DLIyIiIsoqPr5HRERERERERES5jp1SRERERERERESU69gpRUQoF3BE3yEQERERERHRZ4adUkRERERERERElOv0PtA5EREREVGe4joJMLDWdxRERDlGzNZyVtYnORuHPgRu0s16un/y/61u/XSz0oIkNQ7A8AyzsVOKiIiI9CYlVeDyg5eIeZMARytTVPe0g6GBlhfK+aA8IiIiItKMnVJERESkF4fDohC0LxxRsQlSmouNKQJalUHTci75vjwiIiIiSh/HlCIiIqJcdzgsCkM2X1PqIAKA6NgEDNl8DYfDovJ1eURERESUMXZKERERUa5KSRUI2hcOoWaZIi1oXzhSUtXlyPvlEREREZF22ClFREREueryg5cqdyx9SgCIik3A5Qcv82V5RERERKQddkoRERFRrop5o7mDKCv58lp5lDNmz56NL774AlZWVnB0dETbtm1x9+5dpTx9+vSBTCZTetWsWVNPERMREVFGstQpFR8fr+s44DHxADwmHtD5eokKspxoi0REOc3RylSn+fJaeZQzQkJCMGzYMFy8eBHHjh1DcnIyGjdurHIubNq0KaKioqTXwYMH9RQxERERZSRLnVJOTk7o168fzp49q+t4iCgT2BaJKD+q7mkHFxtTyDQsl+HjrHjVPe3yZXmUMw4fPow+ffqgbNmyqFixItatW4fIyEhcvXpVKZ9cLoezs7P0srPj90pERJRXZalTauvWrYiNjUWDBg3g7e2NOXPm4MmTJ7qOjYgywLZIRPmRoYEMAa3KAIBKR5HifUCrMjA00NSNlLfLo9wRGxsLACqdTqdOnYKjoyO8vb0xcOBAxMTE6CM8IiIi0kKWOqVatWqF33//HU+ePMGQIUOwdetWuLu7o2XLlti1axeSk5N1HScRqcG2SET5VdNyLljRswqcbZQfmXO2McWKnlXQtJxLvi6PcpYQAmPHjkXt2rVRrlw5Kb1Zs2b49ddfcfLkSSxYsAChoaGoX78+EhMT1a4nMTERcXFxSi8iIiLKPTIhhE7mP166dCm++eYbfPjwAQ4ODhg8eDAmTpwIc3NzlbxxcXGwsbGB2+gdMJArL4+Y00IX4RBJFPtbbGwsrK2t9R1OjtNFW2Q7pJzwubXFzPic6yYlVeDyg5eIeZMAR6uPj9Dl5B1LuV1eXlQQ9rdhw4bhwIEDOHv2LIoWLaoxX1RUFNzd3bFt2za0b99eZXlgYCCCgoJUP+gaCxjkz7ohItKGmP15nftyQveea6T/b3Xrp8dI8qjUOOBJxtcbRtkpIzo6Ghs3bpSe6e/YsSP69++PJ0+eYM6cObh48SKOHj2anSKISAtsi0SUXxkayODrZV9gy/scvH//HkII6Y8fDx8+xO7du1GmTBk0btxY5+WNGDECe/fuxenTp9PtkAIAFxcXuLu74969e2qXT5o0CWPHjpXex8XFwc3NTafxEhERkWZZ6pTatWsX1q1bhyNHjqBMmTIYNmwYevbsiUKFCkl5KlWqhMqVK+sqTiJSg22RiIj0rU2bNmjfvj0GDx6M169fo0aNGjA2Nsbz58+xcOFCDBkyRCflCCEwYsQI7N69G6dOnYKnp2eGn3nx4gUePXoEFxf1j2fK5XLI5XKdxEdERESZl6Uxpfr27QtXV1ecO3cON27cwPDhw5V+BANA8eLFMWXKFF3ESEQasC0SEZG+Xbt2DXXq1AEA7Ny5E05OTnj48CE2btyIH3/8UWflDBs2DJs3b8aWLVtgZWWF6OhoREdH4/379wCAt2/fYvz48bhw4QIiIiJw6tQptGrVCg4ODmjXrp3O4iAiIiLdydKdUlFRUWrHp/mUmZkZAgICshQUEWmHbZEo+/7++2+cOnUKMTExSE1NVVo2bdo0PUVFlH+8e/cOVlZWAICjR4+iffv2MDAwQM2aNfHw4UOdlbNixQoAQN26dZXS161bhz59+sDQ0BC3bt3Cxo0b8fr1a7i4uKBevXrYvn27FB8RERHlLVnqlLKyskJUVBQcHR2V0l+8eAFHR0ekpKToJDgiSh/bIlH2/PLLLxgyZAgcHBzg7OwMmex/g37KZDJ2ShFpoUSJEtizZw/atWuHI0eOYMyYMQCAmJgYnQ6kntHcPGZmZjhy5IjOyiMiIqKcl6VOKU0XBYmJiTAxMclWQESkPbZFouyZOXMmvv/+e3z77bf6DkUtzkxH+cG0adPQvXt3jBkzBg0aNICvry+Aj3dNcUxDIiIiSk+mOqUU4wLIZDKsXr0alpaW0rKUlBScPn0apUuX1m2ERKSCbZFIN169eoVOnTrpdJ2zZ8/G5MmTMWrUKCxevDjL6zkcFoWgfeGIik2Q0lxsTBHQqgyallM/aHN25HZ5VHB07NgRtWvXRlRUFCpWrCilN2jQgGM5ERERUboy1Sm1aNEiAB/vzli5ciUMDQ2lZSYmJvDw8MDKlSt1GyERqWBbJNKNTp064ejRoxg8eLBO1hcaGopVq1ahQoUK2VrP4bAoDNl8DWnvhYyOTcCQzdewomcVnXYU5XZ5VPA4OzvD2dlZKa169ep6ioaIiIjyi0x1Sj148AAAUK9ePezatQu2trY5EhQRpY9tkUg3SpQogalTp+LixYsoX748jI2NlZaPHDlS63W9ffsWPXr0wC+//IKZM2dmOaaUVIGgfeEqHUQAIADIAATtC0ejMs46ebQut8ujgic+Ph5z5szBiRMn1E4Y8O+//+opMiIiIsrrsjSmVHBwsK7jIKIsYFskyp5Vq1bB0tISISEhCAkJUVomk8ky1Sk1bNgwtGjRAg0bNsywUyoxMRGJiYnS+7i4OOn/lx+8VHqELi0BICo2AZcfvISvl73W8WmS2+VRwTNgwACEhITgq6++gouLi9KEAURERETp0bpTauzYsZgxYwYsLCwwduzYdPMuXLgw24ERkXpsi0S6o7jrMLu2bduGa9euITQ0VKv8s2fPRlBQkNplMW80dxBlJZ+u1qOr8qjgOXToEA4cOIBatWrpOxQiIiLKZ7TulLp+/TqSkpKk/2vCv44R5Sy2RaKcoZjNMrNt59GjRxg1ahSOHj0KU1NTrT4zadIkpU7luLg4uLm5AQAcrbRbh7b5dLUeXZVHBY+trS3s7Oz0HQYRERHlQ1p3Sn36mBAfGSLSH7ZFIt3auHEj5s+fj3v37gEAvL298c033+Crr77S6vNXr15FTEwMqlatKqUpZsFctmwZEhMTlSYjAAC5XA65XK52fdU97eBiY4ro2AS14zzJADjbmKK6p246AXK7PCp4ZsyYgWnTpmHDhg0wNzfXdzhERESUj2RpTCkiIqKCYOHChZg6dSqGDx+OWrVqQQiBc+fOYfDgwXj+/DnGjBmT4ToaNGiAW7duKaX17dsXpUuXxrfffqvSIZURQwMZAlqVwZDN1yADlDqKFPdwBbQqo7NBx3O7PCp4FixYgPv378PJyQkeHh4qEwZcu3ZNT5ERERFRXqd1p1T79u21XumuXbuyFAwRZYxtkUh3li5dihUrVqBXr15SWps2bVC2bFkEBgZq1SllZWWFcuXKKaVZWFjA3t5eJV1bTcu5YEXPKgjaF640CLmzjSkCWpVB03IuWVpvXimPCpa2bdvqOwQiIiLKp7TulLKxscnJOIhIS2yLRLoTFRUFPz8/lXQ/Pz9ERUXpIaL/aVrOBY3KOOPyg5eIeZMAR6uPj9Dl1B1LuV0eFRwBAQG5Uk5gYKDKBAFOTk6Ijo4G8HFcuKCgIKxatQqvXr1CjRo18NNPP6Fs2bK5Eh8RERFlntadUuvWrcvJOIhIS2yLRLpTokQJ7NixA5MnT1ZK3759O0qWLJnl9Z46dSqbkX1kaCCDr5e9TtaVF8ujguXq1au4c+cOZDIZypQpg8qVK+u8jLJly+L48ePS+08fj503bx4WLlyI9evXw9vbGzNnzkSjRo1w9+5dWFlZ6TwWIiIiyj6OKUVEKjwmHpD+HzGnhR4jIcpZQUFB6NKlC06fPo1atWpBJpPh7NmzOHHiBHbs2KHv8IjyhZiYGHTt2hWnTp1CoUKFIIRAbGws6tWrh23btqFw4cI6K8vIyAjOzs4q6UIILF68GFOmTJEec9+wYQOcnJywZcsWDBo0SGcxEBERke5o3SlVpUoVnDhxAra2tqhcuXK6U2ZzQEuinMO2SKQ7HTp0wKVLl7Bo0SLs2bMHQgiUKVMGly9fzpG7PIgKohEjRiAuLg63b9+Gj48PACA8PBy9e/fGyJEjsXXrVp2Vde/ePbi6ukIul6NGjRqYNWsWihcvjgcPHiA6OhqNGzeW8srlcvj7++P8+fPslCIiIsqjtO6UatOmjTR9NQe0JNIftkUi3apatSo2b96s7zCI8q3Dhw/j+PHjUocUAJQpUwY//fSTUidRdtWoUQMbN26Et7c3nj59ipkzZ8LPzw+3b9+WxpVycnJS+oyTkxMePnyocZ2JiYlITEyU3sfFxeksXiIiIsqY1p1Snw5imVsDWhKRKrZFouyJi4uDtbW19P/0KPIRkWapqakwNjZWSTc2NkZqaqrOymnWrJn0//Lly8PX1xdeXl7YsGEDatasCQAqdw8LIdK9o3j27Nkqg6cTERFR7snWmFJXrlyRBrT08fFB1apVdRUXEWUC2yKR9mxtbREVFQVHR0cUKlRI7Q9WxQ/ZlJQUPURIlL/Ur18fo0aNwtatW+Hq6goA+O+//zBmzBg0aNAgx8q1sLBA+fLlce/ePenO4ejoaLi4uEh5YmJiVO6e+tSkSZMwduxY6X1cXBzc3NxyLGYiIiJSlqVOqcePH6Nbt244d+4cChUqBAB4/fo1/Pz8sHXrVp7MiXIJ2yJR5p08eRJ2dnYAgODgYD1HQ5T/LVu2DG3atIGHhwfc3Nwgk8kQGRmJ8uXL5+ijsYmJibhz5w7q1KkDT09PODs749ixY9J4cB8+fEBISAjmzp2rcR1yuVx6JJ6IiIhyX5Y6pfr164ekpCTcuXMHpUqVAgDcvXsX/fr1Q//+/XH06FGdBklE6rEtEmWev7+/9H9PT0/pR/SnhBB49OhRbodGlC+5ubnh2rVrOHbsGP766y9pwoCGDRvqtJzx48ejVatWKFasGGJiYjBz5kzExcWhd+/ekMlkGD16NGbNmoWSJUuiZMmSmDVrFszNzdG9e3edxkFERES6k6VOqTNnzuD8+fPSj2AAKFWqFJYuXYpatWrpLDgiSh/bIlH2eHp6So/yferly5fw9PTk43tEmdCoUSM0atQox9avuDv4+fPnKFy4MGrWrImLFy/C3d0dADBhwgS8f/8eQ4cOxatXr1CjRg0cPXoUVlZWORYTERERZU+WOqWKFSuGpKQklfTk5GQUKVIk20ERkXbYFomyR9MgyG/fvoWpqakeIiLKH3788Ud8/fXXMDU1xY8//phu3pEjR+qkzG3btqW7XCaTITAwEIGBgTopj4iIiHJeljql5s2bhxEjRuCnn35C1apVIZPJcOXKFYwaNQo//PCDrmMkIg3YFomyRjGwsUwmw9SpU2Fubi4tS0lJwaVLl1CpUiU9RUeU9y1atAg9evSAqakpFi1apDGfTCbTWacUERERFTxad0rZ2toq/TU5Pj4eNWrUgJHRx1UkJyfDyMgI/fr1k2ZAISLdY1skyr7r168D+Hin1K1bt2BiYiItMzExQcWKFTF+/Hh9hUeU5z148EDt/4mIiIgyQ+tOqcWLF+dgGESkLbZFouxTzLrXt29fLFmyBNbW1nqOiCj/mj59OsaPH690xyEAvH//HvPnz8e0adP0FBkRERHldVp3SvXu3Tsn4yAiLbEtEunOunXr9B0CUb4XFBSEwYMHq3RKvXv3DkFBQeyUIiIiIo2yNKbUp96/f68y0DL/4kyU+9gWibImNDQUv/32GyIjI/HhwwelZbt27dJTVET5h6YJA27evAk7Ozs9RERERBmRTRIQs1WP3US5zSArH4qPj8fw4cPh6OgIS0tL2NraKr2IKHewLRJlz7Zt21CrVi2Eh4dj9+7dSEpKQnh4OE6ePAkbGxt9h0eUp9na2sLOzg4ymQze3t6ws7OTXjY2NmjUqBE6d+6s7zCJiIgoD8vSnVITJkxAcHAwli9fjl69euGnn37Cf//9h59//hlz5szRdYxEpAHbIlH2zJo1C4sWLcKwYcNgZWWFJUuWwNPTE4MGDYKLi4u+wyPK0xYvXgwhBPr164egoCCljlwTExN4eHjA19dXjxESERFRXpelTql9+/Zh48aNqFu3Lvr164c6deqgRIkScHd3x6+//ooePXroOk4iUoNtkSh77t+/jxYtWgAA5HI54uPjIZPJMGbMGNSvXx9BQUF6jpAo71KMcejp6Qk/Pz8YGxvrOSIiIiLKb7L0+N7Lly/h6ekJ4OOYNS9fvgQA1K5dG6dPn9ZddESULrZFouyxs7PDmzdvAABFihRBWFgYAOD169d49+6dPkMjyjf8/f2lDqn3798jLi5O6UVERESkSZY6pYoXL46IiAgAQJkyZbBjxw4AH+/aKFSokK5iI6IMsC0SZU+dOnVw7NgxAEDnzp0xatQoDBw4EN26dUODBg30HB1R/vDu3TuOb0hERERZkqVOqb59++LmzZsAgEmTJmH58uWQy+UYM2YMvvnmG50GSESasS0SZc+yZcvQtWtXAB/b0Pjx4/H06VO0b98ea9as0XN0RPnDN998g5MnT0rnoNWrVyMoKAiurq7YuHGjzsrx8PCATCZTeQ0bNgwA0KdPH5VlNWvW1Fn5REREpHtZGlNqzJgx0v/r1auHO3fu4OrVq/Dy8kLFihV1FhwRpY9tkSjrkpOTsW/fPjRp0gQAYGBggAkTJmDChAl6jowof8mt8Q1DQ0ORkpIivQ8LC0OjRo3QqVMnKa1p06ZYt26d9N7ExEQnZRMREVHOyFKnVFru7u5wd3fXxaqIKBvYFom0Z2RkhCFDhuDOnTv6DoUoX0tvfMMhQ4borJzChQsrvZ8zZw68vLzg7+8vpcnlcjg7O+usTCIiIspZWXp8DwBOnDiBli1bwsvLCyVKlEDLli1x/PhxXcZGRFrI6bboMfEAPCYe0Nn6iPKSGjVq4Pr169lax+zZs/HFF1/AysoKjo6OaNu2Le7evaujCInyPn2Mb/jhwwds3rwZ/fr1g0wmk9JPnToFR0dHeHt7Y+DAgYiJicmR8omIiEg3stQptWzZMjRt2hRWVlYYNWoURo4cCWtrazRv3hzLli3TdYxEpAHbIlH2DB06FOPGjcOyZctw4cIF/Pnnn0ovbYSEhGDYsGG4ePEijh07huTkZDRu3Bjx8fE5HD1R3qCP8Q337NmD169fo0+fPlJas2bN8Ouvv+LkyZNYsGABQkNDUb9+fSQmJmpcT2JiImcLJCIi0iOZEEJk9kNFihTBpEmTMHz4cKX0n376Cd9//z2ePHmS7ufj4uJgY2MDt9E7YCA3V1oWMadFZsMhSpdif4uNjYW1tbW+w9GpnGyLabFtUnblxbZoYKD6txmZTAYhBGQymdL4Ndp69uwZHB0dERISgi+//FKrz+TFuqGCK6f3t8jISFy5ciVHxzds0qQJTExMsG/fPo15oqKi4O7ujm3btqF9+/Zq8wQGBiIoKEh1gWssYMC2SEQFm5gtyzgTadS95/8mxdnq1k+PkeRRqXHAk4yvN7J0p1RcXByaNm2qkt64cWP+hYkoF7EtEmXPgwcPVF7//vuv9G9WxMbGAgDs7Ow05uHdGVRQJCUloV69evj777+ltGLFiqF9+/Y51iH18OFDHD9+HAMGDEg3n4uLC9zd3XHv3j2NeSZNmoTY2Fjp9ejRI12HS0REROnIUqdU69atsXv3bpX0P/74A61atcp2UESkHbZFouxRTA6g6ZVZQgiMHTsWtWvXRrly5TTmmz17NmxsbKSXm5tbdjaDSG+MjY0RFhamNK5TTlu3bh0cHR3RokX6d/C+ePECjx49gouLi8Y8crkc1tbWSi8iIiLKPVrPvvfjjz9K//fx8cH333+PU6dOwdfXFwBw8eJFnDt3DuPGjdN9lEQkYVsk0p2NGzemu7xXr16ZWt/w4cPx559/4uzZs+nmmzRpEsaOHSu9j4uLY8cU5Vu9evXCmjVrMGfOnBwvKzU1FevWrUPv3r1hZPS/y9i3b98iMDAQHTp0gIuLCyIiIjB58mQ4ODigXbt2OR4XERERZY3WnVKLFi1Sem9ra4vw8HCEh4dLaYUKFcLatWvx3Xff6S5CIlLCtkikO6NGjVJ6n5SUhHfv3sHExATm5uaZ6pQaMWIE9u7di9OnT6No0aLp5pXL5ZDL5VmKmSiv+fDhA1avXo1jx46hWrVqsLCwUFq+cOFCnZV1/PhxREZGol8/5bE7DA0NcevWLWzcuBGvX7+Gi4sL6tWrh+3bt8PKykpn5RMREZFuad0p9eDBg5yMg4i0xLZIpDuvXr1SSbt37x6GDBmi9axhQgiMGDECu3fvxqlTp+Dp6anrMInytLCwMFSpUgUAlMaWAqDzx/oaN24MdXP0mJmZ4ciRIzoti4iIiHKe1p1SmiguDHJzLAEiUsW2SKQbJUuWxJw5c9CzZ0/89ddfGeYfNmwYtmzZgj/++ANWVlaIjo4GANjY2MDMzCynwyXSu+DgYH2HQERERPlUlgY6Bz6Ow1G+fHmYmZnBzMwMFSpUwKZNm3QZGxFpgW2RSPcMDQ3x5MkTrfKuWLECsbGxqFu3LlxcXKTX9u3bczhKorzln3/+wZEjR/D+/XsAUHtHExEREdGnsnSn1MKFCzF16lQMHz4ctWrVghAC586dw+DBg/H8+XOMGTNG13ESkRq52RY9Jh5Qmx4xJ/3Zj4jysr179yq9F0IgKioKy5YtQ61atbRaB3940+fuxYsX6Ny5M4KDgyGTyXDv3j0UL14cAwYMQKFChbBgwQJ9h0hERER5VJY6pZYuXYoVK1YoDQDbpk0blC1bFoGBgeyUIsolbItE2dO2bVul9zKZDIULF0b9+vX5Q5pIS2PGjIGxsTEiIyPh4+MjpXfp0gVjxoxhWyIiIiKNstQpFRUVBT8/P5V0Pz8/REVFZTsoItIO2yJR9qSmpuo7BKJ87+jRozhy5IjKrJMlS5bEw4cP9RQVERER5QdZ6pQqUaIEduzYgcmTJyulb9++HSVLltRJYESUMbZFoswbO3as1nl1OZU9UUEVHx8Pc3NzlfTnz59DLpfrISIiIiLKL7LUKRUUFIQuXbrg9OnTqFWrFmQyGc6ePYsTJ05gx44duo6RiDRgWyTKvOvXryu9v3r1KlJSUlCqVCkAH6e0NzQ0RNWqVfURHlG+8+WXX2Ljxo2YMWMGgI+PwaampmL+/PmoV6+enqMjIiKivCxLnVIdOnTA5cuXsXDhQuzZswdCCJQpUwaXL19G5cqVdR0jEWnAtkiUeZ9OX79w4UJYWVlhw4YNsLW1BQC8evUKffv2RZ06dfQVIlG+Mn/+fNStWxdXrlzBhw8fMGHCBNy+fRsvX77EuXPn9B0eERER5WGZ7pRKSkrC119/jalTp2Lz5s05ERMRaSGvtEV1s/JxRj7KLxYsWICjR49KHVIAYGtri5kzZ6Jx48YYN26cHqMjyh/KlCmDP//8EytWrIChoSHi4+PRvn17DBs2DC4uLvoOj4iIiPIwg8x+wNjYGLt3786JWABonnaeiJTldFsk+hzExcXh6dOnKukxMTF48+aNHiIiyn8iIyPh5OSEoKAg7N+/HwcPHsTMmTPh4uKCyMhIfYdHREREeVimO6UAoF27dtizZ4+OQyGizGJbJMqedu3aoW/fvti5cyceP36Mx48fY+fOnejfvz/at2+v7/CI8gVPT088e/ZMJf3Fixfw9PTUah2nT59Gq1at4OrqCplMpnJuE0IgMDAQrq6uMDMzQ926dXH79m2lPImJiRgxYgQcHBxgYWGB1q1b4/Hjx1neLiIiIsp5WZ59b8aMGTh//jyqVq0KCwsLpeUjR47USXBElD62RaLsWblyJcaPH4+ePXsiKSkJAGBkZIT+/ftj/vz5eo6OKH8QQkAmk6mkv337FqamplqtIz4+HhUrVkTfvn3RoUMHleXz5s3DwoULsX79enh7e2PmzJlo1KgR7t69CysrKwDA6NGjsW/fPmzbtg329vYYN24cWrZsiatXr8LQ0DB7G0lEREQ5IkudUqtXr0ahQoVw9epVXL16VWmZTCbjD2GiXMK2SJQ95ubmWL58OebPn4/79+9DCIESJUqodPASkaqxY8cC+Hi+mTp1KszNzaVlKSkpuHTpEipVqqTVupo1a4ZmzZqpXSaEwOLFizFlyhTpDsYNGzbAyckJW7ZswaBBgxAbG4s1a9Zg06ZNaNiwIQBg8+bNcHNzw/Hjx9GkSZNsbCkRERHllCx1Sj148ED6vxACANT+hYyIclZebYufjg3HQc8pP7CwsECFChX0HQZRvnL9+nUAH88/t27dgomJibTMxMQEFStWxPjx47NdzoMHDxAdHY3GjRtLaXK5HP7+/jh//jwGDRqEq1evIikpSSmPq6srypUrh/Pnz2vslEpMTERiYqL0Pi4uLtvxEhERkfayNKYUAKxZswblypWDqakpTE1NUa5cOaxevVqXsRGRFtgWiYhIH4KDgxEcHIzevXvj8OHD0vvg4GAcOXIEP//8M0qWLJntcqKjowEATk5OSulOTk7SsujoaJiYmCjNpJk2jzqzZ8+GjY2N9HJzc8t2vERERKS9LN0pNXXqVCxatAgjRoyAr68vAODChQsYM2YMIiIiMHPmTJ0GSUTqsS0SEZG+fDoZQO/evTXm27Vrl07KS3snsKaxrDKTZ9KkSdJjiMDHO6XYMUVERJR7stQptWLFCvzyyy/o1q2blNa6dWtUqFABI0aM4A9holzCtkhERPpiY2OTK+U4OzsD+Hg3lIuLi5QeExMj3T3l7OyMDx8+4NWrV0p3S8XExMDPz0/juuVyOeRyeQ5FTkRERBnJUqdUSkoKqlWrppJetWpVJCcnZzsoItIO2yIREenLunXrcqUcT09PODs749ixY6hcuTIA4MOHDwgJCcHcuXMBfDzvGRsb49ixY+jcuTMAICoqCmFhYZg3b16uxElERESZl6UxpXr27IkVK1aopK9atQo9evTIdlBEpB22RSIiKgjevn2LGzdu4MaNGwA+Dm5+48YNREZGQiaTYfTo0Zg1axZ2796NsLAw9OnTB+bm5ujevTuAj3dt9e/fH+PGjcOJEydw/fp19OzZE+XLl5dm4yMiIqK8J0t3SgEfB1c+evQoatasCQC4ePEiHj16hF69eik9m79w4cLsR0lEGrEtEhFRfnflyhXUq1dPeq84f/Xu3Rvr16/HhAkT8P79ewwdOhSvXr1CjRo1cPToUVhZWUmfWbRoEYyMjNC5c2e8f/8eDRo0wPr162FoaJjr20NERETayVKnVFhYGKpUqQIAuH//PgCgcOHCKFy4MMLCwqR8eWFqeqKCjG2RiIgKgrp160IIoXG5TCZDYGAgAgMDNeYxNTXF0qVLsXTp0hyIkIiIiHJCljqlgoODdR0HEWUB2yIRERERERHlV1kaUyqneUw8AI+JB/QdBhERERERERER5ZA82SlFRAUHO5mJiIiIiIhInTzdKcUfs0REREREREREBVOe7pQiIiLKL5YvXw5PT0+YmpqiatWqOHPmjL5DIiIiIiLK0/JFpxTvmCIiorxs+/btGD16NKZMmYLr16+jTp06aNasGSIjI/UdGhERERFRnpUvOqWIiIjysoULF6J///4YMGAAfHx8sHjxYri5uWHFihX6Do2IiIiIKM/KV51SvFuKiIjymg8fPuDq1ato3LixUnrjxo1x/vx5tZ9JTExEXFyc0ouIiIiI6HNjpO8AiOjz8GmncsScFnqMhEi3nj9/jpSUFDg5OSmlOzk5ITo6Wu1nZs+ejaCgoNwIj4iIiIgoz8pXd0oRERHlVTKZTOm9EEIlTWHSpEmIjY2VXo8ePcqNEImIiIiI8hR2ShFRrlNMXsBHcqkgcHBwgKGhocpdUTExMSp3TynI5XJYW1srvYg+Z6dPn0arVq3g6uoKmUyGPXv2SMuSkpLw7bffonz58rCwsICrqyt69eqFJ0+eKK2jbt26kMlkSq+uXbvm8pYQERFRZrBTioiIKBtMTExQtWpVHDt2TCn92LFj8PPz01NURPlLfHw8KlasiGXLlqkse/fuHa5du4apU6fi2rVr2LVrF/7++2+0bt1aJe/AgQMRFRUlvX7++efcCJ+IiIiyKN+NKZX2zgqOTUOUv6m7W4rtmvKbsWPH4quvvkK1atXg6+uLVatWITIyEoMHD9Z3aET5QrNmzdCsWTO1y2xsbFQ6fZcuXYrq1asjMjISxYoVk9LNzc3h7Oyco7ESERGR7uS7TikiKvjYUUX5TZcuXfDixQtMnz4dUVFRKFeuHA4ePAh3d3d9h0ZUIMXGxkImk6FQoUJK6b/++is2b94MJycnNGvWDAEBAbCystK4nsTERCQmJkrvORMmERFR7mKnFBERkQ4MHToUQ4cO1XcYRAVeQkICJk6ciO7duyuNx9ajRw94enrC2dkZYWFhmDRpEm7evKlyl9WnOBMmERGRfuX7TinFHRW8i4KIiIioYEtKSkLXrl2RmpqK5cuXKy0bOHCg9P9y5cqhZMmSqFatGq5du4YqVaqoXd+kSZMwduxY6X1cXBzc3NxyJngiIiJSke87pYiI0mJnNRFRwZOUlITOnTvjwYMHOHnyZIazVlapUgXGxsa4d++exk4puVwOuVyeE+ESERGRFgpMp1RGU8vzxykRERFR/qTokLp37x6Cg4Nhb2+f4Wdu376NpKQkuLi45EKERERElBUFplMqIxl1Wn2KHVhEec+nbVhdG1XXxtlZTUSUP7x9+xb//POP9P7Bgwe4ceMG7Ozs4Orqio4dO+LatWvYv38/UlJSEB0dDQCws7ODiYkJ7t+/j19//RXNmzeHg4MDwsPDMW7cOFSuXBm1atXS12YRERFRBj6bTqnM8Jh4gD9WifKwzHQyExFR3nflyhXUq1dPeq8Y56l3794IDAzE3r17AQCVKlVS+lxwcDDq1q0LExMTnDhxAkuWLMHbt2/h5uaGFi1aICAgAIaGhrm2HURERJQ57JTSQNOPXnZWERUcGd19pYv15sT6iYgKmrp160IIoXF5essAwM3NDSEhIboOi4iIiHIYO6UySZd3aPBHKlHelNFA6RxInYiIiIiIKPvYKaVHBfURJP5Qp4Ioo/aqq/acU3dv6ZNim1IT3+k5EiIiIiIiykvYKUU6l1OdbQXlBzrlTTndSZyVQddz4s7MzHR6qbsjTN3nC2JHGhERERER5Ty9dEopxgXgX80pM4qN+S1T+cOCmgAA4uLiAGQ8HsXniG0xfRntc5ndJ3NrXdqu/9M0RXv5lGK/0BSbom19uv+ktx2KfGyLqhR1oqhTopzE86JmUp2ksi0SUcEX917fEeRvSZ9WIM8bqlK1u96QCT1ckTx+/Bhubm65XSx95h49eoSiRYvqO4w8hW2R9IFtURXbIukD26IqtkUiIiLdyuh6Qy+dUqmpqbh79y7KlCmDR48ewdraOrdDKNDi4uLg5ubGuv1/Qgi8efMGrq6uMDAw0Hc4eUpqaiqePHkCKysryGQyfYeTLQV1vy9I28W2qFl6bbEg7QOacBtzF9uiZrxGzbq8tI/nJ6y3rGG9ZQ3rLWtYb1mj7fWGXh7fMzAwQJEiRQAA1tbW/GJzCOv2f2xsbPQdQp5kYGBQ4P5KXlD3+4KyXWyL6mnTFgvKPpAebmPuYVtUj9eo2cd6yxrWW9aw3rKG9ZY1rLfM0+Z6g38eIyIiIiIiIiKiXMdOKSIiIiIiIiIiynV665SSy+UICAiAXC7XVwgFFuuWPkcFdb8vqNtF2vsc9gFuI+Ul/K6yhvWWNay3rGG9ZQ3rLWtYbzlLLwOdExERERERERHR542P7xERERERERERUa5jpxQREREREREREeU6dkoREREREREREVGu01un1PLly+Hp6QlTU1NUrVoVZ86c0Vco+VJgYCBkMpnSy9nZWVouhEBgYCBcXV1hZmaGunXr4vbt23qMmCj7Zs+ejS+++AJWVlZwdHRE27ZtcffuXaU8BWHfnz17NmQyGUaPHi2lFYTtoswrSOfKgnjeOn36NFq1agVXV1fIZDLs2bNHabk225SYmIgRI0bAwcEBFhYWaN26NR4/fpyLW0GfKkhtThe4j2eerq5VPrd6A4AVK1agQoUKsLa2hrW1NXx9fXHo0CFpOestY1m9hvwc600X1yWfY73lBL10Sm3fvh2jR4/GlClTcP36ddSpUwfNmjVDZGSkPsLJt8qWLYuoqCjpdevWLWnZvHnzsHDhQixbtgyhoaFwdnZGo0aN8ObNGz1GTJQ9ISEhGDZsGC5evIhjx44hOTkZjRs3Rnx8vJQnv+/7oaGhWLVqFSpUqKCUnt+3izKvIJ4rC9p5Kz4+HhUrVsSyZcvULtdmm0aPHo3du3dj27ZtOHv2LN6+fYuWLVsiJSUltzaD/l9BbHPZxX0883R1rfK51RsAFC1aFHPmzMGVK1dw5coV1K9fH23atJE6Alhv6cvONeTnWm/ZvS75XOtN54QeVK9eXQwePFgprXTp0mLixIn6CCdfCggIEBUrVlS7LDU1VTg7O4s5c+ZIaQkJCcLGxkasXLkylyIkynkxMTECgAgJCRFC5P99/82bN6JkyZLi2LFjwt/fX4waNUoIkf+3i7KmoJ0rC/p5C4DYvXu39F6bbXr9+rUwNjYW27Ztk/L8999/wsDAQBw+fDjXYqePClqb0zXu41mTlWsV1tv/2NraitWrV7PeMpCda8jPtd6ye13yudZbTsj1O6U+fPiAq1evonHjxkrpjRs3xvnz53M7nHzt3r17cHV1haenJ7p27Yp///0XAPDgwQNER0cr1bFcLoe/vz/rmAqU2NhYAICdnR2A/L/vDxs2DC1atEDDhg2V0vP7dlHmFdRz5ed03tJmm65evYqkpCSlPK6urihXrly+3e78qqC2uZzEfVw7WblWYb0BKSkp2LZtG+Lj4+Hr68t6y0B2riE/53rLznXJ51xvumaU2wU+f/4cKSkpcHJyUkp3cnJCdHR0boeTb9WoUQMbN26Et7c3nj59ipkzZ8LPzw+3b9+W6lFdHT98+FAf4RLpnBACY8eORe3atVGuXDkAyNf7/rZt23Dt2jWEhoaqLMvP20VZUxDPlZ/beUubbYqOjoaJiQlsbW1V8uTX7zm/KohtLqdxH89YVq9VPud6u3XrFnx9fZGQkABLS0vs3r0bZcqUkX7ks95UZfca8nOtt+xel3yu9ZYTcr1TSkEmkym9F0KopJFmzZo1k/5fvnx5+Pr6wsvLCxs2bEDNmjUBsI6pYBs+fDj+/PNPnD17VmVZftv3Hz16hFGjRuHo0aMwNTXVmC+/bRdlX0H6zj/X81ZWtqkgbHd+VRD3wZzGfVwzXV+rfA71VqpUKdy4cQOvX7/G77//jt69eyMkJERaznpTlpPXkAW53oCcuy4p6PWWE3L98T0HBwcYGhqq9B7GxMSo9ESS9iwsLFC+fHncu3dPmjWAdUwF1YgRI7B3714EBwejaNGiUnp+3fevXr2KmJgYVK1aFUZGRjAyMkJISAh+/PFHGBkZSbHnt+2irPsczpUF/bylzTY5Ozvjw4cPePXqlcY8lDs+hzana9zH05eda5XPud5MTExQokQJVKtWDbNnz0bFihWxZMkS1psGuriG/BzrTZ3MXpew3nQn1zulTExMULVqVRw7dkwp/dixY/Dz88vtcAqMxMRE3LlzBy4uLvD09ISzs7NSHX/48AEhISGsY8rXhBAYPnw4du3ahZMnT8LT01NpeX7d9xs0aIBbt27hxo0b0qtatWro0aMHbty4geLFi+fL7aKs+xzOlQX9vKXNNlWtWhXGxsZKeaKiohAWFpZvtzu/+hzanK5xH1dPF9cqn2O9aSKEQGJiIutNA11cQ36O9aZOZq9LWG86lHtjqv/Ptm3bhLGxsVizZo0IDw8Xo0ePFhYWFiIiIkIf4eRL48aNE6dOnRL//vuvuHjxomjZsqWwsrKS6nDOnDnCxsZG7Nq1S9y6dUt069ZNuLi4iLi4OD1HTpR1Q4YMETY2NuLUqVMiKipKer17907KU1D2/U9nThGi4GwXaa+gnSsL4nnrzZs34vr16+L69esCgFi4cKG4fv26ePjwoRBCu20aPHiwKFq0qDh+/Li4du2aqF+/vqhYsaJITk7W12Z9tgpam9MF7uOZp6trlc+t3oQQYtKkSeL06dPiwYMH4s8//xSTJ08WBgYG4ujRo0II1pu2snIN+TnWmy6uSz7HessJeumUEkKIn376Sbi7uwsTExNRpUoVaZpU0k6XLl2Ei4uLMDY2Fq6urqJ9+/bi9u3b0vLU1FQREBAgnJ2dhVwuF19++aW4deuWHiMmyj4Aal/r1q2T8hSUfT/tBUVB2S7KnIJ0riyI563g4GC1x6TevXsLIbTbpvfv34vhw4cLOzs7YWZmJlq2bCkiIyP1sDUkRMFqc7rAfTzzdHWt8rnVmxBC9OvXT2p/hQsXFg0aNJA6pIRgvWkrK9eQn2O96eK65HOst5wgE0KI3Lsvi4iIiIiIiIiISA9jShEREREREREREbFTioiIiIiIiIiIch07pYiIiIiIiIiIKNexU4qIiIiIiIiIiHIdO6WIiIiIiIiIiCjXsVOKiIiIiIiIiIhyHTuliIiIiIiIiIgo17FTioiIiIiIiIiIch07pbJh/fr1KFSokPQ+MDAQlSpVytQ6ZDIZ9uzZo3F5REQEZDIZbty4kaUYc9qpU6cgk8nw+vVrfYdCOpKf9+u0seuDh4cHFi9enCtlffXVV5g1a5b0/t27d+jQoQOsra3zZbvcv38/KleujNTUVH2HQtlQt25djB49Wt9hKMnomERERKqycg2oS1OnTsXXX38tvRdC4Ouvv4adnV2e/n2kya1bt1C0aFHEx8frOxSiPIWdUkREWaCpAyw0NFTpAiqn/Pnnnzhw4ABGjBghpW3YsAFnzpzB+fPnERUVBRsbmxyPQ5datmwJmUyGLVu26DsUyoZdu3ZhxowZAHK3kxbQ/AMqKioKzZo1y7U4iIjyOplMlu6rT58+GD9+PE6cOKGX+J4+fYolS5Zg8uTJUtrhw4exfv167N+/H1FRUShXrpxeYsuq8uXLo3r16li0aJG+QyHKU9gp9RlKSUnhnQhEGnz48CFbny9cuDDMzc11FI1my5YtQ6dOnWBlZSWl3b9/Hz4+PihXrhycnZ0hk8lUPpfd7ctpffv2xdKlS/UdBmWDnZ2d0n6pC9ndb52dnSGXy3UUDRFR/hcVFSW9Fi9eDGtra6W0JUuWwNLSEvb29nqJb82aNfD19YWHh4eUdv/+fbi4uMDPzw/Ozs4wMjJS+Vx+uM5ZsWIFUlJS9B0KUZ7x2XdK7dy5E+XLl4eZmRns7e3RsGFDxMfH4/Tp0zA2NkZ0dLRS/nHjxuHLL7/Uat2hoaFo1KgRHBwcYGNjA39/f1y7dk0ln+IvuGZmZvD09MRvv/2W7nrDw8PRvHlzWFpawsnJCV999RWeP3+uMb/ijo79+/ejTJkykMvlePjwoVbxyWQyrF69Gu3atYO5uTlKliyJvXv3aizr/fv3aNGiBWrWrImXL19mUEOUUz6H/Rr4uG8XK1YM5ubmaNeuHV68eKG0vE+fPmjbtq1S2ujRo1G3bl3pfd26dTF8+HCMHTsWDg4OaNSoEQBg4cKFKF++PCwsLODm5oahQ4fi7du3AD4+ttq3b1/ExsZKf1EMDAwEoHpnSGRkJNq0aQNLS0tYW1ujc+fOePr0qbRccWfHpk2b4OHhARsbG3Tt2hVv3rzRuN2pqan47bff0Lp1a6XtWLBgAU6fPg2ZTCZto4eHB2bOnIk+ffrAxsYGAwcOBAB8++238Pb2hrm5OYoXL46pU6ciKSlJJa61a9eiWLFisLS0xJAhQ5CSkoJ58+bB2dkZjo6O+P7775Vii42Nxddffw1HR0dYW1ujfv36uHnzprT85s2bqFevHqysrGBtbY2qVaviypUr0vLWrVvj8uXL+PfffzVuP+Vtisf36tati4cPH2LMmDFSO1E4f/48vvzyS5iZmcHNzQ0jR45UepwhK/vt+vXrERQUhJs3b0rlrV+/HoDq43u3bt1C/fr1pWPk119/LbVv4H/Hjh9++AEuLi6wt7fHsGHDlNoIEVF+5uzsLL1sbGwgk8lU0tLefao4Ns6aNQtOTk4oVKgQgoKCkJycjG+++QZ2dnYoWrQo1q5dq1TWf//9hy5dusDW1hb29vZo06YNIiIi0o1v27ZtStc5ffr0wYgRIxAZGQmZTCZ1VmXlOg5Q/n1UqlQpmJubo2PHjoiPj8eGDRvg4eEBW1tbjBgxQqkD6cOHD5gwYQKKFCkCCwsL1KhRA6dOnZKWP3z4EK1atYKtrS0sLCxQtmxZHDx4UFrepEkTvHjxAiEhIdp+VUQF3mfdKRUVFYVu3bqhX79+uHPnDk6dOoX27dtDCIEvv/wSxYsXx6ZNm6T8ycnJ2Lx5M/r27avV+t+8eYPevXvjzJkzuHjxIkqWLInmzZur/NicOnUqOnTogJs3b6Jnz57o1q0b7ty5ozFmf39/VKpUCVeuXMHhw4fx9OlTdO7cOd1Y3r17h9mzZ2P16tW4ffs2HB0dtY4vKCgInTt3xp9//onmzZujR48eajucYmNj0bhxY3z48AEnTpyAnZ2dVvVEuvW57NeXLl1Cv379MHToUNy4cQP16tXDzJkztdqGtDZs2AAjIyOcO3cOP//8MwDAwMAAP/74I8LCwrBhwwacPHkSEyZMAAD4+fmp/FVx/PjxKusVQqBt27Z4+fIlQkJCcOzYMdy/fx9dunRRynf//n3s2bMH+/fvx/79+xESEoI5c+ZojPfPP//E69evUa1aNSlt165dGDhwIHx9fREVFYVdu3ZJy+bPn49y5crh6tWrmDp1KgDAysoK69evR3h4OJYsWYJffvlF5Xby+/fv49ChQzh8+DC2bt2KtWvXokWLFnj8+DFCQkIwd+5cfPfdd7h48aK0vS1atEB0dDQOHjyIq1evokqVKmjQoIF0zOjRoweKFi2K0NBQXL16FRMnToSxsbFUpru7OxwdHXHmzJmMvzjK03bt2oWiRYti+vTpUjsBPnYINWnSBO3bt8eff/6J7du34+zZsxg+fLjS5zO733bp0gXjxo1D2bJlpfLStjXg4/mwadOmsLW1RWhoKH777TccP35cpfzg4GDcv38fwcHB2LBhA9avXy91chERfa5OnjyJJ0+e4PTp01i4cCECAwPRsmVL2Nra4tKlSxg8eDAGDx6MR48eAfh4zK1Xrx4sLS1x+vRpnD17FpaWlmjatKnGu5pevXqFsLAwpeucJUuWYPr06ShatCiioqIQGhoqLcvsdZzCu3fv8OOPP2Lbtm04fPiwdM188OBBHDx4EJs2bcKqVauwc+dO6TN9+/bFuXPnsG3bNvz555/o1KkTmjZtinv37gEAhg0bhsTERJw+fRq3bt3C3LlzYWlpKX3exMQEFStW5HUO0afEZ+zq1asCgIiIiFC7fO7cucLHx0d6v2fPHmFpaSnevn0rhBBi3bp1wsbGRloeEBAgKlasqLG85ORkYWVlJfbt2yelARCDBw9WylejRg0xZMgQIYQQDx48EADE9evXhRBCTJ06VTRu3Fgp/6NHjwQAcffuXbXlrlu3TgAQN27c0BhbevF999130vu3b98KmUwmDh06JIQQIjg4WAAQf/31l6hYsaJo3769SExMTLccylmfy37drVs30bRpU6W0Ll26KMXeu3dv0aZNG6U8o0aNEv7+/tJ7f39/UalSJY3bp7Bjxw5hb28vvU9bTwru7u5i0aJFQgghjh49KgwNDUVkZKS0/Pbt2wKAuHz5shDiY/2am5uLuLg4Kc8333wjatSooTGW3bt3C0NDQ5Gamprutiniadu2bYbbN2/ePFG1alXpvbq4mjRpIjw8PERKSoqUVqpUKTF79mwhhBAnTpwQ1tbWIiEhQWndXl5e4ueffxZCCGFlZSXWr1+fbiyVK1cWgYGBGcZMeZO/v78YNWqUEEK5PSh89dVX4uuvv1ZKO3PmjDAwMBDv37+XPpfV/Vbd8QqA2L17txBCiFWrVglbW1vpmCeEEAcOHBAGBgYiOjpaCPHx2OHu7i6Sk5OlPJ06dRJdunTJMCYiovxG0zVN2mOq4tiY9jqgTp060vvk5GRhYWEhtm7dKoQQYs2aNaJUqVJK1yyJiYnCzMxMHDlyRG08169fFwCUrp+EEGLRokXC3d1dKS0713EAxD///COlDRo0SJibm4s3b95IaU2aNBGDBg0SQgjxzz//CJlMJv777z+ldTdo0EBMmjRJCCFE+fLlM7yGadeunejTp0+GMRN9Lj7rO6UqVqyIBg0aoHz58ujUqRN++eUXvHr1Slrep08f/PPPP9JdAGvXrkXnzp1hYWGh1fpjYmIwePBgeHt7w8bGBjY2Nnj79i0iIyOV8vn6+qq813RHydWrVxEcHAxLS0vpVbp0aQAf72rQxMTEBBUqVMhSfJ9+zsLCAlZWVoiJiVHK07BhQxQvXhw7duyAiYmJxjgo530u+/WdO3fUlpEVn/4lTiE4OBiNGjVCkSJFYGVlhV69euHFixeZmjHlzp07cHNzg5ubm5RWpkwZFCpUSKkuPDw8lMbgcXFxUWljn3r//j3kcrnaMaPUUbd9O3fuRO3ateHs7AxLS0tMnTpV5TtMG5eTkxPKlCkDAwMDpTRFrFevXsXbt29hb2+v9F0+ePBA+h7Hjh2LAQMGoGHDhpgzZ47a79fMzAzv3r3Tatso/7l69SrWr1+vtI80adIEqampePDggZQvq/ttRu7cuYOKFSsqHfNq1aqF1NRU3L17V0orW7YsDA0NpfcZtUsios9B2bJlVa4DypcvL703NDSEvb290rXBP//8AysrK+mYb2dnh4SEBI3XeO/fvwcAmJqaahVTVq/jzM3N4eXlpbQtHh4eSnc2fXqdc+3aNQgh4O3trXQOCwkJkbZl5MiRmDlzJmrVqoWAgAD8+eefKrHxOodImerocJ8RQ0NDHDt2DOfPn8fRo0exdOlSTJkyBZcuXYKnpyccHR3RqlUrrFu3DsWLF8fBgweVnhnOSJ8+ffDs2TMsXrwY7u7ukMvl8PX11WoAPk0/NlNTU9GqVSvMnTtXZZmLi4vG9ZmZmamsU9v4Pn20RhFb2oHSW7Rogd9//x3h4eFKJybKfZ/Lfi2EyLA8AwMDlXzqxoRJ2yH38OFDNG/eHIMHD8aMGTNgZ2eHs2fPon///pkaU0YIoXab06Zr08Y+5eDggHfv3uHDhw9adQKn3b6LFy+ia9euCAoKQpMmTWBjY4Nt27ZhwYIFSvnUxZVerKmpqXBxcVG7PylmKgwMDET37t1x4MABHDp0CAEBAdi2bRvatWsn5X358iUKFy6c4XZR/pSamopBgwZh5MiRKsuKFSsm/T+r+21GNLVLANlql0REn4OsXBtUrVoVv/76q8q6NJ3rHRwcAHx8jE+b64GsXsdlZVsMDQ1x9epVpT9aAJA6sgYMGIAmTZrgwIEDOHr0KGbPno0FCxYozZb88uVLpc4wos/dZ90pBXw80NSqVQu1atXCtGnT4O7ujt27d2Ps2LEAPh5YunbtiqJFi8LLywu1atXSet1nzpzB8uXL0bx5cwDAo0eP1A7cfPHiRfTq1UvpfeXKldWus0qVKvj999/h4eGhdsaJzNA2Pm3MmTMHlpaWaNCgAU6dOoUyZcpkKzbKns9hvy5Tpox0t9enZXyqcOHCCAsLU0q7ceOGygVHWleuXEFycjIWLFgg/TVwx44dSnlMTEwynDmlTJkyiIyMxKNHj6S7pcLDwxEbGwsfH590P5sexaCj4eHhSgOQauvcuXNwd3fHlClTpLSHDx9mOR6FKlWqIDo6GkZGRkqz5aTl7e0Nb29vjBkzBt26dcO6deukTinFX0417SuUv6hrJ1WqVMHt27dRokSJTK1Lm/1W23a5YcMGxMfHSz9kzp07BwMDA3h7e2cqJiIiSl+VKlWwfft2aQIUbXh5ecHa2hrh4eFZOi5rcx2XFZUrV0ZKSgpiYmJQp04djfnc3NyksbUmTZqEX375RalTKiwsDB07dsx2PEQFxWf9+N6lS5cwa9YsXLlyBZGRkdi1axeePXum9GNR8dfYmTNnaj0QtEKJEiWwadMm3LlzB5cuXUKPHj1gZmamku+3337D2rVr8ffffyMgIACXL19WGXBVYdiwYXj58iW6desmzVB19OhR9OvXL9NTi2obn7Z++OEH9OjRA/Xr18dff/2V5fVQ9nwu+/XIkSNx+PBhzJs3D3///TeWLVuGw4cPK+WpX78+rly5go0bN+LevXsICAhQ6aRSx8vLC8nJyVi6dCn+/fdfbNq0CStXrlTK4+Hhgbdv3+LEiRN4/vy52tuwGzZsiAoVKqBHjx64du0aLl++jF69esHf31/trebaKly4MKpUqYKzZ89m6fMlSpRAZGQktm3bhvv37+PHH3/E7t27sxyPQsOGDeHr64u2bdviyJEjiIiIwPnz5/Hdd9/hypUreP/+PYYPH45Tp07h4cOHOHfuHEJDQ5X2zYsXL0p331H+5+HhgdOnT+O///6TOq+//fZbXLhwAcOGDcONGzdw79497N27V+mCXR1t9lsPDw88ePAAN27cwPPnz5GYmKiynh49esDU1BS9e/dGWFgYgoODMWLECHz11VdwcnLS3cYTERF69OgBBwcHtGnTBmfOnMGDBw8QEhKCUaNG4fHjx2o/Y2BggIYNG2b5Okeb67is8Pb2Ro8ePdCrVy/s2rULDx48QGhoKObOnSvNsDd69GgcOXIEDx48wLVr13Dy5Eml65yIiAj8999/aNjw/9q7m1fo1ziO459hIwuyGMqCJDOUNBZTkzJ5ODFjQSEPiTRlKPKQsjEWYyMKC5qFRNQ0Y8lCsaMoD38BCywlJAssJmdxOlOO+7jnZpq5b/N+ra+5+v7q6tf06Xt9f399uR7gu0joUCotLU37+/uqq6uTyWSSx+PR7OysnE5neE1SUpK6u7sVCoXedH1EYmVlRff39yotLVVnZ6cGBweVmZn5bp3X61UwGFRJSYnW1tbk9/v/t9MoOztbBwcHCoVCqq2tVXFxsYaGhpSenv7mfnc06/sV8/PzamlpUVVVlc7Ozr60Fz4nUc61zWbT8vKyFhYWZLFYtLu7K4/H82ZNbW2tJiYmNDY2JqvVqsfHx4ie12KxaG5uTtPT0youLpbf79fU1NSbNWVlZerr61Nra6uMRqNmZmbe7fPvZ+gzMjJkt9vDs9c2NjZ+WsPPuN3uH7bCR6KhoUEjIyMaGBiQxWLR4eFh+OtmX2EwGLS9vS273S6XyyWTyaS2tjZdXl4qKytLycnJur29VVdXl0wmk1paWuR0OuX1esN7BAIBdXR0KDU19cv1IP4mJyd1eXmp/Pz88BWMkpIS7e3t6fz8XOXl5SotLdXExMSHV9ClyM5tU1OTHA6HKisrZTQaFQgE3u2TmpqqnZ0d3d3dyWq1qrm5WdXV1VpcXIzegwMAJP3zzt3f31dOTo4aGxtVVFQkl8ulp6enDzun3G63gsHgp65NR/I/7rNWV1fV1dWl0dFRmc1m1dfX6+joKNwRHwqF1N/fr6KiIjkcDpnNZvl8vvDvA4GAampqlJubG5V6gO/A8BrJYJYE19PTo+vra21tbcW7FCBqONd/tufnZ5nNZgWDwW/TVXRzc6PCwkKdnp4qLy8v3uUAAIA4eX19lc1m0/DwsNrb2+NdTlS8vLyooKBAgUDgl0ZnAN9dws+U+sjDw4NOTk7k9/u1ubkZ73KAqOBcfw8pKSlaX1//9By439HFxYV8Ph+BFAAACc5gMGhpaemHX6/7U11dXWl8fJxACvgPOqU+UFFRoePjY/X29mp+fj7e5QBRwbkGAAAAAPwOCKUAAAAAAAAQcwk96BwAAAAAAADxQSgFAAAAAACAmCOUAgAAAAAAQMwRSgEAAAAAACDmCKUAAAAAAAAQc4RSAAAAAAAAiDlCKQAAAAAAAMQcoRQAAAAAAABijlAKAAAAAAAAMfc3d7SPIA8jclkAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -2452,12 +2493,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [05:53<00:06, 6.73s/it]" + " 99%|████████████████████████████████▋| 100/101 [02:14<00:01, 1.32s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2469,30 +2510,28 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [06:01<00:00, 7.10s/it]\n", - "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.94model snapshot/s]\n" + "100%|█████████████████████████████████| 101/101 [02:16<00:00, 1.35s/it]\n", + "Reindexing: 100%|█████████████| 7/7 [00:01<00:00, 4.86model snapshot/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", - "exists. Use `overwrite=True` or pick a different name\n", - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/aef6\n", - "42d24bf39d00d34f4f187f20c545_ar\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/aef642d24bf39d00d3\n", + "4f4f187f20c545/aef642d24bf39d00d34f4f187f20c545_ar\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [00:39<00:42, 1.62s/it]" + " 49%|█████████████████▏ | 25/51 [00:32<00:33, 1.27s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2504,12 +2543,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [01:20<00:01, 1.87s/it]" + " 98%|██████████████████████████████████▎| 50/51 [01:04<00:01, 1.27s/it]" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAD6CAYAAABwKvR6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACIl0lEQVR4nO3dd1QU198G8GfpvUuzAGIJFlAxKhjF3htqLLH33o3GikQjlthiLFFjr1HRWLFib9hFjFEjggoWULGBAvf9w9/Oy7ILLEWW8nzO2XPYO3dmvnN37pTL3LkyIYQAERERERERERFRLtLSdABERERERERERFT4sFGKiIiIiIiIiIhyHRuliIiIiIiIiIgo17FRioiIiIiIiIiIch0bpYiIiIiIiIiIKNexUYqIiIiIiIiIiHIdG6WIiIiIiIiIiCjXsVGKiIiIiIiIiIhyHRuliIiIiIiIiIgo17FRioiI0hQbG4tOnTrB1tYWMpkMbdq0kaa9fPkSI0aMgLOzM/T19WFnZ4emTZsiNjY2zeWtWrUKMpkMJiYmCulJSUmYP38+mjRpgmLFisHIyAhubm746aef8Pr1a7ViPXHiBGQyGU6cOKGwvjZt2sDZ2RmGhoYoVaoUBg0ahKioqHSX9ezZM1hbW0Mmk2HHjh0K06ZNmwaZTIaXL19mGNOnT58wcOBAODg4QFtbG5UqVQIATJo0CZUrV4aVlRUMDAxQsmRJ9O/fH48ePVJaxr///ot27drB0tISRkZGqF69Ovbs2ZNxgfxPnTp1UKdOHaX0xYsX45tvvoG+vj5cXFzg7++Pz58/K+V7/vw5evbsCRsbGxgZGcHLywvHjh1Te/0ymQzTpk2Tvl+/fh3NmzdHiRIlYGhoCCsrK3h5eWHjxo3pLkcIgdq1a0Mmk2Ho0KFK069duwYfHx+Ym5tDJpNh4cKFSnmOHj0KmUyW5u83efJklChRAjo6OrCwsAAAnDlzBn379oWnpyf09fUhk8kQHh6uMsbo6GgMHToUJUuWhKGhIZycnNCnTx9EREQo5KtTp44Uh6pPdHS0lFdVHYyKisLkyZPh5eUFGxsbmJmZwdPTEytWrEBSUpJSXO/evcPIkSPh6OgIAwMDVKpUCVu3bk2ntNMm3/9TfwwMDNKdL706Ja+7qj4XLlzIUpy5RdXxYPPmzSr3v9yWXhyp62VuyexvffXqVTRo0AAmJiawsLBA27Zt8d9//+V63ERE9PXoaDoAIiLKu6ZPn45du3Zh9erVcHV1hZWVFQDg6dOnqFWrFnR0dDBlyhSULl0aL1++RHBwMD59+qRyWU+ePMHYsWPh6OiIN2/eKEz7+PEjpk2bhs6dO6Nv376wsbHB1atXMWPGDOzduxeXL1+GoaFhpuP38/ND3bp1MXPmTBQtWhR3797F9OnT8ffff+PatWuws7NTOd+QIUMyvMlWx7Jly/DHH39g8eLF8PT0lBrjXr9+jc6dO8PNzQ2mpqYICwvDjBkzsGfPHty+fRvW1tYAgPDwcHh5ecHBwQHLly+HiYkJli1bhjZt2mD79u1o165dluL65ZdfMGXKFPz0009o1KgRQkJCMHnyZDx58gQrVqyQ8iUkJKB+/fp4/fo1Fi1aBFtbWyxZsgRNmjTB0aNH4ePjk+l1v379GsWLF0fnzp1RtGhRvH//Hps2bUK3bt0QHh6OyZMnq5xvyZIluH//fprL7d27N96/f4+tW7fC0tISzs7OCtPfvXuHfv36wdHREU+fPlWa/++//8Yvv/yCSZMmoWnTptDX1wcAHDt2DEePHkXlypVhZmam0OiZUkJCAmrXro1Xr17B398f5cqVw927d+Hn54dDhw7hzp07MDU1BQAsXboUcXFxCvN/+PABTZo0gaenJ+zt7aV0VXXwypUrWL9+Pbp3744pU6ZAV1cXBw8exKBBg3DhwgWsXr1aYdlt27ZFSEgIZs2ahTJlymDz5s3o3LkzkpOT8cMPP6RZpukJCgqCubm59F1LK/3/c6pTp2bOnIm6desqpFWoUCFL8WnS5s2bERoaipEjR+bZOM6fP49ixYrlflD/o85v/c8//6BOnTqoVKkS/vrrL8THx2Pq1KmoVasWrl+/jiJFiuRmyERE9LUIIiKiNDRo0EC4ubkppbdu3VoULVpUxMbGqr2sFi1aiJYtW4oePXoIY2NjhWmJiYni5cuXSvNs375dABAbNmzIcPnBwcECgAgODpbSnj17ppQvJCREABDTp09XuZwdO3YIExMTsW7dOgFAbN++XWG6n5+fACBevHiRYUx9+/YVhoaGGeYTQogDBw4IAOLPP/+U0gYMGCAMDAzE48ePpbTExETh5uYmihcvLpKSkjJcro+Pj/Dx8ZG+v3z5UhgYGIj+/fsr5Pvll1+ETCYTt2/fltKWLFkiAIhz585JaZ8/fxblypUT1apVU2u7AAg/P78M81WvXl0UL15c5bSHDx8KExMTERgYKACIIUOGKOXR0dERgwYNSnP5Q4YMEZUrVxaTJ09W+fvNmDFDAFDaZ1KW8dy5cwUA8fDhQ6XlHzlyRAAQq1atUkjfvHmzACACAwPTjE0IIdauXatyflV1MDY2Vnz69EnlNgIQERERUtr+/fsFALF582aFvA0bNhSOjo4iMTEx3bhSy8z+L5dRnZLX3dTpue3Tp0/i8+fPmZpHVXk0b95cODk55XB0Qnz48CFT+b9WHNmRmd/6+++/FzY2NuLNmzdSWnh4uNDV1RXjxo37mmESEVEuYvc9IqIC4v79++jVqxdKly4NIyMjFC1aFC1btsStW7eU8sbFxWHs2LFwcXGBnp4eihYtipEjR+L9+/cAvjyhI5PJcPToUdy5c0fqXnHixAmEh4djz5496NevHywtLdWKbePGjTh58iSWLl2qcrq2trb0dFBK1apVAwBERkYqpP/zzz9o0qQJjIyMYGNjg4EDB+Lt27dK89va2iqleXp6QltbW2mZwJeuUkOGDMEvv/yCEiVKpLtNkZGRaNu2LczMzGBubo6uXbvixYsX0nSZTIZVq1bh48ePUvmtXbs2zeXJ/+uvo/P/DzGfPXsWHh4eKFq0qJSmra2Npk2bIjIyEpcuXZLShRCYM2cOnJycYGBggCpVquDgwYNK6wkKCkJ8fDx69eqlkN6rVy8IIbB7924pbdeuXShbtiy8vLykNB0dHXTt2hWXLl3CkydPpPS4uDj069cP1tbWMDExQZMmTfDvv/+mU4KKbGxsFLY9pf79+6Nhw4bw9fVVmrZ27VrIZDIkJiZi2bJlUlmndPr0aaxYsQKrVq2Ctra20jKcnZ2lJ7Ts7OwUujZl9ASQnK6uLgAoPD0EQOoGmNFTQn/++SdMTEzQsWNHAOnXQUtLS2l9Kcnry+PHj6W0Xbt2wcTEBN9//71C3l69euHp06e4ePGiQvrmzZvh5eUFExMTmJiYoFKlSvjzzz/VKAHVMlOncoK6x0F5N7INGzZgzJgxKFq0KPT19dN9Gk8dderUwf79+/Ho0SOFrmlynz59wowZM6Sus0WKFEGvXr0Ujh3Al32yRYsWCAwMROXKlWFgYAB/f38AX54arF27NmxtbWFsbIyKFStizpw5Ct1vM4pDVfe90NBQtG7dGpaWllI3z3Xr1qksty1btmDSpElwdHSEmZkZGjRogLt372ar7FJKTEzEvn370K5dO5iZmUnpTk5OqFu3Lnbt2pVj6yIiIs1ioxQRUQHx9OlTWFtbY9asWQgKCsKSJUugo6OD6tWrK9wsfPjwAT4+Pli3bh2GDx+OgwcPYvz48Vi7di1atWoFIQQcHBxw/vx5VK5cGSVLlsT58+dx/vx5VKlSBadPn4YQAo6OjujcuTNMTExgYGCAOnXq4Pz580pxPX/+HCNHjsSsWbMy3V3k+PHjAIDy5ctLac+ePYOPjw9CQ0OxdOlSbNiwAe/evVP5niFVTp48iaSkJIVlyg0fPhwuLi5qLcvX1xelSpXCjh07MG3aNOzevRuNGzeWbgzPnz+PZs2awdDQUCq/5s2bKywjMTERHz9+xLVr1zBy5EiUKVMGbdu2laZ/+vRJ6kaWkjzt5s2bUpq/vz/Gjx+Phg0bYvfu3Rg0aBD69eundKMYGhoKAKhYsaJCuoODA2xsbKTp8rzu7u5K65en3b59G8CXBrE2bdpIN/i7du1CjRo10LRp0zTLLzk5GYmJiXjx4gWWLl2KQ4cOYfz48Ur5Vq1ahUuXLuH3339XuZzmzZtL+1379u2lspb7+PEj+vTpg5EjR6JKlSoql7Fr1y706dMHwJdGu/Pnz6Nv375pxq5KzZo14enpiWnTpiEkJATv3r3D1atXMXHiRFSpUgUNGjRIc9579+7h9OnT6NSpk9TFM706mJbjx49DR0cHZcqUkdJCQ0Ph5uam1OAn/w1T/t5Tp05Fly5d4OjoiLVr12LXrl3o0aOHynedVaxYEdra2rCzs0P37t2V3psll5k6NWTIEOjo6MDMzAyNGzfGmTNnMpwnNXWPg3ITJkxAREQEli9fjr1798LW1lZqEOzZs2em17906VLUrFkT9vb20m8m3x+Tk5PRunVrzJo1Cz/88AP279+PWbNm4ciRI6hTpw4+fvyosKyrV6/ixx9/xPDhwxEUFCR1133w4AF++OEHbNiwAfv27UOfPn0wd+5cDBgwQK04VLl79y68vb1x+/Zt/PbbbwgMDES5cuXQs2dPzJkzRyn/xIkT8ejRI6xatQorVqzAvXv30LJlS5XvNFMlo9/6wYMH+PjxY5rHn/v37yM+Pl6tdRERUR6n0ee0iIjoq0lMTBSfPn0SpUuXFqNGjZLSAwIChJaWlggJCVHIv2PHDgFAHDhwQErz8fER5cuXV8gXEBAgAAgzMzPRunVrERQUJHbu3Cnc3d2FgYGBuHHjhkL+du3aCW9vb5GcnCyEECq776ny+PFjYWdnJ6pWrarQhWr8+PFCJpOJ69evK+Rv2LChUve91OLi4qSub2/fvlWYtm/fPqGrqytu3bolhEi7m4m8u07KMhVCiE2bNgkAYuPGjVJaetsaFRUlAEif6tWriydPnijkadOmjbCwsFCKtVatWgKAmDlzphBCiFevXgkDAwPh6+urkO/s2bMCgEL3vX79+gl9fX2VMZUpU0Y0atRI+q6rqysGDBiglO/cuXMKXcIOHjwoAIhFixYp5Pvll1/S7L43YMAAadv19PTE0qVLlfI8fvxYmJubiz/++ENKQxrd99JKHzNmjChZsqTU9Smt7mfqdEtLr/ueEF/2r5YtWyr8rnXq1BExMTFpLlOIL/s0AHH+/HmlaarqoCqHDh0SWlpaSvtl6dKlRePGjZXyP336VGEf+u+//4S2trbo0qVLuutZv369+OWXX8SBAwfE8ePHxaxZs4SVlZWws7NT6GYqhPp16urVq2LEiBFi165d4tSpU2L16tXCzc1NaGtri6CgoAy3PT1pHQflsdSuXVtpnvDwcKGtrS169+6d4fIz031vy5YtAoDYuXOnQrq8S3HKOuDk5CS0tbXF3bt3011/UlKS+Pz5s1i/fr3Q1tZW6FKdXve91PWyU6dOQl9fX6HrpxBCNG3aVBgZGYnXr18LIf6/3Jo1a6aQ76+//kpzH05J3d9afuzasmWL0jJmzpwpAIinT5+muy4iIsof+KQUEVEBkZiYiJkzZ6JcuXLQ09ODjo4O9PT0cO/ePdy5c0fKt2/fPlSoUAGVKlVCYmKi9GncuLHS6HWqJCcnAwCKFSuGnTt3onHjxmjbti2CgoKgpaWl8F/1nTt3Yu/evVi5cqVSl6r0xMbGolmzZhBCYNu2bQpdqIKDg1G+fHl4eHgozJPRC5vj4+PRtm1bPHr0CNu3b1cYAfDNmzcYMGAAxo8fr/aLlbt06aLwvUOHDtDR0UFwcLBa89vY2CAkJARnzpzBypUrERsbi7p16yqMDDh06FC8efMG3bt3x3///Ydnz55hypQpOHfuHID/71p2/vx5xMfHK8Xk7e0NJycnpXWn91uknqZOXvk2p15/er/JxIkTERISgv3796N3794YOnQofv31V4U8AwcOhIeHB/r165fmctJz6dIlLFy4EH/88UeWXpSfGZ8/f0bHjh1x/fp1rFy5EqdOncK6devw5MkTNGzYUOnl/nKJiYlYt24dypcvjxo1amRp3VevXkWHDh1Qo0YNBAQEKE1X5zc8cuQIkpKSMGTIkHTX1a1bN0ycOBFNmzZF3bp1MX78eBw8eBAvXrxQqPuZqVOVK1fGwoUL0aZNG9SqVQu9evXCuXPn4ODggHHjxqU7b2rqHgflVA0W4OTkhMTExGx1W1Rl3759sLCwQMuWLRWOvZUqVYK9vb3Ssdfd3V3hqTe5a9euoVWrVrC2toa2tjZ0dXXRvXt3JCUlZarLbErHjx9H/fr1Ubx4cYX0nj174sOHD0pPWbVq1UopVgAqn6pLKbO/dWaOVURElD9x9D0iogJi9OjRWLJkCcaPHw8fHx9YWlpCS0sLffv2VegW8uzZM9y/f1/lO2kAKAxtror83U8NGjRQeD+Pg4MDPDw8cPXqVQBfRjsbMmQIhg0bBkdHR7x+/RoApNH5Xr9+DV1dXRgbGyss/9WrV2jYsCGePHmC48ePo2TJkgrTY2Ji4OLiohRXyhHLUktISICvry/OnDmDffv2oXr16grTJ02aBF1dXQwdOlSK8927dwC+dHd8/fo1zM3NFW6CUq9PR0cH1tbWiImJSTOO1PmrVq0K4EvXryZNmsDFxQWzZs3CokWLAAD169fHmjVrMGbMGLi6ugIAypUrh+nTp2PixInSu6bk61RVBqnTrK2tER8fjw8fPsDIyEhhWmxsLDw9PRXyqtqe2NhYAJBGY4yJiZG2P711p1SiRAnpHUPNmjUD8KUrVY8ePVCkSBHs2LEDQUFBOHPmjFKDzqdPn/D69WsYGxunuR8DX0bka9u2LapWrSr9rvIuP3FxcdDX15dGxMuuP//8EwcPHkRISIj0u9aqVQvfffcdXF1dsXDhQvj5+SnNd+DAAURHR6vsuqiOa9euoWHDhihdujQOHDig1N1T3d9Q/k6jrIzIVq1aNZQpUwYXLlyQ0rJSp1KysLBAixYtsHz5cnz8+FHtRkV1j4NyDg4OmdzarHv27Blev34NPT09ldNTH3tVxRYREYFatWqhbNmyWLRoEZydnWFgYIBLly5hyJAhKrdRHTExMSrX5+joKE1PKXVdl+93WVm/qt9avvy09l2ZTCa9r42IiPI3NkoRERUQGzduRPfu3TFz5kyF9JcvXypcvNvY2MDQ0FBp2PiU09Oj6h0fckII6emdly9f4tmzZ5g3bx7mzZunlNfS0hKtW7dWeLH2q1ev0KBBAzx8+BDHjh1TuS5ra2tER0crpatKA740SLVp0wbBwcH4+++/Ub9+faU8oaGhCA8PV9mI0qNHDym2lOUYHR2t8ALyxMRExMTEqHxhuzqKFSsGR0dHpScdevTogS5duuDevXvQ1dVFqVKlEBAQAJlMhlq1agH4/xvEtMrF2dlZ+i5/l9StW7cUGueio6Px8uVLhadaKlasqPJF+fI0eV5ra2uV25/Wb6JKtWrVsHz5cvz3338oUqQIQkNDkZiYqPLpoZUrV2LlypXYtWsX2rRpk+Yyb9++jdu3b2P79u1K01xdXeHh4YHr16+rHWN6rl+/Dm1tbaV3PpUsWRLW1tYK725K6c8//4Senh66deuW6XVeu3YNDRo0gJOTEw4fPqz0knXgy2+4ZcsWJCYmKrxXKvVvKH/R/uPHj5WellFHyroPZK1OqVomkLknYtQ9Dsrl5tM2NjY2sLa2RlBQkMrpqRtIVcW2e/duvH//HoGBgQpPQWZ3P7a2tlZ4SlPu6dOnADI+L2RX6t/a1dUVhoaGaR5/SpUqleHgAURElD+wUYqIqICQyWRKT0ns378fT548QalSpaS0Fi1aYObMmbC2tlb5xFFGqlevjmLFiuHw4cNISkqSnpZ6+vQpbty4IXXZsre3V9mVbdasWTh58iQOHjyocKMjb5D677//cOTIEVSuXFnl+uvWrYs5c+bgxo0bCl34Nm/erJRX/oTU8ePHERgYiMaNG6tc5sKFC6WnOeSuX7+OUaNGYdq0afDx8VHo7gcAmzZtUniq6K+//kJiYiLq1Kmjch0ZuX//Ph4/fqzULQb48lSVm5sbgC/dolasWIHWrVtLN6U1atSAgYEBNm3apNAd6dy5c3j06JFCo1STJk1gYGCAtWvXKjRKyUexS9nI4+vri8GDB+PixYtS3sTERGzcuBHVq1eXnqKQ/yabNm3C8OHDpflV/SZpCQ4OhpaWlvRkXM+ePVWWZd26ddGmTRuMGDEiw25hqva/tWvXYt26ddi9e7dCo2J2OTo6IikpCSEhIQrl+u+//yImJkblE0jR0dE4cOAA2rZtm+nGzOvXr6NBgwYoVqwYjhw5kuZImL6+vli5ciV27twpjewHAOvWrYOjo6MUa6NGjaCtrY1ly5YpjLaojgsXLuDevXsKv31W6lRKr169wr59+1CpUqVMNT6oexz8mvT19VU+MdSiRQts3boVSUlJSk9rqkveaJNyG4UQWLlypdpxqFK/fn3s2rULT58+leo1AKxfvx5GRkZZ7lqqDlW/tY6ODlq2bInAwEDMmTNHarCLiIhAcHAwRo0a9dXiISKi3MVGKSKiAqJFixZYu3YtvvnmG7i7u+PKlSuYO3eu0s3wyJEjsXPnTtSuXRujRo2Cu7s7kpOTERERgcOHD2PMmDHp3jBpaWlhwYIF6NChA1q3bo1Bgwbh/fv3mD59OvT09DBhwgQAkEbkS23t2rXQ1tZWmPbx40c0btwY165dw8KFC5GYmKjQFahIkSJS97WRI0di9erVaN68OWbMmAE7Ozts2rQJ//zzj9K62rdvj4MHD2LSpEmwtrZWWKaZmRnKlSsHAKhUqVKa21u+fHmV2xEYGAgdHR00bNgQt2/fxpQpU+Dh4YEOHTqkuSzgy4h5o0aNQvv27VGyZEloaWnh1q1bWLBgAaytrTF27Fgp7/PnzzFv3jzUrFkTpqam+OeffzBnzhxoaWlhyZIlUj5LS0uMHTsWM2bMQN++ffH9998jMjIS06ZNU3pSxcrKCpMnT8aUKVNgZWWFRo0aISQkBNOmTUPfvn2lMgG+dH9bsmQJvv/+e8yaNQu2trZYunQp7t69i6NHj0r5GjVqhNq1a2PcuHF4//49qlatirNnz2LDhg1K29+/f3+YmZmhWrVqsLOzw8uXL7F9+3Zs27YNP/74o/TEjrOzs0JjWkpFixZVq/FPVR75e3tq1qyp1tMfL168wMmTJwH8/9NFBw8eRJEiRVCkSBH4+PgAAHr16oUFCxagXbt2mDx5MsqWLYv//vsPM2fOhLGxMQYOHKi07HXr1iExMTHTI/3dvXtXGs3vl19+wb1793Dv3j1puqurq1SOTZs2RcOGDTFo0CDExcWhVKlS2LJlC4KCgrBx40apUdnZ2RkTJ07E9OnT8fHjR3Tu3Bnm5uYICwvDy5cv4e/vDwDw8PBA165d4ebmJnUbmzt3Luzt7RXeCZSZOvXDDz+gRIkSqFq1KmxsbHDv3j3MmzcPz549w9q1azNVNuoeB9Pz6NEjuLq6okePHll6r1TFihURGBiIZcuWwdPTE1paWqhatSo6deqETZs2oVmzZhgxYgSqVasGXV1dPH78GMHBwWjdujV8fX3TXXbDhg2hp6eHzp07Y9y4cYiPj8eyZcvw6tUrteNQxc/PD/v27UPdunUxdepUWFlZYdOmTdi/fz/mzJmj8im8rMjMb+3v749vv/0WLVq0wE8//YT4+HhMnToVNjY2GDNmTI7EQ0REeYAm37JOREQ559WrV6JPnz7C1tZWGBkZie+++06cPn1a+Pj4KIy+JoQQ7969E5MnTxZly5YVenp6wtzcXFSsWFGMGjVKREdHS/nSG/lr9+7d4ttvvxUGBgbC3NxctGrVSty+fTvDOFWNSPfw4UOFEctSf3r06KGQPywsTDRs2FAYGBgIKysr0adPH/H3338rjb6X3jJTl0lqGY2+d+XKFdGyZUthYmIiTE1NRefOncWzZ88y3Nbo6GjRtWtX4erqKoyMjISenp4oWbKkGDhwoNLIVzExMaJRo0aiSJEiQldXV5QoUUIMGzZM5QhxycnJIiAgQBQvXlzo6ekJd3d3sXfvXpW/vxBCLFq0SJQpU0bo6emJEiVKCD8/P/Hp0yelfNHR0aJ79+7CyspKGBgYiBo1aogjR44o5Xv9+rXo3bu3sLCwEEZGRqJhw4bin3/+URrla/Xq1aJWrVrCxsZG6OjoCAsLC+Hj4yM2bNigtExVkMnR91LL7Oh78v1AnX3o3r17olu3bsLZ2Vno6+uLEiVKiI4dO6ZZL8qUKSOcnZ2lkSlVUVUH16xZk+6+vWbNGoX8b9++FcOHDxf29vbSvqFqVDMhvoyuJ6/XJiYmonLlygrL69SpkyhVqpQwNjYWurq6wsnJSQwcOFCtkdDSqlMBAQGiUqVKwtzcXGhra4siRYoIX19fcenSpQyXmZq6x8G0YhHi/49HqY87qqjab2JjY0X79u2FhYWFkMlkIuXl9ufPn8Wvv/4qPDw8pDL+5ptvxIABA8S9e/ekfE5OTqJ58+Yq17l3715p/qJFi4off/xRGgEz5fEvvThS10shhLh165Zo2bKlMDc3F3p6esLDw0NpX0qr3ORlljp/apn9rS9fvizq168vjIyMhJmZmWjTpo24f/9+uusgIqL8RSbE/zpxExERERERERER5RKtjLMQERERERERERHlLL5TioiIiIjytOTkZCQnJ6ebJ+XogkRERJQ/8EkpIiIiIsrTfv75Z+jq6qb7CQ8P13SYRERElEl8pxQRERER5WlPnz7F06dP083j7u4OPT29XIqIiIiIcgIbpYiIiIiIiIiIKNex+x4REREREREREeU6NkoREREREREREVGuY6MUERERERERERHlOjZKERERERERERFRrmOjFBERERERERER5To2ShERERERERERUa5joxQREREREREREeU6NkoREREREREREVGuY6MUERERERERERHlOjZKERERERERERFRrmOjFBERERERERER5To2ShERERERERERUa5joxQREREREREREeU6NkoREREREREREVGuY6MUERERERERERHlOjZKERERERERERFRrmOjFBERERERERER5To2ShERERERERERUa5joxQREREREREREeU6NkoREREREREREVGuY6MUERERERERERHlOjZKERERERERERFRrmOjFBERERERERER5boca5Rau3YtZDKZys/YsWNzajWUjmnTpkEmkymkOTs7o2fPnplazrlz5zBt2jS8fv06U/OlXteJEycgk8mwY8eOTC0nPR8+fMC0adNw4sQJpWnyfTA8PDzH1pefpa6TBgYGsLe3R926dREQEIDnz59rOkTMnDkTu3fvVkqX7zuqfmdNqVOnDurUqSN9Dw8Ph0wmw9q1azO1nM2bN2PhwoWZmkfVuuT1/eXLl5laVnrCwsIwbdo0lXWoZ8+ecHZ2zrF1UcZS1mFVdUEIgVKlSkEmkynsmzkhreN5XqqTmt4n0ztXpj5eEFH+d/HiRfj6+qJEiRLQ19eHnZ0dvLy8MGbMGIV8S5cuzfS1QWppXR9R3pOZ67HcvC8jyk90cnqBa9aswTfffKOQ5ujomNOrITXt2rULZmZmmZrn3Llz8Pf3R8+ePWFhYfFV15VZHz58gL+/PwAoXfA3b94c58+fh4ODw1eNIb+R18nPnz/j+fPnOHPmDGbPno1ff/0V27ZtQ4MGDTQW28yZM9G+fXu0adNGIb1KlSo4f/48ypUrp5nA1ODg4IDz58/D1dU1U/Nt3rwZoaGhGDly5FdfV2aFhYXB398fderUUbrZnzJlCkaMGPFV10+qmZqa4s8//1Q65p08eRIPHjyAqanpV48hP9TJ3JbeuXLp0qWaCYqIvor9+/ejVatWqFOnDubMmQMHBwdERUXh8uXL2Lp1K+bNmyflXbp0KWxsbDLd+JBSWtdHlL/l5n0ZUX6S441SFSpUQNWqVdXK+/nzZ8hkMujo5HgY9D+VK1f+6uv4+PEjDA0Nc2Vd6SlSpAiKFCmi0RjyotR1sl27dhg1ahS+++47tG3bFvfu3YOdnV2215OUlITExETo6+tne1lmZmaoUaNGtpfzNenr63/1GFOWqabL42s3iFHaOnbsiE2bNmHJkiUKF7N//vknvLy8EBcX99VjyA91Mrs+fPgAIyOjHFkWG++ICpY5c+bAxcUFhw4dUrhv6dSpE+bMmaPByCg/0fS9Uko5ec4jyq5ce6eU/NH/DRs2YMyYMShatCj09fVx//59AMDRo0dRv359mJmZwcjICDVr1sSxY8eUlrN//35UqlQJ+vr6cHFxwa+//qrUbS29bjUymQzTpk1TSLt37x5++OEH2NraQl9fH25ubliyZInK+Lds2YJJkybB0dERZmZmaNCgAe7evau0nqCgINSvXx/m5uYwMjKCm5sbAgICAAAbNmyATCbD+fPnleb7+eefoauri6dPn6ZbnqrKQZXUj4kmJydjxowZKFu2LAwNDWFhYQF3d3csWrQIwJdHUH/88UcAgIuLi1LXEWdnZ7Ro0QKBgYGoXLkyDAwMpCeX0nokNT4+HqNHj4a9vT0MDQ3h4+ODa9euKeRJq6tDyu4Z4eHhUqOTv7+/FJt8nWl131u9ejU8PDxgYGAAKysr+Pr64s6dO0rrMTExwf3799GsWTOYmJigePHiGDNmDBISElSWbX5WokQJzJs3D2/fvsUff/whpavzOwD/X8fmzJmDGTNmwMXFBfr6+ggODkZ8fDzGjBmDSpUqwdzcHFZWVvDy8sLff/+tsEyZTIb3799j3bp10m8pX3daXYX27NkDLy8vGBkZwdTUFA0bNlSqR/Ljwe3bt9G5c2eYm5vDzs4OvXv3xps3bzIsGyEE5syZAycnJxgYGKBKlSo4ePCgUj5Vx5kXL16gf//+KF68OPT19VGkSBHUrFkTR48elcp3//79ePTokULXyozKNL1jWmRkJNq2bQszMzOYm5uja9euePHihVJZpz7uAYp1du3atfj+++8BAHXr1pVik69TVVep+Ph4TJgwAS4uLtDT00PRokUxZMgQpUfM5ceNoKAgVKlSBYaGhvjmm2+wevXqNH4FSqlz584AgC1btkhpb968wc6dO9G7d2+V83z69AkzZszAN998I+2LvXr1Uto3Pn/+jHHjxsHe3h5GRkb47rvvcOnSJaXlqaqTly9fRqdOneDs7AxDQ0M4Ozujc+fOePTokcK88mNzcHAwBg0aBBsbG1hbW6Nt27YZnutSLqNs2bLSOXr9+vVqxQiorqvyY/6tW7fQqFEjmJqaon79+gCAI0eOoHXr1ihWrBgMDAxQqlQpDBgwQKFrRkbnSlXH0tjYWAwePBhFixaFnp4eSpYsiUmTJimdY2QyGYYOHYoNGzbAzc0NRkZG8PDwwL59+9QqKyLKeTExMbCxsVH5j3Qtrf+/nXJ2dsbt27dx8uRJ6bggP3fmxPURAERHR2PAgAEoVqwY9PT04OLiAn9/fyQmJma4HcePH0edOnVgbW0NQ0NDlChRAu3atcOHDx+kPNk9f6S+H1D1ehEg7ev2bdu2wcvLC8bGxjAxMUHjxo2V7hsyc92ekJCAn3/+GW5ubjAwMIC1tTXq1q2Lc+fOSXmEEFi6dCkqVaoEQ0NDWFpaon379vjvv/8yLFO5Z8+eZXjdmdP3ZcnJyZgzZ470W9na2qJ79+54/Pixwnrr1KmDChUq4NSpU/D29oaRkRF69+6NPn36wMrKSuH3l6tXrx7Kly+v9vYTZUeOP6Ik/8++wkpSHMAnTJgALy8vLF++HFpaWrC1tcXGjRvRvXt3tG7dGuvWrYOuri7++OMPNG7cGIcOHZIuFI8dO4bWrVvDy8sLW7duRVJSEubMmYNnz55lOd6wsDB4e3tLN+n29vY4dOgQhg8fjpcvX8LPz08h/8SJE1GzZk2sWrUKcXFxGD9+PFq2bIk7d+5AW1sbwJf/Xvfr1w8+Pj5Yvnw5bG1t8e+//yI0NBTAl/96jxs3DkuWLIGXl5e07MTERPzxxx/w9fVNt8tjdsphzpw5mDZtGiZPnozatWvj8+fP+Oeff6SbyL59+yI2NhaLFy9GYGCg1BUu5X99r169ijt37mDy5MlwcXGBsbFxuuucOHEiqlSpglWrVuHNmzeYNm0a6tSpg2vXrqFkyZIZxizn4OCAoKAgNGnSBH369EHfvn0BIN2nowICAjBx4kR07twZAQEBiImJwbRp0+Dl5YWQkBCULl1ayvv582e0atUKffr0wZgxY3Dq1ClMnz4d5ubmmDp1qtpx5hfNmjWDtrY2Tp06leVl/PbbbyhTpgx+/fVXmJmZoXTp0khISEBsbCzGjh2LokWL4tOnTzh69Cjatm2LNWvWoHv37gCA8+fPo169eqhbty6mTJkCAOk+0rx582Z06dIFjRo1wpYtW5CQkIA5c+agTp06OHbsGL777juF/O3atUPHjh3Rp08f3Lp1CxMmTACADBtC/P394e/vjz59+qB9+/aIjIxEv379kJSUhLJly6Y7b7du3XD16lX88ssvKFOmDF6/fo2rV68iJiYGwJdH+vv3748HDx5g165dapdpenx9fdGhQwcMHDgQt2/fxpQpUxAWFoaLFy9CV1c33XlTat68OWbOnImJEydiyZIlqFKlCoC0n5ASQqBNmzY4duwYJkyYgFq1auHmzZvw8/PD+fPncf78eYWn5m7cuIExY8bgp59+gp2dHVatWoU+ffqgVKlSqF27ttpxFkZmZmZo3749Vq9ejQEDBgD40kClpaWFjh07Kr2jLDk5Ga1bt8bp06cxbtw4eHt749GjR/Dz80OdOnVw+fJlGBoaAgD69euH9evXY+zYsWjYsCFCQ0PRtm1bvH37NsO4wsPDUbZsWXTq1AlWVlaIiorCsmXL8O233yIsLAw2NjYK+fv27YvmzZtj8+bNiIyMxI8//oiuXbvi+PHj6a5n7dq16NWrF1q3bo158+ZJ55GEhASFm8HM+vTpE1q1aoUBAwbgp59+kq5dHjx4AC8vL/Tt2xfm5uYIDw/H/Pnz8d133+HWrVvQ1dVV61yZUnx8POrWrYsHDx7A398f7u7uOH36NAICAnD9+nXs379fIf/+/fsREhKCn3/+GSYmJpgzZw58fX1x9+7dTJ03iShneHl5YdWqVRg+fDi6dOmCKlWqqDzH7tq1C+3bt4e5ubnUjVd+LsyJ66Po6GhUq1YNWlpamDp1KlxdXXH+/HnMmDED4eHhWLNmTZrbEB4ejubNm6NWrVpYvXo1LCws8OTJEwQFBeHTp08wMjLKtfNHWmbOnInJkyejV69emDx5Mj59+oS5c+eiVq1auHTpksIxVp3r9sTERDRt2hSnT5/GyJEjUa9ePSQmJuLChQuIiIiAt7c3AGDAgAFYu3Ythg8fjtmzZyM2NhY///wzvL29cePGDbV6FGTlujO792WDBg3CihUrMHToULRo0QLh4eGYMmUKTpw4gatXryqch6OiotC1a1eMGzcOM2fOhJaWFiwsLLB69Wps3rxZuq8CvtwfBwcHKz2kQfTViByyZs0aAUDl5/PnzyI4OFgAELVr11aY7/3798LKykq0bNlSIT0pKUl4eHiIatWqSWnVq1cXjo6O4uPHj1JaXFycsLKyEik35eHDhwKAWLNmjVKcAISfn5/0vXHjxqJYsWLizZs3CvmGDh0qDAwMRGxsrBBCSPE3a9ZMId9ff/0lAIjz588LIYR4+/atMDMzE999951ITk5Os7z8/PyEnp6eePbsmZS2bds2AUCcPHkyzfkyUw5CCOHk5CR69OghfW/RooWoVKlSusufO3euACAePnyoNM3JyUloa2uLu3fvqpyWcl3yMqtSpYpCWYSHhwtdXV3Rt29fKc3Hx0f4+PgoLbNHjx7CyclJ+v7ixQul31BOvg/K43716pUwNDRU+s0iIiKEvr6++OGHHxTWA0D89ddfCnmbNWsmypYtq7Su/EBeHiEhIWnmsbOzE25ubtJ3dX8HeR1zdXUVnz59SjeOxMRE8fnzZ9GnTx9RuXJlhWnGxsYK+4ycfN8JDg4WQnw5Hjg6OoqKFSuKpKQkKd/bt2+Fra2t8Pb2ltL8/PwEADFnzhyFZQ4ePFgYGBikWy9fvXolDAwMhK+vr0L62bNnBQCFslF1nDExMREjR45Mc/lCCNG8eXOFsky9PFVlqmpd8u0cNWqUQt5NmzYJAGLjxo1SWlp1JnWd3b59u0K5p5R6HwgKClJZzvLj2IoVKxTWY2BgIB49eiSlffz4UVhZWYkBAwYorYu+SFmH5XUiNDRUCCHEt99+K3r27CmEEKJ8+fIK++aWLVsEALFz506F5YWEhAgAYunSpUIIIe7cuZPuPqTqeK5q35BLTEwU7969E8bGxmLRokVK2zF48GCF/HPmzBEARFRUVJrLlNf9tM4jKffJtGJUVX/kx/zVq1enuW4hhEhOThafP38Wjx49EgDE33//LU1L71yZ+li6fPlyleeY2bNnCwDi8OHDUhoAYWdnJ+Li4qS06OhooaWlJQICAtKNl4i+jpcvX4rvvvtOurfR1dUV3t7eIiAgQLx9+1Yhb+pjclqycn00YMAAYWJionA+FUKIX3/9VQAQt2/fTnN9O3bsEADE9evX08zzNc4f8uuV1FJft0dERAgdHR0xbNgwhXxv374V9vb2okOHDlKautft69evFwDEypUr09zm8+fPCwBi3rx5CumRkZHC0NBQjBs3Ls15U26fOtedOXlfJv8NUp9bL168KACIiRMnSmk+Pj4CgDh27JjS8n18fJRiGDRokDAzM1Pat4m+lhzvvrd+/XqEhIQofFI+KdWuXTuF/OfOnUNsbCx69OiBxMRE6ZOcnIwmTZogJCQE79+/x/v37xESEoK2bdvCwMBAmt/U1BQtW7bMUqzx8fE4duwYfH19YWRkpLD+Zs2aIT4+HhcuXFCYp1WrVgrf3d3dAUDqrnDu3DnExcVh8ODBKh9VlRs0aBAAYOXKlVLa77//jooVK6b71EB2y6FatWq4ceMGBg8ejEOHDmXpXSTu7u4oU6aM2vl/+OEHhbJwcnKCt7c3goODM73uzDh//jw+fvyo1KWwePHiqFevnlL3UJlMplSG7u7uSl1RChIhRLbmb9Wqlcr/FG7fvh01a9aEiYkJdHR0oKuriz///FOp26S67t69i6dPn6Jbt24KT0aYmJigXbt2uHDhgtKjx6rqanx8fLqjDp4/fx7x8fHo0qWLQrq3tzecnJwyjLNatWpYu3YtZsyYgQsXLuDz58/qbJ5S3Jl5wil1rB06dICOjs5Xr1/yp1tS16/vv/8exsbGSvWrUqVKKFGihPTdwMAAZcqUKdD1Kyf5+PjA1dUVq1evxq1btxASEpJm1719+/bBwsICLVu2VDivVapUCfb29tJj//J9JK19KCPv3r3D+PHjUapUKejo6EBHRwcmJiZ4//69yrqe0flTFXndT+s8kl2pr0kA4Pnz5xg4cCCKFy8uHb/k9T+rx7Djx4/D2NgY7du3V0iX15/U9aVu3boKL7C3s7ODra0t6wuRhlhbW+P06dMICQnBrFmz0Lp1a/z777+YMGECKlasqPZIuNm9Ptq3bx/q1q0LR0dHheN706ZNAXwZACMtlSpVgp6eHvr3749169ap7JqWW+cPVQ4dOoTExER0795dYd0GBgbw8fFR6pqtznX7wYMHYWBgkOb5Ur7NMpkMXbt2VVivvb09PDw81B51NivXndm5L5P/Bqmvw6pVqwY3Nzel84qlpSXq1auntJwRI0bg+vXrOHv2LAAgLi4OGzZsQI8ePWBiYqJ2PETZkeONUm5ubqhatarCJ6XUI6PJu5y1b98eurq6Cp/Zs2dDCIHY2Fi8evUKycnJsLe3V1qnqjR1xMTEIDExEYsXL1Zad7NmzQBA6SRjbW2t8F3+SO7Hjx8BQOpvXaxYsXTXbWdnh44dO+KPP/5AUlISbt68idOnT2Po0KHpzpfdcpgwYQJ+/fVXXLhwAU2bNoW1tTXq16+Py5cvZzivXGZHt0srVnmXpq9FvnxV8To6Oiqt38jISKGhD/jy+8bHx3+9IDXo/fv3iImJydbomKrKNjAwEB06dEDRokWxceNGnD9/XrqBzmpZZvRbJicn49WrVwrpGdXV9NaT1fq1bds29OjRA6tWrYKXlxesrKzQvXt3REdHZzivXHbrl46ODqytrXOlfuno6Ch1n5XJZCrrd+rfA/jym6T3e9D/k8lk6NWrFzZu3Ijly5ejTJkyqFWrlsq8z549w+vXr6Gnp6d0bouOjpbOa2nt7/J9KCM//PADfv/9d/Tt2xeHDh3CpUuXEBISgiJFiqj8XTVRJ9NjZGSk1GU4OTkZjRo1QmBgIMaNG4djx47h0qVL0j+osrq/xsTEwN7eXumfVba2ttDR0WF9IconqlativHjx2P79u14+vQpRo0ahfDwcLVedp4T10fPnj3D3r17lY7t8nf/pNc45urqiqNHj8LW1hZDhgyBq6srXF1dpfcXyZefG+ePtLYNAL799luldW/btk1p29S5bn/x4gUcHR3T7er97NkzCCFgZ2entN4LFy6o3eCYlXNcdu7LMnufk9b1ZevWreHs7Cx11Vu7di3ev3+PIUOGZBgDUU7J9WHvUl+Qyfu6Ll68OM2Rfezs7KSR+lTd3KVOkx+gUr/oLnXltLS0hLa2Nrp165ZmxXNxcUlna5TJb9BSv2BOlREjRmDDhg34+++/ERQUBAsLC6X/OKRmaWmpdjmooqOjg9GjR2P06NF4/fo1jh49iokTJ6Jx48aIjIxUaxSG9J4AUyWtWFMevA0MDFS+hFrdE4Eq8uVHRUUpTXv69KnS+04Km/379yMpKUnh5ZmZ/R1U7QsbN26Ei4sLtm3bpjA9Oy+Mz+i31NLSgqWlZZaXn3o9ae2zqV/0nZqNjQ0WLlyIhQsXIiIiAnv27MFPP/2E58+fIygoSK0YslK/ihYtKn1PTExETEyMQv3S19dXWf7ZabiytrZGYmIiXrx4odAwJYRAdHQ0vv322ywvm1Tr2bMnpk6diuXLl+OXX35JM5/8ReJp7XPyJ3BS7u+q9qH0vHnzBvv27YOfnx9++uknKV3+zpScklGdTCmtc39mjl+hoaG4ceMG1q5dix49ekjp8kFZssra2hoXL16EEEJhvc+fP0diYmKhPx8R5Ue6urrw8/PDggULpPfGpicnro9sbGzg7u6e5jkgo3801qpVC7Vq1UJSUhIuX76MxYsXY+TIkbCzs0OnTp2+yvkj5bE55bsmUx+b5cfBHTt2qPV0ujqKFCmCM2fOIDk5Oc2GKRsbG8hkMpw+fVrlCNI5Map0WrJzX5by2jj1wxCq7nPSur7U0tLCkCFDMHHiRMybNw9Lly5F/fr1M3yPKlFOyrXR99JSs2ZNWFhYICwsTOkJK/lHT08PxsbGqFatGgIDAxVawN++fYu9e/cqLNPOzg4GBga4efOmQnrq0S2MjIxQt25dXLt2De7u7irXndnWfm9vb5ibm2P58uUZdo3y9PSEt7c3Zs+ejU2bNqFnz54ZvjQ8M+WQEQsLC7Rv3x5DhgxBbGysNPqFOi37mbFlyxaFsnj06BHOnTun0Bji7OyMf//9V+HEHBMTozAyRmZj8/LygqGhITZu3KiQ/vjxYxw/flx6gX5hFBERgbFjx8Lc3Fx6cTKg/u+QHplMBj09PYWTX3R0tFL9A9T/z3/ZsmVRtGhRbN68WWFfev/+PXbu3CmNyJddNWrUgIGBATZt2qSQfu7cuUx3mylRogSGDh2Khg0b4urVq1J6Tj/tkDrWv/76C4mJiUr1K/Xx8Pjx43j37p1CWmbql7z+pK5fO3fuxPv37wt1/fpaihYtih9//BEtW7ZUaDBJrUWLFoiJiUFSUpLK85r8QlO+j6S1D6VHJpNBCKF0sb5q1SokJSVlYetUK1u2LBwcHNI8j6QkbzROva/v2bNH7fXJj1uptyvlKKVyma0v7969w+7duxXS5aMIsr4Q5W2q/ikG/H+X3pSNQWmd53Pi+qhFixYIDQ2Fq6uryuO7uk+/a2tro3r16tLTMfLrlK9x/kjr2Jz6vqVx48bQ0dHBgwcP0rwnzKymTZsiPj5e5ejFci1atIAQAk+ePFG5zooVK2Z6vVmR2fsyeVe81NdhISEhuHPnTqbOK3379oWenh66dOmCu3fvZthzhyin5fqTUqmZmJhg8eLF6NGjB2JjY9G+fXvY2trixYsXuHHjBl68eIFly5YBAKZPn44mTZqgYcOGGDNmDJKSkjB79mwYGxsr/GdW3i949erVcHV1hYeHBy5duoTNmzcrrX/RokX47rvvUKtWLQwaNAjOzs54+/Yt7t+/j71792Y4KpCq7Zk3bx769u2LBg0aoF+/frCzs8P9+/dx48YN/P777wr5R4wYgY4dO0Imk2Hw4MFqrUPdclClZcuWqFChAqpWrYoiRYrg0aNHWLhwIZycnKRRvuQH30WLFqFHjx7Q1dVF2bJlFd5vkRnPnz+Hr68v+vXrhzdv3sDPzw8GBgbSqBTAl1HL/vjjD3Tt2hX9+vVDTEwM5syZo9S1wtTUFE5OTvj7779Rv359WFlZwcbGRuUTLBYWFpgyZQomTpyI7t27o3PnzoiJiYG/vz8MDAyURlYsqEJDQ6X+8c+fP8fp06exZs0aaGtrY9euXQpPuaj7O6SnRYsWCAwMxODBg6XR66ZPnw4HBwfcu3dPIW/FihVx4sQJ7N27Fw4ODjA1NVX5nxktLS3MmTMHXbp0QYsWLTBgwAAkJCRg7ty5eP36NWbNmpX1AkrB0tISY8eOxYwZM9C3b198//33iIyMxLRp0zLsKvTmzRvUrVsXP/zwA7755huYmpoiJCQEQUFBaNu2rcI2BwYGYtmyZfD09ISWllaWLrTkAgMDoaOjg4YNG0qj73l4eKBDhw5Snm7dumHKlCmYOnUqfHx8EBYWht9//x3m5uYKy6pQoQIAYMWKFTA1NYWBgQFcXFxUNs43bNgQjRs3xvjx4xEXF4eaNWtKo+9VrlwZ3bp1y/I2UdrU2dc7deqETZs2oVmzZhgxYgSqVasGXV1dPH78GMHBwWjdujV8fX3h5uaGrl27YuHChdDV1UWDBg0QGhoqjfyYHjMzM9SuXRtz586VjsEnT57En3/+CQsLixza2i91f/r06ejbt690Hnn9+rXKOmlvb48GDRogICAAlpaWcHJywrFjxxAYGKj2+r755hu4urrip59+ghACVlZW2Lt3L44cOaKUNzPnyu7du2PJkiXo0aMHwsPDUbFiRZw5cwYzZ85Es2bN0KBBg0yWDBHlpsaNG6NYsWJo2bIlvvnmGyQnJ+P69euYN28eTExMMGLECClvxYoVsXXrVmzbtg0lS5aEgYEBKlasmCPXRz///DOOHDkCb29vDB8+HGXLlkV8fDzCw8Nx4MABLF++PM1XiCxfvhzHjx9H8+bNUaJECcTHx0sjw8mPQV/j/NGsWTNYWVmhT58++Pnnn6Gjo4O1a9ciMjJSIZ+zszN+/vlnTJo0Cf/99x+aNGkCS0tLPHv2DJcuXYKxsTH8/f0z9bt17twZa9aswcCBA3H37l3UrVsXycnJuHjxItzc3NCpUyfUrFkT/fv3R69evXD58mXUrl0bxsbGiIqKwpkzZ1CxYkXpXcA5LTv3ZWXLlkX//v2xePFiaGlpoWnTptLoe8WLF8eoUaPUjsPCwgLdu3fHsmXL4OTklOX3NRNlWU69MT2jkb7ko+Js375d5fSTJ0+K5s2bCysrK6GrqyuKFi0qmjdvrpR/z549wt3dXejp6YkSJUqIWbNmqRzV4c2bN6Jv377Czs5OGBsbi5YtW4rw8HCVo1A9fPhQ9O7dWxQtWlTo6uqKIkWKCG9vbzFjxowM409rpL8DBw4IHx8fYWxsLIyMjES5cuXE7NmzlbY7ISFB6OvriyZNmqgsl7SoWw6pR3mYN2+e8Pb2FjY2NtK8ffr0EeHh4QrzTZgwQTg6OgotLS2F0YycnJxE8+bNVcaU1uh7GzZsEMOHDxdFihQR+vr6olatWuLy5ctK869bt064ubkJAwMDUa5cObFt2zalEb+EEOLo0aOicuXKQl9fX2GEj9SjeMitWrVKKitzc3PRunVrpdFJevToIYyNjZViSmvEkPwg9YiYenp6wtbWVvj4+IiZM2eK58+fq5xPnd9Bvt/PnTtX5TJmzZolnJ2dhb6+vnBzcxMrV65UWZbXr18XNWvWFEZGRgqj26U1itbu3btF9erVhYGBgTA2Nhb169cXZ8+eVcgjX8+LFy9UloeqkbJSSk5OFgEBAaJ48eJCT09PuLu7i7179yqNppW67sfHx4uBAwcKd3d3YWZmJgwNDUXZsmWFn5+feP/+vTRfbGysaN++vbCwsBAymUwqk/TKNL3R965cuSJatmwpTExMhKmpqejcubPCqJ5CfDnOjBs3ThQvXlwYGhoKHx8fcf36daU6K4QQCxcuFC4uLkJbW1thnarq4sePH8X48eOFk5OT0NXVFQ4ODmLQoEHi1atXCvnSOm6kNdojfaHOCJpCqB7p6fPnz+LXX38VHh4ewsDAQJiYmIhvvvlGDBgwQNy7d0/Kl5CQIMaMGSNsbW2FgYGBqFGjhjh//nyax/OUdfLx48eiXbt2wtLSUpiamoomTZqI0NBQpXnT2g51RvSTW7VqlShdurTQ09MTZcqUEatXr1a5T0ZFRYn27dsLKysrYW5uLrp27SouX76scvQ9Vcd8IYQICwsTDRs2FKampsLS0lJ8//33IiIiQuX1Q1rnSlX7dkxMjBg4cKBwcHAQOjo6wsnJSUyYMEHEx8cr5AMghgwZohSXqvpKRLlj27Zt4ocffhClS5cWJiYmQldXV5QoUUJ069ZNhIWFKeQNDw8XjRo1EqampgKAwnEqu9dHQnwZiXr48OHCxcVF6OrqCisrK+Hp6SkmTZok3r17l+Y2nD9/Xvj6+gonJyehr68vrK2thY+Pj9izZ49Cvpw+fwghxKVLl4S3t7cwNjYWRYsWFX5+fmLVqlUqr8t2794t6tatK8zMzIS+vr5wcnIS7du3F0ePHpXyZOa6/ePHj2Lq1KnSOcTa2lrUq1dPnDt3TiHf6tWrRfXq1YWxsbEwNDQUrq6uonv37irvWVStU53rzpy+L0tKShKzZ88WZcqUEbq6usLGxkZ07dpVREZGKszv4+Mjypcvn+52nDhxQgAQs2bNSjcf0dcgEyKbw2/lAdOmTYO/v3+2RxLThL1796JVq1bYv3+/9HJ1IiIiIiKi/MbZ2Rl16tRJt8sc5T1jxozBsmXLEBkZmeWX1RNllca77xVWYWFhePToEcaMGYNKlSpJQ7kSERERERERfW0XLlzAv//+i6VLl2LAgAFskCKNYKOUhgwePBhnz55FlSpVsG7dukyPuEVERERERESUVfLBglq0aIEZM2ZoOhwqpApE9z0iIiIiIiIiIspftDQdABERERERERERFT5slCIiIiIiIiIiolzHRikiIiIiIiIiIsp1bJQiIiIiIiIiIqJcp5HR95KTk/H06VOYmppy1DnKdUIIvH37Fo6OjtDSKjztsqx3pGmse6x7pBmse6x7REREuU3d6w+NNEo9ffoUxYsX18SqiSSRkZEoVqyYpsPINax3lFew7hFpBuseERER5baMrj800ihlamoK4EtwZmZmmgiBCrG4uDgUL15c2g8LC9Y70jTWPdY90oxCX/cWA2aGGg4mI1YZTI/V4LqJSGMC2mo6AqKsSwCwAMjw+kMjjVLyR6jNzMx4gU4aU9ge5We9o7yCdY9IMwpt3TMEzIw0HExGjDOYHq/BdRORxuhrOgCiHJDR9UfhebEAERERERERERHlGRp5UoqIiIgoI0nJApcexuL523jYmhqgmosVtLUK19M+GWEZERERUX6m0UapCn6HoKX/5Xnq8FnNNRkKUaEhr3esc0SUlwWFRsF/bxii3vx/vyUHcwP4tSyHJhUcNBhZ3sEyIiIiovyO3feIiIgoTwkKjcKgjVcVGlsAIPpNPAZtvIqg0CgNRZZ3sIyIiIioIGCjFBEREeUZSckC/nvDIFRMk6f57w1DUrKqHIUDy4iIiIgKCjZKERERUZ5x6WGs0tM/KQkAUW/icelhbO4FlcewjIiIiKigYKMUERER5RnP36bd2JKVfAURy4iIiIgKCjZKERERUZ5ha2qQo/kKIpYRERERFRRslCIiIqI8o5qLFRzMDSBLY7oMX0aYq+ZilZth5SksIyIiIioo2ChFREREeYa2lgx+LcsBgFKji/y7X8ty0NZKq0mm4GMZERERUUHBRikiIiLKU5pUcMCyrlVgb67Y/cze3ADLulZBkwoOGoos72AZERERUUGgo+kAiIiIiFJrUsEBDcvZ49LDWDx/Gw9b0y/d0fj0z/9jGREREVF+x0YpIiIiypO0tWTwcrXWdBh5GsuIiIiI8jN23yMiIiKiPGnp0qVwcXGBgYEBPD09cfr0aU2HRERERDmIjVJERERElOds27YNI0eOxKRJk3Dt2jXUqlULTZs2RUREhKZDIyIiohzCRikiIiIiynPmz5+PPn36oG/fvnBzc8PChQtRvHhxLFu2TNOhERERUQ5hoxQRERER5SmfPn3ClStX0KhRI4X0Ro0a4dy5cyrnSUhIQFxcnMKHiIiI8jY2ShERERFRnvLy5UskJSXBzs5OId3Ozg7R0dEq5wkICIC5ubn0KV68eG6ESkRERNnARikiIiIiypNkMpnCdyGEUprchAkT8ObNG+kTGRmZGyESERFRNuhoOgAiIiIiopRsbGygra2t9FTU8+fPlZ6ektPX14e+vn5uhEdEREQ5hE9KERERaUBSssD5BzH4+/oTnH8Qg6RkoemQiPIMPT09eHp64siRIwrpR44cgbe3t4aiIiIiopzGJ6WIiIjUFBAQgIkTJ2LEiBFYuHBhlpcTFBoF/71hiHoTL6U5mBvAr2U5NKngkAOREuV/o0ePRrdu3VC1alV4eXlhxYoViIiIwMCBAzUdGhEREeUQNkoRERGpISQkBCtWrIC7u3u2lhMUGoVBG68i9XNR0W/iMWjjVSzrWoUNU0QAOnbsiJiYGPz888+IiopChQoVcODAATg5OWk6NCIiIsoh7L5HRESUgXfv3qFLly5YuXIlLC0ts7ycpGQB/71hSg1SAKQ0/71h7MpH9D+DBw9GeHg4EhIScOXKFdSuXVvTIREREVEOylKj1Pv373M6DiJSA+sekWYMGTIEzZs3R4MGDTLMm5CQgLi4OIWP3KWHsQpd9lITAKLexOPSw9icCJuIiIiIKE/LUqOUnZ0devfujTNnzuR0PESUDtY9oty3detWXL16FQEBAWrlDwgIgLm5ufQpXry4NO3527QbpFJSNx8RERERUX6WpUapLVu24M2bN6hfvz7KlCmDWbNm4enTpzkdGxGlwrpHlLsiIyMxYsQIbNy4EQYGBmrNM2HCBLx580b6REZGStNsTdVbhrr5iIiIiIjysyw1SrVs2RI7d+7E06dPMWjQIGzZsgVOTk5o0aIFAgMDkZiYmNNxEhFY94hy25UrV/D8+XN4enpCR0cHOjo6OHnyJH777Tfo6OggKSlJaR59fX2YmZkpfOSquVjBwdwAsjTWJ8OXUfiquVh9nQ0iIiIiIspDsvWic2tra4waNQo3btzA/PnzcfToUbRv3x6Ojo6YOnUqPnz4kFNxElEKrHtEuaN+/fq4desWrl+/Ln2qVq2KLl264Pr169DW1s7U8rS1ZPBrWQ4AlBqm5N/9WpaDtlZazVZERERERAWHTnZmjo6Oxvr167FmzRpERESgffv26NOnD54+fYpZs2bhwoULOHz4cE7FSkT/w7pHlDtMTU1RoUIFhTRjY2NYW1srpaurSQUHLOtaBf57wxReem5vbgC/luXQpIJDtmIm+po+fvwIIQSMjIwAAI8ePcKuXbtQrlw5NGrUSMPRERERUX6TpUapwMBArFmzBocOHUK5cuUwZMgQdO3aFRYWFlKeSpUqoXLlyjkVJxGBdY+ooGhSwQENy9nj0sNYPH8bD1vTL132+IQU5XWtW7dG27ZtMXDgQLx+/RrVq1eHrq4uXr58ifnz52PQoEGaDpGIiIjykSw1SvXq1QudOnXC2bNn8e2336rMU7JkSUyaNClbwRGRItY9Is07ceJEjixHW0sGL1frHFkWUW65evUqFixYAADYsWMH7OzscO3aNezcuRNTp05loxQRERFlSpYapaKioqTHttNiaGgIPz+/LAVFRKqx7hFlzr///osTJ07g+fPnSE5OVpg2depUDUVFlH99+PABpqamAIDDhw+jbdu20NLSQo0aNfDo0SMNR0dERET5TZYapUxNTREVFQVbW1uF9JiYGNja2qocjYiIso91j0h9K1euxKBBg2BjYwN7e3vIZP/fNU4mk7FRiigLSpUqhd27d8PX1xeHDh3CqFGjAADPnz9XGGmSiIiISB1ZapQSQqhMT0hIgJ6eXrYCIqK0se4RqW/GjBn45ZdfMH78eE2HQlRgTJ06FT/88ANGjRqF+vXrw8vLC8CXp6b4PkMiIiLKrEw1Sv32228AvvyHedWqVTAxMZGmJSUl4dSpU/jmm2+yFIjzT/sBAOGzmmdpfqKC7GvWPaKC6tWrV/j+++81HQZRgdK+fXt89913iIqKgoeHh5Rev359+Pr6ajAyIiIiyo8y1Sglf7GlEALLly+Htra2NE1PTw/Ozs5Yvnx5zkZIRKx7RFnw/fff4/Dhwxg4cKCmQyEqUOzt7WFvb6+QVq1aNQ1FQ0RERPlZphqlHj58CACoW7cuAgMDYWlp+VWCIiJFrHtEmVeqVClMmTIFFy5cQMWKFaGrq6swffjw4RqKjCj/ev/+PWbNmoVjx46pHEDgv//+01BkRERElB9l6Z1SwcHBOR0HEamBdY9IfStWrICJiQlOnjyJkydPKkyTyWRslCLKgr59++LkyZPo1q0bHBwcFAYQyKvOf+8BYzPtjDOqUOv2FZwu75nDEQFtsUv6OxDK3R6Pyq7m+DozY9ohNfI0/vpxFDSqypXlqL6U5Zdfyk2duqSQP59sV2HiD+VRzf3gnyPLyeqy8otZ+AnArAzzqd0oNXr0aEyfPh3GxsYYPXp0unnnz5+v7mKJKAOse0RZI3/CkIhyzsGDB7F//37UrFlT06EQERFRAaB2o9S1a9fw+fNn6e+05If/mBHlJ1+r7skHFwA4wAAVfPKRK3mOIsoeS0tLWFlZaToMIiIiKiDUbpRK2W2IXYiIcg/rHlHWrV+/HnPnzsW9e/cAAGXKlMGPP/6Ibt26aTgyovxp+vTpmDp1KtatWwcjIyNNh0NERET5XJbeKUVERJTXzZ8/H1OmTMHQoUNRs2ZNCCFw9uxZDBw4EC9fvsSoUaM0HSJRvjNv3jw8ePAAdnZ2cHZ2VhpA4OpVzb4LiYiIiPIXtRul2rZtq/ZCAwMDsxQMESlj3SPKmsWLF2PZsmXo3r27lNa6dWuUL18e06ZNY6MUURa0adNG0yEQERFRAaJ2o5S5ufnXjIOI0sC6R5Q1UVFR8Pb2Vkr39vZGVFSUBiIiyv/8/FSPHkRERESUFWo3Sq1Zs+ZrxkFEaWDdI8qaUqVK4a+//sLEiRMV0rdt24bSpUtrKCqiguHKlSu4c+cOZDIZypUrh8qVK2s6JCIiIsqH+E4pIiIqkPz9/dGxY0ecOnUKNWvWhEwmw5kzZ3Ds2DH89ddfmg6PKF96/vw5OnXqhBMnTsDCwgJCCLx58wZ169bF1q1bUaRIEU2HSERERPmI2o1SVapUwbFjx2BpaYnKlSunO6w2X3JJlHNY94iypl27drh48SIWLFiA3bt3QwiBcuXK4dKlS3yqgyiLhg0bhri4ONy+fRtubm4AgLCwMPTo0QPDhw/Hli1bNBwhERER5SdqN0q1bt0a+vr6APiSS6LcxLpHlHWenp7YuHGjpsMgKjCCgoJw9OhRqUEKAMqVK4clS5agUaNGGoyMiIiI8iO1G6VSvtiSL7kkyj2se0Tqi4uLg5mZmfR3euT5iEh9ycnJ0NXVVUrX1dVFcnKyBiIiIiKi/Cxb75S6fPmy9JJLNzc3eHp65lRcRJQO1j0i1SwtLREVFQVbW1tYWFio7O4qhIBMJkNSUpIGIiTK3+rVq4cRI0Zgy5YtcHR0BAA8efIEo0aNQv369TUcHREREeU3WWqUevz4MTp37oyzZ8/CwsICAPD69Wt4e3tjy5YtKF68eE7GSET/w7pHlL7jx4/DysoKABAcHKzhaIgKnt9//x2tW7eGs7MzihcvDplMhoiICFSsWJFdZYmIiCjTstQo1bt3b3z+/Bl37txB2bJlAQB3795F79690adPHxw+fDhHgySiL1j3iNLn4+Mj/e3i4iLdNKckhEBkZGRuh0ZUIBQvXhxXr17FkSNH8M8//0gDCDRo0EDToREREVE+lKVGqdOnT+PcuXPSTTEAlC1bFosXL0bNmjVzLDgiUsS6R6Q+FxcXqStfSrGxsXBxcWH3PaJsaNiwIRo2bKjpMIiIiCify1KjVIkSJfD582el9MTERBQtWjTbQRGRaqx7ROqTvzsqtXfv3sHAwEADERHlT7/99hv69+8PAwMD/Pbbb+nmHT58eC5FRURERAVBlhql5syZg2HDhmHJkiXw9PSETCbD5cuXMWLECPz66685HSMR/Q/rHlHGRo8eDQCQyWSYMmUKjIyMpGlJSUm4ePEiKlWqpKHoiPKfBQsWoEuXLjAwMMCCBQvSzCeTydRqlGrcuDHOnDmDDx8+QCaTwc7ODqtXr0bTpk2lPKVKlcKDBw8U5jM2Nsa7d++yviFERESU56jdKGVpaanwH+f379+jevXq0NH5sojExETo6Oigd+/eaNOmTY4HSlRYse4RZc61a9cAfHlS6tatW9DT05Om6enpwcPDA2PHjtVUeET5zsOHD1X+nVVXrlxB586d0bJlSyQkJGDYsGFo2bIlnj59qtDd1sbGBseOHZO+GxsbZ3vdRERElLeo3Si1cOHCrxgGEaWFdY8oc+Sj7vXq1QuLFi2CmZmZhiMiKjh+/vlnjB07VuEJRAD4+PEj5s6di6lTp2a4jJcvXyp8r1ixIsqVK4dt27Zh2LBhUrqOjg7c3d1zJnAiIiLKk9RulOrRo8fXjIOI0sC6R5Q1a9as0XQIRAWOv78/Bg4cqNQo9eHDB/j7+6vVKJXa06dPAQDFihVTSI+OjoaWlhZ0dHRQsmRJ7Ny5E+XLl09zOXFxcYiLi5O+v337NtOxEBERUe7K0julUvr48aPSi5f5X2mir491jyhjISEh2L59OyIiIvDp0yeFaYGBgRnOHxAQgMDAQPzzzz8wNDSEt7c3Zs+erTACJlFhktYAAjdu3ICVlVWml5ecnIwuXbrAzMwMvr6+Unrz5s1haWkJDw8PXL16Fb/++is8PT3x/PnzNM91rVq1wsmTJzMdAxEREWmOVlZmev/+PYYOHQpbW1uYmJjA0tJS4UNEXwfrHpH6tm7dipo1ayIsLAy7du3C58+fERYWhuPHj8Pc3FytZZw8eRJDhgzBhQsXcOTIESQmJqJRo0Z4//79V46eKG+xtLSElZUVZDIZypQpAysrK+ljbm6Ohg0bokOHDpleroeHB16+fImjR48qpC9atAjTpk2Dr68vpk+fjvPnzyMhIQEzZsxIc1l79uxBZGSk9AkLC8t0PERERJS7svSk1Lhx4xAcHIylS5eie/fuWLJkCZ48eYI//vgDs2bNyukYieh/vlbdc/5pv/R3+KzmOREqkcbNnDkTCxYswJAhQ2BqaopFixbBxcUFAwYMgIODg1rLCAoKUvi+Zs0a2Nra4sqVK6hdu/bXCJsoT1q4cCGEEOjduzf8/f0VGnb19PTg7OwMLy+vTC3T3d0dd+7cwfHjx/Htt9+mm7dSpUrQ1dXFrVu30sxjZmam8BRVyq58RERElDdlqVFq7969WL9+PerUqYPevXujVq1aKFWqFJycnLBp0yZ06dIlp+MkIrDuEWXGgwcP0Lz5l0ZWfX19vH//HjKZDKNGjUK9evXg7++f6WW+efMGALLUTYkoP5O/39DFxQXe3t7Q1dXN8rKSk5NRqVIl3L59G0FBQWo18N67dw+fP39G8eLFs7xeIiIiynuy1H0vNjYWLi4uAL78Vyo2NhYA8N133+HUqVM5Fx0RKWDdI1KflZWV9KLjokWLIjQ0FADw+vVrfPjwIdPLE0Jg9OjR+O6771ChQoU08yUkJEgvXE794mWi/M7Hx0dqkPr48WOW9nV3d3fcunUL8+fPh52dHW7evImbN29K57To6GhUrVoVK1aswJkzZ7Bw4UJUqVIFWlpamDZt2tfaNCIiItKALDVKlSxZEuHh4QCAcuXK4a+//gLw5SkOCwuLnIqNiFJh3SNSX61atXDkyBEAQIcOHTBixAj069cPnTt3Rv369TO9vKFDh+LmzZvYsmVLuvkCAgJgbm4uffhkBxUkHz58yPa7DW/fvg0AGDlyJDw8PKTPuHHjAHzpDhgeHo6BAweiVq1aGDt2LOzs7HDu3Dk4Ojp+tW0jIiKi3Jel7nu9evXCjRs34OPjgwkTJqB58+ZYvHgxEhMTMX/+/JyOkYj+JzfqHt8vRQXF77//jvj4eADAhAkToKurizNnzqBt27aYMmVKppY1bNgw7NmzB6dOnVIatj61CRMmYPTo0dL3uLg4NkxRgfHjjz9m+92GQoh0p1tZWeHly5c5ES4RERHlcVlqlBo1apT0d926dXHnzh1cuXIFrq6u8PDwyLHgiEgR6x6RehITE7F37140btwYAKClpYVx48ZJT2KoSwiBYcOGYdeuXThx4oTUfTY9+vr60NfXz1LcRHkd321IREREOSlLjVKpOTk5wcnJKScWRUSZwLpHpJqOjg4GDRqEO3fuZGs5Q4YMwebNm/H333/D1NQU0dHRAABzc3MYGhrmRKhE+Up67zYcNGiQJkMjIiKifChL75QCgGPHjqFFixZwdXVFqVKl0KJFCxw9ejQnYyMiFVj3iNRTvXp1XLt2LVvLWLZsGd68eYM6derAwcFB+mzbti2HoiTKX/huQyIiIspJWWqU+v3339GkSROYmppixIgRGD58OMzMzNCsWTP8/vvvOR0jEf0P6x6R+gYPHowxY8bg999/x/nz56URvuQfdQghVH569uz5dYMnyqPk7zYEvrw/benSpdDX18eoUaPw448/ajg6IiIiym+y1H0vICAACxYswNChQ6W04cOHo2bNmvjll18U0oko57DuEamvY8eOAL7UETmZTAYhBGQyGZKSkjQVGlG+lfrdhv/88w8uX77MdxsSERFRlmSpUSouLg5NmjRRSm/UqBHGjx+f7aCISDXWPSL1PXz4UNMhEBUonz9/RqNGjfDHH3+gTJkyAIASJUqgRIkSGo6MiIiI8qssdd9r1aoVdu3apZT+999/o2XLltkOiohUY90jUp98IIC0PkSUObq6uggNDYVMJtN0KERERFRAqP2k1G+//Sb97ebmhl9++QUnTpyAl5cXAODChQs4e/YsxowZk/NREhVirHtEWbN+/fp0p3fv3j2XIiEqOLp3744///wTs2bN0nQoREREVACo3Si1YMEChe+WlpYICwtDWFiYlGZhYYHVq1dj8uTJORchUSHHukeUNSNGjFD4/vnzZ3z48AF6enowMjJioxRRFnz69AmrVq3CkSNHULVqVRgbGytMnz9/voYiIyIiovxI7UYpvpuDSDNY94iy5tWrV0pp9+7dw6BBgzhKGFEWhYaGokqVKgCAf//9V2Eau/URERFRZmXpRecpCSEA8EKEKLex7hFlXunSpTFr1ix07doV//zzj6bDIcp3goODNR0CERERFSBZetE58OVdHRUrVoShoSEMDQ3h7u6ODRs25GRsRKQC6x5R9mhra+Pp06eaDoMoX7t//z4OHTqEjx8/Avj/f5QQERERZUaWnpSaP38+pkyZgqFDh6JmzZoQQuDs2bMYOHAgXr58iVGjRuV0nEQE1j2izNizZ4/CdyEEoqKi8Pvvv6NmzZoaiooof4uJiUGHDh0QHBwMmUyGe/fuoWTJkujbty8sLCwwb948TYdIRERE+UiWGqUWL16MZcuWKbwktnXr1ihfvjymTZvGG2Oir4R1j0h9bdq0Ufguk8lQpEgR1KtXjzfORFk0atQo6OrqIiIiAm5ublJ6x44dMWrUKNYtIiIiypQsNUpFRUXB29tbKd3b2xtRUVHZCsj5p/0AgPBZzbO1HKKC6GvWPVXk9RFgnaT8Jzk5WdMhEBU4hw8fxqFDh1CsWDGF9NKlS+PRo0caiurrKVI+Am2xS+W0QPhmenmqlqVy+QIYLHPK9PJzwlLxCEvVyajBGPOjtMp1MFiG6pI19pP+9oO/BiNRn20j9Y+LL2Sr8812FXYNRJVMz+NfCF8DbP2mK2LMZ2WYL0uNUqVKlcJff/2FiRMnKqRv27YNpUuXzsoiiUgNrHtE6Rs9erTaeTl0PVHmvX//HkZGRkrpL1++hL6+vgYiIiIiovwsS41S/v7+6NixI06dOoWaNWtCJpPhzJkzOHbsGP7666+cjpGI/keTdY9PTVF+cO3aNYXvV65cQVJSEsqWLQvgyxD22tra8PT01ER4RPle7dq1sX79ekyfPh3Al26xycnJmDt3LurWravh6IiIiCi/yVKjVLt27XDp0iXMnz8fu3fvhhAC5cqVw6VLl1C5cuWcjpGI/od1jyh9KYernz9/PkxNTbFu3TpYWloCAF69eoVevXqhVq1amgqRKF+bO3cu6tSpg8uXL+PTp08YN24cbt++jdjYWJw9e1bT4REREVE+k+lGqc+fP6N///6YMmUKNm7c+DViAvDlqQw+jUH0/3Kr7hEVFPPmzcPhw4elBikAsLS0xIwZM9CoUSOMGTNGg9ER5U/lypXDzZs3sWzZMmhra+P9+/do27YthgwZAgcHB02HR0RERPmMVmZn0NXVxa5dql/4SERfD+seUebExcXh2bNnSunPnz/H27dvNRARUf4XEREBOzs7+Pv7Y9++fThw4ABmzJgBBwcHREREaDo8IiIiymcy3SgFAL6+vti9e3cOh0JEGWHdI1Kfr68vevXqhR07duDx48d4/PgxduzYgT59+qBt27aaDo8oX3JxccGLFy+U0mNiYuDi4qKBiIiIiCg/y/Loe9OnT8e5c+fg6ekJY2NjhenDhw/PkeCISBHrHpH6li9fjrFjx6Jr1674/PkzAEBHRwd9+vTB3LlzNRwdUf4khIBMpjyu9bt372BgYKCBiIiIiCg/y1Kj1KpVq2BhYYErV67gypUrCtNkMhlvjIm+EtY9IvUZGRlh6dKlmDt3Lh48eAAhBEqVKqXUmEtEGRs9ejSAL+eaKVOmwMjISJqWlJSEixcvolKlShqKjoiIiPKrLDVKPXz4UPpbCAEAKv9rRkQ5i3WPKPOMjY3h7u6u6TCI8rVr164B+HLuuXXrFvT09KRpenp68PDwwNixYzUVHhEREeVTWWqUAoA///wTCxYswL179wAApUuXxsiRI9G3b98cC46IlLHuERFRbgsODgYA9OrVC7/99htMTU01HBEREREVBFlqlJoyZQoWLFiAYcOGwcvLCwBw/vx5jBo1CuHh4ZgxY0aOBOf8036F7+GzmufIconyq9yqe0RERCmlHBygR48eaeYLDAzMjXCIiIiogMhSo9SyZcuwcuVKdO7cWUpr1aoV3N3dMWzYMN4YE30leaXupWwwZmMxEVHBZ25urukQiIiIqADKUqNUUlISqlatqpTu6emJxMTEbAdFRKqx7hERkSasWbNG0yEQERFRAaSVlZm6du2KZcuWKaWvWLECXbp0yXZQRKRaXqx7zj/tlz5ERERERERE6srWi84PHz6MGjVqAAAuXLiAyMhIdO/eXRo2GADmz5+f/SiJSMK6R0RERERERAVBlhqlQkNDUaVKFQDAgwcPAABFihRBkSJFEBoaKuXjUPVEOYt1j4iI8rs6derg5MmTCmlaWlpISkoCACQnJ6NevXo4ffo0kpOTYW5ujnXr1qF169aaCJeIiIi+oiw1SsmHBSai3MW6R0REBYG+vj4uXbokfdfV1ZX+bt68OU6ePIkff/wRXl5eGDFiBNq2bYvIyEg4OjpqIlwiIiL6SrL0TikiIqLCZOnSpXBxcYGBgQE8PT1x+vRpTYdElK/JZDK4u7tLHzc3NwBfnpI6fPgwmjRpgjlz5sDX1xehoaFITk7Gjz/+qOGoiYiIKKexUYqIiCgd27Ztw8iRIzFp0iRcu3YNtWrVQtOmTREREaHp0Ijyrfj4eGhra0NXVxclSpTAiRMnAACnTp1CcnIyunfvLuU1MzODvb09Lly4oKFoiYiI6GvJ8ovOiYiICoP58+ejT58+6Nu3LwBg4cKFOHToEJYtW4aAgAANR0eU/9SrVw/ffvstatSogQcPHmDmzJmoX78+/vnnH9y9excAULZsWYV5LCws8OLFi3SXGxcXh7i4OOn727dvcz54IiIiylFslCKiHOP8037p7/BZzTUYCVHO+PTpE65cuYKffvpJIb1Ro0Y4d+6cynkSEhKQkJAgfU95k0xEwNSpUxW+9+zZEw4ODhg7diyaNWsG4MuLz1MSQmS43FatWim9QJ2IiIjyNnbfIyIiSsPLly+RlJQEOzs7hXQ7OztER0ernCcgIADm5ubSp3jx4rkRKlG+ZWtrCwsLC9y/f196QurOnTsKed68eQNzc/N0l7Nnzx5ERkZKn7CwsK8WMxEREeUMNkoR0Vfh/NN+6UOU38lkMoXvQgilNLkJEybgzZs30icyMjI3QiTKt+Li4vD69WvY2dmhdu3a0NLSwoYNG6Tp7969Q3R0NGrUqJHucszMzFCsWDHpU7Ro0a8dOhEREWUTu+8RERGlwcbGBtra2kpPRT1//lzp6Sk5fX196Ovr50Z4RPlS1apV0a1bN1SuXBn37t3DxIkTkZycjOnTp0NLSwuNGjXCwYMHMX78eNSoUQOjRo2ClpYW5s6dq+nQiYiIKIexUYqIiCgNenp68PT0xJEjR+Dr6yulHzlyBK1bt9ZgZET51/PnzzF69GgkJydDS0sL9vb2+Pvvv1GzZk0AwP79+1GvXj38+uuvSE5Ohrm5OXbs2AFHR0cNR05EREQ5jY1SRERE6Rg9ejS6deuGqlWrwsvLCytWrEBERAQGDhyo6dCI8qWIiIh0p2tpaeHEiRO5EwwRERFpFBuliIiI0tGxY0fExMTg559/RlRUFCpUqIADBw7AyclJ06EREREREeVrbJQioq9O/rLz8FnNNRwJUdYMHjwYgwcP1nQYREREREQFSr4afY8jeRERERERERERFQz5qlFKjg1TRPmfvJGZ9ZmIiIiIiKhwypeNUkRERERERERElL/xnVJElGty6qmolMvhe6qIiIiIiIjyp3zbKMUXJxMVHGk1MrFrHxERERERUcGVbxul5NS5aWXDFVHhxieriIiIiIiI8p583yilDlUNV7wxJcqb+HQUERERERFR4VAoGqVUSevGl41VRPkLG7GIiIiIiIjyp0LbKJWWnLjBZcMWEREREREREVH62Cj1FeTmkxtsACPKHFXvl+K76YiIiIiIiHIfG6XyubzedYk38pSXZbX+qNP9N7NdhDNqLFOnLvGF7kRERERElJ+wUYq+qq/ZaMabbspN6uzLOZUnp5eRVmOVOo1YbOgiIiIiIqKvRSONUkIIAEBywgdNrJ4KiBKjtmd6nlD/xoiLiwPw//thYcF6l3+o2rczu7+nlV++/wOK+0LK9Ap+hzK1THXJ11dY617KMibKTYX9vPc+LinLy0jG2zSnvUfml5ve8lJLyPTSc0ZyXN6PMT9Kq1xZhpmRoOKvvC0z9QlIyDfbVbgo/ypZO6+o/nUL8m+eHPcOQMbXHzKhgSuUx48fo3jx4rm9WiIFkZGRKFasmKbDyDWsd5RXsO4RaUZhq3v//fcfXF1dNR0GERFRoZbR9YdGGqWSk5Nx9+5dlCtXDpGRkTAzM8vtEAqFuLg4FC9enGWcihACb9++haOjI7S0tDQdTq5JTk7G06dPYWpqCplMpulwvorCtM/nx21l3VOue/nxd8yqwrKteXE7C2vde/36NSwtLREREQFzc3NNh5Mv5cX9OT9h+WUPyy/7WIbZw/LLHnWvPzTSfU9LSwtFixYFAJiZmfEH/spYxsoK48WplpZWofkPeWHa5/PbtrLuqZbffsfsKCzbmte2s7DWPeDLtuel3yI/ymv7c37D8ssell/2sQyzh+WXdepcfxSef5cREREREREREVGewUYpIiIiIiIiIiLKdRprlNLX14efnx/09fU1FUKBxzKmwqYw7fOFaVsLssL0OxaWbS0s25kf8LfIPpZh9rD8sofll30sw+xh+eUOjbzonIiIiIiIiIiICjd23yMiIiIiIiIiolzHRikiIiIiIiIiIsp1bJQiIiIiIiIiIqJcp7FGqaVLl8LFxQUGBgbw9PTE6dOnNRVKvjZt2jTIZDKFj729vTRdCIFp06bB0dERhoaGqFOnDm7fvq3BiImyJyAgAN9++y1MTU1ha2uLNm3a4O7duwp5Cup+HxAQAJlMhpEjR0ppBXVbC4uCdi4srPWTdTNvKmj1K6ecOnUKLVu2hKOjI2QyGXbv3q0wXZ19NyEhAcOGDYONjQ2MjY3RqlUrPH78OBe3QnNy6jhXWMtw2bJlcHd3h5mZGczMzODl5YWDBw9K01l2mZPV809hLsOcuH8uzOX3VQgN2Lp1q9DV1RUrV64UYWFhYsSIEcLY2Fg8evRIE+Hka35+fqJ8+fIiKipK+jx//lyaPmvWLGFqaip27twpbt26JTp27CgcHBxEXFycBqMmyrrGjRuLNWvWiNDQUHH9+nXRvHlzUaJECfHu3TspT0Hc7y9duiScnZ2Fu7u7GDFihJReELe1sCiI58LCWD9ZN/Omgli/csqBAwfEpEmTxM6dOwUAsWvXLoXp6uy7AwcOFEWLFhVHjhwRV69eFXXr1hUeHh4iMTExl7cm9+XUca6wluGePXvE/v37xd27d8Xdu3fFxIkTha6urggNDRVCsOwyIzvnn8Jchjlx/1yYy+9r0EijVLVq1cTAgQMV0r755hvx008/aSKcfM3Pz094eHionJacnCzs7e3FrFmzpLT4+Hhhbm4uli9fnksREn1dz58/FwDEyZMnhRAFc79/+/atKF26tDhy5Ijw8fGRLjwK4rYWJoXhXFjQ6yfrZt5VGOpXTkjdKKXOvvv69Wuhq6srtm7dKuV58uSJ0NLSEkFBQbkWe16RleMcy1CRpaWlWLVqFcsuE7Jz/insZZjd++fCXn5fQ6533/v06ROuXLmCRo0aKaQ3atQI586dy+1wCoR79+7B0dERLi4u6NSpE/777z8AwMOHDxEdHa1Q1vr6+vDx8WFZU4Hx5s0bAICVlRWAgrnfDxkyBM2bN0eDBg0U0gvithYWheVcWNDrJ+tm3lRY6tfXoM6+e+XKFXz+/Fkhj6OjIypUqFAoyzcrxzmW4RdJSUnYunUr3r9/Dy8vL5ZdJmTn/MMyzN79M8sv5+nk9gpfvnyJpKQk2NnZKaTb2dkhOjo6t8PJ96pXr47169ejTJkyePbsGWbMmAFvb2/cvn1bKk9VZf3o0SNNhEuUo4QQGD16NL777jtUqFABAArcfr9161ZcvXoVISEhStMK2rYWJoXhXFjQ6yfrZt5VGOrX16LOvhsdHQ09PT1YWloq5Sls5ZvV41xhL8Nbt27By8sL8fHxMDExwa5du1CuXDnphp5ll77snn8Kexlm9/65sJff15DrjVJyMplM4bsQQimNMta0aVPp74oVK8LLywuurq5Yt24datSoAYBlTQXX0KFDcfPmTZw5c0ZpWkHY7yMjIzFixAgcPnwYBgYGaeYrCNtaWBXk364g10/WzfyB5Z91WSm7wli+OX2cKyxlWLZsWVy/fh2vX7/Gzp070aNHD5w8eVKazrJL29c8/xSWMvxa98+Fpfy+hlzvvmdjYwNtbW2lVsTnz58rtUhS5hkbG6NixYq4d++eNIoAy5oKomHDhmHPnj0IDg5GsWLFpPSCtN9fuXIFz58/h6enJ3R0dKCjo4OTJ0/it99+g46OjrQ9BWFbC5uCfi4s6PWTdTNvK+j162tSp47a29vj06dPePXqVZp5CoPsHOcKexnq6emhVKlSqFq1KgICAuDh4YFFixax7NSQE+efwl6GqWX2/pnll/NyvVFKT08Pnp6eOHLkiEL6kSNH4O3tndvhFDgJCQm4c+cOHBwc4OLiAnt7e4Wy/vTpE06ePMmypnxLCIGhQ4ciMDAQx48fh4uLi8L0grTf169fH7du3cL169elT9WqVdGlSxdcv34dJUuWLDDbWtgU1HNhYamfrJt5W0GtX7lBnTrq6ekJXV1dhTxRUVEIDQ0tFOWbE8e5wl6GqQkhkJCQwLJTQ06cfwp7GaaW2ftnlt9XkGuvVE9BPkzvn3/+KcLCwsTIkSOFsbGxCA8P10Q4+dqYMWPEiRMnxH///ScuXLggWrRoIUxNTaWynDVrljA3NxeBgYHi1q1bonPnzhySmvK1QYMGCXNzc3HixAmFoVw/fPgg5SnI+33KEVaEKNjbWtAVxHNhYa6frJt5S0GsXznl7du34tq1a+LatWsCgJg/f764du2aePTokRBCvX134MCBolixYuLo0aPi6tWrol69eoVmOPScOs4V1jKcMGGCOHXqlHj48KG4efOmmDhxotDS0hKHDx8WQrDssiIr55/CXIY5cf9cmMvva9BIo5QQQixZskQ4OTkJPT09UaVKFWkYVcqcjh07CgcHB6GrqyscHR1F27Ztxe3bt6XpycnJws/PT9jb2wt9fX1Ru3ZtcevWLQ1GTJQ9AFR+1qxZI+UpyPt96guPgrythUFBOxcW5vrJupn3FLT6lVOCg4NV1tMePXoIIdTbdz9+/CiGDh0qrKyshKGhoWjRooWIiIjQwNbkvpw6zhXWMuzdu7dUL4sUKSLq168vNUgJwbLLiqycfwpzGebE/XNhLr+vQSaEELn3XBYREREREREREZEG3ilFRERERERERETERikiIiIiIiIiIsp1bJQiIiIiIiIiIqJcx0YpIiIiIiIiIiLKdWyUIiIiIiIiIiKiXMdGKSIiIiIiIiIiynVslCIiIiIiIiIiolzHRikiIiIiIiIiIsp1bJTKIWvXroWFhYX0fdq0aahUqVKmliGTybB79+40p4eHh0Mmk+H69etZivFrO3HiBGQyGV6/fq3pUCgL8vM+nDp2TXB2dsbChQtzZV3dunXDzJkzpe8fPnxAu3btYGZmli/r4L59+1C5cmUkJydrOhRSU506dTBy5EhNh6Ego+MPEREpy8r1Xk6aMmUK+vfvL30XQqB///6wsrLK0/c9abl16xaKFSuG9+/fazoUonyDjVJERJmQVgNYSEiIwkXV13Lz5k3s378fw4YNk9LWrVuH06dP49y5c4iKioK5uflXjyMntWjRAjKZDJs3b9Z0KKSmwMBATJ8+HUDuNsgCad9ARUVFoWnTprkWBxFRXieTydL99OzZE2PHjsWxY8c0Et+zZ8+waNEiTJw4UUoLCgrC2rVrsW/fPkRFRaFChQoaiS2rKlasiGrVqmHBggWaDoUo32CjVCGXlJTEpxOIAHz69Clb8xcpUgRGRkY5FE3afv/9d3z//fcwNTWV0h48eAA3NzdUqFAB9vb2kMlkSvNld/u+tl69emHx4sWaDoPUZGVlpbAP5oTs7qP29vbQ19fPoWiIiPK/qKgo6bNw4UKYmZkppC1atAgmJiawtrbWSHx//vknvLy84OzsLKU9ePAADg4O8Pb2hr29PXR0dJTmyw/XNMuWLUNSUpKmQyHKF9golcKOHTtQsWJFGBoawtraGg0aNMD79+9x6tQp6OrqIjo6WiH/mDFjULt2bbWWHRISgoYNG8LGxgbm5ubw8fHB1atXlfLJ/9NraGgIFxcXbN++Pd3lhoWFoVmzZjAxMYGdnR26deuGly9fpplf/pTHvn37UK5cOejr6+PRo0dqxSeTybBq1Sr4+vrCyMgIpUuXxp49e9Jc18ePH9G8eXPUqFEDsbGxGZQQ5YTCsA8DX/bjEiVKwMjICL6+voiJiVGY3rNnT7Rp00YhbeTIkahTp470vU6dOhg6dChGjx4NGxsbNGzYEAAwf/58VKxYEcbGxihevDgGDx6Md+/eAfjSRbVXr1548+aN9F/GadOmAVB+WiQiIgKtW7eGiYkJzMzM0KFDBzx79kyaLn/aY8OGDXB2doa5uTk6deqEt2/fprndycnJ2L59O1q1aqWwHfPmzcOpU6cgk8mkbXR2dsaMGTPQs2dPmJubo1+/fgCA8ePHo0yZMjAyMkLJkiUxZcoUfP78WSmu1atXo0SJEjAxMcGgQYOQlJSEOXPmwN7eHra2tvjll18UYnvz5g369+8PW1tbmJmZoV69erhx44Y0/caNG6hbty5MTU1hZmYGT09PXL58WZreqlUrXLp0Cf/991+a2095h7z7Xp06dfDo0SOMGjVKqhNy586dQ+3atWFoaIjixYtj+PDhCt0ZsrKPrl27Fv7+/rhx44a0vrVr1wJQ7r5369Yt1KtXTzoe9u/fX6rLwP8fJ3799Vc4ODjA2toaQ4YMUagPRET5mb29vfQxNzeHTCZTSkv99Kn82Dhz5kzY2dnBwsIC/v7+SExMxI8//ggrKysUK1YMq1evVljXkydP0LFjR1haWsLa2hqtW7dGeHh4uvFt3bpV4ZqmZ8+eGDZsGCIiIiCTyaTGqqxcswGK9z1ly5aFkZER2rdvj/fv32PdunVwdnaGpaUlhg0bptCA9OnTJ4wbNw5FixaFsbExqlevjhMnTkjTHz16hJYtW8LS0hLGxsYoX748Dhw4IE1v3LgxYmJicPLkSXV/KqJCjY1S/xMVFYXOnTujd+/euHPnDk6cOIG2bdtCCIHatWujZMmS2LBhg5Q/MTERGzduRK9evdRa/tu3b9GjRw+cPn0aFy5cQOnSpdGsWTOlG9ApU6agXbt2uHHjBrp27YrOnTvjzp07acbs4+ODSpUq4fLlywgKCsKzZ8/QoUOHdGP58OEDAgICsGrVKty+fRu2trZqx+fv748OHTrg5s2baNasGbp06aKywenNmzdo1KgRPn36hGPHjsHKykqtcqKsKyz78MWLF9G7d28MHjwY169fR926dTFjxgy1tiG1devWQUdHB2fPnsUff/wBANDS0sJvv/2G0NBQrFu3DsePH8e4ceMAAN7e3kr/aRw7dqzScoUQaNOmDWJjY3Hy5EkcOXIEDx48QMeOHRXyPXjwALt378a+ffuwb98+nDx5ErNmzUoz3ps3b+L169eoWrWqlBYYGIh+/frBy8sLUVFRCAwMlKbNnTsXFSpUwJUrVzBlyhQAgKmpKdauXYuwsDAsWrQIK1euVHrE/MGDBzh48CCCgoKwZcsWrF69Gs2bN8fjx49x8uRJzJ49G5MnT8aFCxek7W3evDmio6Nx4MABXLlyBVWqVEH9+vWl40OXLl1QrFgxhISE4MqVK/jpp5+gq6srrdPJyQm2trY4ffp0xj8c5RmBgYEoVqwYfv75Z6lOAF8ahBo3boy2bdvi5s2b2LZtG86cOYOhQ4cqzJ/ZfbRjx44YM2YMypcvL60vdb0CvpznmjRpAktLS4SEhGD79u04evSo0vqDg4Px4MEDBAcHY926dVi7dq3UyEVEVFgdP34cT58+xalTpzB//nxMmzYNLVq0gKWlJS5evIiBAwdi4MCBiIyMBPDlmFu3bl2YmJjg1KlTOHPmDExMTNCkSZM0n2p69eoVQkNDFa5pFi1ahJ9//hnFihVDVFQUQkJCpGmZvWaT+/DhA3777Tds3boVQUFB0vXxgQMHcODAAWzYsAErVqzAjh07pHl69eqFs2fPYuvWrbh58ya+//57NGnSBPfu3QMADBkyBAkJCTh16hRu3bqF2bNnw8TERJpfT08PHh4evKYhUpcgIYQQV65cEQBEeHi4yumzZ88Wbm5u0vfdu3cLExMT8e7dOyGEEGvWrBHm5ubSdD8/P+Hh4ZHm+hITE4WpqanYu3evlAZADBw4UCFf9erVxaBBg4QQQjx8+FAAENeuXRNCCDFlyhTRqFEjhfyRkZECgLh7967K9a5Zs0YAENevX08ztvTimzx5svT93bt3QiaTiYMHDwohhAgODhYAxD///CM8PDxE27ZtRUJCQrrroZxTWPbhzp07iyZNmiikdezYUSH2Hj16iNatWyvkGTFihPDx8ZG++/j4iEqVKqW5fXJ//fWXsLa2lr6nLic5JycnsWDBAiGEEIcPHxba2toiIiJCmn779m0BQFy6dEkI8aV8jYyMRFxcnJTnxx9/FNWrV08zll27dgltbW2RnJyc7rbJ42nTpk2G2zdnzhzh6ekpfVcVV+PGjYWzs7NISkqS0sqWLSsCAgKEEEIcO3ZMmJmZifj4eIVlu7q6ij/++EMIIYSpqalYu3ZturFUrlxZTJs2LcOYSfN8fHzEiBEjhBCK+75ct27dRP/+/RXSTp8+LbS0tMTHjx+l+bK6j6o6NgEQu3btEkIIsWLFCmFpaSkd34QQYv/+/UJLS0tER0cLIb4cJ5ycnERiYqKU5/vvvxcdO3bMMCYiovwmreuX1MdU+bEx9Tm/Vq1a0vfExERhbGwstmzZIoQQ4s8//xRly5ZVuD5JSEgQhoaG4tChQyrjuXbtmgCgcK0khBALFiwQTk5OCmnZuWYDIO7fvy+lDRgwQBgZGYm3b99KaY0bNxYDBgwQQghx//59IZPJxJMnTxSWXb9+fTFhwgQhhBAVK1bM8HrF19dX9OzZM8OYiUgIPin1Px4eHqhfvz4qVqyI77//HitXrsSrV6+k6T179sT9+/elJwNWr16NDh06wNjYWK3lP3/+HAMHDkSZMmVgbm4Oc3NzvHv3DhEREQr5vLy8lL6n9ZTJlStXEBwcDBMTE+nzzTffAPjypENa9PT04O7unqX4Us5nbGwMU1NTPH/+XCFPgwYNULJkSfz111/Q09NLMw7KWYVlH75z547KdWRFyv/OyQUHB6Nhw4YoWrQoTE1N0b17d8TExGRqFJU7d+6gePHiKF68uJRWrlw5WFhYKJSFs7Ozwnt5HBwclOpTSh8/foS+vr7Kd0apomr7duzYge+++w729vYwMTHBlClTlH7D1HHZ2dmhXLly0NLSUkiTx3rlyhW8e/cO1tbWCr/lw4cPpd9x9OjR6Nu3Lxo0aIBZs2ap/H0NDQ3x4cMHtbaN8rYrV65g7dq1CvtD48aNkZycjIcPH0r5srqPZuTOnTvw8PBQOL7VrFkTycnJuHv3rpRWvnx5aGtrS98zqoNERIVB+fLllc75FStWlL5ra2vD2tpa4Trg/v37MDU1lY75VlZWiI+PT/N67uPHjwAAAwMDtWLK6jWbkZERXF1dFbbF2dlZ4cmmlNc0V69ehRACZcqUUTiHnTx5UtqW4cOHY8aMGahZsyb8/Pxw8+ZNpdh4TUOkPuU3xxVS2traOHLkCM6dO4fDhw9j8eLFmDRpEi5evAgXFxfY2tqiZcuWWLNmDUqWLIkDBw4o9C3OSM+ePfHixQssXLgQTk5O0NfXh5eXl1ov6kvrBjQ5ORktW7bE7NmzlaY5ODikuTxDQ0OlZaobX8ruNvLYUr8ovXnz5ti5cyfCwsIUTmD0dRWWfVgIkeH6tLS0lPKpek9M6ga5R48eoVmzZhg4cCCmT58OKysrnDlzBn369MnUe2aEECq3OXW6OvUpJRsbG3z48AGfPn1Sq8E39fZduHABnTp1gr+/Pxo3bgxzc3Ns3boV8+bNU8inKq70Yk1OToaDg4PK/Uk+UuG0adPwww8/YP/+/Th48CD8/PywdetW+Pr6SnljY2NRpEiRDLeL8r7k5GQMGDAAw4cPV5pWokQJ6e+s7qMZSasOAshWHSQiKgyych3g6emJTZs2KS0rrfO6jY0NgC/d+NQ592f1mi0r26KtrY0rV64o/NMCgNSQ1bdvXzRu3Bj79+/H4cOHERAQgHnz5imMjBwbG6vQGEZEaWOjVAoymQw1a9ZEzZo1MXXqVDg5OWHXrl0YPXo0gC8HoE6dOqFYsWJwdXVFzZo11V726dOnsXTpUjRr1gwAEBkZqfJlzhcuXED37t0VvleuXFnlMqtUqYKdO3fC2dlZ5cgUmaFufOqYNWsWTExMUL9+fZw4cQLlypXLVmykvsKwD5crV0562ivlOlIqUqQIQkNDFdKuX7+udBGS2uXLl5GYmIh58+ZJ/yH866+/FPLo6ellOJpKuXLlEBERgcjISOlpqbCwMLx58wZubm7pzpse+YtIw8LCFF5Kqq6zZ8/CyckJkyZNktIePXqU5XjkqlSpgujoaOjo6CiMoJNamTJlUKZMGYwaNQqdO3fGmjVrpEYp+X9T09pXKO9SVSeqVKmC27dvo1SpUplaljr7qLp1cN26dXj//r10I3P27FloaWmhTJkymYqJiIjSV6VKFWzbtk0a7EQdrq6uMDMzQ1hYWJaOy+pcs2VF5cqVkZSUhOfPn6NWrVpp5itevLj0bq0JEyZg5cqVCo1SoaGhaN++fbbjISoM2H3vfy5evIiZM2fi8uXLiIiIQGBgIF68eKFwAyn/r+2MGTPUfjm0XKlSpbBhwwbcuXMHFy9eRJcuXWBoaKiUb/v27Vi9ejX+/fdf+Pn54dKlS0ovZpUbMmQIYmNj0blzZ2nUqsOHD6N3796ZHoJU3fjU9euvv6JLly6oV68e/vnnnywvh9RXWPbh4cOHIygoCHPmzMG///6L33//HUFBQQp56tWrh8uXL2P9+vW4d+8e/Pz8lBqpVHF1dUViYiIWL16M//77Dxs2bMDy5csV8jg7O+Pdu3c4duwYXr58qfLR7AYNGsDd3R1dunTB1atXcenSJXTv3h0+Pj4qHz9XV5EiRVClShWcOXMmS/OXKlUKERER2Lp1Kx48eIDffvsNu3btynI8cg0aNICXlxfatGmDQ4cOITw8HOfOncPkyZNx+fJlfPz4EUOHDsWJEyfw6NEjnD17FiEhIQr75oULF6Sn7yh/cXZ2xqlTp/DkyROpoXr8+PE4f/48hgwZguvXr+PevXvYs2ePwgW7Kurso87Oznj48CGuX7+Oly9fIiEhQWk5Xbp0gYGBAXr06IHQ0FAEBwdj2LBh6NatG+zs7HJu44mICF26dIGNjQ1at26N06dP4+HDhzh58iRGjBiBx48fq5xHS0sLDRo0yPI1jTrXbFlRpkwZdOnSBd27d0dgYCAePnyIkJAQzJ49Wxphb+TIkTh06BAePnyIq1ev4vjx4wrXNOHh4Xjy5AkaNGiQ7XiICgM2Sv2PmZkZTp06hWbNmqFMmTKYPHky5s2bh6ZNm0p5tLS00LNnTyQlJSk8CaKO1atX49WrV6hcuTK6deuG4cOHw9bWVimfv78/tm7dCnd3d6xbtw6bNm1K80kjR0dHnD17FklJSWjcuDEqVKiAESNGwNzcXKEfeE7GlxkLFixAhw4dUK9ePfz777/ZWhZlrLDswzVq1MCqVauwePFiVKpUCYcPH8bkyZMV8jRu3BhTpkzBuHHj8O233+Lt27dqbW+lSpUwf/58zJ49GxUqVMCmTZsQEBCgkMfb2xsDBw5Ex44dUaRIEcyZM0dpOfKh6S0tLVG7dm3pPWvbtm3LMIaM9O/fX+Xj8epo3bo1Ro0ahaFDh6JSpUo4d+6cNOJZdshkMhw4cAC1a9dG7969UaZMGXTq1Anh4eGws7ODtrY2YmJi0L17d5QpUwYdOnRA06ZN4e/vLy1jy5Yt6NKlC4yMjLIdD+Wun3/+GeHh4XB1dZW6YLi7u+PkyZO4d+8eatWqhcqVK2PKlCnpdi0H1NtH27VrhyZNmqBu3booUqQItmzZorQcIyMjHDp0CLGxsfj222/Rvn171K9fH7///nvObTgREQH4csw9deoUSpQogbZt28LNzQ29e/fGx48f031yqn///ti6dWuWuk2rc82WVWvWrEH37t0xZswYlC1bFq1atcLFixelp9+TkpIwZMgQuLm5oUmTJihbtiyWLl0qzb9lyxY0atQITk5OORIPUUEnE+q8oIUk/fr1w7Nnz7Bnzx5Nh0KUJdyH87f4+HiULVsWW7duLTBPFb148QLffPMNLl++DBcXF02HQ0RERLlACIEaNWpg5MiR6Ny5s6bDyREJCQkoXbo0tmzZkqnXZBAVZnynlJrevHmDkJAQbNq0CX///bemwyHKNO7DBYOBgQHWr1+f5Xe+5UUPHz7E0qVL2SBFRERUiMhkMqxYsULl6HX51aNHjzBp0iQ2SBFlAp+UUlOdOnVw6dIlDBgwAAsWLNB0OESZxn2YiIiIiIiI8hI2ShERERERERERUa7ji86JiIiIiIiIiCjXsVGKiIiIiIiIiIhyHRuliIiIiIiIiIgo17FRioiIiIiIiIiIch0bpYiIiIiIiIiIKNexUYqIiIiIiIiIiHIdG6WIiIiIiIiIiCjXsVGKiIiIiIiIiIhyHRuliIiIiIiIiIgo1/0fLVCQS+/gHb0AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -2521,7 +2560,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [01:23<00:00, 1.64s/it]\n", + "100%|███████████████████████████████████| 51/51 [01:06<00:00, 1.31s/it]\n", "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:589: UserWarning:\n", "\n", "'kappa' with will be cast to \n", @@ -2532,20 +2571,54 @@ "name": "stdout", "output_type": "stream", "text": [ - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/aef6\n", - "42d24bf39d00d34f4f187f20c545_ar\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/aef642d24bf39d00d3\n", + "4f4f187f20c545/aef642d24bf39d00d34f4f187f20c545_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|████████▍ | 25/101 [00:33<01:40, 1.32s/it]" ] }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|████████████████▊ | 50/101 [01:06<01:07, 1.32s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [02:50<02:56, 6.79s/it]" + " 74%|█████████████████████████▏ | 75/101 [01:40<00:34, 1.32s/it]" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAD6CAYAAABwKvR6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACO8UlEQVR4nOzdd1gUx/8H8PfRe5dmAexiQcWoYBQb9q6xxN6x15hYgWjE2E1iiRW7RkVj771jFzVGjYgFREFFUUBgfn/4u/163B0cRU7g/Xqee/RmZ3c/u7ezZdiZkQkhBIiIiIiIiIiIiHKRjrYDICIiIiIiIiKigoeVUkRERERERERElOtYKUVERERERERERLmOlVJERERERERERJTrWClFRERERERERES5jpVSRERERERERESU61gpRUREREREREREuY6VUkRERERERERElOtYKUVERERERERERLmOlVJERKRWbGwsOnfuDHt7e8hkMrRp00aa9vLlS4wYMQKurq4wNDSEg4MDmjZtitjYWLXLW758OWQyGczMzBTSU1JSMHfuXDRp0gRFihSBiYkJypUrh59++gmvX7/WKNbjx49DJpPh+PHjCutr06YNXF1dYWxsjJIlS2LQoEGIjIxMd1nPnz+Hra0tZDIZtm7dqjAtICAAMpkML1++zDCmpKQk+Pn5wcnJCbq6uqhcuTIAYOLEiahSpQpsbGxgZGSE4sWLY8CAAXj06JHSMv7991+0b98e1tbWMDExQY0aNbBz586Md8j/q1u3LurWrauU/vvvv6Ns2bIwNDSEm5sbAgMD8fHjR6V80dHR6NWrF+zs7GBiYgIvLy8cOXJE4/XLZDIEBARI369du4bmzZujWLFiMDY2ho2NDby8vLBu3bp0lyOEQJ06dSCTyTB06FCl6VevXoWPjw8sLS0hk8kwf/58pTyHDx+GTCZT+/tNmjQJxYoVg56eHqysrAAAp0+fRr9+/eDp6QlDQ0PIZDKEh4erjDEqKgpDhw5F8eLFYWxsDBcXF/Tt2xcREREK+erWrSvFoeoTFRUl5VVVBiMjIzFp0iR4eXnBzs4OFhYW8PT0xNKlS5GSkqIU17t37zBy5Eg4OzvDyMgIlStXxqZNm9LZ2+rJj/+0HyMjo3TnS69Mycuuqs/58+ezFGduUXU+2LBhg8rjL7elF0facplbevXqle6x//nvrS5v2bJlcz1uIiL6cvS0HQAREX29pk6diu3bt2PlypUoUaIEbGxsAADPnj1D7dq1oaenh8mTJ6NUqVJ4+fIljh07hqSkJJXLevr0KcaOHQtnZ2e8efNGYdqHDx8QEBCALl26oF+/frCzs8OVK1cwbdo07Nq1C5cuXYKxsXGm4/f390e9evUwffp0FC5cGHfv3sXUqVPx999/4+rVq3BwcFA535AhQzJ8yNbE4sWL8eeff+L333+Hp6enVBn3+vVrdOnSBeXKlYO5uTlu376NadOmYefOnbh16xZsbW0BAOHh4fDy8oKTkxOWLFkCMzMzLF68GG3atMGWLVvQvn37LMX1yy+/YPLkyfjpp5/QqFEjhIaGYtKkSXj69CmWLl0q5UtMTESDBg3w+vVrLFiwAPb29li4cCGaNGmCw4cPw8fHJ9Prfv36NYoWLYouXbqgcOHCiI+Px/r169G9e3eEh4dj0qRJKudbuHAh7t+/r3a5ffr0QXx8PDZt2gRra2u4uroqTH/37h369+8PZ2dnPHv2TGn+v//+G7/88gsmTpyIpk2bwtDQEABw5MgRHD58GFWqVIGFhYVCpefnEhMTUadOHbx69QqBgYFwd3fH3bt34e/vjwMHDuDOnTswNzcHACxatAhxcXEK879//x5NmjSBp6cnHB0dpXRVZfDy5ctYs2YNevTogcmTJ0NfXx/79u3DoEGDcP78eaxcuVJh2e3atUNoaChmzJiB0qVLY8OGDejSpQtSU1Px/fffq92n6dm/fz8sLS2l7zo66f+dU5MyNX36dNSrV08hrUKFClmKT5s2bNiAsLAwjBw58quN49y5cyhSpEiuxzR58mT4+fkppbds2RKGhob45ptvFNKNjY1x9OhRpTQiIspHBBERkRoNGzYU5cqVU0pv3bq1KFy4sIiNjdV4WS1atBAtW7YUPXv2FKampgrTkpOTxcuXL5Xm2bJliwAg1q5dm+Hyjx07JgCIY8eOSWnPnz9XyhcaGioAiKlTp6pcztatW4WZmZlYvXq1ACC2bNmiMN3f318AEC9evMgwpn79+gljY+MM8wkhxN69ewUAsWLFCilt4MCBwsjISDx58kRKS05OFuXKlRNFixYVKSkpGS7Xx8dH+Pj4SN9fvnwpjIyMxIABAxTy/fLLL0Imk4lbt25JaQsXLhQAxNmzZ6W0jx8/Cnd3d1G9enWNtguA8Pf3zzBfjRo1RNGiRVVOe/jwoTAzMxMhISECgBgyZIhSHj09PTFo0CC1yx8yZIioUqWKmDRpksrfb9q0aQKA0jHz+T6eNWuWACAePnyotPxDhw4JAGL58uUK6Rs2bBAAREhIiNrYhBAiODhY5fyqymBsbKxISkpSuY0AREREhJS2Z88eAUBs2LBBIa+vr69wdnYWycnJ6caVVmaOf7mMypS87KZNz21JSUni48ePmZpH1f5o3ry5cHFxyeHohHj//n2m8n+pOHLa8ePHBQAxadIkhXRV1woiIsp/2HyPiCifuH//Pnr37o1SpUrBxMQEhQsXRsuWLXHz5k2lvHFxcRg7dizc3NxgYGCAwoULY+TIkYiPjwfw6Q0dmUyGw4cP486dO1KziePHjyM8PBw7d+5E//79YW1trVFs69atw4kTJ7Bo0SKV03V1daW3gz5XvXp1AMDjx48V0v/55x80adIEJiYmsLOzg5+fH96+fas0v729vVKap6cndHV1lZYJfGoqNWTIEPzyyy8oVqxYutv0+PFjtGvXDhYWFrC0tES3bt3w4sULabpMJsPy5cvx4cMHaf8FBwerXV6hQoUAAHp6/3uJ+cyZM/Dw8EDhwoWlNF1dXTRt2hSPHz/GxYsXpXQhBGbOnAkXFxcYGRmhatWq2Ldvn9J69u/fj4SEBPTu3VshvXfv3hBCYMeOHVLa9u3bUaZMGXh5eUlpenp66NatGy5evIinT59K6XFxcejfvz9sbW1hZmaGJk2a4N9//01nDyqys7NT2PbPDRgwAL6+vmjbtq3StODgYMhkMiQnJ2Px4sXSvv7cqVOnsHTpUixfvhy6urpKy3B1dZXe0HJwcFBo2pTRG0By+vr6AKDw9hAAqRlgRm8JrVixAmZmZujUqROA9MugtbW1tL7PycvLkydPpLTt27fDzMwM3333nULe3r1749mzZ7hw4YJC+oYNG+Dl5QUzMzOYmZmhcuXKWLFihQZ7QLXMlKmcoOl5UN5kcO3atRgzZgwKFy4MQ0PDdN/G00TdunWxZ88ePHr0SKHJmVxSUhKmTZsmNZ0tVKgQevfurXDuAD4dky1atEBISAiqVKkCIyMjBAYGAvj01mCdOnVgb28PU1NTVKxYETNnzlRofptRHKqa74WFhaF169awtraWmnmuXr1a5X7buHEjJk6cCGdnZ1hYWKBhw4a4e/dulvbZihUrIJPJ0KdPnyzNT0REeRsrpYiI8olnz57B1tYWM2bMwP79+7Fw4ULo6emhRo0aCg8L79+/h4+PD1avXo3hw4dj3759+PHHHxEcHIxWrVpBCAEnJyecO3cOVapUQfHixXHu3DmcO3cOVatWxalTpyCEgLOzM7p06QIzMzMYGRmhbt26OHfunFJc0dHRGDlyJGbMmJHp5iLyZhvly5eX0p4/fw4fHx+EhYVh0aJFWLt2Ld69e6eynyFVTpw4gZSUFIVlyg0fPhxubm4aLatt27YoWbIktm7dioCAAOzYsQONGzeWHgzPnTuHZs2awdjYWNp/zZs3V1hGcnIyPnz4gKtXr2LkyJEoXbo02rVrJ01PSkqSmpF9Tp5248YNKS0wMBA//vgjfH19sWPHDgwaNAj9+/dXelAMCwsDAFSsWFEh3cnJCXZ2dtJ0ed5KlSoprV+eduvWLQCfKsTatGkjPeBv374dNWvWRNOmTdXuv9TUVCQnJ+PFixdYtGgRDhw4gB9//FEp3/Lly3Hx4kX88ccfKpfTvHlz6bjr0KGDtK/lPnz4gL59+2LkyJGoWrWqymVs374dffv2BfCp0u7cuXPo16+f2thVqVWrFjw9PREQEIDQ0FC8e/cOV65cwYQJE1C1alU0bNhQ7bz37t3DqVOn0LlzZ6mJZ3plUJ2jR49CT08PpUuXltLCwsJQrlw5pQo/+W/4+e89ZcoUdO3aFc7OzggODsb27dvRs2dPlX2dVaxYEbq6unBwcECPHj2U+s2Sy0yZGjJkCPT09GBhYYHGjRvj9OnTGc6TlqbnQbnx48cjIiICS5Yswa5du2Bvby9VCPbq1SvT61+0aBFq1aoFR0dH6TeTH4+pqalo3bo1ZsyYge+//x579uzBjBkzcOjQIdStWxcfPnxQWNaVK1fwww8/YPjw4di/f7/UXPfBgwf4/vvvsXbtWuzevRt9+/bFrFmzMHDgQI3iUOXu3bvw9vbGrVu38NtvvyEkJATu7u7o1asXZs6cqZR/woQJePToEZYvX46lS5fi3r17aNmypco+zdLz5s0bbN26FQ0aNICbm5vS9A8fPsDR0RG6urooUqQIhg4dmm6/hURElAdp9T0tIiL6YpKTk0VSUpIoVaqUGDVqlJQeFBQkdHR0RGhoqEL+rVu3CgBi7969UpqPj48oX768Qr6goCABQFhYWIjWrVuL/fv3i23btolKlSoJIyMjcf36dYX87du3F97e3iI1NVUIoXmTjCdPnggHBwdRrVo1hSZUP/74o5DJZOLatWsK+X19fZWa76UVFxcnNX17+/atwrTdu3cLfX19cfPmTSGE+iZF8uY6n+9TIYRYv369ACDWrVsnpaW3rZGRkQKA9KlRo4Z4+vSpQp42bdoIKysrpVhr164tAIjp06cLIYR49eqVMDIyEm3btlXId+bMGQFAofle//79haGhocqYSpcuLRo1aiR919fXFwMHDlTKd/bsWYUmYfv27RMAxIIFCxTy/fLLL2qb7w0cOFDadgMDA7Fo0SKlPE+ePBGWlpbizz//lNKgpvmeuvQxY8aI4sWLS02f1DU/06RZWnrN94T4dHy1bNlS4XetW7euiImJUbtMIT4d0wDEuXPnlKapKoOqHDhwQOjo6Cgdl6VKlRKNGzdWyv/s2TOFY+i///4Turq6omvXrumuZ82aNeKXX34Re/fuFUePHhUzZswQNjY2wsHBQaGZqRCal6krV66IESNGiO3bt4uTJ0+KlStXinLlygldXV2xf//+DLc9PerOg/JY6tSpozRPeHi40NXVFX369Mlw+Zlpvrdx40YBQGzbtk0hXd6k+PMy4OLiInR1dcXdu3fTXX9KSor4+PGjWLNmjdDV1VVoUp1e87205bJz587C0NBQoemnEEI0bdpUmJiYiNevXwsh/rffmjVrppDvr7/+UnsMp2fx4sUCgNi4caPStLlz54q5c+eKgwcPioMHD4qJEycKExMTUbZsWaVzIhER5V18U4qIKJ9ITk7G9OnT4e7uDgMDA+jp6cHAwAD37t3DnTt3pHy7d+9GhQoVULlyZSQnJ0ufxo0bK41ep0pqaioAoEiRIti2bRsaN26Mdu3aYf/+/dDR0VH4q/q2bduwa9cuLFu2TKlJVXpiY2PRrFkzCCGwefNmhSZUx44dQ/ny5eHh4aEwT0YdNickJKBdu3Z49OgRtmzZojAC4Js3bzBw4ED8+OOPGnes3LVrV4XvHTt2hJ6eHo4dO6bR/HZ2dggNDcXp06exbNkyxMbGol69egojAw4dOhRv3rxBjx498N9//+H58+eYPHkyzp49C+B/TcvOnTuHhIQEpZi8vb3h4uKitO70fou00zTJK9/mtOtP7zeZMGECQkNDsWfPHvTp0wdDhw7F7NmzFfL4+fnBw8MD/fv3V7uc9Fy8eBHz58/Hn3/++cU7R/748SM6deqEa9euYdmyZTh58iRWr16Np0+fwtfXV6lzf7nk5GSsXr0a5cuXR82aNbO07itXrqBjx46oWbMmgoKClKZr8hseOnQIKSkpGDJkSLrr6t69OyZMmICmTZuiXr16+PHHH7Fv3z68ePFCoexnpkxVqVIF8+fPR5s2bVC7dm307t0bZ8+ehZOTE8aNG5fuvGlpeh6UUzVYgIuLC5KTk7PVbFGV3bt3w8rKCi1btlQ491auXBmOjo5K595KlSopvPUmd/XqVbRq1Qq2trbQ1dWFvr4+evTogZSUlEw1mf3c0aNH0aBBAxQtWlQhvVevXnj//r3SW1atWrVSihWAyrfq0rNixQrY2tqqbJo7atQojBo1Cr6+vvD19cW0adOwZs0a/PPPP1i2bFmm1kNERF8vjr5HRJRPjB49GgsXLsSPP/4IHx8fWFtbQ0dHB/369VNoFvL8+XPcv39fZZ80ABSGNldF3vdTw4YNFfrncXJygoeHB65cuQLg02hnQ4YMwbBhw+Ds7IzXr18DgDQ63+vXr6Gvrw9TU1OF5b969Qq+vr54+vQpjh49iuLFiytMj4mJUdnM4/MRy9JKTExE27Ztcfr0aezevRs1atRQmD5x4kTo6+tj6NChUpzv3r0D8Km54+vXr2FpaanwcJ92fXp6erC1tUVMTIzaONLmr1atGoBPTb+aNGkCNzc3zJgxAwsWLAAANGjQAKtWrcKYMWNQokQJAIC7uzumTp2KCRMmSH1Nydepah+kTbO1tUVCQgLev38PExMThWmxsbHw9PRUyKtqe+TNZ+SjMcbExEjbn966P1esWDGpj6FmzZoB+NSUqmfPnihUqBC2bt2K/fv34/Tp00oVOklJSXj9+jVMTU3VHsfApxH52rVrh2rVqkm/a0JCAoBPfWAZGhpKI+Jl14oVK7Bv3z6EhoZKv2vt2rXx7bffokSJEpg/fz78/f2V5tu7dy+ioqJUNl3UxNWrV+Hr64tSpUph7969Ss09Nf0N5X0aZWVEturVq6N06dI4f/68lJaVMvU5KysrtGjRAkuWLMGHDx80rlTU9Dwo5+TklMmtzbrnz5/j9evXMDAwUDk97blXVWwRERGoXbs2ypQpgwULFsDV1RVGRka4ePEihgwZonIbNRETE6Nyfc7OztL0z6Ut6/LjLjPrv3HjBi5duoQRI0aobKasStu2bWFqaqpwrBERUd7GSikionxi3bp16NGjB6ZPn66Q/vLlS6mzZeDTGzrGxsZKw8Z/Pj09qvoYkhNCSG/vvHz5Es+fP8ecOXMwZ84cpbzW1tZo3bq1Qsfar169QsOGDfHw4UMcOXJE5bpsbW0RFRWllK4qDfhUIdWmTRscO3YMf//9Nxo0aKCUJywsDOHh4SorUXr27CnF9vl+jIqKUuiAPDk5GTExMSo7bNdEkSJF4OzsrPSmQ8+ePdG1a1fcu3cP+vr6KFmyJIKCgiCTyVC7dm0A/3tAVLdfXF1dpe/yvqRu3rypUDkXFRWFly9fKrzVUrFiRZUd5cvT5HltbW1Vbr+630SV6tWrY8mSJfjvv/9QqFAhhIWFITk5WeXbQ8uWLcOyZcuwfft2tGnTRu0yb926hVu3bmHLli1K00qUKAEPDw9cu3ZN4xjTc+3aNejq6ir1+VS8eHHY2toq9N30uRUrVsDAwADdu3fP9DqvXr2Khg0bwsXFBQcPHlTqZB349Btu3LgRycnJCv1Kpf0N5R3tP3nyROltGU18XvaBrJUpVcsE0n/TKy1Nz4NymVl2dtnZ2cHW1hb79+9XOT1tBamq2Hbs2IH4+HiEhIQovAWZ3ePY1tZW4S1NuWfPngHI+LqQFfI30TLbf1vaY42IiPI2VkoREeUTMplM6a/Ne/bswdOnT1GyZEkprUWLFpg+fTpsbW1VvnGUkRo1aqBIkSI4ePAgUlJSpLelnj17huvXr0tNthwdHVU2ZZsxYwZOnDiBffv2KTzoyCuk/vvvPxw6dAhVqlRRuf569eph5syZuH79ukITvg0bNijllb8hdfToUYSEhKBx48Yqlzl//nzpbQ65a9euYdSoUQgICICPj49Ccz8AWL9+vcJbRX/99ReSk5NRt25dlevIyP379/HkyROlZjHAp7eqypUrB+BTs6ilS5eidevW0kNpzZo1YWRkhPXr1ys0Rzp79iwePXqkUCnVpEkTGBkZITg4WKFSSj6K3eeVPG3btsXgwYNx4cIFKW9ycjLWrVuHGjVqSG9RyH+T9evXY/jw4dL8qn4TdY4dOwYdHR3pzbhevXqp3Jf16tVDmzZtMGLEiAybhak6/oKDg7F69Wrs2LFDoVIxu5ydnZGSkoLQ0FCF/frvv/8iJiZG5RtIUVFR2Lt3L9q1a5fpysxr166hYcOGKFKkCA4dOqR2JMy2bdti2bJl2LZtmzSyHwCsXr0azs7OUqyNGjWCrq4uFi9erDDaoibOnz+Pe/fuKfz2WSlTn3v16hV2796NypUrZzhy4ec0PQ9+SYaGhirfGGrRogU2bdqElJQUpbc1NSWvqPp8G4UQKpuzqYtDlQYNGmD79u149uyZVK4BYM2aNTAxMcly01J1EhMTsW7dOlSvXl3jJtMAsHXrVrx//z7H4yEiIu1hpRQRUT7RokULBAcHo2zZsqhUqRIuX76MWbNmKT0Mjxw5Etu2bUOdOnUwatQoVKpUCampqYiIiMDBgwcxZsyYdB+YdHR0MG/ePHTs2BGtW7fGoEGDEB8fj6lTp8LAwADjx48HAGlEvrSCg4Ohq6urMO3Dhw9o3Lgxrl69ivnz5yM5OVmheUahQoWk5msjR47EypUr0bx5c0ybNg0ODg5Yv349/vnnH6V1dejQAfv27cPEiRNha2ursEwLCwu4u7sDACpXrqx2e8uXL69yO0JCQqCnpwdfX1/cunULkydPhoeHBzp27Kh2WcCnJiujRo1Chw4dULx4cejo6ODmzZuYN28ebG1tMXbsWClvdHQ05syZg1q1asHc3Bz//PMPZs6cCR0dHSxcuFDKZ21tjbFjx2LatGno168fvvvuOzx+/BgBAQFKb6rY2Nhg0qRJmDx5MmxsbNCoUSOEhoYiICAA/fr1k/YJ8Kn528KFC/Hdd99hxowZsLe3x6JFi3D37l0cPnxYyteoUSPUqVMH48aNQ3x8PKpVq4YzZ85g7dq1Sts/YMAAWFhYoHr16nBwcMDLly+xZcsWbN68GT/88IP0xo6rq6tCZdrnChcurFHln6o88n57atWqpdHbHy9evMCJEycA/O/ton379qFQoUIoVKgQfHx8AAC9e/fGvHnz0L59e0yaNAllypTBf//9h+nTp8PU1BR+fn5Ky169ejWSk5Mz/abI3bt3pdH8fvnlF9y7dw/37t2TppcoUULaj02bNoWvry8GDRqEuLg4lCxZEhs3bsT+/fuxbt06qVLZ1dUVEyZMwNSpU/Hhwwd06dIFlpaWuH37Nl6+fInAwEAAgIeHB7p164Zy5cpJzcZmzZoFR0dHhf6fMlOmvv/+exQrVgzVqlWDnZ0d7t27hzlz5uD58+cIDg7O1L7R9DyYnkePHqFEiRLo2bNnlvqVqlixIkJCQrB48WJ4enpCR0cH1apVQ+fOnbF+/Xo0a9YMI0aMQPXq1aGvr48nT57g2LFjaN26tcq+lT7n6+sLAwMDdOnSBePGjUNCQgIWL16MV69eaRyHKv7+/ti9ezfq1auHKVOmwMbGBuvXr8eePXswc+ZMlW/hZceOHTsQGxur9th/9OgRvv/+e3Tu3BklS5aETCbDiRMnMH/+fJQvXz7TZYaIiL5i2uxlnYiIcs6rV69E3759hb29vTAxMRHffvutOHXqlPDx8VEYfU0IId69eycmTZokypQpIwwMDISlpaWoWLGiGDVqlIiKipLypTfy144dO8Q333wjjIyMhKWlpWjVqpW4detWhnGqGpHu4cOHCiOWpf307NlTIf/t27eFr6+vMDIyEjY2NqJv377i77//Vhp9L71lpt0naWU0+t7ly5dFy5YthZmZmTA3NxddunQRz58/z3Bbo6KiRLdu3USJEiWEiYmJMDAwEMWLFxd+fn5KI1/FxMSIRo0aiUKFCgl9fX1RrFgxMWzYMJUjxKWmpoqgoCBRtGhRYWBgICpVqiR27dql8vcXQogFCxaI0qVLCwMDA1GsWDHh7+8vkpKSlPJFRUWJHj16CBsbG2FkZCRq1qwpDh06pJTv9evXok+fPsLKykqYmJgIX19f8c8//yiN8rVy5UpRu3ZtYWdnJ/T09ISVlZXw8fERa9euVVqmKsjk6HtpZXb0PflxoMkxdO/ePdG9e3fh6uoqDA0NRbFixUSnTp3UlovSpUsLV1dXaWRKVVSVwVWrVqV7bK9atUoh/9u3b8Xw4cOFo6OjdGyoGu1MiE+j68nLtZmZmahSpYrC8jp37ixKliwpTE1Nhb6+vnBxcRF+fn7i2bNnardBTl2ZCgoKEpUrVxaWlpZCV1dXFCpUSLRt21ZcvHgxw2Wmpel5UF0sQvzvfJT2vKOKquMmNjZWdOjQQVhZWQmZTCY+v93++PGjmD17tvDw8JD2cdmyZcXAgQPFvXv3pHwuLi6iefPmKte5a9cuaf7ChQuLH374QRoB8/PzX3pxpC2XQghx8+ZN0bJlS2FpaSkMDAyEh4eH0rGkbr/J91na/Or4+voKU1NTERcXp3J6bGysaNu2rXB1dRXGxsbCwMBAlCpVSowbN04aCZCIiPIHmRD/32CfiIiIiIiIiIgol7CXQCIiIiIiIiIiynXsU4qIiIiIvmqpqalITU1NN8/nowsSERFR3sA3pYiIiIjoq/bzzz9DX18/3U94eLi2wyQiIqJMYp9SRERERPRVe/bsGZ49e5ZunkqVKsHAwCCXIiIiIqKcwEopIiIiIiIiIiLKdWy+R0REREREREREuY6VUkRERERERERElOtYKUVERERERERERLmOlVJERERERERERJTrWClFRERERERERES5jpVSRERERERERESU61gpRUREREREREREuY6VUkRERERERERElOtYKUVERERERERERLmOlVJERERERERERJTrWClFRERERERERES5jpVSRERERERERESU61gpRUREREREREREuY6VUkRERERERERElOtYKUVERERERERERLmOlVJERERERERERJTrWClFRERERERERES5jpVSRERERERERESU61gpRUREREREREREuY6VUkRERERERERElOtYKUVERERERERERLmOlVJERERERERERJTrWClFRERERERERES5LscqpYKDgyGTyVR+xo4dm1OroXQEBARAJpMppLm6uqJXr16ZWs7Zs2cREBCA169fZ2q+tOs6fvw4ZDIZtm7dmqnlpOf9+/cICAjA8ePHlabJj8Hw8PAcW19elrZMGhkZwdHREfXq1UNQUBCio6O1HSKmT5+OHTt2KKXLjx1Vv7O21K1bF3Xr1pW+h4eHQyaTITg4OFPL2bBhA+bPn5+peVStS17eX758mallpef27dsICAhQWYZ69eoFV1fXHFsXZezzMqyqLAghULJkSchkMoVjMyeoO59/TWVS28dketfKtOcLIsr7Lly4gLZt26JYsWIwNDSEg4MDvLy8MGbMGIV8ixYtyvS9QVrq7o/o65OZ+7HcfC4jykv0cnqBq1atQtmyZRXSnJ2dc3o1pKHt27fDwsIiU/OcPXsWgYGB6NWrF6ysrL7oujLr/fv3CAwMBAClG/7mzZvj3LlzcHJy+qIx5DXyMvnx40dER0fj9OnT+PXXXzF79mxs3rwZDRs21Fps06dPR4cOHdCmTRuF9KpVq+LcuXNwd3fXTmAacHJywrlz51CiRIlMzbdhwwaEhYVh5MiRX3xdmXX79m0EBgaibt26Sg/7kydPxogRI77o+kk1c3NzrFixQumcd+LECTx48ADm5uZfPIa8UCZzW3rXykWLFmknKCL6Ivbs2YNWrVqhbt26mDlzJpycnBAZGYlLly5h06ZNmDNnjpR30aJFsLOzy3Tlw+fU3R9R3pabz2VEeUmOV0pVqFAB1apV0yjvx48fIZPJoKeX42HQ/6tSpcoXX8eHDx9gbGycK+tKT6FChVCoUCGtxvA1Slsm27dvj1GjRuHbb79Fu3btcO/ePTg4OGR7PSkpKUhOToahoWG2l2VhYYGaNWtmezlfkqGh4ReP8fN9qu398aUrxEi9Tp06Yf369Vi4cKHCzeyKFSvg5eWFuLi4Lx5DXiiT2fX+/XuYmJjkyLJYeUeUv8ycORNubm44cOCAwnNL586dMXPmTC1GRnmJtp+VPpeT1zyi7Mq1PqXkr/6vXbsWY8aMQeHChWFoaIj79+8DAA4fPowGDRrAwsICJiYmqFWrFo4cOaK0nD179qBy5cowNDSEm5sbZs+erdRsLb1mNTKZDAEBAQpp9+7dw/fffw97e3sYGhqiXLlyWLhwocr4N27ciIkTJ8LZ2RkWFhZo2LAh7t69q7Se/fv3o0GDBrC0tISJiQnKlSuHoKAgAMDatWshk8lw7tw5pfl+/vln6Ovr49mzZ+nuT1X7QZW0r4mmpqZi2rRpKFOmDIyNjWFlZYVKlSphwYIFAD69gvrDDz8AANzc3JSajri6uqJFixYICQlBlSpVYGRkJL25pO6V1ISEBIwePRqOjo4wNjaGj48Prl69qpBHXVOHz5tnhIeHS5VOgYGBUmzydaprvrdy5Up4eHjAyMgINjY2aNu2Le7cuaO0HjMzM9y/fx/NmjWDmZkZihYtijFjxiAxMVHlvs3LihUrhjlz5uDt27f4888/pXRNfgfgf2Vs5syZmDZtGtzc3GBoaIhjx44hISEBY8aMQeXKlWFpaQkbGxt4eXnh77//VlimTCZDfHw8Vq9eLf2W8nWrayq0c+dOeHl5wcTEBObm5vD19VUqR/Lzwa1bt9ClSxdYWlrCwcEBffr0wZs3bzLcN0IIzJw5Ey4uLjAyMkLVqlWxb98+pXyqzjMvXrzAgAEDULRoURgaGqJQoUKoVasWDh8+LO3fPXv24NGjRwpNKzPap+md0x4/fox27drBwsIClpaW6NatG168eKG0r9Oe9wDFMhscHIzvvvsOAFCvXj0pNvk6VTWVSkhIwPjx4+Hm5gYDAwMULlwYQ4YMUXrFXH7e2L9/P6pWrQpjY2OULVsWK1euVPMr0Oe6dOkCANi4caOU9ubNG2zbtg19+vRROU9SUhKmTZuGsmXLSsdi7969lY6Njx8/Yty4cXB0dISJiQm+/fZbXLx4UWl5qsrkpUuX0LlzZ7i6usLY2Biurq7o0qULHj16pDCv/Nx87NgxDBo0CHZ2drC1tUW7du0yvNZ9vowyZcpI1+g1a9ZoFCOguqzKz/k3b95Eo0aNYG5ujgYNGgAADh06hNatW6NIkSIwMjJCyZIlMXDgQIWmGRldK1WdS2NjYzF48GAULlwYBgYGKF68OCZOnKh0jZHJZBg6dCjWrl2LcuXKwcTEBB4eHti9e7dG+4qIcl5MTAzs7OxU/iFdR+d/j1Ourq64desWTpw4IZ0X5NfOnLg/AoCoqCgMHDgQRYoUgYGBAdzc3BAYGIjk5OQMt+Po0aOoW7cubG1tYWxsjGLFiqF9+/Z4//69lCe714+0zwOquhcB1N+3b968GV5eXjA1NYWZmRkaN26s9NyQmfv2xMRE/PzzzyhXrhyMjIxga2uLevXq4ezZs1IeIQQWLVqEypUrw9jYGNbW1ujQoQP++++/DPep3PPnzzO878zp57LU1FTMnDlT+q3s7e3Ro0cPPHnyRGG9devWRYUKFXDy5El4e3vDxMQEffr0Qd++fWFjY6Pw+8vVr18f5cuX13j7ibIjx19Rkv9lX2Eln53Ax48fDy8vLyxZsgQ6Ojqwt7fHunXr0KNHD7Ru3RqrV6+Gvr4+/vzzTzRu3BgHDhyQbhSPHDmC1q1bw8vLC5s2bUJKSgpmzpyJ58+fZzne27dvw9vbW3pId3R0xIEDBzB8+HC8fPkS/v7+CvknTJiAWrVqYfny5YiLi8OPP/6Ili1b4s6dO9DV1QXw6a/X/fv3h4+PD5YsWQJ7e3v8+++/CAsLA/Dpr97jxo3DwoUL4eXlJS07OTkZf/75J9q2bZtuk8fs7IeZM2ciICAAkyZNQp06dfDx40f8888/0kNkv379EBsbi99//x0hISFSU7jP/+p75coV3LlzB5MmTYKbmxtMTU3TXeeECRNQtWpVLF++HG/evEFAQADq1q2Lq1evonjx4hnGLOfk5IT9+/ejSZMm6Nu3L/r16wcA6b4dFRQUhAkTJqBLly4ICgpCTEwMAgIC4OXlhdDQUJQqVUrK+/HjR7Rq1Qp9+/bFmDFjcPLkSUydOhWWlpaYMmWKxnHmFc2aNYOuri5OnjyZ5WX89ttvKF26NGbPng0LCwuUKlUKiYmJiI2NxdixY1G4cGEkJSXh8OHDaNeuHVatWoUePXoAAM6dO4f69eujXr16mDx5MgCk+0rzhg0b0LVrVzRq1AgbN25EYmIiZs6cibp16+LIkSP49ttvFfK3b98enTp1Qt++fXHz5k2MHz8eADKsCAkMDERgYCD69u2LDh064PHjx+jfvz9SUlJQpkyZdOft3r07rly5gl9++QWlS5fG69evceXKFcTExAD49Er/gAED8ODBA2zfvl3jfZqetm3bomPHjvDz88OtW7cwefJk3L59GxcuXIC+vn66836uefPmmD59OiZMmICFCxeiatWqANS/ISWEQJs2bXDkyBGMHz8etWvXxo0bN+Dv749z587h3LlzCm/NXb9+HWPGjMFPP/0EBwcHLF++HH379kXJkiVRp04djeMsiCwsLNChQwesXLkSAwcOBPCpgkpHRwedOnVS6qMsNTUVrVu3xqlTpzBu3Dh4e3vj0aNH8Pf3R926dXHp0iUYGxsDAPr37481a9Zg7Nix8PX1RVhYGNq1a4e3b99mGFd4eDjKlCmDzp07w8bGBpGRkVi8eDG++eYb3L59G3Z2dgr5+/Xrh+bNm2PDhg14/PgxfvjhB3Tr1g1Hjx5Ndz3BwcHo3bs3WrdujTlz5kjXkcTERIWHwcxKSkpCq1atMHDgQPz000/SvcuDBw/g5eWFfv36wdLSEuHh4Zg7dy6+/fZb3Lx5E/r6+hpdKz+XkJCAevXq4cGDBwgMDESlSpVw6tQpBAUF4dq1a9izZ49C/j179iA0NBQ///wzzMzMMHPmTLRt2xZ3797N1HWTiHKGl5cXli9fjuHDh6Nr166oWrWqymvs9u3b0aFDB1haWkrNeOXXwpy4P4qKikL16tWho6ODKVOmoESJEjh37hymTZuG8PBwrFq1Su02hIeHo3nz5qhduzZWrlwJKysrPH36FPv370dSUhJMTExy7fqhzvTp0zFp0iT07t0bkyZNQlJSEmbNmoXatWvj4sWLCudYTe7bk5OT0bRpU5w6dQojR45E/fr1kZycjPPnzyMiIgLe3t4AgIEDByI4OBjDhw/Hr7/+itjYWPz888/w9vbG9evXNWpRkJX7zuw+lw0aNAhLly7F0KFD0aJFC4SHh2Py5Mk4fvw4rly5onAdjoyMRLdu3TBu3DhMnz4dOjo6sLKywsqVK7FhwwbpuQr49Hx87NgxpZc0iL4YkUNWrVolAKj8fPz4URw7dkwAEHXq1FGYLz4+XtjY2IiWLVsqpKekpAgPDw9RvXp1Ka1GjRrC2dlZfPjwQUqLi4sTNjY24vNNefjwoQAgVq1apRQnAOHv7y99b9y4sShSpIh48+aNQr6hQ4cKIyMjERsbK4QQUvzNmjVTyPfXX38JAOLcuXNCCCHevn0rLCwsxLfffitSU1PV7i9/f39hYGAgnj9/LqVt3rxZABAnTpxQO19m9oMQQri4uIiePXtK31u0aCEqV66c7vJnzZolAIiHDx8qTXNxcRG6urri7t27Kqd9vi75PqtatarCvggPDxf6+vqiX79+UpqPj4/w8fFRWmbPnj2Fi4uL9P3FixdKv6Gc/BiUx/3q1SthbGys9JtFREQIQ0ND8f333yusB4D466+/FPI2a9ZMlClTRmldeYF8f4SGhqrN4+DgIMqVKyd91/R3kJexEiVKiKSkpHTjSE5OFh8/fhR9+/YVVapUUZhmamqqcMzIyY+dY8eOCSE+nQ+cnZ1FxYoVRUpKipTv7du3wt7eXnh7e0tp/v7+AoCYOXOmwjIHDx4sjIyM0i2Xr169EkZGRqJt27YK6WfOnBEAFPaNqvOMmZmZGDlypNrlCyFE8+bNFfZl2uWp2qeq1iXfzlGjRinkXb9+vQAg1q1bJ6WpKzNpy+yWLVsU9vvn0h4D+/fvV7mf5eexpUuXKqzHyMhIPHr0SEr78OGDsLGxEQMHDlRaF33yeRmWl4mwsDAhhBDffPON6NWrlxBCiPLlyyscmxs3bhQAxLZt2xSWFxoaKgCIRYsWCSGEuHPnTrrHkKrzuapjQy45OVm8e/dOmJqaigULFihtx+DBgxXyz5w5UwAQkZGRapcpL/vqriOfH5PqYlRVfuTn/JUrV6pdtxBCpKamio8fP4pHjx4JAOLvv/+WpqV3rUx7Ll2yZInKa8yvv/4qAIiDBw9KaQCEg4ODiIuLk9KioqKEjo6OCAoKSjdeIvoyXr58Kb799lvp2UZfX194e3uLoKAg8fbtW4W8ac/J6mTl/mjgwIHCzMxM4XoqhBCzZ88WAMStW7fUrm/r1q0CgLh27ZraPF/i+iG/X0kr7X17RESE0NPTE8OGDVPI9/btW+Ho6Cg6duwopWl6375mzRoBQCxbtkztNp87d04AEHPmzFFIf/z4sTA2Nhbjxo1TO+/n26fJfWdOPpfJf4O019YLFy4IAGLChAlSmo+PjwAgjhw5orR8Hx8fpRgGDRokLCwslI5toi8lx5vvrVmzBqGhoQqfz9+Uat++vUL+s2fPIjY2Fj179kRycrL0SU1NRZMmTRAaGor4+HjEx8cjNDQU7dq1g5GRkTS/ubk5WrZsmaVYExIScOTIEbRt2xYmJiYK62/WrBkSEhJw/vx5hXlatWql8L1SpUoAIDVXOHv2LOLi4jB48GCVr6rKDRo0CACwbNkyKe2PP/5AxYoV031rILv7oXr16rh+/ToGDx6MAwcOZKkvkkqVKqF06dIa5//+++8V9oWLiwu8vb1x7NixTK87M86dO4cPHz4oNSksWrQo6tevr9Q8VCaTKe3DSpUqKTVFyU+EENmav1WrVir/UrhlyxbUqlULZmZm0NPTg76+PlasWKHUbFJTd+/exbNnz9C9e3eFNyPMzMzQvn17nD9/XunVY1VlNSEhId1RB8+dO4eEhAR07dpVId3b2xsuLi4Zxlm9enUEBwdj2rRpOH/+PD5+/KjJ5inFnZk3nNLG2rFjR+jp6X3x8iV/uyVt+fruu+9gamqqVL4qV66MYsWKSd+NjIxQunTpfF2+cpKPjw9KlCiBlStX4ubNmwgNDVXbdG/37t2wsrJCy5YtFa5rlStXhqOjo/Tav/wYUXcMZeTdu3f48ccfUbJkSejp6UFPTw9mZmaIj49XWdYzun6qIi/76q4j2ZX2ngQAoqOj4efnh6JFi0rnL3n5z+o57OjRozA1NUWHDh0U0uXlJ215qVevnkIH9g4ODrC3t2d5IdISW1tbnDp1CqGhoZgxYwZat26Nf//9F+PHj0fFihU1Hgk3u/dHu3fvRr169eDs7Kxwfm/atCmATwNgqFO5cmUYGBhgwIABWL16tcqmabl1/VDlwIEDSE5ORo8ePRTWbWRkBB8fH6Wm2Zrct+/btw9GRkZqr5fybZbJZOjWrZvCeh0dHeHh4aHxqLNZue/MznOZ/DdIex9WvXp1lCtXTum6Ym1tjfr16ystZ8SIEbh27RrOnDkDAIiLi8PatWvRs2dPmJmZaRwPUXbkeKVUuXLlUK1aNYXP59KOjCZvctahQwfo6+srfH799VcIIRAbG4tXr14hNTUVjo6OSutUlaaJmJgYJCcn4/fff1dad7NmzQBA6SJja2ur8F3+Su6HDx8AQGpvXaRIkXTX7eDggE6dOuHPP/9ESkoKbty4gVOnTmHo0KHpzpfd/TB+/HjMnj0b58+fR9OmTWFra4sGDRrg0qVLGc4rl9nR7dTFKm/S9KXIl68qXmdnZ6X1m5iYKFT0AZ9+34SEhC8XpBbFx8cjJiYmW6Njqtq3ISEh6NixIwoXLox169bh3Llz0gN0VvdlRr9lamoqXr16pZCeUVlNbz1ZLV+bN29Gz549sXz5cnh5ecHGxgY9evRAVFRUhvPKZbd86enpwdbWNlfKl56enlLzWZlMprJ8p/09gE+/SXq/B/2PTCZD7969sW7dOixZsgSlS5dG7dq1VeZ9/vw5Xr9+DQMDA6VrW1RUlHRdU3e8y4+hjHz//ff4448/0K9fPxw4cAAXL15EaGgoChUqpPJ31UaZTI+JiYlSk+HU1FQ0atQIISEhGDduHI4cOYKLFy9Kf6DK6vEaExMDR0dHpT9W2dvbQ09Pj+WFKI+oVq0afvzxR2zZsgXPnj3DqFGjEB4erlFn5zlxf/T8+XPs2rVL6dwu7/snvcqxEiVK4PDhw7C3t8eQIUNQokQJlChRQuq/SL783Lh+qNs2APjmm2+U1r1582albdPkvv3FixdwdnZOt6n38+fPIYSAg4OD0nrPnz+vcYVjVq5x2Xkuy+xzjrr7y9atW8PV1VVqqhccHIz4+HgMGTIkwxiIckquD3uX9oZM3tb1999/Vzuyj4ODgzRSn6qHu7Rp8hNU2o7u0hZOa2tr6Orqonv37moLnpubWzpbo0z+gJa2gzlVRowYgbVr1+Lvv//G/v37YWVlpfQXh7Ssra013g+q6OnpYfTo0Rg9ejRev36Nw4cPY8KECWjcuDEeP36s0SgM6b0Bpoq6WD8/eRsZGanshFrTC4Eq8uVHRkYqTXv27JlSfycFzZ49e5CSkqLQeWZmfwdVx8K6devg5uaGzZs3K0zPTofxGf2WOjo6sLa2zvLy065H3TGbtqPvtOzs7DB//nzMnz8fERER2LlzJ3766SdER0dj//79GsWQlfJVuHBh6XtycjJiYmIUypehoaHK/Z+diitbW1skJyfjxYsXChVTQghERUXhm2++yfKySbVevXphypQpWLJkCX755Re1+eQdias75uRv4Hx+vKs6htLz5s0b7N69G/7+/vjpp5+kdHmfKTklozL5OXXX/sycv8LCwnD9+nUEBwejZ8+eUrp8UJassrW1xYULFyCEUFhvdHQ0kpOTC/z1iCgv0tfXh7+/P+bNmyf1G5uenLg/srOzQ6VKldReAzL6Q2Pt2rVRu3ZtpKSk4NKlS/j9998xcuRIODg4oHPnzl/k+vH5ufnzvibTnpvl58GtW7dq9Ha6JgoVKoTTp08jNTVVbcWUnZ0dZDIZTp06pXIE6ZwYVVqd7DyXfX5vnPZlCFXPOeruL3V0dDBkyBBMmDABc+bMwaJFi9CgQYMM+1Elykm5NvqeOrVq1YKVlRVu376t9IaV/GNgYABTU1NUr14dISEhCjXgb9++xa5duxSW6eDgACMjI9y4cUMhPe3oFiYmJqhXrx6uXr2KSpUqqVx3Zmv7vb29YWlpiSVLlmTYNMrT0xPe3t749ddfsX79evTq1SvDTsMzsx8yYmVlhQ4dOmDIkCGIjY2VRr/QpGY/MzZu3KiwLx49eoSzZ88qVIa4urri33//Vbgwx8TEKIyMkdnYvLy8YGxsjHXr1imkP3nyBEePHpU60C+IIiIiMHbsWFhaWkodJwOa/w7pkclkMDAwULj4RUVFKZU/QPO//JcpUwaFCxfGhg0bFI6l+Ph4bNu2TRqRL7tq1qwJIyMjrF+/XiH97NmzmW42U6xYMQwdOhS+vr64cuWKlJ7TbzukjfWvv/5CcnKyUvlKez48evQo3r17p5CWmfIlLz9py9e2bdsQHx9foMvXl1K4cGH88MMPaNmypUKFSVotWrRATEwMUlJSVF7X5Dea8mNE3TGUHplMBiGE0s368uXLkZKSkoWtU61MmTJwcnJSex35nLzSOO2xvnPnTo3XJz9vpd2uz0cplctseXn37h127NihkC4fRZDlhejrpuqPYsD/mvR+Xhmk7jqfE/dHLVq0QFhYGEqUKKHy/K7p2++6urqoUaOG9HaM/D7lS1w/1J2b0z63NG7cGHp6enjw4IHaZ8LMatq0KRISElSOXizXokULCCHw9OlTleusWLFiptebFZl9LpM3xUt7HxYaGoo7d+5k6rrSr18/GBgYoGvXrrh7926GLXeIclquvymVlpmZGX7//Xf07NkTsbGx6NChA+zt7fHixQtcv34dL168wOLFiwEAU6dORZMmTeDr64sxY8YgJSUFv/76K0xNTRX+MitvF7xy5UqUKFECHh4euHjxIjZs2KC0/gULFuDbb79F7dq1MWjQILi6uuLt27e4f/8+du3aleGoQKq2Z86cOejXrx8aNmyI/v37w8HBAffv38f169fxxx9/KOQfMWIEOnXqBJlMhsGDB2u0Dk33gyotW7ZEhQoVUK1aNRQqVAiPHj3C/Pnz4eLiIo3yJT/5LliwAD179oS+vj7KlCmj0L9FZkRHR6Nt27bo378/3rx5A39/fxgZGUmjUgCfRi37888/0a1bN/Tv3x8xMTGYOXOmUtMKc3NzuLi44O+//0aDBg1gY2MDOzs7lW+wWFlZYfLkyZgwYQJ69OiBLl26ICYmBoGBgTAyMlIaWTG/CgsLk9rHR0dH49SpU1i1ahV0dXWxfft2hbdcNP0d0tOiRQuEhIRg8ODB0uh1U6dOhZOTE+7du6eQt2LFijh+/Dh27doFJycnmJubq/zLjI6ODmbOnImuXbuiRYsWGDhwIBITEzFr1iy8fv0aM2bMyPoO+oy1tTXGjh2LadOmoV+/fvjuu+/w+PFjBAQEZNhU6M2bN6hXrx6+//57lC1bFubm5ggNDcX+/fvRrl07hW0OCQnB4sWL4enpCR0dnSzdaMmFhIRAT08Pvr6+0uh7Hh4e6Nixo5Sne/fumDx5MqZMmQIfHx/cvn0bf/zxBywtLRWWVaFCBQDA0qVLYW5uDiMjI7i5uamsnPf19UXjxo3x448/Ii4uDrVq1ZJG36tSpQq6d++e5W0i9TQ51jt37oz169ejWbNmGDFiBKpXrw59fX08efIEx44dQ+vWrdG2bVuUK1cO3bp1w/z586Gvr4+GDRsiLCxMGvkxPRYWFqhTpw5mzZolnYNPnDiBFStWwMrKKoe29lPZnzp1Kvr16yddR16/fq2yTDo6OqJhw4YICgqCtbU1XFxccOTIEYSEhGi8vrJly6JEiRL46aefIISAjY0Ndu3ahUOHDinlzcy1skePHli4cCF69uyJ8PBwVKxYEadPn8b06dPRrFkzNGzYMJN7hohyU+PGjVGkSBG0bNkSZcuWRWpqKq5du4Y5c+bAzMwMI0aMkPJWrFgRmzZtwubNm1G8eHEYGRmhYsWKOXJ/9PPPP+PQoUPw9vbG8OHDUaZMGSQkJCA8PBx79+7FkiVL1HYhsmTJEhw9ehTNmzdHsWLFkJCQII0MJz8HfYnrR7NmzWBjY4O+ffvi559/hp6eHoKDg/H48WOFfK6urvj5558xceJE/Pfff2jSpAmsra3x/PlzXLx4EaampggMDMzU79alSxesWrUKfn5+uHv3LurVq4fU1FRcuHAB5cqVQ+fOnVGrVi0MGDAAvXv3xqVLl1CnTh2YmpoiMjISp0+fRsWKFaW+gHNadp7LypQpgwEDBuD333+Hjo4OmjZtKo2+V7RoUYwaNUrjOKysrNCjRw8sXrwYLi4uWe6vmSjLcqrH9IxG+pKPirNlyxaV00+cOCGaN28ubGxshL6+vihcuLBo3ry5Uv6dO3eKSpUqCQMDA1GsWDExY8YMlaM6vHnzRvTr1084ODgIU1NT0bJlSxEeHq5yFKqHDx+KPn36iMKFCwt9fX1RqFAh4e3tLaZNm5Zh/OpG+tu7d6/w8fERpqamwsTERLi7u4tff/1VabsTExOFoaGhaNKkicr9oo6m+yHtKA9z5swR3t7ews7OTpq3b9++Ijw8XGG+8ePHC2dnZ6Gjo6MwmpGLi4to3ry5ypjUjb63du1aMXz4cFGoUCFhaGgoateuLS5duqQ0/+rVq0W5cuWEkZGRcHd3F5s3b1Ya8UsIIQ4fPiyqVKkiDA0NFUb4SDuKh9zy5culfWVpaSlat26tNDpJz549hampqVJM6kYMyQvSjohpYGAg7O3thY+Pj5g+fbqIjo5WOZ8mv4P8uJ81a5bKZcyYMUO4uroKQ0NDUa5cObFs2TKV+/LatWuiVq1awsTERGF0O3WjaO3YsUPUqFFDGBkZCVNTU9GgQQNx5swZhTzy9bx48ULl/lA1UtbnUlNTRVBQkChatKgwMDAQlSpVErt27VIaTStt2U9ISBB+fn6iUqVKwsLCQhgbG4syZcoIf39/ER8fL80XGxsrOnToIKysrIRMJpP2SXr7NL3R9y5fvixatmwpzMzMhLm5uejSpYvCqJ5CfDrPjBs3ThQtWlQYGxsLHx8fce3aNaUyK4QQ8+fPF25ubkJXV1dhnarK4ocPH8SPP/4oXFxchL6+vnBychKDBg0Sr169Usin7ryhbrRH+kSTETSFUD3S08ePH8Xs2bOFh4eHMDIyEmZmZqJs2bJi4MCB4t69e1K+xMREMWbMGGFvby+MjIxEzZo1xblz59Sezz8vk0+ePBHt27cX1tbWwtzcXDRp0kSEhYUpzatuOzQZ0U9u+fLlolSpUsLAwECULl1arFy5UuUxGRkZKTp06CBsbGyEpaWl6Natm7h06ZLK0fdUnfOFEOL27dvC19dXmJubC2tra/Hdd9+JiIgIlfcP6q6Vqo7tmJgY4efnJ5ycnISenp5wcXER48ePFwkJCQr5AIghQ4YoxaWqvBJR7ti8ebP4/vvvRalSpYSZmZnQ19cXxYoVE927dxe3b99WyBseHi4aNWokzM3NBQCF81R274+E+DQS9fDhw4Wbm5vQ19cXNjY2wtPTU0ycOFG8e/dO7TacO3dOtG3bVri4uAhDQ0Nha2srfHx8xM6dOxXy5fT1QwghLl68KLy9vYWpqakoXLiw8Pf3F8uXL1d5X7Zjxw5Rr149YWFhIQwNDYWLi4vo0KGDOHz4sJQnM/ftHz58EFOmTJGuIba2tqJ+/fri7NmzCvlWrlwpatSoIUxNTYWxsbEoUaKE6NGjh8pnFlXr1OS+M6efy1JSUsSvv/4qSpcuLfT19YWdnZ3o1q2bePz4scL8Pj4+onz58ulux/HjxwUAMWPGjHTzEX0JMiGyOfzWVyAgIACBgYHZHklMG3bt2oVWrVphz549UufqREREREREeY2rqyvq1q2bbpM5+vqMGTMGixcvxuPHj7PcWT1RVmm9+V5Bdfv2bTx69AhjxoxB5cqVpaFciYiIiIiIiL608+fP499//8WiRYswcOBAVkiRVrBSSksGDx6MM2fOoGrVqli9enWmR9wiIiIiIiIiyir5YEEtWrTAtGnTtB0OFVD5ovkeERERERERERHlLTraDoCIiIiIiIiIiAoeVkoREREREREREVGuY6UUERERERERERHlOlZKERFRgeDq6gqZTKb0GTJkiMr8x48fV5n/n3/+yeXIiYiIiIjyJ62Mvpeamopnz57B3Nyco85RrhNC4O3bt3B2doaOTsGpl2W5I23TdtkLDQ1FSkqK9D0sLAy+vr747rvv0p3v7t27sLCwkL4XKlQoU+tl2SNt03bZ0xaWPSIiIu3R9P5DK5VSz549Q9GiRbWxaiLJ48ePUaRIEW2HkWtY7uhroa2yl7YyacaMGShRogR8fHzSnc/e3h5WVlZZXi/LHn0teN0jIiKi3JbR/YdWKqXMzc0BfAru878+E+WGuLg4FC1aVDoOCwqWO9K2r6nsJSUlYd26dRg9enSGb1BUqVIFCQkJcHd3x6RJk1CvXr108ycmJiIxMVH6LoQAwLJH2vM1lb3cJF33+gAWBloOhoiIqICJSwKKrkSG9x9aqZSSPwBYWFjwBp20pqC9ys9yR1+Lr6Hs7dixA69fv0avXr3U5nFycsLSpUvh6emJxMRErF27Fg0aNMDx48dRp04dtfMFBQUhMDBQKZ1lj7Ttayh7uUm67hkAFoZaDoaIiKiAyuj+QyuVUkRERNq0YsUKNG3aFM7OzmrzlClTBmXKlJG+e3l54fHjx5g9e3a6lVLjx4/H6NGjpe/yt1SIiIiIiEgRK6WIiKhAefToEQ4fPoyQkJBMz1uzZk2sW7cu3TyGhoYwNORrGUREREREGdFqpVQF/wOImJf+qEdElLMq+B+AjqGJ9D18RnMtRkOU+1atWgV7e3s0b575Y//q1atwcnL6AlERZU1KqsDFh7GIfpsAe3MjVHezga5OwWqmR0RERHkX35QiIqICIzU1FatWrULPnj2hp6d4CRw/fjyePn2KNWvWAADmz58PV1dXlC9fXuoYfdu2bdi2bZs2QidSsj8sEoG7biPyTYKU5mRpBP+W7mhSgZWnRERE9PVjpRQRERUYhw8fRkREBPr06aM0LTIyEhEREdL3pKQkjB07Fk+fPoWxsTHKly+PPXv2oFmzZrkZMpFK+8MiMWjdFYg06VFvEjBo3RUs7laVFVNERET01WOlFBERFRiNGjWCEGkf4z8JDg5W+D5u3DiMGzcuF6IiypyUVIHAXbeVKqQAQACQAQjcdRu+7o5sykdERERfNR1tB0BEREREmrv4MFahyV5aAkDkmwRcfBibe0ERERERZQErpYiIiIjykOi36iukspKPiIiISFtYKUVERESUh9ibG+Vovq/ZokWL4ObmBiMjI3h6euLUqVPaDomIiIhyECuliIiIiPKQ6m42cLI0grreomT4NApfdTeb3Awrx23evBkjR47ExIkTcfXqVdSuXRtNmzZVGJCAiIiI8jZWShERERHlIbo6Mvi3dAcApYop+Xf/lu55vpPzuXPnom/fvujXrx/KlSuH+fPno2jRoli8eLG2QyMiIqIcwkopIiIiojymSQUnLO5WFY6Wik30HC2NsLhbVTSp4KSlyHJGUlISLl++jEaNGimkN2rUCGfPnlU5T2JiIuLi4hQ+RERE9HXT03YARERERJR5TSo4wdfdERcfxiL6bQLszT812cvrb0gBwMuXL5GSkgIHBweFdAcHB0RFRamcJygoCIGBgbkRHhEREeUQVkoRERER5VG6OjJ4lbDVdhhfjEymWMEmhFBKkxs/fjxGjx4tfY+Li0PRokW/aHxERESUPayUIiIiIqKvip2dHXR1dZXeioqOjlZ6e0rO0NAQhoaGuREeERER5RD2KUVEREREXxUDAwN4enri0KFDCumHDh2Ct7e3lqIiIiKinMY3pYiIiIjoqzN69Gh0794d1apVg5eXF5YuXYqIiAj4+flpOzQiIiLKIayUIiIiIqKvTqdOnRATE4Off/4ZkZGRqFChAvbu3QsXFxdth0ZEREQ5hJVSRERERPRVGjx4MAYPHqztMIiIiOgLYZ9SRERERERERESU61gpRUREREREREREuY6VUkRERERERERElOtYKUVERERERERERLlO65VSrj/tgetPe7QdBhERERERERER5aIsVUrFx8fndBxEpAGWPSIiIiIiIsovslQp5eDggD59+uD06dM5HQ8RpYNlj4iIiIiIiPKLLFVKbdy4EW/evEGDBg1QunRpzJgxA8+ePcvp2IgoDZY9IiIiIiIiyi+yVCnVsmVLbNu2Dc+ePcOgQYOwceNGuLi4oEWLFggJCUFycnJOx0lEYNkjIiIiIqK8J2DB/z55iWyBv7ZDyPey1dG5ra0tRo0ahevXr2Pu3Lk4fPgwOnToAGdnZ0yZMgXv37/PqTiJ6DMse0RERERERJTX6WVn5qioKKxZswarVq1CREQEOnTogL59++LZs2eYMWMGzp8/j4MHD+ZUrET0/1j2iIhIGz58+AAhBExMTAAAjx49wvbt2+Hu7o5GjRppOToiIiLKa7JUKRUSEoJVq1bhwIEDcHd3x5AhQ9CtWzdYWVlJeSpXrowqVarkVJxEBJY9Ivq6pKQKXHwYi+i3CbA3N0J1Nxvo6si0HVam5IdtyE2tW7dGu3bt4Ofnh9evX6NGjRrQ19fHy5cvMXfuXAwaNEjbIRIREVEekqVKqd69e6Nz5844c+YMvvnmG5V5ihcvjokTJ2YrOCJSxLJHlHUBAQEIDAxUSHNwcEBUVJTaeU6cOIHRo0fj1q1bcHZ2xrhx4+Dn5/elQ80T9odFInDXbUS+SZDSnCyN4N/SHU0qOGkxMs3lh23IbVeuXMG8efMAAFu3boWDgwOuXr2Kbdu2YcqUKayUIiIiokzJUqVUZGSk9Nq2OsbGxvD3Z6dgRDmJZY8Kqn///RfHjx9HdHQ0UlNTFaZNmTJF4+WUL18ehw8flr7r6uqqzfvw4UM0a9YM/fv3x7p163DmzBkMHjwYhQoVQvv27TO/EfnI/rBIDFp3BSJNetSbBAxadwWLu1X96it18sM2aMP79+9hbm4OADh48CDatWsHHR0d1KxZE48ePdJydERERJTXZKlSytzcHJGRkbC3t1dIj4mJgb29PVJSUnIkOCJSxLJHBdGyZcswaNAg2NnZwdHRETLZ/5pWyWSyTFVK6enpwdHRUaO8S5YsQbFixTB//nwAQLly5XDp0iXMnj27QFdKpaQKBO66rVSZAwACgAxA4K7b8HV3/GqbweWHbdCWkiVLYseOHWjbti0OHDiAUaNGAQCio6NhYWGh5eiIiIgor8nS6HtCqLqNAxITE2FgYJCtgIhIPZY9KoimTZuGX375BVFRUbh27RquXr0qfa5cuZKpZd27dw/Ozs5wc3ND586d8d9//6nNe+7cOaWOmxs3boxLly7h48ePaudLTExEXFycwic/ufgwVqG5W1oCQOSbBFx8GJt7QWVSftgGbZkyZQrGjh0LV1dX1KhRA15eXgA+vTXF/gyJiIgoszL1ptRvv/0G4NNfppcvXw4zMzNpWkpKCk6ePImyZcvmbIRExLJHBdqrV6/w3XffZXs5NWrUwJo1a1C6dGk8f/4c06ZNg7e3N27dugVbW1ul/FFRUXBwcFBIc3BwQHJyMl6+fAknJ9VNu4KCgpT6rspPot+qr8zJSj5tyA/boC0dOnTAt99+i8jISHh4eEjpDRo0QNu2bbUYGREREeVFmaqUkndsKYTAkiVLFPriMDAwgKurK5YsWZKzERIRyx4VaN999x0OHjyY7Q7GmzZtKv2/YsWK8PLyQokSJbB69WqMHj1a5TyfNxUE/ve2Ytr0z40fP15heXFxcShatGh2Qv+q2Jsb5Wg+bcgP26BNjo6OSs1gq1evrqVoiIiIKC/LVKXUw4cPAQD16tVDSEgIrK2tv0hQRKSIZY8KspIlS2Ly5Mk4f/48KlasCH19fYXpw4cPz9JyTU1NUbFiRdy7d0/ldEdHR6WR+aKjo6Gnp6fyzSo5Q0NDGBoaZimmvKC6mw2cLI0Q9SZBZZ9MMgCOlkao7maT26FpLD9sg7bEx8djxowZOHLkiMqBB9JrEktERESUVpY6Oj927FhOx0FEGmDZo4Jo6dKlMDMzw4kTJ3DixAmFaTKZLMuVUomJibhz5w5q166tcrqXlxd27dqlkHbw4EFUq1ZNqWKsINHVkcG/pTsGrbsCGaBQqSN/f8y/pftX3UF4ftgGbenXrx9OnDiB7t27w8nJKd23BomIiIgyonGl1OjRozF16lSYmpqqbeYgN3fu3GwHRkSfsOxRQSd/UzC7xo4di5YtW6JYsWKIjo7GtGnTEBcXh549ewL41Ozu6dOnWLNmDQDAz88Pf/zxB0aPHo3+/fvj3LlzWLFiBTZu3Jgj8eRlTSo4YXG3qgjcdVuhw3BHSyP4t3RHkwqq+9v6muSHbdCGffv2Yc+ePahVq1aWl9G4cWOcPn0a79+/h0wmg4ODA1auXKnQxLZkyZJ48OCBwnympqZ49+5dltdLREREXx+NK6WuXr0qjTZ09epVtfn4FzOinMWyR/Q/mvTppM6TJ0/QpUsXvHz5EoUKFULNmjVx/vx5uLi4AAAiIyMREREh5Xdzc8PevXsxatQoLFy4EM7Ozvjtt9/Qvn37nNmYPK5JBSf4ujvi4sNYRL9NgL35p+ZueentovywDbnN2toaNjbZa9Z4+fJldOnSBS1btkRiYiKGDRuGli1b4tmzZ7C3t5fy2dnZ4ciRI9J3U1PTbK2XiIiIvj4aV0p93myITYiIcg/LHhGwZs0azJo1S+r/qXTp0vjhhx/QvXt3jZexadOmdKcHBwcrpfn4+ODKlSuZirUg0dWRwauE+v618oL8sA25aerUqZgyZQpWr14NExOTLC3j5cuXCt8rVqwId3d3bN68GcOGDZPS9fT0UKlSpWzFS0RERF+3LPUpRURElFvmzp2LyZMnY+jQoahVqxaEEDhz5gz8/Pzw8uVLjBo1StshEhUYc+bMwYMHD+Dg4ABXV1el/tWyUon77NkzAECRIkUU0qOioqCjowM9PT0UL14c27ZtQ/ny5dUuJy4uDnFxcdL3t2/fZjoWIiIiyl0aV0q1a9dO44WGhIRkKRgiUsayRwXd77//jsWLF6NHjx5SWuvWrVG+fHkEBASwUoooF7Vp0yZHl5eamoquXbvCwsICbdu2ldKbN28Oa2treHh44MqVK5g9ezY8PT0RHR0NCwsLlctq1aqV0mAIRERE9HXTuFLK0tLyS8ZBRGqw7FFBFxkZCW9vb6V0b29vREZGaiEiooLL398/R5fn4eGBly9f4ty5cwrpCxYskP7ftm1btG/fHlWqVMG0adMwc+ZMlcvauXOn0ptS7u7uORovERER5SyNK6VWrVr1JeMgIjVY9qigK1myJP766y9MmDBBIX3z5s0oVaqUlqLKvpRUwQ62Kc+6fPky7ty5A5lMBnd3d1SpUiXTy6hUqRLu3LmDo0eP4ptvvkk3b+XKlaGvr4+bN2+qzWNhYaHwFtXnFVRERET0dWKfUkRE9FULDAxEp06dcPLkSdSqVQsymQynT5/GkSNH8Ndff2k7vCzZHxaJwF23EfkmQUpzsjSCf0t3NKngpMXIiNIXHR2Nzp074/jx47CysoIQAm/evEG9evWwadMmFCpUKMNlpKamonLlyrh16xb279+POnXqZDjPvXv38PHjRxQtWjQnNoOIiIi+EhpXSlWtWhVHjhyBtbU1qlSpku5w3BypiCjnsOxRQde+fXtcuHAB8+bNw44dOyCEgLu7Oy5evJiltzO0bX9YJAatuwKRJj3qTQIGrbuCxd2qsmKKvlrDhg1DXFwcbt26hXLlygEAbt++jZ49e2L48OHYuHFjhsuoVKkSbt26hfnz58PBwQE3btwA8KmjcxsbG0RFRaFFixYYMGAA3N3dcenSJUyePBk6OjoICAj4kptHREREuUzjSqnWrVvD0NAQQM53cklE6rHsEQGenp5Yt26dtsPItpRUgcBdt5UqpABAAJABCNx1G77ujmzKR1+l/fv34/Dhw1KFFAC4u7tj4cKFaNSokUbLuHXrFgBg5MiRCul9+/bF8uXLYWBggPDwcPj5+UEIAV1dXbi6umL9+vVwdnbOsW0hIiIi7dO4Uurzji1zupNLIlKPZY8Kori4OKlvmIz6hVE3EtfX6OLDWIUme2kJAJFvEnDxYSy8StjmXmBEGkpNTYW+vr5Sur6+PlJTUzVahhCqqmX/x8bGBi9fvsxSfERERJS3ZKtPqUuXLkmdXJYrVw6enp45FRcRpYNlj/I7a2trREZGwt7eHlZWViqbrQohIJPJkJKSooUIsyb6rfoKqazkI8pt9evXx4gRI7Bx40bpraWnT59i1KhRaNCggZajIyIiorwmS5VST548QZcuXXDmzBlYWVkBAF6/fg1vb29s3LiRnVASfSEse1RQHD16FDY2NgCAY8eOaTmanGNvbpSj+Yhy2x9//IHWrVvD1dUVRYsWhUwmQ0REBCpWrJgvmtgSERFR7spSpVSfPn3w8eNH3LlzB2XKlAEA3L17F3369EHfvn1x8ODBHA2SiD5h2aOCwsfHR/q/m5ub9PD7OSEEHj9+nNuhZUt1Nxs4WRoh6k2Cyn6lZAAcLY1Q3c0mt0Mj0kjRokVx5coVHDp0CP/884808EDDhg21HRoRERHlQVmqlDp16hTOnj0rPRQDQJkyZfD777+jVq1aORYcESli2aOCyM3NTWrK97nY2Fi4ubnlqeZ7ujoy+Ld0x6B1VyADFCqm5FVu/i3d2ck5ffV8fX3h6+ur7TCIiIgoj8tSpVSxYsXw8eNHpfTk5GQULlw420ERkWose1QQyfuOSuvdu3cwMsp7zdyaVHDC4m5VEbjrtkKn546WRvBv6Y4mFZy0GB2Rst9++w0DBgyAkZERfvvtt3TzDh8+PJeiIiIiovwgS5VSM2fOxLBhw7Bw4UJ4enpCJpPh0qVLGDFiBGbPnp3TMRLR/2PZo4Jk9OjRAACZTIbJkyfDxMREmpaSkoILFy6gcuXKWooue5pUcIKvuyMuPoxF9NsE2Jt/arLHN6ToazRv3jx07doVRkZGmDdvntp8MpmMlVJERESUKRpXSllbWyv8pTo+Ph41atSAnt6nRSQnJ0NPTw99+vRBmzZtcjxQooKKZY8KqqtXrwL49KbUzZs3YWBgIE0zMDCAh4cHxo4dq63wsk1XRwavErbaDoMoQw8fPlT5fyIiIqLs0rhSav78+V8wDCJSh2WPCir5qHu9e/fGggULYGFhoeWIiOjnn3/G2LFjFd5cBIAPHz5g1qxZmDJlipYiIyIiorxI40qpnj17fsk4iEgNlj0q6FatWqXtEIjo/wUGBsLPz0+pUur9+/cIDAxkpRQRERFlSpb6lPrchw8flDpe5l+zib48lj0qSEJDQ7FlyxZEREQgKSlJYVpISIiWoiIqeNQNPHD9+nXY2NhoISIiIiLKy3SyMlN8fDyGDh0Ke3t7mJmZwdraWuFDRF8Gyx4VRJs2bUKtWrVw+/ZtbN++HR8/fsTt27dx9OhRWFpaajs8ogLB2toaNjY2kMlkKF26NGxsbKSPpaUlfH190bFjR22HSURERHlMlt6UGjduHI4dO4ZFixahR48eWLhwIZ4+fYo///wTM2bMyOkYiej/sexRQTR9+nTMmzcPQ4YMgbm5ORYsWAA3NzcMHDgQTk5O2g6PqECYP38+hBDo06cPAgMDFSqEDQwM4OrqCi8vLy1GSERERHlRliqldu3ahTVr1qBu3bro06cPateujZIlS8LFxQXr169H165dczpOIgLLHhVMDx48QPPmzQEAhoaGiI+Ph0wmw6hRo1C/fn0EBgZqOUKi/E/ev6Gbmxu8vb2hr6+v5YiIiIgoP8hS873Y2Fi4ubkB+NSHTWxsLADg22+/xcmTJ3MuOiJSwLJHBZGNjQ3evn0LAChcuDDCwsIAAK9fv8b79++1GRpRgePj4yNVSH348AFxcXEKHyIiIqLMyFKlVPHixREeHg4AcHd3x19//QXg01scVlZWORUbEaXBskcFUe3atXHo0CEAQMeOHTFixAj0798fXbp0QYMGDbQcHVHB8v79e/ZtSERERDkmS5VSvXv3xvXr1wEA48ePx6JFi2BoaIhRo0bhhx9+yNEAieh/WPaoIPrjjz/QuXNnAJ+O+7Fjx+L58+do164dVqxYoeXoiAqWH374AUePHpWuP8uXL0dgYCCcnZ2xZs0abYdHREREeUyW+pQaNWqU9P969erhzp07uHz5MkqUKAEPD48cC46IFLHsUUGTnJyMXbt2oXHjxgAAHR0djBs3DuPGjdNyZEQFE/s2JCIiopyUpTel0nJxcUG7du34UEyUy1j2KL/T09PDoEGDkJiYmO1lBQUF4ZtvvoG5uTns7e3Rpk0b3L17N915jh8/DplMpvT5559/sh0PUV7Evg2JiIgoJ2W5UurIkSNo0aIFSpQogZIlS6JFixY4fPhwTsZGRCqw7FFBU6NGDVy9ejXbyzlx4gSGDBmC8+fP49ChQ0hOTkajRo0QHx+f4bx3795FZGSk9ClVqlS24yHKi9i3IREREeWkLDXf++OPPzBq1Ch06NABI0aMAACcP38ezZo1w9y5czF06NAcDZKIPmHZo4Jo8ODBGDNmDJ48eQJPT0+YmpoqTK9UqZJGy9m/f7/C91WrVsHe3h6XL19GnTp10p3X3t6eD9xE+F/fhj4+Phg/fjyaN2+O33//HcnJyZg7d662wyMiIqI8JkuVUkFBQZg3b57CA/Dw4cNRq1Yt/PLLL3wwJvpCWPaoIOrUqROAT8e6nEwmgxACMpkMKSkpWVrumzdvAAA2NjYZ5q1SpQoSEhLg7u6OSZMmoV69emrzJiYmKjQ3jIuLy1J8RF+jtH0b/vPPP7h06VKm+jasW7cuTpw4oZCmo6MjleXU1FTUr18fp06dQmpqKiwtLbF69Wq0bt065zaEiIiIvgpZar4XFxeHJk2aKKU3atSIN99EXxDLHhVEDx8+VPr8999/0r9ZIYTA6NGj8e2336JChQpq8zk5OWHp0qXYtm0bQkJCUKZMGTRo0CDdvnOCgoJgaWkpfYoWLZqlGIm+Nh8/fkS9evXw77//SmnFihXLUt+GhoaGuH79uvQJCwuTpjVv3hwnTpzAmDFjEBISAgsLC7Rr1w7Pnj3LsW0hIiKir0OW3pRq1aoVtm/frjQE/d9//42WLVvmSGBEpIxljwoiFxeXHF/m0KFDcePGDZw+fTrdfGXKlEGZMmWk715eXnj8+DFmz56ttsnf+PHjMXr0aOl7XFwcK6YoX9DX10dYWBhkMlm2lyWTyVQ2vU1NTcXBgwfRpEkTzJw5EwDQoEEDWFpa4ocffsD69euzvW4iIiL6emhcKfXbb79J/y9Xrhx++eUXHD9+HF5eXgA+9Wtz5swZjBkzJuejJCrAWPaooFuzZk2603v06JGp5Q0bNgw7d+7EyZMnUaRIkUzHU7NmTaxbt07tdENDQxgaGmZ6uUR5QY8ePbBixQrMmDEjW8tJSEiArq4udHR04OTkhDVr1qBu3bo4efIkUlNTFcq1hYUFHB0dcf78+eyGT0RERF8ZjSul5s2bp/Dd2toat2/fxu3bt6U0KysrrFy5EpMmTcq5CIkKOJY9KujknfrLffz4Ee/fv4eBgQFMTEw0rpQSQmDYsGHYvn07jh8/Lg1rn1lXr16Fk5NTluYlyuuSkpKwfPlyHDp0CNWqVVMaeECTzs7r16+Pb775BjVr1sSDBw8wffp0NGjQAP/88w/u3r0LAApvKAKfrnMvXrxId7lxcXEKTdnfvn2r6WYRERGRlmhcKfXw4cMvGQcRqcGyRwXdq1evlNLu3buHQYMGKTVlTc+QIUOwYcMG/P333zA3N0dUVBQAwNLSEsbGxgA+Nb17+vSp9HbW/Pnz4erqivLlyyMpKQnr1q3Dtm3bsG3bthzYMqK8JywsDFWrVgUAhb6lAGjcrG/KlCkK33v16gUnJyeMHTsWzZo1A/Cp4/PPCSEyXG6rVq2UOlAnIiKir1uW+pT6nPwmISf6FyAizbHsUUFWqlQpzJgxA926dcM///yj0TyLFy8G8Gnkr8+tWrUKvXr1AgBERkYiIiJCmpaUlISxY8fi6dOnMDY2Rvny5bFnzx7pwZmooDl27FiOL9Pe3h5WVla4f/++9IbUnTt3ULlyZSnPmzdvYGlpme5ydu7cqfSmlLu7e47HS0RERDknS6PvAZ/6+KhYsSKMjY1hbGyMSpUqYe3atTkZGxGpwLJH9Imurm6mRuMSQqj8yCukACA4OBjHjx+Xvo8bNw7379/Hhw8fEBsbi1OnTrFCigjA/fv3ceDAAXz48AGAZm8yqRMXF4fXr1/DwcEBderUgY6OjsJ17d27d4iKikLNmjXTXY6FhQWKFCkifQoXLpzlmIiIiCh3ZOlNqblz52Ly5MkYOnQoatWqBSEEzpw5Az8/P7x8+RKjRo3K6TiJCCx7VDDt3LlT4bsQApGRkfjjjz9Qq1YtLUVFVDDFxMSgY8eOOHbsGGQyGe7du4fixYujX79+sLKywpw5czJcRrVq1dC9e3dUqVIF9+7dw4QJE5CamoqpU6dCR0cHjRo1wr59+/Djjz+iZs2aGDVqFHR0dDBr1qxc2EIiIiLKTVmqlPr999+xePFihc5lW7dujfLlyyMgIIAPxkRfCMseFURt2rRR+C6TyVCoUCHUr19fowdgIso5o0aNgr6+PiIiIlCuXDkpvVOnThg1apRGZTI6OhqjR49GamoqdHR04OjoiL///luqZN6zZw/q16+P2bNnIzU1FZaWlti6dSucnZ2/2HYRERGRdmSpUioyMhLe3t5K6d7e3oiMjMx2UESkGsseFUSpqanaDoGI/t/Bgwdx4MABFClSRCG9VKlSePTokUbL+LzfNlV0dHQUmtESERFR/pWlSqmSJUvir7/+woQJExTSN2/ejFKlSuVIYESkjGWPCorRo0drnFeTIeiJKGfEx8fDxMREKf3ly5cwNDTUQkRERESUl2WpUiowMBCdOnXCyZMnUatWLchkMpw+fRpHjhzBX3/9ldMxEtH/Y9mjguLq1asK3y9fvoyUlBRpZK5///0Xurq68PT01EZ4RAVWnTp1sGbNGkydOhXAp+a0qampmDVrFurVq6fl6IiIiCivyVKlVPv27XHx4kXMnTsXO3bsgBAC7u7uuHjxIqpUqZLTMRLR/2PZo4Li82Hn586dC3Nzc6xevRrW1tYAgFevXqF3796oXbu2tkIkKpBmzZqFunXr4tKlS0hKSsK4ceNw69YtxMbG4syZM9oOj4iIiPKYTFdKffz4EQMGDMDkyZOxbt26LxETEanAskcF1Zw5c3Dw4EGpQgoArK2tMW3aNDRq1AhjxozRYnREBYu7uztu3LiBxYsXQ1dXF/Hx8WjXrh2GDBkCJycnbYdHREREeYxOZmfQ19fH9u3bczwQ15/25PgyifKTL1X2iL52cXFxeP78uVJ6dHQ03r59q4WIiAquiIgIODg4IDAwELt378bevXsxbdo0ODk5ZdiBOREREVFama6UAoC2bdtix44dORzKp4opVk4Rqfelyh7R16xt27bo3bs3tm7diidPnuDJkyfYunUr+vbti3bt2mk7PKICxc3NDS9evFBKj4mJgZubmxYiIiIiorwsy6PvTZ06FWfPnoWnpydMTU0Vpg8fPjxHgiMiRSx7VBAtWbIEY8eORbdu3fDx40cAgJ6eHvr27YtZs2ZpOTqigkUIAZlMppT+7t07GBkZaSEiIiIiysuyVCm1fPlyWFlZ4fLly7h8+bLCNJlMxgdjoi/kS5Q9VW8nhs9onuUYiXKaiYkJFi1ahFmzZuHBgwcQQqBkyZJKlbJE9OWMHj0awKdrzeTJk2FiYiJNS0lJwYULF1C5cmUtRUdERER5VZYqpR4+fCj9XwgBACr/akZEOYtljwoyU1NTVKpUSdthEBVIV69eBfDp2nPz5k0YGBhI0wwMDODh4YGxY8dqKzwiIiLKo7JUKQUAK1aswLx583Dv3j0AQKlSpTBy5Ej069cv20HJ39zg2xpEyr5k2SMiIlLl2LFjAIDevXvjt99+g7m5uZYjIiKivCRghLYjyBoxIlDbIeR7WaqUmjx5MubNm4dhw4bBy8sLAHDu3DmMGjUK4eHhmDZtWo4GSUSfsOwREZE2fD6oQM+ePdXmCwkJyY1wiIiIKJ/IUqXU4sWLsWzZMnTp0kVKa9WqFSpVqoRhw4bxwZjoC2HZIyIibbC0tNR2CERERJQPZalSKiUlBdWqVVNK9/T0RHJycraDIiLVWPaIiEgbVq1ape0QiIiIKB/SycpM3bp1w+LFi5XSly5diq5du2Y7KCJSjWWPiIiIiIiI8otsdXR+8OBB1KxZEwBw/vx5PH78GD169JCGDQaAuXPnZj9KIpKw7BEREREREVF+kKVKqbCwMFStWhUA8ODBAwBAoUKFUKhQIYSFhUn5OFQ9Uc5i2SMiIiIiIqL8IkuVUvJhgYkod7HsERERERERUX6RpT6lcovrT3u0HQIREREREREREX0BX3WlFBERERERERER5U+slCIiIiIiIiIiolzHSikiIiIiIiIiIsp1X32llOtPe9i3FBEREVE+oaenB5lMpvSpWLEiAKBkyZJK08zMzLQcNREREX0JX32lFBERUU5atGgR3NzcYGRkBE9PT5w6dSrd/CdOnICnpyeMjIxQvHhxLFmyJJciJcqfbt68ievXr0ufX3/9FQDQt29fKY+dnZ1CnuvXr2srXCIiIvqC9LQdABERUW7ZvHkzRo4ciUWLFqFWrVr4888/0bRpU9y+fRvFihVTyv/w4UM0a9YM/fv3x7p163DmzBkMHjwYhQoVQvv27bWwBUR5X7ly5RS+9+zZE3p6ehg+fLiUpqenh0qVKuV2aERERJTLWClFREpUNZkNn9FcC5EQ5ay5c+eib9++6NevHwBg/vz5OHDgABYvXoygoCCl/EuWLEGxYsUwf/58AJ8epi9duoTZs2ezUoooB7x79w7Xr19Hw4YNoaPzvxf4o6KioKOjAz09PRQvXhzbtm1D+fLl011WXFwc4uLipO9v3779YnETERFRzmClFBERFQhJSUm4fPkyfvrpJ4X0Ro0a4ezZsyrnOXfuHBo1aqSQ1rhxY6xYsQIfP36Evr6+0jyJiYlITEyUvn/+kExEiiZPngwhBGbMmCGlNW/eHNbW1vDw8MCVK1cwe/ZseHp6Ijo6GhYWFmqX1apVK5w4cSI3wiYiIqIckmcqpeRvbvBtDSLt4NtTlNe9fPkSKSkpcHBwUEh3cHBAVFSUynmioqJU5k9OTsbLly/h5OSkNE9QUBACAwNzLnCifGzt2rWwt7dH1apVpbQFCxZI/2/bti3at2+PKlWqYNq0aZg5c6baZe3cuVPpTSl3d/cvEzgRERHliDzX0TlH4iMiouyQyWQK34UQSmkZ5VeVLjd+/Hi8efNG+jx+/DibERPlT2fOnEFMTIxCB+eqVK5cGfr6+rh582a6+SwsLFCkSBHpU7hw4ZwMl4iIiL6APPOmFBERUXbY2dlBV1dX6a2o6Ohopbeh5BwdHVXm19PTg62trcp5DA0NYWhomDNBE+VjEydOhI6ODqZMmZJuvnv37uHjx48oWrRoLkVGREREuSXPvSlFRESUFQYGBvD09MShQ4cU0g8dOgRvb2+V83h5eSnlP3jwIKpVq6ayPyki0kxycjJOnz6Nb775BkZGRlJ6VFQUqlWrhqVLl+L06dOYP38+qlatCh0dHQQEBGgvYCIiIvoi8uSbUuzbhoiIsmL06NHo3r07qlWrBi8vLyxduhQRERHw8/MD8Knp3dOnT7FmzRoAgJ+fH/744w+MHj0a/fv3x7lz57BixQps3LhRm5tBlOfNmjULKSkpSv2vGRgYIDw8HH5+fhBCQFdXF66urli/fj2cnZ21FC0RERF9KXmyUkoVdoROlPtYQUx5TadOnRATE4Off/4ZkZGRqFChAvbu3QsXFxcAQGRkJCIiIqT8bm5u2Lt3L0aNGoWFCxfC2dkZv/32G9q3b6+tTSDKF8aPH4/x48crpdvY2ODly5daiIiIiIi0Id9USsnxIZmIiNIzePBgDB48WOW04OBgpTQfHx9cuXLlC0dFRERERFTw5LtKKVUyGrGPlVZERERERERERLmrQFRKZYSVVkREREREREREuYuVUhrIqNIqs1jJRfkZm9ASERERERGRJlgppQU5WcnFh33KL1iZRUREREREVLCwUiqPy+m3uABWBNCXp+lxy4oqIiIiIiKi/IuVUkT0xX2JylMiIiIiIiLK21gpRUq0XYHAN2Eos770G1V8Y4uIiIiIiCjnaaVSSggBAEhNfK+N1dNXrtioLV9s2WGBjREXFwfgf8dhQZFfyp2mx8eXPI4ys/ywwMZKaRX8D3yx+b4EVbFoIm288mOvoJY9+bmHKLcV9OteXJKWAyEiIiqA5NffjO4/ZEILdyhPnjxB0aJFc3u1RAoeP36MIkWKaDuMXMNyR18Llj0i7ShoZe+///5DiRIltB0GERFRgZbR/YdWKqVSU1Nx9+5duLu74/Hjx7CwsMjtEPKVuLg4FC1alPtSQ0IIvH37Fs7OztDR0dF2OLkmNTUVz549g7m5OWQymbbDyZT8cIzn9W3IifhZ9pTLXl4/LvKL/P47FNSy9/r1a1hbWyMiIgKWlpbaDidPyu9l40vj/sse7r/s4z7MHu6/7NH0/kMrzfd0dHRQuHBhAICFhQV/4BzCfam5gnhzqqOjk+f/Qp4fjvG8vg3ZjZ9lT7W8flzkF/n5dyioZQ/4tO359XfNLfm5bOQG7r/s4f7LPu7D7OH+yzpN7j8Kzp/LiIiIiIiIiIjoq8FKKSIiIiIiIiIiynVaq5QyNDSEv78/DA0NtRVCvsF9SfldfjjG8/o25PX4v1bcr18H/g75E3/X7OM+zB7uv+zh/ss+7sPs4f7LHVrp6JyIiIiIiIiIiAo2Nt8jIiIiIiIiIqJcx0opIiIiIiIiIiLKdayUIiIiIiIiIiKiXKe1SqlFixbBzc0NRkZG8PT0xKlTp7QVSp4QEBAAmUym8HF0dJSmCyEQEBAAZ2dnGBsbo27durh165YWIybKvLx2nJ88eRItW7aEs7MzZDIZduzYoTBdk3gTExMxbNgw2NnZwdTUFK1atcKTJ0++ivh79eql9HvUrFnzq4k/P+C1MPfktfMLZR/Ll2p5/dqlbUFBQfjmm29gbm4Oe3t7tGnTBnfv3lXIw32o3uLFi1GpUiVYWFjAwsICXl5e2LdvnzSd+y5zgoKCIJPJMHLkSCmN+zB9OXE/UJD335eglUqpzZs3Y+TIkZg4cSKuXr2K2rVro2nTpoiIiNBGOHlG+fLlERkZKX1u3rwpTZs5cybmzp2LP/74A6GhoXB0dISvry/evn2rxYiJMi8vHefx8fHw8PDAH3/8oXK6JvGOHDkS27dvx6ZNm3D69Gm8e/cOLVq0QEpKitbjB4AmTZoo/B579+5VmK7N+PM6XgtzX146v1D2sHypl9evXdp24sQJDBkyBOfPn8ehQ4eQnJyMRo0aIT4+XsrDfahekSJFMGPGDFy6dAmXLl1C/fr10bp1a+mhn/tOc6GhoVi6dCkqVaqkkM59mLHs3g8U9P2X44QWVK9eXfj5+SmklS1bVvz000/aCCdP8Pf3Fx4eHiqnpaamCkdHRzFjxgwpLSEhQVhaWoolS5bkUoRE2ZeXj3MAYvv27dJ3TeJ9/fq10NfXF5s2bZLyPH36VOjo6Ij9+/fnWuxCKMcvhBA9e/YUrVu3VjvP1xR/XsRrYe7Ky+cXyjyWL83k9WvX1yA6OloAECdOnBBCcB9mhbW1tVi+fDn3XSa8fftWlCpVShw6dEj4+PiIESNGCCF4/Gkiu/cDBX3/fQm5/qZUUlISLl++jEaNGimkN2rUCGfPns3tcPKUe/fuwdnZGW5ubujcuTP+++8/AMDDhw8RFRWlsE8NDQ3h4+PDfUp5Tn45zjWJ9/Lly/j48aNCHmdnZ1SoUOGr2abjx4/D3t4epUuXRv/+/REdHS1Nywvxf614LdSO/HJ+ofSxfGVdfrl25aY3b94AAGxsbABwH2ZGSkoKNm3ahPj4eHh5eXHfZcKQIUPQvHlzNGzYUCGd+1Az2bkf4P7LebleKfXy5UukpKTAwcFBId3BwQFRUVG5HU6eUaNGDaxZswYHDhzAsmXLEBUVBW9vb8TExEj7jfuU8rr8dJxrEm9UVBQMDAxgbW2tNo82NW3aFOvXr8fRo0cxZ84chIaGon79+khMTATw9cf/NeO1MPflp/MLpY/lK+vyw7UrNwkhMHr0aHz77beoUKECAO5DTdy8eRNmZmYwNDSEn58ftm/fDnd3d+47DW3atAlXrlxBUFCQ0jTuw4xl936goO+/L0FPWyuWyWQK34UQSmn0P02bNpX+X7FiRXh5eaFEiRJYvXq11PEw9ynldfnxOM9KvF/LNnXq1En6f4UKFVCtWjW4uLhgz549aNeundr5vpb484K8djznZfnx/ELp4++ZdXn52pWbhg4dihs3buD06dNK07gP1StTpgyuXbuG169fY9u2bejZsydOnDghTee+U+/x48cYMWIEDh48CCMjI7X5uA/V+1L3AwVl/30Juf6mlJ2dHXR1dZVqEaOjo5VqJEk9U1NTVKxYEffu3ZNGC+A+pfwmLx/nmsTr6OiIpKQkvHr1Sm2er4mTkxNcXFxw7949AHkv/q8Jr4Xal5fPL5Q+lq+sy4/Xri9l2LBh2LlzJ44dO4YiRYpI6dyHGTMwMEDJkiVRrVo1BAUFwcPDAwsWLOC+08Dly5cRHR0NT09P6OnpQU9PDydOnMBvv/0GPT09aR9wH2ous/cD3H85L9crpQwMDODp6YlDhw4ppB86dAje3t65HU6elZiYiDt37sDJyQlubm5wdHRU2KdJSUk4ceIE9ynlaXn5ONckXk9PT+jr6yvkiYyMRFhY2Fe5TTExMXj8+DGcnJwA5L34vya8FmpfXj6/UPpYvrIuP167cpoQAkOHDkVISAiOHj0KNzc3hench5knhEBiYiL3nQYaNGiAmzdv4tq1a9KnWrVq6Nq1K65du4bixYtzH2ZSZu8HuP++gNzsVV1u06ZNQl9fX6xYsULcvn1bjBw5Upiamorw8HBthJMnjBkzRhw/flz8999/4vz586JFixbC3Nxc2mczZswQlpaWIiQkRNy8eVN06dJFODk5ibi4OC1HTqS5vHacv337Vly9elVcvXpVABBz584VV69eFY8ePdI4Xj8/P1GkSBFx+PBhceXKFVG/fn3h4eEhkpOTtRr/27dvxZgxY8TZs2fFw4cPxbFjx4SXl5coXLjwVxN/XsdrYe7Ka+cXyh6WL/Xy+rVL2wYNGiQsLS3F8ePHRWRkpPR5//69lIf7UL3x48eLkydPiocPH4obN26ICRMmCB0dHXHw4EEhBPddVnw++p4Q3IcZyYn7gYK8/74ErVRKCSHEwoULhYuLizAwMBBVq1aVhlEl1Tp16iScnJyEvr6+cHZ2Fu3atRO3bt2Spqempgp/f3/h6OgoDA0NRZ06dcTNmze1GDFR5uW14/zYsWMCgNKnZ8+eGsf74cMHMXToUGFjYyOMjY1FixYtREREhNbjf//+vWjUqJEoVKiQ0NfXF8WKFRM9e/ZUik2b8ecHvBbmnrx2fqHsY/lSLa9fu7RN1b4DIFatWiXl4T5Ur0+fPlK5LFSokGjQoIFUISUE911WpK2U4j5MX07cDxTk/fclyIQQIvfeyyIiIiIiIiIiItJCn1JERERERERERESslCIiIiIiIiIiolzHSikiIiIiIiIiIsp1rJQiIiIiIiIiIqJcx0opIiIiIiIiIiLKdayUIiIiIiIiIiKiXMdKKSIiIiIiIiIiynWslCIiIiIiIiIiolzHSqkcEhwcDCsrK+l7QEAAKleunKllyGQy7NixQ+308PBwyGQyXLt2LUsxfmnHjx+HTCbD69evtR0KZUFePobTxq4Nrq6umD9/fq6sq3v37pg+fbr0/f3792jfvj0sLCzyZBncvXs3qlSpgtTUVG2HQhqqW7cuRo4cqe0wFGR0/iEiImVZud/LSZMnT8aAAQOk70IIDBgwADY2Nl/1c486N2/eRJEiRRAfH6/tUIjyDFZKERFlgroKsNDQUIWbqi/lxo0b2LNnD4YNGyalrV69GqdOncLZs2cRGRkJS0vLLx5HTmrRogVkMhk2bNig7VBIQyEhIZg6dSqA3K2QBdQ/QEVGRqJp06a5FgcR0ddOJpOl++nVqxfGjh2LI0eOaCW+58+fY8GCBZgwYYKUtn//fgQHB2P37t2IjIxEhQoVtBJbVlWsWBHVq1fHvHnztB0KUZ7BSqkCLiUlhW8nEAFISkrK1vyFChWCiYlJDkWj3h9//IHvvvsO5ubmUtqDBw9Qrlw5VKhQAY6OjpDJZErzZXf7vrTevXvj999/13YYpCEbGxuFYzAnZPcYdXR0hKGhYQ5FQ0SU90VGRkqf+fPnw8LCQiFtwYIFMDMzg62trVbiW7FiBby8vODq6iqlPXjwAE5OTvD29oajoyP09PSU5ssL9zSLFy9GSkqKtkMhyhNYKfWZrVu3omLFijA2NoatrS0aNmyI+Ph4nDx5Evr6+oiKilLIP2bMGNSpU0ejZYeGhsLX1xd2dnawtLSEj48Prly5opRP/pdeY2NjuLm5YcuWLeku9/bt22jWrBnMzMzg4OCA7t274+XLl2rzy9/y2L17N9zd3WFoaIhHjx5pFJ9MJsPy5cvRtm1bmJiYoFSpUti5c6fadX348AHNmzdHzZo1ERsbm8EeopxQEI5h4NNxXKxYMZiYmKBt27aIiYlRmN6rVy+0adNGIW3kyJGoW7eu9L1u3boYOnQoRo8eDTs7O/j6+gIA5s6di4oVK8LU1BRFixbF4MGD8e7dOwCfmqj27t0bb968kf7KGBAQAED5bZGIiAi0bt0aZmZmsLCwQMeOHfH8+XNpuvxtj7Vr18LV1RWWlpbo3Lkz3r59q3a7U1NTsWXLFrRq1UphO+bMmYOTJ09CJpNJ2+jq6opp06ahV69esLS0RP/+/QEAP/74I0qXLg0TExMUL14ckydPxsePH5XiWrlyJYoVKwYzMzMMGjQIKSkpmDlzJhwdHWFvb49ffvlFIbY3b95gwIABsLe3h4WFBerXr4/r169L069fv4569erB3NwcFhYW8PT0xKVLl6TprVq1wsWLF/Hff/+p3X76esib79WtWxePHj3CqFGjpDIhd/bsWdSpUwfGxsYoWrQohg8frtCcISvHaHBwMAIDA3H9+nVpfcHBwQCUm+/dvHkT9evXl86HAwYMkMoy8L/zxOzZs+Hk5ARbW1sMGTJEoTwQEeVljo6O0sfS0hIymUwpLe3bp/Jz4/Tp0+Hg4AArKysEBgYiOTkZP/zwA2xsbFCkSBGsXLlSYV1Pnz5Fp06dYG1tDVtbW7Ru3Rrh4eHpxrdp0yaFe5pevXph2LBhiIiIgEwmkyqrsnLPBig+95QpUwYmJibo0KED4uPjsXr1ari6usLa2hrDhg1TqEBKSkrCuHHjULhwYZiamqJGjRo4fvy4NP3Ro0do2bIlrK2tYWpqivLly2Pv3r3S9MaNGyMmJgYnTpzQ9KciKtBYKfX/IiMj0aVLF/Tp0wd37tzB8ePH0a5dOwghUKdOHRQvXhxr166V8icnJ2PdunXo3bu3Rst/+/YtevbsiVOnTuH8+fMoVaoUmjVrpvQAOnnyZLRv3x7Xr19Ht27d0KVLF9y5c0dtzD4+PqhcuTIuXbqE/fv34/nz5+jYsWO6sbx//x5BQUFYvnw5bt26BXt7e43jCwwMRMeOHXHjxg00a9YMXbt2VVnh9ObNGzRq1AhJSUk4cuQIbGxsNNpPlHUF5Ri+cOEC+vTpg8GDB+PatWuoV68epk2bptE2pLV69Wro6enhzJkz+PPPPwEAOjo6+O233xAWFobVq1fj6NGjGDduHADA29tb6S+NY8eOVVquEAJt2rRBbGwsTpw4gUOHDuHBgwfo1KmTQr4HDx5gx44d2L17N3bv3o0TJ05gxowZauO9ceMGXr9+jWrVqklpISEh6N+/P7y8vBAZGYmQkBBp2qxZs1ChQgVcvnwZkydPBgCYm5sjODgYt2/fxoIFC7Bs2TKlV8wfPHiAffv2Yf/+/di4cSNWrlyJ5s2b48mTJzhx4gR+/fVXTJo0CefPn5e2t3nz5oiKisLevXtx+fJlVK1aFQ0aNJDOD127dkWRIkUQGhqKy5cv46effoK+vr60ThcXF9jb2+PUqVMZ/3D01QgJCUGRIkXw888/S2UC+FQh1LhxY7Rr1w43btzA5s2bcfr0aQwdOlRh/sweo506dcKYMWNQvnx5aX1pyxXw6TrXpEkTWFtbIzQ0FFu2bMHhw4eV1n/s2DE8ePAAx44dw+rVqxEcHCxVchERFVRHjx7Fs2fPcPLkScydOxcBAQFo0aIFrK2tceHCBfj5+cHPzw+PHz8G8OmcW69ePZiZmeHkyZM4ffo0zMzM0KRJE7VvNb169QphYWEK9zQLFizAzz//jCJFiiAyMhKhoaHStMzes8m9f/8ev/32GzZt2oT9+/dL98d79+7F3r17sXbtWixduhRbt26V5unduzfOnDmDTZs24caNG/juu+/QpEkT3Lt3DwAwZMgQJCYm4uTJk7h58yZ+/fVXmJmZSfMbGBjAw8OD9zREmhIkhBDi8uXLAoAIDw9XOf3XX38V5cqVk77v2LFDmJmZiXfv3gkhhFi1apWwtLSUpvv7+wsPDw+160tOThbm5uZi165dUhoA4efnp5CvRo0aYtCgQUIIIR4+fCgAiKtXrwohhJg8ebJo1KiRQv7Hjx8LAOLu3bsq17tq1SoBQFy7dk1tbOnFN2nSJOn7u3fvhEwmE/v27RNCCHHs2DEBQPzzzz/Cw8NDtGvXTiQmJqa7Hso5BeUY7tKli2jSpIlCWqdOnRRi79mzp2jdurVCnhEjRggfHx/pu4+Pj6hcubLa7ZP766+/hK2trfQ97X6Sc3FxEfPmzRNCCHHw4EGhq6srIiIipOm3bt0SAMTFixeFEJ/2r4mJiYiLi5Py/PDDD6JGjRpqY9m+fbvQ1dUVqamp6W6bPJ42bdpkuH0zZ84Unp6e0ndVcTVu3Fi4urqKlJQUKa1MmTIiKChICCHEkSNHhIWFhUhISFBYdokSJcSff/4phBDC3NxcBAcHpxtLlSpVREBAQIYxk/b5+PiIESNGCCEUj3257t27iwEDBiiknTp1Sujo6IgPHz5I82X1GFV1bgIgtm/fLoQQYunSpcLa2lo6vwkhxJ49e4SOjo6IiooSQnw6T7i4uIjk5GQpz3fffSc6deqUYUxERHmNuvuXtOdU+bkx7TW/du3a0vfk5GRhamoqNm7cKIQQYsWKFaJMmTIK9yeJiYnC2NhYHDhwQGU8V69eFQAU7pWEEGLevHnCxcVFIS0792wAxP3796W0gQMHChMTE/H27VsprXHjxmLgwIFCCCHu378vZDKZePr0qcKyGzRoIMaPHy+EEKJixYoZ3q+0bdtW9OrVK8OYiUgIvin1/zw8PNCgQQNUrFgR3333HZYtW4ZXr15J03v16oX79+9LbwasXLkSHTt2hKmpqUbLj46Ohp+fH0qXLg1LS0tYWlri3bt3iIiIUMjn5eWl9F3dWyaXL1/GsWPHYGZmJn3Kli0L4NObDuoYGBigUqVKWYrv8/lMTU1hbm6O6OhohTwNGzZE8eLF8ddff8HAwEBtHJSzCsoxfOfOHZXryIrP/zond+zYMfj6+qJw4cIwNzdHjx49EBMTk6lRVO7cuYOiRYuiaNGiUpq7uzusrKwU9oWrq6tCvzxOTk5K5elzHz58gKGhoco+o1RRtX1bt27Ft99+C0dHR5iZmWHy5MlKv2HauBwcHODu7g4dHR2FNHmsly9fxrt372Bra6vwWz58+FD6HUePHo1+/fqhYcOGmDFjhsrf19jYGO/fv9do2+jrdvnyZQQHByscD40bN0ZqaioePnwo5cvqMZqRO3fuwMPDQ+H8VqtWLaSmpuLu3btSWvny5aGrqyt9z6gMEhEVBOXLl1e65lesWFH6rqurC1tbW4X7gPv378Pc3Fw659vY2CAhIUHt/dyHDx8AAEZGRhrFlNV7NhMTE5QoUUJhW1xdXRXebPr8nubKlSsQQqB06dIK17ATJ05I2zJ8+HBMmzYNtWrVgr+/P27cuKEUG+9piDSn3HNcAaWrq4tDhw7h7NmzOHjwIH7//XdMnDgRFy5cgJubG+zt7dGyZUusWrUKxYsXx969exXaFmekV69eePHiBebPnw8XFxcYGhrCy8tLo4761D2ApqamomXLlvj111+Vpjk5OaldnrGxsdIyNY3v8+Y28tjSdpTevHlzbNu2Dbdv31a4gNGXVVCOYSFEhuvT0dFRyqeqn5i0FXKPHj1Cs2bN4Ofnh6lTp8LGxganT59G3759M9XPjBBC5TanTdekPH3Ozs4O79+/R1JSkkYVvmm37/z58+jcuTMCAwPRuHFjWFpaYtOmTZgzZ45CPlVxpRdramoqnJycVB5P8pEKAwIC8P3332PPnj3Yt28f/P39sWnTJrRt21bKGxsbi0KFCmW4XfT1S01NxcCBAzF8+HClacWKFZP+n9VjNCPqyiCAbJVBIqKCICv3AZ6enli/fr3SstRd1+3s7AB8asanybU/q/dsWdkWXV1dXL58WeGPFgCkiqx+/fqhcePG2LNnDw4ePIigoCDMmTNHYWTk2NhYhcowIlKPlVKfkclkqFWrFmrVqoUpU6bAxcUF27dvx+jRowF8OgF17twZRYoUQYkSJVCrVi2Nl33q1CksWrQIzZo1AwA8fvxYZWfO58+fR48ePRS+V6lSReUyq1atim3btsHV1VXlyBSZoWl8mpgxYwbMzMzQoEEDHD9+HO7u7tmKjTRXEI5hd3d36W2vz9fxuUKFCiEsLEwh7dq1a0o3IWldunQJycnJmDNnjvQXwr/++kshj4GBQYajqbi7uyMiIgKPHz+W3pa6ffs23rx5g3LlyqU7b3rkHZHevn1boVNSTZ05cwYuLi6YOHGilPbo0aMsxyNXtWpVREVFQU9PT2EEnbRKly6N0qVLY9SoUejSpQtWrVolVUrJ/5qq7lihr5eqMlG1alXcunULJUuWzNSyNDlGNS2Dq1evRnx8vPQgc+bMGejo6KB06dKZiomIiNJXtWpVbN68WRrsRBMlSpSAhYUFbt++naXzsib3bFlRpUoVpKSkIDo6GrVr11abr2jRolLfWuPHj8eyZcsUKqXCwsLQoUOHbMdDVBCw+d7/u3DhAqZPn45Lly4hIiICISEhePHihcIDpPyvttOmTdO4c2i5kiVLYu3atbhz5w4uXLiArl27wtjYWCnfli1bsHLlSvz777/w9/fHxYsXlTpmlRsyZAhiY2PRpUsXadSqgwcPok+fPpkeglTT+P6vvfsLafoL4zj+0W7EiyJoCV3UwtoSZMxAsCCrNVK7yKiw4osrBC3Q1AjqoknYTSiVkCIRUWSMrZsiL8IF/XGllRviRRfhqM3Ii8iKKDCh4e/i92sw9Fdzyqx8v67P9/AcePhyeHjOOck6d+6cDMOQw+HQy5cvU54HyVsoOVxfX6+enh61trZqeHhYHR0d6unpSRjjcDgUCoXU1dWlcDis06dPTylSTSc3N1ffv39Xe3u7Xr9+rRs3bujSpUsJY8xms75+/ar79+9rbGxs2tZsp9Mpm80mwzA0ODiogYEBuVwubd68edr282SZTCatX79eT548Sen7NWvW6M2bN/L5fHr16pUuXryo27dvpxzPD06nUxs2bNCuXbvk9/sVjUbV398vt9utUCik8fFx1dXV6dGjRxoZGVFfX5+CwWBCbj579izefYc/i9lsViAQ0OjoaLxQffLkST19+lS1tbUaGhpSOBxWd3d3woZ9OsnkqNlsViQS0dDQkMbGxjQxMTFlHsMwlJWVpYMHD+rFixd6+PChjh49qsrKSuXk5Mzd4gEAMgxDy5YtU3l5uR4/fqxIJKLe3l41NDTo7du3036TmZkpp9OZ8p4mmT1bKiwWiwzDkMvl0q1btxSJRBQMBtXS0hJ/Ya+xsVF+v1+RSESDg4N68OBBwp4mGo1qdHRUTqdz1vEACwFFqf8sXrxYgUBAO3bskMVikdvt1vnz51VWVhYfk5mZqUOHDikWiyV0giTj6tWr+vTpkwoKClRZWan6+notX758yrjm5mb5fD7ZbDZdv35dHo/nfzuNVqxYob6+PsViMZWUlCg/P18NDQ1asmRJwjnwuYxvJtra2lRRUSGHw6Hh4eFZzYVfWyg5XFRUpCtXrqi9vV12u1337t2T2+1OGFNSUqKmpiadOHFChYWF+vLlS1LrtdvtunDhglpaWpSfny+Px6OzZ88mjNm4caOOHDmiffv2yWQyqbW1dco8P56mX7p0qYqLi+P3rN28efOXMfxKTU3NtO3xySgvL9exY8dUV1cnu92u/v7++Itns5GRkaG7d++quLhYVVVVslgs2r9/v6LRqHJycrRo0SJ9+PBBLpdLFotFFRUVKisrU3Nzc3wOr9crwzCUnZ0963iQXmfOnFE0GlVubm78CIbNZlNvb6/C4bA2bdqkgoICNTU1/fRouZRcju7Zs0elpaXaunWrTCaTvF7vlHmys7Pl9/v18eNHFRYWau/evdq2bZs6OjrmbuEAAEn//nMDgYBWrlyp3bt3Ky8vT1VVVRofH/9p51RNTY18Pl9Kx6aT2bOl6tq1a3K5XDp+/LisVqt27typ58+fx7vfY7GYamtrlZeXp9LSUlmtVnV2dsa/93q92r59u1atWjUn8QB/u4zJZC5oQVx1dbXevXun7u7u+Q4FSAk5/Gf79u2brFarfD7fX9NV9P79e61bt06hUEirV6+e73AAAEAaTE5OqqioSI2NjTpw4MB8hzMnJiYmtHbtWnm93hldkwEsZNwplaTPnz8rGAzK4/Hozp078x0OMGPk8N8hKytLXV1dKd/59juKRCLq7OykIAUAwAKSkZGhy5cvT/t63Z9qZGREp06doiAFzACdUknasmWLBgYGdPjwYbW1tc13OMCMkcMAAAAAgN8JRSkAAAAAAACkHRedAwAAAAAAIO0oSgEAAAAAACDtKEoBAAAAAAAg7ShKAQAAAAAAIO0oSgEAAAAAACDtKEoBAAAAAAAg7ShKAQAAAAAAIO0oSgEAAAAAACDtKEoBAAAAAAAg7f4BmwciZrkKVDsAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -2557,12 +2630,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [05:53<00:06, 6.91s/it]" + " 99%|████████████████████████████████▋| 100/101 [02:14<00:01, 1.32s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2574,30 +2647,28 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [06:01<00:00, 7.09s/it]\n", - "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.84model snapshot/s]\n" + "100%|█████████████████████████████████| 101/101 [02:16<00:00, 1.35s/it]\n", + "Reindexing: 100%|█████████████| 7/7 [00:01<00:00, 4.72model snapshot/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "The directory `/home/sambray/Documents/moseq_test_proj3` already\n", - "exists. Use `overwrite=True` or pick a different name\n", - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/3230\n", - "c67ed1b7a904a173d32a721f8e4c_ar\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/3230c67ed1b7a904a1\n", + "73d32a721f8e4c/3230c67ed1b7a904a173d32a721f8e4c_ar\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [00:50<00:52, 2.03s/it]" + " 49%|█████████████████▏ | 25/51 [00:31<00:33, 1.27s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2609,12 +2680,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [01:42<00:02, 2.03s/it]" + " 98%|██████████████████████████████████▎| 50/51 [01:04<00:01, 1.27s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2626,7 +2697,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [01:45<00:00, 2.07s/it]\n", + "100%|███████████████████████████████████| 51/51 [01:06<00:00, 1.30s/it]\n", "/home/sambray/mambaforge-pypy3/envs/spyglass-moseq-1/lib/python3.9/site-packages/keypoint_moseq/fitting.py:589: UserWarning:\n", "\n", "'kappa' with will be cast to \n", @@ -2637,20 +2708,54 @@ "name": "stdout", "output_type": "stream", "text": [ - "Outputs will be saved to /home/sambray/Documents/moseq_test_proj3/3230\n", - "c67ed1b7a904a173d32a721f8e4c_ar\n" + "Outputs will be saved to /stelmo/nwb/moseq/projects/3230c67ed1b7a904a1\n", + "73d32a721f8e4c/3230c67ed1b7a904a173d32a721f8e4c_ar\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|████████▍ | 25/101 [00:33<01:40, 1.32s/it]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|████████████████▊ | 50/101 [01:07<01:07, 1.32s/it]" ] }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stderr", "output_type": "stream", "text": [ - " 49%|█████████████████▏ | 25/51 [03:09<02:56, 6.78s/it]" + " 74%|█████████████████████████▏ | 75/101 [01:40<00:34, 1.32s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2662,12 +2767,12 @@ "name": "stderr", "output_type": "stream", "text": [ - " 98%|██████████████████████████████████▎| 50/51 [05:59<00:06, 6.75s/it]" + " 99%|████████████████████████████████▋| 100/101 [02:14<00:01, 1.32s/it]" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2679,8 +2784,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████| 51/51 [06:07<00:00, 7.21s/it]\n", - "Reindexing: 100%|█████████████| 5/5 [00:01<00:00, 4.77model snapshot/s]\n" + "100%|█████████████████████████████████| 101/101 [02:16<00:00, 1.35s/it]\n", + "Reindexing: 100%|█████████████| 7/7 [00:01<00:00, 4.82model snapshot/s]\n" ] } ], @@ -2704,17 +2809,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tutorial_kappa5_mini training results: /home/sambray/Documents/moseq_test_proj3/411c8460ca6c2e53b6e62826b7e49bd7_ar/fitting_progress.pdf\n", - "tutorial_kappa6_mini training results: /home/sambray/Documents/moseq_test_proj3/8b46f4d1412b3b5343c7568134c8ecac_ar/fitting_progress.pdf\n", - "tutorial_kappa7_mini training results: /home/sambray/Documents/moseq_test_proj3/aef642d24bf39d00d34f4f187f20c545_ar/fitting_progress.pdf\n", - "tutorial_kappa8_mini training results: /home/sambray/Documents/moseq_test_proj3/3230c67ed1b7a904a173d32a721f8e4c_ar/fitting_progress.pdf\n" + "tutorial_kappa5_mini training results: /stelmo/nwb/moseq/projects/411c8460ca6c2e53b6e62826b7e49bd7/411c8460ca6c2e53b6e62826b7e49bd7_ar/fitting_progress.pdf\n", + "tutorial_kappa6_mini training results: /stelmo/nwb/moseq/projects/8b46f4d1412b3b5343c7568134c8ecac/8b46f4d1412b3b5343c7568134c8ecac_ar/fitting_progress.pdf\n", + "tutorial_kappa7_mini training results: /stelmo/nwb/moseq/projects/aef642d24bf39d00d34f4f187f20c545/aef642d24bf39d00d34f4f187f20c545_ar/fitting_progress.pdf\n", + "tutorial_kappa8_mini training results: /stelmo/nwb/moseq/projects/3230c67ed1b7a904a173d32a721f8e4c/3230c67ed1b7a904a173d32a721f8e4c_ar/fitting_progress.pdf\n" ] } ], @@ -2732,6 +2837,13 @@ " f\"{new_model_key['model_params_name']} training results: {training_results_path}\"\n", " )" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/notebooks/py_scripts/60_MoSeq.py b/notebooks/py_scripts/60_MoSeq.py index 600fda126..7d9136e48 100644 --- a/notebooks/py_scripts/60_MoSeq.py +++ b/notebooks/py_scripts/60_MoSeq.py @@ -44,8 +44,8 @@ # We can access an example set of keypoint pose data here: # + -# # %load_ext autoreload -# # %autoreload 2 +# %load_ext autoreload +# %autoreload 2 from spyglass.position.position_merge import PositionOutput # Key defining the DLC data we are using @@ -73,7 +73,7 @@ # merge ids to `create_group` # + -from spyglass.behavior.core import PoseGroup +from spyglass.behavior.v1.core import PoseGroup # Define the group name and bodyparts to include in the Moseq model group_name = "tutorial_group" @@ -111,7 +111,7 @@ # ** Note: All bodyparts in the `PoseGroup` entry will be used in the model # + -from spyglass.behavior.moseq import ( +from spyglass.behavior.v1.moseq import ( MoseqModel, MoseqModelParams, MoseqModelSelection, @@ -191,7 +191,7 @@ # + # %load_ext autoreload # %autoreload 2 -from spyglass.behavior.moseq import MoseqSyllableSelection, MoseqSyllable +from spyglass.behavior.v1.moseq import MoseqSyllableSelection, MoseqSyllable # Make a selection table entry defining the pose data and moseq model to use pose_key = ( @@ -287,6 +287,7 @@ for i in [5, 6, 7, 8]: new_params = original_params.copy() new_params["kappa"] = 10**i + new_params["num_epochs"] = 100 new_model_params_name = f"tutorial_kappa{i}_mini" new_params_key = { "model_params_name": new_model_params_name, From d68890aa8b59cf713c1df89092b054d97dae96a8 Mon Sep 17 00:00:00 2001 From: samuelbray32 Date: Tue, 28 Jan 2025 08:48:28 -0800 Subject: [PATCH 42/42] fix for codespell update --- tests/common/test_lab.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/common/test_lab.py b/tests/common/test_lab.py index 0133c2bfe..400ab94b3 100644 --- a/tests/common/test_lab.py +++ b/tests/common/test_lab.py @@ -39,9 +39,9 @@ def add_member_team(common_lab, add_admin): last_name="Basic", ), dict( - lab_member_name="This Loner", + lab_member_name="This Loner", # codespell:ignore loner first_name="This", - last_name="Loner", + last_name="Loner", # codespell:ignore loner ), ], skip_duplicates=True, @@ -55,8 +55,8 @@ def add_member_team(common_lab, add_admin): admin=0, ), dict( - lab_member_name="This Loner", - google_user_name="This Loner", + lab_member_name="This Loner", # codespell:ignore loner + google_user_name="This Loner", # codespell:ignore loner datajoint_user_name="this_loner", admin=0, ),