From 7b4d0146c2dadfe948d8254c475b7a3a56099c35 Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Tue, 21 May 2024 20:25:58 +0000 Subject: [PATCH 01/15] Initial commit --- code/aind_ccf_reg/__init__.py | 2 +- code/aind_ccf_reg/configs.py | 144 +++++++++++ code/aind_ccf_reg/plots.py | 202 +++++++++++++++ code/aind_ccf_reg/preprocess.py | 294 +++++++++++++++++++++ code/aind_ccf_reg/register.py | 440 ++++++++++++++++++++------------ code/aind_ccf_reg/utils.py | 27 +- code/main.py | 167 +++++++----- 7 files changed, 1046 insertions(+), 230 deletions(-) create mode 100644 code/aind_ccf_reg/configs.py create mode 100644 code/aind_ccf_reg/plots.py create mode 100644 code/aind_ccf_reg/preprocess.py diff --git a/code/aind_ccf_reg/__init__.py b/code/aind_ccf_reg/__init__.py index ead3795..a6494be 100644 --- a/code/aind_ccf_reg/__init__.py +++ b/code/aind_ccf_reg/__init__.py @@ -1,3 +1,3 @@ """CCF Registration package. """ -__version__ = "0.0.17" +__version__ = "0.0.18" diff --git a/code/aind_ccf_reg/configs.py b/code/aind_ccf_reg/configs.py new file mode 100644 index 0000000..e32e81b --- /dev/null +++ b/code/aind_ccf_reg/configs.py @@ -0,0 +1,144 @@ +""" +This config file points to data directories, defines global variables, specify schema format for +Preprocess and Registration. +""" + +from pathlib import Path +from typing import Dict, Hashable, List, Sequence, Tuple, Union +import dask +import numpy as np +from argschema import ArgSchema +from argschema.fields import Dict as sch_dict +from argschema.fields import Int +from argschema.fields import List as sch_list +from argschema.fields import Str + +PathLike = Union[str, Path] +ArrayLike = Union[dask.array.core.Array, np.ndarray] + +VMIN = 0 +VMAX = 1.5 + +class RegSchema(ArgSchema): + """ + Schema format for Preprocess and Registration. + """ + + input_data = Str( + metadata={ + "required": True, + "description": "Input data without timestamp", + } + ) + + input_channel = Str( + metadata={"required": True, "description": "Channel to register"} + ) + + input_scale = Int( + metadata={"required": True, "description": "Zarr scale to start with"} + ) + + input_orientation = sch_list( + cls_or_instance=sch_dict, + metadata={ + "required": True, + "description": "Brain orientation during aquisition", + }, + ) + + template_path = Str( + metadata={"required": True, "description": "Path to the SPIM template"} + ) + + ccf_reference_path = Str( + metadata={"required": True, "description": "Path to the CCF template"} + ) + + template_to_ccf_transform_path = sch_list( + cls_or_instance=Str, + metadata={ + "required": True, + "description": "Path to the transform that aligns SPIM template to CCF"} + ) + + output_data = Str( + metadata={"required": True, "description": "Output file"} + ) + + reg_folder = Str( + metadata={"required": True, "description": "Folder to save registration results"} + ) + + bucket_path = Str( + required=True, + metadata={"description": "Amazon Bucket or Google Bucket name"}, + ) + + code_url = Str( + metadata={"required": True, "description": "CCF registration URL"} + ) + + metadata_folder = Str( + metadata={"required": True, "description": "Metadata folder"} + ) + + OMEZarr_params = sch_dict( + metadata={ + "required": True, + "description": "OMEZarr writing parameters", + } + ) + + prep_params = sch_dict( + metadata={ + "required": True, + "description": "raw data preprocessing parameters", + } + ) + + ants_params = sch_dict( + metadata={ + "required": True, + "description": "ants registering parameters", + } + ) + + reference_res = Int( + metadata={ + "required": True, + "description": "Voxel Resolution of reference in microns", + } + ) + + #-------------- DO we need to pass transforms to next capsule-------------------------# + downsampled_file = Str( + metadata={"required": True, "description": "Downsampled file"} + ) + + downsampled16bit_file = Str( + metadata={"required": True, "description": "Downsampled 16bit file"} + ) + + # affine_transforms_file = Str( + # metadata={ + # "required": True, + # "description": "Output forward affine Transforms file", + # } + # ) + + # ls_ccf_warp_transforms_file = Str( + # metadata={ + # "required": True, + # "description": "Output inverse warp Transforms file", + # } + # ) + + # ccf_ls_warp_transforms_file = Str( + # metadata={ + # "required": True, + # "description": "Output forward warp Transforms file", + # } + # ) + #-------------- TODO end-----------------------# + diff --git a/code/aind_ccf_reg/plots.py b/code/aind_ccf_reg/plots.py new file mode 100644 index 0000000..94f8a15 --- /dev/null +++ b/code/aind_ccf_reg/plots.py @@ -0,0 +1,202 @@ +""" +Plot functions for easy and fast visualiztaion of images and regsitration results +""" +import matplotlib.pyplot as plt +import numpy as np + +def plot_antsimgs(ants_img, figpath, title="", vmin=0, vmax=500): + """ + Plot ANTs image + + Parameters + ------------ + ants_img: ANTsImage + figpath: PathLike + Path where the plot is going to be saved + title: str + Figure title + vmin: float + Set the color limits of the current image. + vmax: float + Set the color limits of the current image. + """ + + if figpath: + ants_img = ants_img.numpy() + half_size = np.array(ants_img.shape) // 2 + fig, ax = plt.subplots(1, 3, figsize=(10, 6)) + ax[0].imshow(ants_img[half_size[0], :, :], cmap='gray', vmin=vmin, vmax=vmax) + ax[1].imshow(ants_img[:, half_size[1], :], cmap='gray', vmin=vmin, vmax=vmax) + im = ax[2].imshow(ants_img[:,:, half_size[2],], cmap='gray', vmin=vmin, vmax=vmax) + fig.suptitle(title, y=0.9) + plt.colorbar(im, ax=ax.ravel().tolist(), fraction=0.1, pad=0.025, shrink=0.7) + plt.savefig(figpath, bbox_inches = 'tight', pad_inches = 0.1) + +def plot_reg(moving, fixed, warped, figpath, title="", loc=0, vmin=0, vmax=1.5): + """ + Plot registration results: moving, fixed, deformed, + overlay and difference images after registration + + Parameters + ------------ + moving: ANTsImage + Moving image + fixed: ANTsImage + Fixed image + warped: ANTsImage + Deformed image + figpath: PathLike + Path where the plot is going to be saved + title: str + Figure title + loc: int + Visualization direction + vmin, vmax: float + Set the color limits of the current image. + """ + + if loc >= len(moving.shape): + raise ValueError( + f"loc {loc} is not allowed, should be less than are {len(moving.shape)}" + ) + + half_size_moving = np.array(moving.shape) // 2 + half_size_fixed = np.array(fixed.shape) // 2 + half_size_warped = np.array(warped.shape) // 2 + + if loc == 0: + moving = moving.view()[half_size_moving[0], :, :] + fixed = fixed.view()[half_size_fixed[0], :, :] + warped = warped.view()[half_size_warped[0], :, :] + y = 0.75 + elif loc == 1: + # moving = np.rot90(moving.view()[:,half_size[1], :], 3) + moving = moving.view()[:,half_size_moving[1], :] + fixed = fixed.view()[:,half_size_fixed[1], :] + warped = warped.view()[:,half_size_warped[1], :] + y = 0.82 + elif loc == 2: + moving = np.rot90(np.fliplr(moving.view()[:, :, half_size_moving[2]])) + fixed = np.rot90(np.fliplr(fixed.view()[:, :, half_size_fixed[2]])) + warped = np.rot90(np.fliplr(warped.view()[:, :, half_size_warped[2]])) + y = 0.82 + else: + raise ValueError( + f"loc {loc} is not allowed. Allowed values are: 0, 1, 2") + + # combine deformed and fixed images to an RGB image + overlay = np.stack( (warped, fixed, warped), axis=2 ) + diff = fixed - warped + + fontsize = 14 + + fig, ax = plt.subplots(1, 5, figsize=(16, 6)) + ax[0].imshow(moving, cmap='gray', vmin=vmin, vmax=vmax) + ax[1].imshow(fixed, cmap='gray', vmin=vmin, vmax=vmax) + ax[2].imshow(warped, cmap='gray', vmin=vmin, vmax=vmax) + ax[3].imshow(overlay) + ax[4].imshow(diff, cmap='gray', vmin=-(vmax), vmax=vmax) + + ax[0].set_title("Moving", fontsize=fontsize) + ax[1].set_title("Fixed", fontsize=fontsize) + ax[2].set_title("Deformed", fontsize=fontsize) + ax[3].set_title("Deformed Overlay Fixed", fontsize=fontsize) + ax[4].set_title("Fixed - Deformed", fontsize=fontsize) + + fig.suptitle(title, size = 18, y=y) + + if figpath: + plt.savefig(figpath, bbox_inches = 'tight', pad_inches = 0.01) + plt.close() + else: + fig.show() + + +def plot_reg_before_after(moving, fixed, warped, figpath, title="", loc=0, vmin=0, vmax=1.5): + """ + if moving and fixed images have same dimension, + plot registration results: moving, fixed, deformed, + overlay and difference images before and after registration + + Parameters + ------------ + moving: ANTsImage + Moving image + fixed: ANTsImage + Fixed image + warped: ANTsImage + Deformed image + figpath: PathLike + Path where the plot is going to be saved + title: str + Figure title + loc: int + Visualization direction + vmin, vmax: float + Set the color limits of the current image. + """ + + if loc >= len(moving.shape): + raise ValueError( + f"loc {loc} is not allowed, should be less than are {len(moving.shape)}" + ) + + half_size_moving = np.array(moving.shape) // 2 + half_size_fixed = np.array(fixed.shape) // 2 + half_size_warped = np.array(warped.shape) // 2 + + if loc == 0: + moving = moving.view()[half_size_moving[0], :, :] + fixed = fixed.view()[half_size_fixed[0], :, :] + warped = warped.view()[half_size_warped[0], :, :] + y = 0.85 + elif loc == 1: + # moving = np.rot90(moving.view()[:,half_size[1], :], 3) + moving = moving.view()[:,half_size_moving[1], :] + fixed = fixed.view()[:,half_size_fixed[1], :] + warped = warped.view()[:,half_size_warped[1], :] + y = 0.85 + elif loc == 2: + moving = np.rot90(np.fliplr(moving.view()[:, :, half_size_moving[2]])) + fixed = np.rot90(np.fliplr(fixed.view()[:, :, half_size_fixed[2]])) + warped = np.rot90(np.fliplr(warped.view()[:, :, half_size_warped[2]])) + y = 0.85 + else: + raise ValueError( + f"loc {loc} is not allowed. Allowed values are: 0, 1, 2") + + # combine deformed and fixed images to an RGB image + # green: fixed image, magenta: moving/moved image + overlay0 = np.stack( (moving, fixed, moving), axis=2 ) # before registration + overlay1 = np.stack( (warped, fixed, warped), axis=2 ) # after registration + + diff0 = fixed - moving + diff1 = fixed - warped + + fontsize = 14 + + fig, ax = plt.subplots(1, 7, figsize=(20, 6)) + ax[0].imshow(moving, cmap='gray', vmin=vmin, vmax=vmax) + ax[1].imshow(fixed, cmap='gray', vmin=vmin, vmax=vmax) + ax[2].imshow(warped, cmap='gray', vmin=vmin, vmax=vmax) + ax[3].imshow(overlay0) + ax[4].imshow(diff0, cmap='gray', vmin=-(vmax), vmax=vmax) + ax[5].imshow(overlay1) + ax[6].imshow(diff1, cmap='gray', vmin=-(vmax), vmax=vmax) + + ax[0].set_title("Moving", fontsize=fontsize) + ax[1].set_title("Fixed", fontsize=fontsize) + ax[2].set_title("Deformed", fontsize=fontsize) + ax[3].set_title("Before registration\nDeformed Overlay Fixed", fontsize=fontsize-2) + ax[4].set_title("Before registration\nFixed - Deformed", fontsize=fontsize-2) + ax[5].set_title("After registration\nDeformed Overlay Fixed", fontsize=fontsize-2) + ax[6].set_title("After registration\nFixed - Deformed", fontsize=fontsize-2) + + fig.suptitle(title, size = 18, y=y) + + if figpath: + plt.savefig(figpath, bbox_inches = 'tight', pad_inches = 0.01) + # plt.close() + else: + fig.show() + \ No newline at end of file diff --git a/code/aind_ccf_reg/preprocess.py b/code/aind_ccf_reg/preprocess.py new file mode 100644 index 0000000..8583aab --- /dev/null +++ b/code/aind_ccf_reg/preprocess.py @@ -0,0 +1,294 @@ +""" +Preprocess lightsheet data +""" +import logging +from datetime import datetime + +import ants +import matplotlib.pyplot as plt +import numpy as np +import scipy +from aind_ccf_reg.plots import plot_antsimgs + +import scipy.ndimage as ni +from skimage.filters import threshold_li +from skimage.measure import label +from skimage import io +import tifffile + +from pathlib import Path + +from aind_ccf_reg.configs import VMIN, VMAX +from aind_ccf_reg.configs import PathLike + + +LOG_FMT = "%(asctime)s %(message)s" +LOG_DATE_FMT = "%Y-%m-%d %H:%M" + +logging.basicConfig(format=LOG_FMT, datefmt=LOG_DATE_FMT) +logger = logging.getLogger(__name__) +logger.setLevel(logging.INFO) + +def perc_normalization(ants_img): + """ + Percentile Normalization + + Parameters + ------------- + ants_img: ANTsImage + + Returns + ----------- + ANTsImage + """ + percentiles = [2, 98] + percentile_values = np.percentile(ants_img.view(), percentiles) + ants_img = (ants_img - percentile_values[0]) / (percentile_values[1] - percentile_values[0]) + + return ants_img + +def write_and_plot_image(ants_img, data_path=None, plot_path=None, vmin=VMIN, vmax=VMAX): + """ + Write and plot ants image + + Parameters + ------------- + ants_img: ANTsImage + data_path: PathLike + Path where the ANTsImage to be saved + plot_path: PathLike + Path where the plot of ANTsImage to be saved + vmin, vmax: float + Set the color limits of the current image. + """ + if plot_path: + title = plot_path.split("/")[-1].split(".")[0] + plot_antsimgs(ants_img, plot_path, title, vmin=vmin, vmax=vmax) + + if data_path: + ants.image_write(ants_img, data_path) + + +class Masking: + """ + Class to compute the mask on the ANTsImage + """ + def __init__(self, ants_img): + self.ants_img = ants_img + + def _getLargestCC(self, segmentation): + labels = label(segmentation) + assert( labels.max() != 0 ) # assume at least 1 CC + largestCC = labels == np.argmax(np.bincount(labels.flat)[1:])+1 + + return largestCC + + def _get_threshold_li(self, arr_img: np.ndarray) -> float: + """ get the optimal threshold using Li thresholding """ + start_time = datetime.now() + low_thresh = threshold_li(arr_img) + end_time = datetime.now() + + logger.info( + f"Find optimal threshold using Li thresholding, execution time: {end_time - start_time} s -- low_thresh={low_thresh}" + ) + return low_thresh + + def _cleanup_mask(self, arr_mask: np.ndarray) -> np.ndarray: + """ + Morphological operations will be applied to clean up the mask by closing holes and + eroding away small or weakly-connected areas. The following steps are applied: + - Closing holes + - Dilation with radius 1 voxel + - Morphological closing + - Retain largest component + """ + # 3x3 structuring element with connectivity 2 + struct = ni.generate_binary_structure(3, 2) + + mask = ni.binary_fill_holes(arr_mask).astype(int) + mask = ni.binary_dilation(mask, structure=struct).astype(int) + mask = ni.binary_closing(mask).astype(int) + mask = self._getLargestCC(mask) + + mask = ni.binary_dilation(mask, structure=struct, iterations=6).astype(int) + arr_mask = ni.binary_fill_holes(mask).astype(int) + + return arr_mask + + + def run(self) -> np.ndarray: + """ compute the mask """ + arr_img = self.ants_img.numpy() + + # get optimal threshold using Li thresholding + # https://scikit-image.org/docs/stable/auto_examples/developers/plot_threshold_li.html + low_thresh = self._get_threshold_li(arr_img) + + # thresholding + arr_mask = arr_img > low_thresh + + # clean up + arr_mask = self._cleanup_mask(arr_mask) + + # convert numpy array to ants image + ants_img_mask = ants.from_numpy( + arr_mask.astype("float32"), + spacing=self.ants_img.spacing, + origin=self.ants_img.origin, + direction=self.ants_img.direction) + + return ants_img_mask + + +class Preprocess(): + """ + Class to Preprocess lightsheet data + 1. resample to isotropic to have same resolution of the SPIM template + 2. N4 bias correction + 3. intensity normalization + """ + def __init__(self, args, input_data, reference_data): + self.args = args + self.input_data = input_data + self.reference_data = reference_data + + def resample(self, ants_img, ants_template): + """ Resample OMEZarr image to the resolution of template """ + logger.info(f"Resample OMEZarr image to the resolution of template") + ants_img = ants.resample_image( + ants_img, ants_template.spacing, False, 1 + ) + + logger.info(f"Resampled OMEZarr dataset: {ants_img}") + + # #------------- TODO: do we need? -------------# + + # logger.info(f"Size of resampled image: {ants_img.shape}") + + # # convert input data to tiff into reference voxel resolution + # downsampled_file_path = Path( + # f"{self.args['metadata_folder']}/{self.args['downsampled_file']}" + # ) + # ants.image_write(ants_img, str(downsampled_file_path)) + + # # convert data to uint16 + # im = io.imread(str(downsampled_file_path)).astype(np.uint16) + # downsampled16bit_file_path = Path( + # f"{self.args['metadata_folder']}/{self.args['downsampled16bit_file']}" + # ) + # tifffile.imwrite(str(downsampled16bit_file_path), im) + # #------------- TODO end -------------# + + write_and_plot_image( + ants_img, + plot_path=self.args["prep_params"].get("resample_figpath"), vmin=0, vmax=500) + + return ants_img + + + def compute_mask(self, ants_img): + """ compute make """ + logger.info("Computing Mask") + + start_time = datetime.now() + mask = Masking(ants_img) + ants_img_mask = mask.run() + end_time = datetime.now() + + logger.info( + f"Mask Complete, execution time: {end_time - start_time} s -- image {ants_img_mask}" + ) + + write_and_plot_image( + ants_img_mask, + data_path=self.args["prep_params"].get("mask_path"), + plot_path=self.args["prep_params"].get("mask_figpath"), + vmin=0, vmax=1) + + return ants_img_mask + + + def compute_N4(self, ants_img, ants_img_mask): + """ compute N4 """ + logger.info("Computing N4") + n4_bias_params = { + "rescale_intensities": False, + "shrink_factor": 4, + "convergence": {"iters": [50, 50, 50, 50], "tol": 1e-7}, + # "spline_param": 15000, # TODO + "return_bias_field": False, + "verbose": False, + "weight_mask": None, + } + + logger.info(f"Parameters -> {n4_bias_params}") + start_time = datetime.now() + ants_img_n4 = ants.utils.n4_bias_field_correction( + ants_img, mask=ants_img_mask, **n4_bias_params + ) + end_time = datetime.now() + + logger.info( + f"N4 Complete, execution time: {end_time - start_time} s -- image {ants_img_n4}" + ) + + write_and_plot_image( + ants_img_n4, + data_path=self.args["prep_params"].get("n4bias_path"), + plot_path=self.args["prep_params"].get("n4bias_figpath"), vmin=0, vmax=500) + + # Compute the difference between ants_img and ants_img_n4 + ants_img_intensity_difference = ants_img - ants_img_n4 + + write_and_plot_image( + ants_img_intensity_difference, + data_path=self.args["prep_params"].get("img_diff_n4bias_path"), + plot_path=self.args["prep_params"].get("img_diff_n4bias_figpath"), vmin=0, vmax=200) + + return ants_img_n4 + + + def intensity_norm(self, ants_img): + """ compute percential normalization """ + logger.info("Start intensity normalization") + start_time = datetime.now() + ants_img = perc_normalization(ants_img) + end_time = datetime.now() + logger.info( + f"Intensity normalization complete, execution time: {end_time - start_time} s -- image {ants_img}" + ) + + write_and_plot_image( + ants_img, + data_path=self.args["prep_params"].get("percNorm_path"), + plot_path=self.args["prep_params"].get("percNorm_figpath"), vmin=VMIN, vmax=VMAX) + + return ants_img + + + def run(self) -> str: + start_date_time = datetime.now() + + ants_img = self.resample(self.input_data, self.reference_data) + ants_img_mask = self.compute_mask(ants_img) + ants_img = ants_img * ants_img_mask + ants_img = self.compute_N4(ants_img, ants_img_mask) + ants_img = self.intensity_norm(ants_img) + + end_date_time = datetime.now() + logger.info(f"Preprocessing complete, execution time: {end_date_time - start_date_time} s") + + return ants_img + +def main(input_config: dict): + """ + Main function to execute + """ + + mod = Preprocess(input_config) + return mod.run() + + +if __name__ == "__main__": + main() diff --git a/code/aind_ccf_reg/register.py b/code/aind_ccf_reg/register.py index a9244e7..e117806 100644 --- a/code/aind_ccf_reg/register.py +++ b/code/aind_ccf_reg/register.py @@ -1,5 +1,16 @@ """ -CCF registration of an image to the Allen Institute's atlas +Register an lightsheet data to the Allen Institute's CCF atlas via the SPIM template + +Pipeline: +(1) preprocessing an brain image +(2) rigid + SyN registration: register the preprocessed brain image to the SPIM template +(3) apply transform to align deformed image from (2) to the CCF template + +Quality control on registration: +(1) visualization: plot the overlay/difference image between deformed and fixed images +(2) TODO: compute the similarity metics to automatically detect registration failure + +# TODO: need to pass transforms that aligns brain image to CCF to aind-smartspim-cell-quantification capsule """ import logging import multiprocessing @@ -20,22 +31,24 @@ from aicsimageio.types import PhysicalPixelSizes from aicsimageio.writers import OmeZarrWriter from aind_data_schema.core.processing import DataProcess, ProcessName -from argschema import ArgSchema, ArgSchemaParser -from argschema.fields import Dict as sch_dict -from argschema.fields import Int -from argschema.fields import List as sch_list -from argschema.fields import Str +from argschema import ArgSchemaParser from dask.distributed import Client, LocalCluster, performance_report from distributed import wait from numcodecs import blosc from skimage import io -from .__init__ import __version__ -from .utils import check_orientation, create_folder, generate_processing +from .__init__ import __version__ blosc.use_threads = False -PathLike = Union[str, Path] -ArrayLike = Union[dask.array.core.Array, np.ndarray] + +from aind_ccf_reg.utils import check_orientation, create_folder, generate_processing +from aind_ccf_reg.configs import PathLike, ArrayLike +from aind_ccf_reg.configs import VMIN, VMAX +from aind_ccf_reg.configs import RegSchema +from aind_ccf_reg.plots import plot_antsimgs, plot_reg, plot_reg_before_after +from aind_ccf_reg.preprocess import perc_normalization +from aind_ccf_reg.preprocess import write_and_plot_image +from aind_ccf_reg.preprocess import Preprocess LOG_FMT = "%(asctime)s %(message)s" LOG_DATE_FMT = "%Y-%m-%d %H:%M" @@ -127,111 +140,10 @@ def get_pyramid_metadata() -> dict: } -class RegSchema(ArgSchema): - """ - Schema format for Registration. - """ - - input_data = Str( - metadata={ - "required": True, - "description": "Input data without timestamp", - } - ) - - input_channel = Str( - metadata={"required": True, "description": "Channel to register"} - ) - - input_scale = Int( - metadata={"required": True, "description": "Zarr scale to start with"} - ) - - input_orientation = sch_list( - cls_or_instance=sch_dict, - metadata={ - "required": True, - "description": "Brain orientation during aquisition", - }, - ) - - reference = Str( - metadata={"required": True, "description": "Reference image"} - ) - - output_data = Str( - metadata={"required": True, "description": "Output file"} - ) - - bucket_path = Str( - required=True, - metadata={"description": "Amazon Bucket or Google Bucket name"}, - ) - - code_url = Str( - metadata={"required": True, "description": "CCF registration URL"} - ) - - metadata_folder = Str( - metadata={"required": True, "description": "Metadata folder"} - ) - - OMEZarr_params = sch_dict( - metadata={ - "required": True, - "description": "OMEZarr writing parameters", - } - ) - - ants_params = sch_dict( - metadata={ - "required": True, - "description": "ants registering parameters", - } - ) - - downsampled_file = Str( - metadata={"required": True, "description": "Downsampled file"} - ) - - downsampled16bit_file = Str( - metadata={"required": True, "description": "Downsampled 16bit file"} - ) - - reference_res = Int( - metadata={ - "required": True, - "description": "Voxel Resolution of reference in microns", - } - ) - - affine_transforms_file = Str( - metadata={ - "required": True, - "description": "Output forward affine Transforms file", - } - ) - - ls_ccf_warp_transforms_file = Str( - metadata={ - "required": True, - "description": "Output inverse warp Transforms file", - } - ) - - ccf_ls_warp_transforms_file = Str( - metadata={ - "required": True, - "description": "Output forward warp Transforms file", - } - ) - - class Register(ArgSchemaParser): """ Class to Register lightsheet data to CCF atlas """ - default_schema = RegSchema def __read_zarr_image(self, image_path: PathLike) -> np.array: @@ -254,6 +166,197 @@ def __read_zarr_image(self, image_path: PathLike) -> np.array: img_array = np.squeeze(img_array) return img_array + def _qc_reg(self, ants_moving, ants_fixed, ants_moved, moved_path: PathLike=None, figpath_name: str="reg") -> None: + """ + Quality control on registration results and write deformed image. + The plots will be saved to the same folder as the deformed image. + + Parameters + ------------- + ants_fixed: ANTsImage + fixed image + ants_moving: ANTsImage + moving image + ants_moved: ANTsImage + deformed image + moved_path: PathLike + Path to save deformed image + figpath_name: str + figpath name + """ + # plot moving, fixed, moved, overlaid, difference images in three directions + figpath = f"{self.args['reg_folder']}/{figpath_name}" + logger.info(f"Plot registration results: {figpath}") + + if np.any(ants_moving.direction != ants_fixed.direction): + logger.info(f"Reorient moving image direction to fixed image direction ...") + ants_moving = ants.reorient_image2(ants_moving, orientation=ants.get_orientation(ants_fixed)) + logger.info(f"Reoriented moving image -- {ants_moving}") + + for loc in [0, 1, 2]: + plot_args = (ants_moving, ants_fixed, ants_moved, f"{figpath}_{loc}") + plot_kwargs = {"title": figpath_name, "loc": loc, "vmin": VMIN, "vmax": VMAX} + + if np.all(ants_moving.shape == ants_fixed.shape): + # moving and fixed images have same dimension + plot_reg_before_after(*plot_args, **plot_kwargs) + else: + # moving and fixed images do not have same dimension + plot_reg(*plot_args, **plot_kwargs) + + # plot moved image + if moved_path: + figpath = moved_path.replace(".nii.gz", "") + title = moved_path.replace(".nii.gz", "").split("/")[-1] + logger.info(f"Plot aligned image: {figpath}, title: {title}") + plot_antsimgs(ants_moved, figpath, title, vmin=VMIN, vmax=VMAX) + + logger.info(f"Saving aligned image: {moved_path}") + ants.image_write(ants_moved, moved_path) + logger.info("Done saving") + + def rigid_register(self, ants_fixed, ants_moving): + """ Run rigid regsitration to align brain image to SPIM template + + Parameters + ------------- + ants_fixed: ANTsImage + fixed image + ants_moving: ANTsImage + moving image + + Returns + ----------- + ANTsImage + deformed image + """ + logger.info(f"\nStart computing rigid registration ....") + + # run registration + start_time = datetime.now() + registration_params = { + "fixed": ants_fixed, + "moving": ants_moving, + "type_of_transform": "Rigid", + "outprefix": f"{self.args['reg_folder']}/rigid_", + "mask_all_stages": True, + "grad_step": 0.25, + "reg_iterations": (60, 40, 20, 0), + "aff_metric": "mattes" + } + + logger.info(f"Computing rigid registration with parameters: {registration_params}") + reg = ants.registration(**registration_params) + end_time = datetime.now() + logger.info(f"Rigid registration Complete, execution time: {end_time - start_time} s -- image {reg}") + + ants_moved = reg["warpedmovout"] + + reg_task = "reg_rigid" + self._qc_reg(ants_moving, + ants_fixed, + ants_moved, + moved_path=self.args["ants_params"]["rigid_path"], + figpath_name=reg_task) + + return ants_moved + + + def register_to_template(self, ants_fixed, ants_moving): + """ + Run SyN regsitration to align brain image to SPIM template + + Parameters + ------------- + ants_fixed: ANTsImage + fixed image + ants_moving: ANTsImage + moving image + + Returns + ----------- + ANTsImage + deformed image + """ + logger.info(f"\nStart registering to template ....") + + if self.args['reference_res'] == 25: + reg_iterations = [100, 10, 0] # TODO + # reg_iterations = [1, 0, 0, 0] + elif self.args['reference_res'] == 10: + reg_iterations = [400, 200, 40, 0] + else: + raise ValueError( + f"Resolution {self.args['reference_res']} is not allowed. Allowed values are: 10, 25" + ) + + start_time = datetime.now() + registration_params = { + "fixed": ants_fixed, + "moving": ants_moving, + "syn_metric": "CC", + "syn_sampling": 2, + "reg_iterations": reg_iterations, + "outprefix": f"{self.args['reg_folder']}/"} + + logger.info(f"Computing SyN registration with parameters: {registration_params}") + reg = ants.registration(**registration_params) + end_time = datetime.now() + logger.info(f"SyN registration complete, execution time: {end_time - start_time} s -- image {reg}") + + ants_moved = reg["warpedmovout"] + + reg_task = "reg_to_template" + self._qc_reg(ants_moving, + ants_fixed, + ants_moved, + moved_path=self.args["ants_params"]["moved_to_template_path"], + figpath_name=reg_task) + + return ants_moved + + def register_to_ccf(self, ants_fixed, ants_moving): + """ + Run manual regsitration to align brain image to CCF template + + Parameters + ------------- + ants_fixed: ANTsImage + fixed image + ants_moving: ANTsImage + moving image + + Returns + ----------- + ANTsImage + deformed image + """ + logger.info("\nStart registering to CCF ....") + logger.info(f"Register to CCF with: {self.args['template_to_ccf_transform_path']}") + + # for visualizing registration results + ants_fixed = perc_normalization(ants_fixed) + + start_time = datetime.now() + ants_moved = ants.apply_transforms( + fixed = ants_fixed, + moving = ants_moving , + transformlist=self.args["template_to_ccf_transform_path"] + ) + end_time = datetime.now() + + logger.info(f"Register to CCF, execution time: {end_time - start_time} s -- image {ants_moved}") + + reg_task = "reg_to_ccf" + self._qc_reg(ants_moving, + ants_fixed, + ants_moved, + moved_path=self.args["ants_params"]["moved_to_ccf_path"], + figpath_name=reg_task) + + return ants_moved + + def atlas_alignment( self, img_array: np.array, ants_params: dict ) -> np.array: @@ -262,19 +365,32 @@ def atlas_alignment( Parameters ------------ - img_array: np.array Array with the image ants_params: dict Dictionary with ants parameters """ - # get data orientation + #----------------------------------# + # load SPIM template + CCF + #----------------------------------# + + logger.info("Reading reference images") + ants_template = ants.image_read(os.path.abspath(self.args["template_path"])) # SPIM template + ants_ccf = ants.image_read(os.path.abspath(self.args["ccf_reference_path"])) # CCF template + logger.info(f"Loaded SPIM template {ants_template}") + logger.info(f"Loaded CCF template {ants_ccf}") + + + #----------------------------------# + # orient data to SPIM template's direction + #----------------------------------# + img_array = img_array.astype(np.double) img_out, in_mat, out_mat = check_orientation( img_array, self.args["input_orientation"], - self.args["ants_params"]["orientations"], + self.args["ants_params"]["template_orientations"], ) logger.info( @@ -284,52 +400,40 @@ def atlas_alignment( f"Output image dimensions: {img_out.shape} \nOutput image orientation: {out_mat}" ) - # convert input data to tiff into reference voxel resolution ants_img = ants.from_numpy(img_out, spacing=ants_params["spacing"]) - fillin = ants.resample_image( - ants_img, ants_params["new_spacing"], False, 1 - ) - logger.info(f"Size of resampled image: {fillin.shape}") - - downsampled_file_path = Path( - f"{self.args['metadata_folder']}/{self.args['downsampled_file']}" - ) - ants.image_write(fillin, str(downsampled_file_path)) - - # convert data to uint16 - im = io.imread(str(downsampled_file_path)).astype(np.uint16) - - downsampled16bit_file_path = Path( - f"{self.args['metadata_folder']}/{self.args['downsampled16bit_file']}" - ) - - tifffile.imwrite(str(downsampled16bit_file_path), im) - # read images - logger.info("Reading reference image") - img1 = ants.image_read(os.path.abspath(self.args["reference"])) - img2 = ants.image_read(str(downsampled16bit_file_path)) - - # register with ants - reg12 = ants.registration( - img1, img2, "SyN", reg_iterations=[100, 10, 0] - ) - - # output - shutil.copy( - reg12["fwdtransforms"][0], - self.args["ccf_ls_warp_transforms_file"], - ) - shutil.copy( - reg12["fwdtransforms"][1], - self.args["affine_transforms_file"], - ) - shutil.copy( - reg12["invtransforms"][1], - self.args["ls_ccf_warp_transforms_file"], - ) - - return reg12["warpedmovout"].numpy() - + ants_img.set_direction(ants_template.direction) + ants_img.set_origin(ants_template.origin) + + write_and_plot_image( + ants_img, + data_path=self.args["prep_params"].get("rawdata_path"), + plot_path=self.args["prep_params"].get("rawdata_figpath"), vmin=0, vmax=500) + + #----------------------------------# + # run preprocessing on raw data + #----------------------------------# + + prep = Preprocess(self.args, ants_img, ants_template) + ants_img = prep.run() + logger.info(f"Preprocessed input data {ants_img}") + + #----------------------------------# + # register brain image to CCF + #----------------------------------# + # ants_img = ants.image_read(self.args["prep_params"].get("percNorm_path")) # + + # register to SPIM template: rigid + SyN + rigid_image = self.rigid_register(ants_template, ants_img) + aligned_image = self.register_to_template(ants_template, rigid_image) + + # aligned_image = ants.image_read(self.args["ants_params"].get("moved_to_template_path")) # + + # register to CCF template: apply manual regsitration + aligned_image = self.register_to_ccf(ants_ccf, aligned_image) + + return aligned_image.numpy() + + def write_zarr( self, img_array: np.array, @@ -444,19 +548,21 @@ def run(self) -> str: """ Runs CCF registration """ - # Creating output folders input_data_path = os.path.abspath(self.args["input_data"]) output_data_path = os.path.abspath(self.args["output_data"]) metadata_path = os.path.abspath(self.args["metadata_folder"]) - reference_path = os.path.abspath(self.args["reference"]) + reg_folder = os.path.abspath(self.args["reg_folder"]) # save registration results # input_data_path = glob(f"{input_data_path}_stitched_*/")[0] logger.info( - f"Input data: {input_data_path}\nOutput data: {output_data_path}\nMetadata path: {metadata_path} reference: {reference_path}" + f"Input data: {input_data_path}\nOutput data: {output_data_path}\nMetadata path: {metadata_path}" ) - + + logger.info(f"Regsitration results save to: {reg_folder}") + create_folder(output_data_path) + create_folder(reg_folder) create_folder(metadata_path) # read input data (lazy loading) @@ -514,7 +620,7 @@ def run(self) -> str: self.args["reference_res"], self.args["reference_res"], ) - ants_params["reference"] = reference_path + aligned_image = self.atlas_alignment(img_array, ants_params) end_date_time = datetime.now() @@ -525,7 +631,7 @@ def run(self) -> str: start_date_time=start_date_time, end_date_time=end_date_time, input_location=str(image_path), - output_location=str(image_path), + output_location=str(reg_folder), outputs={}, code_url="https://github.com/ANTsX/ANTs", code_version=ants.__version__, @@ -546,6 +652,7 @@ def run(self) -> str: } aligned_image_dask = da.from_array(aligned_image) + self.write_zarr( img_array=aligned_image_dask, # dask array physical_pixel_sizes=ants_params["new_spacing"], @@ -583,7 +690,7 @@ def run(self) -> str: generate_processing( data_processes=data_processes, dest_processing=metadata_path, - processor_full_name="Camilo Laiton", + processor_full_name="Di Wang, Camilo Laiton", pipeline_version="1.5.0", ) @@ -594,7 +701,6 @@ def main(input_config: dict): """ Main function to execute """ - mod = Register(input_config) return mod.run() diff --git a/code/aind_ccf_reg/utils.py b/code/aind_ccf_reg/utils.py index 5980b36..62315f5 100644 --- a/code/aind_ccf_reg/utils.py +++ b/code/aind_ccf_reg/utils.py @@ -16,9 +16,7 @@ import pydantic from aind_data_schema.core.processing import (DataProcess, PipelineProcess, Processing) - -PathLike = Union[str, Path] - +from aind_ccf_reg.configs import PathLike def create_folder(dest_dir: PathLike, verbose: Optional[bool] = False) -> None: """ @@ -475,3 +473,26 @@ def print_system_information(logger: logging.Logger): net_io = psutil.net_io_counters() logger.info(f"Total Bytes Sent: {get_size(net_io.bytes_sent)}") logger.info(f"Total Bytes Received: {get_size(net_io.bytes_recv)}") + + + +def save_string_to_txt(txt: str, filepath: str, mode="w") -> None: + """ + Saves a text in a file in the given mode. + + Parameters + ------------------------ + txt: str + String to be saved. + + filepath: PathLike + Path where the file is located or will be saved. + + mode: str + File open mode. + + """ + + with open(filepath, mode) as file: + file.write(txt + "\n") + diff --git a/code/main.py b/code/main.py index 92c1d09..569b8f1 100644 --- a/code/main.py +++ b/code/main.py @@ -7,43 +7,51 @@ import multiprocessing import os import subprocess +from datetime import datetime from aind_ccf_reg import register, utils from natsort import natsorted +from aind_ccf_reg.configs import PathLike +from aind_ccf_reg.utils import create_folder -logging.basicConfig( - level=logging.DEBUG, - format="%(asctime)s - %(levelname)s : %(message)s", - datefmt="%Y-%m-%d %H:%M", - handlers=[ - logging.StreamHandler(), - # logging.FileHandler("test.log", "a"), - ], -) -logging.disable("DEBUG") -logger = logging.getLogger(__name__) -logger.setLevel(logging.INFO) - - -def save_string_to_txt(txt: str, filepath: str, mode="w") -> None: + +def create_logger(output_log_path: PathLike) -> logging.Logger: """ - Saves a text in a file in the given mode. + Creates a logger that generates output logs to a specific path. Parameters - ------------------------ - txt: str - String to be saved. - - filepath: PathLike - Path where the file is located or will be saved. - - mode: str - File open mode. + ------------ + output_log_path: PathLike + Path where the log is going to be stored + Returns + ----------- + logging.Logger + Created logger + pointing to the file path. """ + CURR_DATE_TIME = datetime.now().strftime("%Y-%m-%d-%H-%M-%S") + + LOGS_FILE = f"{output_log_path}/register_process.log" + + logging.basicConfig( + level=logging.DEBUG, + format="%(asctime)s - %(levelname)s : %(message)s", + datefmt="%Y-%m-%d %H:%M", + handlers=[ + logging.StreamHandler(), + logging.FileHandler(LOGS_FILE, "a"), + ], + force=True, + ) + +# logging.disable("DEBUG") + logging.disable(logging.DEBUG) + logger = logging.getLogger(__name__) + logger.setLevel(logging.DEBUG) + logger.info(f"Execution datetime: {CURR_DATE_TIME}") - with open(filepath, mode) as file: - file.write(txt + "\n") + return logger def read_json_as_dict(filepath: str) -> dict: @@ -72,7 +80,6 @@ def read_json_as_dict(filepath: str) -> dict: return dictionary - def execute_command_helper(command: str, print_command: bool = False) -> None: """ Execute a shell command. @@ -109,10 +116,31 @@ def main() -> None: """ Main function to register a dataset """ +# data_folder = os.path.abspath("../data/") +# processing_manifest_path = f"{data_folder}/processing_manifest.json" +# acquisition_path = f"{data_folder}/acquisition.json" +# processing_manifest_path = f"{data_folder}/smartspim_test_dataset/derivatives/processing_manifest.json" + + #--------------------------- TODO ----------------------------# + + subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44" + data_folder = os.path.abspath("../data/") - processing_manifest_path = f"{data_folder}/processing_manifest.json" - acquisition_path = f"{data_folder}/acquisition.json" - + processing_manifest_path = f"{data_folder}/processing_manifest_639.json" + acquisition_path = f"{data_folder}/{subject_dir}/acquisition.json" + + #-------------------------------------------------------------# + + template_path = os.path.abspath("../data/smartspim_lca_template/smartspim_lca_template_25.nii.gz") + ccf_reference_path = os.path.abspath("../data/allen_mouse_ccf/average_template/average_template_25.nii.gz") + template_to_ccf_transform_path = [ + os.path.abspath("../data/spim_template_to_ccf/syn_1Warp.nii.gz"), + os.path.abspath("../data/spim_template_to_ccf/syn_0GenericAffine.mat")] + + print(f"template_to_ccf_transform_path: {template_to_ccf_transform_path}") + + #-------------------------------------------------------------# + if not os.path.exists(processing_manifest_path): raise ValueError("Processing manifest path does not exist!") @@ -127,24 +155,32 @@ def main() -> None: acquisition_json = read_json_as_dict(acquisition_path) acquisition_orientation = acquisition_json.get("axes") + print(f"acquisition_orientation: {acquisition_orientation}") if acquisition_orientation is None: raise ValueError( f"Please, provide a valid acquisition orientation, acquisition: {acquisition_json}" ) - logger.info( - f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" - ) - # Setting parameters based on pipeline sorted_channels = natsorted(pipeline_config["registration"]["channels"]) # Getting highest wavelenght as default for registration channel_to_register = sorted_channels[-1] - results_folder = f"../results/ccf_{channel_to_register}" - + #-------------------------------------------------------------# + +# results_folder = f"../results/ccf_{channel_to_register}" # TODO + dataset_id = subject_dir.split("_")[1] + results_folder = f"../results/{dataset_id}2ccf_{channel_to_register}" + create_folder(results_folder) + + logger = create_logger(output_log_path=results_folder) + logger.info( + f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" + ) + + reg_folder = os.path.abspath(f"{results_folder}/registration") metadata_folder = os.path.abspath(f"{results_folder}/metadata") utils.print_system_information(logger) @@ -171,37 +207,50 @@ def main() -> None: logger.info(f"{'='*40} SmartSPIM CCF Registration {'='*40}") example_input = { - "input_data": "../data/fused", +# "input_data": "../data/fused", # TODO + "input_data": f"../data/{subject_dir}/image_tile_fusing/OMEZarr/", "input_channel": channel_to_register, "input_scale": pipeline_config["registration"]["input_scale"], "input_orientation": acquisition_orientation, "bucket_path": "aind-open-data", - "reference": os.path.abspath( - "../data/ccf_atlas_image/ccf_atlas_reference_25_um.tiff" - ), + "template_path": template_path, # SPIM template + "ccf_reference_path": ccf_reference_path, + "template_to_ccf_transform_path": template_to_ccf_transform_path, "reference_res": 25, "output_data": os.path.abspath(f"{results_folder}/OMEZarr"), "metadata_folder": metadata_folder, - "downsampled_file": "downsampled.tiff", - "downsampled16bit_file": "downsampled_16.tiff", - "affine_transforms_file": os.path.abspath( - f"{results_folder}/affine_transforms.mat" - ), - "ls_ccf_warp_transforms_file": os.path.abspath( - f"{results_folder}/ls_ccf_warp_transforms.nii.gz" - ), - "ccf_ls_warp_transforms_file": os.path.abspath( - f"{results_folder}/ccf_ls_warp_transforms.nii.gz" - ), "code_url": "https://github.com/AllenNeuralDynamics/aind-ccf-registration", - "ants_params": { - "spacing": (14.4, 14.4, 16), - "unit": "microns", - "orientations": { - "left_to_right": 0, - "superior_to_inferior": 1, - "anterior_to_posterior": 2, + "reg_folder": reg_folder, + "prep_params": { + "rawdata_figpath": f"{reg_folder}/prep_zarr_img.jpg", + #"rawdata_path": f"{reg_folder}/prep_zarr_img.nii.gz", + "resample_figpath": f"{reg_folder}/prep_resampled_zarr_img.jpg", + #"resample_path": f"{reg_folder}/prep_resampled_zarr_img.nii.gz", + "mask_figpath": f"{reg_folder}/prep_mask.jpg", + #"mask_path": f"{reg_folder}/prep_mask.nii.gz", + "n4bias_figpath": f"{reg_folder}/prep_n4bias.jpg", + #"n4bias_path": f"{reg_folder}/prep_n4bias.nii.gz", + "img_diff_n4bias_figpath": f"{reg_folder}/prep_img_diff_n4bias.jpg", + #"img_diff_n4bias_path": f"{reg_folder}/prep_img_diff_n4bias.nii.gz", + "percNorm_figpath": f"{reg_folder}/prep_percNorm.jpg", + "percNorm_path": f"{reg_folder}/prep_percNorm.nii.gz", }, + "ants_params": { + "spacing": (0.0144, 0.0144, 0.016), + "unit": "millimetre", + # "ccf_orientations": { + # "anterior_to_posterior": 0, + # "superior_to_inferior": 1, + # "left_to_right": 2, + # }, + "template_orientations": { + "anterior_to_posterior": 1, + "superior_to_inferior": 2, + "right_to_left": 0, + }, + "rigid_path": f"{reg_folder}/moved_rigid.nii.gz", + "moved_to_template_path": f"{reg_folder}/moved_to_template.nii.gz", + "moved_to_ccf_path": f"{reg_folder}/moved_to_ccf.nii.gz", }, "OMEZarr_params": { "clevel": 1, From a116abf8d5325571b74de76e51d032a543ec01af Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Wed, 22 May 2024 03:32:23 +0000 Subject: [PATCH 02/15] add align ccf annotation to brain space --- code/aind_ccf_reg/register.py | 57 ++- code/install_pkgs.sh | 15 + code/main.py | 21 +- code/register_ccf_to_brain.ipynb | 797 +++++++++++++++++++++++++++++++ 4 files changed, 870 insertions(+), 20 deletions(-) create mode 100644 code/install_pkgs.sh create mode 100644 code/register_ccf_to_brain.ipynb diff --git a/code/aind_ccf_reg/register.py b/code/aind_ccf_reg/register.py index e117806..8973be0 100644 --- a/code/aind_ccf_reg/register.py +++ b/code/aind_ccf_reg/register.py @@ -166,6 +166,20 @@ def __read_zarr_image(self, image_path: PathLike) -> np.array: img_array = np.squeeze(img_array) return img_array + + def _plot_save_img(self, ants_moved, moved_path: PathLike=None) -> None: + # plot and save moved image + if moved_path: + figpath = moved_path.replace(".nii.gz", "") + title = moved_path.replace(".nii.gz", "").split("/")[-1] + logger.info(f"Plot aligned image: {figpath}, title: {title}") + plot_antsimgs(ants_moved, figpath, title, vmin=0, vmax=None) + + logger.info(f"Saving aligned image: {moved_path}") + ants.image_write(ants_moved, moved_path) + logger.info("Done saving") + + def _qc_reg(self, ants_moving, ants_fixed, ants_moved, moved_path: PathLike=None, figpath_name: str="reg") -> None: """ Quality control on registration results and write deformed image. @@ -203,18 +217,11 @@ def _qc_reg(self, ants_moving, ants_fixed, ants_moved, moved_path: PathLike=None else: # moving and fixed images do not have same dimension plot_reg(*plot_args, **plot_kwargs) - - # plot moved image - if moved_path: - figpath = moved_path.replace(".nii.gz", "") - title = moved_path.replace(".nii.gz", "").split("/")[-1] - logger.info(f"Plot aligned image: {figpath}, title: {title}") - plot_antsimgs(ants_moved, figpath, title, vmin=VMIN, vmax=VMAX) - - logger.info(f"Saving aligned image: {moved_path}") - ants.image_write(ants_moved, moved_path) - logger.info("Done saving") + + self._plot_save_img(ants_moved, moved_path) + + def rigid_register(self, ants_fixed, ants_moving): """ Run rigid regsitration to align brain image to SPIM template @@ -281,7 +288,7 @@ def register_to_template(self, ants_fixed, ants_moving): logger.info(f"\nStart registering to template ....") if self.args['reference_res'] == 25: - reg_iterations = [100, 10, 0] # TODO + reg_iterations = [200, 20, 0] # TODO # reg_iterations = [1, 0, 0, 0] elif self.args['reference_res'] == 10: reg_iterations = [400, 200, 40, 0] @@ -420,7 +427,7 @@ def atlas_alignment( #----------------------------------# # register brain image to CCF #----------------------------------# - # ants_img = ants.image_read(self.args["prep_params"].get("percNorm_path")) # + ants_img = ants.image_read(self.args["prep_params"].get("percNorm_path")) # # register to SPIM template: rigid + SyN rigid_image = self.rigid_register(ants_template, ants_img) @@ -431,6 +438,30 @@ def atlas_alignment( # register to CCF template: apply manual regsitration aligned_image = self.register_to_ccf(ants_ccf, aligned_image) + #----------------------------------# + # TODO: register CCF annotation to brain space + #----------------------------------# + + template_to_brain_transform_path = [ + f"{self.args['reg_folder']}/rigid_0GenericAffine.mat", + f"{self.args['reg_folder']}/0GenericAffine.mat", + f"{self.args['reg_folder']}/1InverseWarp.nii.gz", + ] + + ccf_anno_to_template_deformed = ants.image_read(os.path.abspath("../data/ccf_annotation_to_template_moved.nii.gz")) + + # apply transform + ccf_anno_to_brain_deformed = ants.apply_transforms( + fixed = ants_img, + moving = ccf_anno_to_template_deformed, + transformlist=template_to_brain_transform_path, + whichtoinvert = [True, True, False] + ) + + self._plot_save_img(ccf_anno_to_brain_deformed, + self.args['ants_params']['ccf_anno_to_brain_path']) + + return aligned_image.numpy() diff --git a/code/install_pkgs.sh b/code/install_pkgs.sh new file mode 100644 index 0000000..e46363b --- /dev/null +++ b/code/install_pkgs.sh @@ -0,0 +1,15 @@ +pip install -U --no-cache-dir \ + antspyx \ + argschema==3.0.4 \ + s3fs==2022.11.0 \ + scikit-image==0.19.3 \ + tifffile==2022.10.10 \ + bokeh==2.4.2 \ + zarr==2.13.3 \ + aind-data-schema==0.22.1 \ + xarray_multiscale==1.1.0 \ + dask[distributed]==2022.11.1 \ + matplotlib==3.7.3 \ + ome-zarr==0.8.2 \ + natsort==8.4.0 \ + aicsimageio@git+https://github.com/camilolaiton/aicsimageio.git@feature/zarrwriter-multiscales-daskjobs \ No newline at end of file diff --git a/code/main.py b/code/main.py index 569b8f1..128a35c 100644 --- a/code/main.py +++ b/code/main.py @@ -124,7 +124,13 @@ def main() -> None: #--------------------------- TODO ----------------------------# subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44" - + subject_dir = "SmartSPIM_694513_2023-09-30_00-03-18_stitched_2024-01-11_10-15-23", + subject_dir = "SmartSPIM_709391_2024-01-08_20-45-17_stitched_2024-01-11_15-48-31", + subject_dir = "SmartSPIM_710625_2024-03-29_10-22-21_stitched_2024-03-30_22-18-10", + subject_dir = "SmartSPIM_693196_2023-09-28_23-12-22_stitched_2024-01-11_10-23-15", + subject_dir = "SmartSPIM_693197_2023-09-29_05-18-50_stitched_2024-01-11_13-16-50", + subject_dir = "SmartSPIM_694513_2023-09-30_00-03-18_stitched_2024-01-11_10-15-23", + data_folder = os.path.abspath("../data/") processing_manifest_path = f"{data_folder}/processing_manifest_639.json" acquisition_path = f"{data_folder}/{subject_dir}/acquisition.json" @@ -172,7 +178,7 @@ def main() -> None: # results_folder = f"../results/ccf_{channel_to_register}" # TODO dataset_id = subject_dir.split("_")[1] - results_folder = f"../results/{dataset_id}2ccf_{channel_to_register}" + results_folder = f"../scratch/{dataset_id}_to_ccf_{channel_to_register}" create_folder(results_folder) logger = create_logger(output_log_path=results_folder) @@ -223,15 +229,15 @@ def main() -> None: "reg_folder": reg_folder, "prep_params": { "rawdata_figpath": f"{reg_folder}/prep_zarr_img.jpg", - #"rawdata_path": f"{reg_folder}/prep_zarr_img.nii.gz", + "rawdata_path": f"{reg_folder}/prep_zarr_img.nii.gz", "resample_figpath": f"{reg_folder}/prep_resampled_zarr_img.jpg", - #"resample_path": f"{reg_folder}/prep_resampled_zarr_img.nii.gz", + "resample_path": f"{reg_folder}/prep_resampled_zarr_img.nii.gz", "mask_figpath": f"{reg_folder}/prep_mask.jpg", - #"mask_path": f"{reg_folder}/prep_mask.nii.gz", + "mask_path": f"{reg_folder}/prep_mask.nii.gz", "n4bias_figpath": f"{reg_folder}/prep_n4bias.jpg", - #"n4bias_path": f"{reg_folder}/prep_n4bias.nii.gz", + "n4bias_path": f"{reg_folder}/prep_n4bias.nii.gz", "img_diff_n4bias_figpath": f"{reg_folder}/prep_img_diff_n4bias.jpg", - #"img_diff_n4bias_path": f"{reg_folder}/prep_img_diff_n4bias.nii.gz", + "img_diff_n4bias_path": f"{reg_folder}/prep_img_diff_n4bias.nii.gz", "percNorm_figpath": f"{reg_folder}/prep_percNorm.jpg", "percNorm_path": f"{reg_folder}/prep_percNorm.nii.gz", }, @@ -251,6 +257,7 @@ def main() -> None: "rigid_path": f"{reg_folder}/moved_rigid.nii.gz", "moved_to_template_path": f"{reg_folder}/moved_to_template.nii.gz", "moved_to_ccf_path": f"{reg_folder}/moved_to_ccf.nii.gz", + "ccf_anno_to_brain_path": f"{reg_folder}/moved_ccf_anno_to_brain.nii.gz", }, "OMEZarr_params": { "clevel": 1, diff --git a/code/register_ccf_to_brain.ipynb b/code/register_ccf_to_brain.ipynb new file mode 100644 index 0000000..30670c7 --- /dev/null +++ b/code/register_ccf_to_brain.ipynb @@ -0,0 +1,797 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "8ecc0021", + "metadata": {}, + "outputs": [], + "source": [ + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "35b40dee", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "import sys\n", + "import time\n", + "from datetime import datetime\n", + "from pathlib import Path\n", + "from typing import List, Optional\n", + "\n", + "import glob\n", + "import ants\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3a2641b2", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from aind_ccf_reg.plots import plot_reg, plot_antsimgs" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "22179f60", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def perc_normalization(ants_img):\n", + " \"\"\"\n", + " Percentile Normalization \n", + " \n", + " Parameters\n", + " -------------\n", + " ants_img: ANTsImage\n", + " \n", + " Returns\n", + " -----------\n", + " ANTsImage\n", + " \"\"\"\n", + " percentiles = [2, 98]\n", + " percentile_values = np.percentile(ants_img.view(), percentiles)\n", + " ants_img = (ants_img - percentile_values[0]) / (percentile_values[1] - percentile_values[0])\n", + "\n", + " return ants_img" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "1824c1c9", + "metadata": {}, + "outputs": [], + "source": [ + "channel_to_register = \"Ex_639_Em_660\" \n", + "subject_dir = \"SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44\"\n", + "dataset_id = subject_dir.split(\"_\")[1]\n", + "results_folder = f\"../results/{dataset_id}_to_ccf_{channel_to_register}\"\n", + "reg_folder = os.path.abspath(f\"{results_folder}/registration\")\n", + "\n", + "template_to_brain_transform_path = [\n", + " f\"{reg_folder}/rigid_0GenericAffine.mat\",\n", + " f\"{reg_folder}/0GenericAffine.mat\",\n", + " f\"{reg_folder}/1InverseWarp.nii.gz\",\n", + "]\n", + "\n", + "ccf_to_template_transform_path = [\n", + " os.path.abspath(\"../data/spim_template_to_ccf/syn_0GenericAffine.mat\"),\n", + " os.path.abspath(\"../data/spim_template_to_ccf/syn_1InverseWarp.nii.gz\"),\n", + "]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bff3d3d4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "f83424a4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/root/capsule/data/allen_mouse_ccf/average_template/average_template_25.nii.gz\n", + "ccf: ANTsImage (ASL)\n", + "\t Pixel Type : float (float32)\n", + "\t Components : 1\n", + "\t Dimensions : (528, 320, 456)\n", + "\t Spacing : (0.025, 0.025, 0.025)\n", + "\t Origin : (0.0, 0.0, 0.0)\n", + "\t Direction : [-0. 0. -1. 1. -0. 0. 0. -1. 0.]\n", + "\n", + "../data/allen_mouse_ccf/annotation/ccf_2017/annotation_25.nii.gz\n", + "ccf_anno: ANTsImage (ASL)\n", + "\t Pixel Type : float (float32)\n", + "\t Components : 1\n", + "\t Dimensions : (528, 320, 456)\n", + "\t Spacing : (0.025, 0.025, 0.025)\n", + "\t Origin : (0.0, 0.0, 0.0)\n", + "\t Direction : [-0. 0. -1. 1. -0. 0. 0. -1. 0.]\n", + "\n", + "/root/capsule/data/smartspim_lca_template/smartspim_lca_template_25.nii.gz\n", + "template: ANTsImage (RAS)\n", + "\t Pixel Type : float (float32)\n", + "\t Components : 1\n", + "\t Dimensions : (576, 648, 440)\n", + "\t Spacing : (0.025, 0.025, 0.025)\n", + "\t Origin : (-1.5114, -1.5, 1.5)\n", + "\t Direction : [ 1. 0. 0. 0. 1. 0. 0. 0. -1.]\n", + "\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAFBCAYAAACLu47vAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAAsTAAALEwEAmpwYAABKsUlEQVR4nO3deXxU5fn//9eVPexhC8gqEFFwwYqoxbqgIouCLW64K5+i1bpU/VBr9YdFK9rHtwpad0XQuoDbB4pWP4qgYgUBAREUiAiyhz0sgRBy/f6YQz5hCSQwkzOZvJ+Pxzwy5z73zFwnkJlr7nOf6zZ3R0RERCRRJIUdgIiIiEg0KbkRERGRhKLkRkRERBKKkhsRERFJKEpuREREJKEouREREZGEouRGREREEoqSGxEJnZm1N7NZZrbZzG4LOx4RqdpSwg5ARAQYBEx0905hByIiVZ9GbkQkHrQC5oYdhIgkBiU3IhJ1ZtbCzN41szVmts7M/hG0/9bMvg9OP80zs1+Y2afA2cA/zGyLmR11gOftbWYzzSzfzJaa2QOl9rU2Mzeza83sZzNba2Z/LrX/ATMbY2avBK8/18w6l9p/jJlNMrONwb4+MfnliEjMKbkRkagys2RgPLAEaA00A940s0uAB4BrgDpAH2Cdu3cDvgB+7+613H3BAZ5+a/D4ekBv4HdmdtFefU4H2gPnAP+fmR1Tal8f4M3g8eOA3UlXKvAv4H+BxsCtwGtm1r6ixy8i4VNyIyLR1gU4Avhvd9/q7tvdfTLwX8Df3H2aR+S6+5KKPLG7T3L3Oe5e7O7fAm8AZ+7V7S/uXuDus4HZwAml9k129w/cfRfwaql9pwK1gEfcvdDdPyWSoPWv4LGLSBxQciMi0dYCWOLuRftp//FwntjMTjGzicHprk3ATUDDvbqtKnV/G5Gkpax9GWaWQiQZW+ruxaX2LyEy6iQiVYySGxGJtqVAyyBp2Lu97WE+9+tETie1cPe6wLOAHeZzAqwAWphZ6ffElsDyKDy3iFQyJTciEm1fAyuBR8ysppllmFlX4EXgbjM7ySLamVmrCj53bWC9u283sy7AFVGKeSqRkZxBZpZqZmcBFxKZnyMiVYySGxGJqmA+y4VAO+BnYBlwmbu/BfyVyOjLZuB/gPoVfPqbgSFmthn4/4AxUYq5MIi5J7AWeBq4xt1/iMbzi0jlMncPOwYRERGRqNHIjYiIiCQUJTciEleCAnpb9nO7MuzYRKRq0GkpERERSSgauREREZGEouRGREREEoqSGxEREUkoSm5EREQkoSi5ERERkYSi5EZEREQSipIbERERSShKbkRERCShKLkRERGRhKLkRkRERBKKkhsRERFJKEpuREREJKEouREREZGEouRGREREEoqSGxEREUkoSm5EREQkoSi5ERERkYSi5EZEREQSipIbERERSShKbkRERCShKLkRERGRhKLkRkRERBKKkhsRERFJKEpuREREJKEouREREZGEouRGREREEoqSGxEREUkoSm5EREQkoSi5ERERkYSi5EZEREQSipIbERERSShKbkRERCShKLkRERGRQ2JmI8wsz8y+K0fflmY20cxmmtm3ZtYrVnEpuREREZFDNRLoUc6+9wFj3P1E4HLg6VgFpeRGREREDom7fw6sL91mZm3N7EMzm2FmX5jZ0bu7A3WC+3WBFbGKS8mNiEgVY2Y9zGy+meWa2T1hxyOyl+eBW939JOBu/m+E5gHgKjNbBnwA3BqrAMzdY/XcIiISZWaWDCwAzgOWAdOA/u4+L9TApNoys9bAeHc/1sxqAWuA+aW6pLv7MWZ2J5G84+9mdhrwEnCsuxdHO6aUaD+hiIjEVBcg190XAZjZm0BfQMmNxIMkYKO7d9rPvgEE83Pc/SszywAaAnnRDkLJjYhI1dIMWFpqexlwyt6dzGwgMDDYPKkS4pIE5e5Wgb75ZvaTmV3i7m+ZmQHHu/ts4GfgHGCkmR0DZBAZ5Yk6zbkREUlA7v68u3d2985hxyKJy8zeAL4C2pvZMjMbAFwJDDCz2cBcIiOLAHcBvw3a3wCu8xjNjdHIjYhI1bIcaFFqu3nQJlLp3L1/Gbv2uTw8mBfWNbYRRWjkRkSkapkG5JjZkWaWRqReyLiQYxKJKxq5ERGpQty9yMx+D3wEJAMj3H1uyGGJ7KFHjx6+du3acvefMWPGR+5eZjFAM6sHvAgcS6Rezg3u/lVZ/ZXciIhUMe7+AZE6ISJxae3atUybNq3c/ZOSkhoepMtw4EN3vzgYsaxxoM5KbkRERCTqojVX2MzqAmcA1wXPWwgUHugxmnMjIiIiUefu5b4BDc1seqnbwFJPdSSRS8ZfDhbdfNHMah7otTVyIyIiIlFVKmkpr7UHKFuQAvyCyJIOU81sOHAPcH9ZT6aRGxEREYm6Co7cHMgyYJm7Tw223yaS7JRJIzciIiISdcXF0Vkyyt1XmdlSM2vv7vOJVDk+4HIjSm5EREQk6qJcfPhW4LXgSqlFwPUH6qzkRkRERKLqEObcHOz5ZgHlXkpEyY2IiIhEXYyWjSoXJTciIiISdUpuREREJKEouREREZGEouRGREREEka0JxRXlJIbERERibpo1bk5FEpuREREJOo0ciMiIiIJQ6elREREJOEouREREZGEouRGREREEoqSGxEREUkoSm5EREQkYWhCsYiIiCQc1bkRERGRhKKRGxEREUkoSm5EREQkYWjOjYiIiCQcJTciIiKSUMJMbpJCe2WROGJmPcxsvpnlmtk9YccjIlLV7T41VZ5btGnkRqo9M0sGngLOA5YB08xsnLvPCzcyEZGqS6elRMLVBch190UAZvYm0BdQciMicgjcXXVuRELWDFhaansZcErpDmY2EBgYbJ5USXFJYlrr7o3CDkIk1jRyIxLn3P154HkAMwvvL1YSwZKwAxCpDEpuRMK1HGhRart50CYiIodIV0uJhGsakGNmR5pZGnA5MC7kmEREqqyKXCmlq6VEYsDdi8zs98BHQDIwwt3nhhyWiEiVptNSIiFz9w+AD8KOQ0QkUSi5ERERkYQS7eTGzBYDm4FdQJG7dy6rr+bciIiEyMxGmFmemX1Xqq2+mX1sZguDn1lBu5nZE0El7W/N7BfhRS5yYDGac3O2u3c6UGIDSm5ERMI2EuixV9s9wAR3zwEmBNsAPYGc4DYQeKaSYhSpkN1F/Mp7izYlNyIiIXL3z4H1ezX3BUYF90cBF5Vqf8UjpgD1zKxppQQqUkExGLlx4H/NbEZQWLVMmnMjIhJ/st19ZXB/FZAd3N9fNe1mwEr2sldVbZFKV8HTTQ3NbHqp7eeD4qmlne7uy82sMfCxmf0QfDnYh5IbEZE45u5+KFWxVVVbwlbB5GbtwebRuPvy4Geemb1HZF3A/SY3Oi0lIhJ/Vu8+3RT8zAvaVU1bqoRoF/Ezs5pmVnv3faA78F1Z/ZXciIjEn3HAtcH9a4GxpdqvCa6aOhXYVOr0lUhcifKcm2xgspnNBr4G3nf3D8vqrNNSIiIhMrM3gLOIzDlYBgwGHgHGmNkAIgttXhp0/wDoBeQC24DrKz1gkXKKZp0bd18EnFDe/kpuRERC5O79y9h1zn76OnBLbCMSiQ5VKBYREZGEsbvOTViU3IiIiEjUaeRGREREEoqSGxEREUkoSm5EREQkoSi5ERERkYRxCKt9R5WSGxEREYk6JTciIiKSUJTciIiISEJRnRsRERFJGJpzIyIiIglHyY2IiIgklDCTm6TQXlkkRsxshJnlmdl3pdrqm9nHZrYw+JkVtJuZPWFmuWb2rZn9IrzIRUQSx+5TU+W5RZuSG0lEI4Eee7XdA0xw9xxgQrAN0BPICW4DgWcqKUYRkYSWcMmNmfUws/nBt+F7Dv4Ikehx98+B9Xs19wVGBfdHAReVan/FI6YA9cysaaUEKiKSoCqS2FSJ5MbMkoGniHwj7gD0N7MO0X4dkQrKdveVwf1VQHZwvxmwtFS/ZUGbiIgchjCTm1hMKO4C5Lr7IgAze5PIt+N5MXgtkQpzdzezCv01mdlAIqetRESkHBKtzs3+vgmfsnenvT4sTopBHFJ9rHX3Rgfps9rMmrr7yuC0U17QvhxoUapf86BtD+7+PPA8QEUTIxGR6qhaXi3l7s+7e2d37xxWDJIwlpSjzzjg2uD+tcDYUu3XBFdNnQpsKnX6SkREDkHYc25iMXJTrm/CIrFiZm8AZwENzWwZMBh4BBhjZgOIJEOXBt0/AHoBucA24PpKD1hEJAElWhG/aUCOmR1JJKm5HLgiBq8jsl/u3r+MXefsp68Dt8Q2IhGR6iehkht3LzKz3wMfAcnACHefG+3XERERkfiVUMkNgLt/QGS4X0RERKqhhEtuREREpPrSquAiIiKScJTcxCkzC/UfJ57odyEiIhURZhE/LZxZhiZNmnDKKafQuHHjsEMJXd26dTnllFNo2bIlZhZ2OCIiUgUkWp2bhNCwYUOaNm1KVlYWP/74IwsWLAg7pFA0a9aM4447joyMDIqLi1m6dOnBHyQiItVa2HNuNHJThnXr1rFr1y4yMjLIycmhTp06YYdU6WrVqsWxxx5LZmYmAHl5eTo1JSIi5RLtkRszSzazmWY2/mB9ldyUYdWqVeTn5wOQlpZGmzZtQo6o8rVt25YaNWoAsH37dlavXh1yRCIi+2rdujXp6elhhyF7icFpqduB78vTUclNGdydjRs3lvzSmzZtSlpaWshRVZ6UlJQ95htt3ryZgoKCECOSw5WVlcXRRx9NcnJy2KEclhYtWtC6deuww5A4ccYZZ/DSSy/x5JNP0qBBg7DDkVKimdyYWXOgN/BieV5byc0BrFixouSXnpaWRt26dUOOqPKkpaWVJHPuzsqVWkuyqqpRowann346nTp1AsK9giEaduzYwUknnUTv3r3JysoiKUlvY9VVixYtuP/++6lbty6dOnVi2LBhHHvssVU+gU8UFUxuGprZ9FK3gXs93TBgEFCuNzBNKD6A9evXs2XLFurUqYOZUb9+fdasWRN2WJWibt26pKamAlBUVEReXl7IEUlFpaenk5OTQ4MGDZgxYwZbtmwJO6SoyMvL45133iEjI4M2bdrQqVMnpk2bljDHJ+WTlZXF3XffTb169QBISkrimGOO4cknn+Ttt9/mueeeo6ioKNwgq7FDmFC81t0772+HmV0A5Ln7DDM7qzxPpuTmAIqKili9ejW1a9fGzKhVq1bYIVWaunXrllz2vWrVKn1wVCFmRnZ2Nq1btyY3N5fvvvsu7JBiYvv27cybN4/Vq1fTsmVLsrKymDZtGoWFhWGHJjFmZlx22WX88pe/3Kc8Re3atUsuhNi8eXNIEQpEdZS4K9DHzHoBGUAdM/unu19V1gM0nnsQK1euLMk+69SpQ0pK4ueDycnJNGnSBIhk3+vXrw85IimvGjVq0LVrV3bu3MmUKVNYu3Zt2CHF3Lp165g3bx4//fQTOTk5ZGRkhB2SxFiTJk3o27fvfutuzZgxg/vuu0+JTRyI1pwbd/+Tuzd399bA5cCnB0psQMnNQW3cuJF169YBkeRm9xBoIsvIyKBmzZpA5Nvx8uXLQ45IyiMjI4OjjjqKefPmlfyfrU5WrFhBbm4ubdu2rVLz48yshZlNNLN5ZjbXzG4P2uub2cdmtjD4mRW0m5k9YWa5Zvatmf0i3COoXA0aNGDo0KE0atRoj3Z3Z/r06fz5z3+ulv//45GK+MWxXbt2sWrVKho2bIiZVXjyYlJSEnXr1qV+/fp06tSJzMxMduzYwcyZM1m2bBnbt2+PSpxJSUkcccQRdOjQgcaNG1NQUMCsWbMoKChg1apVFRoerFGjRsl8m7Vr17Jjx46oxCix06xZM+rWrcv3339frf+9duzYwQ8//MApp5zC+vXr+eGHH8IOqTyKgLvc/Rszqw3MMLOPgeuACe7+iJndA9wD/BHoCeQEt1OAZ4Kf1cIFF1zAscceu0ebu5eM2FSH0cqqIFZJi7tPAiYdrJ+Sm3JYvXo17du3JzU1lSZNmux3cm1qaipZWVlA5DLqU045hUaNGtGxY0fq168PREZBWrZsSXZ2Nu7O559/zvDhw1m0aNFhxdemTRtuuukmzjzzTNLT01m9ejU///wzF110EbVq1WLp0qV89913rFmzhjlz5rBlyxYyMjJYsWLFfucn1K5dG4icL122bNlhxSaxl5KSQqNGjZg7dy47d+4MO5zQ7dq1i6+++or27duTnZ0d9/WZ3H0lsDK4v9nMvgeaAX2Bs4Juo4i8of8xaH/FI58cU8ysnpk1DZ4noTVs2JDf/OY3+7QrsYlPWjgzzm3evJk1a9bQrFkzGjduTHJyMrt27QIiicW5555Ljx49aNCgATt37mTlypXMmzePOXPm8Omnn5Kfn8/69etxd2rVqkW7du2444476NatG8cffzxPPfUU48ePr/AoTnJyMj169ODuu++mcePG/PjjjwwfPpzp06ezZcuWkiu86tSpw9FHH81xxx3HRRddxBFHHEG9evVYunQpH374IRMmTOCnn34qGd3ZfXXY2rVrdZVUnEtJSaFhw4bMmTOn5P+kRN5U58+fT9u2bVm/fn2VSfrMrDVwIjAVyC6VsKwCsoP7zYDS66AsC9oSOrlJTU3lqquu4ogjjtijfcaMGdx7772aGxiHlNxUAfn5+TRr1oykpCTMjCZNmnD99dfTq1cvGjRowLZt25g+fTqvvPIKc+bMKXMy26ZNm5gxYwYDBgzgoosu4o477mDw4MGcccYZDBs2jDVr1rBt27YyP6iSk5OpUaMGjRo14tZbb+XMM8/E3fnb3/7Ge++9V1JVebe8vDzy8vLIzc1l/PjxpKWlceKJJ9KnTx/OP/987rjjDv7rv/6LyZMn8/rrrzN79uySEagtW7ZU+ZooiSwjI4PMzEzWrFmjxGY/3J3c3FwaN27Mhg0b4j7BMbNawDvAHe6eX3qyrLu7mVXokyKoE7J3rZAq6/jjj6dfv357TCLesmULzzzzjBKbOKXkpgrYvdZU48aNufXWW+nduzfNmjWjsLCQzz//nGHDhvHjjz+W+w20sLCQMWPGsGLFCgYNGsR5551Hly5d2L59O++//z5vvPEGBQUF1KpVi+3bt1NUVERmZib9+/end+/eZGRkULduXVavXs2DDz7IZ599Vq6aDoWFhUydOpVvvvmGl19+mcsuu4xf//rX9OzZk1/96le89dZbLF26lK1bt2oicRzLzMykffv2fP/990psDmL9+vWce+65zJs3j59//jnscPbLzFKJJDavufu7QfPq3aebzKwpsHsYdTnQotTDmwdte3D354Hng+ev0ovC1alThz/96U8l69xBZH7VyJEjmTVrVniBSZnCXjhTyU05bd68mV/84hd0796devXqYWasXr2aBx54gC+//PKQvxVOnjyZBQsWcPPNN9OvXz/q1q3L9ddfz8UXX8yuXbtISUmhuLiY4uJikpOTS2ruFBUVMXr0aF544YVDSkJ27txJbm4uDz/8MBMmTODPf/4z7dq147rrrmPjxo188sknTJo06ZCOSWKva9euTJ8+vVpPHi6voqIiPvvsM375y1+ydOnSuFv81SJDES8B37v7Y6V2jQOuBR4Jfo4t1f57M3uTyETiTYk+36Znz560bNmyZNvdeeONN3jjjTdCjEoOJsyRfyU35dCsWTPuuOMOunfvTlpaWslw9913382CBQsO+80yLy+PoUOHMn36dPr3709WVhZNmjShRo0aJVdnFRcXs3PnThYvXkxRUREffPABL7/88mF/uLk7U6ZM4Q9/+ANDhw6lQ4cOZGVl8etf/5oGDRrw+OOPk5ube1ivIdFVu3ZtkpOT2bRpU9ihVBkFBQVs2rSJ2rVr73PqNg50Ba4G5pjZrKDtXiJJzRgzGwAsAS4N9n0A9AJygW3A9ZUabSWrW7cul1566R5Xqs6aNYtRo0YpuY9zGrmJU+np6XTv3p1rr72Wjh07ApF/rPfff5/HHnssqust7dixg/Hjx/PRRx+RnJxMy5YtSUtLK6nlsGbNGgoLC/n5559x96j/Uefm5jJgwADuu+8+LrjgAlJSUujWrRtt27blqaee4pNPPtHCmXEgMzOTX//614wbNy7uRiDiXW5uLhdeeCFjx46Nq4rb7j4Z2LcaXcQ5++nvwC0xDSqO3HXXXbRq1apke+PGjTz33HMq0lcFKLmJQzVq1OCWW27h6quvLqn54u589dVXPPjggzH79rdz50527tzJggULYvL8B5Kfn8+QIUMwM3r37o2Z0apVKx5++GF++ctf8uCDD7Jt27ZKj6sizKwF8AqRK0sceN7dh5tZfWA00BpYDFzq7huCUwLDiXwT3gZc5+7fhBF7eXTr1o158+axcePGsEOpcjZu3MjEiRM588wzef/998MOR8rh/PPP5+yzzy7ZLi4uZvz48UyfPj3EqKQ8wp5zc9CKdGY2wszyzOy7Um0JXTmzRo0a3H///Vx33XV7JDbjx4/n9ttvj8dh7ajZsmULDzzwAKNHjy6ZR5SSkkKfPn24//77qVGjRsgRHtTugmgdgFOBW8ysA5ECaBPcPQeYEGzDngXRBhIpiBaXGjVqRK1atfjmm7jNveLeihUrWL16Na1btw47FDmI5ORkunfvvsck4vnz5/Pcc8+FGJVURJgVistTbnck0GOvtir/QVGWevXqcf/999OnT5+Sc7wFBQUMGzaMv/zlL3E1nB0rW7duZejQoTzxxBMlp6KSkpLo06cPQ4YMoXnz5iFHWDZ3X7l75MXdNwOlC6KNCrqNAi4K7pcURHP3KUC94MqUuNO2bVs+/fRTXZ5/mObOnbtPrRSJP7179+a0004r2c7Pz+eRRx7R6fEqJK6TG3f/HNi7iECV/6DYnzZt2jBixAj69u27R2Lz6KOP8uKLL7J169aQI6w8hYWFjBgxgttuu42lSyP1wpKSkujduzdPP/00bdq0CTnCgzvMgmh7P9dAM5tuZqGMh2dnZ9O2bVvWrFkTxssnlIKCAvLz8/eYxyHxpVatWlx++eWkpaUBkSvexowZU1WW05BAXCc3ZTisD4p41LZtW4YNG8YxxxxTUiSquLiYkSNH8tZbb1XLb8vFxcVMnjyZJ598co8aOjk5OQwbNoy2bduGGN2B7V0QrfS+YEJmhf6a3P15d+/s7p2jGGa59e3bl08//TSMl05IS5Ys4cILL6zwWnFSOc4999yS95eioiJGjhzJiy++qJpOVUxVTG5KHMoHBYT/Tbi0du3a8fjjj5OTkwNEvtnNnDmTxx57jBEjRlTLxKa0Tz75hL///e97XDGVk5PD448/Trt27UKObl8HKogW7K9wQbQwNWrUiDVr1sT9GklVyebNm5k5c2aVGIGsbtq1a8cNN9xAcnIyAK+++iovvvhiuYqUSvxw95IabeW5RduhJjeH/UER9jfh3U499VSee+45cnJycHeWLVvGzTffzLXXXstLL71ULebYHExBQQEjR47kD3/4AwMHDmTKlCm4Ozk5Obz44ov07Nkz7BBLlKMgGuxbEO2aYDL8qcRhQbQTTzyRyZMnV/skO9pmzJgR16OP1VFGRgZXX311yZyolStX8tZbbymxqaKq4shNlf2g2M3MOP/88xk6dChHHHEE7s4XX3zBtddey5QpU+J+HZowFBUVMX36dO68807efvttioqKyM7OZtCgQZx//vl7rPkSot0F0bqZ2azg1otIQbTzzGwhcG6wDZGCaIuIFER7Abg5hJjLlJGRwaZNmzTXJga2b9/O8uXLqV+/ftihSODMM8+kV69eJdtjx47V4r1VWJjJzUHr3JjZG8BZQEMzWwYMJgEqZx511FEMHjyYrKwsiouL+eCDD3j44YfZsGFD2KHFvQ0bNjB06FBWrlzJ7373O5o0acLgwYNZvHgx8+fPDzW2RCuI1qpVq7hdDykRLF++nE6dOjFx4sSwQ6n2atasyRVXXFHyJWnr1q2qZ1PFxXURP3fvX8auKvdBsVuNGjW4++67ycrKoqioiHfffZe//e1v1epqqMNVUFDACy+8gLtz8803k5WVxV//+lduuOGGhK4DVJnMjJSUFM21iaENGzawbt06MjIy2L59e9jhVFtmxtlnn80xxxxT0vbGG28we/bsEKOSwxH3RfwS0WmnncYvf/lL3J1Jkybx6KOPKrE5BEVFRbz44ou8+OKLFBcXc8wxx9Cjx94lkeRQtWrViubNm2uuTYxt27Ztj0UZpfI1aNCA2267bY8SHNOmTdMSI1VcVZxzU2VlZGRw4403kpSUxKxZsxg8eHDcLykQz4qKihgxYgTjx4/HzLjyyiupV69e2GElhE6dOmlYvhIsWbKEk08+OV7mjFU7SUlJnHvuudSpU6ekberUqXz77bchRnXoMjMz6dixI+np6WGHEjolN5UkJSWF3/3ud7Rv356VK1fy6KOPsn793vUJpaK2bNnCY489xs8//0xOTg4PPPAANWvWDDusKq1GjRoceeSRWkOqEuzcuZPi4mJdORWSFi1aMGDAAFJSIrMkVq9ezcsvv1wlL+o46aSTePvtt5kwYQKjR4/m3HPPLTmu6kjJTSXp1KkT11xzDe7Oo48+qvO5UbR69Wruuece1q5dyznnnEP37t3DDqlKO+OMM/jmm29UtKySzJs3j5NOOinsMKqd1NRU/vznP5OVlQVEPgzffvtt5s6dG3JkFde5c2deeuklTjnlFFJSUjj99NN59dVX+cMf/rDH+ljViZKbSmBmXHXVVaSnp/P+++/zySefhB1Swpk1axYvvPACAL/5zW9KFh2ViqlRowa9e/fmp59+CjuUamPBggWcfPLJJR+yUjm6du3K8ccfX7K9aNEixo8fH2JEh6ZOnTo8/vjj+6y7l5qayp133smzzz5b7UZwqmoRvyqnRYsWnHTSSSxZsoQnnnhC34hj5J133uHLL7/k2GOP5YQTTgg7nCrpzDPPZP369SVreknsFRQUsHr1anr37h12KNVGeno6V111VcmHfmFhIY8//niVrOl01lln0b59+/3uS01NpXv37vz2t7+t5KjCp5GbSnDppZdSq1Ythg8frktrY2jbtm08++yzFBcXc+2111a7byuHKzk5mV69ejF37lxdKVLJpk+fzvnnn0+NGjXCDqVaOO200/YYtZkxYwbTpk0LMaJDY2YHXacsNTWV3/72txx77LGVGFn4lNzEWJ06dTjzzDOZM2cOEyZMCDuchDdnzhw+//xzunTpQqNGjcIOp0pp2rQpOTk5zJs3L+xQqp1vv/2WBg0a7PGBK7GRmZnJlVdeWZIQrF27locffrjKjqiX57RKy5YtueSSSyohmvih5CbGevbsSZMmTRg2bFiVnIFf1ezatYtRo0bh7vTr1y/scKqUY445hl27drF48eKwQ6l2tm/fzs6dO/eZNyHRd+qpp3LccccBkavVnnrqKVatWhVyVIfG3Rk/fny5ErOjjjqq2lwiXpHERsnNIUhNTaVXr158+eWXujqqEs2ePZvRo0fTvXv3PepXyIF16dKF9evXa6HAEGzbto25c+dy5pln6nRqDGVmZtK/f/+S3/GcOXP45JNPqvRp2M8++4zly/e7RvQeTj/9dH75y19WQkTxQclNDB133HG0b9+ekSNHVtkhz6rI3Xnrrbdo0KABJ554YtjhVAkpKSk0a9aMRYsWaSmAELg7S5YsoU2bNmRkZIQdTsI69dRTS+ae7Nq1izfeeIOCgoKQozo8W7du5dNPPz1ov8zMTI4++uhKiCg+KLmJoW7durFx40YWLlwYdijVzpo1a1i2bBmnn366qr+WQ0ZGBq1atdJVUiHavfCr/r/GRlpaGldccQVpaWlAZJ7TV199FXJUh2/Xrl18+eWXFBYWHrRvixYtDjj5OJFEK7kxswwz+9rMZpvZXDP7y8FeO6F/w5mZmfzqV7/iq6++0tpRIdixYweTJk3i7LPPplatWmGHE/caNmxIzZo1yc3NDTuUaqu4uJisrCyOPPLIsENJSF27dt3jiqHXX389YUYpP/vsMzZs2HDQfuedd161qAEW5To3O4Bu7n4C0AnoYWanHugBCZ3cHHHEETRt2jQhvhlUVTNnzqR+/foqbV8O2dnZJCUlsWLFirBDqbbmz5/P1q1badq0adihJJy0tDSuuuqqkg/2xYsX88MPP4QcVfRs3LiRt99+u0rPHYq2aI3ceMSWYDM1uB3wQQmd3DRt2pSkpCR+/vnnsEOptubNm8eaNWtU0K8c2rdvz44dO8jLyws7lGprzZo1zJs3T/9fY6Br164lV0gBvPTSS6xcuTLEiKKruLiY1157rVynpqqLaM65MbNkM5sF5AEfu/vUA/VP6EsCGjRowMSJE1m2bFnYoVRb+fn5vPfee+zYsSPsUOJey5YtWbJkyUFPodatW3ePq3mKi4vZuHGjvjHuxcyoV6/eHvMbioqK2LRpU5mPKS4uprCwsGROiERH06ZNGTRoUMm/xZo1a5g5c2bIUUXf0qVLmTZtGqeffnrYocSFCr4nNTSz6aW2n3f350s91y6gk5nVA94zs2Pd/buyniyhk5uxY8cyduzYsMOo9p599tmwQ4h76enpHH/88SxevPiAtZhOOukk7r//fmrXrl3StmzZMm666aYqf8VJtKWmpjJkyBA6dOhQ0rZ582YefPBBZsyYUebjvv32Wy688ELS09OVlEfJscceS4MGDUq2FyxYwNq1a0OMKDYKCgoSajTqcFUwuVnr7p3L8ZwbzWwi0AMoM7lJ6NNSIlXF7sJeY8aMKbNPzZo1ufPOO2nevDl169Ytuf38889KbPajsLCQ9evX7/G7at68OXfddRf169cv83H/+c9/SE9P1yKaUXLEEUdw9913l4zaFBcX88UXXyRsLafRo0drFJXoFvEzs0bBiA1mlgmcBxxwwpaSG5E40LJlSzIzM1m0aFGZfbp160a7du32adcbacUcddRRXHbZZWXuX716NVu3biU7O7sSo0pMZka/fv32SCbz8/P57LPPQowqtvLz8/U3GYjinJumwEQz+xaYRmTOzQGXj1dyIxIH2rZty7ffflvmpaRpaWn07NmT5OTkffZ17NhRl9rvR1paWplLKZx11lk0bNhwv/u2bNnCRx99xC9+8YtYhlctpKenc/LJJ+/RNn36dDZu3BhOQJUgOzv7gHWSPv3002qzDFAUr5b61t1PdPfj3f1Ydx9ysNdO6Dk3IlVF8+bNmT17dpl/5Ndccw0nnXQSEDmvP3XqVL766iuKi4vp2rUr7dq1Y9asWSQlJdGuXTsWLlxYLb89nnTSScyePZuioiJat25NYWEhf/3rX0lKSuK0007jlFNOITMzk7Zt23LJJZfwzDPP7Pd5VqxYUa0qycbK9u3bGTRoENnZ2Zx99tn06NGD6dOnJ+yHe61atfjd735XZnKzdetWvvjii3IttJkIwjxOJTeSUMwsA/gcSCfy//ttdx9sZkcCbwINgBnA1e5eaGbpwCvAScA64DJ3X1zJMZOVlVXmSuBNmzalX79+JCcn8+OPP/Lkk08yZcqUkjkLU6ZMoW7duiX9+/Xrx8iRI6vdxMaMjAx+85vfMHfuXIqKisjMzOS1115j8uTJQOQCg+OPP57bb7+djh07cskll/DFF1/w3Xf7zkn84Ycf6NevHykpKQk7N6SyrFq1ilWrVjF79mzefPPNhJxIvNv111/PqafuW1tu69atLFiwgLvvvps5c+aEEFnli9WyCuWl5EYSze5KllvMLBWYbGb/Bu4EHnf3N83sWWAA8Ezwc4O7tzOzy4FHgbInZMRASkoKbdq0YdSoUfvsS09PZ8CAATRq1IjvvvuOP/3pT/skLatWrSqpjZOTk8MZZ5zB2rVreemll6rNN0SI1FHp0qULRx99NLNmzeK7777b4/iLior45ptvuOeeexgyZAgnnHACd9xxB7fddhvbtm3b47m2bdvG9u3btQxDlFXVlb/L66233sLd9zl9/Nlnn7Fo0SLy8/NDiiwccZ3cmFkLIt9ss4lUBHze3YebWX1gNNAaWAxc6u4bLPJuMBzoBWwDrnP3b2ITvsiePPLXtL9Klt2AK4L2UcADRJKbvsF9gLeBf5iZeSX+VaamprJ69ep9vtGaGT169OCcc87h3//+N08//fR+R2PcvWRR2IULFzJu3DguueQS/vWvfyX8h8lutWvX5qabbmLOnDklI2BlLZS7cuVKbr/9dvr370///v259dZbGT58+B7LAGzYsIGCggLq1KnDunXrKuUYpOpbtWoV//jHP8IOI26EmdyUZ0JxEXCXu3cATgVuMbMOwD3ABHfPASYE2wA9gZzgNpDIB4hIpdm7kiXwI7DR3XefX1gGNAvuNwOWAgT7NxE5dVVpcnJyaNq0KTVr1ixpS0lJoWPHjjRu3JhbbrmFwYMHl+s0U3FxMWPGjGHr1q1ceeWVsQw7rvTo0YOMjAz+8Y9/lKtC7LZt2xgxYgQDBw5k3bp19O3bd4/CffXq1aNBgwYcf/zxsQxbJKFFs0JxRR105MbdVwIrg/ubzex7Ih8IfYGzgm6jgEnAH4P2V4JvvlPMrJ6ZNQ2eRyTm9q5kCRz2zFAzG0gkWY+6Tp060bRpU4YPH864ceP44Ycf+OGHH1i4cOF+54MczLp165gzZw7nnXce//rXv1i0aBGpqakUFhaWOZqxtxo1arBr165KLWKXnJxc7vjMjNq1a1NUVEStWrW48MILmTlz5gEvpd+bu7No0SIWLVpEZmYmDRs2pHHjxrRv357TTz+do48+mjZt2jBx4sRDPSSRai2uT0uVZmatgROBqUB2qYRlFZHTVlDqm3Bg97fkPZKbWH5YJJJOnTpRr149Jk2aFHYoVU6pSpanAfXMLCUYnWkOLA+6LQdaAMvMLAWoS2Ri8d7P9TzwPICZRfUv1sxKqrcmJSWxYMGCw04qCgoKqFevHo8++igrVqygWbNmTJw4keHDh5f0KV1UrXRbo0aN6NatG++//36lJTdJSUncdttt/Pvf/2bBggX7xJSSkrLHiEzv3r357W9/y6pVq2jcuDEtWrRgyZIlh/z6BQUFFBQUsGHDBpo0aUKbNm2oUaMGrVu3xsxi+iZdFSfBixxMlZlQbGa1gHeAO9w9v/REO3f3ir7hx/LDIlGkpKTwxz/+kebNm9O9e3dVoS0HM2sE7AwSm92VLB8FJgIXE/mwuBbYvS7HuGD7q2D/p5U53yY5OZmOHTuyevVq7r33XmbPnh2V523cuDHp6ek0adKEFi1aUFRURI0aNfboc8kll9CrV689/l9lZGRw8skns3DhQkaPHh2VWMrrmGOO4eabb+bLL7/cY/5LzZo1mTdvHo888kjJm2XTpk3Jzs6mWbNmuDtpaWk0btz4sBORgoICPvzwQ3766SeGDBlCvXr1yMzM3GfCcZRVuUnwIuUR98lN8Af3DvCau78bNK/efbrJzJoSmd8A//dNeLfS35KlAmrWrEmXLl2ASEEyJTfl0hQYZWbJROaUjXH38WY2D3jTzB4CZgIvBf1fAl41s1xgPXB5ZQbbpEkTOnXqxPDhw6OW2JgZderUYcaMGYwcOZKzzjqLL7/8kv/85z8lferUqcPvf//7PdZd2v1GtGLFCh555JFKvdKquLiYRx55hC5dunDBBReUHMdunTt35vXXXy8ZnXnllVfIzc3lV7/6FfPnz6dXr16cfPLJ1KpVi82bNx92PPPnz2fo0KEMHTqUo48+mm++id01EVVxErxIeYR5teZBJxQHVz+9BHzv7o+V2rX7Gy/s+034Gos4Fdik+TZSWcqqZOnui9y9i7u3c/dL3H1H0L492G4X7C//pI0oaNq0Kf/617/497//HbXnbNCgAV26dKGwsJDJkyfz0EMPMXHixD1OMfXp02ePInW7PxdXrlzJfffdx5QpU6IWT3ktWrSIm266iRUrVuwRE0RGoq677rqS7R07djBx4kSGDBnC6NGj2bJlC/Xq1aNx48ZRi2f27Nn885//pH379lF7zrJUtUnw8UKrt8e3MCcUl+dqqa7A1UA3M5sV3HoBjwDnmdlC4NxgG+ADYBGQC7wA3Bz1qKuZhg0bqlpqAjIzOnXqxKuvvlruibTlceyxx9KkSRMWLly43/21a9dm4MCBJCUlsWvXLsaNG8ewYcMYNmwY119/PePGjYtaLBU1ZcoUbrjhhpJ4Xn755ZKk7OKLLy4zefnkk0+oWbMmLVu2jFos7s6YMWNo1KjRHleyxYK773L3TkRGursQpUnwZjbdzKYf7nPFo65du/Lee+9Ru3btsEOR/ahIYhPW1VKTgbIqWZ2zn/4O3HKYcQmRUxa1atUiLS1NawcloNTUVN5///0y15M6VC1atOB//ud/eOWVV/a7/4QTTqBdu3a4O6NGjeL+++/fY45L2KZPn8706ZHP47S0NFatWsWgQYNo0qQJ559/Pq+++uo+j/noo4947733ylxL6lDt3LmTsWPHVtrcgaoyCT5sqamp3HHHHZx44olkZ2dH5VSkRF+817mRkGzYsIHNmzezefNmNm3aFHY4EmWFhYUxWSLhn//8JzfeeGOZxeeuvPJK0tPTmTlzJn/729/iKrHZW2FhIU8//TRfffUVSUlJ9OvXj9TU1H36bdu2jZtvvpl//vOfUY9hyZIlUT3dtTczaxSULaDUJPjv+b9J8LD/SfAQwiT4eJCSksIJJ5zAjz/+yM8//xx2OFKGuB65kfCsWbOGG264gW3btsV0QqMklgO9WbRo0YLOnTuzc+dOBg8ezJo1ayo5uorbtm0bgwcPZuzYsXTq1IlWrVqRm5u7T79YTl6M8TpdVWoSfLwoLi7m3XffLVfRRglH3F8tJeFwdz7//POww5AEkZqayqBBg2jTpg1Tp05l5syZYYdUbnPmzOHTTz+lT58+3HXXXdx9991s3bq10l4/lvV+3P1bIvXD9m5fRGT+zd7t24FLYhZQFbB9+3Zef/11brjhBlasWME777yjBU7jkE5LiUhMmRkXX3wx/fr1A2Dq1KlVqrTArl27SubhXHzxxTz44IOkpOi7WXXl7jz11FOMGjWKG2+8kSeffJI2bdqEHZaUEvaEYiU3ItXAKaecwtChQ0lPT2fHjh18/PHHUX+N0nVp9l4VORomTJhAfn4+SUlJXHLJJVx88cVatbsaW7duHf/v//0/rrrqKjp06MCbb75J69atww5LSlFyE+cyMjLo2LFjVJ6rY8eO3H///QwYMIBWrVpF5TkB6tatS+/evXnwwQfp0aNHVD5cTjjhBOrVq3f4wUmojjjiCP7+979jZixfvpy//vWvfP3111F9jZSUFO666y5q165NrVq1GDZsWNSvXFqwYAH33nsvP/30Ezt37uTPf/4zxxxzTFRfQ6qeFStWcPnll1NQUMArr7xCZmZm2CFVmJklZKJeXFxc7lu0Kbkph1atWnHPPffsU76+os455xw+/vhjhgwZwgsvvMDHH38clW8aderU4eWXX2bs2LHcd999jB49+rBXhE5JSeG2225TfZ0qLjMzk8GDB3PUUUcxcuRIzj33XJ5++umYzE/YtGkTxcXFbN++nR9//DHqV/gVFxfzxhtv0KtXL4YMGULjxo35+9//Tp06daL6OlL1rFy5koceeqhk2ZGqpEaNGrzwwgu8++67ZGdnH/wBVYhGbuLczz//jLsf1uWg2dnZPPfcczRt2hSIZOo5OTlcdNFFhx1fnz596Nu3b8loTZ06dXj00Uc56qijDvk5a9euTUZGhi6zrMKSkpK488476du3Lz/88ANPPfUUeXl5MXkjKSoq4oUXXmDr1q0UFRUxbNiwmNUeycvL491332X+/Pl07tyZwYMHV7kPNIm+/Px86tWrx1lnnRV2KBVSv359Lr30Ui666CLeeOONks+Iqk5zbqqAgoICXn755cOqUtqhQwdat27NwoULmTRpUsk/ZjSGIleuXFlyOeTChQtZuHAh2dnZnH/++Yf8nMXFxfzrX/8qKYUvVc9ll13GTTfdRFJSEi+88AJ5eXkHf1AVkZ+fz5AhQ9i+fTv9+/fnxhtvTMhhfSm/M844gzVr1vDZZ5+FHUqF1K1bt+T/7tlnn829994bkzlrYVCdmypg4sSJh/X4s846i4KCAq644grWrl3LjBkzGDt27H6rrVbUF198wbPPPsvVV1/NFVdcQVFRERMmTDisbwD5+fm89dZbhx2bhOfHH3/ktddeY/Hixbz77rsHf0AVM2nSJO6//36OO+44Vq5cSXJysi4HrqYaNWrEddddx5NPPhn1it+x1q9fvz0q0A8YMIDWrVuXWb/n888/Z/jw4ZUV3mFRnZtqYPHixezcuZNVq1aRl5dHr169mDdvXlSG7gsLC/nv//5vRo0axbx58zAz5s+ff1jrFbl7VNc7kv1LTk4+6IjDof5bfP3111GfOBxPioqKGDly5GE9Ryx//1I5zIxhw4ZRWFjImDFjwg5nH507d6ZFixYl29u2bWPChAklifjeozSZmZlccMEF+32uvLw8Hn/88dgFG2VKbqqBefPmsWvXLho0aMCyZcuYOnVqVJ+/qKiIWbNmAZGrY4488kgmT54c1deQ6PvNb35Dnz59DtgnLy+PBx54QOvnRFl6ejp/+tOfaNu27QH7/ec//+GZZ56ppKikoq666ip69uzJhRdeyPr168MOp0RaWho33XQT999/Pw0bNixp37lzJ8899xxDhw6t8Gn/GTNmVKn3dSU31cB3333HBRdcwLx582L+Wnl5efTv358ffvgh5q8lh+frr79mwIABe7z57a19+/ZcddVV+oCNsl69etGzZ88Dzm/YsWNHlTkFUF317NmTpUuXxtX7Xc2aNbnzzjsZNGjQPosep6am8vvf/57Vq1fz0EMP8fXXX7Njx46DTorfuXMnTz31VCzDjqpYzaUpLyU3lWTr1q1RH60pS1FREZMmTaqU15LDs2TJEu6+++6Djh7k5+eTkpKiOSVRtHTpUh5++OED9snPzy8ZEZX49fTTT5e5UGwYHnnkEW655ZYDnvL8r//6L15++WUmTpzIXXfdxa233kr79u3L7D958uSYFN+MpViu93YwFg+LyZpZ+EFIVTbD3TtX1ovp/6scpkr9/wqJ/X/2nHPOYdWqVcydOzfsUADo0aMHr7/+OllZWQfs5+588cUX3H777cyePZusrCxOPvlkrrvuOurWrbtH3y1btjBo0CAWL14cw8gPGGuFL0Vs0KCB9+jRo9z9X3/99aj+XWjkRkREqqwJEyaEHcIerrvuuoMmNhCZCH3GGWfw4Ycf8swzz/Dwww/z0Ucf8dFHH1VClJVDp6VERESquKysrAOeWtqf7Oxs7rvvPnbt2sVDDz0Uo8gqX9hzblTET0REJArq169/SEvWpKSkcOONN0Z1vcF4EK0ifmbWwswmmtk8M5trZrcf7LWV3IjIIWnVqhXXXHMNSUllv40kJSVx3nnnJdybtki01axZk4yMjLDDiKooViguAu5y9w7AqcAtZtbhQA9QciMih+SSSy5h2LBhtGvXrsw+jRo1YsSIEdx++0G/aIlUeTk5OYe8dML06dOZP39+lCMKV7SSG3df6e7fBPc3A98DzQ70GM25EZFD0qpVK2rWrHnAVbmzsrKoU6dOwiwGKHIg3bt3JzU1tcKP27VrFy+88EIMIgpXBefcNDSz6aW2n3f35/fuZGatgROBA9ZWUXIjCcnMkoHpwHJ3v8DMjgTeBBoAM4Cr3b3QzNKBV4CTgHXAZe6+OKSwq5RHH32UsWPH8u2335bZZ+HChVx00UUsWbKkEiMTqVoWLFjA+PHjww4jqty9onVu1h7sUnAzqwW8A9zh7vkH6nvQ01JmlmFmX5vZ7GAiz1+C9iPNbKqZ5ZrZaDNLC9rTg+3cYH/rch+aSPTcTmTocrdHgcfdvR2wARgQtA8ANgTtjwf9pByWLVvGJ598UuYCfxD5Rjpx4kQWLVpUiZGJVL6UlJQDVhovS2FhIaNGjWL79u0xiCpc0VwV3MxSiSQ2r7n7QVcCLs+cmx1AN3c/AegE9DCzU9GHhcQpM2sO9AZeDLYN6Aa8HXQZBVwU3O8bbBPsP8cOtpKiiMhe6tevT69evfZpLyoqYufOnWV+gE+dOpUnnngi1MumYyWKV0sZ8BLwvbs/Vp7XPmhy4xFbgs3U4Obow0Li1zBgELB7TLQBsNHdd69dsIz/m4zWDFgKEOzfFPTfg5kNNLPpe50TFhEBoF+/ftSrV69ke8uWLfzjH/+gc+fOdOrUiVdffXWP0zRFRUV89dVXXHPNNRQUFIQQcWxVJLEpR2LXFbga6GZms4LbvplkKeWacxPMX5gBtAOeAn6knB8WZrb7w2JteV5L5HCY2QVAnrvPMLOzovW8wcS254PXSLyvWCJyyLKysrj11lvZvHkzmzdvpri4mIceeogRI0aUJDS33HILRUVFnHfeeQA89dRTPPvss2zatCnM0GMqWqNR7j4ZqNAgSbmSG3ffBXQys3rAe0DFqxTtxcwGAgMP93lE9tIV6BNk9RlAHWA4UM/MUoKEvDmwPOi/HGgBLDOzFKAukYnFIiLl0qlTJ5555hm++OILFi5cCMC2bdv2+HDfsmULN910E2lpaQAUFBSEurBkZagyyy+4+0YzmwicxmF+WOibsMSCu/8J+BNAMHJzt7tfaWZvARcTuWLqWmBs8JBxwfZXwf5PPRFPfotIzEycOJGJEycetN/OnTvZuXNnJUQUH+J6+QUzaxSM2GBmmcB5RK5CmUjkwwD2/2EB+rCQ+PFH4E4zyyVymvSloP0loEHQfidwT0jxiYgklGheLVVR5Rm5aQqMCubdJAFj3H28mc0D3jSzh4CZ7Plh8WrwYbEeuDzqUYuUg7tPAiYF9xcBXfbTZztwSaUGJiKS4A6hzk1UHTS5cfdviVQD3LtdHxYiIiKyX1Vmzo2IiIhIeSi5gS1AYq0YVn4Nqb6XyUfr2LXktIhInFFyA/MPtqZEojKz6Tp2ERFJJLGaKFxe8ZLciIiISAJRciMiIiIJRclNUMyvmtKxi4hIwqn2yU1Qrbha0rFLPElLS6NTp07UrFmTXbt2MWPGDLZu3RrT10xPT+fkk08mNTWV4uJivvnmGzZv3hzT1xSR2Kv2yY2IhC8pKYm//e1vXH/99aSlpbFjxw4uuugiJk2aFNPXbdiwIW+//TZ169bF3RkzZgw33XQT27dvj+nrikjshF3E76DLL8SamfUws/lmlmtmCVf63sxamNlEM5tnZnPN7Pagvb6ZfWxmC4OfWUG7mdkTwe/jWzP7RbhHcHjMLNnMZprZ+GD7SDObGhzfaDNLC9rTg+3cYH/rUAOvhlJTU2ncuDHp6emYGTt27ChZBDCWCgoKWL9+PWZGUlISxx9/PDVq1Ij568YT/Z1IIgpz+YVQk5tgSYengJ5AB6C/mXUIM6YYKALucvcOwKnALcEx3gNMcPccYAL/t6ZRTyAnuA0Enqn8kKPqdiJrke32KPC4u7cDNgADgvYBwIag/fGgn1SiHTt2MGzYMHbs2AHArFmzWLcu9gukr1+/vmTRwZ07d/Lggw+yfv36mL9unNHfiSScapvcEFm+IdfdF7l7IZEVm/uGHFNUuftKd/8muL+ZyBtYMyLHOSroNgq4KLjfF3jFI6YQWX29aeVGHR1m1hzoDbwYbBvQDXg76LL3ce/+fbwNnBP0l0q0aNEiVq5cya5du3j99dcr7dTQu+++S35+Pvn5+cyYMaNSXjNe6O9EElW8L5wZS82ApaW2lwGnhBRLzAVDyCcCU4Fsd18Z7FoFZAf39/c7aQaspOoZBgwCagfbDYCN7l4UbO8+Nih13O5eZGabgv7VtXpzKNauXcsdd9xBq1atGDNmTKW97qeffsq1114LwNKlSw/SO+EMQ38nkmBUxK+aMLNawDvAHe6eX/rLlru7mYX3vyAGzOwCIM/dZ5jZWSGHIxXw4YcfVvprujv//ve/K/11wxbLvxMzG0jk1LZIKKpzcrMcaFFqu3nQllDMLJVIYvOau78bNK82s6buvjI47ZQXtCfK76Qr0MfMegEZQB1gOJHTbCnBt9LSx7b7uJeZWQpQF4j9hA+RcMXs7yQotfA8QKJ9eZKqIczkJuw5N9OAnODKgDTgcmBcyDFFVXA+/CXge3d/rNSuccC1wf1rgbGl2q8Jrpo6FdhU6vRVleHuf3L35u7emsi/66fufiUwEbg46Lb3ce/+fVwc9NcbsiQ0/Z1IIqu2c26Cc8a/Bz4CkoER7j43zJhioCtwNTDHzGYFbfcCjwBjzGwAsAS4NNj3AdALyAW2AddXarSx90fgTTN7CJhJJPEj+PmqmeUC64m80YtUV/o7kSot7Do3pqRfpGI0xC+HaYa7d67MF9T/WTkc7l7hK/Jq1qzpHTt2LHf/adOmRfXvIuw5NyIiIpKAqvOEYhEREUlASm5EREQkoSi5ERERkYQRdhG/sC8FF4k6M1tsZnPMbJaZTQ/aqsVCpSIi8aI6ry0lEitnu3unUrPvq8tCpSIicUHJjUjsJfxCpSIi8aS4uLjct4MxsxFmlmdm35XntZXcSCJy4H/NbEawvg5UfKFSERE5RBUZtSnnyM1IoEd5X18TiiURne7uy82sMfCxmf1QeuehLFSqRQhFRCommqeb3P1zM2td3v5KbiThuPvy4Geemb0HdOEwFyrVIoQiIhWjq6VEosTMappZ7d33ge7AdyT4QqUiIvGmgqelGprZ9FK3wxop18iNJJps4L3IYuykAK+7+4dmNo3quVCpiEgoKjhys1ZrS4mUwd0XASfsp30dcM5+2h24pRJCExGpNlTET0RERBJONK+WMrM3gK+A9ma2LBiFL5NGbkRERCTqylO/przcvX9F+iu5ERERkajTwpkiVctaYGvwszpqiI79cLSKRiAi8SzsOTdKbkQqyN0bmdn0aM7sr0p07NXz2EUqSsmNiIiIJBQlNyIiIpJQlNyIVD3Phx1AiHTsInJQYSY3FuaLi4hI7Gk9NDkc7m4VfUxaWpo3adKk3P2XLl06QxWKRUREJK7ptJSIiIgklGgW8asoLb8gUgFm1sPM5ptZrpndE3Y80WZmLcxsopnNM7O5ZnZ70F7fzD42s4XBz6yg3czsieD38a2Z/SLcIzh8ZpZsZjPNbHywfaSZTQ2OcbSZpQXt6cF2brC/daiBi8SZaC6/UFFKbkTKycySgaeAnkAHoL+ZdQg3qqgrAu5y9w7AqcAtwTHeA0xw9xxgQrANkd9FTnAbCDxT+SFH3e3A96W2HwUed/d2wAZg95o2A4ANQfvjQT8RoWKJjZIbkXB1AXLdfZG7FwJvAn1Djimq3H2lu38T3N9M5EO+GZHjHBV0GwVcFNzvC7ziEVOAembWtHKjjh4zaw70Bl4Mtg3oBrwddNn72Hf/Tt4Gzgn6iwgauRGpKpoBS0ttLwvaElJwmuVEYCqQ7e4rg12rgOzgfqL9ToYBg4DdkwUaABvdvSjYLn18Jcce7N8U9BcRlNyISJwxs1rAO8Ad7p5fep9H3okS7tJiM7sAyHP3GWHHIpIIwkxudLWUSPktB1qU2m4etCUUM0slkti85u7vBs2rzaypu68MTjvlBe2J9DvpCvQxs15ABlAHGE7kVFtKMDpT+vh2H/syM0sB6gLrKj9skfgU5qXgGrkRKb9pQE5w9UwacDkwLuSYoiqYM/IS8L27P1Zq1zjg2uD+tcDYUu3XBFdNnQpsKnX6qkpx9z+5e3N3b03k3/ZTd78SmAhcHHTb+9h3/04uDvon3IiWyKEIe0KxRm5Eysndi8zs98BHQDIwwt3nhhxWtHUFrgbmmNmsoO1e4BFgjJkNAJYAlwb7PgB6AbnANuD6So22cvwReNPMHgJmEkn+CH6+ama5wHoiCZGIBMKsc6PlF0REEpyWX5DDcSjLL6SkpHjt2rXL3X/jxo1afkFERETim5ZfEBERkYQRq7k05aXkRkRERKJOV0uJiFRjZrbYzOaY2Swzmx60VZv1vCQxqYifiIic7e6dSk2qrE7reUkCUnIjIiJ7qxbreUniUnIjIlK9OfC/ZjbDzAYGbYe1npeZDTSz6btPc4lUJnenuLi43Ldo04RiEZHwne7uy82sMfCxmf1Qeqe7e0Vr1bj788DzoDo3Eg5NKBYRqcbcfXnwMw94D+hCsJ4XQAKv5yUJTKelRESqKTOraWa1d98HugPfUQ3W85LEprWlRESqr2zgvciapaQAr7v7h2Y2jeq7npdUcWEX8dPaUiIiCU5zbuRwHMraUmbmycnJ5e6/a9euA64tZWY9gOFEFi1+0d0fOdDzaeRGREREoi5agydmlgw8BZxH5OrAaWY2zt3nlfUYzbkRERGRqIvinJsuQK67L3L3QuBNIvWeyqSRGxEREYm2j9y9YQX6Z+xVk+n5oJwB7L+20ykHejIlNyIiIhJV7t4jzNfXaSkRERGJZxWu7aTkRkREROLZNCDHzI40szTgciL1nsqk01IiIiISt9y9yMx+D3xE5FLwEe4+90CPUZ0bEZEEZ2abgflhx1FBDYG1YQdRQYkYcyt3b1RZwUSLRm5ERBLf/AMVSItHZjZdMcdeVYy5PDTnRkRERBKKkhsRERFJKEpuREQS3/MH7xJ3FHPlqIoxH5QmFIuIiEhC0ciNiIiIJBQlNyIiCcrMepjZfDPLNbN7wo6nNDMbYWZ5ZvZdqbb6ZvaxmS0MfmYF7WZmTwTH8a2Z/SKEeFuY2UQzm2dmc83s9ioQc4aZfW1ms4OY/xK0H2lmU4PYRgeF8TCz9GA7N9jfurJjjhYlNyIiCcjMkoGngJ5AB6C/mXUIN6o9jAT2Xn/oHmCCu+cAE4JtiBxDTnAbCDxTSTGWVgTc5e4dgFOBW4LfZzzHvAPo5u4nAJ2AHmZ2KvAo8Li7twM2AAOC/gOADUH740G/KknJjYhIYuoC5Lr7IncvBN4E+oYcUwl3/xxYv1dzX2BUcH8UcFGp9lc8YgpQz8yaVkqgAXdf6e7fBPc3A98TWa06nmN2d98SbKYGNwe6AW8H7XvHvPtY3gbOMTOrnGijS8mNiEhiagYsLbW9LGiLZ9nuvjK4vwrIDu7H1bEEp2tOBKYS5zGbWbKZzQLygI+BH4GN7l60n7hKYg72bwIaVGrAUaLkRkRE4o5HLuWNu8t5zawW8A5wh7vnl94XjzG7+y5370RkJe0uwNHhRlQ5lNyIiCSm5UCLUtvNg7Z4tnr3qZvgZ17QHhfHYmapRBKb19z93aA5rmPezd03AhOB04icItu9/FLpuEpiDvbXBdZVbqTRoeRGRCQxTQNygitj0oDLgXEhx3Qw44Brg/vXAmNLtV8TXIF0KrCp1KmgShHMPXkJ+N7dHyu1K55jbmRm9YL7mcB5ROYKTQQuLiPm3cdyMfCpV9FieCriJyKSoMysFzAMSAZGuPtfw43o/5jZG8BZRFalXg0MBv4HGAO0BJYAl7r7+iCx+AeRq6u2Ade7+/RKjvd04AtgDlAcNN9LZN5NvMZ8PJEJwslEBjPGuPsQM2tDZIJ5fWAmcJW77zCzDOBVIvOJ1gOXu/uiyow5WpTciIiISELRaSkRERFJKEpuREREJKEouREREZGEouRGREREEoqSGxEREUkoSm5EREQkoSi5ERERkYSi5EZEREQSyv8P9uJt4q12RsEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# deformed_path = \"/root/capsule/scratch/template_to_ccf/25um/Output Image Volume.nrrd\"\n", + "template_path = \"/root/capsule/data/smartspim_lca_template/smartspim_lca_template_25.nii.gz\"\n", + "ccf_path = \"/root/capsule/data/allen_mouse_ccf/average_template/average_template_25.nii.gz\"\n", + "\n", + "ccf_annotation_path = \"../data/allen_mouse_ccf/annotation/ccf_2017/annotation_25.nii.gz\"\n", + "ccf = ants.image_read(ccf_path)\n", + "print(ccf_path)\n", + "print(f\"ccf: {ccf}\")\n", + "outprefix = \"/root/capsule/scratch/ccf_to_brain/\"\n", + "plot_antsimgs(ccf, \n", + " f\"{outprefix}/ccf\",\n", + " title=\"ccf\", \n", + " vmin=0, vmax=None)\n", + "\n", + "###############################################\n", + "\n", + "ccf_anno = ants.image_read(ccf_annotation_path)\n", + "print(ccf_annotation_path)\n", + "print(f\"ccf_anno: {ccf_anno}\")\n", + "outprefix = \"/root/capsule/scratch/ccf_to_brain/\"\n", + "plot_antsimgs(ccf_anno, \n", + " f\"{outprefix}/ccf_anno\",\n", + " title=\"ccf_anno\", \n", + " vmin=0, vmax=None)\n", + "\n", + "###############################################\n", + "template = ants.image_read(template_path)\n", + "print(template_path)\n", + "print(f\"template: {template}\")\n", + "\n", + "plot_antsimgs(template, \n", + " f\"{outprefix}/template\",\n", + " title=\"template\", \n", + " vmin=0, vmax=None)\n", + "\n", + "###############################################\n", + "# apply transform\n", + "ccf_anno_to_template_deformed = ants.apply_transforms(\n", + " fixed = template,\n", + " moving = ccf_anno,\n", + " transformlist=ccf_to_template_transform_path,\n", + " whichtoinvert = [True, False]\n", + " )\n", + "\n", + "print(\"\")\n", + "dataset_id = \"\"\n", + "plot_antsimgs(ccf_anno_to_template_deformed, \n", + " f\"{outprefix}/ccf_anno_to_template_deformed\",\n", + " title=f\"ccf_anno_to_template_deformed\", \n", + " vmin=0, vmax=None)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60ae0bb4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "4e98d074", + "metadata": {}, + "outputs": [], + "source": [ + "# ants.image_write(ccf_anno_to_template_deformed, \n", + "# f\"{outprefix}/ccf_annotation_to_template_moved.nii.gz\") \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "92d4f7c4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "19bfc308", + "metadata": {}, + "source": [ + "## register to brain" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "c222aa45", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/prep_percNorm.nii.gz\n", + "brain: ANTsImage (RAS)\n", + "\t Pixel Type : float (float32)\n", + "\t Components : 1\n", + "\t Dimensions : (535, 738, 314)\n", + "\t Spacing : (0.025, 0.025, 0.025)\n", + "\t Origin : (-1.5114, -1.5, 1.5)\n", + "\t Direction : [ 1. 0. 0. 0. 1. 0. 0. 0. -1.]\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "brain_path = f\"{reg_folder}/prep_percNorm.nii.gz\"\n", + "brain = ants.image_read(brain_path)\n", + "\n", + "print(brain_path)\n", + "print(f\"brain: {brain}\")\n", + "\n", + "outprefix = \"/root/capsule/scratch/ccf_to_brain/\"\n", + "plot_antsimgs(brain, \n", + " f\"{outprefix}/brain\",\n", + " title=\"brain\", \n", + " vmin=0, vmax=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "06ee5b46", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/1InverseWarp.nii.gz',\n", + " '/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/0GenericAffine.mat',\n", + " '/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/rigid_0GenericAffine.mat']" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "template_to_brain_transform_path" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "1b936d14", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/rigid_0GenericAffine.mat',\n", + " '/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/0GenericAffine.mat',\n", + " '/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/1InverseWarp.nii.gz']" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "template_to_brain_transform_path" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "1ffe3297", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAFuCAYAAACbaPJIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAAsTAAALEwEAmpwYAABaPUlEQVR4nO3deXyU9bn//9c1M5mskJUdBKLIIgoKghuI4AJqpdal6rG1rad2tbXHnlr767ft8fScas+xrfa0nnLUikul1BVbrVWEurDJpiwBCSEQAgkBQhKyJ/P5/TF30rAnMMnMJO/n4zGPmfnc99z3NZPJzDWf1ZxziIiIiMQjX7QDEBERETlZSmREREQkbimRERERkbilREZERETilhIZERERiVtKZERERCRuKZERERGRuKVERiQGmNlIM1trZlVm9q1ox9PVzOwpM/tpBI/3AzN7PFLH8445zcx2tnNfM7Pfm1m5ma2IZByRYGaFZnZ5tOMQiYRAtAMQEQC+Byxyzo2PdiAdYWZPATudcz+MdixtOef+M8ohXAJcAQx2zlVHORaRbk01MiKxYSiwIdpBxAMzi4cfYEOBwpNJYuLk+YnEDCUyIp3AzIaY2UtmVmZm+8zsf7zyL5tZnteEtNHMzjOzd4DLgP8xs4NmduZxjnuNma0xs0ozKzKzn7TZNszMnJndYWY7zGyvmf1/bbb/xMzmm9nT3vk3mNnENttHm9liMzvgbbvuBM/xLuCfgO95cb92MsdpI8fM3vJi+7uZDW1zLmdm3zCzLcAWr+wR7zWoNLNVZjblsOf6bHtel+M8v2SvyavczDYC5x+2faCZvej9jbe1NAma2Z3A48CF3uvyb175l80s38z2m9kCMxt4rOfX0oxlZt8zsz1mttvMPm1mV5vZJ94xftDm8T4z+76ZbfXeb/PNLKvN9s+Z2XZv2wmfu0hccc5F/ALMBDYD+cD3O+McuugSqxfAD3wE/BJIBZIINzXcBBQT/kI04AxgqPeYxcA/t+PY04CzCf8IOQcoBT7tbRsGOOD/gGRgHFAPjPa2/wSoA672YvwZsMzbluD9v/4ACALTgSpg5AnieQr4aZv7p3KcKmAqkAg8ArzfZrsD3gKygGSv7HYgm3AT+b1ACZDU5rk+257X5TgxPQi8551zCLCecDMa3uu/CviR9zxzgQLgKm/7Fw6LfzqwFzjPe36/Bt491vPz/s5N3vETgC8DZcAfgF7AWUAtMNx7/LeBZcBg7/i/A573to0BDrZ5bX/hHfvyaP+v6KJLJC6RP2D4A3Kr948dJPyBPibaT1QXXbrqAlzofekEDit/E/j2MR6zmHYkMkd53K+AX3q3W76wB7fZvgK4xbv9E+DtNtvGALXe7SleIuBrs/154CcnOP9THJrInMpx5rW5nwY0A0O8+w6YfoJjlAPj2jzXwxOZo74uxzleATCzzf27+EciMxnYcdj+9wO/925/gUMTmSeAnx/2/BqBYUd7foQTmVrA793v5e0zuc0+q/hHEpsHzGizbYB3/ADhZKjta5sKNKBERpducumMpqVJQL5zrsA51wDMA2Z3wnlEYtUQYLtzruko5VtP5cBmNtnMFnnNGRXAV4Gcw3YraXO7hvCX5rG2JXl9MgYCRc65UJvt24FBHQzxVI5T1HLDOXcQ2O8d74jtAGb2Xa+ZrsLMDgDpHPlatHW81+VoBh52zu1tbg8FBnrNZwe88/8A6HecY7U+3nt++zj0dSk67DH7nHPN3u1a77q0zfbaNs9hKPBym1jyCCeC/Q5/Hi7cb2ffMeIUiTudkcgM4tB/yJ10/MNQJJ4VAacdpdNmEXD6KR77D8ACwjUV6cD/Em6mOlW7gCFm1vYz4TTCTWHH4yJ0HAgnegCYWRrhZpZdRzuX1x/me8DNQKZzLgOoIDKvRYvdbWMi/DxaFAHbnHMZbS69nHNXH+NYuwgnGy3xpxJuFmv7uhz+WnZEETDrsHiSnHPFhz8PM0vxzi3SLUSts6+Z3WVmK72L00WXdl7KovWe7YAVhL88HjSzVDNLMrOLCXcA/a6ZTbCwM6xNh9Z26gXsd87Vmdkk4LYIxbyccC3F98wswcymAZ8iXKN6PKWEm5FP9TgAV5vZJWYWBP6dcP+dw2spWvQi3M+jDAiY2Y+A3u04R0fMB+43s0wzGwzc3WbbCqDKzO6zcKdgv5mNNbPzj34onge+aGbjzSwR+E9guXOuMEKx/i/wHy3vJzPrY2YtNeEvANe2eW0fQAM9pBvpjDdzMYf+ihnMUX6NOefmOOcmOucmHr5N5Di2n3iX6PKaAz5FuDPvDsK1kp91zv0J+A/CtSpVwCuEax064uvAA2ZWRbjvw/wIxdzgxTyLcKfU3wKfd85tOsFDnwDGWLhJ45VTOA6EX5cfE25SmkC4M++xvAn8FfiE8HuijiObZk7Vv3nH3gb8DXimZYP3N74WGO9t30s4UU0/2oGcc28D/w94kXCSezpwSwRjfYRwTd3fvPfGMsL9eHDObQC+Qfj13U24L1G7JvYTiQfm3KnUZh7lgOHq9E+AGYQTmA+B27x/pmM9JrJBSHe2SsmviIi0iPjES865JjP7JuFfTH7gyeMlMSIiIiInq1PaSZ1zrzvnznTOne6c+4/OOIdId2XhSeQOHuXyT/EcT6w9Ly+mN44R0w9O/GgRiQURb1o6qSDUtCTtp6YlERFppZ7rIiIiEreUyIiIiEjcUiIjIiIicUuJjIiIiMQtJTIiIiISt5TIiIiISNxSIiMiIiJxS4mMiIiIxC0lMiIiIhK3lMiIiIhI3FIiIyIiInFLiYyIiIjELSUyIiIiEreUyIiIiEjcUiIjIiIicUuJjIiIiMQtJTIiIiISt5TIiIiISNxSIiMiIiJxS4mMiIiIxC0lMiIiIhK3lMiIiIhI3FIiIyIiInFLiYyIiIjELSUyIiIiEreUyIiIiEjcUiIjIiIicUuJjIiIiMQtJTIiIiISt5TIiIiISNxSIiMiIiJxS4mM9DhmNtPMNptZvpl9P9rxiIjIyVMiIz2KmfmB3wCzgDHArWY2JrpRiYjEPjN70sz2mNn6dux7mpktMrM1ZvaxmV3dWXEpkZGeZhKQ75wrcM41APOA2VGOSUQkHjwFzGznvj8E5jvnzgVuAX7bWUEFTrSDmT0JXAvscc6N9cqygD8Cw4BC4GbnXLmZGfAIcDVQA3zBObe6c0IXOSmDgKI293cCk4/3ADNznRqRdGvOOYt2DCKR4Jx718yGtS0zs9MJ13L3Ify9/2Xn3CbAAb293dKBXZ0VV3tqZJ7iyAzs+8BC59wIYKF3H8LV9SO8y13AY5EJU6RrmdldZrbSzFZGOxYRkRg2B7jbOTcB+C7/qHn5CXC7me0EXgfu7qwATpjIOOfeBfYfVjwbmOvdngt8uk350y5sGZBhZgMiFKtIJBQDQ9rcH+yVHcI5N8c5N9E5N7HLIhMRiSNmlgZcBPzJzNYCvwNavvNvBZ5yzg0m3ErzjJl1SneWEzYtHUM/59xu73YJ0M+7fbRq+0HAbkRiw4fACDMbTjiBuQW4LbohiYjEJR9wwDk3/ijb7sRrzXHOLTWzJCAH2NMZQZwS55wj3BbWIaq6l2hwzjUB3wTeBPIId0bbEN2oRETij3OuEthmZjcBWNg4b/MOYIZXPhpIAso6I46TrZEpNbMBzrndXtNRS4bVrmp7CFfdE25bU2dK6VLOudcJt9mKiEg7mdnzwDQgx+v78mPgn4DHzOyHQALhkaAfAfcC/2dm3yFc2fEFr+Ij4k42kVkA3AE86F2/2qb8m2Y2j/BIkIo2TVAiIiISp5xztx5j0xFDsp1zG4GLOzeisPYMvz5aBvYgMN/M7gS2Azd7u79OuFNPPuFhWF/shJhFREREALBOqunpWBBqWpL2W9XVI4n0/pRToXlkRDrXyTYtiYiIiDBz5ky3d+/edu+/atWqN51z7Z0h+ISUyIiIiMhJ27t3LytWrGj3/n6/PyeS51ciIyIiIqckmt1UlMiIiIjISXPOKZERERGR+KVERkREROKWEhkRERGJW0pkREREJG4pkREREZG45JwjFApF7fxKZEREROSUqEZGRERE4pYSGREREYlbSmREREQkLmlCPBEREYlrSmREREQkbimRERERkbilREZERETikvrIiIiISFzThHgiIiISt1QjIyIiInFLiYyIiIjEJfWRERERkbimREZERETilhIZERERiVtKZERERCRuKZERERGRuOSc0zwyIiIiEr9UIyMiIiJxS4mMiIiIxC0lMiIiIhKXNCGeiIiIxLVIJzJmVghUAc1Ak3Nu4rH2VSIjIiIip6STamQuc87tPdFOSmRERETklKhpSUREROJSJ80j44C/mZkDfuecm3OsHX2RPrNIVzKzJ81sj5mtb1OWZWZvmdkW7zrTKzcze9TM8s3sYzM7L3qRi4h0Hy0dfttzAXLMbGWby11HOeQlzrnzgFnAN8xs6rHOfcJExsyGmNkiM9toZhvM7Nteub4sJBY8Bcw8rOz7wELn3AhgoXcfwv8QI7zLXcBjXRSjiEi31sFEZq9zbmKbyxG1Lc65Yu96D/AyMOlY525PjUwTcK9zbgxwAeHMaAz6spAY4Jx7F9h/WPFsYK53ey7w6TblT7uwZUCGmQ3okkBFRLqxDiYyx2VmqWbWq+U2cCWw/lj7nzCRcc7tds6t9m5XAXnAIPRlIbGrn3Nut3e7BOjn3R4EFLXZb6dXdgQzu6ul2rPzwhQR6R4imcgQ/sx+38w+AlYAf3HO/fVYO3eos6+ZDQPOBZbT8S+L3Yh0Meec8zqLdfRxc4A5ACfzeBGRniLSE+I55wqAce3dv92JjJmlAS8C9zjnKs2s7Uk7/GXhde45WgcfkVNVamYDnHO7vdrAPV55MTCkzX6DvTIRETkF0Rx+3a5RS2aWQDiJec4595JXXNrSZHQyXxbOuTktHX1ONniRY1gA3OHdvgN4tU35570O6RcAFW1qFUVE5CRFuGmpQ9ozasmAJ4A859wv2mzSl4VEnZk9DywFRprZTjO7E3gQuMLMtgCXe/cBXgcKgHzg/4CvRyFkEZFuJxQKtfsSae1pWroY+BywzszWemU/IPzlMN/74tgO3Oxtex24mvCXRQ3wxUgGLNKWc+7WY2yacZR9HfCNzo1IRKRniflFI51z7wN2jM36shAREenhYjqRERERETkeJTIiIiISt5TIiIiISNxSIiMicc/n83XKiAQRiW0x39lXROR4AoEAI0eOZMaMGRQVFbFlyxbq6uooLy9nyJAhpKWlUVRUhJnh8/mor6/HzGhsbMTMqK6uprGxkaamJpqamqL9dETkJCiREZG4k5iYyLhx47j00kuZNGkSQ4YMobGxkYMHDxIKhdi/fz99+vQhGAxSXFxMMBgkMTGRmpoa6urqOHjwIA0NDezZs4e6ujoOHDhAUVER27Zto6ysjJqamqh+OIpI+ymREZFjCgQC+Hw+GhoaonJ+MyM5ORmAhIQEMjIy6NWrF7NmzWLatGn06dMHny88t6bf72fHjh2EQiHKysr46KOP2L17N/v37yc9PZ0hQ4aQk5NDcnIyu3btor6+nmAwSGZmJrm5uVxxxRU0Njaye/du/va3v7FkyRIaGxuj8rxFpP2i2aysREYkhiUlJTFq1CiCwSDr16+npqamU8/n8/nIysoiMTGR5ORkRo4cyWmnncY555yDmZGYmEhOTg7p6ekkJSW1JjAtQqEQ69ev549//CNlZWXU1tbS3Nzc+mstEAjg9/vx+/2EQiGampowM8yMYDBITk4OgwcPZsKECQwcOJBAIKBERiTGqY9MD+Tz+TjttNOoqKigvLw82uFIjEpISGDy5MlMnTqV2tpaAoEA69evp6qqKuIfGn6/n4EDB3LVVVcxffp0+vXrh8/nIzk5Gb/fT9tFYo/HzJg0aRJ/+ctfKCgoOGL78frBNDQ0cPDgQQoLC1m2bFlUa6FEpGOUyPQww4cP5//9v//HRx99xGOPPUZdXV20Q5IYNGnSJC666CKCwSDBYJCLLrqIxMRENm7cSHV1NdXV1RH58AgGg1x//fXceOONDB48mMbGRg4cOABAfX09tbW1OOdITU0lMTGRpKSkQ5Kb5uZmGhoaKC8vZ9OmTSxatIidO3eeUkzq9CsSX5TI9CBpaWlcd911jBs3jpEjR1JSUsKCBQuorq6OdmgSI3w+H8OGDWP06NGkpKS0lqenp3PJJZcwbNgwysvLWb16NSUlJadUa5GcnMy1117L17/+dZxzvPfeeyxfvpwtW7YQCoVISkpqTWrS0tJIS0tjxIgRDBkyhNNOO40DBw6Ql5dHWVkZBQUF7Nixo1NqjEQktimR6SESExOZOXMmn/nMZ0hKSiIxMZGvfe1r9OrVi2effbbT+z9IfMjKyuKyyy7jtNNOO2JbMBhk6NCh9O/fn379+rFs2TK2bNlyUu+dlJQUvvSlL3HDDTewa9cunn/+eZYtW8b+/ftb+7WY2REfUEuXLiUpKYmkpCSqq6upr69X4iLSwymR6QF8Ph/jx4/njjvuIDs7Gwj3J+jTpw933nknwWCQJ598UslMD5eTk8OsWbMYMmTIMful+P1+UlJSSExMZNKkSVRVVVFYWNihUQNpaWnceuutXHvttSxbtoy5c+eyZcsWmpubD9nvaB9Ozc3NrU1bIiLq7NtDDBo0iO985zvk5uYe8QUVCARISkqKUmQSK1JTU5kyZQq5ubn4/f4T7u/3+8nIyCApKandHyJ+v59Bgwbxuc99jnHjxvHwww+zdOlSDh48eEqx+/1+nHOa2Vekh1Ii080lJSVx4403Mnr06COGqzY1NbFw4ULmzp2r2pgeLCEhgQkTJnDWWWcRCLT/3zI5OZmsrCwSEhJO2FcmMzOTmTNnMn36dHbv3s2PfvQjNm/eHJEPoFAoREJCAomJiQwdOpSGhgbq6+vZt28fdXV16rx7CsxsJvAI4Aced849GOWQRI6geWS6sUAgwMUXX8zs2bMJBoOHbGtsbOS9997jV7/6FWVlZVGKUGLB0KFDmTBhAomJiR16XCAQYMiQIWzYsOGYiYzP52PMmDF8/vOfx+/38/vf/56VK1dGdGizc46Ghgb8fj9ZWVlcd911jBgxgpKSEvLz8/nwww9ZunQp9fX1ETtnT2BmfuA3wBXATuBDM1vgnNsY3chEDqUamW5s2LBh3H333fTt2/eQ8traWl599VUee+wx9uzZE6XoJBYEAgFGjRpFVlZWhx/rnCMlJYXU1NSjzknUMhfN7bffzpIlS3jllVeorKyMRNhHVVtby5IlS6ivr+e2225j8uTJnHfeecyYMYPf//73vPXWW+zfv7/Tzt8NTQLynXMFAGY2D5gNKJGRmKE+Mt1YYmIis2fP5vTTTz+kX0xlZSW///3vefbZZ0+5b4LENzNj2LBhjBgx4qQe7/P5CAaDJCUlHTHCKCsri1mzZnHppZfy3HPPddl0/01NTaxYsYJdu3bxzW9+k6lTp5KTk8NXv/pVJk6cyDPPPMOmTZs02V37DAKK2tzfCUyOUiwix6REppsaMWIEV1xxxSF9Hmpra3n66ad5+umn1SdG8Pv9nH766aSlpZ30MZKSkujbty+FhYU0NTXh8/nIzc3l9ttvJzk5mUcffZQNGzZ06QeNc46ioiIeffRRqqurueqqq+jVqxeXXnopY8eOZfny5bzxxht88sknHDhwQMO3T5GZ3QXc5d2dEM1YJL4559o3jfeRj4t0KO2mRKaTpKam8oUvfIFBgwa1ljU2NvLiiy+qY6+0CoVC5OXlkZyczNixYzvcRwagd+/erR1+g8EgV111FVdffTUrVqxg3rx5VFVVdULk7bNr1y7mz59PbW0t06dPJzs7mz59+nD11VczY8YMVq9ezeuvv84HH3yg2smjKwaGtLk/2Cs7hHNuDjAHwMyUFUqXUyLTzZgZM2fO5KKLLmqtjQmFQrz55pv8+te/1ge2ALQ2N5aUlLBixQpqa2s555xzgHCzZDAYbNcaR4FAgH79+pGbm8s111zDsGHDmDt3LsuWLYv6aCHnHJs2bWLXrl3k5+fzmc98htzcXILBIMnJyVx88cWMGTOGhoYGFi1aFNVYY9SHwAgzG044gbkFuC26IYkcSYlMN9O/f39uuukmMjMzW8u2bt3KY4891qkdLSV++Hw+fD5f6zpFZWVlrF69mrKyMnr37s2AAQNIT08nLS2NXr16HTFs/3CDBg3iK1/5Cg0NDTz44IMUFRXFVHNNZWUlf/7zn1mzZg1Tp05l+vTpDB8+nKSkJBISEo7ax0fAOddkZt8E3iQ8/PpJ59yGKIclcgh19u1mzIzp06czatSo1rKqqiqeeeYZCgsLoxeYxJTevXvTt29f6uvrqaiowDlHdXU1mzZtIjMzk08++QSfz8fAgQMZM2YMQ4YMOWL4flv9+/enb9++PPDAA+zYsaMLn0n7NTY2UlhYSGlpKWvXrmXy5MkEAgEaGhpYvXq1kphjcM69Drwe7ThEjkfzyHQj48aN4+abb27t69DY2Mgf/vAHXnvtNc16KkC4KSg5OZlQKISZkZOTA0BZWRl1dXWUlZXR1NREKBSitLSUbdu2MWPGDMaMGXPUpqZAIMCgQYP461//yvr167v66XRYbW0t69atIy8vDzMjGAxSW1sb7bBE5BSoRqabSEtL4+abbyY3NxcID0NdunQpTz/9NHV1dVGOTmJFeno648aNIzU1leLiYhobG9mzZw+pqakkJiZSUVHRmvQ2Njayb98+1q9fz5AhQ+jdu/cRx8vIyGD//v3MmzcvbpJl51zrUHANwxaJf9FMZI7f8C7tZmZceumlXHbZZQQCAZqamli9ejUPPfSQJgCTQxw4cICNGzfS3NzMhAkTOP/88znjjDNISUlp7TPTVigUYufOnUft9xIIBMjOzmb+/PlHnRBPRKSztfSRae+lPczMb2ZrzOzPJ9pXiUyEDB48mH/6p38iPT2dUCjEmjVr+NnPfsa2bduiHZrEmObmZnbs2MGbb75JQUEBzjlOO+00zj//fEaPHk3fvn2PWG+ppqaGtWvXsnfv3kPKc3Jy2LFjB2+//XZXPgURkUNEOpEBvg3ktWdHJTIRkJSUxO23387YsWMByMvL46c//WnEFuST7qllOv8PPviA7du34/f7GTFiBOeddx7Z2dkEAgH8fj8pKSkkJSVRVVVFaWlpa41Ny6rpTz31VJfM2Avh0VbZ2dlMmDCB6667jqFDh3bJeUUktkUykTGzwcA1wOPtObf6yJwiM+Oyyy7j+uuvB+Djjz/mv/7rv/jkk0+iHJnEg8rKSj755BP27t3LwYMHGTZsGEOHDiUlJYX9+/ezb98+gsEgmZmZrbP2VlZWkpWVRU5ODgUFBV32XsvMzOSaa67hqquuYujQoQQCAZ577jkef/zxDi0G2dJh2czipk+PiBxfhH+0/wr4HtCrPTsrkTlFQ4cO5Utf+hJNTU387Gc/45133tEikNJuLZ1eWxKZAwcOkJWVxbhx4xg9ejQA1dXVrRPItcy1kpSUhM/n409/+lOXdJYdMmQI3/rWt5g6dSpJSUmt5Z/97GfZsmULb7/99kklJQkJCTQ1NanmUiTOdfB/OMfMVra5P8ebnRozuxbY45xbZWbT2nMwJTKnICkpiZtuuokRI0bw2muvsWDBAqqrq6MdlsQZ5xxNTU0cPHiQbdu2UVZWRiAQwMzo37//UVfFHjZsGKtWraKgoKBTY2tZt+kHP/gB48aNO6LvTu/evbnhhhv48MMP293ZuOUDLxgMti7hsW3bNiUzInHKOdfRHzJ7nXMTj7HtYuA6M7saSAJ6m9mzzrnbj3Uw9ZE5SWbGhAkT+NSnPkVFRQXPP/+8khg5Zc3NzVRUVPDhhx+yePFiNm3adESzTXp6OuXl5Tz77LOdumaXmTF27Fj+8z//k3PPPfeIJKZlnzPPPLN1yoGOqK+vbz1HcnJyJEIWkSiJVB8Z59z9zrnBzrlhhJfkeOd4SQyoRuakZWdnc/fdd5OTk8Pzzz+vWXslohobG8nPz6ehoYH6+npGjRpFWloaycnJDBgwgEceeYSSkpJOO7+ZMWLECO677z7OPPPM46751Lt3byZNmsTatWtpbm4+5BipqalkZmaSmZlJYWEhVVVVh3yQbd++nYaGhnatKSUisUsT4sWZQCDATTfdxFlnnUVpaSnPP/+8VrOWiAuFQuzYsYPy8nJKS0u58MILmThxIq+//jpLly7t1I6yZ555Jj/84Q8ZPXr0CZOMQCDAzJkz2bRpE3//+98JhUL4fD4uuOACZs+eTVZWFmlpaSxfvpyXXnqJkpISmpubCYVCNDU1UVxcrGYlkTjXGf/DzrnFwOIT7adE5iScc8453HTTTYRCIV588cVO76cgPVcoFKKyspLNmzfTv39/Ro8ezauvvnpIzUek5eTkcOuttzJ27NgTLlbZYujQoXzhC19g48aNlJaW4vP5mDBhAtOmTcPv9xMKhRgwYAATJkygsLCQ7du3s3XrVvLz89m1a5dGL4nEsWgvGqk+Mh00cOBA7rvvPvr06cOKFStYsGCBPoSjxMyGmNkiM9toZhvM7NteeZaZvWVmW7zrTK/czOxRM8s3s4/N7LzoPoP2aVlQMjMzk0WLFnXqTNF+v5+bbrqJWbNmtTuJgfAw8kWLFlFRUQGE+/ps2rSJiooKGhoaKCkp4d1336WoqIjzzjuPoUOH0tjYqJpMkW6iEybEa7cT1siYWRLwLpDo7f+Cc+7HZjYcmAdkA6uAzznnGswsEXgamADsAz7rnCuMeORRkJ6ezle+8hXOPvtsysrK+P3vf09RUVG0w+rJmoB7nXOrzawXsMrM3gK+ACx0zj1oZt8Hvg/cB8wCRniXycBj3nVMMzOmTp3KVVddxY9+9KNOPdeoUaO44oorDhlifSKhUIglS5bwl7/8pXVNMeccH3zwAWlpaaSmppKfn8+GDRvw+XyMHDmSXbt2sXPnzs56GiKdKjc3l0AgwLZt27psMspYF+t9ZOqB6c65g2aWALxvZm8A/wL80jk3z8z+F7iT8BfDnUC5c+4MM7sFeAj4bCfF32USEhKYPXs21113Hc3NzSxevJi1a9eqbT+KnHO7gd3e7SozywMGAbOBad5ucwm3sd7nlT/twn+0ZWaWYWYDvOPErMTERM4//3z+/ve/d+qXv8/n47LLLmPYsGHtfkxzczPr1q3jscceo6ys7JBtNTU1/PnPf24dXt5ixYoVkQpZpMtlZGQwe/ZsMjIy2LBhA2+99ZbWOSPGF410YQe9uwnexQHTgRe88rnAp73bs737eNtnWDcYkjB58mS+/OUvk5SURHl5Oa+//rqqxWOImQ0DzgWWA/3aJCclQD/v9iCgbRXaTq8spuXk5FBZWclzzz3Xqe+55OTkDvWLaW5uZv369Tz00EPs2LHjqPs0NjYeksSIxDO/38+0adPo27cvwWCQs88+m0mTJuH3+6MdWtRFs2mpXZ9Y3iqUa4E9wFvAVuCAc67lE6rtF0Lrl4W3vYJw89Phx7zLzFYeNrtfTMrMzORTn/oU2dnZNDU18cILL7Bu3bpohyUeM0sDXgTucc5Vtt3m1b50+D8nlt6fgwcPpqCggIMHD55451MQCoXIy8ujrKzshJ2JQ6EQa9eu5Re/+AWbNm1SzaT0CP379+fss88GoKmpiffee4933nmnUzvfx4OWCfHae4m0do1acs41A+PNLAN4GRh1qif2piNumZI4Zj8FfT4fM2fOZPr06TjnWLt2LS+99JJqY2KE19z5IvCcc+4lr7i0pcnIzAYQTsABioEhbR4+2Cs7Qiy9P/fu3cv27ds7vVN5bW0tTz31FB999BHTp09n3Lhx9OvXj8TERCD8wd3Q0EBzczMfffQRjz32GHl5eUpiJC6ZGWaG3+8nPT2dgQMHkpaWhplRUlJCUVHRIct/mBmjR48mJSUFgNLSUt577z31kfHEeh+ZVs65A2a2CLgQyDCzgFfr0vYLoeXLYqeZBYB0wp1+49KYMWO45ZZbSE1Npby8nP/7v/+juPio333SxbwmyyeAPOfcL9psWgDcATzoXb/apvybZjaPcCffiljvHwOwdevWLjtXRUUFixcvZvny5QwfPpxzzjmHUaNGkZqaSkFBATt37qS8vJy1a9d2eg2RSKQlJibSr18/xo8fz9ChQ0lPTycjI4N+/frR2NjIjh07KC4uZvjw4YwfP57NmzezZcsWGhoa6N27N2eddRYQ/tJeuXIltbW1UX5GsSOmExkz6wM0eklMMnAF4Q68i4AbCY9cOvzL4g5gqbf9HRenP9l8Ph/jxo1rnX595cqVfPzxx/oFGjsuBj4HrPOaPgF+QDiBmW9mdwLbgZu9ba8DVwP5QA3wxS6N9iRF4/1WW1vLxo0bycvLIzk5mUAgQE1NTadVDYtEmt/vJzExkV69etGvXz9GjhzJFVdcwYgRI0hLSyMvL4+8vDwWLlzIli1b2LVrF3V1da3v7+TkZHJzc7nssstITU0lLS2N9PR0QqEQ27dvV/eCNqI9j0x7amQGAHPNzE+4T81859yfzWwjMM/MfgqsIfzLGO/6GTPLB/YTXishLg0YMIBPf/rT+P1+qqurWbhwIZWVlSd+YDc2bNgwrrrqKrZv386SJUui+no4594HjtWRfMZR9nfANzo1qG7GOadmVIkbZkZKSgozZsxgypQpDB8+nGAwyNKlS7niiivIzMykqqqKX//617z66qtUVlYe8wu4traWDRs2sHPnTv793/+dt99+m7feeov+/fuzbds2ra13mJhOZJxzHxMeDXJ4eQEw6SjldcBNEYkuisyM4cOHM2zYMMyM/Px8Vq9e3aN/jfp8PgYNGsR9991HZmYmc+fO5b//+781H4iIREUgEKBPnz6ceeaZDBw4kNzcXPr378/kyZOprq5m9erVrF+/ng8++IClS5diZhQXF5Ofn9/uz/KLLrqIs846i1/84hfs2rWLXbt2dfKzik8xncj0VElJScyYMYOkpCQaGxt5//33KS0tjXZYUZGWlsb555/Phx9+yJo1a/jd737HD3/4Q7761a8yZMgQ7r//fj755JNohykiPUAwGKR///6ce+65XHjhhYwbN46srCx8Ph/79++npKSEP/3pT7z88ssUFha2Dv//5JNPCAQCHZ4O4KyzzmLbtm36wXYCSmRijJkxbtw4pk2bRiAQYNeuXXzwwQc9tnd6Tk4Ojz32GM888wyPP/44f/jDH5g0aRLXX3891113Hfv27eNb3/pW66yuIiKRlpGRwcyZM5kyZQqnnXYaZWVllJSUsGjRIkpLS9m6dSubNm2isrKSxsbG1i/WQCBARkYG9fX1J9VBPSEhgUBAX5UnokQmxmRmZvKd73yHfv36EQqFWLVqFVu2bIl2WFGTmJhI7969+eEPf8j555/Pb37zG5YuXcq1115LMBjkyiuvpE+fPlquQUQiLiMjgwsuuICZM2dSV1fHihUrePLJJ9m4cSN1dXXH/AL1+XyMGjWKa6+9lg8//JAlS5ac1JdtQ0MDaWlpJCQkaHLHY2iZRyZalMgcxU033cSYMWMwM3bv3s0rr7zSozt27d27l8LCQgYMGMB1113HyJEjWbt2LRUVFfTp04fm5mb9g4tIRCUnJ3P11VczY8YM8vLy+OUvf0lxcXG7Pmuys7O5+eabGTVqFHPmzGHjxo0nXWNQU1NDdXV1j+4f2R6qkYkhqampjBs3Dr/fTygUYvXq1T1+mN2BAwdYsGBB61Tco0aNol+/fq0TQ3X2iswSW1JTU0lMTKS8vFxTEUinGDBgAHfccQd+v5+f//zn7Nixo0OJRHp6Oo2NjTz44IPs3n1qU0W98sorFBQUUF9ff0rH6e6UyMSQ8ePHM3bsWMyMffv2MW/ePKqqqqIdVlQ1NzezZs0aampq6NWrFxBufoNwteuiRYv0T95DpKSk8M1vfpOMjAx+/etfawSHRFRKSgoXXnghl1xyCStWrODtt98+qb6JBQUFFBQURCSm3bt3U1JSEpFjdWdKZGJEamoq11xzTeuXdH5+vkbjeLZv305paWlrItMiEAgwYMAAzEy/znuAUaNGceONN9KnTx8CgQD/8z//w/bt26MdlnQDycnJXHrppeTl5bF06dJOm78oOTmZYDBITU1Nu5MkfbYdXzxMiNdjXHLJJUyZMqV1iN5f//pXTcPu2blzJ++//z65ubmHrI5cXV2t16iHSEtLY+rUqWRlZZGWlsZtt91GU1MTP//5zykvL492eBLHcnJyOP/881m1ahV79uw58QPawefzEQgEDmmSmjZtGjfddBP9+/enpKSEN954gzfeeEM1yhGgRCZGbNq0iddff53LL7+ctLQ01q1bp0zcc/DgQR566CFOP/10LrnkEsLLHIXXAXrvvff0OkVBWloazc3NXbbeS3V1NXPnziUUCnHPPffQu3dvbr31VioqKvj1r3/dozvEt5eZDQGeBvoRXpV9jnPuETPLAv4IDAMKgZudc+XeemKPEF5aowb4gnNudTRi7yx9+vRh9OjRLF26lAMHDkTkmGbGmDFj2Lt3L/v37+eaa64hPT2dr3zlK2RkZABw5plncsEFF3D++efzy1/+kr1790bk3D2VEpkYsX37dh599FH+9re/MWnSJC0OeZjNmzfzox/9iMcff5zTTz+dpqYmXn/99Yi1RUvH+P1+xo4dS01NDWZGbW0t9fX1ZGdnc+DAARobG/H7/RQVFdHc3HzK53POUV5ezpw5c2hoaOD+++8nLS2NL33pS+Tl5fHqq6+e+CDSBNzrnFttZr2AVWb2FvAFYKFz7kEz+z7wfeA+YBYwwrtMBh7zruNey/vX7/ezdOnSiM7T5ZwjLy+PhIQEpkyZwj333ENGRgYJCQmH7BcMBvn0pz9N7969+Zd/+ZceO1dYJCiRiSHV1dWsWrWK1atXq5bhMM45PvjgAx599FH+/d//nX379vHMM89oBdgoqa2tZezYsZx77rlUV1eTkZHBoEGDSElJoa6ujoqKCoqKinjooYci+muzrq6OefPmMWPGDC699FIyMjKYMmUKr7/+ur4ITsBbbX23d7vKzPKAQcBsYJq321xgMeFEZjbwtLdO2DIzyzCzAbG0antCQgIXXXQR77//frsSZp/Px5lnnsno0aPZunUra9eujfjQZjPj/PPP5/Of/zxnn302KSkplJaWUlBQwIUXXkgwGGzdNxQKceDAAQ2vPgWaRyZGKYk5usbGRp555hlycnKorKzUtN1R1NDQwPr167n22mtJSUnB7/cTDAapra0lFAqRmppK7969O+UD5sCBA/z2t7/l3HPPJSMjg8mTJ5Oenq7q+Q4ws2GE17FbDvRrk5yUEG56gnCS03amyZ1eWcwkMomJiQSDwXZ9Zvbu3Zvrr7+ejIwM5s2b12nLvjjnKCws5KmnnsLn85Gamkp2djYLFy5kypQpTJkyhYyMDPbs2cPatWt56623IlJr2ZOpRkbiSnl5OT/72c9ISkpSv4goy8vLY+HChWRnZ1NVVUVzc3NrB+y6urpO/ZW0bt06iouLycjIoF+/fgwePFiJTDuZWRrwInCPc66ypc8ZhFdpN7MOfSuY2V3AXZGNsn2qq6tZuHDhcd9rZsZZZ53Fvffey/79+/m3f/s3KisrOzWukpKSow6bfuWVV3jttdcwM0KhUGvcKSkpTJ48mfXr11NWVtapsXVHSmQk7tTW1qpJKQZUVlby4osv0r9/fxISEti3bx+lpaWEQiGampo6tamnsrKSrVu3kpubS3JyMldeeSV5eXkaAXICZpZAOIl5zjn3kldc2tJkZGYDgJahO8XAkDYPH+yVHcI5NweY4x2/S79R2jv0tq6ujvnz57N27dpOT2KOx8wYMGAANTU17N+/n2AwyA033MANN9zA4MGD+epXv6pE5iQokRGRk+Kco6SkhNLSUnw+Hz6fj6ampi6pJm9sbOSJJ57g3XffpU+fPgwcOJBBgwap8/dxeKOQngDynHO/aLNpAXAH8KB3/Wqb8m+a2TzCnXwrYql/THs558jPzyc/Pz/aoeCc47Of/Sz79+9n7ty5DBw4kMGDB/PWW2+xcOHCmIgxHimREZGT1lI13tVt/M45lixZwtKlS/H5fPj9fnX2PbGLgc8B68xsrVf2A8IJzHwzuxPYDtzsbXud8NDrfMLDr7/YpdF2Qy0jmUaMGEFRURELFy7kv/7rv6IdVlzThHgiErdaPsBamrLk+Jxz7wN2jM0zjrK/A77RqUF1gZSUFLKzsykqKjrxzp3soosuYsKECSxatIg1a9ZoYEeEKJEREZFuq66uLib6Tp1++uk88MADbNu2jR/96Efs27cv2iF1G0pkRESk2wqFQhFbeqC9gsEgWVlZVFdXk52dzaxZs7jzzjsZOnQoX/va17RGWIRpHhkREZEIys3N5X//939JSkqib9++ZGVlEQqFWLFiBQsXLlSTUgRFuo+MmSUB7wKJhPOUF5xzPz7W/kpkRESk29m+fTv33HMPkyZNYtq0aeTn57NixQrWrFnTpYucmlnrnDXdWYQTw3pgunPuoDddwftm9oZzbtnRdlYiIyIi3U5tbS1r165l7dq1PPvss50+QeTR+P1+rrnmGs477zyWL1/OO++8ExN9hTpDJBMZr5P7Qe9ugnc55gmUyIjIcZmZquElrtXU1ETlvGPHjuXRRx9l0KBB5OXl8ZnPfKbbzlMT6c8IM/MDq4AzgN8455Yfa18lMiJyTMnJyZhZ1L4IRDpDTk4OiYmJFBcfMUlyRA0dOpTS0lIWL17MH//4RwoLCzv1fNHUwUQmx8xWtrk/x5uduu3xmoHxZpYBvGxmY51z6492MCUyUWJm+Hw+LVQmMa2uro626wCJdAdTpkzhtttu45577unUZOYvf/kLixcvpq6ujoaGhk47T7SdRGffvc65ie089gEzWwTMBJTIxAoz45xzzuHyyy9n3bp17N27l927d1NZWUl9fb0mFpOYEe0ZO0U6w4YNG8jKymLIkCGdmsg0NzdHdV2prhThUUt9gEYviUkGrgAeOtb+SmSiwMwYNWoUX//61/H5fBw8eJCioiJ2797NmjVrePvtt/nkk0+6fS93EZFo2LJlC3feeSe7du3q8GMTExO7bD2zeBLhHzwDgLlePxkfMN859+dj7axEJgpCoRDLli1jy5YtXHTRReTk5DBs2DCcc1x33XXcdtttfO9732PJkiVKZkREIsw5d1L9VbKyspg9ezbbtm1j8eLFEY8rnkXyu8o59zFwbnv390XszNIhO3fu5Le//S0lJSWtZWZGUlISY8eO5Sc/+QmnnXZaFCMUEek5+vbtS2Zm5nH3qaio4L333mPTpk1dFFV8aGmCbu8l0pTIRElzczPvvPMO77///hHbzIzRo0fTv3//KEQmItLzlJeXn7A/S3NzM/n5+Yf8AJUwJTI91MGDB1myZAmNjY1HbCsoKOjWQ/Uk9mRkZJCdnY3Pp48F6XkmTJhAampqtMOIW0pkerD333+fNWvWHNJxLBQKsXjxYsrKyqIYmfQkwWCQK6+8kmeeeYY77riD5OTkaIck0qU+/vhjqqurox1G3FIi04Pl5+fzwAMPsGzZMg4ePEhdXR2ffPIJr732mnrFS5cJhUJUVVVx+umnc80119CvX79ohyTdhJkxcODAmJ+PqKamRp+5pyCaiYxGLUVZU1MT7733HsXFxZx11lnk5OTw97//nW3btkU7NOlBmpqaKC8vZ//+/ezevVsz+UrEOOcoKSnRfETdWLTnm1IiEwNCoRD5+fls3boViPyaFSIn0tLBvKmpicbGxpj/9SzxRdNIdH9xkch4E9OsBIqdc9ea2XBgHpBNeGGnzznnGswsEXgamADsAz7rnCuMeOTdkBIYiRbnHC+88AJvvPEGNTU1PWY2UhGJjGgmqx3pI/NtIK/N/YeAXzrnzgDKgTu98juBcq/8lxxnWmGRU2VmSWa2wsw+MrMNZvZvXvlwM1tuZvlm9kczC3rlid79fG/7sKg+gRhSVVVFSUmJkhgR6bCY7+xrZoOBa4DHvfsGTAde8HaZC3zauz3bu4+3fYapnlo6Tz0w3Tk3DhgPzDSzC1CiLSJtpKSkkJSUFO0wuqV4mRDvV8D3gJa6o2zggHOuZXXDncAg7/YgoAjA217h7S8ScS7soHc3wbs4lGiLxIxY+BfLzMzk/vvvZ9iwYTERT3cT04mMmV0L7HHOrYrkic3sLjNbaWYrI3lc6XnMzG9ma4E9wFvAVpRoi8SMYDAY9eShtraW66+/ngULFjBmzJioxtIdxfrw64uB68zsaiAJ6A08AmSYWcD7MhgMtKyFXgwMAXaaWQBIJ9zp9xDOuTnAHAAzUy9XOWnOuWZgvJllAC8Do071mGZ2F3DXqR5HRCApKYlQKHTUWcy7SlpaGr179yYhIQG/398l50xOTsY5R11dXZecL5qiOVjlhDUyzrn7nXODnXPDgFuAd5xz/wQsAm70drsDeNW7vcC7j7f9HafhONIFnHMHCL8vL8RLtL1NR0u0OVGi7Zyb6Jyb2Nlxi3R3wWCQrKysqMYwc+ZM0tPTSUtL44EHHuCqq67q9CUJevfuzYwZM3pE35yYblo6jvuAfzGzfMJV80945U8A2V75vwDfP7UQRY7NzPp4NTGYWTJwBeHRdUq0T1JycjKTJ0/m+uuv57zzziM7O5vU1FQSEhKi3jwg8am6ujrqi+C+/PLLvPzyyzQ2NjJjxgyee+45Hn74YdLS0jrtnKWlpSxZsqTbL/kR7c6+HZoQzzm3GFjs3S4AJh1lnzrgpgjEJtIeA4C53jxHPmC+c+7PZrYRmGdmPwXWcGii/YyXaO8nXMsobaSnp/Ov//qvnHvuuezZs4f169ezcuVKVq1axY4dO9i/fz9NTU0nPpCIp6amhsbGRlJSUqI2a3RZWRl33303f//73/nhD39I//79+cxnPsObb77Jq6++2mnzoJSXlxMIdP+5Z6M5j0z3f3WlW3POfQyce5RyJdonqaysjL/85S+MHDmSoUOHMnjwYM4//3zWrVvHiy++yIoVKygpKdFsrdIh27dvp2/fvhQWFkYthurqap5++mmqq6v57W9/S3JyMv/93/9NVVUVb7/9dqedtyck/jHdR0ZEepbm5maef/55Hn74YSoqKggEAvTt25eJEydy9dVXM3LkSDIyMqIdpsSZ6upqkpKSSExMjGocLWs/tXTA7du3L9/61rcIBoNRjSvexU3Tkoj0DHV1dcybN4+qqipuv/12+vbtS319PQUFBTQ3N9PQ0BDtECUOFRYWkpGRQWlpaVTjCIVCh/T3SktLIxAI6H19kjorQWkvJTIiclR1dXW89NJLLF68mJSUFAAqKipoaGiIqQ98MyMpKYn6+vq4ae7qqWvX1dXVEQgESEhI6JKh2MFg8Kjv1Q8//JB//dd/5VOf+hRNTU3Mnz+/RwyR7kxKZEQkJjnn2LdvH/v2HTFCPWZkZWVhZtTW1kY7lI5oWbuut3e/ZUmNeWb2v4SX0niMNktqmNkt3n6fjUbAkVJdXU1mZib79+/v1POYGSkpKTQ1NR2R4DY2NjJv3jz+9Kc/AeHmVDk16iMjIofw+/0kJSURCATw+fRveizJyclceeWVjBs3Lm7m6ujpa9c557okienfvz9mdtw+Oc3NzUpiIkR9ZESkVa9evRgzZgyJiYlUVlZSU1PDnj17qK+vxzlHc3Nz6y/Mnv4hnJiYyBlnnEF2djZbt26lqKgoHl6TXxFeu66Xd7/da9eZWcuSGnu7LNo4lJaWxuc//3leeeUVNm/eHO1wegQ1LYkIZka/fv24/vrrmTFjBg0NDZSUlLBx40bWrVvHwYMHW/dtamoiEAhQUVFBcXFxVD9EoqmhoYH9+/czadIkCgsLqays7PRf+6ei7dp1ZjYtgsfVkhptnHnmmezcuZOCgoJoh9IjOOc0j4xIT2dmnHnmmcyePZspU6bQr18/AAYOHMjQoUMZM2YMu3btap1cKysri8zMTBYuXEhxcfEJjt59NTQ0sGzZMs477zxuv/12qqqqWLFiRSz3l9HadZ3M5/Nx8cUX884770R1baeeRn1kRHq4rKwspk6dypgxY/D7/dTX1wOQkpLCkCFDuOiii5g1axYXXXQR48ePZ8yYMaSnp7N9+/YeWxsD4ZqpLVu28PLLL9OnTx9++tOfcs0117SOsoo1Wruu85kZGzdupKioKNqh9CjqIyPSw/n9flavXs3u3bsZPnw4o0ePJjc3t3VEjt/vJy0tjdNPP701yfnrX/8a1VlSY0VVVRXvv/8+/fr14yc/+QmPPvooI0eO5JFHHjmkOS7G3YeW1IiI5ubmTp2lV45OfWREeoisrCwSExMpKSk55B9/79691NbWUlxczK5duygrK6OsrKw1menduzcJCQkkJyeTmJjIpk2bePPNNzX3BeEP0MrKShYtWsSUKVO44YYbOOecc0hOTo7pREZr18UeMyMhISGm5kmKB5oQT6QH6dOnDxkZGezZs+eQ0TWhUIiDBw9SW1tLTU0NFRUV7N69m3Xr1pGTk8N5553HgAEDyMjIoK6ujvnz5/PJJ59E8ZmERwyZGXV1dZhZVD/IQqEQu3fv5k9/+hNbt25l4cKFVFRURC0eiU+f/exnOeOMM/jZz34WD6PfYooSGZEeIDU1lWnTprFhw4ajfkg652hqamodcl1WVkZCQgKpqans3r2bMWPGkJOTw7p16/jggw+ithCdz+dj+PDhzJw5k9TUVObPn0/v3r3ZtWsXe/dGb1RwbW0tixcv5r333qO6ulpfRNIhCQkJXHnllZSXl0c7lLikREakB8jOzubyyy9nz549+Hy+4w5XbGpqoqqqCp/PR0VFBeXl5Xz00UcMGjSIzZs3U1lZ2YWR/0NiYiJTp07l7rvvZuLEiQDMmjWLPXv2sHjxYh5//PGojhSprq6O2rklviUnJzNw4EA++OADJcEnIZKJjJkNIbw0Rz/AAXOcc48ca38lMiJdpL6+nj179hAMBtv1T98y+R2EO7RWVVVRWlra2tm3q6WkpHDjjTfyjW98g+HDh7fOOHz22WcD4eadZ599VkNeJS61rMy9Y8eOaIcSlyJcI9ME3OucW21mvYBVZvaWc27j0XZWIiPSRSoqKti2bdspdYyL1vwoWVlZ3HjjjfzzP/8zQ4cOPWLZhJY+MvolK/HK7/fj8/niZqmLWBLpCfGcc7uB3d7tKjPLIzzLtRIZkWhyzrWOijhR01Ks8Pv9DB8+nFmzZnHzzTdz2mmn4ff7D9mnZekfJTISz4LBYMzPDB3LOvjjLMfMVra5P8eb1PEIZjYMOBdYfqyDKZER6SI+n4+0tDTGjx/PCy+8ELUmovYwM9LS0rjwwgv5yle+wvjx4+nVq9dRa2JaxPBsuiInVFJSwpe//OWodliPZx1MZPY65yaeaCczSwNeBO5xzh2zY6ASGZEuUl9fz5YtW5g8eTLBYDAmE5mEhASysrI455xzmDlzJpdccglDhw4lEDj0o+LwBZidcxQVFal/jMSt+vp6SkpKoh1G3Ir0qCUzSyCcxDznnHvpePsqkRHpIqFQiJUrVzJ58uQjEoNYEQwGufrqq7n77rsZMGAAgUDgkKTl8ASmhXOO7du3x0VzmYhEVqQnxLPwB80TQJ5z7hcn2l9rLYl0obKyMnw+X8yuBVRdXc3bb7/NokWLCIVCmNkhl2Opq6tj+/btXRipiMSSCK+1dDHwOWC6ma31Llcfa2clMiJdqK6ujubmZs4555zjJgbRVFRUxB/+8Ad27Nhx1Bidc60T9tXV1eGco7GxUdO6i/RgkUxknHPvO+fMOXeOc268d3n9WPvHZv22SDdVXV3Nyy+/zMUXX8yiRYtidq2ksrIySktLOfPMM1vL6uvrOXDgAHl5eXz44YcUFRVx2mmncdFFF5GbmxuTfX5EpGtoZl+RHmTNmjVcfvnlpKSkxGwik5CQQEFBAU1NTYRCIXbs2MGOHTvYtm0bmzdvZufOndTX1xMMBnn11Ve5+eabo772k4hER6TnkekoJTIiXay2tpbExEQyMzNjds6K7du388ADDxAKhXDO0dDQ0JrUwD9+fdXW1pKXl8fDDz8c0ytNi0jnUo2MSA/S2NjIhg0bGDBgAFu3bu3y8/t8vta+L8eawK6pqYkDBw6063jOOaqqqiIVnojEISUyIj1IKBSipKSEXr16dcn5UlJSyM3NJSMjg9NPP5309HT8fj+VlZUUFBSwcuVKJSIickqUyIj0MOXl5ZxxxhmtaxR1pvT0dO6//35yc3NJTEw8ZEmBsrIy5syZw2uvvaZRRyJyUiI9j0xHafi1SBRUVVWRkJDQJUOwKysrqaysJDk5uXVhPJ/Ph9/vp2/fvtx8882ce+65MTscXERiX4TnkekQJTIiUTJ8+PAumeG3traW5cuXH3VUgc/n44wzzuArX/kKEyZMOGJBSBGR9lAiI9LDVFRUkJKSQnJycqefKxQK8dZbbx1z5t1AIMD48eP57ne/yxVXXHHCmHw+HwMGDCAhIaEzwhWROKRERqSHqaiowO/3k5OT0yXnKy0t5W9/+9sxF3X0+/2MGjWK+++/n+9+97sMGDDgqPulp6cze/ZsHnjgAUaMGNGZIYtInGiZR6a9l0hTZ1+RKKivr2fXrl2MGTOmS4ZgNzU18cILLzB+/HguuOCCo+5jZmRkZHDddddRUVHBnDlzWifsa2mC+tKXvsTs2bM5ePAgPp9+B8Wog8DmaAdxDDnA3mgHcQyKDYae7AM1akmkh2loaGDjxo3k5OR0ycglCC878Nhjj5Gbm0vfvn2PuV8wGOT6669n9erVrFy5kqFDhzJ16lRuu+02Ro8eTSAQYP369RQXF3d6zHJSNjvnJkY7iKMxs5WKreNiObYWMZ/ImFkhUAU0A03OuYlmlgX8ERgGFAI3O+fKveW3HwGuBmqALzjnVkc+dJH4VlhYyNSpUwkGg122TtHHH3/MnDlz+Na3vkXv3r2PuV96ejoTJ04kFApx3333cc4555CamkooFCIvL49XXnml3RPmiUj3F/OJjOcy51zbqq3vAwudcw+a2fe9+/cBs4AR3mUy8Jh3LSJtFBUV4Zyjf//+x+yIG2mhUIgFCxYQCAT453/+Z7Kyso5oImpoaGD16tW88cYbbN++nR//+MfMmjWLmpoaysvL+fjjj9m8eXNUP7hEJLbESyJzuNnANO/2XGAx4URmNvC0Cz+rZWaWYWYDnHO7TyVQke7m4MGD5OXlcckll7Bjx44u+yCor69n/vz5bNu2jdmzZ5Obm0t6ejrJyclUVFSwYMEC/vznP1NaWopzjrVr17J+/fpO66gnETcn2gEch2I7ObEcW9QnxGtvIuOAv5mZA37nnJsD9GuTnJQA/bzbg4CiNo/d6ZUpkZFOYWZ+YCVQ7Jy71syGA/OAbGAV8DnnXIOZJQJPAxOAfcBnnXOFUQqbUCjE3/72N+69916WLVvWpesuNTc3s3z5ctavX0/v3r0JBAL4fD4CgQDbt28/YnRTU1NTl8Ump8b7fI5Jiu3kxHJsLeJhZt9LnHPnEW42+oaZTW270at96dCzMLO7zGylma3syONEjuLbQF6b+w8Bv3TOnQGUA3d65XcC5V75L739omrPnj2sXbuWG2+8sUvmlGnLOcfBgwfZtWsXO3bsoLCwkPz8/GMO0RYROZaYn0fGOVfsXe8BXgYmAaVmNgDAu97j7V4MDGnz8MFe2eHHnOOcmxjrPbEltpnZYOAa4HHvvgHTgRe8XeYCn/Zuz/bu422fYVGal79leYDx48dTX19P3759Ofvss6MRinQTZjbTzDabWb7Xb7Grzz/EzBaZ2UYz22Bm3/bKs8zsLTPb4l1neuVmZo968X5sZud1QYx+M1tjZn/27g83s+VeDH80s6BXnujdz/e2D+vkuDLM7AUz22RmeWZ2YSy9bu0RzXlkTpjImFmqmfVquQ1cCawHFgB3eLvdAbzq3V4AfN57sS8AKtQ/RjrRr4DvAS3/HdnAAedcS1tIS9MmtGn29LZXePt3GZ/PR0pKCsOGDWPChAlccsklnHHGGfh8PqZPn67ZcuWkeM2rvyFcaz4GuNXMxnRxGE3Avc65McAFhGvvx/CPgSEjgIXefTh0YMhdhAeGdLZYrb19BPirc24UMM6LMZZet+PqSG1MtGpk+gHvm9lHwArgL865vwIPAleY2Rbgcu8+wOtAAZAP/B/w9YhHLQKY2bXAHufcqk44dsSaPs2MYDBIVlYWgwcPZtSoUUyaNImxY8eSnZ1NSkoKdXV15Obm0qtXr0iELz3PJCDfOVfgnGsg3EdsdlcG4Jzb3TLVhnOuivCX8SAOrQk9vIb0aRe2DMhoqeXvDLFae2tm6cBU4AkA51yDc+4AMfK6tVc0E5kTdvZ1zhUQzhAPL98HzDhKuQO+EZHoRI7vYuA6M7saSAJ6E/5lk2FmAa/WpW3TZkuz504zCwDphDv9HsHrXDcHwOvkflKSk5PJzs4mJyeH3r17079/fwYMGEBGRkbrgpHOOQ4cOEB9fT19+vRh//79J3s66bmONsgiatNeeE0x5wLLiZ2BIb8iXHvb8muh3bW3ZtZSe9sZs+sOB8qA35vZOMIDFL5N7Lxu7RIPo5YkSnw+n4a8HoNz7n7gfgAzmwZ81zn3T2b2J+BGwr9KD2/2vANY6m1/x3Xif19ycjKnn346I0aMoF+/fgQCATIzMwkGgy3xU1tby4EDB/jwww/JyMhgzJgxbN4cq7PLi5yYmaUBLwL3OOcq21ZkOOfcqfwwOIWYWmtvvc+KWBIAzgPuds4tN7NH+EczEhC9160jlMjIUZkZgUCAhoaGaIcSb+4D5pnZT4E1eFW23vUzZpYP7Adu6awAAoEAZ555Jpdccklr8tL2A725uZm9e/eSl5dHfn4+xcXFDB48mMsvv1zJq5yMdg2y6GxmlkA4iXnOOfeSV1zaMpfYyQwMiZBOq72NgJ3ATufccu/+C4QTmVh43dpNiYwcVSAQIDExUYlMOzjnFhOelLGlOXTSUfapA27qzDgCgQDZ2dkMGTKEKVOmkJWV1fb81NTUUFxczK5du8jLy6OsrKx1uPPBgwfJzMwkISGhy5YskG7jQ2CEN4dSMeEk/bauDMDrQ/IEkOec+0WbTS01oQ9yZA3pN81sHuFmsE4bGBLLtbfOuRIzKzKzkc65zYS7bGz0LlF93dqrs/q+tJcSmRgWDAZJTEykqqoq2qHICfh8PhITE8nNzeXcc89l+PDhBINBnHM0NjayZ88etm/fTmFhIXv27KGysvKISeaqqqqoq6sjKyuL3bs10E/az+vH8U3gTcAPPOmc29DFYVwMfA5YZ2ZrvbIfEP4inm9mdwLbgZu9ba8TXpMvn/C6fF/s0mjDol5767kbeM4b/l1A+LXwEbuv2xGimchYNE/eGkSMt/1Fi5nh8/lobm6OdiixZFVXzz10ovdnamoqZ599NsOHD2fIkCGkpqbS1NTE7t27KSkpab3et28f9fX1x/yHNzNuuOEGnHO8+uqrmk23m3DORWWuIpGukpqa6saMaf9o/5UrV0b0c1w1MjHMOae+EnGgT58+TJ06ldTUVCorK9m0aRMFBQXk5+dTVVVFY2Nju36tOOfYsmUL3/rWt6isrOTdd99VE5OIxIVoflcpkYlxsVBjJsdXWVlJYWEhdXV1bN68meLiYmpqak7qH7uwsJADBw7w5S9/mczMTN5++23Ky8v1PhCRmBXtPjJqWpJ4E3NNSwAJCQmt02+fyv+Uz+fjzDPP5JprrmHUqFGUlJQwd+5c8vPzT/qYEl1qWpLuLiUlxY0cObLd+69du1ZNSyKxJlILLYZCITZv3szWrVvp3bs3F198Md/5znf4zW9+w8aNGyNyDhGRSItkpYiZPQm0zP0z9kT7t3f1axHpIi0jnfbt28ebb77Jxo0b+eIXv0i/fv1O/GARkSiI8BIFTwEz23tuJTIiMay+vp758+fT0NDAzTffTGJiYrRDEhE5QiQTGefcu4SHvbeLEhmRGFdWVsYTTzzB8OHDufHGG/H7/dEOSUSkVUeSmM7ol6tERiQOFBQUMGfOHC6++GJuueUW1cyISEzpYCKTY2Yr21zuOpVzq7OvSJzYvHkzP//5z/na175GMBhk/vz5VFdXRzssEZGOTjexN5KjllQjIxInnHMUFhby8MMPk5ubyz333MOAAQOiHZaIiJqWRKT99uzZw+9+9zv69u3L/fffz8SJEwkEVLkqItER6T4yZvY84QU7R5rZTm+9qWNSIiMSh4qLi3n44Yepqanhu9/9LtOmTSMpKSnaYYlIDxXhUUu3OucGOOcSnHODnXNPHG9/JTIiccg5x44dO3j66aepra3l29/+NjfeeCPp6enRDk1EeiA1LYnIScnLy+ORRx6hvLycz33uc9x777186lOfYsCAAfh8+vcWka4RzURGay1JvInJtZaiyczIzc3lzjvvZNy4cSQkJLB161Zef/11Vq1aRUlJiVZRjyKttSTdXVJSkhs8eHC799+6dWtEP8eVyEi8USJzDL1792bAgAFMmjSJmTNnMmDAALZs2cJLL73EqlWrqKioiNiaUNJ+SmSku0tMTOxQIlNQUKBERno0JTInkJCQwMCBA5k4cSI33ngjWVlZfPLJJyxZsoTFixdTUlLSKdW7cnRKZKS7S0xMdAMHDmz3/oWFhUpkpEdTItNOfr+f4cOH86lPfYopU6aQkZHBxx9/zKuvvsqSJUtoaGhoTWjMDOdc67VEjhIZ6e4SExNdR+a02r59uxIZ6dGUyHSQ3+9nxIgRzJgxg4EDBzJkyBAKCgpYvnw5NTU1NDc3k52dTVpaGnv37uXvf/87dXV10Q6721AiI91dYmKi69+/f7v337FjR0Q/xzWLlkg319zczKZNmygoKCAnJ4eLL76YK6+8kvvvv5+Kigp27NjBjh072L17N6FQiObm5miHLCJxpLNGI7WXEhmRHqKhoYFdu3bx2muvsWHDBk477TR27NjBrl27qKmpobGxUc1KInJSlMiISJepq6tj48aNbNy4MdqhiEg3oURGRERE4pYSGREREYlbSmREREQkLjnnojp7uBIZEREROSWqkREREZG4pURGRERE4pYSGREREYlLmhBPRERE4lo0Exlfe3Yyswwze8HMNplZnpldaGZZZvaWmW3xrjO9fc3MHjWzfDP72MzO69ynICIiItHUUivTnkuktSuRAR4B/uqcGwWMA/KA7wMLnXMjgIXefYBZwAjvchfwWEQjFhERkZgS04mMmaUDU4EnvGAbnHMHgNnAXG+3ucCnvduzgadd2DIgw8zav763iIiIxI2WeWTae4m09tTIDAfKgN+b2Roze9zMUoF+zrnd3j4lQD/v9iCgqM3jd3plIiIi0g3FdI0M4Q7B5wGPOefOBar5RzNSyxNwQIeiM7O7zGylma3syONEDmdmhWa2zszWtryf1IdLRKTrxHoisxPY6Zxb7t1/gXBiU9rSZORd7/G2FwND2jx+sFd2COfcHOfcROfcxJMNXqSNy5xz49u8n9SHS0Ski8R0IuOcKwGKzGykVzQD2AgsAO7wyu4AXvVuLwA+7/3yvQCoaNMEJdJV1IdLRKSLRDORae88MncDz5lZECgAvkg4CZpvZncC24GbvX1fB64G8oEab1+RzuSAv5mZA37nnJtDx/twKdkWETkJcTEhnnNuLXC0JqAZR9nXAd84tbBEOuQS51yxmfUF3jKzTW03Ouecl+S0m5ndRbjpSURETiDmExmRWOacK/au95jZy8AkvD5czrndJ9uHC5gD0NEkSESkp4n5mX1FYpWZpZpZr5bbwJXAetSHS0Sky8RDHxmRWNUPeNnMIPx+/oNz7q9m9iHqwyUi0ulaJsSLFotmdVBrEKq6l/Zb1dVD9vX+lFPhnLNoxyDSmczM+f3+du/f3Nx83M9xM5tJeGkkP/C4c+7B4x1PNTIiIiJySiJVKWJmfuA3wBWER5V+aGYLnHMbj/UY9ZERERGRUxLBPjKTgHznXIFzrgGYR3j+r2NSjYyIiIickgh2UznaXF+Tj/cAJTIiIiJyKt4Ecjqwf9Jh6yzO8aa8OClKZEREROSkOedmRvBw7Zrrqy31kREREZFY8SEwwsyGe8si3UJ4/q9jUo2MiIiIxATnXJOZfZNwc5UfeNI5t+F4j9E8MhJvNI+MxBXNIyPSudS0JCIiInFLiYyIiIjELSUyIiIiErfU2VfkxA4Cm6MdxEnIAfZGO4gOiseY4dhxD+3qQER6GiUyIie2uas7GEeCma2Mt7jjMWaI37hFugM1LYmIiEjcUiIjIiIicUuJjMiJnfQaIFEWj3HHY8wQv3GLxD1NiCfxpssnxBMRkdilGhkRERGJW0pkRI7BzGaa2WYzyzez70c7nrbM7Ekz22Nm69uUZZnZW2a2xbvO9MrNzB71nsfHZnZeFOMeYmaLzGyjmW0ws2/HeuxmlmRmK8zsIy/mf/PKh5vZci+2P3oL3GFmid79fG/7sK6OWaQnUSIjchRm5gd+A8wCxgC3mtmY6EZ1iKeAmYeVfR9Y6JwbASz07kP4OYzwLncBj3VRjEfTBNzrnBsDXAB8w3tdYzn2emC6c24cMB6YaWYXAA8Bv3TOnQGUA3d6+98JlHvlv/T2E5FOokRG5OgmAfnOuQLnXAMwD5gd5ZhaOefeBfYfVjwbmOvdngt8uk350y5sGZBhZgO6JNDDOOd2O+dWe7ergDxgEDEcu3fug97dBO/igOnAC1754TG3PJcXgBlmpoUjRTqJEhmRoxsEFLW5v9Mri2X9nHO7vdslQD/vdkw+F6/J5VxgOTEeu5n5zWwtsAd4C9gKHHDONR0lrtaYve0VQHaXBizSgyiREemGXHg4YsyOBjSzNOBF4B7nXGXbbbEYu3Ou2Tk3HhhMuLZuVHQjEpEWSmREjq4YGNLm/mCvLJaVtjS7eNd7vPKYei5mlkA4iXnOOfeSVxwXsTvnDgCLgAsJN3O1LPPSNq7WmL3t6cC+ro1UpOdQIiNydB8CI7yRKUHgFmBBlGM6kQXAHd7tO4BX25R/3hsBdAFQ0aYZp0t5fUWeAPKcc79osylmYzezPmaW4d1OBq4g3LdnEXDjMWJueS43Au+4WJiwS6Sb0oR4Em+6bEI8M7sa+BXgB550zv1HV5y3PczseWAa4VWXS4EfA68A84HTgO3Azc65/V7y8D+ERznVAF90zq2MQtiY2SXAe8A6IOQV/4BwP5mYjN3MziHceddP+MfffOfcA2aWS7gTeBawBrjdOVdvZknAM4T7/+wHbnHOFXRlzCI9iRIZiTea2VdERFqpaUlERETilhIZERERiVtKZERERCRuKZERERGRuHXCRMbMRprZ2jaXSjO7J5YXeRMREZGe4YSJjHNus3NuvDer5QTCQyBfJrYXeRMREZEeoKNNSzOArc657cTwIm8iIiLSM3Q0kbkFeN67HdOLvImIiEj31+5Expum/TrgT4dvO5lF3szsLjNbaWZRmWFURERE4l9HamRmAaudc6Xe/VNa5M05N8c5N1GztIqIiMjJ6kgicyv/aFaCGF7kTURERHqGdq21ZGapwA4g1zlX4ZVlE6FF3rTWknSA1loSEZFWWjRS4o0SGRERaaWZfUVERCRuKZERERGRuKVERkREROKWEhkRERGJW0pkREREJG4pkREREZG4pURGRERE4pYSGREREYlbSmREREQkbimRERERkbilREZERETilhIZERERiVuBaAfgOQhsjnYQHZAD7I12EB0UbzEfK96hXR2IiIjErlhJZDbH04rGZrYynuKF+Is53uIVEZHoUNOSiIiIxC0lMiIiIhK3YiWRmRPtADoo3uKF+Is53uIVEZEoMOdctGMQEREROSmxUiMjIiIi0mFRT2TMbKaZbTazfDP7frTjATCzJ81sj5mtb1OWZWZvmdkW7zrTKzcze9SL/2MzOy8K8Q4xs0VmttHMNpjZt2M5ZjNLMrMVZvaRF++/eeXDzWy5F9cfzSzolSd69/O97cO6Ml4REYldUU1kzMwP/AaYBYwBbjWzMdGMyfMUMPOwsu8DC51zI4CF3n0Ixz7Cu9wFPNZFMbbVBNzrnBsDXAB8w3sdYzXmemC6c24cMB6YaWYXAA8Bv3TOnQGUA3d6+98JlHvlv/T2ExERiXqNzCQg3zlX4JxrAOYBs6McE865d4H9hxXPBuZ6t+cCn25T/rQLWwZkmNmALgnU45zb7Zxb7d2uAvKAQbEas3feg97dBO/igOnAC8eIt+V5vADMMDPrmmhFRCSWRTuRGQQUtbm/0yuLRf2cc7u92yVAP+92TD0Hr9nlXGA5MRyzmfnNbC2wB3gL2AoccM41HSWm1ni97RVAdlfGKyIisSnaiUxccuGhXjE33MvM0oAXgXucc5Vtt8VazM65ZufceGAw4Zq5UdGNSERE4lG0E5liYEib+4O9slhU2tL84l3v8cpj4jmYWQLhJOY559xLXnFMxwzgnDsALAIuJNzE1bJsRtuYWuP1tqcD+7o2UhERiUXRTmQ+BEZ4o1WCwC3AgijHdCwLgDu823cAr7Yp/7w3EugCoKJNc06X8PqLPAHkOed+0WZTTMZsZn3MLMO7nQxcQbhfzyLgxmPE2/I8bgTecZoASUREiIEJ8czsauBXgB940jn3H1ENCDCz54FphFdgLgV+DLwCzAdOA7YDNzvn9ntJxP8QHuVUA3zRObeyi+O9BHgPWAeEvOIfEO4nE3Mxm9k5hDvv+gkn0/Odcw+YWS7hDt9ZwBrgdudcvZklAc8Q7vuzH7jFOVfQVfGKiEjsinoiIyIiInKyot20JCIiInLSlMiIiIhI3FIiIyIiInFLiYyIiIjELSUyIiIiEreUyIiIiEjcUiIjIiIicUuJjIiIiMSt/x9myB/yljwJwQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "###############################################\n", + "# apply transform\n", + "ccf_anno_to_brain_deformed = ants.apply_transforms(\n", + " fixed = brain,\n", + " moving = ccf_anno_to_template_deformed,\n", + " transformlist=template_to_brain_transform_path,\n", + " whichtoinvert = [True, True, False]\n", + " )\n", + "\n", + "print(\"\")\n", + "dataset_id = \"\"\n", + "plot_antsimgs(ccf_anno_to_brain_deformed, \n", + " f\"{outprefix}/ccf_anno_to_brain_deformed\",\n", + " title=f\"ccf_anno_to_brain_deformed\", \n", + " vmin=0, vmax=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "835d8c68", + "metadata": {}, + "outputs": [], + "source": [ + "ants.image_write(ccf_anno_to_brain_deformed, \n", + " f\"{outprefix}/ccf_anno_to_brain_deformed.nii.gz\") \n" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "78ab809a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "###############################################\n", + "# apply transform\n", + "template_to_brain_deformed = ants.apply_transforms(\n", + " fixed = brain,\n", + " moving = template,\n", + " transformlist=template_to_brain_transform_path,\n", + " whichtoinvert = [True, True, False]\n", + " )\n", + "\n", + "print(\"\")\n", + "dataset_id = \"\"\n", + "plot_antsimgs(template_to_brain_deformed, \n", + " f\"{outprefix}/template_to_brain_deformed\",\n", + " title=f\"template_to_brain_deformed\", \n", + " vmin=0, vmax=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "78e92e6e", + "metadata": {}, + "outputs": [], + "source": [ + "ants.image_write(template_to_brain_deformed, \n", + " f\"{outprefix}/template_to_brain_deformed.nii.gz\") \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0f487f2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "04af1b7c", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_overlay(ants_img1, ants_img2, title=\"\", loc=0,):\n", + "\n", + " assert ants_img1.view().shape == ants_img2.view().shape, \"Input images should have same dimension\"\n", + " \n", + " print(ants_img1.view().shape)\n", + " print(ants_img2.view().shape)\n", + " \n", + " half_size = np.array(ants_img1.shape) // 2\n", + " \n", + " fig, ax = plt.subplots(1, 3, figsize=(10, 6))\n", + " \n", + " img1 = ants_img1.view()[half_size[0], :, :]\n", + " img2 = ants_img2.view()[half_size[0], :, :]\n", + " overlay = np.stack( (img1, img2, img1), axis=2 )\n", + " ax[0].imshow(overlay)\n", + "\n", + " img1 = ants_img1.view()[:, half_size[1], :]\n", + " img2 = ants_img2.view()[:, half_size[1], :]\n", + " overlay = np.stack( (img1, img2, img1), axis=2 )\n", + " ax[1].imshow(overlay)\n", + "\n", + " img1 = ants_img1.view()[:, :, half_size[2]]\n", + " img2 = ants_img2.view()[:, :, half_size[2]]\n", + " overlay = np.stack( (img1, img2, img1), axis=2 )\n", + " ax[2].imshow(overlay)\n", + " \n", + " fig.show() " + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "5ec64f2e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(576, 648, 440)\n", + "(576, 648, 440)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAEUCAYAAADp3XjlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9eZBl2XHeCf7OW2NfMiNyXysrq7L2KlQBhY0EAZAESIACKUEAwRFFQFDDuiVKHNO0qTkym5bGZjRGtllLph6pqYEoSOCIEkhx2CQlUgJJEFxEEiC2AlBAFaoKWVtWLpWRmbGv7707f/j9wv2+jNwjMiMzroc9i4j37rurn+Ofu3/uJ2VZRimllFJKKaWUUkopNy6VW30CpZRSSimllFJKKXeKlMCqlFJKKaWUUkopZZ2kBFallFJKKaWUUkop6yQlsCqllFJKKaWUUkpZJymBVSmllFJKKaWUUso6SQmsSimllFJKKaWUUtZJNgRYpZTem1L6TkrphZTSz27EMUoppZRSSimllFI2m6T17mOVUqoCzwE/AJwAvgR8JMuyb6/rgUoppZRSSimllFI2mWxExOpNwAtZlh3PsmwZ+AzwgQ04TimllFJKKaWUUsqmktoG7HMv8Gr4/wTwZPdGKaVPAJ/I/318A86jlFKuW7IsS7f6HEoppZRSSrn9ZCOA1VVJlmWfBD4JkFIq19UppZRSSimllFJue9mIVOBrwP7w/778vVJKKaWUUkoppZQ7WjYCWH0JOJpSOpxSagA/DvzWBhynlFJKKaWUUkopZVPJuqcCsyxrpZR+GvgsUAU+lWXZt9b7OKWUUkoppZRSSimbTda93cJ1nUTJsSplk0lJXi+llFJKKeV6pOy8XkoppZRSSimllLJOUgKrUkoppZRSSimllHWSElhtFSkTW6WUUkoppZSy4XLL+liVssGS1ngBrNyyMyqllFJKKaWUO17KiNWdKgl7ulUcVFUon3gppZRSSimlbKCUZvZOlQyPVHWAdv67TAneEkkpvTel9J2U0gsppZ+91edTSimllFLKxkjZbuFOlhihEtDK8lcFA1qdW3Nqm13Ws91CSqkKPAf8ALZ25peAj2RZ9u31OkYppZRSSimbQ8qI1Z0sAk4p/C8IK6BVasDNkDcBL2RZdjzLsmXgM8AHbvE5lVJKKaWUsgFSktfvZEn4E67gQKqTv79CEXiVccONkr3Aq+H/E8CT3RullD4BfCL/9/GbcF6llHLVUjbNLaWUq5MSWN1GkkhsYxs99JCR0aLFIotkl0JENcgGM5ZWllhpr5h5bwJLwCk8giXQFdOCShmWctMky7JPAp+EMj1eSimllHK7SgmsbgOpU6eHHr6H7+Hv8Hd4iIeoUaNDhxYt31AcKrAnW4Pl8WWeWXiGV6ZfodXXgiFgAJgAlmAiTTDBBNNMc5rTzDLLIoucS+e4kC7Q2+llhRUqVFbBnI6rY2f5TymXlNeA/eH/ffl7pZRSSiml3GFSktc3uQwxxIf4EH+Tv8lBDrKDHVQuRYyqYsCqigGrPuBRYAfwu1ikagA4BHwbsmW77Vl/BrOQtTKyLGMlW+FUOsUJTrDUWWKeeXaxiyWWmGSSu7iLZZb5Ml/mBCeoU+fX+XVe4AVWWOEwh3mRF2nRYoghFllkiSU6txFTfp3J6zWMvP5uDFB9CfiJyy1OXo6JUjablKnAUkq5OtmSEasRRgCYZPKWnseVZAc7+Dgf50f4Ed7IGy8NqCI5PWHAqgkcAUaxVN8gBqwWgReAXki1BG1IfQlmWeVf1bIad3EXh7PDq5GoRFqNWK2wQh993Mu9XOACFSrsYx+v8Apt2pziFA0a9NPPKKM8yqN8m2/zFE+xxBIAU0yxzDIVKtSoscgiAFWqrORdTIcZZpZZ2rTX+9beVMmyrJVS+mngs9jT+dTlQFUppZRSSim3r2zJiFUvvQAssHAzDwsYQAEumTpLJKpUuYd7eBfv4h28g+/j+xhllCrVtXcaWypkQB1oADuBu7Ao1dex9J8iWvfm27Ty13GgJ98mdGfPMgNTdeoAq2nAOvXVa+nkPxe4wNf4Goc4xBf4AtvYxmM8Ri+9TOApx0km+Qv+gimmeIAHVvd9kpNMMsmf8qc8zdPsZjdNmrzMyzc92nWrvfMyYlXKZpNbPSZKKeV2kS0JrG6mVKgUQMEOdtCixXnOF7ar5j9P8AS72c27eTc/xo/RpMkgg9SuJbjYwyrHiv0Yr+rbOFl9HzACTANT+XtLGECbxIFVZgBwKptajfJdTgQWZ5jhNKcZYYQOHcYZp0KFNu1VcBiBZYcOVaqc4hRf5ItMMcWX+TLb2c5n+SxTTPESL1GnzhxzNwVk3WojciePiVJuT7nVY6KUUm4XKYHVBkqDBmOMcZKTq+/10UeLFsssr743wggNGryRN/JRPsokk3w/388hDl3fgatYNKoaXi0sHdjEeFcV4JvAbgxYPY2Bq06+rUBY7H11FZKR0aHDMsv00LMa1boaWWaZOeZo0KBGjTZtnuIpZpjhF/lFHuAB/hX/qnA/N0putRG5U8dEKbev3OoxUUopt4tsSY7VpaQ7unS1Iv5RIrGXvZzgBACHOUwPPQUgsJ/9fJfv0qRJhw4rrNBPP3vZywf5IG/mzSQSo4xe/4W0MZBUwwCUUoQdYBjjWS1j5PYdWKrwJHAWA2FLGFdrMXz3GqRCZTXdei3SyH8kHTqr92OYYYYY4lN86pr3W0oppZRSSik3S0pghfOeBhhghpnL8p8A+uknkZhllp3s5B7u4Rt8g0EGadLkPu6jQYO7uZslltjGNgAOcYh7uIdneIZ7uZcppjjJSR7ncT7AB9jBDvroW5+LyjDwpPUCJReAL+af7wH6MeJ6G+NmHcV6XPUD3+Wal7zp0CHlPzcqIutnZDzJk5zhTNnWoZRSSimllE0tWxpYValSo8ZRjpKRcZ7zvIk38VbeyilOUaXKBBM0aDDOOE2aLLPMIINMMsk5zvFRPsoQQ1zgAonEfvbTpMkFLtBPP4MMMsAATZrUqJFIdOgwwQQzzHCYwwAFMvi6SNb1O8o8Fsk6iXGs5vL37sEWX3kKA1t1LC14DUV5lyTY34BcifBfSimllFJKKZtFtiyw6qef+7mfD/AB9rCHd/NuWrRo0lzlPC2xxHnO008/wwwXIigiYuu9FVZWwZHaElSprjbPjOTzNm22sY0ZZlYbfa67xGahWhcwLrrcxsDU72Ppv4NYWvAkcC7f5l7gJYzQ3uaWL9hcNiItpZRSSills8uWA1bDDJOR8ZP8JP+Af8A44xdV3ClCUqNGkyZgkZgYUeqOzCyzvBqRSqTVFgJriQDZQQ6SSMwzTzP/WVeJ4EqSdb2/iEWvFoAvAzPY0jd7MWA1m7+gBFallFJKKaWUcgXZcsDqHu7hDbyBv8/fZw97LrvtlQBSlAEGruk8EokeegDrrr7uEvFHWuMVt+kAL4f3X8UqCM9h0Sx9Rws43yRZYYVEWgW+PfRwmMM3pSqwlFJKKaWUUq5HLtHK+86Vb/JNKlTYze7V9zIyppha7Qp+x0nCILRaL4A9+QZra8AI1oahgnVur+Z/1zDe1U3SmjbtQpp0hBHewltuzsFLKaWUUkop5TpkywGrDp01l4Z5hVfuTGClSJPSf4pSNYHx/LN4O+o436qGVRZ2wnb18PcGd7XpoafQfmGCCT7P5zf2oKWUUkoppZRyA7LlUoFNmuxhz0XgStV8d6QIUCW8wi9h5HXC/9r2JMar6gCv5+9VsMhVX/6ZANc1NhC9EVlkkdd47eYcbItLP/1kZMznSlKjxgADLLBwkQNSp06HDjVqLLFEgwbLLNNHHwssFHhxVaoMMrjaSLZGjRlmqFJliSWaNOmhZ7UCd5LJ1QKPXnpJJBo0mGSSfvpZZnm16KRJkwUWaNEiI1vlMrZp00svgwxyilN06FCnTh99zDO/ujYl2HJXCyzQQw+DDLLCCtNMM8gg88xTp84yy3TorIL+Bg2mmV69b3PMUaO2WuTSLb30sshiyRcspZQ7VLYUsEokfowfYz/7C5NaIl3Vki23vcR5XAsyC3BJWhiwOkkRbIlftYhFrdQ4fi2C/AZJSV5ff6lQ4RjHeBfvYi97Vws07uVeWrR4gRcAWzGghx7atFliiYxsFWBtYxvLLDPEEKc4xRhjTDDBEY7wMi8XVhnop5+HeXh19YFBBvkm32SccV7kRcYZZx/72MMeznCGL/JFhhhiiSUOcpAaNcYZ5/f4PR7ncSaYYJJJ9rCHXeziRV6kRYt55lcB2hxzHOQgj/Iov8KvMM8844xzmMO8yIuc5SxgoO8gB3mJl9jHPh7gAS5wgad4iod4iOMcZ5hhJphgkUXGGSeRGGOMr/JVAI5xjGd4hhFGWGGFOeYuuudHOMKLvLi67uYyy1fVUDcjY4KJ1TVOF1nkK3yF7/CdG9CAUkopZb1lyy1pcx/38Uk+yVt4y4b0XNpUItJ5DQdA3QR2cGDU/f5a+5IDrvYLsav7BonA1Eu8xFt4C2c4s3EH0zG3yJI2RznKR/kof4O/wU52XrKXWkbGMsvUqa+ZSr8eEeDKyK46WixdUEp/XXu/3SRp02aeeQYYWAVW/fRf8XsZGS/xEjvZSY0an+fz/BK/xL/n39+Es771Y6KUUm4X2XIcq2mm6aV33YzDppVYyRffk1yqarB7O5HWBc7Es6phy+P0seFatMgic8yVEasNkMMc5h28YzX6cilJJJo013Xc1POfyKO7kqidSXf7k42Wdv5zvdKhs6q7FSqrVcQ1ate02sIhDtFLL3XqPMETN7b0VSmllLIhcsVZMqX0qZTS6ymlp8N721JKv5dSej7/PZq/n1JK/1tK6YWU0jdSSm/YyJO/Hrk7/7kdPd1rEoGgSz3hStgu/oZiejCjyNFKGLG9D+iFm0FLq1GjTr0EVhsgSrvdCkcjhZ/NLp3853rlDGdWI3RqIqz1Ra/2+lPXz3a2X3U7mFJKKeXmydXMpv8WeG/Xez8LfC7LsqPA5/L/AX4IW23uKPAJ4BfW5zTXT+7mbgYZvNWncfNlrUah3bJWr6vIoVK06jzGtTqPEdk3uEKwTp0mzRJUbYBkZAVuVSlri6Jr1yu72V1Id84yywlOXFMUrHQsSinl9pArAqssy/4YM6FRPgB8Ov/708CPhvd/KTP5AjCSUtrNJpIGjZtmRLr7MN106Y40rcWvgmJ0S2k/urbPwmdtrAfWATxFeBNuaWlY1l9ERC/l6mWRRZ7juVV9vJ77N8gg29l+zXNRNxm+BMSllLL55Hrj/zuzLDuV/30a2Jn/vRfr2y05kb+3KaRO/aLla9aS9TLg3+W7nOLUDXEzrksUQYqgKErkX+l3tevVwEBT7FnVCvvIgAFgjGJ/rA2UOvU7v+DgJss885ziVAmurkGaNFcXT48Vj9ciiUQ//decgu0muZfPrZRSNp/ccLuFLMuy66lgSil9AksX3jRp0bqq5WMWWKBK9YajW4c5fPM5JOkSf8f3upe16QZaLQxY1fPPVzBN6YS/W9gyONXwvQ2e49WzqJT1k0McYhvb1mVfiyzSpHnHR1HiUleReC+Qs1HXf6ff11JKuVPkeoHVmZTS7izLTuWpvtfz918D9oft9uXvXSRZln0S+CTcvNLyjIxXeIU27ctGrnrpZZ55Fli4of5Wt4RYGvlQkaDena7r5lFpe/WsanV9v40BLYEr9bXKcAL7MhsavarkP6Wsn9So0U//uhjtzfBsChGcZP8vpAVeT69zqmLNQccZB6xv1e7ObtpZm2bWpJE18q9d/b0owU4ppZTSLdcLrH4L+Cng5/Lfvxne/+mU0meAJ4GpkDK85VKlyoM8eMXttEDybd+JPbZb6I5SKf0Xt4s9rwSSoghcJQxUtcPvNsVFmjcAXO1gB0MMrTZ0LOXGZb1AFXBNbRPWU1bSCktpiZcrL/N05WlOVE5wb7qXofoQs7VZzjbO8mr1VU42TtKpdhhvj9PqtHiMx3io/RC/N/d73L98P2PtMfZ29tLX7qOv00e6xrZNtwJkbQYwW0oppRTlisAqpfQfgO8DxlJKJ4B/iAGqX00pfRxLCH0o3/x3gB8GXsAWTPnYBpzzDcnVpuZuWy5PTM1VuXQj0A7QQzHC1Mj/XsbBVrtrm4SBqzrWvb2Vf1aFjaaSlRyr9Zc++m6bqEs7tVlKS7xUeYnvVr/Lt9O3eSI9wWyapb/WT32oTntHm0Njh3jnkXfSf7jfOIAD+auO6WkLT10vwX0v3kf2jYyFVxd44dUXOH/yPMsry9zTuod9rX3U2pt3gYpyPJRSyuaTK84YWZZ95BIfvXuNbTPgb9/oSW2UVKlyjGPr5uVlZCyySA89m8c4KRolIyKAFaNJ2q6DgSkBsUEMLCkSpX0sh+8oOqW1AgW8wCNgvvRaKZtcTnLyiqnxWyUZGVnKOF85zxerX+S16mssVZfYPrSdJw89ybHDx9g7upfeei8cgHRXMn1OwAKup/P5awWP3LYwXW8AI5Del+jr6+Ph2YfJ/jzj7J+f5blTz/Glc1/iXcvvYtvyNlJ7k4zxICvlYCullE0nm2823UDpp59xxlcb862HbBpAJRHvSSk7iQBXd0PQhHnzWqpsBWv+KbDUBObwyJTAVSfsT2DrJlUHlrJ+MsHENQOrDh2mmGKEkQ3R/4yMmeoMX61+lWerzzLQO8AD9zzAO7/3nTQONqhtq8E4pqstDDwtAmcwQLWCA38w3VTxhZyMqMMT+e8eYBDSGxI73rSD8do4y68u8/lPf56Z52d4z/J7GFwevOYUYSmllLK1ZEsBqwYNvsN3uI/7GGb4hvcnLtamEvGkREYX9wmKbRgqa/xWSk+Fky3cKOn/KBFIKbK1gW274rIgpayPDDF0zRHcRFpdkmU9pZVaTFQn+LXqr7HUWOKtO9/KTzz5Eww+MUg6mEz/5rCueqfwiKkiUEpFK81XpdiTrY73alvGnYEVPK29CEwCDUh9iebBJu/5v72Hb33uW3zyNz/JmyfezOPLj9PT3kRR6lJKKWVTyZYCVtvZzkEO3pkTYqz8i2k/Xao89Ur4u4qnBBeAEayOE8zQKI2yhGnKPGsDJ2lR5xKfr5Oc4xyzzG7cAbag7Gc/NWq0aV/1osax3cCNitJ9J2sn+Y3qb3Ck/wg/eO8Pcuith6g/WCdVkwGdb1GsOq1hESY1rW1QjEipCEPpcAErpavbOBhTSlAgaxkbD9PAOUjbEw986AEOvPcAv/JPfoXPfelzfHTpoxxYOQDZ2lHrjIwlljaf47WJJKX0XuCfYU/lF7Ms+7lbfEqllLIusqWA1QorHOHIqrc9zzxVqpes/lthhQ6dzV8dGHlU8tLltVfCS6BLPapq+W+t+TePGZQGlh5MmPFayI+ziJPeF3CDpW7sAmobJAssXHdDxlLWFqUCbwUJOiPjeO04z9SeYXZklr/6wF9l/P3jVHZVLDJ1Etc5RU4Fopr57978N7huw8WpvzgWVLwhYLWIR7DkUCzl77eA05DmEkPHhvj4//ZxvvWb3+JT/59P8cjEI7xn6T30t4tNOyXlOn6XlpRSFfgXwA9gjaS/lFL6rSzLvn1rz6yUUm5cthSwmst/lPq4kje5zPLNBVbdAAncqFypL6ZAk9Id3YBK+27krz6gP3/14CCqFxjFgdIgRS9+Cudx6bWQH2etFg3rKPvYxza2cY5zG3eQLSZaculqIlXr1QBTHKr/Wv+vzAzN8INP/iB7f3AvlfEKXACO49FR6ayiUHIEpKsCVvX8dxVvbLuMg6rF8LdeDTxV3sR7tM3j6XQBrkngW1CZr/DQTzzEPd9zD1/7f3yN//il/8ixxWM8svwIPR1PDyZSWbF3eXkT8EKWZccB8hY9HwBKYFXKbS9bCli1aa+CpatpNtlH37od+4qEeRmNboJ57D2Vl4cDDrj0mQzEWt/Xq4ml+wYw8NTEAFY9/zvypRbyczoPbMcMi85PpF8deyXfvsOGAqurTVVttKSUPgW8H3g9y7IH8/e2Ab8CHAJeAj6UZdmFlFLC0h0/jJnsj2ZZ9tVbcd5ryXnOX3I9y+704ElOsotd1wQY2rSZY2514fMsZfxp7U/57d7f5oOPfJBH3/cotYM107PnMf2WfvXguqnx0ZO/+jA97gsvzWYVTCen8/2poW0Wfkc1UrpQY0x+lHhaGmtzGOjrQPORJk/+8pM88puP8K3//Vv82gu/xn1L9/HoyqNUs+pN09MbaWB8i2Wt5c+e7N6oa4WOx2/CeZVSylVLlq1dybKlusvVqVOhwiKLV7X9eixH06bNPPNc4MLaBkweuYxI5EJFzpRSfIoyDeTf0bYCPbA2IBMvZSj/fj3fRwRoVdxA7caiAQOYoZHhURolRq262y7c+fJvgfd2vfezwOeyLDsKfC7/H+CHgKP56xPAL9ykc7wqOce5SwKrVv4jGWPsmonuFSqroGqpusRvN3+bmYMz/OzP/CyPf/xxav01eA5bn2EO18EhzAkYwqKm+n8b1ptqJ7YI+GFsrYcdmLMwgJPTl/F0X4eLdbhNEWTFyK5SjuJyKV2+hHXu+zKkVxO9P9LL4595nA/9Xz/EU3c9xS/0/QKn66dv2vqgd3oxR5Zln8yy7Iksy5641edSSilXK1sqYtVDDyOMrGsk6krSps1JTl5Mmhc3SYBIXnO0W2tFn2KpeBWb9Dtd23XPtUqP6LtqDLqEGYsKZsxWMOMmsnoGzOLrAyplGAGV0oRXKRu9ntrNkCzL/jildKjr7Q9gjXQBPg38IfA/5e//Ut7j7QsppREtB3WTTvey8gAPAGtHVLtT4N3/X82zTCQyMs7Wz/Jvmv+Gd7/h3Tz2sceodqrwCpaii4t+y8HoBjWKXPVhEdRt+f9NnNs3h+nrfL5fjRM5AaogjEBLaXaNGX0GPkbBx5BaO7yWH2cS0s5E879r8rEPfozX/ufX+N3P/y7DM8Pct3Qfh9uHqVPfMH2fZnpD9nsT5KqXPyullNtNthSwep3XOcEJ9q2Wvm281KlzmMPF9IkqlMQJiVGpHiyitA2vxJMXL8LuyxgXpUXRKIB74GuBq17M+x/M/xbnVvsV8VfHamNRgoX8PMRFWaHo7StCcJWyWRtS3qDsDGDpNBZTgbVTHnuxhgEFuRULk5/gxCUjVleSeebJyC7beiFLGd9ofIN/NfSv+B/+yv/A/W++nzSRjKu3QrF4oonpv1J/+n8A01VFdgW0EgZy1C5hLv9b+tnO/1Z0qhrev1S0NUawangqEIpVtctY+nIWe5J7oLqnyoGfO8Bff+mvM/2L0/zu7/wuz80/x9tW3sZoe3RDwNXNdBLXWb4EHE0pHcYA1Y8DP3FrT6mUUtZH7jjrdjlZZplznFvXBqFXkotIrCLhyiOPqbxxzIc7CuzBDEobB0Bz+e8XsfLzM8AM7p3Dxe0OIiFeEbBlYDjfVlGAQbz7uoCZuCxT+THOhX1eLkJ2BbnTSb1ZlmXXs7D4rViYfIklqlwfJ+hKRr1T6fC5+ud4fux5fv6jP0/fkT7Sy8krTwfxCj8R0eVYRIJ6Hw5oRC6fw3VQ6b7l8F6HYiRYIt0VgOpOn6uaUBEtRcNU+Ro5i6osfB0bI6eBMUh7E8P/yzB/5Sf/Cl/9p1/lX3/hX/P9C9/PA8sPUM/WN3r15MW0pNtCsixrpZR+Gvgsdpc/lWXZt27xaZVSyrrIlgJWffRdt3e+HpJVMl9nrw4pJXsCfRig2oPRMw/kX2hgkatBvEP0PBY0fxSLffwJtjKjlqLRhB9F6Y5pfN20DpZSaWCGTOR3GbEGHqXqYIZsFDMiAmmxE/tVyu2cAryCnFGKL6W0G7tTsMlTHjcSObzcs1yprPD7jd+nerjKxz7yMXr39FqktYXpm8CUWiYoSjqM8am0tl9MfyvNB+6ggKf0BKJUJaiGnyr40Dho4cBL0a3Y80r71pqCii7rO6ow1P9LGFhcwqJYZ4C9ULmrwhOffoKH/vNDPPMvnuGz3/ksx5aOcaR1ZN2W1bqNU4FkWfY72PqypZRyR8mWAlaLLLK0OsveAqnCUn2Jeq1OpVIxQ3I/ZkzuwwBVHffktTzHin2XYZxIvhe4B4tu/QHwp1j0aomLo0lKiYCBsyZm3KYw0u8KZsxUgp7wFIq4VvLkezHDkrq2K+W3gJ/CFij/KeA3w/s/nZeTPwlMbRZ+FcAoo+tm5MF4VwuVBf5L87+w/cHtvONvvIPUSZYMbeGVfIN4+m8Q08c+TMdHMMCi9fzUX01pP3BuobhX5NvHqj+l/aSfSv1FzlVMDYqnHwszIrBSZCwCMG2ncdDCIrvz2FjbC833NHn0yUc5+r8e5Vd/41f54/k/5q8v/3VqWe2GHY3d7L6h75dSSinrL1sKWPXQwwADNzUVuCp1SI1ET7XHybqHsaWst9vnbMMiQ4uYoelg6Q0tHhurBhNmpO7Nv98P/BEWJ1mr75Um/aV8mxZmwJawSNQoxfUEl3Fy/SwO2Kr5K0YBtpiklP4DRlQfSymdAP4hBqh+NaX0cSw286F889/BWi28gJnbj930E76MHOc488yvyxJPYJGqf9f8dxx96Cjv+JvvIC0mj90N4xw/tUtQlesQzrWq4+0SVEyhKBM4H1DE9Zi+k/6KBxVbKUgUbcrC3908K/2tz+JyOZXwmcZDD+7AyCGax5ydSWAv9P/f+/nxt/04f/jzf8inT3ya9y+9n52dnXdyFLeUUrakbClgNcww29i22sfqZklWy1Y7nadqclD1ESxKNYAZEJFywTkmAjSx8ac86aX8/93Aj2J06d/GUoTq3xONRQub9NUwcRab+PdgRmEAA1uNcKxFvPu1lriJCzJvQcmy7COX+Ojda2ybAX97Y8/o+mUve695LGRkzDLLAAMFUNCutPmz5p/xpmNv4pGPPWKg6hQ2y4xiAGoYT/f140BLXdVbmI4pSiWnQs4I2LjQ/7GAQuls6bfSfLHKL1baxgIMfRb5Vd0EdyiCN6UMY5WuZlR1cJ/Kf88Cu6D3+3t570PvZeJnJ/jjL/0xTyw+wYHWgRJclVLKHSRbCliNMcYxjt1c8nQ+6We1jFRLTlL/QeAIZnAGcQDVwYyCPPLlsB9w4KWu0fLadwJvxSIBv44ZtEl80o8gSEt4yGi1MF7IMNYjSP2rBM4msejBTNe+NnhtwG5ZYomV1VxQKeshTZrXtZ5d93eylPGt5rfYeXAnxz52jJQlS4WpX9ogruujWJR1GG/9IUJ67D0FxShtJJx3v1q4I7GCOwSt8L2YBlyrma24VoTjxXQfXb+1z7hMTsKb7s7gqxEsYeBqGtLdifF/Nc67/9d3859++T/x+OLj3Ldy3yXXHSyllFJuL9lSwKpNmxatmzt51SHVEqmSzEAcAo4BjwG7MOOigEEbLymXl96Hpxjm8aU3oNibp4pFAB7CElFfwYzKLEXPO5LNlzFA1cjP4wLwXYx3NZRvM4t53RO4odLxN7jTerdMM83C6sKFpayHbGPbNUesuhdhzlLG6eZpRsdH2fff7zNQdRJvaKsI1Uj+exfmXCgCNYNFpwRC2jigynAieqz+E+ephqff5sPnkT8V9b5FMbUX1wwEr9DVMcHbLmisdQM8jS39DZ6qX8LB3oX8PGeAwzD894f5yJ6P8N3//bu8dP4lDi4ftHtXSiml3NaypYBVL703d0HlKmSNDKp5CrAXuBvjRUVPW4R0kW9ls+r4hB3XLItevIyPKpiGsMpCpfOO42v5RVKuthdoU6VTBYtOicgeUxtKrWywXKrxZJNmubDtOksffTe0CHNGxunGaZ4ee5p3/rV3kuqBU9WHgakRLEI1ioGsUZxwfh5PNUcyulLfAjcC9AIxqoJVym8mbLuCR6r0vfi/AFJM/YFHqCJPK2HjNrZYUGowro4g8nqMrKk6cT6ctzhjC5CmErUP1zj64FH+4O//AcuvLHNk+Qi1bEtNy1tOqlQLnfnjCh8bVbVeoUKW/2g5t9hP8GqCDR06q9tlZKvzhs45Umy0bVwZoEaNChU6dMjI6NChRrGAQ/vSdvGzqznHFq3VZbgut323jenQKawycaOypUbweixRc02icnEZi+1Yqu0uzKBUgYPYxC2uhkRGpIWDpD7cY47Vf2rmKU9/L5ZyqWKT+im8slAL1EYPXuXssVeQeCqxt4+MA+H9SnhvneR1XqdGje1sL7w/yCC99K7vwba4nOb0DU3m5+rn+FT/p/i7f/XvUttds15OVawQQ9Gqkfz/8fw9FUYs41wkRVyl6zGyKt1T6lod//W52ioIMKmSFnxlgMiDUqRLY0kATqsSqBI2crGqYdtYFahzbXAxpwt83Cp6LJCn1ilzULm7wrv/ybt59e+/ypePf5knl58sI1cbKEMMUaVKixY99HCEIwwyyEEOMsUUAwysrsF4gQtMMcUhDl12n5fj7c4yS5MmiywyxhgHOch3+e7quNvLXho06NDhLGeZX+0pAnP5j4DGIIM0aV50rDZtFlmkn/4CWEgk+uhjD3uYZJJFFhlnnF3s4hme4Xv5XmrUCj3pllmmmv9EOcMZ6tTpo48ppniap7mHezjBCRo0eIVX2M1uOnQ4wxmaNJliahXMvZk3c5CDnOUsCyzwbb7NEzzBOOOrYOt1XmeRRQ5wYNUO9NJLmzYNGped/1dY4Qt8gSMcoY++y66jOcVUYX9/xB/x9/h7rNcSUVsOWN00Ua+qajKDsR34XqyjUQ8GrlRCPoxN1uJaaWJfxMFUbPIJzsVaCO9reZqB/DuPYJP557EolIxJCzcOMlryvCN/Sm0WBOR1nNg8sYGnO9ZJhhha81lNM12YdEq5cdEkeqnPLrccS7va5j81/xPvf/v7GTg6YABeKTABqkEMUCla1Yvp4gU85SbdFl9QgEt6KtCj9yKfStsLPKmoI6b4Et7CRNGndjiOIl/dzoZ0PKYACe+rK7vGRJxNYxpRQEugUuc6ixWadCDdk9j/T/fT83d7+MpLX+ENy2+4qQU2W0F66eVhHuYH+UHu4z7u5m4GGGA3u1fBRZs2Cyysrm+5nP9cbnWBy0mLFiusrHISFcW5WlukKNMiizRoXLaZ741Wu8doVPf/awHH9/Ce6z4WwAf4wOpxrgbQ6Poud/1v5I2r/19LxOpVXr3q87ga2VLAqp3/dL+n0OG6SQU69Q6pkiw1UsGA1RsxIyNy+iiWwpjAO55rAo/rpS3hQEjeePSQe8J3dHkD+XuHsXaUx/HO7TG9qHUAI2ATmIrGRiBLfaxkbBQBEz9mHeRSXkkffTc3lbsFZD/7L9kk9BznGGFkzeeRpYzPNj/L8P3DPPQDD5Emk0dnhigumiyyunhRdTziWsH0VxV+0iOBEQEpcagiRyr2kFruer8Ha8W6C69IlK5Wwrb67gwWRT6P9aFawcdE1vXSGI1ViKnrpWtQlEyRLoFJXcs8Nj7bkB5OjP/jcU789Ala51s0VkRCK+VGZYQR/jn/nPfwnkLvtu55v0KlQDdo5j/XIxkZNWoX0ReuxdZo2/7V5TeuvO2Nylr7WXcbGSSCmSutO3o5uZ77ulGypYDVpaIgwwyv643u1Du0Ki1qlRqpmSzddzfmse/A02hNzPCoK7pSHJqUeyimHtRPSpWCVXx9tCF8ItfSHr1YWvDh/D2lH1r5Z9o2lq+rpUKGgbMKxutazrdfoLiIs4CYzn2dZJ55WrQYWmXR27qLd/pyODdbeui5pO4PMnjJisETjRN8Zfwr/I8f/h+pLFYMbPdgDoJA1TBWrboNB0oqplBrgrwNCeBRpqhrWf6dufx/8Zsip0lRpzYG4A5hLUiGcaDTLVIjYcax/HstDFy9nL9i64UItOIanYqA6Rq7Se0CkLG6sRd3XuYxsn8V0iOJx37mMbKfyy5OK5Zy3fJ23s77eN9l00PrLVeyKTEStJmqQTMyVlhZjVbfyLnpGhOJs5xljLE15/Bb0lsyyHqvXbulgNUKKxdFrAYZLDzQRRZvzIDnvW3qqW7tFQawKsB34WmIMcx4KA3Si0ePtNxHJKaLxK5TkhGTQzuLGyilGkSI34alHc/lf0/hy2+od1AHS1GOYZ77QH5Oc1jK5gQGyuYwI6BIlrRHhrJ7QejrFA3EEkTdWrlU+mOlusLv9/w+P/HDP0Fvo9fI6k0cUI1goGZb/p5ag8xR5PNpzUzwSKyAvXRUCyzHNGDkWClatAtrX7ITJ8ZrWGdd/1/qPTk8O/ClpJ7FI8aKIMeWC2u1b6iE7WKrBh1LkSsBS1XbvmqfpR9LpP+WbEWFRUpZB7mbuwtO2mYQAZhbEYWPRPa1pE6dTv4D0E5WUV/NqjRTc1Wnr4YkvswyPfQwxNAlj3ezQNUcc0wwwQGKvePWk7gOWwxYrZWfbtEqGPDrXZB2VWrYcjUqNR/HJultmMFZxoyGCOfqt9PIP1/ADY74I7G6SamE6LEvY152Pwa4YspDYGoHZnxU7j2ZfyfLt9kL/CUslaP1A7XfZ7BU4jPAK1h07Vz+ubgoMi6Kpt2ALLO8Zgh9kcWyj9UtloyMrzS+wq77dnHXG+8yfRCvajC8tmP6JuAkR0H6oVS3iOMaF2q9EHutyVlQGlDbtzG9fiQ/VsTha4GotT67+AJ9rO3Jz+d1PJIsIBc5VoosxSVvwB2jFH4LcMU2KRrDi1hacBDrz/81fCWFUq5JatRWjWWFCo/wyDXP61cCH2vJlXiJUSpUrquH3PVKTLm1aLGQFqhQYSEtcKpyihcrL7Kvso9mT5O55hxfqH+B6eo0AJ1ahwf7HmRHbQd3L93NmYUzfGXxKzy68Cj9i/3sbO+k1Wkx0BmgJ3M+WSKtRsUvRfG4mZGqHnrYxa4NP86WAlZrcXS6/7+hcn61Sqhgk+N+4Pvyv9sYcIrLZ2gRWnFL5ilOyvJ81RqhD+/bM4lXHWqJD6VKFOUSwJrBeCb6v4NForQf8nO9Kz9GTHuMY8brXoyz8ic4Sfks7lErGifOyw1I9zORZzfDDIulC3/LJCNjtjbLNwe+ycd+9GOkqeTr/2lpGgGrEbwfm4jnSotJX22nrvtzeMpPKe9IVtd+xAu8G1tjc5QiwIdilEiA6GoCoAI7AnOD+TnFRqBaOF3ASZ3V5/PfAo/aXucTz0Nrcuqe6D7NYePrEeAdwP9BCaxuUDKy644KLbF0TZXI10p+vlRrmfWSjIwWLaYr05yonOC16mv09vbS7mnzQvMFdjR30N/sZ3z/OEO7htg1uovdR3ZDP7yx9kaylfz8OsYXTh3jUu6q7uJhHoZZWH5lmey1jFMvnKL9Spv2uTb9S/3QYtNVt65V7bgRsqWA1Vqex7oqtKru9Hoz8DYcSKn551ksAnQIS5moy7oWUe7Hq4p0epXwfx8WheqEzxfyv8WP6sMM0OsYV2Q8f68vP8YQ5pGrJYMAW3f1k0CioljTOPlWPXk64Zjy3m/AGKz1TNarWqOUG5AEv974dd78tjdTHa+aXmnR8F7cURigmDITcBK5XeMETH+mMd3XOpnzeERKkVlVwS5iQOpBjLsYe71FPpTGTz28F6NJV7jO1VUPtGC0xoiuT+1MlNpUL7gLWJR3GifAC4B1pwvjb/CClCl8VcnPYWn4Uv2vSWJqp0btqsjf3XK5KMul5FoAXEbGOc4xzPC69OcTn2mZZSYrkzxbfZaFngVqozXmjsxx5MgR3rjvjQweGKQx2OBd2btI7URaSM73UyPbcxSDALF6HAxkpQQJegZ74DEsgl3HqCN/BHwT5wBvcudgvYHtlgJWG2mcs2rGfHWentRDtadqIGQU4y0NYcqmw2/HSakCQtFrVYRKnrmUO6Ycmjj/RGR1GSz1y+lg6TstUVPH1wLcjoGtXooDR12tY/RJUbjtwAOYR92DR6Z0XjKyMoLrdLsTiSbNQs6/lJsnSolcqF1gZdsK937vvaRzyZ6zQFU/pmND+e8qpocil6tgQrqkdgdTGKgS909cq0hIb+Mp8vuwyKrAfgVvMKpok8bCYn48pdOVvou8J8la82o9P+dRHCjqOps4R0rjp4W3mZjAnBoFWMVl1Fjp7gencxfn6gTwKBYpvsDFi6qXctWilgebUYYYum7itOzZPPMcrxwnq2ac6jkFO+DIfUd4YP8DjNw9Qn17nppUwZGAk+Z3RYUl0usGxea5AVit2qRlDDzp816MWvLXsIKMzwNP48tV6XubTNYbG2wpYKUlbSaYuK6lPC4rNTibznJg4IAp1j0YcFHln9IFTWxiVgoQfDFldZw+hYMgKbbSfAuYkgp4xVSKqvWUjjiZb6tKxCZG7h3Jz6E7va8IVGy/oMGg9MXu/P9p3BAK9M1hQDKmb9ZRdrCDYYY5w5n13XEpV5SUEr9f/30efdOjNAYaZvibeBRUacB+TB/m8D5UmpBVlAEOqgSspHviT4nnJOL6MAaq9mCTt8BWTKGp0rWNt3YAHyOqYBVwq2NjQGk9GY0IshRlq4TjVfNrUd8tcIOhFLzG1gTuKHW3b5AzlYXPxbeawMbxj+DLU5VyXVKlygILG552u1ZJJBqrOfGrE13DJJPMVmf5s54/I9uf8YYH3sDOozu5d/xeGsMNS8EpnS2enoJiCXdwYqNccDqLorEaXzHqCw7KxIPU3y0MtM1itubvYOP7OLZc2reBl6Az0yG10rqmCjfT891SwEpK/BzP8Rbesn47zqvrdjR2UBmtGHDZl79q2ITcj02W27FJt4lN7osYABrJP5vGgNgE5lloQddoSOSFq7+PDEtMR/Rhyi2PmHy/WdgHFDkg08BngSeA+/HS8OPYIFkAngO+gxlWRRUir2UOM346r3UMMG2GAXMnS/fEtMLK6pIT87V5lkeWefRtj/qSNZFXNYRXAgr8K5qj/mfSQ/Vvmslf4icp7dfCdEvvHcB0UgUf8/lxpesr+TnMcnEKUsYjLsqsFJ1S8KPY2BNIEgm9E7ZX65PF/Nx68OpGpfs6eLR3BRvTS7hHH6U7NaJ9CODNY/f5XcDPsa4R4I2QlNKngPcDr2dZ9mD+3jbgVzDSw0vAh7Isu5BSSsA/A34Yu9KPZln21Y06twYNdrKTRRYvm9rbTIZ5LcnIeL3yOn9U/yP2ju/lnsfu4cce/THqe+sGUKTXshNNbNxpHhfnUS8oRlDX0mel1WU3YmpQla1K9cXCpQ7G3+1g4+AYFoH9ceA8pN9LZmvOcU1pwoyMJZao5T9RFJW8VrAKZbuFG5YqVXazmxVWrusBXCQ5SEmVRN9gnynbg1gz0BqmVPLUV7BJdhSfsOtYRdMZXFEHcWJ5Gxsc6vujtIciARMU039VLOIlz3cXZryquHc+BGsG69rANzDuzHT+3VeBL+CtF04Dz2PTYff8k1EEivJiStm0EtuPRCAFgZOY4Ov1r/OG+99Arb9metDE9Ek6NYpFRvsppq8VidEYUMfxKUzHxKsSSFdl6XT+3iFsUlYESB72HDY+FBVV2nE2/z+m6ERGV+RVAEUAShGm/nCOijJpu5X8OsE99O4oVORwiVOp6lqtxSmDpdYoSlFWwv6q+bWfx4pKtuf3axMDK+DfAv8c+KXw3s8Cn8uy7OdSSj+b//8/AT8EHM1fTwK/kP/eEGnTXuVLXQ40tfKfzbZsVkbGZGWSkz0nmTg2wfe8/XvYeXQnlaziNqUPX9lAaXJVeEvnBJTkYAgwxUixEEGiGCWNVa36H5zjqOiy3lefRo3JNjZv5PtJP5RsJZJfBJ7Kv3sVIlrIWnI99ny1ncQ6k8CuCKxSSvuxwbITuy2fzLLsn20Wb+RaZJ55znCGHexggYX1AVaaEOuYcRnB0oAj+XsLmKJXsJYG5ykagQqstld5Ge9a3Y+n/hbx6kBFpVZw0m8k9y5jBkfnpLSDCLdDFHPlkpSf8yjGyzqTH3M6//sCXgqvgRgrnbQPrTW4Pd92mjKNsYklkny7x4OqZ5ary7zY+yIf/r4Pmx6Ak7rFORrEgYf4GQItirpKd+fwVHJsq0D+/2T+ezfGMVJ6UZP/HM69ii0/lProobjUU+yiDu6dx87p4OlBGSBFj+p4DzcBvCmcg6J5XmM0grIIlkSwj2R2pTxjxaQAl8DUYSxqvIkly7I/Tikd6nr7A1hdNMCngT/EgNUHgF/KsiwDvpBSGkkp7c6y7NRGnFuTJsss06J1WZL4WlGQWykZGTOVGRabi2T3Zhz9oaPcf/B+0lwyfezBOY3bMWAljp/6HMrBnsHHXKLI8dPYiMVXGjttbPxKb2PaMEa0wMcUOEUg4ZkZRV0Vje3FtOE/AL+NNwS+gqxnRHGeedq01527ezVa1AL+L1mWfTWlNAh8JaX0e8BH2QTeyLXI8zxPRlZYcPKGpYYvINvBupzvwBV+EkuPiBeSAS/m72miVePEvnz7BXwJEKUSFygOkFMUO1QL7Ii3It6LCIUH82PGiqyon+KHjGBVi8/jizCr15DAlPLwWtgZfKDq9xTGt1IEoZRNKVeqYsrIeLb2LHffezeV7RXrs6SmtpX89zAGyDXpCuxUcCI7eMp6GtOLGXy9Pk3QM5jebcfGkipNz+PjR0R3pf1UmRoLO/SZ1vqLrQ8i16sa9ingJLClJruKpM3iIE1RqDlsrKt/nJqX6qUxE52c6PVr/zGlLhC2mB9THMnbT3YGsHQac87BXMxXw3Yn8vcuAlYppU8An7iRk6hRYxvbrgiabtRgL7CA+jbdsAjQ74btP7yd6gNV7/PWiwOp7XgqW7xZ6b6iSDE6LJ3UPC29i9FlpQyjRPDfCd+J72ucK1gQ1+XUWNG2ajR9GvjJ/Lu/wYY3xM3ImGaaOebYzW766V934jpcBbDKB8ap/O+ZlNIz2CDYFN7ItcgOdqx2k14X1CtPVJ7qYSyPvBublEdw5VKFXwMzEuSfy7tNsFoRrNTeAjZ4pJQr+XtKpQjha5maWXwttn7cKNWwgRdJi+AT+SLwLaxE9vM4f0rb6KUUif5XKbtaRKjyQ4ZHDUvjQC5lU8kVl92oZHy7+W3e/33vN0+5jeuWKk2HKC6HpPYHilQJ8MzhvCpNrHIOpOPz2Ng5jFe+yhhMYgZCER1NwrHKDtwhkceuliEaFwN4FLgWvq90oSJiGtsyDuKAda8yIA6lwKZK12dx0KjzE2iL6Rl5+R2K1yKgqihhl7RobYhR2AjJsixLKV3zyWZZ9kngkwDX8/0KFZZYuim9i9ajg3qHDqmaSMOJ9M7E0NuGfMmzATyrMJ6/hvHolCK483jRx2J4iQsVWycIEClYrb+l43F7iQBY5GTF1D/YmFCRh8jw2qe+ryKS14APYvPC77FKH9moJX8qVBhlNL+UtH5gOMg1xT3zUO9jwBe5QW9kPTyRa5VDHGKEkXV7SFk9o1VpUa/UzbjsxsuzRygSZaXo53DjkbCBoaooGSBxTsDJffP5/xewMGrkoahisJofN8OiUwrdTuIKrX48s/m+XsF65XwVe4qxGaIGgkK90RjIG1L/ojlcm1RFch5PCZbA6raU47XjHNh9gIG9A5YSjtyNPrx9hybpRez5D1HkOYnErf5n4nmo6acchSU8jS4en6Kx09h4iBO+7KUm7xgxauGGSCBPol5xA/gSUHH5nLhsk6YLATXxFaPRUQRL/DL9HyMDEoGpbqdFnr3Gi853njXlPOc3bRuBXM7IqU4p7cbLHl7D2GOSffl76y5VqtSpX5FftR5yI1XmGRlLlSVavS2a9zSp/3DdIpUqAhnLX3vy3/14Clr8VyiCoBgJFZldczO4w0D4jsB8dARS13dilEoOdiS7ywmZxfQ5tibRnKBxLerIBPA3sMrB5/z46+04JBKDDF70/k3nWK2eUEoDwP8P+D9nWTZtVCqT6/FGbtQTuR5Z1/YKebVRrVqzSXYfxjaLE7SadLawbaT8ilqdxSf9C3il3wQGjIZxsu80BpAmsYn3dTyqpXRIDe/IPo2TYGsYR2MYN2DqszONp/wU0ZL3o2qoJl5eq+3UamEObyExjS/lo0iEjFD08EvZNHKldb6+W/suxx455mBBDT5FzB7BxsIcDgjUhkBRnyU8UqVolcDRIqaTagy6gAP+ITzaK2dDIEPzoJwHedriPSlKKu+b/Ngi5Yr/sYj3cpOuK70/hacZ5ZkrUia9lhHSTKrO8HGeFkCT0YkcFZ1rbDMhwKboV+CetGixyCIDDDDO+PrwRDdOfgv4Kayu8aeA3wzv/3RK6TMYTWRqozIaWkx4/lLo9BZLRsZyWmamMUPPfT30/2g/aUdyvRvFFzPfjYEtRXtmcKAkwK8sgvQvksu1rYa89Ezf76aGaGzFrIoAl+gvcqy1nRwDOU6KRrfxeaFCcaUOOVHLWNXg/2L/J9JN47ytt4NyVWedUqpjoOqXsyz79fztW+6NXKvc6ErdBalZJeBqSmQvxmMayF/gRmcRA1GvYUqkaNFefLJW6XcVJ5gvYgBsEieRn8EmfBkyedfdPJJwnheFaWNDQlUhijsVqz3GKS6/oRSkytrBDV8FmwTEVanlv7WgrULRpWwqWWSRS60sv1BbYG5wjn1v2Oe902LzwCHsmQ/gHMBYhq1olHiBaq2gprbijCh1ISC+gI2XmJKTURAQkcgALOHkbwGjTr5/pSPAo7YyEHFpncgbG8JbhsgpiGOs1vVb19odmdW4kjcvAxcJ9HJi9He8vll82SlsDpODuJnaAqSU/gNGDRlLKZ0A/iEGqH41pfRxrDTnQ/nmv4MVN72A95jfMLmf+xljbCMPcV2SkfFK5RXae9sc+MsHqD5YJS0nbzQ7iKf9RjC9jABcXEcBFFFSoq5FHlR3ylm6WQn702exkW7UT/Fw1Tao0nWM7bijMoHZK0WeFaVS9WF0gjSHPIjRAJ7hylmOimWN2vU2tVQrriF6i+VqqgIT8K+BZ7Is+yfho1vujVyrrPvyNeJuaC29XdiELOK4PFqVVoMbIilb5CmpbHYg/18RqWVMQZ/FI1bqBRR79cg4VMN7ekUvJlZ4xP47Kosfxbyj4Xx7EZCn8a69p/FqQfUdUuplOly3eGKvU0atNqFcLtT+XPU5Du4+SHW4aon8bs4EOGDRZ218wpUOC1RF8qyI6op8zmA8v2kMiO/HxpIqD6PnDab3Av0yGkqfx7YK0/l7C3h7iIQbJ/G14nUImDXx6sIYaYo8xe6Kv+WwXSt8T+91p/4EpDpdL43NBQrAqkp1fYtv1kmyLPvIJT569xrbZsDf3tgzcjnFqfXNVtygZGR0Uof5nnl2vGMHPT/cQ6omX5tyGANT2/AKvyVMl+W4iKQOF1fqqco2cq0UdYp6rEhVTP0pMh0/U6p+BGvS2xe+Iw6hCppkT4by89+O9T1coNjJXf9rXMtp6QBvpZAOvEhkp+4G3gbVPVU73zmsAemXMMfsFlajX03E6m0Yb/+bKaWn8vf+AZvEG7kWWc9oVYHkpzBtExsQqoiQN7yEga4mdkcErGRohLLlyXYwxRPB9zlsWYAZPNWgirxdeLh4Gw7qpKhKJcRUjb4PntLpw5uajuQvXady4+qyPo9VNj6NeRYvY4NeKaHR/Fw1l3Xw3lxl64VNJX30rTkuMjKm6lO8+e1vdj3sw/S6B+dGKFI0hfd6UoRJBG6BK5HVVWihYocTWOnLVP7dFzHOn7zaHdhSSgfyv8cxLsZ5vIWIjIb4UuAOxGT+Uq8qOTwZDgZFaI+gEC6OUMmIRT4XFMFTTLeAA71O2Fbn1823ioTiPsx52eBKqTtd1ps/cyPSocNsZZb6gToDPz4A+yC18szHDmw+H8MASR1Pfysa3MCjVBpn0qHYzkSV5Jqzu4G9HOsYMQVPM0bdPIXRXN6CjQOl9Ftd29bwivh2fq5j+T5fwKNiiqxpvHVzMe/HKTUxzanz2w78JeCNuU2XY9+Dwfgnsd6Lf4y3I7rJcjVVgf+NSxf73nJv5FpEqcAWLRLp+itF5LE2MDBzCFdWKWzkVEzh3BRVS4l8KDJ7L85PWcbCqNMY2v8aboRa+XePYWum7cOjTEq5LeTnqWhShhmv1zBlbeIGZj+WwuzBvSN5RDII/eG6wEPVD+bn9zymxC/jVVVjmOGr4WBrmqLHdAnJyGjT3lQ9Ze5UuZTRWamu0N/fT2Nfwzl48jAFeDKsTEVR1yY+GSvVJwdCXdQ1oUoX1CJkF+acjGHe5glcV45i+q7o1QV8Mp+nuEZlE5t4pTqzuAc+h3MfCectrpUqGyP3KabuFAVThDlh46R74o7pykjyjem/FsWolVIz0fD1Y45LGem9IZlhhjbt1ZR3RsY889e1MPONSqvRovH2Bs0PNi3tt4Tp6x7McdhDsWhBzTWV4lahRCySkKMs/RYQk73o1s82xWXL5LzswsaRKngXsCzJduA9mK6/ii8wrqBA3P8iZod244GHUcxOvUKRhqIxoXlF43AXNkaXcYqMomK7sEZPD2DzhjI2ApDiP74bs0+/itmlSzj0G1VVu6Usl8LB6sR7XcAqpgpUFXUvNiiU0qjhK9IfwIyFvANFoxo476gHA1b6/zRmWF7COqGLDFgD3pC/YjagginzHgzwvIKv5baIo/b9+bF2Y15/wqJtMhDD+d8DuDEQIVieu1IuyokPYkZvG9aq4VlsYE/n+z6XH3uYYvPDK4i6gJeysXKBC6slzZKMjMXqIjsO7yA1k01gCvULVDXxCKw8TxU9SF/l2ao6TsBiHp/U+4DH8R5tg/j4EedpHnMuHqYIcnrwCVV8k4MYR0MGYhabWKfy4+k4Gd7nTdFfTcxQjLZGwxErZGXcNFYEkpTS0LYi9kYAFUnrkceil679KUpgtQ7S3Rj0ZnRXLyyRk4AhaHywYZGfSbx6ezfmnIuYrn5p0nPNv0s4nUMOioo6VB2uvnACPEqbqc2Ixmkv3sSzjkfBpMuq6DuLMeeG8nNeDi85Sho70vEpPC04nJ/DGL5moZyyyPESLUZgsYoBuu/FHKtTmD18O3AE53Mprb+QH1fjaB6zh/8d8BmMZnAJjq9A93rKlrJcSnncUL8RKUw/Xq2RYYqzA08lqBEiFEnhIvZpsh7GjMgEnrJ7BUuzvYgT1QeAH8SiVArxylCdx5T6LO7tSOFVmnsIMzZtzHsQaFLkqpEfo8bFizNHqeGRCVUAzuMK/xls0VjxwwZwRd/GVbdeWO++IqWsLfPMrzmpHK8f58jjRzzd1aTYH0ppbvVnU9NNkVzl8Wrij161ojj9eNsDAW4BoFEsDXYWcwKewPlR4u/14VHRKs51VNGFJt/t2FiK3raiTrEqqoVXBYqr0u3pim+l39o2C/sCj2zFVJ/uQTu8p+/qPXEx1RfuW9ySVMadJEMMFVLe61rEdBUyX5mn50APlU9UTDfPYeNnBLMfcnIn8y8o46FIjcC+dEdjqrtnlfhOykTsxHS/iafv1xIBDt0S6eHrmJOyIz/mRP65AJE4i/34SiByotRuoR+PSI3gVeo6phBI5PzOYGP7Q8A78s+ncMAmyoEyP8r46FpmccelCXwY+PeY098Frm4oc3UZ2XLA6oYGlBReSPwo5kVvw5RQxF6BlO3hu0pHyPuQ8k3lf5/HF5U9jhmCSUxJlFMew3lZ8mYWKXa6lTcRPfIMC6Hq+Ip2jeKDQ0azmx9yKdEx5UEdyO/JR/Jz/Fp+bgO45yQSuzz3S8hmqna60+UABy4i9rYrbc70neGRvY8U19irh5cKMjR5Sa+VHhDXQ8RZRaoEskYw3RDgEEm8H69y3Y7plYxCjAZpLJKfzwDmPAzhHrQuawhLC4xiaesJLk6R6DrFjVSKbxaPuskZESASGIOiTmssxYrGbjAVI3idrm3Ut+ib2LxQAqsbkkUWWWb5ktWvGyWJBFVoPNgg/Z3k678OYE7uCB75V9sPvRejnNIZVdF2gypFeBT5Gscd/MuJdHCGYpudC/jSawfzbaewcb6ENyXtw8aUCOhL+XcV4RYtRWlHOUbS51g9rIBAP2b/3oo56yMUU+Oz4dhyXmSHajjFQHZJadO/lJ/LS1zkLG1EW4ctB6y6ZZll6tSvbsBVwksRm15MocUbifwrhfPlISsMCh5G7cUG2QXMEJ3AiLkX8OUsfiT/rUiV0h8aeAJICqlqgAjdj+FNHZt4Obn6kOjSr2XOEQDr4PywDPOU3o9F3c7h4eNBvNJKwLCUWy5r9W95rfoaz+59lvcMv8eAsNIRdTyik/B1x9SOAzxVrJ5U8mDFtVrAxssI7hjIy5ZOyHuVfknXIygRn3EXzlFR/zTxuQRw+rCxsQfT1VexCVap90m8GjfLz1P7H8qv+wLFJZ40qeuadV7RmAngEa6nm7ge35MRVduVP8VBZinXLUMMsXS1q/yup1SBt0PtYzUv1tB8P4DpyiQO5IfwaE4Fd5I1jmZx3VZ0agjLQOwO378aUURnPt/PAr6qwQQGrLbh692qrc8yFgnbgUdrdWsb2Hgcx7MUc+H6pOuKvMVsbE9+nDo2Nn8kvyaNkd04uFNqUynMTn5uo7gDF4GlCm8+iK0RI+c+yHoD7i0PrF7lVfaz/+oa7Qk0RUC1Axsoh/H0mxRwGo8OaSApxaD8uMiIGZb6eAZv/jmC1VfuwRuuReMCXp6r9+U9yNg18bUKRUwfzs9LGdEb0SlFUXXsZWwR6oewSq/utMkong68TQ3GnbQweWsNVucrtVd48uCT2sD5VYrIqvBCxHF5nkrpaRKWA6BnPYlNumN45IfwO4bzBaoi8VvOjN7biY0Rec4i+2o7tUFQ+5KhfNvD+Tm/gpewC1+K/KrI8DCut7H4Inreuk9wcZVWjFTpFaNVek9/N7B55WUsdXGbjpHNJHPM3fzKwDrwTuD/hFM1pH/iBiqa0osvDyW+n1Ja0ziPUa8mBmDuwdd/vVqR7i7jPeVkrxZwAKhxphTjPN7YVzZM56VxLhqJHLFhrGBqluIqHqIWKJor576O6fx+bGm44fxYF3DOleyoOGKaVxRUGM2vU/dNFIXl/LPvB34dB5S5rHc7ji0FrLrXHMrIVisErygx762JfAf2gGfwTunTeLRqimLfniHc61VqRRP6HFZhdyLfRy/GqdqDR6k0kStqNogvACvjIAVTZKov3yZWS8mT13WthyjKIM7NG4C/wO4NOKlxOwYgY7j29pMWd8jC5N3tFjqpw/H6cX7k7h8pRpMEnlSBJ2AhzzCSsTVJq3dOhpdD78O5fJrkNVl3pz+gGPGNFXMHsT42kcwr/erJz1HphyrO+ZvExoJS1y/hUTkZDDViVLpTxq+Gj2lFrTTudK0aA5GMLiDVCq8ItNrh/WFsbvkMDuRKuSHppZd++lf1vEAqvwa56u81sRH/V/HF3UZxorjSzoq8DOJRVenNDBY5mqHY1uQIBqgEMK5G5NxqbII3cp7GQYhS1xXMaZnBm/Qq8ryEFySpsOQMNrZkawa6ruccNnZEA1DVeQufVxTh/hMM/GjcDuCNhYdwPpqq1mfDdWpf4/k9ncFXA0n5Nd+LNZD6w3AvWNvBvBHZUsCqe0B06HCSkxzhyJW/LA8Y7KEexADKBPbwJ/GS7QameErRzeUvGRKlG6TYr+I9oaSEb8eI6jJSGowyZuP404vcY/Gl6jjoauIkdli7Q/uNilJAir6pfFeevwDXDizVqQnkNpQ7aWHy7jGxUlnhSyNf4sOHP+wTqDgSqryr4GlAeaeRNxQBhTxUsOrR0XwfMh7n8GVqYpqxWzfEmWpgun8I52Op+m8Qn1w1Nmo4z0PcR5WTD2PgTCkZ6WjKP5NHHdtN9OXfVSRPDkIKf8s7F8BSKjOS3PW/xoxS97uxeeApPBJQyg3JLLMsByvaXQV7tbLCCi1al2/Q2oMBqvfh7WdkBwQulFEQAJHOaQ4VUXsaBzb7MJ7gdq4eUIFXD67gY0URqBksmqbxIdu0D5vdVKHYi+txBRuzC9j4WwJOUmwhIm7kaL7PaZw6oBYKCS/kWsDGzJ8DP4ABRzlQIvm/mp+zUoAa8/N42l7jXvQURdjFm6zm1/suDAx+kw2jpGxpYFWhwvYCw/zSktUyqELKkg2S+zDgM0lxPa8KNlgioq9iES0pl16nMaV8DfgypsxtjBD/MN6PRPsGB1VSdhk+kYcVUZNCDeH9f9Y32mmi0lyFlaXw6l+ic5InNI43Y4z8kttUbveFybtlobrA20ffTrPe9PSuiK2KWAlsRD6QdFFecSRzi1c1ihPdF7FJboq1O6bHSI10ZxQvCJnHJ+45PJUgAryKSsVrFO9QgKgPMywNLI74HbxcW4ZHLUjETVzEnZNZPOJEuHb9LZAV0/a6LgFPgSo5I4P56z/jBrWUG5JRRjnMYfrpX404CVRdK5m9nv9cUnqx4p33YgTsFr7ShkCVeLVKC4qOoUIQEdIVSapjse27cPAj6Z47Y6pZY+p82E8NByNy6pdwRyDDAgUaJyn/f3d+zudwADOD95MTTWB7/r6u/UFMn8/i7RuUMuzHsxhN4Ov5NT6Cc7L68+OJkyaHqAePgkeeo+6z7G4Ds7uKqiuyPolFFE/k18T697Pa0sAqkRhj7MqDK38oWS2zpQciEh7BjcUQNpAmcc9eCitOyov4pKxw79cx72YJM7fvwNMSQvnghkUEcCF/VUnI+AlIjYT3r4egfimJxkSDVATHWdxQKPXYwqs4lrCo1Xl8QN+mcicsTN4tL1Rf4MEDD5IWkoftFa1SelkRGAEWTejijchzreb/Sxej56jqIU20Ip32UyStyxnYg0Vd58P3Vc0kndcdU6ohphllaJRaHMz/n8HG1X68HYR69GgiViStieuywCPhuBrvMfUXU5Ua07HXUEwL7cZinM9w1f3eSrm8XOAC00yvltS3aFGjxhJL19x257J2ooHFpd+LGWxlLAZwzlQLT1PHdHh0RgSqJvPvfw/ulEuiXsS0uaLFc9g8rLGj9ON5nPwuvlYsxFDqWdykRQwkqbBjECe4a3zKeVik2H7hDGbLNAYFCnd1HS/Dx/IjmCOjeUbjSBEtjeM4ruV0tfFlqwTcKjgFoR8ffyL+vx34bdtXZ51DVxsRw9i0kpEVbmCHDic4cWW0WoVUTVQqFUfsIv8t4A0PZWSkgF/GDc5ZbGmac1js4hRmWI5j7f5nMAV4HOdexdTBeP5SxCBGgurh93D+2o6HoFN4Xa9Eb0gROhnHOWxgRW9rOT8HGaF5bLL4I7yy6jbWvsstTJ5/vpvbYGHyglTgz+t/Tu99vZ7uUpRKL4ElASI9Q4ERGRBwfdmJR1QrmH6cZ+3+Oor0Rk7hSNiHOCkj+FJMTXzSFJBRxEgTemzBMJZvI6M3i034O3G+ohwiTcT6fyA/niqwNB9EHpruRzt8X1EwEYV1nxRR24bNAf8FT9mUsi6iFF4irVaA99CzLpVgGRmtWovsezOrOnsVe76KSIkArt5Lw5j+KgoqILOEV+ZNYvr4boqgKkZI9b8in+JD6VjivCr1dwG3V3IYxGtUylktgch/78hf5/Do7hCm5wJmMb0XqxVn8pci0m2cI1XN9ylu1teAN2HjcgAPBKhC8XQ4TuRaKvqrgjJRXJSC19wlp6gHA2wCWY/k95eLG8jeqGypiNULvMApTrGXvain1VWlArtzt23sgY/hJa9T+ecqURWY+C6m1OCdx5v5917FUhCnMYU4ilUsiZek6rmd+Usebqx4EmCS0ZFnoZRF9PqvRtbCmBFUqVpFg0Wet8i34ptU8FXQRZSUoVyiSNxf85DXRzC9GXKnLkyeVTKONY9xcPtB704e+VVy8JfwypzI14tpLU3qg/iYEbiYy99XdSy4Pi9TLJMewlIEQ+F97Vt6JjClz2U0VOgrUCiwpbGlNPnZ/Jz35Od3Lj8P6ahmSUXhlvCosa4VivwrcJ5VJPVrfEQi/nB+Lp/B5oJAqi3lxmWKqTXbilyNXGkealVbVB+qWofvM9izG8YrXJVqG8hf/XjUVvwn6a+cz20YwXqAIqjS76jHdXxuFvdROraI8xgXcd5t5AXKpoGNhfP5+T+B2TelME/knymNLm5UHH+KhE3g2Qs5KeKUTYdzmsQa4O7CwdoMvq7sHOZ+xshw5GGKgiASvMaZnD+lERXp6sPbQKgy8zHg96DeKYHVdcs44wwxtPp/IrGTnZcnMioSpLTHEKZ0/Vi0qY2BIQ2aFj7pjmKK0s4/2443ZHsBKy19KT/OCJaTVjWVPOQxLKQaB5SMnHglQuKqyIidI6IxklxriiGSbSOpUIN4GY9a6f9Wfr27cC9OHtIkpvBLeBqo65ymmGKIoU0JrLiDFiaPspJWGB8Yp5qqxeVYwMGVoi8yDuAAQi+BrWXs+YtzNIk3AtTkF/lYIvAKMC1izoYq/ZQ6UfFHjEhFflOsvI3RMIG3DAeFfdj4Op3vbwfOB5H3n+EGTMZlMZyPOI4aI7p+Gc6YEtR4VD8eEe4/B3wJJzeXsm6yn/1XXMImy3+uqYl0BWr7a/C3IM0k08ltFEGVOH/DuA4rrRULPJax8bEdW8ZlkCIHtXvOFqgQgBDXsINzDlUVN4u3P1jEQI3s1HbMZvTiDr1SlTpmE6tGHMMCBfp+bAmhAq2l/PcePCXZh9uMxfw6Z/Lfnwd+goub9o7m53sKTxlqvPTi0TLNFXKmYiVzjGSJCqDKxfP5ddwPfAEWphZYT9lSwGqEEYYYIiNjhRXq1Blg4PJfqpknTwVSX7JQ5pH8dQZD1CfwdMKZ/PcIDo4ErvZi0ZvzGFL/LmZm+7AyUAEypQoG8U5JUjoBKYU4Y8QqNkVLFCNVcWAKIEVDBj7gtc+V8H8EV8pnd5frKj0qsmSMKui3DKOifLpHXUTdAQY2K6i6oxYmjzJVnWJh54LxCAUQquE3+PMSeI8kbAEI6Zo4VSpoUPQnVsOlrpcmSRV83IW3L6njOivDpPOInKQYKYrAClwHRWYX+BrBIldNbFI/j3MC5RjpvMWpVISgQrGEvIVHJvrwsaHxoKrdKtZL6ytYRZSqt0pZV2nTZoYZRhi57JyyFpn9UttnKYMdWEf1Gpb0V8ZA0SJFqhTBkq4p7aZoyxIGMvoxl20Yn3PBsw4xIqO5WN9XtEjz6yyWKZnH198UmMkwG3V3fn6KIFfzfbyGzeGyM2o1MowVVX0ea4tQxyr4tuefzeXHGM+v5Ry+Zmykiixic/+vYWNBHF2Nb3B7Vsd5jscwEoVs00R+PRrHAlA6hgpYMmx8T+JE+z5Wo1bZIxln/9tZss76kRq3FLCKkalFFq8qr5rVMjrVDpWUf3cbprBtzJt+BFOKV7GHtg97yFNYxd8CTgR8AYtjvI5NqGcxZdiRf08RHOWsd+OgQ2HVyO2IvJFF3IvXgJRXHj1gGUIoevqRBAheWRFLvtXLRINkHs/by9ApMjWBgcyX8MiWjqloxSCeCuqScgHmmy+zaZb29naRnC5goqEiw6+hFMm30hVFtnL+wqoBUDpOHJC92NiQ9xjTEwnvDScvU9FNgZsq3l5EaQQBNG0nDlS0j/q7OwI7hi9N1cC9b4Em9ebR9cYx08ZJsm2KayIqJaEx0MHmhj/BHKxebL4oU4AbIj30XLHz+lprxmVkLLLIa7zGPvatrl+6nJbpjHZofqxpOjqFr2ShdHbCSd+xpUJ0UJUKn8q/9xbWJqpL5zRuZBOkg/O4UzOF8wblnNcxfbyAg6F7ML2Tc/wKxfSasjPdXD9lYp7A5neNT/WxkiMxiQGweeD7MPClMfxtrPJ1AUuh7sG5wRrPkRyfYe1V9uHzjuxjHV/DUE6TnP4YuRZfVAT33vzeTAH3watffpVsvgRW1yXR++hfJSFdRmoGrOaqcwxVhuxubQcewBH+IDYhH8VSexnWwwOs19VJbKI+hT1UhYlP4usuHc3fi6BmGFcETdxKHyhE3MJRugyWvPvYckGKFdOJGtzzqzfHI0udsE0Wfst4Loe/RVYUf0ZESpEl78IGwIvY4B7L72EVL3ddP30u5TolI2MwDfKmvjd5Oqo74qnJXCArhuDlTWtyA2/ip6oepQfBdGI73nB0EZvgY8Qq8lK62zpIp3UeAlD6X+csYySJRktAT7qrlP8c7rws4Jwsnb+cJUXfBOSW8/MFHyc65vn8+l7EANV5nMPVDr9LWXdRBeD1RMArVNjDntWVOTqpQ2uwReNvNEhHk81zg3jH73lM7/rwlJrI2JpTY8RVaefvxQCGROMtfk9jS/wl6blSjpq/Z7E5WHP/AubE17Eo1f35fk7jER/dmpn8fM7gfRB1PnNYYGARiwAdoEhEfz3f3zcx7rACBf8539cCHmVqYhSanfi4Iz+P3vy3ANoyBji7GTtyvgRQNS8oYicsrbEqEf8yd6DSYKJ/T78FPtZJthSwUsTqqvPoVUiVxGDPoIfw5zHlmsbRu8KKyqUrp72EKeAC3tHoNAayzubbqPJCkRspi1IVihBo/zJqbVzRYpRKfCe1XlC1ogxbhuenlY7RccENm0LKhP/1d0wJCmApxz5JseM8+T24nyLZWMDxOKVsBknwnep3uH/v/TSyhnt64ilEEru871iZI4Clij6l7qRjel9psv14em0Fm3incR0RjzBWDuqcNBELjChSKwOhCV3cp8h76hbpsXhXikhL3wfwpo3LeMNdKE7m4rYoqiy+YaxurOGrNchhaYbv38ayWZd5atDgER65eMmyqGd5yulk+yTLS8vsWtlFs92EjItaMnQaHXp+qIfKQxUHH9vwdjrk+5NTIJDQDi/pvJzQu/BGteC6Vwn7jAUgM5jNiZw+VRUqm6D09Cze2uYIlk5TlWAVc/4VPWvi1d4T2NPai+ntNN4weCRc20x+LdtxUPlw/v1X8cj36Xy/e/J7Np+fl1Lkihwr4reCR7JbWMPct+KVlpIKpnFn8NYK4kMqs6Rgg+YEUQE0vyzAY/sfo/LdCp1sfQbilgJW17yEQS3nVjWSPfR7MaVRaHcYG1QDeBpkBlMiIWzljZVWeBbrUyNlvA/nXrRxL0fARwg8RqliKkMTOzgYUjg0fhbJjhqginQ1KHYHFpdkPhxL3rQ8LhmNC1hO/lXMYzmPL48QI3CV/BhjWH6/ipe3z17yEZSywdKiZZVPCR7seZD+0X7XMU104vNJ38QPsh14VZIMgjhJ0mmlM6SPgzjvQ2BFaWvtk/z7ihxpv9qPHIYYMdU4iSnJWEErybr+1iQr0D+SfyY9FncmRqsicVbfU4RMYFQpREV7l/LrPIYXdHRzwG5fabEJl3naxz4e5mGGGXZ9GsWewd0YwB8BtsH2vu1kcxmN5xpkT2WkLyaP6ICR1Q/XbIHg0zgQV5Wc+icN4hkDZQDi3BwBUgOzKXKYtc1K+N3Eq8Gl9xp3SvmJ3yq+Uh/e1kSRqrvxCOwozvUTRwkcFIp+chzniMUAgCrf5ThUcfBXxZimv4/xiF/BeYyLeJpxEYvgKhUup11ZnVP4kmjfwMDT9+bPTHZJ89QuLOARAwkdLIAxgPcQi1WUel7TUB2rrmtfxS0FrK5pGYMqdKodlhvL9KZeG0D3YcqpiJIUKRK1+/LvK+0nzlEFU7AvYWnAXsyHG8VL2/vxklA9fA0iefyRBB7DxAp7CkBpm6j8EfAohdGDATxFGGQ05aipTYIGrzyiC3jX+JnweR0HmopWLIV9jOMelkiEkdt1GVlmmZu+mOodLrGH29nmWYb7hm2Sg2KpdwQB4jHFKGa76331T4tpBn1XpPZYMRf70GiCi1VC8bjRCIGDnHi+bYpGLMPbnETjpYlUnvAw7jX34O0TBvCUpTxzjWu9ZBhkJKKx1WcrWITiAGZUdL1r+Hyd/Od24BtuxmWeEokmTfZU9tDsaVp05u0YP+gQztHJo/jN+abpyr1YpdozwH/EanoXsGf5ffj8uh0DCwIZfXjxgxyRyBvUe4vhdQxfTUDbtjC9U3RWn6mFjygf0mtFqtp4tErZgwo25+7M/+/k1x0jP4rkiOIB3k5lGYsaDeFAUUBlHpv7VZyh65Td+h4MBPVgtmJbfm/vyu/RLMa3egV7Nhr34hiP5ec8l7/3OvA8xrWCIrhS9FHZmp78tYxHrlYoNg6W81XHF7MugdW1yzVFrOpQqVToqfc4ILgLf4ijOFKvYFNKA5t89UA7mAJP5q8v45PpLqy9QuxtM4Arl0CODIkm3wiKZHj0f+R66Pcc5rl0VxypYmkENx7y8JWekCGYxozFAu4VqYfKQYq8LCmwiO0n8NSg7o9IyB24UlFmlKd4ipdW+1OUsh7SoEEikZHxpf4vcXfj7qKHLYAu3WmG/yNxO1bgSR8FPuQVS0cVHRLYFodJEVnp0kz+/gDFZqSRCBzJvDqnWNgRI7zyYnVdOscViutoNvJjCjgpxScCrHgnMcUovlQUXYfuwXC4V9+LV001uaNkUyzzlKBSr/C20bdx7Ngx0hMJHsLmXUWtBEaaGHDYiVd6LgNvxqr0jgH/73zbIxigUfR9hGLUUynADp41kHMgXVNGoDffnxzNSvieHAKNl6hLAgVyAOREKAshAFbBokx78N6B4oJFR0TnJvqIwKYyCSqM6s9fK3iFoXi1sncKMoiPfBBP21fy7x/BbekerPv5HBa7HMFBYxVfJkd2djCcd0bxGnrxiLJS+B2cnhJBm6LPytooyrxOsqWA1bVErLJqxsnKSXaz29ostLHoTA82QS7ghLwmBrzmsNDjPvzhLWNg6otYWfUUho6P4YRAhWbFSenFJ9uYd18LRHXCZzIuCgFPht/qy6N2HTIe41gUbgxH+lJilbQ+nx9vPFx/TPEoOiUjK3AW0yArXLzqObgHcRXSzn9K2QCpQNabFcnnAh4ROIODA4F7RZ303RilEjjXPlTuHHVmDtMzHU+A6Aymy4N4e4O4jQxRfv6ract47gJvkecigCVg1F3HIv2dw3U4erjxvcgbFJgT4NM16zp1/f35dx/F4jcxtRqkkv/cTnLLl3lKmK4cgso7Ktz32H0cHTtqTvU4BjQG8GVTYvRTUSTpicDEz2DP7t/goGMEbyugubAHTwMKXChiL+cCfEzswjMcmscVRdV4msOXnpHOirMYI7sz+MLN0stBvEq9gqfCLle3VcEzCbJPsgnD+TVNYTZlGrcpiljV8vuq6j6BQlVMyuZszz/rx2zU72COxpvy7Ubwat0GXhCwOz/PCK70/2h+jhfwzEkbs9NzeI9IBRkErDp4ynGdpARWa0muiP21flItmR8lD0efJ1yZd+efj+fb9OKexUkMVD2FGY8mNriPYP6bJv0evCOswrTxFQ1bTM3FASlS4ss4wV7ej4yeJn4wEHgiP8e7MY9NaYspLPT6XdwINPEoWgUPm8b9xtRNA6/oAo86ROMTuTlXkPVeKLMUl07q0OppFdNj0rtY/RmfcezFA8VnH8nqEcRo8hXgSNikdw7XE4GinZgeqrJKkShFYzvhGPodJ1pFSaV3MjhKy8jgdE8L4pQpldeHl27rWrtbOAiARr6jjKHAZuxlVcOoBd/Bxr287duYxH65ZZ6yLDu1ocs86Z6OA98PvA12De7iXdveRW245q079Fw1r0aDK/6RnFDNaw3gnRhnaAHnHA1g+xUVQ0VMatcBxflOgElAW7G7BTz6tIRHeAQS9X2dk0DMEr5EktJyGlN92N0dw6O+Oq50s/v+SeRsREde2ZTzWExR920Jr7zVnK4xp4yEgGFG0TbGCvaD+PI1crb7cXBWw9KIu/JzXMsU1DC7+pVw/3QdhHsl4Ky/FSXsp7hCyA3IlgJWV50KrMJpTtOpdBipjRjiPYrnlefwFNZh/AHGpmSqyHgWWyNQ08kgBlLEd1JZudKGQxS7kUdiu4yUcuoa0ArVTuCptz68P4hSKeBpuklskExh09kE5iUM5vufwsPJ47hnFUPIMhrREHdHPCIvR2XHMlhVnK9yFTK1Sv4pZb3ldOU0J+onvNJOAETGJUapCH8rtaFn392qQQZPeiJOQ9Tp2fwlQDOH6eEhXN9jywYZF1XlRT6f9FPH6VBcj1CTviROCTGFKR7JIh7V0LFiakfH6oR9RQAWDVj39DMAvAdb+EhRq9sUWN3SZZ4q2Pz0JmwB+0PQe6CXnx79ae4fup+Ukje/jBHLWHCg+U4Oazt8rueuyr1hPII6gDsR4IuWQzHrIP6TsgqKfArwZ+F9Rf2jTitlnnAgptTWBZy0Dp6G241TNnRucXyvZQ7j3C2HX4UbL+PVd+BzgGyezk9ASDzFOO/XMbvTi4G+VzHnfRBfIk5VveJq1fLPH8FbNTTxNG60Of0Y+HoRH1OyXYpoywmLnLfdWOr3v4bruwHZUsDqaiNWWcp4Lj3HwfpBU4zDmKLOYgryEvbgHsQeZC/eSFBEu3kMTJ3EvPF5TAkO4I0IwdsoKP2n0KmMmaJUMiR6qVfJObx/SAXLXT+CgSR5UMqbC8xIuWawgXIcI2qeochw0OCK++me+Ntd28rQyJDqfCOvJRJ+F7lq2ayd2G9nWWSRNm3mKnO8q/9dblT0rPSKXq6MTSyiADcA7bAPif6Wt9qdyojR2GV8EdsOpusDOFCKKRZ58jJC0r1K2Dbys3RdUbKuv2XYenDuV3R2otevbTWuZOwkimzpmPE+LGBOy7uwxcnFA7k9A7Nv41Ys81TFAPiTWLTiIKR7En935O/yM9M/Q32u7gvBC+BPYM9NKaHu6IXmcD1HOQIH8aiYAFIL7xcl0XhprPG3xkasyMu6Xm288bKitNJxgTyNHaXjZnG9GcKc6l7MPuzDgwICgd2WX9/VnL0Qtp/F7MJ5iuNewEfnolS3rlO8sciLamO2agEDVC/k+xrNt9F19+XnDh4d7GA2qoE3FJVDo3EIBpKexW2NAGxMswpA67lMYPqzCyPT3+AY3FLACiyddFkDnaBdbTNRm+CtvW+1Gz+JExwH8b4538YU7gimhKP5dlOYcn4ZC/VfwHvYPIkBGoVC+/J9Cs1r8Ojht/EQ9RweMTuPTVPnMMW+C+sVtR0fjDV8AEeAJVCzDQsXP4BRTf8MA1ixdF3l8QptR/JvJWyjCEc0xuJ7yZOSByejqxYUV+mlx3UeS1kfOc1pppjiqfQUe/r3+LMQyI960xv+j0YgRmug2F+nji/vAQ64Y1oYiik6ga9lTPcm8BJtbbcYtlGKTS8oAhpFlCPAiiLjp2vQuUbPWMaoikcRIqiKqfYIPDW5dx9L92kKG7vn8utUZOI2k1uyzFMV6yD+XrxJcy+MLIzw1+p/jUZ/w1rlaD6dwuduRT2lv9KjxbCN0lziJs3i87Y4tJMU+wRKYoRGxUixuEP6EqPAMSq1gvOcZBPm8bE4gxOwZU8ih6+Wn1s1/188qMjViucbo8eTeFpR9yGSvDVHbMv/V6+tRtiXKuwUcJAzr2iugg8dvHu7AOMiZjf2Y+NC4OfpfN/b8fVzZ7B5QXZJEbQKZnfHccdIVfzxmrTvTr79USzrc4NU3i0FrKaZpk378uXLFViqLHFX9S5qlZqh/V6MIzWOeS0D2ECWxyFFEek1YX03nsNZAwNYhEtATQNESDzDlyaIhkWe1TyeIz6T73sx//4bMa9Nl6WJPvJS9H7kj8QI02EsyrUXW7dsOv+OeFWRm0XX9/P7VvBKZPzkHQqgaQJSSFjRrKuQMmK1/rLEEiOMsFJZodZTc9Cs3lIyIiK0SsfkAca0gkCFPN5BiuBJhkSecPQoZYCUVpCuS+/krEinBT40UWryjilLGVTpnlIia4lUS9egFGYTN1xrVefGKF4cDzEyG/U7kuwbmCGbwqLME5gzdvtGrW6eKDr/Q1h0ZgemE3ugf6ifXWkXqZWK/KmY4gNPIevzSGzujrjEKM/XMc6VgEgTmzu7o6ERXOmzmEbWHKnobaRWSOd78fRzEwdTygRMh9+zGNgZyredDvdFdkn3QJXgApkSpeXFM1uhOB5kV3ZjY1UZDo2/OOaaOFAboegwiG8lThY4LUTFIfP5cZQanM+vbx9OrFfULraPkO2U3dRnHcjqGVSx9LDAseaTKcyONvBgwHXKlgJWpznNCiuXB1ZVmEgTHOo5RBpNhmDvw3kae3FEvBMn6MnjmcMQ7xewkKLI7Dtwgh75Pobyzy7gSF7Kpf9lpGQsJrEo2AKmrG/HlE+DUqFYGYAKbiBEqoxRJxF/wSJuj+WffzF/fxseUYvl7N3eOWG/AoYK6yoUroCTBuc5fOCWckukQoVllrm/dj/3Dd53MagQuTRWUQksxHQhONgQAVhclGl8UlYUUyBqGSepCoz14J38FdWdwInk0r9e3BMVUAEfNzKi8/kxR1k7YiWRHsZUhzx0ATYZPXA+TEZxvMVobjehv473exNhXZXAT2Kpkds0anVTpQ94H9ZcU2naEWAIKisVanM1f/aKMCr6o2erOTsSymOKOeEra8S56jyWanoDXhWnSNFaqeY4TqRjykSoqlBRHjkYSpdrDlVhQwUHFBEcXcg/vwuzUdM4x0lViQJpol/EtLV0Nt4T3QOZS425MbzBp+ZypdwVDQOvrJVd7MXtmmyUuGq6h0N41b0q78dwDuYI3ttRz2qK1SavJIx+s4yl9fTMdR2DkLUzK0qLETQVWim6XQKrq5cznKF1hQ5gWTXjRDrBkz1P2oM6hJNZa9gEfxcWjpzGe4SAPZQlbGHVl7AH1oc9tAfCdooCDeJRKvCUhiZrKZeU9yQWCdOAfBPe5C6CmyZFICWCnwauBo0AUPS8h7EJYxpLdSpqEVM/4JNTJDjr/WhsI/+kn2Ka5ULYXym3RE5zmgoVGpUGtWbNJyDpjdLIquCJ0cuYxhAYUbR0ApsQY0WedGUO9/Qr+FJQL2P60Jt//zzecHEhHEOVpgJ/dTyapnSiKqsUfZjB+9usJVGHwcdIjEhHoyFDRPifcI2xulJpEW0TqxH78OriYazy6QJl1OpyUsGi//fiTSz78M7eM/hacXF+kxMZQXI7/I68qYRzeZSak35XMef5GA6MZIgF9rvBlfQJXD8iH1EOiYCA9ifAF89BBUixIrYPy6gcxcGROL9KhYED+0jej9Hnbr3T+Nd9V9pOqbw4rytSpTEggr74j3H8Kcqs56BWP5prJnFi/grexkJOfivsR857lm//dcx2j+XbKOVegdRKpIVUjFoqIhjJ7hEEX4dsKWA1xtjlo1UJFioLnK2cpdpXNbS8hCnsAPa/0Ln6i0xQrDJ5BuMqKXVA/n1xs5SKG8QJrK3wfXlPAll6uC/gC1vWsdTBXool7AIwAlQxBSjFF99FAzRyS8j3M4JFrl7CWjLouhWpizn67hRhfh9XOVwiHKoMWcdbye/dVfKrStkYWWKJRKKRGj6Jy5OU3igaJHAu3YEiWVVk1n4MmM/lf/fgHqe+O43pr/Y9jgErEUqXMf3YTpFrqCpaRRfiOAOf0WJ0VmmTGTy12Z3603lFT10TuPg4moAFkmQ8wCdqjeEYtQIfo4oqa+wJHKotyn2Y87Qc9llKURpYZbVSeTLI03iaS4BC85OepebAaIz13GPVKbhToLk1clfB9GkXnipWijtWQoNXb8dU5ALew1CpSIE5peDmw75WwvvdAOs1bJyM4073QTxNpjS4zjsWZChKpfEcz1Fp0GrYVk68Il2D+FhU1EqOiLZPYd8ruD1U9C/ybMVhFA1AEcZBvGJe+5ez1YPbmeP5e6MUx1ssPhHNQDZ3IRyvgVMYbmD8XRFYpZR6gD/GfcRfy7LsH6aUDgOfwR7pV4CfzLJsOaXUxBbjfBwLoH44y7KXrv8U10/q1K9IXF9KS+yr7bPJ+z4s3acJuQ9TWClNGyc0glUK/gamzGP4MghHsYcpxRPCF0kyDrZZimXjr+MkdSn7fiySFsm5MlCRsC4wJE9eiqVJRgBIhkSAq45NGHdhfKtn8nPdj6diZEzh4miVvKDe/P4p56/qFpH0F8J3S7klUqPGBBMsdhaLE0mMRGqClP7KWKmCtU0RrIxg+nUW05cBHDgI6JzDuxglzBNu4ksdVTEvUwYpEn5n8Sab0mHxr+JLnylKu4B5wirwiOmhaLAEiCKhOaZHwAFRm6LX2+naLgIsVU/pmnU9inAs5PdhEMrOIpeRfoxaoZ5/eoZTFA2nIjACDd1ReiiCgW5nUfOynMLIN014b7PIU1KkSGlp8HldBlwprNex5x0jZlMU5+r5sE+9r4q2CYzQ/TzwV/AqWoHLAYqraUjn5EAR9hd1PoVrFrDTuJczA06PWQjfF8jR+0rDZWH/C3imJfLZYiRP24kDVcds6nw4hvYrx+QMTr2RfRW/Us9Z93gSH7OKbErGsUDGRgKr/LDvyrJsNm8A999SSv8F+HvAP82y7DMppX8JfBxbSPPjwIUsy+5OKf048PPAh6//FNdPHubhi1YrL0gFWqnFvvo+UpacB6JUhQbxPD4ZL2LA4TWsi/LrWIi6B4v4jGEPVgqiaEAEUQuYoTmPN5+bwVJxZ/AHnPLPHsTTMvLMNXGDV4Jsy89ZCh4BW42Lw9vhPtCHVRl+PT+XF/LrPpJfr4xC1vV3jIAJ8Mnz0TGruJdXAqtbKqOMMsQQPe0eKnMVdxhilU0kmmuCihEYGS7poADELKbX4uldwKNR53GPvIJXIIpX0V0tNYeB/XEMGA1iY2OC4hgQ4ThOyErBqeKrifP9YuRIkS8ZJ31HY13pGt0j6W8sq5ejos9ipCOOi3i/5Ki1sHE7yo20yryzJeHzT6w8U9RDnJnIh9M81IPrMRTBtQCG5jBFZObxqKuAhMBVjETJIdVxpUuqHIxcKVWkXaAYIZKOzeIk7irFNWdXMIflOTzdfpQiCJIoxab2PAKDcm4EaqBYmCG7ovsr0K97KXpLN+jqvt96RWCY8nv6Km6bdE8iABaAUxTwNF6FGDNEGkvz2JyisSzieg9uxwXIRnHnLj4/zR8j+Dx1nfbpisAqL4udzf/Vrcqw7is/kb//aeAfYcDqA/nfAL8G/POUUsr3c0tlkUUu124hq2a8yqsc7Ttq3KkRPH+tNNYMXo4aQct/w8jqD2Bh6q9jCnAMV3Ap3DTeQ+oUXh03jleXRD6A7lzCe2pFY6f9ylOo4qQ/TRAyMHHykVGLZHRNOhUs2rQHI2oqfdN9PqzxnpRU+xeYWwnvRUJkKbdUatS40LnAhQsXuKt6lwMD8IqZ2HZBkVHpiyZUjQWljMGMRz82VmZx0DaDGQZ52eT7ncu/k+GVRx3MuIxik+teDFhtA76JgynxqqCYsgOPQiiyEcm8MiICOAKLAlUyoNJj6azIr/qexl+Memgs6H5FfY+RkZiqUnShlLUlw/XmdVzvoFhsoEiNIvcCA3IMql3bK5KkKFVMAw7jDrWqWOUIqGpNz1fkd6XizuXfnQ/7l3OxgEdpBFSkxwIzAmIzeEVgD6b/5/DKvxhVBi/gUOozgk6BOUV8YvajG3DGyF+DIggEtx9R3xVhjsGEuP+p/PojqBSpPnXtR2Dzq1gW6TC+GoMKVc7igLaJp/+r4beKCxToqOXnMUWxkrgf78J+nVGrq+JYpZSqWLrvbuBfYK29JrMs0/R7ApvuICyumWVZK6U0hUGBia59foLrWVzzBuSKDUIrcJKTZlxGKS6oqUGWMED0GpYWnAO+hqXr3oZFk6bybXZTBCpS0Dnsbj6HV3b04WR08Y9mKE7EPVj6JCpsnOx1LCHvU/ikP4T3FIrXI+MTc8rytPsxb+i7uAeuCUCcrRit0kCNaUVpiCYwnaO8x1JuqVzgAhUqTHemWVxY9BlBKQtNqDEiqUo8GSlNqjF6IF1bwnR5T/6dSTx1dyp/X+NCBmQSGwc78LJxkdL7cS+/B0uJK6or50HuX5zwI1iM/Iw4bsQHkdGQTuseaN/g4yAaEW0vA6nIWRyjApYySpHUr+0jZ6yUoihjkOFLIQkoCFzHKmilCwfxQhzpeIwiSicERuSQ1vC5SvsRQXwEn0+jAVa0VpFWpfNa+f4G8Pn5z3GQIPCxgOt8hqeH+/CsyQjmgAzn+57FiddViq17pJsa06P593VOIqfL8YkVfjELofeUttP90XyvuUCpPShGuuX8ywFprfGSI6Pn0cmv5XnMzo4D/z3GMe7Nj3caA1bgRTdq4yNSeiTUy6mKUTJtK/7zEDdUXHVVwCrLsjbwaEppBPg/sDjMDck1L665DlK/ihnrB/gB6pW6gZpevBR0Mv//DAYjV7AbfwoDUu/MXxnGs2pjhkGEPR36AkZOfZrisjbjWITpHD6A+vGBm/L9badIqpQiS3FjHj3yRYTaFZoVP0aDTsoewVANS7+I8xEJwTIWhGMqRAuuyDJoOkcNUk1wMQJQyk2XB3iAKlWOtI/w/MTzPvlEYBE90ejpx8gUeCRhCJvoZjEDMYmnU/S8M0yntuPEcnmPfZhX2ofpzilMVxQx7cuPp9S4IrjS/0hWnaFYCBIjQ/KUZZSjPmuMCVjFiVnva/s4fuRw6D19Xunab/TKJRqLDUqn43KitM+u/P84hwhc9WCAZQTTjzFMbyKZOkaZolG/gPP7lOJT5WnK9zmPR1j17MHnO4GYCNKrFLlOK7gt0D56Mef5IJYxGA3nrX1o3tT5HacYrb2AR3/EC1PEdSC8VvAUoaLCcsRjtEiAI0a7BDwjaNI2cqjAx0MPDmZi+wPtP6YyY7RqBgtCdDDO7xngV/Jj7Mv/1zn3hf0oAhXvl15yDFXV2My/u4TbyOFw365DrgpYSbIsm0wpfR54CzCSUqrlUat9OCvgNUw1TqSUavkpnru+01tf6aPv0lGr/KafSWc40DpgA+Y4vmL4duyB92Ih2Gk82vQmDFQNY60WXsC5UgrBZpgyfAdLXwhUiYx+X34eF/AIkhRNyrAPByTVsF296z0N4Ohha8Dr+xqoscoiGgvJGBYV+GbX/uLgi96Nzrfd9RK4VFi4iXfVLuWWiQo6GisNlk8vs3xmmcZYo9hiQABLE5g83OjNgk9kvZjRW8BSNSvYBLgXm8DO44ZBROMz+ftgcfHxfN8v4ZVS5zCnZgkzDD0YaJvHjJ3GgQyXnBbpoIyZ9FhAT0Aycm/ADYlSftpPJKhrBo1AKW6n98XXELdFE77GbIwIdnNlSinKItaw+a/ijqKMN3hl6k5MD3dT7LzfPcfpvitKorRzbHUgZ1VO8Gv5cc7jkVLNpbF6NEbsBeTIP9+GAagVLOMxiIUsDuCRtl6cJ6RISwUDHPX8usQbvIBXzM7glbwaB7JJ4oIpQicQ0p1+i0R1XVM1/M4oAphIrtf2utfx3GPUKhabzGLzgK5B47WG9SvbheXCnsHCOw3s2d6Hzzs6p1gkovSlnkN//vccF4/HZr6fu/JjzeMO0jXIFYFVSmkcWMlBVS/wAxgh/fPAB7HKwJ+iuLjmT2FBzg8Cf7AZ+FVwhVRggnZqs1BdKHJJRE5fwThUO7CBdQTnXIkM28Y6J7+ODRAptQDFJAasZvGHNYSR3cfxUvNpzKBc8HNbXVxSwCmGYLs97ehJa1KQcYxpRHnSlbBtfE9crQOYMsdoQNyvto/ckhip0u/ouTewAVR65rdUenJrlDqJ7QvbOfu1s+z5wB7SdCr2WNNkqQguFMFIFD3fPVi06Qw+6auIIUbGNBn3YODrQL6NUuU6/klsbO3K9z2Gc2xm8PUFZUBjuiGmv6thG51vHDPL+EoHK+FzfaZZM6b1YupRqVPtW1VO0fmIAE1jox0+2xQz5iaVNhbFeAcW2dSzVSRTUdNxDLwoAig9iGnj+BLBeRivSAN3QhURGcy3UzRU86LGSLejIX1RlkCgRnNhM7+OWHCkMaQIjCKZA/lx6frsAk4KXwnHUjSoJ3+/F5+TZ/EGnprLwdOtShMqlVbDMxZKCWp8RWAWo3R6NhHsVMM+9NwSFsQYw+kpcr5245Xlh/Nz/mq+3SP4OrzgYCw6fXHMCWzKuZItVOSqBxv3I/m9PsfGAKv8sj6d86wqwK9mWfafU0rfBj6TUvp/YtnPf51v/6+B/29K6QUMz//4tZ/WxshlgVUFZtMsw41hGzgHsStfxCb0USxiNIan+KYxQzCOPbDnsCjXCMX+OyLJPoulSGJo+A2YspzGFe87GIiLVRaj2HmJaBvBTeRaKVIlL0VeQYwcgQ8+nUf3b/DBvD8/vtIpOq6AXCQyd3DFVq59EfcSwInz+zDA1qKUWyQ1aqiYY9/SPn7r2d/i/fe+n/rDdZvo5Pl2V8lIvyKQiZIwfd2LOQlL2HjRd9r42ptgYGkYd1D+Ij92wg1ewibVl3Dj9RoeTZujWLHUHUnQ39oGLiblLmET9RTeSiVyEGWYNVay8L/Gq44nRyZGMRSh6y55j3wWGapS1hYBiU9jUau7Mf0YxNt2KH12Fk/bKZIlB5Z8m/Phb/GdYupPojnsAt5KRM6GiNTiUUVnUsY9Rq/kjGv+VoXsAA6KYrZBRl+gRzrbwoGFSsx03JjBiJFljeEVilVx0kFFq8VB0r1s4tEkRbSgWDggO9Sg6GSoNYXsl46rcSNum1KlOvdWuO+ypYcxOyue51LYjyLGuk6Nz27qCuHvaE+V7RnG7LhoP9coV1MV+A2sXWT3+8exJFj3+4uYum86uWwPqwpUqVqjxBY2cP4s/z2Ol3AOYwr+FAa8duKEwnPYoLsLe0ALeITnFEYCj6HlHVi3L3lHPRjAOkmxxYK2Xcvbju8JYAkYxby/uAL6vzuSpRy9/pYxqGMKdhAjEC7hSxNE7YlKHDlYUnSFlRVqXsLAp9I8pdwSmWGGDh0qVKi2qjw69yjf+INv8Nihx6iMV3zCl7GJYFzAZa1hpcl7BAf7GR6BEogSyKrln30Li/qewMbXMSw6BQ6YWlik6jwexu9QBFaKOsdIhrzVqKcZnq5fxMDfFM5T6U7LRacopgh1zTI43WNBBkvbxP3pu5H7c5mpKiNjgQX6Vi9sC0obo1z8C0xHjgEPYQBdKTTd+yFMj1UMoYIkzUuqMBQImcRTUErJKeV4DgP238mPqXlVz1fOq0CJ5lFxZeWAKn2prMAQHv0SEIIiJ1UpPp1bHW+EeiQcR9t2wrYCS/qt/YtbJmCjiFMsJlnCwM0BbM4Wd0yptEQxIiu7IfAqPrIKM6KzofvawuYKAcd5fAwMUaxK3obRU0a4OEIIxdS/XrqXMTIcOccxS6XI3DaukSzlcp1fuz2lTZtLtltI0Jv10pN6nHgodH0YG6hCyC9iAGg3DjLOY0TEDu51R5DyHbzpnybmezHFnMSVWkoWJ98a3tQwcjIigBKwihN/DIPGktoIcBSa1vdj+Fb7HcAG7vN43yBNToR9QTG9or812cR0ZBubBHvxvi2l3HSZZJIs3PxDC4dYeH2BX/7UL/OX//Jfpv/xfp8Yl/Cme5MYCFGIXsALijoQy7JVLTiNRUBH8319ATNYmqT3Y9Hfr2PjZjueIpG+HsacGoE9TfJLFHkbSmPI+GniVtRAvJopvKpREQEoevsaX4TfijzJOdC23Q5GTE/GtHlM++n9q6gKvGw/vq0ibUwP/wJLDSkKNIDp0DYsirUjf38UB9lqkSA9UUR0CAMRK/n2sQr0PMY1/XPMSd6JA7gqzvESaBM4Wcar1ASuF8P3+jHHdRFzGDQOYiaiHb6j1hE6Tg+uy9KpJj72Il83w62+wI2AldpELIW/tV+N/f35+er+JXz+lg3TNQ7kx1aUtoOvNNKmuMTZYL79XP6dWSwY0cyfQ0zhqRpY4FXv63wUOdSYh2LVYqTD6DtxvOo9VVhGO3qVsqWA1fM8T4vWmtWBWcqoVqq2OKMe1CHMCCzg3lALm4TfRzGq9AqWEB3D+2OAPZCz2EAkbD+AD6ZXcYNwBn/4khquhKpq6X7QMfIUB2QDG/wxv6+UHeEaugm+sQy1F5tEapiBHcPDszIUUUQYluLGSkIZtw6muNvxrvKl3HTZxrZCijxlifsW7mP49DDf+fff4ZHJR6i+r1psr6ACjl48OqBnDu45inAuUD2D6cp8/vefA5/FqqL+MqYLL2O6MYxN4q+Gl0TAXIYvGjLplnRd4yXya+QxK7USJ/64j0r4W1E7OREab9OYMZDHq/EQCbop7FupxsjhkvHtDdd3mYhVIlEtGe4mMTKoKjew+TbSFZQGVMZhCCdT67m2cd6nwLi+t4DNzS/hoOMu4O0UF9LWd+WcL4W/wVPbyoBUwrGUFj+D92aLgEAAUCBrBm+w2a2X4gnGaFUPDlwigT0CK0WjZF+ijr6c379hipGtZthHFr4rDtdMfi5RNG5n8QibxqWA3Uk8uCFHPQYV9NxjyjOOtXr4X9vIRiolrGektL8iiXKQdOwSWF1aznGu4J0XpAJL1SV6Kj1eofAsZkD2YZO48tzHMHAhL3UFSxvOA/fgzclEGHwGm4AldWxQNvHmccNYROgs/lA1ucbwpPLBMZ0nuxjTM6qSEKhqhP0qgiTjIRAlBZKRECdAEbMRvFut3q+FfQgQajDXwkvpTh1fkYAdeIq0lJsu00zToVMw1Kmd2Lu4l10zu0i/lSxC+wTmCDTwtb6UAtfkJS9ZE+UXMWdD1TriWS1ii149gxPhfwcjI8szHcCNpCbTmB45ja+LFoG9DEusVurmunRzxlpdf2u7GBEWOIvHamEk6km8I7yiB5GzIidGhOBZ3NioSkuE6tiSopSrl6gfUKxIU7TlAsbJ6+bYxFdljb/jb82PVawybRrT2xGKURuBF6WiI9jX3DuJ2Zc3YPP+Ap4W19wsfqFA1wxejS7Ao/S69F6Rs5gmiyRzze8CYCvhd+T1Kpqb4eTwNt4BXelDgSrdT93/C/lLrYOa4TOBKnESZbP6sXHxVWzlkTeF/caikViUEkXvxRTsHDafiNur56LfspOipUSu1XXKlgJWb+ANrLkIcz6Qmqnpod8qNlE+hBn/41jJp6oWenAFOY2T1gexaJUm8ynM244EurF822/hA/4VvLQzRnYSxSU7NLihWOWklIiAjLwtRaz0fVWzVHEvSudWDfuNVSXgXt4Fiksh6P7JgMQQNuF8JjEPZJzi4NuG57lLuelSpXpRajxLGTPNGZZ6lhj7njH4UZxvIF3SMKqt7sgBup7lo5jD8DU8eqqy97+CpZX/AONTvROLCJ/D9U6tGbqNZsLG5loTn/QvRlLjezFtLnCvcaTjRrAYgRnhc13zw3jEqhn2HcdOBGbLmEEZothZOxqO2xBUbbo1ZbsjfhFYd79f6fo8gmftJ0b5Iz9JabCYMu4+tv5XhCUafaXG5HDG7wjQKVoawWI8/6zrf+lt9/vxGjvhveiw0PW3nGtlNFpd7+k6xHWMc7uutwNZJVsdUylLF4NgHXMlvAQu4z3Rb42vFL671nXof91PHa97vzFFf4WI8dXIlgJW29l+ycrAVePSwZR4BFuepo5Fknqxu6VKhkW8xPY4lht/CHsgS3gY8iS+OKjytm2MO1LD0h0tfO28iMA1CNTkTcZAoEd/R0MX04UKIRM+i1wuwnkpFKtjSrkFNMUDmMBzz9FDy9Z46Ro0Kb2CAax94Vj9+NJA3d5HKRsuM8wUorhZynix90W+OvJVnnzfk7ZwVYaZPkWkFJEUF6lJsdxZf4toqgl3EBtXkxg/8d1Ymcuv5d9T9EopcaUOh/Pv9uMT+yE8lSfDpqhuveu3okj6fACv/hJHQ1G1WZzjIg83gqLIvariKzTENEU0XDGqLO9cDs4izveKBRxXAFZZ/nPFlSRurixxq9eUjcaw21BW8QXBVTWoOV0pvBbFVKCipz2Ybp7FnGgB7fdgzYeUEla08VKRIEW7FFHalZ/L0xhncBtOi4jpOIHxCPjlPItcrzFQD9uJFiLnVilIRWsU0ZLe6rr0amBBAO33AGbjRvPzUvQMfJk2wnXuz8971u7fLLNUqhX6a/3F5sJKgQ/gUbjHw32UKL2n8xF/GYoOva5XY3+AoqOlOUT3WOlUpXhj0cF1ypYCVpesCoyDr4ZPtjUsHPkY5n3vxquXtG0LI9r2YZGtCdzYrGB5aU3UNdwL34VFb4byY8xwaaSt044DR8rbnQZZCt+JBEPl9MUnmcdTlcorK9cPxTCyIlm6/h6K3kk7bCPPP1ZKxfTliXzfRzDF78MG7wVuG2C16bzzG5Cd7CyMi1PNU0xsn+BHP/Kj1O6tmSHpw9N/ijCO4OnAyOmTCGzLeAlE1/J9tLFnvgv4Ycw5+Q6miy/iRSNHMUA/SHHJGRkSGRlF0lTBpYlVzoy8fk20o/n/k+F7S+E98S+iodGEHPkcMT0v4yyJf0fAFcdVTIPEdNFlZJZZllhijLHLb3gT5ZatKSu90zMQ728c09Ed+d89+CoSAj/SJxnp6OiBzc2iQGSY8/w1rNjiJeB78PlwKHwv8uYWwt+aF0Vm745STWAOReQqRRK2UoUC7Tq22kLENKaApPS+N7y0rRz6+fA98aUUMWrgFJiDmFOsbEcr7EP3Tk55BS9QmYI0kRjMBj3qtYKNQ4EqOTzTeOPTvfgagAoK6H51R5PjcWMEOkYkNfb0DASoFim2Y9H8oft/HRHkLQWsrtR1HSjyKqYw0vZhDH03MFAlA7GEAYWvYgoHxbX4JvJXDD1O4s0QJ7CI1hxrgwqdk1Jv3YNKSqXJOHrH8khUgSFA1Q6vWHYbUyFKT0TglnDSYqyA0u8Ypo2kUZ2XPK0VLHK1iKdZd1Ik929+ufXe+QbISm2FZ/qf4W3veBu1wzVfUX4Ur9qJHDrpo0AF4bdkmmLXZhmxlfyzAbytwT3YRPsIxm8UYJexU68qRax2YuMvw7tKKyIBHnEQX7A7TSg9beIAUNvX8bQ3FNN/Md2nyb3R9XlMjYjM3M0V09jqTmHEaMUa0qHDCCOX3uAWyU1fU1b8pYNYhfX9WFSlH+eWKlKaYQ7cKB5ZiuRpgWpFp+ZxXdUz3YHxobZj+rk9P48+vJ9bt3FXZCYCZ+mc5u0W1joiksFXKAIBASgR1lvh3ATUtuOOhc45RrV68SrehDc4FVgR50jASvdE42+E4qLkiu7GNKMAmziMGvOizmj8af/KeChjA17g0cj3P4VXEJPv90R+LZp7FOWD4hjXmNd9bobtY8FLNexf936WIg3gGmRLAauznEU9ewoiw68BsRuLUh3E0wR6UCJla6I8h03AD1HsTp1haFt9RkTuncbXKZrFDQUU02f6X16wgJd6buhYAkQ6fymalEWDIIY/F8O+9H41fJ7CS55A5F/Fc1aKQxNHBGLRu9D1RF7aMF4Grf3fBnLLvPMNkJgGPN44zs6DO2k+3DTPWdEdORLyXmVIlE6DtbkfCxhZWDrbR3Fx0zqmA6oAehnrWXU3Rgh+GtNV6bsm6l3YGB3Pj7PMxRG0OIHHkL5SmP04BzE2ZIxR4TbmCMkARFAl50bXKuNZCdcmoKbxGzldCa/mik7SVWjEMMNX3ugWyE1dU7aCObPvw7IJ/RjQHqEYmdE8O4CDjqhTVQzKiXKhKM1OPDIvaeAL9MouyB6sxdmLc7ScEZ27nN0WXnmuqE90mDW/CqwM4tws8u0TFkE7SJEmEjm4FYr6Dg46RDURyBGwU8shjRWNW9kMReGgaB907fMUx+0gXtgiPrGi2hprcupj5mUKB8or+Xkcz/f3IMXMjigtehaRriJ7Rti2FbZpUbSTU1wxenwp2VLAaoyxS6cDY9RlG16auhPv2yGwMoNXL7yIDeYh7EFED/48xRyxDMwj+fe/xtqhxnguka8RU2xQNGaVru0jUXIh/1zpjVbX5wo307U/RZjI93Eyvw9T4R5JgVXxJ2AmD0LH6z5HsAltAbt/4pzccqhxdXLTvfMNkkEGSSSySsZ07zQPPvkgaSnZ81N6DZyfobSC4ORaw0kT1WuY0WhhAGoUn5BVsKDxkmFOiibRIxgx/Diut9vw1Q9GwnnM40tQKErVzM9hDofAmjAj2IrpE/0vQLmAL/khUcoo0gVkqGTE4mQth0djUgZREeW1uECbijp17bLha8oqCvWTmGHVvVvCRlRvvrex/Iiaj+XUCTz35d/bQZGwrPlMTrH08yz2rLdjdkHulSKTmkNjhD5mEmJB0ApmRyZxB1wgCRywKIo0j6+ROYinFwXwwFNryojUwiuCCumjCp6i/mvunqOYWs8ozs8RUElnZbfUukGptE5+bYP4GFSKUvsYwiNVihjJmRH/Vvt+Ce9+/wDegDimhbtto/an+SGmBzUnyWYJVAlIXodsKWDVWH2SXRIfSC/mCcccvMhvysuCDYgmNj2o0k2ercqtZygO5B5ssB/Ovy++Vfe5dItCvZG3JOWISh3D0DGXLcVaoEikjDl8bRPD1jIMbQxUvYpFC2RYNJHEiFok7UYCp8CcRIZnAW/+OMVtA6xuqnd+E6Rda5O2J3r39HoHc6Ux9FKhRKxSjRK5DhOYmVzAxtUuTK8mcc9T0a9ZLAL1IjaZfRcH26NY6riOGbO7MEOoyJQAeQR6iixJNOlqcpbhlAGQcVm9Gfh8oLEBHoGKx4iALEaMZVA1phpd+56nmNrXPi/h9212ualrylaxjMJhbP6UcyhSuKIsO7EI6C6KXMBu0VGlE+IdReDfwRpWVjFj3sLmcoGbCDAExKPjqso5vRby47yGOQ8vY+DiWH7OcmAEnJROjikrza8JGyf92DgS4JPN0Xc0X0uPFRmLURmND0WSpce6T+qvpfGmfSvqGqNlcQwogitbkYXPlHatYPODCkkUPXwJA7MD+TN4FQNpFSyyfm+4JgU/dC0672jPwe1jjFTFfl5TmFN4nbzfLQWsznJ27Q90s+v4+maDeI58GVO0GoaSx3AF7GADQiAmhn3FHRFoaWBk3BbWw+f0JU40ehfg+eiYZuue0IXyxc+o44NRIEkh1m4CblS4jKKBXMZA1WmcVLiCL0gqlK8+VRqwOtdIEhSg0/XpHCPJ/jaTDffON1ie4zk6dHi99jrDu4aLEZfIQwIHCUod63mDT1AyTLM4v2oYA0rz+bb6jibHnrCNHJIXMR5VPzbe5nF+TORLdfCQfUzNxDRO9LijQwIXG1sZGo2bCKDi92K6IV6T/tZ9i3wpjc8OazsQev8KHKtNKru5WWvKNoEnMR2TYypHT1GYWWzOmcRG2ig+Z+lZRd6TnrmiFZMU0211WDUfAlTLuD4KVAikC+x3V7XJyVRK60VshYHl/DzPYYDxIAYMpecadwJM0q05PPU5gjn50/nxMrw6No7XPpyHprk+6p7sSwXnDOtaBFDAnQ8VcOj7AktNihW2Kp5StFhzv+6RIm3ieMlGzGOa04MBqxHgR7AZ9izFOUr2TDxOcIdeTo2ikZF3HAsLFjDO26W4z1chWwpYbV9lG3aJHoyqKxYoNjQ7iyFmIWJ5RlJAkexaYZvYuC3DjMgDGOp+Cu9tdaUJNHrYkfyoUKrAjRQjRq5ETl8K20TvJCqkzlOv6fy6Z/Cw7iI2kSlXH7koS9hEEfuy9IfvdXs+eoHX1t0mclO98w2WlfxnrjJHu6/tE6sMkDxB/S2wrklak2aHi6tORf5UtCpWQonH0odPoD14Gu41vBJwFD8vRTiVIngZH6+akKWXarMgsCiDpBSHCLUaUzE1J33sjkZIolesbbrTBjGlL8NVDZ8JqEZHSeP5NnMybuqasv2YDsSoe5xL9Z7mvhmKSy8pZRujHEpDyfHU3CkOksBCDY9kKKUdgbKer5xLAQq9J8N9Hou2HMLSmbHXoMbOLB7ZHMCjXXN4535dm/hLYE5KPz4uFTFdxhdV74T9aazPhPNWBEmRqOgUK3qt+wgOFgVEmhSXZ1sM+9D9it+J0aLo2A1izYmfwQDoCNZX78343PEa5vwLNAnwKTuj56TrEeleehOLYrT9JMXirmuU28ic3bgsXWq1Xw1Qoe4qXl00hlcIiU8h7xjgPszrkIJEr14POYKqeYqLLEfpjlRJ2vnxpdgKoQrQEP4nHF/nEImVuj6Bo0gwV95faZw4wcc0ozhb8oLk2ffiXqIIin0US1kVvdN16Xo1YK8zp32T5eZ55xssI4ywxBLbK9sZHhkukm81aSolKBAtHdCz0uQpwLWCXeU03o18Fh8PYGNhB07a1b6r2Jg7i02Yo3g17nk8GrWERVHP445OnAi7AY8MaQ1f1FXebUxPSLcTHq1WtVh0Wmph3/VwLOlwjCiv4I5NjBRX1vgtrtCmgN2bUPRcanjrBAF6AXQZyxiJWuDi9FV0FvSdRYpzqdLNolIowiFbsBef3yKPpw/PMmhMSBemsXl2DFsSJxZHQBHYaUwtYmOgjUfqprHomoCVnFhFpAReOnhloJyeC7jOK8oW7YOcd4murbtSUs8kktR1zyKQEsgR6NGxo01QJFz3oJ5f4wiWD3gCq/y8H6fnLGG5AIEhAeTorETbpXlqIbymKK5hqOdzncR1KIGViR5CHfOExiiWyfZiD6yKKaRCrxp8GrQxVSCgVcEMyP58+wncOO3HBsSzFEnsa6UX5E0IjGggRKXUdWiQ6hW9phS+owlc6bwzGOiTJyMDIa9/gCJhcxaPaCl1qpc8EIE45fil4Br08lpuI2NyU73zDZYppqhTZ646x/DAcJFwLYOvyVGTvSbRGEUV2FIZ9gVsDG3PvzOHV+mBjbN+PNwu4xEr8+TxKmpwId/mLL5EhZyhyLPS9tHIKt0sEq2uTVVi4jBG8CMDIcMYo64yrNEQaWzGNHd3NDk6Tyl8X85JC6+OKmVtqWA6th2bW5X2033Vs5LjKd2KRQbScdE2YvpXkQ8wPVOkZwrn0Kr4QLYhps7VvmMAX6xe+58N2yi1LRASozfgdkbjbiD//hTWU2syvwdKu2lcCvwI3KmaUKm9iXAs8Vwjl1DAUfeqO4or7mHU8Rhlkh3KwufRHiqbobEl2xYBXqwKFPf5QSz6PZyfh7ZpYtFvAc9lDIyJfiMCvsbgHBY4OI9HyeJYnMP50dcpWwpY7Wb32h/EFJUexBze8VkDroIRC8Up6sE8lm9QnDBlKGr570G8ykrHGcSK82cxsq7QcRVfIFJGCNw7EZExhe/IuEGRqCtFaq/xmb67lO/7Aj6ha6D05Nc7nL83gymkIniaUE5jA13RKXlJmuAUetbAlYGJBlnlt6XcVJlnnjp1ltJSMb3VPTnqmUrvBIblJEQO3xSm13vx1Enko/TiPYD0zGewSW4M19nB/DvizWhyjuBLxqyfYlRU5ymvv4Xp5zAX991SWkO8DullPXw/pn3a4RgxrZR17SNGDPR/jGbFbbL8vlzgtiriuOkix0761o8Z0WGKlAXN2d3FMzE9pucXnxP48+rFI0GqEG3g0RQBb0W0FOWRfim6NoqT4dU2YBmvrJatgKK90HEFuuWk7sUA5WmsJcmLWAWtIjPSHaW9hvEWEVU8yqsxEiks0l9FsnSfxMfSeGuH/SmtBu5gyAauhL/BU/4H8n2+joNOOeV6TjE6OYbxx/pxMByzH335/ZzAx2ofF6d72/j8pPNRwAJ8neAbSAPCFgNWAGu2W4hpqAF87S+lMES6HQifKw0wgocRY7pEClXD1zU7i3FCZDQmMb6VokmKYu3EltGZsrc7WYe0lEhnkvcVkvev8DLhnKLnIQXVuUnxF3GSpsqKNUD6MZL9OD4RaHDsxKJaz2OpmnP5Pi/g6Uoogif9H3P03cYrRuxKuWlSo0aFCitphaw3K+qwAJUingJGkjhhCkwIqPdjk/kKNoZkfASIhigav3O4h6mUwhjOi5FhEQFZRk3VRgJW0u+YglmiuJxJnAJidE6Rp6iPMiYypBpT4ONMgC46VtquEvYTU6YxTaIUaRMbV6WTcXmZw+atHdiz7cFBkFJl4rcKJMl4tvLPBCAi6JIeQFEnIn8wRtx7w7ZQjJRGUZRUUTNxY8dx7tRi/v4ozvlZwCOzOneB+ype7TiOO/tyPPS9qItycMWPjUUd0U4IRM7jTTh1TLUr0PH0WUynt8Pnmj90n5SmVBpuEp9DYgqxgY/XBvas9Z6eSRxXCZsvJnF7qGih5iXNN5rLBKpS+K1AwQ2kAWGLAavp1XKJLompwB68ug88xCyyrhC68vu7sQf4PFbJoYd4It9uBxb1aWGAZBo3Er+Lgxp5TwcxFD9v72dknEwn2dvea179SQzMCblrcMiogIdDtV+lGDp4dEoeVAyDg/UPOoxXVWmC16AbyM9R3oDy/RpQMY2pAa2UjQyUyqHH8+0Vmi6B1U2XEUaYYoql9hLZSuYTlaJPquzpwSdKTe4xShvD/hk2ySkKpMle2ypyNIOTcc/jfakW8m224xHa2OYhGkrpvcZsTD2ID9OHGYgB1iaFRz6U/hcFQAZFx57nYhKuvOwY6Yv8ru6IVTt8X/sbye/DM5Rj4UqyhDmk9+Jk74TNtTLODS6OqGou6g3/R8AVo+zx+UqHtb0KJHrx6JmO290XCoqcVs39vZhOCqjIyEufxZXSsWSf4ucNbB69O78Hk3jDTPF4R3HHSBFpXb+AiappY4RXNmMaB5BVfOkejTldf4x+xSitIotKnYs3NRmOoQi4xm8zv5dKccrWzmBzQrR7ynb0YU5/B6PWzGARLHHjJsM5KEIdQZm4dSp2uEHHZksBq77VxZy6JOaFFbWSF1nFHtC3MCU+gBPYK5jS3Q/8CWYc+rHI1Lexu/seLAr1p1gJ52K+v1MUF14FU6Z+Ch5ri5ZxwzSwlzAgMo0DQaUjpLgyBtHQqLx0rXLXCgZy7sp/x1y6JpJucDmGhZ+l3K9T9CIE6sRN08Qxik2A2/Cw7GvhnEq5qTLBBAMMcLx1nMpMhQe2P+CGRuBKExAU2x3EyVnPWw5CHxcTUrWd0hIiHM/lx9GEP4svoTOAjasR3GDGFID4M6o4jOcKPpkOc3FrhW5RhFXjJ0asYtm6rkUgk/Bed6pQ4CqmVKNH38a95z/Di0ZKubR0MPrF2zC9qGM6M4RFcQRiWjhwBddpAWjxa+SIxqiFANUspoOaY/X8dufHm8d7Timaspbo+9GJjylppa7Aq1w1DjVnN7iYnyeQMYvZl73YKiATeKpUYE/6Jz3WtWQ4LysSv2NqkPC/xjc48VuOMxQBaR4gWLVTsTpQ9kkRsNn8/VE84LA93GdxensoOkHNfJtteJbl6zj4i/xGFT0okp1wwCsnKPL1rlO2FLDqp//iN6MSgd1YVWyo2qgHG8Aqx5ZnXc23HcAm7lM46FnBHnQNi16dxB7kKD5Quo8NDlo6wFmYXp7mRV7krnRXMXevQaE0ogxALfwfI1ia7AWmtK/dWARKnoAMSvxe5NdEftYAVhW5BHwR54bIiICXz9by7XdjnsVs/tkL+HqKpdx0OcAB2rSZ68xxfu580eiocV8kdUcDIe9bXr6+qwokcD2XyIBEXqPGgyqZwFPQ8tZHccMVJ+hYiSjPV2RbjVEdQ+e/FriKBkvXIUMc+VgaZ1k4TnTMZDR0z7QdFCNX0Usfxhy3r1EsWS/l0jID/DYOcsaxqMQQdAY6tBttu5fiyGoeihy4Gg7AlCqKEX45sVHnK3YMHsDm+YQ7AJcC7nrmUATcfbhzHkGAIrTKjAi4CWQpqgtuB4YwMPIdbKyM4wBeToUKNBrheN3tPQS8IsiMRSpyZPbg0WONQd1LRfCUNYnnLxsSx73aRCj6NI0DrAa+UPoy5mRtC99RFG0gvHcQi/y+jNm1aPblzMXonJ69Iltz3LBsKWB12UWYoZiPVYWgIki78cHRxFfFPoNNih1sEE5R5IP8fv6+PJ9e7OFlXS9FACax0O6QHafvtT7G2+PFfkIx5RC5G/K0oWhc4jXWsYE2nl+fBq54VNFrj7nxmOaTp1HHlP9BbDB8FUf7uiZNZvX8Hu7AInrfzI9bpgFvqcwyS5s2x7JjLM0vuee2gC+PoUlSqWPplFJ93am0mLIQoI/8upgihKJeEbZpYmNvEHNsFK3S+JJ3HdM2ccKVJ5phhlgcj+6oQtTXeD5yXHQ8GQ0ZZfCxEtOd8dpjBC0aXR1vGON0fBlfGaGUK0sbywpUgO/H7t1R4AwszC8wMTTBtr5tpGoqRp9mKRbO9ODPWVFERaEEPpQdANvXI/k2FZw4vxaois56/D8L2yslFR0Ypd0HKKYxRcru7dq3IjvDOBAZwiM9TZwzJYK4yOvRhsSUnvYfU+qRI/gc3tBXAEW628arJhv5echBqmD2VXZ2Gi8AaOD8LkUAT+AR5558+9ew/l+6D0PhPBRdVsovJqlUTCbAKUA1hwdDXubiTNJ1yJYCVpckrkuUMouAYA4DT/uwB9jGHqy4QX+CrRh3Ch9sGhDn8QZvdZwEr0k1TujKJUsp9tl+ehd7efj8w7ZPKWc85+gBR55VHMSKIGjw9eKpQ6XpIliLHhYU+7AozF7B+Qo14HFsUDyNeyoxCrAD426dA/6Cosclw1TKTZf+/GesM8Yvz/8yb6m9xSf9yJmKfLssfN4dcRW3RYBGBkzpLYGmVthfNEpKEYibUcEdnBhN0nZyIKpcHEGSEYnficUdhONGY6vzUpEK+JiI+4/ba9/dDtNK+DymyhXpmAQ+ixn80sG4Nmlh800b68S+DNwNU+NT/Hbttzkye4TaQM3BtpzJ8/n/Ar9ySDuYnimarnYaAsyRXzSJRd5HKYIu7Vd/K/KlaBQUI74q6uiO7LSwOVIAIXLDxBtUtCnDo2cZTs6XE6v/5QTFQg2dt+6RongDeJR3GQP/U+H82xj9oyfsR1GrmOJTywg5Ojp/vX8OB1q6X4pCnQzHyzAH/mS+f1XtD1McsxkenRyhmEGJZHrZtIX83kknnmNdbNGWAlZrRqziYFDPD3nns3h102nsATaxQdXCCJRfwoDWKVwRJ/GHH5G/BosMgDzfJqYEB3GiXid/7yikb6ViqDOee4xSCRgpXTKMe1RS5Fp4ZeF3pWs/ApZC90pb9IRzFOrXIH4i//9ZipWK+7DQ+Rzmmc9RrLoqjcktkz3ssd+dPexZ2VOsfoucEIEJRV9iSi0aDUWrItCI6ZcIssRv6Mc9SzkCM9i4OojrbiPsR/qoiiqBPOmwAJCqn8Qz0blGblRM8+japvF+bbpGbSMDEaNlMdXebWCjwyOR5/6HeP+vFqVcq7SwyNUJ4HuAOrRqLf7R3n/ESO8IP1n/Seq1epEztwufXxNuXMVtVbQlgv8WZgPuxeZ6RYeUDpOOq1cWFKMisWWPnr0iI9KbyJtS4YRAuJxf8BQ9FIHDDKaH01gwYDu+BqtaJ1Qp6j4UdVMZjYF8f1l+LmNYNGcCJ7crsi1er0CN+Fpy6COVRKnU3fk+d2Jj4AI+RpUaHcn3NYXZjCZmZ0QT0DiOY5f82pthmxYOLmMVqGz8+fy8X8eA2zrYoy0FrNaMWIEPHvE2lM5SGJX875exG/8StnDm17DJ/2W8gzT5d7sJcO3wmbxplQlvw0ObE/lrHO+jFVG/JmoZrgiM5J2PYArYTzEsqko/TfQxchbBHjiYksctku02bNC18WicQuqjGJH/HDYJNfLruhvznASqSs98U0kiUaVKfanu6bPIDxI4EWlUXikUDUJndYeum0qhRd1aoqi7/XhDPwG6DmYs76MYKaiEbeI+9J7GiJwLjYkUPlM6Q+caHYyY2gD3bsUPiQAzAsRIJ2iFv6Fo0JQCWcH61x3Hxs151sVT3pIiCsVnMZD1Hph5fIZ/3PzHvGX8Ldy3/T53LqUPmjNX8FYNkWsj7qr4TvMY5eMQBjjkCMzjBlsRrh4cZAg0C5iLbK73odhyJlaka7y1cPoJ4XNVBm7L961zX8Hm4NexYqvZ/HxVbbsW0JfEaFuGF4YMYqnWYcwGzuHjNVbOg/ecE59rAQc+AxiY2pn//SA2zmVLR/Nj9OGV5xfy17cw530t1KLzXsj3I7vdwZf/0UvzxRL+/F7HikeWWRfZUsBqbi1WWgzR6yGox4byvzGq8grwX/H1iYTgo+ewVmorImoN6kPYauY7KEaRpEgNPNzZH/YRc+NxktiODbJePGetlJ9CujI4kQcDDnY0IHQPdL4J8zLuzt+bxNODTbyfzChwT/57JD+Hb2BgVOHXElRtPulAdabqXjUU9ay7sCHy9xTllZ5EDzwaDRmJFqbPAhl92Bg4RZEnMYrrczyXCJDgYmBXCb/lMIgI3+2QKHIwFI4hQ1jB5oPITdG1xCoyec3dab94nwQIRTeYw1LiUKxcK+X6RM/yOPBvgS/BqXee4vP3fp5jy8dIp5IvUiyuqwpqwB1qle4r+9CH6eGnsfVde3CDPEMxChrTYtqfwI6KIJShSJizeYDiKgLiAUl343zZDPtXmk1RVTkryjAoENCHjSVV04nGkVEEV3FO7uCVuvM4D2kMB3FnMRug7TVmWnjzzRpuQzRGBGwjh62NgasVDLwN4AGFKXyMfguLYO/O99lNQ+hgdkbPQuNMhTjifOm+RmcM1nXFgy0FrC7ZbiGG7mPu9XW8Y/Qr2EP5OqYEx/EOrdpHd2qrG/1r4hZqn8WA2R48CiTvQlEBpSPFh+oGJTI0Y/lL4WmhfRk6GTsNPHCuizxwTU6KKmlyyfJ9P4ZNMtPYQJUn3wnf12S1goPPOdwQlbKppEOHjAwyODh/0Cf1GH2NwCRGOgUaNDlFg0DYRjoqr10ARLNPHzaRnsn/F7cqRhm6OV1Ks+iliJR0HIpRK73AgZfAU4wma9/yyGfwhoV13NjIS1ekWM6UrlHjVKTkZbziaQHjZp7Lr3utcV3K9YlAwZdh+ZvLPLv7WWYen2HwiUHSXcl1bxQH+IrG9mH6pvlSc+ingf8XxQrRSYpOtYy5oqGK6EsfxeUSEK9j4CTqbuTuxajvAMWIlkC45npV/slxka4pnX4gfFeg6xKmcBUkiUQeKyrP44uXj+TnNIvbFnGlFPGr4kudiX+8grdPqWK0kT/Nr/EYHrHqdmIE2E7iwCqCQwUkJvJzjMGB6fz7OndVXIKP9dFL3I/rlC0FrBoXkZRyiWBIKcAF7CGcy/9+Nv/saUxZZykChQim4m8NFk3gfVifkQcxJTwO/DHGD1A/mxY+SCe5GFTFtEMD610yghu/SOrVoI2cmQiGlMqTIi7l1xY97wpGPN8W7pWMlvLUmiDamHI/jXkbGsyl4diUEtfPfHj5YdpLbaq1qhuLaAxi/zbxKKRXNbznlRyUmMrQTKP0Qkz56Xf0FkV2FQiKfBMRgsVd0QQsXe5OCQoUQZGHpeqrvrDveWzMy9NVqqiNTdzxWnRuck40HwzjPdoW8cldDstrWBpQ3ylTgOsvHcgWMr5+/Ot89eWv8o7ffYfRFN6Fzb1KoWk+O4NHNcT5ewn4DeDfYSClhi0f8xg2L5/D53ZFdRYwMCGeVuQZ6lnLUbmAOey78DSi9HcW51opIiXHXPO8xpiCAaJ9qMpuJr+uBpZpWME71q/l/MuZnseDBgKi/TinsR/T8ViMISdckbMVTP+/g4GmVzHwciQ/5oX8Xn0jv8ZD+eeKymmMnst/a96ZwaU7nTmPt0iawSOQLeyZCFhpfhAIlKzjONxSwOqSHKvuUOs03r/kPKb8M5jynMcXe9RkHAdEnChjKkK593uwxprD+XfHMXD1Z9jyvU28V8hZTDFGKAKTGBnYjS+ZUw/vKzKgCisZyniecUBpUJ3FvAKRH/diaZKduDclz1wGVvtuY32pvooPzNJobGrppZdEIssyvr74de6bvI+R0ZGi0e+unFrEe07FtIJeVbzJYeS0KGo1k79ELlXIPqb2oJimjxEpOQXChKquitE2VTfFtLckRt2a+NpyQzhfRxW88ral7/358fpxndc+RdgdwAxCCzdUsZz/2fw7OtduMnEp6yIdOswww9Ptp3li6gn6v9hP+noyIPMAFiHZD9lABmOQepM9p6exOewPsHkwth/4PPBm7FlOYM+uH59DBa4inwtcl+VQKI33DL58WArbK+oSt5dToWKNHhyADWB2qw/Tt2FMt8V3HcFAjSJQ0teYEgcfG2286e42PLIn51vH1PgUQIlVtH+O6bps4ABm52Sv5oC3Y4EG0V3ErQLnLmsMj2CFUDpPSYw09+KFCAt4dFLRSEXdI++zhQcB1km2HLDKyC4GWAqTKk88i3mVr+d/v44vOjzFxakDvSLBtYp7wqo2fBM2mEWKH8z3dQhThq9g3tQCNhhmMKWIhgY8irADXzokls9GAKTrAxtUF3DeVox8LWCgcRIDfoMY2fw5rBKmFraTN6/OxTKax4Ev4BGsMkq16SXTQ8pgb3svzRNN74ofQUxsi6GJSRwjcewExqoUeUNKoWlcLOKVVVW8j0yMHLfyfSgypQk7jrWMYpdtTZaKlMXXWj6VrkcVvHPY+IgEVlX29uN9c9RPKB5X3BkZNhnYCDrb2LxyNt93H8VIRCnrLs/xHGc5yyKL1Dt1GvMN0ovJIk+/y2phUKenQ7VdtWcmmkO3U9iG9gtt0h8mKk9WDLScw9PBck4FsgQSutPN0pUhTBe+hQEMpbw1l2u+FXld4Ex81g5e1LGMOzsau8P5MaewJdcqeEPncziPUc5SLw7+p/L97cU5Wq/jNi6m1WL0ZwGb//8Eu8e1fB9T+WfjuH2rYqt99OevgfzVl5/HKB7EuAt4C17JKdE9maDIkdTcI3qMeMcKKihqrjH6enhG6yBXDaxSSlXM1L6WZdn7U0qHgc9g+PMrwE9mWbacUmoCv4R1NjoHfDjLspfW75SvX7JLWXoBq1lM0Yfw9ctOsnYqay0+lZB5D4asj2LRrlcwD+kA9oCH8TCrJuudWHogwz1Y5eJjxZ4iTf34wpQKbUaPR+elQSaPeyeuXJoIZvPr3Qn8dTw69cPA/4yFa0/lx9OgU9RhCjdIf4oD0BJU3VaSSLQ7bZ6efZo31t7oEzvhd0znVcJ7qniLKWc5FD14o8/ICXkV76h8jmKPNxmHSBwXiKrgEaY49jrhe3pfKcpLAZcYaW7ixqEPG/viYSgiNog3SNV3Y7VXb35ek+F6JLoP48CjmCf/F/l9iNGN2zzCu9nsxBxz/CF/yN/ib7Habkf6kfPz0qRVxa4lGRkdOlSokEikxcTsr80yuGeQtD95Q+joqMboq9J+4Hoi7pS4hc9j9kJpsshNVKRKRr+ev7dA0dkQy0UOzwwOrsTnej4/7v04zeXlcD86mC1YwADMYXydQFWWv4Jd81ncMZrF5n3Zz29jTjZ4cGEHHqRQoOEQxVVM4hiVDVU67wnW5kEJFM3iKUlFrkfx5qQiy0cKzFK+fQ2eee0ZOp31G3zXErH6GSxwOZT///PAP82y7DMppX8JfBz4hfz3hSzL7k4p/Xi+3YfX7YxvQGqXu1x5yN/FOU1CtVBMe0TPXaBHSj6ChTbfgAO0DHgjBljO5fvcgYdlm1iU4CF8LTZVAeoVPd86lgLsodhPSBJTFPKQ+sN+BLbk+TcxT+Yxih7BEPDjwE8D/x5fmVxGcwFP5TyFeSjR4JWy6SXLfxKJSlZhZmbGwZJt4B63QL/IpOJ/yGNXdaBSzlO4jqpQQpVTmoyjh6k0hHT9fL6NIk7SaR1fzoLK3ZWubOOTaRzyEYjpt/6uYkZB3Z0VSVLqT8UlsXqrghs4kdTF7ZBx7HT9XcG86HdgTS2/jIGsKTzNc3vLprMTM/nPTnZe83fbtJliim1sA6CSVeiZ7CH7lxn8HUg7ki8mPoA3yJ3Hn7vshMaKHPWoV1/AQJZOMYIrOTGKlCq13aJY4abxOYhzhXspNqx+DtPdI1jRlMDOVH4MVZDvwnmTmg+G8+99Gws4HM/PV72vevFG0E9gadMl4J2YvZIN+grwX7A06wW82EnXK5vUg/MVZ/B0qSTLz3sq3K/uiNq2cP8EHMEj4Xmx1tnXzrKeUrnyJpBS2ge8D/jF/P+E0QB/Ld/k08CP5n9/IP+f/PN359vfUknhZ00RGFHVhAZLJOgpTKpeGAI9mrx3YBPm92KKpMn2CDaZZth0M4KnN+TBNzGELoMmDyFyVzRJ78Jz6PLK4WLQpOiZPH1VJ6lflzhSBzEvRlOh3zQbfMPA7wD/EPh1bGC9jkesvo4ZiLJs/LaT2dWZBsbaY2QnM7J25vqiFKDSfrF1gEC7+qzpM42XyEUcoMhHFMl0kWKaURGvNmYI/v/tvXmUpVd13v07996ax67qSd2tVmtqhISEJDQZBMgMRmAZxf4IgzHGmISsFTvBK/Zng1e+lS/5kphkJYCycHAYnACxjRmMBYYIyyBmJCEkJJCEpJbULbW61VN1zcOdzvfHPk+dc29XDzV1VXedp1atW3Xve9/3vPee4Tl7P3vvPTQKasdo1C3puTQ/WmrpbXaj03Q/2sEeIi6AQ8Rdb4nG8h9ye8jirCitcmjHJNFdeDSc63A4/wHM8vsMtoE7gI27N2ILURtntDhjta4T00xTO4mfx+OpUWvwashaBTS8v7Xeijvk4OPEdCFa4OvEfGUTRKKtPl4gzsdtNHow7iG6xBsbF+f5GlGcLteWohdlBWsjFo4eIYrcB0M7HsLyRh0M527DyNBF2Lol7eMYjVnRpcsax8jRrnCPI9hYHCOm4dmK9etfwixTA5gFqQPbUPyT0MavEbO6H0nOld6zxzbtB2g0CBxK7iEd5+3EdbYr+azkIdJ4HQ3vewx2TO44PjdYAE51GH8Y+EOMC4N9RcPeey2je7GPkvD4LID3vuqcGwnHH05P6Jx7D/CeBbd8ATjhBydS0kw108lXX2q6+1Bk1DrMqH0lcYdQDq+/AOuAEuHJyqSFyRNNmSJG6TGphbKHWDBZu6FUK5WaoAs05uBJd8QtxBDYZkKVYivwX4F/iw3Ih4hi9k6scz9J3OVnnFHonk3kA+2+naHRIWrUKLWUGjOqy3wuq5SsRul4kJVIu/UWYtHUEtZvPdGiI3IlkgKxX8td8hy24dB1UhccNIaya+wqOqp5dhPJE+nrJupNCtjY2kPMHi3BqxYwBZIM05heIiWf0h1KH5ZuNDSWpYkZxRaSDcAtxBqaqTvzzMKHWYXrRD/99M0KjuaHFlpmrVUN7ao5/LMe/6ce935n/UJuQQVtiGxrQ62ciNpQS58ny8phzHL1Mho9DM2ubfV1kfzO5BiRfQVXOGIOq3Xh/UeIRGUD1se1UZEHRZsludAIxzyFrVVXhraPYuNBBgcFemwNv5uIVrO+cNzR8PybgC8T5452GrVW2sAoGObh0L5u4maqTmNuKlm62micBw4Q1/Lp8F0pHcZPYLA+OKvBXgqclFg5524BDnrvf+ycu2lJrgp47z8GfCxc47RMIydlpKmLL9UopaZbdQLtuivYNHID5k7rIRKux4FziR30MHHKkWtAA0cTs65ZJdaKKibv2UgU5/qm32ryvESOep/y/aTkUQuFI+68W5N7lybgSuCPgX9JXHgOEKNSpsgRgGcwNC6K9SK7Z3aze2w3F7VfFMmUiIME6J0cW9tO1s9WoiC0iE2A3URtSAc2sT5PJP8Qx4I2GnViWY9nMH2iJkaNB7kH68m51GdTLUuqM9TGJo0A9tiS/jy26NRpLE2ic3YS3TdaROSS1BiSK1wEUKkeUrdNSrbK2LywEfjHmIsljXg8Q7Ca14nh2UyWx4eqDzQ/d0LUwD/hqf6PKqV/VcLNOCMZsppoMytyVSValGQN1WahA5uLnwO+h6XfkTBd61HzJlp6P/Un6aF6iONERGwa6+vdmPfkMDaGp5P3jYXnLyR6XFw4/36idWgTMepObkDN/TWMtM0Q8y86omVOmqcq1ud/MRyzPrS7h2jdlvVXUYKeRu1j82ejsSlLtSQwR4iGihFi8FUrZigY4bgau4XiVFyBLwPe6JzbjYkQXwXcBvQ750TMtmFdgvB4LkB4vY+YjWJFoYHi8UzPJWZojoKSHzYdziJXqQvvCsyk309ceCAKwrWr7eH4u2h14lQfNU4kXDViSGoaQi4iVUmObdZkyRTtk+spck9asnFsUhD5kgBd9/4S4J8SQ4u1yKUh7UvbNzNON+pwVfkqxn863hjNpLGgPibSIauVNhsiNJrY9HiExjIvfdhY0S431QMq2ilddJ4j1uIcIbqg9TvFsQtV6jqRKF3tHyFazqYxUnUUs580n0uLoO5H0X6jNM4V2u1rfIlQaQfdTmPId0ty7mlsQdsEvIa4Az+zsGrXiSJFWmiZ1RMuFRwOV3UM3TtkTs0tRG2hghcUzTdGzGWmNUUEP03T0YuR63toDAJKSZXciJ3Ja+qjqdu6A7NSnQOzRjdpqdIUH6PEoKQCtg58FyN492BpEw4T++5MeI+E4tJHiTxtCvfUk/wta11/OGYd0SCxN7RDlir1/VZiuh+9lgajpHIEbaK6iPVHtfHXhkfRx2q7x9Jq1GDOOsKLwEnP5r1/v/d+m/d+ByZl/qb3/u2YNO1N4bB3AreHv78c/ie8/k3v/aozbJePVxRIX4ImYUH+ZS0iwmZiyGhqWRrGdtmpmVav6XwQzZ0QrWPKhzKTHF/ABkcbjfmqRJZkXUgtYboPl7yue5xOzqVOJ3/5M8n9i5QB3Iyli+gi+qklMExDbzPOWLyw/kLue+Y+fI9vzCieRpFCTICYLhKtyS9EvdQIcfIuY/1xkFjWRv0r1RSmGqkiMf2JLEPdNO6sRfB03WkaU4No9yz3SBVbxuUSfyYcq3Ge3o+sR3JhSqeYWqdSHUqqx5JrM/1stJiKuEkkfAB4PZbrTp/hGYLVvE6oukCNGtNML4hceTxjjB3zXodjY2Wj1Sn8GkYVS8T+DjHIYxIbC+M0bko0dypKsBfrj98mWrvsYscSLBH0biKZaCWuASIZg0RdboU4tjTWIFqLZQh4Bgus6AptqhI3MunmQJtzjZkijWRIm65RbANTx1yQW8Jxl2OaraPEDX8l3Mvm8NtB4/yQWoTjl2TQupZGCNaIVjZJYB5lNvXJnIaWRWAxNO2PgH/lnNuFfW2fDM9/EhgMz/8r4H2La+LyoGfWJ3eK0BeaRj+1YwOpj8YdA1jH6CVadurJMal1Sa+JBIkoHSYOoCpR+KfddBopoo4oNq/zacKvJI9aIBX63U4kVAexkNwjyTkl5NeC+EpMkPjK8P7RcNx64m5hacl/xmnEYG2Qu4/ezUx9JuoE1W9EzrXTriXPy/UgMqGUBLLu7idae7TDXU90jWjHDo3ERDqSKrazfSa0qY9IUnqJm4Y6MU2DNI7SM2mT0IL19/7Q1meILhyRs+7QNu1uZeXSeJBkQAuYkM4TGqca96mrUrt4LQKENpSxNCdyJZ35WPF1okCBYvhpa/Dxzg+pHjGFw5kb8LOYRupcYqLZZh2QXHLaOIvIK4pNVp8+zDX9dUx+keruUnKVjrfW8P4BbG5eF94zHV5fH57vI9ZLTF3rvTQKwduwzUsfMbGviKA0xiJoHcS8jOPhOgPhnLLaecwaNxbe20UMkHKYVleCf41TifPlQte96jfVP6dyBHmbFHA2ShTXa374NrObuhNmDFgA5nU27/23gG+Fv5/CUl42HzONqQVWLRak/tckmeYQUWipIg2kQ5G5VwniRD7SXQI0uln0tzrDUWwagpjIrVmwrl2PIlE0QJoF7ymB08Su3USB6Gs/HI7ZRlw8xsM9tIQ2dWGDbQemKXsEM6cOEQWH0BhNkrFq0bwDb6m1cNnQZVR2V2hf194Y/aa8LxKxywWdTsZaKBTUUSNGxz6G9R2IGsX1xMUnFaLr/OpDmpinMOtVKzb2ZJHtxCZNuTxE/CAW1dXiUMIWAWm99hE3RVqoRMxkAdb5NJbTXbMsx6mVSpYx7f51X8XksYVGC3MFI49XYtKC+zkjo2xX2zpxgAOMM866kAipRo0ixXmtA6d07CRGF+vYHT+L9UlH3HTK2imICMiKKVKgOX4cyw94ATbf9iavqQ+S/C3CI7LeEd4j67IIvXS/Q8SUCmDz+mZiKZwNoW3DRPlLhbi2lbHSPz7c7zRxXWxP7kVi/HEi+ZJgfRrr898Mx+xIPo9OorC+DRu3slJNYnMHxLWvTozorxBJ7Ag23kdCe+7E1rtl8qWdHXuiBcLjqVKl5WQ1JTRhpkLbLmxRkBVJpKsFm6y1GxDxgTjZauei5yRslBBWJtGt4bU+ojlVWixZttI26lfX1FyQimkl8JPBTtedIhI0DX4RSHXknxNJmNyUl2ED8W5s5y+NjCMSxowzBgVf4Pry9Tzx5BNc/Yqro+5OGwCZ12VRUVBEXziBXA2ahFMtyT7McpVatCBafmaS90AcNyIjGj9lLDqpTnQ1aOMxTdRfiCDp+U5iVvnD2A75KDFvjnbjIjsK7hA5GiVabtPf1IKs9sotnxIwiO7R1HWYklC55H8R27QoL1jGgrGDHQ0eiqXW08xCWqqPY+PmdcSEmkWiO0vz/DhxLLQTXWv9xKSxpXDsbmxD8QKMtEjYnsI1PULMa6U+rA3vCDHiVdZcaRuHsTm9TFwnUtnJOmJ+qAliNnVZ2yRC1+vSWh0hWmXlGtWGRuTqC5jkZICoAR4mpnWBuNHpIwagCNKlyTI4TtQPj4TP8kdY3sVkXJUpL6n+bk0Tqxo1nuVZLuCCEx+onad2HNJG9BB3IhLrlYhhoxBdcKnvWs+L8Ggh0K5WEXepv1q6D7lHJEbXN5i64BR9JCtVGs0ok61EjmmYu9yJU9jCVSJGDR7GdtPpDlp/rwNeixWTfpIYki6dV14Yzhg4HJtqm/jKc1/h6paro35JUZ8SrmoOSiPuIIq2tVtVpGoR63eHiZoNkW+Z+XW83iPClRIYkud3h783hvNvJmZH1w5XglYRr1FsfD1BjOpLLava+UozKbHuMLEUldqjNuq+RZpSYiWLXfo5yG2hMad7UxqLfZjF6kJi+oWMBaEQfqaYmk25UKe+5FFgDZgC/hojFbdiOp5R7HuUy0/W2HEagz+0tgwS15JJ4nh6GOv352D9o5eTSy90q2mqn9bQJgncU02itGC9xLJLbURCM4gRH0XZSiup9UXiehfONRCOGSdGDeteNWZawnHXYJF6V4Xnhon5p4rEpMIdxChdEULNHanLLw3McuGz+ybHRN320stpTbdwNqNIkXMtMOXE0MRXJBKrdoypF4iusjas02hxgbhYTBELWaZ6EPmA5dYbxyxem8N5uokuCpmMNShFplxyvmbXSSvRSqYFL7VkFZLzpO4dWSP2hfbIelVK3itTtaIar8cG5vPY4DuStHXVhS9kHA9bqlvYtHsTftzj2lxjIkz1Zy0AY8Qkian7ISX3mpgV8bOf6CpP3eEiFrpeKiCX5SfVNSkHlfq3JvD25FjBY/3yKYxYyZoqDYd25HJRSiupSVmWMBE99WcRpLSP61zN2iu9Jkt2atHSJqlKDDN/KeY+bQqkqVPnhMmOM2ZRp06NGlNBSV6jxiEOsZnNy3vhGUyeP41J+YcxIlMlusZktVWwkvJHQfQsKLhCEhOtFU9h2qsBTLqxmbiZL9BoDRbSMdFK9IRoA6wNyWFifKYsadPEvIgiUN3EQBGIchRZl0Wk5L7TuqjzaVxPEYuoX4lFIz6EVS+ZJm5WjhLXV7VVVjdtkIZC+yXHkZVdgVhfJ1ZDSXDcYLYFYk0Rq+aJyOFO7ga0AyMJSt1+MseWiUxdGo70UnKPSbOhyTR1r4Sdu3/O46c9BVeILkd1WA0YWQdSvZYi+2RZkHtDbgp1aEFm5hkao0ikV9EOXOdVeKp23RDdknI/9mBB1v+ALWIbsEVMgvmMVQdFSaVjo73ezs7RnUw8N0H31u6oT9LkpehA7YBFjrQB6aGRKKWaLLm+DxIXElnERojC0p5wzPOYGHg7jRFAao82JiNY/px1NFpvNaE+hy1Eh5I2aLMhnUsayi2XtwTvIlApCZLVSuepJq/rMyE5Z+oWTK1eOoeInrQh1wBfIi4MGQvCAQ7MzvMlSpzDOafnwhVsIR/DUtXIgiOtbR9mFdL/8mxoPtb8KvLfxrGE4RC2+e3EpCPbiWPgRFB/7sb6ms4vN760xFXiZkUel3FiTq4+Ypkz5WRLXXPridYriHNEGpmu8Q82Bs7DrEobMO9HhVgNYYy4cUrlBHJvTtFYrkZBXBXgi9imbg4L8Mky888Xa4pYLRgp05drTZ1NJn/tNg9irgktNFqMUkFv865Xg2cC2Af3cR/Xla+zQZj60tNJW4sVRFHuNFFTsg5bnFJRn0SKImoKxSW5Dy0wcglqR5GKc9MIx34aF6J+zC34t+F+zsV2V1p0MlYVjmf63lzZzOhDo3Sf192oz5D+TgJWWVDVt+S+9kTLTxpN2EkcGxKWanMyTMzQPEbMeVPBhNwS70JMeqhFSGNvV7i2NI7jmM7lMLG2ZWrNTUlVK7HEjiCCJhKkvp9GRKVuSm0gmi1YEBdKWePSc2lsadE5irl7Lg731dCkHHY7H3TQQfusCfI0o4pZYA5j5KqXGPWmOXw9NleLKMgqlHoHNGe3E61WIlfSPT6BzbVdWKTdRmKKBfW9FNqs9yZ/yyvSiZGQw0RN7v5w3BCN1t4urM8OE/PAKSJQ1mCI7jdZoGQFKxC1i5OYhuy/YyL2G8O1RrCxrHVTYngRtJmkXfo80nH8NUymcpwNfoVK1lgtBIsynWsiLiaPskLJiqQ8GWknFpnQZRUhoclTTFqD5Ck7x9P+aa4buy66WBSOrkVLE7B2CSJUcstJ+wWNWaHVFg0gEbMZYkctJeeXlU3HqsOmbhl9Dnr/NOYGvA74RvhcOojWr7MIzrkiViXxOe/9Lc6587Gg60EsM8s7vPdl51wb8GkszeoR4C3e+90r1OwGtNM+pyW3s9rJw489zDmvOwdXcI0JMGUpksYiJQfSV4iMybUnF7osRDLHT2DWpENYnxvEJshHw3vagFdjSXi1KZCVSpsIjb9xzGo1QXTlHSZOpprI9Zr0LqmFoDO8JndGaiGGRrG6Fjwtetr0puNM7vlUX6VzyE0OcWHTvKFzXYUFhqQbsYxTRoECFSoNeYqUKPS0EdQ61p//BPh1TD8nIbX6Sj+2GZaoW2NG3gZ5TaBx7texqTttCnMh/5xoBJCgXK49eSVEfER+HFHWsgnTdPVg43Id5oGA6IobpdG9XUyu0U3jhmOEqIOqJ+eR1UpjrS+c988xXe8OjNQ9jWWkv4ToQVHwzCRRx6Y1UbKbL2Ji9dO4/qwZYgXHugLnjX5sJwmxc2vH24lN7Fpk5EfWAqLjFa4uUaw66G5gH9TqlsSuwUokcbs6n1xrzRqtdqxTDhI7a+pqFDGcSd4PMRUExAHRLOpN3YBp1KEscKlwdxor6PkA0eo2eUqf8JmG92JTpuwo/wn4kPf+s865PwPeDXw0PB713l/knHtrOO4tK9HgZhxvl9Zf7+foyFGqB6q0bGmJfUy/ctdtx/raCMemEejAJnW5p6Ud6sL60FGiXuJBYpLBlIzMYPlmrsRCzruxCV+WLoWOE849ztwWYREqkSmIZKod+wbryWvaCSt3jqYOkaqUXAmpi08WbCF12ze7/jT2dLzmikliYfZMrBYEh2OCiWM21tNM0znLok8Dgvu7/md1/C95Cm8s4EacjQH1AY/1beWDmiK642RVFUSOJC6XTqtJWjJ7nkliGSlZj7VWtWNrxiZiTrjxcL7DwB1Y6exuYnkYiH0yJXwKUuknWsIg6p7SzZbGlsa71jZZmw9gQQBKPebsM+S3sLlgODmXomm1IenANmhfxAjmaZairBlitSRiT02wqUtOi0kNGyTqXOpw2rXqPZq4fXKuYYyNV0xQP84407Vp2ivtjTmo5AKsJP/LitCOdeg+4qQ+RXTbaHGRyyPdkafESGxfz4v8QdxVa2DKdF3DOr/cQRIt7sBcOLJm6bM4C+Cc2wb8MvAfsASIDlOY/Xo45FPA/4sRq1vD32ABxR9xzrnVWJFAcN6xtbyVR3/4KFf85hUxf5PcgSIliootEtMRyGIlItPcf+tYX9XuegdmlfoJkYhvI2osBonkaZhInvpoDMZIdYSpC08RvCJhGq/STkkAm2oZU32GrG8iOKkrUERSVuFmspUSKr03JVjpfJEep9QLm4lJfDPmjRo1BhhoSADpcKeXVKWYhtpXa9SfrFN6Swk34IwApBagDcS0Bdqoiii1EceX+o/c8R3ETU9KyjT+UjmL3q/N9x7MZa50O5qnpzFCdhdWfmYdjVoxfawiSbJspdaqUWIhI2ku1a50LGq8KVhKY1CBU2AWtA8C/xeWsb2WvB+i1e4HmNZ3mFOKqlVesxwVOE8silhpQpT1SZOpdEoiO4pSEIHQxK1fTdIQO38ZY+ZaLICaqzHkh9hS2tJIRNTh0wVKptduYi4eWaVSUiYSp288fV4kKRUnp+3Xfaa7CoUCp2H1MsP6cG/nYcRKFoxF8tpVhg8Df0jM9DIIDHvvNcT3YnJSwuOzAN77qnNuJBx/OD2hc+49wHuWt9mnjotqF/GtPd/iRVMvotBSiDq6dOLVbjol6FViAsJuohtDk6e0Jf3hHDXsE9ocXu8iRiylbulUFK4NStqnZD3WmISYhFQ6EInt5cJuJebkEkmTNTm1CgvpJC2iVaNRT5larTTOhFTwnkoMUneh7qlGLEp7RE/VqFBZOc3QGYgOOphi6pggjZVAgQIttRYqj1QY+i9D9L6ml9JrS7hxF4Mwnsf67ADx+58kSkY8jUXCNacr8EEelJScpNrClGTpPMfTBmqOP4DVDLwitEkbpjS6VprFdJ0bwWz6Exy7oVeQidonr8vjRLedJ7oPhT3YdvVFmGtwQzhuDJPT/AAjcvPQ9ars0VJhzRArWKQrUBMuxF2tCJZM90exBUHakdTkmboN1cEdcZeS7Fhf6l7KP/h/4B3j78BVXGNOKkHWACWSS3fKmqzTkG5oTK2giVw7FIhuGenFJDLWwNGipMWrM7mWNDfSYClqRG5FuUYXgbu4a3EnWCI4524BDnrvf+ycu2mpzuu9/xjwsXCN02LNOtFk0lProW24jWcfepbzrjwvljbSdz2J7QhFmuyE0e2sUGvtNuWacMREhXJ7KHijQHT3yS0hy6yuqb6ekhHt5DVGtXj0Ezcd2lxo7Ggcyxomy5v0irLcanypv8uVr2zs2mi00lg4N91UqT3Novc6jbOwgki0KerFFtg9+ngtqXHGqWOIoZVuQgMcjlbfSv9oP899+TlqP61x3pvPo3BewaxXQ5jLq49YnqYHswSJgCgXVLqeyPqpRKTa9MrSrD4lYbc2CakFVutU6tbWxr2KabcGQ7u0KWmWhGgc7MMIjqIIU7ehNjOaB/RbwojRibq4XJU/wiQEHcS1VPe5gNkzW6wWgONZrPRBnpB0pVqnlPWnuiOPESR10ils56FOCXFCFQMvAJNQH7HeVqCAw3GFv4Lv8B1GRkbon+hv1JCoM/fSKLxN8wtJ4BtvPu6gNfh0L9JXpQuACJQGYGrxkvlZn4EWWelR9D5ZNXqw3Y6usQg8wzOLO8HS4WXAG51zbyB+G7cB/c65UrBabSMawJ/D4iP3OudK2JR55PQ3e35w3rGjuoOnH3ia8649L4pB5bYYJ5Y56iNGBskdmGqbFK0jcqV+J4/MUWI/78GIVR8xoeBMuN4RGrOzi2RpDE4T+7csRrJwdRI3E+rjCqxoJUbXHsXGcp1GQqaxIyLX7GLQIqT7S132qSUgJVppIIqukS5sCn0P01OJ0mzNOomwM06MCSaYYmrJrFVLlUesSJFzq+cyuWuSIx86Qu9VvbT+aiuuM7gHR7CgjgPEYsQDRMIk0bb6iubnVFuofp7qotJNd+qWS+d/rRnajGvDUiNmUFfKIXlp5FZUeh6tB+n6Ka2YxqqI1WQ4zxNY9N6pSEZSHdoicUppl+aBNU2sPH42cdwJfe4y1Y/Nnswgll3EdhjTRCbeirk3pG/SpKzOLHfZMNQqNerUZwuEttLKy3k5RyaO0H+k3xYaLR5p1IUsAT75lUUgNbmmobRzWc3ScFiFsEovkp5HZEmDb5LGa0PjrkgWKrmLzhJXoPf+/cD7AYLF6g+89293zn0eeBMWGfhO4Pbwli+H/38YXv/matFXnWxhvrById/f832uO3gdnT2dMdeU3BOyYkEk3SVijhr1LwnZ5ZoQ6XDhNVl5S0SXgMSvStEgt4X6abrb1cKSjjVFsqpPShMm3UqRGCSShq1LRK+xTHIOQcfqvqXT0qKl82oB08KVWqk0NxSTc0svM5V8RsfJSVShwqM8OveLGbOoU18yK5/HU6FC60kTRZ0aHI4u30XnZCcTP5xg6uEpei7tofi6ovX/w8SyLEex7Zo0hz3Eza02walWT5sKRfHq+ZToQKMERMRMx6QuxHSqkBVsiDj2asnx6VwgXaM21ulYk4WpgpHGz9JAlE7J8LEEyHmsFoG5vpwixZMPEu1wNfnJXD+OdYwpjGUPYIvNAWInrRCjHKwRkbkX7RwttWPZ8uX+ch4uP0x9b53COYVG/Ug6IFIdlTp0Ohg0mUu4m0ZyyL3ZkTwnATvJ+2XZSkXCPnmUtW5vOG4dkbxJ2NtJFECfJQL2OfBHwGedc/8ei4n8ZHj+k8BnnHO7sKnorSvUvjlxIu1JsV7k/Onz2fvDvez81Z1GpCaJmolO7LkeYp0zTZpTxEm1hJExWaxS62admAh3GBtTzxB359rhFjAr1jA29iSklcsu1V9ps6Bxq4jdMSJ5gbhZSa1rGo4aoyJKleS1SvK6XN4aDyJ+Ok6WZGi0XKV6yXSD00zG1jEnWmjhhbxw7hczZlGhQn2JJh2Hm90AN0PXWEgaB4eju95NfbiOu9fZevIGLN3GJLZx17iTe1D5r/qJ/bSSPKbSC5+8ptclHNdakH5EskBB43qSem10Xulq0zWohI1puedllZLMZIJIzjxmof4rTI+VcJw69WVJi9FM2I73nS4Ua4ZYzWWxOtEgOQaDRPdA6nKYwXbxj2FZitKEaKkVKTW9pmLeseScyY6gjTYmahOM7Bth3fi6KBZMJ2WIiw40mnTTY7SwSRcCUSfSSaNbpJ68JrGv3J3Kw6V7c9iOald4rpcomtQ1+zFfuxYiWRnOEnjvvwV8K/z9FJbBq/mYaeAfn9aGnSJGGT0hsXI4rqtcx1/95K+44HUXUOooRdec3HsjNNafbCVOop5YnFzkKg1ykCtDuiywnfm+cPwVGJmSBWqCmLFaO91uYr8t0zhWNOZ0bkd0JaZRgb3EhUAblVaiZlCkSi5AWbSUZ04W5NRioD4/RezzOndqZYDGDUwa4dRKzE83x3ez0mLsMwHyRiy3eL1MeX5ryhwoUJhNdlv/yzoz983Q/oZ23NYgbt+PrUOHsbk1jZxVss40eErjc5ToYdAaVKNxfYK4EVd/TCUwQmrcSbW/qZ63g7iRV19XgJZSOYjcbcFSOvwdx+SaWq6ajlWqlCjNEqxJJpfUrb5miNWikJpCtfucJPqRDxIz1GpHrkWnhu0wtHOWq0Edba4wameT5lVcxfePfp/XPf463KCLAyW1HImkydUhc7AWjFRYK9OsNCUaXNBI/ETWUjemBll6/mcw69yl2KCewAZwS3LeDcRw8Q6iKD5jVaCDjpMuNp21TlomWvjJ3T/hmldeE4nVJPbdjmF9WeRKO2KI33cvsb+KEKWuA+2kpbMaxfrWc8R8PWBjb4BY9iUl+9I2phoqvUdZnyH2XwVy9GALUzcxECPVFmpMpIlutYlQJK7Oq+s1u8dTQa3Or+dKyfNapHxoj8cinTIWjGmmOchBqlSXXEuTYkkjNYPls/5wnfGnxylfVab/9f0U+4s23kYx2/chrJ+sJ244+oiW3jQBqFzfqVg89Wpoc6KKG2lbmo9zNBoEtDakmir1Zbn/FVUvrWUJk8v8HWatWmRw03zQQgsezwQTy6JTXDPEalG7O02m6e5zLPw+j+XWUARUaknqo1EcCI0LygTHJs5MOmo33Vxbv5Znfv4M28/ZjtvhGgmeFqFU/5HumOU+VH6ftLNrcCjyTzqPdKCkUUxyf8rdMRrOfUP4bEaJRFJkDGzBOgcLoZVAvnkHlLFiKFE66bhw3vHa8mv5+L0f58qXX0mptRTr6E2G3yPYd76OGBouEaw2BN3E4q/NmoyUxEhkPon1G4jV7rUuKl2C9FI9RG1Wuki45H+NPYiERjmuemlMRQLRKidXutwZqaVK96j3pa6VKjEzdmpprifPpYEkSkdRDvc5iM0xh8njZZEoUmzIZXU64PFMM00rrQuyvBQo0FXvojZe4+gPjnLvQ/fSe1Uvl77iUvo39lvEuITkQ0SXtKJgZTXS+FLf1Jxeb/pNXdY+Of54G+F0DGuN1PPjxPqCaZogvS739p8C36ExmvY0opXWZXE1ZmJ1KqgSfdtHsUnxCOaueAojV5cRF4S0g7jkNxXqlWksa6DOD7PExjnHgB+ga7rLZM8lLLYsFepqcUl3EOm1FWGkdskFo0ldk7iQtkG+cUUaamBUMJPzADEUHqJORsJdXWOAKF5UjqC8UKxazCUY3VzdzODhQe6/936ue+l15pKYxCZwJYRNSY/cyjrFDNFlJuuPNiKp+0ETtI6dwZLnTmF18wawflYjFoBVSPkg0fWghUNRs9JhaRxqo9QZ2iGC5JO/5f4T6ZH7P4141P2li5DGxCixLpzOnUYLQqPFWf9LkziAOZnV9owFYYaZFUtRUQg/i0GRIufWzmXzyGae/s7T3HnvnXSf2821L7mWdS9aR3FdEVd21k+GifO9xqQun3oom/tt6hpPg6xIHlMrl0hVmrpBbnMdI2ODouLbiYmkv4OF9Cjf1ArA4ZbNgrlmiBUsIrJAglTpocA68VNEk+YgjZma06zkaTi1JtUyRsia9Ua+8W/nHO31diN03wVuwiJD5DrRrlmDKT1HKfk/vY5cfFM05v6R+xIiEdOuXgQLbHcvc26BKDIeJ+Y10r3r+HYaa8udRTqrsxHNepRCvcDbym/jS9//Ei+57iUUu4oxrFpWHOWS0k5Z37d2rOpbCsLobbhgDPaQ5kraqCIxie5ObHPRSWOh2i7iOBCUsDdNQ5L29ZQYpVNDSpo09qUPUToFES2NOy1QSkNxCCOf0htqPKVks5A86pxa3DaEz+cOTns5joXCObcbmyVrQNV7f41zbgArTLIDK9z1Zu/90VCp4DZMoj0J/Jb3/v7laNdprQuYYLF6q+ZztdLKzvpOdk7u5MjjR3j6yaf5/le/T9+lfbRe1sq1F15Ly8YWq+05SdQES76haFmIAvNmspTmZkz7rDWiMR+VNhBybadBG0oOvDGc6ykslcLjwCPEGp4rvGHQHKdURzmP1TyxaKGnklymO0/tgJWQbTT8L4HrXGRKDH8E02al+i04doIXPEZafgi8BhMsalCUmn7T96U7CZ0nHRhaCGTNqiTnUQ4dic61w6/QWEpEiR01qDQ4NQhloj7IkuSzylheTDBBhQrrmsLRBioDtB1o4+A9B9n8is24CWffvVzO6jOdxMzqIvCTHGsNTcmL3MdTyXOy7ipSbxore3MAy7q8mTj+FBWlPpmOV2me0n6XitmPB5GnYWIqiHSDkbrX5cYbxhaNo8QiuqnLhOQczbt/jcl2bPM0hNU5W9pI8OXGL3rvDyf/vw/4hvf+A86594X//wh4PWaDvBi4Hsulff1yNKhMmWGGT3iMx1OjdlrdhR7PDDPzckdpDVvv1zNYHeSakWs4ePdBHr33UR5se5CZnhm6t3azbuc6+s7vo3dHL67V4WoukvcJGt3VkqrIeqxxnEo29FqzZyXNV6WNxzrMmjwCfAarvjGcHLsKN9VLnRMuE6tTgTrTdqxTThEj59qwqAZpSxRJpN17SmTSPFDPc3ITf/NrdYycPIhpm2RWVUoHLSKp609I/dspqdJ41uCQqyS1PqRWLOlD5PbbjZl7tTDKKqDjZIHoDW1PrQQZqxJddM35vPOOW8q38IW7vsC7rn0XpZ6STZ4TRPefiLqsUXJHa7ORFpVVTrY+GvV86sMiRyIo6puKjLoYs2CpuelspnPJtabzqk0nGneyPCk0XDt/LUwzRFGwyOB48qvI11Q7lWoXIZLAVN+iDVgvRko/jJGrM9sNeCtmZwern/ktjFjdCnw65HO72znX75w7x3u/fzkacTJiBcdGoJ0OsjXFFAUKC8qLpfVsk9/ExtpGmITKZIWZgzPsfnA3TxefptZT48CmA1yw8wK2nLeFnh099G3rw7U5XNU11v+UHnCGxhyEENePZnd5gRhcomzvRzFB+t3E+qGLdPctdz6rbLFaBE72pXg8depzCw3rWG4RO9CgJKCXY+QiNaGKSKWpD7QDH6Ixu2yqjZrLcpWihplT1wOXEIXlcpto95vu0DXJp7lxqjRGKmoxSHNU9SdtTsW1smA9E45pJ0YrNrcBopAfbPEdOc69ZawKnGic9Ff7ufTopdz5t3dy82/cjBtz0SIlF58ScabuOqXhUFRsnRjp1xb+Tl1w0jjJNaZHudkrwE+xifsKYi4fNb15ZpuPdlgbjBaMKIkMprt3bSQ0rrV4aCNB8lqqsywkx6X3KWtxFxbs8RRwJ2eatcoDfx/KMf2PUKJpU0KWnscyFkFSPzNgb3iugVgtVf3M/tnClHPjeFU5RhhhgIFlWdAd7qTtms+5wMTYrb6Vy2uX42sef8QzNjTG8GPD7CnsYV/rPjq7OmnraqO1vZWR1hG29W6DrbBp3SbWb15P67mtRry8a6whKJ1t2FB47/FVDwdgavcUM7tnGNo1xI79OyhNlRacs1CENi2MPMwwRYr0NugH5ocT5RmrUcsWq4XgVC1WE0zM/eXVsZ15eooe4AXEyIuUWCjCKTXxa1fwOEYuUldASqi0eLQn56kk55oB7guvX5gcJ7ejozGRaJqJGuJuXLt4mWfT6MJWTCeSRvJViJXVRzFy10lMPdFGDGHXZ6bdULrD0YJyZu/E1yScd1xbvpZP/OQTHLjmAJu3bG50lcklKO3fBmKyWPW5NIGh+pO0T+oXCqyQEF2ERX1Wmcv3YxuVbZgFq49GgkXT36cC5aTajwWoTNI4pqQFE9mSO4WkjRpTPnlO0POyVkmv2ILRjq3g/72H5zEXzpmDG733zznnNgJ3Oud+nr7ovffzrYG5FPUzZY2YLxyOvtkd4fJgOfNqac3r83301frYXtsOFfAT5oKsuArTTHOocIip4hSH3CEqLRWe6HqC7tZuulu7GW4fpo02drbtZKZjhoniBM9Xn2fj+EYqoxV2T+7mvMnz8GXPlvoWeuo9FOqRuCzU0pSSHI+nTJn1rJ/3OVJ9ncOhLPwibcuFTKyajjkuIxZpETkpYIL1PuxT1MSaZijX+0SMpjEB3xMcm822iBG0TZg4dzPmEigQJ17l9tkd/r4Hm4wvJE7UmvTVL9OoQBEa1UWT2D61SGkhUDI5FXnWDr1ELN0jguUxDZVIlIibCFUaWq425UinVY/j7fBaq628fur1fOIrn+AP/vkf0N7WblYdESTpNApEV58SeY4x9yZArkG5wtSPRDiUcDQlLiJQ01iC3l2Yu/58LKBCVrC5hv3xpgIfrrUHG6fTNIrkmzUpOn+zELjZWqVzV5rOoTxf7diYfwH473hqd9SgDCV/5kzR3vvnwuNB59yXsGS5B+Tic86dgwkCINbPFLYRa2suKWrUuJu7+TV+bc41oEyZAoVjXH4Od9pTNCwndO8ORzvttPt2eugxN2KwjPoZz3nj5xmxcdGS4/G00EIXXWxhi4nyPbOZ/4/nRqtTp0yZjtncQHMjJWDN0XoOx0Y2Lsn9jzDCEY5wERct+nwnwtnTa04Bi2KomiyljdBkmopQRa5Si0wqTn0G00fNJOdUNuqLsUSb5xAzLiugJI06msJSPfwc+BlWCbwFuIhI+lIXg6NRowKN2qrUmiZNlMLJpReThaCNxgVpilgUWiRNUZASNIsYjhEJW+qWzFhx1KjNuaufYIISpTknxR3lHbzgmRdwx1fv4NY33mp6jQmiPip9nMGITh3rQxKFQyTYImIi8eojeg3iGJP4W83V+6qYQ2kvNqa2Y2Slh0jcSM6lvi8t1RAmPFf5kFRcT/LY7NrT39IVpiHsaSoU/arcj8ZMBxY99ULwRzyH/vMhuia66KrNrXVbjXDOdQEF7/1Y+PuXgH9HrJP5AY6tn/m7zrnPYqL1keXSV3XSObvAz5XEc7mtF6sRJ6q0UA8/JV+aV/6tuc5ZoHDSyMiTueAW8t3Indi8KVwXfprP2ULLccnhQrBmiNWSln/QaVIXRRrKKsIgS00NcyvcS8yFo+ipAYxQXYnpK9IJu5KcU0JfiYTXY2Ts++G8rdhCokil1FqUJoaDuJOWq06i3HLyXJrHRJYqaIxyEtFSVl1paWZo1JtUMLcixNIla2seW7WYYooKlTknv+7ZBDTHwtUdt5Zv5b/84L9w9carOff6c3HPO9MkpUEUKSkZwPruODH61BHzYKWkSn1PeaNEqNII22aCk0bhTmKJex8hhn4rGEPnV5JTEb3ppnOS/J3eh36bM643ayZFLFOrtSKDtelpx0jVC8BXPSPvG+HxfY9zQ/mG4372qxSbgC9ZFgVKwF967+9wzv0I+Jxz7t2YHfDN4fivYakWdmHf1ruWq2GTTPIVvsIbeSPXc31DFJ7DLVvZlNNVQHipUQw/wmLuYyXLLo0xRjvtDRvD47WlQiVrrBaKRX/BJYy87CcSEE2aIij6REVW9HqZmH+qju2iN2OWpu3EkHG5HVLrkjJKK9mhck854CYsBP0ebLLeStSCyMKmPFrpIiERrdqZZoRX1JbuWaRMbUqTJsry1Bsex8J9dBMteF3EBUbpIXLKhVWBh3iIKtU5d/InGy+t1VbeU34PX/37r/LmHW+mY12HWX3GiCVl5C6D2A9niJF8k8TIVrkSUzIll5/6YxqoAZHEqb9DdBVCjOKbTN6niF713TTiT+lFII4THasNSRphm7rz0zGvcZbqF5XhSa75NoyOXAS+5jn6+0fZ9+A+bijfsGyL/XIh1Ml88RzPHwFePcfzHvid09A0AHaxi7fyVn6RX+QWbpl1Z13ABQwwcMJEkWXKC4ram+u9Cy0qXKFySlUSII7bpSJ2cgWeSp88lWs2H3Oy9lWpzorZT2RdbCZGSxUYsBCsGWK1aOasCfaFGNE5hGWEPgcjM2l2ZYgTrib4QYwcDWKTaSdxEteCIxKj9yrpolxuqYtBgnUHXBteuy88SjAsF570UOmuPhWra/HR36n1QIuJSBREbYgsBUVsQRUBlFtGehWJ/lONVxawrwqcz/mL0pEMlgd50ciLuOuv7+L1v/V63HoXS2wooii1AM0Qgx4k3JZQXRsTuZLV31IXs/qwrLueaGlNyzOltQFFilKil1qTRKA0DuVqTC1PjsZxA425fdI8Vc26qmkaUzAUsI3HJuAFUB+q88M/+iH8GF4y8xKKfu25pk4HDnCAz/N57uVexhhjkkm2s51LuIQLuGD2My9S5FzO5SAHmWCCGWZYz3o66GCIIWrUuIRLmGCCvexlc/j5KT9FiTzbaKNMmW1sw+PZz35GGWWSSc7hHGrUeCEvZC97GWGEEiXGGWeAAcYYYwMbGGWUkRBCLYLWTz/b2c4BDrCBDXTQQRttPMmTbGQjnXQumATCwt1uQoUKRYoUKJzQAjSfgtgVKtSpI+3V8Vx2NWqMMUYfffO+j3u5d17HnwxrhlgpGduCUSLmq7oRE5DvxpKfVYELMMKgXbZcC8qO3oWVvVmHWauaNVupZUmbJ9VB0+tyH6QRRW2YOPhqbEH7Ufh7gEZRsFwzqWVKAnppq1IXR0oQdV0tblM0inCr4b46MTH780RtVk9yz0PEHFfZYrUqMMjgorJDO++4unw13977be77zH1c895rcHVn3/U4jZZOufLSfjkQjhsh9nGVWUrd4NpYqH8qN5Ysr+1Eq1RqSZU1S/09dY2TtE8bCLVThEkucm0W6sl7ZSVr3qyIlClgJSVoSpy6DdhuQvXn/+R5pp+d5uXll9PqT21RXI7CsWsBNWo8lVS1fjT8NGOuxTt9TsRBBEHapOZjixRRGp/m19JzNL92Ir2P3pdafEQ81jIhX4yFLicIXSA8nimmFvZmaYdehkXglTBd1CFMw/EElnemFyNQdWzBOB/blQ4Ss5i3E61TysczFp7TgqMdtgo+p5am1BqrRaSEkZfLgTvhyD1HGLh6wKwHcj20EV0kEg5Lr5LutlNSBXGHrQVogrj7Vt6dPmwhPRDaP0AkYEfC8f2YqFiCXZ33zMrTc9ZhP/sXnwSxDjdO38h39nyH/Z/czzn/9Bxcydl3r74tyII7g/WbdqzPKeGmiHoFZodr6hpvFsanfTu1ismFLsiSBZH4VJP/SdopAqdNTzl5TVYnETFZq/QaxI2KEi7K+taD6am2Axtg5hMz3P6R27l4/GJeWX7lvCIAhxg6aaRVxsIx1yKbPpcSpbkWZf1fm2OC02vpOZpfO9Eir/cd75oZK49TGsmrtQbUfFCixAADC3uzou52EvNLzWCT5CBmITqCRelNA6/FdqTrMLKl3XZzjhtN9qqjV0meK4b3alesyD5plNJdutxr59l12x5to/69OoULCjaJrwssfoooLNfCIQvTRsw9oTZq4RHp0mKVuk5asAiqISxweiexRpx29nJvysIgl0+2WK0KVKkuekJ2OEr1EjfO3MhPHvkJHZ/tYN071tn3fIi4IRCJl/tuHOtzSiQqXZVIlVzUaeRgsys57U8SpkunmGqr0og+9b300SfH+OQ9ei0VyadEKrVy6f/UWq3N0jpsk7Xd2jz9f09z19fu4qKpi7iicsW8NVULnssyMjKWHfPZpq66GlDzwYLNpLJW3YBZZ7qwBUC5mqrYznsrlgl9EiM4feFYWarSrOXKI6WSN3J1KMuzS55LFxNN6FpIpDWZIi5M50H3E92Ux8tM/HQCnoCuc7oobCvgBh2zGuUKZmF6DOoTddx1DtflovsCGhMbqt3SjBzEFq5NwFXEqEhZxKrEHbva30Fc7HJk4KrAz/k5FSpLUuW9pdbC5dOX8617vsWLWl7EtrdvswSXw1gaA1mIlCi3GxsnbRjxUE1A6fTkXlMJKVmOlOIjteDKxZduVuTGTqMFodGdJ6SC85RkORrTqqTHpC7FVACv/t1GLES7BdgM9Z/VefT/eZQfPPoD3jDzBrbUtixoXlrLLp+MjNWOxbgCbwVuCn9/ClamBtR8sGBitRGzyEj3IX1IcxmZVPckt58sO7q0yFQadaeEmdpla0c/nbyuxSTNRE1yPbk91gN90DpppQ38uGdo1xAPPP0Am7s2c1nXZTjnYNII1bf9t/lW4Vu8b+R9dGztaNSW6H6kY9mPkb914TPpJ0YITmA6GU/UvhBe76VRZwXRvZixotjBjiVLguhwtNfauXH6Rv739/43V3M1173lOlwhuAWHsXEiq+YM1p+6wmMnUatXIFp7JW5Py8a45Fypmy7N+ZZG5DUTp7lSI0C0TKV9P00dkVqoIGrC0vOozmY/tuEKkboz/3OGz/zZZ+g52sNby2+lu96dCVJGxlmIU51RPau0BtSpYkEWqzQSEBpDvVU3qVnjoR1rGtUnV5jHdu4FYkmbDZgmSVFJctWpHl+6S1Z7Ksl50wVAJUTOwUpxeBMXD7gBXl1/tS1sI/H2pt00TxWe4iH3EHun93Kxu7gxw7SsWg4jUgOYi1OLmXRgExhpGiTu7GdotNb1YYvm3nD+Myua/KzFCCNzaj0WCoejp9bD26ffzie/+0lmRma48VdvpLCtYH1SOayUB60N6z9d2HiZwgiJNFdgfasejpugMeO5ogo1FjXWUnG6SFNaCFZESe9pTgaaRviJyMnqnGoTFcSh9ijVyBZsMzYItR/X2HfbPh764UNcNHMRr6i8goJfml3F8zy/JOfJyMhYOpwqsVqVNaDmgwURK1mnLiBOqr00RtnJ5K8Juo3oTvPJ6+PJ+crYQiKqKfdiWmevgi0uE0Q3hq4p14T0JFoUZFmSeDxYtZx3+hAaXBwddPAW/xa+6r9qmbPTkjbKm7URI0ctyTW1MCqCcUtyPbls1DaJ69uJkYqKKsyb9RVHDz0LyqtzMvTWevmXM/+S239yO7cfvZ2b/+nNdGzviORKqTnaiEW8VahZ1qv28KigxS4iaUotUPpfVlxpA0V60s2HxktzMMhc56sn59T507QkaY1ARfv1Y/nptkJ9X53n3vcct3/tdraPbufGyo2sqx2b9Xkx6KFnyc6VkZGxNDglYrVaa0DNF/Oe0ByNVicRj9Q9V8Mmf03AIj3Sg8iyo8hAiXHrmOy/TKyxp3MqTHyaqMfqIAp1Uy2TEnGKdIFZhkR0dMvaUScU1uGYZppeetnRscOelMtRNQJV7qOUnEcEsEQkXbIYaPeehqGLZHVjxHSYnHJhlWCKqWWLJirWitzqb+X+Pffzkds+wjvf+U427txoVssJjEBJoC439wxGrqRtbMMsVh3ExLjqc2nCUWkTFeihcSdipRQM6TjQZojkvWkqktQiLMuYNg8iWC2YNXYLZrPfDH7cU/t4jds/cTtHjxzlV8q/wrnVc5eFwP6IHy35OTMyMhaHkxKr1VwDaj5YkMXKESf0VNCqXDxVbGLVJC/Rd+rSA5uQ5R7U5K7IJrkRpasqYwuKJ5IpTe7SF0scPk0sK5NqmvRc+itX3Bizi4wf8/y09lOuLF5Jsb/YmB1diwfEaKuUUOk+0uzyIn1paR9Z+vS59NFIqJrIXsbpxWIThJ4MxXqRa2auoeVAC7f92W385ut/k52/tBM34szNrCLH2mDIPajCy63JYztGzvuJwRQOs2QpvcF4uLCIkAh+GiyRuhKLyXHNeklZpLQ50JjQJqqXWI9wC1aS5r+PcM/t91B7qsYNMzewubqZgj+2DuNSYYKJZTlvRkbGwnEqM+qqrQE1Hyw4KjB1FaS6DREdZYqWa0P6KLk0FOHUlrxfUYVp6gKRI5Gw1M2ohUfCXJ2rhInBRcR0zER43IhN/tPhsQNbhIbCMe1wqHyI13S8BtcdPptUKK96hvpb7UzJk9ybWnwq4dyKmtRnkpKr1FKQsaJ4mIdnsyU3o0oVh0MFmheagM95x4vLL2bz8Gb+/m/+nr279vKKt72ClotarC+OEvNOTRHd4m3EDYuI1GT4HcOswAoS0Saolei2VoIYRfaJwKcbJbm0UzG7xmKa60rjS3mpNmNxz6HqQvXvqnz349/lwUcf5DUzr2FneSctvmXZxenZFZiRsfpwUmK12mtAzQfzneQ8Hl/yFIqFOPlqspWlSYRDYnWImqIqMfu0tEZz5cxJJ/aW5HhlXW/ebZcw8jKKLR4S0E+H5/dgROoFNC4SEEvMFIBB2PrsVrZ2b43asbSciMLfW5PnUjGwrFSKBkxzdLXTKPSVBa6buPClwvyMFcE00yd0BaavHeYwgwwuOD3A5upmfr3+6/zo/h/xJ0/+Ce965bvY9uptuI3OhARHieWSFBUrC6z6pvr4CNb30xQo0mKp78rlnpayadIZhpuMj3pd+qxa02MbJm64AvxWT+27NR7+4MP87IGf8aLpF/E7ld+hVD+1mm5LgeW0NmZkZCwMa2ZULsRiVadOuV6mw3VEC5I+MYnJJ4kpBWStSsW0k+F/7biVlyrVb6TkRxO7opLSIrTK0j5EdHsoykoERpqP1KLmiIJy1SjsBLfO0THdYdaKLuLuvTmHDzSGsac6ln5iWLxK5kg3o/bLalAnCpBFwjKpWlHsZOdxF+cSpQZitZ71i75esV7k+pnr2Tq0lU//3ae5+IGLufnVN9P7sl6LaD2M9XEls1UUrITnZWKJqBmilUrWrdSaqjEhveFcG5o0VYNcffpVjT/1+y5MPXo11Ct1dv/ebr7+f77O+rH1vKH8Bvpr/ac9fcIww6f1ehkZGSfHmiFWMH+LVdEX6ZjuiKkDHLZblhAbjNgorUCqPSoQJ2WJa1tptFrFhjVGI0nPAY2FaWtEoXjqlqgRiVcZW6Ckx9J5lTCxDSvLM2JtvurCq0xMrGjGtDCtrl8kioMVqVVIzp9asLQgqn3Sg6XZ1vUZ6e9c1mbFcLJUC+mYWQrSoA3O9up2/rD2hzy+53E+/78/z7ZvbOPGX7yRzhs6cZucWa8O0ZiwtoU4jkS6RKxk1ZWbT0Q+zSGX9juIKUWkm5JIXRsiCdRVjuZCqO+s88y9z/DFP/ki6/as43Xl17GjsuMYYbrKnCyHYH0NYxx4bKUbsURYj20jznScLfcB87+X8473wpohVgvSWHkad852oija7sSsNXUs0q2fmMdGLgwJ3dMQblmhRKC0CEwkzyuyUO0QMWnHROiTRBeJyJvOV8cWnLFwfJoGQucasL9dT1jERJDSaCqJ80tEi5SsdMrlVU/eo89GZWyOl6BR7yFpf8aKYICBeZdTWSq0+BYurVzKhbULeeCZB/jLv/hLXvb3L2PghgE2XbsJt9NFt59SNEjHJ8uV3IXaEKRWVkXwilClhZ2lmdImRZugtO97Zmtf+gs9tdYan/n/PsN9X7+Pt0+9nevK11GsF487r1SoLKrA9algjdWHe8x7f81KN2Ip4Jy772y4l7PlPmBp7yUTqxNBeWxU3T4Nxa7CbECOrFXDmBuun0im0olalhu5ySASKWmUPI0WHu2qFX0o10YJ20WL/OlR5EekbILoApTVTbUG9b51yfVE6qR10T1Ix+KT86QpJUSYVDhXlgCJknX/cqemCRozVgwzzMx7cfb42TI4i7ViORzt9XZuKN/AtdVrObzvMF/48heo/kOVmy+6mQtfdiEtv9ASrcUTxFJJEF3PaZqPNOIvrXygsZGmTVAy2xka+79c5uvAb/A89chTfOVjX+Gi3RfxX2f+K23VthPeu8MtO6nKyMhYnVgzxAoW4MoQsXoOy2YuV5ci/ZRVXHmmOoh19DaHc6TWGJ+co568nh6jCDpZgFILj7K3K6S8SIw81K0pKad0KGVsx38AixLUYiOCJdFvNRyf6r7SRKRpCY9UH6bnlE9Ibhm5A1PBvxay1NWYEsszCGdDYXKAgxykRm3eVqsy5SWpLyiokPPm+mb+WfWf8UjlEfY9uI8fPvJDur7UxbUvuZat122l5ZwW3LkuWqtSl7Pcd9oMiWzJfS/CJT1j2hdVX7CL2SAL3+6ZHp/m3tvu5dHvP8qbpt7E1vJWXP306qgyMjLOLKwZYrWgnbVIzWPA1cRdchB/N5AFZY7uwIhVGbMo9dNYMFYJRdP0BGkuKFmsUmG3XI8iNYXkfCJFQlpqQ3muOjAyN4Qlz9C3rp17D7b49BKtY9I+qWSNXIISqqdrqgTyXcRoxjSMvTmnVmqlOrMtVmd0YXKIxGo+cDi6Z0WGS48W38KLqy/GVz0T5Qmem3qOe/bdw8++9jOu7biW7Zu30/fCPtads47+wX4bT1vAXRjGuIo8K8hCGxWI/VGW4xLWb5W81oF/yDP1oyn27d7HN/Z8g6unrubd5XfTUlk6IpmxIHxspRuwhDhb7uVsuQ9YwntZU8RqQeSqhsnZJrAJPI0eUpSS9EbSJG3DSMUQZtMQwVLxWVmCtFtWQtH0XCkRSa1b0nM5bDFQxupyOL9IniIRtatP6xmmCTyV8X0ES3aoCMO0ZI2KSRdpXKxS3Vma5XoaSwUhcpbWYWu2gMlleXbgVuCm8PenOAMKk9/IjbTP5glZXXA4uuvd7KzvZGd1J7/qfpXxmXH2jO3hzifvpLfQy3PuOa4sXklLewuHNhziwvUXcv6O8+l7cR/uHGe5rqAx35rGcOiH1ZEq5SfKtD/RzuSuSZ7b9Rz7p/bTVevityu/TalWimWhMlYMoQzaWYGz5V7OlvuApb2XNUOsYIFWqwrmbnsC+IXwnLKPQyRHiqgDm7R7sDIXM9ju+QDRVdaJ6ZrUHLksOsN5pZWSFkrC9BmsvPUEJj4fIJIoERodL+LTgxGxaYzcqTyNIvsOhTZMEbUlsoqleivdlyxMxab/1T5Z1ZSZXtBipvP4pufOPHjO8MLkAEc5So3aqs6HpHHb5ttoq7UxWBvkaq6mTp0pN4V3nj2Te2AYhp8c5nv3fo/ql6ocbDvIUy1PMVAcYH3Hei7vv5yuUheu7KjUKuwv7odxqI/UuWP8Dv5J7Z9wfv18NtU2cVHtIgr15cuYnpGRcfZi9c6mS4wFW6zkgtuFOW8UHSd3m0Tc0krJpddGdA3KRVbFCNZeYvJQRRB2Ea06neGcIicjxGzTIllbaMwMLcuSJ1qp+oiWoxFi3h/pqZS+oYJZ5SYxd4hE7RAtWNLh6j0iRqkVQNqVCRoL4qY12po/pzN33TrjC5ODEauTpVxYrShQoMt3gYfL6pcBMc3B5PQk5bEyI26EcqHMhLNIkyJFZkL0SBddlChxqb+Ul9dfTme9c+HzREZGRkZAJlanggqWzXw/5uarJs9PEzOUy3LUkjzXG46tYaTmfIwUQbQqTRHdiMq2rgLPKmkzEo5T4WURuqmm96TlaBSeLsH6EY6tY6gkiKPAM8DlRKuZ8l7JdVkjWshE/HRtWbyk6ZJbcjJ5vxI9+qZffS1nkID9bClMPs74rBD9bCAUGufd3jRgA35g1uK60JI8J8JynDPjWDjnbsYCQIrAJ7z3H1jhJh0XzrlzgU9jFmsPfMx7f9uZGNwC4JwrAvcBz3nvb3HOnQ98FnO0/xh4h/e+7Jxrw+77Jdhq8xbv/e4VavYxcM71A58AXoR9L7+NKaiX/Ds5s6XD88SiiNUU8L3wmNbDU1qByeRxOnlU/b60aGwn5sbbjHXNTRjZ2hD+3xpe24BZnTZhX/sLwnHriW5HWdTSTOxK5ilrWXf47SEmUZRVyWHWqlFsqQ8h5g3pGeTqTA0biv5rx1yMW7HIyX6MTHaFvzcTBfzQGC0oUqXfMwTOuS7nXI/+xgqT/4xYmByOLUz+m85wA6ukMDlEC89awHJYoypUqFNfsc9wLRC6sLD/KRYEcinwNufcpSvbqhOiCvy+9/5S4Abgd0J7FdxyMfCN8D80Bre8BwtuWU14L/Bo8v9/Aj7kvb8Iy4L47vD8u4Gj4fkPheNWE24D7vDeX4KV6XuUZfpO1gyxWtSkKmLxc+AeYjZyuftEWtrDc7ImjWFER+47WZW6iLmc0vN0EC1cel3X78JIVi/RHZemS5BFSLXUxohWpV5inT5d0xPrBu4Jfx8h6sMGwv1ITJ8mNK0lz3cSSZFE6Sp424kRrg2hjXIVNrsAVyY/5WKwCfiec+5B4F7gq977O4APAK91zj0BvCb8D1aY/CnMofxx4J+f/ibPjYMcpMjxk1xmHAuR0Tp1WmhZkDvVJz+LwVa2Lur9ZwiuA3Z575/y3pcxa8mtK9ym48J7v1/WDe/9GLaAb8Xa/Klw2KeAfxT+ng1u8d7fDfQHi/eKwzm3DfhlzNJDsOS8CvhCOKT5PnR/XwBeHY5fcTjn+oBXAJ8E8N6XvffDLNN3kl2BpwqRlCeAlxLDttsw4iJrUGrdGU/+F+mSy1BEA2I6BbnalINHCTTlzlOSUFnQOojWH4iJR1OLkEgQNOaPKgBPY5aqEWK04UHMatYV3jfKsWJ26bimiZGDEturXmCBSC4VRVluOpfuP82JdQbgbCpMvoUtVKjg8aedXHk8M8ys2qjEE6FKdZaQnmoNxZREzYSfHnoW9bmvkZI5cwV/rIp0JSeDc24HcBW2JV9UcMsK4cPAH2IrHNjqMOy9l5hEbYXkPrz3VefcSDh+NZS8OR8L1fqfzrkXYy7M97JM38maGJXCohYOJQs9RCQwBzEx+gQxlYCysIMRihEs7cIRjLg0u+ykkUqtTSI6ImJyuxWIZW3qRGuZfhVVCJF8HSWmi0iTjoJZqsaJVqcKsC8814O59rYQSWAxeW+al0tuz3FiclIRwJHwOSlLfZqHyzWdM+O0o0yZ7/LdFbl2nTpHOboi114sSpTmRWoOcnDWbQjQRhu99C6azD7bMPdnrCY457qBLwK/570fTV8Lm61VPfM5524BDnrvf7zSbVkClLBslB/13l+FrUjvSw9Yyu9kzVislgQz2NdxP/ArmDWniFllqpg2qY+YMLONY0vgTBIzt5eI2qMSMTqwk5h3R5YdpTboCNdQKY4OGsmOrF9K0pmW7hhP/j4S2r+BaHlSqgYJ6VXgtg0jZ2NEgpdmVJf7T1auXoxQHSGK5NNs71pLcr7FFcdjPEYrrStisZpkks1sXlDm94WiSpVC+FkoFvI5rWd9w/vmew5Zu6pUaaEFj2ea6TM2onOeWLXBH8eDc64FI1V/4b3/m/D0mRbc8jLgjc65N2ArVS+mU+p3zpWC1Sptq+5jr3OuhK1UR05/s+fEXmCv9/6e8P8XMGK1LN/JmrFY1alTXmw2Slmt7sbiB+oYOZkgplIYJearkni8i6hXkuVH2ctV4Fg1zPQeWZ9Uf28mPG7GLEkDGCkSGVM0ntySncSIvtbQfrkTxzGptbK+zwTNR83HWn+ybrUTrVd94TWlYNDr/ZjFbF1ok6IGS+G5NOeVCJgI45rpgasTU0xxgAMcnqe13uM5ylEqs3k15o8uuihTZmq20y0/TrfIXDoq1/QzXxzlKB7PEEOzmfJ3sYvHeXypm7wa8SPgYufc+c65VuCtWEDIqkTQFX0SeNR7/8HkpTMquMV7/37v/Tbv/Q7sM/+m9/7twF3Am8Jhzfeh+3tTOH5VWOW8988DzzrnXhCeejXwCMv0nawZi9UooxzgwOLFnjOYS+8O4M3h/yGMSHRjXtlNGOFIy9dAFK+ngnP9imhIAO4wAqSoQp2ri5iewWEe7KMYoTkaXlPeLKV8UNoFRxSpK03CcLzeSH2EnsM9FCeLsQabkoa2E3VfYzRmchfJkvVqiJiZXtcVqdL55JJcFcNu7eIoR/mP/EeOcIRXJ/KwMcaoUaOf/tn/J5hgF7vYwQ42sYkKFdppP661aZRRWmllkklaaaWb7gZSUaPGAQ5QoMAAA7TO7gBOjDJlqlTpomv2ObkVB2dTrTeimcx4PHvYQx99rGMdI4zQRhtjjLGBDafUjhNhlFF6QyRKhcqc97aPfUwzTR99s5/VIIO00caP+TGXcAkjjPAsz9JBB+OMs4c9bGQjM8xQoMA+9i26rasdQa/zu8DXsRnkz733D69ws06ElwHvAH7qnPtJeO6PsWCWzznn3o0JMd4cXvsaFta/C5uh33VaWzt//BHwWefcvwceIAjCw+NnnHO7sFXgrSvUvuPhXwB/Ecj5U9jnXGAZvhO3Ggjl6UiGeC7ncjd3s2U2idQioGi4G4GbsI9dlqMOjOxs4Ni0BRDda3IFyo2WYjIcf4RYc9CHx2mMQBWIFi9F2k0Qa/uJfKlumnRceu0A8F1mNV3eecqFMi1dLRR+tQAvD/cga5hP2vMMMc9VKWlLmp5BubwcRjalTXsGi658nChml+XsJHgn7+TTfPrkBy4BvF/ZGianK0Go0EorHXTM/q8UAiJN9fAzwwyttFKiNKflpZk4ORx16jjcnASsRo069eOeby40ty09l547lXPNMEORIiVKs22tUVuS4tKn4t6U5qpIkRo1ChRmP4cJJuiggxq1WRJVpz5L0ipUKFFalMVwvljpMZGRcaZgzVisWmihk86lOZmE4T/ArFRXEN2CcoFJ3zSAucrkDism5+gg6pVUf08oYERKlidBZWN0HpE8vUdRiA4jTZJgSNskjdc24DKM4IyD844212YE7IdYzqxtGKlKXZWjGHF8jihSd0RBf2e4XwnTBzH35G5Mp9WOEbQn5/5oM1YG5fBzKqieCgvOWDSO933o+dNJqjIyMk4da4ZYLXlyQLnXvomRhYs4NokmxBp+svzILaas5RCJkrKVp+kSpMtK6+xJOK6SN3I7Kq/VZHhvbbyDZwAAFW5JREFUd/KcEpt2YoTLYcGjnZhEb5TozjsIfAdLStpH1GrJHbgxnEPuQpdcsz38doT7072eixGuI8B5wE8xMia3ZxqtmJGRkZGRcYZiTRGrJYfyNP09RpzOJbripKOaIpaIkdhb9QZlderHsqnPEKPyFEGnEjUQ6+6pNt9M+LtMJD2KEpT1rCc5XlYk/d0arq3IQGmktmEe6O9jejFHdDv2hPdNYh5pF+5N4vTpcFx/aENaskbi+j7MkjWa3GtGRkZGRsZZgDUVk7Xk5EqkZgS4EyMVqvE3Gn4V0ZfWyyuH14YxYlHEhOrDmLvsUHhUjquUGClLexuRhCmCT245BcamlixF4+kYETa1SRapEmbp2okRq/uJGi6ILsXB8LfyVklPNU5MzaBUDxLsywpXJWaB13PZWpWRkZGRcRZgTVmslsVqJcvRPuArWJBpG0YqjhCtRCprI4uSIuqkj5LIfBIjVGmZm7RUTCdRlC7XnciK8kiJ4Km0jCL3ZB1SUs5OjAB5ovBcJKoV04d9BUsSej7RjanizOdiVqsyUVNWxTKGKGv8unCuGUzEvoeY90skLyMjIyMj4yzBmrFYLRuxAiMVU1id7P9DjIirYtab4fD6OEYqVA5GBElao3J4foRopUp/ZZXqJKZeKBCtYnUaLUGyIk0m51b6Bn3zzdeXC7KI5a7yWGYPledR5nTlr1LqBD2vbOvPht/dWN6v7wEPE3N9pRGF0lhlZGRkZGSc4VgzFitY5krwEqk/gFloXkNMhXCUaEWSK7CAkSC542TVKWPWoNQSldb9S11ylfA+WbuK4ZwSsEtzpfcrL5YjZoMfIroFRbak/SpgeqtnMZH+q8L5U4uXhOwtRJdkLVxL9QePEsmnxPZqVxatZ2RkZGScRVgzxGpZLVaCyMM9GFl4LUZOxohFk5XgE4ygyGqlNAlTGEmRfquEkTIRF/0/Ec4ra1MrjRnP5ZqT+7BCdM9J+zSBWY9q4fy9oV3SiYGRtHOw3McDWAFq6bLaMK3VAaKrsw0jVZPJubqJtQIV4Si9V1ogOiMjIyMj4wzHmiFWsMwWK6GGEZ97MZfYrxDJlKw40ihVMQJSCH9PEfNMKWeUC48qytwbLzUrep8mJg9V5KDOATHPlPRWIl4lYDtmZathOqru5DiljmgL5/96uMYrMZKldncR3YwigapXmNYylKWrFp7vx8jhmnFIZ2RkZGSc7VgzxOoQh/jX/Gu66aYj+emnnwIFuummlVZaaKGVVrroooUWOuigTp3W5KcUPjZlk1ZW5Nn/qwWYAv+op364TvGmIlyMkY0RzNrTFx5V81ylYsbC/0q1IBdfa/iV1UmkqYgRmgkiuVI6B+XVasPIj0hdWjS5gOWruhcjaZdi5EouOrkOW8LzPwzX+AXMkiUr3CFiBna1SdeTYF5VPSpEUpYWaV4T9WQzMjIyMs5mnBKxcs71A58AXoQtlb+NSbX/GluWdwNv9t4fDQUob8Pq7EwCv+W9v3+pGz5fDDHEB/ngcV8XKdJPCy2zjyqfof876aSVVtpoY5BB+uhjggnaaGMDG+ikE1dztE+3M3RgiF/7219j4MoBqyCltANV4Ai4HsdF5YtoK7YZqVIE4QyRQAUNU6FcwI07IygSrItojRPLykh/Jdegyuio7I60WxKpn4eVmtmNkbPLiJGEIkBK9FnEsrX3hut3EvNYQUyd0E4sTt0S7jtNGNqJpXRowzRcI+EcqUswE62MjIyMjDMMp2qxug24w3v/plDAsBMrKvkN7/0HnHPvA96HFWd8PWafuRi4HvhoeFzV8Hiq4WfJEATtH61+FPcjZykZXo/pkgK5KVQKvJAX0j7RbiRE2dR7iSVpgrD8tS2vZfP05qiZqjY9DgEdsMFv4KXFl+IKLqZfEElTxKKH0niJja0bcTVnKRV6sHrfl4brSxQvIb0i+AqYpW0IeB4TqPfRKLaHmMJB1i8lTZX7rw+4ECN7jxCjBSFaurL2KiMjIyPjDMJJiZVzrg94BfBbAN77MlB2zt2KlSAG+BTwLYxY3Qp82lt157udc/3OuXO89/uXvPVnCGrVmpGNZ4HPYtF1VzKrqXqw+GC0DqmETbu9NmsJOgr3FO6Jei25DieI0YTjdnypVKKrpSu6BJtL4IT8UV2VLq6fvJ5CqWCvX4WRvwexfFwhg3xxpMirpl7FlnooYK1ovwqWp+pQuPYgbCps4pKxS3DORfdjC0buVC/RW23CjpYOCt0F3KCz7O8iiVWOtV5lZGRkZGScATgVi9X52NL5P51zLwZ+DLwX2JSQpeex4idgFeieTd6/NzzXQKycc+8B3rPwpp9hUDqGGpZ08ynMjreVWIA5Teh5ELNMKUVDmtlchCnNTyXXXQWqU1VGWkaiNkrnnyC64hyMtI7wpakvGZF5HrMxXgJ8G/vWXxXO3QafG/9czK8FMSt8HSNFk8BR6OruYrA2iCu7WP9Q7k3pxQrQ3tLOS6svZV3HuhixWArtFVEMGq0++hhkkJ/xs0V/DRkZGRkZGcuJUyFWJeBq4F947+9xzt2Guf1m4b33zrl52Re89x8DPgYw3/ee0VCqgweBXZgL7iJMb6SIPGVzL9OgsZpNDKqs7frUpLWStSeNNJQr0BOzuCtFA8RiyZOYO+4yLKHnHVj9wheHx25iEWWJ00cxt2Z3+HsSJmYmmOiaiOftDPcrAf0os/qsx0Yfi3m9toY2i/y1hDYF0uW8w2cTVkZGRkbGKsepEKu9wF7v/T3h/y9gxOqAXHzOuXMwGwvAc1ixE2FbeC5DEHFSIs2nsMzklwGXY+EAighUbixlbZcQXCRLaQ1k6RIZkYAdIlGBmDNL4vg0ku9+jOitw0rPfC78vTEcV8KIFER33eFwP3LjTRNdhMpVVcL0VBKzl8L79FkQ7mU7sZDzOA1Z2n3ZH6vhyjUGMzIyMjJWGU5KrLz3zzvnnnXOvcB7/xjwasy28QjwTuAD4fH28JYvA7/rnPss5uwaWcv6qhNCOvkKRnTuxnJKvQAjWJdhlh+5xRTlVw7vHSZqsJSia5qYw0plZnrC35NES5fybYl8STf1D+G1Gcw69XngHeEcaqsKPctV2ctslCMTmIWrI2lXgegK7AvXUj6u4XDsARqtXKmFbIYYedj8O8OsCzRHEWZkZGRkrDScacxPcpBzV2LpFlox+8q7sOXyc5idYQ+WbmEopFv4CHAztpS+y3t/30nOn+0OQjH8lrAknOsxonUeRkqkkZIWSccfxkhNH2bRUs6oPqJFaoqY/0qZ2ZXm4EsYuVGm+HFirqvLgd8I7RkL72kLrzvMytUfrv8kkTBuCteXRW2EqDVTjizl9dpPLMWjdBMQy+BUiNnbJ8Pfes1jli1ltF8CeO9XtHqhc24MS2my2rCeaG9cLchtOjUspk3nee83LGVjMjLOVpwSsVr2RmRidSxk6Unddco71YFZkFrCYx+W+uA8LLJPFrAS0XKk6EDRBVl7JJq/A9N8SZAuQbxcjlcDbwvXOoKRmR5ifcIasQbiSHj/OmI0YC/ROqYcXGrHGGa5UsZ2EanxcK02GqMEffL6MBZacZCYnmIJsAqI1X3e+2tWsg1zYTW2K7fp1LAa25SRcTZizWReP+PQXHS5HB4dRiYOhP+VoqEdIxeTwEuICTzHaUxfkOaHEil6ElPS6dhUw6RIvp+Ea7we6zXdxN4zHR67iJa2GYwwKW3EkfB8b/IeFYWuYLqy8XA/HiNfhfBYaroHifL7MPKme8/IyMjIyFhhZGJ1psA3PdaS1xxGUKYwQ//TWJb37ZhVSa416bRUYqaMpVa4HyM1SnvQfF1ps36MpVbYSrRI7QjHSdOl7O49mNBdbkW5ESeIuqxWoiuyM7zWTYxSdOF9KkqtuoiOaHGbJBKyrLHKyMjIyFhhZGJ1NkBWHOmmHsfK0wxgaRy2Y+40EZIxTCm3CyMzZRqJWjOqRH3TD7DC0nXMyjWGZU8fCNduJeqfZElT2RuV3Jki5uZqwTRaimbsx4iS2jtFdDEql5fDNFkjxOzwZx8+ttINOA5WY7tym04Nq7FNGRlnHbLG6myFys80a7WUJ0u/JyJUzWjDNFvXAzdgBGgGszJdjFmhOmgsKN1D1Fd1hr9VgPpQOGcxnKsvHDOJacb2Yy5PCdrlUjxCTLZaw4jfbpZUKrzSGquMjIyMjDMT2WJ1tuJ4brHF1N8rh/c/gEX8nUuM0NtPLF1TC9fvxKL1RrCeViJmi+/CrFyKcOwmFojuDK+VMKtYFTiK6ah0fogRknWMlK22GKyMjIyMjDWHTKzWGhZjG1Ri0QngLuCXMYvUCEZ8WjHNVQtGctL6h+XwXuW76gzv7SdGAg5iGq6W8L5tmIXraWI5nTaiS7Ae3lcO58pFmzMyMjIyVhiFlW5AxhkGRewNAV8n6qGmMTL1BObikyuyjhExWbEmiVauIcwi9QwWmfgzLHPTMEbUHgd+TizR00XUXqnnqryPcmedBXDO3eyce8w5t8s5976Tv2PJrvvnzrmDzrmfJc8NOOfudM49ER7Xheedc+6/hTY+5Jy7epnadK5z7i7n3CPOuYedc+9d6XY559qdc/c65x4Mbfq34fnznXP3hGv/tXOuNTzfFv7fFV7fsdRtStpWdM494Jz7u9XSpoyMtYZMrDLmjzpGrg4C/wcjR8qJdQTTO40R800phYNyV7UQtVHTxPxTsmY9jWmrvouJ7A9jrsZ94fH58PdQeO0QZ42A3TlXBP4US2xxKfA259ylp+ny/wtL7JvifcA3vPcXA98g1gl9Paasuxgrpv7RZWpTFfh97/2lmLLvd8LnsZLtmgFe5b1/MXAlcLNz7gbgPwEf8t5fhG0N3h2OfzdwNDz/oXDccuG9wKPJ/6uhTRkZawqZWGUsDLI+HQC+hdU6fByzNilx5zBRU6U0D7JcFYnlaMpEknQYm/5FoEbD+SBGPVYwYjdMTEZ69uA6YJf3/invfRn4LHDr6biw9/472DeR4lbgU+HvTwH/KHn+095wN9AfaoYudZv2e+/vD3+PYaRh60q2K5xbvbKFmBDkVVgt1bnapLZ+AXh1qFCxpHDObcMc9J8I/7uVblNGxlpE1lhlLBxyC4ro7MU0UhdiS18Ncw2OYDmv+jE7wlZiLq1WjGC1Yr1xCCNSI5gbcALTVNWIrkW5ElXUWdqqs0NftRV4Nvl/LxaHuVLYlNT6fB4LW4C527kVo8TLguCuugq4Z6XbFSyLPwYuwiyMTwLD3ns5pXXdhjZ576vOuRFMUbjU4RYfBv6QWNlzcBW0KSNjzSETq4zFQ+LzAvActoRtJEb1OayaZAH4IVax7EVYCZ5DWJRhB0a+jmIkzWEWsBqmq0ohC1jGaYX33q9UahTnXDfwReD3vPejqXFlJdrlva8BVzrn+rFKm5eczus3wzl3C3DQe/9j59xNK9mWjIy1jkysMpYOdWJKhmex3lVJXi8Ss6ofwIhVCROvq0ah4JL/zy5X38nwHJbIQtgWnlspHHDOneO93x9caioedNra6ZxrwUjVX3jv/2a1tAvAez/snLsL+AXM7VgKFqL0umrTXudciVhxcynxMuCNzrk3YDbeXuC2FW5TRsaaxGohVuNYPNhqw9lWoX650Ngm2Q4qTUfVkscyFgV4PCze/rCYz+m8RV994fgRcLFz7nxs8Xsr8Osr2J4vA+8EPhAeb0+e/13n3GcxV+VI4ppbMgTdzyeBR733H1wN7XLObQAqgVR1AK/FxN93AW/CdHHNbXonZq99E/BNv8SZmb337wfeH9p3E/AH3vu3O+c+v1JtyshYq1gtmddXZdX11diu3KZTw2ps06kiWB0+jNn4/tx7/x9O03X/CrgJI6UHgH8D/C3wOaww0h7gzd77oUB4PoJFEU4C7/Le37cMbboRiw/9KdGG+ceYzmpF2uWcuwITfhcxB/fnvPf/zjl3AUZgBjAH929472ecc+3AZzB92BDwVu/9U0vZpqb23YQRq1tWS5syMtYSMrE6AVZju3KbTg2rsU0ZGRkZGWc/crqFjIyMjIyMjIwlwmohVqu16vpqbFdu06lhNbYpIyMjI+Msx6pwBWZkZGRkZGRknA1YLRarjIyMjIyMjIwzHplYZWRkZGRkZGQsEVacWDnnbnbOPRaqrL/v5O9Ysuv+uXPuoHPuZ8lzA865O51zT4THdeF555z7b6GNDznnrl6mNp3rnLvLOfeIc+5h59x7V0m72p1z9zrnHgzt+rfh+fOdc/eE6/+1c641PN8W/t8VXt+xHO0K1yo65x5wzv3damlTRkZGRsbaxYoSq1Bv60+xivSXAm9zVrn+dOB/YbluUrwP+Ib3/mLgG+F/QvsuDr/vAT66TG2qAr/vvb8UuAH4nfB5rHS7ZoBXee9fDFwJ3OycuwFLivgh7/1FWDGad4fj3w0cDc9/KBy3XHgvVphXWA1tysjIyMhYo1hpi9V1wC7v/VPe+zKWyO7W03Fh7/13sMR4KdKK782V4D8dqtrfjZWJOGcZ2rTfe39/+HsMIwxbV0G7vPd+PPzbEn498CrgC8dpl9r7BeDVLi3utkRwzm0Dfhn4RPjfrXSbMjIyMjLWNlaaWB2vEv1KYVNS/uJ5YFP4+7S3M7iqrsIyTK94u4LL7SdYTbY7gSeB4VCDrPnas+0Kr48Ag8vQrA8Df0jMyD24CtqUkZGRkbGGsdLEatUi1M1akVwUzrlurOjs73nvR1dDu7z3Ne/9lVgh1+uAS053G1I4524BDnrvf7yS7cjIyMjIyEix0sTqtFaiPwUckCstPB4Mz5+2djrnWjBS9Rfe+79ZLe0SvPfDWLHZX8BcjyrknV57tl3h9T7gyBI35WXAG51zuzEX8quA21a4TRkZGRkZaxwrTax+BFwcIrlagbdiVddXCqr4DsdWgv/NEIV3AzCSuOaWDEHz80ngUe/9B1dRuzY45/rD3x3AazH9113Am47TLrX3TcA3/RJnovXev997v817vwPrN9/03r99JduUkZGRkZGx4pnXnXNvwLQyReDPvff/4TRd96+Am4D1wAHg3wB/C3wO2A7sAd7svR8KhOcjWBThJPAu7/19y9CmG4HvAj8l6ob+GNNZrWS7rsCE30WMjH/Oe//vnHMXYNaiAeAB4De89zPOuXbgM5hGbAh4q/f+qaVuV9K+m4A/8N7fslralJGRkZGxNrHixCojIyMjIyMj42zBSrsCMzIyMjIyMjLOGmRilZGRkZGRkZGxRMjEKiMjIyMjIyNjiZCJVUZGRkZGRkbGEiETq4yMjIyMjIyMJUImVhkZGRkZGRkZS4RMrDIyMjIyMjIylgj/Pzp9EN2R7OsDAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_overlay((ccf_to_template_deformed), \n", + " (template))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ea2a1b00", + "metadata": {}, + "outputs": [], + "source": [ + "for loc in [0, 1, 2]:\n", + " plot_reg(perc_normalization(ccf_anno), \n", + " perc_normalization(ccf_norm,\n", + " ccf_anno_to_template_deformed, \n", + " f\"{figpath}_{loc}\" , title, loc=loc, vmin=0, vmax=1.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b361323", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "###############################################\n", + "# apply transform\n", + "ccf_to_template_deformed = ants.apply_transforms(\n", + " fixed = template,\n", + " moving = ccf,\n", + " transformlist=ccf_to_template_transform_path,\n", + " whichtoinvert = [True, False]\n", + " )\n", + "\n", + "print(\"\")\n", + "dataset_id = \"\"\n", + "plot_antsimgs(ccf_to_template_deformed, \n", + " f\"{outprefix}/ccf_to_template_deformed\",\n", + " title=f\"ccf_to_template_deformed\", \n", + " vmin=0, vmax=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "63767067", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['/root/capsule/data/spim_template_to_ccf/syn_0GenericAffine.mat',\n", + " '/root/capsule/data/spim_template_to_ccf/syn_1InverseWarp.nii.gz']" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ccf_to_template_transform_path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cd176af7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e122af36", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c799b576", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['/root/capsule/data/spim_template_to_ccf/syn_0GenericAffine.mat',\n", + " '/root/capsule/data/spim_template_to_ccf/syn_1InverseWarp.nii.gz']" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ccf_to_template_transform_path" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f19f48f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkMAAAE0CAYAAAAv9jd/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAAsTAAALEwEAmpwYAADYa0lEQVR4nOz9aXCk6XUeCj5v7vuGHVVA7dW19MruJlskLXExTYktqS+1ULRkWfLoWuOwFbbDV7ZkO+7Yc8P2SI4J2/LIYw/HcpiSr0TJsmRtFCUNRYqiyCbZzW52dVd3de0FoLAj9w1I5Ds/Mp+Dkx8StXShCkDhfSIyACQyv+/LL9/lOec85xxjrYWDg4ODg4ODw36Fb6cvwMHBwcHBwcFhJ+HIkIODg4ODg8O+hiNDDg4ODg4ODvsajgw5ODg4ODg47Gs4MuTg4ODg4OCwr+HIkIODg4ODg8O+hiNDDg57DMaYR4wxrxpjysaYv7vT13M/YYw5bIyxxpjADl/HNWPMX77D137cGDNljKkYY56639d2NzDG/HNjzH/b6etwcNhtcGTIwWHv4R8B+IK1Nmmt/fdbvcgY81+NMf/iXk+2Xce53zDGfMAYM73T1wHg/wngp6y1CWvtKzt9MQ4ODreHI0MODnsPhwC8sdMX4bAl3vH3Y4zxb/O1ODg43AEcGXJw2GEYYyaMMb9ljFk0xiwbY36x+/zfNMa82Q2HnTfGvMsY86cAPgjgF7thmJNbHPMnAfwIgH/Ufd3vdZ8/bYz5ojGmYIx5wxjzvbe5tq2OM26M+R/da76qw3XdUMx/N8b8t+61nzPGnDTG/GNjzEI3hPRX1Ou/aIz5fxhjvm6MKRljfscYk9viev6GuidXjDH/1+7zcQB/CGC8e52V7jX6jDE/a4y53L23v7HVsT3n+VFjzPXue/6p5399j2mMCRtjKgD8AL5ljLl8u3ve9br9R2PMZ40xVQAf7Ibk/qEx5jVjTNUY80vGmBFjzB92P/f/zxiTVcd4zhjzle7xv2WM+YD63xFjzJ913/cnAAZv99kdHPYlrLXu4R7usUMPdDdOAP8WQBxABMD7AfwggBkAzwIwAI4DONR9zxcB/K93cOz/CuBfqL+DAC4B+CcAQgA+BKAM4JG7PI4PwMsA/m/d4xwFcAXAR7v//+cAGgA+CiAA4JcBXAXwT7vX8DcBXFXH+2L3sz7avQf/A8B/6/7vMAALIND9+3kAx7r35DsA1AC8q/u/DwCY9lz73wPwIoCDAMIA/j8Afu02n/cMgAqAb+++598AaAH4y3dyzO71Hr+Te969t0UA7+ve1wiAa93jjwA4AGABwDcBPNX9/58C+Gfd9x8AsAzgY933f6T791D3/1/tXn+4+3nKvLfu4R7usfFwniEHh53FuwGMA/iH1tqqtbZhrf0ygP8VwL+21n7DdnDJWnv9Hs/1HIAEgJ+z1q5aa/8UwO8D+Kt3eZxn0dls/4/uca4A+P8C+KR6zZ9ba//IWtsC8N8BDHXPuwbgMwAOG2My6vW/Yq193VpbBfC/A/hEv5CRtfYPrLWXu/fkzwD8MYC/dItr/VsA/qm1dtpa20SHqP2AubUg+wcA/L619kvd9/zvANrv8Jh3cs9/x1r7F9batrW20X3u/2WtnbfWzgD4cwBfs9a+0v3/b6NDjADgrwH4rLX2s933/wmAlwB8zBgzic539b9ba5vW2i8B+L1bfG4Hh32LHc3QcHBwwASA613S4H3+8jafaxzAlLVWb+zX0fEu3A0OoROOKqjn/Ohs2sS8+r0OYMlau67+BjokgceY8lxTEH1COsaY7wLwzwCcRMcTEgNw7jbX+tvGGP2Z19Hxusxs8Z5xfT3W2qoxZvkdHvNO7vkUNsN7/7x/J9S1/KAx5nvU/4MAvtA9d75LMPW5J/qcz8FhX8ORIQeHncUUgEljTMBDiKbQCQfdC6zn75sAJowxPrU5TwJ4+y6PM4VOmOvEPV6fht6gJwGsAVjSzxtjwuiE0P46Ot6UNWPM/0QnZNbvOnmt/xdr7V/cxbXMAjitzhsDMPAOj3kn97zfdd8pptDxqv1N7z+MMYcAZI0xcUWIJu/xfA4ODyVcmMzBYWfxdXQ2358zxsSNMRFjzPsA/GcAP22Medp0cLy7ud0N5tHR8xBfQ0dj84+MMcGu0PZ70Alb3c1xvg6gbIz5GWNM1BjjN8Y8aox59i6vT+OvGWPOdInH/wHgN5UniQiho31ZBNDqeon+ivr/PIABY0xaPfefAPxL3jtjzJAx5oXbXMtvAvhuY8z7jTGh7vXotfJujvlO7/md4r8B+B5jzEe730PEdEoMHOyGVV8C8H83xoSMMe/vntvBwcEDR4YcHHYQ3Q3/e9ARSN8AMA3gh6y1/x3AvwTwq+iIXv8ngNtmQXnwSwDOdLOM/qe1drV7ru9Cx+vy/wbw1621b93lcdYBfDeAJ9ERRi+hQ97SWx/itvgVdMTEc+iIhDcVk7TWlrvP/waAPIAfBvC76v9vAfg1AFe61zoO4Be6r/ljY0wZHWHye251IdbaNwD8HXTu/Wz3XLp+0R0f8x7u+R3BWjsF4AV0BNqL6HiK/iE21vYf7l7bCjrhxV/ejvM6ODxsMNY6j6mDg8POwRjzRXQynP7zTl+Lg4PD/oTzDDk4ODg4ODjsazgy5OCwh9Et4lfp8/iRnTjOXoEx5ke2+LyusreDwz6EC5M5ODg4ODg47Gs4z5CDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrODLk4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrODLk4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrODLk4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrODLk4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrODLk4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrODLk4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrODLk4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrODLk4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrODLk4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrODLk4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77Go4MOTg4ODg4OOxrBHb6AhwcHBwcHBweLnznd36nXVpauuPXv/zyy39krf3O+3hJt4QjQw4ODg4ODg7biqWlJXzjG9+449f7fL7B+3g5t4UjQw4ODg4ODg7bDmvtTl/CHcORIQcHBwcHB4dthbUW7XZ7py/jjuEE1A4ODg4ODg7bDmvtHT/uBMaYa8aYc8aYV40xL3Wfyxlj/sQYc7H7M9t93hhj/r0x5pIx5jVjzLtudez7QoaMMd9pjLnQvYifvR/ncHBwcHBwcNi92G4y1MUHrbVPWmuf6f79swA+b609AeDz3b8B4LsAnOg+fhLAf7zVQbedDBlj/AD+Q/dCzgD4q8aYM9t9HgcHBwcHB4fdi/tEhrx4AcCnu79/GsD/op7/ZdvBiwAyxpixrQ5yPzxD7wZwyVp7xVq7CuAz3YtycHBwcHBw2Ce4SzI0aIx5ST1+st8hAfyxMeZl9f8Ra+1s9/c5ACPd3w8AmFLvne4+1xf3Q0Dd7wLe431R94Pwwzx9H67DYf9gyVo7tNMX4eDg4ODQwTvw+Cyp0NdWeL+1dsYYMwzgT4wxb3nOaY0x78jNtGPZZNbaTwH4FAC804t3cOji+k5fgIODg4NDL7Y7td5aO9P9uWCM+W10IlHzxpgxa+1sNwy20H35DIAJ9faD3ef64n6Eye7qAhwcHBwcHBwePmynZsgYEzfGJPk7gL8C4HUAvwvgx7ov+zEAv9P9/XcB/PVuVtlzAIoqnLYJ98Mz9A0AJ4wxR9AhQZ8E8MP34TwODg4ODg4OuxTbXGdoBMBvG2OADnf5VWvt54wx3wDwG8aYn0AnSvCJ7us/C+BjAC4BqAH4G7c6+LaTIWttyxjzUwD+CIAfwH+x1r6x3edxcHBwcHBw2J3Yhiwx7/GuAHiiz/PLAD7c53kL4O/c6fHvi2bIWvtZdFiZg4ODg4ODwz6Ea8fh4ODg4ODgsK/hyJCDg4ODg4PDvoYjQw4ODg4ODg77FtutGbrfcI1aHRzg+uk5ODg4bDceUDuObYHzDDnse6h+eh9Bp2L6N4wxv2utPb+zV+bg4OCwd7EbSM6dwnmGHBxcPz0HBweHbYfzDDk47C3ctp+e66XnsI1wvfQcHnpYa7e76OJ9hSNDDg53ANdLz2Eb4XrpOewL7AaPz53CkaFdiG65cfnpRb8BtpcG3S6E66fn4ODgsM3YS/uSI0O7CMaYnsdW8A4wa628nv/bS4NwF8D103NwcHDYZuylfciRoV0CTYJ8Pl8PGTLG9Awq7+/9/u8lRw5bw/XTc3BwcNh+7KX9x5GhXQBNgkiEtgqV9fP86Ofa7baQo35EyaE/XD89BwcHh+3DbskSu1M4MrTD0KSHZEgTIk2GtiJA/KnJD4mR8xI5ODg4OOwE9tKe48jQLoDP54Pf70cgEIDf74ff7+8JlfULg3lJkJcAtdttefRj6HtpkDo4ODg47D3spX3GkaEdhA6PBYNBhEIhhEIhIUTAZm9QPxKkCY+1Fuvr62i321hfX5eHPgbPvZcGqoODg4PD3oKrM+RwW2giFAgEEA6HEY1GEQwG4fP5tvTq9CMxXl2R3+/f9NxWhEjDkSMHBwcHh+2A0ww53BVIhjQJarVaW4a3gN5BRubt9RgBGzokggRLv16DRMtpjBwcHBwc7hV7aQ9xZGgH4K0nRBLSarUAbCYttxJR9xNSE/0y04wxtyVFDg4ODg4O94q9tL84MvSA4a0fRKyvr/d4e243iG5Vd0gfW3uH+hEwLynyeoccHBwcHBzeCRwZcuiLrQiG11PTTyfUD1vVHPISLm9BR56POiJXtdrBwcHBYbuxl/YUR4Z2GPTO0DN0q1YbtzsOf/I93vCYz+eDtVYIkTFGMs+2Css5ODg4ODjcLZyA2qEv+hEMnRqvw2T9XnenhEiTIq+AGkDfkJnWKvG9Dg4ODg4O94K9tJc4MrTD8Op2+pEenU7v/b/+X79wFz1A+r0UVmuB9dra2p5j8g4ODg4OuxeuzpDDJtzKu6MJUb+O9XfiGbpVCn6/th7elh9erZLra7Y/sFUZhe367u/2OG7MOTg8PNhLc9l3uxcYY/6LMWbBGPO6ei5njPkTY8zF7s9s93ljjPn3xphLxpjXjDHvup8Xv9fQTw/krSTd7+F93Vbp9Vsde6tjAp3NhxWv2QbEYf/gVuPnVrhTXdndLoZ7afF0cHDYGv32rVs9dhp3svP9VwDf6XnuZwF83lp7AsDnu38DwHcBONF9/CSA/7g9l/nwwSt49pKXO3nuTgeQlxTp4wGdjY190frVJnJ4ONHPC3mnr79bb8+DghuvDg67Bw8VGbLWfgnAiufpFwB8uvv7pwH8L+r5X7YdvAggY4wZ26Zr3bV4pwuwlxD1Iyve0NWt9EH6evqF2vjQvct0eM7n88nDYe/hbsfh/ViEtkoUeKfHeief6W7f4wiUg8P9wV4iQ+9UMzRirZ3t/j4HYKT7+wEAU+p1093nZuGBMeYn0fEeOaBXo6MXdG2Je4XU3oX/TvQWWlDtfS2JkNYROexe6DHgHTf347u7k2Nu53n1se7kc+n70O957+9bnceNeweH7cFemkv3LKC21lpjzF1/YmvtpwB8CgDeyfu3E/e6AN7Ne29lud5qwb6dqFqTp602Re1N0mEya21Phpnf7xfS5CVhDg8eW93/W3kH7zfuJ+nqB47DW43FO3l+K0/qTt5LB4eHFXtpPr1TMjRvjBmz1s52w2AL3ednAEyo1x3sPrersZNfmCZA+rl+np+tnvfiVtavd2Ow1sLv9wNAT5iMBRr30mB+WHG3ZPtB4E7Os50hM753O72WW3mSHBwc7h17bW69UzL0uwB+DMDPdX/+jnr+p4wxnwHwHgBFFU5zuAW8pKifR8ZbUdqrqfC+13tsfSyv50c/6CXiMffSgHZ4Z+g31u6U8Pj9fgSDQcRiMcRiMUSjUUQiEYRCIQQCnSXGWotms4lyuYxSqYR6vY56vS4tYe70fPcrDOfg4LD9eKjqDBljfg3ABwAMGmOmAfwzdEjQbxhjfgLAdQCf6L78swA+BuASgBqAv3EfrvmhRr9Q2VYkx0uOvM/r43n/1hoTEiOvZ8jn8931ZuVw/3A3upm7xa10NDxuIBBAKBRCNBpFPB5HMplEJpPByMgIcrkc4vE4wuEwAoFAX82btRa1Wg31eh21Wg3Xrl3DjRs3sLS0hFqt5saXg8NDhr00p29Lhqy1f3WLf324z2stgL9zrxfl0Et8+oXS+nmH+pGgfuEu/bf+3VuI0Qmpdw63E/puhe0UA/t8PkSjUQwNDWFychLj4+MYGBhAIpFAOBxGMBiUMcN2Mt4sSN33zufzIZlMIp1Ow+fzYWJiAuVyGeVyGZcvX8Ybb7yBfD6/pTV5NzolN24dHHYee2kOugrUewBeMuQlQN6/dYiNXh+tj+gXy22322i1Wq6+0C7BTm34xhiEQiEMDw/jkUcewSOPPIKhoSGEw2EA2FT+wdvPThNrAPD7/T3EaH19HWtra/D5fAgEAhgcHEQul8Pk5CSefvppfP3rX8err76KarXa9/q2+rzee3G392WvkSdjzHcC+AUAfgD/2Vr7czt8SQ4OPdgvmiGHd4B3QjC8HiJNjPo99Hn6hcS8mTOaNBHsau+wu3G7TL/bLUT6vT6fD4lEAkeOHMGTTz6Jw4cPIxaLwdpOXapWqyWh00AgsMmL6K1N1W+stdttrK2tYXV1Fc1mE81mUz6D3+9HJpPB93zP9+Dxxx/HH/7hH+LGjRs943CrTLA7/ay3et1eWrSNMX4A/wHAR9ApX/INY8zvWmvP7+yVOTj04j4Ya34ALwGYsdZ+tzHmCIDPABgA8DKAH7XWrhpjwgB+GcDTAJYB/JC19tqtju3I0APA3WZ+9UM/UbTekHQ3ev4f6A2T9TtPv3BZvyrVDrsH21HyQB8jlUrh9OnTeOaZZzA2NoZgMCgEyO/3IxQKIRgMIhgM9q1U7tWsaeKtwWM2m000Gg3UajXUajU0Gg3REyUSCZw8eRKHDh3CF77wBXz1q19FuVy+K2K3Fe70Xu0BL9G7AVyy1l4BgG7CygsAHBly2FW4D/Po7wF4E0Cq+/fPA/i31trPGGP+E4CfQKfzxU8AyFtrjxtjPtl93Q/d6sCODN1HeDeDrUJQtxI8a2xFavp5hXRYTL/f6/Hxep7W19fvSpuxG2GM+S8AvhvAgrX20e5zOQC/DuAwgGsAPmGtzZvOh/0FdIT/NQA/bq395k5c993gdhu2V4Df77WJRAKnTp3Cs88+i8nJSfj9frRaLbTbbQSDQYRCISFCgUBAiJAmRN5wmA6d6XGtQ2T6mHz/2toa1tbWUCwW0W63MTw8jO/7vu/DY489hj/+4z/GhQsXsLq6uukzbeUt2kpvtZ2kaQfRr7jte7wvMr2FbZ9+ANfl8JDCWvuOdBPbOZeMMQcBPA/gXwL4B921+0MAfrj7kk8D+OfokKEXur8DwG8C+EVjjLG3uCBHhu4TvISHmTjhcBihUEhEp61WC2tra/L77bwx3g2gn37Iex3aUufDW3RRv/ZetBe7BP8VwC+i4yYl2E/v54wxP9v9+2fQ20/vPehMpE0by07jbjUx/V7LYwQCARw9ehTf8R3fgaNHjyIQCIgAOhqNIhwOi0BaEyGOYT7v9/tlLFFzpscwxyL/9hJtTZ5WV1cRDAbRaDRQLpcBAMPDwzh79iyOHDmCV199FZ///Odx/fp1udY7+ex387+HDXYXFbZ12J+4y/k2aIx5Sf39qe4YJv4dgH8EINn9ewBAwVrb6v7NjheAMhistS1jTLH7+qWtTu7I0H2GMQaRSATDw8OSgpxKpRAMBmGtxdraGgqFAhYWFrCysoJSqYRms9mz4PcLkW3lHdKv40a1la5oK+u5H/bSJmKt/ZIx5rDn6RfQKREBdCyIL6JDhl5At58egBeNMRnTLSj6gC73trhXcbB+XzKZxPve9z4899xzSCQSMs4ikQgikYgQIZIe7cXxenS0nkhrivoRIR22ZV2i9fV1hEIhRCIRABCvU61WQ7lcxtraGur1OrLZLN773vfi1KlT+PKXv4yvfOUrWFxc7Ktr6zeu78RLtsewJ4vbOuwvbOW5vQWWrLXP9PuHMYae/peNMR/YhsvbBEeG7iOMMYjFYpicnMTx48cxMDCAeDwumw43hUAggFKphMXFRVy+fFlqrzAssNXivtVA09b37YTW96o92UO4p356Zgd66W31PXu/rzv5/owxGBsbw8c+9jE88sgjADrjIxwOS5FEeoO0B9NLgLyhL3qEGOYiMfLqz/SDz1GMzUw1ekgBoF6vo9FoYG5uDpVKRYyI559/Hu9617vw5S9/GV//+tdRKBTks+ifGlsRSS9J2ur9uxDfAHCiKx6dAfBJbIQKHBx2DbYxEed9AL7XGPMxABF0NEO/gE4z+EDXO6SNAhoM08aYAIA0OkLqLeHI0H0ACUcsFsP4+DgmJiaQyWQQiURgjEGj0UCj0ZANh1V7JycnMTQ0hOPHj+P8+fO4fv06KpVKj1ZCnwPoT3j64Z14ffbIxnDXsPbu++ntRMjhbr6XWxEiv9+P06dP42Mf+xhGRkYkVBaNRnuIkPYGkRjpAorABgFiZhizwkiEdOo9r0k/xwc9UjQImASwtrbWQ5RYtZo/0+k0RkdH8X3f93145pln8MUvfhHf+ta3UK1W73q87tVwcNft/1MA/gid1Pr/Yq19Y4cvy8FhE7ZrXllr/zGAfwwAXc/QT1trf8QY898B/AA6GWU/ht5uGD8G4Kvd///prfRCgCND9w2BQADZbBbDw8NIpVLw+XxotVqim9BhBG4M4XAYkUgEx44dw+DgIC5fvozz589jbm4OzWZzU/p7P31QPwvXa5FvBR3e2Eubwx3ioeqnR9wuLBQKhfDss8/iox/9KBKJhIRt4/G46INIfrROyO/3iyaI5IUCaBIf/t6PCOn6Q14y5NWxeQkX/0dC1Gg0JJzMjLN0Oo3Dhw/jk5/8JB5//HH86Z/+KS5fvoxWq7XlfXmYYK39LDoV/x0cdi0ewBz8GQCfMcb8CwCvAPil7vO/BOBXjDGXAKyg4z29JRwZ2maYbs0UVtqNx+M9mTbcYDRxYRG6tbU12RzS6TSeeOIJDAwM4Jvf/CauXbsmLQvuJESiQyz9HvsQD2U/vVuFhcLhML7jO74DH/rQhyQsm0gkNhEhHRbr5wnykh4So36EiMTe6xnS406TIW/IjMYCX0titrq6ikajgXq9jlarhUajgWQyiXg8LnWRvvjFL+Iv/uIv7igV38HB4f7ifu011tovoqP5hO2Ul3h3n9c0APzg3RzXkaFtBi3vZDKJRCLRU8CQKcskPNr65gakO8hHIhEcOXJENq8LFy70NLfU59Q6IO/z3gyeW137w7CJGNdPD5FIBB/+8IfxgQ98QMTPyWQSqVRKeoj1qx+kPUFesqMzxvrphPg70N/L2I+Q61YdOgS3vr6OdrstouxIJAK/349Go4HV1VW0Wi2srq6iVqshmUwimUziYx/7GI4dO4bPfe5zuHr1ak9fPX1ND8MYd3DYC9hLc82RoW2EMUa6dzNDBtjQWTC0xUJ2TFfWjVHD4TB8Pl/PRsUaMNFoFG+++SaKxaKEJRhOAHp7i2nQ8tbE7CEOh8Huo356/Tb3UCgkHiGOKTZVpWeIITF6LTmOrLVYXV0VMTOJST8C5H2eJEXXGiJ0WFeTHU2UdBiOREYbB+yFFggERGDNIo71eh3JZBJnz57F8PAwPvvZz+Kb3/wmVldX5fj65+3Ciw4ODveOvTSfHBnaRvj9ftH9kKDozURnkHmtclrm3KC48PM18XgciUQCkUgEr7zyCkqlkmw8DK95yZC+BqY0u+rSDx80+fX5fHjuuefwkY98REh3Op1GKpVCIpHoCZNRx0biQm8LyYj2DvF5kh9NXCik9r6XhIYEJhQKwefzyXs5N/SDniVgo5Cj/px+v18SEXi+er2O1dVV1Ot1pFIpZLNZfP/3fz9GRkbwhS98QeoW8RhbeUid58jBYXuxl+aSI0PbBHpzotGoEBktJCWYShyJRBAMBkW7QQ9RNBoFAPEQkTilUimk02kkk0khRMvLyyKsXltbA7BRq4Xot5n002847E14v98nnngCzz//vIyzTCYjobFYLCaZi6FQCADEu7i6utpDePoJpTVZ8vYYazQa8pMPNv6ltzSVSonHVJMqnVTA+lskSvxc2gNqjJE5Qy0RSZgmRR/60IcwODiI3/u938Pi4uKm+3W7++ng4HBv2EvzyZGhbYAxRlLkI5FIT00W76IObFSjjkQiiEaj8j4KXEmWqDGixRoMBjE+Po6BgQGEw2F84xvfwNLS0qaKvFqLxGJ42iOk+5V5u447crT3wO/syJEj+PjHP45IJIJQKIRsNot0Oo1EItEjmKZYn2NUC59JKPoRI018+DcLJJbLZVSrVdRqNSHm2uNZLpdRKpUwODiIeDwuJIzjtB+0V5XH0w1h+TdT8Hk9JESZTAaPPfYYkskkfuu3fgtTU1NyvwA35h0c7if6OQN2MxwZukdwQY9Go1JQURep05k0DEloPUQoFJLwBQnS4OCgCK2DwaBsToFAQMIc9PC89NJLqFQqAIBoNIp0Oi2EyRiDSqWCQqGA2dlZ2biazWaP4NVLiBz2Fqy1GBgYwA/8wA8gnU4jGAwik8kgk8kgmUxu8gatra3J+NEtNOjt8T4YAqM2p1aroVqtolgsolAooFAoCLmKx+MYGxvD6Ogostks4vE4Wq0WSqUSlpaWUCqVUCgUJNzFcLGXFPF3eo70wuoNBevQMr1SHOfpdBoTExP4xCc+gc985jOYmZmRe6bhCJGDw/ZjL80pR4beIXR6cDgcFu8O3fcMlZEQkQBpbYTtFp0jKUqlUqLtYN0hWtHs8l2v15FIJPDYY4+J7uLGjRuIxWI4cOAAHn/8cTz11FMYHx+XMEKxWMTU1BSuXr2Kixcv4q233sLU1BQKhQLq9bocx1ssz2FvIBQK4bu/+7sxMTEBv9+PdDqNbDYrY4mFFf1+P5rNphBtLYJmuGmrsBcJEMlPoVBAuVxGq9VCNBrFkSNHcOTIERw8eBCpVEo8UF6DwFqLer2O5eVlXL16FfPz84hEIsjlclKJmtAZaVqD5CVDNEi0NqlWq4kHa21tDSMjI3jhhRfwmc98BisrK5vGuBvvDg7bj700rxwZugfQc0NBqvYK8cFQGTceHa7yCld9Pp8UaGQ9lVarhWAwKBuFrl595swZxGIxLCwsIBqNYnBwEJOTkxgbG+vJVpucnMSjjz6K1dVVVKtVXLx4EX/6p3+KL3zhC3j77bd7qly70MHegjEG7373u/H0052m5Lq+VTweF40ZgJ4QGTU23tBYvV6XR7VaRbVaRblcRqFQwPLyMlZWVlCtVtFutyV76/Tp0xgdHRWdmybUJETU/Pj9fqRSKYyMjOD06dOYnZ3Fq6++ivn5eQSDwR6DwlvBmkYFvUg8l04coMeJPc5qtRry+TystTh06BA+/OEP43d+53cky2yrEJ2Dg8O9Yy/tIY4M3QMYHqNXSGeJ6XR5YCN+ytCE1mBQSK2zb7hB1Wo1GGOk6m40GhWLN5PJ4D3veQ9CoRDW19dRq9Wwvr6O+fl5tNttpNNpeQ/Py9YMY2NjGBoawm/+5m/irbfeEktah80cdj9GR0fx0Y9+VNq/sL4VQ7YM366urmJ9fX1TPR9dzLBWq6FSqaBSqaBcLqNYLCKfz2NxcRErKyuoVCpYX19HNBrFyZMn8cQTT+DAgQM9Hh2OH2+5Bwr7+VrOh0OHDmFoaAg3btyQc1QqFRSLxZ4UfmBDg+Stkq1LA+iq1vF4HIFAQMhcMBjEE088gbfeeguvv/66XPNeWrAdHgw0udZhXI4zjm9dXkJr7xzuX9HF+wVHhu4B4XC4Z+PR/Zy0NcyJQwLEjSEYDKLZbCIUCslEajabPd2/V1dXhUQFg0EkEgkJbQGdScsQQjgcRr1eR7FYRKlUQj6fx+DgIMbGxpBKpeR8jUYDgUAAp06dwtmzZzE7OyubmA5nOO/QzuFO7n0wGMRHPvIRZDIZ2fw5Fvlg1fN4PC7aHn7X9AQxBFYqlUTTQxK0uLiIfD6PZrOJQCCAsbExPPnkk1IM1O/396TD85qZSaaJEecFQ1r0mMZiMRw+fBgDAwObKl7Tm1ksFrGysoJyuYx6vb6parYmXwQzPBOJBCqVCvL5PMLhMN773vfi6tWrqFQqbpzvY2iyw3HE32lI0MvobRejjVtdgoIGLg2K/U6O9tJnd2ToHUJvPt4O31zsvVWh6e2htoE1UlifqF6vo1KpIBAI9Ewy6ovq9bp4oUi0dEFHAGLpt1otLC8vo91uSy8qXhc3sGazKROeYC0ib5VrhweLO1lETp48iSeffBLWWvmOdef5WCyGdruNUqmEUCgkGWIkIRREUwtUKpWwsrKClZUVzM3NYXFxEaVSCe12G7FYDKdOncJjjz2GXC4Hn8+HZrPZ480EejO1mDFGUhQIBHqyGenBASDkhp5SenUACHGr1WooFAqYn5/H7OwsKpWKbFwUh3uvhQLraDQqXqfJyUkcPXoUr7/+uqu3tY/ArN94PC6lSuLxOEKhUI8GrV9fPW9/Pe/vHOuRSASJRAIDAwPI5/NYWFhAs9ncc16S7cJe+syODL0DcNCTmHiJkDcFmO8hGQI26gH5/X6xHviaVqsl3iKGNxgioFVPK0Y/X6lUJBSWTqell1m1WsXS0lLPeZkJlM/nUalUZGOjteTE1DsPrzWqEYlE8MEPflDGgCZCJBHUz+TzeckG41hjaIweoUKhgJWVFSwvL2Nubg4LCwviOcnlcnj66adx5MgRRKNR8fp4PZm6xhUJDM9Hws3QMj+TrnJNMsTQsA5NBAIBxGIxhEIh5HI5TExM4MaNG5ienkalUtlE6r2FKHlfSqUS0uk0HnvsMVy8eBH1ev3+fHkOOw62cSH5YXal1rZ5C9BqI5BjkFXQdRVznd1IY1WXofD7/RgaGkI2m0WpVEK1WhVPZ6PR2Dceo730GR0Zegfo5xXy6hiAXiuDYEhBe4705sICeAx3cJOJxWJYX18X8aq2eP1+PwqFAprNJsLhMMbGxmTDIxEql8vw+XzIZrNIJBJoNBq4fPkyXn/9dSneqAWv1C057By8BRV1dtXJkydx/PhxWGsldV6HjVqtFvL5vJAXrWegR5JESGuDSISq1SqstRgeHsa73/1uHDx4UMo80LMEQMi3N2mAXqdGowFrLUKhkGwCqVQKsVgMQG8tIXoxq9UqVlZWMDw83GO18374fD7kcjkkk0lks1lcunSph9QwS9Obqh8KhaQW0qFDhzAwMICbN2/uuHfIGPNfAHw3gAVr7aPd53IAfh3AYQDXAHzCWps3nQ/1C+j006sB+HFr7Td34rp3I4wxkkwyPDyMTCYjGk6t+eHvXoLD3wn9nPYYaUKkCT09/tqoHR4e7jleuVzG/Py8tFV6WOHqDD3koFfIS4S8fcaADcLjHRQMURCs0cIii7TiWVcolUpJLDocDotlo8NvDGUEAgHZAIvFoniA2u02MpkMWq0WLl++jFdeeQV//Md/jMuXL/f0b2K2jk6JdnjwuJVHLhwO49u//dt76lTRS8kH0BlXJCBcdNfW1no0QsViEcvLy1hcXMTs7Czm5+elGfDQ0BCeeuopDA4OiqeHP/m7DtNy/Pn9fjkPizAGAgFpstpsNiX9Htho1spjZbNZLC8vY2lpCUNDQ1IKgASdVn0wGMSBAwdgjMHNmzdRrVZ7GsV6vbOcM9VqFUNDQxgZGZFkgx3GfwXwiwB+WT33swA+b639OWPMz3b//hkA3wXgRPfxHgD/sftzX4NZigcOHMDQ0BBisZgYpt4WR16Pqw6BeX9yTdQEqJ+HiGQoGAz2NCz2lpbgOn3kyBFUKhXMzMyIB/ZhxF76XLclQ8aYCXQm6QgAC+BT1tpf2K+WC0XMbLuhw1XUAunw0lapu1o/xM2k1WrJ+xkKYyo9046DwSCADYuaRIbaCW35UFjN7JxLly5hamoKFy9exLVr17CysoLV1VUJQ9DdC/Rqh7yWucP9h/de67+PHTuGEydOAABisZiUdmCYjISZPbsotl9fX0ej0UClUukJjS0tLQkRqtVqkon46KOPiheRHh6OTZJzLvTUoSWTSfF0emsE0aPEEF00GhUjgsSIFdMzmQwKhQJmZmakeCMACStrnUYmk8Ha2hpisRgqlUpP2QoSJ2AjG42fZWBgYBNh2glYa79kjDnsefoFAB/o/v5pAF9Ehwy9AOCXbedDvWiMyRhjxqy1sw/ocncV/H4/MpkMJiYmMDQ0JIJnr8feS4Q0idGFR/VzXm+QJs3e8BqwUWqFEgc+pz1INEzoIY1EIpiamkI+n98NpHzbsZf2jDvxDLUA/G/W2m8aY5IAXjbG/AmAH8c+s1y0V0jX8dFtB/pV0e03IPTGoK3YUCgkCz6JDzeLWCwm1jFDEfQqkVSRTFUqFdkMZ2ZmcPHiRVy/fh2zs7NYXFxEo9GQzYSLBPUeOgtIT3inH9pZ8Dt67rnnZHEnCQqHw0LQ2RSY2Yj0plCPQ3K8srIiHqGFhQUhQpFIBI8++ijS6TTa7Taq1aqMJTZZZVYiw2SRSATpdBpAZwxT8M/2GAB6mrM2m82equv8HdjQYPAzUMidy+VkjHotct6bcDjcE7rgfeMc8/v98jnoPdilGFEEZw4dYxQADgCYUq+b7j63r8iQz+dDMpnEwYMHMTo6ilgsJm2MaBR4Pfb08mi9jl7f9Jji317oDDKvsJrXxbGoDQIej/OHBCwcDuPIkSMA8FASor20X9yWDHUn5Gz397Ix5k10Jt++s1wo4tTFFRlS0uExTYL6WfhaeMeFn6Sk0WiIUJRaIbZWYKq0ToPXne25QZZKJVy5cgU3btzAzZs3cenSJczPz0tmEK9bTzztyeIGwdc4QrQ7YK3F6Ogozpw5g/X1dRHv61538Xi8p5M7LVRmYzHlN5/PY2lpqUcjxLH16KOPYnR0VFz+jUYDhUIBxWJRxPa6tgoAydIplUrIZDI9xR05rqil0On9rLaux6QuphiJRLC2toZisYjV1VVkMhmEQiEZl7VaTf7H0BmwIeDWhEi3weHxvdqR3QhrrTXG3PUFGmN+EsBP3odL2lEEg0EMDAzg8OHDyGazPcksXJt1Ri+/X01CtM6nX6isn4dIv157hvSxSLhpGPN37g36uhgNMMbg8OHDWFtbQ7lc3tVj8W6xlz7LXWmGuq7cpwB8Dfdouey1iWpU2w3tFdIVdvk6YGurwvvQ+gdOJnYbj8ViGB4eRiKRkGaUfA/Poz1JPp8PKysrOHfunGgh2MJjbW1NXLjM5tGTXVtPPAdf04/UOTx4+Hw+PP3004jFYmJVhsNh2dwBiEXKwpz07jGLhWn0y8vLmJ+fx9zcnNRDaTQayGQySCQSQlzq9boQoeXlZZRKJVnAgY2ic9ZaadExMjKCXC4nIQs9fugV0oUUw+FwTw0uNiduNBoANjaQQqGARqOBZDIpuiRm6ejsM2DDEKE3is8ZY6RfGgmgd2zvEnI0TyPSGDMGYKH7/AyACfW6g93nNsFa+ykAnwKAd0KmdhtIgkZHRyU1nskDJEJ6DHjFzV4i5BVC9yM9/Z7nz7W1Nen9yPAuX6v7A3KNJlj/ivOIBsXY2FhPDbm9jr22b9wxGTLGJAD8DwB/31pb8rj/7tpy2WsTlSnBXOC92TP64R0AekLpZq26X1kwGEQsFkMwGJRmq2zYykVfF2xMJpNSi6XZbGJubk5aJxSLRTSbTanJUq1WJdOB4QgWXiyVSqIroVWjw2esDbPXBvbDiEQigSeeeEJSd+mdZGmHer2OdrstoSCSAF1ckbWEFhYWeojQ2tqaFJqbnp6WStH07jAcRoJNg4DQHp9wOIyBgYGeelnAhqiZYdhqtSobA7U89G4CG5XYAUjWZKPRwPLysoiqAcgY1echOdKhEb42GAxKmw5vKvUuGue/C+DHAPxc9+fvqOd/yhjzGXTkB8WHwet+KzAL9vDhwxgcHBQvKENi2htk7UaKuw5lad3OrTxCAHrWZz6v5wELgVarVdHW0RtKPR3X3unpaeRyOWSzWRn32svONRcAstks0uk0lpeX72gM3qr0xm7Bbr2ufrgjMmSMCaJDhP5Pa+1vdZ++Z8tlr4DCuH5eIa87Vr8H6E3N1KEFbbHyOCMjIzh79iyGh4fRaDRw5coVce/zfOFwWBYE6oZarZakJDcaDSwuLuL69es9OhB6hTQpo1W1srKCWq3W0zwWgGysuu4QP9teGuQPA4wxOHr0KHK5HFZXV5FIJHoKxXFjYDo7dTrtdls8QgyPMYU+n8/3hKsAiLckHA6L9oGki8cvFApyXh1upQcqn89L+wstxKfHUc8ZVky31iIajSIUCkn2GccZLWiWmyiXy2g0GkICSd4J7d3U7XC4+QBArVZDuVzeJIrdCRhjfg0dycGgMWYawD9DhwT9hjHmJwBcB/CJ7ss/i05yyiV0ElT+xgO/4AcEpslPTk5icnJSMni9RW5JyplQoomQ1/ujyZBX96NDY6wJpKu1s2Hx2toahoaG8NxzzyGdTstrSfbD4TBGR0cxPDyMarWK6elp5PN5ZDIZABvlVfTn5FwbHBwUT9NW9yQcDkubJaBj7LAy+26rX7SbruV2uJNsMgPglwC8aa39N+pf+8Zy4aTUXiF6aLQAeSvouDLT6mm5s4jciRMnMDw8jOvXr+PFF19EJBLB448/jtOnT2NgYACxWEyycEhWmKZMTQU70s/MzMikBdBTq4XXQ4FqPB5HIpHA4uKitGvgxOTEooVP/QfvyV4a6Hsdfr8fTz31lCzwHAOaWHNM6vCPLq5IndD8/DyWl5d7sgfL5bIs6EwUoBCVqfrWWinkqcO12qNirRXNWrValVYh3GjoseE8ovjZdsXe7PXH57VAmueMxWLyHhIrnVLv9fbosAkfJIhekfVOwFr7V7f414f7vNYC+Dv394p2HixaePLkSdEFcQ3WBW6BDe+l1gRxLOqCiDpUpgmRfp5kSpMR6uZY2uSZZ57BsWPHJMtSj0+9rgcCAalyPTU1hVKphEQi0ZMEQ5C4JxIJkT0Q2gOay+UwPj7eU5ZidXUVuVwOlUoFy8vLPeN6p7FbruNOcCeeofcB+FEA54wxr3af+yfYR5YLvULspk1viRbKAZvdll6LxNu/JhQKYWhoCGNjY5iamsJf/MVfoFKpIBwO46mnnpKNAehY7Jyo3PwajQauXr2Kq1evYmpqCgsLCygWiz1WsVfTpK+PRE67nRcXF9FsNuV/OuSgrS2HBwdjjBBmek20xovp8vS0kNDSnc9U+pWVFczPz2NhYaGnazvrUlHAz2rmq6urEn7TtbE0KaZ2R4coWq2WNF1l7z4Km3XldSYIJJNJABtNXlk/ieNWC1B5zZqs62xK70PPQa0dopbOYfchEong8OHDOHLkiKxLupYWxwLJC8esJjZa10MPD0mOJk3aIOBaODg4KMVpWZqEa+vJkyfx7LPPYnl5uafmlSb6nHscb6FQCOPj47hx44bMKS/55ljX18OiukBnzA8PD+PAgQNinPD6KXtgVufS0tKmEPBOYBeFnO8Id5JN9mUAW7k9HnrLhW5Jr1ZItwq4VYhMx6O1BcMquu12G1//+td7mmhaazEzM4MvfelLOHbsmGT3cNCzEWCxWMTMzAxKpZJsVHrj4ATV3hxN3HRWQzqdFotrdnZWNEW6Tgs3POcdevA4fvw44vE46vV6zxjkd10sFqVMA79jpr+Xy2UhQtSWtdud4m/Hjh3DyMgIGo0Grl+/jqmpKWnrorNluIl4xxDJ1MjICKy10iSYVnOj0UA+n+/pi8ffqXeKx+OYnJzE4OAgAPSdXzq8y40P6C3YqMMemrhrjQi9VMViEfV6vSeM7bCzMMYgnU7j1KlTGB4eFq9kLBZDIpEQgTTF/kwS0NmJJEAkSN6mvxx3NDSpNyKhpuEbiUR6RPy1Wg0AcObMGTEkmDGpQ278yTHL/0WjUSSTSansrucp1+B2u425uTmRMLBuEmUOw8PDSKVSWF1dFVLI6AANGQAYHByUhIbdQIj2ClwF6tuAwumtvEL99EKEtkhpxTAjLJPJoF6v48qVKz0uXG3BlstllEolzMzMCFHxLvq8RlolGtqa7ucl0qQG6IhUR0dHAQAzMzOy+fH9tML3GuPf6/D7/Xj00UfFta6LfGpdDAkxF2ktmmY9IS6QqVQKzz77LJ544gnE43FUq1Ukk0nxAmkPFBduLvAMWXBOHDp0CEePHkUgEMDy8rKQKmoftKZC6yOo+6CY+ezZszh48CDq9fqmKusUpebzealRxKJ1W2UC6ef0XFldXcXS0lJP1o4j9jsLn8+HkZERnDp1Cul0WjRqsVhMtJoAxBjUBIdkiPID/RyNS65tLFGiq+zr8BawWdZAD+vw8DDW1tZQKBRgjBHvpbUbJR1YwoKlLYwxMs4ikYh43b3rtc/nk9pfbKk0ODjYY4BTM8fPn8vlEI1GJcrAdcEYg2w2K6R/J0NVe2lOOTJ0C3Dj0dWmtQBUEyHtjeFPvThzopL112o1LC4uAthwd2q3PuPK3ARo0QAbxEY3etUhLVrA2vPjFa4StC4odKWbuNFoYGFhQUJuQK9niBaH20TuPxKJBCYmJqRCuVfEr70b1M/olhusMM3wWCQSwXvf+1586EMfklYv8Xgcq6urmJqaQrlc7iFWXv0Csxyt7dQ9OnbsmKQQp1IpZLNZ5HI5XLt2TTxR3hCrTh5gC5qXXnoJzWYTjz/+eA8Z00YIvWP1el1a1tBI0CRdh6m1V8jn80m/Pi02dWN45+D3+3Hw4EGcOnVKqpLrbDEWDNVp8VoyQF0cSQJfFwgEMDAwgFwuJ+VJuP5prz3HgV6HWZizXq9jcXER9XodIyMjUrWfYz2TyQhZotA/mUwimUxKxiTDygzD8TMDG977tbU1XLlyBdZaDA0NYWKik4Okz8Xw2Pr6OlZWVhCLxaQ6Oz1ltVpNjBTeu50s5riX5pUjQ7eAFpJyImmX6laiaa9HSFssfr8ftVoNKysrEiP2bhT09HCSckIwvVmfR29Uums4r1//ri0SEhy+n65foGPBDA8Po1wui2BWEyKtx9htMA9h+5gDBw4glUpJ6rm3zQDB71tXiC4Wi1hYWJDQJ4XYzz//PIaGhrC8vCzamVwuh5GREUxPT/dsFno8kyyzvMPQ0BDa7Tbm5+eFmIRCIcn+yWazmJqawvLysoQudJiA84nz69VXX4W1Fu9///sB9I5LABLi0B4rXW1aQ38GbTzQQ9bvPV6vqcP9BT2LJ0+elJpZzBhj7TWto/FqL5lBq7PI2Kg1k8kIISC82YMMY2ltke7jt7KygpWVFSQSCQSDQWn3YrqZvCQyJGs65MVrrVarPYSe45bHCQaDmJ+fR7lclvBYMpkU3R2TZoLBoGQLs7n24cOHcfDgQWSzWTQajZ42JKVSSdoslUqlHRnTe2keOTJ0C1CQprvRe8NMmnB4NQpcpDlZaGXPzc0JudEeIQCyENC12q9dACeR7n9zq7YCW3mHvMJv3XwzHo9L2EQfR6dK79KB/lC1jzHGSB8yAJs8JbqWD72E2mIuFAq4efMmisUiAODo0aP43u/9Xhw/fhxLS0uSis9aV7lcTgiKXtD5/2PHjuHQoUNiIFhrsbKyIpldehzS4o9Go7hx4wbm5uZQqVR6ykpw89KZa+fOncPq6iq+67u+SwTa3HQ4X3hvtAfIOx85F3ktoVAIpVIJFy9e3FIvtEvH9EOJYDCIo0eP4vjx4xLeYeiUHk6uRxyPJELaO0gikkgkMDQ0hHQ6LUaCHgNezyGwQa74oIelXq+jUqmgUqkA6BgK2ijgNfCYhUJBSk6QuMTjcZmj9OpyD9DGRbPZxPXr1xEOhzEyMoJkMikkjnvHxYsXEYlExAuVzWaRTCZx7do1lEolnDlzBslksqcNCc89MTGBy5cvP/CEgb0mp3BkaAtwYnLR14Ljfh4hPeG8OiFaHLQAtBhUpxxHo1Hp70QBsw7BARueHC78+pr0tWnyozdP72fwkjtugEzzXFpaArDhraKVrbVDuylUZh+y9jHBYBBHjhwRq9O70HFx1cUMSV4Yil1eXgbQqXD7sY99DM8884xUz2V9KY5fhhO06J8p72NjY3j88ccRj8dFxFqr1UTXocO7rVZLFl8WpIvFYpiZmcHS0pLMCep/mFXGefD2229jdXUVzz//PAKBQA9RBza3vPFmkHm9rbxXV69eFZGqHrO7aQzvB4RCIRw9ehQnTpyQ9YRp8wA2fT9aI0TdEAXU4XAYBw8eRCaT6Sm+2K/oIuFNDCARWlpaQqFQEO0c623xXH6/X0LI9HTy2gcGBoSEsYzF0NBQT6kIPY7pRX3rrbdQr9dx6NAhjI+PS0iM56JxUi6XEQgEcPz4cRw5cgTxeBzFYhGvv/46Xn/9dZw5cwbxeHyTt7TdbmN4eBjT09MPXFC9l+aUI0NbwGuleFN7vVYp4a1dQWYPQCYZ9RmaCCUSCWQyGbGEdbiLx9VWriZDOuylM3Y0AfJqnPg59E9usLqTPT1B3rCavge7FeYhaB/DUJQ3pV57YbRHRLv9S6US5ubm0Gw2kc1m8eEPfxgf+tCHEA6HUSqVZMHXYlGGKljAbn19HblcDkeOHEEymZTNikLRZDKJVCrVQ5YZtuDmRuIzMjIiWTBzc3OSUNBoNOQzUSzr8/lw+fJl/MEf/AE++MEPyufkT6/2Q3tj+fm9hR4LhQLOnz8voV+N3TyOHzaEQiGcOHECx44dkzVMZ3X1Iy469Lu2tibFZAcHBzE0NCShU2CzXtMb7iX512O/0Wjg5s2bEk7S9a+azSYWFxcxPz+P0dFRGbfMTKQRQsKWTCaRTqelPAWrpdNjpL1CKysrmJ2dRS6Xw4EDBzAwMCDFR621YmwMDAwgHo9jYGAAQ0ND8rpcLge/349XXnkFb7zxBh555BFp/8Hm3px7rEH0IMf6XppXjgxtAcaub+UN0mRAu101GdIpnhS90erhREomk8jlchIK8Ao7OTG17kHrLLz/u13IjD/1hgL0eomAjRRnXZZep47uZkJkHpL2MWyYSt2Yl9jy++DCrN391DsEg0G8613vwkc+8hEkEglUq1UpyknSq1OP/X6/hGAnJibwxBNPIBgMIp/Po1QqIRQKSXiLBN7bp69Wqwmh0pVyU6mUeLroodEi02aziWg0ioGBATSbTVy4cAHRaBSnTp0SzRRbc3gJkTZAdJNYhqRff/113Lx5s8frsNs8mw87AoEAjhw5gqNHj8r3R9KsiZD+XuhBJBFi6OrAgQPI5XJiJBB6HngrTvPhDXndvHkT+XxeSAvnAMX/q6urOHfuHIwxoqekXgnYWP+j0WhPMg3nlCYoWpZw4cIFhEIhTExMyNxstVqIx+MyR4vFIozplB3IZDJIJpNiNITDYZw8eRLBYBDf+MY38Nprr+HMmTPidVpfX0csFsPq6ioOHTqEt99++4H1PvOS2t0OR4b6gOGIfg32CG/8WU9iLcjjwFtaWuopG89BQpEpgJ7y7/1E1SQ82jvAzUw/vxVx40MTKGCzqFB/TvY+48aiP/dWAvKdhnlI2scYYzAxMSFjS3+3mgQQWi/EQnHNZhOTk5P4yEc+glwuJyGzWq0m3kkt6AQ2en0NDAzg/e9/P8bHx0VzxDFord2U4q9bY4TDYTEEmCqfyWQwPz+PZDKJI0eOSJ8x/ozH47L5cVyHw2GcO3dO0q0LhQJCoRDGxsYQj8f7Wv30aHHuGWOwsLCAN954Q2oxAXvLan0Y4PP5MD4+jqNHj8raRa2YlwgBG7Wj6GmkENgYg8nJSaluTn2Rfo/OKtO6Nx0y43hZXl6WMhCUJjBbstVqSQgsEAjgwoULKJfLmJycRCQSEe8qACEnDIdxHDKMzXvAtZyNjw8ePChZb+FwGMvLy3jzzTcxNzfXs39Qo8SwG+9ZJBLBsWPHEAgE8JWvfAWvvfYaTp8+LR4p1k5iP0u2v3kQ2EtzzJGhPmCIjIPJq8fhgk/oCawnH7tzs3p0IpHoyaaJRCKiEaIIkGRKEw9a3rrWkfYQ6CJ13DD5HDcsPvRrgA0ipwXfdBsz+0h7jrwtOXabVW06H+yhaB/j8/kwNjYm48IbquXCr6s/M5xQKBSwuLiIUCiEZ599FseOHcPKygrK5bKINrUXSFvLtF7PnDmDs2fPyuaiQ05au+P1VnFDYEaLFuVHo1HU63Vks1mcOHECpVJJrN98Po/BwcGecWi6iQKXL1/GqVOnUK/XcfHiRbz55puinQA2DAxvzS6go994+eWXsby8vGXWmb6vu2k8PywwxmBgYAAnTpyQJsC6rYaXCHFN0in0pVIJAEQf5G0TpA1Jb6iUzwEbnqNmsym99pgZFggEZJ2mbmd8fBzhcFjE2oVCAUtLSxgZGcHQ0BD8/k4DYRYbZVICr43eLy0AZxkLv98vwmeGC48ePQpjDGZnZ+WamUl27tw5NBoNPPfcc4jFYrImkyAGg0G8/PLLePXVVyUszcSEeDyOgwcPSnPmB4G9NJccGeoDhsi8VX4JbYkC6LFOvW56tiaIxWI9Yj5OOloRXiLEjYCuVa1f0h4gvkbrSILBoFhcW70H6O00zk2UHc4rlQoajYYQQ1pf3o1jF3qHHpr2MZFIRMiBl5QzRKZJuP4e2Xx3ZGQE73nPe7C2toZ8Pi86H2utjHFm5miSHo1G8eSTTyKZTKJQKMi44njzXhMXcy/Z1sSEonye6+DBg1hcXMSVK1fQbDaxtLQkrWFYuI5jjhtWOp3G/Pw8pqamcP36dQwPD+OZZ57B2NhYzzzknM3n87h48SKuXbu2KTwGbCY/e2nx3itgiOf06dNIJBLiVfQSoX5eTpKhUqmE9fV1TExMiE7GK0nQJNqrI9N/c47Qg8qK7MxG0+0u/H6/nNvn8/WEcK9fv463334bw8PDGBoaEkOAa3a73ZZxzL2E6225XEahUJDms9wH6vU6gsEgRkdHkc1mUS6XEQwGe8Joc3NzuHDhAtLpNNLpdI+xMjw8jG/7tm/D+fPnJQPt6NGjiEajPVW3q9XqA/nu99J82ldk6E6sPm+ITIuUNbwLqHeiNRoNtNttEeSx8i1JTiwWkxCUJldaJK2JDetH9CNnmghp4kQCpK+Rv2vriYsO63awtgUAEfJpwqYJ0G4jQ/Yhah/DLCt6f/hd0iukvwst4KzVauIFOX36NMbGxpDP52VhZVZMMpkUVz7RbrcRiUQwOjoqBEOnBbOVDMdxPw2bznhMpVKw1op3lN7Q5eVl+P1+vPe970Wj0cD8/DwqlQqmp6eRy+WkGSs/L/Ub2WwWhw4dQqvVwo0bN3Djxg3MzMzg+PHjePrpp5HL5SSccvXqVczPz+P69esyHwmuBXtpsd6rSCQSUlma+jbdaFV7woGNsUzjrFwuo9FoiEeI40GnxXtJkA6DaT0Z9XQkKisrK2i3Ox0BRkZGZH7Qq8/wL3V1xWJReu1FIhEZl4lEQspScA7m83nMz88DgIS3uA9cuXJFxNYs3pjJZEQIznlIInTs2DHRAFUqFeTzedy8eVPqH7HMgN/vRyqVwtmzZzE0NITr16+jXC5L+YpkMomJiQlcuHDhgYz9vTS/9hUZupMvhmRIF1fk8/08RPypyQWFfuwLFY/He2qr0GujhdR6odbaIE1q+vWkAjaIk45HU7znJS/62r3kjSXk9UJEosQFhe/lMb0ibIftQyKRkJCWHo+6rIHWodHqZAuOcDiMs2fPAuj0LuM4Wl1dxcjICNLptCz6bNOxvr4u7QDC4bAIQEnKdVqwDpUBG9WkddhWk/tarYZGoyH9lSqVCnw+Hz7ykY/ga1/7Gm7cuIF6vY6lpaW+FYNLpZKELg4cOABjDKamplCtVsUSHhoaQiKRQKlUEku7XC5v0sU5PBhEo1GcPHkSAwMD4hHiJg/06if5k7ov3VKGGVSBQGCTN8jr/fGSID60joc6NQAYGRnB+Pg4rO301qOeToe50um0CPe5PlprkUgkpKHr7OxsT4ZkPp8X73q1WpV+Z6VSCbVarSdMSDkFPbP0WAGd0hTpdLonwaZSqeDixYvIZDIYHx+XVjhMyGEGmt/vx+LiYk/B1kQi0ZMkcb+w14yNfUWG7gS6jDmATW5/YPOXzL+1+3V1dRXLy8sSH9fhMVZW5Xu1la9JDgmNrlzN93NRYRomAJnw1lqpAcN4Na0Sfb3r6+sSN6/VavI7K09r8R8FhV7sNs/QwwJjOv2FtPBSPwgtgichYv2gXC6Hw4cPS+PVSCQipJxVbkul0qbaJAzh8rj87mn1chFllhivg+NDi/m9+jdN4iKRCBqNBkZHR/HBD34Q58+fx4ULF1Cr1VCr1XrCckCnrgs9TMViUUjR3NwcyuUy1tbWMDMzI4QsEon0EKE7NYYe9AJu9lDVdO2tI7ba9ILBIA4dOoShoSH5mw2vSZS3Co/xQa/L4OCghOp1WKgfEdLZZNorREE/i5EaYzA2Nobx8XG0Wi1UKhUhI7reUaVSwcrKiowpbZwy/EQDlB5TenN5nzgvuT5zTLOwI71MCwsLqNVqWFpawuLiIprNJq5cuYJsNouhoSG0Wp0u9QMDA6jVarhy5YoIo6PRKFZWVgBAGtsmk0mpUbS+vi4Gdjgcvu9kCNg+w8MYEwHwJQBhdHjLb1pr/5kx5giAzwAYAPAygB+11q4aY8LozKmnASwD+CFr7bVbncORIQV6hXT7jVvpYjSp0FV/m82mDD72jaFmgpOs30KgNxQW8yL4Oi2ajsViSKfTsnFxAcjn89JDh+ekG5jHYpYPe1gxtu2tfK2rXGudhfe+OWw/+L0CG/osLzH3anNWV1dFlMzGlIuLi+JZ4oKYSCRkc+FxdTX0aDQqY5bWONPaaV1TT+bdGIHOOGUldd3lm2OcP8vlsrROeOKJJzA4OIhLly4hn8/L2KOhwIJ7QGcMF4tFtFotjI6OSh0hre3Q80ljF3oyd33VdK4jiURCDDBNUovFIiqVihh5JPNs/KwTQEgWvOFZL4mp1+swxvToeDQR0uNVe9g5F7g26+K31WoV5XIZPp9PvE1sns0aWHpdp3HAfn0sLRGJRJBIJMTYZcYbPfORSETmCIm6TkDgPGYNI7a5GRoaEjLEz7C8vIyvfvWrOHXqlBSWjMViSCQSKBQKuHr1Kk6fPi0h4kql0mMsc++ggcv/PQjd0DbOsyaAD1lrK6aTLfxlY8wfAvgHAP6ttfYzxpj/BOAn0JkPPwEgb609boz5JICfB/BDtzqBI0MKXNy1NmerVHVviMxbyr1cLiOZTPbUtaCl602b10JU7QnY6hppoWi3LReBarWK+fl5KWRH12qr1ZJ4O0kQtUHaWuHm1m63xcvVjxByg9qFG8tDg2g02tfq5sKvvUJaD0Gd2vj4uGShMJul3W6LxdpsNsUy9W4gHJ88B71DNBh0MgAJkx7HmhRpLQg/D2v/NJtNzMzMYHBwUIo3JhIJzMzMoFQqibeSodparSZjP5FISBf7AwcOiNBan3OrMdqPwHl/f1Cwu7xqeiAQQCqVwuDgoDQ91T3xuFbMzc2JPsvv94vQmesKDUwdcuf7deiL5KXRaCCbzYroWovx+6XJ6/Fl7UbjVYaOWRvI7/dLKjuNBEKvdxw3zFqjdlLPCxbUJXHnfdGer3Q6LcYnyRXvhzFGsuS4rqdSKZw+fRqVSgWzs7MSddD7Cwlps9nEt771LUSjURw7dkzCkbVaradWHg0hakG32l+2G/2yN98JumO90v0z2H1YAB8C8MPd5z8N4J+jQ4Ze6P4OAL8J4BeNMcbeYoI7MqTASauF017dkP7JicjwGFMqS6WShLLoptfVnHVYTAu0+dDnJmhtMLOLC1CxWOzxPHECsN+UPgeto0KhIKETfu5+Rey4cfI1/eC8QvcP1Bhoy1db1BS36wxG6oX8fj9GRkZk09DfK3slkQwvLS3JeOC4ZME3hmX1WNTXwA0KgGTS6I0A2CBEmjyxbxPFzouLizh8+LCQfbauIRHi9WjLPRwO94hyR0ZGhPh7zwn0H6u7jcibXVQ1nd9FKpXC2NiYZDTRi0j9Ctcq/v/SpUtYW1sTbw5Lg+jwGNcw77hmGKxer8Pn80krF03W9XfmNdQ0ISIRqtfrKJVKqFaroqnJZrOIxWLi2eF40To36vHolSTx0aJqnkd7O/meZDIpYxmAeC77reNsHMyQYCaTwcDAABYXF3vuMe8d25CEw2HUajW89NJLSKVSGBoaQi6Xw+LiIgqFgoTJuB/xeh9Eav1W4dNbYNAY85L6+1O2U+wWAGCM8aMTCjsO4D8AuAygYK1lvI/zAFBzxFrbMsYU0QmlLW11ckeGFDRj9wqSNRngF6zTmZmeXC6X0Wq1etyvAEQkR3iP7+0fRnAS+P1+IT+sfKobV3Ii0+rhRrm+vo5QKCT6kFKpJBVNddG8fqEXTY64kHkXIn0/HLYP9FJqtz8JT7PZFPGlTqfnol+pVOD3+5HNZiVUqskBsxg5ZhcXF8WbZK1FMplEo9FApVIRsSXHls4W09YzSZcWetMjqrUefr9fvFTWdjJsWAH48OHDsnhzDszNzUlWJd38vBYKcTkPEokEBgYGsLy8jEAg0FNgsR9227g1u6hqOteHRCKBsbEx+W5IMEw3I1ZnhHFcZjIZ2dx5LK5hHC8cF95NmZv16uqqtH/huOX/OSe8oTFvqj2JEDMpgU6RW3oho9GoXE8/SYJes2ko6yQB6jIZeqbEQpO/aDQqpJHFdb1aHb5ueXkZFy9eRCKRQCqV6rm/bN7KzvQ8B/tZLi0t4c0335T0+VwuJ7ojkigaFrokx/3GXZ5nyVr7zC2OtQ7gSWNMBsBvAzh1b1fXC0eGujDGCNPmxPW6/nUYixORVivV//V6XUrEVyqVHu+K9gDx2LqKNAetnix0kVYqFfEy6WvRYS0uAgsLC8hmsyL2Yy2ZfD4vGTws2NUvDKhDgAAkzkyPAtFPk+HCZtsDrTvQ3+3q6mpP1V1mxnAMFgoFVKtVpNNpyWL0ejJ9Pp8sjK1WSzyFugbMwYMHUSgUerxCupYL0GuV00Oqq6MDG73sGALQnqxWq9MLLR6Py/g8cOCAbHDZbBbVahVLS0tCyHkurQvi5/f5fBgcHJTw2ztx0e/U+DW7qGo616N4PI7h4eGelHMtIgY2SBDHH5M8fvqnfxrf+ta38PWvf12OSaOPaepeHQ1fx+fpWdJhMC078IbNdNYYQ8bFYlHWzUgkglwuJ7ob3cJDe8A5ZnVIjySc846aUBotnCea9Lfb7U3tOei9pYyB+iMKpAuFAi5fvozJyUmUy2URdA8ODqJYLEpbnnQ6jVAoJA29g8Eg3nzzTYyOjmJiYgLxeBw+X6euFzODtUyD9/Z+437MJWttwRjzBQDfBiBjjAl0vUN6HnCOTBtjAgDS6Aipt4QjQ11Q8Oltd6HThPWmwklXr9dFgMyFIJ1O91hGXEDoHvVaSCRAtCCop2BjV04u9oKi+1VXlOamWC6XZQGoVqsyEXWmWSQS6SvG1fBaXbTiGd8GNuLi3vc53DsoktSZMtriJUmmjoZEiOm82WxW6pVoMk/okAQXSz6/vr6OI0eO4O2335ZWGvyuGWrVhJlufFrY3CCAjbCFDivoGi46TFEsFjE2NoZIJIJmsyktPBYXF3uIFl/PucS5xdcYYzA/Py/z5m7c9TtEhHZV1XTeU/bC4sZOwbAeC6zgzG7vrKT/6U9/Gv/6X/9rXLlyRfp7WdtbTZ+6IK59AHrGkU6/9z60bsjrDaK+plKpSMHEQCCATCaDXC7XQ070+s7z64KOnD96jeW16ur+9OJybmqtEo1sknSWDWDtOLbKIAGdmZnB+fPnZX6HQiEsLS2hWq0KEapWqyKAppj75s2beOmll6SBq/acMqmH4csHpRnarvlkjBkCsNYlQlEAH0FHFP0FAD+ATkaZd478GICvdv//p7fSCwGODAmYKcMF1jtJtAXMBZ1EiB6h9fV1DA4OivCYky2VSiGdTsvk5kTh5OLk4CLEtgn0yKTTaeRyOXHvcjB7r43HLZVKmJ6extzcXE+Hbi4yfO9WHiEuMPwM7XanPUc6nUatVnsgKZn7GcYYRKNRpFIp0b/QitXfETO1SIRWVlaQz+dlsdZkQH/fJN3cnGjR0mpkxlYul8PCwgLC4bCIMlmtl9DH0aELXjfd8pxTHE/0cPHzcsNdXV1FLBaTtP1sNotkMol6vS4pwbSEQ6GQZBzRC9ZsNqWUxMrKCkKhEBYWFkS8erv7vkNkftdUTdfeCm7W3LBJhOh1qVarWF5elr5ZNAQbjQZefvllvPjii3j++efxa7/2az0eHZJlrXnhved4JXSWmf7dS4Q0IeI4YAiLIS56tDgOvPICGhj0WvKcfD8JDddQknOGz2hQUAunJQz0NrENDo0DEkN6poLBIAYHB0XPZ62VDDiSrvX1dblnvJdM8b9w4QLW19fx7LPPioBdi69pmDworec2zqcxAJ/u6oZ8AH7DWvv7xpjzAD5jjPkXAF5Bx6hA9+evGGMuAVgB8MnbncCRIXQWQU5+EgUtZNbiU04YTjYSITLuaDQq4TGgs5gPDg4CgFjVDHfQSqALNxwOo1AoiKYnm81K1kMymZTqpF4ixN8pno7H42LVXblyRfpDad2H/kxEP6EuB3Oj0ZBMkgfZ6G8/grod1h5hXyFN0LkhVKtVKaWwvLyMYrEom0KxWMTk5GTPdx8IBGQhBSDW6Pz8vFiLDDulUim8/fbbQoZ0ewxvOJcbAM/NAnLaU6S9OrwW/s1FnqQsHA7Lhnf48GHxKkWjUfGwLi0t4fz586jValLPJhKJCNFimGd8fByXL18WMWo/6Pn0oMe23UVV07Umhhs1hbfsAcbwE71B6+vrIqxm+Mdai1/91V/Fv/pX/wrHjh3D7OyskHetqaGXWnsY1ecUQqHJhR573jAyN34agcx847ro1WpqfZr3ONrwADZIO0khQ8o63KaPw9/Z00wn4pDMA5DEAD7C4TAGBweFwHD+cu1nIUfuGXrs+v1+nD9/HtPT0zh69CgOHjwoVa91uZYHQYbegYD6Vsd6DZ3EAu/zVwC8u8/zDQA/eDfncGQIG/oMxn11+InQGwDTG0mEOMhSqZRY3evr61JqnVlm2uLQniO25igWi1JMLpfLYXx8XLQ/OtOsX9gD6G2amU6nhZy9/fbb0nWcE4qLTz/vEBccbbEzzJZMJnsqtDpStP2gp4OLbDKZRDKZFCtVeyZLpRJWVlbEm0jPzdraGi5cuICnn35a6gRxIWcqPb/fbDbbk1nYbDaRz+cxPDyMdrst2iF6PLWAmvASaYYVuFnwOa3/ADaqrWu9BUPF9FKxwSQ3Wt3TCgCGh4eRy+XkWriBUyfBtiavvPIKlpeX+45ZN4470Akb2uOsPZHFYhHLy8sShk8kEmi322LEkbSXy2X80i/9Et71rndhYWFBQrJabkBvB0ksgJ51lmsVxwbHGZ/Tr6ex2W532muEQiFJJtBziN4urWPyjksdCdAPEhm99vUzCrzgc977y1CarvTO48bjcdkv6A3VxJHNv/1+P+r1OjKZDJ566inMzc3htddew/nz57GysiL9z8LhsBgSe9AzdN/hyBA2ND3aSvBmF2hCoIkQNxW6YHVKu247oF27WgDKbAktbh4dHcXBgwelHUO/tHbvYPaGvhhqmZiYgLUWFy9elJCC1vp4SRUnORc13h9O3HA4LBkSjgzdH9CVDWxY6nTR61CX9kzSy6gt6XPnzmFxcRGDg4OYn59HKpWSGkFs1wEAQ0ND4tHkhjE3NyctAAqFgpyfY1tn2XCR1uPEO2Z1qIPaNn4+HZLRc4TGSbvdRiwWQywWk/sDABMTE8hkMrLJVqtV2Ti4yTJMNzQ0hAMHDqBQKMjG5B33+x1eTzg3aorRtT5tbW1NxqVupJpMJrG2toZ4PI54PI5z587hxo0bGBgYgM/nkxAu11Ovoaf1NmxDw9cDmz1BwIY8AOgQYa6bJNL0lKfTaWSzWSlIq0PIAHqIlv5bj12dQON9DaHXT76P106jgMYCQ8M0BnSZFI5drgH0rurwNgAxxNPpNE6dOoVTp04hkUjg1Vdfxbd/+7djZGRERNucJw9KM/ROkhh2CrclQ+YBlMHeaWhLAdggFsBGXJmWB12wFIFy0WeKMCdpPB4H0Cm3ztcCG1lrzOaiy5lhhaGhIRw8eBDpdFo2F6Lf4s2JR68Br5mTMRKJ4ODBgygWi5iZmZEJyPfxs3rF1Pp5vWDQm+VdFBy2D97vnJuF9zump5HjUGf8seXA5z73OfzIj/yIFGijd2hpaQkHDx6EMQaJRALDw8OYnZ1FLpdDKBTCzMwMDhzolOyYnZ1FNpvtqVNCQX+/kAM3CK8niBbt2toayuUy/H6/hC640NNjSq8OW9fQgufmyLlGzQm9Vl6Dhh4Hay0GBwelHAHQ27neYQPa6Mvn8z1hKf5keIuNnbnmBQIBrK6uSkjfmE5RwQMHDggxoAeIhhh73ulMMO3l4frGEC3XWE06dKiKOptCoYADBw7g0KFDSCaTQiiy2awI7PWY02ujPhaw4cH0rneavHNu6jIkWkuk5wHXUZI+vcdwvPL13vPqtT0Wi2F0dFQ8oDRmDhw4gDfeeAP5fB7j4+N91/gHgb20P9yJZ+i+l8HeSXAyekNjWiOkBykFz3Tlk8Ubs1Hp2VorfZeY2kzXPYWIrIGh+4Cxo3AymdyyyCGhrRhumMDGhNMkJhaLYWxsDMvLyyLM5mf3ht+890ZbTTw+J7nzDN0/cIH2asO0RcdFkYSCG/3NmzfFwnzxxRcxOTmJ9773vbh69aq4zAuFQk8Gz+joKK5duyZC/kKhINknFy5cQDgcxokTJ5DJZMRzxTCYftDi5TwANjZXWr/WWjEWWEma3lHWTuEY5kNvIhyzuk4WDRpu0rqHGscqQwSswssNy43hDZBkc+3QhJHeNgA9nkivtoYaFaBjaI6Pj+P06dN47bXXZO3hGNE6NYqGuW7WajWREPAa+PCuj9ZaWZ+puyTxGRwc7PHukHxzHPCadJhWh8V08oKWQWjCQnilDPTE6jWT84H3j3Pd65XXGjp6hzgXOOZTqZR449i+h2M9FouhXC7L8ajv8hZRvV/Ya3PrtmSoK9a7r2WwdxIcsF4iwAFOFyxJEF3GzAZgQ0kdV9cxZRItWtxMdbx58yaq1aoczxiDwcFBpNPpTd4YwpsdxMnoJXCEtmrS6bQUXiRB01b0VvC6jQlmD3ktKYd7By1b/X1rAsuFkEXZ4vG4LPbUmF27dg3lchmJRAK//du/jZGREYyMjEh2mM/nQz6fRywWg7UW6XRatAdsWQBAMrGstSKcp+A/Fov1CKP1XKKlrTcQFuVj5gvQ8TAUCgV87Wtfw8zMDI4dO4b3vve9Pc2MeWygt/q16Qqz4/F4T5ib56SYFtioTaR1FzyGG78d6JCPXkt0WEeXRGCDX4Y+qaWkVqdcLiMajeIjH/mIEACSbe1tYs8whnL0GkYpgZYZ8Dq92Ys0WrkmUwtEoxXYIHt6nHjHq17z9LVoDRWvh/dNG41eITjfS1LFecYMR+21McZgZGQEiUQCrVZL6tfpDDbb1VqlUilks1kJTcdiMdlPAoGAaLmM6TSkDYVCmJubEwH2g8Bemlt3pBky96EMtrnHUvHbBb1AEtqdSTembjhJMRr/1q7bdrstCn8OUoJp+Fw0dOolG/WR+etFWk82TkCvuJvXvRWCwSAymQzm5+d7MiWArcMEesHR1pj2Quylwb6XQFGl7i7N78nv9yMWiwlh0As4xcSBQACXLl0SV/yv/Mqv4O/+3b8rBe9CoZBUarbWimenWCyiVCrh5MmTIuofGxvD6OiohMpWVlawvr4uXiZgQxPEceL1EHEexeNxJBIJ2aharRZef/11XL58uSc04vP5RGyrvWJ6MwQ2QhK8P9oD0Gq1RDuivUoabvxuQN9HrxaGpFs3sdZZWJQJaJH9wsICRkdH8fTTT+Nzn/tcj86Qa6zuTq8TUeg1WVhYkNAoPYv0MpJU6/CtrvdDwqGbvFJnx2N4vRdai6S1lcAGCdLrsdf72M8g5ZzQ6yzXT13fy+/3S9IMPWP0KHH+ABCDIpvNSvkNlobxGq7Mek4kEpJqv7CwcNvIw3ZhL82vOyJD9j6Uwbb3UCp+u9DPO6ItCMa3OQn4Wor+mKKsLWCKCgEI8THGoFgsivUBbG4OmUqlxMLXnh5twXJy0rqizkm7V/uBYlRmmOkwQb/3aK8TrTGtDdEZaQ73B9VqFcViEcPDw7K50EtEAs92Ajp81mq1pIBbq9XCtWvXkMlkMDU1hd/6rd/CJz/5Sdy4cUOIVKFQkKyVtbU1LC8vI5FI4MCBAygWi1hYWEAymcTY2Jh0rM9kMlI3y1tckaJXb3hVZ5bRo0SPQCqVwpEjR5DJZPD4448jmUzKsZiZBGyk5Ot5pD875wf/5n3TG5feBNz47Q9vaCwWi0lhS4b7mdEHQAxFVkPmGGBtHhIlr7HGNZaaSmOMtJNg2YiVlRWsra3Jz2g0ipGREQwODiIej4tnku+n1yoSiYh3amlpCeFwWLJ1G41GT5ajJvAcK1z3eR+Ajaw675qpPfS8ZyRkWleqS0mwbAEA0b6Nj4+LN4feHWbwUszO+U/PDz8D96TV1dWekGaxWJQEi0QiIYV7OW/vN/bSHLurbDJ7n8pg7yS0Kh/oTaXUtS34OuoO2DhSWwOst2GMkS7JFMNxwumwgiYxzLbQzN5LhOipaTQastBQH9GPDOnjG9NJ12aojAuT1y2sj6HPqSe1viaH+4NGo4GpqSkMDw9L6wym0XLBZ6iWmxPJQL1eRywWE4ErC7a9+OKLOH36NI4cOYLFxcWe1ON8Pi+hipMnT8IYg69//euo1+sYGhoSHQeFtel0WjZGAD3jjB4iPUZ0mID6Hm6Y7373uyUbk9oPhi9owXtDW1ojx/mnz+UVUtOI0HAhsv4g6QwGg5KJRW0Kvye9bnLMseIzQzVMaach6IX24jHECmzobhj6nJ2dlZ51lBKwFIrXe8Nxo6ud37hxQ1q+0IvC/+s1TYdl9fjhcfhakup+a6g3XKbDYDwun9PFHEmEOMf4+mQyibNnz8Ln8+Hll1+WLDhmzXFtjsViPYYygJ6+fVqD5xWc30/spfl1J9lk970M9k6Bk0F7QoBeQgSgJ1WXblgd26ZXiBWkde0IHdbS7lIdm+eiw0miSYaOJWv3Mieevmavl8tLVnR7A2opeP1e4sT383e9cPF1Dyo9cz+i3W7j9ddfx6OPPioaomg0KiFa/k5Swc3JWitWPFPR/+iP/kjaxfz6r/86/v7f//tiRfp8PpTLZdy8eRP1eh0jIyPI5XJ47bXXcPHiRXHZ00PUanUKKtIi9YaetAdTEyD+j4SEVXdZgI+Wqm71oUWk/Jv3Buit/dXvef27Pg7hdEOboT2N4XBYBMgsdqm9fnwtxyDbSrAILY/x9ttvS1aat+hrP68M1xXWwGq321L2QXd857rL7476Gu1x4XEA9AjsvWOE3n2en3Oq3W5jdnYW5XIZY2NjSKfTYpzw+ulV9Xr9veJqrvX8na9jVMB7DRSQMxx44sQJnDt3TkJ/DA2SANJ4Z7RC7w38SaL7IOANQe523Ak9vO9lsHcKerHWRIN/63ReXWlUlzbna6mhACCThcfihPeGD3g+unvpsvVqIDTp0BNVEyr9mbYKmVFITaGdJkHegasXRU2I9CaniZ3D9mNmZgZvvPEGnn76aZRKpU1aDa2fIGHnxsJMmmeeeQbz8/P46le/ilarhStXruBXf/VX8f3f//1oNpuIxWIimh4fH8fIyAimp6fx1ltvYWJiQo67urqKlZUVVKtVGGMk1ECLnlap1pFxnHDMUkTbaDR6Kr4DG9WGmaWkrXRav6whpI0Vjn/vfNAW8drammQpeQWx/cb9fh7PnPM6dZvGn9YPeskLN1kt3OXmPDU1hWKxKB4VTYb075pEaLDpKMcSv1NNaNbW1pDP5yXkxO+f3nz9Xj229Jjh9RAkGiz+yPVON7nW5APYaE/D6+LxtLeT94neL4YR+639TGyw1ko7Jq7jPCfXZH42JrdwX9JGrP6OHwRupWPdbbiTbLL7XgZ7J9EvJd1r8ZB8kH1Xq9WebuC64Bczz/SmwM1AEy8vGeI1aPerV9/AQczr0Zk1/QiNfi+fj8fjSKVSKBQKPeEFHXrQ4Dl1uim1SjqNdD9vIPcLrVYLX/7ylxGLxXD69Gnk83k0m03pT+etQ0Vw4aYL/sCBAz1j7+tf/zpGR0dx9OhRITpsGXDu3DlcvXpVNq5sNivVhBcXF1EulzE5OYnp6WmMjo7C2o0CkV5tnTdsxTFcKBTEywBsCFtZxBSAeI0I1ieiRe4Vjut5zNcyUaFcLotuwpuc0C+0vF/B74mbNcX29PKwQCzXKb6Gqdo0APn9UFDNpA1uzCTR2jAE0PNerdkEIB5KnYau5QzMRNPeRE2iOf60x6TfukUCz/Xb7/djdHQUAKSoLhMY4vG49Gjjus/Po0NkwIYGiddOQpPL5cQoYOjOWisGA2tjARuefRI8noufQZMjYCNMxnIqXsP5QWAvzad9XYFap+JqDwy9OAxD6AWTg58LO61Qkh1qibRlwEWD7N07eJnezGvweoO0p0eTED3hdDqnJjbaewVAhNRsr9AvO02/noujtjR0yE+TN4ftgR5vhUIBv/d7v4eFhQU899xzkvHFUBW9QRwTeoOglbi4uNhTCbdSqeDatWsYHBwUb9GLL76IQqHQYwzcuHEDN2/eRDgcluKguVwOmUxGssra7bbUgrkdweBcqNfrKBaLomtiIVOGmek9aLVa0qOMWUBaEO09vvZgNptNVCoVFIvFHn2fNwzt0AtNUNh6g2VFgN5MW75Wk1aScABChqy1OHv2LJaWluRvbwYvyZOu88O11RgjITLWIiLp1TV7eBxNhPg31ym9Hno9696QFgDJWtNrutY0UTfHOUjvlLcUgPY+AZ2SAaOjo9LTTRudzWYTxWJRxORaZ0TipDM2ef91mA2AZP55vUMPkqA4MrRHoPUNBD0vjE3rcvBsrUHFPp9vt9sSp/b2btIxcX1eTWRocfF4/Tw0t/P46MntdYNqC9rn80mKLNtz9CNCXpcqNyftftYp9ltdo8O9o16v48tf/jLm5+fx2GOPSTaIDmWw1g5Jt9/vR6PRwI0bN3D16lXR6nC85/N5XLhwAQsLCzh37hzy+bws/KwkzEWUyQDlchmNRgOnT5/uaT9DbYh3nBOa3HMs1et12QRarZboIriRcn6QtL/22muYnp6G3+/v0a/QmOHmzBAKKxC3222pPszze72ZW5G4/Qbt0THGiO5Rhxz1hurd5L1SA6Bzv9mq48knn0S5XEaz2RTPC8kRgB5Sz/EwODiITCaDl156STx89MRorQ6NVhoCDC1pUsLP2C9UqnU1+qGNWHoXAYiwnPOPXptIJIJisdgj5O738Oqv2NKE4cilpSWcPHlyk0ZLX48mPySOnOfWWtFwMalHf38PAg+aeN0r9jUZ0q58AOL6ZZaLFuppa5OLNBcPDlLtxtXn0Noa/qTVoouD9auBQuK0lejNS4j4U29AOqzg8/lk82QRPS+h8g5ibq7MZNPWkNfD5LA90JY3ANFt6LopAHosPu/7ad1760rpTU+//04Wy37/v9V79Jjv97mAXsLdL3TBTZOZb9wIaSXz8xCs0UKittthdlHLo63WgO51ymu8JMj7eu9axASTRCIhhiM9HiQsHKvtdruH5NMTqbN7+dCG5/2C/tx6TfaScP5OL5SOCngfJOTecKE+rnd/4rVs5d30zjGt6dopODK0y6GZtl6ImbLoLSxG4sKmmLr3DImKMaaHmXvPoa1PXYxOZwH1g3cz8U4Chq30xOx3DP3ZQ6GQpGlrr46Ocetj6Qm4traGSqUiNS60fmk3YDdtLPcC/T0Gg0E8/vjj+MAHPoBcLicEWj80keCCGgqFcPz4cYTDYczPz0sogVqgM2fOSJbKV7/6VRSLxR5hPK9BJxFks1nJUmPVW/ahAjYvftrzyP+1Wq2eTZGNW3VPK76epOfJJ5/EsWPHetoT8LjcGHW4gO0disViT9sIvdnwHLvAI7QrWh7RqKPWjAUyWUgRQM/axffo+0cCoNfDI0eO4Omnn8Zbb73VU+OH45XfC4mRNibPnTsHAMhkMlL0U1f8Z1iJWjKu4/xedVKB12vu9RLx+jVJ06SLBjKz0lhFnd6qarWKxcXFHn2UlzQSyWQShw4dEkF0MBjE4OAg1tfXReOjSwEQJJXaQOX3wNfRQGXfuEqlIvejH8G6n3BkaI9AkyF6ObxZOcCGC5JeIW8Iip4dbxYMz6EXDh5Le2p4HK9lpf/2nle/ThOyraCvgdVkWeaex/CG8ryfg6SLvdSY6cBNqJ9VvwPYFRvLvUB/V/F4HB/84Afx1FNPyfhMJBI9GTJbfVcM966trfUUyoxGozh48CCSyaRkF/r9fpRKJeTzeUxPT6PVaiGXy2FsbAyxWAylUgmLi4uy6BtjJA2fYV4aDf2uR3sIYrEY0um0hDYYjm42m1IQlISIBC6VSgkJ4z3Sniyddk8PQjqdRiaTwcrKClZWVno2X32fd5oQ2c6F7IqWRzwEBdOpVErWDOq3dKFCTcj5fn43FOZrvRDLPujvy0uIeA7vesjEFa2X8RoBXMeZZUlypnVoen5pYb/2qOgsMVZC10UTjTFSc4uEgwJunkcTPq8XtlarYXZ2VuYzP6PpapFyuZzU/WIRUr139Eud10UkvcY51+l+8/N+YhfsB3cMR4bMRiqpN3NMu0MpnNaWhc7EYtjB68HRA09PCi/R0QNbe3r0tWpC5F3Yvdk7W31WgouGPr9OnfVaEfq9FLRyE9OTfqexmzaWe4XP58Nzzz2Hd73rXfD5fEgmkxgYGJAKzgxXcrHXXiJ6VarVKpaXl3syaM6ePYv3v//9qNVqCIfDQpACgQBOnDiBw4cP41vf+hZyuRza7TZqtRp8Ph+GhoYQDodRLpdx8uRJZDIZaQvCzY9jux+x50ZA7xI3DYalmQKv06a118dbUsJLhrhJMBtIa5LofdJeWD1m+z33IGF2Qcsj3lctPOY40+sFiZCGTpnndxKJRLC6uorBwUHxOuowkfc+a10Zx5QxHYE9NW3aY8/XAJDSJLwWPRe0Z6ifFIFEin9rb0u73cbc3BzW19cxNjYm/dioH6JuSSe/8P5oeYT2ZOoyK2yJEw6H5bNQb1Sv17G8vCz6otXVVRQKBfj9fjSbTSm6q/cA/ZMFGmns8PoeJHbBMnrH2PdkiIPE6xHSiyb1Gqurq5uyy/g7Wbg3vKQJhX4N4dVraI2SPgaPqyedvgbvw+tF4nusteJW1iExTYa8n9/7WXW4wxui2Q3YDRvLvcKYTnPFp556CtZa6S3EsBRFm/2KLjJMVCwW8eabb+Lll18WK3p0dBQ/+qM/Kin1fD4Wi+H111/H6uoqTp48iXK5jFdeeQXZbBaJRELEmNlsFtVqVbxT3Cj1eNRkn2FYHd6i5kk37uSmC3Q2C2Yi8W9vqr3exPTmpV9HASxDGqxofCvs1Bi2u6TlkfbgMcuP4nzt0eFaQLLB9aPRaPSE1UKhECYmJrCysoLl5U4jAq/B5xVdk/Dyu6D3haF5HcrlNXNdLhaLcl5d0dxLVHher+GodUg61MZyKZoI0bD1emp4Dr2msy2JFkCTpNP70+/cKysrGBsbgzEG+XwexWIRxnTKU2SzWVi7UVaCY5/fCQAhWtoY7hcevB/wGkW7HfuaDHndqP2yYfTmorMLvB6Tfr13uPjTpdvPK6TdwSQrOtTWTw/kFWhr8an2HPH6NVGp1+vI5/Oo1Wo916IniL4+r95DQ4sGdxN2y8ZyLzDG4MyZM7KAciPQhRa5aXHh53P1eh2FQgFXrlzBn/zJn2BpaUlIwcc//nEMDw9jZmZG+tSl02mMjY3h7bffxs2bN6W55vz8PBYWFpDJZDAwMCBaDV0vZqtMRC74HMvNZlMyGRliIBnS1r7O9tKWviboOizCe0WPkL4GEn56Ebzp3LsRdhe0POJa0Gw2USgUAADpdBrWWtFTajLCcFi5XO5Jfff5OrV0jh49itnZWVy5cgUAekI1HMMkT14tWKlUwtzcHFqtTgf3gYEBpFKpnvWa33cymZRaVPoaGTZloVzdjoNjjUVBSWD4HgAYGhqScxYKBVk3eS6um/qecG0kMdGeKh1RAIBSqYRkMildCPj+aDQqxUJbrRYuXboEANJ8mKSL1+31hgGbdbFe4nm/8aA9UfeCfUuGOED0pNILMdBbxtxbp0RvAv2Ef7QoOFk1EdLEQveN0eRCE6JbLeD8DPq6vQSG52fIpFQqoVgsiuXN12hCxGvSni1v2E7/3AkX7O2wGzaWd4pwOIzDhw9LuIG6HHrj6Knk/ScRYGhsdnYWL774Iq5du4Z0Og0AOH36NL79278d09PTiMfjqFQq0oSTHqBWq4Xr169jaGgI73vf+/C5z30OzWZT6rysrq72eHY47rh5ciPiGNbjiWOK4TSOyRs3bmBpaQnZbBYnT56UTaHdbveEQnguEiFvBg//p4WvPDc1MP28nTttvZpd1PJIe4lZVgGA1IbSjVr1mGOmI8clM2WBTsHEfqExGqJaDE0CYa1FpVLB0tISrLUihC+VShgfH8fAwICUYqCxaUxHf8bwlenqbw4ePChNS3kc7b3xGoxAb4o99VK6JIDXE6QJB98PbCS46OPyPjODjt60AwcOiC6OY7ZSqeCNN95Aq9VCqVQSDx0F0tlsVr4rvZ/x3Pyu9HVpone/sdNz626wb8kQsDmMxeeAXiKk9QR8eK2AfsI8kiGdMkpob9Dq6ipSqdQmMkGC0s/dqIlbP/E0X8+shGKxiEKhgEqlInVjvGE9fR7vZ/YSRX2/vPdvJyfAbtpY7gVMKeYCTwuQYn16iLzfGdsSfOtb38Jbb70lNYOSySQ+8YlPoFKp9OgrstksgI3mqSMjI5ibm8Pc3BxGRkYwNDQkJDqVSiEYDKJUKgGAFE3Unk8uvjqrkq58Zsfovn2tVguzs7Oy4C8sLOB973uffGafz9fTYFWHVfQDgFyH1nHwPQDk3mnsgq8a2KUtj0hwqR2iAFpnMwEbNaG4sZOQ02NJ7Yp37SB5CIfD4inkWsnf6REdHBzs8fIUi0Wsr6+Lfk5rNikyps5ueHhYzuf3+0WI3U+8zeMbY3p0PPycXs8+0JsxqUmGd43W97XVakmozVorNYYOHjwoGWa8jnw+3+OJ5fvL5bKIq2u1Wo8miusDw9lMlmH43Nu0+H5hl8yvO8K+JUOayesH0OtR0cURdQjA60HyZpGRCHlrD3kHBweyPj+AvuSD594qNEZwkrOQ18rKilhE1AJwEmpS5o0r6+e5ofF8+j7sMuzKjeVuwUVME1FN0Gu1mhQA1e79crmMy5cv4+2335bwms/nww/+4A9K37FIJIJCoSCZYNwA1tfXMTw8jFKphKmpKQwNDSGdTuPKlSuoVquYmJhANBoV8s7Kzrw+Vm3XWTOagFAEWq1WpdheIpHAqVOnsLy8jIWFhZ7Pwx5TXoNAjztm+2hPpiZImvDvphIQGnYXtjziPaZHh2GqSqUi6fdaAsBMQOq/rO300orFYjh37pwQaYqDtUSB3j9tuDWbTSQSCYyNjckY1d4jfsfNZlMKFbK+1MrKioTD6EXh+CF58qacd++rhFT13xxLDENp3acOt3m9Qrfylut9gfe53W5jZmYGzWZTwslMLKB3iokCjUYDhUIByWRS5km9Xt9E4KiXCwQCKBaLmJ2dRaFQeCBkqJ8Rv5uxb8kQsHUGliYCXJh1hVOgf3yYx9FpnHRVet2qepAwxs7qu/p6+oXAvC7Zft4saoNWVlZ69EGcYADEpd3PG6ShB7WOw2vhtPcYO4XduLHcLYwxkgECbGhmtKZsdXVVWlTQzV6r1XDz5k1MTU1hfX0d2WwWPp8PH/zgB/Hcc8/h+vXrSCQSEqbK5XIyLkulEtbW1hCNRqV3XbvdxuDgIABIejGFngzVaQ2Gttxppeq5EIlEZONk+MXv7/R+ev755zE/P49YLCbtabjxABuGAI/JucljsZo6xaLeYpPaot7pMbqb4fUCc7PWnu52uy3eFXpL1tfXEY1GpS5RIpFAKpXC+vo6Pv/5z+Opp57qWd94PHqPSFQZwiLhYXYhsNG+yBuu53pFr0wgEEClUpHxQl0PibsmMHodpxBai/K5zuq6cFzvtEiar9UeIH4OkjEek/eU84H3kfNnampKvF3U2nFOaKkFS2GMjY2J51ULsSuVCtLpNHw+HxYWFqQGEsObDwJ7aa7tazIEbK7oqTd1rT3gpNXaIE4mrb3hc1zMY7EYWq2WtB9gzLdQKMjkoLVMN6jXK+T92+ul0osE6yEVCgVxh3LDisfjiEajMunK5TLy+TwqlcqmlhpekqgtIZI7Tnzv4rSXJsBuha5+TnCD0L9Td0MP4NTUFKrVKtLpNAKBAE6fPo0XXnhBUngZto1GowiHw+Jen5+flxR3emxYGPH06dMYGBiQxZvnjUQim3RwOrNMZ2qSpKyvr0utIq1xiMViOHz4sIRU+H5+Tu/mpRMSaBXTM6Gz0jgejTGiadL306EXmqREIhHRb+kwkl7HWNyS7wU6pIIeyWaziYsXL4qXk98pRcVa00IvD2tj0YvD71uHtLyaF66RzHys1WooFAryYCICxcfNZrOnXAOAnrFBIkhipPusaS+Q9kTq9ZDjThsHWh/K/USLsBna8obA6TWih4jX12w2USqVRNzNOWWtRb1eR61WQyKREE8y5zaTgR4E9tIc29dkyKuVIWP3PgdAKrLSy6J7MpXLZTmm9tZwUrNYI1OT4/G4NJ3khCkUCggGgyKg04Oe0O5h7SngRNIFwNgigwUWM5kM4vG4ZNRYazEwMIBsNouFhQUsLS1J12Weiz81weGCor1he2nA7wV4CZAOgwG9RRW1R4ad5wHIRvbCCy/AGINyuYxUKiUbztjYmIzxWq2GhYUFZLNZOc6hQ4eQTCYBAAcOHJDwF8/L1+lCdNzo9KZHcq9TfpvNZk8BRR5LfzYtztVjXAun+Ts3F4bYms2mjFEdAszn8z0bHs/X777vZ3COx+Nx5HI58YxwU200GlJJOpFIIBgMigaRHg6GrqjrYSsVAD3tjkiGuOmTJDDEpUkHQ0RAb+sKreWh5zuVSomHiEkE2WwWmUxGMuRIlnUxSe3BB3q97rwHNFT4fx0O00Y038eHNjT5fpJ3esZIWlheglljGjR6gU5UYX5+XkJlIyMjAIClpSWsra2JZ5cesge9Zu+lOeXIUBdal9BvIAMdHQdZNclOuVzucZNykHMi1ut1WSBojes6HLR66Nb11m/RYTHtreF1ccLwoTMFotGoEDBa5noSawswEolgdnYW1Wp10wDW94afkendXj3HXhr8uxXGGBkf/I41uaV2gfqder0umwg3jGAwiNOnT+PQoUOYnp4WNzuPm06nhRgsLS2hUqlgeHhYPJhjY2PiYWFvKI6vdrvdQ6qBjU3Am0JMcDNrtzt9p1KpVE9xRRKZZDIp3iJuqNZaEecCG9qN2dlZXLhwAbFYDMPDwz2e1Xa7LdcLAIVCAdPT05s0Q1uFhvcjvPOcnm16dSiGZvidYVJqUqhh4++VSgUnTpzAu9/9bnz1q18FANGV6UbYXu8f1yVqZIANUqzXRC0lADZS/EkoaKhSjN1oNDA7O4tQKCQecj2GvVECPqc1mhxP2uPI13j/p0s/AOgxCmgw6IKpxhghL/Rsae+nLv2i9ybdeiYWi2FxcREvvfQSms0mXnnlFek2wO+UhsqDwF7aD/YdGdpKG6RJj9fq4CMcDiORSIjnpV6vo1wuy+LBxZiahXq93uNRMabTCZpiU294i3F4Wk66urAWSXPjoYvVG6oIhULS8iAej296v570zLiglXTz5s2+hAjYqAxLNyzdzA8qTXO/wFrb05mbYQiGm2hV6zAQxaPRaFTI0JkzZ8RTQvLTaDQkZECCtby83COGDYfDyGaz4nXJZDIyxnXoWG9gHBu8NhJ2nXmkrWG/399TswjohFfY4oXXTc3FzZs3RXfEjbTZbCKfz2Nubg7WWgwPD0vSgp4f5XIZly5dkqJ/W91zb0h4P4KeEa5/XKs47qy10kR1aWkJpVIJlUpFuriTIK2vd3p5/a2/9bfwe7/3e/I3iRBT9DXR5TjQoTp6bYBeI5C6NWZcaR0MRdQk5xxrPp8P0Wh0U20rXRDUm0Tj1Utx7SXh9noxdQ0lwnt9vD8k9SygCmxkPOp7okNkDOtRqM49KxKJYG5uDleuXEGpVEIgEMDo6ChSqZSEtzV5exBjXDsW9gL2HRnyLnraG9TPBU8ipEkNU0d1yMpbyMvr9idRomWeSqUAYFNoSseXdYhBX7POqAA2LA66lqkNojXgXdz08ejaZvpqq9XC/Pw8arWa3Bt+hmg0KqnVFPb1KyTpcG9gWIuiZRJokhiGFDT5poWYz+dRr9el8SPDuXqMp9PpHtFptVrt2XQ4hpaXl6W/Fwkaxf7AxmJHi11b/bw2ene8r/fqMbT4FYBU+W2327hx4wZu3rwp4mp6wmKxGM6ePYtqtYpYLCYbCHURhUIBy8vLmJ2dlVTs22G/j2NuvCTiup8Yv1NNVCKRCJaWllAul8WAo8fx4x//OJaWlvDmm29K2xZdQZqbfq1WE2KuN096TLR3nONGi7u3+l4LhQJKpZKEiHjNDCvTi6rJDs/JtZhGALCx9rZarZ6Cj7xWQnvx9f0isdeV3xkm1J0Nms2m9AHk+qvF//wM9NTxvgNApVLB5OQk3vWud0kmHrPP+GAW3YPAXppP+44MaXg9P2TN2vrQRIiCNb3Aa9ZPosOBycnCQR+NRnsyuNLpdI/YVGffaHetnuyaoHAScLEKh8MSXqMrlC5ibUHR7c1CadpiyGQyEr5g00y/3y/hO6Z0a0Glvi6Hewd1PJVKBZlMpqceCcExxUWYnqHl5WUsLXU6iWjLWRMRLrzcSEiGSWrC4TB8Ph9WVlakjxg9BHqzA7DJIAiHwxIO5txhrRou5tojxNBGo9FAIpGQVGK+hyEZbtLFYnHTdfr9fkkWIAGbm5tDsVjE/Pz8Jq1Ev5CYE/53oMOy3Li12JihK9YbYshpeXkZhUJBPJqPPPIInn/+efz8z/+8rDskGgBkTPM8Wmis5QA6oQTYTDS8EgJ+BpJlZhUC2FQMku/jmORzuq4XP78ek5q4c97ozvJaTE0ipJtiU8ANQHSlHMutVkvC1iRhNEJ1F4RoNNpjoDMSceTIEXzgAx/A4OCgvIZV6nUSgSNDm7EvyZAOj3ET14RDZy6QrLBJXrlc3uRy1J4aWgJ0d1Kgx75SOk00EAhIvRa6jfUE7wednaNJkF5o+Hko3qangBYFSR4np/7srE2jsxni8TjC4TAqlYosdvo+Omw/+N0NDAz0jAltKdM7xNdnMhlks1lEIpEeC9qr6wLQE37VliUXcabnR6PRnuwu9qfS5Irnof5Mbwy8Vt2Xj2RIlwio1WqSIsyijLodBDcTXbOLXi+Ses4ZejZ101diK22QG8sbYIJIqVRCLBZDIpGAMUbuJ0m4FlDHYjFkMhlpZv23//bfxh/8wR9ItXOOA5IJjgc9FrRRSq8RgJ61kGsqvUTaQ6Q973ptLpVKQqwjkQhGRkZ6jkGDVXtgeF4atPTkMIOStdq0p1MTN84tVmvXeh0m4QDoEUj7fD7k83mkUimcPXsWFy9exLVr1+D3+zE2Nib3n9mXTIjg3hQOh/Hss89iZGRE6ivR60avKYmYyybbjH1JhoANl72O82oCpDcPVu3URIDQniNtZZAExeNxJJNJsVL064FOFV9aK9ot7B2s3LQ0AdI9qTTJ0USoWCz2CF55zfQi8fUMywEQbxPvkzEGpVJJxOBb3U+H7UO73ZZsLR0G1d4/km5q1CiWp7C6VquJLgPozXzhYhkMBpFMJjd5It966y2cOXNGPAEMzXkz23hcXh8JuQ45AxChv9fryrYC1lrkcjnR4tELVCwWe7LQdHIDK1pzU2XIJp/PiwbD4e5Bb0KlUsHCwoKQHRIBJk9w/JEUhUIhJJNJrK+v41Of+pTUueG4oteJ65MOl3Id5jgDIN4Tr95R/07Co/U+2rvO9Y31uJaXlxGLxXq0Pvq42ojQnn2dNh+JRMRg1MSG81OXlNDjlg9q3ugJYuiqXC5jdHQUp0+fRjKZxNLSEm7cuCG9BsfHx9FqtWQNYMHF+fl5NBoNHDt2DJOTk4hGo6jVaqLp4jzkPuZtxXS/sNeiBfuSDGn9jXZ7ekXUwAYRYj0W/eXeyuKMRqMiYKbQTQvi6Fo1xojLWbtdNRh6oNCOk8ybXaBj/evr67KpMFyis3ESiYRYDTynnvjcZFmMz0vivJ/fYXvBxYuLvN546FLnd0UtBLMHE4kEisUi8vm8VPel9UzrXIezhoeHEQqFZOEsl8sIBoNSNdgbOub1cTMj2dZWtFdkrWscURhN136tVsPExISkaFPvMzc3JyEKeovoEaMOgqFchnCXl5clo4lj2Htft/IOOWyAhKhUKsm4OXjwoHh5tG6Sr2+1Om0yLl26hEajgePHj8v/NMnQ5RK8awi/X9bAYogH6PUKAZDsSq9uiL+3222pdwRAipSycTG9mVz3tCaI18Hxws9Hz0oqlUIsFkM0GpX1VnvnuQ43Gg25xkKhIGRK669YIyuTyeDEiRMSOqPx2W63kc/nMTg4KAkxvI9ra2vSluOxxx5DKpVCo9HAysoK6vU6stmsaKYYJdBap/uNvbRH7EsyRHjJkPd/jUYD5XJZRKP9FlLtSqWrNBqNIpPJIJPJSGEtHW9mZgUzYnRaNDN6gI2whO4vo/VE2pph7F2H7yieo36I1tjw8LAUTNNESIvGi8WiEKGtBrTTWdxf6K7rJD46HRfYsJo5nuLxOFKpFFZWVrCwsLCp8CC1ELoI59DQEFqtTs8wbgZMpwcg4Sxd1VkLpzl+Oca8c0RvYty46BGi92p8fFzSsYvFIm7evIlCodDj6qdWggSN3iPqVhYWFlCpVHqKgm6VPaM3OYf+4PfJUOXq6ipyuZzUKwM2POMU/V67dg3VahWBQECMLy065rglieK40M9b20nXZ0NpHaolUdHX6NXScbyRmMRiMXmuVqtJw1ldC4tgmI0hN342HW6it0cbKVrnRJTLZVSrVbkHjCzobFCeK5lM4vDhw9KjslKpSEYc7wu1SNREtduduk9+vx9PP/00xsfHsbq6ipWVFTSbTWSzWWmBwigItX/aK3Y/sZfmlyNDSoegyQWrQver1skFVgvwaP2yDD1dsTocQLLEomDcTHSGhXYVx2IxcYV6FxFtyWhrm8JSbS3x89CiZlVSQruqucGUSqVNBeocHiyYRQZsDg/oBVwvyqzhAwA3b96UkKhOJ/bWoWo0GlhcXBRCw82Jr2VYQxMieoP0JgVsJAJwfHo3Kl47RdOtVgsTExMAgFKphPn5eVy+fBmLi4tSmZegUUAPE2t8RSIR3Lx5E/l8vocEEVstyP28Entp8X4QICFiW5+VlRUhQ9xQ6YmgNgeAFJIdHR2V8aPJKdc6oLdQLc9JwkANDYso8tjaM+nN9uI59IbPsD9rIHG8Dw4O9jV0tWHIZAau4fra6aUlUeK16XAvvWuMCnA/oOE8MDCA8fFxKXBZq9Vw4cIFzM/PbyKNzDzjntBoNPDoo4/i+PHjUiajXC6Llov7WL1eF3JKT++DwF6aT/ueDJFMcKKSOGiBHKEnsvYI0ZXL6tJ0gerS6toi4ObFFhzcQLSQjgI5TjZer564DL1pYSrTokmq0uk0IpGIZOXQSmKsmxYDj9NsNrG8vPzAuho7bA1alf30bHrj0F4jEu1gMCgZValUCvPz8/KadrvTW8pbkZyLPEXJJPNa9MpsSJIvEmadMaSFqLRGvdfLz0M9XalUwuXLl/H666/3iKb5WmblULdCcTfr3dCK5j1qNBo9vbB4bv3TC+ct2hr0bLCptP4++4W7rLVYWVnB0tISDh48KB5DeiZ0qAvobTnEY0ajURSLRSwuLopn3OvRoNGnDQReG71RQC8ZCgaDKBQK0oJmaGgI9Xp9U9iP+0OlUhEvOluE0HPEpqrRaLRHCsH3sEWG1tuRsDM7c2hoCJlMBkCnAGqxWJTwrzGdfoBPPvmkaIZ4XtYMO378OEKhEBYWFqT1iA61sR6eNmx0SZf7BX6PewV3TIZMpwv4SwBmrLXfbYw5AuAzAAYAvAzgR621q8aYMIBfBvA0gGUAP2StvbbtV34P4MSl61FrYmgBezUy3nAFUzc54AYHBzeJBUmEaBXRquVABjZqBGm2HolEkEwmezYDTiK+hgOai4y+DobNQqEQjh8/jqGhISwvL+PP/uzPUCqVUC6Xpdw7r4VWTKVSkRpDd3ofHbYf1lrRGAC9gmS9wPD/XHApZo1Go9Kr7PHHHxdPCwkOmzY2Gg3Rw1FbRo0CALFotXeIYCaMJkE6Y0in8NLAYD0ZeiLj8TiazSZeffVVvPXWW1hdXZUyFMwgo7ESDocl4YC4fv16T5+/TCaDdDotG1sikRAtlN7Ab3XfdwJ7ZX0lQbgTrK6u4tq1a4jH4xgaGuoxsGgEaj0aDU0SB66xpVIJS0tLGB0dFSLFQook215hPgCRHJAkURqQTCYlc2tqagrtdhvDw8MwxkjLFr1+W2uRyWQQjUbl+rnGkhzqbEzOMxqp/FwDAwOiyeP6n0wmxSAIhULIZDI4fvy4hLqWlpZw4sQJjI2Nyf2npw4Azp49i0wmI3ooNss1xogwe2lpSbxtuhjpg8Be2iPuxjP09wC8CSDV/fvnAfxba+1njDH/CcBPAPiP3Z95a+1xY8wnu6/7oW285m2DNzNG17rQ8BKheDyOgYEBcePGYjEMDAyIVcPFXh+b7+dk1eXVNYFiqE1X8eXE5GZIMRwtH7pytYs6FAphcHBQJtnAwAByuRzeeOMNAMDAwECPiFVn8OwlNv8wg/2edAowx5UeM7pGVSAQEN3Q9PQ0zp8/jyeffFJ0REyjZ70sipPpsWFmGuvzsESENhK4qALoEfxrw4LeRm5MdNVb26mhxNBBJBLBF7/4RVy9ehVAZ8PKZrPS+kYTqkQiIX398vk8rly5IgXkhoeH8cwzz+DIkSNot9tYWVnBlStXsLy8LNY9j6M1VLtosX4o1lfvPa1UKrhw4QLC4TDS6bQQDGDD8+cFMyCttdLoenFxEeFwGENDQ5t0k1wnNQninNFeU66XzWYTiUQCQKcw49TUFGq1GgYHByVLjJ4gXfGcHv54PC4V3NmCZHBwEMPDw6JD4hidn5+HMQajo6Mifq7X63jrrbekZyUAKbPCwqok8gxPUhtEEra+vo5HHnlEegyura3J8RkKLBQKuHHjBtrtNoaGhmTfYV/MB4Html/GmAl0jIARABbAp6y1v2CMyQH4dQCHAVwD8Alrbd50FshfAPAxADUAP26t/eatznFHZMgYcxDA8wD+JYB/0D3RhwD8cPclnwbwz9GZrC90fweA3wTwi8YYY3fRqkNwAulNpp+OgJOLMd6RkRGk02kpRkaxqdbe6PizTjfmJPd6nZjazk7hOjSia3E0m02pTkxLnpOXeiRjOsUTqR3hBjU6Oorp6WksLi6iWCyKm5bHqNfrmywGbyzd4cHAGCPZH2xqygVMW5vaM0SiE41Gkc1mMT09jTfffBNLS0vIZrNSZ0TXStF6Nh6zVqthbm4Oi4uLOHDggGiHuJnocC6vi1a4JvtMPebf9GDm83m0222kUim8/PLLuHjxoohIh4eHpfaWDllws1hdXcXU1BSuX78ubUYeffRRnD17VqxxblhnzpzB4uIiAODy5cuiq/Pe550mRg/T+trvMorFIs6fPy/ZTlzrvMkAfC8970QqlRJRfTAYRC6XE/0bHzq9niSIP/X/SIyo2QE6hGhpaQmtVguDg4NCgLSRzGrwXJ9ZJ6nRaCCVSiGdTotxSe9LJBLB2NgYjOn0HOM8Msbg2LFjeP3111Eul1EqleR89XodyWSypxbTjRs3ZG+gIXHkyBFMTk72FEFlKLBcLuPtt9/GW2+9BZ/Ph6NHj4qRUy6XhSA9CGzjsGwB+N+std80xiQBvGyM+RMAPw7g89banzPG/CyAnwXwMwC+C8CJ7uM96Myd99zqBHfqGfp3AP4RgGT37wEABWst07CmARzo/n4AwBQAWGtbxphi9/VL+oDGmJ8E8JN3eP77AhKNfgQF2FwBlfFdFsJjGwAOQqA3Bg5s9JrR7mWt0eCkBTqCVobSdMya2iVOBLphSZJosTOMoGtoMAXZ5/Ph0KFD8Pl8+MpXviJhEC3M7ld7witE3WXW9EMLazsVwJeXl2UD4fOEFnJqDUIkEsHAwACi0ShmZ2fx8ssv4/nnn0cul0OpVEI4HJZ2F1xwSXKoF6pUKnjjjTcwMDAg5+Gm4vVSccPh2NAbBa1fCj51uvTCwgLefvtt+X8ul8PAwIDogQBImJni6fn5eZRKJaRSKZw5cwZnzpyRcLU2NnhtAwMDeOyxxyRkw/nOe3knobMHgH+HbV5fgd2xxgKde7u8vIwLFy7g0UcfFW+Pl6BoY3QrQjQ9PQ2fzycp43w/Sbh+6Cxhfs/ai0oSQY0PBeDpdFrGTyAQwPDwMMLhsIzFQqGAer2OoaEhnD17VjLnmNGri4Bms1nJ8qTRqzsQMEuN56JGlPofaztZzVeuXJE5Ojk5iUceeUS0oUxmsNZiYWEBr776KmZnZ5HL5ZBIJOSzcs7XarUH+t1v03FmAcx2fy8bY95EZy68AOAD3Zd9GsAX0SFDLwD45a6R8KIxJmOMGesepy9uS4aMMd8NYMFa+7Ix5gO3efkdw1r7KQCf6p5jR1Yirb/YigiRLBhjkM1mMTAwgHA4LKGrZDLZo7XQqZA600anF/N8dPEy9MAUUr2g872svVKv18WCp7XO17ApH2PVJFLcXOLxOI4cOYJ8Po9vfvObUsdCbw7ee9Fvs3CE6MFgfX0dc3Nzkini1QrpEAO1O1xQs9kscrkcbty4gRdffBGPP/44Dh8+LJ7D9fWNyrw6REbvSrvdxmuvvYaxsTHkcjmpSMw5QW8N67RwTJJ8swJ0q9XqSSgoFovw+/0olUp4++23peFvKpXC4OCgZCnprDdjDI4ePQqgs5kdP35crotzmBoUnU3EzzY0NISnn34ahUIBKysr8hrex53E/Vpfgd2xxqprwfz8PCKRCB555BEhF8YYSTPXRJvjiSnk1lqkUikJa/l8Pmnqywe981pL1I/Ia90nj08Cz7o9ACRLd2VlRYyCarWKgYEBnDp1SlpksJ0GK/Vba4W4eQsx6rDegQMHcP78eWlvBHT2iqmpKVy8eFGE1gDEYDh27Bgee+wxMci1F+zmzZv4yle+grW1NTz55JOIRqMyBymFoEbqQX3ndzm/Bo0xL6m/P9Udwz0wxhwG8BSArwEYUQRnDp0wGqCMhi5oULxzMgTgfQC+1xjzMQARdGLavwAgY4wJdK2XgwBmuq+fATABYNoYEwCQRkfotyvR78vS7lcO3FgsJq0OyLS58WghNvU6JEO6smqr1eppmUGhINDxCtGLBGyE8Jjdxr4/evBrXVIwGEQ2m+3RkrCezOrqqpAkbiwzMzO4fv26LDTa3azJzlZhMkeI7j+stZiamtq0UfChF3tgw5qmiHp4eBg3b97EjRs38IUvfAGf/OQnMTg4KBau7uelhaa02ufn5/Hnf/7nePLJJ2GtlXRkju9QKIRcLgcAQrwJLsK8JnoHKOycmprCwsICAMhxGB5mZg6NgKNHj2JiYkJ+p65CZ3RyLmiPA8doMBjE4cOHcfr0aXzjG9+QZq7EDo/lh3p91VhfX8fU1BRisRiOHj0qySQkCDrMpck+q4m3222k02mUy2XZ1FlLRxuZmtjrdHau0STQ9MbQmF1ZWenJhOR6zvT0eDyOs2fP4uDBg6hWqz3Nfzkf4/G4RAt0pjDXba/XMh6PY2FhAZlMRgyRQCCAkydPIhAI4PLlyzDGIJ1O49ixYzh06BCSyaQck6HnGzdu4Ktf/Sr8fj+efPLJnvWeNcRY5fpBjvW7PNeStfaZW73AGJMA8D8A/H1rbckTubD3QvpvS4astf8YwD/uXsgHAPy0tfZHjDH/HcAPoJPx8GMAfqf7lt/t/v3V7v//dLfEs28HrygP2CgYl0qlRDjH+g6xWEwGJcNMnGhaT8H/0yLhBsSJz4mjJykfDJdUKpWezUa/hvFkhu54/SReXBjoFmYrD7pdSdZ4fV5xnf76nIboweLmzZtCKvqNDe1J1N4hhsqy2SwWFhbwta99DSMjI/ie7/ke0R4wrZ4eFLr7aZG2Wi1cunQJxWJRvErJZFIs4lKpJMUbucjTrc9xSWKTz+d7NBCzs7NyHuowfD6fhFDYcX50dBTf8R3fIfNDa3x0OFkTeb250igJhUJ4/PHHcf36dczMzPSEUHZyedpP6yvQ0S9eunQJgUAAhw4dkvECbAiqtXSAIX/tZUgmk6hWq5iamkKz2cTAwID0zOP37iVIPAYL0ZK8c+yMjY1JppfWfTIEGwqFcPbsWUxMTEjqO/V5wEbygC7HQsNBh/F0Y9pYLIaTJ0/im9/8Jqanp5FMJiVrjZECzrnBwUH4/X5UKhXpSwlANHQvv/wyYrEYTp8+LWJvGj0UYF+7du2Bl0zZzqFpjAmiQ4T+T2vtb3Wfnmf4yxgzBmCh+zyNBkIbFH1xL3WGfgbAZ4wx/wLAKwB+qfv8LwH4FWPMJQArAD55D+d4IODmzomkyZC1G71odCNVHSKjBcEmhgDEKtGWvM7WoUuXKcPARqVWrS+ihoPhLi76+pi8Pk5wegeoM2LsnSELLWLVXgdaSt5wTD/sofV3T4NtNZgNoi3d9fX1TdVvSYZCoRDS6TRGRkawsrKCxcVFfO5zn0M2m8Vf/st/GZFIBNFoFOVyWTxMwWBQ6vXQa7m6uorp6WkUCgVMTk5KFiXHDAsdskM2LdVgMIhms4lSqSShs0KhgJs3b+LmzZsiYGVbEKAzprhwz83NIZPJ4OMf/ziSyaSMf2+Sgw51AxsZmfr/fM3AwABOnz6N5eVlEWjvBgH1Fnho1lcvGo0GLly4AGstDh06JB5AYIMQkUAA6PEC6rHeaDQwPz+PcrkswnuGgUmUNZHiesfnKISmsXHw4EEsLCzImG21WtL+aHBwEOPj46hWq+Jp15olrs2cN6VSSeahTi7Q2rbV1VUMDQ1heHgYCwsLmJmZQbvdlnR7krFQKIRisYiFhQUEAgEcPHgQhw4dkrID586dQywWw2OPPYZkMikJNfRoVatVLC4u9mRUPihsV0jOdL74XwLwprX236h/0Tj4OWw2Gn7KGPMZdITTxVvphYC7JEPW2i+iI1CCtfYKgHf3eU0DwA/ezXF3Elq7o0mQBt2edHnSs8MQGScaw1LautFaD62dILPXRe84AbXIU3ea1x4ALgyhUEhS8blosAEry8FHo1ERR2ezWczNzaFQKPRYX/2qw/Ia9Iah7xl/d7h/WFtbw7Vr1zA2NrappYtOs/d+l0yxHxoawsLCgoTLfv/3fx+jo6M4efIk4vG4pKozvMu0W+1ZbLfbKJVKuHDhAoLBII4ePSreJ5/Ph0KhIPVW6KliqCEQCKBWq2FmZgYzMzNSxwXYaDdjjJGWN+vr6ygUChgZGcELL7wgJF97sfRc4GcmvBsT5xI3vBMnTuDixYu4ceNGzzF2wzh+GNfXrcD08larhSNHjgBAT1aUHnuUAXB80TPJtaper+Pq1atIpVIYGhqSMBL/rw1Hgt83xwjXx7GxMalTxWxOhm7D4bC0e6ERG4lEYK3F0tKSFAvl2KPImyFjGqVa88lsr3w+j+npabTbbYyNjUmWbzgc7jG019bWejJE8/k8EokEHn30USFC1OvVajWUy2VUKhXxxD5IvAPN0K3wPgA/CuCcMebV7nP/BB0S9BvGmJ8AcB3AJ7r/+yw6afWX0Emt/xu3O8G+rUDdL9zj3eA5gahRoCXA6rY6tZkZXsDG4qz1P+FwWCaxTvXUWV+6WjUtXJ/Ph3g8jpWVFbkeXgszh3QqPhcMZp7xfbzecDiMmzdvSkaDXih0BhzJ2VZ6IX2fHO4f2u02Lly4gPe9730AIJasJs46rABARMiRSAS5XA5jY2MoFosol8t466238Pu///v4oR/6IcnQojeRfY10PzotYq3X63jzzTfFG8k2CaFQSBpSUkcHQCxShsWq1aocm+OXmwIt2UajgUOHDuGjH/0oQqFQj7eV0AaD9hZ4dUA6VMb7lEwmcezYMSwsLKBarW4aw7vQQ/TQotlsilD42LFj4lXkOkvy4PXqaNE0SRF1lYVCAYlEAkNDQ1KJXZMgDb0HaOE25w096MvLyxI2o8cpGAxK4+zV1VWk02nJ5OVrGDZj0VB+Dm10sz7Q5OQkLly4gLm5OSQSCSSTncRCGgETExPI5XJoNpu4evUqlpaWsLa2hsnJSRw+fBiRSETIG7VBlUoF1WoVN27ceCAVp7e6x9t0nC8D2Eqf8eE+r7cA/s7dnGPfkiENbTV4XfCs6ktiAnSsmlQq1SOI42ILoIckcfDTs8SwBICebszARlVpkhBO+HQ6LUyfx+N1cUGg/oIF8dhklt4E6jiazSaKxWIPEfJ6nHQhPV0OwHvPHB4MpqamUK1WxSupH946LdRLUM+QTqcxPDwsTU8bjQZefPFFpNNp/KW/9Jekvkmz2cTCwgIWFxclBVeHjLnI12o1LC4uildyfHwcR48eFQG0tZ2+TDdv3sT169cxNTUl59bjmuNMe5PY6fw973mPeAS0ng6AeMTYrkBnYHqhPahMRAiFQjh48KDUMuLreP/cuH6wWF1dxaVLl9BqtXDixAkAEC8NSTe/X50VxgfX5nq9Lu1hSAZYwDObzfYQFRJeEiySG55Tk3SSERa5jUajQtB1KROObX0OepJYDJGVrb2e9bW1NQwNDWF6ehq1Wg1LS0siwWBF6XQ6LX3JRkZGEAgEMDk5ieHhYVhrJdOYZIhEaGFhQdb7ncBemk/7mgzdKtzDCaO7ydNyoVYD2GiCSleufi//Tw8OiQjjwfoYAMQzRGJDC9vn82FoaEg6evO62RxQb4psb0ASpFMz6W7VMXR9vToGrkNkOmTm8OBRKpUwPT2No0ePio5Hh8p0+QcAkk1Gss56P5VKRer0fOELX8Dq6ioeffRRsSqvX7+O2dlZ1Go1sWY1EQE682RhYUFc8teuXUMkEsGRI0fQarVQKpVw/fp1XLt2DfPz8z2tXTSxInHXIv+zZ8/i5MmTPV4AACI8ZWp8vV5HNBpFJpPpqY/Uz9PrtcKZbDA4OIjFxcVNGiSHB49Wq4WrV6+i2Wzi1KlTIsgHILoZhlPZQsir8wyFQrLucX60Wi3Mzs5ibm4OyWQSuVxO+j16BfZc02lkci2nwbq2toaFhQUcPXpU+o21Wi3k83khU8zcJSlhaIz/Yy0iGpv8DCytcvjwYbzxxhvSi43FJXUZDIamh4eHkUwmpQErf7ItR61Ww/Lyco8cYiewl+bWviRDXle49ox4Qe+MXlD1Qk2vC/9Py0C39eBEXl5e7iE73swtLZDlIk6LQ3t3GOPWPdR04S/Gm/UGobVN+jPre0CrS4sMeR3eYnW7HWaP9Hq6E7RaLZw/fx4nT54UtzvJkE5D1jV/SODb7TYymQyGh4dlkSwWi1hZWcGf/dmfYX5+HiMjI6jX67hy5QqWlpZ6mrECvY1ijTFCljKZDNbX1/HGG29gYWEBPl+n39Pi4qLokPh+Ha7gpkOBaTQaxcTEBMbHx8WLyuwyTfDYpoPH1Z5Y/k0CCKAng1OXuaAglhoMh53H+vo6ZmZmUK/XcerUKQwMDPT8n6SIZIWeS+2JoTeU9YF0mKpcLiOfz4uRqesC6XFOrxCNABqyiUQC8/PzOH36NGKxGKrVao/nnZ5MjjF9LBqq2kD1ShCs7fQ/y2QyWF5eloxH6j/ZUkmH8ljAlJXluf4zZKhT/3cKe2GvIPYlGfKSAO025eavNRO0IoBOJgRdp8yS4cbBKtCagNACLpVKwtJpoXrJFzcwkhudtcONjANeky2CXgMd6uIk5fXotGwvAdQZZVp8yM+2lwY2HpJeT8TFixfFItYian631BmwpYom72traxgYGBCrkQ15C4UCXnrpJcRiMbTbbWnS623J4iXIJBA8N7Vp9JKSrFC3FI/HexIL+Ds3r1QqJZV6Y7GYlKzwCqOpR9J90vScIekB0DMH9aZJ4pjJZBCJRKRfmsPOo91uY3l5Gd/85jdx/PhxTExMbBK507AkieF6qEtP6HHCDFvdJoMi48XFxZ51kGt1JpNBNpuVCs/09JRKJVy8eBFPPvkkqtUqgM3JJ1yvtZ6N10mJhHeP4Wc3xmBsbAyFQkFKqbAVD7ChS9V90mgY02NG3R+zQncSey3svC/JkBfeL0xbl5oIAZABarsZKhSmcXDTvcoJQdfpwsKCDE4Oah2SYnycHhi25qCXR7N/nbLPc2vtCCckSRv/1iGyrTQWvHYdB79VOHE3wjxEvZ6AjdDU1atXceLEiR4PItDJOEylUlIDiKnBbANAkjIwMCBaAr146pokWtxMD40e0xTm6yQBEiQSNL/fj2QyKXWOdNYlNx1dLZvV0fmTFXup9dF6DB1a0KnxOuTLa9Pv0yUkmGkXjUalLc0u+rr3NaztlFc4f/488vk8jh8/jnQ6LetXs9kUIuT3+6VYrSYH/J51TSHOGe9Pji++l6UkpqamZOzoVhblchntdhsTE50SNv0MUq691DOtra1JNlcikehZt3kMzg3dvJbzk6+jMcNsM61XZT2hpaUlqZW0G7CX5pUjQwo6LKRTlbX3hG5Oa61sInSz6pLwukYGU4/1MbQXyrtBaBEsz08LQIereF08L6+DG5t+bn19XQTYWxEhbY1r8exeGtBd/Ds8RL30qJV45ZVXcPr0aVnAtQeRlrG1nfopFKFGo1G0Wp3GpdlsVrQFjUZDmlO2223pKL6+vi41iHQoi+R9aWkJlUpF6lF5SzAEAgEkEgkcOXIEw8PDIujnnNCJARy3iURCWsnoyr0k5DQ4uMnRUvdeg3dj4vu9hg3DDBS/7qSmwqE/Wq2W1Lc6evQoxsfHEYvF0Gg0JMzFNZKkiGskZQrARjILH5oc8cHnAfR4kkjwKVxmyvqXv/xlHDhwQEJm7C1G45eedXpbp6ensb6+Lh0C+oVmKVFgiyRgs2dlfX0d09PTWFlZEVE4DR1mj+n9YTdgN13L7eDIUBfa++H9CWx4izhoSYZoaVLcRpcoF34Am0qgM7aswRgzrWJOcu0i7sf2dao9ALESGo0G4vF4j5WsC371+6y0oPl6LiqaEO12cmQewl56vN9vv/02isUiUqlUjyeE2WAMFzCri1YyNwrdo4iWbqlUAgBpOswO3BSO0tIlKSEJIWnXHhoSpmw2i6GhIfGg8jPo0AFfzxR9ZstwDnDTsNZKWIAkjgYIdUAkQtzcCF3nSxMe6k+SyWSP13e3j+39BmstyuUyXn/9dczNzeHw4cPI5XIIhULitWStHwqVOSa4NpOkcN3jGqfHhZYR6LHE/3FckSQxY+3P//zPMTg4iCNHjiCVSskx2OqGyQqZTAa5XK7HM8nPpwvorq6uYnFx8ZaSBGutSCa83tndiL1kaDgy1Afe0BCwoachiSHp4ORieXUNb0Evgq5g9qPRQk8KBHXVaK2F8F6n9gzwurUbmCnN9Xp9ExnykhwdYtCv7adv2sV4aHs9FYtFvP766/jABz4g5IbjsNlsCqnQBRkZLqCwNJ1O93TYpvUKQMJfZ86cQSqVgt/vF6FosViU3njMaNEgKU+lUshkMgDQs9BrUTOJfyQSQTKZFE0R06hZaE4vpLTKeQ6Kn5m149XH8W9dpBHYyCiLx+OSjUbsFcK/37C+vi5d3EdGRiSTKplMSvsWkiMaksFgsGcOcE30tkLi8QH0jCHtbdSEisfMZDJYXV1FqVTCyy+/DGBD0M81O5lMYnx8XMY1sCH212OTx2WdpDsZe1sZx7sJTjO0h+H98jgZ+LzW63AA0yWqG1hywWdF337sOJ/PS/YMJyePpQc63xuLxTZ5c/gekid6rBg+ASDiOp15puElfvr8/Qrb7XbYh7jX0/r6Ol566SV827d9m2SnaMEyvUSs/MyQEgWnrFmitULcJGq1mmSotNttJBIJ0fRQM8RxpQX81CYx3DUyMiLhAB5bg/OEPZfYikN7tDjnaBDQymeoT3u+AoEASqWSvIb3gjomr0eI5I+Cc113htilX/++hrWd+lVs8Ds4OIjJyUlks9kew4DjlYal1jrScNDJB0xy0R4hrS+jh9ybXEPSFY1GpVWOrqOla2jxOa2B09fMv+fm5h667Ma9NJccGfLA++XR5bq2tibERi+6Ol2Yg11bv7pDtrY8q9UqCoUCBgcHZZIB6LFMtPXNasGs2+LVGXHD0s1Y9eTT1rEmNiQ7uqikfo03vMFz76VB3sVD0etpenoaly5dwpkzZ4TQcDHVVWYZotJZVywYpx8cG3Nzc5JZdf78eSlYRyLFBpKDg4NCrkm0eex0Oo2hoaGeitVax0ByRW0Q28hojZIOdXEDrNfriMViGBgYkHHO+ZdIJGCMkcKOJGn8qcc0x7BOa95r1ut+B41S1sNi4UEtrvbqifiThicNBS8x8epFvdlhJE76vVrzCfRqTPW6rrVJmpTxuWvXrqFUKj10Y3EvfR5HhvpAe0q4yVAIzcwYTgSGwjQZAtBTW6Lf8a21mJmZQSqVEutY64i0hQJ0hLCsM8GJq1uEABtESFtF2lIGeico/9Z9pkh09CbCTYX/2ysD3D5EvZ5471dXV/Hiiy/ikUcekY1B64WMMaIVoxdG93zyZtZoN/3CwgIajYaE45588klkMhnE43EhV9wUqOHheGdYgOREW8OsFk3SFI/HpX0Bibwm7xzTzWYT1WoV6XQa6XS6x1rXYmhmTfK6dHgX6G3WyhAGr2u3hxoc+mN9fR0rKysolUoYGhrC5OQkMpkMwuGweCrpgeQY03o1jh+tI9LQmYoaOsRGYqTJuzZAeWwSHk2+OG9arRZu3LghpSkeNuyVvQJwZGgTtAXAAcxFn+51XeyNX7buo8ONaH19vS8ZIiqVCq5du4bjx49L1o3OECOYXTYwMABjTE94g+en/oPX1s/1rzcQWjvMxIhGo/IeigA56Xk/vKE0bV07bC/6eeH4+5tvvompqSlMTExIl3cu9kwz9mYUkgSQEGk9hNbakBAtLi7izTffxLve9S7pVK8JR7PZFIJE4h6LxeQ6tLufpD0cDiOXyyGbzSKZTErNGG48HGd+vx+lUgm1Wg2jo6OIRqM9YlNgwwJvtVqoVqvI5/OSqKDDFPq+cTNiHaN8Pt/jBXDjeO+BVabZuHR8fByDg4Oi09HtlHSFfQCb5oBXnqDHjH6O79WGodfr4x1X3nkGdNo6TU9PP5QeIWDveV0dGeoDik5JOOr1ujR11DVTaKkDkM2CnhbWe7lV4StrO92OjTE4fvx4j8jOK972+XySCkyXcKVSkb5kOiMCgOib6I4FNtLnNZFhfx1tOVFoqEXUfL/TVzwYeEOr+j7XajV86Utfwg//8A9Lqw1awPQIegslckHW/fB0erFepNmfbHZ2Fq+99hqefvppjI6O9pAqHa7S2jXt1eHiT3FrKpXCwMAAUqmUaOC0tczrZlPZoaEhIeneTQvoeAeWlpZw6dIllEol8QZovQZfx5/tdhvRaBT1eh1zc3O3zNx5kDDGXANQBrAOoGWtfcYYkwPw6wAOA7gG4BPW2rzpTN5fQKcrdw3Aj1trv7kT171bwHYZS0tLiMfjPUJrzgntEfJqIL0kRz+v54/3OU2YdEKD9t5Tv0mvUqVSweLiIvL5/KYCpw8bdsPculM4MtQH2sWuCxXSQmUGCz00sVhMCnzpNhba9bnVoGi321hcXAQAaVTozXDhJOZmw75RdPuTtPB/dMPyeS0A1FlnxhhEo9Ge6sDUe2hxrjcdX1+bw/3FVt63c+fO4caNG5icnBTxM8MCFHYyDZltCBhCYon/fnoynpOEaHp6Gq1WC08//TQOHjwoxoD2MNGbQ1IEdIyDcDiMZDIpRgQzzagPIrnR3spKpYJms9kjlPYSNwq+b968iWvXrqHRaPStUaRDviT4rIN06dIlLC8v77Yx/EFrra5v9bMAPm+t/TljzM92//4ZAN8F4ET38R50ioe+50Ff7G5Eu91GuVxGuVzGtWvXpFxEJpNBIpGQzEUd8veSnFuFq7weIa0f0uVL6M23ttNElYVOG42GtKrZZWPvvmAvfUZHhvpAZw5ofYLP50OpVBLvCgtycYIBkAlQKpWkhsvtQA9RNBrFgQMHemoZ9ctG0FY+SZgWdtN7pCsK8zMw64zkSaflcxOJRCI9bT9oWffzDDncX/S719Z2SjN88YtfxF/7a39N2gvo2iv8ntg+huOTLnx2q/d6W7SXZ2FhAZVKBXNzc/jSl76Exx9/HKdOnUIqldo0Pkna9PPaw8m2HKzFRbKiyTm9nHydrqPC8Fy5XMbCwgJmZmZQKpWE3OgsIu0F0GHftbU10R6dO3duL7TieAHAB7q/fxod/dvPdJ//Zdu5+BeNMRljzJi1dnZHrnKXotVqyTo8MzMDn88nBD2dTouH0tv6hfCGyHREwPu7DoFxDK6srGB+fr5HW7fLx9u2Yy/poBwZ2gK0KHVmGAXRXMjD4bA0j/RmGUxPT2+ZJun1sACdQTMzMyPdiqmfADb0Ebo6NMWx2kLXPaN0hgStb3oPCC0w1YSIBK9arfY0s+x33Q47A2stzp07hzfffBOPPvqoFFLUGWO1Wg2BQEBCBWtrazBmowIux47WN+gMxVAohMXFRQlbvfTSS/j/t3eusY1e553/HV0o3kRS99GMxqPJ2LHrzU7sNE0TpDWKulmkdZD0QzZN0c2tBvJh0yIFumjSfly0QPqlqRctsutN203a7KZBGsNBktrr2HW9Tm3Hl47t+jKeq0ajOzUixbsuPPuB73PmkCPNSGNJJKXnBwji5SV5+PIlz/99zv95nvn5ee666y5XEdgvIOePDa4a+eW1xLfhiye//ou0HpCzezmOpQVIOp1maWnJJTRIRFa+m77ol3HISUu5XKazs5NEIsH09DRnzpxpNU+DBf6vqRX0/B+2VuRzxBM4s8BIcNlVTQ+Qiup1Ysg0sWp6qyGeHvHYzc3N1f2O+hlocj0SibiGwfInz+ULIt8Uvba25lreZLNZd0J6EGmx79cNUTG0Cf6ykGTBSKaChFvlvxRdhJrAmJycvKZ4lr9e7Xs7/BBrtVrl0qVLrrCcH6GCesO2RHmk0KNf3NF/Pt/07HsoZAKUCJE8p7yeCCfxiLSTwj8oVCoVHn30UY4fP04sFiOfz9f1E5PJXzw8IhjkR1yW03xPmD9BSJXmhYUFFhcXKZVKXLhwgcXFRW6//XZOnjzJ0NCQizr5kRi4Ktoba2j5KcWSEDAzM8PS0hLFYtFNJlIlWyYUY4z7/vmmWD+q6UeExNOXz+dZX19nYGCArq4unnnmGfL5fKv9UP+CtXbKGDMMPGaMedO/01przTYrn9smVk1vByTaKMeIj/9daDRgix9NjmE/YcEvNKq0VyRMxdAm+Cm3MjFIiFVaDfhmVPkiXLlyxfksfOEiE088HieZTLpsB2mRIGcsxWKRqalaceR4PO6+aCJQ/AJh4vkRn8/KyoqLEPlhXBFEkt0m782fHP0JTH4EpGqxL8I0OtRaXLp0iSeffJL77ruPUqlELperyyyT2kPW2mvEre8R83/A/ahjb28vqVSKwcFBFhcXnWB5+eWXuXz5MnfccQe33367qwHkZ4fBVf+bTBx+LSSATCbDqVOnmJqacku/coYei8WIxWJ1SxHynI3JBr4p1n+tQqHA+vq68428/vrrvP766+49t0pGpLV2Kvg/b4x5iFoZiDlZ/jLGjALzweZSNV3wK6orO4AcQzfKCFauT7O/V9tBxdAm+EsH0tQxFAq5uisy4fipxsvLy5w+fdotpYkISiaT9Pf3OxOfmJaBuoJ5UohxcXGRdDrtIkiy5hyNRl1GmSBnLNICQQyojWcnMk5/qa0xa03er0xm4XDYnZ1rPZbWpFqt8tRTT3H8+HHuvPNO52lrzKYKh8OuNlBjlpkUQ/SN8rKN1AUSQSTH5/LyMplMhmeffZY333yTY8eOcfz4cUZGRojFYtcUIRUkHX55eZkLFy5w4cIFjDH09/fXVVmH+gmpcWzyXL4Q8v1BxWKRcrmMMYZkMsng4CDpdJrHHnvM1T2S15DnatYPtzEmBnRYa3PB5f8A/FeuVkf/CtdWTf8dY8y3qRmns+oXUloRFUP7AP/HUc6gxfcAV8u7i5BZWlpiYmKC1dVVF62JRCKMjIwwOjrqml821rjwfQ3S0K+/v5/Lly8zPz/P8PAwQJ3vQSYaPytCRFcoFGJ5efkav5KsZ/uZP40ei0ZhJMUYRRD526iRenfZzv4tFos8/PDDDA0NOcHSKBDW19frqpSL0Ba/mPQG8495MdjLsS+ZOQMDA86YeuXKFQqFAq+++iqnT58mlUoxMjLCoUOH6Ovrc01i8/k86XSaTCbjjNKy5NXT0+PS9huR41b2id9iobEwqHxH5Pm7u7vp7e1lYGCAbDbLww8/zMzMTCsetyPAQ8H76gL+t7X2EWPM88B3jDH3AxPAJ4Ltf0Qtrf4stdT6z+39kBXlxrTgd21TDrwY2mzSEaEhQkAmBznz9CcZyXJZXV0llUqRSqVc08yxsTFSqZRLJZaUfOmlJJORTDpS9ycajXL+/HnS6TTDw8NOhPk90WSZzW86KM9RKBQ2XdLymxn6xenkuUUkScQgFAq5NiDX22fKzrGd/WuMYWZmhu9973t8+tOfxlrL0tKSex45Tv3qvJIgIMelCGo/s8yPEPnmUmml0d/fz9DQkDNYS2TzypUrnD592mW2yThCoZB7jI/vm2tEhJDvs2vMFhO/nPiLOjo6iEQi7ns4Pz/PQw89xNmzZ3dkf+80tlYd/d0b3L4I3LvB7Rb4wh4MTVFumnbzTh14MbTRh9XV1UUqlSIcDrsf+WKxSDQadeLHL+QGV3skpVIpbrnlFpLJpGszIEtqknEgE5DUnZCUT1lW88XKG2+8wczMjCsgJi0E5PF+ATwZi6TPixiSZS/fEOibAmU/+Gn7fs816Qbte0GU1kGO4ddff50f/vCHfPSjH3VLQb4YkuNDRA3ghLUfOZQCoo3RQznWRBBJtEiOS4nKyJ9kM4rnLpVKOcO/eOwas9kax+x/JxqXxOS76L+WjEvqGZ0/f56HHnqIycnJtvtxVpR2p52+bwdeDDVijHEVTKXD9/z8PNls1oXzRcRIpdFQKERfXx9Hjx5lYGCA3t5eJzb8SUh+2GVikZosElWSFH05Cx4cHOS2227jpZdeYnJykv7+fgYHB0kkEiwvL7sMIT8NX/xDslTm13yRiawxIiQTi5xlS4TAH7Ofmq2RodZBPgv5/y//8i/E43HuvfdeV0fHr5HSWKJB7pPjwzfd+5FHibjI8SkdwldWVlyjVT+jxq9P5Uc+/Sim+Opk28bokH/sybbyPqUKuyQNyIlHLBZzmZjPP/88jzzyCOl0WqOaitIE2ikLeUtiyBygUvGdnZ0MDg7S39/vCtPFYjHm5ubIZrOUSiX3wy5+BN8Y3Zj+3tnZ6YRTY6E53wMxPz9PtVp1S2riUzp06BDHjx/n5Zdf5sKFC5TLZVKpFNZahoaG6s6mZelDXldec6N2CUBdBEiuy5m6P2nJY0ulUl2qv04su8PN7FfZfnV1lSeeeIJIJMIHP/hByuXyNREREb0SGWyspSXVqn3R7t8ul/16RNIQVqKfjT+Cfp0WPzoqY5MxyXP4gsw3g0sigERIRWhJhCoSiZDL5Xj88cf5yU9+QrFY3HA/KYqy+7TT9207kaF9XyreGEM0GmV4eNjV2RH/QTweZ3l5mfn5ebq6ujhx4oRrCCjRHriaHeYXZpQzaelD4xtAZUludXWVmZkZenp6iMfjLqITDoc5evQoExMTzM3NMT09zezsrCuYJ74MmYyk0aYfBdiowqqfleOLN7i6rCaTlR/R0jPs3Wc7+3WjbUulEo888ghdXV28733vc8eD37G+XC7XpbH7fhw57v2+dnA1pb2x/5Kf1bXZspf/fyOxJPdL1FU8db6I8r1BUOurJ/4lqfc1MTHBo48+ymuvvVZXLNSPoG13HyuKsn3abVn67SyT7btS8ZLiG4/HnWFZznw7Ojro7+/n0KFDAIyNjdWZmqUxpfiJxMcjosj3Zfg9meTsfHBwkHw+z9zcHJFIpG4pI5FIMDIywuLiopuECoUCb731Vl0Rx2q16jLOksmke7wfLWqspOrXg/EFkiBiSDLh1DfUuvgCNZ/P84Mf/IDV1VU+8IEPuPII4rMRISFRHfnzm0qK302iRLJMKseSeIz8qKcvdPzih5v9MPr3+Ut2jQUUK5WKyxKTk4R4PE5vby89PT0Ui0V+8pOf8MQTT7CwsHBNJGyjy4qi7C7t9H3bqhg6EKXiOzo6SKVSLgoijR39BpjJZJK1tTVisRjGGHcmLMUTC4WC81HE43G3JCCiBXCCSLLKZNIZGRlhfn6eQqHgxIwsX4yMjHDu3Dk3IfkTiIgxOfD8ZbjGUvJ+/7LG+xpT7X0kguBHA3yvitIc/P3f+Dnk83n+8R//kWKxyD333ENPTw+ZTIZKpeIyFiX7UKKLIogkUiSiSJZKZZlMjgOhMTPNjwJtVJVXLvuNYn1vkyzTSjRIoqoSOU0kEsRiMdbX1zl//jyPP/44//Zv/3ZNUUdFUZpHO80NWxVDB6JUvNTVkbNSCccnEgl3NioeIDGcNvpyjDFkMhmy2axbipAMF3+CEWEkBRsBIpEIyWSS+fl5YrFYnVCR7LZCobDpUpV/Xc7O/QaBfjaOHykSseYLLN+jIfsmFAq57Ld2MsbtZ2609FMsFvnxj39MNpvlQx/6EIlEglwu5yItYn72o0NSc0hEkeDXt/LFfEdHh/vfaNaWY8mPAIk48k37svQmniER+FJwtKuri1gsRjKZJB6P09HRwfz8PE8//TTPPfccS0tLbfXDqygHgXb6Tm5JDNkDUiq+s7OzrjGfMYZcLsfQ0JDzzchEIMUVOzs7XYXfRCJBf38/w8PDrlHf4uIiuVzOpaeLqJKlN3k+Cf/HYjGmpqY4cuRIXVaXiBHBNzE3IllscDVNeaPHSITHF06Sat14EMtSmZ+yr1Gh5rDRfr/e57C2tsazzz5LOp3mvvvuY2xszEVbJA3e72nW09NDpVKpE0d+1FCEs7/MKycGImR8Q39jpMhfcvOjP/J48Q3JSUI0GqWvr49EIkF3dzeZTIaf/vSnPP3008zOzt50dXR/P6qXSFF2nnb6Pt1QDJkDVCq+0asQiURIp9OUy2VXR0haFJRKJVZXV120SJBIkDRyTSQSrudYLpdzywx+Z2RZXhA/RzabJZ1OEwqFnJjJZrPXVOj1hZB/0PX09NRFDDbaTp7XN8DKWb000Gw0vDbuH6U5bEcIyf3WWs6cOcPf/d3fce+993Ly5ElXTLNSqVAqlZwg8osz+iZrMVr7EU4RQr6PSMQQ4KJEjXW5RASJECqVSu7Yk0KnUrJCMjvz+TzPPfcc//zP/8ylS5c2rFi9HYGuXiJF2T32o4H6wJSK9yd4KeAGMDs7Szwedz4Lidg0FkyUH2I/C0ZqscgPfrlcdt6ibDZLPp+va5MwOTlJoVDgwoULzoi9srLC4uKiqyrt/0G9CRUgHA7XZZQ10hgtkolNRI8/yfhejkY/kfqG9o7GKMbN7u+FhQUeeughzpw5wz333MPo6CjVatX18hIx5AsiEUB+wU6JFgF1S2ONFaz9DER/ecxfFpMoVbVadZdjsRhDQ0OkUinW1tZ45ZVXePzxx3nzzTfrsjK3KwwVRdk72slOcUMxZA9QqfhGI2p3dzcDAwPMzs66KE0oFCIWixGJRNwSg3Tb9gWRZGb5puaenp5rzoaLxaKLBC0tLZHJZFyKfKVSoa+vj3A47AyrfpaanxXmVxmWtHvfVL3Ze/WjQr4gEvEjE5d4O+Q1NTK0tzQu59yI6wmFSqXCSy+9xMWLF7nrrrt4z3vew+DgINZaCoUC5XLZCR5ZOhMxJPWFGvvbyevJsdI4Vj+tXwRQuVymWCxSKpVcwca1tTXi8TjDw8PE43EuXbrEj3/8Y06dOnVdv5yiKK1HO31HtQK1h+91EEFz6NAhotEoi4uLvPnmmxQKBcbHx11Kr2/6bFxC8s+YgTqPhRhC19fX3TKAZPp0dHQwPDzM0aNHSSQSdHV1kU6nKZVKbnmuMRLlp02HQiEXufIFXmOWmB8d8lOiG5fKZJKTita6TNZ8buRx2crS2eLiIk8++SSvvfYad999NydPnqS/vx/ACf1isbhhCxf/WN/sWPD9ZX5EyBdC+Xy+rr1NPB53wuyxxx7jySefdKnymy0L3wwH0COUB043exDbYBBI33Cr1qHdxgtbH/Oxm32Bdvp+qRjykB9rv12AhOtHRkaYmJhgYmKCYrHI+Pg4g4ODTniIV8IPCzZW2PWFEVxNm+/s7GRsbIxMJsP8/DypVIqTJ0/S19fnnndwcBCA5eVlcrncNWOWcUvESJb4NvNF+JOLHw2Cq80xJVK0vr7O6uqqE0P++PUMfW/ZyWVJifzNzs7y2GOP8eKLL/IzP/MznDx5kkOHDtXVrioWiy4BwC/JsJkgarwux79fOFGWxiQ5QDx0MzMzPPLII7z55pvXLNlu9B5uZl8cwGP2tLX2vc0exFYxxryg491ddnvM+9EzdGBYX193TR/lTFXS7Xt7e+nr6+PixYtcuHCBfD7PiRMn6qpVy9mvLy4ar/uiw29z0N3dTW9vr4sKJZPJuqyuSCTCsWPHWF1d5eLFiywuLrrxyfKbRHOAuiKJcO2k4R+o0hBT3rNEivyokh8Z2ohWEkVmn7ePudF+3upn4W+ztrbG/Pw86XSal156iWPHjvGud73LRUHFJyeieys/dI2eNv87AVePUX/57vnnn+eZZ57Zcqr8VpbNtrI/Wun4VZT9Qjt9p1QMeayvr5PP50kmk27pq1KpuCWCVCrFHXfc4bwMp0+fJpPJOPEiBev81GPfK+Gnu/sZNoCL7lhriUQi17QskMkkHo9z/Phx1tfXSafTzssRiUTqlrYkY61cLl+TVeZPZL43qPEMXy77TTSvtyzSYhNKW7eP2WwZZyv7+O18BtVqlVwux2uvvcbp06dJpVIcPnyYsbExRkdH6evrcxmQklXmC53GaKhv1pdokoig9fV1crkchUKByclJXnnlFaanpzfMmrxRROx67/l69/lLwYqi7Cw7+b0yxvw18BFg3lr7ruC2HTvJVTHkYa0lk8kwODjoxIRMSvJDHovFOHHiBMlkkrfeeouLFy+STqcZGhqiv7+fWCzmfuzlOX3PEFA3gUAti2x5eZmZmRmstc4w7SOTh2SfnThxgq6uLmZnZ939EsWSbJtoNOoq8m6WeQZcc8buv+ZGAkq4kW+oxcRRW7WPudn9diMvzGbCYqPI4erqKgsLC6TTaV599VXXEFWKHyYSCfr6+hgaGiKZTLpCjbKUJs/XGP2RGkITExNMTk4yMzPD8vLyhqny/nvZiqjZLi10fO42DzZ7ANtEx7v77PqYd/j79b+AvwC+6d22Yye5KoY8rLUsLS2RTqcZHR11kRprrYuwdHR0EI1GGR0dJRqNMjc3x/z8PJOTk8zOzpJKpYjFYq5Gi98Gwzc7y+WVlRXy+Tzz8/NMTU25/mdizhYfkCzDiXcnFApx4sQJyuUymUzGnamLz8daSywWY3l5+Zq6QRuJIV8I+V6gxkhR4wTaSOPrNAnLPmofs919upUoyXY+G/87UC6XuXLlCpOTk+77IJHJeDxOPB4nHA4TjUZdBEmWXSuVisuYLBQK5HK5OlP+VthM9BwgUXNTBN+BtkHHu/vsxZh38ntprX3KGDPecPOOneSqGGpAih6OjY25IosSdVlfX6dYLLpO9rJkkEqlSKVSLC8vk8/nyWQyQH0Rx8ZlBFkWK5fL5PN5NzG8973vZXR0FGOMM66KT0PS840xLmvs+PHjvPrqq65DN1z1+EgZgGw2u+EkKJOcCCgRQeIh8vFT8DcSRC02Ge2r9jFb8cU0bnuzr7Hdx8jyaaVSccf9Rkut/mu8HTGzG9EhRVF2nptYfh40xrzgXX9wC4LtbZ3k+qgY2oB8Pu9+5FdXV116cTQapVqtks/nnbdHOsxLVWqp6Ov3WNrIcCrCIp/PMzs7Szabpauri8OHDzvjsyy3SV0WXxBJlk88Hmd0dJSJiQn3vHIWHw6HSSaTFAqFaxpr+mxUgLHxIBZht5HJutUmILtP28fcyDcDuytO/dfeqn9nK2O+2TFc73UVRWk+2yy6mLZvI7vtZk5yfVQMbUCpVGJhYcFVchYDtKT+rq2tUSgUWF9fJxqNugrUnZ2dzvwMV8WFCAyo7ygPtUjU9PQ0Tz31FPPz83XiSWoXiXfJT5+X1ymXyxw6dMh1u/fToROJhOvrlE6nr5ksGic2ee6NJhWJkF0vo6wVMPu8fcxG+36vIiKNIudmHncjrmccv9FzbXU/HKQIkjHmw9SMpJ3A1621X2nykDDGHKXm+xihtqT9oLX2gXbI+DTGdAIvAFPW2o8YY44D3wYGgBeBT1lrV4wxPdTe488Ci8BvWGsv7vFYU8DXgXdR28+/Ta3W1J7t4z34nu3YSW7H9e48qEjtldXVVReRyefzLCwssL6+7sSJLHFJx24xl/b29pJMJkmlUvT19ZFKpUgkEvT29roO4ZJSH4vFOHLkCEeOHGFlZYWZmZk6/44sf/mF76TBayQScWbp4eHhuuq+UtW3o6PDtTXwM2c2Wi4TQeSLJD8TaLPHtxgjwNPGmJeBnwI/tNY+Qk0EfcgYcwb4leA61NrHnKfWPuZ/Av9574d8c2wkEHbzs7leJuFOPb8/fv/1tvq+tjK+Fj52d5Rg4v5LambSO4HfNMbc2dxRAbAG/L619k7g/cAXgnGJGfY24PHgOtSbYT9PzQzbLL4IvOFd/1Pgq9baW4El4P7g9vuBpeD2rwbb7TUPAI9Ya++g1kXiDfZ4H/vzxY3+bhI5yYVrT3I/bWq8ny2c5KoYakA+lGw2y5UrV5zJubOzk4WFBRYWFpwfp7Ozk3K5TKFQcN4eqP8Rl9os5XKZXC5HPp+nWCy6ZbTGKNLFixcpFotYa5351F+aauwab4yhVCoRjUax1rpO5CsrKxSLRQB6e3s5evQoQ0NDrp2HPF7ec2NtJF8cyfu4nuejVbDWnrfWvjv4+3fW2j8Jbl+01t5rrb3NWvsr1torwe3WWvsFa+0Ja+2/t9a+cP1XaB3e7uew2+Jmu2wWudzO42/0mFZ7z7vM+4CzwXdihVoE42NNHhPW2hmJOlhrc9Qm6SPUxvaNYLNvAL8eXHZmWGvts0AqiALsKcaYMeA+atEWgmjKLwPfDTZpHLO8l+8C95o9PPCMMUngHuCvAKy1K9baDHu4j7cjhLZ4ovN/gGeA240xl02tL+qOneTqMtkG2GCJampqioGBAWeg7ujo4PLly1SrVYaHh52Z2e+55AuWjcSGn/VljGF1dZXFxUXm5uaIxWIYY7hw4QLj4+N1TWHF8yPPJa03xIjte5QqlUqdQVsiVZLlMzs7S6lU2nDy8bPefE9QY3Xt6+07pT24GbGx12x3ie1G2x+w43MjE2nTa2j5BNlBdwPPsYNm2F3iz4E/AHqD6wNAxlorNSFkXOCN2Vq7ZozJBtvvVcuO48AC8DfGmHdTW8L7Inu8j3fy+2at/c1N7tqRHqkaGboOS0tLbtlqbW3NtbiYnp5menqaQqEA4Ho2wdX2GL54kPTjcDhc16E+m81y6dIlTp06RT6f5+d+7uf4xV/8RarVKufPn2d5edktk0mtFl+cSCRqbW2Nubk5VlZW3J9f7FGiVj09PRw5coTx8XFisdim77tx2QWu1iJS9hebRUqaFT15O697wIRO22OMiQP/APyetXbZvy+YzFrmAzXGSLG/F5s9li3SBbwH+Jq19m6gwNUlMWBv9vEeLJPtGBoZ2gRrazV9JicnSSQSDAwMABCLxVhZWWFqaopSqcTAwACJRIKenh5CoZB7vN9VXoSECJVCocDy8jILCwtMTU2RyWS46667+MAHPkA4HCaVSnHq1CnOnTvHrbfeSiQSqRtXY1sPSWuWlHuJ6BSLRfr7+ymVShhjXKRpeHgYYwznzp1z9230/mHjydI/cA+SGXU/stln16zPVI+lHaVlMyWNMd3UhNC3rLXfC25u5YzPDwIfNcb8GhAGEtQ8OSljTFcQHfLHJWO+bIzpApLUjNR7xWXgsrX2ueD6d6mJoT3dx+30fdbI0HWw1pLL5Th//jz5fN715wqFQiSTSZaWljhz5gznzp1jZmaGbDZLsVh09YGWl5e5cuUKCwsLTE9Pc+nSJS5cuMDk5CTpdNoVeBwZGeHuu+8mkUjQ0dHB6Ogot99+O+vr60xMTLgq0v6BJZEfqAk0v/q1NH8tFosurV6M1VJIcmhoyKXx+1lvjRhj3DaNtYf8bTa6rChKU3keuM0Yc9wYEwI+Sc1Y2lQC78xfAW9Ya//Mu2vHzLA7jbX2D621Y9bacWr78Qlr7W8B/wR8fJMxy3v5eLD9nikDa+0sMGmMuT246V7gdfZ4H2tkaB9hrSWdTnPu3Dne+c53Eg6HqVarruhiNptlenqaubk5V30XcDWK/I7yUvfn8OHDRKNRrly5wvz8PO94xztIJpMu2tPR0cHhw4fJZrOcOXOGyclJjh49SjgcdmJDmrNWKhXC4TBDQ0OUSiW6u7tdBKpSqbC8vEw4HHZLdeJV6u7u5vDhwywtLbG0tFRnypboE3BNp3IpPtkKB6+iKJsTeFV+B3iUWmr9X1trX2vysKAWZfkU8Kox5lRw2x9RM79+JzDGTgCfCO77EbWU77PU0r4/t6ejvT5fAr5tjPlj4F8JDMvB/781xpwFrlATUHvN7wLfCoTweWr7rYM92sf+PNIOqBi6AeLPmZ2dJRqNcsstt9Dd3U2xWCQajTojtWSaSfREzMvlcplqtUp/fz+HDx9mfHycvr4+uru7icfjrscTUJfJ1dPTw9jYGIVCgampKay1HD16lEgk4iI1fkXsaDSKMYZwOEwkEmF1ddWJonw+74o3ipjp7OwkHA5z5MgRcrmcqzrte4SstS4iFAqFXN0jiZBthi6dKUprYK39EbWJrmWw1j4NbBZC3hEz7G5irX2SWtsHrLXnqWXtNW5TBv7jng7s2jGcAjYqYrhn+7id5gEVQ1tA/EOXLl0iFosxODhItVqlUChgjCGVShGPx7HWukjK2toa+Xze9S679dZbeec730kqlXK+nlAoRE9PjzM6S3NXWYqLx+McO3bMeZeq1Srj4+OuT5mIFcAVfVxfX3cZa5K9Jn2hpPmsn+3W19dHMplkcbG2nN2YsebXNeru7na3yXKboiiKomxEO80RKoa2QalU4ty5c3R1dZFMJrHWks/nAQiHw86vIxljsmzW0dHB+Pg48XicSqVCNpsllUpRrVbp7u4ml8u5XmMS8ZHijolEgmPHjrG2tsbExAThcJjDhw8DuAasEors6elxfch8kSSd7CuVihM3Ioa6uro4dOgQmUym7nFSXkBEmmwvy3jSz2wzNDqkKIpysGmnOUAN1FtEIjHZbJa33nrLdYNfWVlxxRQLhQKVSsUtjVlriUajDAwMEAqFWF9fJ5vN1tUl6u/vZ2pqinK5TKVSca9XLpfdcllvby9jY2MMDAwwMTFBsVh03ev9ytCRSIRKpeKM0oBbtotGo0BN0MljJf0/mUzS29vrxJAIIqlZVC6XXbmAlZUVFwG7nnG6nb4EiqIoys6yHfN0K8wXKoa2iQiic+fOkc1mXR+wXC5HqVRyvcyk1k+1WiUajTphUSgU3DLTysoKw8PDZDIZFx2yttZFXgSLeHuSySS33HIL1WqV2dlZFz2SKI0xhlAoRLVadY+VA0wEkfQzK5VKTtxArU7S4OCgE1W+GFpZWaFUKlEoFJyA8itia/aYoiiKshHtJIZ0mewmsNY6j83Ro0dJJBJuyUpaaIjPRpq5SuaXRGwk2iL+nuXlZRKJRF3EpVQqEYlE6O7uJhQKkUqlOHLkCHNzcwwNDbku8rJ9OBwmkUg4s7e11hWDlGhOOBx25uqenh6gJpaSySRdXV3OC+QfnCKw5PJWDl5dJlMURTnYtNMcoGLoJpAPeHFxkVKpVFfRWbKuOjs7iUajzldTKpVcCwzJ8pLoUDweJ5/Pu3pC0uajWCzS2dnpfEihUIihoSFmZ2fJ5XJOhEmkpquri5GRERYXF1leXiYSibhIj4gieT4RZz09Pe62UCjkGr/CtY1AfRXf2NB1o4NeBZGiKMrBpZ1+/7ckhowxKWrN6d5FrXz3bwOngb8HxoGLwCestUtBQa0HqNUsKAKftUFTvv2EiIJiscjZs2eJxWIMDQ0BNUEkKewiQnyTs/h2xDs0ODjoagL5jVullYb4fYwxRCIRUqkUmUyGVCpFKBRyIkpS7A8fPszp06edd0lS7qVOkNQbKpfLLoMNapGlXC7nHrPRe/bfu4+/vX+fCiJFUZSDx36tM/QA8Ii19uNBAacotSJZj1trv2KM+TK1Ut9fAn4VuC34+3nga7RYc8CdRDxDkiV2+fJlurq6XIq9NHmV/mXSn0wKGQriRUokEkQiEcLhsKsHlEgk6O7udktrsViM6elpV2TRf56uri5SqZRbDoNaHzRJvZeDU0SatOPo7u4mkUiQyWTc9o1cb31XBZCiKIri007zwA3FkDEmCdwDfBbAWrsCrBhjPgb8UrDZN6gVofoS8DHgm0ERp2eNMSnphbLjo28hJBVdUu1vBr8thv/np8JLYcRqtcrZs2edRwmoS3kvFotuu46ODiqVihNEsiwm14vFoqus3dPTw+rqqosONUZ8tmp6U0GkKIpysGmnOWArkaHjwALwN8aYdwMvAl8ERjyBMwuMBJePAJPe4y8Ht9WJIWPM54HP3/zQ9x/bddWXSqUbbiPRoUKhsOH9fhsOfwxb6TfWTge6oiiKsre00xyxFTHUBbwH+F1r7XPGmAeoLYk5rLXWGLOtd22tfRB4EGC7j1V2Dt8HtNHtG92nKIqiKDeineaOrdQZugxcttY+F1z/LjVxNGeMGQUI/s8H908BR73HjwW3KYqiKIpyANh3RRettbPApDHm9uCme4HXge8Dnwlu+wzwcHD5+8CnTY33A9n97hdSFEVRFKWedhJDW80m+13gW0Em2Xngc9SE1HeMMfcDE8Angm1/RC2t/iy11PrP7eiIFaX5pIFC8P8gM4jug5vZB8d2YyCK0mq0gsjZKlsSQ9baU8B7N7jr3g22tcAX3t6wFKV1sdYOGWNesNZu9J04MOg+0H2gKNdjP9YZUhRFURRF2RKtsvy1VVQMKYqiKIqy46gYUpT9z4PNHkALoPtA94GibIqKIUXZ5wR1sg40ug90HyjK9VAxpCiKoijKgUbFkKIoiqIoB5Z2M1BvpQK1oigBxpgPG2NOG2POGmO+fONHtCfGmKPGmH8yxrxujHnNGPPF4PZ+Y8xjxpgzwf++4HZjjPlvwX55xRjznua+g53DGNNpjPlXY8wPguvHjTHPBe/174P6axhjeoLrZ4P7x5s6cEVpMu1UdFHFkKJsEWNMJ/CXwK8CdwK/aYy5s7mj2jXWgN+31t4JvB/4QvBevww8bq29DXicq30KfxW4Lfj7PPC1vR/yrvFF4A3v+p8CX7XW3gosAfcHt98PLAW3fzXYTlEOLCqGFGV/8j7grLX2vLV2Bfg28LEmj2lXsNbOWGtfCi7nqImBI9Te7zeCzb4B/Hpw+WPAN22NZ4GU9C5sZ4wxY8B9wNeD6wb4ZWo9GuHafSD75rvAvcH2inIgqVarW/5rNiqGFGXrHAEmveuXg9v2NcFyz93Ac8CI12twFhgJLu/XffPnwB8A8ms9AGSstWvBdf99un0Q3J8NtleUA0e7NWptFQN1Hjjd7EG0ANrrSXs9tRTGmDjwD8DvWWuX/UCHtdYaY5r/K7ZLGGM+Asxba180xvxSk4ejKG1HK4icrdIqYui09vfRPkfQ8vtgCjjqXR8LbtuXGGO6qQmhb1lrvxfcPGeMGbXWzgTLYPPB7ftx33wQ+Kgx5teAMJAAHqC2BNgVRH/89yn74LIxpgtIAot7P2xFaQ3aSQzpMpmibJ3ngduCbKIQ8Eng+00e064QeF3+CnjDWvtn3l3fBz4TXP4M8LB3+6eDrLL3A1lvOa0tsdb+obV2zFo7Tu2zfsJa+1vAPwEfDzZr3Aeybz4ebN8+s4Gi7DC6TKYo+xBr7Zox5neAR4FO4K+tta81eVi7xQeBTwGvGmNOBbf9EfAV4DvGmPuBCeATwX0/An4NOAsUgc/t6Wj3li8B3zbG/DHwr9REI8H/vzXGnAWuUBNQinJgaQWRs1VMKwzWGPN5LWuv+wF0HyiKouwHjDG2q2vr8Za1tbUXm2mRaAkxpCiKoijK/sEYYzs7O7e8/fr6+nXFkDHmw9Q8e53A1621X3n7o7yKLpMpiqIoirLj7FT9IK/g7YeolbN43hjzfWvt6zvyAqiBWlEURVGUXWAHDdS7XvC26ZGh3Q59tQrGmKPAN6kVqbPAg9baB4wx/cDfA+PAReAT1tqlIJvnAWqm1CLwWakI3O4EKv8FYMpa+xFjzHFqB/cA8CLwKWvtijGmh9o++1lqKcq/Ya292KRhK4qiKFvnUWp147ZK2Bjzgnf9Qc8/ulFR159/m+Oro6liaC9CXy2E9Hp6yRjTC7xojHkM+Cy1Xk9fCRp/fplatorf6+nnqfV62tEPv4lIr6dEcF16PX3bGPPfqfV4+hperydjzCeD7X6jGQNWFEVRto619sPNHsN2aPYymfZ60l5P2utJURRFuR67XtS12WJov/Yzui7a60l7PSmKoihbZtcL3jZbDB04Gns9+fcF1Wr3ba0Dv9dTs8eiKIqitAfBybAUvH0D+M5OF7xttoF6P/Yz2hTt9aS9nhRFUZTtY639EbVK97tCsyND2utJez1prydFURSlqTS9AnUQJfhzrvZ6+pOmDmiXMMb8AvD/gFe56pf5I2q+oe8AtxD0erLWXgnE018AHybo9WStfeGaJ25TjDG/BPyXILX+HdTM8/3Uej39J2ttxRgTBv6Wmr/qCvBJa+35Jg1ZURRF2ac0XQwpiqIoiqI0k2YvkymKoiiKojQVFUOKoiiKohxoVAwpiqIoinKgUTGkKIqiKMqBRsWQoiiKoigHGhVDiqIoiqIcaFQMKYqiKIpyoPn/7+2kS91llEQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "markdown", + "id": "5c8bd495", + "metadata": {}, + "source": [ + "## load ccf_to_template_ref for comparison " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "29c6bb31", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "###############################################\n", + "ccf_to_template_ref = ants.image_read(\"../data/spim_template_to_ccf/ccf_in_template_multisyn.nii.gz\")\n", + "print(f\"ccf_to_template_ref: {ccf_to_template_ref}\")\n", + "\n", + "plot_antsimgs(ccf_to_template_ref, \n", + " f\"{outprefix}/ccf_to_template_ref\",\n", + " title=\"ccf_to_template_ref\", \n", + " vmin=0, vmax=None)\n", + "\n", + "\n", + "print(np.sum(np.abs(ccf_to_template_ref.view() - ccf_to_template_deformed.view()))\n", + ")\n", + "plot_antsimgs(ccf_to_template_ref - ccf_to_template_deformed, \n", + " f\"{outprefix}/ccf_to_template_ref\",\n", + " title=\"ccf_to_template_ref\", \n", + " vmin=0, vmax=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "42243002", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlUAAAE0CAYAAAAFRsbQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAAsTAAALEwEAmpwYAAAsJElEQVR4nO3df5RlVX3n/ffH5ochKj+V8EshoU2GmCUKQWY5yTii2Bh/rQkihhE0mDYrmugy80RMVtSH6AzO80wQl46xRYwwKhCMSgwJQZAZMysijRIVkIeWSGiCYPNLtKOk09/nj7MLDkVV162uU3Wrbr1fa91V9+5z7rn7Huh7v3fvfb7fVBWSJElamMeNuwOSJEmTwKBKkiRpAAZVkiRJAzCokiRJGoBBlSRJ0gAMqiRJkgZgUCWJJD+b5PokDyb5nXH3ZzElOTRJJdll3H3ZkSTPTXJLkh8kecW4+yNpbgZVkgB+D/hiVT2xqt4/205J/jTJuxf6YkMdZ7EleV6SzWN6+TOBD1TVE6rqs2Pqg6R5MKiSBPA04IZxd2K1GHGUzP8m0gpjUCVNoCSHJPnzJN9Lck+SD7T230hyU5vmuzHJs5NcBfwH4ANtqunpsxxzPXAK8Httv79o7f8mydVJ7k9yQ5KXzdG32Y5zYJJPtz7/Q38aMsm7kvxZkv/Z+v6NJE9P8vYkdye5Pcnxvf2vTvJfk3wlyfeTfC7JPrP053W9c3Jrkje09p8E/go4sPXzB62Pj0tyRpJvt3N78WzH7r3G1JTj6Un+Ebiqtf96e+37klye5Gmt/dvATwN/0V539x0dX9LyYFAlTZgka4DPA7cBhwIHARcmeSXwLuBU4EnAy4B7qur5wJeAN7Wppv9vpuNW1QbgE8B/a/u9NMmuwF8AfwM8Bfht4BNJfna2/s1ynMe14/x96+9xwFuSvKj31JcCFwB7A18DLqf7DDuIbqrsw9Ne6lTg14EDgG3AbNOadwMvaefkdcDZSZ5dVT8ETgD+qfXzCVX1T+09vgL498CBwH3AB2d7v9P8e+DfAC9K8nLg94H/CDyZ7r/Bp9o5+hngH4GXttf98YjHlzRGBlXS5DmG7sv+/6qqH1bVj6rqb4HX0wUy11ZnU1XdtsDXOhZ4AnBWVT1UVVfRBXSvnudxfhF4clWd2Y5zK/AR4OTePl+qqsurahvwZ3SByFlV9S/AhcChSfbq7X9BVX2zBUd/CJzUAs5Hqaq/rKpvt3Pyv+gCxF/aQV9/E/iDqtrcgp13ASeOOKX3rvbf5J/bcf5rVd3U3tN/AY6cGq2StPIs66tfJO2UQ4Db2hf19PZvD/xaBwK3V9X2XtttdKNH8/E0umm2+3tta+hGb6bc1bv/z8CWqvrX3mPoArypY9w+rU+7AvtNf+EkJwDvBJ5O90NzD+Abc/T1M0n67/lfgf2BO3bwvOl9ehpwTpL/3u8O3blbaLAraQwMqqTJczvw1CS7TAusbgd+ZoHHrmmP/wk4JMnjeoHVU4EZpxB3cJzbgX+oqrUL7F/fIb37TwX+BdjSb29rlT5NN1X4uar6lySfpQtuZurnVF9/var+z070qX+824H3VNUnduI4kpYhp/+kyfMV4E7grCQ/meTxSZ4LnAv85yRHpXP4Tkw13UW3gHrKNcBWukXnuyZ5Ht3apwvneZyvAA8meVuSn0iyJskzkvziPPvX95+SHJFkD7o1V5f0Rram7AbsDnwP2NZGrY7vbb8L2DfJnr22PwHe01tU/uS2Pmq+/gR4e5Kfb8fZs617k7RCGVRJE6YFDi8FDqdb7LwZeFVV/RnwHuCTwIPAZ4EdXrU2g48CR7Qr/T5bVQ+11zqBbhTofwCnVtW35nmcf6VbLH4k8A/tWOcCe85+iDldAPwp8F3g8cBjkppW1YOt/WK6Bee/Blza2/4tusXjt7a+Hgic0/b5myQPAl8GnjPfzlXVZ4D30l1E8H3gm3TnUdIKlaqZRrclaeVKcjXwP6vq3HH3RdLq4UiVJEnSAAyqJD1KS+D5gxlup4zjOCtFklNmeb9mRZdWCaf/JEmSBuBIlSRJ0gAMqiRJkgZgUCVJkjQAgypJkqQBGFRJkiQNwKBKkiRpAAZVkiRJAzCokiRJGoBBlSRJ0gAMqiRJkgZgUCVJkjQAgypJkqQBGFRJkiQNwKBKkiRpAAZVkiRJAzCokiRJGoBBlSRJ0gAMqiRJkgZgUCVJkjQAgypJkqQBGFRJkiQNwKBKkiRpAAZVkiRJAzCokiRJGoBBlSRJ0gAMqiRJkgZgUCVJkjQAgypJkqQBGFRJkiQNwKBKkiRpAAZVkiRJAzCokiRJGoBBlSRJ0gAMqiRJkgZgUCVJkjQAgypJkqQBGFRJkiQNwKBKkiRpAAZVkiRJAzCokiRJGoBBlSRJWtaSrEtyc5JNSc6YYfsvJ/lqkm1JTpy27bQkt7Tbab32o5J8ox3z/Umy0H4aVEmSpGUryRrgg8AJwBHAq5McMW23fwReC3xy2nP3Ad4JPAc4Bnhnkr3b5g8BvwGsbbd1C+2rQZUkSVrOjgE2VdWtVfUQcCHw8v4OVfWdqvo6sH3ac18EXFFV91bVfcAVwLokBwBPqqovV1UB5wOvWGhHd1noASRJkvrWrVtXW7ZsGXn/66677gbgR72mDVW1od0/CLi9t20z3cjTKGZ67kHttnmG9gUxqJIkSYPasmUL11577cj7P+5xj/tRVR29iF1aEk7/SZKkwVXVyLc53AEc0nt8cGsbxWzPvaPd35ljzsqgSpIkDaqq2L59+8i3OVwLrE1yWJLdgJOBS0fsyuXA8Un2bgvUjwcur6o7ge8nObZd9Xcq8Lmde7ePMKiSJEmDG2qkqqq2AW+iC5BuAi6uqhuSnJnkZQBJfjHJZuCVwIeT3NCeey/wR3SB2bXAma0N4LeAc4FNwLeBv1roe84Iw27zP2iyDjgHWAOcW1VnDf4ikiRpWTrqqKPq7/7u70bef/fdd79uEtZUDb5QvZdP4oV0q+mvTXJpVd049GtJkqTlaTEGbZa7xZj+mzOfhCRJmmwDLlRfMRYjpcJI+SSSrAfWt4dHLUI/tHpsqaonj7sTkqTOpAVLoxpbnqqW1GsDQJLVd+Y1pNvG3QFJ0qMZVA1jIfkkJEnSBDCoGsbD+STogqmTgV9bhNeRJEnL1Aj5pybO4EFVVW1LMpVPYg1wXlXdMPTrSJKk5ck1VQOqqsuAyxbj2JIkafkzqJIkSRqAQZUkSdIADKokSZIWaLWuqbKgskRXrzLJzUk2JTlj3P2RpJXOjOrSKmS9Skka3iQFS6NypEqyXqUkDc6RKml1mrNepbUqNSBrVWriVZXJPyXNzFqVGpC1KrUqTNII1KgMqiTrVUrS4FZjUOWaKqlXrzLJbnT1Ki8dc58kaUVzTZW0ClmvUpKGN0nB0qgcqZLo6lVW1dOr6meq6j3j7o8krWTzGaUaJfiaK5dgkt2TXNS2X5Pk0NZ+SpLre7ftSY5s265ux5za9pSFvm9HqiRJ0uCGGqkaMZfg6cB9VXV4kpOB9wKvqqpPAJ9ox/kF4LNVdX3veadU1cZBOoojVZIkaREMOFI1Si7BlwMfb/cvAY5Lkmn7vLo9d9EYVEmSpMFt37595BuwX5KNvdv63qFmyiV40LSXe3ifqtoGPADsO22fVwGfmtb2sTb194czBGHz5vSfJEka1E5c1belqo5erP4keQ6wtaq+2Ws+paruSPJE4NPAa4DzF/I6jlRJkqTBDTj9N0ouwYf3SbILsCdwT2/7yUwbpaqqO9rfB4FP0k0zLohBlSRJGtyAQdUouQQvBU5r908Erqp24CSPA06it54qyS5J9mv3dwVeAnyTBXL6T5IkDW6oq/9myyWY5ExgY1VdCnwUuCDJJuBeusBryi8Dt1fVrb223YHLW0C1BvgC8JGF9tWgSpIkDW7I5J9VdRlw2bS2d/Tu/wh45SzPvRo4dlrbD4GjButgY1AlSZIGNWnlZ0ZlUCVJkgZnUCVJkjSAln9qVTGokiRJg1uNI1VzplRIcl6Su5N8s9e2T5IrktzS/u7d2pPk/a2g4deTPHsxOy9JkpafoQsqrxSj5Kn6U2DdtLYzgCurai1wZXsMcAKwtt3WAx8appuSJGklMaiaQVX9b7qcD339woUfB17Raz+/Ol8G9kpywEB9lSRJK8RqDKp2dk3V/lV1Z7v/XWD/dn+2ood3Mk0rlrh+erskSVr5JilYGtWCF6pXVSWZ95mrqg3ABoCdeb4kSVq+DKpGd1eSA6rqzja9d3drH6XooSRJmmCTNq03qp0tqNwvXHga8Lle+6ntKsBjgQd604SSJGmV2L59+8i3STHnSFWSTwHPA/ZLshl4J3AWcHGS04Hb6Ko/Q1eX58XAJmAr8LpF6LMkSVrmVuNI1ZxBVVW9epZNx82wbwFvXGinJEnSyrYag6qdnf6TJI1JknVJbm6Jls+Y+xnS0lqtyT8tUyNJK0iSNcAHgRfSpa25NsmlVXXjeHsmPdokBUujcqRKklaWY4BNVXVrVT0EXEiXeFlaVhypkiZAkvOAlwB3V9UzWts+wEXAocB3gJOq6r4kAc6hu8BiK/DaqvrqOPotjWimJMvPmb5TP8HyrrvuetR+++23NL3TRLn//vvZunVrdua5kxQsjcqgSpPoT4EPAOf32qbqVZ7V1qCcAbyNR9erfA5dvcrHfEFJK00/wfKBBx5Yb3jDG8bcI61EH/7wh3f6uasxqHL6TxPHepWacCZZ1rLnQnVpsi2oXqW1KrWMXAusTXIYXTB1MvBr4+2S9FiTlNRzVI5UadVp+dTm9dOoqjZU1dFVdfQidUsaSVVtA94EXA7cBFxcVTeMt1fSYw05UjVXGpEkuye5qG2/Jsmhrf3QJP+c5Pp2+5Pec45K8o32nPe3NbYL4kiVVgvrVWpiVNVldBUspGVrqGm9EdOInA7cV1WHJzkZeC/wqrbt21V15AyH/hDwG8A1dP+e1gF/tZC+OlKl1cJ6lZK0RAZeUzVKGpH+utlLgON2NPLUflw/qaq+3GYvzueRtbY7zaBKE6fVq/w74GeTbG41Ks8CXpjkFuAF7TF0v05upatX+RHgt8bQZUmaOPMMqvZLsrF3669hnW3tKzPt06bIHwD2bdsOS/K1JP8ryS/19t88xzHnzek/TRzrVUrS+M1z+m/LIq1ZvRN4alXdk+Qo4LNJfn4RXgcwqJIkSYtgwFQJo6x9ndpnc5JdgD2Be9oP5x+3/lyX5NvA09v+B89xzHlz+k+SJA1uwDVVD6cRSbIbXRqRS6ft0183eyJwVVVVkie3he4k+Wm6RM+3trWz309ybFt7dSqPrLXdaY5USZKkQVXVYHmqqmpbkqk0ImuA86rqhiRnAhur6lLgo8AFSTbRJX8+uT39l4Ezk/wLsB34zaqaSg79W3QVOH6C7qq/BV35BwZVkiRpEQyZKX2mNCJV9Y7e/R8Br5zheZ8GPj3LMTcCzxiskxhUSZKkRTBJ5WdGZVAlSZIGZ1AlSZK0QJNWKHlUBlWSJGlwBlWSJEkDMKiSJEkawGoMqkz+KUljlOS8JHcn+WavbZ8kVyS5pf3du7UnyfuTbEry9STPHl/PpdlN5aka9TYpDKokabz+FFg3re0M4MqqWgtc2R4DnECXEXotsB740BL1UZq3ATOqrxhzBlVJDknyxSQ3JrkhyZtbu7+kJGmBqup/02WA7ns58PF2/+PAK3rt51fny8BeSQ5Yko5K82RQNbNtwO9W1RHAscAbkxyBv6QkabHs32qTAXwX2L/dPwi4vbff5tYmLTsGVTOoqjur6qvt/oPATXT/iP0lJUmLrLpvnHl/6yRZn2Rjko1bt25dhJ5JO2ZQNYckhwLPAq5hgb+k+v/g59tpSZpwd039GG1/727tdwCH9PY7uLU9RlVtqKqjq+roPfbYY1E7K003n4BqVQZVSZ5AV5TwLVX1/f62nfkl1f8HP5/nSdIqcClwWrt/GvC5Xvupbe3qscADvR+30rKyGoOqkfJUJdmVLqD6RFX9eWu+K8kBVXXnzv6SkqTVLsmngOcB+yXZDLwTOAu4OMnpwG3ASW33y4AXA5uArcDrlrzD0ogmKVga1ZxBVZIAHwVuqqo/7m2a+iV1Fo/9JfWmJBcCz8FfUpI0q6p69Sybjpth3wLeuLg9koYxSfmnRjXKSNVzgdcA30hyfWv7ffwlJUmSZjBp03qjmjOoqqq/BTLLZn9JSZKkxzCokiRJGoBBlSRJ0gBWY1Bl7T9NFMsqSdLyMGRKhSTrktzcPqvPmGH77kkuatuvaXk1SfLCJNcl+Ub7+/zec65ux7y+3Z6y0PdsUKVJY1klSRqzIZN/JlkDfJDu8/oI4NXtc73vdOC+qjocOBt4b2vfAry0qn6BLlPBBdOed0pVHdlud7NABlWaKJZVkqTlYcCRqmOATVV1a1U9BFxI99nd1/+MvwQ4Lkmq6mtV9U+t/QbgJ5LsPtBbfAyDKk0syypJ0vgMGFSN8jn98D5VtQ14ANh32j6/Cny1qn7ca/tYm/r7w5aXc0FcqK6JNL2sUv/fSlVVknmXVQI2tGOvvtWXkjQPVTXf5J/7TfvRuqF97g4iyc/TTQke32s+paruSPJEuu+L1wDnL+R1DKo0cSyrJEnjN8+r/7bsoBbwKJ/TU/tsTrILsCdwD0CSg4HPAKdW1bd7/buj/X0wySfpphkXFFQ5/aeJMkJZJbBArSQtugGn/64F1iY5LMluwMl0n919/c/4E4Gr2qzEXsBfAmdU1f+Z2jnJLkn2a/d3BV4CfHOh79mRKk0ayypJ0jIwVJ6qqtqW5E3A5cAa4LyquiHJmcDGqrqU7sf0BUk2AffSBV4AbwIOB96R5B2t7Xjgh8DlLaBaA3wB+MhC+2pQpYliWSVJWh6GTP5ZVZfR/Qjut72jd/9HwCtneN67gXfPctijButgY1AlSZIGtVoLKrumSpLGyCoAmlRDZlRfKQyqJGm8rAKgiWRQJUlaUlYB0KTavn37yLdJYVAlScvEYlUB2Lp16+J1WprBfEapHKmSJA1qehWA/rZ2leq8qwBU1dFVdfQee+wxYE+l0azGoMqr/yRpzKwCoEk0ScHSqBypkqQxsgqAJpUjVZKkpWYVAE2kSQqWRmVQJUljZBUATaJJG4EalUGVJEkanEGVJEnSACYp/9So5lyonuTxSb6S5O9bCYX/u7UfluSaVirhoiS7tfbd2+NNbfuhi/weJEnSMrMaF6qPcvXfj4HnV9UzgSOBde2Kk/cCZ1fV4cB9wOlt/9OB+1r72W0/SZK0Spj8cxatFMIP2sNd262A5wOXtPbpJRSmSitcAhzXLhmWJEmrhEHVLJKsaZf63g1cAXwbuL+qtrVd+mUSHi6h0LY/AOw7wzEfLqGwoHcgSZKWndUYVI20UL2q/hU4MslewGeAn1voC1fVBmADQJLJOaOSJGmigqVRzSujelXdD3wR+Ld0ldGngrJ+mYSHSyi07XsC9wzRWUmStDKsxpGqUa7+e3IboSLJTwAvBG6iC65ObLtNL6EwVVrhROCqmqQzJkmSdmi1LlQfZfrvAODjSdbQBWEXV9Xnk9wIXJjk3cDX6GpX0f5ekGQTcC9w8iL0W5IkLWOrMU/VnEFVVX0deNYM7bcCx8zQ/iPglYP0TpIkrUhDjkAlWQecA6wBzq2qs6Zt3x04HziKbsnRq6rqO23b2+nSPf0r8DtVdfkox9wZ81pTJUmSNIqhpv/aTNkHgROAI4BXJzli2m4z5shs+50M/DywDvgfLaPBKMecN4MqSZI0qIHXVB0DbKqqW6vqIeBCupyYfbPlyHw5cGFV/biq/gHY1I43yjHnzaBKksbIUmCaVPMMqvabyl3Zbut7h3o4/2XTz435mH2m5cic7bmjHHPeDKo0UfyC0gpkKTBNpHkGVVuq6ujebcO4+78zDKo0afyC0opSHUuBaeIMOP33cP7Lpp8b8zH7TMuROdtzRznmvBlUaaL4BaWVaLFLgW3dunWR34H0WAMGVdcCa9uMw250C88vnbbPbDkyLwVObrMShwFrga+MeMx5G6lMjbSStKs6rgMOp7u6Y+QvqCRTX1Bbph1zPdCf45cGU4tcCuzAAw+cnOyKWhGGTOrZPpvfBFxOl/7gvKq6IcmZwMaqupRZcmS2/S4GbgS2AW9s/96Y6ZgL7atBlSbOYn9BWatSi6Wq7k/yqFJg7cfATKXANlsKTMvZkMk/q+oy4LJpbe/o3Z81R2ZVvQd4zyjHXCin/zSxylqVWgEsBaZJNeD034phUKWJ4heUVqADgC8m+TrdOo8rqurzwNuAt7bpjH15dCmwfVv7W4EzxtBnaU6rMahy+k+TxlqVWlHKUmCaQJMWLI3KoEoTxS8oSVoeDKokSZIGYFAlSZI0AIMqSZKkARhUSZIkLVBVDZqnaqUwqJIkSYNzpEqSJGkABlWSJEkDMKiSJElaIJN/SpIkDcSgSpIkaQAGVZIkSQMwqJIkSVqg1Zqn6nGj7phkTZKvJfl8e3xYkmuSbEpyUZLdWvvu7fGmtv3QReq7JE0EP181iaYWq49ymxQjB1XAm4Gbeo/fC5xdVYcD9wGnt/bTgfta+9ltP0nS7Px81cQxqJpFkoOBXwHObY8DPB+4pO3yceAV7f7L22Pa9uPa/pKkafx81aQyqJrd+4DfA6YmSPcF7q+qbe3xZuCgdv8g4HaAtv2Btv+jJFmfZGOSjTvXdUmaCO9j4M9XePRn7NatWxep69LsliqoSrJPkiuS3NL+7j3Lfqe1fW5Jclpr2yPJXyb5VpIbkpzV2/+1Sb6X5Pp2e/1cfZkzqEryEuDuqrpuHu9xTlW1oaqOrqqjhzyuJK0Ui/X5Co/+jN1jjz2GPry0Q/MJqAYYqToDuLKq1gJXtsePkmQf4J3Ac4BjgHf2gq//t6p+DngW8NwkJ/SeelFVHdlu587VkVGu/nsu8LIkLwYeDzwJOAfYK8ku7dfSwcAdbf87gEOAzUl2AfYE7hnhdSRptfHzVRNrCaf1Xg48r93/OHA18LZp+7wIuKKq7gVIcgWwrqo+BXwRoKoeSvJVun9zO2XOkaqqentVHVxVhwInA1dV1SmtEye23U4DPtfuX9oe07ZfVZM0YSpJA/HzVZNsCUeq9q+qO9v97wL7z7DPw1PnTX9aHYAkewEvpRvtmvKrSb6e5JIkh8zVkYXkqXobcGGSdwNfAz7a2j8KXJBkE3Av3QeFJGl0fr5qxZtnnqr9pq2x3lBVG6YeJPkC8FMzPO8P+g+qqpLMO0prI7+fAt5fVbe25r8APlVVP07yBrpRsOfv6DjzCqqq6mq6YTXaix4zwz4/Al45n+NK0mrn56smyU6MQG3Z0RrrqnrBbNuS3JXkgKq6M8kBwN0z7HYHj0wRQjfFd3Xv8Qbglqp6X+81+1Pr5wL/bUdvAOaXp0qSJGkkSzj9158W70+X910OHJ9k77ZA/fjWRhsR3hN4S/8JLUCb8jIenUtuRpapkSRJg1vC5X5nARcnOR24DTgJIMnRwG9W1eur6t4kfwRc255zZms7mG4K8VvAV1vatw+0K/1+J8nLgG100+2vnasjBlWSJGlwSxVUtWm642Zo3wi8vvf4POC8aftsBmZMoFtVbwfePp++OP2niWQtNUkaLzOqS5PDWmqSNCZLnPxz2TCo0sSxlpokjd9qDKpcU6VJ9D66WmpPbI9HrqWWZKqW2pb+AZOsB9YvbrclaXJMUrA0KkeqNFGsVSlJy8P27dtHvk0KR6o0aaylJkljNmnTeqNypEoTxVpqkrQ8rMY1VQZVWi3eBry11Uzbl0fXUtu3tb8VOGNM/ZOkibIagyqn/zSxrKUmSeMzScHSqAyqJEnSoCZtBGpUTv9J0pgl+U6SbyS5PsnG1rZPkiuS3NL+7t3ak+T9rQrA15M8e7y9l2a2Gqf/DKokaXn4D1V1ZC9txxnAlVW1FriSR9b7nQCsbbf1wIeWvKfSCAyqJEnLRT/b//QqAOdX58t06UIOGEP/pB1ajXmqDKokafwK+Jsk17Xs/QD7V9Wd7f53gf3b/YerADT9CgEPS7I+ycYkG7du3bpY/ZZmtFpr/7lQXZLG799V1R1JngJckeRb/Y1VVUnm9c1TVRuADQAHHnjg5HxracWYpGBpVI5USdKYVdUd7e/dwGfo0n/cNTWt1/7e3XafqgIwpV8hQFo2VuNIlUGVJI1Rkp9M8sSp+8DxwDd5dLb/6VUATm1XAR4LPNCbJpSWjdUYVDn9J0njtT/wmSTQfSZ/sqr+Osm1wMVJTgduA05q+18GvBjYBGwFXrf0XZbmNknB0qgMqiRpjFq2/2fO0H4PcNwM7QW8cQm6Ju20SRuBGpVBlSRJGtxqDKpcUyVJkga3VHmqZqs+MMN+p7V9bklyWq/96iQ3t4oG17ercEmye5KLWvWCa5IcOldfRgqqLKEgSZLmYwkXqs9WfeBhSfYB3gk8h+7q2ndOC75OaRUNjmxX4QKcDtxXVYcDZwPvnasj8xmpsoSCJEma0xIn/5yt+kDfi4ArqureqroPuAJYN4/jXgIcl3ZFyWwWMv1nCQVJkjSjeQZV+01VAGi39XMdv2e26gN9c1Ui+FibjfvDXuD08HOqahvwALDvjjoy6kL1qRIKBXy4ZeqdbwmFR+VRaSdsPidNkiStEPMcgdrSmwl7jCRfAH5qhk1/MO015119gG7q746WL+7TwGuA8+d5DGD0oGpRSyjsxAmQJEnL2JBX/1XVC2bbluSuJAdU1Z3Tqg/03QE8r/f4YODqduypigYPJvkk3Zqr83mkesHmJLsAewL37KifI03/WUJBkiTNxxKuqZqt+kDf5cDxSfZuC9SPBy5PskuS/QCS7Aq8hK6iwfTjnghcVXN0ds6gyhIKkiRpPpZ4ofpZwAuT3AK8oD0mydFJzm39uRf4I+Dadjuzte1OF1x9HbiebhDoI+24HwX2TbIJeCszXFU43SjTf5ZQkCRJ87LQ/FOj2kH1gY3A63uPzwPOm7bPD4GjZjnuj4BXzqcvcwZVllCQJEnztRozqlumRpIm3J133vmDd73rXTePux/zsB+wZdydmIeV1l8Yvc9P29kXMKiSJE2im3d0ufpyk2Sj/V1ci93n1VpQ2dp/mjiWVZKk8VvCherLhkGVJpVllSRpjAyqpMllWSWtZhvG3YF5sr+Lb9H7bFAlTYapskrX9epHzbes0qMkWT9Vk2qxOi0tllbBYsWwv4tvKfq8GoMqF6prEllWSZLGaNKCpVEZVGni9MsqJXlUWaUZakNZVkmSFsFSJf9cTpz+00SxrJL0iCTrktzcrm6ds8TGUkhySJIvJrkxyQ1J3tzal/0VuknWJPlaks+3x4cluab17aIku7X23dvjTW37oWPo615JLknyrSQ3Jfm3S32OV+P0n0GVJs3+wN8m+XvgK8BfVtVfM0ttKLqySrfSlVX6CPBbS99laXhJ1gAfpLvC9Qjg1UmOGG+vANgG/G5VHQEcC7yx9WslXKH7ZuCm3uP3AmdX1eHAfcDprf104L7Wfnbbb6mdA/x1Vf0cXVWUm1jic2xQJa1wVXVrVT2z3X6+qt7T2u+pquOqam1VvaAV0qRd9ffGqvqZqvqF6mpFSZPgGGBT+zfxEHAh3dWuY1VVd1bVV9v9B+m+7A9imV+hm+Rg4FeAc9vjAM8HLmm7TO/z1Hu5BDiu7b9Ufd0T+GW6gsBU1UNVdT9LeI7nE1AZVEmSlruRrmwdpzYt9izgGhZ4he4SeB/we8DUQqF9gfuratsM/Xq4z237A23/pXIY8D3gY2268ty2HGJJz7FBlSRJSyDJE4BPA2+pqu/3t1X3LbtsvmmTvAS4u6quG3dfRrQL8GzgQ1X1LOCHPDLVByzNOTaokiRNimV7ZWuSXekCqk9U1Z+35rumppyW4RW6zwVeluQ7dNOoz6dbs7RXkqmr6Pv9erjPbfuewD1L2N/NwOaquqY9voQuyFrSc2xQJUmaFNcCa9sVarsBJ9Nd7TpWbW3RR4GbquqPe5uW7RW6VfX2qjq4qg6lO49XVdUpwBeBE2fp89R7ObHtv2SRQ1V9F7g9yc+2puOAG1nic7wagyrzVEnSBKqqbUneBFwOrAHOq6obxtwt6EZ9XgN8I8n1re336a7IvTjJ6cBtwElt22XAi+mu0N0KvG5Je7tjbwMuTPJu4Gu0heHt7wVJNgH30gViS+23gU+0gPpWuvP2OJboHFfVqsxTleUQIZqhWgt0XT1SOHnR+f+rFmhJ/3+VxuHxj398PfWpTx15/1tuuWUi/l04UiVJkga3HAZtlppBlSRJGtxqDKpcqC5Jkga1lMk/Zyu/M8N+p7V9bklyWmt7YpLre7ctSd7Xtr02yfd6214/V18cqZIkSYNbwpGqqfI7Z7Ual2fQXUTwsCT7AO8EjqbLz3Vdkkur6j7gyN5+1wF/3nvqRVX1plE74kiVJEka3BKmVJit/E7fi4ArqureFkhdAazr75Dk6cBTgC/tbEcMqiRJ0uDmGVTtl2Rj77Z+Hi81W/mdvlFK8ZxMNzLVj/J+NcnXk1yS5BDmMNL0X5K96IpIPoNu2OzXgZuBi4BDge8AJ1XVfS2x2zl0OS+2Aq+tVjxTkiRNvp3IU7VlRykVknwB+KkZNv3BtNetBaS9OZkuh9qUvwA+VVU/TvIGulGw5+/oAKOOVJ0D/HVV/RzwTLqq4lNzmGuBK3mkrtAJwNp2Ww98aMTXkCRJE2LI6b+qekFVPWOG2+eYvfxO3w5L8SR5JrBLv75jVd1TVT9uD88Fjpqrn3MGVUn2BH6Zlim2qh6qqvuZfQ7z5cD51fkyXW2kA+Z6HUmSNDmWcE3VbOV3+i4Hjk+yd7s68PjWNuXVwKf6T5gWu7yMbkBph0aZ/jsM+B7wsRbJXQe8mdnnMGebt3xUHaE2XzqfOVNJkrRCLOHVfzOWOEpyNPCbVfX6qro3yR/R1cQEOLOq7u0d4yS6ZUt9v5PkZcA2unJDr52rI6MEVbvQVbf+7aq6Jsk5PDLVB+zcHGZVbQA2gGU/JEmaNEsVVFXVPXRFo6e3bwRe33t8HnDeLMf46Rna3g68fT59GWVN1WZgc1Vd0x5fQhdkzTaHucN5S0mSNNmWMvnncjJnUFVV3wVuT/Kzrek44EZmn8O8FDg1nWOBB3rThJIkaRVYjUHVqBnVfxv4RJLdgFuB19EFZI+ZwwQuo5uX3ESXUuF1g/ZYGr8twA/b39VsPzwHO3MOnrYYHZGWm0kKlkY1UlBVVdfTpXafbqY5zALeuLBuSctXVT05ycYd5VRZDTwHngNpR+aZp2oiWPtPkiQNatKm9UZlUCVJkgZnUCVpVBvG3YFlwHPgOZBmZVAlaSQtz9qq5jnwHEg7YlAlSZI0AIMqSZKkBVqtC9VHyaguqUmyLsnNSTYlOWPuZ6xMSQ5J8sUkNya5IcmbW/s+Sa5Ickv7u3drT5L3t/Py9STPHu87GE6SNUm+luTz7fFhSa5p7/Wilr+PJLu3x5va9kPH2nFpzFZj8k+DKmlESdYAHwROAI4AXp3kiPH2atFsA363qo4AjgXe2N7rGcCVVbUWuJJH6oCeAKxtt/XAh5a+y4vmzTy6Ov17gbOr6nDgPuD01n46cF9rP7vtJ61aBlWSduQYYFNV3VpVDwEXAi8fc58WRVXdWVVfbfcfpAsqDqJ7vx9vu30ceEW7/3Lg/Op8GdhrqjboSpbkYOBXgHPb4wDPp6uBCo89B1Pn5hLguLa/tCpt37595NukMKiSRncQcHvv8ebWNtHaNNazgGuA/Xu1PL8L7N/uT+q5eR/we8DUp/6+wP1Vta097r/Ph89B2/5A219adVZrQeXlslD9B8DN4+7EMmAtNWupLStJngB8GnhLVX2/P/BSVZVkcj4Np0nyEuDuqrouyfPG3B1pxZmkYGlUyyWoutn6WdYRg2V/Du4ADuk9Pri1TaQku9IFVJ+oqj9vzXclOaCq7mzTe3e39kk8N88FXpbkxcDjgScB59BNbe7SRqP673PqHGxOsguwJ3DP0ndbWh5WY1Dl9J80umuBte3qr92Ak4FLx9ynRdHWAn0UuKmq/ri36VLgtHb/NOBzvfZT21WAxwIP9KYJV6SqentVHVxVh9L9t76qqk4Bvgic2Habfg6mzs2Jbf/V960iNU7/SZpVVW1L8ibgcmANcF5V3TDmbi2W5wKvAb6R5PrW9vvAWcDFSU4HbgNOatsuA14MbAK2Aq9b0t4urbcBFyZ5N/A1uuCT9veCJJuAe+kCMWnVmqRgaVRZDm86yXrLPXgewHMgSZMgSe2yy+jjNtu2bbtuGS/9GNmymP7zS7TjefAcSNKkWKrpv9mSEs+w318nuX8qkW+vfbCEvssiqJIkSZNlCfNUzZaUeLr/h25Zw3SDJfQ1qJIkSYNbwoXqsyUlnt6fK4EH+21DJ/Qd+0L1JOvoLlNeA5xbVWeNuUuLIskhwPl0yRIL2FBV5yTZB7gIOBT4DnBSVd3X/sOdQ7f4dyvw2qkM1ytdK/eyEbijql6S5DC67OT7AtcBr6mqh5LsTnfOjqK7NP1VVfWdMXVbkjS6y+nyDo7q8Uk29h5vmMdykNmSEo9i5IS+SaYS+s6aS3GsQVWvltoL6d7ItUkuraobx9mvRTJVS+2rSZ4IXJfkCuC1dMOWZ7UCvWfQXV3Ur6X2HLpaas8ZS8+HN1VL7Unt8dTQ64VJ/oRuyPVD9IZek5zc9nvVODosSRpdVa0b8nhJvgD81Ayb/mDa6441KfG4p/+spWYtNWupSZJ2qKpeUFXPmOH2OVpSYoBpSYlHcQ8toW97PFNCX0ZN6DvuoGpS64XtkLXUrKUmSRrMbEmJ59QS9A6W0HfcQdWqM72WWn9b+481/sRhi6RfS23cfZEkTYyzgBcmuQV4QXtMkqOTnDu1U5IvAX9GN+uxOcmL2qa3AW9tiXv35dEJffdt7W9l9qsKHzbuheqTWC9sVtZSs5aaJGlYVXUPcNwM7RuB1/ce/9Isz7+VbjnS9PYfAa+cT1/GPVJlLTVrqVlLTZI0EcZepqaNWryPR2qpvWesHVokSf4d8CXgGzyynuj36dZVXQw8lVZLrarubUHYB4B1tFpqLeqeCEmeB/znllLhp+kuUtiHrpbaf6qqHyd5PHAB3fqze4GT2y8KSZKWnbEHVZIkSZNg3NN/kiRJE8GgSpIkaQAGVZIkSQMwqJIkSRqAQZUkSdIADKokSZIGYFAlSZI0gP8fSrLvKhzMLFUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9452ab1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 71406c0abd09fedaf9c68a68722a4c65e22ac382 Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Thu, 23 May 2024 00:43:24 +0000 Subject: [PATCH 03/15] update registration to template: combine rigid+SyN --- code/aind_ccf_reg/configs.py | 14 +++---- code/aind_ccf_reg/preprocess.py | 4 +- code/aind_ccf_reg/register.py | 73 +++++++++++++++------------------ code/main.py | 40 +++++++++--------- 4 files changed, 64 insertions(+), 67 deletions(-) diff --git a/code/aind_ccf_reg/configs.py b/code/aind_ccf_reg/configs.py index e32e81b..fa1b4f7 100644 --- a/code/aind_ccf_reg/configs.py +++ b/code/aind_ccf_reg/configs.py @@ -111,14 +111,14 @@ class RegSchema(ArgSchema): } ) - #-------------- DO we need to pass transforms to next capsule-------------------------# - downsampled_file = Str( - metadata={"required": True, "description": "Downsampled file"} - ) + #-------------- DO we need to pass transforms to next capsule ?# + # downsampled_file = Str( + # metadata={"required": True, "description": "Downsampled file"} + # ) - downsampled16bit_file = Str( - metadata={"required": True, "description": "Downsampled 16bit file"} - ) + # downsampled16bit_file = Str( + # metadata={"required": True, "description": "Downsampled 16bit file"} + # ) # affine_transforms_file = Str( # metadata={ diff --git a/code/aind_ccf_reg/preprocess.py b/code/aind_ccf_reg/preprocess.py index 8583aab..129ea89 100644 --- a/code/aind_ccf_reg/preprocess.py +++ b/code/aind_ccf_reg/preprocess.py @@ -182,7 +182,9 @@ def resample(self, ants_img, ants_template): write_and_plot_image( ants_img, - plot_path=self.args["prep_params"].get("resample_figpath"), vmin=0, vmax=500) + data_path=self.args["prep_params"].get("resample_path"), + plot_path=self.args["prep_params"].get("resample_figpath"), + vmin=0, vmax=500) return ants_img diff --git a/code/aind_ccf_reg/register.py b/code/aind_ccf_reg/register.py index 8973be0..f987ca6 100644 --- a/code/aind_ccf_reg/register.py +++ b/code/aind_ccf_reg/register.py @@ -219,11 +219,11 @@ def _qc_reg(self, ants_moving, ants_fixed, ants_moved, moved_path: PathLike=None plot_reg(*plot_args, **plot_kwargs) self._plot_save_img(ants_moved, moved_path) - - - - def rigid_register(self, ants_fixed, ants_moving): - """ Run rigid regsitration to align brain image to SPIM template + + + def register_to_template(self, ants_fixed, ants_moving): + """ + Run SyN regsitration to align brain image to SPIM template Parameters ------------- @@ -237,6 +237,11 @@ def rigid_register(self, ants_fixed, ants_moving): ANTsImage deformed image """ + + #----------------------------------# + # rigid registration + #----------------------------------# + logger.info(f"\nStart computing rigid registration ....") # run registration @@ -245,7 +250,7 @@ def rigid_register(self, ants_fixed, ants_moving): "fixed": ants_fixed, "moving": ants_moving, "type_of_transform": "Rigid", - "outprefix": f"{self.args['reg_folder']}/rigid_", + "outprefix": f"{self.args['reg_folder']}/ls_to_template_rigid_", "mask_all_stages": True, "grad_step": 0.25, "reg_iterations": (60, 40, 20, 0), @@ -266,25 +271,10 @@ def rigid_register(self, ants_fixed, ants_moving): moved_path=self.args["ants_params"]["rigid_path"], figpath_name=reg_task) - return ants_moved + #----------------------------------# + # SyN registration + #----------------------------------# - - def register_to_template(self, ants_fixed, ants_moving): - """ - Run SyN regsitration to align brain image to SPIM template - - Parameters - ------------- - ants_fixed: ANTsImage - fixed image - ants_moving: ANTsImage - moving image - - Returns - ----------- - ANTsImage - deformed image - """ logger.info(f"\nStart registering to template ....") if self.args['reference_res'] == 25: @@ -301,10 +291,11 @@ def register_to_template(self, ants_fixed, ants_moving): registration_params = { "fixed": ants_fixed, "moving": ants_moving, + "initial_transform": [f"{self.args['reg_folder']}/rigid_0GenericAffine.mat"], "syn_metric": "CC", "syn_sampling": 2, "reg_iterations": reg_iterations, - "outprefix": f"{self.args['reg_folder']}/"} + "outprefix": f"{self.args['reg_folder']}/ls_to_template_"} logger.info(f"Computing SyN registration with parameters: {registration_params}") reg = ants.registration(**registration_params) @@ -322,6 +313,7 @@ def register_to_template(self, ants_fixed, ants_moving): return ants_moved + def register_to_ccf(self, ants_fixed, ants_moving): """ Run manual regsitration to align brain image to CCF template @@ -347,7 +339,7 @@ def register_to_ccf(self, ants_fixed, ants_moving): start_time = datetime.now() ants_moved = ants.apply_transforms( fixed = ants_fixed, - moving = ants_moving , + moving = ants_moving, transformlist=self.args["template_to_ccf_transform_path"] ) end_time = datetime.now() @@ -388,7 +380,6 @@ def atlas_alignment( logger.info(f"Loaded SPIM template {ants_template}") logger.info(f"Loaded CCF template {ants_ccf}") - #----------------------------------# # orient data to SPIM template's direction #----------------------------------# @@ -425,13 +416,16 @@ def atlas_alignment( logger.info(f"Preprocessed input data {ants_img}") #----------------------------------# - # register brain image to CCF + # register brain image to template #----------------------------------# - ants_img = ants.image_read(self.args["prep_params"].get("percNorm_path")) # + # ants_img = ants.image_read(self.args["prep_params"].get("percNorm_path")) # # register to SPIM template: rigid + SyN - rigid_image = self.rigid_register(ants_template, ants_img) - aligned_image = self.register_to_template(ants_template, rigid_image) + aligned_image = self.register_to_template(ants_template, ants_img) + + #----------------------------------# + # register brain image to CCF + #----------------------------------# # aligned_image = ants.image_read(self.args["ants_params"].get("moved_to_template_path")) # @@ -441,26 +435,25 @@ def atlas_alignment( #----------------------------------# # TODO: register CCF annotation to brain space #----------------------------------# - - template_to_brain_transform_path = [ - f"{self.args['reg_folder']}/rigid_0GenericAffine.mat", - f"{self.args['reg_folder']}/0GenericAffine.mat", - f"{self.args['reg_folder']}/1InverseWarp.nii.gz", - ] - + # TODO ccf_anno_to_template_deformed = ants.image_read(os.path.abspath("../data/ccf_annotation_to_template_moved.nii.gz")) + template_to_brain_transform_path = [ + f"{self.args['reg_folder']}/ls_to_template_0GenericAffine.mat", + f"{self.args['reg_folder']}/ls_to_template_1InverseWarp.nii.gz", + ] + # apply transform ccf_anno_to_brain_deformed = ants.apply_transforms( fixed = ants_img, moving = ccf_anno_to_template_deformed, transformlist=template_to_brain_transform_path, - whichtoinvert = [True, True, False] + whichtoinvert = [True, False], + interpolator = 'genericLabel' ) self._plot_save_img(ccf_anno_to_brain_deformed, self.args['ants_params']['ccf_anno_to_brain_path']) - return aligned_image.numpy() diff --git a/code/main.py b/code/main.py index 128a35c..586bd68 100644 --- a/code/main.py +++ b/code/main.py @@ -123,13 +123,13 @@ def main() -> None: #--------------------------- TODO ----------------------------# + subject_dir = "SmartSPIM_694513_2023-09-30_00-03-18_stitched_2024-01-11_10-15-23" + # subject_dir = "SmartSPIM_709391_2024-01-08_20-45-17_stitched_2024-01-11_15-48-31" + # subject_dir = "SmartSPIM_710625_2024-03-29_10-22-21_stitched_2024-03-30_22-18-10" + subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44" - subject_dir = "SmartSPIM_694513_2023-09-30_00-03-18_stitched_2024-01-11_10-15-23", - subject_dir = "SmartSPIM_709391_2024-01-08_20-45-17_stitched_2024-01-11_15-48-31", - subject_dir = "SmartSPIM_710625_2024-03-29_10-22-21_stitched_2024-03-30_22-18-10", - subject_dir = "SmartSPIM_693196_2023-09-28_23-12-22_stitched_2024-01-11_10-23-15", - subject_dir = "SmartSPIM_693197_2023-09-29_05-18-50_stitched_2024-01-11_13-16-50", - subject_dir = "SmartSPIM_694513_2023-09-30_00-03-18_stitched_2024-01-11_10-15-23", + # subject_dir = "SmartSPIM_693196_2023-09-28_23-12-22_stitched_2024-01-11_10-23-15" + # subject_dir = "SmartSPIM_693197_2023-09-29_05-18-50_stitched_2024-01-11_13-16-50" data_folder = os.path.abspath("../data/") processing_manifest_path = f"{data_folder}/processing_manifest_639.json" @@ -150,14 +150,22 @@ def main() -> None: if not os.path.exists(processing_manifest_path): raise ValueError("Processing manifest path does not exist!") - if not os.path.exists(acquisition_path): - raise ValueError("Acquisition path does not exist!") - pipeline_config = read_json_as_dict(processing_manifest_path) pipeline_config = pipeline_config.get("pipeline_processing") if pipeline_config is None: raise ValueError("Please, provide a valid processing manifest") + # Setting parameters based on pipeline + sorted_channels = natsorted(pipeline_config["registration"]["channels"]) + + # Getting highest wavelenght as default for registration + channel_to_register = sorted_channels[-1] + + #-------------------------------------------------------------# + + + if not os.path.exists(acquisition_path): + raise ValueError("Acquisition path does not exist!") acquisition_json = read_json_as_dict(acquisition_path) acquisition_orientation = acquisition_json.get("axes") @@ -168,17 +176,11 @@ def main() -> None: f"Please, provide a valid acquisition orientation, acquisition: {acquisition_json}" ) - # Setting parameters based on pipeline - sorted_channels = natsorted(pipeline_config["registration"]["channels"]) - - # Getting highest wavelenght as default for registration - channel_to_register = sorted_channels[-1] - #-------------------------------------------------------------# # results_folder = f"../results/ccf_{channel_to_register}" # TODO dataset_id = subject_dir.split("_")[1] - results_folder = f"../scratch/{dataset_id}_to_ccf_{channel_to_register}" + results_folder = f"../results/{dataset_id}_to_ccf_{channel_to_register}" create_folder(results_folder) logger = create_logger(output_log_path=results_folder) @@ -255,9 +257,9 @@ def main() -> None: "right_to_left": 0, }, "rigid_path": f"{reg_folder}/moved_rigid.nii.gz", - "moved_to_template_path": f"{reg_folder}/moved_to_template.nii.gz", - "moved_to_ccf_path": f"{reg_folder}/moved_to_ccf.nii.gz", - "ccf_anno_to_brain_path": f"{reg_folder}/moved_ccf_anno_to_brain.nii.gz", + "moved_to_template_path": f"{reg_folder}/moved_ls_to_template.nii.gz", + "moved_to_ccf_path": f"{reg_folder}/moved_ls_to_ccf.nii.gz", + "ccf_anno_to_brain_path": f"{reg_folder}/moved_ccf_anno_to_ls.nii.gz", }, "OMEZarr_params": { "clevel": 1, From d3e76e6b002107837982e5c888ddeb7b6e2c7a87 Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Thu, 23 May 2024 18:06:24 +0000 Subject: [PATCH 04/15] update path to moved images and transforms --- code/aind_ccf_reg/configs.py | 4 ++++ code/aind_ccf_reg/register.py | 6 +++--- code/main.py | 15 ++++++++------- 3 files changed, 15 insertions(+), 10 deletions(-) diff --git a/code/aind_ccf_reg/configs.py b/code/aind_ccf_reg/configs.py index fa1b4f7..151318d 100644 --- a/code/aind_ccf_reg/configs.py +++ b/code/aind_ccf_reg/configs.py @@ -62,6 +62,10 @@ class RegSchema(ArgSchema): "description": "Path to the transform that aligns SPIM template to CCF"} ) + ccf_annotation_to_template_moved_path = Str( + metadata={"required": True, "description": "Path to the deformed CCF annotation in SPIM template space"} + ) + output_data = Str( metadata={"required": True, "description": "Output file"} ) diff --git a/code/aind_ccf_reg/register.py b/code/aind_ccf_reg/register.py index f987ca6..8d924df 100644 --- a/code/aind_ccf_reg/register.py +++ b/code/aind_ccf_reg/register.py @@ -291,7 +291,7 @@ def register_to_template(self, ants_fixed, ants_moving): registration_params = { "fixed": ants_fixed, "moving": ants_moving, - "initial_transform": [f"{self.args['reg_folder']}/rigid_0GenericAffine.mat"], + "initial_transform": [f"{self.args['reg_folder']}/ls_to_template_rigid_0GenericAffine.mat"], "syn_metric": "CC", "syn_sampling": 2, "reg_iterations": reg_iterations, @@ -435,8 +435,8 @@ def atlas_alignment( #----------------------------------# # TODO: register CCF annotation to brain space #----------------------------------# - # TODO - ccf_anno_to_template_deformed = ants.image_read(os.path.abspath("../data/ccf_annotation_to_template_moved.nii.gz")) + + ccf_anno_to_template_deformed = ants.image_read( self.args["ccf_annotation_to_template_moved_path"] ) template_to_brain_transform_path = [ f"{self.args['reg_folder']}/ls_to_template_0GenericAffine.mat", diff --git a/code/main.py b/code/main.py index 586bd68..eecd227 100644 --- a/code/main.py +++ b/code/main.py @@ -124,12 +124,12 @@ def main() -> None: #--------------------------- TODO ----------------------------# subject_dir = "SmartSPIM_694513_2023-09-30_00-03-18_stitched_2024-01-11_10-15-23" - # subject_dir = "SmartSPIM_709391_2024-01-08_20-45-17_stitched_2024-01-11_15-48-31" - # subject_dir = "SmartSPIM_710625_2024-03-29_10-22-21_stitched_2024-03-30_22-18-10" + subject_dir = "SmartSPIM_709391_2024-01-08_20-45-17_stitched_2024-01-11_15-48-31" + subject_dir = "SmartSPIM_710625_2024-03-29_10-22-21_stitched_2024-03-30_22-18-10" - subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44" - # subject_dir = "SmartSPIM_693196_2023-09-28_23-12-22_stitched_2024-01-11_10-23-15" - # subject_dir = "SmartSPIM_693197_2023-09-29_05-18-50_stitched_2024-01-11_13-16-50" +# subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44" + subject_dir = "SmartSPIM_693196_2023-09-28_23-12-22_stitched_2024-01-11_10-23-15" + subject_dir = "SmartSPIM_693197_2023-09-29_05-18-50_stitched_2024-01-11_13-16-50" data_folder = os.path.abspath("../data/") processing_manifest_path = f"{data_folder}/processing_manifest_639.json" @@ -144,6 +144,7 @@ def main() -> None: os.path.abspath("../data/spim_template_to_ccf/syn_0GenericAffine.mat")] print(f"template_to_ccf_transform_path: {template_to_ccf_transform_path}") + ccf_annotation_to_template_moved_path = os.path.abspath("../data/ccf_annotation_to_template_moved.nii.gz") #-------------------------------------------------------------# @@ -155,6 +156,7 @@ def main() -> None: if pipeline_config is None: raise ValueError("Please, provide a valid processing manifest") + # Setting parameters based on pipeline sorted_channels = natsorted(pipeline_config["registration"]["channels"]) @@ -163,7 +165,6 @@ def main() -> None: #-------------------------------------------------------------# - if not os.path.exists(acquisition_path): raise ValueError("Acquisition path does not exist!") @@ -178,7 +179,6 @@ def main() -> None: #-------------------------------------------------------------# -# results_folder = f"../results/ccf_{channel_to_register}" # TODO dataset_id = subject_dir.split("_")[1] results_folder = f"../results/{dataset_id}_to_ccf_{channel_to_register}" create_folder(results_folder) @@ -224,6 +224,7 @@ def main() -> None: "template_path": template_path, # SPIM template "ccf_reference_path": ccf_reference_path, "template_to_ccf_transform_path": template_to_ccf_transform_path, + "ccf_annotation_to_template_moved_path": ccf_annotation_to_template_moved_path, "reference_res": 25, "output_data": os.path.abspath(f"{results_folder}/OMEZarr"), "metadata_folder": metadata_folder, From 78b82e0021c864d8c3031ec81cb88aefc688b9c6 Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Fri, 24 May 2024 05:12:45 +0000 Subject: [PATCH 05/15] fix channel_to_register --- code/aind_ccf_reg/register.py | 65 +++++++++++++++++++++-------------- code/main.py | 27 +++++++++++---- 2 files changed, 60 insertions(+), 32 deletions(-) diff --git a/code/aind_ccf_reg/register.py b/code/aind_ccf_reg/register.py index 8d924df..ba05056 100644 --- a/code/aind_ccf_reg/register.py +++ b/code/aind_ccf_reg/register.py @@ -167,16 +167,16 @@ def __read_zarr_image(self, image_path: PathLike) -> np.array: return img_array - def _plot_save_img(self, ants_moved, moved_path: PathLike=None) -> None: - # plot and save moved image - if moved_path: - figpath = moved_path.replace(".nii.gz", "") - title = moved_path.replace(".nii.gz", "").split("/")[-1] - logger.info(f"Plot aligned image: {figpath}, title: {title}") - plot_antsimgs(ants_moved, figpath, title, vmin=0, vmax=None) + def _plot_write_antsimg(self, ants_img, img_path: PathLike=None, vmin:float=VMIN, vmax:float=VMAX) -> None: + """plot and save moved image""" + if img_path: + figpath = img_path.replace(".nii.gz", "") + title = img_path.replace(".nii.gz", "").split("/")[-1] + logger.info(f"Plotting image: {figpath}, title: {title}") + plot_antsimgs(ants_img, figpath, title, vmin=vmin, vmax=vmax) - logger.info(f"Saving aligned image: {moved_path}") - ants.image_write(ants_moved, moved_path) + logger.info(f"Writing image: {img_path}") + ants.image_write(ants_img, img_path) logger.info("Done saving") @@ -218,7 +218,7 @@ def _qc_reg(self, ants_moving, ants_fixed, ants_moved, moved_path: PathLike=None # moving and fixed images do not have same dimension plot_reg(*plot_args, **plot_kwargs) - self._plot_save_img(ants_moved, moved_path) + self._plot_write_antsimg(ants_moved, moved_path) def register_to_template(self, ants_fixed, ants_moving): @@ -258,11 +258,11 @@ def register_to_template(self, ants_fixed, ants_moving): } logger.info(f"Computing rigid registration with parameters: {registration_params}") - reg = ants.registration(**registration_params) + rigid_reg = ants.registration(**registration_params) end_time = datetime.now() - logger.info(f"Rigid registration Complete, execution time: {end_time - start_time} s -- image {reg}") + logger.info(f"Rigid registration Complete, execution time: {end_time - start_time} s -- image {rigid_reg}") - ants_moved = reg["warpedmovout"] + ants_moved = rigid_reg["warpedmovout"] reg_task = "reg_rigid" self._qc_reg(ants_moving, @@ -278,8 +278,7 @@ def register_to_template(self, ants_fixed, ants_moving): logger.info(f"\nStart registering to template ....") if self.args['reference_res'] == 25: - reg_iterations = [200, 20, 0] # TODO - # reg_iterations = [1, 0, 0, 0] + reg_iterations = [200, 20, 0] elif self.args['reference_res'] == 10: reg_iterations = [400, 200, 40, 0] else: @@ -291,11 +290,12 @@ def register_to_template(self, ants_fixed, ants_moving): registration_params = { "fixed": ants_fixed, "moving": ants_moving, - "initial_transform": [f"{self.args['reg_folder']}/ls_to_template_rigid_0GenericAffine.mat"], + # "initial_transform": [f"{self.args['reg_folder']}/ls_to_template_rigid_0GenericAffine.mat"], + "initial_transform": rigid_reg["fwdtransforms"][0], "syn_metric": "CC", "syn_sampling": 2, "reg_iterations": reg_iterations, - "outprefix": f"{self.args['reg_folder']}/ls_to_template_"} + "outprefix": f"{self.args['reg_folder']}/ls_to_template_SyN_"} logger.info(f"Computing SyN registration with parameters: {registration_params}") reg = ants.registration(**registration_params) @@ -338,8 +338,8 @@ def register_to_ccf(self, ants_fixed, ants_moving): start_time = datetime.now() ants_moved = ants.apply_transforms( - fixed = ants_fixed, - moving = ants_moving, + fixed=ants_fixed, + moving=ants_moving, transformlist=self.args["template_to_ccf_transform_path"] ) end_time = datetime.now() @@ -410,7 +410,10 @@ def atlas_alignment( #----------------------------------# # run preprocessing on raw data #----------------------------------# - + logger.info(f"{'=='*40}") + logger.info(f"Start preprocessing....") + logger.info(f"{'=='*40}") + prep = Preprocess(self.args, ants_img, ants_template) ants_img = prep.run() logger.info(f"Preprocessed input data {ants_img}") @@ -418,6 +421,10 @@ def atlas_alignment( #----------------------------------# # register brain image to template #----------------------------------# + logger.info(f"{'=='*40}") + logger.info(f"Start registering brain image to template....") + logger.info(f"{'=='*40}") + # ants_img = ants.image_read(self.args["prep_params"].get("percNorm_path")) # # register to SPIM template: rigid + SyN @@ -426,6 +433,9 @@ def atlas_alignment( #----------------------------------# # register brain image to CCF #----------------------------------# + logger.info(f"{'=='*40}") + logger.info(f"Start registering brain image to CCF....") + logger.info(f"{'=='*40}") # aligned_image = ants.image_read(self.args["ants_params"].get("moved_to_template_path")) # @@ -433,14 +443,18 @@ def atlas_alignment( aligned_image = self.register_to_ccf(ants_ccf, aligned_image) #----------------------------------# - # TODO: register CCF annotation to brain space + # register CCF annotation to brain space + # TODO: register_to_template() return transforms #----------------------------------# + logger.info(f"{'=='*40}") + logger.info(f"Start registering CCF annotation to brain space....") + logger.info(f"{'=='*40}") ccf_anno_to_template_deformed = ants.image_read( self.args["ccf_annotation_to_template_moved_path"] ) template_to_brain_transform_path = [ - f"{self.args['reg_folder']}/ls_to_template_0GenericAffine.mat", - f"{self.args['reg_folder']}/ls_to_template_1InverseWarp.nii.gz", + f"{self.args['reg_folder']}/ls_to_template_SyN_0GenericAffine.mat", + f"{self.args['reg_folder']}/ls_to_template_SyN_1InverseWarp.nii.gz", ] # apply transform @@ -452,8 +466,9 @@ def atlas_alignment( interpolator = 'genericLabel' ) - self._plot_save_img(ccf_anno_to_brain_deformed, - self.args['ants_params']['ccf_anno_to_brain_path']) + self._plot_write_antsimg(ccf_anno_to_brain_deformed, + self.args['ants_params']['ccf_anno_to_brain_path'], + vmin=0, vmax=None) return aligned_image.numpy() diff --git a/code/main.py b/code/main.py index eecd227..ea8981b 100644 --- a/code/main.py +++ b/code/main.py @@ -8,6 +8,7 @@ import os import subprocess from datetime import datetime +import glob from aind_ccf_reg import register, utils from natsort import natsorted @@ -116,10 +117,13 @@ def main() -> None: """ Main function to register a dataset """ -# data_folder = os.path.abspath("../data/") -# processing_manifest_path = f"{data_folder}/processing_manifest.json" -# acquisition_path = f"{data_folder}/acquisition.json" -# processing_manifest_path = f"{data_folder}/smartspim_test_dataset/derivatives/processing_manifest.json" + + """ + data_folder = os.path.abspath("../data/") + processing_manifest_path = f"{data_folder}/processing_manifest.json" + acquisition_path = f"{data_folder}/acquisition.json" + processing_manifest_path = f"{data_folder}/smartspim_test_dataset/derivatives/processing_manifest.json" + """ #--------------------------- TODO ----------------------------# @@ -127,9 +131,9 @@ def main() -> None: subject_dir = "SmartSPIM_709391_2024-01-08_20-45-17_stitched_2024-01-11_15-48-31" subject_dir = "SmartSPIM_710625_2024-03-29_10-22-21_stitched_2024-03-30_22-18-10" -# subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44" - subject_dir = "SmartSPIM_693196_2023-09-28_23-12-22_stitched_2024-01-11_10-23-15" - subject_dir = "SmartSPIM_693197_2023-09-29_05-18-50_stitched_2024-01-11_13-16-50" + # subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44" + # subject_dir = "SmartSPIM_693196_2023-09-28_23-12-22_stitched_2024-01-11_10-23-15" + # subject_dir = "SmartSPIM_693197_2023-09-29_05-18-50_stitched_2024-01-11_13-16-50" data_folder = os.path.abspath("../data/") processing_manifest_path = f"{data_folder}/processing_manifest_639.json" @@ -157,11 +161,19 @@ def main() -> None: if pipeline_config is None: raise ValueError("Please, provide a valid processing manifest") + """ # Setting parameters based on pipeline sorted_channels = natsorted(pipeline_config["registration"]["channels"]) # Getting highest wavelenght as default for registration channel_to_register = sorted_channels[-1] + """ + + all_zarr = glob.glob(f'{data_folder}/{subject_dir}/image_tile_fusing/OMEZarr/*.zarr') + all_zarr = sorted(all_zarr) + all_zarr = [ zarr.split("/")[-1].replace(".zarr", "") for zarr in all_zarr] + channel_to_register = all_zarr[-1] + # lower_channels = all_zarr[:-1] #-------------------------------------------------------------# @@ -184,6 +196,7 @@ def main() -> None: create_folder(results_folder) logger = create_logger(output_log_path=results_folder) + logger.info(f"channel_to_register: {channel_to_register}") logger.info( f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" ) From ff4aaa652a27819b7311027cfee87298c773594e Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Fri, 24 May 2024 05:12:45 +0000 Subject: [PATCH 06/15] fix channel_to_register --- code/aind_ccf_reg/register.py | 73 +++++++++++++++++++++-------------- code/main.py | 27 +++++++++---- 2 files changed, 64 insertions(+), 36 deletions(-) diff --git a/code/aind_ccf_reg/register.py b/code/aind_ccf_reg/register.py index 8d924df..44810a0 100644 --- a/code/aind_ccf_reg/register.py +++ b/code/aind_ccf_reg/register.py @@ -167,16 +167,16 @@ def __read_zarr_image(self, image_path: PathLike) -> np.array: return img_array - def _plot_save_img(self, ants_moved, moved_path: PathLike=None) -> None: - # plot and save moved image - if moved_path: - figpath = moved_path.replace(".nii.gz", "") - title = moved_path.replace(".nii.gz", "").split("/")[-1] - logger.info(f"Plot aligned image: {figpath}, title: {title}") - plot_antsimgs(ants_moved, figpath, title, vmin=0, vmax=None) + def _plot_write_antsimg(self, ants_img, img_path: PathLike=None, vmin:float=VMIN, vmax:float=VMAX) -> None: + """plot and save moved image""" + if img_path: + figpath = img_path.replace(".nii.gz", "") + title = img_path.replace(".nii.gz", "").split("/")[-1] + logger.info(f"Plotting image: {figpath}, title: {title}") + plot_antsimgs(ants_img, figpath, title, vmin=vmin, vmax=vmax) - logger.info(f"Saving aligned image: {moved_path}") - ants.image_write(ants_moved, moved_path) + logger.info(f"Writing image: {img_path}") + ants.image_write(ants_img, img_path) logger.info("Done saving") @@ -218,7 +218,7 @@ def _qc_reg(self, ants_moving, ants_fixed, ants_moved, moved_path: PathLike=None # moving and fixed images do not have same dimension plot_reg(*plot_args, **plot_kwargs) - self._plot_save_img(ants_moved, moved_path) + self._plot_write_antsimg(ants_moved, moved_path) def register_to_template(self, ants_fixed, ants_moving): @@ -242,7 +242,7 @@ def register_to_template(self, ants_fixed, ants_moving): # rigid registration #----------------------------------# - logger.info(f"\nStart computing rigid registration ....") + logger.info(f"Start computing rigid registration ....") # run registration start_time = datetime.now() @@ -258,11 +258,11 @@ def register_to_template(self, ants_fixed, ants_moving): } logger.info(f"Computing rigid registration with parameters: {registration_params}") - reg = ants.registration(**registration_params) + rigid_reg = ants.registration(**registration_params) end_time = datetime.now() - logger.info(f"Rigid registration Complete, execution time: {end_time - start_time} s -- image {reg}") + logger.info(f"Rigid registration Complete, execution time: {end_time - start_time} s -- image {rigid_reg}") - ants_moved = reg["warpedmovout"] + ants_moved = rigid_reg["warpedmovout"] reg_task = "reg_rigid" self._qc_reg(ants_moving, @@ -275,11 +275,10 @@ def register_to_template(self, ants_fixed, ants_moving): # SyN registration #----------------------------------# - logger.info(f"\nStart registering to template ....") + logger.info(f"Start registering to template ....") if self.args['reference_res'] == 25: - reg_iterations = [200, 20, 0] # TODO - # reg_iterations = [1, 0, 0, 0] + reg_iterations = [200, 20, 0] elif self.args['reference_res'] == 10: reg_iterations = [400, 200, 40, 0] else: @@ -291,11 +290,12 @@ def register_to_template(self, ants_fixed, ants_moving): registration_params = { "fixed": ants_fixed, "moving": ants_moving, - "initial_transform": [f"{self.args['reg_folder']}/ls_to_template_rigid_0GenericAffine.mat"], + # "initial_transform": [f"{self.args['reg_folder']}/ls_to_template_rigid_0GenericAffine.mat"], + "initial_transform": rigid_reg["fwdtransforms"][0], "syn_metric": "CC", "syn_sampling": 2, "reg_iterations": reg_iterations, - "outprefix": f"{self.args['reg_folder']}/ls_to_template_"} + "outprefix": f"{self.args['reg_folder']}/ls_to_template_SyN_"} logger.info(f"Computing SyN registration with parameters: {registration_params}") reg = ants.registration(**registration_params) @@ -330,7 +330,7 @@ def register_to_ccf(self, ants_fixed, ants_moving): ANTsImage deformed image """ - logger.info("\nStart registering to CCF ....") + logger.info("Start registering to CCF ....") logger.info(f"Register to CCF with: {self.args['template_to_ccf_transform_path']}") # for visualizing registration results @@ -338,8 +338,8 @@ def register_to_ccf(self, ants_fixed, ants_moving): start_time = datetime.now() ants_moved = ants.apply_transforms( - fixed = ants_fixed, - moving = ants_moving, + fixed=ants_fixed, + moving=ants_moving, transformlist=self.args["template_to_ccf_transform_path"] ) end_time = datetime.now() @@ -376,7 +376,7 @@ def atlas_alignment( logger.info("Reading reference images") ants_template = ants.image_read(os.path.abspath(self.args["template_path"])) # SPIM template - ants_ccf = ants.image_read(os.path.abspath(self.args["ccf_reference_path"])) # CCF template + ants_ccf = ants.image_read(os.path.abspath(self.args["ccf_reference_path"])) # CCF template logger.info(f"Loaded SPIM template {ants_template}") logger.info(f"Loaded CCF template {ants_ccf}") @@ -410,7 +410,10 @@ def atlas_alignment( #----------------------------------# # run preprocessing on raw data #----------------------------------# - + logger.info(f"{'=='*40}") + logger.info(f"Start preprocessing....") + logger.info(f"{'=='*40}") + prep = Preprocess(self.args, ants_img, ants_template) ants_img = prep.run() logger.info(f"Preprocessed input data {ants_img}") @@ -418,6 +421,10 @@ def atlas_alignment( #----------------------------------# # register brain image to template #----------------------------------# + logger.info(f"{'=='*40}") + logger.info(f"Start registering brain image to template....") + logger.info(f"{'=='*40}") + # ants_img = ants.image_read(self.args["prep_params"].get("percNorm_path")) # # register to SPIM template: rigid + SyN @@ -426,6 +433,9 @@ def atlas_alignment( #----------------------------------# # register brain image to CCF #----------------------------------# + logger.info(f"{'=='*40}") + logger.info(f"Start registering brain image to CCF....") + logger.info(f"{'=='*40}") # aligned_image = ants.image_read(self.args["ants_params"].get("moved_to_template_path")) # @@ -433,14 +443,18 @@ def atlas_alignment( aligned_image = self.register_to_ccf(ants_ccf, aligned_image) #----------------------------------# - # TODO: register CCF annotation to brain space + # register CCF annotation to brain space + # TODO: register_to_template() return transforms #----------------------------------# + logger.info(f"{'=='*40}") + logger.info(f"Start registering CCF annotation to brain space....") + logger.info(f"{'=='*40}") ccf_anno_to_template_deformed = ants.image_read( self.args["ccf_annotation_to_template_moved_path"] ) template_to_brain_transform_path = [ - f"{self.args['reg_folder']}/ls_to_template_0GenericAffine.mat", - f"{self.args['reg_folder']}/ls_to_template_1InverseWarp.nii.gz", + f"{self.args['reg_folder']}/ls_to_template_SyN_0GenericAffine.mat", + f"{self.args['reg_folder']}/ls_to_template_SyN_1InverseWarp.nii.gz", ] # apply transform @@ -452,8 +466,9 @@ def atlas_alignment( interpolator = 'genericLabel' ) - self._plot_save_img(ccf_anno_to_brain_deformed, - self.args['ants_params']['ccf_anno_to_brain_path']) + self._plot_write_antsimg(ccf_anno_to_brain_deformed, + self.args['ants_params']['ccf_anno_to_brain_path'], + vmin=0, vmax=None) return aligned_image.numpy() diff --git a/code/main.py b/code/main.py index eecd227..ea8981b 100644 --- a/code/main.py +++ b/code/main.py @@ -8,6 +8,7 @@ import os import subprocess from datetime import datetime +import glob from aind_ccf_reg import register, utils from natsort import natsorted @@ -116,10 +117,13 @@ def main() -> None: """ Main function to register a dataset """ -# data_folder = os.path.abspath("../data/") -# processing_manifest_path = f"{data_folder}/processing_manifest.json" -# acquisition_path = f"{data_folder}/acquisition.json" -# processing_manifest_path = f"{data_folder}/smartspim_test_dataset/derivatives/processing_manifest.json" + + """ + data_folder = os.path.abspath("../data/") + processing_manifest_path = f"{data_folder}/processing_manifest.json" + acquisition_path = f"{data_folder}/acquisition.json" + processing_manifest_path = f"{data_folder}/smartspim_test_dataset/derivatives/processing_manifest.json" + """ #--------------------------- TODO ----------------------------# @@ -127,9 +131,9 @@ def main() -> None: subject_dir = "SmartSPIM_709391_2024-01-08_20-45-17_stitched_2024-01-11_15-48-31" subject_dir = "SmartSPIM_710625_2024-03-29_10-22-21_stitched_2024-03-30_22-18-10" -# subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44" - subject_dir = "SmartSPIM_693196_2023-09-28_23-12-22_stitched_2024-01-11_10-23-15" - subject_dir = "SmartSPIM_693197_2023-09-29_05-18-50_stitched_2024-01-11_13-16-50" + # subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44" + # subject_dir = "SmartSPIM_693196_2023-09-28_23-12-22_stitched_2024-01-11_10-23-15" + # subject_dir = "SmartSPIM_693197_2023-09-29_05-18-50_stitched_2024-01-11_13-16-50" data_folder = os.path.abspath("../data/") processing_manifest_path = f"{data_folder}/processing_manifest_639.json" @@ -157,11 +161,19 @@ def main() -> None: if pipeline_config is None: raise ValueError("Please, provide a valid processing manifest") + """ # Setting parameters based on pipeline sorted_channels = natsorted(pipeline_config["registration"]["channels"]) # Getting highest wavelenght as default for registration channel_to_register = sorted_channels[-1] + """ + + all_zarr = glob.glob(f'{data_folder}/{subject_dir}/image_tile_fusing/OMEZarr/*.zarr') + all_zarr = sorted(all_zarr) + all_zarr = [ zarr.split("/")[-1].replace(".zarr", "") for zarr in all_zarr] + channel_to_register = all_zarr[-1] + # lower_channels = all_zarr[:-1] #-------------------------------------------------------------# @@ -184,6 +196,7 @@ def main() -> None: create_folder(results_folder) logger = create_logger(output_log_path=results_folder) + logger.info(f"channel_to_register: {channel_to_register}") logger.info( f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" ) From 2dba87d2fe5eb8c0854cff5bb63bc46d58f2fa19 Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Tue, 28 May 2024 17:45:17 +0000 Subject: [PATCH 07/15] remove experimental files --- code/install_pkgs.sh | 15 - code/register_ccf_to_brain.ipynb | 797 ------------------------------- 2 files changed, 812 deletions(-) delete mode 100644 code/install_pkgs.sh delete mode 100644 code/register_ccf_to_brain.ipynb diff --git a/code/install_pkgs.sh b/code/install_pkgs.sh deleted file mode 100644 index e46363b..0000000 --- a/code/install_pkgs.sh +++ /dev/null @@ -1,15 +0,0 @@ -pip install -U --no-cache-dir \ - antspyx \ - argschema==3.0.4 \ - s3fs==2022.11.0 \ - scikit-image==0.19.3 \ - tifffile==2022.10.10 \ - bokeh==2.4.2 \ - zarr==2.13.3 \ - aind-data-schema==0.22.1 \ - xarray_multiscale==1.1.0 \ - dask[distributed]==2022.11.1 \ - matplotlib==3.7.3 \ - ome-zarr==0.8.2 \ - natsort==8.4.0 \ - aicsimageio@git+https://github.com/camilolaiton/aicsimageio.git@feature/zarrwriter-multiscales-daskjobs \ No newline at end of file diff --git a/code/register_ccf_to_brain.ipynb b/code/register_ccf_to_brain.ipynb deleted file mode 100644 index 30670c7..0000000 --- a/code/register_ccf_to_brain.ipynb +++ /dev/null @@ -1,797 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "8ecc0021", - "metadata": {}, - "outputs": [], - "source": [ - " " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "35b40dee", - "metadata": {}, - "outputs": [], - "source": [ - "import logging\n", - "import os\n", - "import sys\n", - "import time\n", - "from datetime import datetime\n", - "from pathlib import Path\n", - "from typing import List, Optional\n", - "\n", - "import glob\n", - "import ants\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3a2641b2", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "from aind_ccf_reg.plots import plot_reg, plot_antsimgs" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "22179f60", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def perc_normalization(ants_img):\n", - " \"\"\"\n", - " Percentile Normalization \n", - " \n", - " Parameters\n", - " -------------\n", - " ants_img: ANTsImage\n", - " \n", - " Returns\n", - " -----------\n", - " ANTsImage\n", - " \"\"\"\n", - " percentiles = [2, 98]\n", - " percentile_values = np.percentile(ants_img.view(), percentiles)\n", - " ants_img = (ants_img - percentile_values[0]) / (percentile_values[1] - percentile_values[0])\n", - "\n", - " return ants_img" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "1824c1c9", - "metadata": {}, - "outputs": [], - "source": [ - "channel_to_register = \"Ex_639_Em_660\" \n", - "subject_dir = \"SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44\"\n", - "dataset_id = subject_dir.split(\"_\")[1]\n", - "results_folder = f\"../results/{dataset_id}_to_ccf_{channel_to_register}\"\n", - "reg_folder = os.path.abspath(f\"{results_folder}/registration\")\n", - "\n", - "template_to_brain_transform_path = [\n", - " f\"{reg_folder}/rigid_0GenericAffine.mat\",\n", - " f\"{reg_folder}/0GenericAffine.mat\",\n", - " f\"{reg_folder}/1InverseWarp.nii.gz\",\n", - "]\n", - "\n", - "ccf_to_template_transform_path = [\n", - " os.path.abspath(\"../data/spim_template_to_ccf/syn_0GenericAffine.mat\"),\n", - " os.path.abspath(\"../data/spim_template_to_ccf/syn_1InverseWarp.nii.gz\"),\n", - "]\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bff3d3d4", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "f83424a4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/root/capsule/data/allen_mouse_ccf/average_template/average_template_25.nii.gz\n", - "ccf: ANTsImage (ASL)\n", - "\t Pixel Type : float (float32)\n", - "\t Components : 1\n", - "\t Dimensions : (528, 320, 456)\n", - "\t Spacing : (0.025, 0.025, 0.025)\n", - "\t Origin : (0.0, 0.0, 0.0)\n", - "\t Direction : [-0. 0. -1. 1. -0. 0. 0. -1. 0.]\n", - "\n", - "../data/allen_mouse_ccf/annotation/ccf_2017/annotation_25.nii.gz\n", - "ccf_anno: ANTsImage (ASL)\n", - "\t Pixel Type : float (float32)\n", - "\t Components : 1\n", - "\t Dimensions : (528, 320, 456)\n", - "\t Spacing : (0.025, 0.025, 0.025)\n", - "\t Origin : (0.0, 0.0, 0.0)\n", - "\t Direction : [-0. 0. -1. 1. -0. 0. 0. -1. 0.]\n", - "\n", - "/root/capsule/data/smartspim_lca_template/smartspim_lca_template_25.nii.gz\n", - "template: ANTsImage (RAS)\n", - "\t Pixel Type : float (float32)\n", - "\t Components : 1\n", - "\t Dimensions : (576, 648, 440)\n", - "\t Spacing : (0.025, 0.025, 0.025)\n", - "\t Origin : (-1.5114, -1.5, 1.5)\n", - "\t Direction : [ 1. 0. 0. 0. 1. 0. 0. 0. -1.]\n", - "\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# deformed_path = \"/root/capsule/scratch/template_to_ccf/25um/Output Image Volume.nrrd\"\n", - "template_path = \"/root/capsule/data/smartspim_lca_template/smartspim_lca_template_25.nii.gz\"\n", - "ccf_path = \"/root/capsule/data/allen_mouse_ccf/average_template/average_template_25.nii.gz\"\n", - "\n", - "ccf_annotation_path = \"../data/allen_mouse_ccf/annotation/ccf_2017/annotation_25.nii.gz\"\n", - "ccf = ants.image_read(ccf_path)\n", - "print(ccf_path)\n", - "print(f\"ccf: {ccf}\")\n", - "outprefix = \"/root/capsule/scratch/ccf_to_brain/\"\n", - "plot_antsimgs(ccf, \n", - " f\"{outprefix}/ccf\",\n", - " title=\"ccf\", \n", - " vmin=0, vmax=None)\n", - "\n", - "###############################################\n", - "\n", - "ccf_anno = ants.image_read(ccf_annotation_path)\n", - "print(ccf_annotation_path)\n", - "print(f\"ccf_anno: {ccf_anno}\")\n", - "outprefix = \"/root/capsule/scratch/ccf_to_brain/\"\n", - "plot_antsimgs(ccf_anno, \n", - " f\"{outprefix}/ccf_anno\",\n", - " title=\"ccf_anno\", \n", - " vmin=0, vmax=None)\n", - "\n", - "###############################################\n", - "template = ants.image_read(template_path)\n", - "print(template_path)\n", - "print(f\"template: {template}\")\n", - "\n", - "plot_antsimgs(template, \n", - " f\"{outprefix}/template\",\n", - " title=\"template\", \n", - " vmin=0, vmax=None)\n", - "\n", - "###############################################\n", - "# apply transform\n", - "ccf_anno_to_template_deformed = ants.apply_transforms(\n", - " fixed = template,\n", - " moving = ccf_anno,\n", - " transformlist=ccf_to_template_transform_path,\n", - " whichtoinvert = [True, False]\n", - " )\n", - "\n", - "print(\"\")\n", - "dataset_id = \"\"\n", - "plot_antsimgs(ccf_anno_to_template_deformed, \n", - " f\"{outprefix}/ccf_anno_to_template_deformed\",\n", - " title=f\"ccf_anno_to_template_deformed\", \n", - " vmin=0, vmax=None)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "60ae0bb4", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "4e98d074", - "metadata": {}, - "outputs": [], - "source": [ - "# ants.image_write(ccf_anno_to_template_deformed, \n", - "# f\"{outprefix}/ccf_annotation_to_template_moved.nii.gz\") \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "92d4f7c4", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "19bfc308", - "metadata": {}, - "source": [ - "## register to brain" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "c222aa45", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/prep_percNorm.nii.gz\n", - "brain: ANTsImage (RAS)\n", - "\t Pixel Type : float (float32)\n", - "\t Components : 1\n", - "\t Dimensions : (535, 738, 314)\n", - "\t Spacing : (0.025, 0.025, 0.025)\n", - "\t Origin : (-1.5114, -1.5, 1.5)\n", - "\t Direction : [ 1. 0. 0. 0. 1. 0. 0. 0. -1.]\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "brain_path = f\"{reg_folder}/prep_percNorm.nii.gz\"\n", - "brain = ants.image_read(brain_path)\n", - "\n", - "print(brain_path)\n", - "print(f\"brain: {brain}\")\n", - "\n", - "outprefix = \"/root/capsule/scratch/ccf_to_brain/\"\n", - "plot_antsimgs(brain, \n", - " f\"{outprefix}/brain\",\n", - " title=\"brain\", \n", - " vmin=0, vmax=None)" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "id": "06ee5b46", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/1InverseWarp.nii.gz',\n", - " '/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/0GenericAffine.mat',\n", - " '/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/rigid_0GenericAffine.mat']" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "template_to_brain_transform_path" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "1b936d14", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/rigid_0GenericAffine.mat',\n", - " '/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/0GenericAffine.mat',\n", - " '/root/capsule/results/685111_to_ccf_Ex_639_Em_660/registration/1InverseWarp.nii.gz']" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "template_to_brain_transform_path" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "1ffe3297", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "###############################################\n", - "# apply transform\n", - "ccf_anno_to_brain_deformed = ants.apply_transforms(\n", - " fixed = brain,\n", - " moving = ccf_anno_to_template_deformed,\n", - " transformlist=template_to_brain_transform_path,\n", - " whichtoinvert = [True, True, False]\n", - " )\n", - "\n", - "print(\"\")\n", - "dataset_id = \"\"\n", - "plot_antsimgs(ccf_anno_to_brain_deformed, \n", - " f\"{outprefix}/ccf_anno_to_brain_deformed\",\n", - " title=f\"ccf_anno_to_brain_deformed\", \n", - " vmin=0, vmax=None)" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "835d8c68", - "metadata": {}, - "outputs": [], - "source": [ - "ants.image_write(ccf_anno_to_brain_deformed, \n", - " f\"{outprefix}/ccf_anno_to_brain_deformed.nii.gz\") \n" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "78ab809a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "###############################################\n", - "# apply transform\n", - "template_to_brain_deformed = ants.apply_transforms(\n", - " fixed = brain,\n", - " moving = template,\n", - " transformlist=template_to_brain_transform_path,\n", - " whichtoinvert = [True, True, False]\n", - " )\n", - "\n", - "print(\"\")\n", - "dataset_id = \"\"\n", - "plot_antsimgs(template_to_brain_deformed, \n", - " f\"{outprefix}/template_to_brain_deformed\",\n", - " title=f\"template_to_brain_deformed\", \n", - " vmin=0, vmax=None)" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "78e92e6e", - "metadata": {}, - "outputs": [], - "source": [ - "ants.image_write(template_to_brain_deformed, \n", - " f\"{outprefix}/template_to_brain_deformed.nii.gz\") \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d0f487f2", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 42, - "id": "04af1b7c", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_overlay(ants_img1, ants_img2, title=\"\", loc=0,):\n", - "\n", - " assert ants_img1.view().shape == ants_img2.view().shape, \"Input images should have same dimension\"\n", - " \n", - " print(ants_img1.view().shape)\n", - " print(ants_img2.view().shape)\n", - " \n", - " half_size = np.array(ants_img1.shape) // 2\n", - " \n", - " fig, ax = plt.subplots(1, 3, figsize=(10, 6))\n", - " \n", - " img1 = ants_img1.view()[half_size[0], :, :]\n", - " img2 = ants_img2.view()[half_size[0], :, :]\n", - " overlay = np.stack( (img1, img2, img1), axis=2 )\n", - " ax[0].imshow(overlay)\n", - "\n", - " img1 = ants_img1.view()[:, half_size[1], :]\n", - " img2 = ants_img2.view()[:, half_size[1], :]\n", - " overlay = np.stack( (img1, img2, img1), axis=2 )\n", - " ax[1].imshow(overlay)\n", - "\n", - " img1 = ants_img1.view()[:, :, half_size[2]]\n", - " img2 = ants_img2.view()[:, :, half_size[2]]\n", - " overlay = np.stack( (img1, img2, img1), axis=2 )\n", - " ax[2].imshow(overlay)\n", - " \n", - " fig.show() " - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "5ec64f2e", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(576, 648, 440)\n", - "(576, 648, 440)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_overlay((ccf_to_template_deformed), \n", - " (template))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ea2a1b00", - "metadata": {}, - "outputs": [], - "source": [ - "for loc in [0, 1, 2]:\n", - " plot_reg(perc_normalization(ccf_anno), \n", - " perc_normalization(ccf_norm,\n", - " ccf_anno_to_template_deformed, \n", - " f\"{figpath}_{loc}\" , title, loc=loc, vmin=0, vmax=1.5)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5b361323", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "###############################################\n", - "# apply transform\n", - "ccf_to_template_deformed = ants.apply_transforms(\n", - " fixed = template,\n", - " moving = ccf,\n", - " transformlist=ccf_to_template_transform_path,\n", - " whichtoinvert = [True, False]\n", - " )\n", - "\n", - "print(\"\")\n", - "dataset_id = \"\"\n", - "plot_antsimgs(ccf_to_template_deformed, \n", - " f\"{outprefix}/ccf_to_template_deformed\",\n", - " title=f\"ccf_to_template_deformed\", \n", - " vmin=0, vmax=None)" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "63767067", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/root/capsule/data/spim_template_to_ccf/syn_0GenericAffine.mat',\n", - " '/root/capsule/data/spim_template_to_ccf/syn_1InverseWarp.nii.gz']" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ccf_to_template_transform_path" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cd176af7", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e122af36", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "c799b576", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/root/capsule/data/spim_template_to_ccf/syn_0GenericAffine.mat',\n", - " '/root/capsule/data/spim_template_to_ccf/syn_1InverseWarp.nii.gz']" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ccf_to_template_transform_path" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "f19f48f9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [] - }, - { - "cell_type": "markdown", - "id": "5c8bd495", - "metadata": {}, - "source": [ - "## load ccf_to_template_ref for comparison " - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "29c6bb31", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.0" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "###############################################\n", - "ccf_to_template_ref = ants.image_read(\"../data/spim_template_to_ccf/ccf_in_template_multisyn.nii.gz\")\n", - "print(f\"ccf_to_template_ref: {ccf_to_template_ref}\")\n", - "\n", - "plot_antsimgs(ccf_to_template_ref, \n", - " f\"{outprefix}/ccf_to_template_ref\",\n", - " title=\"ccf_to_template_ref\", \n", - " vmin=0, vmax=None)\n", - "\n", - "\n", - "print(np.sum(np.abs(ccf_to_template_ref.view() - ccf_to_template_deformed.view()))\n", - ")\n", - "plot_antsimgs(ccf_to_template_ref - ccf_to_template_deformed, \n", - " f\"{outprefix}/ccf_to_template_ref\",\n", - " title=\"ccf_to_template_ref\", \n", - " vmin=0, vmax=None)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "42243002", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c9452ab1", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From c3fd4ac7c802180596b69a6b25f7d48f3be13a29 Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Thu, 30 May 2024 21:44:53 +0000 Subject: [PATCH 08/15] upload pipeline-version main.py and doc --- code/main.py | 103 ++++----- code/main_register_dataset.py | 283 ++++++++++++++++++++++++ code/template_based_ccf_registration.md | 61 +++++ 3 files changed, 386 insertions(+), 61 deletions(-) create mode 100644 code/main_register_dataset.py create mode 100644 code/template_based_ccf_registration.md diff --git a/code/main.py b/code/main.py index ea8981b..356a6dd 100644 --- a/code/main.py +++ b/code/main.py @@ -54,7 +54,6 @@ def create_logger(output_log_path: PathLike) -> logging.Logger: return logger - def read_json_as_dict(filepath: str) -> dict: """ Reads a json as dictionary. @@ -118,89 +117,60 @@ def main() -> None: Main function to register a dataset """ - """ - data_folder = os.path.abspath("../data/") - processing_manifest_path = f"{data_folder}/processing_manifest.json" - acquisition_path = f"{data_folder}/acquisition.json" - processing_manifest_path = f"{data_folder}/smartspim_test_dataset/derivatives/processing_manifest.json" - """ - - #--------------------------- TODO ----------------------------# - - subject_dir = "SmartSPIM_694513_2023-09-30_00-03-18_stitched_2024-01-11_10-15-23" - subject_dir = "SmartSPIM_709391_2024-01-08_20-45-17_stitched_2024-01-11_15-48-31" - subject_dir = "SmartSPIM_710625_2024-03-29_10-22-21_stitched_2024-03-30_22-18-10" - - # subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10_stitched_2024-01-11_10-16-44" - # subject_dir = "SmartSPIM_693196_2023-09-28_23-12-22_stitched_2024-01-11_10-23-15" - # subject_dir = "SmartSPIM_693197_2023-09-29_05-18-50_stitched_2024-01-11_13-16-50" + subject_dir = "SmartSPIM_714635_2024-03-18_10-47-48" + subject_dir = "SmartSPIM_725271_2024-05-22_17-24-06" + subject_dir = "SmartSPIM_725379_2024-04-25_17-02-42" - data_folder = os.path.abspath("../data/") - processing_manifest_path = f"{data_folder}/processing_manifest_639.json" - acquisition_path = f"{data_folder}/{subject_dir}/acquisition.json" - - #-------------------------------------------------------------# + input_data = glob.glob(f"../data/{subject_dir}*_stitched_*/image_tile_fusing/OMEZarr/") + if input_data is None: + raise ValueError("Please attach the stitched data asset for registration!") + + input_data = input_data[0] + + data_folder = os.path.abspath(f"../data/{subject_dir}/") + processing_manifest_path = f"{data_folder}/derivatives/processing_manifest.json" + acquisition_path = f"{data_folder}/acquisition.json" - template_path = os.path.abspath("../data/smartspim_lca_template/smartspim_lca_template_25.nii.gz") - ccf_reference_path = os.path.abspath("../data/allen_mouse_ccf/average_template/average_template_25.nii.gz") - template_to_ccf_transform_path = [ - os.path.abspath("../data/spim_template_to_ccf/syn_1Warp.nii.gz"), - os.path.abspath("../data/spim_template_to_ccf/syn_0GenericAffine.mat")] - - print(f"template_to_ccf_transform_path: {template_to_ccf_transform_path}") - ccf_annotation_to_template_moved_path = os.path.abspath("../data/ccf_annotation_to_template_moved.nii.gz") - - #-------------------------------------------------------------# - if not os.path.exists(processing_manifest_path): raise ValueError("Processing manifest path does not exist!") + if not os.path.exists(acquisition_path): + raise ValueError("Acquisition path does not exist!") + pipeline_config = read_json_as_dict(processing_manifest_path) pipeline_config = pipeline_config.get("pipeline_processing") if pipeline_config is None: raise ValueError("Please, provide a valid processing manifest") - - """ - # Setting parameters based on pipeline - sorted_channels = natsorted(pipeline_config["registration"]["channels"]) - - # Getting highest wavelenght as default for registration - channel_to_register = sorted_channels[-1] - """ - - all_zarr = glob.glob(f'{data_folder}/{subject_dir}/image_tile_fusing/OMEZarr/*.zarr') - all_zarr = sorted(all_zarr) - all_zarr = [ zarr.split("/")[-1].replace(".zarr", "") for zarr in all_zarr] - channel_to_register = all_zarr[-1] - # lower_channels = all_zarr[:-1] - - #-------------------------------------------------------------# - - if not os.path.exists(acquisition_path): - raise ValueError("Acquisition path does not exist!") acquisition_json = read_json_as_dict(acquisition_path) acquisition_orientation = acquisition_json.get("axes") - print(f"acquisition_orientation: {acquisition_orientation}") if acquisition_orientation is None: raise ValueError( f"Please, provide a valid acquisition orientation, acquisition: {acquisition_json}" ) - #-------------------------------------------------------------# - - dataset_id = subject_dir.split("_")[1] - results_folder = f"../results/{dataset_id}_to_ccf_{channel_to_register}" + # Setting parameters based on pipeline + sorted_channels = natsorted(pipeline_config["registration"]["channels"]) + + # Getting highest wavelenght as default for registration + channel_to_register = sorted_channels[-1] + + subject_id = subject_dir.split("_")[1] + results_folder = f"../results/{subject_id}_ccf_{channel_to_register}" create_folder(results_folder) - + + metadata_folder = os.path.abspath(f"{results_folder}/metadata") + logger = create_logger(output_log_path=results_folder) - logger.info(f"channel_to_register: {channel_to_register}") + logger.info( f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" ) + logger.info(f"channel_to_register: {channel_to_register}") + reg_folder = os.path.abspath(f"{results_folder}/registration") metadata_folder = os.path.abspath(f"{results_folder}/metadata") @@ -226,10 +196,21 @@ def main() -> None: profile_process.start() logger.info(f"{'='*40} SmartSPIM CCF Registration {'='*40}") - + + #---------------------------------------------------# + # path to SPIM template, CCF and template-to-CCF registration + template_path = os.path.abspath("../data/lightsheet_template_ccf_registration/smartspim_lca_template_25.nii.gz") + ccf_reference_path = os.path.abspath("../data/lightsheet_template_ccf_registration/ccf_average_template_25.nii.gz") + template_to_ccf_transform_path = [ + os.path.abspath("../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_1Warp.nii.gz"), + os.path.abspath("../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat")] + print(f"template_to_ccf_transform_path: {template_to_ccf_transform_path}") + ccf_annotation_to_template_moved_path = os.path.abspath("../data/lightsheet_template_ccf_registration/ccf_annotation_to_template_moved.nii.gz") + + #---------------------------------------------------# example_input = { # "input_data": "../data/fused", # TODO - "input_data": f"../data/{subject_dir}/image_tile_fusing/OMEZarr/", + "input_data": input_data, "input_channel": channel_to_register, "input_scale": pipeline_config["registration"]["input_scale"], "input_orientation": acquisition_orientation, diff --git a/code/main_register_dataset.py b/code/main_register_dataset.py new file mode 100644 index 0000000..fe19f6b --- /dev/null +++ b/code/main_register_dataset.py @@ -0,0 +1,283 @@ +""" +Main used in code ocean to execute capsule +""" + +import json +import logging +import multiprocessing +import os +import subprocess +from datetime import datetime +import glob + +from aind_ccf_reg import register, utils +from natsort import natsorted +from aind_ccf_reg.configs import PathLike +from aind_ccf_reg.utils import create_folder + + +def create_logger(output_log_path: PathLike) -> logging.Logger: + """ + Creates a logger that generates output logs to a specific path. + + Parameters + ------------ + output_log_path: PathLike + Path where the log is going to be stored + + Returns + ----------- + logging.Logger + Created logger + pointing to the file path. + """ + CURR_DATE_TIME = datetime.now().strftime("%Y-%m-%d-%H-%M-%S") + + LOGS_FILE = f"{output_log_path}/register_process.log" + + logging.basicConfig( + level=logging.DEBUG, + format="%(asctime)s - %(levelname)s : %(message)s", + datefmt="%Y-%m-%d %H:%M", + handlers=[ + logging.StreamHandler(), + logging.FileHandler(LOGS_FILE, "a"), + ], + force=True, + ) + +# logging.disable("DEBUG") + logging.disable(logging.DEBUG) + logger = logging.getLogger(__name__) + logger.setLevel(logging.DEBUG) + logger.info(f"Execution datetime: {CURR_DATE_TIME}") + + return logger + +def read_json_as_dict(filepath: str) -> dict: + """ + Reads a json as dictionary. + + Parameters + ------------------------ + + filepath: PathLike + Path where the json is located. + + Returns + ------------------------ + + dict: + Dictionary with the data the json has. + + """ + + dictionary = {} + + if os.path.exists(filepath): + with open(filepath) as json_file: + dictionary = json.load(json_file) + + return dictionary + +def execute_command_helper(command: str, print_command: bool = False) -> None: + """ + Execute a shell command. + + Parameters + ------------------------ + command: str + Command that we want to execute. + print_command: bool + Bool that dictates if we print the command in the console. + + Raises + ------------------------ + CalledProcessError: + if the command could not be executed (Returned non-zero status). + + """ + + if print_command: + print(command) + + popen = subprocess.Popen( + command, stdout=subprocess.PIPE, universal_newlines=True, shell=True + ) + for stdout_line in iter(popen.stdout.readline, ""): + yield str(stdout_line).strip() + popen.stdout.close() + return_code = popen.wait() + if return_code: + raise subprocess.CalledProcessError(return_code, command) + + +def main() -> None: + """ + Main function to register a dataset + """ + subject_dir = "SmartSPIM_714635_2024-03-18_10-47-48" + subject_dir = "SmartSPIM_725271_2024-05-22_17-24-06" + subject_dir = "SmartSPIM_725379_2024-04-25_17-02-42" + + input_data = glob.glob(f"../data/{subject_dir}*_stitched_*/image_tile_fusing/OMEZarr/") + if input_data is None: + raise ValueError("Please attach the stitched data asset for registration!") + + input_data = input_data[0] + + data_folder = os.path.abspath(f"../data/{subject_dir}/") + processing_manifest_path = f"{data_folder}/derivatives/processing_manifest.json" + acquisition_path = f"{data_folder}/acquisition.json" + + if not os.path.exists(processing_manifest_path): + raise ValueError("Processing manifest path does not exist!") + + if not os.path.exists(acquisition_path): + raise ValueError("Acquisition path does not exist!") + + pipeline_config = read_json_as_dict(processing_manifest_path) + pipeline_config = pipeline_config.get("pipeline_processing") + + if pipeline_config is None: + raise ValueError("Please, provide a valid processing manifest") + + acquisition_json = read_json_as_dict(acquisition_path) + acquisition_orientation = acquisition_json.get("axes") + + if acquisition_orientation is None: + raise ValueError( + f"Please, provide a valid acquisition orientation, acquisition: {acquisition_json}" + ) + + # Setting parameters based on pipeline + sorted_channels = natsorted(pipeline_config["registration"]["channels"]) + + # Getting highest wavelenght as default for registration + channel_to_register = sorted_channels[-1] + + subject_id = subject_dir.split("_")[1] + results_folder = f"../results/{subject_id}_ccf_{channel_to_register}" + create_folder(results_folder) + + metadata_folder = os.path.abspath(f"{results_folder}/metadata") + + logger = create_logger(output_log_path=results_folder) + + logger.info( + f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" + ) + + logger.info(f"channel_to_register: {channel_to_register}") + + reg_folder = os.path.abspath(f"{results_folder}/registration") + metadata_folder = os.path.abspath(f"{results_folder}/metadata") + + utils.print_system_information(logger) + + # Tracking compute resources + # Subprocess to track used resources + manager = multiprocessing.Manager() + time_points = manager.list() + cpu_percentages = manager.list() + memory_usages = manager.list() + + profile_process = multiprocessing.Process( + target=utils.profile_resources, + args=( + time_points, + cpu_percentages, + memory_usages, + 20, + ), + ) + profile_process.daemon = True + profile_process.start() + + logger.info(f"{'='*40} SmartSPIM CCF Registration {'='*40}") + + #---------------------------------------------------# + # path to SPIM template, CCF and template-to-CCF registration + template_path = os.path.abspath("../data/lightsheet_template_ccf_registration/smartspim_lca_template_25.nii.gz") + ccf_reference_path = os.path.abspath("../data/lightsheet_template_ccf_registration/ccf_average_template_25.nii.gz") + template_to_ccf_transform_path = [ + os.path.abspath("../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_1Warp.nii.gz"), + os.path.abspath("../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat")] + print(f"template_to_ccf_transform_path: {template_to_ccf_transform_path}") + ccf_annotation_to_template_moved_path = os.path.abspath("../data/lightsheet_template_ccf_registration/ccf_annotation_to_template_moved.nii.gz") + + #---------------------------------------------------# + example_input = { +# "input_data": "../data/fused", # TODO + "input_data": input_data, + "input_channel": channel_to_register, + "input_scale": pipeline_config["registration"]["input_scale"], + "input_orientation": acquisition_orientation, + "bucket_path": "aind-open-data", + "template_path": template_path, # SPIM template + "ccf_reference_path": ccf_reference_path, + "template_to_ccf_transform_path": template_to_ccf_transform_path, + "ccf_annotation_to_template_moved_path": ccf_annotation_to_template_moved_path, + "reference_res": 25, + "output_data": os.path.abspath(f"{results_folder}/OMEZarr"), + "metadata_folder": metadata_folder, + "code_url": "https://github.com/AllenNeuralDynamics/aind-ccf-registration", + "reg_folder": reg_folder, + "prep_params": { + "rawdata_figpath": f"{reg_folder}/prep_zarr_img.jpg", + "rawdata_path": f"{reg_folder}/prep_zarr_img.nii.gz", + "resample_figpath": f"{reg_folder}/prep_resampled_zarr_img.jpg", + "resample_path": f"{reg_folder}/prep_resampled_zarr_img.nii.gz", + "mask_figpath": f"{reg_folder}/prep_mask.jpg", + "mask_path": f"{reg_folder}/prep_mask.nii.gz", + "n4bias_figpath": f"{reg_folder}/prep_n4bias.jpg", + "n4bias_path": f"{reg_folder}/prep_n4bias.nii.gz", + "img_diff_n4bias_figpath": f"{reg_folder}/prep_img_diff_n4bias.jpg", + "img_diff_n4bias_path": f"{reg_folder}/prep_img_diff_n4bias.nii.gz", + "percNorm_figpath": f"{reg_folder}/prep_percNorm.jpg", + "percNorm_path": f"{reg_folder}/prep_percNorm.nii.gz", + }, + "ants_params": { + "spacing": (0.0144, 0.0144, 0.016), + "unit": "millimetre", + # "ccf_orientations": { + # "anterior_to_posterior": 0, + # "superior_to_inferior": 1, + # "left_to_right": 2, + # }, + "template_orientations": { + "anterior_to_posterior": 1, + "superior_to_inferior": 2, + "right_to_left": 0, + }, + "rigid_path": f"{reg_folder}/moved_rigid.nii.gz", + "moved_to_template_path": f"{reg_folder}/moved_ls_to_template.nii.gz", + "moved_to_ccf_path": f"{reg_folder}/moved_ls_to_ccf.nii.gz", + "ccf_anno_to_brain_path": f"{reg_folder}/moved_ccf_anno_to_ls.nii.gz", + }, + "OMEZarr_params": { + "clevel": 1, + "compressor": "zstd", + "chunks": (64, 64, 64), + }, + } + + logger.info(f"Input parameters in CCF run: {example_input}") + # flake8: noqa: F841 + image_path = register.main(example_input) + + # Getting tracked resources and plotting image + utils.stop_child_process(profile_process) + + if len(time_points): + utils.generate_resources_graphs( + time_points, + cpu_percentages, + memory_usages, + metadata_folder, + "smartspim_ccf_registration", + ) + + +if __name__ == "__main__": + main() diff --git a/code/template_based_ccf_registration.md b/code/template_based_ccf_registration.md new file mode 100644 index 0000000..3ada8a2 --- /dev/null +++ b/code/template_based_ccf_registration.md @@ -0,0 +1,61 @@ +# Template-based smartspim-ccf registration + +This capsule is used to register SmartSPIM datasets to CCF Allen Atlas via SPIM template at 25 um. +`main.py` is compatible with the `aind-smartspim-pipeline`. +`main_register_dataset.py` is used to regsiter a stitched testing dataset. +It assumes that the fused image comes in OME-Zarr format with different multiscales. +At this point, we are using the 3rd multiscale from the original resolution for registration. + +Workflow of template-based smartSPIM CCF registration: +1. preprocessing + - resample the raw image to isotropic to have the same resolution as the SPIM template. + - masking, using Li thresholding to segment ROI + - N4 bias correction + - intensity normalization, using 2nd and 98th percentile normalization +2. register the resulting preprocessed image from step 1 to the SPIM template using ANTs (rigid + SyN). By default, the highest channel will be used for registration. +3. register the resulting moved image from step 2 to the CCF Allen Atlas using the template-to-CCF transforms computed by Yoni. + +## Usage +Please attach the data asset (both stitched and unstitched data you would like to run registration, i.e., `SmartSPIM_714635_2024-03-18_10-47-48` and `SmartSPIM_714635_2024-03-18_10-47-48_stitched_2024-03-28_04-43-39`) and update `subject_dir` line 121 in main.py, i.e., `subject_dir="SmartSPIM_714635_2024-03-18_10-47-48"`, then run +``` +conda activate ccf_reg +python main_register_dataset.py +``` + +## Output directory structure of registration +After running main.py given one testing dataset, a directory will be created with the following structure +```console + /path/to/outputs/registration/ + ├── prep_*.nii.gz + ├── prep_*.png + ├── moved_rigid.nii.gz + ├── moved_ls_to_template.nii.gz + ├── moved_ls_to_ccf.nii.gz + ├── moved_ccf_anno_to_ls.nii.gz + ├── moved_*.png + ├── reg_*.png + └── ls_to_template_SyN* +``` +1. `prep_*.nii.gz`: the intermediate images in preprocessing steps, `prep_*.png` are the corresponding plots. +2. `moved_rigid.nii.gz`: the preprocessed brain image was aligned to the SPIM template using rigid registration. +3. `moved_ls_to_template.nii.gz`: the resulting image 2 was aligned to the SPIM template using SyN registration. +4. `moved_ls_to_ccf.nii.gz`: the resulting image 3 was aligned to the CCF using the template-to-CCF transforms computed by Yoni. +5. `moved_ccf_anno_to_ls.nii.gz`: the CCF annotation was aligned to the sample space. +6. `moved_*.png`: visualize the deformed images 2, 3, 4, 5. +7. `reg_*.png`: visualize the registration results for 2, 3, 4. +8. `ls_to_template_SyN*`: the transforms that align the preprocessed brain image to the SPIM template. + +By default, the output file is for the channel-to-register (highest channel) if the file name does not contain the channel info. + + +## Running time + +From Camilo's NFS 2024 abstract: +```console +A typical dataset between 1 and 2 terabytes with 3 channels, 3.3 hours destriping and flat field, 0.2 hours transforms for stitching, 1.7 hours fusion to OMEZarr, 0.1 hours for registration to the 25 um template, 5-8 hours hours for cell detection and 0.2 hours for quantification. Total 10.5 hours without considering waiting times of the cluster and very labeled-dense datasets. Acquisition is about 3 hours per channel and data transfer from the microscope to the VAST and VAST to cloud about 20 mins. +10.5 + 3*(3) + ACQ_TO_VAST + 0.3 = 19.8 +``` +Di update on template-based smartSPIM-CCF registration: +```console +About 3 mins for preprocessing, 7 mins for registering to SPIM template, 9 seconds for registering to CCF. Total time: ~11 mins +``` \ No newline at end of file From 29cc68c0ba790fd15741c974074fc7059f4dcf73 Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Thu, 30 May 2024 22:31:35 +0000 Subject: [PATCH 09/15] update main.py --- code/aind_ccf_reg/register.py | 4 +-- code/main.py | 52 +++++++++++++---------------------- 2 files changed, 20 insertions(+), 36 deletions(-) diff --git a/code/aind_ccf_reg/register.py b/code/aind_ccf_reg/register.py index 44810a0..bc1f7f4 100644 --- a/code/aind_ccf_reg/register.py +++ b/code/aind_ccf_reg/register.py @@ -9,8 +9,6 @@ Quality control on registration: (1) visualization: plot the overlay/difference image between deformed and fixed images (2) TODO: compute the similarity metics to automatically detect registration failure - -# TODO: need to pass transforms that aligns brain image to CCF to aind-smartspim-cell-quantification capsule """ import logging import multiprocessing @@ -254,7 +252,7 @@ def register_to_template(self, ants_fixed, ants_moving): "mask_all_stages": True, "grad_step": 0.25, "reg_iterations": (60, 40, 20, 0), - "aff_metric": "mattes" + "aff_metric": "mattes" } logger.info(f"Computing rigid registration with parameters: {registration_params}") diff --git a/code/main.py b/code/main.py index 356a6dd..5ba5f5b 100644 --- a/code/main.py +++ b/code/main.py @@ -54,6 +54,7 @@ def create_logger(output_log_path: PathLike) -> logging.Logger: return logger + def read_json_as_dict(filepath: str) -> dict: """ Reads a json as dictionary. @@ -116,33 +117,22 @@ def main() -> None: """ Main function to register a dataset """ - - subject_dir = "SmartSPIM_714635_2024-03-18_10-47-48" - subject_dir = "SmartSPIM_725271_2024-05-22_17-24-06" - subject_dir = "SmartSPIM_725379_2024-04-25_17-02-42" - - input_data = glob.glob(f"../data/{subject_dir}*_stitched_*/image_tile_fusing/OMEZarr/") - if input_data is None: - raise ValueError("Please attach the stitched data asset for registration!") - - input_data = input_data[0] - - data_folder = os.path.abspath(f"../data/{subject_dir}/") - processing_manifest_path = f"{data_folder}/derivatives/processing_manifest.json" + data_folder = os.path.abspath("../data/") + processing_manifest_path = f"{data_folder}/processing_manifest.json" acquisition_path = f"{data_folder}/acquisition.json" if not os.path.exists(processing_manifest_path): raise ValueError("Processing manifest path does not exist!") - + if not os.path.exists(acquisition_path): raise ValueError("Acquisition path does not exist!") pipeline_config = read_json_as_dict(processing_manifest_path) pipeline_config = pipeline_config.get("pipeline_processing") - + if pipeline_config is None: raise ValueError("Please, provide a valid processing manifest") - + acquisition_json = read_json_as_dict(acquisition_path) acquisition_orientation = acquisition_json.get("axes") @@ -157,20 +147,15 @@ def main() -> None: # Getting highest wavelenght as default for registration channel_to_register = sorted_channels[-1] - subject_id = subject_dir.split("_")[1] - results_folder = f"../results/{subject_id}_ccf_{channel_to_register}" + results_folder = f"../results/ccf_{channel_to_register}" create_folder(results_folder) - - metadata_folder = os.path.abspath(f"{results_folder}/metadata") - + logger = create_logger(output_log_path=results_folder) - logger.info( f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" ) - logger.info(f"channel_to_register: {channel_to_register}") - + reg_folder = os.path.abspath(f"{results_folder}/registration") metadata_folder = os.path.abspath(f"{results_folder}/metadata") @@ -196,8 +181,9 @@ def main() -> None: profile_process.start() logger.info(f"{'='*40} SmartSPIM CCF Registration {'='*40}") - - #---------------------------------------------------# + + #-------------------------------------------------------------# + # path to SPIM template, CCF and template-to-CCF registration template_path = os.path.abspath("../data/lightsheet_template_ccf_registration/smartspim_lca_template_25.nii.gz") ccf_reference_path = os.path.abspath("../data/lightsheet_template_ccf_registration/ccf_average_template_25.nii.gz") @@ -206,11 +192,11 @@ def main() -> None: os.path.abspath("../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat")] print(f"template_to_ccf_transform_path: {template_to_ccf_transform_path}") ccf_annotation_to_template_moved_path = os.path.abspath("../data/lightsheet_template_ccf_registration/ccf_annotation_to_template_moved.nii.gz") + + #-------------------------------------------------------------# - #---------------------------------------------------# example_input = { -# "input_data": "../data/fused", # TODO - "input_data": input_data, + "input_data": "../data/fused", "input_channel": channel_to_register, "input_scale": pipeline_config["registration"]["input_scale"], "input_orientation": acquisition_orientation, @@ -228,13 +214,13 @@ def main() -> None: "rawdata_figpath": f"{reg_folder}/prep_zarr_img.jpg", "rawdata_path": f"{reg_folder}/prep_zarr_img.nii.gz", "resample_figpath": f"{reg_folder}/prep_resampled_zarr_img.jpg", - "resample_path": f"{reg_folder}/prep_resampled_zarr_img.nii.gz", + # "resample_path": f"{reg_folder}/prep_resampled_zarr_img.nii.gz", "mask_figpath": f"{reg_folder}/prep_mask.jpg", - "mask_path": f"{reg_folder}/prep_mask.nii.gz", + # "mask_path": f"{reg_folder}/prep_mask.nii.gz", "n4bias_figpath": f"{reg_folder}/prep_n4bias.jpg", - "n4bias_path": f"{reg_folder}/prep_n4bias.nii.gz", + # "n4bias_path": f"{reg_folder}/prep_n4bias.nii.gz", "img_diff_n4bias_figpath": f"{reg_folder}/prep_img_diff_n4bias.jpg", - "img_diff_n4bias_path": f"{reg_folder}/prep_img_diff_n4bias.nii.gz", + # "img_diff_n4bias_path": f"{reg_folder}/prep_img_diff_n4bias.nii.gz", "percNorm_figpath": f"{reg_folder}/prep_percNorm.jpg", "percNorm_path": f"{reg_folder}/prep_percNorm.nii.gz", }, From 808c46269aa4f8b92678700492b185be64a36065 Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Sat, 1 Jun 2024 03:35:14 +0000 Subject: [PATCH 10/15] update codes to follow aind-python standards --- code/aind_ccf_reg/__init__.py | 1 + code/aind_ccf_reg/configs.py | 86 +++----- code/aind_ccf_reg/plots.py | 184 +++++----------- code/aind_ccf_reg/preprocess.py | 265 +++++++++++++---------- code/aind_ccf_reg/register.py | 367 ++++++++++++++++++-------------- code/aind_ccf_reg/utils.py | 8 +- code/main.py | 65 +++--- code/main_register_dataset.py | 78 ++++--- code/register_datasets.py | 1 + 9 files changed, 548 insertions(+), 507 deletions(-) diff --git a/code/aind_ccf_reg/__init__.py b/code/aind_ccf_reg/__init__.py index a6494be..c213b5f 100644 --- a/code/aind_ccf_reg/__init__.py +++ b/code/aind_ccf_reg/__init__.py @@ -1,3 +1,4 @@ """CCF Registration package. """ + __version__ = "0.0.18" diff --git a/code/aind_ccf_reg/configs.py b/code/aind_ccf_reg/configs.py index 151318d..85e334b 100644 --- a/code/aind_ccf_reg/configs.py +++ b/code/aind_ccf_reg/configs.py @@ -1,17 +1,18 @@ """ -This config file points to data directories, defines global variables, specify schema format for -Preprocess and Registration. +This config file points to data directories, defines global variables, +specify schema format for Preprocess and Registration. """ from pathlib import Path -from typing import Dict, Hashable, List, Sequence, Tuple, Union +from typing import Union + import dask import numpy as np from argschema import ArgSchema from argschema.fields import Dict as sch_dict from argschema.fields import Int from argschema.fields import List as sch_list -from argschema.fields import Str +from argschema.fields import Str PathLike = Union[str, Path] ArrayLike = Union[dask.array.core.Array, np.ndarray] @@ -19,6 +20,7 @@ VMIN = 0 VMAX = 1.5 + class RegSchema(ArgSchema): """ Schema format for Preprocess and Registration. @@ -46,34 +48,48 @@ class RegSchema(ArgSchema): "description": "Brain orientation during aquisition", }, ) - + template_path = Str( metadata={"required": True, "description": "Path to the SPIM template"} - ) - + ) + ccf_reference_path = Str( metadata={"required": True, "description": "Path to the CCF template"} ) - - template_to_ccf_transform_path = sch_list( + + template_to_ccf_transform_path = sch_list( cls_or_instance=Str, metadata={ - "required": True, - "description": "Path to the transform that aligns SPIM template to CCF"} + "required": True, + "description": "Path to the template-to-ccf transform", + }, ) - + ccf_annotation_to_template_moved_path = Str( - metadata={"required": True, "description": "Path to the deformed CCF annotation in SPIM template space"} + metadata={ + "required": True, + "description": "Path to CCF annotation in SPIM template space", + } ) - + output_data = Str( metadata={"required": True, "description": "Output file"} ) - + + results_folder = Str( + metadata={ + "required": True, + "description": "Folder to save registration results", + } + ) + reg_folder = Str( - metadata={"required": True, "description": "Folder to save registration results"} + metadata={ + "required": True, + "description": "Folder to save derivative results of registration", + } ) - + bucket_path = Str( required=True, metadata={"description": "Amazon Bucket or Google Bucket name"}, @@ -93,14 +109,14 @@ class RegSchema(ArgSchema): "description": "OMEZarr writing parameters", } ) - + prep_params = sch_dict( metadata={ "required": True, "description": "raw data preprocessing parameters", } ) - + ants_params = sch_dict( metadata={ "required": True, @@ -114,35 +130,3 @@ class RegSchema(ArgSchema): "description": "Voxel Resolution of reference in microns", } ) - - #-------------- DO we need to pass transforms to next capsule ?# - # downsampled_file = Str( - # metadata={"required": True, "description": "Downsampled file"} - # ) - - # downsampled16bit_file = Str( - # metadata={"required": True, "description": "Downsampled 16bit file"} - # ) - - # affine_transforms_file = Str( - # metadata={ - # "required": True, - # "description": "Output forward affine Transforms file", - # } - # ) - - # ls_ccf_warp_transforms_file = Str( - # metadata={ - # "required": True, - # "description": "Output inverse warp Transforms file", - # } - # ) - - # ccf_ls_warp_transforms_file = Str( - # metadata={ - # "required": True, - # "description": "Output forward warp Transforms file", - # } - # ) - #-------------- TODO end-----------------------# - diff --git a/code/aind_ccf_reg/plots.py b/code/aind_ccf_reg/plots.py index 94f8a15..65956f0 100644 --- a/code/aind_ccf_reg/plots.py +++ b/code/aind_ccf_reg/plots.py @@ -1,9 +1,12 @@ """ -Plot functions for easy and fast visualiztaion of images and regsitration results +Plot functions for easy and fast visualiztaion of images and +regsitration results """ + import matplotlib.pyplot as plt -import numpy as np - +import numpy as np + + def plot_antsimgs(ants_img, figpath, title="", vmin=0, vmax=500): """ Plot ANTs image @@ -20,21 +23,39 @@ def plot_antsimgs(ants_img, figpath, title="", vmin=0, vmax=500): vmax: float Set the color limits of the current image. """ - + if figpath: ants_img = ants_img.numpy() half_size = np.array(ants_img.shape) // 2 fig, ax = plt.subplots(1, 3, figsize=(10, 6)) - ax[0].imshow(ants_img[half_size[0], :, :], cmap='gray', vmin=vmin, vmax=vmax) - ax[1].imshow(ants_img[:, half_size[1], :], cmap='gray', vmin=vmin, vmax=vmax) - im = ax[2].imshow(ants_img[:,:, half_size[2],], cmap='gray', vmin=vmin, vmax=vmax) + ax[0].imshow( + ants_img[half_size[0], :, :], cmap="gray", vmin=vmin, vmax=vmax + ) + ax[1].imshow( + ants_img[:, half_size[1], :], cmap="gray", vmin=vmin, vmax=vmax + ) + im = ax[2].imshow( + ants_img[ + :, + :, + half_size[2], + ], + cmap="gray", + vmin=vmin, + vmax=vmax, + ) fig.suptitle(title, y=0.9) - plt.colorbar(im, ax=ax.ravel().tolist(), fraction=0.1, pad=0.025, shrink=0.7) - plt.savefig(figpath, bbox_inches = 'tight', pad_inches = 0.1) + plt.colorbar( + im, ax=ax.ravel().tolist(), fraction=0.1, pad=0.025, shrink=0.7 + ) + plt.savefig(figpath, bbox_inches="tight", pad_inches=0.1) -def plot_reg(moving, fixed, warped, figpath, title="", loc=0, vmin=0, vmax=1.5): + +def plot_reg( + moving, fixed, warped, figpath, title="", loc=0, vmin=0, vmax=1.5 +): """ - Plot registration results: moving, fixed, deformed, + Plot registration results: moving, fixed, deformed, overlay and difference images after registration Parameters @@ -54,149 +75,60 @@ def plot_reg(moving, fixed, warped, figpath, title="", loc=0, vmin=0, vmax=1.5): vmin, vmax: float Set the color limits of the current image. """ - + if loc >= len(moving.shape): raise ValueError( - f"loc {loc} is not allowed, should be less than are {len(moving.shape)}" - ) - + f"loc {loc} is not allowed, should less than {len(moving.shape)}" + ) + half_size_moving = np.array(moving.shape) // 2 half_size_fixed = np.array(fixed.shape) // 2 half_size_warped = np.array(warped.shape) // 2 - if loc == 0: + if loc == 0: moving = moving.view()[half_size_moving[0], :, :] - fixed = fixed.view()[half_size_fixed[0], :, :] + fixed = fixed.view()[half_size_fixed[0], :, :] warped = warped.view()[half_size_warped[0], :, :] y = 0.75 - elif loc == 1: + elif loc == 1: # moving = np.rot90(moving.view()[:,half_size[1], :], 3) - moving = moving.view()[:,half_size_moving[1], :] - fixed = fixed.view()[:,half_size_fixed[1], :] - warped = warped.view()[:,half_size_warped[1], :] + moving = moving.view()[:, half_size_moving[1], :] + fixed = fixed.view()[:, half_size_fixed[1], :] + warped = warped.view()[:, half_size_warped[1], :] y = 0.82 - elif loc == 2: + elif loc == 2: moving = np.rot90(np.fliplr(moving.view()[:, :, half_size_moving[2]])) - fixed = np.rot90(np.fliplr(fixed.view()[:, :, half_size_fixed[2]])) + fixed = np.rot90(np.fliplr(fixed.view()[:, :, half_size_fixed[2]])) warped = np.rot90(np.fliplr(warped.view()[:, :, half_size_warped[2]])) y = 0.82 else: raise ValueError( - f"loc {loc} is not allowed. Allowed values are: 0, 1, 2") - + f"loc {loc} is not allowed. Allowed values are: 0, 1, 2" + ) + # combine deformed and fixed images to an RGB image - overlay = np.stack( (warped, fixed, warped), axis=2 ) + overlay = np.stack((warped, fixed, warped), axis=2) diff = fixed - warped - + fontsize = 14 - + fig, ax = plt.subplots(1, 5, figsize=(16, 6)) - ax[0].imshow(moving, cmap='gray', vmin=vmin, vmax=vmax) - ax[1].imshow(fixed, cmap='gray', vmin=vmin, vmax=vmax) - ax[2].imshow(warped, cmap='gray', vmin=vmin, vmax=vmax) + ax[0].imshow(moving, cmap="gray", vmin=vmin, vmax=vmax) + ax[1].imshow(fixed, cmap="gray", vmin=vmin, vmax=vmax) + ax[2].imshow(warped, cmap="gray", vmin=vmin, vmax=vmax) ax[3].imshow(overlay) - ax[4].imshow(diff, cmap='gray', vmin=-(vmax), vmax=vmax) + ax[4].imshow(diff, cmap="gray", vmin=-(vmax), vmax=vmax) ax[0].set_title("Moving", fontsize=fontsize) ax[1].set_title("Fixed", fontsize=fontsize) ax[2].set_title("Deformed", fontsize=fontsize) ax[3].set_title("Deformed Overlay Fixed", fontsize=fontsize) ax[4].set_title("Fixed - Deformed", fontsize=fontsize) - - fig.suptitle(title, size = 18, y=y) - - if figpath: - plt.savefig(figpath, bbox_inches = 'tight', pad_inches = 0.01) - plt.close() - else: - fig.show() - - -def plot_reg_before_after(moving, fixed, warped, figpath, title="", loc=0, vmin=0, vmax=1.5): - """ - if moving and fixed images have same dimension, - plot registration results: moving, fixed, deformed, - overlay and difference images before and after registration - - Parameters - ------------ - moving: ANTsImage - Moving image - fixed: ANTsImage - Fixed image - warped: ANTsImage - Deformed image - figpath: PathLike - Path where the plot is going to be saved - title: str - Figure title - loc: int - Visualization direction - vmin, vmax: float - Set the color limits of the current image. - """ - - if loc >= len(moving.shape): - raise ValueError( - f"loc {loc} is not allowed, should be less than are {len(moving.shape)}" - ) - - half_size_moving = np.array(moving.shape) // 2 - half_size_fixed = np.array(fixed.shape) // 2 - half_size_warped = np.array(warped.shape) // 2 - if loc == 0: - moving = moving.view()[half_size_moving[0], :, :] - fixed = fixed.view()[half_size_fixed[0], :, :] - warped = warped.view()[half_size_warped[0], :, :] - y = 0.85 - elif loc == 1: - # moving = np.rot90(moving.view()[:,half_size[1], :], 3) - moving = moving.view()[:,half_size_moving[1], :] - fixed = fixed.view()[:,half_size_fixed[1], :] - warped = warped.view()[:,half_size_warped[1], :] - y = 0.85 - elif loc == 2: - moving = np.rot90(np.fliplr(moving.view()[:, :, half_size_moving[2]])) - fixed = np.rot90(np.fliplr(fixed.view()[:, :, half_size_fixed[2]])) - warped = np.rot90(np.fliplr(warped.view()[:, :, half_size_warped[2]])) - y = 0.85 - else: - raise ValueError( - f"loc {loc} is not allowed. Allowed values are: 0, 1, 2") - - # combine deformed and fixed images to an RGB image - # green: fixed image, magenta: moving/moved image - overlay0 = np.stack( (moving, fixed, moving), axis=2 ) # before registration - overlay1 = np.stack( (warped, fixed, warped), axis=2 ) # after registration - - diff0 = fixed - moving - diff1 = fixed - warped - - fontsize = 14 - - fig, ax = plt.subplots(1, 7, figsize=(20, 6)) - ax[0].imshow(moving, cmap='gray', vmin=vmin, vmax=vmax) - ax[1].imshow(fixed, cmap='gray', vmin=vmin, vmax=vmax) - ax[2].imshow(warped, cmap='gray', vmin=vmin, vmax=vmax) - ax[3].imshow(overlay0) - ax[4].imshow(diff0, cmap='gray', vmin=-(vmax), vmax=vmax) - ax[5].imshow(overlay1) - ax[6].imshow(diff1, cmap='gray', vmin=-(vmax), vmax=vmax) + fig.suptitle(title, size=18, y=y) - ax[0].set_title("Moving", fontsize=fontsize) - ax[1].set_title("Fixed", fontsize=fontsize) - ax[2].set_title("Deformed", fontsize=fontsize) - ax[3].set_title("Before registration\nDeformed Overlay Fixed", fontsize=fontsize-2) - ax[4].set_title("Before registration\nFixed - Deformed", fontsize=fontsize-2) - ax[5].set_title("After registration\nDeformed Overlay Fixed", fontsize=fontsize-2) - ax[6].set_title("After registration\nFixed - Deformed", fontsize=fontsize-2) - - fig.suptitle(title, size = 18, y=y) - if figpath: - plt.savefig(figpath, bbox_inches = 'tight', pad_inches = 0.01) - # plt.close() + plt.savefig(figpath, bbox_inches="tight", pad_inches=0.01) + plt.close() else: - fig.show() - \ No newline at end of file + fig.show() diff --git a/code/aind_ccf_reg/preprocess.py b/code/aind_ccf_reg/preprocess.py index 129ea89..edcaa61 100644 --- a/code/aind_ccf_reg/preprocess.py +++ b/code/aind_ccf_reg/preprocess.py @@ -1,26 +1,17 @@ """ Preprocess lightsheet data """ + import logging from datetime import datetime import ants -import matplotlib.pyplot as plt import numpy as np -import scipy -from aind_ccf_reg.plots import plot_antsimgs - import scipy.ndimage as ni +from aind_ccf_reg.configs import VMAX, VMIN +from aind_ccf_reg.plots import plot_antsimgs from skimage.filters import threshold_li -from skimage.measure import label -from skimage import io -import tifffile - -from pathlib import Path - -from aind_ccf_reg.configs import VMIN, VMAX -from aind_ccf_reg.configs import PathLike - +from skimage.measure import label LOG_FMT = "%(asctime)s %(message)s" LOG_DATE_FMT = "%Y-%m-%d %H:%M" @@ -29,75 +20,95 @@ logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) -def perc_normalization(ants_img): + +def perc_normalization( + ants_img, lower_perc: float = 2, upper_perc: float = 98 +): """ - Percentile Normalization - + Percentile Normalization + Parameters ------------- ants_img: ANTsImage - + Returns ----------- ANTsImage """ - percentiles = [2, 98] + percentiles = [lower_perc, upper_perc] percentile_values = np.percentile(ants_img.view(), percentiles) - ants_img = (ants_img - percentile_values[0]) / (percentile_values[1] - percentile_values[0]) + ants_img = (ants_img - percentile_values[0]) / ( + percentile_values[1] - percentile_values[0] + ) return ants_img -def write_and_plot_image(ants_img, data_path=None, plot_path=None, vmin=VMIN, vmax=VMAX): - """ - Write and plot ants image + +def write_and_plot_image( + ants_img, data_path=None, plot_path=None, vmin=VMIN, vmax=VMAX +): + """ + Write and plot an ANTsImage Parameters ------------- ants_img: ANTsImage + image will be plotted or/and saved. data_path: PathLike Path where the ANTsImage to be saved plot_path: PathLike Path where the plot of ANTsImage to be saved vmin, vmax: float - Set the color limits of the current image. + Set the color limits of the antsImage. """ if plot_path: title = plot_path.split("/")[-1].split(".")[0] plot_antsimgs(ants_img, plot_path, title, vmin=vmin, vmax=vmax) if data_path: - ants.image_write(ants_img, data_path) + ants.image_write(ants_img, data_path) + - class Masking: """ - Class to compute the mask on the ANTsImage + Get a binary mask image from the given light sheet volume after + thresholding. We compute the optimal threshold using Li thresholding """ + def __init__(self, ants_img): + """Class constructor + Parameters + ---------- + ants_img: ANTsImage + image from which mask will be computed. + """ self.ants_img = ants_img - + def _getLargestCC(self, segmentation): + """get the largest connected component""" labels = label(segmentation) - assert( labels.max() != 0 ) # assume at least 1 CC - largestCC = labels == np.argmax(np.bincount(labels.flat)[1:])+1 + assert labels.max() != 0 # assume at least 1 CC + largestCC = labels == np.argmax(np.bincount(labels.flat)[1:]) + 1 return largestCC def _get_threshold_li(self, arr_img: np.ndarray) -> float: - """ get the optimal threshold using Li thresholding """ + """get the optimal threshold using Li thresholding""" start_time = datetime.now() low_thresh = threshold_li(arr_img) - end_time = datetime.now() + end_time = datetime.now() logger.info( - f"Find optimal threshold using Li thresholding, execution time: {end_time - start_time} s -- low_thresh={low_thresh}" - ) + f"Find optimal threshold using Li thresholding, execution time:\ + {end_time - start_time} s -- low_thresh={low_thresh}" + ) return low_thresh def _cleanup_mask(self, arr_mask: np.ndarray) -> np.ndarray: """ - Morphological operations will be applied to clean up the mask by closing holes and - eroding away small or weakly-connected areas. The following steps are applied: + Morphological operations will be applied to clean up the mask by + closing holes and eroding away small or weakly-connected areas. + The following steps are applied: - Closing holes - Dilation with radius 1 voxel - Morphological closing @@ -109,16 +120,17 @@ def _cleanup_mask(self, arr_mask: np.ndarray) -> np.ndarray: mask = ni.binary_fill_holes(arr_mask).astype(int) mask = ni.binary_dilation(mask, structure=struct).astype(int) mask = ni.binary_closing(mask).astype(int) - mask = self._getLargestCC(mask) + mask = self._getLargestCC(mask) - mask = ni.binary_dilation(mask, structure=struct, iterations=6).astype(int) + mask = ni.binary_dilation(mask, structure=struct, iterations=6).astype( + int + ) arr_mask = ni.binary_fill_holes(mask).astype(int) return arr_mask - def run(self) -> np.ndarray: - """ compute the mask """ + """compute the mask""" arr_img = self.ants_img.numpy() # get optimal threshold using Li thresholding @@ -133,156 +145,183 @@ def run(self) -> np.ndarray: # convert numpy array to ants image ants_img_mask = ants.from_numpy( - arr_mask.astype("float32"), - spacing=self.ants_img.spacing, - origin=self.ants_img.origin, - direction=self.ants_img.direction) + arr_mask.astype("float32"), + spacing=self.ants_img.spacing, + origin=self.ants_img.origin, + direction=self.ants_img.direction, + ) return ants_img_mask -class Preprocess(): +class Preprocess: """ Class to Preprocess lightsheet data 1. resample to isotropic to have same resolution of the SPIM template 2. N4 bias correction - 3. intensity normalization + 3. intensity normalization """ + def __init__(self, args, input_data, reference_data): + """Initialize Preprocess class. + Parameters + ---------- + args: dict + Dictionary with preprocessing parameters + input_data: ANTsImage + image to be processed + reference_data: ANTsImage + spim template + """ self.args = args self.input_data = input_data self.reference_data = reference_data - - def resample(self, ants_img, ants_template): - """ Resample OMEZarr image to the resolution of template """ - logger.info(f"Resample OMEZarr image to the resolution of template") + + def resample(self, ants_img, ants_template): + """Resample OMEZarr image to the resolution of template""" + logger.info("Resample OMEZarr image to the resolution of template") ants_img = ants.resample_image( ants_img, ants_template.spacing, False, 1 ) logger.info(f"Resampled OMEZarr dataset: {ants_img}") - - # #------------- TODO: do we need? -------------# - - # logger.info(f"Size of resampled image: {ants_img.shape}") - - # # convert input data to tiff into reference voxel resolution - # downsampled_file_path = Path( - # f"{self.args['metadata_folder']}/{self.args['downsampled_file']}" - # ) - # ants.image_write(ants_img, str(downsampled_file_path)) - - # # convert data to uint16 - # im = io.imread(str(downsampled_file_path)).astype(np.uint16) - # downsampled16bit_file_path = Path( - # f"{self.args['metadata_folder']}/{self.args['downsampled16bit_file']}" - # ) - # tifffile.imwrite(str(downsampled16bit_file_path), im) - # #------------- TODO end -------------# write_and_plot_image( ants_img, data_path=self.args["prep_params"].get("resample_path"), - plot_path=self.args["prep_params"].get("resample_figpath"), - vmin=0, vmax=500) - + plot_path=self.args["prep_params"].get("resample_figpath"), + vmin=0, + vmax=500, + ) + return ants_img - - + def compute_mask(self, ants_img): - """ compute make """ + """compute make""" logger.info("Computing Mask") - + start_time = datetime.now() mask = Masking(ants_img) ants_img_mask = mask.run() end_time = datetime.now() logger.info( - f"Mask Complete, execution time: {end_time - start_time} s -- image {ants_img_mask}" + f"Mask Complete, execution time: {end_time - start_time} s\ + -- image {ants_img_mask}" ) - + write_and_plot_image( ants_img_mask, - data_path=self.args["prep_params"].get("mask_path"), - plot_path=self.args["prep_params"].get("mask_figpath"), - vmin=0, vmax=1) + data_path=self.args["prep_params"].get("mask_path"), + plot_path=self.args["prep_params"].get("mask_figpath"), + vmin=0, + vmax=1, + ) - return ants_img_mask + return ants_img_mask - - def compute_N4(self, ants_img, ants_img_mask): - """ compute N4 """ + def compute_N4( + self, + ants_img, + mask=None, + rescale_intensities=False, + shrink_factor=4, + convergence={"iters": [50, 50, 50, 50], "tol": 1e-7}, + spline_param=None, + return_bias_field=False, + verbose=False, + weight_mask=None, + ): + """N4 Bias Field Correction + https://antspy.readthedocs.io/en/latest/utils.html#ants.utils.bias_correction.n4_bias_field_correction + """ logger.info("Computing N4") n4_bias_params = { - "rescale_intensities": False, - "shrink_factor": 4, - "convergence": {"iters": [50, 50, 50, 50], "tol": 1e-7}, - # "spline_param": 15000, # TODO - "return_bias_field": False, - "verbose": False, - "weight_mask": None, + "mask": mask, + "rescale_intensities": rescale_intensities, + "shrink_factor": shrink_factor, + "convergence": convergence, + "spline_param": spline_param, + "return_bias_field": return_bias_field, + "verbose": verbose, + "weight_mask": weight_mask, } - + logger.info(f"Parameters -> {n4_bias_params}") start_time = datetime.now() ants_img_n4 = ants.utils.n4_bias_field_correction( - ants_img, mask=ants_img_mask, **n4_bias_params + ants_img, **n4_bias_params ) end_time = datetime.now() - + logger.info( - f"N4 Complete, execution time: {end_time - start_time} s -- image {ants_img_n4}" + f"N4 Complete, execution time: {end_time - start_time} s\ + -- image {ants_img_n4}" ) - + write_and_plot_image( ants_img_n4, - data_path=self.args["prep_params"].get("n4bias_path"), - plot_path=self.args["prep_params"].get("n4bias_figpath"), vmin=0, vmax=500) - + data_path=self.args["prep_params"].get("n4bias_path"), + plot_path=self.args["prep_params"].get("n4bias_figpath"), + vmin=0, + vmax=500, + ) + # Compute the difference between ants_img and ants_img_n4 ants_img_intensity_difference = ants_img - ants_img_n4 write_and_plot_image( ants_img_intensity_difference, - data_path=self.args["prep_params"].get("img_diff_n4bias_path"), - plot_path=self.args["prep_params"].get("img_diff_n4bias_figpath"), vmin=0, vmax=200) - + data_path=self.args["prep_params"].get("img_diff_n4bias_path"), + plot_path=self.args["prep_params"].get("img_diff_n4bias_figpath"), + vmin=0, + vmax=200, + ) + return ants_img_n4 - def intensity_norm(self, ants_img): - """ compute percential normalization """ + """compute percential normalization""" logger.info("Start intensity normalization") start_time = datetime.now() ants_img = perc_normalization(ants_img) end_time = datetime.now() logger.info( - f"Intensity normalization complete, execution time: {end_time - start_time} s -- image {ants_img}" + f"Intensity normalization complete, execution time:\ + {end_time - start_time} s -- image {ants_img}" ) write_and_plot_image( ants_img, - data_path=self.args["prep_params"].get("percNorm_path"), - plot_path=self.args["prep_params"].get("percNorm_figpath"), vmin=VMIN, vmax=VMAX) - + data_path=self.args["prep_params"].get("percNorm_path"), + plot_path=self.args["prep_params"].get("percNorm_figpath"), + vmin=VMIN, + vmax=VMAX, + ) + return ants_img - def run(self) -> str: + """ + Runs preprocessing + """ start_date_time = datetime.now() ants_img = self.resample(self.input_data, self.reference_data) ants_img_mask = self.compute_mask(ants_img) ants_img = ants_img * ants_img_mask - ants_img = self.compute_N4(ants_img, ants_img_mask) + ants_img = self.compute_N4(ants_img, mask=ants_img_mask) ants_img = self.intensity_norm(ants_img) - + end_date_time = datetime.now() - logger.info(f"Preprocessing complete, execution time: {end_date_time - start_date_time} s") - + logger.info( + f"Preprocessing complete, execution time:\ + {end_date_time - start_date_time} s" + ) + return ants_img - + + def main(input_config: dict): """ Main function to execute diff --git a/code/aind_ccf_reg/register.py b/code/aind_ccf_reg/register.py index bc1f7f4..ce259b3 100644 --- a/code/aind_ccf_reg/register.py +++ b/code/aind_ccf_reg/register.py @@ -2,14 +2,12 @@ Register an lightsheet data to the Allen Institute's CCF atlas via the SPIM template Pipeline: -(1) preprocessing an brain image -(2) rigid + SyN registration: register the preprocessed brain image to the SPIM template -(3) apply transform to align deformed image from (2) to the CCF template - -Quality control on registration: -(1) visualization: plot the overlay/difference image between deformed and fixed images -(2) TODO: compute the similarity metics to automatically detect registration failure +(1) check orientation and run preprocessing on the given image. +(2) register the preprocessed brain image to the SPIM template using ANTs rigid and SyN registration. +(3) register the deformed image from (2) to the CCF Allen Atlas by applying template-to-CCF transforms +(4) register CCF annotation to brain space """ + import logging import multiprocessing import os @@ -35,18 +33,16 @@ from numcodecs import blosc from skimage import io - from .__init__ import __version__ + blosc.use_threads = False -from aind_ccf_reg.utils import check_orientation, create_folder, generate_processing -from aind_ccf_reg.configs import PathLike, ArrayLike -from aind_ccf_reg.configs import VMIN, VMAX -from aind_ccf_reg.configs import RegSchema -from aind_ccf_reg.plots import plot_antsimgs, plot_reg, plot_reg_before_after -from aind_ccf_reg.preprocess import perc_normalization -from aind_ccf_reg.preprocess import write_and_plot_image -from aind_ccf_reg.preprocess import Preprocess +from aind_ccf_reg.configs import VMAX, VMIN, ArrayLike, PathLike, RegSchema +from aind_ccf_reg.plots import plot_antsimgs, plot_reg +from aind_ccf_reg.preprocess import (Preprocess, perc_normalization, + write_and_plot_image) +from aind_ccf_reg.utils import (check_orientation, create_folder, + generate_processing) LOG_FMT = "%(asctime)s %(message)s" LOG_DATE_FMT = "%Y-%m-%d %H:%M" @@ -142,6 +138,7 @@ class Register(ArgSchemaParser): """ Class to Register lightsheet data to CCF atlas """ + default_schema = RegSchema def __read_zarr_image(self, image_path: PathLike) -> np.array: @@ -164,25 +161,36 @@ def __read_zarr_image(self, image_path: PathLike) -> np.array: img_array = np.squeeze(img_array) return img_array - - def _plot_write_antsimg(self, ants_img, img_path: PathLike=None, vmin:float=VMIN, vmax:float=VMAX) -> None: + def _plot_write_antsimg( + self, + ants_img, + img_path: PathLike = None, + vmin: float = VMIN, + vmax: float = VMAX, + ) -> None: """plot and save moved image""" if img_path: figpath = img_path.replace(".nii.gz", "") title = img_path.replace(".nii.gz", "").split("/")[-1] - logger.info(f"Plotting image: {figpath}, title: {title}") + logger.info(f"Plotting image: {figpath}, title: {title}") plot_antsimgs(ants_img, figpath, title, vmin=vmin, vmax=vmax) - - logger.info(f"Writing image: {img_path}") - ants.image_write(ants_img, img_path) + + logger.info(f"Writing image: {img_path}") + ants.image_write(ants_img, img_path) logger.info("Done saving") - - - def _qc_reg(self, ants_moving, ants_fixed, ants_moved, moved_path: PathLike=None, figpath_name: str="reg") -> None: - """ - Quality control on registration results and write deformed image. + + def _qc_reg( + self, + ants_moving, + ants_fixed, + ants_moved, + moved_path: PathLike = None, + figpath_name: str = "reg", + ) -> None: + """ + Quality control on registration results and write deformed image. The plots will be saved to the same folder as the deformed image. - + Parameters ------------- ants_fixed: ANTsImage @@ -197,48 +205,56 @@ def _qc_reg(self, ants_moving, ants_fixed, ants_moved, moved_path: PathLike=None figpath name """ # plot moving, fixed, moved, overlaid, difference images in three directions - figpath = f"{self.args['reg_folder']}/{figpath_name}" - logger.info(f"Plot registration results: {figpath}") - + figpath = f"{self.args['reg_folder']}/{figpath_name}" + logger.info(f"Plot registration results: {figpath}") + if np.any(ants_moving.direction != ants_fixed.direction): - logger.info(f"Reorient moving image direction to fixed image direction ...") - ants_moving = ants.reorient_image2(ants_moving, orientation=ants.get_orientation(ants_fixed)) - logger.info(f"Reoriented moving image -- {ants_moving}") - - for loc in [0, 1, 2]: - plot_args = (ants_moving, ants_fixed, ants_moved, f"{figpath}_{loc}") - plot_kwargs = {"title": figpath_name, "loc": loc, "vmin": VMIN, "vmax": VMAX} - - if np.all(ants_moving.shape == ants_fixed.shape): - # moving and fixed images have same dimension - plot_reg_before_after(*plot_args, **plot_kwargs) - else: - # moving and fixed images do not have same dimension - plot_reg(*plot_args, **plot_kwargs) - - self._plot_write_antsimg(ants_moved, moved_path) - - - def register_to_template(self, ants_fixed, ants_moving): - """ + logger.info( + f"Reorient moving image direction to fixed image direction ..." + ) + ants_moving = ants.reorient_image2( + ants_moving, orientation=ants.get_orientation(ants_fixed) + ) + logger.info(f"Reoriented moving image -- {ants_moving}") + + for loc in [0, 1, 2]: + plot_args = ( + ants_moving, + ants_fixed, + ants_moved, + f"{figpath}_{loc}", + ) + plot_kwargs = { + "title": figpath_name, + "loc": loc, + "vmin": VMIN, + "vmax": VMAX, + } + + plot_reg(*plot_args, **plot_kwargs) + + self._plot_write_antsimg(ants_moved, moved_path) + + def register_to_template(self, ants_fixed, ants_moving): + """ Run SyN regsitration to align brain image to SPIM template - + Parameters ------------- ants_fixed: ANTsImage fixed image ants_moving: ANTsImage moving image - + Returns ----------- ANTsImage deformed image """ - - #----------------------------------# + + # ----------------------------------# # rigid registration - #----------------------------------# + # ----------------------------------# logger.info(f"Start computing rigid registration ....") @@ -246,119 +262,142 @@ def register_to_template(self, ants_fixed, ants_moving): start_time = datetime.now() registration_params = { "fixed": ants_fixed, - "moving": ants_moving, + "moving": ants_moving, "type_of_transform": "Rigid", - "outprefix": f"{self.args['reg_folder']}/ls_to_template_rigid_", + "outprefix": f"{self.args['reg_folder']}/ls_to_template_rigid_", "mask_all_stages": True, "grad_step": 0.25, "reg_iterations": (60, 40, 20, 0), - "aff_metric": "mattes" + "aff_metric": "mattes", } - logger.info(f"Computing rigid registration with parameters: {registration_params}") + logger.info( + f"Computing rigid registration with parameters: {registration_params}" + ) rigid_reg = ants.registration(**registration_params) end_time = datetime.now() - logger.info(f"Rigid registration Complete, execution time: {end_time - start_time} s -- image {rigid_reg}") + logger.info( + f"Rigid registration Complete, execution time: {end_time - start_time} s -- image {rigid_reg}" + ) ants_moved = rigid_reg["warpedmovout"] - + reg_task = "reg_rigid" - self._qc_reg(ants_moving, - ants_fixed, - ants_moved, - moved_path=self.args["ants_params"]["rigid_path"], - figpath_name=reg_task) + self._qc_reg( + ants_moving, + ants_fixed, + ants_moved, + moved_path=self.args["ants_params"]["rigid_path"], + figpath_name=reg_task, + ) - #----------------------------------# + # ----------------------------------# # SyN registration - #----------------------------------# + # ----------------------------------# logger.info(f"Start registering to template ....") - if self.args['reference_res'] == 25: - reg_iterations = [200, 20, 0] - elif self.args['reference_res'] == 10: + if self.args["reference_res"] == 25: + reg_iterations = [200, 20, 0] + elif self.args["reference_res"] == 10: reg_iterations = [400, 200, 40, 0] else: raise ValueError( f"Resolution {self.args['reference_res']} is not allowed. Allowed values are: 10, 25" ) - + start_time = datetime.now() registration_params = { "fixed": ants_fixed, "moving": ants_moving, # "initial_transform": [f"{self.args['reg_folder']}/ls_to_template_rigid_0GenericAffine.mat"], "initial_transform": rigid_reg["fwdtransforms"][0], - "syn_metric": "CC", + "syn_metric": "CC", "syn_sampling": 2, - "reg_iterations": reg_iterations, - "outprefix": f"{self.args['reg_folder']}/ls_to_template_SyN_"} - - logger.info(f"Computing SyN registration with parameters: {registration_params}") + "reg_iterations": reg_iterations, + "outprefix": f"{self.args['results_folder']}/ls_to_template_SyN_", + } + + logger.info( + f"Computing SyN registration with parameters: {registration_params}" + ) reg = ants.registration(**registration_params) end_time = datetime.now() - logger.info(f"SyN registration complete, execution time: {end_time - start_time} s -- image {reg}") - + logger.info( + f"SyN registration complete, execution time: {end_time - start_time} s -- image {reg}" + ) + ants_moved = reg["warpedmovout"] - + reg_task = "reg_to_template" - self._qc_reg(ants_moving, - ants_fixed, - ants_moved, - moved_path=self.args["ants_params"]["moved_to_template_path"], - figpath_name=reg_task) - + self._qc_reg( + ants_moving, + ants_fixed, + ants_moved, + moved_path=self.args["ants_params"]["moved_to_template_path"], + figpath_name=reg_task, + ) + return ants_moved - - - def register_to_ccf(self, ants_fixed, ants_moving): - """ + + def register_to_ccf(self, ants_fixed, ants_moving): + """ Run manual regsitration to align brain image to CCF template - + Parameters ------------- ants_fixed: ANTsImage fixed image ants_moving: ANTsImage moving image - + Returns ----------- ANTsImage deformed image """ logger.info("Start registering to CCF ....") - logger.info(f"Register to CCF with: {self.args['template_to_ccf_transform_path']}") + logger.info( + f"Register to CCF with: {self.args['template_to_ccf_transform_path']}" + ) # for visualizing registration results ants_fixed = perc_normalization(ants_fixed) - + start_time = datetime.now() ants_moved = ants.apply_transforms( - fixed=ants_fixed, - moving=ants_moving, - transformlist=self.args["template_to_ccf_transform_path"] - ) + fixed=ants_fixed, + moving=ants_moving, + transformlist=self.args["template_to_ccf_transform_path"], + ) end_time = datetime.now() - logger.info(f"Register to CCF, execution time: {end_time - start_time} s -- image {ants_moved}") + logger.info( + f"Register to CCF, execution time: {end_time - start_time} s -- image {ants_moved}" + ) reg_task = "reg_to_ccf" - self._qc_reg(ants_moving, - ants_fixed, - ants_moved, - moved_path=self.args["ants_params"]["moved_to_ccf_path"], - figpath_name=reg_task) - + self._qc_reg( + ants_moving, + ants_fixed, + ants_moved, + moved_path=self.args["ants_params"]["moved_to_ccf_path"], + figpath_name=reg_task, + ) + return ants_moved - - + def atlas_alignment( self, img_array: np.array, ants_params: dict ) -> np.array: """ - Aligns the image to the reference atlas + Register an lightsheet volume to the CCF Allen atlas via the SPIM template + + Pipeline: + (1) check orientation and run preprocessing on the given image. + (2) register the preprocessed brain image to the SPIM template using ANTs rigid and SyN registration. + (3) register the deformed image from (2) to the CCF Allen Atlas by applying template-to-CCF transforms + (4) register CCF annotation to brain space Parameters ------------ @@ -368,19 +407,23 @@ def atlas_alignment( ants_params: dict Dictionary with ants parameters """ - #----------------------------------# + # ----------------------------------# # load SPIM template + CCF - #----------------------------------# - + # ----------------------------------# + logger.info("Reading reference images") - ants_template = ants.image_read(os.path.abspath(self.args["template_path"])) # SPIM template - ants_ccf = ants.image_read(os.path.abspath(self.args["ccf_reference_path"])) # CCF template + ants_template = ants.image_read( + os.path.abspath(self.args["template_path"]) + ) # SPIM template + ants_ccf = ants.image_read( + os.path.abspath(self.args["ccf_reference_path"]) + ) # CCF template logger.info(f"Loaded SPIM template {ants_template}") logger.info(f"Loaded CCF template {ants_ccf}") - - #----------------------------------# + + # ----------------------------------# # orient data to SPIM template's direction - #----------------------------------# + # ----------------------------------# img_array = img_array.astype(np.double) img_out, in_mat, out_mat = check_orientation( @@ -399,78 +442,84 @@ def atlas_alignment( ants_img = ants.from_numpy(img_out, spacing=ants_params["spacing"]) ants_img.set_direction(ants_template.direction) ants_img.set_origin(ants_template.origin) - + write_and_plot_image( ants_img, - data_path=self.args["prep_params"].get("rawdata_path"), - plot_path=self.args["prep_params"].get("rawdata_figpath"), vmin=0, vmax=500) - - #----------------------------------# + data_path=self.args["prep_params"].get("rawdata_path"), + plot_path=self.args["prep_params"].get("rawdata_figpath"), + vmin=0, + vmax=500, + ) + + # ----------------------------------# # run preprocessing on raw data - #----------------------------------# + # ----------------------------------# logger.info(f"{'=='*40}") logger.info(f"Start preprocessing....") logger.info(f"{'=='*40}") - + prep = Preprocess(self.args, ants_img, ants_template) ants_img = prep.run() logger.info(f"Preprocessed input data {ants_img}") - - #----------------------------------# + + # ----------------------------------# # register brain image to template - #----------------------------------# + # ----------------------------------# logger.info(f"{'=='*40}") logger.info(f"Start registering brain image to template....") logger.info(f"{'=='*40}") - - # ants_img = ants.image_read(self.args["prep_params"].get("percNorm_path")) # + + # ants_img = ants.image_read(self.args["prep_params"].get("percNorm_path")) # # register to SPIM template: rigid + SyN aligned_image = self.register_to_template(ants_template, ants_img) - - #----------------------------------# + + # ----------------------------------# # register brain image to CCF - #----------------------------------# + # ----------------------------------# logger.info(f"{'=='*40}") logger.info(f"Start registering brain image to CCF....") logger.info(f"{'=='*40}") - - # aligned_image = ants.image_read(self.args["ants_params"].get("moved_to_template_path")) # - + + # aligned_image = ants.image_read(self.args["ants_params"].get("moved_to_template_path")) # + # register to CCF template: apply manual regsitration aligned_image = self.register_to_ccf(ants_ccf, aligned_image) - #----------------------------------# + # ----------------------------------# # register CCF annotation to brain space - # TODO: register_to_template() return transforms - #----------------------------------# + # ----------------------------------# logger.info(f"{'=='*40}") logger.info(f"Start registering CCF annotation to brain space....") logger.info(f"{'=='*40}") - - ccf_anno_to_template_deformed = ants.image_read( self.args["ccf_annotation_to_template_moved_path"] ) - + + ccf_anno_to_template_deformed = ants.image_read( + self.args["ccf_annotation_to_template_moved_path"] + ) + template_to_brain_transform_path = [ - f"{self.args['reg_folder']}/ls_to_template_SyN_0GenericAffine.mat", - f"{self.args['reg_folder']}/ls_to_template_SyN_1InverseWarp.nii.gz", + f"{self.args['results_folder']}/ls_to_template_SyN_0GenericAffine.mat", + f"{self.args['results_folder']}/ls_to_template_SyN_1InverseWarp.nii.gz", ] # apply transform ccf_anno_to_brain_deformed = ants.apply_transforms( - fixed = ants_img, - moving = ccf_anno_to_template_deformed, - transformlist=template_to_brain_transform_path, - whichtoinvert = [True, False], - interpolator = 'genericLabel' - ) + fixed=ants_img, + moving=ccf_anno_to_template_deformed, + transformlist=template_to_brain_transform_path, + whichtoinvert=[True, False], + interpolator="genericLabel", + ) + + self._plot_write_antsimg( + ccf_anno_to_brain_deformed, + self.args["ants_params"]["ccf_anno_to_brain_path"], + vmin=0, + vmax=None, + ) - self._plot_write_antsimg(ccf_anno_to_brain_deformed, - self.args['ants_params']['ccf_anno_to_brain_path'], - vmin=0, vmax=None) - return aligned_image.numpy() - def write_zarr( self, img_array: np.array, @@ -589,15 +638,17 @@ def run(self) -> str: input_data_path = os.path.abspath(self.args["input_data"]) output_data_path = os.path.abspath(self.args["output_data"]) metadata_path = os.path.abspath(self.args["metadata_folder"]) - reg_folder = os.path.abspath(self.args["reg_folder"]) # save registration results + reg_folder = os.path.abspath( + self.args["reg_folder"] + ) # save registration results # input_data_path = glob(f"{input_data_path}_stitched_*/")[0] logger.info( f"Input data: {input_data_path}\nOutput data: {output_data_path}\nMetadata path: {metadata_path}" ) - + logger.info(f"Regsitration results save to: {reg_folder}") - + create_folder(output_data_path) create_folder(reg_folder) create_folder(metadata_path) @@ -689,7 +740,7 @@ def run(self) -> str: } aligned_image_dask = da.from_array(aligned_image) - + self.write_zarr( img_array=aligned_image_dask, # dask array physical_pixel_sizes=ants_params["new_spacing"], diff --git a/code/aind_ccf_reg/utils.py b/code/aind_ccf_reg/utils.py index 62315f5..948f49b 100644 --- a/code/aind_ccf_reg/utils.py +++ b/code/aind_ccf_reg/utils.py @@ -1,6 +1,7 @@ """ File for utilities """ + import logging import multiprocessing import os @@ -14,9 +15,10 @@ import numpy as np import psutil import pydantic +from aind_ccf_reg.configs import PathLike from aind_data_schema.core.processing import (DataProcess, PipelineProcess, Processing) -from aind_ccf_reg.configs import PathLike + def create_folder(dest_dir: PathLike, verbose: Optional[bool] = False) -> None: """ @@ -474,8 +476,7 @@ def print_system_information(logger: logging.Logger): logger.info(f"Total Bytes Sent: {get_size(net_io.bytes_sent)}") logger.info(f"Total Bytes Received: {get_size(net_io.bytes_recv)}") - - + def save_string_to_txt(txt: str, filepath: str, mode="w") -> None: """ Saves a text in a file in the given mode. @@ -495,4 +496,3 @@ def save_string_to_txt(txt: str, filepath: str, mode="w") -> None: with open(filepath, mode) as file: file.write(txt + "\n") - diff --git a/code/main.py b/code/main.py index 5ba5f5b..12fcd92 100644 --- a/code/main.py +++ b/code/main.py @@ -2,18 +2,18 @@ Main used in code ocean to execute capsule """ +import glob import json import logging import multiprocessing import os import subprocess from datetime import datetime -import glob from aind_ccf_reg import register, utils -from natsort import natsorted from aind_ccf_reg.configs import PathLike from aind_ccf_reg.utils import create_folder +from natsort import natsorted def create_logger(output_log_path: PathLike) -> logging.Logger: @@ -28,7 +28,7 @@ def create_logger(output_log_path: PathLike) -> logging.Logger: Returns ----------- logging.Logger - Created logger + Created logger pointing to the file path. """ CURR_DATE_TIME = datetime.now().strftime("%Y-%m-%d-%H-%M-%S") @@ -46,7 +46,7 @@ def create_logger(output_log_path: PathLike) -> logging.Logger: force=True, ) -# logging.disable("DEBUG") + # logging.disable("DEBUG") logging.disable(logging.DEBUG) logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) @@ -81,6 +81,7 @@ def read_json_as_dict(filepath: str) -> dict: return dictionary + def execute_command_helper(command: str, print_command: bool = False) -> None: """ Execute a shell command. @@ -123,16 +124,16 @@ def main() -> None: if not os.path.exists(processing_manifest_path): raise ValueError("Processing manifest path does not exist!") - + if not os.path.exists(acquisition_path): raise ValueError("Acquisition path does not exist!") pipeline_config = read_json_as_dict(processing_manifest_path) pipeline_config = pipeline_config.get("pipeline_processing") - + if pipeline_config is None: raise ValueError("Please, provide a valid processing manifest") - + acquisition_json = read_json_as_dict(acquisition_path) acquisition_orientation = acquisition_json.get("axes") @@ -149,7 +150,7 @@ def main() -> None: results_folder = f"../results/ccf_{channel_to_register}" create_folder(results_folder) - + logger = create_logger(output_log_path=results_folder) logger.info( f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" @@ -182,26 +183,37 @@ def main() -> None: logger.info(f"{'='*40} SmartSPIM CCF Registration {'='*40}") - #-------------------------------------------------------------# + # -------------------------------------------------------------# # path to SPIM template, CCF and template-to-CCF registration - template_path = os.path.abspath("../data/lightsheet_template_ccf_registration/smartspim_lca_template_25.nii.gz") - ccf_reference_path = os.path.abspath("../data/lightsheet_template_ccf_registration/ccf_average_template_25.nii.gz") + template_path = os.path.abspath( + "../data/lightsheet_template_ccf_registration/smartspim_lca_template_25.nii.gz" + ) + ccf_reference_path = os.path.abspath( + "../data/lightsheet_template_ccf_registration/ccf_average_template_25.nii.gz" + ) template_to_ccf_transform_path = [ - os.path.abspath("../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_1Warp.nii.gz"), - os.path.abspath("../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat")] + os.path.abspath( + "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_1Warp.nii.gz" + ), + os.path.abspath( + "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat" + ), + ] print(f"template_to_ccf_transform_path: {template_to_ccf_transform_path}") - ccf_annotation_to_template_moved_path = os.path.abspath("../data/lightsheet_template_ccf_registration/ccf_annotation_to_template_moved.nii.gz") + ccf_annotation_to_template_moved_path = os.path.abspath( + "../data/lightsheet_template_ccf_registration/ccf_annotation_to_template_moved.nii.gz" + ) + + # -------------------------------------------------------------# - #-------------------------------------------------------------# - example_input = { - "input_data": "../data/fused", + "input_data": "../data/fused", "input_channel": channel_to_register, "input_scale": pipeline_config["registration"]["input_scale"], "input_orientation": acquisition_orientation, "bucket_path": "aind-open-data", - "template_path": template_path, # SPIM template + "template_path": template_path, # SPIM template "ccf_reference_path": ccf_reference_path, "template_to_ccf_transform_path": template_to_ccf_transform_path, "ccf_annotation_to_template_moved_path": ccf_annotation_to_template_moved_path, @@ -209,21 +221,22 @@ def main() -> None: "output_data": os.path.abspath(f"{results_folder}/OMEZarr"), "metadata_folder": metadata_folder, "code_url": "https://github.com/AllenNeuralDynamics/aind-ccf-registration", + "results_folder": results_folder, "reg_folder": reg_folder, "prep_params": { "rawdata_figpath": f"{reg_folder}/prep_zarr_img.jpg", "rawdata_path": f"{reg_folder}/prep_zarr_img.nii.gz", "resample_figpath": f"{reg_folder}/prep_resampled_zarr_img.jpg", - # "resample_path": f"{reg_folder}/prep_resampled_zarr_img.nii.gz", + "resample_path": f"{reg_folder}/prep_resampled_zarr_img.nii.gz", "mask_figpath": f"{reg_folder}/prep_mask.jpg", - # "mask_path": f"{reg_folder}/prep_mask.nii.gz", + "mask_path": f"{reg_folder}/prep_mask.nii.gz", "n4bias_figpath": f"{reg_folder}/prep_n4bias.jpg", - # "n4bias_path": f"{reg_folder}/prep_n4bias.nii.gz", - "img_diff_n4bias_figpath": f"{reg_folder}/prep_img_diff_n4bias.jpg", + "n4bias_path": f"{reg_folder}/prep_n4bias.nii.gz", + # "img_diff_n4bias_figpath": f"{reg_folder}/prep_img_diff_n4bias.jpg", # "img_diff_n4bias_path": f"{reg_folder}/prep_img_diff_n4bias.nii.gz", "percNorm_figpath": f"{reg_folder}/prep_percNorm.jpg", "percNorm_path": f"{reg_folder}/prep_percNorm.nii.gz", - }, + }, "ants_params": { "spacing": (0.0144, 0.0144, 0.016), "unit": "millimetre", @@ -231,15 +244,15 @@ def main() -> None: # "anterior_to_posterior": 0, # "superior_to_inferior": 1, # "left_to_right": 2, - # }, + # }, "template_orientations": { "anterior_to_posterior": 1, "superior_to_inferior": 2, "right_to_left": 0, - }, + }, "rigid_path": f"{reg_folder}/moved_rigid.nii.gz", "moved_to_template_path": f"{reg_folder}/moved_ls_to_template.nii.gz", - "moved_to_ccf_path": f"{reg_folder}/moved_ls_to_ccf.nii.gz", + "moved_to_ccf_path": f"{results_folder}/moved_ls_to_ccf.nii.gz", "ccf_anno_to_brain_path": f"{reg_folder}/moved_ccf_anno_to_ls.nii.gz", }, "OMEZarr_params": { diff --git a/code/main_register_dataset.py b/code/main_register_dataset.py index fe19f6b..4e2da58 100644 --- a/code/main_register_dataset.py +++ b/code/main_register_dataset.py @@ -2,18 +2,18 @@ Main used in code ocean to execute capsule """ +import glob import json import logging import multiprocessing import os import subprocess from datetime import datetime -import glob from aind_ccf_reg import register, utils -from natsort import natsorted from aind_ccf_reg.configs import PathLike from aind_ccf_reg.utils import create_folder +from natsort import natsorted def create_logger(output_log_path: PathLike) -> logging.Logger: @@ -28,7 +28,7 @@ def create_logger(output_log_path: PathLike) -> logging.Logger: Returns ----------- logging.Logger - Created logger + Created logger pointing to the file path. """ CURR_DATE_TIME = datetime.now().strftime("%Y-%m-%d-%H-%M-%S") @@ -46,7 +46,7 @@ def create_logger(output_log_path: PathLike) -> logging.Logger: force=True, ) -# logging.disable("DEBUG") + # logging.disable("DEBUG") logging.disable(logging.DEBUG) logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) @@ -54,6 +54,7 @@ def create_logger(output_log_path: PathLike) -> logging.Logger: return logger + def read_json_as_dict(filepath: str) -> dict: """ Reads a json as dictionary. @@ -80,6 +81,7 @@ def read_json_as_dict(filepath: str) -> dict: return dictionary + def execute_command_helper(command: str, print_command: bool = False) -> None: """ Execute a shell command. @@ -120,14 +122,20 @@ def main() -> None: subject_dir = "SmartSPIM_725271_2024-05-22_17-24-06" subject_dir = "SmartSPIM_725379_2024-04-25_17-02-42" - input_data = glob.glob(f"../data/{subject_dir}*_stitched_*/image_tile_fusing/OMEZarr/") + input_data = glob.glob( + f"../data/{subject_dir}*_stitched_*/image_tile_fusing/OMEZarr/" + ) if input_data is None: - raise ValueError("Please attach the stitched data asset for registration!") - + raise ValueError( + "Please attach the stitched data asset for registration!" + ) + input_data = input_data[0] - + data_folder = os.path.abspath(f"../data/{subject_dir}/") - processing_manifest_path = f"{data_folder}/derivatives/processing_manifest.json" + processing_manifest_path = ( + f"{data_folder}/derivatives/processing_manifest.json" + ) acquisition_path = f"{data_folder}/acquisition.json" if not os.path.exists(processing_manifest_path): @@ -167,9 +175,9 @@ def main() -> None: logger.info( f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" ) - + logger.info(f"channel_to_register: {channel_to_register}") - + reg_folder = os.path.abspath(f"{results_folder}/registration") metadata_folder = os.path.abspath(f"{results_folder}/metadata") @@ -195,26 +203,37 @@ def main() -> None: profile_process.start() logger.info(f"{'='*40} SmartSPIM CCF Registration {'='*40}") - - #---------------------------------------------------# + + # ---------------------------------------------------# # path to SPIM template, CCF and template-to-CCF registration - template_path = os.path.abspath("../data/lightsheet_template_ccf_registration/smartspim_lca_template_25.nii.gz") - ccf_reference_path = os.path.abspath("../data/lightsheet_template_ccf_registration/ccf_average_template_25.nii.gz") + template_path = os.path.abspath( + "../data/lightsheet_template_ccf_registration/smartspim_lca_template_25.nii.gz" + ) + ccf_reference_path = os.path.abspath( + "../data/lightsheet_template_ccf_registration/ccf_average_template_25.nii.gz" + ) template_to_ccf_transform_path = [ - os.path.abspath("../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_1Warp.nii.gz"), - os.path.abspath("../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat")] + os.path.abspath( + "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_1Warp.nii.gz" + ), + os.path.abspath( + "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat" + ), + ] print(f"template_to_ccf_transform_path: {template_to_ccf_transform_path}") - ccf_annotation_to_template_moved_path = os.path.abspath("../data/lightsheet_template_ccf_registration/ccf_annotation_to_template_moved.nii.gz") - - #---------------------------------------------------# + ccf_annotation_to_template_moved_path = os.path.abspath( + "../data/lightsheet_template_ccf_registration/ccf_annotation_to_template_moved.nii.gz" + ) + + # ---------------------------------------------------# example_input = { -# "input_data": "../data/fused", # TODO + # "input_data": "../data/fused", # TODO "input_data": input_data, "input_channel": channel_to_register, "input_scale": pipeline_config["registration"]["input_scale"], "input_orientation": acquisition_orientation, "bucket_path": "aind-open-data", - "template_path": template_path, # SPIM template + "template_path": template_path, # SPIM template "ccf_reference_path": ccf_reference_path, "template_to_ccf_transform_path": template_to_ccf_transform_path, "ccf_annotation_to_template_moved_path": ccf_annotation_to_template_moved_path, @@ -222,6 +241,7 @@ def main() -> None: "output_data": os.path.abspath(f"{results_folder}/OMEZarr"), "metadata_folder": metadata_folder, "code_url": "https://github.com/AllenNeuralDynamics/aind-ccf-registration", + "results_folder": results_folder, "reg_folder": reg_folder, "prep_params": { "rawdata_figpath": f"{reg_folder}/prep_zarr_img.jpg", @@ -231,12 +251,12 @@ def main() -> None: "mask_figpath": f"{reg_folder}/prep_mask.jpg", "mask_path": f"{reg_folder}/prep_mask.nii.gz", "n4bias_figpath": f"{reg_folder}/prep_n4bias.jpg", - "n4bias_path": f"{reg_folder}/prep_n4bias.nii.gz", - "img_diff_n4bias_figpath": f"{reg_folder}/prep_img_diff_n4bias.jpg", - "img_diff_n4bias_path": f"{reg_folder}/prep_img_diff_n4bias.nii.gz", + # "n4bias_path": f"{reg_folder}/prep_n4bias.nii.gz", + # "img_diff_n4bias_figpath": f"{reg_folder}/prep_img_diff_n4bias.jpg", + # "img_diff_n4bias_path": f"{reg_folder}/prep_img_diff_n4bias.nii.gz", "percNorm_figpath": f"{reg_folder}/prep_percNorm.jpg", "percNorm_path": f"{reg_folder}/prep_percNorm.nii.gz", - }, + }, "ants_params": { "spacing": (0.0144, 0.0144, 0.016), "unit": "millimetre", @@ -244,15 +264,15 @@ def main() -> None: # "anterior_to_posterior": 0, # "superior_to_inferior": 1, # "left_to_right": 2, - # }, + # }, "template_orientations": { "anterior_to_posterior": 1, "superior_to_inferior": 2, "right_to_left": 0, - }, + }, "rigid_path": f"{reg_folder}/moved_rigid.nii.gz", "moved_to_template_path": f"{reg_folder}/moved_ls_to_template.nii.gz", - "moved_to_ccf_path": f"{reg_folder}/moved_ls_to_ccf.nii.gz", + "moved_to_ccf_path": f"{results_folder}/moved_ls_to_ccf.nii.gz", "ccf_anno_to_brain_path": f"{reg_folder}/moved_ccf_anno_to_ls.nii.gz", }, "OMEZarr_params": { diff --git a/code/register_datasets.py b/code/register_datasets.py index 66050fd..d2c20d6 100644 --- a/code/register_datasets.py +++ b/code/register_datasets.py @@ -1,6 +1,7 @@ """ Module to register multiple datasets """ + import logging import os import subprocess From 34788e482c2fa2936cbd6e785a2920bbdf010a4d Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Mon, 3 Jun 2024 17:32:21 +0000 Subject: [PATCH 11/15] update antspyx to latest version 0.4.2 --- environment/Dockerfile | 2 +- pyproject.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/environment/Dockerfile b/environment/Dockerfile index 2d6432a..92989a4 100644 --- a/environment/Dockerfile +++ b/environment/Dockerfile @@ -12,7 +12,7 @@ RUN conda create -n ccf_reg python=3.8 SHELL ["conda", "run", "-n", "ccf_reg", "/bin/bash", "-c"] RUN pip install -U --no-cache-dir \ - antspyx \ + antspyx==0.4.2 \ argschema==3.0.4 \ s3fs==2022.11.0 \ scikit-image==0.19.3 \ diff --git a/pyproject.toml b/pyproject.toml index e33c217..8b35f46 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,7 +15,7 @@ dynamic = ["version", "readme"] dependencies = [ 'argschema==3.0.4', 'dask==2022.10.2', - 'antspyx==0.3.7', + 'antspyx==0.4.2', 'scikit-image==0.19.3', 'tifffile==2022.10.10', 'zarr==2.13.3' From e18da9a0f852f6cd92ff4511fa2c82dfc25c9d2c Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Mon, 3 Jun 2024 19:48:51 +0000 Subject: [PATCH 12/15] save derivative images to registration_metadata/ folder --- code/aind_ccf_reg/register.py | 2 -- code/main.py | 53 ++++++++++++++++++++++++++--------- code/main_register_dataset.py | 50 +++++++++++++++++++++++++-------- 3 files changed, 78 insertions(+), 27 deletions(-) diff --git a/code/aind_ccf_reg/register.py b/code/aind_ccf_reg/register.py index ce259b3..3913a07 100644 --- a/code/aind_ccf_reg/register.py +++ b/code/aind_ccf_reg/register.py @@ -650,8 +650,6 @@ def run(self) -> str: logger.info(f"Regsitration results save to: {reg_folder}") create_folder(output_data_path) - create_folder(reg_folder) - create_folder(metadata_path) # read input data (lazy loading) # flake8: noqa: E501 diff --git a/code/main.py b/code/main.py index 12fcd92..cd75d0c 100644 --- a/code/main.py +++ b/code/main.py @@ -150,16 +150,17 @@ def main() -> None: results_folder = f"../results/ccf_{channel_to_register}" create_folder(results_folder) + reg_folder = os.path.abspath(f"{results_folder}/registration_metadata") + metadata_folder = os.path.abspath(f"{results_folder}/metadata") + create_folder(reg_folder) + create_folder(metadata_folder) - logger = create_logger(output_log_path=results_folder) + logger = create_logger(output_log_path=reg_folder) logger.info( f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" ) logger.info(f"channel_to_register: {channel_to_register}") - reg_folder = os.path.abspath(f"{results_folder}/registration") - metadata_folder = os.path.abspath(f"{results_folder}/metadata") - utils.print_system_information(logger) # Tracking compute resources @@ -183,8 +184,7 @@ def main() -> None: logger.info(f"{'='*40} SmartSPIM CCF Registration {'='*40}") - # -------------------------------------------------------------# - + # ---------------------------------------------------# # path to SPIM template, CCF and template-to-CCF registration template_path = os.path.abspath( "../data/lightsheet_template_ccf_registration/smartspim_lca_template_25.nii.gz" @@ -192,20 +192,47 @@ def main() -> None: ccf_reference_path = os.path.abspath( "../data/lightsheet_template_ccf_registration/ccf_average_template_25.nii.gz" ) + template_to_ccf_transform_warp_path = os.path.abspath( + "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_1Warp.nii.gz" + ) + template_to_ccf_transform_affine_path = os.path.abspath( + "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat" + ) template_to_ccf_transform_path = [ - os.path.abspath( - "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_1Warp.nii.gz" - ), - os.path.abspath( - "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat" - ), + template_to_ccf_transform_warp_path, + template_to_ccf_transform_affine_path, ] print(f"template_to_ccf_transform_path: {template_to_ccf_transform_path}") + ccf_annotation_to_template_moved_path = os.path.abspath( "../data/lightsheet_template_ccf_registration/ccf_annotation_to_template_moved.nii.gz" ) - # -------------------------------------------------------------# + if not os.path.isfile(template_path): + raise FileNotFoundError( + "template_path not exist, please provide valid path to SPIM template" + ) + + if not os.path.isfile(ccf_reference_path): + raise FileNotFoundError( + "ccf_reference_path not exist, please provide valid path to CCF atlas" + ) + + if not os.path.isfile(template_to_ccf_transform_warp_path): + raise FileNotFoundError( + "template_to_ccf_transform_warp_path not exist, please provide valid path" + ) + + if not os.path.isfile(template_to_ccf_transform_affine_path): + raise FileNotFoundError( + "template_to_ccf_transform_affine_path not exist, please provide valid path" + ) + + if not os.path.isfile(ccf_annotation_to_template_moved_path): + raise FileNotFoundError( + "ccf_annotation_to_template_moved_path not exist, please provide valid path" + ) + # ---------------------------------------------------# example_input = { "input_data": "../data/fused", diff --git a/code/main_register_dataset.py b/code/main_register_dataset.py index 4e2da58..3a95fd0 100644 --- a/code/main_register_dataset.py +++ b/code/main_register_dataset.py @@ -168,19 +168,17 @@ def main() -> None: results_folder = f"../results/{subject_id}_ccf_{channel_to_register}" create_folder(results_folder) + reg_folder = os.path.abspath(f"{results_folder}/registration_metadata") metadata_folder = os.path.abspath(f"{results_folder}/metadata") + create_folder(reg_folder) + create_folder(metadata_folder) - logger = create_logger(output_log_path=results_folder) - + logger = create_logger(output_log_path=reg_folder) logger.info( f"Processing manifest {pipeline_config} provided in path {processing_manifest_path}" ) - logger.info(f"channel_to_register: {channel_to_register}") - reg_folder = os.path.abspath(f"{results_folder}/registration") - metadata_folder = os.path.abspath(f"{results_folder}/metadata") - utils.print_system_information(logger) # Tracking compute resources @@ -212,20 +210,48 @@ def main() -> None: ccf_reference_path = os.path.abspath( "../data/lightsheet_template_ccf_registration/ccf_average_template_25.nii.gz" ) + template_to_ccf_transform_warp_path = os.path.abspath( + "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_1Warp.nii.gz" + ) + template_to_ccf_transform_affine_path = os.path.abspath( + "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat" + ) template_to_ccf_transform_path = [ - os.path.abspath( - "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_1Warp.nii.gz" - ), - os.path.abspath( - "../data/lightsheet_template_ccf_registration/spim_template_to_ccf_syn_0GenericAffine.mat" - ), + template_to_ccf_transform_warp_path, + template_to_ccf_transform_affine_path, ] print(f"template_to_ccf_transform_path: {template_to_ccf_transform_path}") + ccf_annotation_to_template_moved_path = os.path.abspath( "../data/lightsheet_template_ccf_registration/ccf_annotation_to_template_moved.nii.gz" ) + if not os.path.isfile(template_path): + raise FileNotFoundError( + "template_path not exist, please provide valid path to SPIM template" + ) + + if not os.path.isfile(ccf_reference_path): + raise FileNotFoundError( + "ccf_reference_path not exist, please provide valid path to CCF atlas" + ) + + if not os.path.isfile(template_to_ccf_transform_warp_path): + raise FileNotFoundError( + "template_to_ccf_transform_warp_path not exist, please provide valid path" + ) + + if not os.path.isfile(template_to_ccf_transform_affine_path): + raise FileNotFoundError( + "template_to_ccf_transform_affine_path not exist, please provide valid path" + ) + + if not os.path.isfile(ccf_annotation_to_template_moved_path): + raise FileNotFoundError( + "ccf_annotation_to_template_moved_path not exist, please provide valid path" + ) # ---------------------------------------------------# + example_input = { # "input_data": "../data/fused", # TODO "input_data": input_data, From 72df33c37982668fecbb18fb4855e75def7e824e Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Mon, 3 Jun 2024 20:38:40 +0000 Subject: [PATCH 13/15] update template_based_ccf_registration.md --- code/template_based_ccf_registration.md | 81 +++++++++++++++---------- 1 file changed, 49 insertions(+), 32 deletions(-) diff --git a/code/template_based_ccf_registration.md b/code/template_based_ccf_registration.md index 3ada8a2..e9777e7 100644 --- a/code/template_based_ccf_registration.md +++ b/code/template_based_ccf_registration.md @@ -1,54 +1,71 @@ # Template-based smartspim-ccf registration -This capsule is used to register SmartSPIM datasets to CCF Allen Atlas via SPIM template at 25 um. +This capsule is used to register SmartSPIM datasets to CCF Allen Atlas via the SPIM template at 25 um. `main.py` is compatible with the `aind-smartspim-pipeline`. -`main_register_dataset.py` is used to regsiter a stitched testing dataset. It assumes that the fused image comes in OME-Zarr format with different multiscales. At this point, we are using the 3rd multiscale from the original resolution for registration. -Workflow of template-based smartSPIM CCF registration: +## Workflow +The workflow of the template-based smartSPIM-CCF registration: 1. preprocessing - - resample the raw image to isotropic to have the same resolution as the SPIM template. - - masking, using Li thresholding to segment ROI - - N4 bias correction - - intensity normalization, using 2nd and 98th percentile normalization -2. register the resulting preprocessed image from step 1 to the SPIM template using ANTs (rigid + SyN). By default, the highest channel will be used for registration. -3. register the resulting moved image from step 2 to the CCF Allen Atlas using the template-to-CCF transforms computed by Yoni. + - resample the raw image to isotropic to have the same resolution as the SPIM template. + - masking, using Li thresholding to segment ROI. + - N4 bias correction. + - intensity normalization, using 2nd and 98th percentile normalization. +2. register the resulting preprocessed image from step 1 to the SPIM template using ANTs (rigid + SyN). +3. register the resulting moved image from step 2 to the CCF Allen Atlas using the [template-to-CCF transforms](https://codeocean.allenneuraldynamics.org/data-assets/97d978ca-f328-49e0-ae6d-3e4544afcf02/lightsheet_template_ccf_registration?filters=N4IgZglgNgLgpgJxALhAQylEAaEBHAV0QE8UR4BbAByjXgFoYB7HEAZyYRjIGME46cACashcNjxQwERXFTQBzOCgCMcxAAVFy5ACYADLjRCAbmgB2PYSmABfXObQUdIKBAUALGGw9w4MAH1KGkEAnh4wAP4FCDZpOggmc1FxPggqGETk1AAROjQAAjBOAuDaBgAjNDZhAoBhOoAxAujY%2BMykgroC3QBWAoIKbAKISygCIVGFAoBlCjQuGY0ASQBZAoAVOGpyuAKTAGYAOhVDeqbhiyFShAs2YoQKNlKPbox3c1LtkPhSpnPGpdzNcGs0LOYmDAEp1Rl8doICmx5FYjgAdZK4KEKNgoADaIHCYBAAF1cABrUYiVBCfI1bi4NgQABeOlOugAHL0AGzsgDsvN0uEgUHEKF6uBpULpOOQuNAECpICEvTAAE40GgwLz6Gh2TxdPQACxaw30VW9MT0FQHODsrloODmh2q1iZGAishzBYwJZrTbfXb7Y6nTb-UEFABKcBicVuHU%2BBEZ5mm83MBAwBVoFTgUGe3T6AwoR391E4C2I%2B0QjKSAG4CgB3aBQArZlpwEJWIRHVgUJgEczcVBIiAUIIB0LMMIRFIi%2BBUsAYGr2eWKg76Cpgdfhehcw1c7WGiqG1U6lT809oFSG3TGsAqMBc10Qd0uL2LFbrAAydQAgiWfnshwnPoIyfBQFADOYz55jABQUAQsDpCKbYcOM8Y4rgvb9oO7DzFww6jlAPBoGO8LwDO-jWMgC65nAy4gAqZC8qqG6qvoBwGr0ERgEa7HsvQFS6BU-HsmgN4LvoqrsnABwVE%2BL5kD%2BmBwJ8qx9jU9RMOBnR1EwnCTI4vyNLczj1pwZIFAAFMsA6II4UAAJQ9n2A5kBgIrmAEWE1FORISjmlHzoudHYCuZD6A%2BPAqKqXI8PQ7EHGgRo8PaOqctqmrcmucC6LoaDcvJHqoG%2BPofgEPK9CoVUBAYugHPFJ4cgEKj8dFVr6AEcTPjwvhCDV%2Bg3vFKhWiozX6FaXJGoaznYZ6eGlWs5WclVo21fVkn0E1LVWiepydW6PXCP1g36MN1WnBNU0UXOKA0UuoUMYqKgVLyxqvRUAkVPo42HvlaVcpNvS8jwhqnIaNKqpuhWvvNvqrOVqqGpVBzHetJ5rgE33xfVLX7d1vXHaap0jWNVq9JtBwza5xWw2VXKI8jqMNfQGNY%2BxVrsnjMCHX1tVE2do0XSo5N1ddVF3SFYWoDwQhgGIPAHPxcBcgIRrslU9DsoaINmnyGpgL05rsrofnkM%2BRUgCVcMBLykkHKqq0Dfz8WcwYRrk2eXM84TQ0k8LassyoVM4VbZW26q9uOydw36K7P0e7yXsE3zvvneThr8QcQf%2BbO4vBfRjGoCq%2BjKsr43mr0BrHuyw26iocUqEIvLspJvJwPX7KU5i5sw961u8qcXJ9D77O6KqpO5Zto1ddzydO9jLMdZP22nMHc192Hg-Dyno-jxdk%2B6NPB1zyd9UY8vrX6GLQW0QXipwAbvJy2gcXMS3au6EImu2%2BN%2Bj08YYBNxwB4PoSQ3cFI0w3otemWcYpMw2k1OqVoDS5STkdHeAsJ4416GvSB75oER2ilyeBjVXY4xQboNBvN57E3OuNJBwtr63Xzg9Qu6BegVCEPTKw9AhA13jilU8d5NZcn0KDNi%2BpeSXmhuvfB8MYHRUTmtZmY9MYe34r0DqM9vYYL9jjQGV9MIuRDrTAhsClEDTRptce%2Bh1H0E0VQkemDrSXU0Uw6iLCpYgGPMIXoHFtRgAOAKI0XCDR634sRHgFpVQcisE-GReCFrwwFN9fcI9TTDxUJNNquhE7aJPkTD2vRmoGiyUaF0RjZqJP7gYP%2BFiToZOKWUnJeTj7oJoUUkpl1jzuIlnfMgqoeBt0NAcGk39toZ2BprK8tcKhcgXOyaSYBDQ9PARbUOi0B7sjYoadJm1E60JPIbRxO8Mmcz-gvU6uDLamOSS1HZezcmYzOkc8e%2BT2kNM2ucya7Mrk50Csw2%2BrDFQChbsJEBmtQEHn5GEoSw1NFcg4mAOqzFkUJJuVA5JN5hZR0KWTZ58V6HEPedQk6HtiFu16PxQ%2B1yNlYtBpVEenTiZY10MStppK8VZP6vY6l2clQBRuh4oFXjFZ9HVlrXhQgglGgHvVNAhoplwCqCA3khsOQv3RXSm22LK5MvxbYlmpphYnI6VaA5pTyZZ1pbcnVDLKE72ZVa41xSSX6s9gNMmgdemeMemQZVwD9AyQNIjG0yV2Rf3NKAkJvIuRHgOEPFiugtW2oFJXAe%2BrUFnk2kTdl%2BMPl4tUVVFm5MqU2sxTq9NuL4oi0odmk6ebZ4FprdY5qw0DilvZD6kVfrUBsTgH4605MW4D3KUgmKKt7ESSEEGoQqpgGPjWb3ORNtrSqlepmzmbUZXWnLSuuV67dmOq%2Bc1dG2pd3-KFX04FZAeRWFVHw002sWLu2LQqrkw1FX7g1Jw3Q%2BpTZunWamq8iLik7xxlun6B4u2VOphi-dIGO0jwg6TRVatu33S8WgZuiMNzkz-vOo0jpTQRsAfYw0Don7sX1DaFNFaB57iQ%2BBjmqHoOmtPiesRRoz4VJAFhOD2qGOgeQyxi6aGM7saJvVJqXGRks142IXON8lykhAFQRAFBYjVnMDKUACweoQBMDoaQsgQDCGfFIGQcAGSvH4JZ0zJgIBwHrPZ6zIBHPOZmLZ4zVn7DsChORVAkB7KsCYPWcwiBliKmkmJPK0qdxng%2BoeC6UlP4CVOI3Xkis0APpELgMLEWEAADknAuByBAAoAB1CwChWB8AEHOH8g4zxnlSZ3XkRw6pZ0ReyXAVQagAFUEBYFQF4GAVA2DIAAPRTZ4EwMQTArAWCOO5FSEWCC3CgEIYgjhNM8DYEcTgCgpuSmqP4NgU2Yu5WMPVD9vIksVBS8bL%2Bj3TpN2y7lqb6653N2IvQQJHJylwHGg6LkX8bRIxWZqCIA06toAmwhOAUWyDskAWgV7cVuRSJCSXASIMkpCBUAOu00r5nqzhwjkUGxiDqbIEmBQHpcDEUp3AGY4xauoDPJorJ-LmdsERyV5wblKT0DYPNAi9BCT0FaLGaEnx6BwgAgJM7X9oh1a0lQAgAWsjI9QLqe73Isb3YikaBVw1FmBM2oAxGXJK69E0cmpn8P%2BcijYAN%2Bnqg5DpBzKMcQ7uphilwJSOAAAPGYAWXBzZ2AC3AtA4g2TECHqiLWf48mPEcPxfJcninQDwTIRmADy4Wqx4i8VduLt3EtGle7rNLr3MsfaEHlkAu2ysVeq8mVg2w0DQDIJMI49YasAAFVtQR026LXcBDsIFq7YVToxNcwDyFCUvvalQqnVJqDKeoq4mjNBaOAVobR2mdL0Z0dG5H-kDEBEMGwwxNEjNGNocYsgDHp3BCw6ZmxZhzDBHo-RBhiwthSxbgEAKwjMEBtM6xGxMAWw9h%2BAOxhBuxYMcICJSIAIggmBfIMNJY181wNwtw4pdx9xq9jxTxzxLxLxrxbx7xF0zYIF4MkkChvw-xgCAIgxgJQI4IIJ%2BxoIuhYJ4JEIaB4DxAmA0IsgMI%2BNjE6dxcqARwAgiISIyhBAcD%2BlUBmJWJ2JOJuJeJFYBIhIRIxJjQ0BJJpJZJ0UlIPICg1JEw9hdJtJPhdJ9JRgERjJSszIEALJrJbIEB7InIUC3JlJPJvI4BsDL084e02EIpYoiE4oEokptZUpdQgYdQDZEUg1rsCol1ZEkklpKpqplEEEt1WpdotEOUnE-ZxoykVk91ciKoVoSET0V5SjJNU5BYqjJoajwjlNcC2FnpXoTQPoKgvofoqhyZdQAZ7FgZQYxEIYoZsjqk6YGZrRGjWZf4UM3VdE6EvVRYAjFiCEkYVjCj0YOo2YNjyitj2idiu4BUlNAVMM18ZY5ZgE9DlZVYM4NYtYdYpIpFMojYTYL9cjw5I4KjY4eUkZzVWjaFBZ05M5%2BV%2BMTF6M7YHZQS453ZITNiaFnFYTvVuj7jejFRi5S5RF99K5yka40p64rQm4W51124eBO5AT%2B4t4wMaFpM956EUEj581OUF5z5SlL5ajmS-5t42TW194uSoSz4l4BT2pVCb1UAH4gZn5X4pIfpntv42Z-5ZYgEQEwF6CgMK0FE4FjiT0GEKEoTnF6FsEhSljYEKVLEVEyFkFNpKFMTo5KiKYyZ5SsMOEuFBlD8%2BExMuJJpLxhE7QxFopQFclpEFjGDrZjT6krFVFDVtoHF3TnZzp9F7FDEpCql4y7TFFGiUy7F0yLisS9FXFczFMAVhUHi2EfFlR-F-sgkq5Qlv5dRJcX5olYk4B4k4zBNak0lTlNomlslGpWkeT3UmlSlOjeMEScialUl6kiZGlmpxz9koTOkVBZzykfS19BlhlRkko%2BQJk%2BQ4oa5QYdQ5kFklkVleNANl0gT7kxFHkDkXl7E3lyzPkZMfl1p4TpD9i7ltlXyRynlDlPyoSzlMY-yhp9y2FQV1w9RxoW4hlZVgljZHsczEUTYUVIZHcDSnyakGVq1UzikWUiUtyJoeUqUp5bTNldVSLmUY5KKMyW1uVKU%2BV4LVxjYqVhJTQm8ZVFUXEFUlUVV9A1UYlRJ9THzFyw5dUHUzUTVDUDgXUqKPVLVcS8yBNU0FLpy1EjV8U2LUyLUvVrU8S6yCT-VswQFg0zQRlD9tYI199o1wZY141E1BImT5Kq1M061tQG0qKi121O16KsVfLj0s0Arc0gq94QreVuKBkg1B0O1IVR1jxx0AZD8VQTCZ1hB50UpvLNk10N1Iqt0z0j8wrV17ZSqzUtoKqL1bjazr0vE71HRH1koX1Dja49xP1Y1fjf1-0iq7lGNWSONcYxNoMqqhMmMxSJqoN0MLKWq19sNtlDwDZ4p6ZHLiNNYdTyNKNNwDgaNlABzgNRqRN5rZU1YpTOMn0eNprEMxqpNRMFqJNjLpNzk7r5NVDVN6tBAhAmtPx0ccwyBVg0AKwx5hg%2BYCgqo9Bcy48YAE9Q9hAgbswRsQAwaIbVQoanYYaVA4bWBGQWRUaQa%2B0W4jgHZrCAAhVgWIZfM7QcEzOiIAA) computed by Yoni. + +This [Code Ocean data asset](https://codeocean.allenneuraldynamics.org/data-assets/97d978ca-f328-49e0-ae6d-3e4544afcf02/lightsheet_template_ccf_registration?filters=N4IgZglgNgLgpgJxALhAQylEAaEBHAV0QE8UR4BbAByjXgFoYB7HEAZyYRjIGME46cACashcNjxQwERXFTQBzOCgCMcxAAVFy5ACYADLjRCAbmgB2PYSmABfXObQUdIKBAUALGGw9w4MAH1KGkEAnh4wAP4FCDZpOggmc1FxPggqGETk1AAROjQAAjBOAuDaBgAjNDZhAoBhOoAxAujY%2BMykgroC3QBWAoIKbAKISygCIVGFAoBlCjQuGY0ASQBZAoAVOGpyuAKTAGYAOhVDeqbhiyFShAs2YoQKNlKPbox3c1LtkPhSpnPGpdzNcGs0LOYmDAEp1Rl8doICmx5FYjgAdZK4KEKNgoADaIHCYBAAF1cABrUYiVBCfI1bi4NgQABeOlOugAHL0AGzsgDsvN0uEgUHEKF6uBpULpOOQuNAECpICEvTAAE40GgwLz6Gh2TxdPQACxaw30VW9MT0FQHODsrloODmh2q1iZGAishzBYwJZrTbfXb7Y6nTb-UEFABKcBicVuHU%2BBEZ5mm83MBAwBVoFTgUGe3T6AwoR391E4C2I%2B0QjKSAG4CgB3aBQArZlpwEJWIRHVgUJgEczcVBIiAUIIB0LMMIRFIi%2BBUsAYGr2eWKg76Cpgdfhehcw1c7WGiqG1U6lT809oFSG3TGsAqMBc10Qd0uL2LFbrAAydQAgiWfnshwnPoIyfBQFADOYz55jABQUAQsDpCKbYcOM8Y4rgvb9oO7DzFww6jlAPBoGO8LwDO-jWMgC65nAy4gAqZC8qqG6qvoBwGr0ERgEa7HsvQFS6BU-HsmgN4LvoqrsnABwVE%2BL5kD%2BmBwJ8qx9jU9RMOBnR1EwnCTI4vyNLczj1pwZIFAAFMsA6II4UAAJQ9n2A5kBgIrmAEWE1FORISjmlHzoudHYCuZD6A%2BPAqKqXI8PQ7EHGgRo8PaOqctqmrcmucC6LoaDcvJHqoG%2BPofgEPK9CoVUBAYugHPFJ4cgEKj8dFVr6AEcTPjwvhCDV%2Bg3vFKhWiozX6FaXJGoaznYZ6eGlWs5WclVo21fVkn0E1LVWiepydW6PXCP1g36MN1WnBNU0UXOKA0UuoUMYqKgVLyxqvRUAkVPo42HvlaVcpNvS8jwhqnIaNKqpuhWvvNvqrOVqqGpVBzHetJ5rgE33xfVLX7d1vXHaap0jWNVq9JtBwza5xWw2VXKI8jqMNfQGNY%2BxVrsnjMCHX1tVE2do0XSo5N1ddVF3SFYWoDwQhgGIPAHPxcBcgIRrslU9DsoaINmnyGpgL05rsrofnkM%2BRUgCVcMBLykkHKqq0Dfz8WcwYRrk2eXM84TQ0k8LassyoVM4VbZW26q9uOydw36K7P0e7yXsE3zvvneThr8QcQf%2BbO4vBfRjGoCq%2BjKsr43mr0BrHuyw26iocUqEIvLspJvJwPX7KU5i5sw961u8qcXJ9D77O6KqpO5Zto1ddzydO9jLMdZP22nMHc192Hg-Dyno-jxdk%2B6NPB1zyd9UY8vrX6GLQW0QXipwAbvJy2gcXMS3au6EImu2%2BN%2Bj08YYBNxwB4PoSQ3cFI0w3otemWcYpMw2k1OqVoDS5STkdHeAsJ4416GvSB75oER2ilyeBjVXY4xQboNBvN57E3OuNJBwtr63Xzg9Qu6BegVCEPTKw9AhA13jilU8d5NZcn0KDNi%2BpeSXmhuvfB8MYHRUTmtZmY9MYe34r0DqM9vYYL9jjQGV9MIuRDrTAhsClEDTRptce%2Bh1H0E0VQkemDrSXU0Uw6iLCpYgGPMIXoHFtRgAOAKI0XCDR634sRHgFpVQcisE-GReCFrwwFN9fcI9TTDxUJNNquhE7aJPkTD2vRmoGiyUaF0RjZqJP7gYP%2BFiToZOKWUnJeTj7oJoUUkpl1jzuIlnfMgqoeBt0NAcGk39toZ2BprK8tcKhcgXOyaSYBDQ9PARbUOi0B7sjYoadJm1E60JPIbRxO8Mmcz-gvU6uDLamOSS1HZezcmYzOkc8e%2BT2kNM2ucya7Mrk50Csw2%2BrDFQChbsJEBmtQEHn5GEoSw1NFcg4mAOqzFkUJJuVA5JN5hZR0KWTZ58V6HEPedQk6HtiFu16PxQ%2B1yNlYtBpVEenTiZY10MStppK8VZP6vY6l2clQBRuh4oFXjFZ9HVlrXhQgglGgHvVNAhoplwCqCA3khsOQv3RXSm22LK5MvxbYlmpphYnI6VaA5pTyZZ1pbcnVDLKE72ZVa41xSSX6s9gNMmgdemeMemQZVwD9AyQNIjG0yV2Rf3NKAkJvIuRHgOEPFiugtW2oFJXAe%2BrUFnk2kTdl%2BMPl4tUVVFm5MqU2sxTq9NuL4oi0odmk6ebZ4FprdY5qw0DilvZD6kVfrUBsTgH4605MW4D3KUgmKKt7ESSEEGoQqpgGPjWb3ORNtrSqlepmzmbUZXWnLSuuV67dmOq%2Bc1dG2pd3-KFX04FZAeRWFVHw002sWLu2LQqrkw1FX7g1Jw3Q%2BpTZunWamq8iLik7xxlun6B4u2VOphi-dIGO0jwg6TRVatu33S8WgZuiMNzkz-vOo0jpTQRsAfYw0Don7sX1DaFNFaB57iQ%2BBjmqHoOmtPiesRRoz4VJAFhOD2qGOgeQyxi6aGM7saJvVJqXGRks142IXON8lykhAFQRAFBYjVnMDKUACweoQBMDoaQsgQDCGfFIGQcAGSvH4JZ0zJgIBwHrPZ6zIBHPOZmLZ4zVn7DsChORVAkB7KsCYPWcwiBliKmkmJPK0qdxng%2BoeC6UlP4CVOI3Xkis0APpELgMLEWEAADknAuByBAAoAB1CwChWB8AEHOH8g4zxnlSZ3XkRw6pZ0ReyXAVQagAFUEBYFQF4GAVA2DIAAPRTZ4EwMQTArAWCOO5FSEWCC3CgEIYgjhNM8DYEcTgCgpuSmqP4NgU2Yu5WMPVD9vIksVBS8bL%2Bj3TpN2y7lqb6653N2IvQQJHJylwHGg6LkX8bRIxWZqCIA06toAmwhOAUWyDskAWgV7cVuRSJCSXASIMkpCBUAOu00r5nqzhwjkUGxiDqbIEmBQHpcDEUp3AGY4xauoDPJorJ-LmdsERyV5wblKT0DYPNAi9BCT0FaLGaEnx6BwgAgJM7X9oh1a0lQAgAWsjI9QLqe73Isb3YikaBVw1FmBM2oAxGXJK69E0cmpn8P%2BcijYAN%2Bnqg5DpBzKMcQ7uphilwJSOAAAPGYAWXBzZ2AC3AtA4g2TECHqiLWf48mPEcPxfJcninQDwTIRmADy4Wqx4i8VduLt3EtGle7rNLr3MsfaEHlkAu2ysVeq8mVg2w0DQDIJMI49YasAAFVtQR026LXcBDsIFq7YVToxNcwDyFCUvvalQqnVJqDKeoq4mjNBaOAVobR2mdL0Z0dG5H-kDEBEMGwwxNEjNGNocYsgDHp3BCw6ZmxZhzDBHo-RBhiwthSxbgEAKwjMEBtM6xGxMAWw9h%2BAOxhBuxYMcICJSIAIggmBfIMNJY181wNwtw4pdx9xq9jxTxzxLxLxrxbx7xF0zYIF4MkkChvw-xgCAIgxgJQI4IIJ%2BxoIuhYJ4JEIaB4DxAmA0IsgMI%2BNjE6dxcqARwAgiISIyhBAcD%2BlUBmJWJ2JOJuJeJFYBIhIRIxJjQ0BJJpJZJ0UlIPICg1JEw9hdJtJPhdJ9JRgERjJSszIEALJrJbIEB7InIUC3JlJPJvI4BsDL084e02EIpYoiE4oEokptZUpdQgYdQDZEUg1rsCol1ZEkklpKpqplEEEt1WpdotEOUnE-ZxoykVk91ciKoVoSET0V5SjJNU5BYqjJoajwjlNcC2FnpXoTQPoKgvofoqhyZdQAZ7FgZQYxEIYoZsjqk6YGZrRGjWZf4UM3VdE6EvVRYAjFiCEkYVjCj0YOo2YNjyitj2idiu4BUlNAVMM18ZY5ZgE9DlZVYM4NYtYdYpIpFMojYTYL9cjw5I4KjY4eUkZzVWjaFBZ05M5%2BV%2BMTF6M7YHZQS453ZITNiaFnFYTvVuj7jejFRi5S5RF99K5yka40p64rQm4W51124eBO5AT%2B4t4wMaFpM956EUEj581OUF5z5SlL5ajmS-5t42TW194uSoSz4l4BT2pVCb1UAH4gZn5X4pIfpntv42Z-5ZYgEQEwF6CgMK0FE4FjiT0GEKEoTnF6FsEhSljYEKVLEVEyFkFNpKFMTo5KiKYyZ5SsMOEuFBlD8%2BExMuJJpLxhE7QxFopQFclpEFjGDrZjT6krFVFDVtoHF3TnZzp9F7FDEpCql4y7TFFGiUy7F0yLisS9FXFczFMAVhUHi2EfFlR-F-sgkq5Qlv5dRJcX5olYk4B4k4zBNak0lTlNomlslGpWkeT3UmlSlOjeMEScialUl6kiZGlmpxz9koTOkVBZzykfS19BlhlRkko%2BQJk%2BQ4oa5QYdQ5kFklkVleNANl0gT7kxFHkDkXl7E3lyzPkZMfl1p4TpD9i7ltlXyRynlDlPyoSzlMY-yhp9y2FQV1w9RxoW4hlZVgljZHsczEUTYUVIZHcDSnyakGVq1UzikWUiUtyJoeUqUp5bTNldVSLmUY5KKMyW1uVKU%2BV4LVxjYqVhJTQm8ZVFUXEFUlUVV9A1UYlRJ9THzFyw5dUHUzUTVDUDgXUqKPVLVcS8yBNU0FLpy1EjV8U2LUyLUvVrU8S6yCT-VswQFg0zQRlD9tYI199o1wZY141E1BImT5Kq1M061tQG0qKi121O16KsVfLj0s0Arc0gq94QreVuKBkg1B0O1IVR1jxx0AZD8VQTCZ1hB50UpvLNk10N1Iqt0z0j8wrV17ZSqzUtoKqL1bjazr0vE71HRH1koX1Dja49xP1Y1fjf1-0iq7lGNWSONcYxNoMqqhMmMxSJqoN0MLKWq19sNtlDwDZ4p6ZHLiNNYdTyNKNNwDgaNlABzgNRqRN5rZU1YpTOMn0eNprEMxqpNRMFqJNjLpNzk7r5NVDVN6tBAhAmtPx0ccwyBVg0AKwx5hg%2BYCgqo9Bcy48YAE9Q9hAgbswRsQAwaIbVQoanYYaVA4bWBGQWRUaQa%2B0W4jgHZrCAAhVgWIZfM7QcEzOiIAA) contains data for computing template-based CCF registration at 25 um, including +- `smartspim_lca_template_25.nii.gz`: SmartSPIM Template v3.10, +- `ccf_average_template_25.nii.gz`: CCF Allen Atlas, +- `spim_template_to_ccf_syn_1Warp.nii.gz` and `spim_template_to_ccf_syn_0GenericAffine.mat`: transforms that align template to CCF, +- `ccf_annotation_to_template_moved.nii.gz`: CCF annotation warped to template space. +The dimension of SPIM template is `576*648*440`. The dimension of CCF Atlas is `528*320*456`. The resolution of SPIM template and CCF is `0.025*0.025*0.025` mm. + + ## Output directory structure of registration After running main.py given one testing dataset, a directory will be created with the following structure ```console - /path/to/outputs/registration/ - ├── prep_*.nii.gz - ├── prep_*.png - ├── moved_rigid.nii.gz - ├── moved_ls_to_template.nii.gz + /path/to/outputs/ ├── moved_ls_to_ccf.nii.gz - ├── moved_ccf_anno_to_ls.nii.gz - ├── moved_*.png - ├── reg_*.png - └── ls_to_template_SyN* -``` -1. `prep_*.nii.gz`: the intermediate images in preprocessing steps, `prep_*.png` are the corresponding plots. -2. `moved_rigid.nii.gz`: the preprocessed brain image was aligned to the SPIM template using rigid registration. -3. `moved_ls_to_template.nii.gz`: the resulting image 2 was aligned to the SPIM template using SyN registration. -4. `moved_ls_to_ccf.nii.gz`: the resulting image 3 was aligned to the CCF using the template-to-CCF transforms computed by Yoni. -5. `moved_ccf_anno_to_ls.nii.gz`: the CCF annotation was aligned to the sample space. -6. `moved_*.png`: visualize the deformed images 2, 3, 4, 5. -7. `reg_*.png`: visualize the registration results for 2, 3, 4. -8. `ls_to_template_SyN*`: the transforms that align the preprocessed brain image to the SPIM template. - -By default, the output file is for the channel-to-register (highest channel) if the file name does not contain the channel info. - - -## Running time + ├── moved_ls_to_ccf.png + ├── ls_to_template_SyN_0GenericAffine.mat + ├── ls_to_template_SyN_1Warp.nii.gz + ├── ls_to_template_SyN_1InverseWarp.nii.gz + └── registration_metadata/ + ├── prep_*.nii.gz + ├── prep_*.png + ├── moved_rigid.nii.gz + ├── moved_ls_to_template.nii.gz + ├── moved_ccf_anno_to_ls.nii.gz + ├── moved_*.png + └── reg_*.png +``` +* `/path/to/outputs/` was defined as `ccf_`. +* `moved_ls_to_ccf.nii.gz`: the preprocessed lightsheet volume warped to space of CCF atlas. `moved_ls_to_ccf.png` is the corresponding plot. +* `ls_to_template_SyN_1Warp.nii.gz` and `ls_to_template_SyN_0GenericAffine.mat`: transforms to move from the lightsheet volume to the SPIM template. +* `ls_to_template_SyN_0GenericAffine.mat` and `ls_to_template_SyN_1InverseWarp.nii.gz`: transforms to move from the SPIM template to the lightsheet volume. +* `/path/to/outputs/registration_metadata/`: folder to save derivative images for registration. + 1. `prep_*.nii.gz`: the intermediate images in preprocessing steps, `prep_*.png` are the corresponding plots. + 2. `moved_rigid.nii.gz`: the lightsheet volume aligned to space of SPIM template after rigid registration. + 3. `moved_ls_to_template.nii.gz`: the resulting image from 2 aligned to the SPIM template after SyN registration. + 4. `moved_ccf_anno_to_ls.nii.gz`: the CCF annotation was aligned to the sample space. + 5. `moved_*.png`: visualize the deformed images 2, 3, 4. + 6. `reg_*.png`: visualize the registration results for lightsheet-to-template-to-CCF tasks. + +### Running time From Camilo's NFS 2024 abstract: ```console From 5e73469362ab69039245e53100be7ca7eb0da729 Mon Sep 17 00:00:00 2001 From: Di-Wang-AIND Date: Wed, 5 Jun 2024 00:27:27 +0000 Subject: [PATCH 14/15] add unit tests --- code/aind_ccf_reg/configs.py | 4 +- code/aind_ccf_reg/preprocess.py | 1 + code/aind_ccf_reg/register.py | 65 ++++++------- code/aind_ccf_reg/utils.py | 95 ++++++++++++------- code/main.py | 101 +------------------- code/main_register_dataset.py | 104 +------------------- code/template_based_ccf_registration.md | 3 +- code/tests/test_ccf_registration.py | 15 --- {code/tests => tests}/__init__.py | 0 tests/test_ccf_registration.py | 121 ++++++++++++++++++++++++ 10 files changed, 225 insertions(+), 284 deletions(-) delete mode 100644 code/tests/test_ccf_registration.py rename {code/tests => tests}/__init__.py (100%) create mode 100644 tests/test_ccf_registration.py diff --git a/code/aind_ccf_reg/configs.py b/code/aind_ccf_reg/configs.py index 85e334b..e968c6f 100644 --- a/code/aind_ccf_reg/configs.py +++ b/code/aind_ccf_reg/configs.py @@ -6,7 +6,7 @@ from pathlib import Path from typing import Union -import dask +import dask.array as da import numpy as np from argschema import ArgSchema from argschema.fields import Dict as sch_dict @@ -15,7 +15,7 @@ from argschema.fields import Str PathLike = Union[str, Path] -ArrayLike = Union[dask.array.core.Array, np.ndarray] +ArrayLike = Union[da.core.Array, np.ndarray] VMIN = 0 VMAX = 1.5 diff --git a/code/aind_ccf_reg/preprocess.py b/code/aind_ccf_reg/preprocess.py index edcaa61..1f8d037 100644 --- a/code/aind_ccf_reg/preprocess.py +++ b/code/aind_ccf_reg/preprocess.py @@ -37,6 +37,7 @@ def perc_normalization( """ percentiles = [lower_perc, upper_perc] percentile_values = np.percentile(ants_img.view(), percentiles) + assert percentile_values[1] > percentile_values[0] ants_img = (ants_img - percentile_values[0]) / ( percentile_values[1] - percentile_values[0] ) diff --git a/code/aind_ccf_reg/register.py b/code/aind_ccf_reg/register.py index 3913a07..ccb1c11 100644 --- a/code/aind_ccf_reg/register.py +++ b/code/aind_ccf_reg/register.py @@ -205,35 +205,36 @@ def _qc_reg( figpath name """ # plot moving, fixed, moved, overlaid, difference images in three directions - figpath = f"{self.args['reg_folder']}/{figpath_name}" - logger.info(f"Plot registration results: {figpath}") - - if np.any(ants_moving.direction != ants_fixed.direction): - logger.info( - f"Reorient moving image direction to fixed image direction ..." - ) - ants_moving = ants.reorient_image2( - ants_moving, orientation=ants.get_orientation(ants_fixed) - ) - logger.info(f"Reoriented moving image -- {ants_moving}") - - for loc in [0, 1, 2]: - plot_args = ( - ants_moving, - ants_fixed, - ants_moved, - f"{figpath}_{loc}", - ) - plot_kwargs = { - "title": figpath_name, - "loc": loc, - "vmin": VMIN, - "vmax": VMAX, - } - - plot_reg(*plot_args, **plot_kwargs) - - self._plot_write_antsimg(ants_moved, moved_path) + if figpath_name: + figpath = f"{self.args['reg_folder']}/{figpath_name}" + logger.info(f"Plot registration results: {figpath}") + + if np.any(ants_moving.direction != ants_fixed.direction): + logger.info( + f"Reorient moving image direction to fixed image direction ..." + ) + ants_moving = ants.reorient_image2( + ants_moving, orientation=ants.get_orientation(ants_fixed) + ) + logger.info(f"Reoriented moving image -- {ants_moving}") + + for loc in [0, 1, 2]: + plot_args = ( + ants_moving, + ants_fixed, + ants_moved, + f"{figpath}_{loc}", + ) + plot_kwargs = { + "title": figpath_name, + "loc": loc, + "vmin": VMIN, + "vmax": VMAX, + } + plot_reg(*plot_args, **plot_kwargs) + + if moved_path: + self._plot_write_antsimg(ants_moved, moved_path) def register_to_template(self, ants_fixed, ants_moving): """ @@ -287,7 +288,7 @@ def register_to_template(self, ants_fixed, ants_moving): ants_moving, ants_fixed, ants_moved, - moved_path=self.args["ants_params"]["rigid_path"], + moved_path=self.args["ants_params"].get("rigid_path"), figpath_name=reg_task, ) @@ -334,7 +335,7 @@ def register_to_template(self, ants_fixed, ants_moving): ants_moving, ants_fixed, ants_moved, - moved_path=self.args["ants_params"]["moved_to_template_path"], + moved_path=self.args["ants_params"].get("moved_to_template_path"), figpath_name=reg_task, ) @@ -381,7 +382,7 @@ def register_to_ccf(self, ants_fixed, ants_moving): ants_moving, ants_fixed, ants_moved, - moved_path=self.args["ants_params"]["moved_to_ccf_path"], + moved_path=self.args["ants_params"].get("moved_to_ccf_path"), figpath_name=reg_task, ) diff --git a/code/aind_ccf_reg/utils.py b/code/aind_ccf_reg/utils.py index 948f49b..9c64839 100644 --- a/code/aind_ccf_reg/utils.py +++ b/code/aind_ccf_reg/utils.py @@ -2,6 +2,7 @@ File for utilities """ +import json import logging import multiprocessing import os @@ -20,50 +21,24 @@ Processing) -def create_folder(dest_dir: PathLike, verbose: Optional[bool] = False) -> None: - """ - Create new folders. - Parameters - ------------------------ - dest_dir: PathLike - Path where the folder will be created if it does not exist. - verbose: Optional[bool] - If we want to show information about the folder status. Default False. - Raises - ------------------------ - OSError: - if the folder exists. - """ - - if not (os.path.exists(dest_dir)): - try: - if verbose: - print(f"Creating new directory: {dest_dir}") - os.makedirs(dest_dir) - except OSError as e: - if e.errno != os.errno.EEXIST: - raise - - def create_logger(output_log_path: PathLike) -> logging.Logger: """ - Creates a logger that generates - output logs to a specific path. + Creates a logger that generates output logs to a specific path. Parameters ------------ output_log_path: PathLike - Path where the log is going - to be stored + Path where the log is going to be stored Returns ----------- logging.Logger - Created logger pointing to - the file path. + Created logger + pointing to the file path. """ CURR_DATE_TIME = datetime.now().strftime("%Y-%m-%d-%H-%M-%S") - LOGS_FILE = f"{output_log_path}/fusion_log_{CURR_DATE_TIME}.log" + + LOGS_FILE = f"{output_log_path}/register_process.log" logging.basicConfig( level=logging.DEBUG, @@ -76,13 +51,67 @@ def create_logger(output_log_path: PathLike) -> logging.Logger: force=True, ) - logging.disable("DEBUG") + # logging.disable("DEBUG") + logging.disable(logging.DEBUG) logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) + logger.info(f"Execution datetime: {CURR_DATE_TIME}") return logger +def read_json_as_dict(filepath: str) -> dict: + """ + Reads a json as dictionary. + + Parameters + ------------------------ + + filepath: PathLike + Path where the json is located. + + Returns + ------------------------ + + dict: + Dictionary with the data the json has. + + """ + + dictionary = {} + + if os.path.exists(filepath): + with open(filepath) as json_file: + dictionary = json.load(json_file) + + return dictionary + + +def create_folder(dest_dir: PathLike, verbose: Optional[bool] = False) -> None: + """ + Create new folders. + Parameters + ------------------------ + dest_dir: PathLike + Path where the folder will be created if it does not exist. + verbose: Optional[bool] + If we want to show information about the folder status. Default False. + Raises + ------------------------ + OSError: + if the folder exists. + """ + + if not (os.path.exists(dest_dir)): + try: + if verbose: + print(f"Creating new directory: {dest_dir}") + os.makedirs(dest_dir) + except OSError as e: + if e.errno != os.errno.EEXIST: + raise + + def read_json_from_pydantic( path: PathLike, pydantic_class ) -> pydantic.BaseModel: diff --git a/code/main.py b/code/main.py index cd75d0c..bc3abca 100644 --- a/code/main.py +++ b/code/main.py @@ -3,7 +3,6 @@ """ import glob -import json import logging import multiprocessing import os @@ -12,108 +11,10 @@ from aind_ccf_reg import register, utils from aind_ccf_reg.configs import PathLike -from aind_ccf_reg.utils import create_folder +from aind_ccf_reg.utils import create_folder, create_logger, read_json_as_dict from natsort import natsorted -def create_logger(output_log_path: PathLike) -> logging.Logger: - """ - Creates a logger that generates output logs to a specific path. - - Parameters - ------------ - output_log_path: PathLike - Path where the log is going to be stored - - Returns - ----------- - logging.Logger - Created logger - pointing to the file path. - """ - CURR_DATE_TIME = datetime.now().strftime("%Y-%m-%d-%H-%M-%S") - - LOGS_FILE = f"{output_log_path}/register_process.log" - - logging.basicConfig( - level=logging.DEBUG, - format="%(asctime)s - %(levelname)s : %(message)s", - datefmt="%Y-%m-%d %H:%M", - handlers=[ - logging.StreamHandler(), - logging.FileHandler(LOGS_FILE, "a"), - ], - force=True, - ) - - # logging.disable("DEBUG") - logging.disable(logging.DEBUG) - logger = logging.getLogger(__name__) - logger.setLevel(logging.DEBUG) - logger.info(f"Execution datetime: {CURR_DATE_TIME}") - - return logger - - -def read_json_as_dict(filepath: str) -> dict: - """ - Reads a json as dictionary. - - Parameters - ------------------------ - - filepath: PathLike - Path where the json is located. - - Returns - ------------------------ - - dict: - Dictionary with the data the json has. - - """ - - dictionary = {} - - if os.path.exists(filepath): - with open(filepath) as json_file: - dictionary = json.load(json_file) - - return dictionary - - -def execute_command_helper(command: str, print_command: bool = False) -> None: - """ - Execute a shell command. - - Parameters - ------------------------ - command: str - Command that we want to execute. - print_command: bool - Bool that dictates if we print the command in the console. - - Raises - ------------------------ - CalledProcessError: - if the command could not be executed (Returned non-zero status). - - """ - - if print_command: - print(command) - - popen = subprocess.Popen( - command, stdout=subprocess.PIPE, universal_newlines=True, shell=True - ) - for stdout_line in iter(popen.stdout.readline, ""): - yield str(stdout_line).strip() - popen.stdout.close() - return_code = popen.wait() - if return_code: - raise subprocess.CalledProcessError(return_code, command) - - def main() -> None: """ Main function to register a dataset diff --git a/code/main_register_dataset.py b/code/main_register_dataset.py index 3a95fd0..5e9faaf 100644 --- a/code/main_register_dataset.py +++ b/code/main_register_dataset.py @@ -3,7 +3,6 @@ """ import glob -import json import logging import multiprocessing import os @@ -12,108 +11,10 @@ from aind_ccf_reg import register, utils from aind_ccf_reg.configs import PathLike -from aind_ccf_reg.utils import create_folder +from aind_ccf_reg.utils import create_folder, create_logger, read_json_as_dict from natsort import natsorted -def create_logger(output_log_path: PathLike) -> logging.Logger: - """ - Creates a logger that generates output logs to a specific path. - - Parameters - ------------ - output_log_path: PathLike - Path where the log is going to be stored - - Returns - ----------- - logging.Logger - Created logger - pointing to the file path. - """ - CURR_DATE_TIME = datetime.now().strftime("%Y-%m-%d-%H-%M-%S") - - LOGS_FILE = f"{output_log_path}/register_process.log" - - logging.basicConfig( - level=logging.DEBUG, - format="%(asctime)s - %(levelname)s : %(message)s", - datefmt="%Y-%m-%d %H:%M", - handlers=[ - logging.StreamHandler(), - logging.FileHandler(LOGS_FILE, "a"), - ], - force=True, - ) - - # logging.disable("DEBUG") - logging.disable(logging.DEBUG) - logger = logging.getLogger(__name__) - logger.setLevel(logging.DEBUG) - logger.info(f"Execution datetime: {CURR_DATE_TIME}") - - return logger - - -def read_json_as_dict(filepath: str) -> dict: - """ - Reads a json as dictionary. - - Parameters - ------------------------ - - filepath: PathLike - Path where the json is located. - - Returns - ------------------------ - - dict: - Dictionary with the data the json has. - - """ - - dictionary = {} - - if os.path.exists(filepath): - with open(filepath) as json_file: - dictionary = json.load(json_file) - - return dictionary - - -def execute_command_helper(command: str, print_command: bool = False) -> None: - """ - Execute a shell command. - - Parameters - ------------------------ - command: str - Command that we want to execute. - print_command: bool - Bool that dictates if we print the command in the console. - - Raises - ------------------------ - CalledProcessError: - if the command could not be executed (Returned non-zero status). - - """ - - if print_command: - print(command) - - popen = subprocess.Popen( - command, stdout=subprocess.PIPE, universal_newlines=True, shell=True - ) - for stdout_line in iter(popen.stdout.readline, ""): - yield str(stdout_line).strip() - popen.stdout.close() - return_code = popen.wait() - if return_code: - raise subprocess.CalledProcessError(return_code, command) - - def main() -> None: """ Main function to register a dataset @@ -121,6 +22,7 @@ def main() -> None: subject_dir = "SmartSPIM_714635_2024-03-18_10-47-48" subject_dir = "SmartSPIM_725271_2024-05-22_17-24-06" subject_dir = "SmartSPIM_725379_2024-04-25_17-02-42" + subject_dir = "SmartSPIM_685111_2023-09-28_18-19-10" input_data = glob.glob( f"../data/{subject_dir}*_stitched_*/image_tile_fusing/OMEZarr/" @@ -165,7 +67,7 @@ def main() -> None: channel_to_register = sorted_channels[-1] subject_id = subject_dir.split("_")[1] - results_folder = f"../results/{subject_id}_ccf_{channel_to_register}" + results_folder = f"../results/{subject_id}_ccf_{channel_to_register}_run1" create_folder(results_folder) reg_folder = os.path.abspath(f"{results_folder}/registration_metadata") diff --git a/code/template_based_ccf_registration.md b/code/template_based_ccf_registration.md index e9777e7..1b88759 100644 --- a/code/template_based_ccf_registration.md +++ b/code/template_based_ccf_registration.md @@ -15,7 +15,7 @@ The workflow of the template-based smartSPIM-CCF registration: 2. register the resulting preprocessed image from step 1 to the SPIM template using ANTs (rigid + SyN). 3. register the resulting moved image from step 2 to the CCF Allen Atlas using the [template-to-CCF transforms](https://codeocean.allenneuraldynamics.org/data-assets/97d978ca-f328-49e0-ae6d-3e4544afcf02/lightsheet_template_ccf_registration?filters=N4IgZglgNgLgpgJxALhAQylEAaEBHAV0QE8UR4BbAByjXgFoYB7HEAZyYRjIGME46cACashcNjxQwERXFTQBzOCgCMcxAAVFy5ACYADLjRCAbmgB2PYSmABfXObQUdIKBAUALGGw9w4MAH1KGkEAnh4wAP4FCDZpOggmc1FxPggqGETk1AAROjQAAjBOAuDaBgAjNDZhAoBhOoAxAujY%2BMykgroC3QBWAoIKbAKISygCIVGFAoBlCjQuGY0ASQBZAoAVOGpyuAKTAGYAOhVDeqbhiyFShAs2YoQKNlKPbox3c1LtkPhSpnPGpdzNcGs0LOYmDAEp1Rl8doICmx5FYjgAdZK4KEKNgoADaIHCYBAAF1cABrUYiVBCfI1bi4NgQABeOlOugAHL0AGzsgDsvN0uEgUHEKF6uBpULpOOQuNAECpICEvTAAE40GgwLz6Gh2TxdPQACxaw30VW9MT0FQHODsrloODmh2q1iZGAishzBYwJZrTbfXb7Y6nTb-UEFABKcBicVuHU%2BBEZ5mm83MBAwBVoFTgUGe3T6AwoR391E4C2I%2B0QjKSAG4CgB3aBQArZlpwEJWIRHVgUJgEczcVBIiAUIIB0LMMIRFIi%2BBUsAYGr2eWKg76Cpgdfhehcw1c7WGiqG1U6lT809oFSG3TGsAqMBc10Qd0uL2LFbrAAydQAgiWfnshwnPoIyfBQFADOYz55jABQUAQsDpCKbYcOM8Y4rgvb9oO7DzFww6jlAPBoGO8LwDO-jWMgC65nAy4gAqZC8qqG6qvoBwGr0ERgEa7HsvQFS6BU-HsmgN4LvoqrsnABwVE%2BL5kD%2BmBwJ8qx9jU9RMOBnR1EwnCTI4vyNLczj1pwZIFAAFMsA6II4UAAJQ9n2A5kBgIrmAEWE1FORISjmlHzoudHYCuZD6A%2BPAqKqXI8PQ7EHGgRo8PaOqctqmrcmucC6LoaDcvJHqoG%2BPofgEPK9CoVUBAYugHPFJ4cgEKj8dFVr6AEcTPjwvhCDV%2Bg3vFKhWiozX6FaXJGoaznYZ6eGlWs5WclVo21fVkn0E1LVWiepydW6PXCP1g36MN1WnBNU0UXOKA0UuoUMYqKgVLyxqvRUAkVPo42HvlaVcpNvS8jwhqnIaNKqpuhWvvNvqrOVqqGpVBzHetJ5rgE33xfVLX7d1vXHaap0jWNVq9JtBwza5xWw2VXKI8jqMNfQGNY%2BxVrsnjMCHX1tVE2do0XSo5N1ddVF3SFYWoDwQhgGIPAHPxcBcgIRrslU9DsoaINmnyGpgL05rsrofnkM%2BRUgCVcMBLykkHKqq0Dfz8WcwYRrk2eXM84TQ0k8LassyoVM4VbZW26q9uOydw36K7P0e7yXsE3zvvneThr8QcQf%2BbO4vBfRjGoCq%2BjKsr43mr0BrHuyw26iocUqEIvLspJvJwPX7KU5i5sw961u8qcXJ9D77O6KqpO5Zto1ddzydO9jLMdZP22nMHc192Hg-Dyno-jxdk%2B6NPB1zyd9UY8vrX6GLQW0QXipwAbvJy2gcXMS3au6EImu2%2BN%2Bj08YYBNxwB4PoSQ3cFI0w3otemWcYpMw2k1OqVoDS5STkdHeAsJ4416GvSB75oER2ilyeBjVXY4xQboNBvN57E3OuNJBwtr63Xzg9Qu6BegVCEPTKw9AhA13jilU8d5NZcn0KDNi%2BpeSXmhuvfB8MYHRUTmtZmY9MYe34r0DqM9vYYL9jjQGV9MIuRDrTAhsClEDTRptce%2Bh1H0E0VQkemDrSXU0Uw6iLCpYgGPMIXoHFtRgAOAKI0XCDR634sRHgFpVQcisE-GReCFrwwFN9fcI9TTDxUJNNquhE7aJPkTD2vRmoGiyUaF0RjZqJP7gYP%2BFiToZOKWUnJeTj7oJoUUkpl1jzuIlnfMgqoeBt0NAcGk39toZ2BprK8tcKhcgXOyaSYBDQ9PARbUOi0B7sjYoadJm1E60JPIbRxO8Mmcz-gvU6uDLamOSS1HZezcmYzOkc8e%2BT2kNM2ucya7Mrk50Csw2%2BrDFQChbsJEBmtQEHn5GEoSw1NFcg4mAOqzFkUJJuVA5JN5hZR0KWTZ58V6HEPedQk6HtiFu16PxQ%2B1yNlYtBpVEenTiZY10MStppK8VZP6vY6l2clQBRuh4oFXjFZ9HVlrXhQgglGgHvVNAhoplwCqCA3khsOQv3RXSm22LK5MvxbYlmpphYnI6VaA5pTyZZ1pbcnVDLKE72ZVa41xSSX6s9gNMmgdemeMemQZVwD9AyQNIjG0yV2Rf3NKAkJvIuRHgOEPFiugtW2oFJXAe%2BrUFnk2kTdl%2BMPl4tUVVFm5MqU2sxTq9NuL4oi0odmk6ebZ4FprdY5qw0DilvZD6kVfrUBsTgH4605MW4D3KUgmKKt7ESSEEGoQqpgGPjWb3ORNtrSqlepmzmbUZXWnLSuuV67dmOq%2Bc1dG2pd3-KFX04FZAeRWFVHw002sWLu2LQqrkw1FX7g1Jw3Q%2BpTZunWamq8iLik7xxlun6B4u2VOphi-dIGO0jwg6TRVatu33S8WgZuiMNzkz-vOo0jpTQRsAfYw0Don7sX1DaFNFaB57iQ%2BBjmqHoOmtPiesRRoz4VJAFhOD2qGOgeQyxi6aGM7saJvVJqXGRks142IXON8lykhAFQRAFBYjVnMDKUACweoQBMDoaQsgQDCGfFIGQcAGSvH4JZ0zJgIBwHrPZ6zIBHPOZmLZ4zVn7DsChORVAkB7KsCYPWcwiBliKmkmJPK0qdxng%2BoeC6UlP4CVOI3Xkis0APpELgMLEWEAADknAuByBAAoAB1CwChWB8AEHOH8g4zxnlSZ3XkRw6pZ0ReyXAVQagAFUEBYFQF4GAVA2DIAAPRTZ4EwMQTArAWCOO5FSEWCC3CgEIYgjhNM8DYEcTgCgpuSmqP4NgU2Yu5WMPVD9vIksVBS8bL%2Bj3TpN2y7lqb6653N2IvQQJHJylwHGg6LkX8bRIxWZqCIA06toAmwhOAUWyDskAWgV7cVuRSJCSXASIMkpCBUAOu00r5nqzhwjkUGxiDqbIEmBQHpcDEUp3AGY4xauoDPJorJ-LmdsERyV5wblKT0DYPNAi9BCT0FaLGaEnx6BwgAgJM7X9oh1a0lQAgAWsjI9QLqe73Isb3YikaBVw1FmBM2oAxGXJK69E0cmpn8P%2BcijYAN%2Bnqg5DpBzKMcQ7uphilwJSOAAAPGYAWXBzZ2AC3AtA4g2TECHqiLWf48mPEcPxfJcninQDwTIRmADy4Wqx4i8VduLt3EtGle7rNLr3MsfaEHlkAu2ysVeq8mVg2w0DQDIJMI49YasAAFVtQR026LXcBDsIFq7YVToxNcwDyFCUvvalQqnVJqDKeoq4mjNBaOAVobR2mdL0Z0dG5H-kDEBEMGwwxNEjNGNocYsgDHp3BCw6ZmxZhzDBHo-RBhiwthSxbgEAKwjMEBtM6xGxMAWw9h%2BAOxhBuxYMcICJSIAIggmBfIMNJY181wNwtw4pdx9xq9jxTxzxLxLxrxbx7xF0zYIF4MkkChvw-xgCAIgxgJQI4IIJ%2BxoIuhYJ4JEIaB4DxAmA0IsgMI%2BNjE6dxcqARwAgiISIyhBAcD%2BlUBmJWJ2JOJuJeJFYBIhIRIxJjQ0BJJpJZJ0UlIPICg1JEw9hdJtJPhdJ9JRgERjJSszIEALJrJbIEB7InIUC3JlJPJvI4BsDL084e02EIpYoiE4oEokptZUpdQgYdQDZEUg1rsCol1ZEkklpKpqplEEEt1WpdotEOUnE-ZxoykVk91ciKoVoSET0V5SjJNU5BYqjJoajwjlNcC2FnpXoTQPoKgvofoqhyZdQAZ7FgZQYxEIYoZsjqk6YGZrRGjWZf4UM3VdE6EvVRYAjFiCEkYVjCj0YOo2YNjyitj2idiu4BUlNAVMM18ZY5ZgE9DlZVYM4NYtYdYpIpFMojYTYL9cjw5I4KjY4eUkZzVWjaFBZ05M5%2BV%2BMTF6M7YHZQS453ZITNiaFnFYTvVuj7jejFRi5S5RF99K5yka40p64rQm4W51124eBO5AT%2B4t4wMaFpM956EUEj581OUF5z5SlL5ajmS-5t42TW194uSoSz4l4BT2pVCb1UAH4gZn5X4pIfpntv42Z-5ZYgEQEwF6CgMK0FE4FjiT0GEKEoTnF6FsEhSljYEKVLEVEyFkFNpKFMTo5KiKYyZ5SsMOEuFBlD8%2BExMuJJpLxhE7QxFopQFclpEFjGDrZjT6krFVFDVtoHF3TnZzp9F7FDEpCql4y7TFFGiUy7F0yLisS9FXFczFMAVhUHi2EfFlR-F-sgkq5Qlv5dRJcX5olYk4B4k4zBNak0lTlNomlslGpWkeT3UmlSlOjeMEScialUl6kiZGlmpxz9koTOkVBZzykfS19BlhlRkko%2BQJk%2BQ4oa5QYdQ5kFklkVleNANl0gT7kxFHkDkXl7E3lyzPkZMfl1p4TpD9i7ltlXyRynlDlPyoSzlMY-yhp9y2FQV1w9RxoW4hlZVgljZHsczEUTYUVIZHcDSnyakGVq1UzikWUiUtyJoeUqUp5bTNldVSLmUY5KKMyW1uVKU%2BV4LVxjYqVhJTQm8ZVFUXEFUlUVV9A1UYlRJ9THzFyw5dUHUzUTVDUDgXUqKPVLVcS8yBNU0FLpy1EjV8U2LUyLUvVrU8S6yCT-VswQFg0zQRlD9tYI199o1wZY141E1BImT5Kq1M061tQG0qKi121O16KsVfLj0s0Arc0gq94QreVuKBkg1B0O1IVR1jxx0AZD8VQTCZ1hB50UpvLNk10N1Iqt0z0j8wrV17ZSqzUtoKqL1bjazr0vE71HRH1koX1Dja49xP1Y1fjf1-0iq7lGNWSONcYxNoMqqhMmMxSJqoN0MLKWq19sNtlDwDZ4p6ZHLiNNYdTyNKNNwDgaNlABzgNRqRN5rZU1YpTOMn0eNprEMxqpNRMFqJNjLpNzk7r5NVDVN6tBAhAmtPx0ccwyBVg0AKwx5hg%2BYCgqo9Bcy48YAE9Q9hAgbswRsQAwaIbVQoanYYaVA4bWBGQWRUaQa%2B0W4jgHZrCAAhVgWIZfM7QcEzOiIAA) computed by Yoni. -This [Code Ocean data asset](https://codeocean.allenneuraldynamics.org/data-assets/97d978ca-f328-49e0-ae6d-3e4544afcf02/lightsheet_template_ccf_registration?filters=N4IgZglgNgLgpgJxALhAQylEAaEBHAV0QE8UR4BbAByjXgFoYB7HEAZyYRjIGME46cACashcNjxQwERXFTQBzOCgCMcxAAVFy5ACYADLjRCAbmgB2PYSmABfXObQUdIKBAUALGGw9w4MAH1KGkEAnh4wAP4FCDZpOggmc1FxPggqGETk1AAROjQAAjBOAuDaBgAjNDZhAoBhOoAxAujY%2BMykgroC3QBWAoIKbAKISygCIVGFAoBlCjQuGY0ASQBZAoAVOGpyuAKTAGYAOhVDeqbhiyFShAs2YoQKNlKPbox3c1LtkPhSpnPGpdzNcGs0LOYmDAEp1Rl8doICmx5FYjgAdZK4KEKNgoADaIHCYBAAF1cABrUYiVBCfI1bi4NgQABeOlOugAHL0AGzsgDsvN0uEgUHEKF6uBpULpOOQuNAECpICEvTAAE40GgwLz6Gh2TxdPQACxaw30VW9MT0FQHODsrloODmh2q1iZGAishzBYwJZrTbfXb7Y6nTb-UEFABKcBicVuHU%2BBEZ5mm83MBAwBVoFTgUGe3T6AwoR391E4C2I%2B0QjKSAG4CgB3aBQArZlpwEJWIRHVgUJgEczcVBIiAUIIB0LMMIRFIi%2BBUsAYGr2eWKg76Cpgdfhehcw1c7WGiqG1U6lT809oFSG3TGsAqMBc10Qd0uL2LFbrAAydQAgiWfnshwnPoIyfBQFADOYz55jABQUAQsDpCKbYcOM8Y4rgvb9oO7DzFww6jlAPBoGO8LwDO-jWMgC65nAy4gAqZC8qqG6qvoBwGr0ERgEa7HsvQFS6BU-HsmgN4LvoqrsnABwVE%2BL5kD%2BmBwJ8qx9jU9RMOBnR1EwnCTI4vyNLczj1pwZIFAAFMsA6II4UAAJQ9n2A5kBgIrmAEWE1FORISjmlHzoudHYCuZD6A%2BPAqKqXI8PQ7EHGgRo8PaOqctqmrcmucC6LoaDcvJHqoG%2BPofgEPK9CoVUBAYugHPFJ4cgEKj8dFVr6AEcTPjwvhCDV%2Bg3vFKhWiozX6FaXJGoaznYZ6eGlWs5WclVo21fVkn0E1LVWiepydW6PXCP1g36MN1WnBNU0UXOKA0UuoUMYqKgVLyxqvRUAkVPo42HvlaVcpNvS8jwhqnIaNKqpuhWvvNvqrOVqqGpVBzHetJ5rgE33xfVLX7d1vXHaap0jWNVq9JtBwza5xWw2VXKI8jqMNfQGNY%2BxVrsnjMCHX1tVE2do0XSo5N1ddVF3SFYWoDwQhgGIPAHPxcBcgIRrslU9DsoaINmnyGpgL05rsrofnkM%2BRUgCVcMBLykkHKqq0Dfz8WcwYRrk2eXM84TQ0k8LassyoVM4VbZW26q9uOydw36K7P0e7yXsE3zvvneThr8QcQf%2BbO4vBfRjGoCq%2BjKsr43mr0BrHuyw26iocUqEIvLspJvJwPX7KU5i5sw961u8qcXJ9D77O6KqpO5Zto1ddzydO9jLMdZP22nMHc192Hg-Dyno-jxdk%2B6NPB1zyd9UY8vrX6GLQW0QXipwAbvJy2gcXMS3au6EImu2%2BN%2Bj08YYBNxwB4PoSQ3cFI0w3otemWcYpMw2k1OqVoDS5STkdHeAsJ4416GvSB75oER2ilyeBjVXY4xQboNBvN57E3OuNJBwtr63Xzg9Qu6BegVCEPTKw9AhA13jilU8d5NZcn0KDNi%2BpeSXmhuvfB8MYHRUTmtZmY9MYe34r0DqM9vYYL9jjQGV9MIuRDrTAhsClEDTRptce%2Bh1H0E0VQkemDrSXU0Uw6iLCpYgGPMIXoHFtRgAOAKI0XCDR634sRHgFpVQcisE-GReCFrwwFN9fcI9TTDxUJNNquhE7aJPkTD2vRmoGiyUaF0RjZqJP7gYP%2BFiToZOKWUnJeTj7oJoUUkpl1jzuIlnfMgqoeBt0NAcGk39toZ2BprK8tcKhcgXOyaSYBDQ9PARbUOi0B7sjYoadJm1E60JPIbRxO8Mmcz-gvU6uDLamOSS1HZezcmYzOkc8e%2BT2kNM2ucya7Mrk50Csw2%2BrDFQChbsJEBmtQEHn5GEoSw1NFcg4mAOqzFkUJJuVA5JN5hZR0KWTZ58V6HEPedQk6HtiFu16PxQ%2B1yNlYtBpVEenTiZY10MStppK8VZP6vY6l2clQBRuh4oFXjFZ9HVlrXhQgglGgHvVNAhoplwCqCA3khsOQv3RXSm22LK5MvxbYlmpphYnI6VaA5pTyZZ1pbcnVDLKE72ZVa41xSSX6s9gNMmgdemeMemQZVwD9AyQNIjG0yV2Rf3NKAkJvIuRHgOEPFiugtW2oFJXAe%2BrUFnk2kTdl%2BMPl4tUVVFm5MqU2sxTq9NuL4oi0odmk6ebZ4FprdY5qw0DilvZD6kVfrUBsTgH4605MW4D3KUgmKKt7ESSEEGoQqpgGPjWb3ORNtrSqlepmzmbUZXWnLSuuV67dmOq%2Bc1dG2pd3-KFX04FZAeRWFVHw002sWLu2LQqrkw1FX7g1Jw3Q%2BpTZunWamq8iLik7xxlun6B4u2VOphi-dIGO0jwg6TRVatu33S8WgZuiMNzkz-vOo0jpTQRsAfYw0Don7sX1DaFNFaB57iQ%2BBjmqHoOmtPiesRRoz4VJAFhOD2qGOgeQyxi6aGM7saJvVJqXGRks142IXON8lykhAFQRAFBYjVnMDKUACweoQBMDoaQsgQDCGfFIGQcAGSvH4JZ0zJgIBwHrPZ6zIBHPOZmLZ4zVn7DsChORVAkB7KsCYPWcwiBliKmkmJPK0qdxng%2BoeC6UlP4CVOI3Xkis0APpELgMLEWEAADknAuByBAAoAB1CwChWB8AEHOH8g4zxnlSZ3XkRw6pZ0ReyXAVQagAFUEBYFQF4GAVA2DIAAPRTZ4EwMQTArAWCOO5FSEWCC3CgEIYgjhNM8DYEcTgCgpuSmqP4NgU2Yu5WMPVD9vIksVBS8bL%2Bj3TpN2y7lqb6653N2IvQQJHJylwHGg6LkX8bRIxWZqCIA06toAmwhOAUWyDskAWgV7cVuRSJCSXASIMkpCBUAOu00r5nqzhwjkUGxiDqbIEmBQHpcDEUp3AGY4xauoDPJorJ-LmdsERyV5wblKT0DYPNAi9BCT0FaLGaEnx6BwgAgJM7X9oh1a0lQAgAWsjI9QLqe73Isb3YikaBVw1FmBM2oAxGXJK69E0cmpn8P%2BcijYAN%2Bnqg5DpBzKMcQ7uphilwJSOAAAPGYAWXBzZ2AC3AtA4g2TECHqiLWf48mPEcPxfJcninQDwTIRmADy4Wqx4i8VduLt3EtGle7rNLr3MsfaEHlkAu2ysVeq8mVg2w0DQDIJMI49YasAAFVtQR026LXcBDsIFq7YVToxNcwDyFCUvvalQqnVJqDKeoq4mjNBaOAVobR2mdL0Z0dG5H-kDEBEMGwwxNEjNGNocYsgDHp3BCw6ZmxZhzDBHo-RBhiwthSxbgEAKwjMEBtM6xGxMAWw9h%2BAOxhBuxYMcICJSIAIggmBfIMNJY181wNwtw4pdx9xq9jxTxzxLxLxrxbx7xF0zYIF4MkkChvw-xgCAIgxgJQI4IIJ%2BxoIuhYJ4JEIaB4DxAmA0IsgMI%2BNjE6dxcqARwAgiISIyhBAcD%2BlUBmJWJ2JOJuJeJFYBIhIRIxJjQ0BJJpJZJ0UlIPICg1JEw9hdJtJPhdJ9JRgERjJSszIEALJrJbIEB7InIUC3JlJPJvI4BsDL084e02EIpYoiE4oEokptZUpdQgYdQDZEUg1rsCol1ZEkklpKpqplEEEt1WpdotEOUnE-ZxoykVk91ciKoVoSET0V5SjJNU5BYqjJoajwjlNcC2FnpXoTQPoKgvofoqhyZdQAZ7FgZQYxEIYoZsjqk6YGZrRGjWZf4UM3VdE6EvVRYAjFiCEkYVjCj0YOo2YNjyitj2idiu4BUlNAVMM18ZY5ZgE9DlZVYM4NYtYdYpIpFMojYTYL9cjw5I4KjY4eUkZzVWjaFBZ05M5%2BV%2BMTF6M7YHZQS453ZITNiaFnFYTvVuj7jejFRi5S5RF99K5yka40p64rQm4W51124eBO5AT%2B4t4wMaFpM956EUEj581OUF5z5SlL5ajmS-5t42TW194uSoSz4l4BT2pVCb1UAH4gZn5X4pIfpntv42Z-5ZYgEQEwF6CgMK0FE4FjiT0GEKEoTnF6FsEhSljYEKVLEVEyFkFNpKFMTo5KiKYyZ5SsMOEuFBlD8%2BExMuJJpLxhE7QxFopQFclpEFjGDrZjT6krFVFDVtoHF3TnZzp9F7FDEpCql4y7TFFGiUy7F0yLisS9FXFczFMAVhUHi2EfFlR-F-sgkq5Qlv5dRJcX5olYk4B4k4zBNak0lTlNomlslGpWkeT3UmlSlOjeMEScialUl6kiZGlmpxz9koTOkVBZzykfS19BlhlRkko%2BQJk%2BQ4oa5QYdQ5kFklkVleNANl0gT7kxFHkDkXl7E3lyzPkZMfl1p4TpD9i7ltlXyRynlDlPyoSzlMY-yhp9y2FQV1w9RxoW4hlZVgljZHsczEUTYUVIZHcDSnyakGVq1UzikWUiUtyJoeUqUp5bTNldVSLmUY5KKMyW1uVKU%2BV4LVxjYqVhJTQm8ZVFUXEFUlUVV9A1UYlRJ9THzFyw5dUHUzUTVDUDgXUqKPVLVcS8yBNU0FLpy1EjV8U2LUyLUvVrU8S6yCT-VswQFg0zQRlD9tYI199o1wZY141E1BImT5Kq1M061tQG0qKi121O16KsVfLj0s0Arc0gq94QreVuKBkg1B0O1IVR1jxx0AZD8VQTCZ1hB50UpvLNk10N1Iqt0z0j8wrV17ZSqzUtoKqL1bjazr0vE71HRH1koX1Dja49xP1Y1fjf1-0iq7lGNWSONcYxNoMqqhMmMxSJqoN0MLKWq19sNtlDwDZ4p6ZHLiNNYdTyNKNNwDgaNlABzgNRqRN5rZU1YpTOMn0eNprEMxqpNRMFqJNjLpNzk7r5NVDVN6tBAhAmtPx0ccwyBVg0AKwx5hg%2BYCgqo9Bcy48YAE9Q9hAgbswRsQAwaIbVQoanYYaVA4bWBGQWRUaQa%2B0W4jgHZrCAAhVgWIZfM7QcEzOiIAA) contains data for computing template-based CCF registration at 25 um, including +This [data asset](https://codeocean.allenneuraldynamics.org/data-assets/97d978ca-f328-49e0-ae6d-3e4544afcf02/lightsheet_template_ccf_registration?filters=N4IgZglgNgLgpgJxALhAQylEAaEBHAV0QE8UR4BbAByjXgFoYB7HEAZyYRjIGME46cACashcNjxQwERXFTQBzOCgCMcxAAVFy5ACYADLjRCAbmgB2PYSmABfXObQUdIKBAUALGGw9w4MAH1KGkEAnh4wAP4FCDZpOggmc1FxPggqGETk1AAROjQAAjBOAuDaBgAjNDZhAoBhOoAxAujY%2BMykgroC3QBWAoIKbAKISygCIVGFAoBlCjQuGY0ASQBZAoAVOGpyuAKTAGYAOhVDeqbhiyFShAs2YoQKNlKPbox3c1LtkPhSpnPGpdzNcGs0LOYmDAEp1Rl8doICmx5FYjgAdZK4KEKNgoADaIHCYBAAF1cABrUYiVBCfI1bi4NgQABeOlOugAHL0AGzsgDsvN0uEgUHEKF6uBpULpOOQuNAECpICEvTAAE40GgwLz6Gh2TxdPQACxaw30VW9MT0FQHODsrloODmh2q1iZGAishzBYwJZrTbfXb7Y6nTb-UEFABKcBicVuHU%2BBEZ5mm83MBAwBVoFTgUGe3T6AwoR391E4C2I%2B0QjKSAG4CgB3aBQArZlpwEJWIRHVgUJgEczcVBIiAUIIB0LMMIRFIi%2BBUsAYGr2eWKg76Cpgdfhehcw1c7WGiqG1U6lT809oFSG3TGsAqMBc10Qd0uL2LFbrAAydQAgiWfnshwnPoIyfBQFADOYz55jABQUAQsDpCKbYcOM8Y4rgvb9oO7DzFww6jlAPBoGO8LwDO-jWMgC65nAy4gAqZC8qqG6qvoBwGr0ERgEa7HsvQFS6BU-HsmgN4LvoqrsnABwVE%2BL5kD%2BmBwJ8qx9jU9RMOBnR1EwnCTI4vyNLczj1pwZIFAAFMsA6II4UAAJQ9n2A5kBgIrmAEWE1FORISjmlHzoudHYCuZD6A%2BPAqKqXI8PQ7EHGgRo8PaOqctqmrcmucC6LoaDcvJHqoG%2BPofgEPK9CoVUBAYugHPFJ4cgEKj8dFVr6AEcTPjwvhCDV%2Bg3vFKhWiozX6FaXJGoaznYZ6eGlWs5WclVo21fVkn0E1LVWiepydW6PXCP1g36MN1WnBNU0UXOKA0UuoUMYqKgVLyxqvRUAkVPo42HvlaVcpNvS8jwhqnIaNKqpuhWvvNvqrOVqqGpVBzHetJ5rgE33xfVLX7d1vXHaap0jWNVq9JtBwza5xWw2VXKI8jqMNfQGNY%2BxVrsnjMCHX1tVE2do0XSo5N1ddVF3SFYWoDwQhgGIPAHPxcBcgIRrslU9DsoaINmnyGpgL05rsrofnkM%2BRUgCVcMBLykkHKqq0Dfz8WcwYRrk2eXM84TQ0k8LassyoVM4VbZW26q9uOydw36K7P0e7yXsE3zvvneThr8QcQf%2BbO4vBfRjGoCq%2BjKsr43mr0BrHuyw26iocUqEIvLspJvJwPX7KU5i5sw961u8qcXJ9D77O6KqpO5Zto1ddzydO9jLMdZP22nMHc192Hg-Dyno-jxdk%2B6NPB1zyd9UY8vrX6GLQW0QXipwAbvJy2gcXMS3au6EImu2%2BN%2Bj08YYBNxwB4PoSQ3cFI0w3otemWcYpMw2k1OqVoDS5STkdHeAsJ4416GvSB75oER2ilyeBjVXY4xQboNBvN57E3OuNJBwtr63Xzg9Qu6BegVCEPTKw9AhA13jilU8d5NZcn0KDNi%2BpeSXmhuvfB8MYHRUTmtZmY9MYe34r0DqM9vYYL9jjQGV9MIuRDrTAhsClEDTRptce%2Bh1H0E0VQkemDrSXU0Uw6iLCpYgGPMIXoHFtRgAOAKI0XCDR634sRHgFpVQcisE-GReCFrwwFN9fcI9TTDxUJNNquhE7aJPkTD2vRmoGiyUaF0RjZqJP7gYP%2BFiToZOKWUnJeTj7oJoUUkpl1jzuIlnfMgqoeBt0NAcGk39toZ2BprK8tcKhcgXOyaSYBDQ9PARbUOi0B7sjYoadJm1E60JPIbRxO8Mmcz-gvU6uDLamOSS1HZezcmYzOkc8e%2BT2kNM2ucya7Mrk50Csw2%2BrDFQChbsJEBmtQEHn5GEoSw1NFcg4mAOqzFkUJJuVA5JN5hZR0KWTZ58V6HEPedQk6HtiFu16PxQ%2B1yNlYtBpVEenTiZY10MStppK8VZP6vY6l2clQBRuh4oFXjFZ9HVlrXhQgglGgHvVNAhoplwCqCA3khsOQv3RXSm22LK5MvxbYlmpphYnI6VaA5pTyZZ1pbcnVDLKE72ZVa41xSSX6s9gNMmgdemeMemQZVwD9AyQNIjG0yV2Rf3NKAkJvIuRHgOEPFiugtW2oFJXAe%2BrUFnk2kTdl%2BMPl4tUVVFm5MqU2sxTq9NuL4oi0odmk6ebZ4FprdY5qw0DilvZD6kVfrUBsTgH4605MW4D3KUgmKKt7ESSEEGoQqpgGPjWb3ORNtrSqlepmzmbUZXWnLSuuV67dmOq%2Bc1dG2pd3-KFX04FZAeRWFVHw002sWLu2LQqrkw1FX7g1Jw3Q%2BpTZunWamq8iLik7xxlun6B4u2VOphi-dIGO0jwg6TRVatu33S8WgZuiMNzkz-vOo0jpTQRsAfYw0Don7sX1DaFNFaB57iQ%2BBjmqHoOmtPiesRRoz4VJAFhOD2qGOgeQyxi6aGM7saJvVJqXGRks142IXON8lykhAFQRAFBYjVnMDKUACweoQBMDoaQsgQDCGfFIGQcAGSvH4JZ0zJgIBwHrPZ6zIBHPOZmLZ4zVn7DsChORVAkB7KsCYPWcwiBliKmkmJPK0qdxng%2BoeC6UlP4CVOI3Xkis0APpELgMLEWEAADknAuByBAAoAB1CwChWB8AEHOH8g4zxnlSZ3XkRw6pZ0ReyXAVQagAFUEBYFQF4GAVA2DIAAPRTZ4EwMQTArAWCOO5FSEWCC3CgEIYgjhNM8DYEcTgCgpuSmqP4NgU2Yu5WMPVD9vIksVBS8bL%2Bj3TpN2y7lqb6653N2IvQQJHJylwHGg6LkX8bRIxWZqCIA06toAmwhOAUWyDskAWgV7cVuRSJCSXASIMkpCBUAOu00r5nqzhwjkUGxiDqbIEmBQHpcDEUp3AGY4xauoDPJorJ-LmdsERyV5wblKT0DYPNAi9BCT0FaLGaEnx6BwgAgJM7X9oh1a0lQAgAWsjI9QLqe73Isb3YikaBVw1FmBM2oAxGXJK69E0cmpn8P%2BcijYAN%2Bnqg5DpBzKMcQ7uphilwJSOAAAPGYAWXBzZ2AC3AtA4g2TECHqiLWf48mPEcPxfJcninQDwTIRmADy4Wqx4i8VduLt3EtGle7rNLr3MsfaEHlkAu2ysVeq8mVg2w0DQDIJMI49YasAAFVtQR026LXcBDsIFq7YVToxNcwDyFCUvvalQqnVJqDKeoq4mjNBaOAVobR2mdL0Z0dG5H-kDEBEMGwwxNEjNGNocYsgDHp3BCw6ZmxZhzDBHo-RBhiwthSxbgEAKwjMEBtM6xGxMAWw9h%2BAOxhBuxYMcICJSIAIggmBfIMNJY181wNwtw4pdx9xq9jxTxzxLxLxrxbx7xF0zYIF4MkkChvw-xgCAIgxgJQI4IIJ%2BxoIuhYJ4JEIaB4DxAmA0IsgMI%2BNjE6dxcqARwAgiISIyhBAcD%2BlUBmJWJ2JOJuJeJFYBIhIRIxJjQ0BJJpJZJ0UlIPICg1JEw9hdJtJPhdJ9JRgERjJSszIEALJrJbIEB7InIUC3JlJPJvI4BsDL084e02EIpYoiE4oEokptZUpdQgYdQDZEUg1rsCol1ZEkklpKpqplEEEt1WpdotEOUnE-ZxoykVk91ciKoVoSET0V5SjJNU5BYqjJoajwjlNcC2FnpXoTQPoKgvofoqhyZdQAZ7FgZQYxEIYoZsjqk6YGZrRGjWZf4UM3VdE6EvVRYAjFiCEkYVjCj0YOo2YNjyitj2idiu4BUlNAVMM18ZY5ZgE9DlZVYM4NYtYdYpIpFMojYTYL9cjw5I4KjY4eUkZzVWjaFBZ05M5%2BV%2BMTF6M7YHZQS453ZITNiaFnFYTvVuj7jejFRi5S5RF99K5yka40p64rQm4W51124eBO5AT%2B4t4wMaFpM956EUEj581OUF5z5SlL5ajmS-5t42TW194uSoSz4l4BT2pVCb1UAH4gZn5X4pIfpntv42Z-5ZYgEQEwF6CgMK0FE4FjiT0GEKEoTnF6FsEhSljYEKVLEVEyFkFNpKFMTo5KiKYyZ5SsMOEuFBlD8%2BExMuJJpLxhE7QxFopQFclpEFjGDrZjT6krFVFDVtoHF3TnZzp9F7FDEpCql4y7TFFGiUy7F0yLisS9FXFczFMAVhUHi2EfFlR-F-sgkq5Qlv5dRJcX5olYk4B4k4zBNak0lTlNomlslGpWkeT3UmlSlOjeMEScialUl6kiZGlmpxz9koTOkVBZzykfS19BlhlRkko%2BQJk%2BQ4oa5QYdQ5kFklkVleNANl0gT7kxFHkDkXl7E3lyzPkZMfl1p4TpD9i7ltlXyRynlDlPyoSzlMY-yhp9y2FQV1w9RxoW4hlZVgljZHsczEUTYUVIZHcDSnyakGVq1UzikWUiUtyJoeUqUp5bTNldVSLmUY5KKMyW1uVKU%2BV4LVxjYqVhJTQm8ZVFUXEFUlUVV9A1UYlRJ9THzFyw5dUHUzUTVDUDgXUqKPVLVcS8yBNU0FLpy1EjV8U2LUyLUvVrU8S6yCT-VswQFg0zQRlD9tYI199o1wZY141E1BImT5Kq1M061tQG0qKi121O16KsVfLj0s0Arc0gq94QreVuKBkg1B0O1IVR1jxx0AZD8VQTCZ1hB50UpvLNk10N1Iqt0z0j8wrV17ZSqzUtoKqL1bjazr0vE71HRH1koX1Dja49xP1Y1fjf1-0iq7lGNWSONcYxNoMqqhMmMxSJqoN0MLKWq19sNtlDwDZ4p6ZHLiNNYdTyNKNNwDgaNlABzgNRqRN5rZU1YpTOMn0eNprEMxqpNRMFqJNjLpNzk7r5NVDVN6tBAhAmtPx0ccwyBVg0AKwx5hg%2BYCgqo9Bcy48YAE9Q9hAgbswRsQAwaIbVQoanYYaVA4bWBGQWRUaQa%2B0W4jgHZrCAAhVgWIZfM7QcEzOiIAA) contains data for computing template-based CCF registration at 25 um, including - `smartspim_lca_template_25.nii.gz`: SmartSPIM Template v3.10, - `ccf_average_template_25.nii.gz`: CCF Allen Atlas, - `spim_template_to_ccf_syn_1Warp.nii.gz` and `spim_template_to_ccf_syn_0GenericAffine.mat`: transforms that align template to CCF, @@ -23,6 +23,7 @@ This [Code Ocean data asset](https://codeocean.allenneuraldynamics.org/data-asse The dimension of SPIM template is `576*648*440`. The dimension of CCF Atlas is `528*320*456`. The resolution of SPIM template and CCF is `0.025*0.025*0.025` mm. +This [Code Ocean data asset](https://codeocean.allenneuraldynamics.org/data-assets/3b379c74-d089-48b6-a6b4-2e80d83eb863/testing_data_for_lightsheet_template_ccf_registration?filters=N4IgZglgNgLgpgJxALhAQylEAaEBHAV0QE8UR4BnHECgewRjIGME414ATajuCplGAiK4ADmgDmcFAEZRiAAoSpyAEwAGXGg4A3NADsmcLsmABfXHrQBbZeV4wIe8QH0O7NM7D1nUCOIAWMBT%2BcHAwzvBWIlDscM5MTGDOrOIQFILsELR63LwsECIO2WSUDk4ABG4waOVeCOW%2BAUEhYRFwUTHw8YnJcKnpCJnZyOUAbAAcAKzSM91JAKIAHs6jAMwAnM7zViujatTV4lTIANogCWAgALq4ANaOxiBVaBRh1BQQAF7Kq2qr05N1pM1JNcJAoLwUAAWcayJ7uV5BFAnUAQR4cSZgdZoNBgADsAFo0OMmCoCVD8VCCUCeATpKs4ONRmg4ECWesDhAYBCyABlKxoBi8%2BQASQAsuUACrtaKxcraVYAOmkailtHKAGENQAxcoAJT6aQyRT05QIHwqAr0BAwDTQACM4FAKOV2OUVJMzVZFVKZfRBcR5YgPtkANzlADu0Cg5Ud5VYssMHEV1CstAIekYqAoIggO0isq6MFoc1yEM4KDAGFe5lRj1%2B9rAantCQJoyho0JUPtUPWROkeMJaGkw6hKgpYGkYFGnO5tn5gpgwvF5QAMhqAIK%2BjpyhXK1WOcpWKxmvRcl1uqwEWAFCHx3i0KAEE1UXBpjNZmgChg5vM%2BJgeAWnRSLgPDlkYlbVnAtYgGiZB4usjbrH8ZKTIkYDkn84wEvaKj2th4xoOOVZqOs4xwKs9qzjyqAbpgcCmmK6avJqtDHtkrH0Bwjhytqgw2BG9C3OUAAUIqZoglhQAAlKm6aZmQGAQnozjvq8pagU6YQQcgVbOtB2B1mQajTkw0jrKMTAEn8qxoOSTDMkSUxDmAkxrGocAqCoaBudR87fkuopiisUwzNIzjqCoqzWX2KjjM40jYeZdJqM46RckwIQcBFajjtZ0h0uFKp0qM5JQnJH58gFy7BRM0yzJF0WkQScUJUlfYqmlDgwJlRg5XlagFbMxXSKVULlZp4HGHpNaGbBjzSPaeIUst9o4faahqOS9o%2BU5oylZMeJMFCKpQm46xNn5VWLjVKzrFC0yrP1TV9r8zibdZ0WJV1GVZf1VKDYVCVbdIkwtasFUKagC5CkFd0PfSz0xQSb0fX8dLxelPV-ZFANDUVINg1FZbadNUEwXBqBMBwYA8EwqzYXAoxsOS4w7QS4xQsd1LjHiOKuUC4wqJcuDdTRIAw4F4rOHipEbOFuP5dZ8XqOSYMDj92N9YrgPDWDMIo9IkOfpLt2y%2Bs8v-Uragq1tD10nimu9dlOv4wl%2BvYasRuTaTkH6RTjyYmoGJM1tQKTGSvawk50hWdIHB4uMpF4nAsfjBDotcuLptw3iKqjB6VvoyomzFV5LXhVjztF9Fb3l4lKXG9dsPS3nagF5MNctaXW3lyolfddXOu16l9dJfsPsVrp5NzZTIBwK5eK02gVkIUnrMqBwHOy1t7fYjTTZwEwaj8Jnc7N1LtUW%2BZoxI81rVRXSZJeU7OO5XjQNl19kxN9D1Vw6Ma%2BFk76xRVl9Z%2BKhX7a3fkrYavdv4kynjNAyRlUA%2BXtBwQBhgCQcFhHbNCpVhyTg5nsE6yFSR829uQLO-kboAKAY7RqyMS7vXVthYEUCXYwN1kVL6B0J4gHfFDCW-9paAK9usRhuUXrd1YRjAkHCq5vwGm7ekJUFECLAr7ae-tZ6PF7EYSYqwVCEjAKsPEkdMFkl5sSAkAEmCTA4OsOKhgl5XT-nQ1u6h25SIGlSQuo06SxUdko6BA11ad2kGSQJvZf4iM8cFCxm1OxF38ZE0qyUTGcKLhEhK0SxocknjpZBAcyDrCYCnKEqw3DbwbjCI6HNpAnSJPaUYVZxjkTAONQp1Dz4eJbokxKyEoSpJao7XWfZATZJ1v4%2BK7dPr5TiTnVuQy1AjJmWM96Q1JmbFCVwvxLU5mlXRoNRBxSZ6oJABYpO%2BFj4cxPl2Qc1i8IFWBGsYWUUEJgBUO4%2BJAyZbjlBgrbhuTAYfRULfPZOSSo5QUdhfuSzRGJMBdMaFoMtnWV7pCweyiAbq1vqrSY8KqFaKQRc%2BaZAGYejZpzHBHBzHkjztFNAUIGlwB2sfPEgI4or1%2Bcs5FJ0I5os7iCFGVJ0VQp1urcZ0SwZe0RQkgFgrIFSrpCKuV4rO6SpBQ7d6srDZnLJroy5ExDDrFwVSLmiE1YzCJB2AqrLOw4gwSoUkItenZyRTLJpaxO7DwxsDRlrMFX-Lzh2f4XdvrFVZcGopRrZqXLQIne6jYwZ7zgOSVkVJxgHwUVCFkS8-ikgZHyr1YbfWRvitGrsmMcVhIBtFVqazyS1x6UIk2ZafURv9VGu2NbpncMbXMy1rbDV%2BwTRS1AkinGJwAgSMxcVyTrDgFtFkowt4MgeuNXEiRcq-MaIEYIoRwhAViHMXo-RjRZByG%2BeSn4D3NGPW0HcXQLgXqNIME0Y6dETrngQj0FktobAZayxI1JAF2UmJiIxeIMHxzYKWxVeJfgQoJTq1qajVhNQEe2i%2BZsUP7WhRh2u2Hv0lL0WQdlR8PLGOpFUjNXMc3UmBFZM6eJRg9lWAXRCPyz6eqQx6ExwLwktUgQOFqANsW-XrdZImpcCr-DhSGy%2BAKI55yI2JwkA0pNa32Xi2RtrFNErI%2BSueXKOCOkWtFCy2CuZqDsiy9sdjnFeWFunDEAixa0NDYJ9TqqX7ie08ps2vnhP6YC1pyTJnjWTpAOZZsZkiJ0laVvfNsHt7lw8k2E%2BEcexVMQz5mDmwNkBMJLlckvHBF3rw7nD05jivcLSQlMrkdKukvOTFue452MXSbGMpprNcHUg4BUuxK77STB2ivMyp8PXeZUxYorozSvWVawOg5EKIqvK7D-W9lV%2BkLbqwhZbkSWsVfWwDfxBLttq2i7%2Bx4C9-hMHtJRFqpkKuKfWBbEGGxGQqjAKyCyBWVN1TCiAw5bUgmNz28I-lIV6rCZkRh9q0OnhaTJf7G4IARCICsGkEMehjigEFJlCA2hlCCGEPPbiWZKdwFwMEQUFOhD05ANoCAcAIwCBZ7gdnnPeT%2BCZ9zog5gaDVHgGQSAUlqC0AjHoRAIpHjkSIt5elbYBxrW7MVMim8cIqnjshwi5quC4Fl-LhAAA5awtgAAiEBygAHV9DiGoCwNgnANxZgHAOIxFkpiKgtlMNyuAdqvAAKoICwKgQIMARAUGQAAegT0wWgPBaCGH0IqJSDF5cEEGFADgxBLB46YBQRU9BxAJ%2BeIiCgCfldeS0NFUYGvtra6Flve0%2BuE4MzQMbhPlF6sVKpBwG2fYYStKJBx-xjJg7p3ZUyDO5w0Bx%2BvHARXZBxhgCrJ3k%2BCinXkhHx346dkODSDgES9dXGwBs1d8vigq-JTEBx2QC04geS4AAiviEvInwu9QD7waZvW-L-OAK3GwRSB4AkCgAKX8KwOxMDFID9IYU0AkcoU9eAHCF4IwAkFIV3NiEQZ8ZA9fVAUIHaC6VOakUGMfJOQkJaYqB0BOBgs6DgYmD-O-VfCgMPV-GQXAB4OARYXkcXWwFPDoX2XAGIdIcSHgRYHSb3LlDYNuRUNZZxWWUYTQJgBwcnAAeTl2DGREuXr1Vybxby1zDnbz10Gm7yNw4BNxAGL1t3tydycGoHaDQGgDIG4kVAjGdwAAFs8zxCdupnw4By8EAXdTAsdHACCYAbd3B9DYsMQsR%2BYhwSRI5KRmNaR6RGRmRWRJh2RgcaptxCw4B5QlQVQ1RNQdR9RDQBhkCzRX8jx9AbQYwYhHRnRXQYB3RPQCBvQij-QEBAxycEACdwwoxMBYwSiEwYgkwUwYdPxYDn1iiIgSwLg7sUFYsGwmwWwrJ2xOxtpex%2BxBx%2BxRxiJJxpwCigo1xNwijgJSj9xyhDxjxTxzwOijxrwHBohJiHwnwXw4loDFwFioAAJFjgI1jSlUAEIkIUIFF0JMIGYcI8ICIiIKQ0BSJyJKJfk6JlJygmJzQSiNQ2I0xTQCSuIeJ4Byg%2BJrdBIEBhIxIJIEApJZI5jFJ6IVI1I4hVi41x11i54TJLIb4rIbI7IuZHJiRDoiRXJ3JPJvJfI%2BN5tbpQcGppFmEq0UdOptUVFP4QYxoJoqt9s-kQdQolTH575VSod1S609NYECZ1FxowSKN-8loVpux1oPpuxdpiR9oFEjoTo1lzpLo5SasxF7pHpwdUZd4vpa1pMrSeFA1QZwZgt6EEYnomFmpwyFlvoNSP44E1UEyuSf0eTHhqZaYj54SmYWZx87JOZuYyI%2BZcRAQiVhYLjW45Z1gwtrZbY1ZdUszrT3ZWYDVmSDszZWz2ywVOz7YNYezYz4yDZ5V8zyNLkg4Q49hmMI4l1o5iRY46QE4k5JFU4mB05mzBl25C5-UWEy5n4B5oyu465olx5EyVkTy-VB0DNe5LyLsFlbz5EVR7TLkF5Dpl5V4yI7ZzDeY0YIMD4PJj5ZsvMgyr4JE0MTTQEIpwFRMPzpz4E1UHz4Kb5wcH5UKX4pzVFMLQZfzYt0FMFykM1cFo0CF%2BxiEmQ1l4sKFhwjy7oJFfEkdNhRUG5FFLSi5VE%2BENFsL2LzJOLmFuK2ENF0LBL1FgQyK54DEMRjFTFzFLEC5t5bF7FHFnESQ4A3FAyhzatklfFLsWp0kocskpzckolbS21qsjKvETKTsEoMlgl0KbL8kl0FLHhylKlqkqy85sJ6krJYRmkHQ2liROluk2KgrhlltxltkFFdl%2BKSsjkFlTlByDSzZVl1lGtNkJlkr0LZl3pjkmoSV0cOt7t4I4pmwSQtok5RtWULEOYXkNF3lvl6tvlYqUVRzQUCpwUdMh4dVRpYUiUK4RKLFBU%2Bq1UMVBqPKYVCViUfLKUhYiV8Jh96VHk1EWU2UOU1AuVdLeVDLsratlVhU5FVhNUFqNZyt4y5y9TYcy0UUVURr1UxVZrrLdU7q5UKqppuTwSQBTVWQLV7JrUEYCpHMHV2M6yXU3VYqu1nyBpIzA0Y0YRJrEbK1Uaa0Vq0Fk1uxXJrJAEGMs0OZc1Jh819KmxVhi0QI5s4LvVw0kaG0A1q1WZ0Kh13oR0UZ7L9S4dy1u0Xze0g0YQOaIdm0qkebcaQBp1JESQ7IF1grl1V0mYN04At180wBd1KtYLUAH0j1Wh0COSehEDaiv0sr9aWgT0ZRgJz1Tar1ih5zTNA4HIAMVzgNHkwMLJsQFFoNzE4MeA0BYqCNELwsq0SNMVJqQ6iNw6UZSMnbOsHtHRj4KIyR7oGR7ImMgRd82Mp8uMS5cIeq1MZqIsJMiaFrzyFMwZjMsr%2BbQsNNmsy724K75MUZq7xhpbzNLMXtwNbNj4HMOwqQmAXMvJr9ql5KTq67i6G7Asota7nrp7-NNMm6ZwE7qr-9kIWwRxokUtyQk01peZMsF5NoHE8JxpF9dbTqvElsStTtVsKtJqjsGsNs77ysxxpbutAEt9e4w1BtsJzVRtDBmxJscQEhY4i76sXLxM37IEpyrsttvTbt56BMb78qVsYHiqWprtEGHppbHs0IXs1phZLIPswYvtfg6Rfs8EAcvtV76bHLaojTEcVTIdkofzkH-lFTmHTTWGOpNFKr41oIsc3dYgOBPdVwHQnQyAAApDMcoKEbAd0d%2BcoUGVQKhCQmAKQ-gowCRtomRuRhRpR8cFRyYNR94L4OAXRqR1AFQRUIWcoAAcQACFqA0hYjqhERhdoIgA) contains the testing data for this package.