diff --git a/datamint/entities/annotations/__init__.py b/datamint/entities/annotations/__init__.py
index 31a57f8e..1fbe4705 100644
--- a/datamint/entities/annotations/__init__.py
+++ b/datamint/entities/annotations/__init__.py
@@ -1,9 +1,13 @@
 from .image_classification import ImageClassification
+from .image_segmentation import ImageSegmentation
 from .annotation import Annotation
+from .volume_segmentation import VolumeSegmentation
 from datamint.api.dto import AnnotationType # FIXME: move this to this module
 
 __all__ = [
     "ImageClassification",
+    "ImageSegmentation",
     "Annotation",
+    "VolumeSegmentation",
     "AnnotationType",
 ]
diff --git a/datamint/entities/annotations/annotation.py b/datamint/entities/annotations/annotation.py
index bc3ac293..bbed2240 100644
--- a/datamint/entities/annotations/annotation.py
+++ b/datamint/entities/annotations/annotation.py
@@ -122,9 +122,14 @@ class Annotation(AnnotationBase):
     def __init__(self, **data):
         """Initialize the annotation entity."""
         super().__init__(**data)
-        self._cache: CacheManager = CacheManager('annotations')
         self._resource: 'Resource | None' = None
 
+    @property
+    def _cache(self) -> CacheManager[bytes]:
+        if not hasattr(self, '__cache'):
+            self.__cache = CacheManager[bytes]('annotations')
+        return self.__cache
+
     @property
     def resource(self) -> 'Resource':
         """Lazily load and cache the associated Resource entity."""
diff --git a/datamint/entities/annotations/image_segmentation.py b/datamint/entities/annotations/image_segmentation.py
new file mode 100644
index 00000000..7abc1afa
--- /dev/null
+++ b/datamint/entities/annotations/image_segmentation.py
@@ -0,0 +1,252 @@
+"""Image segmentation annotation entity module for DataMint API.
+
+This module defines the ImageSegmentation class for representing 2D segmentation
+annotations in medical images.
+"""
+
+from .annotation import Annotation
+from datamint.api.dto import AnnotationType
+import numpy as np
+from PIL import Image
+from pydantic import PrivateAttr
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ImageSegmentation(Annotation):
+    """
+    Image-level (2D) segmentation annotation entity.
+    
+    Represents a 2D segmentation mask for a single 2d image.
+    Supports both binary segmentation (single class) and multi-class 
+    semantic segmentation.
+    
+    This class provides factory methods to create annotations from numpy 
+    arrays or PIL Images, which can then be uploaded via AnnotationsApi.
+    
+    Example:
+        >>> # From binary mask
+        >>> mask = np.zeros((256, 256), dtype=np.uint8)
+        >>> mask[100:150, 100:150] = 1  # lesion region
+        >>> img_seg = ImageSegmentation.from_mask(
+        ...     mask=mask,
+        ...     name='lesion'
+        ... )
+        >>> 
+        >>> # Upload via API
+        >>> api.annotations.upload_segmentations(
+        ...     resource='resource_id',
+        ...     file_path=img_seg.mask,
+        ...     name=img_seg.name
+        ... )
+    """
+
+    _mask: np.ndarray | Image.Image | None = PrivateAttr(default=None)
+    _class_name: str | None = PrivateAttr(default=None)
+
+    def __init__(self,
+                 name: str | None = None,
+                 mask: np.ndarray | Image.Image | None = None,
+                 **kwargs):
+        """
+        Initialize an ImageSegmentation annotation.
+        
+        Args:
+            name: The name/label for this segmentation class
+            mask: Optional 2D numpy array or PIL Image containing the segmentation mask
+            **kwargs: Additional fields passed to parent Annotation class
+        """
+        super().__init__(
+            identifier=name or "",
+            scope='image',
+            annotation_type=AnnotationType.SEGMENTATION,
+            **kwargs
+        )
+        
+        self._mask = mask
+        self._class_name = name
+
+    @classmethod
+    def from_mask(cls,
+                  mask: np.ndarray | Image.Image,
+                  name: str,
+                  **kwargs) -> 'ImageSegmentation':
+        """
+        Create ImageSegmentation from a binary or class mask.
+        
+        Args:
+            mask: 2D numpy array (H x W) with integer labels or binary values,
+                or a PIL Image
+            name: The name/label for this segmentation
+            **kwargs: Additional annotation fields (imported_from, model_id, etc.)
+        
+        Returns:
+            ImageSegmentation instance ready for upload
+        
+        Raises:
+            ValueError: If mask shape is invalid or data types are incorrect
+        
+        Example:
+            >>> mask = np.zeros((512, 512), dtype=np.uint8)
+            >>> mask[200:300, 200:300] = 255  # binary mask
+            >>> img_seg = ImageSegmentation.from_mask(
+            ...     mask=mask,
+            ...     name='tumor',
+            ... )
+        """
+        # Convert PIL Image to numpy if needed
+        if isinstance(mask, Image.Image):
+            mask_array = np.array(mask)
+        else:
+            mask_array = mask
+        
+        # Validate mask array
+        mask_array = cls._validate_mask_array(mask_array)
+        
+        instance = cls(
+            name=name,
+            mask=mask_array,
+            **kwargs
+        )
+        
+        return instance
+
+    @staticmethod
+    def _validate_mask_array(arr: np.ndarray) -> np.ndarray:
+        """
+        Validate mask array shape and dtype.
+        
+        Args:
+            arr: Input array to validate
+        
+        Returns:
+            Validated array (possibly with dtype conversion)
+        
+        Raises:
+            ValueError: If array is invalid
+        """
+        if not isinstance(arr, np.ndarray):
+            raise ValueError(f"Expected numpy array, got {type(arr)}")
+        
+        # Check dimensionality - should be 2D (H x W)
+        if arr.ndim != 2:
+            raise ValueError(
+                f"Mask must be 2D (H x W), got shape {arr.shape}"
+            )
+        
+        # Check dtype - convert floats to int if they're effectively integers
+        if np.issubdtype(arr.dtype, np.floating):
+            if not np.allclose(arr, arr.astype(int)):
+                raise ValueError(
+                    "Mask array contains non-integer float values"
+                )
+            arr = arr.astype(np.uint8)
+        elif not np.issubdtype(arr.dtype, np.integer):
+            raise ValueError(
+                f"Mask must have integer dtype, got {arr.dtype}"
+            )
+        
+        # Check for negative values
+        if np.any(arr < 0):
+            raise ValueError("Mask array contains negative values")
+        
+        return arr
+
+    @property
+    def mask(self) -> np.ndarray | None:
+        """
+        Get the stored segmentation mask.
+        
+        Returns:
+            2D numpy array or None if not stored
+        """
+        return self._mask
+
+    @property
+    def mask_shape(self) -> tuple[int, int] | None:
+        """
+        Get the shape of the stored mask.
+        
+        Returns:
+            Shape tuple (H, W) or None if no mask stored
+        """
+        if self._mask is None:
+            return None
+        
+        if isinstance(self._mask, Image.Image):
+            return (self._mask.height, self._mask.width)
+        
+        return self._mask.shape
+
+    @property
+    def class_name(self) -> str | None:
+        """
+        Get the class name for this segmentation.
+        
+        Returns:
+            Class name string or None
+        """
+        return self._class_name
+
+    @property
+    def name(self) -> str | None:
+        """
+        Alias for class_name.
+        
+        Returns:
+            Class name string or None
+        """
+        return self._class_name
+
+    def to_pil_image(self) -> Image.Image | None:
+        """
+        Convert the mask to a PIL Image.
+        
+        Returns:
+            PIL Image or None if no mask stored
+        """
+        if self._mask is None:
+            return None
+        
+        if isinstance(self._mask, Image.Image):
+            return self._mask
+        
+        return Image.fromarray(self._mask)
+
+    def get_binary_mask(self, threshold: int = 0) -> np.ndarray | None:
+        """
+        Get a binary version of the mask.
+        
+        Args:
+            threshold: Values above this threshold are set to 1
+        
+        Returns:
+            Binary numpy array (0s and 1s) or None if no mask stored
+        """
+        if self._mask is None:
+            return None
+        
+        if isinstance(self._mask, Image.Image):
+            mask_array = np.array(self._mask)
+        else:
+            mask_array = self._mask
+        
+        return (mask_array > threshold).astype(np.uint8)
+
+    def get_area(self) -> int | None:
+        """
+        Get the area (number of positive pixels) of the mask.
+        
+        Returns:
+            Number of non-zero pixels or None if no mask stored
+        """
+        if self._mask is None:
+            return None
+        
+        if isinstance(self._mask, Image.Image):
+            mask_array = np.array(self._mask)
+        else:
+            mask_array = self._mask
+        
+        return int(np.count_nonzero(mask_array))
diff --git a/datamint/entities/annotations/volume_segmentation.py b/datamint/entities/annotations/volume_segmentation.py
new file mode 100644
index 00000000..f9995392
--- /dev/null
+++ b/datamint/entities/annotations/volume_segmentation.py
@@ -0,0 +1,273 @@
+"""Volume segmentation annotation entity module for DataMint API.
+
+This module defines the VolumeSegmentation class for representing 3D segmentation
+annotations in medical imaging volumes.
+"""
+
+from .annotation import Annotation
+from datamint.api.dto import AnnotationType
+import numpy as np
+from nibabel.nifti1 import Nifti1Image
+from pydantic import PrivateAttr
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class VolumeSegmentation(Annotation):
+    """
+    Volume-level segmentation annotation entity.
+    
+    Represents a 3D segmentation mask for medical imaging volumes.
+    Supports both semantic segmentation (class per voxel) and instance 
+    segmentation (unique ID per object).
+    
+    This class provides factory methods to create annotations from numpy 
+    arrays or NIfTI images, which can then be uploaded via AnnotationsApi.
+    
+    Example:
+        >>> # From semantic segmentation
+        >>> seg_data = np.array([...])  # Shape: (H, W, D)
+        >>> class_map = {1: 'tumor', 2: 'edema'}
+        >>> vol_seg = VolumeSegmentation.from_semantic_segmentation(
+        ...     segmentation=seg_data,
+        ...     class_map=class_map
+        ... )
+        >>> 
+        >>> # Upload via API
+        >>> api.annotations.upload_segmentations(
+        ...     resource='resource_id',
+        ...     file_path=vol_seg.segmentation_data,
+        ...     name=vol_seg.class_map
+        ... )
+    """
+
+    raw_data: bytes | None = None
+
+    _segmentation_data: np.ndarray | Nifti1Image = PrivateAttr()
+    _class_map: dict[int, str] = PrivateAttr()
+
+    
+    def __init__(self,
+                 **kwargs):
+        """
+        Initialize a VolumeSegmentation annotation.
+        
+        Args:
+            **kwargs: Additional fields passed to parent Annotation class
+        """
+        kwargs['scope'] = 'image'
+        kwargs['annotation_type'] = AnnotationType.SEGMENTATION
+        
+        super().__init__(
+            identifier="",
+            **kwargs
+        )
+        
+    @classmethod
+    def from_semantic_segmentation(cls,
+                                   segmentation: np.ndarray | Nifti1Image,
+                                   class_map: dict[int, str] | str,
+                                   **kwargs) -> 'VolumeSegmentation':
+        """
+        Create VolumeSegmentation from semantic segmentation data.
+        
+        Semantic segmentation: each voxel has a single integer label 
+        corresponding to its class.
+        
+        Args:
+            segmentation: 3D numpy array (H x W x D) or Nifti1Image with 
+                integer labels representing classes
+            class_map: Mapping from label integers to class names, or a 
+                single class name for binary segmentation (background=0, class=1)
+            **kwargs: Additional annotation fields (imported_from, model_id, etc.)
+        
+        Returns:
+            VolumeSegmentation instance ready for upload
+        
+        Raises:
+            ValueError: If segmentation shape is invalid, class_map is incomplete,
+                or data types are incorrect
+        
+        Example:
+            >>> seg = np.zeros((256, 256, 128), dtype=np.int32)
+            >>> seg[100:150, 100:150, 50:75] = 1  # tumor region
+            >>> vol_seg = VolumeSegmentation.from_semantic_segmentation(
+            ...     segmentation=seg,
+            ...     class_map={1: 'tumor'}, # or just ``class_map='tumor'``
+            ... )
+        """
+        # Step 1: Convert Nifti1Image to numpy if needed
+        if isinstance(segmentation, Nifti1Image):
+            seg_array = segmentation.get_fdata().astype(np.int32)
+        else:
+            seg_array = segmentation
+        
+        # Step 2: Validate segmentation array
+        seg_array = cls._validate_segmentation_array(seg_array)
+        
+        # Step 3: Standardize class_map to dict[int, str]
+        standardized_class_map = cls._standardize_class_map(class_map, seg_array)
+        
+        instance = cls(**kwargs)
+        
+        instance._segmentation_data = segmentation
+        instance._class_map = standardized_class_map
+        
+        return instance
+
+    @staticmethod
+    def _validate_segmentation_array(arr: np.ndarray) -> np.ndarray:
+        """
+        Validate segmentation array shape and dtype.
+        
+        Args:
+            arr: Input array to validate
+        
+        Returns:
+            Validated array (possibly with dtype conversion)
+        
+        Raises:
+            ValueError: If array is invalid
+        """
+        if not isinstance(arr, np.ndarray):
+            raise ValueError(f"Expected numpy array, got {type(arr)}")
+        
+        # Check dimensionality
+        if arr.ndim != 3:
+            raise ValueError(
+                f"Segmentation must be 3D (H x W x D), got shape {arr.shape}"
+            )
+        
+        # Check dtype
+        if not np.issubdtype(arr.dtype, np.integer):
+            # Try to convert to int
+            if np.issubdtype(arr.dtype, np.floating):
+                # Check if values are effectively integers
+                if not np.allclose(arr, arr.astype(int)):
+                    raise ValueError(
+                        "Segmentation array contains non-integer float values"
+                    )
+                arr = arr.astype(np.int32)
+            else:
+                raise ValueError(
+                    f"Segmentation must have integer dtype, got {arr.dtype}"
+                )
+        
+        # Check for negative values
+        if np.any(arr < 0):
+            raise ValueError("Segmentation array contains negative values")
+        
+        return arr
+
+    @staticmethod
+    def _standardize_class_map(
+        class_map: dict[int, str] | str,
+        segmentation: np.ndarray
+    ) -> dict[int, str]:
+        """
+        Convert class_map to standard dict[int, str] format.
+        
+        Args:
+            class_map: Either a dict or a single class name for binary seg
+            segmentation: The segmentation array to infer labels from
+        
+        Returns:
+            Standardized dictionary mapping labels to class names
+        
+        Raises:
+            ValueError: If class_map format is invalid
+        """
+        if isinstance(class_map, str):
+            # Binary segmentation: assume label 1 = class_map, 0 = background
+            unique_labels = np.unique(segmentation)
+            unique_labels = unique_labels[unique_labels > 0]  # Exclude 0
+            
+            if len(unique_labels) != 1:
+                raise ValueError(
+                    f"Single class name provided but segmentation has "
+                    f"{len(unique_labels)} non-zero labels: {unique_labels.tolist()}"
+                )
+            
+            return {int(unique_labels[0]): class_map}
+        
+        elif isinstance(class_map, dict):
+            # Validate all keys are integers, all values are strings
+            standardized = {}
+            for k, v in class_map.items():
+                if not isinstance(k, (int, np.integer)):
+                    raise ValueError(f"class_map key must be integer, got {type(k)}")
+                if not isinstance(v, str):
+                    raise ValueError(f"class_map value must be string, got {type(v)}")
+                standardized[int(k)] = v
+            
+            return standardized
+        
+        else:
+            raise ValueError(
+                f"class_map must be dict[int, str] or str, got {type(class_map)}"
+            )
+
+
+
+    @property
+    def volume_shape(self) -> tuple[int, int, int] | None:
+        """
+        Get the shape of the stored segmentation volume.
+        
+        Returns:
+            Shape tuple (H, W, D) or None if no data stored
+        """
+        if self._segmentation_data is None:
+            return None
+        
+        if isinstance(self._segmentation_data, Nifti1Image):
+            shape = self._segmentation_data.shape
+            return (shape[0], shape[1], shape[2])
+        else:
+            return self._segmentation_data.shape
+
+    @property
+    def class_names(self) -> list[str] | None:
+        """
+        Get list of class names from stored class_map.
+        
+        Returns:
+            List of class names or None if no class_map stored
+        """
+        if self._class_map is None:
+            return None
+        return sorted(self._class_map.values())
+
+    @property
+    def num_classes(self) -> int | None:
+        """
+        Get number of classes in this segmentation.
+        
+        Returns:
+            Number of classes or None if no class_map stored
+        """
+        if self._class_map is None:
+            return None
+        return len(self._class_map)
+
+    @property
+    def class_map(self) -> dict[int, str]:
+        """
+        Get the stored class map.
+        
+        Returns:
+            Dictionary mapping labels to class names, or None
+        """
+        return self._class_map
+
+    @property
+    def segmentation_data(self) -> np.ndarray | Nifti1Image:
+        """
+        Get the stored segmentation data.
+        
+        Returns:
+            Segmentation array/image or None if not stored
+        """
+        return self._segmentation_data
+
diff --git a/datamint/entities/resource.py b/datamint/entities/resource.py
index 6e2c1c12..0bf5df75 100644
--- a/datamint/entities/resource.py
+++ b/datamint/entities/resource.py
@@ -113,7 +113,12 @@ def __new__(cls, *args, **kwargs):
     def __init__(self, **data):
         """Initialize the resource entity."""
         super().__init__(**data)
-        self._cache: CacheManager[bytes] = CacheManager[bytes]('resources')
+
+    @property
+    def _cache(self) -> CacheManager[bytes]:
+        if not hasattr(self, '__cache'):
+            self.__cache = CacheManager[bytes]('resources')
+        return self.__cache
 
     def fetch_file_data(
         self,
@@ -386,7 +391,6 @@ def __init__(self,
                     raw_data=raw_data,
                     **new_kwargs
                 )
-                self._cache = None
                 return
 
         if convert_to_bytes and local_filepath:
@@ -426,7 +430,6 @@ def __init__(self,
                 raw_data=raw_data,
                 **new_kwargs
             )
-            self._cache = None
         elif local_filepath is not None:
             file_path = Path(local_filepath)
             if not file_path.exists():
@@ -459,7 +462,6 @@ def __init__(self,
                 local_filepath=str(file_path),
                 raw_data=None,
             )
-            self._cache = None
 
     def fetch_file_data(
         self, *args,
diff --git a/datamint/mlflow/flavors/datamint_flavor.py b/datamint/mlflow/flavors/datamint_flavor.py
index 87398dae..2ceda099 100644
--- a/datamint/mlflow/flavors/datamint_flavor.py
+++ b/datamint/mlflow/flavors/datamint_flavor.py
@@ -5,7 +5,7 @@
 from mlflow import pyfunc
 from .model import DatamintModel
 import logging
-from typing import Sequence
+from collections.abc import Sequence
 from dataclasses import asdict
 from packaging.requirements import Requirement
 
@@ -29,7 +29,6 @@ def save_model(datamint_model: DatamintModel,
                extra_pip_requirements=None,
                metadata=None,
                model_config=None,
-               example_no_conversion=None,
                streamable=None,
                **kwargs):
     import medimgkit
@@ -94,7 +93,6 @@ def _get_req_name(req):
         extra_pip_requirements=extra_pip_requirements,
         metadata=metadata,
         model_config=model_config,
-        example_no_conversion=example_no_conversion,
         streamable=streamable,
         **kwargs
     )
@@ -103,11 +101,10 @@ def _get_req_name(req):
 def log_model(
     datamint_model: DatamintModel,
     supported_modes: Sequence[str] | None = None,
-    artifact_path: str = "datamint_model",
+    name: str = "datamint_model",
     data_path=None,
     code_paths=None,
     infer_code_paths=False,
-    conda_env=None,
     artifacts=None,
     registered_model_name: str | None = None,
     signature: ModelSignature | None = None,
@@ -116,20 +113,17 @@ def log_model(
     extra_pip_requirements=None,
     metadata=None,
     model_config=None,
-    example_no_conversion=None,
-    streamable=None,
     **kwargs
 ):
     return Model.log(
         datamint_model=datamint_model,
         supported_modes=supported_modes,
-        artifact_path=artifact_path,
+        name=name,
         flavor=datamint.mlflow.flavors.datamint_flavor,
         # loader_module=loader_module,
         data_path=data_path,
         code_paths=code_paths,
         artifacts=artifacts,
-        conda_env=conda_env,
         registered_model_name=registered_model_name,
         signature=signature,
         input_example=input_example,
@@ -137,8 +131,6 @@ def log_model(
         extra_pip_requirements=extra_pip_requirements,
         metadata=metadata,
         model_config=model_config,
-        example_no_conversion=example_no_conversion,
-        streamable=streamable,
         infer_code_paths=infer_code_paths,
         **kwargs
     )
diff --git a/datamint/mlflow/flavors/model.py b/datamint/mlflow/flavors/model.py
index eb16e6b9..e75f6984 100644
--- a/datamint/mlflow/flavors/model.py
+++ b/datamint/mlflow/flavors/model.py
@@ -22,7 +22,6 @@
 logger = logging.getLogger(__name__)
 
 # Type aliases
-# AnnotationList: TypeAlias = Sequence[Annotation]
 PredictionResult: TypeAlias = list[list[Annotation]]
 
 
@@ -159,6 +158,7 @@ def predict_default(self, model_input, **kwargs):
     """
 
     LINKED_MODELS_DIR = "linked_models"
+    _CACHED_ATTRS = ['_mlflow_models', '_mlflow_torch_models', '_inference_device']
 
     def __init__(self,
                  settings: ModelSettings | dict[str, Any] | None = None,
@@ -214,16 +214,18 @@ def _get_linked_models_uri(self) -> dict[str, Any]:
 
     def _clear_linked_models_cache(self):
         """Clear loaded linked models to free memory"""
-        if hasattr(self, '_mlflow_models'):
-            del self._mlflow_models
-        if hasattr(self, '_mlflow_torch_models'):
-            del self._mlflow_torch_models
+        
+        for attr in self._CACHED_ATTRS:
+            if hasattr(self, attr):
+                delattr(self, attr)
+        
 
     def __getstate__(self):
         state = self.__dict__.copy()
 
-        state.pop('_mlflow_models', None)
-        state.pop('_mlflow_torch_models', None)
+        for attr in self._CACHED_ATTRS:
+            if attr in state:
+                del state[attr]
 
         return state
 
diff --git a/datamint/mlflow/lightning/callbacks/modelcheckpoint.py b/datamint/mlflow/lightning/callbacks/modelcheckpoint.py
index 0a26b1df..a9a02dee 100644
--- a/datamint/mlflow/lightning/callbacks/modelcheckpoint.py
+++ b/datamint/mlflow/lightning/callbacks/modelcheckpoint.py
@@ -123,7 +123,6 @@ def _should_register_model(self) -> bool:
         # If state changed (signature, checkpoint, etc.), register
         current_state_hash = self._compute_registration_state_hash()
         if current_state_hash != self._last_registered_state_hash:
-            _LOGGER.debug("Model state has changed since last registration, will register.")
             return True
 
         _LOGGER.info("Model already registered with same configuration. Skipping registration.")
@@ -169,7 +168,6 @@ def _infer_params(self, model: nn.Module) -> tuple[dict, ...]:
             return ()
 
     def _save_checkpoint(self, trainer: L.Trainer, filepath: str) -> None:
-        _LOGGER.debug(f"Saving checkpoint to {filepath}...")
         trainer.save_checkpoint(filepath, self.save_weights_only)
 
         self._last_global_step_saved = trainer.global_step
@@ -180,7 +178,6 @@ def _save_checkpoint(self, trainer: L.Trainer, filepath: str) -> None:
             for logger in trainer.loggers:
                 logger.after_save_checkpoint(proxy(self))
                 if isinstance(logger, MLFlowLogger) and not self.log_model_at_end_only:
-                    _LOGGER.debug(f"_save_checkpoint: Logging model to MLFlow at {filepath}...")
                     self.log_model_to_mlflow(trainer.model, run_id=logger.run_id)
 
     def log_additional_metadata(self, logger: MLFlowLogger | L.Trainer,
@@ -229,10 +226,9 @@ def log_model_to_mlflow(self,
         if not any('lightning' in req.lower() for req in requirements):
             requirements.append(f'lightning=={L.__version__}')
 
-        _LOGGER.debug(f"log_model_to_mlflow: Logging model to MLFlow at {self._last_checkpoint_saved}...")
         modelinfo = mlflow.pytorch.log_model(
             pytorch_model=model,
-            artifact_path=f'model/{Path(self._last_checkpoint_saved).stem}',
+            name=Path(self._last_checkpoint_saved).stem,
             signature=self._inferred_signature,
             run_id=run_id,
             extra_pip_requirements=requirements,
@@ -286,22 +282,14 @@ def _update_signature(self, trainer):
             _LOGGER.warning("No model URI found. Cannot update signature.")
             return
 
-        mllogger = _get_MLFlowLogger(trainer)
-        mlclient = mllogger._mlflow_client
-
-        # check if the model exists
-        for artifact_info in mlclient.list_artifacts(run_id=mllogger.run_id):
-            if artifact_info.path.startswith('model'):
-                break
-        else:
-            _LOGGER.warning(f"Model URI {self._last_model_uri} does not exist. Cannot update signature.")
-            return
-        _LOGGER.debug(f"Updating signature for model URI: {self._last_model_uri}...")
         # update the signature
-        mlflow.models.set_signature(
-            model_uri=self._last_model_uri,
-            signature=self._inferred_signature,
-        )
+        try:
+            mlflow.models.set_signature(
+                model_uri=self._last_model_uri,
+                signature=self._inferred_signature,
+            )
+        except mlflow.exceptions.MlflowException as e:
+            _LOGGER.warning(f"Failed to update model signature. Check if model actually exists. {e}")
 
     def __wrap_forward(self, pl_module: nn.Module):
         original_forward = pl_module.forward
@@ -333,6 +321,10 @@ def wrapped_forward(x, *args, **kwargs):
     def on_train_start(self, trainer, pl_module):
         self._has_been_trained = True
         self.__wrap_forward(pl_module)
+        logger = _get_MLFlowLogger(trainer)
+        if logger.experiment_id is not None:
+            mlflow.set_experiment(experiment_id=logger.experiment_id)
+        super().on_train_start(trainer, pl_module)
 
     def on_train_end(self, trainer: L.Trainer, pl_module: L.LightningModule) -> None:
         super().on_train_end(trainer, pl_module)
@@ -350,17 +342,33 @@ def on_train_end(self, trainer: L.Trainer, pl_module: L.LightningModule) -> None
             self.register_model(trainer)
 
     def _restore_model_uri(self, trainer: L.Trainer) -> None:
+        """Restore the last model URI from the trainer's checkpoint path.
+        """
         logger = _get_MLFlowLogger(trainer)
+        self._last_model_uri = None
+        self.last_saved_model_info = None
         if logger is None:
             _LOGGER.warning("No MLFlowLogger found. Cannot restore model URI.")
             return
         if trainer.ckpt_path is None:
             return
-        extracted_run_id = Path(trainer.ckpt_path).parts[1]
-        if extracted_run_id != logger.run_id:
-            _LOGGER.warning(f"Run ID mismatch: {extracted_run_id} != {logger.run_id}." +
+        if logger.run_id is None:
+            _LOGGER.warning("MLFlowLogger has no run_id. Cannot restore model URI.")
+            return
+        if logger.run_id not in str(trainer.ckpt_path):
+            _LOGGER.warning(f"Run ID mismatch between checkpoint path and MLFlowLogger." +
                             " Check `run_id` parameter in MLFlowLogger.")
-        self._last_model_uri = f'runs:/{logger.run_id}/model/{Path(trainer.ckpt_path).stem}'
+            return
+        retrieved_logged_models = mlflow.search_logged_models(
+            filter_string=f"name = '{Path(trainer.ckpt_path).stem[:256]}' AND source_run_id='{logger.run_id[:64]}'",
+            order_by=[{"field_name": "last_updated_timestamp", "ascending": False}],
+            output_format="list"
+        )
+        if not retrieved_logged_models:
+            _LOGGER.warning(f"No logged model found for checkpoint {trainer.ckpt_path}.")
+            return
+        # get the most recent one
+        self._last_model_uri = retrieved_logged_models[0].model_uri
         try:
             self.last_saved_model_info = mlflow.models.get_model_info(self._last_model_uri)
         except mlflow.exceptions.MlflowException as e:
diff --git a/notebooks/use_cases/segmentation_2d-unetpp_BUSI_tutorial.ipynb b/notebooks/use_cases/segmentation_2d-unetpp_BUSI_tutorial.ipynb
index 8188646f..0ac388f2 100644
--- a/notebooks/use_cases/segmentation_2d-unetpp_BUSI_tutorial.ipynb
+++ b/notebooks/use_cases/segmentation_2d-unetpp_BUSI_tutorial.ipynb
@@ -46,7 +46,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "f50baf11",
    "metadata": {},
    "outputs": [],
@@ -72,28 +72,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "fbcd7869",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Using existing project 'UNetPP_Segmentation_Tutorial'\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "Project(id='6c770f6c-6483-4af3-924c-16b122bfc6d5', name='UNetPP_Segmentation_Tutorial', created_at='2025-12-23T14:33:11.807Z', created_by='datamint-dev@mail.com', dataset_id='d8c94f56-0897-428b-8d5a-7b846233522a', worklist_id='9ad15be0-4c6d-4537-ab8b-6464fab5eae4', archived=False, resource_count=780, annotated_resource_count=0, description='Tutorial project for UNet++ segmentation on BTCV dataset', viewable_ai_segs=None, editable_ai_segs=None, closed_resources_count=0, resources_to_annotate_count=0, most_recent_experiment=None, annotators=[{'email': 'datamint-dev@mail.com', 'roles': ['PROJECT_OWNER'], 'status': 'active'}])"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "proj = api.projects.get_by_name(PROJECT_NAME)\n",
     "if proj is None:\n",
@@ -130,18 +112,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "17e40043",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dataset already exists at /tmp/BUSI_dataset\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
     "import requests\n",
@@ -201,19 +175,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "2a6e6673",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Found 780 ultrasound images\n",
-      "Found 780 segmentation masks\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Find image and label paths\n",
     "base_dir = DATA_DIR / \"Dataset_BUSI_with_GT\"\n",
@@ -244,7 +209,8 @@
    "source": [
     "### 2.3 Define Classes\n",
     "\n",
-    "We map the folder names to class indices."
+    "We map class ids to class names for segmentation.\n",
+    "We need this mapping because training labels are stored as integers (not strings) in the masks.\n"
    ]
   },
   {
@@ -254,9 +220,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 0: Background, 1: Benign, 2: Malignant\n",
-    "# Normal images are treated as background (class 0)\n",
-    "NUM_CLASSES = 3 "
+    "# Class mapping for segmentation. \n",
+    "CLASS_NAMES = {\n",
+    "    1: \"benign\",\n",
+    "    2: \"malignant\", \n",
+    "    3: \"normal\",\n",
+    "}\n",
+    "\n",
+    "LABEL_TO_CLASS_NAME = {v: k for k, v in CLASS_NAMES.items()}\n",
+    "NUM_CLASSES = len(CLASS_NAMES)\n",
+    "\n",
+    "print(f\"Number of classes: {NUM_CLASSES}\")"
    ]
   },
   {
@@ -271,32 +245,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "0165e447",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "66418a9eba174404b7d4cefdadff213e",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Uploading resources:   0%|          | 0/780 [00:00<?, ?file/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Uploaded 780 images to Datamint\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Upload images to Datamint\n",
     "uploaded_resources = api.resources.upload_resources(\n",
@@ -324,29 +276,7 @@
    "execution_count": null,
    "id": "78c233a0",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f7834df80a374f35bbe3c3547f9c475c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "  0%|          | 0/780 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Segmentation masks uploaded successfully!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from tqdm.auto import tqdm\n",
     "\n",
@@ -376,19 +306,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 114,
+   "execution_count": null,
    "id": "cb37aa5d",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Resource: normal (95).png\n",
-      "  Number of segmentation annotations: 0\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Verify uploads - inspect a sample resource\n",
     "sample_resource = api.resources.get_list(project_name=PROJECT_NAME, limit=1)[0]\n",
@@ -418,21 +339,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": null,
    "id": "95dadab5",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Total resources: 780\n",
-      "Training: 546\n",
-      "Validation: 117\n",
-      "Test: 117\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import random\n",
     "\n",
@@ -552,28 +462,36 @@
     "import torch\n",
     "from torch.utils.data import Dataset\n",
     "from collections import defaultdict\n",
-    "import cv2\n",
     "import numpy as np\n",
     "\n",
-    "class MedicalSegmentationDataset(Dataset):\n",
+    "class MedicalSegmentationDataset(Dataset[dict]): # dataset that returns dicts\n",
     "    def __init__(\n",
     "        self,\n",
     "        split: str | None = None,\n",
-    "        transforms=None,\n",
+    "        transforms =  None,\n",
     "    ):\n",
+    "        \"\"\"\n",
+    "        Medical Segmentation Dataset for BUSI dataset stored in Datamint.\n",
+    "\n",
+    "        Args:\n",
+    "            split (str | None): One of 'train', 'val', 'test', or None for all data.\n",
+    "            transforms: Albumentations transforms to apply.\n",
+    "            resources (list[Resource] | None): Optional pre-fetched list of resources. If None, fetches from Datamint based on split.\n",
+    "            inference_mode (bool): If True, dataset is used for inference (no masks).\n",
+    "        \"\"\"\n",
     "        self.transforms = transforms\n",
     "        self.num_classes = NUM_CLASSES\n",
     "        \n",
-    "        self.resources = list(api.resources.get_list(\n",
+    "        self.resources = api.resources.get_list(\n",
     "            project_name=PROJECT_NAME,\n",
     "            tags=[f'split:{split}'] if split else None,\n",
-    "        ))\n",
-    "        \n",
+    "        )\n",
+    "            \n",
     "        all_annotations = api.annotations.get_list(\n",
     "            resource=self.resources,\n",
     "            annotation_type='segmentation'\n",
     "        )\n",
-    "        \n",
+    "    \n",
     "        self.resource_annotations = defaultdict(list) # just mapping resource_id -> [annotations]\n",
     "        for ann in all_annotations:\n",
     "            self.resource_annotations[ann.resource_id].append(ann)\n",
@@ -581,68 +499,67 @@
     "    def __len__(self):\n",
     "        return len(self.resources)\n",
     "    \n",
-    "    def __getitem__(self, idx) -> dict:\n",
+    "    def __getitem__(self, idx:int) -> dict:\n",
     "        resource = self.resources[idx]\n",
     "        \n",
     "        # Load image\n",
     "        image = resource.fetch_file_data(auto_convert=True, use_cache=True)\n",
+    "        original_width = image.width\n",
+    "        original_height = image.height\n",
     "        # image is a PIL.Image object\n",
     "        image = np.array(image) # image.shape: (H, W, 3)\n",
-    "        # Convert to grayscale if RGB: (H, W, 3) -> (H, W)\n",
-    "        if image.ndim == 3 and image.shape[2] == 3:\n",
-    "            image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n",
     "        \n",
-    "        # image = normalize_image(image)\n",
-    "        \n",
-    "        # Load mask\n",
+    "        # Load mask if not in inference mode\n",
     "        annotations = self.resource_annotations[resource.id]\n",
-    "        if not annotations:\n",
-    "            mask = np.zeros_like(image, dtype=np.int64)\n",
+    "        if not annotations or 'normal' in resource.filename:\n",
+    "            mask = np.zeros((original_height, original_width), dtype=np.int64)\n",
     "        else:\n",
     "            if len(annotations) > 1:\n",
     "                print(f\"Warning: Resource {resource.filename} has multiple annotations. Using the first one.\")\n",
     "            mask = np.array(annotations[0].fetch_file_data(use_cache=True)).astype(np.int64)\n",
     "        \n",
     "        if self.transforms:\n",
-    "            transformed = self.transforms(image=image, mask=mask)\n",
-    "            image = transformed['image']\n",
-    "            mask = transformed['mask']\n",
+    "            if mask is not None:\n",
+    "                transformed = self.transforms(image=image, mask=mask)\n",
+    "                image = transformed['image']\n",
+    "                mask = transformed['mask'].long()\n",
+    "            else:\n",
+    "                transformed = self.transforms(image=image)\n",
+    "                image = transformed['image']\n",
     "        else:\n",
-    "            image = torch.from_numpy(image).permute(2, 0, 1).float() / 255.0\n",
-    "            mask = torch.from_numpy(mask).long()\n",
-    "        mask = mask // 255  # Convert mask pixel values from {0,255} to {0,1}. Specific of this dataset\n",
-    "\n",
-    "        # Convert it back to RGB by repeating channels if needed\n",
-    "        image = image.repeat(3, 1, 1)\n",
-    "\n",
-    "        # final shapes: image: (3, H, W), mask: (H, W)\n",
+    "            # Fallback if no transforms provided\n",
+    "            image = torch.from_numpy(image).float() / 255.0\n",
+    "            if image.ndim == 2:\n",
+    "                image = image.unsqueeze(0)\n",
+    "            if mask is not None:\n",
+    "                mask = torch.from_numpy(mask).long()\n",
     "        \n",
-    "        return {\"image\": image, \"mask\": mask, \"filename\": resource.filename}"
+    "        if mask is not None:\n",
+    "            mask = mask // 255  # Convert mask pixel values from {0,255} to {0,1}\n",
+    "\n",
+    "        res = {\n",
+    "            \"image\": image, \n",
+    "            \"mask\": mask,\n",
+    "            \"filename\": resource.filename,\n",
+    "            'original_width': original_width,\n",
+    "            'original_height': original_height\n",
+    "        }\n",
+    "\n",
+    "        return res"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 117,
+   "execution_count": null,
    "id": "c8ef95ef",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['image', 'mask', 'filename'])"
-      ]
-     },
-     "execution_count": 117,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Test Dataset\n",
     "\n",
     "train_dataset = MedicalSegmentationDataset(\n",
     "    split='train',\n",
-    "    transforms=train_transforms\n",
+    "    transforms=train_transforms,\n",
     ")\n",
     "\n",
     "train_dataset[0].keys()  # Fetch first sample to test"
@@ -660,23 +577,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": null,
    "id": "168737d8",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Building training dataset...\n",
-      "  Training samples (slices): 546\n",
-      "Building validation dataset...\n",
-      "  Validation samples (slices): 117\n",
-      "Building test dataset...\n",
-      "  Test samples (slices): 117\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from torch.utils.data import DataLoader\n",
     "\n",
@@ -732,41 +636,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": null,
    "id": "a6352de7",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Batch image shape: torch.Size([16, 3, 256, 256])\n",
-      "Batch mask shape: torch.Size([16, 256, 256])\n",
-      "Filename: benign (265).png\n",
-      "Filename: benign (98).png\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/cuubUt2nmevnQceREqkxFNmmrIouuiaVTCgG/Dt+K58FTJgw3DNLgiG7QIhCyLFU2aSFC1TSebJaFPrWX7zU587986cC/9fWAEMjDnH6CN6RIt2/FqL6J/9+Mc//vG7T+1T+9Q+tU/tU3v37t1XPlHhU/vUPrVP7VPTPhmFT+1T+9Q+tU/tQ/tkFD61T+1T+9Q+tQ/tk1H41D61T+1T+9Q+tE9G4VP71D61T+1T+9A+GYVP7VP71D61T+1D+2QUPrVP7VP71D61D+1r775A+9GPfvTuj//4j9/9/b//99999tlnX+Qnn9qn9ql9ap/a/x+125L2f//f//e7b33rW+++8pWv/HxG4QzCP/7H//gtx/epfWqf2qf2qf3/oP3hH/7hu9/93d/9+YzCRQjX/tk/+2cfIoWzOvf3WZyvfvWrH679wQ9+8BJZ3Pt99/Wvf/3l9Qu/8Asv19/v7nu/ZbHusx/+8Icvv7t237vebzT3/trXvvbS9/Vxv73XXXf/3/f3/9/93d+9vF8z1nv98i//8svrl37pl979yq/8yof7ueb+Nq/r0/ju3ZiMs5vC9WHMN5973W/vM/3f2Du3fn59+I1xX7v///Zv//ZDXzf3u/7m0Hui1fX39/7e33tZv7vmV3/1V1/WAX3+5m/+5t33vve9l9f3v//9D3PoOlwfXTvzuRcao411Pnre635rbcznxut1/d363Hf33jW+8dzn965/9LIu9/1/+A//4cMYjNG1XRN0wZ83rhvrvYyz61oa3Fh/8zd/890//If/8N03v/nNd7/2a7/2Mlfzt+bX1y/+4i++/H3jvjnd+L7zne+8+/M///MPcz2+c6/yVNfOPMmI64z97oP/8QQakoX7vL/B433d59bmXpVla+C7rjU6dg6VP7Lftepv/5//5//5ibXQ9Invu6a95/XdcZbnbx2ONvf3ym3nXRk25s8iex1L2+qJyie6W+vqHfJqDOX38ui97rrO3zWl0+o1czDv0ls//+bf/JsP+vznMgoGczesQGur2ClsTGuB+hvK+b7rwplcBbVKwUJZ/FN293eZ13gQo79xz1OW91uvMuIJnGv1WWOlL3QxNobEovQ3FqyvLrZ73tgIOEVtPoTUfSm1G7816Rpcf8cAjMIpaspMf/cqc1N0dx/CV6Nz4+rYCGrHc7RlrNGLwWCMGZoToOvrlOe9m8N9XqNgPPcbCuE+s/Y1Uq4t/z4Z4BrIbQwVwbPGR+cbP36uYJev0PQMLyNwivD6vLU25pv3tRoF8yzv7P3wijmgxY2TQcI35LGKo/SoMayyw4uVAWtSmqIPmtXgueeNk1NhDsaCv/RjzUuHyiOl6bs1RDX01lB/pYO1xVOlz9/ld0+GpAq5zm31DRp1Da3XtdLKb83TWNYoVM79vrp59RZHdO/zcxuFCte1Y+oVMoy90YDBr0d0Qt/fINwxiAWqIrgXT+g+o1goOeMp0xnzekZLdMro/q5X7H71AhGbwNSbcI/16hiaG2u9AYJ9c775YPBTHssoaLmMSUApd2NtFISevfdd/9d//dcvUcLNs+tbod315/FcO4Vmne+e9/cpwX/37/7dy3zRjPdM2G781p8yuXH8+3//738i0kTPazVc1ohxuv4YOIrBZ3UUzOdoQ4D0UV6rk3PXHA2/8Y1vvPuN3/iNlyjhrhNllddu/H/5l3/5E8aPIjrDfO9Hs86NZ7qRoXUuvzVKP/rd63jFZ+h5zRrdGO+6G1ujUTxab/Z+03HU+eLxGxNPuJEcvnoyIH5vPuW3ro8x6Z/H7PdV/sZDjilGa0+WzOn6YIBK40aQn0V+6ZTyXaN/68gBtp7Wvwrdu/mQe/dpVOa9Diq6H//U4UHP40cO+N27zs6iMj+tfSmjcJOgiCn6eqXCtvWuMTGCYLKG+pRNI4TCLhsureIo3ECBbHiof+NoSF2i84IJNO/D4mtV7hS2xS5M0oW/xRPuG9Ndf4uvTzRdZV0v7lqNRT2oYwoMUgNdb2EZ3n0a2hpzI7d6oqvcanSt3SmlRosLOVWgC53UozcfdLZWDZcZIY2nbJ7u7/0awUYf92Yg0PK3f/u33/3O7/zOi0E45Y4PrYk5NGRv5HNjuXW/l88L83SNy6tdv+OZRqONLBYKQiMGD19UFj8ogPf8Waej60GmGqVUbozF+EWI9YZrqNDVWuHLOgOFzhp1lIeMr/cuTxsbmI1MWXdGohFyafqV93qqsKo56c9YQeVVuo1q67C6dsddea78nfw88ea1RqzWCO/V6S0fvblRKDSy4UlD3BJlFTMlW8+jYdO1htFPi12PluGhaEpkrQv/GlzQhSsD8QDWiFQYjYVlP8VxCwZGoUhFAO7DEIoizOPu6XvXez0JZJmlXtBT1GZ+jbo6j9JMq+dYL6n36/UUf9evxpNBuRfl1whNH1WQjHKNyf0tUiwtajAaXtchsGYbGWzu4vq/SOHyMdbTd4w+Yb41BnuJiGDMF5Xx7uuFoiE671rUky1dOlefF16p0lpDsrK0cFKdhK67e9WwrlNQ2cMHT/mxKq1G1r2ufES2u17VH+27PFQHsM5RIeUq9B89yHXnVMNQvdT79rP+ps5b9cjquzV6VeaVZ317FSVZffHRjAIrV0xZYhGTEAaMaPDCoBLvBIzyxHiScyw5D6dKphMt9MPoIDICd/x+X6FcQjbUvLlRSProonSeooRf//Vff/Eq7/3mfdb+vMS7L6VhIYWa9ZTrcVeoGIpGDM0/YILSag0luAj0sfdqxFH6W4PmFHjnPKdl2kJnvuM5rmLdsL34aNdf4QLe480xcvd+NMYLVSCEsCH8jY2wNkK0ro1ynuC0Ko/7PbjmXlf+d7x80M19fu36OX5f5YZnq0ALxaAFvi//1WPtWBjixfOb42sUsIYBfUSt+ndf1/czvFEI6Qkaa86pPNY+0beGrs2YG8mix1Mk1MibnOOpJnZ/kKR4I31wlnsVDu4a+tt6ySMcLZtHKLzZCADfoVF1VZ2KQnPHU2tc2up8vLlRaHiF4ZqM6sKZXLE7n5+ypVRqxe/vU5KY0e+OmBVCi9oIoULfsBRBeeSr5K8RAsrRAmAaY22IWaMHWmsydwVNUrUw17UzGOZTiIkg1hiusqRcQXKtcDD/eoOlVyOzGokqU+Moo5XBKGQKVcjcUNg9qtRrjPRT405pcRIKJTWncLSqkVtIZmFKa97IcRXRJiNPqX/3u999uZcksft0HQoPNWq4Po8vqrwaRazSowjrVRf6ovTRXoSBtmht7Sq7hROq2GrE0QI/y/NVljZaYdCOVuhwRrGwENiqPIZ3wdLGXJkuzIN+9XoXHq0BqoIvfRsR1SH40Xjs6E4Jy6NtlED+CtO170apNQRFXPRlnCLhRn74oTyEtnWMawDWmL6pUWjbsKQKWFvFUAuLiBtmlahr0dej37/1Uax9PRr9deyLB2q9tv00/K7n3rC6Qn8K65jp3itYDZvLuIzBhvoNFTEFmtWzbSK9IejCCYtNP2HG2pPSuNb+O856bm27HgsZdQ1LlyrNVj5RvBtltd8nyKTjX4hj+6DgyzPGVG+Pgarnji7lk+XH12C8NZK9/0JQ5rJK0PdbtNE1a14Q/7p/I4Yak4V/3fOM9sGkIuO7rvzfKLvyW4VWed85llfw4q7rvu+a4rGFPjfq+crMs/zSfFijuJWLbUv/zrFt511aazWOxrPXVN4+CnxU5aM1cdIb10O8l1JFXkFDIP02kbu/v6Zyo8QkCMbVKKBKt+Hava/ytFjFbqsEeWX1ohan7phBYScg9zoPiuek71ZlVYAxQPMvC32UATbvAaO/3/IoG+EVC3fP8wYbeVlj3nk9EIzGyNVjLiSAvn1dE1k8lR5WOaxjcNc2L1OF0FK/Rl2tSiqPoWfzG1V4nWcju8WtRSkgQq0y0raKoGvQda0Sb8ECvirMtjy3DoBWZwS/rQfddSMP9USbBytN3eeuPTm918n75VKOLsf7V5nVJH7p6F0+rcasNEPXVvvgu43+uhaNOPZVvvsszmT/Ly3rTDbSqQOrzzW266i17e86ts0JiSI20l5npNFHYbU3MwqUqbYerAV48gBgtyc8J9iYCSxDiVVIalHvd6e4qlA60SfLXg9QX2Vs95cMfvKmS9xaf8Ik5C3+ekqUkiAUMOX+fkvbalS0QjzLSGXMVn3c/+jzssgxGsbAwFQoVTNYK/RA3xU+SujudUKPVsXhq0hd3zXcqKQRlrFVkMyLgniaV43sClT3BZQ29y4fcdcdDZSu3rXWcSvRzOl+d9+7b50b42slW5Vxr10YqYrFmKs0yy9oj98bxZiX1gT/8psxKHmFreNxdKF8K8fNAd1xCge7nUN09DujcPQnD8a3MOIqcevY8vM6OnhkI4QakXX+REhdh0UqfhidIIIv9Epn3dxPN1mX8q71apRr3Lu+GierEJHxKXS4zzhInKJC9YVznyon38wo1LvpZPp38wdP0MJaT0JiUr1PF7fW2avYcJVGLSZmeoKHtv+nEI6A9XoLVxzcYhG24voUbQ1Vx1B44Npa9A2Ze309/0Y767FTSI1MVvCqtNB74Y6NSvSFvh1TDcITNFa46/qv0K2h3HV7MgZdyyat6/XjC/10jKVfI1CGgXDXY9vNfPrpml3bqPLJU+xc+7uOHb91fk+OSyHBer7WsHyxRkY/IqktFAGb+bsYeSM2hRfW4L7jLN1eFkn5J1hjodXOv+Ns5FxeWJ2xsl756Zr+MM5E5aO8XkP0BAlW1+x6NwLZqNPfeLJ8Wf58igAZ7u3Lew3eT2tfevPaEqrYdie5wtnMvaSsjU3dsFZmL4F5V6sY62E0grAIrGQVormUcV4zDOtd1ZsvA/mt8Zob+IVSUTGgQsZYmhyqULaVWcAJVcBo7x6lE3qjTw2BvrbE0nw6z4XKKgA1cK0uKf7eevtWXj0l+zaCcI8V1FWw+M64rUO9Q/SsosaDYD3GoUquAmkdGYXX8Glr1L0HlZOOW78dH+/d9/d/K9Iqe+uMNVoylubzlo5tjTCqUNybDNTpsEeHouQw3f+XtAZF3RjkHnpUSdepxrnedhV7oa561WhRJboGshFvdcC1yln76DEzVfDVW6VtS1frPLWtM7sw7ZOsXStfNMJ8zZF4uvfPbRRuUSkQCph3vAtD8bT8zyYtR0ssI91LyaQEIgaj3EsA1/mN8Whwe5VLoKLuC2hNeZmtjI3w4KKe59TwlDKskWt0YwejEsMTCF5a6/RbkeLza5hqPQ3wGrq0hJEQFBenJBY/7uY+tOj9KwTXTphb9dBIEE0L56yH1Z3H11dzNg3jm7xtBNKIyXX4gYKpgarS6LrW0779CPqv4nOv7j5H0/vOBjuftay6UdXmUtaoXv/XykM3ZzxBJoy71Ud1ELqvA93N5eiDNqLCRlFPHjmItNEDmoEdr6F/Ha46hXKLV659RuFgx7/4i7/4ULZ7MtEopk6csT2hEH7TCizr/BT1N0IsfX+YXIu+XUsWfNfcVB2OKuSnzW814viFjurny3vlFXqq1Zt1rFZPWNuPFimsR2GQFfrFudfL3IQVJX/MsaWYJVKZbb05BKqlLD5LkfPYniKEKhoLbn61uOv9WbT1XJZuGPp+4yA+v+VF1Wuot1PoiVJtv9cIU+9rXC0B9n0ZdJXttXpeFbCFoCgzY6vQthSvjIlRm/spZLCREQdkPakPzBwvXA6n91oPfRUfoQIbdb1FWj1nyj01kZi1rEIsNLoQBZrhpyou14iUzbuKaPNq65w12ilfW5/usC6MuVFyDX2dAAUHDEfHUuejeQlO4hmI+/s2fNagMz6MxZa47jpWlreMW6tctuCjsPePRw9sBFYj1fVbBKLfVw7bt78bsdQg1ZniQHR9Km91AldmRZMfvSRV64Q37BW2P1nI/o5F5Sk0zKtSL6HKECUs5rM4i/tjTONo/8b+GhS24T5B5inpYysj2k+rdXiDlElPK23IqVUBPI2zcIhxNrR3eF4Vx4ap9ThLd/09YdXdl6EVwmplRhNgndN68FWA5S1zqUfVCE/bMlV9f16rB2p90U/eq55ZYRVOj3bX1durImNMa5TJS2G3GvzO4f4XZTkuYufqvl5ViCtLLdoobatoebK9xqtr3T0oCyc9GQbj37OU7u/TBff9GYYbQyPrdRjWcVqjaz2/qFH4WhKzVdJ1wF5zLvr3k8e+RqE5icpCdUdlouusmcPT2CpbH2XzGmJVSRRSqWBWmHhKJucsmBJPOFTGdn0hFUICjnqq5GkYjTjt+2khGZXFNevZYVheThn/2l1rxypvRx+ttvgH/+AfvITQxnRVGj0Yzj1Lz0YVhQZAU+hRGIHSXmya0JaZajzRvyF7k+uuvWgHb4Dw7r3KQVUW73+rMYxnNyx2zj5rkrrRXoUWb7QPAnlj66m4xgCGQTvrgk7dYdpx4b+OzXqo7BEFF15A+7vOKbY9nXc37/3VX/3Vh6qdRlvdrVw4qxEFvqoBasEAA+b39U5FXDeGGnJ6oBFQoSU0OD4/p+neD5pDx0bXDgskryCuq1YSydRw9igZukXS+iCpKtylTXWKta5D+dlDVdJTA9nqo3mpzTmsw+z3VeyMPMPbcekP7Z/61Z/1rFzUQfoo+xQIdZmrEUHx+YVUELmKqV57w3vvNRZ+K1S1cPVaGjbXQi/kUOhDZRBGqoLp+Ovt3ImZd76+HcxVMj06uUnL7tZUxnnX3OcnAI5HKHRTaKDCVMN8Y3Rkcw/WswY80Pu7gkHJbVXC/Y8RSzOKZJOA165vBqJ7OoxbP4SGgbnf3bWt0iDENT5osMKykU2F2bWEpEZpjfwe/LethrGR0p4AvI5LPf6NQHovtBGJbJRoLRf61Ao1le9b/rpK5DVM3vV2IN81NQoi8M6jCghtnfel30KXlPm9n7HAu8fH4LcrY1UKrByes4HfW8qOz5TRUoT4ozBKo4hGeT+aaqfSs/1VKW8029zFOriNSAoVNupp/+XXXfPyWOdkPJUBcvVR4CODM2AQSBn/yXsr0/DmtfUO20xyPdours8Zngrp/r5zWIu7UUSVRIX45ntMiTHvs1rzZZTSpB4Vj/mYvtGBRSwTLL0KUfGMN7lo/oVcdpyaudWr7nqUjv4vlHf/E3oJ+Cri9r97RwhslWrXYcPxhtr18ta5aMS0n2//NS7G69rCKVuW2iOP65WZV+ENY3+C/rrWrxmgVVJrZBa62OhQ6zjbH35o1P2akdNP5dyYtY2yS8dCmmcURAD3N4fHkd+tgNp1qnPaue3Y6yxUfrQ6Ap8NZFr+r2xXBrt2qwd6n0I5NdR1eMqT23/v0d/3+uo0Bvvzop6fyyicBebJMgZ9AIuqlypCnjHBL6ZO8BpSIeYSsZ6gssb7DIRj4Xnn9YAwjntUmelT9cgySvcX1FtbxWlevGg0cChaE5/uIXLw3UZOvEcNwxtXIzSHClJUDU8xSvcElL7XpzNuRGSebbD199dEHqo2zAMTMk6gjwoJmEmIfLACWjnz6cmIUr5N4FbhPEWc7gm+aUmwNa3H2yPHywP4ojBQhQ/v91jsdZgY610HY0BbkIT7ibq2LHPXghK93xf+qPHx+90Y+Fr1YOWF4m1U1vHXcPmuFYrLwz2+u8pPAlqVEjrVEyfjdUT7++OpOqFKobsn4q5tqXKT0z8Kf7lHnRpz87nIeten3j5alx7NrzGMIqzmeRbOMuctPe+aytmUvl+0fennKQjhGrptaGVBDKrKhQJbGKReqUUp0TYBw9MQHRQPpUBcB+IyzsITPNxGCTVqPc/cQt7nh/EeY/rtGhPj6GMH4f0VJgay46uy2wim3lwNhn7KIObW0rnCPYsHO5Lj/pcfoECqoJt03ZMeKT50opB8f/2ab0/XtdY1cuUHa6YapbgwmjTf4f96SzU0zcPgMcq1z4owl9LJd10La1ZvFs3NGc0VJlRZLPZbA4R39jRdY2qEVaNffsLHHTMl6jf32W0qq4Lv942G+uyKKs/ywTVwJmXX+VShVeFaa8/iaLEEfmIA0e/JK6+CXcNFRq07uv4oR7zomw5pPsw4G0U1EuqcfF+Z69pV5zXyIsPNI7q2+sN6NEdoXdZxenOjoCyvCtkgEXBD0YaWTSY19KuHsQtXa7vhcQlo4fskrYaJCwN0MUvo3uNpHD7nkRnXMqbF6iFgq8QJyHoVoqo1Dg3hzX2FoEoSlFMmaWK3L8qw0Ijx+azGux5lx1qvtGtVPsEDfaoUBbQeZ+9Vr3mN5iqEenZrFHzPwWkr5ODeaLnOi883sWkcVdToLBKpErWOVUg8et+JiBf2KO9XybgfBWvOXbN64IXvWuHTPFJlQp8bdXcM5Uvr8PR5eaTK9gmb12p4utbtt85kIWu0fopufjTKuMq+/Fj04BrDgsaV5TpVxrXQYQ3M8mrn33lWdvRdfuy8nmj4JkZBQqjCX3iBB8iybsgr0mir0AqBfUYQGqJRDnvksE1qNkHd501AGRMrvsaIIdkw2kJUQK4566ZK4omBe78muuo1YVIRjWoKJapliOKOhQdqZBkgxrsemE1VGM8x5ZRQH0F6rUoCrdAawy0D+129nCqG7hcB/Uk61xtaJXe/t3GMEqxwdx1UpnBEGJTynI1o6KPk8ckTrzAuT+DLwjzNm3SjIyMtsvWEOP1ZPzxGrlpdtkUTdgWjW52DRig17FW8ZPjeyQheNW5K1fVgwac1qLJ/kqFtu3l0HZtrIKdW8umzEHZ3lvP+qzQbSZl/Ddz3A73WYaqu6avXWhfGfaEl/FFZrdzUYFdmKmNNRJPTdcAaFdTQfNG8wpc+++jJi9tFbzhsImdQ6tXXS+3hbTZ0mVgTUqwuD7xEVFbXyowu/pbKMQr3e8msWviNDmqJy2z9zr2qRCnnPi4S4ysnrBA9nSdfz213UyufbNlpH35D6VICDcHv/e7n9NmWTT4JKeNVT0mrh2LcnWuVHmFw7wojb7qJwmv2c/h9sdn1wOrZiYBsCqzn3jFeq5Got1Wh6jj1waDuMd5V3IURQWOly7VW1aGJsciftRQaP8De7/qr1kE7BhSt9V0veKMjMlYv2X1K93UC/L48cb/fh8o8yRLZbd6uClEkxEiCF/E4xeje5bMq8sJx5k15VqZ/OBFAI7QaXJ8xmtfIeg1T5aHGpBBaDVTzEo3urF2dPE4HOtGFi3p80SjhZQ5f+MopxdI2VCqzYVYL36Mo+tqwvt5N/+b1lnAlJKZeTx1RStB+1gVoRNDxUYhd5P6+Hnzxy1VUG+KVaZ9ocM0YJOFW6XdXeKMAzFKMtl5FBXaVWcdWDL0GcBluw/3OvXPa0Nl9NzHWvor7glUWyqkHvcds1MDh0ToL5YE1gOWhdRjWe+xcV06uNVlOUVUB19BZ//tOEtsx7HU2rvHe9+wvSk4dP8izcEfzeuSz3rP1r5w9GYau6zo7Hc9Gf6uw+vuVj44ZDXqvrt+28lWdzoVhfvjw3Gx9V1etHPS9EdJGK6XH6gAv/S/deu91bsi2tVs67Hq9mVFo5USFuUrcYG6Dic9ar1/iPXkXwmxemwVkFO570ApGblTSSpRihO65TG8Od03PM2oEs4asRKe01nOgJOsxYmpVTZRcw9YeWFbDJNnIMBQiEpqCIwrPUERb8dFEPoXW0JOHWa+8kdQKWdexu15rELaUtopkPcQaFWtKqa0CulYjuoa5vNXEe2lS/r5WnNfY6llS1vU+W9jQ/EC95FZSORixMIjxlsYi40ZTnAT0ImN+20i6lVHm0GIP96nBXe91P8eXC2GWHit3a6w+KKKR2Srf0hYvtCS1zledUrTXF6OLD6zR9bXFBF954O967a41vs6zfbmnV+W6tCycXJ31GipBT9ThFDH1HKWNmj9K9VF3PyJeYR6lVfd3S+QQRYIRMVS3rKe6hsMxEMU0MWtr0aucy7wWovhemaUbw+qZN0fSkFAoXYyzShZdWrFVXFf55RoPuZgaJEaS8ke3Klo0LMRh3pitERYYrWfCM6z1wPf/ejdVohVGXmXhQjAXGpvTes0bOqMJQfDMbPPjHOCjrq9+tjCihQ4VwkYAhR/uf9HYtXpid80Z6ir+eqxVjpUVMoQv1sPl4JTm1rOOy30nj8ZAudfJIlkCXeIF1UgUCBqCrG5MeBo/GiOnp/Jax6fRdXdcr0e+ipwTUh5oTmwjsO5ELyJhHhsFevc3B8qc7/WL70u962gUAVhoqcZUjrFOkOq20qWRGmdMHmGjgkb8NQiNZunAnm3WrQD45KPkFLo4reqh6GGelNaFumWcepiYitAiyHoMmoXRTzdqEdSGX0vE9VYxlXGUkd2vioRyrVLrAq63Uu9vf/PkdVXgOq/XYK2XxQtcV2iLENa4NClWZcK4tEqi61UaULqYa6to6hnXKNRoFX7pURL4wBjqbdUz61zAPy05XCOGhoWmegJpFVn5RjPeKqcq6cJ8FK85VYm02IGyqzEqHXft9dfveg1+4ck2Am+UzHAxamSuUYU+3QMfLW8ULl2+q+LsNXX2rFeTqsZYaBDPlk+eIkzjLh9x3KpDavC1ysZXkgAurKPVWCyvlAZao8ydS8dcb7+Gq/pijULHKJdQud3xr1y86UN2Gr5R0Cdojh12RouNOAjYyXShav2XQTaMsyBVypRDjxdeS+/v9t0QrnOs4SluXEFcRi3MUQ+3irteYOn5xLC9R8P8elh7TtQyE+Nbw9dEcxPaFdgXxsi5NrsmXcsyW2G3euBeVQAULeO+3u9rvFcooxUdG9bXuFe58gYp6SqXhvB4Dy1qADuv9ZLLHx17jULXvTSvc7EKmHfO0D/xwWLv7Y9cNAItnLIQxZMyMjdjqoGsg1Njp63ya6loDePSpFDO9lMad02q1HfzXJWm3xWWu1bIpwZu+6gTsS/91Shce5rjzqewTyHO8pf/64DVwW6xhuhx5/EmRuEG1120cDlYqMdPItav/dqvfRB04a3qGh600MnClICEqZ4YqIOCkHyzGC15xext3cxyDU6/hqjW1uL4/V1DuVIWhZc6/m4aWu/C4jWJfo3y1Gf3hizEoWFSTKRsFER1rVVLGL8J0iqMMt2tG2NlDB1r9zeYZ8uP18PpHCrY+oC135xvbf7RP/pHH/q6zVW3S9wc8U8fpXl9dJ6Fn6ylapwKWvdObJRaWm95Z9vOx/xLU8//sJu9SePXHIjOwxzuMzvR7/+TA/ti7nflgz7+Un9eVXz4xQv/qZQxppbd7i70jVBKj0ZeDHuf74BH97d+j3/WWLQc2OZAz39pznEjkdK3PH2t0cM6QNfAmHVIGaU1gIzPogmNkmtEC0036r7WyLFGuCcF9NWo7KPsU0DwwkBXDeGmFKa6agzkqIetZOCh1fNZ7xkRb5Hv/g7NkluAI+6zCK6tBcd0VVSUNYKXAdbrMe8q02LW+tN672uuMfd6G6IBO1cZtUYu3Yy2ezXgqC0tbbv/a6TQgMKtUHRu3ZXaiKTM2nXrfNGjO+FhnwwMHjmnogrMXFuaqQ//O0wP7cy7SuvGx7B2w9zi4jV46GONKsz1MrtfomuJTq6/uTmorevWSHqNpzUTnVMelAZa+xx+re/myDpXc2vEZfyixzV29aSrqGokfdfIo4ruKTLYXIcTdtGltCivVBbpkObUyNrmP4ocrINSGfhhjEcdVbRolGgO7lOHpLzTKL16r3phI316pRFNo45Cu43Cm1d9bU3f9CE77by4VTcgdQElnFvj3aSmzwq5gBSanFR5QykYSzHPnfiGgSWcOa0C68Jv2GvxtsKguH+FfHHuMljD1CqcVqG0kqC0XeVn8TdPsnMtrRrxbcjeufXeZdoa9uaYmnx+YbKUzvaMJR5fPaLOp3hpoQ7QRT1d9xA9mkMNI8NKyBjnKuLlo65VcywLsdSLfoIdKNw6Lo0G+/sqh65HebreIdpvyWh5faGDwkVrHKqoVmFuP82BLQ8t3FEHxrzL511391roqI7aGs9GKviiumsjtoVrygM/eniu/DqYla/mRRvp4F20Kn065qd17xqUX58c2MpDHd2nPt/UKNzxzkI9N6oCNAiVQp6ZoEaaQNVbuiZsP4Vxh1nxKhkBv0PsKj+CJhJpVQ4PBuHXs22eoBvAKM7mLurZlYHWOjNYjGQVTGEIOKHf9oE7hcAwG+HDaI28dncvJjGHQlN95oH7b8K1Ia1HJzLOpXmVyL1u7e76e69TQFDuuytTxjMXYdo4ePNhUO+6wnZgoXqd5ZHO/WgCRul8Vui1rl8NUu/RJ65RgD13pnykGYs+u/4b9awHXgNUTxbtVd6BjO5xlht1Gr8+C3kxUOsYlAf8vnSzbltlda3JfnqhEcPCcX7LibDhqo7G5hTrKLRiqAqwMlKjIIpcGKbRb52urwxEu8bIenVedJTWa2t0fadPc2oU0/EVmSkk2bxO5WOd7pa4v7lRcKa68L9M0lDLgE7glV4KZ8uAFOkpilM893yCg6gMvrtYEULk4SVPgQko8vWmuxdA3/UI1vOrcFjcVpf03UK4997TwoJhKoyYpSEe5q5na8HR83D1LbusF/3kqVGQMOwyZedbRVHvpspM2FwFWwN+rX2bH2XEMWgZavM0u7GO4mhOyxorpyw9wE9VshR1+a/8cq3rzxDuPRVW4Onj81POci819NZCjsQ6uW95qlHd/a57ExqdrKHbKAsNa4xaBkte9Ff4rXLRxDV6lCc1fSz/Obmg/ZlfHZ/XKgdLF/dZWBQvvcbvGwl6bQ6wENrXBw6r06t/fEB3MJTXR+FFfFdj6T7+b1HH8mD1U2Vto5w6c4tQrP75KNVHJkVg+0CVWmiQ0SZaeEi8Rw+suYRiN3UtnGMMFSovBFtFp1kM1yyRu9iITNj6/b60hQBKq8JE/fxpDPVSushoyCj0hMjSoCHta6Fv52mtCoHUcBQyqjKq91cPVOTi8/Z7rd4g2lJKxVyX5r1/946ALF3b3IKoqPxqvp1rf8tQE+iNMBYu6jgbEZb2G8qTg/W6q6jca8/keoIDauDqyPTvp+vWuPi7CqVwYyHCytfKnP76+ZMM+W6jrRrIlgLvMSzrnLmuNGpkWP5vH/2d1jF0XJXXvdeTPtn/uwaFqHr/OgbXKqMrH2s89VF99xrfvNmT1zAG+KdnBp2St4GmZaH3G569iVx0cFHBb/3Wb737vd/7vZdKJVFCk4StQ69Hc7DBXXNGxead6/+qn1plARa668AmKjRKMH+LgniVC8nUs9xFrpJdT5sCIAzmqM/CFD07hZdpc0xLMG3kaqKrSbYVPoxVBVBFVdjA+Tr1enhB+rQu5lwIoRU/hWEaxvoOndovGuIr/YsaWr3m97x3tBE92DOz0cR6geYm/K7iqID2GRF1dlpuusnpntuER69xqBg7RRRrZCllfNbx4R+RkXVYJ6TQVb3RVRr4cytq8BC5L0/VWJor+KqOIZpwdBbKrOw41cC1F5Hhfzxe2fP7Ohn32cr9Gin8yQh9Nafe4knr3f0wIqHyrnyJz+qENCJlmBm5lu/36YmrS1sFthtw64So7qosdd6fq+fffYnmGavXDFI5p8VXiXSfCb+9Lhq467/xjW+8RAdyBmcQJAlhwSXkveyBoChAR622WSV496c4j5g3NmNfISh8ILnLQBCqMjX4xbxBV6VPPWVzKW0kW7cOvo8+pNDuM8+0xjyEtsyxSmw9KpVNHeeGqJisRqI19mjQB3nUiyweu3mWHgsBarR21ppyNOZ6stpdZy5VrMZsjpQRIyF6dU2hIcqDEquBIIwEuON23fEoY98HBlFwNXLyX0pSzY3C62m1C19tFFzFiIaiKEpnFTel1UjA/42w9G+dG8Hoe43hYvloszIhj1DotFAY3qsnzliZp7xSIy/r6MTljrsR1Hr5C0NdqyxVsddx5RR3ffztpIC75niiugBvPJWz+3wjJIaovL4RzjXr08rOL9q+lFEoY1UJdTE39LzGy5FMVtraSpDdP4CgCEApLZaKWQmY449fJpczTXjcCFwPdRX3etmrmBY+6ffuhQ71zrZevsLaBFKZz/h57wsPreFp63jb90II+9sNayvkvu87b6vz6+8pWPOiIK0hXjHnVq/t/DrepfnuXuXxgZgYwhq3enk1CFrHXxnA712resAiO8aq82u0V0Pc9tqarWdaHts1X2fGvPEeWuzaFu7q+FY5du4LV6189LoqUvQxl4X3ltdq+NZJePpd+eapSsq1T7Lw2UCv5Tnzt96NtHcOyx9o0zVe583n5QVr3vn1On8XkmsJ8EcxCsVnG1rt5xixUEJD3HqpPJNOFBH3SOjCBX7Lkz8BvKehnSdaI2Kj0F3TkJcS281uTaIVPjAeYxPRWNyGsBvS1avpfgYVRH3Ggfkb/zWJzUZBNbo1OMbdEHwVWg3ek9e02DTPbDHNhcq68asYPkVzL8+2tm4KBUBr1m6hj87tSQh48F3HNd7NvdTBITyO8cYf+t8jNKoENiSX9FZ5h/8lgAv9rDFvlNZEcWn8FDGsIuz64JU6O123p+Zezf/oB0+3yqb3rfxTSLuuxlDeK6Ra52+NxToV1mC97hqe8kl5vsagMvCV2VTp9+ZnLmTr+gHtdr8EQ1yZN0en4+q7MF2Vv3F1f0ohMPOqk0c3gue+TJTwM52SqkyxAtsqi+6g7ELdwPqc4ksq24h2GKvJyzXc6/7e3ILFub6uAud2uP75n//5i0GoZ4ZoDbcI6I33qp2K35fAT8nxDZurgCz2Pq+hAqK1QqQC3eikh2hd6wNjjOEUGCXcvII1qCGqISnW7fonz4mivheYpnmTu4aR74m2ZUwQjsevbpRXL0srk68nea+b93e+850XnpH7qUdEWFuwwEO0XmhkQ9n1yTBX4BvFLFRUJcPzX7imB/c1WmLk6zl7v/Hgox6P3nyBqiTX1fnQ6s3ueFchbxTMiRLdVKmRj/WGrR06LhRTeMRcaxDxh8MyN0JZBw0PgYq6K7xRafH5HpC35b5gqs/msaFklWI2zmuciIXZ6ig299XvW4no9/jYdTXg+j+kxe+6k7y7tjveRtfrNLxZ9REC1yiUAertIr4kY0tZEa21+fd+hqAKsBYfAzhO43IE9+74YcapQuH+Lafr0Rxl3EYu9T70V0/DwhX7axhYD6ZhI8brgvl9x1fhMc5u8NkQuiWGi+l2fg0/G92U1sZJee3RGFUg6GIN0MpvCF+VUb3+Qim883qV9YY75/usZzf5znosTl/F7W9r09JC86oXZ07+Zyz12yMWqpA67/UwKQrOBNr4vEqL09FEfmnS8Vfhi8aqOMiqOXWsjVDdv85R5btKtE5HIUDjbkRUHi1fWvc6HeUXSeuV1/J7I/c6qXuP3muN4lez4dJ80KrQHVo3Ei4tvTquRs67Do1gOcAdWx2pRn0tRS6N3bv9rvP3ZjkFzFUl2JpywlMLTLnwzBmBHqR3nuZZwXuZRKsfMMt5SbeJ7rxFjyGUW2gyDEHcz/15tjyCMi3hXIOwC6vvHua2jFwmrKGw0K1yUBfdYyBc34fF1EPjGRnbloFqKzBdN8xfJm9FVBVYIYoatb2/uTGYmLI5p3qsC4HoGwzlfvjJeK7pr7xWw1BBdT/wTo0rpeP+5tmqjyfHoUdy1LAVlqwX+QQhdn6MAo+3vLfVUKVH+bmy2TXahHI9fDQq3Xny8nCMUY2z3zaX0wjl3nmzpetCi2uYyp8rMytf7dv/awh73To0jW7Lfz8eB28Vao1C4fSflttoZFtnofNuchg/mY8IvXxhbZpbqg5G480NvolRkMhVnWOy9ZwJLKV5Ct9OZcJycMJv/uZvvkQFSlGbPyjzNOy5e58x+Ff/6l+97OJ8mUBOIlWq2oWrkPb5tgRazsGYb6wHbREoDyfZM5Usjnt30cro61XUkPASjwYdI0VJ4W01CKEsZESR19NaLwrDaxRkoQDXUFLmf2O7dbqqMVEAxWiXbUPYClRhv3o81qfzEU3WiIKnGHeeEYfgWhUmxcaIWutWrK23bb3RrM/ILoRACZpzq+WsoXcw4F3vcZyqYmq0rGmT9ddaow+OajRD5qyjnc6l8yqJVs3VkenhkMZ1f8v57AOaWurbQ/jKn03sFsp0zTpK9eL11bwKQ104rxG73+ujEYP1aXRMLq4vucivznPCG43qt557DVydSPP27GwG3Brf/6qj1pBu5Fao9yBz1W+f1yqH9MgXbV/67COTqmDVu4Gn+59ROEVr0nfNGYljum6lLzEtBIE+qOhyB5dDuAVwAuJidu5/rRYZRl4vrrghhlEmW+E0v3raCxk0IliPpKEyb9UYC6FhiJZtonkjk3qSTx54vVPjx2hbleB6TOg+NSqFPZrArdKsh0WY1qOrQhPFmdv99pwER2HUkDZZ1/mBC92z0F+NH6Gvgic4rZGvMiqE2WM9GDi88lq5qP7Qvx5b6VP+6lrVgO/6NEdiXUTCffhUlWLx58KahYEYuUJf3evh8+5fKV9bA+umEKT91bNdSGcj7OaM9NecXBV/5cXvq/gXdl35rgH+YSKATfbXEFmHOoI7n40c6EB6b+XC3+izieL2DbLd3xbGXZj3oySaTbKhda0auKYG4V7nDRuk7ynMnt3T8PUYVO7gjMFFBzwzfUjCmnwTxxKyZax6zMUJwVk+rwe3kIuxFhcs09Qo7ILW+JVBjXvD3yqDa00+Fj81rnrk9fz10XGvYPZeZWKNUGOwPeSw1xmPvks39+jZViJIyq1JN8JKIVSZ6vO1HcDo47fG2nC+kY3xdj3wwDVGymcLp+yRL2h4fzdCWuikyoYBrMKr86Uyqfc39ka01rv8VG++v13aub/PFm4zr6f8w9P98EUdlieZKtyiLcxTo9vPu369b52G8n9hqUKxP3zIaZCNjmvXqDQxphrw1aVkeGGd0qY0LC/sPdepXl2ETh9lR/N1bhNVcVEDtGHsvL1vfetbH07FLHRyxJAwFkKBDs6Q8Oz/5E/+5CU6OKPQap96rWCNwg71KvymeK6wvn83TLv7FUZpRFQMugy+cI3WKgtRUnfO+vxJiCiJMgim6B6Q9f7qJdcDApUVE6/nVyGrkr97Witrv+OtwyCUtk7XZz1Ev7t7XgR562ezWh2CnnHV1pxUn+VgreVoCE4Fw9ituUdpNrdUJY0Pjo/tP+hzjEv/hTuVEbcyqeXH952oFC/efTg817qhrlCSuSl79f/BCwxGd3gXfnTPax3bevH1ODkBjVCqKEu30gX0uo4jHdCKra5DZcCrzl9bDYL/rfEaot1ToF+oxdceNmGSD9AhPmgRC9ga3cp7Ldlvsr+GuRAcGbbezV8VFrIG5Mz9S8ONGj7KgXgdsEFg6IOELlfQc4yu3WSE4pTTPijFxjY7dw+rPKMgHEaEtXiIukqMlyl8ZZSauKkiqUKscliPfK3+Qiw3jzL49cPrPMYxh/VCOp5e02iBsgM/1FOoQm7St99Zr2sMlM9auuu3GPQU9hqvesLGvAqrY5NfuojROnhRZiAO40HDPgxnw+OncTWi2ajwWp0F3xOw9unzJnPxL6fj+NTBj610aaRn/Zz11fsry25ZMciqPLA8yFgc3VoGWoNcSKcl0zXW3adTGeu6cnpEDlX0ywfrBLWijMHoKQSVQfdaKOrJw13n6Sl/tzpi+aH3rpP1lazZ5gzWiboGmm6EpdXoFn1YyKzyC66rYblGbp4ihUYHxg3+q7F+c6NgEBvuggFgwrxhAzNgzL1VGybBEyVo92ro3CRRGaAnb97nPfai+YbCKIiJqQrtVCncO8+6CVMLbmGLK3eh+3nD2r1fW8dH6DBpMesakmv1WNcQNPTsHPvbhsmdRz3tDWf9re9GVbDuVoAdjyydeDZN6hXyq7fnvuawsFVLTftiOKp0Gj1UkVmbere81K7LvQo3lscL44iEOSn1xuttyoe1/+LoHWfPBCvEsxHRE7Sya4zH3OM1w1oeqSdahbtlueXTGm2tvF/e7n06j+XH9tP5rJxVcZYe7av3aOtn+/snPu18XduoYB3QhVvJqr7LY0vDpYPPdpxPDu2bGAVEwRw32IsK7lA72L7o4JS7kJeXRBha8SLKENp997vffckj2Ih2jcfRJLIFEUmApkqshslbNtc68HqKsG6CCsrgDa5RqKGk4NBmk6POPuGlF+7quKvEfGa+GO2+LxyzyrNGsMrliUmtTxum5ZHuGCmAQgW+kzQGIx6PoEWhIQ4BZds+agC1NWibA7rvwTut8kCPhQ+anyh/PxnrCvu1QpfnCPX02qPXOTY9k8kzJu7Vx3HyMEFUdZCa5K0yqNIo7z0JfR0c89vPVbzVu+S0bfTaM6CMB+03IunGMXPumBd2tTblzcJAG31anyeIUGvkUzy+jmbzCT8eOLC8V76oMahc1UkxTjSrQeicdi8HHijfGoOo5L5voUZzn6Xvyv+bG4Va/hOGY/T/7D/7zz6UKdZLx1gmqfIHI7SKBuQiZEaI4qjXEOP621M8EXqhAIx4v+vjCgmrRaNEeIX66LNtn7xy93Q/2KNFXI+vAlQD0EWt4q6HXw9b+O7+VeqN0IolF3cs8zC0FXKMv8ldNCdsjcSs19HzHAVRI++8iq70bLTRPgnFGghRRX+7hhNk57eU+I2nh4VVoCvsHRO+rNd8L7S1FudMOOmXE9ByXevN6bgxdtPfXU8+aozNrxhyI5LSHpSJFhRXHbQ6QNbSPG0GPbrsnopGJI30QIeN1O+ac6SqJDlZ7aeQVytyjMc8ttUI1khWX6yhKPRSfVbd8qOHhznVeOx9K0PkoJV3eOu1Cie/3ygb0qLceHmgsBIdUBmoc2q8dYzfNNEM+7ycweHD5wWeN1iCrUeDcXlCyvjWKPDSHSOLEF0kDRNRdK5bz6BQTMNSC4kxih0Kp+9zSmyVx3pn7b+haD2ghu71OsoQ9fT1xeBScIXUen0ZdefLYGGaGjrz1TAcQ8TTub/7BLIaKl4hiET+5K4p1NFEa6EchrLC5Z7dmbvCUFouBFbj1d90N/LTHorCAd1xXYNQY7qeZ8fdqKpzsHbLv50HRVznZl9rSOth6pfsGp88WSvH8EH5pby20cHi2fWyq6CfIsHF+xu1P83Bb/b/dQjaOp7y0rbKYZ25z+aBR09030hTH+hbHVh+NbY6g+a08vyUHyn81LXa8ZdO/exNjYKywYsMLqF8RsEZRteOSKIDEyOAx5D2JlAYLKLjZcEO8gqI2FCoAl+jgOFbcaGyqcpWf60vN3YLWUWzoXojmRqTLloZqQZlFUpDyd5/vSs5GvSkyKq8Os8aoApEK1pEERim91wPpxvubG4CxaDLrRuDAZ+ux4sPbObBT2jWsuQV4CZDeTudk2tb5QFe6qZIQms8DH6VCwOgOu6uAw1Zj65deRJ9CSm+NH6GaIW8EVNfaOesI7+tgVm+WmVE+aAFQ9bKH+tfj9j9mssofzFWjJvPekoAOLnrYzxo18iltKgyr9NUpwuNa1SWhjWw62huztMafPYg4/qpUSgvVpm31LRRkU2gddI2H7Olv5tHXP2yhtQY0EiU+9GMwhmBMwj/5J/8kxcFT1kRruKq3QhzjPHNb37z5RA6BoGHs4q+oVbDpuvj7n9GyQ5owlA4qhviGjpXsJc4C/NUyVqICt1COpiItwsDxuA9uK4L5r485DKMxcZgStaK4/coBEawEQ8aL+bZ+VYh2YzVygp9qJw52tcrbcTF62l0tTABeETflNXxk+u6v8Q81xO23lstg654UzS63pU9LhVsfMKx8dv7jYffwHsZlYNIGB4RQMfZCAu/l26NFCjR7mx3n9ujozSb8Tt62eFKIS8M2EIQ9GlhBsXS9XNfETs+XKWE380dPVwnd1SZ9kLX9Wo92pRBNJ/SEn2r5MsPkAd96KdwWPmlB+r90hxGudFAPXPXuo7ir8Gr0i+c5x6creN/cmMvFr4hs42CQfI1bL6/PumJjumjGQV15TBVSeF6gyZ00QSGdLJqn35Uo2DwnodQRlLOeN5o8f+n9z6n4Qjmubl3P8quyqSK2Xu9/y6qpDYl3raKqR4rZmpkUMVchilDPUEiIBmt4bq5VQmK3oybcKPZ4pgik/U0rNNCbJTgfY4+fR52PWZwSmlmfwmsvx6634NO3M+78TbaQxvGpruw0aveYaNaNL++PanPERWFNCpkrYpjEMtHftNTMUtv/aCx6/XryWM9ckKO4uhyn0tqG28hsN6zPIf+NZYiGffZvE+hvTonvR8eRtfi2WQQH3R9uzaVD62RbxWz73rPRnE9l8ycn9aukcJXPqcysNGMuVqvjr9RUGmBZnUsGx0Zd2W8MLH7NnKsc+f3dTw3CntTo6CahEE4xrlqIUJj8mCG3/7t3/6gyDFcn29gAU0SvMAL4CF6EpcoALELaRCynupZhYkR/eYJdsCIwnXCi1n6qNHNC/TvCgoGqXBhgApdGbd9EqT1iPXVENWYekxHN8XU2JqX+xJWtNH3GrVVKvUYOQd7dMSuV39bD63QRmlVRdMd0LuONZiFjnokAyGpAFY56sc1R9vrp8/iaGTbda1nWpjPOqBh81xLp8pCHR5RzfUtYri/bXi7/x0D7rryNIPZfMBChuSPUe93ovEq0P6uzlQV1GLaflvF1bGVt1YW1jAU1qmz9QT/rMdcI1yF/sMo+te8a593nisf9ej3Wtf0np1z6Vs5b06HMV3DXf7UX/OmH2WfghNKPfP2mIhwyjdc8vmihKtAsXgX/qpq6CYl3mghhSbsGtZ6TOUJwUFRT4lE9+iibuKnnue9znBd+KZaxkaqniPjBYaq0KwlLl7dc4Qanewhd7yNhtY+V+t/1+5mvuLq9RrQT5K2VVnuw7vto1YbtdVIaRVgig6da9goZafg1gBX8WHq+50I4V6FxuSKeqwJB6DKpManSeDeayPBRljmV0fC42Ipviae8fJuXrpx3lwKkXRDoRwco9OKtTvOxW9sanP0B4cIT93fSl1vLCeTJ5/3fhG8Z0Hf6wxJlbO+7r0PezLOGtt9NrVxN0ItHt57FO+3TrtD/a5xsF6N755ttQana2Y81QccpsXkrdF62AzU999XSrYKyHV463QQhd68D6cD3/WRoJsfLe82v7f5xtKuOZ5CYY1GlDEzVs3JfZQdzbW6rCrBuWcvX4kqr/4GeIvtqWitQzYB/1dBmUy3tVcxVDgIC6JhrDJBlRtBuPGKKupZ87aaZDNWBGcQja1HbDQn0BxHNycRhDKR5nfto3mAMhdlQjArOPokmDcXSXj3aYjbcjm0Q+NiwRsdVLm22sY472+KpmvyFPns3PXN4eg6+f4pIb5RUA+0W48LjbyjJ+Vk3fQNy61XWQ8czuxhKJTGKeiuz0Il5lHD2oMRW54tWS+Kdk98ePJmnwijxZlptGj9y6N9/vSOszTvPAovXsMX5ZkaZNFXIb1GEeXz9awrw/WAW9jAEJG1loN3jH5TpX+tPF7jyBA3xyKiYwR6Te/FQNQoXCvvFFba6wpRrXGsbqgD+LO2L/VL4cru7D0CHQOKDhDpDMF5PuelnPddhWACLGO9gYbnJfAmiRBqz3hpCSiiNUSXozhFUy9bbTWPldATbMqF4algNQqokBTXlnC2mA3jGwJu/mFDcDQsLNJ3/WtgCQn+Chel7z67BkqGK/T6rwcjKtmE/DXGFcMu5tn+jAtP3EtOCky4CnXnW0O1IXe9xyqj7acwoTHVA+xa1RAubGDuvccahydaGEP3H7ge7zUSLpxVz/x41edoViepUSVatGKGMu04XbM8eY08Magr64WH+lrIo9e4R/nb9ZXx7X8h3nWy6uBuvuKzkbP7vPuo6vXTjfRIHZc1ajunrkP5o+N+krnSYuWguuNpjd78ITutSuhgjgHO+z6muO/PGPzrf/2vP+CfvNkaBQx9ClpoVCEWhexiXn8iBpYZ3HB/83aMt0TmdZ4Rs9iqJs4DkzhvNEQ4GQxJuDJdy0QZA14Yb84ZQhapsNnSs7TArDxDirXGrnsZ6qVQKpRTN/B0Y05hkWtHH8bM2hhr8wPFUB3mBrLCK62mqAFtJFa+KJxjnKCj4xVKyzpQ9n3cayORu+fRHkRVZey+eHPhGetFKcuduO9WWhWmRP89Rpx3aZc/uLFeew3+fdeouc4IY0AhbcIXzyi4MJ5GtKX50ddYW2JaGIRxN+46dJ+3L8aagl+qzEuvRveNaoy7EUAVqXkYB2NZ59MYQGZgXHT65fePlXXvKv8mfHfOEtpPuH2rCtehw7vNm200oKF7jUyhU23zNZWxj/KQHV4zAvMGjrB/9md/9pJv6BlGN2BMXoEpLow4lHA9epDR/X2MRDH0ZNQqgPuMED4lVhGsCe+LYu4F5iq2jclZ6EYs7isxasz14voI0mLpfThLlbj/O6d6F090agkp5q+30KqfQig1INYSU4Nd7v8qpCrhjuFyPJ5xcfdSUmqsZUyC1TOqRCStUsIvVZJ9LsKW7zVZXuOH9pR2N+MVEsEjrqnh4Bi0/LNzwx+txb/GWNWoWgv8xPFxKCQjVTzcDv4WLXAGKEeQl+qpjrnFIN3ZvmMi33JqNXDlSWgAXqhMdK3rLZ9T1ZJvyl5eQySrb8Z4c0FkYSMFzgvacCrxRKNCsHPLZo3/KzGwR7eNHKwB/VEa1UFD48KnnUtL8Eu3KvIWPdx7cwruV6fF/ZqTrUx/tLOPmtDjFR5xL5lsYXruS0Nv7wSY5avnUlgIluzpbWrlCVLDKQyKaFXOFtL1Em/Ne6z3sBulSvwN/XqfhVkaQZSB1svxmXnxUrR6JhvGdq5lyo6n9254XSVmjF3vheE658J8vUeFuIq3BqICXH5oxFAviJFoTbjkZ8ffefms8EFpVwPXOa0BxNN9PGUxaeNpSXa91kaVxYv7qmH0m3WifFdlznh0Q5mI2dpXAXfTGnpWAe8mtPIrWjaiR/+efabf0p5zQfF7dYOV9TI399n9Am0LES382vV2H/m+6rAq/6/k6JbqlK7hUy6ikZx16pyXbv1ddcHKee/ZMdSwN+qqQ1M6vLlRkCg1UcrIfoVTtL15d1EixnqFmF+Dl973531ewuyMwOUr7n+e97UKYg8PoxjX46gQ3Hgb7hNsBgtT9Owji1YvxXzBWa2IIWAMgoXkIYi8ylyr7FWw7H03FO0T7zCI/tCJV3RNHxRs782LIThVfjV47nvvci7o7Tc13OihiQI8R4N33/HUIIj83ENEKurpJqTCQSqWChX5vl6/OVEU6NjHtjY64S36rpsWrZ0IoDBGc2XWohFfocJ623U86gg1Ie1ed93RBn09+fCuu6i4OQEefCFQOYFWXTVyruEgb3cvEUr3q2j1im9NzL/7Lxyzjw6994vCytqWBtaquQzQMN5BT/xEP53D2TzRjyO/lf/CqGugym9FDNyrv4EU4CNysrqqxqmtOqL5sRrVOnb4Yft5s30KHkpSi1cDgbBdJMbA5zDeQgKuU8l0Za2///u///I3XL7WX/+36PcgHovH6hf+QKha45bF9viAVikwXASAR3NtH9vZqIhCMQb9tXoHHdCtycAmpy188UpGqKWenfOe1VQPYqGgKhpzaX5CEQEh2WfOlpa9VzfWlLnR4P7u+D3DmOKQA2DMSqvmeGqsQUs3ruOfQpSEbpVU10Y/eEmZ5kGijI9rqqjRQx+lXflA9NQNmI0KVaSBcFpFU2fA93i2z2ZutQz6NMJgsFQiicTQ3T4IeTX3R7savLue8hdpXy4RTZqjQiP8IQF+fTAGKqVEf/gav78orDnOA73L42Srv6H8ywd1CrWvJul+DR9awxoI967O83n7r1O1yEGNLB4pQlGDJ4dT+avjqG8yufT/ou1Lw0cmV0+07bUQxm+bIP2JgcSDOEPgSAsGoV4/oh7zHAPvyY6FGSwEj6meWBmCUieonZuEYC2waKcld1qVbSt3OmfM3XvWk/R9x7GwUX9XfJMRq6fe+1ZovaqcCvWVcXn2HQva8VQajaGv9TMnf/fI5ipNfINnJBirFJ8gyiakbbLcpF6xfeM1v46/3zXfUoy79GwSst69+/S9MIO13ooVQl86a+aLbt3E1DU3rvL3NZHKVt7gN/yOZvppFVk9YxGn8VQOFn7qGDk+oOI6NVXwGyXVmC7U6b0v0GT5YHnd+D57eOaB72xi7OZA46tOLH2qqFvJha7oZ2zmQJ/cO0NQfVZnpLTVGvV/VKOAKbZ6oeFWB/iUYGz04DoL5+ltIKMnPL2J2guDb7POJYe72aqMon8eOOWByQlFK6K8V9ibE1jo5D6vZ6yShJdNCEVE1xgLr9KjieMn7LH46DIdL9p4qnCqJFyzm34Y30ZMOzZ9NSF2rdGj3zCM3e/gf0UBqj8o+sIF9ZbQY42H9TvecRyKSq8qZuNtUm6hgH4mWpTL4hUfv6HvevCbDC28UQWABh5D2vV5UmKFbhiLhTp4k3iva3WtvHP34ZlvIYL748sWJzRarYHHT01Ol5bmQH6t930uYhQpGccqut6vzl95rRHvfeZaMrVRQWVeP19PtRC6oSOoiwy5b+dcR6XRQWmxvLMbVBvJtSilUFP5v/2uXJa339woXGhYT7qeFEYvpllGrGX2uQSyhA/oxUmqzsMRzgszLzo4waQYigEjTJN/Cx3xpI3/ohLjvc+FzpjX7085uM6chX6E517G75kTfiN8xSS8DUzB6FUh8qgXR72m1Bdt0KPHiJSR6tGhjf78j/kJEozYdT3DB50YFWdiyTFQFITP//2sGK0cC/qWVjXkqnmuOZgR/a45lE2Ecg28YZdvYZpVKniTorpd+sYP2tDfGp7uqC806DkLjWoaPfkOrNqqIvyhv3u//ynwwg7uf6+D5Py+RoJibLSKT9CNTMiZHERLEfNe8Wkjy87NU/ZAXN/+9rc/8EuLCko/PK+vKtL2DbqE+9dLb57xeAF/9AC7pQd+/GGq4USclVf5IxtcKz94ipyhUfmNLO4zXAr73TibZ6lTgdbmXViVgSy81VzWRzEKlEhDGILUUrOnJFrLS4/xj9igobWkiA0jRlBn6zASa+UbrSAI4vh9MUkE9f0qZN6fhWyjUDCEuRPom6sEZxne31XuCy1VGRQiovB5hfUYKfoqVULUyM190KCRkbGZ0703WkPnzqeKrQz6hN2bQxNsvq83ht7Fwhvt8AB3w1w9RbmT8gfltFVl+vT7vjbCRVtCXK/UO4NlbJtobp6gkU6hUt91zUp/tOBdLiSBZ4pnWzdFGfigOQtKvInn+/3Ja5Vw5bJl2KVR1/D6sQeAUuwcN0fpt/gWzy/6cC/HhnSdS49Gz4UZjbH3//GcgNyNnVWu5uGeRU46vl3zjXobYWzOao02uux11QsbPbl3ZfxNjQIm6xEPBlmlaCAVymMcYb2D9YrH19BgRsyLkDUSreDAjBa/MMuTZa2CIazF18twNTaFcerhgqZq9bdevgzaRVvmKbyGETQeSrHdKgACQSnW42zuoPP2IqAVisIdjaTKDxXg1+ZSIcHAjTAIag2TPrcCp/e4VsXdmvQqa326N/izFSL1GItbm3MVR6tLFrMv//IGGW+Ge6NmRk+U0M+feK00sI767jg6ZvDnfS+qrGNXBa6vbtKzqc36KwxY2KbwWcfaxG8VnkgXP5SnRANdh8pNK+TM7XSGPRnNszTJX0PcNdN+9HCsfI1TnSnNOhiHOZtv148sFpLeF7rhFX32VRnbqqg1Cmuw3swoHGO0QsRNCDXYBMPfol54f6Ho7/7u7778LQTtJqSGNc6IKTMgsImxlBitE7Zhzm/qWcBJqxAtQAViw0LjWYXjHqKClqA1PO386mmskNfzWSvf/43V3IstEhKw3L1gx9dailhmgeeqPrF+907oePk1MFXOBKDREUElRD21FVRoPUAfVQzrecHgKfhTXNda1modjKFVaE7s1a4/Y+fsUNBroMtTaEoejM3aEVQ0aNVKK8D8fiMyUUBzLTWOYInLqzk6u0neu6czuhhhzkqr+cybwlVR1+cKVO5aiXQyjP6uORlXnnsnKFdWORj3EokUXtnoE0RWGeQo3H3wuKKC+96hgKqZwH3Xbw+97PPbKed6/n/3/oyzOiOtvtooo7nHOpb4CM1uvfxNv5S+rYC81gKbp4bP9gC8Lds35jc3Ct35VyWG0VQNUZ6Ukw1nJo4JC09Y9PbtGky1CtwiUg73OqNSyGo9v+KymkTner2Ul3C3tdXCZlCRMV/rWUc1IJQqxYtxNqpqBNEKHWP3vRpsypxA1fBWibdU1bxr3Hpdk2SMTqMK83MsA6W+v9kwuPBXhbB16K6962CqVfbrcWnq7+HvLUoolq2tx9+8RMev8giPUkbGUW/cul1r4r9r2oisWDRjZDyFfo6vrV+jY3zf/TBVcO5z34NsHEfCqHOGmgS+6xiPQm+UzCniG9NtWL1cIyXMuagyp/y6DwONNgrv2PFi6SNX56FdNxe65fq6MdyeJoZJOXGf47IeeZ2/zwJVQhes113zGobfOVSX4EO80cKT5uQa1Rx9mzshm6+V0ZZHGZzObeHpN88pdML1TCVVrz6c59zzcyiqLrQJNUyrci1TNcytRy4RfUpWfXWrDV7D+mqMLEatce/V5znUeyxc0fk0WdgFodhBAhTajs17x12csQnlKpbWtaN180DLfK155rVuskzexLgUE6AHBSNn0xC/Br2eYmndI8RrlAu17boUnmr4XU9fhMDjw1/9Ho9ZI3tcGNnyTmHIJkfJRb21rnf7Xzy4yojhoBCaC7rvT/H2qXBoJLmsv1bUlIea9N59C+sE+f0+c4RyumtU3nEGmuw25oU5ngzj0+eV/0ItnAUGHAzNKFgfEQb58F0jt0bslfevTi6pRRvoawxkkaw00mlfWmGle+/GurbqI9c3uqie0PA0mVkdsojFm+YUGj4dU9yi3MN0GIXmDHpufJ9PYNCEgaBhTgvKq25Cq0kxffQxhRaFB98FLhZ/TT/CWffV7jvzUIWDOftYSv0qQS2EJjKSD+C98/yu3TibJ6lHUmVuTBRese4mDOvB9IynTUAurtzkYE90VWVzND3v7HbHnvGvMaMgeOK79mACArVron/CVIeA4qd8azxahVKFR7GLHhvx9bGH15SGXpRrTt2kd98pcX0yVCKM4tLFyI3FCbs3nsX773VwS6HPNrxjo6B59qFS5AfdzbcJb8qjB9lRGIVr/bYRmc9Apk4aOLodZCNiqPNTXnSPGpc6A42U0aT5BnSXG2gUSNZrGBmvfSxoo9eFT7+fPQhk11oXElZtJ29kTfFp502+yp93b2Na+Sw8SGZelPWUl9eJcx+yYh2bo1rj82Y7mo8IEsYn+KIDggNOuMHzHBsGP1nqhQx4XeAAv5Mopjw1k6cUixdiRAoE7NEEcHcTMlB2Vt9cCVU9DcSvwBD+CiZh7q5Ni1PYog+932isp8xe87kS10YfLUuE+/agtJbuVgHUewYp1OMxXhGB6xrKVhGVGdG/DOveru2+lIVWCmlI2vqNZk3q1Rs7hYwerdRgYO3GbUWM3ytlNce+qmgYBvze8ZiH+Xd+9fK7I//4v5FUISzKgkwsNOpvzlaNwc2FMi28cC/nitXouTdPtUb9PmcwPcJUhCahTblydvCh8R0/1TlpqSu+wc+cP9AQ41TYmSzdq/J392lk/2SMfvzw9DJr1hJ6R2NQ6F33XicHRm5stL3fKKdu7mMhKXue0K16Ak8bf1GXQkmFRN/cKICJzlPkQd/kGYsqA0ToRiSKYD0STO13i5mVARv218PlJdVoNMyr0fA/j7mhLKVmrrx+RDeehngV9HoJKjh2MwrhrwfH02nkUdx1w8YqgeKbmrF0s01huMVwKeyF8NzTq95TlRraUxit7LBuDWUbtvc7BkEzT15Wo4nWnWs1bGskeJaNumoY+hCUpyqZFVp/NwJrzqS81zlX4XZdzct9GA6e63qfxljDXthUlFB+PJ7wlDPr1vExHPVorSEFaC38vkUPrSZrfuE+p8Due0pUrqH8UCfD/Zdu3U9Uetw1PW13ZbD0K3+UL380clQncGFRc29EYx2OPy+yptd2p3hPWGDofYefyh/oisbNCS59Vkct3PRmRuEs2z1E556u5tnLmNggKL57v5CyCTCEFPL6rNh7s/E9XEuo7z48pVrQlkXedzzwRhUWgUcmAqDM7/+LECSwCnPAVTc5vsxCIatQoUAof0anirO7KOthNVKy8KWze9foXF+8iPN+0b8KGN0LO1RgqpjrNfMuexjdKkD9YOwqLd4fxiZI5lbIgDDeWvTZzE8MvvRp9EfgfGYsoqZeWxy28EqhsjoBFE1hA3yGHjzGJ4imc6EAq3Twd0/vbaRtzuSqxqr5PHzlaBhjURCCz49fjJ/3rw9RMLRgx48mxnxyRH7dG7+qcLtredNt+B49GiUWl68jIgdwG1vxHaNK4RaJWBjS/9+PwSJPZISCF+WKTMikuYqW+hwVz9nm+JmXvq3xwkB4AayLh7r+7r0GoPT6KEbhn/7Tf/oTj7FELAeHnQdS3LhQThXfDZy3woK2kofCZgy6Yc2i7mFnJt+D5Ap9WNDCM1XqlL6ysSaC6+0U1ysEVmyPYBIqzNaIpf0UDiiT99V8R5WnhW9CDLPKcXT+3u8eIjw5Fa0Kh1JbjxujGqu165qgq+9Fk5h28yTojBbdBPikgLYdT91LwQFlQJGCR8yx8A+lUwNPKReKqmKiaD146QkCNGb5hD6kyZieIthWY4FURJZVCs1BgIi8qgzJWyFQc+et399kmFHvJi/3UXDRZ4XUaJrHVs7tYZruj9bkiAFq4p4Dgd9FISIYcnXr6wTSLXwoz1nH++6uY6S+HqeGw4L3T5bvusI4VeCFv8hCjysBeT4paRDl6Z4zzIV369i4vzwYZ5mcaaufXPPmRsHjK+vRqO7oscwGUaJQRJ1klW2ZdBNTFEqxzYaixVHLpMUkrxVOqje5z6VtLb3fFj4QIvY+DTuNZWEY/aBBFW1fFRz0pJTqPbyGEZZ2Tnns9UJe1WGEkAdTOvXQv2utLmnuowYTw1egn+DBYuwbSRqn3NDntRoTr9boV3E2cmwEVYOnP62R2fJcx4rnG0lSRt274d6N9Fxv7UAI5etGXY1OymeVD/cT2em70T1F7PeVS/mY5khaIlna7Rgb8Wj18DkimyQV4VOu1qF5l0br5LgORvOF5bka9yrNwoI/mqi/DgsI6j6jnF9z4jYXZG3ouDo6NY5FJion1rURxB59UiOwjtbCsm9mFBpimeQR6mAilqrnGNUo1Lu2SBgC8Tu5+56REYqy4kpQhWi82W72AWmc4muVAebniYhwKqQ2A10/xf0oByHjeoT6KLNUWWHuGgT9VmF0oxOFXINQrwQTbAmjzyXESmtexsGBhBzcxVMrxFO61YD2+2uElSD6jKJkcJ82LPUYlDV+rcZ6ihbwYSMYUaYjNWqc+ljUGjSKqNCFhhevNYzHcxV4a8iLq5d8791xC2rAJ+hWZeL35ZkqzCo3EWWPhm/k0xyH+9ToFapE+8K19z0MHQ15xejIEC9kU0VbB6LOQfeRdP8FeW7e0vpxTvGH8bTSjIKu4q4jaq5/G53jVVgIvUU/ImP83bOLms/DQ9ahx5lUvszNmKvrFBWgB328eUW8bpytNHtzo+A5xpQV5mwpKOViEBTQJVxUJDjVVAhKaVgoE1MJAYM3Sdbyvr/+VR/c5629B0U1TPSYUBARYfY3HJCCqCDWMybQHgpS7LneU8N1IaffHz0Jdz0gi2pumJhBIfieN1wv0TwcKSAawjhohqYgieLuxtTSvN4HDcrQdQAIJDpQUt4pIvCWfQ/XqojrwVWIt1GaxgBbt5tbFISmqk+sd6u7XFe6a9alj8ysYaFszY/xQafmLXzWSjRKhkPUfSgtnmiU1n0f9zJneSnjrqJvBHa/pXRaGYf/0Z8S1Ce+d2Agp0xyt2uNb91T5KL/5Xm5t+tbMlkfNX7NPW2jrG+tyMBW8ph/nYofvC9vraLFK/hR8rqJ7panihROz91z6m1Yc78iAkVDRJ1X4s9ZvYMI5UjqBDBSRSpqGKqHOM8fBT66wdU72LCFB4ypNATYc2cwRLH1wgnF3ja6WLionl9DRN6vxGjzE7WcCNj+yrTGsfDIwkurRKpQN1StAqaAaoQoHcoAo/Pc7v8qcnRr1Yg58WoxKM+u0FohKuMujNX5mY+x86gKaeivXkojo51v+aXQwirsp8/RB97KqWhCnPGytgSl2DHBar+NhnilLT1upLGOTZ2IKkrfdUd4oywOVb3Z8lrpud69vULdx8ILNo7lz8IOmrWqEbvWnAM+c3xEo5hCPPVYC7UWDqkHftf0GBd0L7xXY6KZ38KbRSwYX/dUQGLcv5Q8ZeWK8yiyrVLn5NKB6H3jUCjRfVPlp5WvFsxcH1ftaexPXv/qnfJK9crmMd7s6GzMpyqBB+/mVar1bpuQs+CIXQ9ocb8uHAZv4vBaidrP3bcGYRNd9UAtSKEii9ySVsRepbcLVW/AOCmnevU1ZhVAAu//eqP6AY80x9LzmeoZ9WlxFFHxVnOi4NfDNC/z75yNwTxLnzJjjcIThNa+qrBLg8ItzX0038UA3rXq/SmKCnLPZaoxdK9r5oAnemTCNdEHuuir+ZDW73c+vEuGSB+FqMgUGtWbZySNpU5aoZMeqd3fL4T7tNY1Dn6zZzHd/6Bj15Jx93CUd/mh0Rj61hD1HDBrv3se1tFC/xoGPN+iAjzc/Rc/fL8juvxQ3tW6n8Sa0E3mB7mwZ0GRjjHU+Sg9rLfzvC4SI9N3rEhPhCBrq5Os2cramxuFy44XGy7h+kxl3s8RSiVIw5ojUq1fD/QiBHvkQEs7CyM51sLkG3XAlBEOgxDyjT6E7VWO9YjBMPpaY2Vh6oEyMjwRyqnK4ehx+H6hpWLBraCp91oMnUKkTApHdWyNIspM+mEAfV7s+BrGl3vomLs++iAwvY9IBTRYr03/vFle11ZX1EA4N/+1PSm367b5FA7IVrddbmzPwO/90KzRABmA/1JqoDE03cPp8FjnLipFI2Ws6z1q1vO1Euj73s7yu9cZx6PT7Zw21k3SFtPHv4Un14iU356cLfcgO/ioRqXHf/cEV/dGm1YS0Q91vp7yI9dfS0rRmiw9tc/mfDf9bgTc3fQ16PgLRHxzvffjgdORff5Ho3m09ahSPKf8X9HIrSNHhwHBhzVkGwF+FKNwE2PhOoBWVlQxYQhWuNAL4aiH2bLFYnByGA0dG0YVa+RFuK7eTD3weif19vsbwt3IY0/5pIQQvPdtpVOZ9lo9+iaqmhDbsRJ+v/edOvjOteWLnWsZpkJXBUGhFiPfMLQRAEZm6FxLKVeh3v+q2NCnAkUYm+ArhFec19qh68I8dQbqvfU+93/P0eHEtPigc2Io8WXlgcFHkyqLjRLxKwXQaKQecxXQRrbmaV4URGXkg6C/L7pgyAulrsOloSeno07KvfNk70QD8zo0oREw+t/YlKDjNWu+hg699vwpub7St85K5ayRuHv0tOA6iTx6UdUPAk311dym/OhCguhmDkULzBu/9YmE5mhs+K88vs5ix9ZIciMEkWjp/GZGwWFciM3zrzdcZVUlVI+iYSvCYRwJpiod9+kGrcXitHp59/16zavMyohPfe44KPx7b/afEaMIqkBrtNpvz9tv/77vovd7dMVQ9RbMoQbF+8Ijheiq+Ft50e/MtSEq4eseCr9pP/pWeABa2Fbh2DViFAh6FT8eK3ba+XedtVXEsOTyR+emz0Y+nIdCF7uWflceYEisBc+41+xrDYH76N/Y0aflqgyLNb97nTxZTwa4c+ia2+BWJ87jc88oUJR9BkMdrq5XlfnT3FxXGKl6BvRXpV/nC90bMdT5qbPgVbjyx/OcEPcvTFh0YnOCaNw51JjWgKEVw+BVmMw9axTK33Vyil5YwzW8b2oUWEYbPY4pvvGNb7z7nd/5nRfmuNCIEqScEfOukTjSD8aqounuZl5N7y8/4OjphtvFDV8m9x5rJjw8xns3Bgze7HwXGWEpNrCHnAqm52Gvku85Oz9B+BxQdvO1+cw9GtUsVOHFqDiKo1AYATXvejHCaX3f9a1k4hXd9+c9bysuXVwXnNOHGd3Y9vC8L9o2MsEXvNbSBz828viiDb0Ik4P/KBh0rBdv3UU0VXJdp3qvWiOxrrM5V6ncmOxCrkN1DfRSZY+P7reVJfPEe6rQNOPuXBvdM5iNZhvNGw+4ipz3aIkWblQJ9tkqFF+NKv7aCqxVfj6jf/p8DuNuKW8LE+qsrXPVqrbCUHsQIrlq9LjrT3Efna9whx64kyJ6bpz52JCJL2oEjY3D3TxqYfNGTm9uFLQqGqc+Xiscci8JEgxwRLBzjweiUkL5aBMxN4kLR48ol2BpiVstcz2Q7qXYjUTu6b4I7SgIxoCSreLeTXGYaKMMCp6HWetOcVWIr7nePcFJ9WIJhXJLCfAKRwVCa1JvGVdjiPz+6FEvu7mVRg2FZjz0pMqvEcWX8VQ0DN7ncaORtXFa7cJUTzxrDaxXaW/tCyvBjHmShT6elEh5QcT4FC3qp4qu0Y61p3SssXswij5vNZF+1/vcJHO98EJwlL91XxpWwZ/sH6/82Z/92U94+Ggkj1IoqbQ110LDjjk3n8oORwW/Ng+4ZdReWj1o/VmL7mX5SmC4NYaUsyYvQw7rEJQeZGGj4PL5lZ7WOe6zoGt0rg86pNCYOZpT90RYz4+SUyjh3KAJLouDqCWoh3EcYc9K9mllGMQkEEdUYPt3jUGVTT9r8rPKr0kw428irX3uMRk8hdbe9/5lwMUzN9yrAuPVC2mLd9cw1usgLJipjFdYz+/LCE9QUiML63cMWaXfc6qK7/M00ZoSeY35jL9rUUWzwsRDhlMXZqQU/C9SK+z1dH/3fYJxCp/1Gt9Vkff6etblhRrDNVSFSApDoE/5C2Sm30IFhTwKKz3BBvi+932Caf3uiUbuWQdkTwCoYtqd1E+Gu7DuRufGXePbV41Q+dl3daw2Se5eu2a/kDPB/F7UX1rW+NRRaGS+vIVGDJv7Mu6VEbqhRRatKlw6FA3o+vnsi7afKVJobkBI5mwXngwP7pT5KfV/9a/+1YdnCNxvryLkJnIeu63j97mzeljmUwj3Oxa5CqieB+ioOQTe5PVlh6EFLfbH+pZxLaj7KSlbQ0ShLaM0xKsyLwTQBF8xZ+Prdd0kiMEbIWn3vYiNUJUx3McRyoVNJB17aJwKoU3Wokk//zzssl5U4UO845h0QmAs9pRYX48YrUJCq+O5g7ueIC9jEJEZS9vmQVplVXioync97q1G27njsRqgRrs8Zesosqviumv7VL9i591w2MZJAxU28rJDGT/6rq/Nj2xEsE5LHa0qQ61PBMRHoCdR1j65sDIhKmhF3zVrVUeryrORgleT0z9+T1v05zzuRrnykCpHiv74r/px5a/6qmgB2Edf5lyYrihAHYuiJLfOleve782NQpNREiCHF//jf/yPX0pMDxdTJXGRwe3mO8XD26un3lZFdaGoBb/fwQVb5cMj83exOCH/vUQZGJjQC7uE2IcfNwoyzlvEW+BGNYUfKGuwVheLcDQSaQllo4eNaMqAzl9v6LseZhXIvatsuD7rrWEcc28pcD1CChus0J2g13okBc/5p2H5FFafINbnTNjdvZ4SenRtWw4tgvNsCb+1Q/r662GKhKQRaWnIyBWabDlwIxP5hnrx7W/XWFtlu79fWAeUoF95jBcBnudRLzyl73qhnCAKCX3wBvm7tapyaZTbiNMu5pWB0hoNStdGHn5Th680aG4O73ZXdGWs61cDVUeuVXyud9+vxVCDMLeyzpi6oQ7vQSAqL801vuYoMEb6rY5b+MfYatyLMoDhybx8xEcxChbubuIhOx5G47GMPLirh1bid59LjDbBWg+M4iAEDIKF6u/KcAiBoQrbLDRhDhXaLfejAGD4xRgtTL2GCqS/C/GsIPQac8HMTVJhyNKh98M0pQOjpg6c8n0qtWuyfdfBeHktZcrrw0ZEic6eEbVRVPFe87m/wYJOtKzirUd43wnn62l3HfCeUszSm4BtGN+1EY5X8ZR/yjeFB7p/oE4FBVla+L99FvrBc6X1jqW8i+d7TaGWblirUm8CupGOz0TlPeeKYaj3X8V9bZVODWSTy51bvXe/qXNSZVu52KRxk/M1OJWVRjPGtdDnZ2M4qnyrc9oHKLVIRmWx9FpYbuEw/NVKpd7nSd800qysVl5fi+DfxCjcjeyMPe/sksmevHbf9WyhezISL8QDeWyH34PPEKAPxPA5hvLsYwqjxFqlaPHqvVjYblC7a65fBC+TrfFCWPev57XNdy0LLO5Xo8RLRZNWTzjKWFRT4YU990hqihyTnGA1IjC3m1dD+AoLxq4na5yLR1tLD5yvZ0hB95ypYs63WewiSufOWGf8ZfznWFjnPgCmVWaUBkVvzBW0jo3Qi0IZZx7veqYN+9sPOnTvAtpXGLtnAKxwrR68qNf6Gl+Vp3HfawsG8EIjPHOyVqLeGkF0rXIX1bq3vvDHE97v/5WJyqjPG3GX1o10VC+W3q8pxToSdXI6nia8GdTKXRX19wPXFp5bQ+c3PSnAjmj9LC92/E+Oq6KPyl8jn6539dYiMTVET3DpmyWab8JnBO7QJmWoW29/yuaEXbb+Pr9owvNcHWDHa6kANGxyjMbdUyRSq9ikkkPAehBYoaVuCGHcEMvjAN2zmHytbg91k5+wIIU7esZLE77F+Bv2EmLlh3DSwnRosZGACOrmSPHD2d3nPHJJ2w2B16utkGPaCpnkv81PTTrXYJSJe/BfD+JrdUWTzzen7gauQr3rralae89QuO+OH+/l0LrywGtKRavQHI+iTbH6wh1gGDRYT7nRg/7umua25LLcgwxUGdQ7r8PDCSADhdkYa/AcSKMQm7FZD4fpubY8eq2GD7+KRM2nBgcfVqFTtq4vZl/vv3zpun5fZ67X3rhv7a1TI7HTIfimT+1bx+ezRHPdZFsDZVz6w7dHx9OLLfkG4XLO6mg8yZz7cxCtSQ/71Le/G/018V4eb17ozYyCSRsAwsOI7/8rH6QEiiXukbcUeytoEKoHUvU3JvVaeO64gzKCXZx2WBeX72Lrq54Vz5Vysbhbaoqh9GmcFHiN11p7TCF6wUT6qdLnJRd3RheGomMEPzVp2+ikid16Kxiw5Y6NLnpCpPETUExZWKLrwZtVPVRFQzjQs159vSgem7WHoZrvvc75EJVSHIVGjLuJTEKJPo3KKsw1CsZXOKq/paxrVMgSTx/PmUuTvU8Ksd7gjrnzKJRQKKUQFL6tUlslTdY6/zo+aEzO1sjV6yd7xsK4NGm8EXiNa/MNZKF8hMeqKGsw4Pt9PstCc9r9tkd41NEpFHmtkXkj3+YreohejfmuH6fI+HpmHIPquuq/6lXty8BGP/PzFGDs9Wwplfu7UEFDtH24yeJ+WnMOFeAl5npM4JYeZ8uTsdnMvesV8MTb91YJeMl1GFdDvsIiFTaRg9+KHPYANdfXU7x++jjEuxaGzyMjcKXB3eu8EocQtsa+NGc86qGCmzw4ydkxwuxWSNST8zxrCqwwXGEva7y48mKxK1Ro3UiMIiC8951qt0alVSatrOIxWus6GzUIFbgaeHNv5GpN6xBYD/NkFJsUvcboVTbweI09Je53nIMaiyperf3u55SM5z7gBVHi5qso+ZZv4lO8BFajHypXFOvCRTW4G6l3ri/KK4UCxqk/Mlvj170RNZRP+YavJD/QSLZ00OpMVo9x6MzXeK1bnbE6UY4hdx88gM+ss3xWdWLX/MnReXOj8J//5//5h3LAPu+VMihzYXglggc5IYooArP1TJZi+LWKW4ZKMZ0SgLu3XKvQELiHIaNUKIZTHPWStS7UJsbrrTb6ucbjcdZLBVwISOgo4ZZkNkytBy5Zj7aubSR0/V2Cn6K/OV3ffZiQ60pfuZ9WkXQt6wQQGkcfXLt7gMcIePkBns1jagRIiArXmFM36tx3IsHrnwPgPn/0R3/04dnat9P+KuLOMBzU6bz7FiTc+/WBnjVyFAtjW2PB4YCzG+PRA10vYhbxrZd8RmtPsmWo9kh6vHcNz986lj/cs2cLVdG5TrNrmVz1+dc1jAfDKRk/ngLNggAZSPCUtasck78eX/4UWR5NKvMMTuG13YxX+YMUdEPZwpCcjaPX8WuN+SZxr9XoVXFXzsszvlPAQW7uHZzW36A349lWOJWMg0EbQfS6LR3XNgJ6U6NAGFqiV4WJACZNEcgbaCAonmDho2vFUAl9FaAQ18JUmZW4xT/rIRWCufdW5/C6zcuCLh63EU7vWQ+8IWfD8Xp/Sm/rNWvFgu/v7vgshs27qwA2WqoxxFSFYBrm1xMl9Bti87rrhbQqZ6/vxp96uf7v+S7WWoRXwS7TUxg11H007Cnmc0ju3QObWvBw2O993giRYDe3ZYzWtzBk8edGNtadA1R4TrQjB1DIiXw00f+U8ETbllbueVJNlNeLRF8Ra3NddYT6Al8Uf0ePjTqMszuNN0fQpDU6M9Y1hsXvC4dxSO63PYV5ox5PbDQHEW7l+QnO/WyiNzqskRiUpLK0clk4p8iGF5ozPI04K9eFegsv6pd+oIOrQ6v/PopR4IGW8RsStiSU8m/9N0bsxo0uSPt0z52U76p4ugh9+b74bL0vCqCEb6i3+Kf2WqhGidbrb8KUd+n/nlGknwozeAtdK2AYBMZbKKjQhet2zK2dL6Oh1cJ1LwyTELhjeQp1a4AIwEKH1oTQNQw3H97p8kyNEIeAE8E4Xq39Gd2eaX8RhOod2DLDhLcKeZRXViAr3As71YjV4C7kVL4u7EQ5UBqFWgh7DVEVTg3WkxLsvh7XrUMECqKEr6Fxc2CtCDT2TZg/KaV1UIzHGOu0NHICV1XeVne4pmXlNeDlb2u+uuyzOSCyzoyx8/J7ffWD9S5dyUPXQ7VXCwwY/TUINYAdK56pg9ZX9debnpIqn7AefhM/JiCkttO0O2Cbi1D9IPzR1hjAMylSnhY8WYiJeD0Q61rxvY0envBEAtrv9X3jbyK9i7heUHMu5l0luYtVgbrr5BUwsrmJMEQZ9VbcVy6D8BpXFUFzGNda6mgt64H5fbFg9OXp1ZibB2EiCKKBCmjXwdwcL62ypDh8YagqHwYBTxz/HR/ewYy///u//3JNjy25d/kH9KMMmpTcqrEa/WvGVryXEu1aaYXBRBb6aqnmnpdlPe76HsvSiG8dGWu//NqxU6B4oPmjg5Ou3Zgu+qozpQDhyoybOF5vtsraXOR5+lhWNLMOIifGo9G0ndpkHw/YtX/3UTXp+cmrhDu2r8UJcD/jrWKmy6AjG7WSQbBPS85twCQLdR4gFzWwCy13bGS1EChZaHTy0U5JteCUOAvcXboIcELmmOT1SFZxLmzxFDHwskEhBOBlIsnue7GWcgpNXjbaWE+m46kCuMYjB6k0XG5ftea9X2EHwiGZZfGVV9qEdZAIxivTg0l4bV14zFS8tIqcIUe7fl78diO0whcteyvNGAa/KaS3Rr/Gr4KFwe/vo4VoyZ6FeuL16OqNdV1OORwdT2ndrvlTEN/61rfe/ZN/8k8+JMn1jS8oxzNErWIrLFJ46e5rL02NAvooS+zRHOjW8s4qKsp5I1t9yiNQFN17UgimhtzeEeNuCXb3m9j1bN3JQiM78OvRlxG+cvRGlnRF92CoUjJOfA3iY/AYH4YJXYvzK7rgKDGm+JRiPKPWqKbK/Cln8NmcWLwwbZ2CKl7816jw/j+a6x+E5lVdd+/mQMaMxVqgfRPfdb569EfX/qPARwSZQLZa4BpPw1ELmA0TNcz2m3pnNQxlxiqs4pT6ayjazxe/a1jecbt/a/I7VgvdvQrrPS6DNZTzMu4aJUaOcugGPoLOC6wxdb3chf7MtRCH7xriN4xdaKzRjD6vWW9z7VptaO3/rntb16PjKKxCgBrNFFLARxRV80AdI55RPi35fp9dbuEiCQrdenNm0MbDjCjoNZoV1EJoeMh8rZ/PGm3hjeYKdk4tj10+LsxQZ6Brs7QslNaSVJVQjFOTwBLFEqBgYs7G6YEe3c6wlhcqK+bkyBJOATmjJAsjVcFqjU7Qr/zdiGDp3WuuNRpceGidpeYp1yC9lq/bXE4hpzp1qzMLB7nnGrTqQmP8KPBRrQ3iUGjCv/PAJPBKVI+SK05bY2AyDavANC03q6LRv3AM7OJahOVNCP94bMbR46jrafBMvEBWxlPD1Pd6KhXqGoXS7zyslng2/GYYCl9hEAy1xuhlYecB5TUE/m7tfCvGGLoyo/VgLCi+8kIFtZ5Xmb9ejvUg5K1eYigoGONlANdTwgc18q004rFZ41v/23H/b/7Nv3nhVZsr8e+9wHZ37XnCd91dc++FSusEoGnLGLdIoaWW9ULv8zNOhfWuka1GihX6wiqda+HSwnON6jgdktQnJyqGyHUdNDyABtbnxn3Q3J2DdpHCefh/+qd/+mFjqOQ+J0ikIiLpZsjmjxy2x5DhMzkO3/kdj9q6FJqu8a6CZfDKlz9OtN/rmucxlvuckcQT1Wnk6frYjYvWlLNZB9H6lqcbIRvfKvuOsXmsLwohfSmjUGy7N1E6dgJ1wqXun7d139VK9qjsRgD1oq61IkfzvwobCqWwUGGVYuUVTjgf3JQgbKKWd9nFKbEpvipEC1aj1GqWu4632sijXp5G8Rr/esC9z3oFVdqEZ6Eta8kT7WdL+zKc/uulrWFcL7n9EzRzKiTRtnCJ+fmtJpooPVSNGGfxWPcROZwSg4nzau+AR1VL18+t111TGMR3lDG+Qw/va5QrQ4WPzLnGXeRtPU8OHSx492oRB0irBgANa0QWN+ctHx3Ke4VNjPvo2rEaZw3S0ejKgtGaYYOZozvUobRyEgInlBGgT5xywPsuOtCkMIPlemW0KsKsG+WMb76XQpH7TBSkWIHxd49GVwocOueOrf+Xxpyi8g+Hivxyen1Xp7oFMmjjWhHxU7T+JpHCJomutda5CsuZPIS9SqoDfMK/XYfxeo2FK7FrEPow9jU0VQyIRria6a+RIlzddNVQcqEPv6nSrlW//h3NwDtYWEcrzFZIZXMXhYo6tr1vW5VzDcWG+FVSjGPXrwq7Y+r37aN99buF9QqJdGxriLbPRikw7yrLRhmd+11HEd31kuDGgDckDHn2lE7zIB1TjdBrkBnnplGANe/1TYbyXHnWr0WF6Gt8jbyNbfmmtG2fu64+K0xMAdXR6LX+Rs9WKZYG8g2F8FoVaE0YPDxd41T4yHWFchhF8/t++uv3YDJjb06lxvg1uhnfwlkrsyKIRgLVH0VqKgflI3KNVwpvv7lRoBDqlbPiFKYEzE1MAs9iL6G6+IVVFou+zyWLedWYskS41rN0uvuT4dpoAiShLxYW86w32lC9QoLoxfevbf5DBZJnGbhfsfGFBcyvCrDRx5Mw1Nsvk5f56lEuFts51BhVuVUI4M2rbDZsbS6l4fy15qdqDDvPnmhb/BZ99Fm4SAUK4abAmkQUeXA27uWMrkIoYEf85P7o0fv/hKDFcVkngYGpx9kocyNsv/G3JxfKieB9cCcDR6H1kMWuFU+29LAOII6Fn8q/dEF5oHh68yo9AoNR7flLIN6uZQ2pqrTdGKcPugOPuBZdC83Z2Go+P568FbqAv9bBQrtuuHSfbkplpDbKJWPWGYQIPu9R8SvDlUn3uN9x3Lf45qM8ZAejUEIHF11Wvwcy9dAzHliVpZAZ4XoeyX3Hy/f4TkxSJVJvkOK7Ph0nYKEYpCaKRRIlLgPh917NB1gYTE7wVY0gunkXK1QeV2y0IasKohqAjQB4TRi+ni6jDEap8tYHJUhYawjQqPf2eZmpSr35H59p9YL7+zJ1YaUyOZrop8bqtUiqkajrzBEv1AtdeKsKFlTx7W9/+wWmUVYt6vXM6eu3VSgnB+CmjaYbNbYM2LqAbzwK9VrPALvWY1yu3Rjvnrfv4hSWR8xSesdvLUbgnDiVwHgoVXzYKq6WJ9/cWyXFUaOEGKTKRXdhW3uGsUnqHvth3oouyBC+t1sYP64HDRYqcnGv6oJrNUzl4V95f5gi3ue131jKo40Cmh/qY1T1yfHi4DSZ74Uu+ru52CWPx1WE1QmqkXY/fdj3weF5c6Nwg+MhsZ7w11ZHGDBsrdDAwhBNYvp9j9Dg5dY7rFdWxVprTNAXe1to4QkqWcjJQvVcJQx4jSdw7e7rf0bG/+CshtDrdRhDvYJiu3ttx9EQsx6E//u7RjnrmTcKqCJtH73/l21VdGsUnu7zBGlQ9BXSbeuxllc6fnxCOXaDIT5ySq/Es0okO6Qdl3Fr7elwC+tUcYBy/H1NMrSHF5YfFoIRQTuA0jMp8EE9+0aGCyMsjLQ0axRK2TrxU4FHq5U4F92r0CjqWve7UPpHB+/NF9It+xwI8tHS0spTI0lr77ctEKhD9Nl7o2KdGkH0QMo6I+VrxsS97aWi8OsMkzEwpPUVXRTl6LysZXOQXb+nIp7qgzc3CqoUmnUXclbYhD6rjCxcw7JrQsqWZHanb+vbKS3EWLilnkeVSJVo8fSGV/VE+92NTc00TLaKjSHCXHcNmGjhl7Xuxr3e/b23esY4qrRL1xrJ0r2KtteZYyESa4H5ipOXhtteY7r9rNFZFZw+tr/+3tg77vLbrm9bjcFT3uo+E9Ey/jXKJ6jW4vjAGUtXpeRvSs3RHOBTlXgdN1o2ovDO+NTZKQ8VTmM8rF95t3xeLNsOYP93fZeePhf9iFYbbVbRUWJFA8hH17XORuV8nw3SiKBlnwozOp46nuXz5oOqLK3vtSbrv54zlup0iOYVMOw9q9M4xgpV6IzSytzud8dHazgKiTW6Ja/rDDEWW+33ZZ23L3109t3kBMRiKC9DxCbhujgdbGuyhXBCq+6ShENev8XWWg541/RMm4UnKnSqjFRAwBl75nxhIXPtIlG6q3T6hDaRjo1KxcPrsRVjrtDWGGCICt2ToiQgaN9k+ZNHwxvDuK1OqHF4qlpotddT7uXz2iqgzqNVF8LeeoT1EglYlcZGo533Go3COdZLslNyjpd/PN0D1P7tv/23L9ed8r8yzDtw70pV7/+WOoN0Dm7qWf6i3+tPxIF3nBd211NEds+DISkmsnGRAuOAbpS/+brv/f4gKjJJgZHL3akP3qk3bt8Bx6Z5nnq0dz/Rfr1cidnKPHqonpEbYCDLO67zLG5GovAtPgEV15ky35aO2zX/i+/vh74tD6+TCx0RkZGL+6w0O2jvFP5VtfX+HlImqvQ42evvfucZKA6xJG91SOlBuoKTeeOpHv6yhuFLGYUmxHjEaplZzyp+DGKxGlYVq8dcIoQaCoLYpDFlQIj6fF7385tGEycMjla+d8zSclCKVyvj1MupUSAMsNZWFNW79dkmX4V8xUwpevept6c1MtvcQPMCrllPu//7zHu9xrZGZgzG5zHcRgGFAdFt72Pu60H3Xv4ujZ+i0s614bV7U7KFC5pvuNY8jxwFQbta/BPcO0X0+mIA7omE7sMxaNmmflWiSXZ2vqWLCLhFHujEIWhCc2FJ8GU3rnFQzHuTpzuOermUMOfwKRdWJU6R6wes2sim0bv/+6r3XziKPvF3+4PB37VoXH3FMUD7779X/kplzbfefaOfOmL9v/qhhQnK7OuMgabrWB//4E/PqDnDYtf4/a6OQeUdjRsNvhbJ/9xGgZXvIXe9YTFLxF683cJv4pZyrlEghIV0mozpufQWnqC5xu+vX8+M7nHbrfbofTDWCsl6qz4zXxFHheFJaRVCMC/0K7ZeI7KC6u8mf9creA1+2e92nlXEa0DWCOy4ntoanA3Pd9wb2r+m+J/+7rj3u67hfvYa5l6FJ8np9zD9E9hb929+85svUYO8G2enidtWwdWo1SPsmq/cbD4NxOf/hUCvFeqpgfy8tVvD2/0UnLS7N6/0+iHLrSgsjfVXh235rfeFFqCBF+eyuYKl57X+tkqzZxwVBbjGIGx/O7auV1GAa81xkOk+b0If6AWhuL7OqZBsv2tsvmMklM+Xb2sU1ol13TqVb3bMhRDVruUO3uMer3XRrjXZ5hyZ++6UtbPnjzg9+6WwhokheLH+DQubiT8DcK8///M//4Dv1ysCgfgNi3+t/e6C35gxvbnVCFVo0YN3AdKql/IEb5QJjbkLrJ/OQbhbgV+l+CSEvvsieYTXjEmT1YWd+nmZd73Bhar0CQ578nievOtrLYNWftiIrVHK0opXSSEdb+7GOg5LK8r+4A/+4GXD23l5v/d7v/dSmUeJK2l0MF/xZ3MCN3hiXM9Yur768Ck09lCrjTZvfJymu1efeUCRg8BEERylRufWzzX4C5+AQMiJaBlUS2HXY/e/9ezegPtuIVye/dFWcv/+r4Ks8m0Ui141UHgBXxZG+yxP2SO7LSeWC7Er3jq2UmyNgfEpzFFIUBi9lV7HIyo677v7zX3m3pxa84OYgBHx443F2V1k+qPkFOBu1yjlhnY3gEYRTZL1gLH7HyMqPe0mlGvyEPWIiq3xzFtqVWxeohehetplQ7f23Ux/oTGhvwXtLuf1bDB+k2CEzIItoxX/Lzyg1SiCDQhAE9af5z1XCTcZ5boKqetL0+23TLZKdu9bQXmKcDYKqIChaeewRnONG/6oc7JGbj3hQgK91trUQ13ozHdybP/X//V//cQmM3kD0ICzlig4WPQ5L12fzvnmYEdtMXlrinf99owPoyRnglfMuft16q1SZhyMKrmeadZS0tLgxndQhwoo1xrr9eGeIsFrSl3Nm2K7d5g+/lyYGY+19LS5kXNk65Q0imjk/r33+qL7oRin5kvqyKnCpP8qz4oOTtFT6KfznGmmmcd9x4jQDcr/VYAqfsDb5toosoaVvn5zo7D1tCxq8bQ+VL3eK6Eq9g8uOiI1JKrS6GJX6E1W/xUgggyrbXjpN/Uwqmjap5rtKugKVMfaqKhKZxWkeWBCRqCKr4xi7k9QSGnzeQahyheNXoNunpRzaf40vv7WtV27XvcE36zx6hhLs36+9Fg6W6OOtWvQVhpal0ZLjdB2/FUoFCK+472rQKIYj69ULTEMpwBqjOsA9Wyd8htl63rjMcYet93H6C6Pt0hh4aTyXqPB4uYtXSUHhYXLn3KSdZYaLW5epLi+IpHufC4N0KU6qOvfKiROlVcdn6+/1114oBF0HZwiAjU0xkMGWkFoPfFmo0R/y2tc/4WbNhG+fN7ImgGwDoXP3tQo2JRWi34DcDgWSAnxlL41D0Bhe/j7efK7IWeTJg3lCrfU6Fisbk7z/AcMIjK5g9AcyCX0whR+L4qwO7IRy7U+3hDTVijLNOvFLma8nu/CHe1TH6uYquCfEoZ+3z4wT/HoJwNULxtj+22FuGMjUM0p8YDrUfp871MIr++ue4J/2off1Hi/Bns9/V2eLZRC2Va5lTc4OeZmjwNldteeB+23ylqPn86TrHerPPN48PqkGFXmeG8CuPSro+JeFCoFKR9y/XLOygd15Eprv++BlWSBs+d8I4b1aMgAOu66Hi7vuPm+eu/mftd4VKhqrSZc97nm1qZzrBEQfZRHvpakuKio5fdQCvRVQWTjYx22RjxySnedPBTDZiyFodGh+rPXtXQab3ouSGXzi+YTXub+ha98P3HlYaIDWJwqig3BWWXMgbEYA+fcEzgTphyr/MrIlPPCB60MuHDrfntM8Cd/8icvoXkT2fq9/srwFq9RQr0X17h/lSK6NAfQ6zBoowTKsgvfxadUC32gub/r9YA4GqkYu+tf83p83woditarkZN57HifvBJGwngJ27UqtWuN/tyn9F0PrYZyx71RC17bvozReChnvNg+G7bru9Vgm1cS9js8UmQAbuJUXfWS3APFDgZlJHqKKyy7hsS8mofZiElfTog9GTjY4nZxt0KJzIGYeO81BPcZfB9vU3SFocAe12cfpYof7+/TMdcf+QKhgG6a9KYf+qzw+60qxkYuXX9RU2W7MvLDOJuMAmWOjs3fXBOFqSIy5j4itfJ6fR3dKe5umFsEQvXRrQ04HLRVmBHycX3cunJmukfio5WkVvn4nJLpKX6UE2GiFI5wPSG0zLUh2Sq2Wkf3aWK6iV6Mcwxyx/lKymFcvy/TNJTrOIop82o2AnjyRutptU/97cK2r1VkbR3vKrvmVXrvwhINJ5/GXSVf+lsDv3PP9dA331CjUgFuBPjaXDu27ftpzE906nc1Sk3APUVGjeZK46fIZCONzh1M03O2KOtGmsbT/RfkCj8bK6XV3EWVECdDv43GywsSxcbcfAyD4IlqW8xAsfZU4sJQfTVXRs7cDz3AK+YtoqhxgQIwtuZ0rVEyGtSh8GoU3tLOa51jn9EBytmobGWuNOdALuR6rRVLhbEYxOpNjnWfylZHyDXlq21PkfKbnZLakxBNDmM2+dOQRRXATeo2/9iSX4ttYvUA10tl/Sq03YjWM1JUh9icVMVDITQKca99rwKtJ74MUKXptRFH5/P0W/er0vlpSlu/hJ2A1AOrIHYOaFFaLwS1HvgmxSsQT8q//NPxNknYObmnz9rPGo81GE+tkJjfEMDCVAub1DiDiK5VadVAUTb1dPVBqe+9untXxEx28I++GBXK8K4HWYhAioeTMTxGaePFJmTBI+dh+o0Nb9fPH/7hH35Q/PXEzbklr5uHc10f11perCMHAsFL4BqNnLbQ45w9eqQIwuL8IoQe7Q8GbHn7997Dz8bRikRzdKyJFzkDnxXTL2xXCL15hj43ZZ3SVk91N3uNCVSiDicnvOvw5kbhzke/sPaIBhu83ZyYR3meUrV7P8a1uceDNDB7lRMmaQILJtm8gZcSQYSCOfZAO0YIwXpSJAaj2J4OMLtxELS7X4/XbvK6eZBWFlEGFrqwTCuejGEjFp816Wj8rdRq1NPo4ynSaGTW76xHvdd+38qs4r28po1Y2v9GUTUwew/zXvx0DUPn/Vp7UtxoUghxjRjF1Dk0sbe0a9/WoBBhYSi/ozxOLsBJKovsqbHL1ln+FJ98Hs/1rqNg7m84eyNqSqhRYhPET94rOQOb3PtFDAfDnmNnI1a9aXLXF57CN3KIkuwt3YXVN8pXCdQNbxQ9nilS0OqoOgCe/HZjvnlQnjeOK3ft2n8t+bYq6BrgVnIxUMZj/PKYorjyNN0ieYzuDNO9DjK6FyNMNip/9EHzEOXROisfBT66ziXPYJ9CGha2yusIwhjUCzaxCnjD0Xs1VMJsrvXb61fpm1BXW6Vt0assjGlzF+3jWpXh/qZQV41a20I19UQtdhXUYotak5+d44bnheHaOp8d3yrxa43IGun4bvuuYt259/ong1WF+fSbjv+1qOBp/K+1GoOnqKa0asTWVz9HHy/rAZ6o4sJP9z28/f6ndDgfkpKMin79zxOkJFvj32MueLx4jXdZuLc5wq3WaRUfr5vycy1D2+R8YZbyTaPNy6NQisrAyW3hZxsC6Qzjruz2PvooNNP7czTvc7ud//Z98YzrKt910LphrzqmMCDj1s8bSZe3ynNK5xc26gGHjazK59ZnI/YneXsTo4AJnc0iLPIUqB6RzcoLOYXUwts+YMZi1csqw2rF0pS0yk9QVoTCQtWL5xVhlOYXMFYVaheNcLhPPet+3tC5nsMy8UIlaFAvYKGRGtIqI3NyfeGr3reRxCrOvfa19a+Q7/U1ZMWVhbyvGZP2/3nf7bhfa1XSa4h2zK8ZkO3jtfwLReGzRpGrMNCtkda9Tk4odElHTg5nqoqiD67CD/inHuTJhnUxNrKBhxkrMIpxilgoNtEVGWIURC4tb0Uvhq2yhM6OFwGrkKfuUWDo/C8yqrFao16n0m/wZeWy0C89gj6/mLzM6g8G2kY0cBTj3vPZ7qXKkW5qX+SJ7K5TXN1Dn5aWIh2RX6Pa3ueLOEg/s1FQSneLdRlxh8Xt4U1lLIQXkt3nsE6vZsWFqvUSjnBnRMoESstqdNbDbrlWsdm7rmWnVajNaRjrU4K9XofvnyKaejHb1ps31yr3evTN0RiDVzFJ1zUXUhihY9NWuHrfeiXLYGtYnozeJv9+lvaaon9q6419XntKAPJyXzOaPO3CROux1UMr3t69CFXQeLxrpqLP5s6DWbyq0MuLnsfQyLH8YX4OsbwGT7930E4Trb7r0RD3ziEDbVDAla1VgF3P67OO5JaJUrLrTRcOuWuOPgt5ediNZ8NzMutlF3q5d9f/IDqg970+0ZsxPMfYeVceFlR9ho7NQRpPH9vZB5LRdSKZHuXTkmU7xpsYJ6ct020O9qMkmnksqhH6rGTMYsEwJGKIDJwe+qRshKllJEm1EpcHgkD1IJ5wX0aiBqOL3zrnKtwmZkvYKgFzrodeelTRds76wCRV6sUyO4e2GhT/++zJE/5PFn9qoxdCMjbv+n1N2e5vnryfn7Wtov9pDP5FDMdWp7Tx4PBwy4w3Id3xbeUNp6cJwipntKnz04iBs4Hf60FTohQ3712jpFsebo07Fo4RWcPv9bId03HX8KSbq5O8vXZz6MmtGzXXGbzrbt8QaOhaH0y1uqAwLRrIB5IpayLq8P/TeUeV5+v7b947gS0pLfLQ9YZ2tOqKMWtOpUp7E78t0mgRAFSgkVcdk41A+x3IyTV496MYhZcfvK8w4iHYUCL83EoaxJcIbsKIcpTUY9UK6/Qk0z5Oz2+rtOuZWbiFYJqYWuy6wlxPi7FwTZWcV4Wb4q+RaR/muqFix1sF+PSbGo2OfRVnX9tWoe1vq1jXA27ba2sUNlL6eQ3DT/v+pxmt12h8bSOhwj8V1PVaO78qP7QoptyxLn1Boh1jhb4GurSVjAb/6K/e8/KKa8xJFH2tic86bd1Je965fpvQFT3xcut0bVRGeV1fPaeJEgUxub5VSt2/0KO7RU9kXI6z0bN1W2jq2g+CRsidVA+gP51msyvj2Kqzpb+8a/XeOoZ+S+fVeXbd5hufdBAobMfx5kaBYmcQeAo2wng2aRkPIc4QXGgrz8Aq7nb0JuPgaMVpGR3XClU1B21hgDJ/mXLDwxqZZfAyeS1vo5Iqggp8PZcagSqXl4UYBq0CqjATfEyvX8LQuT8pyK5No5PNkTx55U9GgvfVyKtto4Yyc43kF2mvMfXTuHr9k0AYVz17Sqmw0PZrLXmqPShvDWsNwsKA7a9RdSNWVUX1rE+Obs/NNTtsGzXUY+Qt4udCQGSCbFLuh5N7rOi184Y5cuTMo2ULX6zX6/PKWatiyNn16VkD1zqXOnH+N5cmvW+8hZ44nI2wyIb1o39UfUFA/u69EZHgtwG2EV+jcFWXp6duHHeu1R1qSH4d0w9qRzNzLQ/0lGiRlhwFSKh5VkavBxRec5SKPkWQpdGbGQXPfGUh76aOjzDAbcX9MYMXhpXogR/uURj1EDDHE7b/5DFXIVQhNcfRfss8tcodbxmfscGEVaj3qmC6h7E03K3yxASUrfttqZmwuRFJIxuvp9zBRju723HHqe04zbuK7d7XsKxn/LO2J0PX9e3YXxtzjVP55taS171t8wHemyRsjohCYzwWquzaWwvGgvLpyZvFjrsueIei4bWCVdCjvNp9Kbt3ohHLfXdePOi2CtXn5LNj4qh1bloNZg2je1PiDO5GaN1IxoAUZjKW7k2wzvSUl2sYGNHWZ5H3JoILw7XwxPg9h/oUuzlygPWvTwYI3l+eMFZr0DwCCIoertyZZ51JvLPr8GZGgWLvRpy7WS1zFQ1Gbk29iffpSJhQWZjfL6b4BL/UO6lR6DX+rhfdeu32XdwcwevtN0rpWOsJdgxVqI1o2ueOs9cUjttcwSrr3rdjbb+lX9fqNYZZD3uVcg1pve5tX5Qhv2iI235XyX/etXUUnujVa7rm5bfmAgjcjvtpHL3nrn9bIwwwShPD9got/4ow19FwD/1SihvBUKogjvtbBZLPXCPibxWQ++xeAuvSKOaJ98rnG3H2c0p0cwSiVXwoQW7u67DVieomtB+lKKPP6/bZ5ohqLEsnv0fLpVOTz9eay1hdprl/K72eoKSl22s8+SZGgYUzMYyLOE2qbAnVeqbeMddN2FEUJXjxPv0Q0G4Gq+dRIiNmvelabN/ro4Rt+F2Ya0vtLE6x03t3lsvd6+CzepVPhsPirSe4Rq8RS+lfpn7a6MeDK4TxxCxl3jXGbZ3Hk9A/teKoX7a9NtbXoJ5GUp2vtaJUOh8Hpu1u+3sXRRDOesRbFlwe0az9a3Opo3PXHYxwEfpBLAdPXKWL6Nymt/vM8cw1js1PqJzh1FWhNM8G4iVznUMPmlSlRIZLX86PHCOdsc7Tk6HwezIO0isMJzHeBLe5OCZbJVH3TIGI6u2jjVLTzz777EPuc/eAgGV4+JLQNS53PYTj6Hj0NLeNZJYO5tYkOj3Fce6J0nVay6NFAuo0lNZvZhRk5lnWI9JhbnYKEhKGoRM9RqoVlGxGZMnlJoDrZfi+nhxiaRQgQlu89YYKydQDbwnfKj1zLvMaT3dP7sL3UZ/GqJnTvRcqaHnpRjjoJ6x8WcRs6MHEVYSruJus/2ntyWPrPLqmTx5er63y/qJey09rayDbL3rJtzwZ/kZYVajNY10rHxXHX0Gr4WmOp2Nl6JcWnIjuDi4MKL927zaPnkG4z+6AvOLsErFa16YKgjFrpR0ljk/Mo7v+eyAbWSxEVbjFuq+Xrl/KtWPg0JH1Km25gD5T+3SQ1sSwdSiOX2fNy3h/+X1ZqCIae6CqBxgq46l+YkjquHZ9W41ZQ7aQZZPoIEEyb7yN/Gog9iTc0uLNjYIHdXR7eb0auYOWXjWManik/E2GvQq6jLxCvn+X4V4LNbUNs9xjoZgqGb9pEtD/zXV0oapgOga0Mt72tVUsjYh2Xp3f4rZV2g1DrdFe0/b0eT97jbGeQvLCcD/tPq8x608b59LytXG9do9+9/T90qFeZqOQNTCuX4O1bfnTZ9Zp+YSyFk1LQooQjAmOXk+2BR2NqhuR/rSI2XtpUfo0emq0+kTXyu/TBq6Oa+XTZ+tZ16Er7Ssjr/Fxo6qv5ql4nAFjKHbfMZRHWiVZ2VyId+nUuTbBXiPX6LbRU2VvnYFC7G9uFC6UPUvaM8MRVGWEKgV11gjVDRR23ElO28y2GHuFg0ezSlJ7ijRKqPZdL6WefnHienldDAaRUbCHopa/Sel6IfrqnFrFsp4rmpSpWrdsfMZTLLpGzJwkvAqvrYBXqVfZrifdaEnzWwcm1nC9pnh/3rZOQZVQIcO9/xoM16KpSBgNRX94+SnXZK7+37yVz3f8pS+lupFOx0zpUGSOSaaEnKffCMAzBu7zHhp5rf03wi/PX+PokW9r796gJdBG57fzLE8Ujtaf6xi4eutoaqz3ukjBmlXmVi6s9e6yd7zG3/zN37xEXdeXZ8eYaw3r08m1xi/5Trcsr1rbIgXWyxxqpOtMt0pxHVK8Ul3nXnVY3rwkFRGVRjrfu95FT1KVQJZfaPRgUWB/hUbuJaTCAN2MUmtIEXsM3kYc+vTbhueMFEjgftcNeRUs/TB4ZfwyP6xyvS9044WUZuAycwapEWJKdpUe72ybMN5Go4a9aFqjt8Jrvt3z8dNambNlj0LZhVI2ib5tvfH9/bYaua59eW1p1HmvQd5KmB5qV1gUPzoEkqJr4cTSyT3vXnhiFQUICF83MrWOKvcc0nb9UFSVV3Oj7KowCvM+OQnl+/ICRWstHcEt97B7jkA81sT9ezx2nTj08HeP1igda/zJDyNlznIQ69mbI5j3e+9Riz7gCKLRB3PJW3jOdR3K+8wGXXtAGq0bm3VsTgftyKqXXdqXW3KNPuVRrJ3Iq/rki+YTfqYnr0luXeumMhPshow+gakMtZ54matC3ahAI5Su3/NJGv42lC8jWIB6h08ebxNdLV9lpOoJr7J2r8JshI2ANzx2/Vp987tmzh1f6em7J0x1hf1JeWo1Pj8tIb0NbXptlS/68v4+r8/Oc9dnvc0a5oV91kttFLQQ4RqihufXavCaU8BDG+YXcnptnFX0lFi/44lSKIUNm5SkvBkKxlhkc3/D0quMjF8E8NoYC2kqXmgk5LvyNe+6cNZdV8i40JG9EnIGuzt4c5re7TW4lzmUNnIA+H7lsTnLHyXqakRwr3riTQbTiaXRvTwQDE/A+6/1eJ7qPnNuhFDHsvCSNeh5R+sINI/45kbBkbz3uqZ8jWfMmmEQBqEnLBrsvrSGrQu1VLGtV1flXgigAktJVDFUyfNqq5TLWPXsN6G0MMJ+Z3FamtanLdXQFTa7VuH1ec++wdhVRu7Zio31xj9PiVbpVFC6Ju2jv284/QQdVdHs/bftGKzfE0/0u65150mJ+b/fde3XgzaWXnetm/Ya6hfKqGE2rsKL3Rip4IBCp6yaoGR8tma/PEQJ1uOuA7HJUrwpuim90KzJ2j5UHhRTY9Xx+fuUvb72gVeFQh22edffdY7EL/x54waJ0Turf3pYHZpoPGvjp6B/FAgQRFeobGEa3niP5S4/9oRoRstaiurKF8bTdUQzclVYuI7B6sE60B/NKNiUIUw06EYBt4hCZ9havRuMiCD6bKhjErcgQutWC9SjMa56clUyxeQRVLVOw3hzoIAsDoHEhIxVH+v5nxA1/VdZ82I6P3Oq0C801koEY9qch9Da3IsNt/Vo5MILvZ+1WKWLVq7btjDUesbaE1T0WivjXysMtf30/43A+n8j0NKs8KRj4RvGU+B49lohuTXeSiALJ/Iq8ZjKEq1rtv1VMZdv9AM2KBxVh8RuXb/lXFSejXdhjyIB9chBxApM3P+uPWy+kJDD4hgEvAYOwSueIwEO44Ref8ZSh5KRAvFVhuTq7n59MI+HE1m/q+JiHP7m/XV+3+jR+nTe9/v7rWiFgXDa7UHs+nVybR2v6xNPgaasgZMjGinUMHWdyet93mdPWOcn5OVNDsQjPBRVPdJOoBBQseN67AijbwtWaGO9Fb+heBtmVaE3kqhS2eijkQdhW6YrdqkJL+G9Ha/3nW8NSL2NRlAWdqGOhUCuFeMufLQebcdWuIsAPSnXTUYa00/jj0ZvTwbhiZ9ea9a53v1r/T1BSU/j6VwY+x3/wqBrbO7V3cWNYCoT9Tg3AimPGlPpfm1lzBhLi5M5RyhQ8HZQ9/RRexsYli2jRhtRce9FCXYeHLuNuMkhujRpTk90vdynOT7PNGhOpcepMMwgXMq6D7IhX+ZbeOiut3b3rnjGMRI/el9BJC8CAmtkVWdJ/wcVUfogp0Y0NdB2LDeSesq7oQ1a1tlbRKO8X93CeD/lHt/kITsmXIgC83Tbtus78EIdmHqNQBW1a4qRlVi+b/Sxwub+oKQKbL2uKpIaBc31HUtDO79vFVPHrM9a9SdvdhW89mQUnoxg51fDW8H124acbZ37a30+tdL852kL96xS3/6XVu2j16+xYNSraPEqb7f8UMV+n/WIiNL6Ca7ofOo4bSTw2jy6BnVgTrk4WZWBcxxCvclrrQo6RaXf8jtZMfZG+s0r9Mwn0Svl6Zruz7n+ev/m6IrTm4M+GqndNQyd4hZyWC++HjSFXWTBevd006NHDd73c2YS41IjXYeBkSq0Vzq5rs+MuO9EbuWpOheMNt3ZOZanyz+lgT72+PE3zymwPMXCWLM7CKpPQOsDM1jYhYCawOkzDxDC98UnCYNJdqNOmbj5gG4OIdAWjkCVkTBTPXFeAy/G2Ah5lYG/99nQtf6Elee2DLeKpUJpHYytIXTXqLmcejfGsHBblRC68VRafqetgf68yMC6mt96LsvoNWSv9b2GtX2tkLkvJYLnqnDMG1R4rdDGzqEODCODRzePsNFox6KVJ3behLwe6snBPbrT/G4zKdm4OcgB3m5o93ZImvH2gT4Hfdzv4P9k8OCIHuutYtCYVeIcPW8Xr9/5XgSDJw8KQke7fu/vu+7ufa87XE5lj7Hbbd08wN1XBZOG/jUKxlIoktK/+TWS+YU88xnNihToa6Nya9kzlPrbJo7lG6pHKPyiFOZgvvjWunXOeEV0osrxi0YJL/P6wle+F47iVq95u8VZm6ThPRhgjYVJqcrx/7WFj+6lvKz46Db9WaxNOtWb7+/rRTYaQgOL49qn/RMWc/vd1sjgZUGya3o9gmKKhYYKkbiGQmplCsby/WtRwzLQVloZz86tSrCtME7Xda9ZhSjvompFJKhV0T8ZDfcrDIUvXc+w8uB9b03uux4rgD4wcR53f7OwifJlwt2IkfNTY70RUhUK41/+qSNy/Z+Cu/9v3JSv8YBO7p1CsvZ4pWPQKF7OVRPb5nSvG9sliRsxw8mtnwRwN8LiY6eTysecESjvoP1WAzoxodU9+LHKcvliddcvva+u1PfR0jlPzTXcdz1Go3utVE+dbjtaFPKRQ4K24KvCW6V780Xl1XU2GqVew7OOJPloRqElWQ2ZDW7D/hK90UFLy7qA9a4a0vu+i1oPq8bD9/tdlVa9yFUkG/1seF/rXWjsyWN+WsBGCh1HldAT3PNE387Z+GoUKJ+Ob6sdFhIp3Y2rlQwrSE/rv21p89SePu/8n9andHgtpH76XT35Oix1OronYKtT0Ml+nKXDjgHNStely9O4l4/8pgpxlZ1ae/zOiPTZBPqmZKrEGwWVXgvrVA5W7prcZRRarXRNsrrVTwxTnaw6Pb0/Y6uhrfE0EmNMedmdm1dhqK8nKds9BXV6NlKsfuLJ91Gjlc37W9UYnYrOq+ybf6p8umdhoY6tiMxrztqbVR+ZbBUFAjf51NLLa05arAeFCRtW14taqATD8Cg1Rgaz1GBU6AlLvY6GuJRyPbV6iB13F66lcl20jSKatMIQfotWvE9jaT33T4NrVoGjByik4bu5LDMSan05SqHNOrcS6rVo6Emxv9aK0Rtf8eLXKr3QvNBfWwXk+lZt414VLvTjTfu7UKLnGIgACkP4jc/JQpXuFmLUwOmjUJ1IR78t+fV5MWenBPBe7/OeDQRnBsOAaKrIysfX7hr3v7FdRY35eeQlmMV40ZlhKiR74wE52ehq7JW3QsCbhO9DvRjtIg33O8+Rv7k5ArwwTWV2CwK+mgSu6/XVXMH1J3prYlwhCCe2x47ceJXF9iWaEMU1J1M9IqdSfaT4ZcddHnpzo1BrVyy2yqmCJbSuB7a/oXTWA1r4pUp+ky71wMtQiElotvYXsxWyIdw1TL5DbPcyT+V7ruuYWhVACMzT9ebXuVa51FsrxNLIZ2nv3vdiWFpiCw4w5z7DV1/XhzBe28jviyr8/vanRRRdz/tbRce1p9B6+0Qr96vBrQF0LUEtDNIKpBZJ8GarnIwdffVvh/O9PHe3m6KMze8LuTQavnfnG5VP8RlFeH8bsxzJ7YClMJVhXn7BU8Lwh37xMRyaY3H3r7Nl3j364doZC3zYnb57OGXl5MZlTh5xyfBdWTCFSuZarkmu7z53zc3Nb+76m6/cyn23UJCIYyFg7X53EJzqrRpN9KkBuNYyYw8rugaeuvnqU8VSn+JWWTSuRizuyQjeu/vXsJIDVYYfZZ9Cwy3KtF5u4ZUu+mKstWIbfm44REG3FKwMi2nrxXS87dt1W8YqWqkyWuhpsfQq8yqWKsneu/+v8oa1PvXLCFRJVin0XjsGdGv1yNP8zKv32c/2PqXxT2ubb1meerrOtTWMuw71hPBB6fCE25cXl36NULav9by0fl7nqJ7d4sV1LPym48X35b/OvfdaeFH/1yiI++2VrVIMfZQlGENS0m/Xw2zeyf3qmCy/dA0Kgxhjz1Hqs1UaTaBdPV8RyI3Zsx5Osfo9A9Ex+64wWHVZjfEPsw+Bs1Qs36tFL1XSjdrqCHd9raMoqTnWa9V1peuiJ6WZKLn6tzmiOvRvXpLKW22CyEIWMythWfUyjEmuUjE518IdPeqz+yFqnDAE7NR3ZQDwST3HRgkW3hzqxW1CkHd2n9tcY94Vigr8eqNV/Ly55gJ2014PACuNqvw6/mvC2jK1cZQ2aO++xdQr7MVkm7S1Hr23PhstrVItnRpB9lUe2Siqn2+E595bYfOkSAmO3+DvGvZ6Yk/VQFWkZKMRmuvrlTbaqqKqArhWyK/OV50dkBcl2t94vKPjL0QOxx/nWfu7dCnUuZDbXS+ReU9hKw3Mf0t2zfPeey5Ulfc19GXA2m83kZ6hu8qlb3/72x8KWCS661D1oWCtlhLhGJ98zPff876kfU876P6kNUTr6NJllTvzbH7Wmnke9K3V3RcN8AADUke8xrMGbPegiDTe3CjcjRy8pQRsGbdWrwJTxbUPfelhdRUmuNk1jF4CF8bRQCIdA8ZsXoJCa0UOI1RPuUyOoXkCPc9992ew0A0Fa5z0770M0rNP0JAhKNy1EMkTFLJwUsfodxipJ0A2CqwhQIN79SybE9BGAVW0myuokq8i3SiiXlW9MOWUwuoqG4JS76/ly42c0GXhRjQWmlew8c997viF9uWedtnXWPHK728wRhX7XQeTB+1UvtCwR9ODPqxl+9pD+yideux9/ghaFcsGvVTe7gUaMhdj2ohpobvycY0+unO27rM6W2R8y7DPoH3rW996gcluHH/0R3/08jeY5sZZiAttWr59rbuZ//qv//oDn1bv1Am67+iaPV5bVRJZBglVRm/sB2eJ0hzCedd4xvNdc2NR9VknsQcuFhK2nmtwNgp/M6NQa3o3K8bt+wp5oaBibk0MN/TeUJT3QyjL6BWUeuKE3CI9hbYWtd8t09fq16PZ69er7Zzrkfu/T6PqPCjhKqmGgha6irvXPFUbVQgLHfnthv/9rvfe0LeG8Yl+9ZrKG/iiSkOzXqXV9u06wlXa7Fr4bZ2MJz64zwsj1otvJFH+7BzqAHQuNbZLvyY7l99Lc/S61qKEJ5pU+EsLY25kWaVySuf2OZxMUziuc3Iw5VYFTu7Lc/e3z+8dUlD+rKNRA765tuqX5Rnz8YIk1DmlSLcE1lq0VN087rO/eW/oydtFHRS3str7/4yRe9qTZb70VZEAeq8PJ8I/zZc4iv/uBb5q2Sr94QTXJwd45e4JLn0zo4CRMQiPzc1r0S1c8a3idbvA9TAQtLi5SZvkCv4msBvuV2CrONaYlEnMp4K4UMIKXuevr4WqqrTrxe/xuk9KAkMyTphlnxfbyAN0sbCW9SwtapTWYPBeC+9hNPfze5FT6a5R5l0Lf6NbvRrj7tq0Mqi/6XgLZ6wRWoWLtvWIG/GKSPBeI6eFmfBD8whV8pRI+aIGtLTpPpmn5GMVGuXTyKp9tbKGd1s6nDIEIXnZwOb++sCrhWeLArQiqmXoXTvR1r3kM3ymP8q4a12+YCgbBTFGNX7lvfLaU17vb98r+Moro3MbA+1jONqoPnOstkdlOsq8dHIf8lg6midIiQECszllmv7Fc6q+zEd/0JfqEPL+5kbBphjhGKIpT2TlOsh6R/V4LU493XpiGKiLyWspRIJZQRn6qZLEuFtdQpibD9EsZpVSvQs5ju7Ibija1kQeoYTTEtBuUJHwa1RQBWuOLa1biKy/qQIhtHZEtipkq4lKA8LCqyGoGPSEBPTQkzb1o60nu/DIk0ezBqvzbSN8zW3t/c3JGKxNI7jis9av0cR6wKV9I7arMKmRLW2MYyEflSKVh0aPdXbMmYy1cgh/kE/KhvJ1DL5D5+76k10VcpSSSN15Zy1tfioh7vqaTyGOOon4nedbpUbe7cy9vx1DvScQyCPcd8rmRR/lfZDdQtY1Rr+cs6PM38a4G8vv/u7vfijvrQ6618FWF3V95zvf+XD/MyStGCyUySBYAxv1VCbd7++zW5fmKNDWg4Xu9x4bWh7pRr9C5m9qFDYxU5gGo7Wu/glCKMPU8yEYPYiMYOu/eKIFbYTwZAmrOFrl04qCJl0bmrYkr8yNWeqpEvI1lu5bSKceXr1017TszbX9jbnzVO61pb0ViO4naESDtgsDNoLY9e5YGuVVSalJd80a/12bzr08hV6Fo8yva9XvjGF5ruH8Ez/W81y4rX1sbum8OEJHKbtHYac+F6Cta9zIglB33TeS9b972/vCsDVKppDu2lMmPTG1yhz9GwGSMeuvnxoj8HD5iELVT/nVGhYKWahqYT1PmFvkwTzv84N16hSJiHov46qeQsevvcft93PzK13K73fK6vV5yvmUtIIYTjI61cHB89WFjfjq0D7xSHMGzd8aVx1gvPhREs3ridQrpvwKCezfVWoVNAzZ0JiitzhNnpYg7rm4tFaCL+Tjs1V0T9jgwhK7uBgILYS+T4Ld8N4iNiLCDKVdmaQ0Ms6FUxrG15haQ/dv8h8tajS04uJVppSQz3nWNUDlg418SsPSyb0wuN9XYHYuflfl2t88ffdkFMqjnxe1dHNj510+42DsOPtuHm39f43Zzq35hKdryKrIuoq/87KWlGn3IxUKKmS1ea6OtceR1ymrcZX0xa/WY+dTiLVKz1jRwRoYq+/MpZU5dULu+1/MBrN7SXxzSp1sWsdNFOHMpnspl7XJ764DPT0l1dGi9CMrjbCql9Cr0U77UFTQtf1oiWZeD7jAoEERVbhV+N2FpySsOOh6hi0h3PLQepKYjUfW7xZTrheFQXh415pQs7O4C1ZmKL5f7J5xbAWP8dcLpEid3e8+FyY3ijDvwnE1AkJJfYpiCpO4bg8m1Lcw09qABwi1MLdHC6jkuZcNZq3swC8V8M7jKW9xbY3y9Qkz3gMIt/TuKTptyO3lmhpU829EsrmbYrWEknGwOxgs5MyZQqfaRi3Gip/q5W8EbY3rJfMIm7fy7HBzlQMEtyyOr3QXpo4vyapr7mXXrZ3T9eh5/Stb5enyZuWxG63wZfN0G51UxvEXI1yDhKYtL725MUbVGZ9N9IiGf/EXf/EhIX+Rwb3wiOIb5bAg4RsjPljouoeGdgNgI8sb31UpiW5aIqsCzFo1Gq+M1KC8uVHAWHYq3436oO4KU63devdlEt812VxFXKijXuoyWlvxWUqri1uv1SJhhIUKqqBq7Xdrf5VsIYN6IxjbwlcxUDbrSRVC6OdNtqODuddL6nw2BK4xvv8pAwq9kVjH0z7qrdaTrFfXUNfcq/BLlxqIRgo1KI2klg7bRzH3zoMi5Q2WThRa70nIChtSgt5brdPqkiq+zrPGq/zX8TeqWtr43UbV1mAhA57w8a5S0+LNlRfrY10bMdc5uf45BIzXfdajK0rvrr1X4Vh9o6Pk/31XGHQjA9+RuRpuxsk1Ny47u+UsFjLVqlDN8/72bPrCa/c6Q3F5BFVMNy9G1NPj8NEiBUULnmDRa3X6NtIo7zDkdWI+SqIZk5d5Wp/80mHwsIVaCi3pr6FsPZ8S5sn7q2dQYao30ZdWGOgJGthWuKD/ryF5DdZp8rbf1zMx1yfjuVUwT8pj51aaFVNk5FzT+VbRWyfzLDxQI184rPfmia0nvGNfWixcss5BaeCaJ++n3y8spZ86BjXGXeONygq31WBWsXbONaiNSF5T/v1+17y0Lr0rA3XOirN3bdGhtKp32eZzaMAaWGvYaI+h9vl68aV55ai07xo/GcXl2Y6nztDqg45R5Mso1LH7WhyC0qeIRWErjtQe+XHtDI+E8V3neA2/f6LDU/RT2es6PkWg+lt98aTf3sQo8IyFj81ul5kwqbZnA/n7KUrYhdiJY0KTLxNUCQhBCxNhkN2xW5irVUq8P2OtR92Ss1UcFTTj7xkrFXLM7J5gqyohNN5oCiPs308RijEbZ5PTba2y4gG3zzKudewYvdYwVoEzAvXc11OrAVpIrrzwhJXWkLVkV+VKjeQqauPs85IbHSjV3Ki1irXzdl2x+fJwCxG2vLhyUiOD/q4F5/Y+lR/fHzTp+QsihrvuePoUl0Rtj7XmGDjS+t5bmts8w0ZCjUqrI/BMj9yoAaAXwCv1/Asb3Uulzn1v1zYou8/I6BHsqp2qjNH5l99vzBX51PnFG5WJrmcNp81zoJ+Dn2yys6GtDjN9WsegEGZh4eqbOuRrVJrn/ShGAeFsqBDuIXav80Iwi2vwVRr9DKP5rFUbLacs4zTfgIgI1kqghpsOeqv1rydRJWYRWoLXBNa95Evu1SoDwnmvhpv1Rio8FeoKT8fefqusCNYyVo/HqJGtsnOfaxtdoQNaNRxtf6Vxw3j9b0Snz8J9EnrdHft0tEqdhifHwfq4B5qtYXktunQfBgltQRT+747gRhudc6OqjXDLq1rvVXrJpzx5wu5bB6g7bR1lAco4BdUSVL+7e3afwn13iu3KJO0OvmtPsVGuHmMpf6LUuU7NjbEHMJLJwoxV2NateRGH28HS8TUvHT9TuPId6NjoCS83X0RX/dVf/dVP6JN1MtGbg8UxpYsKKzYi8cjPM8x3PEd5o+/Kf6/d3K6iyaF5jVI75jophQCt50KJb3pKar0bC1lIZhXrQg0b0mz4/6Q8EKieS72K7fu1ULn9+3u/R7wVWnMuYRtKNmfxWpjPY3qCtbSl0ZMy25AYRPTUj/G7vgqlnkax39dCZ0zWtauBWaPecHdp7XftY+ET42/01++f/ve7zR3080J/NbLrMWqcC3/3+4650N8T/FVeqsw80aX3cv2umfn1vo2uek3nvElY/CPJW+++ESCPfIsVwCPQg+bFSnNKtFEMJdr12MqeGgUGq3xXyMZvekYSviWj7tVnWJPlr87zpRe3r96prmvBQ7+vw2knNMXd6KPQXysBrYX3Roury5Zvu+4d95sahbU8nfhrydy1ZAa5Xn690CoSvyv0ozUkXSNBmIqh80qN2Vg7rtbA+43/W0lhvha3Auj8Ggyuz2Lt6602jKw3XOO4m9kItDlWaZdOuwehSr6bk1Y5YvKu7463oTm+gEFXQVWA+l7jUuXYMHwhBXPbaKk80QRllWiNa42FPgsFWG8HrcGMHdm8Bq9C27H3Wp5t1++JX9HGda3xX76ogXKv7rHp2uNVY7x5tSChPLBQlf486N68z4vtWlgPBqSeNZrbv3CfF9YBu6D3RSj683uePTj13nuIHR65Mfr9fX4ed3eT3zq25JRX/5X31UOiDbS9/pZv/d3d18bR0l509UCjG7eIqobx3j1VspVS+InB7IuRr/ww5NWRH+VAvFae1CjA7uzWRNx6B8JuioWyZPWroBq+IyZs/1oJtglCfRtbP3d/Z5vUiHQXZI1WQ81CU12IVp5YpP7eGGuE0Ags4BpjqEff7zHtfb7JMXOqYPOUKOduams4WkN5giCELczW9bjx94z9Gnlz/GkwTaOxjr2R6EJB+MT1TeRfw3O+N9blkUZIzQMQppubx08yeOZ6/ONVxQBCbLk2uijTLBSJH835qVy466KhLQOHH+DO5lx+PUjEbt97nYJ0QmqPbrgxqUpSVms9jbs726/vg0MYyuLxjTQbgSnXZGgcfX2vw9zvQLgby42t/TEGNt61yrH8UD5r9OMwT/qkdOvafPZwWu31e5CP3d5nbDzqtHyF3k463UM9yw/3DOrqzpsz3eao8/tN73NjoNzJlHk1Oqzx6AnBH6UklUAVnqkiaO2+KoQnj4/SIcA80QpvQ6QqgqdrjKVezUYo+5v2UyO3MJjPW2J6/xO6WvIqSZFEW6EbDFwPeL3BeuObzK8XvhAM5lh4YmEG9yhNeIT9G0OvYu9862WXlguPdLwLSVrfrk8NVxVM165RZe/TtXf9htz9Do02x9XoqFFdv+u+hT2Hf2GH8pgxrkJavul8W7CwEAOZRNOlK97TpycCngKzG/f6UNa4R4CU/xcaKh2tVZ0Uc63X3yj7+r9yT140CKj8bw16v6cohwLniTOY7l+jtTL21Yn48Kp9GnUCn9apkSoHgTGsY+1+lR+8VN1GtxqH9V15NIZGP65p4c+bJprdtBjWJp1dQ/Gv1TWp4qSIUuvPW2k4bLEQCpHWUBlXKzswS4WjglZvvv2ZD6tf5thkbZVbx43RytQEU5/GttCWqKqR0ioDimoVfnMFlFbpXcPT77vezeksvarAhMyuMY4ak3rA6P2kvDufKl99V4FrK8Ad45PR3HnWeVkF2tbD4WosK+CEH/2seefX75vM7nxK21Ws17be3Zh9Rqnvb4vpO1rbGPT5m7/5m/+JAq0SpxgLh1njOjqVu65XHRvN+WlyFD2Z1IY7JfHGWc8fNCMi4kHf/VXblU/W6fr6e2Mlwt514ZXvEfvbjPN+f0ZO0nvPPirdum5FS8hIHTDR0hqF8hmebHT6Uc4+Egk4wK3PIqhlpcwwx54Tvx4qpVgCN6FCydfaNxzF/H0ojXDz3jF+E1k8+QqV/iilwgMWi/Cbuz7vN86Wr8JZQ+d6irlhXbHF9caFmjWO9z36mg8owu+03quGfb30axKGNWo1HNcwmXE0F9IKsa51YQdraf1Lh40GN+JrJFDPaD3s5rqMFTxyvwHBlabXBwFez1Kf6wjcdVt6C08vll6e0FcdgEZ+xnSf7/N8d8PkKpeNhsC5dXzcC4x447wH1tQTPSjnYJzbkCVHcGO5/x3tcDxPqd7/FJPTPY2T0uI40g1k3/wlrO2YBs+2+pDyr1N1n92Y3FM+gMzRDeVH49Hn198bHLQjpzWE3eGtdQMkg3Kf2Z9wv/mt3/qtF1jpjMSf/dmffTjg735Hb4B46Tc8eoZSJVXXvRH9FpGQK1HKR4GPdFrv7SlZa4Ab5q9391o4fc1ktFVgBEqY3s8x2H1OIOu1dnNNPT5j2geP+H3DfHOv8D0Zw8IOyv8wYPHxRk5VDFWO+q8wofHOoeNbj7jvfTWi8pvWny9kYey+X6Ph3g3/aziMe52DKtp6dduaYN1rFrpgMDZcxy9oUu+1D2HZSjP0a+WLNbXWm5MyFmu8/NFWL29pU8/6ST4a4TG+fW5wPVJjFeVLpt5vDr+23qKNQiZ1RvRXHqpjsGuBpnitR97cveDs5EI/lcXyo0i6Dh8HD395RgF9xXFaqOiHD88KcY2xcxiqV2qUOSP2f7Sgg9MpF9NnMXAEGD3OifyTOdYINPourzFKeO2jRAoWiIBtGFbBWsJW8Dbcegq/TLrC3lBvFU89nzVA/u85SlVOZdgqjmsIumF+I4gq3qckm3EQOl5GcwprENdIlmnLEB33a8qt/XSuNSK7nvXEStPStvh+o6EqsDJ5N85VOKss9bsG2O/6v+vMobxURdT5NiTHBxu+14lYyGvXlIKyRu5fhUjguzZNHjfqqVGuUaj3Wp6tU2CersODT2cvldd54iKoa/ebS3aaoz0KHKZCtAt59B4LnTWfUNlpyWudBJBP6WS9m8Opckd374XSrP/y5WuOx48HXjUXyEdh4I4BlAqeYzzRjPw7/mLpYf5FAPB75135rWNReLgO50cxCjyAerQlYEvDWu7V85LqadUTMgH9YlYL3RD8GhimXhDPgEdH2JoAFw1g7LPYhZauURSUYyGB4sjwyhoh/4O7eEFXRWDHaMsaW12EWdCXYArNS69eR5gZrI4ZExmP61R2VMk3OcoraSRQBdDQtcrxNU+acsLkjb4IXKMj/XYjXHezGi8F0cPU3B/f1pi7B6+SoIJG4K+FRwtddHNi5+Je/i62XoF/ioxBa40kNiJGkxpvXjIauh+vtEq0Brjeckute7jdfX7VQIfl81RvLGBaY+7mt3v1GR17FD66qWryPzkQ4deQUsL4v+PFi2ixG/xWkdfRoKOqP67hcbxfB7QGtp55K6JahlsjXWTjrjk46fSiaMB4Tubph8oiXnUPlYF3TWFZ/M/oFDL/aM9TUNN+bWEjVpKVW291vaJa8vVom4sQEtbTt8BKOJs7oJC62BKElGWxznq6xew6LvOwID26w6uQAGPYUrgzQDdW5YwWDjRXXLaM1ciiOLX5NEw2ruKSpVs98zJ9lVeNTOe2XonvusmHYlhFTtlasyqLVZIMaT0/fbWtF+/vHoFcxU0ga1isd5V96Y6vF8Yo1NXxWPtGIOXrRjelj76tY6GuRm7lTfcuv9dQG18dr+43Ia/6N+drjQJuDLcLmgzZu3HreEbjHJ7LM4CfGuk8RZl19KqsqiuaPyo01DUwd5+jW6Gp+19ORX/NHTYK2FYIE41qCO51OYKT62tVwGhpz4N8Qh1fjtoZgWvG6z4MK0Og7P+u25yt8Zb3GMSVmzczCg0FG1at8BTrLmNueGxxuri1rGtA6h3WA9I2/KpHtTj95127Bszf9UA3kdv+Gyo3LC6mKDopk7lPYZnSWN/9rDgzpn/y4It7Pin1GrTStHj2hqv9PcVVT3SVV4W3a+f3e20hn45nx2bOWoW4fFM8+jWPvby0jk+dnzoUr/FA+WfnZFyUYmm2MrVQ0dLuSXY6h67Ja9dXNtynWLSog4LhfFDA1oOzcn1LKD/Rtq06pfKNLmskGn1Zn9K9jk91Rav3atg3Qv0ssiP6Kc5vbCKHayIA9GnVDxqeQm9+gedPtzzxysp784l3H2hIEYCnSrbm+t7UKGDoKvMu4FOtcr0bm4HuWspRiVbxyDJ1IZ9aQN/3UKn1rBeDfkooUVwV4kIZrHoxymuSPvVCVrHeZ767+zVpVNzcvNCpkZh515Op0fE/+m+SnFduXjVs3YwoLHa9+xl7zyLCC5i3nk+VTZWzudpB+2Tcq8RrKGp8mxfY6KnKrTRqmN2o6inaLR9Yox5kKIKlGBuFiVJF09bGvapgFv7qmlmHRp0bcRtv69XvMzBE51/jaRyN3haP7/zBPPebgz4pIxvYTqbvngcz/cmf/Mm7b37zmy/HR9t8Zty8ZfQttFUItYax0LFrO7du0HOf7qYHx+CPHp9RA9h7fDZOq9Lzetq+s6nxvrvI/xLz5+zdd81fdBMj3t+KQwYGz1snuqYoQvNR+iefIpVGn/6vk/amp6Q27DL5hvllbDjXDU698TUGoUppvaZrhICH3XJO31v4KovCCC2trJC4TxWlxaiwW7zuwTAHjLj0Eer22AdzZihqBH1+7T73rIYyD1r7m1GCg2OQ+815I/pvjbrHGaKbMrgqlo2IQFWFFNCc8kKzCpw1qsL2mxqResXmev30ASLdNFgj4LA2n/epYuaNlzYpuZ4UBVtF2Tl353G9eI2y9N2tCdoyQmgAKthIu4aS4an3XAPbKMR87prjrX7XklAOiGczr4d99+nxFTxjewcoOtCnCqF76RNfHZx0xqFjcSLr04mjLRGmU7rnaXNFLY8n3y27dF+5Ijh9f9OcRY3Lj2ZDZaPQ8gslffO++d6zmf/0T//03b/+1//6w2M45XnQ11rZLOg75bLmsvesnsRT987R3MM2y4urS958R3OtaYm/4deT8u2kF5d9uk/fq4CfQudrDa0aZfQ6xG1YuiF6veAnb/IppN/QfL+T/GoSz/cWEqM5+qMCXRoREuOp51yj1iipHjxaomcjQHTUz9Kha73r0FalW6PfKLNrZ0yv0b9CUZ6qAS9uvnxZ6GZhzI6xXn2V5Uaj+3uKCt0btS5cUT5+Ev7SsJF2+1z4pJFU6SoiNP7ymu+rbLbPRg1klwJyXSttnBckQiuk+MQnWtfnyfh2Lbo+qycaJZpbIZbqhRrlbtD7wXvjs85Bx9p3zpd9FY4LqfzW0Lh/IWNRfp3avV/nW56t3HhtZHitDuybRgoIWAHvoFyDIQgKr7SVCSXWMsAyUO/l+hKN91kBEH4K26u8d6EqWJ0LRbMCXOjH2LqAmLFjM48Xwmc8XVBQxbXrv0nSjr3G71oF+piyTNTrjEukg6Hvni19ezJs9XYo5FaKGHMNyv22ddjLsGvQq+TXMBi7tUIn6yMyw19rZNC3PKXfCuxGo6AOfbRkGY3LD1UWFIAEo2tL04XbzK1PLyvNKGLKoxDQk2NzTYVNo591NHzeBHGdPUpfVFQ4rGNXHMKTVmZaCPLJAzfvzrdYuF3ift8Ivw5Bo6p66esUNleg6uxHKTd9zShsM76b50Fm3/jGNz48avOS80VWavy69u7RKrmFF7ve5LV8VzgNrSEWTw7ImxgFxHKTEtkmjYapNzC79u47huIIVwgJUarAEQYhCglVOTSpZGxVgoS7SqnlXPeZpK/+njxD39eYaU/eJwx1vdd6q8WMLaKcAyFv1YTQvMxULw3tquC3LLdHA1y1SNcWwxV7vTG2mqIVLlXcXZuGsaIiSmwTfCAxSl1/IBa/L9xmE2CjKWOvIqZ8ry80cAKlsRQS7BoULjK+a8Wtr7/uZC3vwOK77q0qWcPY+Qn169kVBuzc6hXf70FoFCdFqxR68fOtVOHli1jbf73z8ofTR/vMFNdTTMpYjR/k6VoeOhk1npbpNsHt9+jYvqv8DufvbuHmWOQEemTFV99vcuuaf5HG2b17nCG8190DrHROwR1KeLCStQap3/2Pj45G4C57G/A3mptb5dKmPPmNPrcCrFZH5s0TzQsL1NtYj67KkLKCBRa/rTJt4nphgGv1IKp8nmCDevD15DFWQ+p6bua68ECZ7YsQ+TXatF55DUxzAo24eFodV0N+ny28QUH4zr3QjTfS47+rbFbxPPX/BBVRtvWC0bqKsaFt+6kBrQFofoi3iM769vtGZ/Vo67HuPVfJ1hhohUabPLQ+T3KxUF/zZcbR39ZDLz/f9/XkecCVUetQZ6bGdaGy9YrXySk9i3c7W8gGs3rglc9GUBu9tl8KjPNxv9t8G5jFgXMrXyu7INvrpwfZMVavRSxfttVb70540bTorkeGr0yZZ3VC+atFL8Zf/pRQvtyNuSvk+WiJZgte5YJJN3Iw+Cq3HuzWkLNQCiZoiFUiGgemsRCNWK6V4RpSFgLwHQu9OHshpI0aGpJWcH5ao8Tcrx7Aa4q+kAqP8T73IHCLbmyl1yoZglt4gFGocqqyaQjbcLcKZQW+ih9d3Lc8UoGvguZp4pseB8Ib3jK73q+KuYoK7dH1yQHwXddlI71WEVmzPpFtDVRp7vq+XoQxcNi10qoGq2PWGqUZc+m6EfjKlDFTNHWCXNtck/GCKvXJ6Su8JDIvHavgPN63mz27j8WcfMYYmVtp8OSkiJzxE9lvddPP0z5LRVejq2ut/Lt7XrTQ6LY0wXM1CnQaw1nd4HgSBofh97hY6MFHjRTqOXUxSth67R1IoQNCwKo9eS6YsFh1n+faJzyV4fTTfAZjg+koFoyrKqJ4e71JEMcKLcMkydQdhF69593jFlJfNXgEpV6w+9ar7pxaMQEmc3hWvdeNtgjV/S/sBYnsml4fPUVzBXphu5sL43//G0tpolUhVqlZa8oFjn338QwHv69RdjAbGtXotmyPckTfjqGwXJVgPef+3eeG9ATMwkWqj/yOsrzv1K03Au66PEVO9xl+66kBYJpVpgxR4V9JzZaJ3nfF09G8TgJ+54QU/r12Su/GdhDGPbS+PFd8/+btkLfOv/x231fmr8+raKrhaqtuYbhBLPd5YdGP0b7+XiG7n7keTHvw3dHjDsI7uO3gJBVKdJj5ly74ZosY7v97HoM5Mzbmf+O4+Z+8GEuPDHnT6qMySXFAgsFrt8gIU2bDUISzTLHekEYQ6h1UGdSTarKPwSlB67H1eaju6X/XPHkhrkMLC/IEd9Uz7DEJPEGeXUtOVxGt194oqFEagav3UaNTr/MJOmk/6Pd0vxpIfTV6K27fNfQbY1topBCJV9em89Dcp1CS+1zr+tabLpRUejTqwQPlqWutaGnSv/QuvRpplA5d20YzNVBo5zpORulUY2Y+nkXQPhvddb6UfdfEOlfBnhFUbtsqpNJFPujwdI7WKUHzKBJQHYBXes/l31OWjFGjIMYDpFeHwD39vUahuuOzOSyyNN3+tvlMYQK+MBd7N27sl+sAIV9r2XILEq5xXjlcjQjq4C5iUl23svSm1UerpIpZ72aSCnwTwzUMVbztz8I0FG4iqkqp3nAX/qkvC3StkFGV8BqdhYfq9RlXK3Bc+xqcco0nVno+KYu+MMzSaqGnehiY6QnSKU2ejIN1XBijyToCU9q6XxP2Xeuu1YbK9ZhL6xrrHr/gd63vf1qnrmXna5wLp6xxfzKgrcYx5qWl9anS2XXGb35fB8R15l5+8puWU7ZqRfK1srI8pd9CsfrwfbHyVqrZO1SjVB5s9N39PuXNKjK8Uuhp84Xo3Xubp/Hho5Xr1wzCyrbW6KVGuE7j8ha9U0ehdOzxODXu4O0nh8170ZLSjpGoo9vnLXh9FKPQzhEHjIMhhSgrVE+LRaFfq9X3u8ITJVjvd59tZFDvr9gwiKORCWXbzW1dzFY81Kh1Uf3WPBqJlNH7YB40MkZj10cVtu/3OQ31iFquV6+pnlOrkQqJMdIM23rTNXYV2IbIxeurVPze52X2borrU6k0dd/ta5/HYPzC71WYsNUKe43F08NS8Hij4RoH1xyNHPRYuVgIqlUvK5iw7fvNeeGgPLTYyBW2rp9VxjXOzd1tlFLj6XvyXbhiZR8cdmNWnACOwuP+t7lNhU+jx3UUyN4peBAMGla2rBO48+55z3zoc+Ph+OuQPDV6Zh09zVqA6+rUyk+0WKIVl9eXk2erD65dPzb71SEpFNy1updNhBvlNk9Zvac10f1REs1VzCZeRUFgFxLw+1qs9WKuv9216+8q2zUW9Rpd757FS5uk7V6JF0LkPPYqg3osO1b9Snq5X0Nfi1IPvhg2etWT731cu16veZfJnqKSGtBry8j6rmezhq1z7bg2WcjDcW2NfMdfDxLNKO7Cg80ptZhhjyvwAlv5Hf5c6Ke/reLYM2u66760r5FoBUv5TjhfJ6X8WYPvNy1v5Y1byy2sqBdZL1a9ve96v8riOh1dm+bq+kCiJ8XPeJAdDsndR1munec9DqYyWaiy63zfOxzyrrdrunkcyvlJoT9BPNsaLa3x+PF7nnKo5ebq5D5uDAcL6asbU8kgPUA/XJ99mBB+r54gf9bo5t0zqBxp0urB6pRr1XtfhB4vsvaFrgqR6qkTqIbNa/2fvLAVIN/3/72ne1WQvdfzeMKFP28+T1FQDc1TGLfzqTdWge/Z8I0OtIW6rplTo6Mq1b4KVXQ35J6f37FSLhWAVdoVlCoSfdTY73ouRPF5PFQGriFpXoqhaatzsCWpXXv3L36+PNn5ok09Z0ps6aJfteY8sY3m0PCJn3eNnhyoylENZteqnu5COaVtP6vRrpGpLFH0HDVKWMRLQTdKaoTpfpRoDUAdK3xJCXdujVguaXrK1LHdjdqX11deX2ufF0V8NqccUNbG3cinlUyiz15X4wAGUuxRuMmrTl/lvQUwYDlReHmg82dol1ZvtnltN9L0ADYL/2QYqvRAGhVmrUxThaF6RBi1Hm1hGd4pQrOW/az4rXHU+3P/Vg8heKEFXm7/b+RQC319riIvRNPkXRm+IeaG9RX8MkWVGLqtp8CTvf5VcFVhNoqqcSPkd03p3kiikFWNuDVGi3rKxuRh62iq1UiU+XsNmq7h8Xn7pIAoRrTiwfV7PHNKqdBcPfOTj6ssATWIoA5OKKTj2sKY6wSInPALxY2mIr5dK9Ft12Jp3eizmLx1YyBtEtQXGOhocAr6XldRwyCaD+y8D5S6V73iGkBe8OYEyD3aMEKF/Mob28rPP0/77P06XOK89JZXuYjoqn9ESnddj8veaB8f0WPNTVmrRhmv5QJaynvXXrSCPj2bjcEozP3m8FFPONwHeHejRb0zWP01MBFGLA7dg5x6zyoiwtgwXz+NWiiwGimLWa+m1QXG4Lt7L/xDKT0ll3mOxxQU0zEFJbGefj33JmUZIcqs4WA9lAoWZcCTqzLuTuHXvFY0rKEniAs79L3KrJUv6FfF5X5rjEUH6Lm7mTcKdf/27frSyndCa2MqVMaBuGadCHHhOe36P2XYhGvLnVviax1bQ678mYzoc704/OO78k8NEWip0dU6EBs19wC6jXx6gKRqOXyFnsbjN4xdlbXxoX3LcnnKXc9CZ1WIxcHvHmeEytNtRTHqxLyFYdjG0WRU92QGr+qIIgh7CF6fv8xI9znT18BOlSNzk3+T76kjWT3z0Q7Eewp799WwlQDv4zB5T64vTISIy+iIWiZ9GlO91YbxxrLGp+WkFrfKm5fWiKcQk7l4bOFruDajVC+mNNi5VCEvDr+efZVsFWQ9FAbYfHfNajhe875eezVasnbGY8wtJ11l3/9L30IST7h4+UPrd03Ib5SKBl2v8q2x1KjVsC/f7/gZnjohC3c+wYjFpu9V5dh57hothOAa/eKJyll5bfnKOHpM9Nb7b6Tde1S5W+PyBv5YGV2Za1GD2v+FyvBXee6LKsKn9uOH56WvXij/PcFK3R9jjq5rrrK0YfDoyfIe+jKspVfL4l2n7+Y439QoFLcqruu7xSMbtl5rthxRVY08KbcK8L3s4APvtGKFUiZ0LYur18Rbq+Ju9cCTJ218vChz5kXBByXUeAcqsXx3n4kcnGHE09tQrx5UYaQqqGLBVW4E+T67+9TIgjR6QBolVsEszllME53qTXvflzHXqxNl8nirPApL2tRVw1uIA3+IQHften2dDmNa+KlYrb67ua3JcX01eiQXftNjwClTY23yGg8VgsFbKpvuN60uExWaXw2GKOB4rpsmje/erT0vt+eDoYGxwfFBNwyEBPRGiPgSxFpnoQ5ixyTSKQxJ8Z33a0Pmd7/73Zf6/oNqvvWtb72MDezZwpFCw9bjZ40W/jbH0dAxHNO28pjcEjnrMy5qWKpL6zTQife/47VLZ7yLry4Zf3rFGVRHM1DWra/1+qI0+JmfvFbCV3G3ssb/lJE+EBsmh8D3XQ9mK/E02HuPiei2+vXaVCYQSKGs0Li7M33uITdVKPe/EjKKt5jpXWdOjGXpUYV14zyISe5B2Ech1YtHywoxZVbFA7rowYPmhJ4Y7BomoVDrEa+3UUNd7730pkgYsJ4yWoE1j1bXdHwbuVxT9dH10rf5bLFDPbZ6zYvdb/Th+1ZDMRAE8D4vNESBtSy3e2fco3LUqh10LWxIWTZyKxTR9TFfsnLXUQyFMY2xu4QpVH1S9oyS/m5sfbQsA2EdjGX3GJCJW9uOx/XWroZRn/cbO3XxLEV483FGWCHAetxe1u5nab+c52JUH6D3OrGVRXStrnQ4X5/9YW6F0a0liKmv6jO64QwkNMbmVXkha/XRSlLridfaUwYNnevJur6hGINCCRfuKOE3RLxWWKQeUxUF5lih0fY6HswmAM2rnkwhgQ2Vmz9xXReljMuAVLFStuZZvLk4aUPl9fopl0JCpekTrv8ELZTGha86zlXipdt6cU9Qg//7ffMF6xzoq2Mp3xRGcI/yXhPxNYzm1PUrfeoUlY/rAXeNG6H1/6VVWz+vMXjaed01LF3N3/dVkLDw5s3qvTbX1/0ddex6sNzmLHatGsGWV1oR07Xwm/IBuotqGA8IQRX+9tm1Kr99kfbZVCQuf+960otnkB1V4SgLtGnuqU1kX5l1X2tfHsYXyzf9XUusv8y8fyajcANYGMDNy7x9IthaxjJfPd4dfBeZN00w2hBoFa+2Sewar+KPPFYL05MIq8yLq3bB9r4S8OCjCkANYRnOtbyqKuUa4Ros6+PvJre0Cm1hF3PfaEDrtXtgoTHWGLuHexZecH1pea15FiH0k3Ko8VcwYJ4VzB4/TqGhaYUFz1TBFBZZI1marQLqnMu/hVBrJJ+8/a6VMVMi6CMC3jUrhNEonaIwP95+FV2T+ujbs5c4IXd99yOYXx2bylw/35zTygGebvQIQru/RTH6rjNX470G5/Paa8a57bXqH62GWMXRQTlnEO7va+bYyrSOzxzuM8f5UO6MYOVQlFrHEn1BlmsQvshcX8by7ku0wjX1vuBurX7xDiIqQ18rxGGTC+Ks17Cemaw/RkP0WtpriLleMqVTY9Nt+a0eqFItFmvB7vo+46Dnx8CCnyAvcyPg92oCmLB1YYWkPLgqilXk5lYIovenBJsn8Lm1swaUw708d7eGgDBUSBngKupNFnIm7pobW3ePXyu0Rcl1Dk3GghtqVDZK7FiWvj2BkyEv3Eg53/997nbzDY0yKbR6yS1J7fMSGkWX/+tg1YnRR5U9pVSHoTx/61Y5YTT93prddTXwZLmYNxiNbNTrvXGcMsSPhXGt4ckLJXf93j1bEiwCZHzISukLLmmZKn42b2u1DmQb3mNkfmEewvRFPWzOcQtgyH9h6co2/VHZNXbOrfFUlzTiLYqC9+87siBfydi8uVFYpttwz0JrsDPwUJPKrbfHMIi7HpR71wsu7r3H/TbBtf2UWY37CQ4zFvNrEviaA6dqtCiQwj/NLRDQxb/r2eijBqM01m/pXE+2rcai9K2Xr/EQFzoy5t5LW+NV3uh1+mmkoK/moLrWa+Q6po4FT17bMbhncxf12BUZ1HigUflTTTmjxACCGyl9a7kKkSJfXmvk2JzXRiOfF4VUZp7m0MiwrQ7cU+RZ+lXuGczNLzLMy6uNzrvWy6PyKeisdQ6FsM6QSDRvROD6ruGTfHBU+nCwH753Vl77zVOrHkRr9GUkjLE7kstP3cVcp2rhrzpYdKJ1r7NUp6kw4ZsbhUItVbQNEVkmC+1wJoZgB+g3GzpXSfR/CrYEwZSIX0XtM+PsmF3X0PuJcBawoXoXsYyBaTsXCmBhl86rynKPWiY4ZY5VZG2rOI1jw/Re/4SXr2Kv8nGtz+vhNlLq+q1SrvIrvXyOVnUSOu/ew7VP0c9rsNvOzXWdU/sVEYN/uvb4sHPYWnFjqlGoLNRxQYM1uK+t9xrjOl7WRKMweeKV6dKqsGh3M2/Ne+W079eqmMvvO2Y8X8ekvF4YRMSqirAOY+Xpp1UeFYppVPXjcYR2Tkv7/o3W1o0z4PNGzJLCks8tmClstA6NPGwj+MoJoyLyMYbX5vBzGYWzzBbBi2WvAuAt8x4QrpUJvtvz5G286mYQsAxBIkzud2VqhFiFRJlK2FmlwWLfC3xzrZi5/y2qbelVNFq3uXc+662BkpqT2UPZuoBVNkcX+Q5VJI2MCgf0BMZl8PuMgivdu6PU90piW4FDkJTcljGrhPACA6oKopvEnqKWeku8ccaKsDeErkNQpd8EZRV9FWfpXJxcZcsqSGPDR13f7jK+OSun7Nr23oS+RsYaaq8ZTzxW2KSGrV417755CMpdNQ/nhefPuSOHt3a/+Zu/+fI8g56HdPfawgwl491TU8+90bIKJTzUtVfphUdOtnvMBboWRlkj/HkNP4P5jP/z2p5PtfcB1ckDNdmPX+kjeYfjtfLW/d3njZce936/qz6rftBuHwd615n5aPBRPbVrmKq4afFBv9skCGLxquBuGLieQ8vmhNq9v+9OELsLs1BSIw2KqkpsvTafFzuvx9sx1NNoH65x/40SCEijFPSAk6NX9zN0PSgn92rivkoQE7X/emxVrmXy9cDXO9mIcena52ZvhVgVhLnrp9dax0KFC/c1QlzFsHDbek3lD9cUR9fqCS6vdN8MwefAVPHV4y/9yIA+29wPvSjCFm/U499Ir94q3quzVGPbhLPfneI8ZXevK6fGb5RNcySlY+/bfJpoCA9T0Hj93u0cr1Ewtj6cpw8XMpcvApfUWH8ezLSt/FM+q5FkCG/Mp/jpj1ZKybnWqZaTkWzWbyNP8n59NrK4Zj3OcKCFXER3R79porkYbr2mKj6vGo5CAv7fBaA0nrL9TxCC/+vlFP/0u13ADWN9531hkyrrjgdjV0EZyxMDYZSObxnqSdm6XyGNhWS6Ga+KmXC/LHY2PJWWVXJP46nhaHheI1Fljh764P2U+Z/m37ku7+w6um7XB42r9EvHKtGlcQ3KjuFJCXSshXz69/a3hmTlYI3aa6/lw/LOa4ptf1/DUahuE7b3t2SuxK4op1FccyiVg0azT7qh9K3RK7aOxylIucrK4JPe+DLG4ae1Hwe6buRYfucAiP5O8Yuot1y5clQe3rPdumESHetMrREUxfu8m4Y/yjEXJghf3E1KJVo3lDm4qRVLPISWy2G0s5bug2gWoQmy+//CL7sGdxG1Vpist2b8vGwLXKteobFwVbatLtpm4SoYxmcMhZAaTTUBea07E4XnhY2qzOqh+X1hoUJC5qhvsEgPJOv3178zeFynigx0sONC91YMVbE0L/GUNPb5wimrYJ4EsPjxbgrjoV4z/nrjT/1X6RUS8l4oB23N1W8aMVHErWTyu+Ly5kZZtyS3GDaPH9820V3noglRDoQ1RZeTG0ndQojmyujvvJp3E22IAtaBoXBh65UxPNBrTz8oc6eEW61kXCCon7f9+D1P2zVc5+P+VnranBneApk2imwlXaOGdUbu++u7+gcfdR9YHad7MQqKAvDWR9un0PptFRz1Vst8hR0w5iaWq2zgmM0peGcUWrPLwCAwJm5SZgWtRuHpVa+rSqglglW0FohHZR7F9Dt+Bqr3q+BvWW4Zc5nGNa38WEhhveZ6hH67SqfMWvpXmaxRw3iblK+i77EQFaB6QJyA8lHp4drrb5OE/W2NafHj8k7fixFzEMy9Xl2jnPKRcdVxKExiLI3Yerhkob7yIcNQvisc5npzqBH16mGS3QNSKFXuoe2U6tHMCaGw8nr7zWmcAmt5d+dAdjlefu8e9345i02Qm9smlOslu2f1RqONpyjiy7TP3ssoIwTRqMzWMV4oy1js2rem6F/4Tc5zoxFzKi/iO2XA952HNV3f8q33udMi3vzJa/W064F10A3pnn7bhe51FVLE8ZuFCqoEe22P+l24YvtZ7097gikwXIVe2xDu6V71TNu/360i7Lye1sGctApM57f4ece4ir1zWxr0e2MudKBv32+fnW//fhrjjn/X4mlN1wsq3XduNbq7nuWLjn3zKWuwt6/uj1kaLk8sP27/T45Af7NzrIyVPs1LVJGXDyu/y6P6Wjij1zQXVB5dw6lvjtcpsjMK9j90LuVxreOrHiIH1rjRyheBkl5r+hDlnHKvoWlesAavCEFh42s1CtfQlPFkQKtfCg27X2mOpuWJHr3zUYwCT+OawbipaKFCRjAsVhWK703MGSmIbJMQIhX3hruJPFqFsUcgs8plsiqdrfboAl27cR1EBfLqgvD6eTc1kE/Ja/2CZXhnFlxCiAd8QlIlVgFdL5SwNwqxPhuRNIyvp7IGoYrF+Hjd6/UZB0/WvBs5vOaxlV6NIPS7RoNwgb6ePNMqMmPfgwAbjXTtrEd5dH/3pPC7JngPvSv8T4Z6FbF7+53vNgFeBUBONlL2O5V260W35LSyw/stdKOEcnlq4cuOs4rs+m61m0jkXj1avNVLS4dG/RQeo0BenCdkXRzA+LMahmt3dPfJ5HngS3NriKcK2VbeXVM5PU+/EZY16PNVeiQ++opW0MdcoSW3Nj1M8aNUHxnEU9Kwyv817389P38vJt7P7m/PfK03oMng37VKsSwMrN8Z/Zj3rlHatvBSw2MGEKNZCHOxGFVqi7dWgFepm0eFx8F7VTBPXo4xl+6EeQXVHBpydj9EMe/F0c3X/ZsbwbCUHmEufNi/b1ytSqOQ0Abdhc+bb9mEdcNp/28Za/vGkx8EIOWlFTienTnWuamnXePMG+fQFHZEr/LBXWujFI/OGJZ3GnXUaDLAHKPuO7Bm5Ae0ugYHNo0v0M4DY67i6J6DLMF839vwtbtuT2GCp+ogUorGQ7neyynCsPk+ZrLjLL9ylhqd4F+fWwty0TLOn7V9JaXvhYvs0qZrODLdnV+9hkdvvn/913/9oSzVNT34kVEuf1gf61/6XuPAygPddR+l+sjkujfBBKrUKlgEg7dSBbbeKCFpKWINTq3vwhuYpb9pWNVQy/g2UdN71mMtQ7g35Voh37DfuBo5lI5VvBVkSth8VwnV0C7NOxfhc8dRT2ZDTP0thNCS3zVCGw3sPEuj669HEReCM1/r2DFUofKQ0Kw0qVExBvdolNmotb83Xr9v5OKe5Wv9FhYoTFLvtXNpa38N/Teq3Siz891IoYa+dCpvPBmORji35iqOeLQMYsfmN6UhWoFUajzQtX2XtqVLjULXR8Tnt1uiy1Ao6/RaWfhZIoYfTYUZWljn0n9hxOoh89u8Y3nBOvRedZrx3hM82F38qx/e3Ciwjk2KgGcK3/SBOvXaTBbD6NNkrh9eYisP2kcx6yqBVkXcZ6IERNfP0xlA62nUg3WfeqtVMoRux7XREK/5yYvte4XE2LvvAm06hhqKCpTNL5RCE7NoQFlXwKq0eZegg1ZNGENx0ycohDA12bXQS/HgQlt1KKrIS/MKG8OxUWfD7PubUjHXKrZW5Cyk1RI/a7PQ5Xp1XfM6AysbjQxKm1XCPMQmhvFwo7c1ajX0+qzRBj0oPwXLNlHtVaevtK+h7JrZvMjgtCBkDWNzD8bYtaIjes4aGvQaOoWD9JrD90XbD1MxV4VuXUQjmqi4a9xIvUUTvgOhd87u53P8q686acZjTLv2b2oUMFm9tvv7wpJTFg3NiinvIrfU8gZ94RPBVR1SZiR89109HIxUuEe/xRdrMHgLxVN7fSOfLpAxWVxRDUNTRV5v1yLWm+uYfUeYF56qkPX65m/Way8jtvKiG5XWmGzlCgYqDkwAhPoO+8LUjGjhEnNG3+5G7UmmLWvsmLYfRq6KszBWlXCVSgVmjT2aKKnFY2jca8Bk5eXmk+66ff4y3sF/dx/zus97YJr7b8VMjUYdEZv59N1HqaIrJbyRT2FDfNYD5sqDdXzK3xwAn/UgQRCHMdTYbPSJ5spMr78mnUUH6KmPQrP4h+5wj7uvwxd/luigrfe0yQzfyLE1F6KEtQrdXFpaWl7dB4+hievpRDLZfBr9Wz74ojuZf+acAuXdmv8mfWsNt04ZE5YIrq9Cw4Qb3usPwepxVfFYIF6pMTesZagQl2A0j1Esv1j8ena8NuOlkBiLXqcV76yHuqGmufmu+YqnSKOeCDrqo95wFUw9Tr91j1W0xldYq2OoQXmadysgGiY32vgJBp29AsVo+9un8HrhiCrpjqc8Shn3jJ/1/Nxz16StkVsVm/vVacKvT+PtHLdvSqglnG3NNTR6q2LbKL+nolKmp5wvr1AIatejY+uY2zfDUAW9/N8Io84nw+F6Seo6FE2oe3UMvc/Pahw+i2Mh8mUcKGtK/F4SyPjVOjwhKE/QLL1XGHzRiEbnG00Uvfii7UsfiFf4B6HrmdXT5P12gBikMEa9n/5uFXRL0rqoq5CK5xLYI6xEmd/WKOinnse1HdvTXKsk63l1bsbnPlUMVWYEd0O9/XyVXumLsdao7O+7LpiyeYyd9xqGrs+TwexLq+KvoLh3x1poUt94x7zWIKyS6d9rFAobVUF6PYXj68S0j13LrmlfdXaKTxvvk8JaHjIWEWejGtcW2lqeWhiu8lZ4glG419PZZlVI+q+DVEVOUbdar7Bu16J/k7UakjVeLW7wMp+lAbms8/Cak/pk7K5xdlRMVnH3INBu6HySpzVShSW15lifnIUaG59tVNf+3hw+kvjwyDc3redbAa4HhriIiLh26Va56KO4aJVmlcfTQ372GcBN+l3DQPe7q4ToolRpd6GuFe4Bf3RuNVxd0GuLfZaRajzcp9jtXcfjMabSoorBNfrvGtVT7foI++uRaQsl+YwHyptZuMd7q8FWEa+gmWt3XDen0fC6EM3108cz2kS4YyhsVzybkSsf9dGwvlMZ9nSInlbjX8gS3eXbGmUVflrHZPtEJ81uXk8m6+/h1iqCCp+55hRXoSh9O4n0djP3mc/oWVi2eY5CO1V8rmdw6BP3rJLVykvW6Pq/TW6leTeN9iFG+zyFNT4aJf7973//J/RJ+RbtFrr0ezS97zxo5/orzFaYp7Jow1lPSqicikB6kGdhIbxUJ6vyXyjyTY2Ccrc+65e1rqVqmLoeFcLB5zFUPRe/sbhdvLWIhKmQSRNBJS7F0ooA92nu4Vr7q+JB/HoaG9XUO1rIResTmEqX5lv2u6fkW73CMnDHVdp1biscfkOwngxzqxrUUNdbv78pEOveue/RIa7pHpCFwZQTo3s9z9LnvFn0aY4HH1B8+l3vuwoV/Tk0PFPKrpEAWXAUsoe11yPcPEijhq5vE/h1hLrulRGKUt9NzBt7+aRRsnd0lJO4+55ivPLuK0k9um4UWaelzmI9+kas9Wbd09gYd1j7KdMWUqCBNWWI1ngyetZ4ZaT8wOnwneek/9374yiWD1f+r4/vfve7L2O9nKgDDytL97u//Mu//DD3Km4Gxsmv98I3LbmuHkLbOrjuV31X6Ky67wnm/LmNAoEukTfMWs+gC1GBXeZsfw3bl5kXT6N4MU4tcpVwGay/bXhP0Wz43/tpDXH386czSQhMF7sha6G59lnlVSPRxW54SOjMuZi+sLkGp3DfGo0ahY6za23OpVOrRERZhRaWpo0gOietPLIOwobI6Ir32nc98l2D0qs89RSBVVGUtpQKg7/99+/SsRF3DU156LW2Dg9+w2vl99IWXTYypFSdimrfAaNdOtU4PEFxT84H5VVeqhN3RvUUNMPRdXJ0fR2Gzrd6Y2GW0uterYKDXoCSvz+bBdtv5eOigXtd3qCQd+V3HegaDVGmaKYwl/HXQVkYsrqg11S260R9FKNAoOtNV5h5C20I2KoRjGDRqkSvYaoLWzGAig799yA+5ZSbxReqN3qoh9PFa26hBqGJzRXk/m0MNiP5TQ/K6zn0rRopvlgm96JYq1yv3e+F4Ws4tlpGv4yekLSGY8+kYeCKn/p880nu2UjKeJ72StR7xhMSdHePPhGsUaP5NBLCI0oO8aI1wiOq0aqwFk6r0UG/RgcUlvmUB7opT7/GU0ijRrF/g8UKFfiufNVnceCpNbaNQNBJBdK1ypJ53j0uMriNavfshN/+7d/+cIa/yqEn+V6Fg8arZCtDDnlDw5vTKdDzusFHhYTuPp6Vwjh0zwvIqsbxxtSCmGuuOUV+96If0OEX3ssleLg6Y6PPG+fxw+1uNgaH/pWX8DW5wHv3/V1/0cY3v/nND46FjYEcrJY5l4/qjDWq6ZPcyNDqxjczCg0vDaJKs2HN/V/jUWW8Ic8qwMIxzehj+HpSBKbKowoNc7526FfDs6cwsx6A3EchiTItZVtj0+jqFvu1J1fVm6vxbLvvW8lQZWVcXmvAGrZjjuZyFp9crxhNbS60bgujGEuVYw/Vcx+KqB4d2j1V07h2Pb8KWRUuzw9GXcW5UYT1pJgX/gAtaM1HtXQTdl8YslFK59oIqtFOIwxjZZj2oEge7vXR5w804mTMKeFbPzAwWl1EQKH9xm/8xrtvfetbL0rqXmSSYrv/5ZI2kWo90OK18mG0Mdf7nhH02f3+lLY8yd3zxqmkuYdgtqAFn/h75WgRh+oxOuh73/veBxiwfXnImPEdzUBNZxjuN2dsfM6JaSRFj3HQPPvAWteY16nrb1ZPLToAPvIdudp855s9T6E4aEO1Ko96Kgbe8M5v60k15HSvvky4gl+Puouuv3pPC494r3f1GrxUZuq820dD4UYiHUcXvkbwKfQt9tx77rWuqSLpOK8ttGDcXY8KydKzUAZmq0LdqGnhotf2Xfis1y69NjKpgum6+X3ns+vbuVWJlTalUde8+Sn3L5xXqMZ4m+vadcSPvVdhga5d6dF+zINirFFuFNcxyYusoVdl5FgLBobsLWypufcTr1trtDCfa63YufHss5nb9zoQDGqdvzqq2pNjhd5FFrruP0iUJk+wsA5Dy0Fzb86SuSlEEa0Uiai+u+vOmBQGrF7sfZ94c3m/a8yQL9LxpiWplJ7W0LChVmEiC1Sl6zPhYBcUwVsp0qe1bXjeyTZMbh6jQtcM/hNU0bH57f1f2KAGzPwb8lV4CIZ5rjJ3TWla79s9+5DyGq310qtcCRTaFqqqsjfna2tYSuMKKE/K543WzElkyWsvZHS/7Sa7p1yMBiZBn1WOjW7KC8beZwHw1u76Fjx0XBVcXvp6+oVM/F+npsUE5det7S+k041k5nCvVrH53vobs4iIkuRJ3+uUvOOpq2B5wPYiXCWeZycUsnA2j3GZ71bhKQ/l7FQWjPV+91d/9VcvUcaNGfRTr9q1IJzr8wxWE71+U1i2+qX803bfewTn/d1nM/wwz2fo5spGjjeW8+4vOrhrbxxHv+tH1VH1ztGTXDh/SMLYutJJjeh7YB7d23yHfvAxmoHZjHcdtTfPKViIMq+FXi++ns8q0QpfH7XZ3bC7s8/vYI1aLXc9lCrJjq1eesMrwr5evvvD8zqm3qPXESBz1xd4SwUFhqAs5AiK02PejRR62qWDxOQ2VoEZdxNh6/FQyj0B0/3WU6qHVIPeHMN6sZ9XDdbkI7qIMsrg9bo32Xmt9/Edw7SwDb5wj/JEebtKGjSGli3j9CyBwkLNHRlPk7trXLqDumtUj7UPbS88yXmqjBrjKfyePeS51ffZGYKrNLoyz9/6rd96ubaVXff3KRr0P8Xmfve7m3fXmxI/+IeBKtR2Y7/v7ndnbE6ewUTgErIKGgbroLXf9LDE1Ql0Uh0GhrLH8NxYvvOd7/zE09K+MvkOfAGOPKN2v8O3rqEj6xD0EEL9knGtDl7/d37TUyTrfpwvawKWaqRYuXnzs4+qFGqVfeezVcJVvDUQXbyGO1XcNTTXNkxGxLt+T5oshNTxbvhdoffb9t+Q9drmDiz2LmCNX0thq+AYBEah462x6ZgWbniKGDqGzrmtxoYAF4ow17Zi841Y1rsvzSm0Xd8eEbGwykZV3muwajA3tC7/lV5N7huboyC01+ZfyMf49V0nZj26jn2htRohv39yZDoGtG/kdf+DckpDRqIG3mdgo1P6FG33Gz1VvVT29I+3Gfius3kWKrlSTUdwuwcjVvrUqaLMGTP3X3629qKc0qc88lohx4/mnr5vyfHNQWVRowtGRz9dD+PHXy0AqeOGl11TpV5Zf4LdG1nUga2u+iinpNa7ecK8qpTq2S70UQVZK8baCR9fiz7KlASKha5367clWpVXr2dYPhAoGHoV7jJaBcBi8zosRj3lQmBOi3wKvyvgu6gEahmm0EUhnCaZS2vzBk/xetC78NNGez57OurEd03i1Qv0GUXAaHRzVxNmaOe9BpwC2bV2nxrNGgYwxH0niVm47BpDvQ4F5WR8ft+KtxqzJ6XaM/Ib3Zpb16d8vxBhobs1hoVA8LQzjg7asEmtz1rAr3Vk8H/vhz7XWn2F97vJjUE4r/xq/JtUrlFo/3IK6IE3btzLy11zivru12i+e00WcnTN93IgHeiQgbjoBtTUyME5YJ2TqLVOoT03RQCeXqXLaw60yIrc1BlfGbNub24UHJRVhi/jeUj1kydvUhauglW4o17N9bNn3VgoC7MnH8KIy8i+FzJr9fx3t/D9zkJjJoeatSrJOBu6FaKwy9Z3PYel2/QbkdTwSHYxJPWi3Nf4CDqhoKwI610LU+bhtmyQF1YBq/Hq+OpN9X4Y0ftWQsBO6+Xy6p7q1xlosEgPXOsmo0ZeFGz5byMz62Ru/idojnXYXNCudyOrwo43D7JQhd/xFR8vz6xDY7xdk8oSxWAeXj2W2mf47767OV7Z6b1ONuTi6tHjG5GEfjwI6ubXw/ZsCvM/ZX7K9Nvf/vaH2v4aje6ANrbOAT0ZDfL6mpK7MZ3cHcRTSKdlq8pfPcbyDKNd7P/u3/27D7xYeBDNbwx3vcq0e10egZPW0wH6gBtzsG6tsut63W+dp3Tj6cPGqvjJdo0eB26f00EXfpREc5N8PjPQFUSDwtj+L6Thu/XqnixkPSOTr7D29/18oxTjqBGoh9uxrtfZcW4oV0Xx9HktexkYVqr/1l8zjE12lfbeGan2U1iiyqoK3DVlfgr4CZ+vJ4jJO6bSrOvmu3pDhbU2cdq+rPm1VqiUlmiwkUz5hRPR39/vJFlbolveIlj6MUb35/Vt3qCeZKGBlZE1Nhvuo9tTVNixNnqg9CmKQikUpMTyKfzCYIV0jEF5acf7modb6AIPKRGmULu/oq1z5BSgsYqode4ql/4W+V7jTDDu6MbRq6OhmU/hvdUrDKW9CWdMzuDVm4d2FNNH5xrOa3XgwFAbCXa/weqFJ6eiOvspsnqTklQ3qhewjF5mfooYMM4KhrZQQe9d5V8l4tqG/sVRn5ioxFvvt975zq0KdnE7Y2h04LtGQde2MkXrJq5GQWtYmy958jCNa+ED9+w1IsCuC4N1TR+ds2sKMRWqwR87xhrpDXO7/mX+J9iyUUi95zoClGDHvbSCq++xzytw5YEatBodnxVCrKHcHFfnvkq+9CmkUK9vvURjsStZf2jndzdn0FGf1ga+EyFrFFUN4xqu8oT7wNlFvAzSJbULEZOFHsdexXy/u6Q25f503/IziOz+ts+hsFiRh1XOn80Jwu6zssgY1KDfXG0+q77s3h73rRNgXHUK1yG6Zg54qXxSOTBuRnn1wpufkrrKqXXoPBphZ2GZ4vJVvlUC9WK7OWu94h3XCt4aHN7SCuoyVcdWJV6PsN5U7wce4Y3WOBS3BznUKJi7vyk8cJDvO69uwiuD7a7qJg7XCzWvY/BuBnqKiEr/7m4mtMJheRV9dad7ocI95/0pGqpBvSZS8Sp00RLi8kUVCLrWgLfi5yk6bHQhGrADtxVj5bV79ZC0QlD7uMnekwCXTjUMFA/ag7d6MJ9cAaOAV+6ze93mtCvv5Enrx/0LJ1ZGHdN9/bZ1PWqkRCugPhDLXXdeteOv9X0vFVx0iT5uTmcUPJynUck6o+7tf+tx7dbklPaf/dmf/cSx1k2O/8qv/MpPJIzLf+5vsyAdZa3vNweTHTQFYuOtq9qiQ9BA1Fb573o3x/FkpFbPVsddI5t15t60JJXg1Zt6MhAEbHG/KqQN2Xy2XmON0XonXoVK+tsSeaON/kZ/xu769YpdtxBHvQACWuXTUJTx6Jb1vgure717tpYfEwkzKef+jsAZg99v5FNIqBHYMaxnzq4x2OilW+tbHtyqDnSiPEv3romxbescyo/u3/7KJzV0NRRgMmXBpVnXVH+MT3mrHmHXEI3wg752zwHeEI3sPbtOvX9p2Ii93j4FdkdXnCEQHTCmPNtGk8W2m4vRN0O/0fSOp15vj+b4ha9+9d0/+p//53efJSn+y+955ddEfPf55TIu13FRza/8yrtf/z//z3dfd2T2jfe//q/fffb7v/+f0ImM10nwuVzC5Rs2N9MI4+t5imP3QzTf0aS4yOzguGt3rYePqVgqAoBGoLXybZ3HOqKgNOuM313TOWykQN+8uVFYL7OhaSGDZsT721Xqq3QRqsqg/fazfrfXNZzqd/2+hsn1nddGJyX6RjlPofzuHC0jVOmUjkvrvffmBhbrZBR8vzRdfLK/X4X6NI7CAuZYWtX4ttigffbvhsL699516tqhu/tzProGHXfHt5Fu+bdJ7TX0xZXx9zV0LoZcwd7f1UitTHV9n/jhNaipNHQdBXIvNAIX3Ut9v/Ur7ZqI5uEXlisPVQY67v8Ez/4P/+Hd17773XdfPfrcnH/wg3e/+od/+O5H7w+Se+m7c6bYzyhclPD+aW2/9N3vvvuaTW63ht/85uFg/5E2m6fxx+/8zg38A11OOdo0V17pmnxljpoQiYEYq6z1i2aOgaHYmxBXpdS12spLTg8j33tU/irj5fHKRyOpzae9mVEwCSFzvZ4miHitxVi7i7PCVI95oZ8KMe+nXnPDqWKAJXQx/GKhxb7r4ZpTmaMKo+WVvabCUiVUzwAN6723ry7uJk1rSFsqiLY2/3QzU4UEzNDxgcDMt8cFuEdLTesxdjPSRkrWrp7WKul6Q9eOvsL5HqPdaESktHgv3uhO5fJblZrftbIFrVrT7vhvfVMiFCxFgV96SB9eUtFynuJBBX3spvHUI19a1di20myNY+E763mKT5TQe/FoQTIgJnNA4x44iX5+c/PfDY7GKxdxn8PWf/Hb3373rf/+v/+Joxe+dzzjsbeFO25OOZLjDAJF/EEWOGD/w//w7rP/8X98XWHdb/7b//YOd3q5/mhyUcK91mGtQ/KDOGs334uwHG/dBDnvX9kr2jEGdoqrClyHsHpHEh6/g5rWYLXijnwUWq0R0eisj2IUyqAdlFMLW4f7H9fk/6sdr8dXCKEHinUC6xFvFYtrGg0gTENtAiZy8TlL6vPNQ7R1/4BkWE8nrUFouFfGqyFYY/CEXXaehSF8vp4KIdVX6abPY2AC1tryJlH1j57d21C4j9dVBdZIqYy82HkhtK5pPV+KrrXuryXoe98qSdfsIXIVnj5Mvs/StRbq1CXirZe1XBilAitpik4w9Ca0jQcE0RJgc3bf5rhanbZ5qFX+p5wusfuNb3zj5cC7e5WeSpFh2z73nAD88QTN3nv3Inxwnv79v3/3G//iX/xHer5/7oZ5nNL/xTOq7xX8jzx4K4b9haYnv3e/4zGRCF7pZr5HqX1ZqHfv/rv/7t27f/bP3n32X/1XL2OXOxMBWRd0+A/voVIyynD2sMFGhnTeGQab8eRjrJHzpG4N/viP//gDfMUJ2UKQFxqlPLc0bz6Vkb3PWixQvrnX5WnI+kcxClXUCyWt19uBFapYiKihaD2CJ2tXXPopHK9BqXHodaKZDdVfC9k7t4Wl+p0FroVf778GpIayvy+9Pg9O2GjEPayT6xpaopFIrobSPZoEBw9s1NOIoGNa2pdencfTOvK0qtxag79rbR13jdZQlS/qSJg/QWtkW2+LwvWdz+uolI83WrS+SycKpnxVfl0a7hzr8HihIbjoFNIpozMEh3c7abRz1G8TkjzZ1yL4wmVL569/5zvvfuFP//Tdr/7lX/5/TuEcTfNDfJPzhL6PtvdO1uWmOCMHcV0J9XtjUVl8gaY2Sv7jP37341//9Xc/vjmfcX6fS2lpsQi6e3d+/FDWvryza0RGulP7GkfsjMutx5OTuHSs81p+Mq7NWVYfr/74su1Ll6QuhluiVUh9Z8B7iFm9vGs8DZavJVw2E2FWdf2FVBCFN+2+LUOz2AhbD7NjNq4q2363WHjr1Ztoa2RVr4riW7hN//X2e5963GCWhdM6xmKfXatet8YMjgyqM55CSU2ybURUw2Os1heDm59qFtca80ZLXTdR0irOvWefDbH0dY0xtFpMBHjfo+/9pufkF8bk7TVB+drGNfd9EvDl1ycBd43vG22rt/e/Y7AvOrjX7/3e733YtbwOmzn3Mad9OEzzR5VlfPYyxpvrQctf/eq7X/8//o93v/wHf/Dua0mWXmK4/PCD9zz10tf7Q+I+RKJ3n4vw3q/N5RYo7xvjJZ4/wMLN6yWiavvR//a/vfvRv/yXN7F3P/zn//zdD/6L/+InoBd0uT7+3vsznrrzHu83arM+Inj0cebTGgWGWgnw6TPFAPIc1WN9kX1GxFo1Z/naMeX3/933KX/7JkbB4VStZlkPujdv0rObUBzJiwnUEFNghBgURTEgEmig1pDged6sRSfAS2zYJ0VAAC2UfrvTsn1Z7CrIWu3mBQhPz+pHvzbzaIQD/kDbzoGhFK5eIzw/IRSBk3gtlKWxNuRtX63uQSNelWvMqV7nGj203gqIJ355LXeCjujU/QtdF953PeCnyExfa3xBkCp0mpdaY40G7Q+90O/6qWFlhERv1uNpo9TK1DYKkUME+74o4Uo4RQaNXFZxSKA6ssOcGaudm/VoQvrv/ct/+e6r/+v/+gIN/cIpqPe6Ynn8hb6ndJPPuv/vKrCX1sT//e7l8Lxf/uV3f48R5xDMk/J+8ZxXEeb1IxL5u79794v/0//07h/87//7u7/9b/6bn3Au7J/41V/91ZfPDnI5XcJIKykFL929+lwKxgFc5/nMfbgTJ5cuvetViK0OaDWgNeN04Ot9RnojmvIRPbZ8+2bwkYEbXDdnIe4y33qo9b6Lp20YWq8S9FLl1FbPESPtOTu8mrXIJT4B01ejoi5cX+ZhzBqlu9da+CrlJhCbgNq2nm4F1BgqiPv3E3RVL3YV0G6RL0zVdXiCqwqT+O4JIjM29Ne/vxcuaWveYKGwvp7gnHp7rvlp9Lp3QtyoaHFhBmUrsSi+4tL9vq9GEOXl8kajPIpJYrOnw1LA+ixW3RNinzYBul/Hc+1rf/EX7772J3/yH+/9R3/07quepnZ9vYd6Pvz+6Bdj/7Jetx498l1J69Hw4eh4EYlkvZW6fg9eermPc6IoxN0f9b3vvfvFv/qrd//oD/7g5dqv/vqvv/vqf/lf/sRREj8O3FdnyR4HNGphQr3+IgPN1zGi3TfkmuamumaVxYWeV2/uxtjK9eqCNzMKmKqeRKEXXrOF7yCKDVfYTWSF4ycYYR4FWSWjVThaOYOYFcbFRCkVny9xCUIV02KNrRwwdnNdRc6o1vvsNRsVdSMTmnTzEy9xlWEbJuo462E/JdqLt5fWqsYWdiv8VVy269gcQBVdYbY1xI3EPu9YgH6/pZqtLuHZ7fU1kEuLdS6K6S6kwHBQFKAB62nsxlPhr2LY/teIuk/XFJS0j6ekiM37PNXyIMio51+tgfyJPNzpgj/6o3df+xf/4v/zdG9t42SBm+sIgI3+LvtYXvj6+OfmPNVXP85eBvDQGYa/8/yByNQZlZYpk5cPubD31/zC97//7u//L//Lf5zPP/2n7776z//5f0xqvzcwv/AP/+GH3/3FX/zFhz0WlD6HRSXQ9XNr7FynXlNHUwQryvX7OteFUumyOjuFeysLImJrBPos/3/R9qWMQh++gVGqDLRa2g2t6503pH4S+HqOG1LvZ63AcL+tAV7FbyzwuXq3nV8Tkh9C1Pd46b07bvh+Dx9U1dMqGoxhrIU1qhQY2xpKgtGNYPUubUhi+PaUVOsAIvDIwUZs5lDDXU+tRnwrHNAUnbcKapUnBWaONSLXj4egUGaM44Xn6xQ0H/L/tvdvv7fv113fP/fB9radOHFONo6xQxJCDhQQJVFTEgQVqDeU3hWpqEiod4DEQSpI/Au96g0XSIhSuOACEKIg/UgCidQCQTkRQcjRTuw4thPbjQ9xfNre66fxWZ/Hx881Mre9E+x47816S1Pfteb8HN6HcXyN8R5vMICCdvNd6/97Ti2serbWY9epKjPuQHjpo5kr6MOa9sjJGhPF6+uxFnKFeRfL17etFMBHFwb/zDNHfGHgJMHO8qv8eamaXd+ez9AYw5f/k39yu73vfbcH4ZsR2gftzP8pBuuUcbn+EHjw+7MvrzCu7N1g8RdaHnjoEU/hvOagn+k7oTn9Hd5bVYpH+YyCeOLd777d/o//4zNC7qmnbg/+1//1SimdpkqBuBGFMPwjlVpxvR7d6voaiN0oqC87G61yAM+i3W6E7DPMTaFBvzV54POuFO5hVv2t1iYrTscqFNpKaL3OpMDCygRl5mbEECi1xmuFb4jH952sQhs7OF033RGGhD0lMIvenYvb6muQtcxt3Ntb2rDH5QYvIVWlwwIvRFWLfOPwG8Yo824F2X42LoQmKIrCSZq56PvuWb/1sBqYbzomIVyvc3tfdbNrpNQg2BZU++Z9lPpmZu/Rf0qxAt0aFzfu3HTnd2m/72i/dqthIo/eZ/7fM5nLo1WK8u13Sm3fa/6fmE1oP/7jt6c+/OHbEzP2KR8THtmxvlEGI/ifDd2Nt3C8L5Vxx1IHH1EKj+Did7K7Duv+tP4PJZQ5ffIM2h8B7tNL4FkcazCyaRTD/Dsbym7T5x/4gdvtzW++PXjDGx5RwtMaV9xxIsJ4w4UNAKNZz8Nv1nK3eqb4AN3Veyu8u40vhuAL9RZ+S4fs9MW1cA2sxHFPGFS4F790bS3Aq6OBdPxukCyvas8K8U5wmdl1tdxq/d6z/CwypTDfwR37t4vino6Pa21uOh/3lMIWwHUX6zJ7fxm7Sq9wWJ/ru76v69K5bV/KAJRB3eAt9Atb1QuqwaEPhDCB7JorhTHz7DrtHu0ZxxaQG040TxRtNyQ1CNj7SvuXYMpcdP3FGrbh9Nn+bguyc0MhbKXAU9jZOJufu1elXkeV0EH7g+O///23J3/4hzHUI967mEH5/JgnMZ/TgziMokAsI4hndh4sHj5eccYijrHz5Ia21nzMvce7JLU0A2dXBxhvtkZuN5c+99ztwQ/90JFJ9dxXf/UjVjeZABZEh918iz9qELL0XYu+O8f3EBd006NkKYC9XlVM21NAe5+NDn7LSmHjVFsx1DLCbJtxTFRdQRNQAq3gqTAzydV+XN4KIrg360dGToV/GdN7akXW0va7FLbJ/WYRqn2+n8F9bC0ZC7Oti+2hVFiaHwqB4JRBNd9vSKTCxhqMF9NMqx0UK3a/hVLngELaEMymiUJlW5F3fBTb/q3xAkzB6iWcMUx3jBLa5rEKYj7iIc2s6twWh6/7brzbUNjGjbXg5TY9UV8JFPRinnr0Y3fPE7JzbUtVgIfwhA1rLQU+7xpYwz1t87vS2eaz9PWIkP5H/+j2xDvf+RvkwkA+8znWuHW0TmhqFAAeOeZ3lA7amfkfPjqt+Kdnbgsxn3WQjrV5uFjHZ+Aj1v9kFe1Wj/wY56lU7GN47oS5xtsZT+Po80IInj0/ih9ORpGYgbR4azXrgp8bgDZ3NYTIJjRd+iVTSq+FoNFLYetp0zd1lkrv82+FG+95Ip8XT6Fb4SvIe27s8wkV/99WWZkSExbLK5NsjSnAWMFGuFEW7ft2nefTg3maAln8nOAiIBzA3X4bi1YB0o1aO36xYbONL9bjaVYBRdPgaa3VCmhjG6KpwvN7EwOquK1NvQdz3Eyzejl1U2t11voHuVWp1Essto3wrU0hozJa4SM7Yz1vW1He2UB+13o+3e28DY6ulTFuZaF/zSdvn6xZvVPKjid5wTaxogl9AryKUWmLvUHNODcEO+/ZOe/osecfH8plrNwRhvXiT/iG9XoI/5R+FkcZYXrNz/DS8BZs/LT8DwNt0lkTa7s8LYUF12l94KhHNq2dsNUh5Bc0fCgcmVHZq7SzdZ7+uZ+7vfYjH7k9+9/+t4/wOV5piW88ITbTqqYtXtjnb3TDNdur7P6HHrjFqOkJevOZ+Z/guOSGyowvyI7mEvSGWopBl7natnvkORUMFRqY4x7DVlA1c4RiIMQx5lY89XgqdHudPut3a7Ds4yc7tgqA/Uz3Y/5tZe9P52lDCb2nQm+7/nuN/L7TibdQqIKqQIX3dx2q2Ha2hOu8o/NwD0La3mXXt8xbSMl4/J8BYO62S10l7DoKAD00KN113GtjnOWBK0AaqK8Kyn39vl5jM/0aWBSf8DE/DBYbpVj+2r0DnoyJ4iHEK3iOa6a/73vf7dNjhbZwIoPvnO8j02rOLj7jBTOeQymc31+Q5KkU9Ofy2M7Moqcy9mLqYgS+v5Ig0N9nBnVBTkdqatGN0KA5P2hheZOv+OAHb09Nwsi3fuuxG/q5c48R44C1X2XBq63R0HWrjCK7GIvWu/IGfTB66oGUXihwNDUKQcaU62qgft4DzQ2M1nqsdVSFYEAmpt8jLgKt2QG1EKeVWbcS2gJJH0aDFuv3nG1h83BqbRfWqFLQ5xbyw6hVaI9MctJu3V9svYtljit46mF4dgViLR05z333PaVdTH0LMc+f1oyrPlcmhf6BKqpAPLewC4gC7DGNy+2dHQ9DwTrcq1njd5khGHOn31YZak1bVh9/rlPobN6jDIL+mff5fw9asZb1lMwv2I5XWy+0Z/v2OFWeUYPWnV/11SYAAK3mSURBVJ/SBHq3Ec1co8kWZ2vfqvSm3YM0b7/8y7dn/s//8/bpxAGeOpXu/D5K4BOnhfzRUyC5bryGg/+yM/mJ8/tL8CU77ggMo5dzHQ+P9DWvObyj8SJAVRTTU6Hxj3/sY9f3Fz2muuh4FfiKIp3fL/59+ukj+GxGnvnn//z24T/yR26v+N2/+5Gd/s3e25lnNYJqPPOaqkjIp8YB53471NHbNmK9Y2h0+lJDWsxzy7ctlz5vZzTXMtvuLwE5bVuY+5paXduFrnfQ2EGPE9wWTy2bus0ERCeT9iWoKrAbGJpW67obubYmRiDz3fPtdO7CUHqFiSqw60HUXWy6Z13Q7aX1mZcLvo5T7O9VHMZkDbYF3j573rQqsRI4omeF7uwcQrP00syfEby1nswhXH4rWWtQS5tCm9+Ku7a/ew66m73F6Gp4SFuce+ffrPyuiz4a64wHNFqvq9egn8KMNXYcojOCnmfQ0+NGWIhVTH8GvqFAQEt4ynjuZcI9/a//9e2pn/3Zi2a1S9jPwTgf/ehDI2mw9lMhWBsew5H/P15RBG4NyGMNznhDhRfIZ571kQ9/+PapCZ7bGCh2tGp/oevbUgrHHNoB3UrEp2F6KIlXveqozMqjmN9GQE/dqJm3Sef91V/91eO3wfFlbpXfZm3qAXvPrixbww8NdD7cgyaNwdw1O7J8XOVEzqCDL9h5CtuKbR7shi5KzJiH91BCq0tVGEOr21ULh0Da79t9rmXtvYUCah1VaDZbZwdNK3AbINffWoaFR9xbXLSwSoV8FUUFdBe599XT8Fv7Y82qODpX5kCfu0af7Zl73Pegwno2+/56GZ0LfdleTmML3t8+992lPwJwQ0DW2rqoh+O+KvoLtliZYwTyntsqZXQ717A20VqxZHxWqKDzx8rVx3tQV3c33/Ng7639pYhGYb397bcn3/nO2xPvfe+R3XNk5qT8s4AruOKochohRmgdazTrC9PvrvOlGMQMDty/acrxniad9BL2hPuZeXS8a5UtuTa43YlxHjuhYxg8tzaSHvT//vffbr/0S7fbm950KIbh9VESo2hnvpTEqKGM1rZx3DXYsPHmDbISDTeZpHSGTuoJbz7aPPF5L3NRK7KTqfOaTnYhWNnHZKcctCi/zhv8Hkg1biGQTnpxuU4eoSG45n7H5nlfPQDvLBxCEVbh0eLV1Bayz67gFuBmfT+fQK93Vsu181CrC05dRdvxaLVI+h6uZzOTpOK5jmKqUt3eincSYttTqXC4Z1Ebv9K/83+b1w6oICWZi882XkNYdydxs+O6wdHz5vo5spKH0vMPCP7ixxfenV2oO81T5pRgsHLLjZtVwe4MFP/etOh684De5x1z2ppUVRvXCoGi40KkV5ux/dN/entu4JKx1Fuv6NOfvv36eZrYwDXdrHkvoK9fAyE9Pe+ddU+gGfx6zF/4/EHW84LokpV2oQEnXV5xBHR/ZhRd8+jZpzK4ZFSSJ56MEjpgrJnnH/mR24O3ve32sf/5fz6eO+v4tV/7tQctzjkZv/Irv3J717vedWXzVdbxiPWhBk2Ni60Y0EQz7ub77q7u9+qq+a1rUln5eVcKBljlgDjritbK62DrzlTwYuiNtdaiq9Lh5rrPYhCsfc+18EvYVCixqggJ2QO91jsr/Labu7W2xa3nUYIokzetcNzSwiiuQSSYqKmNnadWkcXwTbEzJ4PRllirXPq8zkN3R1cA1GJuDKdub5UperJm82EgPGJJrs+93dKll9KlBmct/FKG7dwS3JQBhSMTCW25ZtOweEkFO9opZOhdoBz8MQrQveYVDTTuUIjGWsy6w5MdvSmWYE+NNfIX/0ifRiufHKEyGUNntdSxyME15uoI6J5Q1TH+bkYDkZ7nhRO8x76K03sZJTEC/WOzC/hMEx5oSLrqkY46Cm8EaWTDset4hN8JYdk8d1j853oeYxj8PjutrVVhprn+WC/lJJ78jRb5KIcnP/zh25f+X//X7ZN/+A/fPvWGNxzXfPVXf/WVHjz9cqaCw6KsEfrf2YzoEvTX36v08E37hU/qjdhMO2s/109fRpZMf+Z3xs3nPfuoDcPUPSrB1WswESypMrYB3hNGnrW9hi3Iak1ViLl/exz3FBsF4betQKbtd1YgUWp19buw7dMee5/r9ypJzErJtF+19Htdx3UP9ig0Y57utSrGDcvsOa/yrue1hfu0WjEb+qh1U2+mOOoOMpd+mo/f+SpNuv+e9c3Kr5fjOd7ZdEHB4o5xz3fX9vkq2pbmaiUXlmj5CrnqhIs4g/gCuqzBVr6gzMojD971rttzb3vbw+DxWbbh8KgWlMEKJ5Cle2r6fGw6O0tLNENqPI55xkBOgtDHXgVQ7wknHamjijOeGUXTeAxHTGGVF5/vRuE8WBvYFOE7vOwEca3PK1/1qoeK9txLcdHjrO2v/upR86l0aj4YAv6PRkYo76SJbSA3k6zrT0bsGJXryps1Nrdh/QWFj0rw29IvRtuBFW6pEOngGnCsJbi1e//fe2u9lhlBN/cEQC3Ni3jvPL9j9cxOMqHhuu5a7CLWot1EtQW8frE86xnVw+i1tUYLSVSgsVBZ/Oaq2TL3lLu5K6HuAGnnrN7Gpp/CRQj+nsLseNrPjq0e0wjDrqcEBZ/i1mVex1HWw5rru8GNJViLvorIUZ33ismZT5Becfa5xqmFaKceFeFLKXi3k7x4AeIKc938pnyzOeBJb2PJ+l7GywjSj33s9oof+7Hb0//u390+8eu/fgR3P3aeilarVW2qKj48qELp1ecZx6lED4Uw/Bro67Bgs1+A0hgBfVnHZ6bYCPvLuDxlRTO1LrhTVdhlxM33h5Jc5yW45plnnjmU1COW+Z1qAvptbs3LNJCdiqqtrIoWoRhNg65MMqfowlw2iFy5tbOfasipV/cF2afA+ir2X6KtRbJhlqZtepaOz6Qdx/Flc5n3EA4OxIbn9gDsrXQwo7RRk1+c232Erf+bQERNoOqH7zvGzse2RgkiC7wzobZl4KhPQgRUgWik+4EZCPgJfDUoagwNTHu/9UIwsrG4vGCTexBS16fCHa5trQnvKg/WLAKvRTXrWxx2v6veg3S9EXy14Pf86wNhNL8320ZZCEKFUUIpjeA1N3aFOs3M8+d7cz3fC8COhVjF6hAUfRGjaX3+mQvCvta8cStn8VVf9VWXJwBOAkWh0emXeWq8w/rUOLkszUn3/Vt/6/br73vf7WMf+cjt/e9//zGO8RiqlGTB4aUZ5aRyPrkTA4LVozXCkEAdZdNDiyZ76VU5W3oygQp7HbEJtIVeTqvfBjhrfHlG06+htaHLk8Z7rscB45wHAX3sLNL41OrzRafDi6dCnKbkhfmYuZlqBxTErJV5nKJ5NZRK24ViN9yK9+cZ+OxKp40CQV/TKBL83VTjz6tSmOCFtLvuLSgB12XZ8IJrKkwIQhOBee8FBT2zEEkncgsbgs/3DZpWgBQeqoVPARGqFeK1hDc8RUE1/jJtB269qx7Jht22e18opS7oXoN6M9vl9P7tZnqmhljtDahl0ufec42No88tRLRhDFZoLddtNRW2qcvdMfSdVUbmuZvF+vw+h3fQwPH2RNtnnqrxm4sGsWtl1tWvkPAsrXDUKAtxghE6hCtjalo9J4qi/NjYRze5HTT5i794e/bHfuz2q+94x+1DH/jAw3OEP/Shh7h89opc/DG0QKnLojvxe7ALIXV5aUMXw1Onpd6NXjyFQ4Go5TXjm3O8BZKb1BCv0Dpcm+nWxrCrdtIu1pfGsHvuwYPba6YcyMracn2D6U02YMzMs0d4N5GFocmjtNb3PGfzVv7ZfMLj7Ga2rnnjkPpamPjzqhTGqhmixLSIvgxJq1ZQGZDW+3vSmfu3gJtmAqZV4BWv845u6Cnj18V0PyGw++j/2z2uxbsFXC0x7qd31qJuny6CTrunFLQNXdX6rsteZbphKu+tEq+gt5Ys3EIeFY73iKz92kpkw16a+dleVaGfDd0QNjuIVwXv2V2rMszz0YJNYPU4emIdKxNMheYZD7Lb9pqg752hY65rzBTu4UGMUgAPlZYoBV6gE8D0oXNBqOnP4bWM8P/pn759/F/+y9v73/ve2wc+8IHbr37wg9fmvRHyh+V+5vg/eWL4E/B1hsGFDIQOBv451okh54Cd05s6spkW7Dh7GeZjQxov5eLJFSgvzV3jVNSxMMxZ7+hYjzvxjwlWz/WfPPdWvDannZWmPj3B9ykxfp6adsU1TlmGT1qIkLKWzFJeoTBrNBR2rjxAu8Zdo8JaFtI8xpWA9ZZvnxelMERSmKbKoMIVzFGhyWpv/SDufBe31hGPoNhfA9S10ghPi8QqxHAVAFqVVyfY+y0qRq/mFtGf1sWopcvK7h4G4y7GfS1Ggk7N4DGncx9Pba5t+e2mQU5fGkdoCp/iZxjZeFuQq0HJnhVRheb3HZClLHbQjRDbXgfhbi3L8ObVcZK1pOpVVChsPPZi5gXbMUpaCwp0I1hrPilDz2xOestpECJgqUlXpAB8P8+f/88zfOqBVFmIZaARsFTP5i6GPQrD4Tnm0PNkCJk/PDrlJz7yv//vtw/+3M/d3ncqhGPn7vQ7MMYhpE9aPuoTnZCu8tyXJW1PzqkUjkCxtRi6OoXnh88A7DGOMQhO2YCPjrVsltkZzFYp1ZnP5n2+P6z1ZhWdx3Gai0t+rMQMx3kedPLsQ/jUTufj+zPeMt+99vu+7/bKN73p9qv/w/9wnUExtYY++MEPPsIfRRnwiB3z5qMwEf6ev85pqCyh7NEPIwoNWE981QOTGCNfEKUA37ZQJqCMVwVhkIgcxjnPaDrizvm/Z01WaDwfpMJlr0VfWMn97f/eobutzSqCWshb6O2U1XoGBHct3gasWbOFLXa5gz5nGitlW8jc1XtQDeFP8ewzp+9BJBUihT48k5fSg969c1tC4EC/d2PVXtO66z2YpGl5W8mWJut1lEYxD0VPMcHkt9Gz+7Ix3eL/+oEeBZGnFdundFn429ozr11bvFNDhWHkO6mQhZDqBbpvxj/C7DZHaf6bf3N7z7//97cPve99hxIby7xQA/jlUBBZ26tG0rx/1iQVSKtACzGOwhhlYxfw8RtD7Ex57QH0NrodgWrlslPQTl+O/i042T6Ewkyd62M+QEvlgSc+s2dm9mIcKaon7Y3COfD581jOFuxs3KMKvvRn/a0DWqv8wm9kFQPOvRtKqoFM8TFGW7mZsvm8K4W6853oPSG1wC+3Mql97t94bxn3c7mIFUD1BsqYriukchHSghD6/CqaCrYuRq9r0K7XbEu2/6/FQCkQTJ45f+tttF/1PBBPIZAKtnpMJbJ7QvzeOnR9fDq+wmwVJnvdKjAIOuOlVKrou4a+a79KI/f+3es7JnOnT+asnk6NizL5NEJ3FIIAf/urtZ/F9DsvnQ/GAOPAuykL72kGFh6aRkgV1rDWvC3C4Qh6vv3tt1f+v//v7X3vetfDXbkjNGpNqjjaeY3XfuzzkJW0eGGuKuw5Qlpw+VCKLUfx8AWHAEfTx2/dOzNjtMaL/7umx36DoAsHj6+ieBcfeS9aNubbQ49HBtoRhB5L+7xfyRYKoUZehXt5BD1WqG+6uRezbHzSx/Oa1INP0FjrT/ntC5J9NIQ0L53dnptYTUKthPnbjINa4Cz3bVXUNd7asJZVBXMF8kWUp5vf3dPTYHsVrMdEBIMvw94LbsNuGz8x6VvQtvwwN9I9VZisztl5qpkD82cO66bC+5VlKAHOv5vV07hMLZzCDRSW/upfFWuJ0hjm/Z5xWFln6d6OsXhpBTdhWKImpBsDsGbWnpcClirm6lNlsg0H69MDdKzjPG/gJDTa5806TVbJG9/4xtvXfM3XXH2VMaOfwy8Oe5/nOcMXrDTvEhx0FsK8c9Zs/tYQwV9zT2s36Zt+Uz7z73kXKEwK6fRnoI53vOMdt+fe/vbbl7/3vbcPTU2hgSoZAK1KcKdeFzobwXnsAj/PVz7gs7Nu0C2bJa3dR3/t1x7GEM99AKAlvPKIIUEQ1lOPkkKTD2LVzxjALi2Id1zfFPNzbIfyWJ7aU+e+ioPXT8U1Y7reOXN4nsfMUAPX1mAy9u6GL+/gMf+vcez3wj7mUPIAQ6WBb3Azfqh8Kx19XpUCV774erMluLI7E6SasBYrgWcSi5OV8bf1WsHg+Sa1QcXGORD0VgauKfFislp5nt+gdJUCgb8Xsf+uFaTPxujf8GfCkyAv88y1yj0QqC1t0T7LLmG1bWHsO/NR+GXHXCiB/taKpIRRsyz0BRNX0VKmLJtCcjUWQDY+3tmyG1Wc08QKCP7ivDwPQrdWVEtRGHu/m7+jDKaExJx7zKKvt1qPAs0QzLB/UJkzlcVOwGnzGTiIRVrFvd9DWYHnQFsNyotfgD2+5kd+5Papn/3Z28dOuOZ4zpleyiKv5X9Y7ZTCzE0g32Ndz4D0JayjwEuX13plPY/g9blRTbG7rQD69+CTMzZASfZ4z8uyXsd0zvUHbaVM9+Wd4N2nz+N8A5PNc63j7LH4+Gtfe3vf+953yRFxvI0IMExLD13D0qGSKtN2xVRyoZCU/jSjcQt9RgA59wVRCgZSj6ALViu4iqFW4mFhrJ2fOu0dJmDDAvfgnWndV1CLo/hwrcUNUXhu3+H/vafX6kc9GM8sXIFZq8QaZH6E0E+hZXdk38vK6H2e80j2xx0Pp8+v5bAJpX20NlVW9UJqGVUp8DT0p55G5916s+z2HhUM07nebnaNg02n2yPovZ7XHHoWsNPJCGExGgHoEei/43f8jsOSZ82XfjrurhkFQ6HjI8qgewrMd+mzsRTCoIquHrU17Xxe8//JT95e/a533Z58//tvn5wYxKlEDro9haTdwY/AFafQt3ZHHOH8vvARTwPdPgI7uf8MBB80Ko158cXZ6UcseYL6Wuee83GnEOPlMYYujntOb+Eqoje8ds7Vs4G1Ljmz+GjSdHnClRHlq65jK/kWFSlvt9/7/3td9e/YFZ7sxnra5RnveaHttxRTIAQqPGpVsL4rwEA29wZYzJ4QrWtUS3ZarUypYLVC+m6TQaN6xy4yVSvVwunb/g6TchGnj4KUFULGxJUDE7HeOgfz76bmFh4isJr3XQwTTmzu6y1hbs/cSkofn49ozFt3THoOS7iCn4DlUfICunmmxF7ITRrofK84nY1t+u29GLiZZoXkOkelL15BvSxZNBMfMM99zvRrYL35DFz05je/+RHPpONq7KAeKJ5R46Zr0I2VaL1nLOhrr2Glgup6vod5wXMzp4oczjnLb/h//p/br03RtDOTxbzo57ZIt2FXo0DAF/Z+KBgHSU2s6MS2j8NzhsZGbhDgWZdLGaTG08WvDDCBWTANeZL78aU5KpQ47ZHi0eu343kPHipOSqrog/mZgHPjfPPOHk60N1UqfIie0MqOE9Wwxq/iF/oIuiufWwvvcTaJ59do+4IcsjMvn3riYy11g0YJpnABi2cm0f21JDeEZLAmYadmYcJi+k35nLarWtZb0Ke9K7uZTbX+yoS1nioE9KlVCT2zSuWysk6loE+s0XtYYd3OvVW92VyyYAqx2DFbq6SWa3F7a0IgmfcWSevZtI2h1KolgAhEu9JrUHReC+Nt2Mi6IXLrWcu+HkEDdfrs9yYZ1NWuq278nsEbGCUw9C5us6GqrVDBAd0t3V27hRHAOu1neYcypvTne7ykVWn0kPdmrMw7XvkDP3B7xc/+7BG0/fIv+7Lbl7z2tbfXzRhf97qHdY5mfc90yIPWWM3nvBu/5ABjOMpPx9J+8iwidwiYs/LpMd8pMGiDGwsfVRz1kLLBs3xGARxxhGQbDbzjfd6pb/VA632DiHgiR0bT0P5zZyntVRbFvw+D5Sx6h+7rFVZeuJcnZl41PEReNGsQvYAvzVsNs/LvRkRcU54q731eC+LVKiVItxLQgX5fAq5G7ETuhthpuHoZG3opFNI001pkhT/q+m2IZbvutYTrku9x1H3dOLoFpyhKpIVX9B/BNy1xWmGDbXEiHERZ4UcZVTFSIlJUWSuF0TZMeA9uMheds3tYaL2We2OBy+7YQg0A2P5WzIWz9MU89vcy64YH5clLRpidw+MdvOENb7gqT3rv52rth/eZj3pKdf0psvap43dP+zDPkiY+rdAt2v3Ur//67VU/8zO3J9/1rtsTH/rQkYp5QDnn2o9yOGhgDpM/rd5DEQf2GEUw19npe0ExyUjqmm66PuY6G8YuXm5GznhNdyojm68K9UN5rDpd58Q9TI9dWX9HIbxAY1d6rblG20+c9811s26zXsn08k7KGk3VI+3eqp0U0vnYfWco1mPjqeDT8nqNJb97LqXS7KTue/q8wkdcexY/pvObwbBaKigr3Ai7uc4AuoiI6t5GnGrmDV1hKhZCrY2dIXARWCof1mOpkPOMWsT6WAgGU5aQa8UZf4nE4ntnT2j6bPGHWg9bWJcxPcMeiFoo9V7MMc+hxLtxTmMDc0wrRFNCrZVca4iApqBkMPnefBdya/mJeoytMtm1aCYTC2y+t5O+ayrrZyCegZImkDxKYUokd9yfi0faCgeUocsrpa0KVYKo+xOsaff5tGBf77083A996Pal3/d9RxlqanyE3fGsuX88gDODbDJtxugTvAXNvPbMjDq805SarmEwQnfw9taXYvVfynDh5MZ9KLuzQuoxzvNjzCPMZQsV9qmQ50Uc87ks5KOvUWD1SI9rBJdvD9NSKYnDc8xa1uOt3Cp/t3wH3qigrmKpDCvEXti2tD9NfS0ps4ye7dW3j9O+4KWzHUmHUCzexp1puR5bSFDSdpRIi3wZGPfI9xUSFoiSMmGuwzQHE6zjPJ0l4P5a6lVeiEF/LUJhqcYkej+GtcjDaKAVNfERSPctUKb+77p6GVxj89QsMJBIYRSE2TEgprq+HcM9t7u7ixvH2IkB5gzExbKqK64PxdbrVXnWWOksePRT69raNoZg3Na3tOBdTQMdJfAt3/ItR6rp/Ft8Y0NDn6uhZ+uzISmCG8Oz/OutEQhiJ4Ux/N7D2Z+vQsBllDEUGpgPrn8FqnNW8cz3rK9y1zMnhM4I3u2Jas+++tWXodD+ylYaKkMLLPPxTi5elEiAj0qXLPXuQShOntRcCoiBc2TKrX0TF53O7+f9D1YZiVFEaPUqIXGm9aI3AluG2XznbIVJP9aqzNFujUEyS4yrXnBTngv/anhYBtv8e9JmZy0KJX5BlcIQ5bxkOk8I6ew0wlse+IUJLjcM5kbYNc1QUK6YWRno4Tp+pqQszbuZ2XssDMb0W/vGwqznsOGWDSXVO9gCDzPv97dt2EOfColVmJTwjbMeWS314u5l4irA7arXMzL3hTM2/AF60d/WS+ozudaEJkbremjbU+nYa0VvT6rrX7iswXKY/wi6OUFrDJZRDP4txbfz8EJbg4Slr46l2WropnRnDavIfPd8h7/Xq+36HHR3Gi3dwMVqnl4egir7b473ncr5+Jy1oK4qBQlcmlfvPMZ/rvMcnlMe7SyicxvRqJbjmsA5VTnXLuaZ31VS4hE+2OcHJHPqeOf53msHNs8g/PgAWrHWl6dCAB+w2rm/qCU/rIVqxuh773UyZ6XvypGNPmyjq2uOJigQ8NJvlo5/y0pB6QFEXmteJ1nE3QBU4WBCCIZtrfe0q35PKdwTTr3Ob/5uhkFUYI/2r1b6dpO3ACpjG6fvvasw2+5zF60CogGzegZVYIV/tsICGZV5OgeFGYrjb4XXayqA7ZrlxbBkhjaGGbjIFXbeyzvaezLMD1qqMN3KtQphW/RV1nP/VVbhrCk08YIJIH/TN33TIfCmH7P34LfCRLWWa42Vpusp1Xgp9GhMpdnSroA1pVKDA5TGO6giPI7UPGv4tF+HZT2f9O2iq9P4EkM4Athgu5ztcRkMp5C9SmhPckmSHB6Zyaarnpb/0aeVNn70J4K9hkvpYuILk9FE8F/rt9bp+D7xje7YPgT9+R7tMoLyOVr2FowXO8aFE9h6aBIvrskeXa+Hj3q0zxtpqCehlXZqhDCoGYNNb5/2BQs0a6CDarYtKKvJTFDdIVb/tBEi45IRMKw8cMv8u4xdwTWNACphw/gooEJbBFyL+HXy/GYnKIFFANtsoh9d5G64az+lsRW+Mh/FEztHFSbTBudmwXl2Yaq5VvGzzgPB7LnzkSpqwxkibDC3mUxbGW3IB4xUBdkg70V0KX7WeevRlN2t3ICaICcltz0mfbC5j0KYeRtF8Ja3vOVIK2XVDUM346e09UJbrbe2BsOvTJnQYOFDNFgoDl1N/ykARlFTUmUFzZg7b3j0k4yeXVzu3KF7CdgxPAbDTrxPVs4I+GdH4WXH7aEA1EZKivOB7/NkzmdOhlCxdjAQhXC8L2mYx7qP8mv6ejzqeV6NqkMBrv0Z049LBp3Pf3KMjTN76TL07tWueu7MFAPBnXspDljrDO4785pX6jPXq+827x/eshERD8594120DInMsSaX+D/aItNK7wwf5zLzQsCis9Fu4P451+ELqhS2tbg1FSZD9N2cQ1BU6IgpHEScow0Jm2rZwgedPL81K0rEfq7ZWUmFTfS7Qry/U2I9CrFBo1rWVVTiDSAWwsgBLna7cse7dZ5wbmCKkmxNlFqI01ot0aYr4x/CIVB26d9i9dsCZ310b0bz6NEE2M/7qqjNAVoprlqIcFpTbzesgvDtDzGfVZLThwbYRxEME07MQFmCuu01Hoyl81EP7SqlsM5yaBC8nle9vnqPhZK290M5yFOXtrpxfDui8VYNpWMPxtvffnvyJ3/y9vTQEc9inbcsE+npU/ARbscz64GeAvHaMzE8eVrkdiA/AhFJQDnHUU93j+PYWTy8Fto6Tkdbpd9lFj0Swzs9AApkOJYgP+RI9jZcNDV9SxqnMtsPKhOyMc+1owhHUaCvemUMx/k7Ru4ogm29k1WzZkOP5lIsYnsEeB1NtIheYTs8S1ahsaFJcm9o6LfljGYnUm3IZLd78EHdwMJIRyXCUzia+E6AAXvWtHtuFoHpfWAKzNh+FDfvO2r1Vql5TwVRLdatfIzLYeqjweWy94QvQqI1azxH0Mi4mnnTYKO5muuG8FjgI1ymzO+sWUt6Y1RKgmVqfA2UzjU9ttJ8sf6ryCnxxhhqCbKkvKfPuwfPEQaFRiji5s7PX4JyPpM91EPW+2zCZY/zgibOPQINnnYzUb06TIxhC0sWYuQB9H2l5Spaa9SS4z4ETKu7uo8QeeWv/drtle95z+2TE2hNQTlnC4BC0H+VAm/g6DtruokYmYMLkhEPaIbPSr+9lMJnBMlnBPGZbnocmxlr/oJy4hl0ra5HdR7PrKKBlubf9dz25/kKQDxY8Y3SZGmEJ63m1FFg8LTc8Yc1sUOeYmFQaOXfBsorewpVV04Zn/6ROdM/yT5fMKXALf/lX/7lozMj2FoKufCBGEJTJ1lQIu3N7gERYC6MUbyuVtzuV72RWnkE1kxUS99atGndYFJmQTw7UFjIp0JLY+nPbzNONXMmqDmCagij2QZzLdeU52ScLBHPZ82Z93uQSg+wnzYYqDz0Br2mmWupmrJcKqivjU2n1+GdPZ94C635qxDcWE/K+hYWmk/T59BR4S70gHYKTc33tbww3fydAo6UhjmUJGHNJTy0DtX8nbka13vOMdhHL2o80irEaT35zLy4voFsv80YeHLzjpmr+T+rs3RsbEND+AI06X1HRtZpyPRsgvEIjjEGlmHR40GfSxDV81fRYH4fOow3q9rtIdhOK/7oD9qglKIYjutmXKOk53PugC7fecbBC8lcOspfZ+/HMZzughazOMtrTKuhVu+MN/Gs/QTLmJ33HkbTCQddsNWZAYhXh85lhzXmxzAEW+J5NKFfvNt6CfXa8VehVDINLdcDH9k83w0d/bZ5CjMJBEwHY+ExXIUbC88AWqbAwJqfvi1PWpgHMK0uNDfOAnu2hXvIC4/W1tEnzyOQuiDGWc38SIDu1PoEtnezWKeY2iiF2SHbsgo9qKSEUIt849CCtK7rPSXmCmsMsC0LVjth2edaj1rpzZSYRtGACTpHsmNkQrl3aGeE7fx12Ewx0sY7mppcQ4JHMH8JyHnPKIgrQHrGZnZGD++vc9N5m/f2DGX0Yd4ZMugE7deTa+C6ymzTHwX8nve85xElwHMr3IIvWpqjVqM5OxTgGAgnhKKgmx27x1jPbB7jvgwKAvLcYXwEfM/vCUIlpQ9+OuGbw3Iew+LMksJHLOGnzsSDX5/5FCA/T2cD8xyAizIWrTpcYU8pRBYVERB/eFJ8ZBWAPNbUGsRbeNAsvKTFqtpaD70xgHtenNhf5USVbVsNzRZGnNb9NOiwcNJ8nO0+vw3NDl+RFfP/QllfcKVQS/yazLUJrcqhwsUC9njDBtkKHVhIhDutkE09EIL/nmB0PYXUBZ1WoVlF0fon9QT2M1kBYiisg1nkwbXnMwHPUQxjtfeaKoUKjP2u7ozcYzMH5reCe3tvjadQzDthYMZkfT3Lvy+X/gyiIzzQXOnDmGrtODIQrOd53ml81kn8pXCe08bm+1G44jCUBQXDkiudFD8uZGO8atI3LRrTVrgXFqiVXYVQOuladTPSJFr8yq/8ysHQLWsxrVlgILxRIvO3dbzU2WIQPa18Bognz7PB67KSzzjQ1b+zNMWzCU4fGL/6Wasy7KE8lnDc/HF8fyqRjRpQVMdJaCev/4ZzF05Pg8AmvH8DLywjSC0ja315KXeK6B0t8RElLy5j7U5JFvNWw63j81tl44bAPLOeceUlz0RfPBt9Fq6ukVbj5guuFAxUXiwXnUW2YQfCpEKFJWSvwzRW9pUXnVxvEymwajJYRt6HSbdnYBLrATSwTZg0SNwzbzFAA8g8FNbqW9/61kdKILMqRlnYMevoR/2vYhWjuddg8Ra6ArBEuKGOQjkEbOEoAlcFzt7XzXSF5MwpGqhHJi7UPG33E5buEbivIVDBMv0EkY0HAO6a66YEhd3H431tC8yctJKocTeewkBBL+Im8526UvP/mZ951/PFzn4zfKPNuQujEN797nfffuEXfuGC7ECDjvGkPOb6uWbiQzOur//6r7+U5fzm/IZprxbnmDllnM1YA801lbM7p8u7H5sNnmeF0WMfQNJB0UO9xyrNQ1HYDzS0FW/zoLFzA9kVkzr574gtJDnkev6Cfy5cPcrAGKoQaiROu4r5NX72xGcUd+s3HR7qCdc44+F4xhlTaLl4ilm/mv3HGCnKsWWSVHz8jn/QbutvFZqqjLSfZT42sX3BdzS3DXFOx4Y4CbYGQmaCZEk0QPNw3h8NWNoEIs9WgM3izHtg7T4WZQa9sdcdzOu/BQVNMMGJQLyPgirsYjHm+7H8x0qdvyOkxhtgidtp6zruppRSResQ8Pw2jL0tEW5gz/1lmc71lDJoo2e0NsALGiJw9lhqTZmv5tfD9OVf9zdE3pRZa6WWv3k3D/M7wq2HOHNlnaZP4xGMIp2YDOZhLBT7fr5WRVvPROZbM3fmM+/q/ymt7mT/rTRjQhuTLjjKYOIWs7Y1bOyfmE9jC8obzJzzKlwnL72bQKcRwAeMFKt3K1HlIrSDXyfGIzvI/gYZZedh9za/sWQp11qrh+cVBcJaP2hqFPWprI51PDOhHojJjIeWWl+1xqsErjhjj8U833nQSjw+EJl4ifl6igd0ekfz/1ee3j5Ym8FKCBcJ2UU80b2g7zTXlBdY+JM66ix1PIIOGdBic9bcuqNnySv1QF6oIfN5UQqwT9Zlc20PQjstEAy10/C0Lq6Jdo3BVQCYqGJu3H0EQ8iLSSAokMYOqskBvwcndcOcrKFZ5FEIY6WOQrORxbwINlVoEfCEaYmIp+X9lNueZ9Y4AWcOaq2XaC9rKkqxQdwr2LaK1dV9NUeFBYuhyqAqnDeN92HuC/8Uiy8cONY4QY0xfAgy86cvnl3i3/BN56eQVSEE79wGhO9/q63GEAaWpcLSbEprlVLhOoLAoT2di2kHvc38/vRP317x//1/V2pox9a1PgTs2sR4WbWMpTEY1obLq97QKUCP+0+L/bDCk0J6GIcUwvk+u6qPfp+ZQgeNNcNmrWUhudJhle2lMJqIcvZtxiBOIJZgn8Ij437wsG8XvLY2qJaX8Qn+7Bw2jlU4HB2UbksnPsbsd546BcIrKPQLtQAnVm7+tikFFu9YLVwfTG7wrVcE86QsKuAFIJvNYpEquDHPnkh148tghDJ3agSynF0EK2g090s5rEU5H4eqzLN4BSO8Bi5yCldrN8kG0bhvzdIoJHNhs6mJX0tWtoE+V5CbN7sY/VbYzjqZ6xlDS4Z8NkUPjptru5nNbxol0jgEz8gcNEjGW3H0JVoY5dr/tyicOWwqIKur3s69Zr71re77Z2t992+2VcGbTwaDjJFCcIW1qly7UVB21XhODC1e9cFXTz55e92//be3p4d+UmnYPoNDCZ6F8QYaqkV98Iyg6jrIaRsEl3IlHHPE5QXpnAK4wvMamxTlCM7DqHQewFl6+5i/5ymUecQfGiw/4eDxYD59eiDHu2KQXEeIDi+dHsTlPTx5pr4Oj80ctKpCgs73FELjaVVejTk1YFxotfG+SykuxAANz3fiBpoSLWD8+Rz1q07avsfnXzClcCzYibNLTWXJcBsH4uiAywDzd+7hLmMKghATIybBNZauuIQsDROyzycWkDFxJri4/whKrrggJiaasRV/no1QtrlX03umOSFEZw6aljnPs4llu5+eM40V2WyHKh8MKMgK+gAvjDXKijQH3clN8dyD1ho7qIdBEPm+gVkWp/UCB0qdLH3oB2VWz8WmrYEnPVtfpNrt/Qk1FD5b+8+1+n+zDcQpa64wlTIIQxdlfPGioY8R/tKBQX+8tlnfFlucNruSBwNndU8jtH71jEUQXv335SFlk9ghwJKxNK3B5SkQpylud/Dp0P54BqdQnowkCuDgEZ4hJe6skzFuTvp6zeTyFwJTQidK+tNnjKM7ng86P5XLw0en5HbiGbMpjdptxtgD87HGzAuzkdN6oVtrV894/vbZSsK0lEuD0frSSg6ucz/jxzqIyZJ75mFoBx+PLHgh7fPCFbCu9773vdfhO8XrCa1OSjE5xLirYzYSD4f0zB5KUy1rYkvQ+kgjNzhjEruLs8G95r5fdeTT5/krZXIa61WsYLBim8Xm3/KX6xlQPAeBr2J3HVOzB5ryW4IwTopoApg7dZfVoi6StSgzeLY5ptDNpXnTN3sOCJmtcPVPLETGkGdS/HuHPK+uJTmMZYi8a6fMwzxr1q5u9z2avdeKUVcR/ue2en/iJ2hnl2De0ByDgEfJM2QMWVNz+swHPnB79S/8wlHzaITgUXSOJXsqJ+cRtOKpeW1M4UqASKbZpXzPDCXlKOb/By0mr39nHO4Cd090P8BnFuei91EQsn2un0fBNe2aEuvans/bXuyTZ/bU5cnIqnLI0nMP90tcHk4aelI59oKmVuJAg8PWbj6q/TJm3VdovB7Ffm49hp0W3yAzXpwm1sArfSHt82YqzUsnaLaDdoWNCv/0yDqZEhbBgAhvAqMZEqxOTOJauPbOoxdTMLnePd83qNPF0VeWK0VSTBBDs1iHKUZYjdU3ngFFMP9vkNjiW7RmDxX7r7LgdiI2Qobn5N55P5xa/j+BIxA4/R4r9fmgE+9ozGUr3V3/nZLcSgEzCY5ap5ZcpwSMqYpN5oRUzM5hy44oIb5PB3u+Vobrd3X993z0g66qPPZ9rqPQpo+zPoQGD7fxkMYeCGuGif/LMBoaQyeHgvjoR29Pve1tty/50R89ahXB+cdKPzzwU2hcRkkCv4yO43vrCurJRjSGHbraAt+cHJBSTlITQ7hSWz8zuZ9J4ohyMD8CxALAx2/JAtpKAyx1rWOg6Xtr07jEs4GYjt/Oa485PvdTMB57lkhjVOaT4Sizj2eLj3bskqxhABRmqvHbGF+9jGkUQI25bqD9bY0pmDgb2aYjU4Fy3N5RAKpmWgDpjzMB4BT4qsE0HxzzFxMmLETbTSRBwl0qBkmA1YplDc27ZRjM/QNbzHgohIGL1BKqgJQmZvHn2TOmySIYpSADQ3BVsHCgqrEeuv286WUylupSguNmPutxgIAoWWlx5mra9IMCpKj7bK3z9dnWvDCIDWXTn+lbN7ztgC5mB2uJh9RDrHKuYqnApEi7SXHmCyz1QpigtOvvvfukgcoAwpiTZDDe5KzhvfvQ6ez8H69tPkOXhEjfyVCoETKNl8RwofBZfpfx8vTTt6/4v//v2ys+/OHbx8c4OOnuWIOziugxX6chcSiqU0EcnxO6OU4pwyc8w/Tt+JtNf4raPXVa7JeyWGUnDmMqQrOW7iFcp497A2Z2Mk966iMYfA+fWmdZH7WUkvI6z6jBsZU4XnjFOhHx4ofxPk/P9ukzC27+7VhOu89BgYzY4e8at/1MQ9vkW6Gh6QM+0WdZcNfc38l6mkaW9ujW3/aYwrTp4AhRwkxgtvVyCHsCHjww94JuKhy6gA1QNnZQRdIdhDS/CSzTEmqYze+sKJg3wp1FVHztCtRl44p6Jwhk/i1GUaHYIJJaPKNIEFKLtYFEaslRZHYxXljpGbhUfgJDtFCeOQW/EVj1tD5bkLatXsy2lHkkhdk0gW7WrjksLFFvs2tgPdGB2IlmPimE/laM11rsDKM2NNu4xpVWmdo09grMb/v8D/NLcGB+MTMf47dbu1ZtU6Kb0cfDnWebjwNnH3qXuZQxHt7CKImzP4P3ywTaQuaewpKKCvdXirte81FfaO7JSXPwexvWKJkjTnB6BQLIx/vXaWRHMPx8/xWgtrM5MSTzdexJSFWDFurjKQmAH30+n8XLfcqmTkoGv2Zjnf0LDLdZMxAng4oBOPuWGCqNjU6zpv52HL4D0eJtio3hW8/VvWDGGmTm47ddKcxLRymMFpVNMo0ld2FymYDrPNg7h+fUHSuhdHAGu7G3Wpt1Eyu8Opkm1LsuIktgnEDA4O7btYRcQ4l4H0vLGBrH6OI1RbQW7z4+0pgopmZW3ctkaJB5Hw3q/Z9rffvvCtRNmF0fgkk/G7foHpGttMyTA50apBNo7vsVGNxKCa1Zm1qUtUrNxVxDsc+7x7IfC7/BbvMoONyEiUKmxYxZ2d3BX4OBsm/sxnsIiRpGjKHr/hWsrKpDp1MCu56cNej4wT3X+QFpLPCDn+9AOvXmrphCKwkPLZ7nHz/S17UGCusVRuuu4cYhQF2UwCOZRBHi6iA9AgPmeQe/P/1wp/ekqV5ear2fL/3S27PZw4LPtmFk3faZ4h1PedQ6mqcGrgs3MUBAw9uARpubZ+/BZ78tSmFe/M53vvMo9jZ16xt9rws1neOCGwRmp1F5EUonwNRNfjFnGhos4/56JCAKxNNUWJY15tLn+eu40bkWhjvXTD9HUBAcmHq+H8uggpBAkIUDW68SKaQFFtDvvT+hFiZC4rqq6Em5zv2tkzPWdLMfmuv+QtpWoubQOtRCwRw7QOY3lvV83xRdGVS8HsULjWWMDnNZ2sNg83zwWg/ucc3APbXO2hwQ9K53veuRKpesyOagWx9W4oxBvxzzKdMNfVJKhe3qBcz7568d8Hsvh5iZAPX8H2RxwDdo5rTOxSw+dMJfzlAu/n8J8TNj6LKUGVfx/s7JuH18BNckDSyY7jin+eTXXx/eDXw1Atf9R0aS4Dq8Xhp1Yh416MZaPxRWky4W5HhATc5FWXtUDuGujEYMIeM1B68+Bfn06YJ1Ttn1/u/6rttH3/SmSQm8ZJA5BhM3iWTirDLDZj3FFCr4d1C5hs+smaxFsKN3Voa2esN8xziqJyd2+7naFyQnD9ESfgQa4bDTs+DsMylcbdZXMcD9vclvvnmtPwKn1rd7pzUAWqVQWIEyY/F3cYoHGhOmdV/r0tTjmcUGmxGEzYhqIJLw5zIag/5Ns7GLMnTOcOu01yovVn8PPtnNPDeHnkAhiIxte3nmtf2FlxqvDDO7NREyKI+Sm/vFo4yrfdRPsBWF6J0C3Swr8SwBYP83HtdSNsWCwXs9K4Thg16N31yjcYpkWus11YMRTC7P7PRsNPKK97739rof/dHbc5PMcCqog8bmGaeiK40fcIh1yIHyhye3g+oyAZNF9syppD4Zr/OAck+IpobDQQ88aN914+M6krQ7iq+jMs/9CJfHdyo9RfOaEXU9W4XUE2o6aP98nvIZ0+w7EKN4br4/afWoYnwq+mOuk+xQhKB7TerVTfP7XN/jAepZWGMyA7+LDXZXuHmzp8qz+76hZfzWM2m+aEphiHECa2XGaa2nQ5AW6nnEhQ3hTytcwyqtBeh+13tvFYbvtmIiwIr764d7igV6r/iCVMitlAjIegQUoDGA1SoclcHWn76T8Lx3yE+9lQlwsVo3ZmzO2sfdNixUJvBOisx4KXZ/va8bEf2fsGw67tANhkEnhdlqSGDee17IJfhyTjXFZR1ZdZMI0BoxAnT2qtRAoOzRo7km1PXZp16Td26LcpprrC8FUovTO0tT5nj+/eoPfvD2xDvecQjLY60mnXdghniPxzqfAdpm+DyiAHYBy9DLlZljM5oKqilXz9q+6AA0KKvoDuS4jRL7Fp7sb6AhGXSZmym3fe1RmPm8Ux77or9mj20oeZ51exiXkM56CPnUZSI3WlsIHNjSIX3vlm/7+8b0dlxPXEFl6O2Jl9au+cv+ohpJXxT4SJv9Cj/0Qz90HYROSJX4MfQM9Jr8pKpOAxcQdtz5ww0+A6QmzaSrI+QdGuHKXe9pVQ32UVS8ne4UJQTnsw/JKVxU5gIvgYTsOqyrR0DApGd3dC3gz1erpa7VPXfNbuZ84LJWNq2VzJKqIC8+z8OA0VvDBtbBXjbc6MvMLyhGX20Gq1XevhHUaKnelrjLjGcyxOrJ8BB6Ot68C0Rjjlh101euPq92mvGwvr1PYFog0l8fFQHwBiOoCqLfHXQ7c/ShD92+fOj0/M3HRjEF8QjPQzieArybyCb//1nQrGwWEI00x1MIHxtCT3z74I3sTToE3Rk/mDZextHXQQ1WzSIei7m3pvY7XGWwxxAYr4sMCVKguF1rHunztW8iBTnVVnLtsdcCn9zOQp8pA0MxfMXrX3976su+7JFMtJkrnut8WO+8aZl5ihZqaKixxRoXkgmGJoZ20IQU9/mgtXvxMXTPgP6iwkdjfQ0TDfY7DQH3uEIaVg2g4rCsUq6+wCMBMqmhxQN7GA0hjCE78QSYwnHV2BhuQzQseTtu7WBuCWfPqOtWxuQpEMjzLPPAinUi2zz/hcA5n8/2fBabpvLmDnTXwyiTE6TWh0HA0uy7rJWYAThu5nAErt3eiu/1JDoE3zhL6aUMaGf3lKZGW/O3mV7zXuugfIR+7j0UWuNb09D4PA8D28VOyDfTqxBmrcXCmCBJ8yztl6X6O3/oh25f+oEPPLTmzx3G876PfPjDjwjMK1unZyTLxDm/B9t0jNpALgcef3oAqo8efDI49oMHt9dNgsnAFWdW4MQHGD1zP16oxwLOmTbXz/0jkI8kC56yQLUswcAoh2fJWzzrKh2Q0GnVM9bm2Udg+l5NMJvfnnioMA+vPaVVGDzHLumksVPqNWQp/bl34ouTgcSw2YYx6LheYGmAgYLvPvCBDxwfmXv1Yhl9UrXJNM++F0P7bVMKmKTWcC3SxhlMIsbGsAQIQQ4TIzRq8dpdKC+/WTUms97IDjJWwehPN6CYUOcrd3dpd9jO/2exRqtb/O6tMH6LxRWda1jCL3ThKhjNqf8jENfVRS1UVXe2MNZuDVjt4J85K5y3vZydSQXnnzGDbEZwws+7ds3b1ocdhzCGKqzSHfhr/s+id485r6XeUt76AxqpsYBG9KkxFv2zkc770En7iX54N76nsHg4nf+O9xUf/ejtyQk65sx0SuyikZyRcMAr8WaPvm36iqe9YZ9p0kzbp/m/MhdiH4/sYHb9gitrUBDsR1kNBfFSsVTcoEZJPfRLAWZ+NP8eBVCe77ieyHvLD88+9dTtg1//9bexzZWixlP6QQZJAOimNSXz0UwVEkOhMGNpRB9KT/N5ZH2TPMOIQEed3y+aUsAgFUzV2HBbzAADK/Qz1zZbB1bHohPFhzGCePau5lpjxaZLLMV990QTZrOgaiHdq2vEpR+LdAQcJp+yH7T+Vlrw7rGG7em41zbEUyjEOFnS+tN4QQOuBOzT24o6oYKm13mf3ZuUPWKrR3C56zm3oc3cTx8qTO3vsLnLc2H6LfBFKdTK3jWRrPUuJULpzVyXPpvVcwmAGCXmopa8awr7mSfr2wyS+Tervrv35z6e0vzbxkLz2Q2EvKIGNQcWeWUsZDRhPwJs/zo3eaUdE/yFiGp9XsdcErCSBLLr+bjnDDAfAeuUyh+r2n01Ki7vZJ7zcHAGeVm9xztSSoaCUqDvyGR6nkO8Wgepzz6gpJSD8L6jHxTn7TPxIrR0GF2vetXtl//QHzoC9x97//uvRBqypspYAsW04Wtl3xmvvb6eReVRjVlzcIw/RiSaoKC2fKvi874vqqcwnf3BH/zB2zd/8zcf5yxgqmkV8gKmNGSFwpvf/OYDKurhL30HmGlwWmmLGIzVx/qqBUb51BLE+D3/oDghC5NFrIyFNNAKplmwET4TG1AUcK4pRjjPHoiiB9g8X2u6qQNZfvEXf/GRDYHNSuiYxFzmM33yvZgAyMyZs82moizk4vPcqngJTtkP871NZLyC1nICD1pvKb/z28ByVWKUUV1uigvDqt80DUN2R/f8xvIX4N97Clh74h9zzc/93M9d/ZjxTEVcSrXegTIl4iWgwXm/+BjvEp2jX9CncXkOhdBkCJlIgtRD8w/e+97bm77ne25PTOzrnE/7KUZAH3T1cMEvK7pWbWMpl6BPTGRgHArjCDgnmMsT4NFcdHAKy3neK3dsLwHdiVtcHmto/RGIa+Y5+wyODWxn8HsUIsV0bcCzN+GMnzj/wXuO0+cokOdRgE+cND5pqa89efWgrew7mfGNoKfUebsUP0HfKrigzZY76Y78icOCaKEF+t2SLU1/FvNkyKqsoMYSHhkjVXr/C2lfsDKRPAJMUMtru1vcohEK0j+HWYYRBfuKK++PZ2JWk1ELkIYudLLhDloVI9a6mcl3CIrdxN1DoY6RNFCCrnVtFNpTDbabWjpvOze5aWcTr5nfBle06c/8TDMu45z3DNHOv8ca550RuoSzNMxpxTM9k7fU9FvClECtBwcTL9Y67+lJbO7bWRGUUeM9vANrVg/As3b8Rh/h/PNMe0sI3q634HXLp+h/ayuJY6Dfwo08X/Eyc1CFXeu3B93zmkABww+Fr0CW1+7W6cdcD3olJBKAZTULtprPc2EfOQ+hSoHwfyT2cOd8h0LFR7rn6T1OjEB56lr0x7PPjXZXLGPXoYp3QikR+q53HsNlLDx8yMN/895GJqi1NH9POOt613rm2ZEbeTXZW9aQ1yIuwEC7YKvAeuKjytfA/ykOcsuBV9OGnxkVjbsxJPFrkRRr0nR4Hqq9OORYZcQXVSnUXbxc3qQrmnz48gykh6nM/7nQ3TlqYgmXQjI7huD7xgcIrAZiipUTatPAXMZDMHQz2VzvwB2ZQ/pKacl4mnE1A8lcXfnXzz57ncY1n7EgGisQxC/uCKtvBo0xNh3NPVxQ4+v2+e6l8Ay1+2fs3fcAEiPUHRlp7ljoiJECqitcOKTMNc3YXFsFY+0lKjwinJZHw2vBdLKheg0obKeLTjs2f53WVmMy86GsvZtHWtrEzDuWw7qrwh/hwNt0DOgjgvqM/xwKcD6BIEaIHaWqT7z/kay66XcFMS8iHgTI5pj79JHFLS5xbCLLdww/O4iPgLLUzDNT6ST0z2T9rAJ2xtijQS+lcPb14KvAp4XGrrIVp4dhvjy3Sk1fjhhFPYbPdOg22UiHhz4G3iR/qEt0enwbyq3sYRzOB6oA0mVQFIqda6AdWykwZhiUPS2xdLgrPTPg0PUud/PZ2he8oDxoAgYHo59ByPIYeGkUwLg9OxOopwtVQJuYaSZongs2IMApjP6F/cJf+wwMZsK3N8E6rVXs7AWauf2UqcSDuIe3T3vb29527KJ9+9vffkBDBLh3glU6lvandZBYBhSq1NGWG7c2hbQIewSLkbiq85lxsqwdDUnRNPNnxj3XjpJUIttclTb0VUyFkpES6njWtkKRxUmtQXc6t1GONgGBeKwvBT+fHoE4vx3ZPGeBRRZeYzvwZGmyPBH4L4HQI0zRGg/IfKL9+QsCxfzGcbzvhCsmfmCfRZXukYJq3PL+bSLMBrFHKoHyagLvHMoiQftLCCaB4TJcTu9nnnvQm6w8pUVWWYZDeSbHf3ZIi10MLDRezxUXSBoqRXdbcaUjftGxrQDrRgUOvkqsaNoRHznp4/C6/vAfvj397d9+e8NXfuUjCEGhm5b9x0sKIdY4Mea595d+6ZcuGWQnO7gRL3aPE3ioXrj344Mmv0iFrTf9olAKkwc+A/wDf+APXINx1u4wpMg8vLYQQHH/58vDPQZxxia42J3IMqAMn+4qBKGU2PtecMs8V6CZhWmiu+mkeLf0WUqo2Os0Lugc1v7zP//zx1yNlzDMjSG7y5mHQlnAt6sgBJ+6SYrgJ/zretYiw1j9NyVO+TSwVeilHpm9HVXAmKZel7k1Phg85WV9pt2zcjAga6ipzIWoKAkVI0dhUfyUGYXUZxeq4s3MPQ3kd94J885jPYR6g2h6B6wpzRok6JqgAil+egUOlW5w/wR6ryCz8ahplBTUo68PO3zRwnWovZP9WN3J6Lmscpb8rjWU3dDTl1dNscv075HAc8ppuP+grSgpNGtOy/9XYLX0gcb9/05Z+vK5ex+0NtfM/QjiZ5451mn4VUl8sDBh7x58UnicUjD20nc9/C24d3/Rgmfg8Q39McRHlniOHfRfVKUwnRsCZnkdLzyVgjo8gpIsaEKl+L9nsahM/FYarsN8zc6pkNAKvdyLOXQxhlnVLin0UsGmNb3RRqw2wmNcxoGHfuInfuKAiuSyT2N17528u//1ZDAMoc4qoXC5thioQrBurd94X90gxrMyL/XYijPPeygnwddawKz2wn1cXrDJPQNg0xeBPtcLvDVWUWhCP+ybMFcUeT28Mqj1088dB2LFoyOMPM07mpI8rV7ZJYBOhbjjCHjD/F3B9+Dll9UdIbKt4kcyjIYOp89wZh7Dqhd0KBC7f5MLb71BVYrGtXhcIR4GzjWnfo/wPl/6SPbQ5ZEtetUOGRC4Tm2kax4SyL6ysVYVhIMncwbDNH371Jd/+e2p05ASE7P5clotegiGNWJAUQrdvwBpaB0yRmyTRsiXfppl1HNGtnGi4dN+90WHjxQKw7Bc3WndN1BXnFCzuMWG57fBeDFuGQVMMt+DVFhY8Fra3bXOUMBYzTqCD44gGasfscP2uW2C2ixXZbPvCbXpz8/+7M/efvzHf/xwIQcuYnVI25Qv7ztCpXANt9NcFuev9aBgH2Ly7O4XQcR23xLYshmMz5zObzb0WTuYPeiEJ0MR9OztWs+eZ/f7XNeU1M/V0IfsIbWTCFTMOtdJYpiGNirU0d8wvvsoKpCWc8CbXYK2m9XDUpxruvMbjLZjU7VerScPUwkQiuPIZhrj5FSGB6QRS/DowxlwB/MocnfQ0lJWx8lsIBgKOd7HNrym+f8I7AosxeSmDbT13PKg78X/KswOeqCEc0YzQX3+55Gx6ucoBcH27bHNfDwSnzkVzgVTiaU8OEtuP/PM7W3/3X93JLy87jzDwqbBuX/oCL/0zANGFRk2rZCs9Ghl4adZ5yp2hqC5bqLFXDvQ7LF2n/70tTlzaM2/vU8ZnheNUpgmIIjIBVxZhiZV7frNEGCIK/B05v9OK+ZN+FgQlmOtPoL/EUvnDhaP+eDx852Jth+B4KRgdpG2Rvvn33P/O97xjsM7GEUwf4eZ7dI17hHC5obnZExXHvpJjMZXPL4pjbIgKBhCjAUDw5y/k5mDKbcFC9+WWun7ae2feWysY8ZN8bvPvV0PljbB7tzu7vKWFYQ+3DfvHSUMR+1+AM+d1mD1PGugANc1rbkWnl3sXeNpzXLjzRXea02c6VuNH3PI8OicefYldKPU5poxbt7znvfcnnv3u2+vOwPgYES03DmdKqQE6ngGl/WpYuisW/j1Ec/jtKDFBrqJDX1/OplMjsaUMip4faSRnorJe493zTMoGxDUelc9DxDVtQGt9POw848EYeuxHIo7mVcX1DbCN1lSD7I+guvgnp73Ytf6yIIxEq0nCNs6ovftARYSpwwYEeibkr13VPBA8Mb1yP6VU9FKhS/E/KJQCgh0BOBotp0pw1rjUczACpnsiaumNMklUm4UCxWTFo+sq+371u9vDKMChOAlOGsd6W+tekLBYk/QaZh5/irENs8pbl7FVNjA2BEUy75u61ZuiKiYK8+mqW71wlzHI+GZdQdnYZTCM+aj7zV/xeR30LRWYq3FCvIGlt2vfyzozmPhmtIB682+Al4Wz8c8SyvmSXYjZSG87k9xVoI1EQ9qTS/rpE+Yf567DZTCNPUKR5EdnswZWL7oe9buFORHHzM/j2DrNqtJIz1rFFE6PZ+gkNP5j6vS6CPPZvWvg29GIaG3a+PZuY+h1r5yF5/54tH6PRccx8OgGFKC4jO3PixV8TSezzMokqamUiLm/sGsz+zh+aqvur36XMPKCooc5DPvRjvW1/x59qZTXvAOKG+om3GjrzvGBm6qLKC8rAH5UCP1i+4pzMD+7b/9t7fv+q7vOjB2FtlObRwCl7q5MzwI5gZcMLeSx7Q2hdENcSakTNcAstr1LNtCK+6bGiYsaxg9F0+/7Fyc6x3lKTj40z/905cCbPC1yq1ZUAiuFvEstiDpxCQIUNdgugbEpyE6VodxSH2c+R5FNZ8JfI/godSaqgkLFTQzN4TaPHuUv2MIzbXx8Ep62AylN+/GPE4og+O2GCFlgX54dL4zLu+d57Ymliyde5V251kzH7NxskK8+0qK25fprTVlNa0xF3PlfVrvr3KwptNmDFO3abyESUiYMbwi8ZlHDpLJBq1DQJ2Gx5O9JvN3eSEpB7IFyBWIftjhK53zskzLC2fhurl+RjClL65NijkS9Io5LOOgCgf97A1uU6BO3y/PYMFbYKiDxs75dOb0QGXm7hh/xvngwYPbB9/61tuvfcd33P7gueFTKXI0Q6jzoHkHF/y1aoRRGPhtrPyROQw1ngZvg+xxwBRlMse/FnIDFY2sMZbuk2qDwrxo4KMh5hE0I7yHaWHTzpudBms1EdXcFMfR6VOozPfz3TCLVNQKjcYlCC4MYIPJ/J2+jYBl5VI2hVhqFWDWBqBh13OPjWVNIZs2ChFuD4ppUH0ayxJDzDsbbGwaqL4ScPUOEA0FwsMg0GYNhsBqAc/36jvJy595HVgJPimDy3x4p1os0/S/3pmxsbDMVwPi7lUvxryx2JvxZV3FcKbVQtuKVDVTB57oUwPnc6+Yw1T4ZYG1Km9TigXUze20ezEQsYorzTFYM88CXe3xWU+ZeSrVHnGlnHhG6R50OWs588sQOs83FpQ/sPTUITroK/suqhDATqqddrPXAbucKat+G2x+RPMVNzgzj17z6lffvvKrvuqyWKdY3xTuww+XlXye2Ha9d6EBB/+Coc5/d3+Bd16KYbyI8eBPSOvYEZ0Deg7aa02vJ564PXOmET/95V9+9Ek8B0xTQ7Xp9mROIZ+mkdvvM88eOFHwd57vuXjAfiCeAZqY60a+TJZiYcV6r2QT+UQWfdF3NGvV2jTaNCVnQTJ139y3se3972ZjbPy+70egTf9yHeHPOmsZAxvrvGv6DwboQduFmWaBR+uXuXgDzSCg2Bps1V9W8rEh6cQXeT57o9Q0MAVLunn9tVqKgZdoi10bqz7Oda3u6L6OgaXegKmx+Fg7wpWQpOSkiyppQgm4f1r3n5iz7r4ulFLIockDsqK2S+3+Ql/muR90Uzffc7qGhSTmOnEvJbg9q+9o9tM0+zusc73XQqJP5nOMpummq+8Hj+XUs/JV5w50xOKfchME8AX1rH0Lc0azA2+myURCe8chPacnhM+avtk5pbAuiIl3IkFhFGmOy7ylT09k4+EhHFU3GGv+VApHv6YvZ4CdUfLk8NUkYUwSQNLbGTAUL4ue7NpJDTue4Zp6700dd73Ehm6sbHkTJfgZPp1ftKdvfkOvO2vui6oUDHasnB4TR6BUWIM11JQpAxBa3UWKwVlrFUAbZ4Sbi2OIYRRPbv0kMQKY7jSLZhMXoS4mMgph3HsBVR7NtBJ+8cZpYCpKQa0jbqXfPAvUYe6aHjpKoQxXhQCaMxfTELzMhfGaas0qt8Dz0Afr52OMG16pZdV0PuU8CMy51i72t771rVfMA9zo3QwKcwy2asaFDA/r082Gzra1vuaARViMd1pzwxsPsPkPNNDYSivpWkf3ofO5rsXT9FvfBmIoDXZN5zmvXFlBx7qkONzRlwRdL4H/8OJHBMYIx+4RekQ5DO1NnyKYrxpCEcAHXCcrSTD1tNAvXjwhHUqhWVvXnJ/K6PJ+bLr7zIuuOZrnMx76m8+XTnpzhKyxTlnsp8/KAHO0pljIUyf8OErhY6fxQklVKTCYmtTBa6UEjKt8i18ZROZcEoKNnGDWxivUJ+OJ8CbQyAUbrrToGnAvmkDztBn4ZN6MYmg2ywxuXKlhgDe96U0HljttJmuCsoQjt7ublLZVS6HU2iLwMHGtdUFELpbnwqLnORaCYJWqWNhDH21Gk3Ypj5iy8htCQUgjCAsvKL2N4HrWQBWffzewROHVUxEotWlwPpNmpy7SCKxxR8eL65nTPmA0mT21wHlaM7YG4cajYsWzwPWvedzTWMOEQhXPNOsgdtR4kLmSVQXKagC30CNhgbHECAj2Zv1UoaFhaa/og1KpZciDlVFHWXlmsee9oajzbkyjpB2vOGs49x9nhZ9BcsLneOaqI0RojvV7lZ4+m/VipMgQOjyJliJPRtBv8JayT6eC2VzOhjXnlzju8ogJnIbQpJzW0j3m3DGapxIyngv+PT2Fg/7Oiqrm/UgvPc9UYEC85iMf+UyV41PmEJDHOdYOvBlB++qHhSOffv3rb8/lbBfQUYvQTYo6L3lkWIPNhDw+1hSxxE82kzYrTZyAnOk7GaXOXC/d1aupAVMk4kUTUyh+W8FMyDWIJ2CsnHK3sBcX707QYyCnloXBe8eOvtOgtVS26zptu4DzvZiId3Uxem5r4QaCqsEjfZZ22jr6LQsCb6wigWHX3exnz7s4DWt+iFfpDUHL+dujKBG1d4CbeD3mY5p5Q+gVwsU87d2g5HgwTRue/ztoyF4BgWIH1YhFaYQ6oSvIzFhoPMX/Dzz+zOBSn4anxMqrBzGtm+Ka742GKBMKe74X0OYF+R5zT2PcoDklLYphMwAo5ZmLBmIJwGv9G+R2mH129x7PP+GWQ5CcQpgiPZSHNM+1MfOYkwVLem7fDVo6AtAnbHT1aRRRNpyZ04l7HAHg8mGgyMPIOE9Su+YmAvAoxeHAnHOzHgV9jGGyeabA3Vj2Z3mMGXtrBj3z2tfePvJf/Ve3j/+O3/GIAeN9pXWeOjqchm/MC+O3Ka27/MQ9uLuwnlhWDbOeUFn0QKthLPbYUh5fdKWgVSgbfAOjM/ETNCYEED9mqWVXBjVgrjU3TkaAia3GbHmLvVOyk8ySEnDsRqUKmqYzNtAqcwYWX/ecy9frYezzV+G7QhnTmvbaPpsrymAat5Hl0lIXo3RltJSIGtiuVS3YWUIm6JpCzALWHzvW1bviJcxvgmyYZ64ZpWDs8/v00byw1gnXCqx59zx/MxrFaN4YJlUwhHiFsPEwRNDBtMJMhABDYa514hqPTZyomw95DejQWuGPpuYSKLLyKoylWDrJ7OKvnMVM6V6GDqjBXEWBe8YhcHvewLY25x3Pw+uP8FAMFjz/rAyl7D+hQC/hm7TjecaVtBFP5JAnZ+AZ/yln4fhRiuEwFM6ihqCnRzD8gRe/7Mtuv/Kt33r7xCqQaJ1Y9RIiGHLorJ58PXX8D7q1mbf7jzpn+Hlnt9mLY79Eob4aQc2sI2delEph2jD7f/pP/+k4Z2FSPMERYxU6wxZhKIVRaIEljQAaVCTMps2Ew6otDm3dDKMGLOcZdocS7gKT8sMRqRIdBKx3zXU9Qax59UNEjSeM4Jh3zNjFKLq72qcbpjxrntGsLRVMZRNVwCPIabODegrvzdintMa0+W3G0o15sxbmx6lR6rSX2HgOUoNZzn4H0YEACbjp06SuylqyBtPmune+851XPn4FrzgDIe3dhLV8/lpNIEVB826cq0cxvymWt0utsMr9JSzMf911jM7YoICcrWud5zNMPs08ikXMhyKkQOHNwzfHGoDS5v09QjMbyCrIBaWHMp1LYB4PRZCArft60P0jsa3zmcpU5CWfOfT+TE81h1Psbv5trYyT4UA48liPQ3vO+kOHRb4O6mkxP8d7zjulhF/rd+6RoFRkXw20NamtjNIPvfWtt3f81//17aMz5x/+8FUWpfE7MkEW3oaX0IN1HxkmTb2edJMfGAeXUls1r1qufqBf9Evw19gG3867BKal/79oAs27zeBH8I91yiUWsGOlEd6D2TlkZ67tgesjLGRzgFW4bhWq85sJJyga1PKXNVsGaMCGlYnYuqO4ZTYQBu1ewUDwsSYwwIxjcExxAWWqvds73d8g0rRHGOVMk9zEhcAEtyjLHe9gnfd0PAFmZS2auVQsufCbtYDrzvsUE6sr3E1ACJiVvbOMxF/Mrz7MNc5D9huBbe4psxoRVdrmqYFbAsF1WiHJZkh1g1w3F4LYzK/3tK6U504ro9cjosDs9fn07IMZAXEKh8MwunOkKlqAz3cerh3GDy98qCiyAY4Qw7tbkR78ljRNG9suz0K5bPGZs9KpchtoZMphoNMrIHpmM1lDfai3KIXVOI/9D8tLPATqaaXLVLoSTL7sy27v+9ZvfWikvepVt4+fULDnM6qsFcOT5ze0PbKsZVFsVpzPnLxI6eDVeploA2w4rV5DIeINabakDxpxHdohX+vlvuiUAte6DMRSJLhZmALQqqgqfyCYyDonNLpXoFkc1eJluMJPmJNbX4hrex+eL7is1s60poLBBivYmylh/IQvYuvOWf11jz5tN9N3DTJd1l6ES0+Iar9GWHPhm0/vPeZK6YmehgfTJzQqlBCjfs5zMdkIt2bXUPLDYJe7f8IE9g+M5WWebSIUaLY/pIq5a1Frv0q71/XfhfWajVXFUuzYXGwlcO/8jyoW9OZZXccdG5vfwQcff9Wrbh+ZDVSTNeUsgkBGj+wads5xsPaWzL5aqqr6TWbOgdmf0NMj85pic/5/vWNt1gNbNdvnMLbiheDBsfrBQJ5dOsMbFPZFh47aPE9bG8U5z3rtW95yeQkMjo++/vW3T37bt12Q54MIdzGWJqRYL6mikkukihoPxTDyCx01HoUWG7cjg3ossdZ0VnPZ7MWdnmpulOKoN/2iUwraN3zDNxwbhOByFnmYfoTFfFQlbTplsbxpcw8hQsASaLVypskIsQGoWHkntFvELRY8fd7l5DNF8VqsjPCSUQMrnnc5/pLg6E5IFvQWUN18Joha65jicx4BAeJZc7/igZvAQBp2gsPxmzdNqSL2IXQKlwIWA6lnUle5QtizZg6aEkzwzjNAYIQo6Mqmn1rXvDe7xG2G5PJj6O78ZonqQ4UTI8D6TcPwaKLCrtABRVaGZsX1vnog4g3e5bu5Z8YNVpk1BL+h019/zWtu/7/f9btu3/Hxj99efx52f7wbDZ1nIB9r3yMtW2J7nac+rUYGz+OycOcz9CyeNtfNelr7lrkQxP5stfyz6/hYhwg/kNEhnLNB8PnavGs8jqsW0Bm0PuCj173u9or/7X87znWYgPZ4V4cnMFWEz/kd2fD0GXdrLAk947FN93gHPaqOgP7cR4mg87muRiRF4VnWYfpDURYaG5lRY4WnRXkyTmQDtgrBi1IpgDEGH6VJpxUTl4JIUJscFjVincZrAFU0OMftg9fC22qltT4ODd7dvhXS85lJdh0mnkYpHZObswGaKVCrh5cxBOk9ILFZxNYMMt4qAgqreGF3+XZ/RQOb8xH/2LtKu1WfomM5g3yk21LG9bAI9jKGsVUA1RsyJ/pKcFJEAnQENsakWHhtUnfbV4YFxYiZ2nd9tc48Fpll7t1MXAE/xkYt2P7b/JhP68Pz9aE0G7SmOIyRkh/MfQThUw6cWfWDjoyf7EDedYkuukqA+Vij03In6I9nDVzXs79XvaBjBurdnJZ+odJmQn3KkZ1nHaQr1rZqKbV/hV52M9fzrIMXvuEbbg++/duvuX/FQDgzh7/2axfiYG3QgUSFV57rQHhbg8aOuk9GPA5fgkZVJzWe7tHaCo63MNePTNzIQOEzc9VgNXmz54YcwbMvWqUwHZVi2LSuCtnuVDZhykZ0wxYrr1byjiF0UmUAFC+t9QV/83wCF2G7rptXWkyvghHRGFvhGNaq9/M2WAGCq4LiiAMTEnwsKr8ZY72vzoHvGzRkHVMKPJH+brOMjTUw1Q2/VFj205TNpgAXsqlHwaImrBG8NaOIKQVKHoTI3S99bXyfEjFfApPTWHWNv6CJ/Wl84jcEdhedgjmbvlooisIrpDT/7w5XtIIurtLYORfgeH/2T1QpWKdCjNeO4fltvp97lpXfPh3vkw47c3Pee6zzud76bL2OYz0DTR21mQItPQKD5qyEQmrHGBtQP+f6KOI3wvwNb3gIZ731rbdPf93XPRSaY4AN3ZxQb0vrgJwqD564EyNDM1UKVQL4vDTb8aNr8kQmYufWPSoSPF9sSCOHqiigEN2fsONoL1qlMCeNjXD5ju/4jis7RCS/mFoHVChnYATYNiFazJcFSMAICM//q1i4a6zr+V6Qt9ZUN5fUsiUsr9S5xczFEKfp81gDrhFn4ZLWfewubGODFVIKVQwVaq106vta6wjK3PCyBKcIwhmf8ySm34Q0OK6FwuajL+AZ864PMPb5v9PsWFXG2J2+rq2HMdcI0k+jACjVBrGNmULo5r663o0H2EDE+ySA0RQPZDKojFs/Mf00ygwdzHvrxteg4e1tRuYpS9kFNfJ6r30Ac1+gvSfm+zuF9w4ljZ5P3rl3NOcj/DdjAQm2Oq53JfbDQ5iNYAdfhdfEG3p2s2wlyk1KacttCx03iFyI86CZr/zK20f+x//xM3DkRz961e1qTNG8NmbXZIwnU8SusOuOS5qnax1yNC+UoV58FQ/aICvEx54vbbTKo8qLYSbzEZzdlNTGLV/U8NEQdnftyXqB9RN0tWQr5GWybA28g6qeVQu0exfqTczv0jMrPEsEAqJ2qXZDS3FIgR2EAO7B3FxMFsa8z5x41sVIJ+Ep6la4wRjEMebawjqFyQTwjafpj/PdMNCswYU3n0pvn/HsnZiBu905ak0fUB/haH0IXDju13zN11zr2JowdoXLUuLpdfd3Y0HTZhw8GjEoiqFWOWWo5EaVUoUJWqRUWqYAc05W3bQqj0KH9XQIeNUyW8RwG0TeXw9y7h16mCoAPzM49q/8yu2b3/72RwStfQYEK+v7sHLPaw76vnOuhfgBz4v3cSjSc1PaFdheHt7BRwOdJj+fQXfMx3xaxLBHeuK7swz4ZAMdfYlXf1jwo7j/0B+6feLrv/5410BpE27+xHve84hAZxjx2vUBv9cw0J6LATD95jF2beYvo0EgF4/Nmo7xNIZrhTz6wZcg1sbfPlurHGpzXz0bqe0z/uERpWFetEqBYJ6OzgaqsUDvpXMWhqB5p8GQCeSNv5b5vK8u8079q0dAcNa997uNdvfSV/u8jqFQFiukBIrwqrB8XEuJ2BdxLzjVQGZht1ojtZJqGSHcnqnQ+WhKXSGWEuElPFKUyxzoV70SsRfvoAimFf83BwLe9SKUkTD+7SJ3PhuHwOTG4n7F6i7B0922KYRmzPPdJBu4X3mQKvWukbXu2lAY9Vjq8XmfvlCAww+jFOb79888jWf8znde+wYqyP29SmcnVdQ7j+/PeXukHEYPw/H7nWw3pbMP/onRUjo/DDvWuHMpZo0ckANGXGeOH7R6ximeeOMbb0989Vc/VGxvfevt2a/4itunTgF90NVpKG6jxZyh7aZ8ozOfT5+0B70olM04ld6tgXPJBzKkMq1xv64tRV3e2nAvQwudu6bPBJOiKRAXWdmEiRelUmDtzxkDrPlOOuYQrJV9Mve1kBQlUOYpZlurlqauqz+NAO7CdjEsgo12R+bHmctfqIkgEWNgGXfj3RDv/D736+P8v8pAVpGGwSiFac10oYyav218rQWF6IqFdw4o3+723hiqOaxHJEsLge600ApYHhRLuwrRXNZisqb6yvubZlNXBXsFMq9uLCXPpAysWa+9VxCO8VIrsVBdN/nN32LI5ojiUidn1tHv0yg7HsCVkplijJSTOlTSeS/Y8xOfuHZDH7QI2pn5S1G6zpX1GUFdr/lk0kcw/SMd9fxJxtJlZJwG09RXmtpCz5xCcUpQMz4OzyGe5qXAR1muXemXsXamrj414zszgh78wT94e/Dd332s66s+9KEDIhI4bozI6Y5NUhkLnjEyGzfRuPU0H8+etIsXe/Y3oT9r6H32nig/YV8VevNcPFJjtOVTyvPkoCxBxsy00hpPg/fZzEl0J9tSheoXLXw0bbyEf/Ev/sXhPjuVrdYQi5IAlDWCCDAv4dJNUSa/UEFhi27MmsnvSWGKrhGelAphiLm74AgBTl8MsIKGoJJFAoOU4cIy8lyMNAs85R5APrVEqxSrnKaB3qbNs2USsZptFquHJUBmrqsQmlHVcwkKH813o8ARNvd67uduG6/5IezFBurtoQMeVoU5L3Heaf0ZBeCf1heinPZYCFNB65Zznt+brltjg/dj7QgIBxHNtU2lnrV+y1vecgh1ez3qlRV/3q0CaT7DD7ND/aCTX//1Q+gd3lMOjT88gpTJblDafPTA+suDSPntxjiO7+f+mZczNXV2BQ9UdPTv5KNDEYyiGBo4vYdjo10Ov7m897Mvh+LPxrfDYJjrv+3bbp/47//743lPnXPaSsqzNjOfUtEpXrvF0bnkFhtgNfyAzz8WuIghCMachocZIeh8aH5kmXin75vCTRYU1i0dThNXxMct/lnjsTJMyiz+sXveRuG51imDL2qlIBA5nWZJNYDWzSK8AoxamANTzkLubBXXYfpp9za51ZKcxoKuVq8QGiVG0LQgGqHlvkIErL32v0HmvrfQ0lyDsLcLWguZ0qtSYjnXQkRsnU9zQwHpm740dsMKkyqqNPTO1jDHrXBbRjInhCLGkE7qU0bQH5Y0l5nxgB6aZttAdb0j/e1amAOC3Lt4hiOIrzz4KMJ6BoQLD2/uN1+jFEZoyBuvgLZO1rU4fb0l1/IeD+H6tV97+9R3fuft1T/yI7enP/zhRzactY8NPB/vefiyz3hCUUaFMy56SlZT41QHZHQWrDvo7Nwz4N/z3FcEj5/+HeNax98eQed55+tff3vi9//+h0HmN7zh9uwUOZxnzxhWZqHAfWlkvpeIQJl3L47rOrbtMT6IhyzhYvqKvsCS9pOMYlIKBu2Y93rrO+aG9opw1Diw/p4B1pIybZ2GNvEqFMPmWinoL3qlYDEUvmvhKC6RBe+kEE4mo7tvC2cQ4I0PTGOdVdNiPoLdohSWwoj65v6Z+Obp977CYYTTzusnZKrA6r3sKo11QSswak0UXy9uzevynI7PvU2xI6xZdWIbQ/zzIfRBQt5dJV7hbB7rrVhHp8fxaEZ4KmuB4Vni8v0pzVkDdbP0acc8CLLNnJi+AkVhvkIFw1RTVdb+GXtLzDMYsIFk0AXPYKw5z+2GNc9oTMT/0SqeqUcJInn21a++feKNb7y9/j3vOSzq25Qp+bVfuz03mXzZd+J5u8Q2qOkIQKeoXPuEBg4DKF5Cg6UHnc1zz41jz6KzHfNxCiBvd2CPiRmeG9WeeMtbbrc/8SeOS4+1ykFa5QFra9+Q8jOg2pEtaEeBQh7/hh2N71PJTGt8joFifxHjZr5Xp23WlnFbtKJIAaG+Y3AtXFm6KlRXCLDnjJAfNYr0G52/JJSCNoQ9lve4v40XUBTKxBooC6yLuoV7CbDehe+4grwKwvU4+zbBpGYP9Lp5nqM4CbwKGZ5KN+bN7/cWvi4iQqmwbzll1olcZoL23gdOj4nu7REoRDaNwsU0PIN6W/NBYAS8o0brERhHd/yCZ5rVM421JMVU4a9Ze79ToPVaKKBpsxbcZszchonNGc+icYXCT5QdLBacMOsx/as7jy7rlRUXVqpl/s5cVfhvem2rMEBnPZyoePa851P/y/9y7dr/xV/8xdsbf/Inb2+YrKTxpnJmyEEjd86LvuZq1jaGwfz/GA+I76RrH3PxVOIQ4yE8e3qdSmOgt8vzOaGkX/vO77x9+vf+3s8kcsxc3oEl8UVjivUUZ+wgT/fWACiUWwOs5SOezJ4fzylvSHgBGU3W3NQ4ohQbhK9MqOGmX+bPOxiM9eahEAwnsmRaU6armAstF45+ySiFn/iJnzgmg4CdhrH25IJkalVXEHFpue8WmIbfrjhrtfGHe21ba41FDGFUmc04CFrlmPUPUxRDtPCFf3zvPYRzPZmmabK4WZGetcs7mBvPLvFgWtlVhdxqdRcqK2y1y4tsBsCI5phVjXCNYVp3lNbLayC6CpF1b/2727kB2ekza9E4mjHUDBL9bj/EXKp4/dZ5QyvePUbPrl2DLgv3Wb8aOIKGrpWPbm1ZnrK5Hsxaf8mX3L7yjW+8PTPHyX7LtxxC9kv+03+6PfWe9xwxh0/O8yIsW2paJpC1OP577pA+6Df5/K639+HiyxzbeVRmPVNfj/6OcPsjf+T2xBg7xviGNxyxjwezphNMn6DuiQKQB9LA8bH1FeehmDYCUF5xv0yzeo3ap1cNq8YDyA28b4/N821gbfZa/8246bPR6jXn68Q8ULO4XKEwRhCa7v1ofOTUS0IpzGAnWDZMUwvTBGPKuvcmspaD66YRVs3B7/M2PlvohoCYhvH3/6sUmqWkb2PdIowh5AoWgrcQDcIrkbimgmpc02ZVsbIrsN2vP/U+mmWh3x1zFU6D09albna9MwRdoY5Jy1jTKL+O1Qczd3c14a0v/bs9xGYFUQzooLtLMU4VzBYgYLvCNeAzNNXvQTktfoZJGQ4bxuQhFkLbMKm+8fgEzpvC2HlmxU4/jhPEZnPdeH4TB5q43Wtec1QS/YRDbebf733vIYjBOdr8fsFM2aBWZXqkkZ41i6443nk/RYDmn/iKrxh34+HO42/91tuT5/6RK1MtCgq/NE2Zd9RUS7i5d9fjbazC3KPvvYGx/PPcWoPt1RlPdy17Z/tQXtyp0JSH60rrhVgbo2Qc2KBWeG/DxlUIhYJfEkphmklT+rguz+C3Ds4pFm3jm2aCMCNmq0tfyxx2DUaxuDZ9NO+cUJ5G+DWg7RyD7sbuBrdp3WimEcx738UI//E25u/8X8B1IAtM3+yYuQ/DVMiYH14JK6nCD/E01lDFaRzbE5vxSBCocmbNaL4XqDN+AqyFxcQv9En2kzMUGhsp406jFIyhpb8LI1l793TnpwwT7+et8H7cV8FF8WBmdKQQHwu1J/IVG585BOegpcIXlOc2BrYiqRJxXXfpz3Of++N//PaJcyPbK0dAzv1Ttv3v/J3bg/e//xFrmUDmQTTeMhCSFFclLa4EkXWW9bS55jVTeeDP/tnbc1/xFQes9KoovCpz71U+vWs32XctQ1NYsusgrVfCApoD8TkjpXBSLeon4+XO/eaFHGA0SEbA8w7PqafgXfMMPFoEoO8tOlIoqPGHIgMK77XsCUVCXjIuwaYvGaUwAx4CmINVvvEbv/HCRwsR1UrjvrOa6tb1Ooxa+GRambQexLQSOIuwlhEF4j2CQCZdITXCd1qtF+9i5eh3dzm/8Y1vvA62mYbA5zsKBI5I6DZNrTAUAd84DIhI5so0eD5cVgZSrWHK2FxNf4wJdFFrqZ6H+zFiCRgjO9cZvAUrn3nwHvPaQGE9B4qvpTam9awF63lg8EknbdxlsqlalVRfMWAZGYxwWObJnGuJDaUHKCH9p8Qps9Lu3omPnuZdhQ5UUN1lTZq4wXuZdvTvpOER1k/8T//TFYx+7jyy8uNn4P5L/8N/uD3z7nc/oggovfnuUJRDH/jDOn3Jl9w++t/8Nw+vH9qbPUaTQXS+Y+5BH9Zg5kDRP99VYeA9PIX+u1PXepUeaoxZe+eikyHo7emnn76OaHW/ed/Qn7+MWu9E2/Ob+I8kisYlayAW6fAe425lhwaLJTvM34kh4VNKccYxG4Odx/6iL509rZpxBvae97zn9m3f9m2XNi6BY0rCzQSwaIt3u58F7F1dBIxNGNTqdm/7YCErVPq8Wgc7qN3NSdsdtegUwgjG2SIvD7vuYKEyTOND4BRnLsGaHxAKK2oab6VQUCGOrcy8e5oxzXc7eO4+DIKBq4DNoaCd/lUxb7imytZ3xtDyGJSL31zL4Ji2ceOOE+5cRWVtr1TMs4CZlFO0Uaiu2HIPN2LtFpKsNVdaKaTAy2WIEGoVjhQq2jJH5row0HPf+I2P0NYTA02Mdzie6lRkVbLjjBsc3kc22R2wxSjT+VDQr3vd7faN3/jw/6MU59yHobHU1Go6MbrrHhbK8x7/FntvokTjM+Z+j5tHWo8LnXzyLLpZqJlir8Ku0C5/VpEwtAolVo5sL7seK+XWdHD0qq+FdZsl5dkSNSAM9eBf9J7CtLFKRjH8qT/1py5C0zAhaxqRl1AacAQ3TGM9TWtMopZqrQ7ZHFU6FkBfMBPCpXg8T7G7uW826DkpjnWKsAgY9c4Jl54XIYBbxWI8rE+eA4HomXaJc2/nrzo7hcocN9r9Eua0RC3zBTFSoFIC4eY7blNl02wd0IaxCtg5YY3SKjRVA8D6gvQcDkSYd72sbzeyEf4VGu7hyaED1hrlx1uZtFlHLqrxZO7kh/dD8LQ8R+McoBACp0K/50NQECCNKnZe8ViJ4NMKy0JTaIVgwVfo4+Pf/u23T4D1BhoZ+p18/VFIQ1OnIK9wo4he98pXXvWBFKYz1zbzDc3P705SbOytiRFoyHsqlCloxgfl1qQN88IKn7FaL8ewOlfkE+t8Y/IEgrFjcIWpKrybXGINChM3q2l7Df7aG8GosPdCULpjMrcQCH02fy8JT+H5YCQwgmwSgaHihiWALnjPWaCdpzUTZ1qVAuFJ6EzD9HUZm+3SQG7LM3Qr/9w7QmMWBqMXD2+xMB8WDCHMsqyl0lzsVkWc1hRYRCIewp2dawceaXG8ejLuNbZit2ClKjWxh2nWhbdm7SiKZkcQXv4ObGb/Q63cHbjDVLV86k3shIRtZbP0plkbwl7/mwzAg3HP9M+eg25yq1dX42V7dRQxetSn7n9hMZcuN4zCS+H9tIzCfBT4K8TVwGWNoml9Bi+777NuaK4eK5oAv02fmyUlMFrIdr63s5iHj8+sqY/m2eZxGv5Ff1fA+1RmZASEofAnA8ycP/PMM49sUET3pW28ij7cv3lh3gtKbuZR4U7zUTjS3DeeVePNnDcmUrmHBtwzfbCv6yWhFAqlzEAGQpqc33F5aEKLgVhM1HbbpnE9EdPO+NC6CNzYeicIr+/psworFc6qiwnX64K41+5k/bC4sHlE7xB6QgNksHfTYtjCTIQUInEfAtaHuqm1WIypLnL7UryXpVo8twF+/Wo2SLOCpPbxlgRcG1AkEBpHqCLzXl5Iv693Y570ba41J55n45mSJjUmeHUtUGgOOl/19roBsWPxe+EDFmXrW1Vg+Et4bBo1zgY1CbxalfVQKB/vt5bWi5HiukIfVQSlQYqvnlGzYfYzKNPScg2wKpRm2pgLz/LvzbM1FnsfS7zyZJrxa5sXKnt6v/kxZ4XHmgCij+13Da4aUtPMb/l731uj2bNBvi/qgnjP12agUyBvGHFSVKv1KxA2zldcbYiPiz0WXfFUxD+t1kePxdxpiIQbJVPXbtr8VkuSlal/IzwIAkQz9woOeh+8Wf5xhRDLpLtgWS8yDeo57TxtwrGKFfGKXTjYfpr5pvh8h5G4zEdGy8I3MVyxesFB99/zkGRuFDIwJvBQoQXKvOPzfZUyBjHXLDdrx5JssJl3wGOZvtkQxSBhVRub55WW/WWFdtNeBZ1x7aymCg+GTr1b76sFCOICyeyd8JIMGp9p8NMzBP+9H5zWfhc+wX/lGwaa3xo/quCibKaZ0xoaTS4ozFts3vx7RxVoaaRrXeMC9PjxQFhiQ3hf4N6812stXOo9fZc+bSi0KAQF3VgYpV+oqKn7HYPn4SkyDrz3ktrRrM0k/MzP/MwRLf+dv/N3XlvXZ6AyUDqhDUJWILrOAhNSFtQ9BMUm9GnFkS0O68m7CVMFsKq8phGI7mmVw/kO09Ylbn88YwtEyrD7K8BKVxrgOQ5uvzkrFt3zFLpZjJLkCoM4CMhadZhQ+m5hEGOdZ8N9Eev8X2kAikCgdu6ZWEyVaT2wzs1mCOcn1Nr0/czBvLNnYdRT4vnMv6X71Qpn7U1rimwFAy+wqaauYbSU3ggAc2XtZp6boq3A2nwU1pOqDEqbEhxKfWylUMu/O+oL4TGgCPXSMqG+vRL1lwT55/0gRzEOa4TW8KPneX8VmvmpsbM3grrf7x3LtGa6FU4BqXTNuhHu01kfMT581Jig+IC5ZexUXhDq87uzwj2/HlNTxfVJvxkAja3M83gApZHp38ij+aiwSi611PdLRilMmwFLv9zpjFsAaH6f1r8IwrUVgk0D3O57hU8j/MV+e9xj3fJaLvNvliRCaQCMtez83SH6GcsOUBo7bJbArYBynvNcU0Gzg2L6tbHX4v0z9w1og2OMGRN2Hfrsrpm1cFIZa2v+P4JXIKxKhtBocLZxgOejgxoKzTDa900f9p4Na8sNb70n4zNn5hVjtnwHwU/oMGqkTnddwI2lv46HUhKbolSH+Zt0wYug/EA2qgoTMNvrnrYFXee2SqJeWaGXJlxsSGW/p0p2J5IYf4OvlER5c3tPjYd1/SoD9KXwafkAPKbvTybtdhIeagB4bg20jqPP7f/RNBlAwOOvxufwtnFZ2z2v6M516KHGrGtr0LzklMK0WjPFZTtpdcV2fME1detKxBZoexgN6NZ9rcYmGIdYMCZhWsumrlwx3goHwnziJ/P9MDHhLcugwmL+Pd93DhDBCPJao8XQEXBdyu1+IiiWxvSjwTPCCITm+e5niVeomHNWkrpBlAN4D1P6t/mkFLp55/nggjIQOGorjWlzzVi2GBTcV6XWewqp7XjLvNMRpjszpPM7rQXKCgdQXlX+PoLJjv0E9dm/Un5Bm+hgPkNPVUIy8mSasbabnLAhx8JqnZ8Kw24StD71OLYndk/4bwzd90rkT2OtF3Ovl1BsvQK3NLTfMY2cKe++JmnGWsfnGcZGPm3671yAqLyjXo55MqadDl0YqqUyjKveBH7qHBVFeEkqhe///u8/6iH91b/6Vx9xAVmZ0r8QIqIAcVSRVKjbNWvBMJzAXt1d2rzW2dd+7ddeZXLrxWyBgci51CWGMmgzF8QLRlDa0TkfJ3u5T8CuqXIsmqahquQ5sYtmR5VJas00eCzQO79Nf0roXHsQR63fKtnizd2U1uA0KMU1YiPTrjo+i+Cb9rnfyaJ6IY2i+lwNDGn9rDvFOOsjoNo1ZtiAJmrhNnNprmtlVx7GNEJcBVgKtUHxWpLeq01KKmXPo5h7eROEE4tTKiO6bimILcQKJ/FMKMZpxd7nLwPKnDaz0HrUk2FEtWhhDbyuOxpsAor7y5P6gQ+ky8o20tcv+ZIvOfgJhFgPicI1VzUqu8aMM1mCNdjQfkufUPhQDO/q2Q+FZM01Y4LnxZiqUqwMfckqBe73bGtvaiO4ppYNS6cwSfH5FopilVnIMjArtVk4FE09BDjutDJT0y77fWEF8NA8lwWCQGqBNXhcSMXY6tIT5GPdU5osDecc2FFZBWlOqnA8T5rlNBZOrQ7M7N3TGvDfmSbmTqZOXVpzoHSIedhpmhWC7iHUWIj3PIPna6WDutm1kHlcTYXmsWFKOC3YrXg0+EUWmmc0qN74WK1Vwe5pGx7Z9ZI2jFdPpIrfnG9auJfJRoGLyzVlVysf+XQs6AL/9L7+u/BTIZJ6W40NgpXueXF4jwI0b51fa1gvnFD+knPzKF5qHzx3QzHmwfz1u74DLdfzr2IXIMYr8w47lnfcqvMz4xNPaKkXhi2ZVgjsJaUUEMUs7lhH8vxh9y11XaGDKD3Dc5rzzFIxwVUsxffr3nX/QK17+L5SzaPEECTroCcmsRhbE6d9RhgNBMsU8V3hEsGmbY0bo75Pm7GANsqQLCbjbaZFcdOuC+IyF/W6CB0Ev+ePomvetrlpvrtx8RKMYbfCaC+Utrr+zR1nSRVjljHES22GmUyxud9cFEIrE1KGW5nOXxa3uRfLAAm2v6Xvzl8FUrOiGhPCU9uAqZVZiBVdMVooqiqFxgzwi/fXM8RXhRt7fwUsumH1g0620C0NbL7YGVeFtCjhrYxVE3j9619/7JcpDVQI77hE+10UYkPdndvCWHiqRigD2DsKfTWOUjnVPSZbcbS8zUtSKUyziGPlIio7Zgm6aRVgiN2OWwyOmeGRBDdsHkEMMUhDtLuyVqCsj3nuQDJzxqu00pn4uUedk5aVaBARxIFhlVru/+HuCKuuYK0N/3cdGGNbMAiHIqrl3d3AhUrGXa1XUEZu2mgVjHkqvk3J1SLFpDKeCgHszKkvRJv3jQc6mTrvete7jnmjkKZPMqycB05Z2tNRa5bgamZVvRoGTNMsd3Muxm+2tU5VU0FZ0z0ljuDpejWmwROqZ9ExVBEQ4rXUu95qQIEgfzPrUiNkjxPMg88dnlOPv/ErStCzmz3oMzJFavVARVCAZ07lDr4BHyqPv72YHTsBcaL9neZq/pudhp92XMLc1lOhGGw+ZWhRdtZ7z80LNZ5elEqBJfbDP/zDt+/+7u8+UlR3nZQqBVa4ip4mt8Kvu0NZEIhgsNeWPdaHWo1qMw2RzDsUTGvqmb7VVe2W+Vob8t4JajhrD6YnMOv2Nq22AgjjyCefhqkJOgxAcFBoiJ+SIMDMBet/3inA3vx879pwHCEqPqDf1qAWc4P22gsl4nv00/VQCgQ2/773ve/aD1Lvqdh8K4yKIxljkx7qLbXvFRbe0/Ewdhrw/M20ehZl/mn1TEFglFM9ls6xMfDa9i7cHbfDQ5Il8CKvez//hbTt+YFICdoR4ni4CgG/G8M0614PS58Lr3mP7547vQM0M/Qiw6xrCMKaxiPGr4pG4i104h3QBIHkGqy8VvPXMdZjYswad+mpykVspRmJL0mlMG0mgBBGCCxNrhptjZDFEKoUNAyNeWUWOEKPBU2jW0iTCT+G8YEWfLaL6z0E/LRa8cVIpeE2VuDfDWZrFr4CZac76gPBJqguc6WWxbYoCpO1r7BxBGis3lWXvIqxhAoamEbI6N8eZ1uZ37+b5WMuKzS6LtZPjMVaVAHWDW+SASVYvL9rXFd+C+d6FR2DzKJmPTUV2lr0WbuxTEt31rTBaPtEqnjr8XQsDVzujKBde4ww3EHj30p7Pniwz92GSOG0rVC6/oWOSpNotnGI5xIv6il+OzmDAtWsQxXWXpd7UCwZgZ7rdWibt7cR03mqMu6466W8ZJXCDMKxgsPIds/anNTryngWpQumsZQHGnjzm998WL3dcVy8tdqfKz796OaTEuO9gN78bRpe8b1ii6zJHWOALXtug6ENVhXzrQBrnIJlVBfT7whQYI2H0cBq51tf3OMdJdBphCwYoZbL/JtgZC3dowGtcJYg8EBAdmlOHxQFnE93S0/Kr0wfm4lYvo3ZGDsvkhfTa4yxzFbhqRX6m98G7iBcKM3ueRBYtoGPcWDtdwZT4Z3Cboybpm9WKXRNzak+1XqulzDXz/yptqm/FeSl3d9K28/6bL/v7+791vlt28+2Zoy8T59nXEAB9j017PDAzFGNhnsGXLOAyCe8RyGgJ7RIQTF0eQJ+2/EdiqYVBPxtvPElqxQ0kzmLJCOgwndbMvNXrnhPbZqJmrNUJ9974KjJMLBgI1xAJ/M8kzq/DdQwCmGYmlvI7SMkqqEpJ4zTjCfWhIXvolEMrBa/7QAl5lWfnbCy6AQdQmxu8lxnsxgFgJk9y//db+7MN6Goz31/BUqFpzHW23Dc5WfzDsSIZg1m/nlqfSZ6qHAzFqmfs9aglPl9dst3Xgsr1prHtJt5a3DUIjP2BnDr/qOp0i8BMN8Lak7b2T68myoia4qWGr9g1Xc9m7bYNUQn+ssw4l3aPFfLdDdKRDxuaHkMulYF1UdlbCjBwfPb9LU0/kIF2udqYMShp3oSDdp/MjGaetHoxTgaK6xBIIFAXKP7OLSdjVUvcccn0Ij55eGQM01OYYTh5fLiPUP5JakURmAPjDSEsyEiC6Jt953FZLMZ72CeBcfHCCyvun6UEetAULvvw7TNksEA+1NBXMuz7uQ07yeUmxpbjLTuezOXipVWgGxYq0qgGUcYfAt0c1rX23fF1AsV3VMM7un3bfO9zXzjnQ0NYOZhCvNnM900CsEmOQJHVpb5IjjNc5lanyrI0YHxNnBbD6N0Y84rDLZnYe72M9SpsfZ+bx2haVVglEczY+bf9XDa93oL9aq7JpR8IT5rU9jUu/CmWM18xuKusrFuw5OzvlK8HdZU+tDfnfW3PeDt9dRS34J4fmMcFJaextt+YsmQ0meVqbnakKbnWeMNY7pXH61PKxY3aaAG1/yfx4heG7+pJ3tPaTEKXvJK4ed+7ucOAvu6r/u6q2JohQhhazKr/ef7UQBj5czGs7e85S2XgGhWQd1nHobMDnsIWEw8CgSuL3Wnm4pKU1tAxASamMalrNdhLNO8p/h1vSM7kOuFuEcQemeJSK+ctr2DluOo4Pbcpvd6Z3H27bY/n+t/73vvG0tusoTe+973HmtFKfIw5t9jbYIVZQepCzTrLiZgDluiQyCxO2u9Hy35P4vMWhmveWDVug50tIWCNWzKZKEztX30t0qsFqrnoJF6ZYQwIYfO5vdCH7UkZR+5zjtrbGhz/fRzFDZ4twcvURoyhCqgS+PGujOCCoEJpuqDsczH+RUgwelDvfgq5npxmudQKuWRJ5bxgj62wmn8Ed00vZkSb8yiCSLGOh/1o8xd6bBpqsY514FHKYB6zB1H5+JloRQQoCwjlggiZn0XtlEsbLKKJudYOisXfRSB84Wn1UrEUIhkn0Wwcb8uENe4FlstygaQt9tf67TMjyG62N4zsIjzBwiiHU9RTqJWToUxQm75jRKk+UbA4gP1BO4J999qmzlz1Kg1HO+ABaZstQBwM7WmH3ajbuOhjeCc1jHsoCNoihVcoWBteZyUdD2CrmOtT8+a64pdE5rTCDj01bpdaFWf1TjqfoPpy3wvxuTQoqbHVuEV4vLepm3zVmZtFN7rJk2tm0AHpiWQavhsb9bfuQ5ESwk0e6re2ECKhVOtTdejmTyMI9fNs7vTGE0/F8+CBW9OpKi3/95FcIstQDS2ktDQDoiusRp0jda6Y9y89DlzXdPYq+SKNmwP6CWrFFh1UzVzJlV6ZfHWLqBSESMcRqAMM/AkQEEIxSR1MqdhuLqtFaglPql/dWObAUCY0urNJNAKN3U80ywoq5Q7LYC94Q33tL87k6g4KQXWw3QomCpa46kb2lIG5s37X+i6Fg4DvVUozHqz9liOvLbGbLwfxKbf9Zq8U27/rkhbxep9FdLbo3JNlYCxFQ6ssmdMdJ56v7musCzk1LUu/W4h1SAyvFxcTlpx4T7jrmFhYx0FIutuPIDuByqt13s2lho/G2aspS1g23s3zZRWaq2Xb7tG5eleV0iH149enj2fSbiaf95oPeHKhMap6m0XNuo16EpyxH5e58D33r/hx8qP/W/0sOXOS1YpTJsJ/oVf+IWLqNT86UKarFEIkyUxfwdW4UqycixQ87tLQGU0WSgNoloYxMsl7BZ4SqjuP9e3gqUCp0G8BuUIR+48+KdYujxk/Sv+upUN66UBTZYwKK2CaxNasdIqLoxTwfbZGssL7l4lZgzmmHCa78QIrH3rJelbD1oqTKZsgEygegzTGleph1emKv7v3s1stcDNB8HD462QMAcVBFuIUZY7XlUoj/XbsVlb54wwqFiiYCjCA+Zey5SyHI9NXKcJDDvDrUqOkG7QHuTWOa233rFXkHbeunmyHk5LdtxTDr7vBtOt0D4dL63GkThIYy/6uL1wSrUb1PDthohnTrsLvEZHDQL9vDc/xlWFoj+82pdNTGHaMPIP/uAPHlkjUu1aksFOZ7VL5v+CWeNC76h7g0EzYXYDN8BDmHs2gpmFU7mxRIXJCO5ZAJuWSmyEsEW3U1pMoLjr9GEUYHfZ1vocxSet8/laGYPVSLjY1MdF3xDCNAwwfXEUZxle3xuQb7ykVjOhgFlmfpqeWYXTgPzAZN0/oJ+FvVjQfttWbo+F7M7QQnnFaFl71rHFx6rA7wX3KoD6G2HQDY2EdKGrKlZ0wlva8OO0WuDiA4Q878+mSAXr5hm8BbQPuqMUVOr0ztZMagprA9Ug0k2D/laRdQ0Ks1Uo71gdWhbr21DU9rq3h19PxvsopKbhPnnOb+OU3d3drB790af5f49TbTJBxwaeBNV1H5a5VtSPkeTT4zeN25iq9ClcxuPLRimwYARKd/mAHp3ISqeht9YnQBCqBTGpO+OiVi8LdZ5nXwEhwHrp+QDyw++5grWaNoYIo3TmQHPmp+l79xLca8WdzSHrfG+ZN3aM0s1dhVHK8CXY4tl9d8dd4TzvtBHO/BTjLWMbe6+xXsXdu6u0OC4viIAsxOIdG46s1UyRGJ956jNqYeqDufQ8gsTv0+bZFYaFR2r1NfDteRvmtFZovEIdfVJAaBNNKyMxgePuBq/gKx5fw6BrWKVdRTb9r+BVVNKYCs8xivA3Pi0sNq2eeHn9nufp3VVCjdW577kYjGQG+igvMFg2jGVtO3+lq3vj5DU0cF1Pz/u2x1mFWUVQJfybhY6OZ91eIs0iTau2VMiqgqPafZpFIpAIJQvcfN8eudcshlqxLM4udmMH+oAR60YXG8SUgqYWeq7z3WTYEP5bKG9oqERZ4WE+FPADKWxBX/cUM/QdmM33BK2+ETr1DJ4P2pnfBYw3jl5hXaHEmm4p8NIGpqIIms2x4xcVHn1/FUo9Kevps4Vdcf56XN61196Yug5tW6h1fvbz0V/PZihmXSizqcidw7lHYUcCbVqFYGMD7efGtSuM2t/Ob+/3fuuD3lULNU/mvQpqxzFKo7vtGETntSmpTywcvl7ehkr3mL2jsbu9Vt5ZmKf3+D+67jX6U+/KPFT29D01Vl5WSmHaT/3UTx0Dn/TUySoaOGU+6voTfLU4ay32+DzVLWH16ttPEI7mtsml57cO00inA+vYhWqxGkgswToar5tM+m/KrlZSLappz0fwGw7z7+krT6iMuwXhtO6MpVRHUBR/nuY5PcwHvi/bqXGNjR8LlheXb3Cal6V/k+mCYWV3Tat3Nb+DAX0wUZMKphV3LnRTL2THmKpEZk42jLNjAfUeJCLw/ljaIDzvKZTGILknyOrxTOOdOmtBX9EyWMkaOrtCLMx8Nfiqdbd84zOUC/jJvYVGC500tRVvlS9aSUBRyBaCQ8Pdp+T3ekGKS9by16+tqKugu3FwWvu/57CKdBrar6zxTjLI+oOMaoDNNUNT+KoeUZXc/J8MQUs2gtaI8hdkVIX1slQKE0R22M1Mjpo21azNntgWpsmW2eJTQUUJjDASk5hniDHMu+d5ICvF0ix0Gakb7VhziBejzL0wcRVhuykFoXDxBfuKpxceEewm8Ir5Sn9r+W7WxyacWkTTWM/6BEqr10UJgIa6SbC7dLc11nLOPDt96wl0PVeb1ap/zSaiMIyndND9H8ZZoeu+Wo0V5Dvu4/k7M6XeLcG4UzGtv3dXqXSzIpryW99LaLre+5o9Z438H4btICdGz71cdvNQWLR0YI55f9bReqP7fZ6JcTdWhaa6ltZi11jaG9umVVnWozMGio1CthaFHj8eemv8yDML6W0v1biqCGtY9PvCVt38imfqsXd+9QdPzbNUcDbveKspuU1lfdkohSHeUQAjNAsTIaAKgLqrZU4E1EJnhUx4GOodOTwd3OP+uaYF09q6ea1CdqeU1vWrNYCYu8lp/m2Hr70bVQJSBFntzX0uUzfDYUM0FYL9HvEKWPptH3lZmGAz0lZwteKqwN1bhus8sKxcWzy7eO09Qb8tpu0t1Tsg+P1OWHk/Qet7z99eA9rpd1V4+qdVqBeS6vx6ZsdQ69J4izN3PAykxhG6wa5Ke6+htdnwYml5QyZ+a0mSfRJh6aMpwYVojclc1KjaFnbpr/1o0Lfr3XjagwV31UDos/Y1lUEdk/XpfFkT7ze329hyr7mot1YFWzou3H3Pm31ZKYUSHpeTBbUFPwimqWfcZimtMOcRshah1jdLwoaSwiKscYK+wptSARvcKw+NCHoq17QZC9x/7h/4aj7DvLPDl4U3fe1uT4RV7BjRsFBZWtOmv/UUmmJIaCFQsZju2sVEPA7Wjmc6u9j76oK3vLc+dqPfDnj3nqb4gZM6B8V1CzntlGIM3UwTEAXBUgy9AqHwU3cUg8a2IOsBROZQX9rq1RHanttNWWo4ocV9wIr3io9RWGoS+aCx7XVtDBsNN8uJcdCUWAqz53SIm6ERc7PLqAgW83rQTN9pvjrO0hA5UIOnv+vjhshK/0+sNWm2lVIU5quGS73h8rc1RXfe15RlxkXT1hl7fq+lj/8aRy1S0nmtsn1ZKoUZ7C/90i/d/tE/+ke33/t7f+8jR1ZO24Rs8hEAYmJVw5AJzlpmAl0mX3XWZiBVQ9cSJ7ClXDYwXgJCMPBMTDqW2wjVfaJbBWc38OmvxjU2N40BgBjm3+oIbSsKnFWi9/FuGV+acYMgCIJ6J/OhLLi13SuAIaRGYoxmdtRV314QpuyaownMXoHgt2Z69Z0YrEkHsOx6LRhujI1ayZi2+wfAhDvbCR0RToQAQdlMni3wGouggKyXeRyaMu/WacNbpf+tUAnEnb23s25qmG3v1FyVXo0Fz25Lvd5E3w/Sq5dWhWiO7U3a1QkKx6GLjqMN3c17KVrnXLfEBh6qdzv3duc1eG5DSU1IaZIKfvXszlc/Neo811jKIy9LpTDlKWbPwgSah4lLsIUfCoX4vhlJDUTWiqzLvQN/tfR3UK648L6vm88QWK011pXUSfVkWMdlVFYTAimWj2DuMWohFHPpbxUh66zu9bTNcA2sa3Vny3CYZ1o9HYFODEngU1jtQ8engZ30qynH02qZVflV+PiOsmsfwJIbhqpnUrjGZ1uuO/tjC549Lve2HIZm7gsn+L85bZyKx+o0vc7ljmdQkrtfta4rpNvfDb+Zf3NRz63017a9OO8kKOsJFI7rGhDKDK8qvXqhG2osDv9E1q90t2Gl0oP3uLeQ5qadPd5CYPpaWukYu/a7b72+67Pp62WnFAZC+d7v/d7bd37ndx6DbWGraSZNcAuzNG+4OfbcbwRDOOwStCzEMuAWLvpYxilO2M1XQywj+OajNLQ+NoOkVoTx1a2uEtNYzRtKAZFg3AaBeRb6WaukRFpm3AxcXLSbCwee607ZMrDn8dxYXjJ8tuIrRNWidrX4WFoUdH/ffeYJsv4YEt5frLgWaNe1/y70YqwUlz5U2daA8e5axNa/CsC6gYjQh+vRsXjB0Jb6VTVUGiPoOPWNsNMf81fB9nxGRue655NXWG5li5+rYGo0lB4bS/IuzyoPWWPjVqFAIUXX8OI+mVLX8060VpppinKvETwufTf7Z/42llgawOtott45+mlq7I6noP1tbFROVeG/bJRCBZKA7Q7o1BLsJFgYTG138PxfWQz7HropbGtZ/x+ikgnTAPUwogWeZxI2XNdRapPV9Iu/+IuHQoAtWjzxi7p8rI2W3m7QCfMgkAZm62brJ8FPIGxhMq2KCcF33wbGMIczn4QFxiimilG9k4IQ56i1Ns+ZdMoybRmAoJhncufralt386L/+qp/8+7ZB0LYNkGgu7wxP0VagcT7Q29Sonsk6o4JlI7NidYUxnqcLZVSZi/9z/sdEDNKYJSxOd0BWd83ecKzmqGF5pudY+3LD+5vAbnOg6w6NMYTNKeFr2rVoynrVqFXA4ECZgzy5stLeLT8s+XHNF6W433F1Bp7odjQWxXDNHxSoU3pFaKtd9s1IMPQL7lQHpumT9OacdjYm3WbOX/ZKYW2d7/73cck9bCcaRunq4VXRmq8YJRCUyiL1W+YoQtcS3J7B57NepgFmcyhUQrzV8bHXEuwESw7a6FCpxhhoZ0K4rqb7iNY62VsWKXE7FmY0RjN7RZMHTtiNr4K11pH0zp3VUL1DppCu3cmW4MtxGplTiuGz/IC41FEFAHhsRXK9tYKB1R51Zu0Du6tRVia9Fu9gnpbe20Jj27YtGN9/lJOxaYLOxQO3EHcxszat8JEG67o+ntHaRkflMZraVuPWtrb0+76MgopsfavsEy9YQac37oO5Y2ngxgUNqs3uGEr64/ua5SVP8oj9Qa2fNlzu+VQDYEiCjvpwnu972WnFArTzDkLI8jf9KY3XURci1YMAMG0bPVMqk0fjhncFT+1EkWZh3bv7s9pLAbExSoeZn3b2952lB1Wgldfp7HmKyDrdk4jZLcLjui1WoUsa/0WOJzfm5llfgnTZn002GtuXV8irzuvPpTr/N6gWd1kz+j10+b71rMaL0u2WMfunkIi1qeWF6uy/ZCa3GBwGbU4rneYm9JklaRrCw3tuaBUCjk1fsXiJWBLa9uS5qU4dJ5FzDgp5APWILD0qVZ6BQiBUqWwx6MVUqvC58V5Lgt+Wq3m0jh+rDKrR7KNp3twkSxDfFhersfWpIBXndlc/s84KES7+Q3dtOLpnqvO2YbGqpjKk21bkTeg3cykeiu8E/9/2SmFtu/5nu85BM8EnGczW13BTjDIZSZPDaH5OxVUi8d+tiZQ17rxJnvDLRbLyVPiBfY8uA+xwsWrcCziNC4ogkSgFEstev9XNZVwwYwyLsxNsdMqmWEKu7/rbheGkm5IsBWuI5gwqcaDYM1M32SCTb9HQRNSTiCb60YhKP5nr8RcZ5zNvDFnxmoOpum7v9KRwYZ2xheuMq99z/QVVNga+4WIduDRPNZ7c0/LfdR6LYxjLNKpK8iHziiEKpRdFLA4NEUvI4kwtEu4WUaFMqs8ipM3ocIcEaiNMehLMwab0t0MpV2RoM+e1uC1nf+1zOd32VcMw6ZudufxDgi/4sxIs1mssGlppGvl+73TvrCX+WiMEy+Y80JC05r67hlNS65y3KhGvZjKr5elUphB2o2pemrT4Lh/ddmkcRIgtRbamq7HFbezudZsJ744t6yPgYxaHtp9DeYVbkAIzerp97V04Nk7E4bgrSXqnc2BrmsLr2yKrnez8ApV1LKFHTdOUQ+k3tm2uj2fVVlobBpiFqeZ5/d0suZptz8V/p6tgQ4xEiYndFzTg+8pf7AURU4Qu869NUbqxqOVjQM3g2hDMO5DK75rthrBV+vce8xV+WLHT/QbrRSasgZ2TE9DIxvu86zGmjqnG9qsR6C/hV5aGHE+jAEGTb2uxloamK432VRjEOL2sqeZp/lNoBjflMYqgJviSg4VIqohcA8Sk/iyrfkqwUKP00rXEIF6dWiI4n9ZVUl9vjYMOYfvCC4RSlzrYtEyD6oENjyjyZTBcIJ21d5d7O3+NkhVLFIQyLvLrBWG29VH7CUqFjTrqRkkLe4F/iEMytB+37uyKYsKJ3NcwdL8+Wms3cZxthe2XeiOu/iofvQ0LjGFFjSssGlwvGuzhVAVaYPShU/sgXF9+yyA2lLSnmU9xsLs/pKu94aP7kEx+jzNGDonUk0dGOQ6nmUz0Pa6FofXJzSsPxRVYyylXfTfZ1TQVQkVTvMptLj/XQOrBhOvqQIQv6AlShvvyD4rbRCQ9dp2XOXBwvw3zFplj3at2T3ol8zAw7Xw9WlDjTWeXHfPK2gffO+eKtrG3V62SuGd73zn7V/9q391+5N/8k9eBe1qsc3EO9z9HkRkwVu6Ydrg/uOBjMJpOYldT92nwsG7wVStN9KNRXXP++5pvBwF+qa1XLfrZ58GS5MysLfB2OYd3E6CHJGzrggTCoKnwaKiUJ3YRWAQTJ0HAqW4bpmMUOXam6+5rmmoFPhcP9/zFqybeZC9VKuwwWUf3kGtaDBelZONhorLESCELYjEOAUjqxiH5iYBgjehHHXX17sLlVUoNbOmcAPvlcDx/8ZD+nz97c7mHZ8wxvl9YLrp/3y6E9sGrVreSsHMBx1J+UT/lGuDtfOxax89VrlvaxrPFZ4DubLozSGar4LiVTW4XEwfP1UIfzqbSsvT21L3Hp4qSNJvjkEF2eGXwkeF5nwYuY6/rcHH4J35aBKIZ3XT46AVDAHPelkrhSGMEeBKVzjUvRbNxhAt/vxWF9z183/B4AqtBm/mY+FrrSAQ+J+yGu7DCIU2aoF3UXughmZREX/jANNquRQmq7IqE4wiLRxBaDdw6/8YipWMCN3TeZ/vYd/Th9baafZQjzcUX7gHNek7aEr/dtYKIQf+aaZUmafKo5BYmbUVMf1mLozLWPtsAtvH87q+zYSqorcJU758m3F3no3dWJr4UK8VNLZLItSyLU8UthKo7hygl0JgjVvpT+GXuZdirkGBlnredr0v/bmXBoqXG/sqjzJ8Ou56qBRWLfZPnbvpPctao/XCcb2v64rHCmF7L8WiP1u+eF7jBV33zmH5pbSun03gAGm/7JVC3WgLjjnqTtbqrcV8r37SPE9QeVsCjeI3yFQBVAuNoqqL2lIDiJ1VQPCxsJtdMq3Bq7rDJSLj266ncTReMNbgNJZXn1fXl+CCnVbQVSmw8nYArJ5R799ZQ3XBWUQC9zvwW4U1DRMUXis8UKusyqFpyBXwBEqt0Q3vVDiXGWvxEZCFrwoHcOkLr9Tb8eyNoft3n7u9pQoT3xX7b1/0p5utplVYl6a61sp4WF/9qOIo3AfnrgXf8XSuKefpO6Vp/venPF+eYXjUW8UneNb6PXEmaqCRKv/Oi3vLi+Uta4L+zX/PD9lrXLi1hkPprlCj9dxQbWGvbdy97JUChviZn/mZ4/9f8zVfc/wdK57wkcrYsr1wagqhrrf8bpZEGbkxCZkys8izAUoGSTfLTJNZMe+RTrkPfOHaVZD5u7HJezgnxdS8dszgO8Sv1R2dD5jKO5p5MnNil/G4oxh6Wscgg0f5EUq2ReCMsemo3tn+8dKmNetmPuaweecUKahkWvFwimW8NwqwQWRQx73zGEBeXQfr0viLuMe0nuZHqN0TMI0Tdc53LMPYzVGzYNqHZsFYZ8oHXfJk60mCHmdtzeFkzSkrL6Opxoo+VsCXn+b+wnfes+kBLGtO6iE6HnS+b/C/O5bROd7Gv8bZLEHZbuhjK7dnTv6twiq0W2+PwWJc9ZTLS74339sAcM+mX+tcHqsHqc9ooorgnmKoEnrZKgVW4OxZIDQIMYRBm3YBWUTb7WYpOLSk0A4Ccz/c214JZxV3MRCohZc2x7JikbDULbJ+zfgIq51pUwuoO40RkPmpMKoF6f3Fes0DCw+hyrJxlsM0sBYGmxTfroHndt8GxUVo8Ri8n/BuMM7Y2k/JA4S+mIT53ddTzNbd2Oa7EVyjZJrPT9nXihbMLFRhfggd9KMPBECFGKHt2VVM06yJZxOQaJIyrcJitFBuLGoejn73UKcGy33fnf4+5kz671w31zjt0G79Ed52/4KsGoOoUaNvzdqql1XPxHroC76iaAtt8k62Z2lNpNvKvipUZ66fTgWB+bcYiX6a9641bN84ee7WtlCx9Tc/5ckqnO5h2DyF/1sZd59z0gB9od6XvVKYNhPyEz/xE7ev+qqvur3hDW+4MGwBt7pgXYRa28Vpy6SYwAfEMQ1DYMJCDdXuJZS+t8JwC/gSyDDsMGA3nTUuMm3+zSKvBUUpNQNr/1b4pplT+9kEA4FWpp5nj6fh4KPi303jq8VTwVOPYdqGWkBPIB3Pa5ByPk3J2wpy48nu15dCGLXQu4b6vuEkz6yb7zvr1X4Xaitd7mcU9mqQtbEPEFjTKGudbovUelW49fsNR9XTqEAmuBk0oxB8PJswM2eF1kpD5cP2Gf35rt5aodDSUL0tNK7P9aK6Du3TpwLn8UC6+W9Dcr23fd9Qp742I8386Y/13v0r/Fj+uAcrbShxw4X/RSiFmcQf+IEfODax/e7f/buvrJF6CMXafY9wYOPTCIRq+W7qoRC4so0FNPhZgsaAoKlCWxWqynLP81r2eiAxJTg2rOT0tSE0h+9wj+vOc/1txKkFVcsGAQqIby+qQmGauMl8JttG/GSsb9fOs1i/1qCZSTyEbrRilVUwcc/3BqQy87yr+HmtXdf12MS5p2m0DVxv+K5CovED88PCQ0c1Ong36K458v0/uvOcHb8hnBqPYbkbw/wtLFoDREOXxlfDZFqDs6WBwnFdpyk5I3V7ru+xrF1T2TxVClVQFa7T9KsCswqGkTR9VZ/IWhjn9Mv/S8tb8TRm88zJL/heXGULYenADXqDv7xzG0XdH1KlS4bwWjyPJ2PNalAVempCShUDWn2h6agHHd5eJo1rPpNey72pdywu2UrFjy28c59rNRVu4NrVohzCq6BDoPozQnKE9jAPApp3yCRwFnQZExHN+REscPWSauERPogf5NWy28OMxU0pugp64yPICBRtQ3DTN5UmKSHlvmcXdwu7ye4iHCtQK2gIKMzOvUf806TL1ipmEdaSbJyFVdmYUq1Nz28lUUp6msOCrA1G9b6m3ppnSngU5QjHeY/UWucTg+y6+5pgobAKZ1jvaYVdpJMSOi21sBXAzDXDwdpNn9DGPA99jIdqvQufoWkKzRnaja2AkfAig2F+93zKnkdcr608p3XMTcCw+954K7jF/vRL+m7pAY2Zg6/4iq+4SqvschzWB9yLFupNM15Avi2aCcIq7VZpz7/tiepcGI8+SpuuZ9oMwsY1/ovzFKbNBPz0T//0RfizmITz7/pdv+uwtqcURiEPizaLZKfk3CNPe7uLmKGpXoUrCutgyhECTk6DXWMezNeF0jeY8HzmnlEo04dhvm1VVbjUrSf4GmCkpHgk2+Luc4urFqNsfwmh5tATGNMIb4RLKHlXYSbvradWaEsrBFhvZ5pEAIzUncgVpjvQV8ve2Fspt+PGcE1TND8sNlYy2G8+sqmq+AmmrbQKOXpX56mCYMeAGsQtf3S+pzVjxjtaRmHDkDwP91A0hWfMUSEoa97T1LaXSoDVE+t3G1rrmhHSmy7Mr/VpGRFetzksJPbMM89c68Zir5IpTYycKJ8yima8LU1R46fxvUJR9Wy9t2PW70Lb1mDDe9sAsub/RaSkTpvBzyL+/M///PGp1THwynd/93cfp7S99a1vfcTaYwFwwacJtHWTmoktPMGq4642YGxRbOx573vfe/Rj/t/nlpHrTvNWMFRLMYNlEArCwMx9hrmpgOi7GsxqfIMlVyy4Ae5tgRAgU3+nAkQMpIUIp7WeTbOwml3j/Qi+QrcCpnjwNOXPWaHmujGJLVzKsH7neWxIqHCLfu7YBat4Au9Dl4QaYVEFXI9v2o55GXsztRov4AVa48acKK2OszDM9sAKsXa8+tm07x04LwRVaLICcMbfkxIrEEufFdie0aCu+ZEZtL1GApki5HER+N5dj5EHy/p+Op7VXt9Cz4LQni1LD9wj8N8No+ROhTW67nPr+YHN8FQhzfZzx5JqNKCV/yKUwkzgP//n//xgQkTy9/7e3ztKVP/Fv/gXb//gH/yDi5AxA+iDe17tO4tSXH4EewNUiH8aIh+P4D3vec+F6ZdAN1xkBy7hVoKxwIRerbsGn0EjdaHLkNMqLBEvK3hbmyX6Cn6ERPmYH+MrDDL9pMBsljLWCv/GNXbmVFuFDWb2/hG2tbIprkk2cG2zMeC1I9gG2lIrSKti12Ys45mxIq01QeWzS1mMclTNlYCbawY6bGaMOSbg7mU1OY9jPkOHrHX31mqWKTOxtQn6OyOkNG6XctfQ2AloAqlekOvFh4bO93kg1tCZCQRdada6OFCqlnshQL81S4o3X95qTA5NG2eVYpMn0Ew9e4gBy/7TKbXBap+GZylXPDhjnnmb+eAlF3bumRsMUAaIZ/c87io1mz6nMbKsvaw68zUyED070re1wl5oXOElrxSmjaD51//6Xx/HdM5k/uRP/uQxmX/n7/ydCzb60R/90SMQzY2sBYCwiudjUr93kS0Y4S041N3LFbq1wAvHIPoGYrd1Kqg9fZ78/17XncW1gAk3jM7FZyW5f1sfPphZH7i9Tc3bwbn2d65vYK7uvTz4Qia1Lj1Ha5+Mq15L7ycAvI+FOJ/5niXd3a/FdSmOGgPdja1V0BY6Y71RFh2/eMUIiBEilHehsR3Ub+CbwGPNNlWaYB0+GEUwf0cwio01zfaeJ1AYhDB1TWlrrsMXo3QIa2U8QJXmtsFRPGZnLc/JmBvn8E7Xu6582Oc2ZbO/oQt0sBVCvQ7jfXIdVYr2yncUXBVZg/+lZfeUlwoF+a3efWNd5YWd+dYYlhgYA42RMH/B1n3Wy14pzGBnr8LUQSJ4ZrImK+kv/IW/cEzWj//4j9++7uu+7pEaOBVKFfYVciWQaWWSnUs8rdfVvZtWdxdmLdOIAK81oTUlVr/mWpVba8lUOOn7vVgBwq4iLKzTuTXePVd1Wbdg7zx5Nne2MQOMXMy+qYvTdtyjisz4eV+eUW+Edbwx67rtxi6tskJGNlaxbEKuHl773M1vDAL7WkagmisWKhoQCN1CcxrIajwBm8pg357Po7Lhr5CS1n+Xdvtbr7nXJk7Hoh7viKBvjaRmTNVTbWCWUlFFoLDQtHrSVS7lBfSMtyosqzjRRL0ffKM9teJnhL41r0fOeGqZ+c03/l2DrTBvlVzbvVgDeYJWqiS7iY1i7/NrVL2slQJGn0kY4f/n//yfP4Ky//Jf/ssDzvk9v+f33L7hG77hqGU01w0zzWeupxwKf5hozDUMJ5OmASuT35jCNFaJRa+lQ3AW9kEMYgh1J7VuAsJovBIBzLrXCIagGAEkFVD/KvgxGEunlpVngSFYR7ViMA33XN/Mg/4jUnMna4PAa7yHa2wO1XipF0MpsSBnzSQYFBq0xoW+hgaae24tMM88U4Df38Z2RoARKFIWu5t8+j5QFoFsnq0tT2H6ps/G3mwsiqgQEdqtYVKrHx0Trk00IFgKIXkPYdMdy5+redZs3tytRtfzKRhCcgpPTpbd8Nr8m+XdvtfYaz8JavQJCqrhxVNrijmaKBxVD/Lpk8+cDVK4yxrwLB0tWnjH+GpkbhiKtV855Dp0g5+qFBhJxjENvIcnpvFKh395Cy97pVBm+If/8B/evvd7v/dY2D/6R//oARv9rb/1t25/5a/8lcvKNkkN1tQtnI80OgssaF1LkdAlOCtsMWUxc+8gsEAr8pxrHZd5EXQFA4aYcUgJ7XtZ4yyRIQiWDGFLuLqOANgeEwtkYCuWPSFP0Os7zLsWYrFpz++ObQKpcIm+FfOtAh8mZAFP4yrPfMzmRWtX5QFywUCFELbA2t7c9G/O62jq4QgB8yMxQd/bZ/SBvoyzkJF5tLZl3GZTlUbr3dUKNK/bw+r8NvuGcVDaI6R2koGGrvtd4xBtL8TrmHdMmZjxoN785jcfscCWMWFUKZvRedjeIFr2XWHK8jsB32B3IcoHgYDMscoCHU/xfe81L/WiO7eda/0sPz2fctjjNXc1lpo0UbqZfs78tpTNy1YpTDMpY2UMhDRtCGqYdYhrXNshulESLMguzjQEsDFuDOQa1naZs+5fU+Q8g7CYJvebAuGZ1HJvMLPwU13PZlJs2ILgxiAzD5SC7Ifi7w2w11pnbUxf5dnD1vW96a8VxALqnddplExTYbtJrpZb3W87sud5MxYKR59gqtPPKjh/CyHs+doBP89lDfICWJO8Mv2D5Vr3jacXFuueBJ96qJ5BCFqTwgAbBuo8if0U5qpwMlb/956WYqlCaFYexe5+774H7ey+VvBW6RVCkwo675wAaRUCgTce24Zl9Lm0tr0e16L3e+0erz2R+cdz22N9Puv7+TB89M3SZyTUK6qMqddWJVVl0d+KKtRTMR8ve6Vg0NP+2B/7YwdUNO2nfuqnDgXx1/7aXzvSVOe6P/2n//R1z4YzNhHXEivMUMu4weHmM+8ievUUBABlYchkmCZTpy7hJqxaAA1Cejb3uFbL/FvWi/e4bj9rv6ueFAu5+ea7QCAmmjHwLszbZ1vDz/V9lXGFHbd+WmEVgmZbr1VOhJuYThXNfAj+4tTGNsrnc7UKr2lgxqY1U2qEF8ODV0LpODejWPs0/Z62S12gUXTQuSn0NIZTz6pADxQtr0wAvrChTCQCTjHExjWsn1TNWuJiZWpWzXcDdw70ttdt3jvKohZwU6rR5ozFs9C5+WgjXNF4C2Z+IuW6bX4r/ehPN4uhwWY9USil5SIDMtTMU5/D4JzGAJzPjA9tDR020aD7UAoPkjMv++wjxD2DHuE/i8OKHa9hJuff//t/f0AKv+/3/b7jHha8Sf4n/+Sf3P7dv/t3t7/xN/7GI0LW5AqcTSMQYJKNF+ysmI0RaoWHWGktecFSZHXXetD/CmoMX2tQ32WoYLgqNO9q9sNurKHp3zCcsYorzGcIlNveDA2pqqqmbgG531PrTh89q8qw1VP1r7AAhqH0R6ix9M1BrX5ZL/OZ5/ad0xrEJSyreGVzmfsyHaU5TcbNzu3f81BrnOCdj3kmGJzTUcvPvBWOM96dvtzWMh8aGi6Ob02spfdRPs4gmNgAITUCftIkeS/o3R4dfXOkKSF8j3cYcbXky3tNbSYYCXj00UDxvKfeaoXwli9tnQPGHwVAyaEFCrDyoMqqxsaGZqsYPA+PkB2jVNzfZIx6MPMdPn9ZBZrrLm2Lb77/j//xPx7/t/isvJkEJR6+7/u+79jANr8NpDQTNR7FYJiTtfRt3/ZtR/0eE1tsViv2Xy/Fb/pWIVj4SKVJCqdlhLvYhE21fttcC2659059LEbquh2faBpkn88VxfAsq2YNeUbfNW3+qss081/PpzBLGZHCrnDEwLWuxjLtGLZFSTDO7y1W6HmY1vgIbP3czyNkirG3bIjnEHobTpx/dwNRhVbfV+VobgiJ1r+Zzzzr3iarTZu81MKExb3RWI0MAkUfjaFW/vy/Xlo9OPAY2gJpmeemrlJyjC10Xw9Pfz1vr52+e1fnEk1VjlQQb96oTHlwJyWUgNavfn/P6Nkw1LQqpntQG+HeZxf+2++s51xlpf9grvb3c7UnHjyf/542lsoEKcY1/GxQwBeimVCBws2ohCwLWdDJhNvFN/f/mT/zZ27veMc7bt///d9//P77f//vPxTFP/tn/+z21//6Xz8C1JiJwOIpFIdH1BYXk+zAUt12Vgt8fP49yol306yeCvu9AaifBkVLbF2jBgvNpevm2RO8m2yabu5h8UxrrMM6cJNdh+mL8e5t98bT35pb3TlroHA+LHlnOpjrwl9iFeIerFHv7XPNQbNF5ho1pqYNPVkrY9I/qcBzTwUzgebZILQyJyVReLFwCOU799tkZ1wE39zHQ8ML8x2vzLPn/5Q1K9ycWv95h41TYJ8Kc+Nr9dNpBG6FK+9RAgWIY/625pD7zKeiiqU7vN+MIXOsH/iN512l67cmGBQlmN9n7GixfPTcOmyq/FeIp/zuOx5L+9NMKfdX+cwHj86/ySx00D0vnR+B7wbPCw2CLNHD/PtP/Ik/cfD8Z4NAX/Sewgzw67/+629/82/+zcM1nZS1iROMVU9RTX2jyTQa4f5n/+yfPWILfv/7f//vH+72n/tzf+72l/7SXzo8gn/6T//p9fyZ0Dnj+Vu+5VsuT6GClbBENN2s0me4niKpxu9vsMh55rjWFrQa3Y7dWl4s0SqCbl5rsG0rCcRNEHjPPH+ITD+MpUpPcK1egvc0c2JaldI9q78CUeCuGGztE+40j8iu0b6z1jMhY0drM5sqrDtPxqs/HUuF+TR0scdX2EJqco0V72+qJw+j9GPMhQzQTI0LfWmZlM5j57slRSjUxq1qUZvvna3j+FQF8MwVpdT58N6hKUqs82nOQIvWY3jY2tbb0QceNau7EKw1QKdiNObKOm54FS801mbuH4QOm/mm/8bZ43UZAjIM62k3jbzz3mQX42n6OrpHL5UF82xKoXRUA6R0Wzn0udqLXilMIyhnp/IohNl38F3f9V3H33/zb/7NkZUwiz3K4zu/8zuP4nijQMYTGI04cYXJpZ7UwpmwH/7hHz6CWZMCN79/z/d8z/H7ZCh1kfZfglDWAGaCV7pGvZPuiK5Q3K7etA0dWPgW4esmtvk0E6gCZ2eQFHtvStz8ZYFVMIFg9KXeSa2qZlFVMVqzjq/jLPNUOFcxbLhQP9R5Ioi91/WeUXx2WoOf7XPnq0xaIVYmqzJkuXVuOzfG3/XgFXR8FVgV/s2e0Qf99AzCxnxTlO4jYCok64kWYrkHnegbQWt8oJ+dnjrfDf3X8/W3MGQTHZTfYHQVmqSkOuYKabxHKRaudf2Gk2pEGV83+j23TkPbnnrXtbysb61sQGE3m6t8VnpHrxSm5AkKrHKokJT/GwvPEBTttx0f+c9SCht3++1uM5h3vetdt3/8j//xcfTmTNJf/st/+fYf/sN/uP3tv/23Dyt/hPt4CN/8zd981Dv6sR/7sWszh6j9bGab+MPc863f+q23P/7H//jtm77pm25/9+/+3ds3fuM3HlDS87WNLXYRfIc5aPb+f7vmtaAQkYXrITeFy1zP1UQUiJ6QKETS8wN2VdISuzF4RzHqWtm9r676tgo7V1q9EO9ofKBCBHOXyFlTz+dab8XQfg+jUaqsX4rWdYXAKsxAiO13lbHraxwU7/b/KoX2k1U9f1mGmv4Xjutz+7wdazF3Oz5WuKfWt/nzDPNUSKtKkrI2FjTfPQO+F3/wvgp9yrTxE4rDmrf+j7E07gaGa0puhXUNFP1FU9sg0RgXGv7aSrZKcVrjIjUI8Yd37diB65W10TfweE+/q7dpLmtYeqb18QzX/2fHFEYgj5X9uD1uj9vj9ri9tNsUMxyU5D9LKYxGmiqPzm993B63x+1xe9xeWm1E/WQFDlS+vZvftFJ43B63x+1xe9z+y2gvPHn1cXvcHrfH7XF72bfHSuFxe9wet8ftcbvaY6XwuD1uj9vj9rhd7bFSeNwet8ftcXvcrvZYKTxuj9vj9rg9bld7rBQet8ftcXvcHrerPVYKj9vj9rg9bo/bTfv/A+NqQ7V5EqKZAAAAAElFTkSuQmCC",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Visualize a sample batch\n",
     "from datamint.utils.visualization import show, draw_masks\n",
@@ -817,66 +690,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": null,
    "id": "8c94e0d6",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Test loss value: 2.4755\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import torch\n",
     "import torch.nn as nn\n",
     "import torch.nn.functional as F\n",
-    "\n",
-    "\n",
-    "class DiceLoss(nn.Module):\n",
-    "    \"\"\"Dice Loss for multi-class segmentation.\n",
-    "    \n",
-    "    Dice Loss = 1 - Dice Coefficient\n",
-    "    \n",
-    "    The Dice coefficient measures overlap between predicted and ground truth masks.\n",
-    "    It's particularly effective for imbalanced datasets where background dominates.\n",
-    "    \"\"\"\n",
-    "    \n",
-    "    def __init__(self, smooth: float = 1e-6, ignore_index: int = -100):\n",
-    "        super().__init__()\n",
-    "        self.smooth = smooth\n",
-    "        self.ignore_index = ignore_index\n",
-    "    \n",
-    "    def forward(self, pred: torch.Tensor, target: torch.Tensor) -> torch.Tensor:\n",
-    "        \"\"\"\n",
-    "        Args:\n",
-    "            pred: Predictions (B, C, H, W) - logits\n",
-    "            target: Ground truth (B, H, W) - class indices\n",
-    "            \n",
-    "        Returns:\n",
-    "            Dice loss (scalar)\n",
-    "        \"\"\"\n",
-    "        num_classes = pred.shape[1]\n",
-    "        \n",
-    "        # Convert logits to probabilities\n",
-    "        pred_soft = F.softmax(pred, dim=1)\n",
-    "        \n",
-    "        # One-hot encode target\n",
-    "        target_one_hot = F.one_hot(target.long(), num_classes)  # (B, H, W, C)\n",
-    "        target_one_hot = target_one_hot.permute(0, 3, 1, 2).float()  # (B, C, H, W)\n",
-    "        \n",
-    "        # Calculate Dice per class\n",
-    "        dims = (0, 2, 3)  # Batch, Height, Width\n",
-    "        intersection = torch.sum(pred_soft * target_one_hot, dim=dims)\n",
-    "        union = torch.sum(pred_soft, dim=dims) + torch.sum(target_one_hot, dim=dims)\n",
-    "        \n",
-    "        dice = (2.0 * intersection + self.smooth) / (union + self.smooth)\n",
-    "        \n",
-    "        # Average over classes (excluding background optionally)\n",
-    "        return 1.0 - dice.mean()\n",
-    "\n",
+    "from torchmetrics.segmentation import DiceScore\n",
     "\n",
     "class CombinedLoss(nn.Module):\n",
     "    \"\"\"Combined CrossEntropy and Dice Loss.\n",
@@ -900,7 +722,9 @@
     "    ):\n",
     "        super().__init__()\n",
     "        self.ce_loss = nn.CrossEntropyLoss(weight=class_weights)\n",
-    "        self.dice_loss = DiceLoss()\n",
+    "        self.dicescore = DiceScore(num_classes=num_classes, \n",
+    "                                   average='macro',\n",
+    "                                   input_format=\"mixed\")\n",
     "        self.ce_weight = ce_weight\n",
     "        self.dice_weight = dice_weight\n",
     "    \n",
@@ -914,13 +738,13 @@
     "            Combined loss (scalar)\n",
     "        \"\"\"\n",
     "        ce = self.ce_loss(pred, target.long())\n",
-    "        dice = self.dice_loss(pred, target)\n",
+    "        dice = 1 - self.dicescore(F.softmax(pred, dim=1), target)\n",
     "        \n",
     "        return self.ce_weight * ce + self.dice_weight * dice\n",
     "\n",
     "\n",
     "# Quick test\n",
-    "dummy_pred = torch.randn(2, NUM_CLASSES, 64, 64)\n",
+    "dummy_pred = torch.randn(2, NUM_CLASSES, 64, 64) # logits\n",
     "dummy_target = torch.randint(0, NUM_CLASSES, (2, 64, 64))\n",
     "\n",
     "loss_fn = CombinedLoss(num_classes=NUM_CLASSES)\n",
@@ -940,7 +764,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": null,
    "id": "ab74c328",
    "metadata": {},
    "outputs": [],
@@ -1103,20 +927,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": null,
    "id": "e357ff10",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Input shape: torch.Size([1, 3, 256, 256])\n",
-      "Output shape: torch.Size([1, 4, 256, 256])\n",
-      "Sample loss: 2.3505\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Instantiate the model\n",
     "model = UNetPPModule(\n",
@@ -1126,10 +940,9 @@
     ")\n",
     "\n",
     "# Test forward pass\n",
-    "with torch.no_grad():\n",
+    "with torch.inference_mode():\n",
     "    sample_input = torch.randn(1, 3, IMAGE_SIZE, IMAGE_SIZE)\n",
     "    sample_output = model(sample_input)\n",
-    "    print(f\"Input shape: {sample_input.shape}\")\n",
     "    print(f\"Output shape: {sample_output.shape}\")\n",
     "\n",
     "    # test loss computation\n",
@@ -1154,18 +967,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": null,
    "id": "326bc867",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Training callbacks configured!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from datamint.mlflow.lightning.callbacks import MLFlowModelCheckpoint\n",
     "from lightning.pytorch.loggers import MLFlowLogger\n",
@@ -1216,845 +1021,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": null,
    "id": "1ab7f543",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">[12/24/25 10:57:06] </span><span style=\"color: #005fd7; text-decoration-color: #005fd7\">INFO    </span> Using 16bit Automatic Mixed Precision <span style=\"font-weight: bold\">(</span>AMP<span style=\"font-weight: bold\">)</span>               <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/accelerator_connector.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">accelerator_connector.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/accelerator_connector.py#515\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">515</span></a>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m[12/24/25 10:57:06]\u001b[0m\u001b[2;36m \u001b[0m\u001b[38;5;26mINFO    \u001b[0m Using 16bit Automatic Mixed Precision \u001b[1m(\u001b[0mAMP\u001b[1m)\u001b[0m               \u001b]8;id=682054;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/accelerator_connector.py\u001b\\\u001b[2maccelerator_connector.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=283201;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/accelerator_connector.py#515\u001b\\\u001b[2m515\u001b[0m\u001b]8;;\u001b\\\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span><span style=\"color: #005fd7; text-decoration-color: #005fd7\">INFO    </span> GPU available: <span style=\"color: #00ff00; text-decoration-color: #00ff00; font-style: italic\">True</span> <span style=\"font-weight: bold\">(</span>cuda<span style=\"font-weight: bold\">)</span>, used: <span style=\"color: #00ff00; text-decoration-color: #00ff00; font-style: italic\">True</span>                                    <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">setup.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py#156\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">156</span></a>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m                   \u001b[0m\u001b[2;36m \u001b[0m\u001b[38;5;26mINFO    \u001b[0m GPU available: \u001b[3;92mTrue\u001b[0m \u001b[1m(\u001b[0mcuda\u001b[1m)\u001b[0m, used: \u001b[3;92mTrue\u001b[0m                                    \u001b]8;id=487455;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py\u001b\\\u001b[2msetup.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=456732;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py#156\u001b\\\u001b[2m156\u001b[0m\u001b]8;;\u001b\\\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span><span style=\"color: #005fd7; text-decoration-color: #005fd7\">INFO    </span> TPU available: <span style=\"color: #ff0000; text-decoration-color: #ff0000; font-style: italic\">False</span>, using: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span> TPU cores                                  <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">setup.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py#159\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">159</span></a>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m                   \u001b[0m\u001b[2;36m \u001b[0m\u001b[38;5;26mINFO    \u001b[0m TPU available: \u001b[3;91mFalse\u001b[0m, using: \u001b[1;36m0\u001b[0m TPU cores                                  \u001b]8;id=893085;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py\u001b\\\u001b[2msetup.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=257420;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py#159\u001b\\\u001b[2m159\u001b[0m\u001b]8;;\u001b\\\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span><span style=\"color: #005fd7; text-decoration-color: #005fd7\">INFO    </span> HPU available: <span style=\"color: #ff0000; text-decoration-color: #ff0000; font-style: italic\">False</span>, using: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span> HPUs                                       <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">setup.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py#169\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">169</span></a>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m                   \u001b[0m\u001b[2;36m \u001b[0m\u001b[38;5;26mINFO    \u001b[0m HPU available: \u001b[3;91mFalse\u001b[0m, using: \u001b[1;36m0\u001b[0m HPUs                                       \u001b]8;id=472700;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py\u001b\\\u001b[2msetup.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=255709;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/setup.py#169\u001b\\\u001b[2m169\u001b[0m\u001b]8;;\u001b\\\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🚀 Starting training...\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span><span style=\"color: #005fd7; text-decoration-color: #005fd7\">INFO    </span> You are using a CUDA device <span style=\"font-weight: bold\">(</span><span style=\"color: #008000; text-decoration-color: #008000\">'NVIDIA GeForce RTX 4090'</span><span style=\"font-weight: bold\">)</span> that has Tensor    <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/fabric/accelerators/cuda.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">cuda.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/fabric/accelerators/cuda.py#166\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">166</span></a>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         Cores. To properly utilize them, you should set                            <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">           </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         `<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch.set_float32_matmul_precision</span><span style=\"font-weight: bold\">(</span><span style=\"color: #008000; text-decoration-color: #008000\">'medium'</span> | <span style=\"color: #008000; text-decoration-color: #008000\">'high'</span><span style=\"font-weight: bold\">)</span>` which will         <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">           </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         trade-off precision for performance. For more details, read                <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">           </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #0000ff; text-decoration-color: #0000ff; text-decoration: underline\">https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precisi</span> <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">           </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #0000ff; text-decoration-color: #0000ff; text-decoration: underline\">on.html#torch.set_float32_matmul_precision</span>                                 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">           </span>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m                   \u001b[0m\u001b[2;36m \u001b[0m\u001b[38;5;26mINFO    \u001b[0m You are using a CUDA device \u001b[1m(\u001b[0m\u001b[32m'NVIDIA GeForce RTX 4090'\u001b[0m\u001b[1m)\u001b[0m that has Tensor    \u001b]8;id=352737;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/fabric/accelerators/cuda.py\u001b\\\u001b[2mcuda.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=30094;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/fabric/accelerators/cuda.py#166\u001b\\\u001b[2m166\u001b[0m\u001b]8;;\u001b\\\n",
-       "\u001b[2;36m                    \u001b[0m         Cores. To properly utilize them, you should set                            \u001b[2m           \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         `\u001b[1;35mtorch.set_float32_matmul_precision\u001b[0m\u001b[1m(\u001b[0m\u001b[32m'medium'\u001b[0m | \u001b[32m'high'\u001b[0m\u001b[1m)\u001b[0m` which will         \u001b[2m           \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         trade-off precision for performance. For more details, read                \u001b[2m           \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[4;94mhttps://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precisi\u001b[0m \u001b[2m           \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[4;94mon.html#torch.set_float32_matmul_precision\u001b[0m                                 \u001b[2m           \u001b[0m\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO: LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span><span style=\"color: #005fd7; text-decoration-color: #005fd7\">INFO    </span> LOCAL_RANK: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span> - CUDA_VISIBLE_DEVICES: <span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span><span style=\"font-weight: bold\">]</span>                                   <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/accelerators/cuda.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">cuda.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/accelerators/cuda.py#61\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">61</span></a>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m                   \u001b[0m\u001b[2;36m \u001b[0m\u001b[38;5;26mINFO    \u001b[0m LOCAL_RANK: \u001b[1;36m0\u001b[0m - CUDA_VISIBLE_DEVICES: \u001b[1m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1m]\u001b[0m                                   \u001b]8;id=372060;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/accelerators/cuda.py\u001b\\\u001b[2mcuda.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=836587;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/accelerators/cuda.py#61\u001b\\\u001b[2m61\u001b[0m\u001b]8;;\u001b\\\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/utilities/model_summary/model_summary.py:231: Precision 16-mixed is not supported by the model summary.  Estimated model size in MB will not be accurate. Using 32 bits instead.\n",
-      "INFO: \n",
-      "  | Name             | Type                 | Params | Mode \n",
-      "------------------------------------------------------------------\n",
-      "0 | model            | UnetPlusPlus         | 26.1 M | train\n",
-      "1 | criterion        | CombinedLoss         | 0      | train\n",
-      "2 | train_mean_iou   | MeanIoU              | 0      | train\n",
-      "3 | val_mean_iou     | MeanIoU              | 0      | train\n",
-      "4 | test_mean_iou    | MeanIoU              | 0      | train\n",
-      "5 | train_dice_score | GeneralizedDiceScore | 0      | train\n",
-      "6 | val_dice_score   | GeneralizedDiceScore | 0      | train\n",
-      "7 | test_dice_score  | GeneralizedDiceScore | 0      | train\n",
-      "------------------------------------------------------------------\n",
-      "26.1 M    Trainable params\n",
-      "0         Non-trainable params\n",
-      "26.1 M    Total params\n",
-      "104.316   Total estimated model params size (MB)\n",
-      "275       Modules in train mode\n",
-      "0         Modules in eval mode\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">[12/24/25 10:57:07] </span><span style=\"color: #005fd7; text-decoration-color: #005fd7\">INFO    </span>                                                                   <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/callbacks/model_summary.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">model_summary.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/callbacks/model_summary.py#104\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">104</span></a>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>           | Name             | Type                 | Params | Mode       <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         ----------------------------------------------------------------- <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         -                                                                 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span> | model            | UnetPlusPlus         | <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">26.1</span> M | train      <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span> | criterion        | CombinedLoss         | <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>      | train      <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span> | train_mean_iou   | MeanIoU              | <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>      | train      <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">3</span> | val_mean_iou     | MeanIoU              | <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>      | train      <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">4</span> | test_mean_iou    | MeanIoU              | <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>      | train      <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">5</span> | train_dice_score | GeneralizedDiceScore | <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>      | train      <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">6</span> | val_dice_score   | GeneralizedDiceScore | <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>      | train      <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">7</span> | test_dice_score  | GeneralizedDiceScore | <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>      | train      <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         ----------------------------------------------------------------- <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         -                                                                 <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">26.1</span> M    Trainable params                                        <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>         Non-trainable params                                    <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">26.1</span> M    Total params                                            <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">104.316</span>   Total estimated model params size <span style=\"font-weight: bold\">(</span>MB<span style=\"font-weight: bold\">)</span>                  <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">275</span>       Modules in train mode                                   <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>         Modules in eval mode                                    <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                    </span>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m[12/24/25 10:57:07]\u001b[0m\u001b[2;36m \u001b[0m\u001b[38;5;26mINFO    \u001b[0m                                                                   \u001b]8;id=922859;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/callbacks/model_summary.py\u001b\\\u001b[2mmodel_summary.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=289688;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/callbacks/model_summary.py#104\u001b\\\u001b[2m104\u001b[0m\u001b]8;;\u001b\\\n",
-       "\u001b[2;36m                    \u001b[0m           | Name             | Type                 | Params | Mode       \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         ----------------------------------------------------------------- \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         -                                                                 \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m0\u001b[0m | model            | UnetPlusPlus         | \u001b[1;36m26.1\u001b[0m M | train      \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m1\u001b[0m | criterion        | CombinedLoss         | \u001b[1;36m0\u001b[0m      | train      \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m2\u001b[0m | train_mean_iou   | MeanIoU              | \u001b[1;36m0\u001b[0m      | train      \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m3\u001b[0m | val_mean_iou     | MeanIoU              | \u001b[1;36m0\u001b[0m      | train      \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m4\u001b[0m | test_mean_iou    | MeanIoU              | \u001b[1;36m0\u001b[0m      | train      \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m5\u001b[0m | train_dice_score | GeneralizedDiceScore | \u001b[1;36m0\u001b[0m      | train      \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m6\u001b[0m | val_dice_score   | GeneralizedDiceScore | \u001b[1;36m0\u001b[0m      | train      \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m7\u001b[0m | test_dice_score  | GeneralizedDiceScore | \u001b[1;36m0\u001b[0m      | train      \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         ----------------------------------------------------------------- \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         -                                                                 \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m26.1\u001b[0m M    Trainable params                                        \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m0\u001b[0m         Non-trainable params                                    \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m26.1\u001b[0m M    Total params                                            \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m104.316\u001b[0m   Total estimated model params size \u001b[1m(\u001b[0mMB\u001b[1m)\u001b[0m                  \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m275\u001b[0m       Modules in train mode                                   \u001b[2m                    \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[1;36m0\u001b[0m         Modules in eval mode                                    \u001b[2m                    \u001b[0m\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d0ab190d2cfa4da1b87d9b1615f21311",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Sanity Checking: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/utilities/data.py:79: Trying to infer the `batch_size` from an ambiguous collection. The batch size we found is 16. To avoid any miscalculations, use `self.log(..., batch_size=batch_size)`.\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "0afe1bb2b68044f082327d9151c1f9a1",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Training: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/utilities/data.py:79: Trying to infer the `batch_size` from an ambiguous collection. The batch size we found is 2. To avoid any miscalculations, use `self.log(..., batch_size=batch_size)`.\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "84b06fb2c8124e4ba22aa924ee4bb0ba",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/utilities/data.py:79: Trying to infer the `batch_size` from an ambiguous collection. The batch size we found is 5. To avoid any miscalculations, use `self.log(..., batch_size=batch_size)`.\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "5763a18173f34f6c9182882c2cd987e8",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "cc2b3471cd444d4b8a73bde0e7477323",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "7fe8a1820b2e478fad6d334757b7c1d3",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "b7c26fe4bf7f4ed185914194185ee0e1",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "5c575c2a73474df0a7ada34be42c37f8",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "8e200a034a4f4f7fbd1b71defa79a915",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ec0479f5f2b746cca04c6cf3bca8f94e",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "af762f1271ab40f5bdca7a9013ab849c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "9b48a8da6fa04451835caec91cc2bc25",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "8644fdc604e6414583476361c2fc4256",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "86ded363b458488c95eff1af5ddc617a",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c08b18ed1eba46df939f6b8b31b87ebe",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3f90a7aff8e54cfebd0bb39401cbd966",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c75657b729514692a1d485a4f432ef46",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "b08e160aef9142aab1fc11a3bc0ee568",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "db599298d1904e579c40b3e2998c4f2f",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "8fb068f2bf1e48afaa8d2db015bce48b",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "16d3a0392192429e847017912fccdfc8",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "be3b8a8a481f4876a9bf568567104df5",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f3d2ac9606b74729b99958768ce5f29c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ee100fad47e4418e87bbe7a0555adb8f",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3d1d48f86cdf45dba9c4d17be932fb7e",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "7e04f8235cad4ea2a9c31cd08a4c76f4",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ee03488543a94b1a93ad94affda76c74",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "7c20e2cd48f14d428abd10b779e0f36c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ff733f731cf343ea9154dff3f9a29cce",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c4228c23423d4a1ea0b0846665fbc98e",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "9e3747be7c8e4385a2e13dd5e18f2a7c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "4297508454834c028658e2a7112d71b8",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c3a36c2649aa46c7b7692cd604849447",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "29f5975ada2342118b337c05d557081d",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "0aae4d46be484fe98d8c956913929763",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d344dc7fff5141be953b7f5b0ee44416",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f28f32275d3c4374ba1b42dbccb667a1",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "93836b2f9d9e43f78ddf64af5969c3fb",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "588b0c9c30bc42b59742f7eb1e72d76c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "7dd224e558714482b88968f04bd73623",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "aca61abbd13a4c099692d15d87d47171",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d4f83bc0f7574a02bebf56ab5c0b6973",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6c912c9945bc4368b0e06b46889d0650",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Validation: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "28b7271b074f4c7fafba524ffc96b3f6",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Downloading artifacts:   0%|          | 0/1 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🏃 View run unetpp_resnet34_busi at: http://localhost:5000/#/experiments/6/runs/4bf421489a8640499334b6a64d5a3494\n",
-      "🧪 View experiment at: http://localhost:5000/#/experiments/6\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Initialize trainer\n",
     "trainer = L.Trainer(\n",
-    "    max_epochs=50,                        # Maximum training epochs\n",
+    "    max_epochs=20,                        # Maximum training epochs\n",
     "    logger=mlflow_logger,                 # MLflow logging\n",
     "    callbacks=[checkpoint_callback, early_stop_callback],\n",
     "    accelerator='auto',                   # Auto-detect GPU/CPU\n",
-    "    devices=1,                            # Single device\n",
-    "    precision='16-mixed',                 # Mixed precision for faster training\n",
-    "    log_every_n_steps=10,                 # Log frequency\n",
-    "    num_sanity_val_steps=2,               # Validation sanity check\n",
+    "    # precision='16-mixed',                 # Mixed precision for faster training, if supported\n",
     ")\n",
     "\n",
     "# Start training\n",
@@ -2082,7 +1060,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": null,
    "id": "59751c46",
    "metadata": {},
    "outputs": [],
@@ -2104,192 +1082,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": null,
    "id": "4f42eebf",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🔍 Evaluating on test set...\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py:149: `.test(ckpt_path=None)` was called without a model. The best model of the previous `fit` call will be used. You can pass `.test(ckpt_path='best')` to use the best model or `.test(ckpt_path='last')` to use the last model. If you pass a value, this warning will be silenced.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">[12/24/25 11:01:11] </span><span style=\"color: #005fd7; text-decoration-color: #005fd7\">INFO    </span> Restoring states from the checkpoint path at                <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">checkpoint_connector.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py#81\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">81</span></a>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #800080; text-decoration-color: #800080\">/home/lhsmello/projects/Sonance/datamint-python-api/noteboo</span> <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                          </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #800080; text-decoration-color: #800080\">ks/use_cases/6/4bf421489a8640499334b6a64d5a3494/checkpoints</span> <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                          </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #800080; text-decoration-color: #800080\">/</span><span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">best_unetpp.ckpt</span>                                           <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                          </span>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m[12/24/25 11:01:11]\u001b[0m\u001b[2;36m \u001b[0m\u001b[38;5;26mINFO    \u001b[0m Restoring states from the checkpoint path at                \u001b]8;id=253080;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py\u001b\\\u001b[2mcheckpoint_connector.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=755053;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py#81\u001b\\\u001b[2m81\u001b[0m\u001b]8;;\u001b\\\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[35m/home/lhsmello/projects/Sonance/datamint-python-api/noteboo\u001b[0m \u001b[2m                          \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[35mks/use_cases/6/4bf421489a8640499334b6a64d5a3494/checkpoints\u001b[0m \u001b[2m                          \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[35m/\u001b[0m\u001b[95mbest_unetpp.ckpt\u001b[0m                                           \u001b[2m                          \u001b[0m\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO: LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span><span style=\"color: #005fd7; text-decoration-color: #005fd7\">INFO    </span> LOCAL_RANK: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span> - CUDA_VISIBLE_DEVICES: <span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span><span style=\"font-weight: bold\">]</span>                                   <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/accelerators/cuda.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">cuda.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/accelerators/cuda.py#61\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">61</span></a>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m                   \u001b[0m\u001b[2;36m \u001b[0m\u001b[38;5;26mINFO    \u001b[0m LOCAL_RANK: \u001b[1;36m0\u001b[0m - CUDA_VISIBLE_DEVICES: \u001b[1m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1m]\u001b[0m                                   \u001b]8;id=251997;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/accelerators/cuda.py\u001b\\\u001b[2mcuda.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=724156;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/accelerators/cuda.py#61\u001b\\\u001b[2m61\u001b[0m\u001b]8;;\u001b\\\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span><span style=\"color: #005fd7; text-decoration-color: #005fd7\">INFO    </span> Loaded model weights from the checkpoint at                <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">checkpoint_connector.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py#224\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">224</span></a>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #800080; text-decoration-color: #800080\">/home/lhsmello/projects/Sonance/datamint-python-api/notebo</span> <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                           </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #800080; text-decoration-color: #800080\">oks/use_cases/6/4bf421489a8640499334b6a64d5a3494/checkpoin</span> <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                           </span>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #800080; text-decoration-color: #800080\">ts/</span><span style=\"color: #ff00ff; text-decoration-color: #ff00ff\">best_unetpp.ckpt</span>                                        <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                           </span>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m                   \u001b[0m\u001b[2;36m \u001b[0m\u001b[38;5;26mINFO    \u001b[0m Loaded model weights from the checkpoint at                \u001b]8;id=831450;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py\u001b\\\u001b[2mcheckpoint_connector.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=18080;file:///home/lhsmello/projects/Sonance/datamint-python-api/.venv/lib/python3.12/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py#224\u001b\\\u001b[2m224\u001b[0m\u001b]8;;\u001b\\\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[35m/home/lhsmello/projects/Sonance/datamint-python-api/notebo\u001b[0m \u001b[2m                           \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[35moks/use_cases/6/4bf421489a8640499334b6a64d5a3494/checkpoin\u001b[0m \u001b[2m                           \u001b[0m\n",
-       "\u001b[2;36m                    \u001b[0m         \u001b[35mts/\u001b[0m\u001b[95mbest_unetpp.ckpt\u001b[0m                                        \u001b[2m                           \u001b[0m\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "52a8ab21a9aa4b38b8df9c996159fa90",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Testing: |          | 0/? [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span><span style=\"color: #808000; text-decoration-color: #808000\">WARNING </span> Run ID mismatch: home != 4bf421489a8640499334b6a64d5a3494.      <a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/datamint/mlflow/lightning/callbacks/modelcheckpoint.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">modelcheckpoint.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///home/lhsmello/projects/Sonance/datamint-python-api/datamint/mlflow/lightning/callbacks/modelcheckpoint.py#361\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">361</span></a>\n",
-       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         Check `run_id` parameter in MLFlowLogger.                       <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                      </span>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[2;36m                   \u001b[0m\u001b[2;36m \u001b[0m\u001b[33mWARNING \u001b[0m Run ID mismatch: home != 4bf421489a8640499334b6a64d5a3494.      \u001b]8;id=321080;file:///home/lhsmello/projects/Sonance/datamint-python-api/datamint/mlflow/lightning/callbacks/modelcheckpoint.py\u001b\\\u001b[2mmodelcheckpoint.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=696212;file:///home/lhsmello/projects/Sonance/datamint-python-api/datamint/mlflow/lightning/callbacks/modelcheckpoint.py#361\u001b\\\u001b[2m361\u001b[0m\u001b]8;;\u001b\\\n",
-       "\u001b[2;36m                    \u001b[0m         Check `run_id` parameter in MLFlowLogger.                       \u001b[2m                      \u001b[0m\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "e3163811369b4e07a7c9c451d4b39a29",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Downloading artifacts:   0%|          | 0/1 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "58f7185168844638b31170c13f0a3591",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Downloading artifacts:   0%|          | 0/1 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Successfully registered model 'UNetPP_Segmentation_Tutorial'.\n",
-      "2025/12/24 11:01:11 INFO mlflow.store.model_registry.abstract_store: Waiting up to 300 seconds for model version to finish creation. Model name: UNetPP_Segmentation_Tutorial, version 1\n",
-      "Created version '1' of model 'UNetPP_Segmentation_Tutorial'.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\">        Test metric        </span>┃<span style=\"font-weight: bold\">       DataLoader 0        </span>┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│<span style=\"color: #008080; text-decoration-color: #008080\">         test/dice         </span>│<span style=\"color: #800080; text-decoration-color: #800080\">    0.49704456329345703    </span>│\n",
-       "│<span style=\"color: #008080; text-decoration-color: #008080\">         test/iou          </span>│<span style=\"color: #800080; text-decoration-color: #800080\">    0.6038552522659302     </span>│\n",
-       "│<span style=\"color: #008080; text-decoration-color: #008080\">         test/loss         </span>│<span style=\"color: #800080; text-decoration-color: #800080\">    0.6820588111877441     </span>│\n",
-       "└───────────────────────────┴───────────────────────────┘\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m       Test metric       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│\u001b[36m \u001b[0m\u001b[36m        test/dice        \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.49704456329345703   \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m        test/iou         \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.6038552522659302    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m        test/loss        \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.6820588111877441    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "└───────────────────────────┴───────────────────────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🏃 View run unetpp_resnet34_busi at: http://localhost:5000/#/experiments/6/runs/4bf421489a8640499334b6a64d5a3494\n",
-      "🧪 View experiment at: http://localhost:5000/#/experiments/6\n",
-      "\n",
-      "✅ Training complete!\n",
-      "Best model checkpoint: /home/lhsmello/projects/Sonance/datamint-python-api/notebooks/use_cases/6/4bf421489a8640499334b6a64d5a3494/checkpoints/best_unetpp.ckpt\n",
-      "Best validation IoU: 0.6097\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Evaluate on test set and register model\n",
     "print(\"🔍 Evaluating on test set...\")\n",
     "test_results = trainer.test(dataloaders=test_dataloader)\n",
     "\n",
-    "print(\"\\n✅ Training complete!\")\n",
     "print(f\"Best model checkpoint: {checkpoint_callback.best_model_path}\")\n",
     "print(f\"Best validation IoU: {checkpoint_callback.best_model_score:.4f}\")"
    ]
@@ -2322,25 +1123,7 @@
    "execution_count": null,
    "id": "88bd7fa3",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "IoU: 78.4%\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/dmPbdl133vu02RDMiU2EkUme1JUY1lXsH1dVSrIBZUvYBQMox4MGP4P/DfVP+An48K4r4YfChDKhgxblC1bFmXLpNhkJhuJPZnN6QpjR3zifM/QihRlRaDq4czMjYgTe6255hxztL8x5lx3njx58uT0vD1vz9vz9rw9b6fT6e5zKjxvz9vz9rw9b9pzo/C8PW/P2/P2vF2150bheXvenrfn7Xm7as+NwvP2vD1vz9vzdtWeG4Xn7Xl73p635+2qPTcKz9vz9rw9b8/bVXtuFJ635+15e96et6t2//RTtMePH59ef/3108/8zM+c7ty589Pc8rw9b8/b8/a8/f9Rmy1pP/zhD08f+9jHTnfv3v3rGYUxCJ/85CdvcnzP2/P2vD1vz9v/D9rXvva10yc+8Ym/nlGYCGHaP/7H//j0b//tvz39s3/2z87Rw5tvvnn6+te/fvpbf+tvnb797W+f/vW//tenT3/606fPfvazp1/+5V8+vec97zm98MIL589cf//+/dO9e/fOVurhw4enR48enT/znZ/z9/l+Pi+++OL53/OZZ8018/eXX3759N73vveqr7GAc+/89Iz5OdewiPP9jMfvE/H0vnnGO++8c/rRj350+slPfnJ6++23z5/5bq6dz/Q1c5lxzRjc77r5ffpwz1w/45h/+8y/O/+5bsY7zRimH8345rp5NjrNM81/fs6Y5jrfG8+0uUaE17nMNXPvfGY+rpn7Hjx4cEWn3m9+Z+a5f/88Js83D2PwrLnnrbfeOn/md2Oae+e5aNJ7uo6zbq5Bx3nG9DXXdIzG1LnOZ653b3lv6DhzNS73WWNzmrGhi/vR2TjRwFj6ca1nTpt/43VjnL6N4aWXXnqmP8+ZnzOO+Uxfc0/HoemrPGAs7tGv7zqm6ctchz6ePfSd331cr58ekjA06bNd22fPeNw7z0IbY+m6+G6uQ5uhg++6Lq7zO56ez49//OMrHnCdZzy5lB100vfcb26b7zq2uW94Bz/g+/l4Dvqih+eZc2XIPOf64Qn6csbjOm3un+dYX/z+p3/6p6c//MM/PP3O7/zOlT7/axkFEx5meN/73nf6R//oH53+5b/8l6ff//3fP39+5Vd+5fThD3/49Bu/8Rvnh06bv22FUgXXhdvC2n93shaE8COqxZ6fswC+p3TdPwJUw1OBQegKSxUVIatiwNyeT+At5DBF51klWubDeK413qN1qECVNmXiMgtlQWhnDFWSGKqCZS7GsBlsj6MCXzpphI/RMxd/Z5i2IZ0xTRuaolsN6ITC1m++5yiYZ3mr9PZc60jBmi+enT7rVMyn/ybkc10dEuMpj1XxdK5VKvgV7Sov+p+/cQAqF3WsyvPa/N2YPL9G/4jnPHdoNHKFRu5hIKyZ3yuro8TIqT6tYZ26Oouee2QUKouex1Gpztg0qdzTBTWmNf4PL/l399e/d/wzvzpV+Aqt6mRWjjkdeLWOYvXGrPfMtQai8qPP0snc/fsDH/jA6TOf+cxZP/9lKYCfyii0EYZ//+///ek//af/dPqt3/qt07/5N//m9Iu/+Iunf/pP/+np937v964Gj4i1itMoCMShgObf9Rx5QpSc6+b5ZVBEJ6SY53vf+95f8LoRaZh1iG1BSth5NmbWZ5mkCsvv20OnGCwQoawCFQXNM7ZyqABtJVvvjhc3nk+FYBtPjL+Nr3GUYeuVz3UTpaF5FUkZ1HynjQJplIXGxre96Aod+hNSY+wzeMOe0bEQMmOpAe369Z5GMjXgY2QontJ0PtZuPo220Ht+NwZKtd6xNbF+opVGIvigzxXFWMsdpXZ9thOFp/HUNtJkZPqfzziAlBn+sj5V1iJ4RqLr2kiyhnf+3aiwnj3HZTs+6Iw3XDP/puRnPjPP7chtJ9T8p81aFUV4fDnPOhSeY43mU+99eAUyMmjDyMzopRo9yMd2VjT8WGcAnfHFzLPRlnE2gmdwXD80nbWcXMJP0/5KRmEmXIIPo3zhC184Rwmf+9znTj//8z9/ZeUxNSY5CtV2iFrPntKr96HN9fNsROTF8Pr2wtYDLRExf5msCglMcxSi1ShUiVdpTRvmwJgMIUEwzip5DFAPUGNs0LjXHYXmVWA8cmOugt5Gp8+tEaMkK3BVLiMEZfj2VUiw/XYujRIphs63fbq3NORgzMdYjp7VuepvPjx+f6vx1M/QsN7v8B5ok7HhVKBVhbXRmr/VKBw5MZq5lR89q4bG+BmMKtwajHrPNZyiYYpv2qxbvW7PNqfKdw10I9LyVHm5DV9uw1PvGb824qoHX8fGuMtbaEmGyazxvPnmm1f6pLK5aVRZLi+Sfw5VI7M6JXSLNduRZeezo54tD11bcD3nuwjJT9P+ypFCrZc2TIkxEa6CWK+zyqhww1HoW4HqYrge41COxX3ruVtY/e8wuUahjMyL01fD7CqLafVmzcGiGG8FsF7gpu8e4w7v/ayQlXHLwIXEaijRvfQujV3L+6MM59PrS6syfOewjdYeZ43GHmOZ37jKJ9uRcN3OEXhur+m6NpKqQa7R770bFqXUzX+MRZVjYa0dAcCAQXg7Yux4GWDfUUActu1AbaOwv6OUKrc1Ps0f7P62HFVhFSIlq52zCGvz3c4pdP08o2uzeaZGpoZ3Oz3lhcrO3fAu2nSe5MHvzRHWMJjLrFUd2x2xMG6e4/mlpXnTJdsRcn2NJN6uo3wrRgGcg5gf/OAHT//kn/yT88A/8pGPnJPNLKVQuiF6veIyOGUyrcqz3hqv3STLMJK/lBciuH+a+yyAiKfJPQzjmX2OdsRcYKhpowy6cJ5dT7IC2MhENFNvukyKjjWq7pFUrzDOc8djxqDbW/JM99SjQafi0GCZejwdZw3G9lyq9LdBODPiQSJ5Q3ZVHJ0HfjOfzqXGWgiPz3jDVRDm0wiLx2y9x/szT14i5YnP6zUXZnOff+PpHQXWkG9YsBCKiIAjJLG716bX777RbSskvDZ9DjTCsSr0sh0WMkIhlgeMhy5pNND1NIfyp/uNrdHBdkJ2hLe97PaBlvTA40sDb61r5GYMyvKrnxSo1BmTXK5DsWWz8yM7Wg3Akf6Z+1555ZVnjBIdOJ/Jtw2aMj85K7cWKQwD/uf//J9P//Af/sPTP/gH/+AMGf3CL/zC6Zvf/ObpX/yLf3EWmBHQSWxMO0reFoLYiyWkm0bYCslgViEeYWiewULUC9pefBm7VpfFFhZOq4W3CBsHRfjOdxqF2HAVk/HszNX4WnVSBbkVaxVeIbl5ZqtqXF/YospB0q4eGSPAeHoWqA7dGYMm1f2dspWEo8Aafld5dQ0KKYLaqmj0XcHu3NxX2LCRKWG2FvigimSH6HivuHk9dsapzy+s4+eOhs2zzgwDZsyFIcsvjHSVWfmyEEeVYT3vrdgb2czfGnXNvwuLba/1qPrJdfidwe0YS+86PK5pYrhr1lZEYHvl1t+4ySIdc8RLL1zqHT+73uQQ7bYeq1HqPPccCyd2TUWULYoxJ7RxXXWFNdUveL7R9Y0ahbE8oxSmLHUy2RMpzEDm7/Phdc3i/+zP/uwVMebDg55mEarA/T7XVTgtQJN2Fr5KcnuYjUpKcIxbptrJT8xSxqxXMp8Rfs9RcdT7zamGZQttsUhjLQwwbehxtViX4z4S3gqm6pTSdzN812bPzdiUjNZ7rLdRL7hKntI1pxr0LcxVcsbQyMU920OsUBn3EcTQJGgVrefV4BWGLF12K620RhuFBTbv9Rr9uH8rR1FNjfpe+4kQycXwSg1JPXWljNawiqbKt7JQWLWOnHv0VRrX+Gz5lVzeNO280W1HVjuv13src0eR5JFTWJnecN69yNXONzRibAHHhmvaX41Soa7ype/RSn9osedcHqpcdV74pFHXjRuFiQYmTPrn//yfn/7+3//7p89//vOnD33oQ2fYaB4+exOmRHUy3ZN8rqc+RoOlpwwtCIUvQdhqI0SYa4rbzsTnb5RP67Ytyq6RBs2oNmgo63eCxMMlmDscnzCSJZ8xi2hGSEEZ9fC3YhVe1opTwioH+v20lr1N3zz0+XuNqb/PWGYtKHh/r7JCsx/84AfPeDZC0embFzveahVUMfj5O6G3jpiy19Xz4t1W2TPahZ82tn4Ew7iuURp+mb8PHYT/kogtf6RIGm0ygFVSVTCtIMKPhcHqlZZ/dgRSh6BOiDlQvGjX6yciFy3M+hQGakVZI4oNl6K9CLzzq7dcr5jiGr4j5/iK7JZ+w3uiqJlTYck6dlX8dfD0syNKdKhTiT/a/5HT1qKUIz3xQvZYbT44K8/sM8DPimBqjJtTrPK2NjWK/k3uCyV7pufQlWil7+ZCK09H0dVf2yiMQfi7f/fvnkubvvSlL52+/OUvX3kqw0zf+c53Th/96EfPE/n+97//jIdH8ZbZELkVTWWEJkI348DKEXKYYf42BmpwtFaF1POZZ4+CeP/73/9MOF9srkxgDhjd30a5IHLxwZn7YH0Yyt8pLVHV7BK3+YohmXtFCc1pFOOsBztjmGdNVCaXskPFerT1THcUw3us562PoePQdNa3Xoe1bzju3xNFFk6hhFsaSZFxAlpF0/0eNtugH2GeRrngAc7BfN+IkGHhVc1HGaKSVIqgIf607kup994Ia+5Tkrj5ulEBBYmfZv5KfjkCG8ceGhbLHt71HI1RqrLc0BfeYPSrwNsPAznzGaMzPAa/Lq/gUQ5A4axGA+iIti1IqAE1P/fUsBaC6XfVDWAmSr6lu56rNUreOasn2QjIecSrNS6FirqplVzNNVupNy8DEiyU6RprUL2I/7chm+tGN1dvFpUA7R5FWn9to8CLJaiINgwzbQTr1VdfPUcJ43l2MvUCMPtReFbMtYJdS04Aa20pYYmxIfgYJkxSr5Iw1gtqHgKjGQ/G3eFeMVP3gth4G+1jvp8xjYL9sz/7syvFV48FxFEDWk92h8G8At5A51kvWGMwMDXB7DOP8hn6pdBtZKw3vNe3nlaFqcb4aEfxtI6HEpx/MyKMWj2vvadkRyS8NVFVeQdfH3mVNbQ7OqoBrZBuaMi6Dv2GbvUqGTN82QgTLtzfxxhXUbq+uZPKTdeSwtuwoPHbADq0ZIwYu8pB+bI4fg3Vpoe1cO/+Hq00HnN1SB2srrPx2w+hH/2LhPZzdvRwdxmp/r0Grwak/KJ/3+2NkWje3eiNqlyzI+g6pp7f3E5RBX1qW1/dqFHgsY1VmgQzuGSiA14rhTHKr0JKAbDKDf0IDe+tOJhNQD1CoJUMmEE/o0AYhWljnIyDQM84eIYE1TXb85vnG0sVkM1yVQxCuumb4BRrnf7H2x6jMONyzYxh+iPsozQwlp9HSUbMJizFxK1k6O7KYsTFTSkbjFSjwBOktAu/zaeQAk/Oxqf2g86FBOt5jnKc52DoRllDl+Et6ySCnL8z8jVKdR6sOcMzvDsGeSfgRZDuqUJAOwK951Ce2DAmpTFjNY/xvutlt0pFJNS1aBLb2uK/Vju1iklEIvoxxhkLKMfaoPN8p2Jlfu6Ngk2qm797Ka7KQz3dGqWtUMs/jTCmD/SwwZOxqxJsSbx1qByjdTfgdZdwo6W7qxqqTgIPnk7D741GGR8RwKxv861V8LuwwHPnb+hdaGnTrbxaevT6jv1WIoWZxCj/IZRBIISFGcGiNJr0sjMSUTEO5Wtyji6osqun3Y+GIRCWYArLMdoo4u4b2DgoIfQ8UId/YyQeDw+veY4yS41VPQ0CXM9rjMV8KnTTpm8KBsYoX9BQFJNUaLrTuUxSY2TdusN7Q3WKBOYjfzHMXqPHE0bPcQoaFhfGqpLD9NPnjLUKmJDaiNYzg+aa6X94B0wz19lJSkF0XqUdAWplUJXTrnISudTj4sla91Zh1WmghBhyxk/UYp7zGaNRHvGcbrJ0PWcJXZv0bWKX/BlLd6fvI2LkDWeMZET/G9pCnxoM61GnhfwpgPA8rTBXodiZA4NZea3RQSuy2IKW8iaeb0QhOjSeGs17OVdJ23rBOOaD3+f6OUlBBNg8nFzjtMpXHefqr/n30JMzPn8bHdY16PpojVzwNnj5VkpSPbQQhoXjlVIYDWF3vqAW2NbtKudGAUdMUHx07vesraxdU8tcxb2ftZPTcH+eNMECpXVBjG/DMKVbLf7+u/soJQqjdINB2ynZZ1e51WgXaiBs9YKm8XAaIcz9VW6UrPsYthoZkBFl33JkisQ1KrgINQPmGmtAqRdKEVWKDEWnjILaeocnFnPmnROSlu41JwEqsy7azvEU2jNHCq6wIDrNmBj7Qll4Ad0kTcE95fH9zGkt5Gilj7VtJFVlaK3nGpCrOXbexd4Lr6BlsXX9V0FxNijvwll16PTPwBpz0YJ61mi1NxDy7Kuzdp5wQ4RPnjx5ZuPhrrarU7WT5XTMOLbDh8a0nUP6q9BY5bS0nfvHSFcPTLMuzRXUkarRNq8N0d6IUdihXT2UMmqrHgoT1TpWoWF+E2j4X4ZqKNpdyz3BUQKn29Qb0mnbey5jNoRkcFq9Ma3nnYh03FNoprRreFzGFBFhtnkmiKl4tvCesi5D1tBWIW3h6W7M3ks5TAN/iDSq2HelR9eZEq332rC88B9vq4m2YX7X66P39V7KdarfQIzf/e53r+A7EcF8JhHfxO48p16c9aVUKKaJenf12bSjQ/2sOwNGIW1PcOYg2mLcG/JXWUtsyiO0GKJ8y5A3YhzaWifGrgpFJNUcC6O5PVfzr0ffVrrNfa3rbw2+56lyKvzjuo5zR6LN+zSaLFy30YXqnMo5JVlnFA3urfutdemBR+v4WceeCCzHuftAh8JRxspp8vyWpVcf7jXZY/Q9frk1o7BxtA6mJXO1Tia8d+MyFhW8Clqt57R6Wpi9nsERUXqEQL2GIwM3f5fF396+hff7GILZxT1J9SnNHZx4b/TyrEY6xlWmoJhcZ048llFO8jWjpFUDWWx9MHqtn64hm79PVdD0xcOuYnCQHQ9WtAKjNZ8KGrrOvynE1rQ3hCX4Gjoz8oU4COfc05c74QHGZ0J1Y5rfjX/+NsZg7v25n/u5K+MztBtjO8ZjaCj6oXDwXQ013t78ICSnkEQnsF7wJQOLhvMsRtgam0MjAH8DGxY/rmGtkRbtOm6cwm6pbteQjPgOBs/xqCOzobbyALiysFvlpZDzUfUR+jZS2x7v5p/yTvH55gp7rf7xHZoe9TuNgaXrWvZt/F0zfe0KrBrcRkqtyGxhRZ9bB/Uooth5g0b+eOJWjYJJ1zLWSFSBI6oJNUTu7xZ1Wz1/109D/JYxFj/cUM4u8SvB9LsNhDn5vvipOc73o5zfeOONs4KZ3ylZ4aHr601s41X69ATLmd8ouPm03M/8K1DWxTWdE0Ox5++ZmJRR4nHPWEapCG95gc0L8WDQGO1mLIUGyrSloetL+yZEu1+knlI9x1auTQMLGc/cBx+3rgwqmGkaJSpxXcjF78WQ0QukSNkxrNZBHXmT/fPpfpNGHYWeWvgwrd6k0l7es78xhl3DKu4tn1U0msgFFNJ1pKi2EStSUIh2y2WfXSeoDk0jhW2wtuKuPDcCrwImG1vWzas6o0b/zjpXqM6q/uqM0Tfz3G4era7hLDUKOIKMzB2fddw1RNVtR/JfPSjyvBWj0IduZY/AtbRVfP7WAdfS7sWvMqNsMd4+qK7P1HchkSMPvqHYu7UqNAxPYCjASRJbbGE8RVsh8rxd5UIhzz2zeGNoRqHVuvN0NhzQtUEn42x4yluDq5cpKaoqbR7hKMu5jxLl7W2D2jXbCsVnQ2pVHs3RdN14VI06QIXlsVbkNAICE8yzQHPzc+jMS3Vvob/yOOHEf/PBD+hh3Oag2q7ecb3M6W8nRVVkbRr1Of7N0ahc6LPVanWwys+FFtCwsOyGNSr3NQobt+9zd9RgDXc0WV7q9S3n3A5n4dLSsEau7d0cVmvyZG2I3Eat67f7PNKJ1yEGdT72vOv0FWEonRpFel4NUJ9PX9xKpKCk0EAxxR54CXNkDIq3l+nPA0pyWpVPPbcmaXYYVwPShfJMY+XBl3i9tmWyVUS8Z4rZZwzC9v4bFurbvSKDKvLW9RP0LnYrLLYiNmbeV0PG7ZHA23uUxrSBWSQzKYYZm0StcsgZs4iBV2StzIeyLgxYRVNBqyBInktCl9aFG1W2gW9qAEUuDMLcN9FcE7WFOgpvigjm2oGc+n4EGxKnv8ldwMWnHSnG5hZ8yrvlefOan/McifPi7+Mk4JPtINXrrbGZpLG1b/QKeuvf3ctIiQxqGLZyL+/Wq24erJU87sXnrQIshLNhkx29N0KuktRaFmwc5UfOSev8jeVhKr6qMzrPrh2dVSVeZ49sikYZ6CrobRzxj3nuqHFHF3W06AvXiShaWHGjRmF7CptAPKNtZTvZMkcn1TDUhCz8Do8kNStgDRMb5u6ywJZi1juzMIVbdhTT74xnn51fQcWcFWD3tjKo9C3Dz8euYYu9PZxGLhXMGuMacYoG/m4tq5g6hpmbjYrTzIlXaiyFkKyl9YV7G0NDdPfUiHUtN9zkZTX2QlDc1tb8uiGsmK2/dc0bpZrL7Iyn1PHaPE9+o4n2o9AexENmCrvVG3cfmGyiw1Eekw+R//GdJPpOTlKYlBFeawk4Q7NPPC0k2CqiQsNkp85alVYhvCrvnlx8hB7g01aVlZ7lmXr/lF0NbqPxRk+iRn/rWqFTk95PDl6Rig7VYduYGn+NlI/vNhrSZ23ZqR7d9Oj6bpqUv3YE0lL3W3mfQj19A6gnWKipWF0JUibZnnZDrP57E0oYvQ3ODsd5vRJBLScr49aLq1FAVP/Wb+e057ohCEpjh37b85jfW9pZmrQdha7mb0w9SrlzquHjvbQ02PgpCn1u/Hifz9RxbJ7ZcMLRfPb4eHXlH9fOcyl7z6gi7ho1MhrlTgFPFNE13nh4vXzHxrdooSF7BZ9watsBaDTd6Jpx9WzHn2znxH0tjaSEPVtOg8GtAt3eNsNcA9Ok+o56wKIbCqpn3n0v18l4HYEqxyq5I6MA0quD4R6yigcKv1XOrMuWmbYas62cy+vlGddvRxM/NPfSa3cEcB293M9w+I4B2w5n6X8rkQJFu61OPdY9gBmUjRs71EGkWmltewoN4xohVNFPq3fuHiWKO1LZkc/2aveigDR4EVUADf2M6yhiwAwEuOV8NURbGERBW8gKcxWam+taLtt+Zx7znbG1PK6w0/x7MPh6nn12haNGdleoHAnJNgotGe4cbYa0vujXCq6WNTPuPGNJ1+nHkSwzl4FXJiKo4dvGtcoGVIivRCbWptEP+Kr0bMFB+Q69Wg02EJU8lc2FhcfwvP0ySqQnwqDknQHWCij82AisPDz9g9BaAkru/Ft1kzHop/JbhV2vus7aEX/UY67cVE63cds7yDcEzag3EjLeOhKPo7zn39sx2wara18I2PV401yq2zqWGt2eBYcPa/BKn/Lclt/qZTxxK0YBwxtgk547DEdMYb9J6OvIGnZy+7kIPsIjPD/aXLQxSfe3AqNe8hbsErpjaBhcz6CKuvPvPCogG6M1Rl7VTpT1Pp5klb9/a4yle0rjKiXXzPhHWVI4Tkzd4Sjvz5hLtypF46w33Ln0U8EqpEdRNqqbphyzTF4j0SjG3wkaxalix7uHKcMm++d5rXBrRAl6mY9d2OXd6zb9eX53Le89PY0IGGFVTVs5tWx0ooIxcrN2ZEIifUdv5ctCHy2LxIfNRZQvvQ63UNJ2srpha0cCdZD6PUcK9LMT8dUzVeyFaPXZ/SIgxSrNKlPXv3S5TuUjbesOslWUwnUMcM9e6zpUn6CxZ3b/RA3WjpzKK9uZ6TjroN3KPoXt0V8X4mwCXBe+HBmG64hYnHqX+tVzbcjX1nfWdk71UGtg3G+B6jXVazkKY7XCaBWYVpkUsmmid3sDpdF1oSDa1WPGvP7up4oj42HgCbu59tC67fHvuVZJ1Ps8ioI6zh1hVQEXqiz2vNfrunWxNvPMUZ74AH3r/dWQNvloXFqx3w03FoopvxULLo0L5VWgN5yyPW5jba6KEpjv5V9K7yPPfPNSIxJtQxAdSyGirovIbj9j02rnBprTaAQuutm8hIb9GB9DQtnqe8u5a+9njbeTuyHSGskZJ4fVycCdI/nY+sdzNxxvjHhy8+vmueY46JbyNb66FaNAgdaytwrgOoW+PcYdQm+j0cW/zhNrSNbFK6ZfC9ywsQp+45XGPK0hb+9xTeEp39d4YfIdRdTzqgLGHF3wjevqt2Pe9Ceku+KgXjoIoDX3M3Y7tSlmXpYyVvPeOC2hkJjm5Tr5c66VLC1kY24dz05GV9lvxXm0JnBv5xExbD1aYhunHeFUsOvF4pmdzG1FnP7Ku/P9eNgOPzQ+dKxzsvmLwWhEZs039Ni135BCDUrXsUqWQWNUSv8jWd2RYh2N9t1W2a6B3E7VjuK3sivv1yHcUSoF2yhpG9kjur+49hx03jVe8/eep1RUQZ8MjvU+cjindTOeawoZoV31IWeuDlBpsulxY0ahUALB7SFvzSe8mzKtNexCTtvvVqjVtDlH6M8LLeG7IBiuTFOGqzU2jr2YvjvKh9TbQBMYdr2Ufpr0I8DGYoExWasWOt6dtJ/fefHgrN5b5urY60Hs/iQ49/lCaD8KQ70/IwjmUfePHwbnBgPN/YxCNyaJVDZkYa8HnrFXYntiNbDG0rOYJGsrVI1i0KD7OMoTnbczeZo3qNJuNIaXePPGgM49DLJv8KNA3D/XtJoHPzBknk8OS8vSdEeQ5cHtvHVzY5PrNbx43ni2bJT3y3/7+PKjvAUHq0qwRqpOwy7DPvL8q5O2k7hpfTenxtZxaQTrfRzmRvaddlydCMJstFOjXaNaZ6tVftNaCl8eYMyrI/C9dW610o0ZhTlnBuNVAFQ5bEvdMKtQyVbU9Q58X0YtloYQ26jskHp7MxbV2MrAVbxVkB370XOarKOEhcz1ZjXj2V4q5heybxyzY94RmDH1BTWttOneiNKkGCzIaq8dxuMt9Tv0LPM2ausx2CM8ffOZ9wlUgOfDWNixjsYUOmW/DXsNboUEnzTxXqPPsdmQQ41DIaJtnMsT1qM8XwE9iuI8x/j2hj2/G7c5Fmqo19lnN4lZZ6Qe5vbU8Q6nohFuDWj5svzU53Rs5RmNgfF3NGq0UEx+R13ze6OLjbFvw1xdUHksqrDHcy902XtkvHwHLCUP4D79TP7I85tg3w4vWSV3hS5rMHa0V0fMpxtmpz9lx7eyT2HqpnkF20P24E64rQJU4licCmYJ6/sK5g59G35WaZaA9Wgwea/tszq3aQRh78HofaCQfeRyGbJhXIXCz3oPZeZ6MI28+n0Ts/VUqsC6FvUSMWH7VOFiLLO2jI37q3AKo/DoMTZPdsbtkLnyATo5+toYt8NwZthLSML6Vkn1MLuG9VuhlH8376FhlVkNq3u242IOO39ShaeVL6po6zyVZ/AcA1fluvl9R6btr2OoAhOBzPqOEut7G6p0W1BSmE2+qXCav3eN6nRYx0bh+KFKstBYDXcNGp7cMnNEw/7uOx51r3/h8m8jS60OA/sNH9MjztEqTKef7ueYMdep2caqUUAjPfe3sKYOYM/cqp6rUW0/N2oUZpfnEEMFBeGZEItn5VyZ+fRArVrjDZHM31teiMkstAOuOimndxKUhtVt3bTTs3X2W48wZQ/bg6luzHhaGaxYMWXqu3oz5qlv/bD2Kh8oanPz9/GyCUO9wUIBaMN7MU9M1ZcY1bsg6A1BCc+c8UR57HC80Ys1Vv7plNU///M/P7/YhufUzX5gKu84sH+g74HgoSlNrbGZZu1a7VJjuHeE4pXuYalix+s9FNCR0taNMbRG6LNxfK2RaUN9v3ccLfM0zyb68Xn5z7Pkg+aAxio5ioPin8/I8jh6gwBYWzzbyHfnDEFpxt+IqsUc+A89ypPDD16sND/LU7P+aF06lmaF0NCsBo7jVvnFSzWs5I4xfO+l0ncW1kCnfScHelaXzTjNx3sU6gDXSWk0XcPYdW5OYTu2IoFZu1/4hV84H8g5azgQrXPYZixT0uwoF2vSxP+NGQXvNsZQO9Mu9Jdc5PmJIgjRTBgG6N8YqUcmWzSLv70tnkQ9N8TDxDshbqF68mY9IIw0fc9YmiQtBLCFpN5KQ/J661U+FAi6eTaFUIij7xPohqR+ms/RJ0NLIc1z++6J1lXvygzMX+WjjyrBesWurbHhZTKYEs2lE8NXuKP5Bie1UmyeUy92Wh0N/FSli5+OPEq0r+dGQczPGV/PSzLOKgCl0njkaG/KjmJ51IW86gmXJh1b4QRnRs28R0GMQZg3I3qNaY2qV2zOnMhvPctCDPXsj8ZC4fFQ+9bAXl+5QY8qfjT1vO6ZKYxW2Lgnkc7cq082NEx+m4NodVgdz5eyR6PGYEecVe7znZde4ZOOo/JRR675RREqWjHg22D1pVgKM2ZedOo45WMQHCPfd5rvQoYbMQr13hFcbXeZinfFE7DwtYRw4246mVajUGhl5xAo3HrlFe7iyIV8GhEwEkdVGvMsxDfmmc/2AstwHTOvoqHkUfhagcFAhdqKsaJrj0LeDIbxajgKt1QR9yU33UnbiIoC6Hj9vWFuIYJCh809EEatQll6wc83TfSLLvtFMvMpHGW8xrUjt/0prsyTm79TDo1gC5OZezdVkpdGch2PcTIejVo7n0Ywm7/RoPDPeI7j+Y8XOYbBd5S/40F69hbDVL6pMu9aHxmoKuENlTVKrlJ2tpXooutQud9QoY+qLQ6Zooe+pZAsW6t67Xsnfh2Zly7XmyI29p2YrlyDmbwytkeGNFIv/+P16aMFB9MYAhsuRQc9Tdk8RifY7DgRrffAt2Jwy96NGYUvfvGLp1dfffXMbDPAmcgo9/3KSsLH06oCLTaJGZ1T04RZvUvGYyueuU6lTz1DXrAXkxwptQo2JYnBK0jzk0H41re+dRX9eJ/BhoLmeTZYbaxSLXMZtd5sX2u4cVD046HsPMpRc3/D1xk7ZtwYNS9pFAv69Njq+fcwHEYXKjMo5oyBMXnfO1w4ooLD46zSq1Iwn3luYSJrurH8el+lRTHr8lPzUTVAlASIxY53POk1jBTl5mWtfXtm/87AFEItriyK5jlSYLxHkNEYA+/fsHvbXEU2Dgr0b7CHlw8xDo3AeOL66YY189lzlEPCp60G25G7v4FHNv5dY1GMvQ7TRiCqT2qUm29pdN680L3LMQ0N0Qofu8+zrQ/eoyNAoZVx82QoKf3PfOYzV4aljpZcQGFRDvYYAi/jcoy/9dvRSo34jRoFRwKMILBaLCkigpWKwdXjo5jmd/eMEuoxFXBHkwRLuV/ugsAcbdaowus+gA35CPm6wKCRWbDB6oSShGMWfazyjGE+3/jGN84/i5liSpAGRtrj2N5wGba0q8BhqGKOhXjqXVL+Db0b1nqvNg9zIAd4+sxTKAqG4u3IFxQWbDTmnKlGZxUI+YUeP4HW/mYOdSbmID/QA6EXvjdCqdGcVsEtJt/IB1QoSvBMToyKE3QeHhl6FcKrV2bt8ZLnKcdsVGiucnXyds2nbe+cIapyM495xte//vVnPOc6Gp23FzcNXfuukvJLFRUaNsLaRRA+40iR2Xr9jEJ5ozzb+TafVR6TmyILVX41vjs5f1Z8lw4Do29tH689FS39NHYeOgM+rXkM64A+DlQUaeIXUdvwkBxS0RNy1twWKNU7V/AnRKbRe+ffOdw4fOSl6PPQmWzfIzsEHsYqJrcZud6nhaVAqtD3h/AUN683VQHTd7HOKmfE4Y2WaYo1SgTNd7L7FMUoMB5WkzxjHMBMxcY7vgqmhSvTHkE1/q1tL7r37+vaf59PGQ9TfuxjHzsbBm8rUyxgUx5mVMKK0Wpw2jeBhWc3eWm88++GxhwKEVZzBoSCwiuEh/+KMx95RtsQ18iKXLZy4Tlayx5LYXwEvpvyCKfnHO0v2DxdBTVrMvkBsM98TwH0rV2F8kqT+dvwoh3c1gftq9ApIvm/Fi5cZxRKX7Lfn55BETqJtNDckTE5avottCyiqIx3bjUehYY8p8Un29t/cpA7bPRYo1D4yTOLcBSOQ1MO4/RtT8w4XhshgUJYw77mc/7tLZGikA2DF47r+G/87KMZhGSlwVQ4EZ8yKG5JQIrBY0oeZN8XSwG0ygMzglu6lR9TbC+xChgRyyzmM43CmX8zeAwDz23mNd506cEgTNTwJ3/yJ+dF5tVSEGUiBpNgwgo386PXTgKiZZVYF7/wXJO5vLx5xsxhooOBA+eVoqOERjHPczH1XDOQxDDmzEV1GZoVGzcOBoeCG0NjLTZkwyFopIZONTjz/PmIHhslUASMAqElHDxJfTUiq2e7c2bGNM8igMaEhjM/CqI7gBVC9LkMQ88x2iW2IoSBgmY98PH0Zf4TpYIxOGg+aDy/e+tc3xcsqqAQJZzdZ0zte8u4Zm6lJejFeoM6Nvy0lfbuEx+Ubwo3MQoM5o5iOAl1TsbZ6bs4Km/No9xZx0ro27PxRPViDbJikCphfFqDW2d6ojrPq0ERjTdy285NdYGfzbWi363kFHhy82AKGzMXs2WFm7hrWFoCz7WjPKvIMcIOtxDXxGsgSvgyGFijO/sYnIb4FLCS0rkeJiiEn3cyj5Kcz0c/+tErgaKMZryjNEfBjuC27M6BZbwAXm8T76VJjcLGorfHNw30USF1jfUYZQOD5p3bGPalL33pylsfIzCfUUpN+g69eJ9Dl5kjzxJ+DFIcASyEyJPh6fJ05CjUeqtaa0UaYapz0NxDhaKtXpNrqph6/XzXMsvy4Y5G6xXPp8UVFdY6JaqniqdPGxo0xzayIG9QSKMQQR0l49twI/5vfqNQI7li3H1Xunt28fIqp3q8jeq2p2osO5m+4duuY5VYjXl5Wu6uyrYGp/mJ+UxptLlW4YP09P/o4CTgs7K81AtyO1vntMCm32359bMOiTwZPtxISQ1eo8M9Ts/xXXXmT9v+SkYBM+8ERhe+TNWdtRvGaMhGISJ6E7/1DjpJCWDn2lSYKSMJ8C50YZSjMNEc6qF6vpIvyaNRnPDAVhGM5w2aAcNITjchNgpxl40Zz44CKqA7rOUZ18uqwClBNNYqJoYQQ1PMM6YZvx3Im7mtSz0qwgVmQhPwRCEKNDB+yq5VMJ4nxLe++AfzV5lUSCiKwhZVWqX3tDotm6+3UcYnnrNzChu+En1ymkqbnqY6v8tf4evSr6XDWudXPH9Xn13X6rVvBbaNTI3pESxZ2W6SdPdVA9WKq0b0nrPXqWO0d+NIZkR/R3mIrnej+CfrbXSdV3NbLZUtVGadigKUfpuPjI0xM65WUJH36t9Ni36qJzcf38o7mimCPeCGXD49q6WKHmGFiHBaCcomgFpCuBlMP9tzKi7dhd+JKl7w9kIoWfXTGu9/kmfdmLdLcnnjo4TLKE3KTv/TDzhAmMiAFKZAt1bqoIdn2qBiHJK1o9QHIhoIZyCJ4tpHO4Dn50BgX/va185GYSKiqTgDMfBs6/GD8fRl7TBtPVxwWudhLes5tUy50EEZvMqCIi+P4MPmdTpPvxOgfrcjtDonm897TxVFPeruZygf1gnhwavm4uXXYFZhNZo0jh7IVoO5ldKe4xGUYy5+9vommo+Mwnw6r15fGlCmm7f1U+hXM9+Rkz5/z3H+5sVRnkkxcj7Nq9DjtEaK5Svz2l66tdxj3Yaz+2+O6I4Pq88amRoHmcBjRUtaYVceuRWjQPGUGI0OipPNT8xcAs11M4FCJ/XMLF6NAgsvYakfuK5TOU1evzytub7lhBTQxrLr3XQzib4Yn1HkE+Z/+ctfPiv+gZWc7TP3jRKmlOUHlL2NUgS9MAQin+u8ozKj79CwuQYY6sBbMya7VRuOd/f5zGPnayhTDPXHf/zHV7DQzKnKV1nc9AMGMubmSAh7o8PyxJFXtT0xjbLjSbdsk+cOgqsCJIRHybbtjTX62UanRrrGVL+NaPt950AGyI55TjMvx2u7njIgD2CTTdMNSfR7c+R8VdFX9rRCdoV8GbzeVzhpQ3DbeGxaNAexlVgNK1oZR2lc49FoofnL+R78qXCkY9H3ey9fxlXHonBNFXnHWVr6HbTqPu9pRl/XF+Jr22stuoZKoAFDVT440s+3ckpqPau2MghiKiMtHqafhuqbwWrVEHX3QUDkOOrJNTG78VSLWwzyqIyriqBY3rS5ToUROEkCa4RtDMYwln0aPZOklRDyHPOM/WatboCpwO31MGdHRYwCH6MwxsqREDUEPUJ6xo7OGM/cCbJrGckK99zbZGY9cAe9WbvNL1tRuK5z08AmVSh7HYtvbwOz+bT8WwNFyOskbCdowxx4y88jj/WosmZHIcZcD7XYdqNbtf/Wp4n5jrs5sxo0ctC1MKa9BjUklb3roqR3W99esyOC3tdn1kh3Tasn9rP2oYldP88TeZmX++6vQxL3urbtqG0bBTQ0RoZSO6JJEYvqG7ppO9DX3bMjqFszCvU6tvA1XDH4lkjBVCtYWr3jEtv9ZYAKYBO8hMbfJNGMt95MDdJ8eJyMS8fVML1Kg9KWSO7BVOM1z08biCaSEc2gFaNwXoSU1LH6zUW03IyXtvM6Xio/n4GKGJxR/GOkivUzPI6hLqbZdeXBiGaOhIPh6t+rNNBxh9o7rN5Kov01Z7QNQ7HXMv32UMvDfW6VZnmzym57/+7ps6rMG+X1e33vKLCevWdtz1M/CgYoFPzKYdib3kpzkAmDUTmuAqphQ6d6/UcwXpXR0ec6Q3T079KtlVBb8eLZjnlft9fKmLdOkkB+8VImN8TZ9a+sdvxb8TciRKNWBfW6bSCr9N8tut68VGOw5eqnbX9l+Ki7SffkELPEN6jCIzUK7WsnlSnIEqzJaBa/AtQ8wcbvKpAdc73QCshehPbTEFDFks17raYaCMdnoJxCZmCxQmWqWXp+FIU+fTcnwUjMvZMvoFRAVN3o0uSYeUxDBzkX8yyM1rWosvT9RCgzt9KpJaTNd+z69COcG801Cmmud6DetJYsd07T0L/J9MJInlfFyahsAezfzHvz6Vb2FVKOR73G0qpR8YY7GL7yxPx9713YclVDVbhDv8XAa8w6742Td254pPeUn8zbHLdyLAxZg9M21/UdAEfRVz1z/RZG6ZgbWdut7OA7vPggkRd+pZjNgVNXCKuYPjrQey1PRe8609WPR/kp95XPGs1Up1nnRvWc41t5n4JWa7Qt57ZqW9H2uxLBvyWDrvMoj6xs+9o7MmuZd5VGveKG8MXXC3ntyKHwV2GTniOk1HIMxeDvZQyQUytSeIySxOCbwltlUrSA91MemAB0hMb1erue27Bvb6xGm/Jq1UjnoKTSeJpoRxt9Nx9Q3qq3ZyxgMvAAWumrnjehxXuEe0cE2vbqd1Tbsbj+qN/tLW7lcuTxaY2Kux4UnWvG0OIb33Uu1qtG0Fq0z8rw/jtFdyRvdcLc0wjriFYtKy8UtqG1LfeFT7u++/DCbbDq3BhDcxLONWsxTCvIHq6X++izjise2fDZUTRlDHWKOt5C2EfH3VQu9Nm16zw4DNa8eZ5bySnUE9leDwuKAPXCtkfRduS5lTHqldUgdQEo5u4G1Gdx1D4LgYvl7mcX2ql1d43nlgmrhEE2oCC0a/10d+9ivJ6RVA+lTFEjxyPpWVSlrXF3rluIysQEUE6nybKuu2sblcmtiHxEdCIHNKsB3V76Dq1bzllnxBoVJqxSr2E76nfDPIRWrqoRUum0+XAr83p4jWTIRdekSnQbQjTvOnY3cxXqNk5HSnO3wqXb44bjH/FL++qYy5Pts1ESepWvugatWBQNNbrAx9sQNxrw7G3APKPVR53D44P9GB3z1kv+XiPba6fPyiJ6dm32unfN9LUNzabxNrLo3RzTrRgFHmuJQ4DAOgNjMAzjHdui3d2JR0Jo8M3WT6MgZe3LZBjIWFj64oGEsJUGRyGv71r2V8bs7l3KxEL1ui60+YhgZvOMvgcKGohn8H+HrdVISFDPtYSkVQh7+zwaOu6b9z4fL7wxjwpilesVU6wXoJhP6dadtrxX6zXh+CS7Z27mN/cPH3zzm9+82qswuZctBJ67y4d7wGAT5tPqjFQ4tiAceenb82tCdSsJ8+73W+D0Rx6quECNihSOvFp94i9z34fEeUbfu2Ddr2s19oUKa0x4zIUjGi03qjOOXSRQenWsnrkjuU2LbhCb6/oeizp1lc0ajTaOlfHUo+ZE0jnKf99ODqt8RKYK7R1FUoXqzIl8luZd+ybVncy8IfDOafdTGvYMryOI78bfvNbz1ysUJt5DosrYGwKqsJVReqY4xVeFZ1Fb7TPj4h2Da0bwpuxTXfxRVHPk9SlbpaCUBpap97wppG2ZyyzbYI1CnPHZAVwFoopIJdHMz4mXPRMFTCTkhDnDneHvNcxlnoa1jeoKiVQoNkzhezkRjMwIzfxmz8PmG5VZYzB66ixmBqO0iYyU8YKlGmF1HYorMyjWubmR7V2hRT3RQj9HHmUbJclgoi86MvrbqJemNYQ1iJ1ba9eP1tRz9bchhV7j/g3BqMap7HLEqtTQ0nwr79UBjYiNbZqxNfreRRYtGjGPGvRWoe1IsjxUI9Bxl2734s1Xwe+orPBtDZ7nH21I3U5O9YV+Xcc5auToGrzWdS5v7g+a3bhRcILlrqmvJauXg6i8jk5uhz+YDQyyPaYKZMN7z3AIH2U6yoOH1ZMiPa+t4ydkhTMaivnbhhOqUPYzfFcs3sfu4RoFewJGcYJYRnnyCkEvfeNVj+uVS0HTnrO0d+12PbT977bt/VSptrLJuJy7Y3161EMjgSYOuy5ldDTcu3prfNGngl7PqnOrEFPiFc4N6W2e39FT+y8v9L7tXXYdNj32EdN7TH7fimfz9VHUt6OOXqvfXcdfxVg6UbCVB783ou46bFim8lJljacqv+5phN78XlvPPtJnI/jyyuaje39JtFmoch9NU/i6Sryf8kAjzq5n+ap07b017Ftuds72xo1CTyQscbuo8E7E0hpB1OohVks0eTP1poR19UjLKNO/45dttlKV0zd+1TJX0XQsiF7i7qqEehMlfr3c/t3vno3h6i2iiXOShiazg9q7K2bvwXx4XBTvjMtOY4qt62DtzI+QNWJr1FRGaiTXkslCXT2DaK53XIboZX53fd8e5dwlZa9V4tvjKcSyE/wVMnTeZcdoZl2sYYVN/xXiGj79V2C30qjz0+dv5TANHevcFH7qMTE7gdtnNEm5FRiZU7atFa4sDY4iXPRvdLKjpe3k7Siz463TVWPXteEwgcSOnJQNgW1enuePPhiZmaKN+W6KPeyt6Riqq54sZ4ROqiFGD05XnTpOG+eoUceG4opImOf28suLlb3OuYc59hmtOrw1o1ALhwEautWrrhfj3m3N94s/plWRYgZEthhOPARFdGPYxokxYz1Myo8S28J7nads4ZtQ25hoj71oGN37dyjZBD1GmgZ/n+sGjpl5O9Cu50T5vXPws95WK4t67nvPfkGbrrtWPN0JmIU6MKUjsSsc9crQvHyAPk0STysN5ROMz/z17T5wEQNRw7+9b83cPXdXzOxId6+nf8/vpWf5qcarPGV+6GCe9Sz7vHq9+wTS7dQwnPv5HUONSyOWytEuWe7+GX23ZL3yXm+/EOGOwGs42nfXyM+t7MzV3qCBXn/1V3/1nNMaHTFHt4CmapDNx/Pvr1Nbt2OAHiBssmfM+wj1vX57/OWp0gb9jU1f18mN8e/y36P1vvGzj9p4iwaGEGWYMk2FbnsaO9w+CntdZ7u3hejCVVF29yeC1nA1jGRZt8DvsK0LUm9C6zwqmNsLO/JEdyP80xg1eYi+VrHVSh1Xy0brdfCOGO+OuUq4iryYbo1hGbnzY/jq5ZReO0LZnljX3VoxMPveI5iC0G+j3b8dKefr/lYe7fflj31veX3zx1HrmOpltq/mfKoEjsZdujYS2XzcqAvc0s2WVWyV2/Lb0Rpur7tyXWOw6eXvO4Kpd9zrjHvk4uMf//gZIXDm19xnz08h1912xPRkPbNjYwS6P2Hz6JEeqQHrdxybPedet/Xvpnn1zI5SNw/e6CmpG3OfAakSGCXcEzfrGXTwOyFYJtuChDAbSy1MMs9CMMpx/i385lV3D0ThqTLtXsxaeOHw9sL2QlYRb0XYOfSz4agKUfcozJid/14Ip3mD3luaNjrh4Ui6oeUec3d7b0VVr2Xjso18SssdxTQaqIdWwyUyqPdVntgCpFVBbaOwBd3fy39dk435HvFHPc/5d/Mm1+28Lg0oDX1UiDu3Gu53463e0+qqFnPUKZq/OS5FSfF2fDZvbeftCMq7Dvpy3+bl8kSVM/pw3rrOPPd5WdTf/Jt/82wUZh6Tr5vKuPlM5VtfWVljuT35aVuuS6e5nvJvhL7pUUNc/vfd5r/CdoVxC99uJ8/3dbYKkW9DdKNGgdUdQu9BIfBcY7KwcecDbU8V0Rvu1IIXttgTqlBsQWQA5u9e3TgM45A6O2Ldv73GLsj2epoELIPXk2q+ZSvKelsV4iaqanRL27mnL+CYa2YtvNu1u6prEG3ok3Rj3Oc6jKPCo2ck2Ylco1AGr7KgdAhuo8TSYAsXGpcf8JH1cnjf8NHkWEBYDNv2xrcnWOXiunrOXce2enHmVqhu88HOZbim615lOB/r2XuqCHtPx1QlWVhjR8M1RFW2Vex1FvrSo26oZBiLX3dOWse/z6vqOtQZw6s7euH8FQI0n6IBc1T9pz/96asXRs24R/GPEZiX10xp/OihDZH2edb07uLDow+692y30r9VitNa6lyd2dxMjVTXt06QwhnP8da2vcF1Ozv7uTdqFJTCVQFiOMxQJhlCj3BTRkrMMIhBV0i7cNvbOQrHu8A7nMbIlCj8G+F5ppTfXtCOYRusejsVrCq4Csj2sHeo3dYQUavl59UbN4Yps4iOuuehhqdey4YO9jgLv+xxHHm1jNdRQvE6751gbOiPkzGe3xjASRruM62OoqqtRKv4d8jd9XQPXtiVJf62+Ve/FECfv5V0S1XrXDURWf7a0AV6zkcJdee64TL31vnZ0VAdIusnz7cjv+3BtmyyfLEVb8ctCimEu9eC3DQiYaxUGk7+YN5rMsZgnKO5ZvYDOYl4jqfv+4sr+43Se+T4vZVLqbxsY7rluD83ClDdiFa9lux0vsbQMvwa/+qKI9nahuxW3tFcImC0Lu5OSqo2MUjloVXkxfzLvIi0w6351FvZRqFKzgKAtRC4MFMJSug7B4alrQJrvK0OaAXArqFumHwEf1ThbK9wC0wVgTbGV2SkWqlesXYUofW6js3Pvhy8ffX5zScVjuoaboVcrxY/2Jyl+srLgvqe2gpQHYCOZ0cKpW0T723lBZU6VRJ7/Qunml+V3VaAvXYLsO825r4b46ltw1yFUagGrx4paDTctDpKNNfwbT6obJa/mz8rJNoooGtV/TI/ye8YA6cBj0FwjPREk9/+9rfPP6fSaCKE3Xejdo5QI+gXo3i787nl0OSxMt2135tdG+3VgNYA9Ts8qbrJT+Pe/Ip/9rPqqFzHR3/tdzR3A1TxvSZdlBy6XmjTUMYiKz1rn55VL4RnbPKIs8u8PL/nmWD07qzuIjYE7xgwzPxbSNryvxL9yCswLoxfxkQPzbjQx+89bmFjs54/rVGMPAsstSW6R5GWn/VYzd2/G46KuGq4GYLt/VYp7DDbva1Gmr/jsfH4eIVoPNdwLPq2OUJUWjUS8j3FbkxbUOoNily6SQ59za3r0zUV+m9azEdxQPnN+OoQVbls41dD0+juumiFkSr/Fu6qHO3ouPBG17LKrfSoZ7oLGaxHdUblaVf+HJVsa15chO+GH7YRGN7xrCrU/Wl13Nup+tq0rS5stK3k1z3l8fJOnZfKFWOHJxppFL0QwTkRoMZyR2mebf22Y3tj72juuf9VtIjpdYLj0TmaojXXe6v/9jgbDWDOjZN1YQh6id6zj64Lw/ucCnI9t13hUsW/cbsKaYUW0+/n9988AszTsdWAboXR8bYvzfN7CF2jp+3NdeylcX/vgXStQHG8dqOm6xKM7t2Kg8dm856x2e+wlZFWmKGGqmOv11ze2OuL/kcRcp9XZdJWfituvp/RVkhj32u+dVQoCsUUxeSbx9mGZH+3+by5E38/Uv7boep69C13DPeO3M1v85v+Np13ToceGR1iHwxd0vLyHcEdKfctv49XlSCDWdnRx4bj5JhaLq4P1+Fvc2oEuR2+rn0dFbrXuPRR/uvfy0u3Un1kw9FWSAbQxBmDUIvr37yoQlKeUSu5jUYXsvfV0+rktzBvwtX4bKOAsFX+hT06hsIV20BY3D2m7fH3Ob4vplp8vj+3cmsjgGi+MUf9bC+whrbC1MRu4RAeGyPIcB4pzY7NWhXWI1Tov73brlsFZpdmbkXQedebcm2NQXlp81//XQivQr3HcmTEN/3LW+V9/dQpKdTRnMfRSajW6gi+6PP6jN02DcobdQDq/bdybfNXjVTXqRHfps2WN/dah21M8Ywx1hnoWm8H48nBi3KOIowakBovfFznTr+tAEM3PNTItsa282kBR/VWx16d3Cjsp21/JaMwUISTPi2YcshR7n2hy4Q2E1mIGCQMpznYTCmp10LOJCRGKYW+/3djnVo98SrablLaUUeTmlWK9UaEhY0SzLuNl6vVS+s1R8+zcH2HLwYBldRDK96+PZftjaPN9nz3HKtohLANWas8N4NtpSw07lq0BLIv+rGejE1PjjVmMNVRnony3Y7J9g5ryKZ5Zndi40uC3GOWfWdd5DIawdaTrAGvsvDsHnLWcRwp3v6Nl9mdzni0vME7LX+Ubu0ffzR3oumHUqyj0PlBD0SMze2gz87FGHufdbRGHX/HvT3jbcC3gcabWyk3p4h295bBqPNSvur4a6jrTM51IoPC3NUPxuM7EdZW6L7b0ChnvDLQPKZnbDreWKL5fFMmXqzOWT1gJAZkrmuiZBKGPKExFq+//vrVxhJWtoeB2blcTB+8MG2HXltJ1Nv3fY3FhlQKtxxFBaoVjpTUtvDo1Weh3caNjaFGrs+uwqwiqRdd76X3bq8M9LCFkZAX7us4Kng7mb6vpWhmvdGm+0O866Hj1ldfCMKA8PSOcivGs/NLjSj8u2tfY3oEE3UMnj2tBqXXFT7bCriGozSqA4Inmoyt59oKwH1NFcHOHzQiZ4jquVbZ7wh2R8e7SopC5ACMbBTr9r0y55FjJepVbtvJab/b0Je+/e5I7sjLJKddQ4miTx02bRulHV11nJzjGoD5cIhHf40cgHMd3NmS07bKbR2pnU9qdN7xdmc53v9pI4a/8tHZiFDvtInJ+bfdg45BwHwzOPsEWrs7VQTz91ESvIuWrjb5hAA9MnhHCA0rLeYmeJXCvqZ9NTysgGxlNO3IU9nP8x1Dtceunx2a9tP+j3DHMkefWRy/iqteDWPRdhSd6d8aVZiMG09IcNcwMLzzvTUtHl3lVOO+BbOtePum7RE9G4H4bN448jz3Ne2vXmLpcaR0zL8Kv8/YcyATTfrWa0YDThVD03d9HzkMjV4L9+25dT6FLgrxOPnT9bD18gtHsnPbCri8vvkQfbdjUAVYA7OryErP7Uw+WZsa300XVO+N8ncGUp03R9IofjG+wkE1Co3qjiDo7SC65rooa9pGCm7UKLDuEseEr5unpp7cprU33njj6nWQ8xlLOZASZcSr+OxnP3vue0rI5nwSmzK6WYNgzfN61khDJAQpnlsvaCvpo4Vv296l3+fvMx8KCOzhma06qWLuAvc7/25FSp+7hWOurVe7lV4VUCOQzmczjnXtq04pnD2P3rM9bZGAdeIBtuSvY6mDsauXjgxA17qKQ3925I6Q8qTAj3uNG2abb/H5XlfF02eaJ1noO0eqQFqiqE80L6wiQipdzcMazO/dZOb6+be5++kU3tdee+2ZY8fxSUse5/69T6h0aB6whRHWEfzYpmRWUYp78CWIqmuqVXHvyLl5S/yFPoVMPKNGjAfP864hfLKKNvZz5XD89PvoNv+u0kbb6Xd0oh3Vsxb2bTUv5xkdG3pZi0Zqzo3T14am5l66+laMgp3McgHzGSU/kx6ivPrqq+eNJLP4o+D/63/9r+cdqEMMzKhagBKcZgIz8I985CPn59hw4uXyFpehUNlURTLEQCRMaIEx/VEEUSYwjv77KPm2vX/vEOjhb4S+HohFrTdeT7GeVDH+aVux7VK1rSAJDCaBHzMWQl5M6D7eizliyF3SZ+zT5noRgWhg1nGM/fCA0HrWTT/FondEUBikxmF7a/UCOSfmhZbDfz00rgn7GQ9e3gauHhrPr/hv1xQP7WigDgCYYRrsfYTZHHibG6IwJgZ3aGo8c8/s5J16/Q9/+MNnGRyYRD5v+p/rJxqfzVwMQ5u5qtwpfbvnw1zwuTkVHq1sMY7upQMKkzWS3E6K5xxBNu+G/c+n8JqxFX7Z+2iM5d7qc0e9vH77gMrL1Rf4AFTmJOOtvHutsSv5nr7t7Ee/0TMgenptnj3XFbbvu+vR/bqI/69lFEogHswMYKyfXMEw5gxyGHW2ns/fvFAGc3W/QT2wWsIRng2tVDHtv2GWISDs0mJshqK4ykz9rt72Fs62htYd5w6pr/uuirUhavMP+5nXLWzH3rahqNIMQx291aueesdbodlwGYXZZHPxbUa+O63xUY/+bV3+Xp+N+bYMsBFrDeZ85vujcL2Rwa5wqidcaGrj6Ztvyts1HI0id/7FPf7dSpmuI1pQTLNxa877mRcZze9jHNAAbTkZYyh6eCVD4A141rqtjkkj8x2VGmNp2FNAj7x9NGqOZ0dmW87K3/1950L63NKhz+i6lFfuHOxHoPidyNxIzbqWB+os2WzpSIo6NkcybR1qhDcasOWc3DDGO+reiMqNGQVCwZsBoxDqaWMEhjGHeJ/73OdOH/3oR8+RwVe/+tWr13PKHZSxavkbklu4Tp4Ho/G83SNKmM1P8+y+y6HMtwUNYesh14PtGCymTxV56YUh65Fsg1APf65vqFi88N2Yvs9v2FvDWm+3kQhmp0zme4rcuUllyO3VGwtvappqKmPp2Sx914VIxjkyxleslOKoR4UO5rA9t9J2+NE69KDGHa1uOKF4f3mi67Gjz+LJXSPQmgihCuTIy55WBVsjOQppPP/5jIx96lOfOtNy5sm75qwN/89n5o1OINwZyzhrI5ONeMo3PVphV5UZP9o2ud09CqXNNu74ps5eI+3tyG1Fbsw1VKXjzhntxHqbfu7ndNjqJrvre7aaeW+eQyc8hyb0VTdjbqenzlC9/B3l7jk2cja+8uDWpTd2dLaBVkFRwMOEk0fwspvxXDAN3I0CIhjC5hLQpBuKD2GETn3hu8V1hMU8e/qbn/N8Se+Bs4RuZZRa9m29jxiwnkPD5ir8nRhqIs+ztsLuDk/KlZKupS9eWjinb2WrAaJ0zYfCGHrMuTDeiDaeZl8BihYqgYy1pbOde+fEqLufp8Or96lhQSPjbHVUlXgjRDARhTVzqoCjfzH/TcttoPHrfLoz1Rj2TtSG5Xt9rdP0M/IgQmq+Y2QGpIP3Pac16aCiWatPfOIT5yh8+Hsic7Qe5Q92nTUGF3knhzHOddNmXciU9RGhF4ax3jXKu9LJ7+jkWegO1juSETzaSK7GpU5No4aj6ADNK6P12su7jcLI+aPLaGJ/5DCr+4zZ3/r88jMlPXqvxmNaHavtpGqlf6+v/O2yfNd3jjsKvLFIoVawg0Z079qdkHQ+EjIEnBBXYdYjAyk0XPLsnkjJ42tlBYayq9p5OeNFDdY6AjCfgZXGiCFkDQEGPoIgqsR2CI0Z9gLp18Js46KPWvEy3ZHXvw3X/BvGiNE2829PoR41hapMzhvuzGUry46/jEZZbMVw9HF9vbh6S+CeTdM+vzyyKzjaN4eBkiiNy8cbDivdjjxXtG7bkVP7KaRSXuq4++mZYZTL0MULjFRubf4iJ8P75anNP1U2vt/KhbdfD3bz31bO9a7xSJOw0/peAxh5y5UbNVeGSqfy2ObPOhfbA69ibd+V9ScHJbiN/BtVbl7HF7tAoU7P5rVthHrN5jtzLwJRHt36ueO7tZfsHE12n80x1wxcRDmP9+mFNz0MropgQx89DdN9fqpoGgU/xodXJdEr0TgGYby0+Uj28Cgx5hbQPqeCjWmbpLKoTVLBxLdS3+V+fnpGGWJ7sP3OWlQQmmgu5FRcvCEmLN3fvaJwvhu6juJROWG93N+1bytTdtx++lvHs9tRFNJEZ3mPMfBdFZbvrRt61SnZCqBjbx97rPVWG5WVNtuo4DMRrmsKo24oauc7Gh2Rw1mzRi59PWrX3hi6hiID67t52992Hb0o9YiG9ebR3PU1PubN0+bkdYzu2w5AFfaWp60Qu17VXfuao7k8uSYXyUi2KGLzeWloXP2u52ftaKx039DzNm5HTtbWKeXLWzEKtdwNCw2uod8s9oSvXnQBn+yO5U5iT8RE6417znhBoI/plzEorDS/TwhN+UvEfeYznzn90i/90tk4jOEaGGWUolKxQjR+rzfbxHZpQMiKJ4tmnPd05PFPa/XCNAzSCiElg3vHYzd2TeMpokMZHE1VkHWDj/CYYXfKKk+PwtGf99wyirMWdQ6MzXUEo15ovcl61GjXI4/xXj1J1Sk1Ftak+YkamCa1NX25H8yDT9G7iguvHuViKFe8OzSoEfEc9+njyJucn9ZfIl9EJ6oS2cLEOTXjiM01CjB45focZ2kcNrw/lWLWrmtdJbaduY4Vr87PkdFCwBw9cJkqme7ah93jJzAjXkD3ozLSRirVVVfKLkUClYU6FndXHrCJevzDIDQi3c5KZdxnw8qVzz67Za0gRdfUGe0ze6aScdHBo9uaK7tRo9D36ra0UUZ+PpJpkle1zMUHexJhmZhy2oldhKS4EIUAgqaG+ffJhjOOEaLmNaY6an6fEtip3hjjMYZrYKUeY9ATXI1lRzbmVsJvy2+e8OF6CPv3evOqavpOCkamTKayobhuPdUNgXRsGM64W55pzY3HWqNxvRlC3DJXJcKuqddZB6Che0Ni62o+O+ndsbZip5UmKm66TlUghTj8vfBaW71W4yh2u2m4o4hGZ342OtHXhsPav/Ln7i0AzzC0NYj16vVXPmAMq8TIV9ekbTtu+u1GLnuMXFOYt45Xr5/cVvc2qOuvI3DkOJamft/z6e/lv+6tuLMi1eqn7bhUjmusjK3QeMe3k+Lll23A0I8zU76rM75RlkYwLd+/lR3NhKADUZHk4Y636LtKtxKtYHbBSuBphR12UmsTtl57LXu9TrXxGNFLvmG1cx9G5MlshtuMZTy+M19whb+XsTDCNgxVULxVY8VgFG/p6piQeoIMWyOKeq+N1upplcEIMi+4kcUOZ91baApje+4O03sfvmhYXIHZwr8V7lZc+vX8GhxraA5VomhcxdO2PeVt/Kv8yyflnTo6m/5aFUUVC5liGLZRMpe+R6N8N21j2jWGjVBKxyrEQl3NIUAC8Gv7L4pgTsY3MjifqVbEa/KSxeePlH0NbderkM2m4dFaln73o5Stce9t9Fm+dk0Nir9tI4tfOo4NnW7Iq3xkjI3EfOpUW4cjJ+fGzj6ibEUHKlJmgAM38G7nb7xuCnKHcBipBFZaWIaXvKb4JA8x4BBCpRELrXzMR5WKg/14Wjbf6cubmya6UClCqYJueNBdbAoRwxCcwjQVkCrERl49dpfSbfjeXbvK5JTiitR66BxvXSUKhlRpIsxs8qzGF52mOa+IwepeA4pUNMcIid7Ae0clwjNfNO3mJvyCR2Z96jlWiDuWM3Nf3lulMv9Gr67HNjTXCZB15j2CbhiUvsWvkWx5gqNQRbOhIpuWXFN+KX/gdZBNzwwzTzQA1dT7tuYz77l/oCT7fEaWqqzwFKfDfMh8nTHzUqPvmGvyYz3xjfdCTyPHA+t2f1MdkA3PtFgF3+78hOftexlffPS+6A20x7vu2zu3t0GvsdlyVcen8Gar08zBOhTGMv4tH80J4e2jsd2oUVCzboFmMLPYo1DHy56HgxeGsPNdIYT5d70p/Tgwyi5MRD0P8FJpD9wzUA+mlivoWfsWkNIbJp8+GakJTUEENRaYDePMNTPWuW8MQ3HieR5PhuLbiaBigpTAftNaDQEveEdHjAfYzd/167Wb872wexiqycIaM5FPjUfLEdu351N0VR71Khs5FHJBB9eYa0sku/t7+pQfQo/WdjMApe/eV1Caby/fv+vJNmFLWZl3I6ujyLbrU4y3uZ7iv2jQsR15ewRcPoehLYzZRPK0HrlAKc8YJmdWz7FOwlGkjgcckzFee6HheqzF65ssBm2hRctttyNkfWZMk9vz1jS054A0ovJpQr1GyJpUKVfuthNg3fr3d/LCK7y3x73hwXr8jRxrDFq+zEneTisj0XfUWENjrTPaKN74Gxn23luJFDYmPJO2aP7OIBA8St6GNdeVKTEtfLHlg7wfScx6Zj3SghDKZdQqu040gUElEveGJ95668mVR2IAc211wIZktsDuEHXXbe8w2TyOklNzv6QzGKFlivWoMCqDWO8TI24Ywr1VjMbTsNZa7BNXWxhgXPM3Ry9QFDUMrpk+CcTeol/4QDO2ek51PMyrEF4/uz88uT/1LgtdHRmOGkeCWliivNYqIx7/yNA4W01E1wDVcahxKgy3X+bu51HlS8dvrLNWPHhy2QQufpioulFBN+pxJI3Dc82BQ1beryLdhss93VQ3bc9xrwNHo+vdvqvTplV22lcN+hG0uKPO/l56W+sa867jLs3dfWyFX6jv3XIst/I6Tg8t8YcZZlI2sI1XP2Ho/BzmnuvGAxjvnrC3mgNUMwzU0JmXUgGnrCdqaIgl5PzGN77xzBuZ5pnu7fk7Mz4QjA1vFglTz3Nn/Jh0+nQs8Hjm2wPxk9Gp0qzir2KjwOrVN4lcL7j4pTJLBmz+bfxNyG1GKBS2PZZtfCTae1RII8UZG+M/pb8N31s8IOHYeeIDnqW1RS9GQ24Hz4AHG0r7FAIoz27MnSdmrlVCFaAKX9e3kA3HqInTwkldawqg3zVa4FDNZ2SneY3hVWPciVc0RCNr3IKJPf96psX+0c5a2fAJ9xfRU/4Ov7Qp0vk+3WCKlo2Im7sxJtd2LSv701QcOnMNrEVmC2XXM96Rdo2gZ1uL++udCO5pBFCZr9Pg2kJT1rl91HkR2bWycLdGKNpRQUnnU/k33xs3Cj1jf3u2VcxT1jah7+y6HOWpymd+n+vm+26vn49QcfqwZX82nI1wqL7p5GT54ZFjSObvE/LyMIdZMamSU+GhIzCKz/PQ6iXzjCnPLn69sH0kQiMInxpTzFTljxZ9pSBmbSsz8uTH6PIyS6t6xI0IKhiUZD28Rl+FZQoZwdR5lPpUHYbW8+96mfXg0VvkZWxexG7+9ZJa8mx/hSMddnSARlXCVVDbm/Ozwlc6zt9bCj2tGyib5DXXlgzro/zBKINPjb07ZevxSsLavXy032ZDmqXHHkuNh7kPn3i/yVw3UNQcVWP+PeOKUzefkavy+IYsjLFet+uMDw0VhexIbUdljOF2qKrU8USjXIava/8kHnhzGOWBLYvb8OJRtMT3o9N6UOOu+rIe4KCOo+OrLHTMhdhKL7x8K5GCCRdHLiNS1pKZc80wzBBjlPXsExjmn5NUv/KVr5wNQwm4LbGa5unLLk5h165C2tHA/HsMhZCWt4lYZUohPCU3rRUehSeMb65v4m1j2GijNXzdlnw+9dZ4DTvc3iFrjcvGja8W+NJbp3ApKoxnnGUc+DVGqyfbkNd5SYygNaQ0MGmZHw91Xr5zz55v1wdkxxMevhjlyHEQgVYJMnjotUuWt5KpcDXUb3KZAbZe+KRKoIqu9EH7wmZKOVuOeeTpNUdnA2dPEu2nSq2K0lx37qXKxLqVV9BvZBrfyFX1ZOPyfMdfupa+28vt+vd+84D5+347MXis8OCO9urAdV3uXlMh2b/13vL1pn377SF6NTw7QjpaxzqXWxeTpc69slVDcCtGoZZHmDn/LgMLN2fhxpsZYXVA3uc///mz988rmjeuTT8ihulrrgXn8Iimz+mbRzXEJRi8BAvQEk55iI6/xK8SxQAEiSIrsxEklR1NctYzOmJE12yBLdSy8wvG0L6b4Nrhr5JRJcG80GmUlQoda8ZQDV3bVxma0qIIG8JTDsp9G7mhQ98wtQ1/Gdj1FTJNVDjPtXbWwY71GZ+XO1UB2ahHcXez11ZUhIxHjYYMYDcqbjybbDQy7PhrMCT7e9ZXFYZnl3dF46JfENuR87C9yJaHV5Z3srZOUHfJc96MTZTMKDT/U6hjJ5e3PtlQtPFvBVj5qb7peDqnwjSVpzqF5T/XvhBnpolcrU7oUY5hR2nzk86So9x0bBGH8Wy9UeNl3i0sGJqU50rbDUXfyo7mRgsbJx4C8MyE9jPg//gf/+NZOcxGsV/8xV88f375l3/5zFBf/vKXz5DSfBBd8tRCTF8zaTkARJ6fzdDPfQMllAmrUAgAb3iudx6SCqmeZFkhKgY78xtFoYStR3I0ZJ9Wr5DnCyoQyoIfzEEV0YaYKgiF8IzNnMt4M9ahyUBMmL3QmPVsya2+5mc3xRk/4TIm770Y2oDy0FrkQhHX+KCV6KLez1YY4KJ6+HiEkbJWFTZ0p9QHnuzu7K6XMXeXbROBHZP79NNyzBpd42+ZdaMuMiIv1IIFkeisn7O77GbuvpMrgV4lodsjrvJEk1YW1dtsKS3nZa4f+Zu/qS7i1JX3qzC3I1SH58hLL81aZKBQYu6fZ25IFL/vjazk3FH6O4n9bl76w/W6zhoukSs5JmuF/YwVLFtUpU5dIT15U/rD9eWpRjJ1ELfDKKKuo3ujRkESrCdywvIQygmo8zeKhtL4+te/fl4YDD05hlEgEz3MfcNsDqoDQzU7z6u3R6FVHNdFBNMsaK2m0kihr3lYwIZ2FTiGkYAZ104gV3G1GVerhgim7+G8Prukzf0Vsio9hmZ7v1WWG1dGxyqk7fkche74AA8QXEpEn8ZWpbOjEGM3ToJUzJz3WlhHP4w+j0zU4JkUszWUI6syui7CYxCNu9dvj7E8sKNqfOO6XR5K0TPG3RfTl6h0V3D5v2vdqKtyUCiscoH3Nqy2E9UMoQhq5HhkaIzVRPYbqinvVamW3vrdjliVXZ08vLWhxkb622D2OZsudRgfHxy8uKGkFjNYh6P+N8S916WGrTzTCK60azFEDWvhXPLLICjfv5UdzWCBMQzN+JskgZxmEjD9uW48VXDQtIka5hyiHqk9RHScsNzENNUxFBO4wyJSzFXQGmVAkHjOw8RjpOZZrutu4F35IzlVbxIDHBkCP3dFDCXjZFOwjH6VbfIMW6lVT79eB+VUWKMhsHl0vZo4FiZjynrFNSCFtJorYKQIK8U2fxt+IUgE1b8b4VShFau236VjQdf9Rrfupp71ZbTxY2GFGuNpTbiWd6qYGu30ug0jFEoi8NvooOGRhze/d7NXI8NCQfWw0WSPTWNAnYdkfs23NNKo90zZFgJ0XMz0N/sMxqGb1jLjRi1g4LaNrVfRbwPdRPHR5rHCKz0Ty1o0l1W55fHXCZpWefb38mllubJoDXpfnasasEabm3eMufc2miEL1kLVJl0yYwHtof+t7GgeJVpvnyAZHEWOWLWuJj4w0e/+7u+ejcEYhjmczmmmk5Aeqz1KexhtmrAM/uo5lAdDw6ssEwnTp8+WzY2iqfKukDZJtBeLwI317byEkBWiliZSoC3VrFcmecn4zVxbmdPoogl9G4a6gY9yKcxRj0OISyFSkJjcGm4Bnv5G0ba00nwwI8PBs8aceKW5kyoJxpHA8YxFc+ZdTHX6lGCen/N3ofd4r5OfEokS2L5ystGC528aoleFsUoDj3juhu+2V2mMFCxHaFqx+LnHa0Rn/tO3ctzSZEcplLpxGY/oGu9x1vqehZYlG08LFFpwIPfnwET8tqvXKLa51zO7ya2FEejbSH1HHY36G3lt777z9h3EQWTQJG3zkneisLd3Xcy+EW0VfHckb77BE03ec9Dk6lqGLzcrSuxzhrfHKI/unOpOkfjozflwLK1DK/puzCggXsOZ4l4bryRkJtfwkaDMvoLpdwwES4chR2ApegwsAV3MsWex99CoWvYZz/a4jxJFmyl2xOFnF9jegA0Xua7eT+u7KVeld0MDysW5TGXAYpDyLBREDcamSf/OgO967EKB9cZ3yFuFuNd9+i5ktHMqjPNWnPo2Zjmejgdf9a1/5jMGfgQHnDfPmX8rTOjmwcJ/1hcvUIo+5tCXvPv75rFpdrvjoW7yct/8jQGbv80YzQ9eb3wzngr2/C6B3wjSetTJmNZjLsr3aLmhwkaWaNKqo9KSEzbKhxcKrjMehQfWRHUYqKaJafSo0wNmK681AjKu/qwxZozMqfdvb9+YH1+uZ3OK1QfGt5PqdR7d07Wfht4iLeteY0dXVt58LyrmPCqw4FjINU35cE+ibSHNrexoLtMUaihD1UumWJpsxXAzea/LlFOwqay4GOXQncUEbidc98ei7ORSlaIFLDRURmg4i3mq8DdsVU9lQ0vGJOfS5CbPb7wvXmzx/obj87syxhoFsEvPQuGhNfnbooHtyXhen6vVKPUa9OP1GHf7n9aKiXqUhGEUyyiaYezNL8aOhry7epjmNjQYpWgTJHiJ8t1rSPCMc/5ez7oJyo3D17Di/+4Qdy2+qCNVR0PEJS+j0gr9RSQzTwUW4E7zrpFtPo68MAwdizWq01HjsecoeqqMVb5akMEwUGbzfE7UXGMNK8dH8lb+7/cbojGe8mYNQHm4/fh9Wvl9WnXANLxGP4BfNXOrsXN/Zb7P2tF8ZaYRJKi974ueBmp1RtzWmXtON75P4cgbbhjYv5dwva/hnffJDrOMkZC3mGvUYYsSZtFbdz+tAl5iTsOs4JsqF+NsmCtSaQhexuu8Gv7OuKv8JT7NG2zguQRCdcm8xlSp7rxuceCPCQvtIm0i1rjrjTUy6G5J1S3zGcwX7ND1KsNX6LZAbRpTwubbnAZl2iMuKD4JMa+MbN5p6KgSrQZKnxi82LqxNUqc/JXy5OGncTjwjN+bpFaB0yS8axqdiGiaq9lKpYawRpXAD6+XhuYk74VnvDyKA0Dhzis4x3Fg8EunRsPoYZ3rJFVuRJHdG9N5mY+qPteba4sF6kw5ebhnjPGyCyd1cymDp8KvUWLltQZgw3nVB+VrBrJGsPc1X/D4mo2ARzBVc3AMQmVoK/jm0DrOOhmNstEP3M74D4+P8wQCbKSNVpsOt/I6ThZd66J0U9v2uEfZ7XDJ900KEYSxesXmCL1xCK9noVtRA4tuOede+DIYg2YsLbWt52azWuGafSBeBYhBa39N0pVWrWCaec/OUUpNHb4zaChY47Gbd4SqobdrRB36ME7hKMUpTzJe+kB69hZQVoW/WqmCtlsgjYNHRXAk11ujrxoGTNjjOqwToWl04Hl9ltYNhSAa6wC6K1QH0iicRPm1Smj6w2MU8lYm7aMKqni4RkniwSY85b3m346ltx5yKYMpl5f7HvNp+JTsibCaXK48KYUUyelv7w3Y0Rt+ZkCNafqUe2iCfjayks+ho+KSkX8er5L26pxGqtdF7jsy2BHZhlEYa31Nq1E/MvxHRqFR/ObT5ghKS/3UeChZx5ONgMnlriraxnKjILtI48aMQjHS7fUb9LaCO0w9InDr3nk28LcSjVIYpuGJ26BGyTEOiFDG92zM47t6zFXcDAYCS+RYAHPrPgkhMCPAYy52a5E23mgePCQK31vreoCf3bQ96gFT9fno2JAe7SRixwOZa0Et06Z/UdoWFB4To9C2hUPZbYW53iwsvzirYzNa1VFvqgJUI7yVgfGIoPABxdroYP7WSiRrK4psAQPHANbfZxcG2UbS+tY5Osr14E2J+Pl3313O2Ms5idIKOfqbPuockbE+s7uq67B0vTcfoMfe3IjOM2ZRv8gfHzRqnjHOtUPPmZM9GSCnHsFSZV3DsL3hDTl1TasLauRco23jrpX/+imfus69fm5HZ0NldbDJ+rTmCiEnDhktHbrW2lHl3o0ZBcdj85Tr/Qgjq/h2VYDvTRIBdrJrh6MsLI9HIobiAA/YOMXrmJ/dVFaiUKqURnFJwstbdQiYcHhgHYk/sEwrsuodMwzT1yhf47CgPE39j1D2GIPxnCZq4MkVo22po3WwFpRvYRjPmQ9oqsbXpiRKR+15N1ft0toyt7nsPEkhEYbMPT0ywsGKmFo5apXBrujoZq96bM1r7ehWFQcDbKMgg4h359nWrnOdaGq+mzXfOHfLR+sZ11Mv/29BrVO1Szvx53xH2c46zke5eOvtVQsa64ZSGS/PbGK+JbuMKDi0iWZGB09yXrxFDY+Za2Ve1CtalmS3IU5uSeHB8KIxizRbGFGHpHCPf3c3OrkvP7nuXnJB22mrQaBXqtA3MtFKPfeSxf6+x68/6IeKLc4Jw76d3kZfO89xK/sUhP5NGvP06hVgOIfeNVNfYd1JsGkGPv2PQsSwBB9DqLxxCJp3ws5RGjbRzE5p4dbcV6PVQ7SOvAbPqWIDJRnLMPGE75/85CevhG/mPC8HaUkeBhwmx9Se3bAYTAAeKGRw9L7jQlOYb9feC2Xdo3Z/chh/+qd/epXgH9o1EumGsllXjHeUtCcEVcbm6Tp05iX6oIWf8z2FIqHWg+540OhXIyRq7N/8jsbzb8LE2Zjfhx8ckLjLSxlEuLvqDu++rXNhPdGuSmR7juQH/RqJgyqbMKxzRQbG8Rm4T/THQVKZItnuZFPGbwo6rKP1FnlXUaMhnuyZT41cCk0ZJwSA8Vf+yzHCM/P3VpmNQ4LPVNQ4bWD43ynIzYHQMcq0i8+jr8Q9+eYw0FfaC5fzAWk2wrV+VfAtZ20RDD02rUhJ4a/KrzbfDY/hH45t+8KnrS7sUenG3whunvN7v/d7N1+Sui1xJ4twiGHSMHOCWaHp8Qb6QDReSLFCC1IhRTyGinUt1jnj7AtDujls73xtyA/TJFDNY6DFKNQRMopV2N7jMrqHop/ioRRpa8IrcDMnEYm+KSKMVQihf6unbn144QRJUluJG++q0FjhEbTixZbRNXOsYNV4TDNOAtWQGozWMFmfTeidmTk4Ko+wEE4hzirYeueEdu+I7W5ijo7xoM+R51ZaHMEJladW3E2/zUF0/QqlTiMDDCrZkHCsl1gjb3w1nqVpI/uOH9xXpW59e+gkGrcSp7m/0q0e+44e5LwmIupR6o0AzVkuwr8LGc24d8krOlW5PllQTqMCcy5dSsutq+gjRqgRXw3Lka7VXN/nN7Lx3Baj0HNQjjqKN24UTJZAW/AZFO99wzCSJbV0oBKLviGHWfSBTVh92PTG3SlGHtOcvupMIkLtSGyKe54pEhnvfbzmjrmLyWDMM2GfwuwZm0TlJM5mfOPhzjU2+TnimNdXz2BXQZl330RXLLZlZ3INLUdt361YQA+eURm1nihaNtRvaWvXl/K3/gQSzVvZU6VBeDAuXhIhzXN5ohSG/nskN6NSAdUvKAR9+9xN994D5piPtwRqDLE1KB5fGMg95rujgWLUFH6NZMs1GQOCXsOMR5vQ3HMe3q7iVKxg/0L3RVQ5G3fltrBF379cg4u+O+o2Vsrc+U367pk8IEGRv2iRkWikWmVJP9nsxXjQN/i/ziRIesbSzZI/vtxBjz/Qb2P1NRB1fNChkTU61SFpZFFeI+94A22bN6gc4KVu1KVD5udEXvJiN24UeJ0NlXfyp5YP48Eja6VhhUrQ7M4bhmXtpy/ho3AIgbx0pCV9MGjELgTCa5g2CuhTn/rUlQWdewZ7HyH65je/eYWjOwajiS4etsWc++c+irfwGLzXuOzJOEr8CI+HLiMMMzawDtx9fs6x4xV8ynLuYyjs8JZXEY2BV3z00zHDsvcb7ZofKqZbJVgBrZe2d8WCuWZ8cilD7woHph76zd8HllO2WKPSKKseprLXJnYZILmT5se6e9rv+uMZb8WJFvit5cyNXMGu+qsS3MoBJm+MVRbGN86S87qqvDhSw4+FQDxXzsa70ofuKuSqvMyBMSZndRrqzKBLq55Ac0UMSts6e91gBRZFjw2LbjrNHIZHuuFz9AhD1p3TDDQFrp9x5ECMDzOeyoH+GjFUZvaLpDTPZIDnU6PNGHXPTiO7+b0IgEo5ssFJ3bqiY/CqUyXFN2oULIIFFk53Bx6GQuRCCjsMAs/MoI+YUMWFsG9DADypbqTZIT1r2/0QIpVZCDkQewSGQQptgH7mXoqkllrIPM2ci9G2Rrtll62pN0bjZgSLc09/M76x+jBi0dZcO0whGTdz7GYrAswTLn22h+xvfVd2cXGeHYFpfz2rB4PDg81fzsK/Z7yY2jzla6yTz4YDWrUG6tqRmPnVm6VIpz87PymQXSxA2TYv0fWvQ4TGjUL6HX4pXckBIRYNi7DcR5E6zqSec9fGGljTRkKFbEW+PWZ8j42XzGC4n8NGqfO4QTqetxOv3hiHR/zeN8k1sjKvDXHNT0ahaEMNSCFoNEKvJtjN0xjvXkaZ6DSKtsntzW8cHWtV+a2TzGlo5G8vRvNH6FA4lRE3JoZhHCe6EL/om55RCOMFSDduFChOFpJFbbSA+LXIvKltOCiS8XIxWOukwQugmsJPDb234FUQKozFWef++V0iTt+scfHRhm7FPotX8/6LxRsfj0Quo5VU9cLKsFUAzYk46oACMV7HhIgQanwwc3MCLQntPKxfFfRO2NaL6ry9UpVhai6GMZdz8TzPmjFT/s39oKVIqZARhYrGIiFKcxu0Ci3PrzmanrFkrbXmHbaB6Jp3bu9mSDo+jgyFqj9zm58j0LswojxfuKZKuTg0ZTfPMR8Kvo5C51y+b1US3mX0ebwgR8qy0WPPISpv1EEyH9BYE9edi/JZfLE3IqJNeW/v02lE0oT6tEYq06rfjKOVWsrhwazTCitNa7XVfAqr9n3l0/qO+8Jnnmn+dcogOGRwPqNbh3e8NvXGjcI8YAbPi5yBgmDqAVj0CnCV6bQmnoeZZsDz0h2VH/OMwelbYTOtzFMPpZARy2qREXPCyr6ucuYzsFG9Hkq7SU0LvHG9QmP6bBiNJq7jvWEIYV5P55wP4eXx8F5BabPIAxMoK52fE+EU3sFYc8DgzFt4jXG8w7obsYrTNxSmROZ+Cng+82xzFUmJJt3PcWhuCf2E8J7PGEwf0yc6zLXgoNK2MMYuIXUy63zAQwxZD3OsosI/+LUGz9pseKCRq0MRq+jLW1UmrrOBj5JVoz+KxUuMCqPKrem3ObzOAS5fGpR2SrgpK5AFPN3aNGfTqKSOxa444m0rry7djbVQDPnGm2hq/Ohfpay/wmvaRhS6M72QHF3Q3N2dg/PLCg+2oqwGxtrg7w390Ym+5xR0jIVyq/itGwha/15hYG04sqPXJk86OhXsunM3N/rmtZmAg+tmEiCZYr0YvJ5WMeyNR7bVQy9xEaxKgHJr3TnFUSyzSpjHhPC8DsI3AjnGiddbr2/mXS/GGHl4xt/xFofuXAjPNPkW/fF6QFfoQCjn2RJ1vHJHJ0joYTz3MFwSuvDNJha7TpS6Z7d0GO3n2Uoz7Q3hNfqgN0/HumNkBp2xbER5lNjr76204pUXnycIYKH+Xg/VfT36otFfq1LqJJhL/9b1NccqkcJ1Lb7AD5SmpH0hrOL51tq8KU8/eeGUS/tGhxYkaGSjSs888Wj5pXlDzhfebaXaVuzuqaEhZ5WlQpvtq+PrGpQ/fMfJ66tC63XbD2QO92MM0XTGNDRrBI2/vPcFnXa+sMUXfXMhGpHn8lv5kj5TVIDmclhzjzyo6LeJ/PZ1K0YB3jwKcgZH8ClWwmewxfMafpexq7zL1M4TqrVvrmILaxm2YZtkIwVSRcLTlysZQlugnchjCDFaIwoKrMq1gqiPGq9t8LS9aa+KroaBUdzYMFgIo87Y0E8CdwwC73szDEVQj0qk07ptxxLMR7jKSJt3DWAVvk9zHph9Q3OilXru1lU0scskS/ddbXKUN0CvOg+N3vrswhwbgqusdG23Q1Th7xi2YnB/MfcqUvJQvqssUJbo03UopNg1KOx19HPnSihYnne91o5V27zAgfNdjbK5+bfPNlo7etMKq9TJaHS0ncqXVkRhDeba8of7K7MUfXm8a7zHyFjZaNsItkYY79V5kXOd6wbxaH6ssGpp/tO0/6l9CgY0SmXgiTmga6wT/Koheuu9qwhbFVHPtHAJTwFh/Q3heaE9irjnvNRz47lSYANNUSg9UXOU5a//+q+fr525eFvcWOHiiHbBzvya2N1Weeca3F8D1pBTco+haTK3AlvYRrK+yglN57upqJoGhpk5eusdJSIaqKfGGM+1mOtrX/valSFQbiuxpqKkSTweO/7x0+/Wt8k58CED0R3jFVJjV23UfMVR9UiToObaHdU9z37vc7CWDEvLGWvU641bB976zNl9NRjbk6/SoNCMvc5BPeaOs3xAJuZ370p3PMZ8R1ZrPOq0FRoqXo+eHAA5O2vepC4oynyMsVFDPfuiDKKW3ToucyndaozrtHWttkNXQ3svx6Y3h4mu4E1rPQq5RnsbCPAiB01O1ma80SG9v3teOFXmC5XBG/IIG6IsD5U2N2oUvOxhJjE1/4Nlf/zjH3+G0WCemKKCUcVtkBioYbXfQQu14hinns8IMo8H7NOchQ8LqtLE7s8ZP6VfYeKNU5oVgCoSh/1VaexIpovSCOkoihh61DMonMIoilyOWj2rUaboRgkovW2JHwihRmpDNPNvENHGc+tVd+zbg0bP/rtRACNiDmcmvYzm6jGXJh0LgbdPRNKNQ4FvzK8OiWtaaus5mw9t8nPUCg+vUS/BZthrDDXruw1l8XRwHXpUwbUP/GTdRj6b92IUhgY8Smu+IZ6jqM7fNjxcZ677JqztEbxjDTb8Vr5R8EGualCUI1OCe6xb9tHV2tTwMWja/RWRu89c5vvuVel8zKMIBgMx+nOw/q0HrH1pVAXfyLTPaGRZCHXTtNffyimpMwD49RBsCDSRAsXereTzswmTEr/MW3ihRDqydLWYVaKIUux1M2K9b+MqlluPCAHr1RNOgu77GrVa8Cp14984bRfO3+oFXregG5Jo+NzEZnMcFEyZFf0koYu98qhb6tn9Go0sCG6VSpNpNRDFmn3AMBsmwlMUJXiK91UFpFpr7h3DxyhQ8nVQjtbDM0WhFdrusWgyvgqoOHLhIHTZWHi94+v4wdo3OkCXbbgaNaAXuEP0hZY7aqLIaiB25FJe7jzQvGOYxshWcW95PFLs+jWuGuVet6G8LTtb7vZz6KG9Ng8D1U3D54X78Ny0HVHSk3VwPavytxP5XfN3o1v/Vv7o3ArJdU1u3CgM5DIT7DkkI3xzxrfTNnkliIAxx0vZpZgEq4mu4nsNqSkhBKhisTDCpj7Dgmj1+Hg3XYBio7xAUYQXv2CICpy2k+tdrD5/e2KYs8LZULSKlRC2r3r3Na48f0zh702yop+++9pTeyEYpb6Poa2GnKERoYDmvHmrh+xt3J4S5aGpGmPUHK185B3Z7T0/leHJb3Un+pFHuSO6wpZ1ctAO/Rvm8+5BQubSuv7tUVZYyxPbM6Z0atyOPMMqoipZMIyIBqw2f2seoOtLfvCBaF8jlzV601qSvse3PfqtuCvLnWsjPPfs6rAq8vbZ6J/8ln+PHKppDARHYNrwlH7osEJjdVamdexbN0w7iqbLb42eWpzSe3fkVCe2jlrneWNGYbDlebikIijptddeOwth3wREEdr9O4LRaKKKoO9Ldh9G7KLzbiSCjryZWUDJ1G5qa0KQgNhh2Xvh7fMZaIwxG2X0xS9+8TxPNfiESCVHveltsNo8e3s5GsatobDwRx43Q1JjSgFuA+NZMO7CPWhfw0cJYvQNGRgbpcGj9hz3VxDRem+ymu+HLuNoTAUYfF8pMUMzkSllNYZ6eGvuUQHlTKd69jY6OYYELzp9cp/GWjiBgqVQ53lV/o0WebXOnTGObbTRfVcVlb5NtFIGnrGhuyOIBJyjlLE19fpt3o+yax5ADozBwzvbIDWRj1aFfeZ6u7Q5Y4WXSuti/O8WqXT+daC2AXX9jiyrLFt59Hi9EwOU3CR3o+HdWgnXPCDZ9h1IdMbU0uiOnbyb54Yf8Z8KRjSfVgSAbN24UaigCMExkSRjIYWGVbW4lBsCbMVURVMPt3BR79vE28cfMAobiyUEtciSs+PdTh92EdsHMCegejOY5KfXX1qgHdoVvjnyUjumHUG0mdP2LHp/vUuM4e8U9IZHpjX8ryCWRoQKrQtNdTMRpVO6NyzfpYo1jjzroXNf4cjhmOcqq50+xxAoy3W8h5Nk7QPZRrBRYRWFqHE7GkceXD25/XFteY68dI0oqt13aVFvfztO26ko72xeY5zwAz7tteUbhg1PtzJwQyWNXIpzg4/JpIjTfNrPpne9ev133pVt9xZeKmS0FW0hIAahBQfT2nf5ZtPrqG2j3Shuj2XL7bT9fSOPevs7MthRF6M07ch43djmNUyCgK33dqppS7tMaIyGvzujo3DIMAAvg+VTUYKxlLgJ2TBOE0fTGlIhJBiox2j4neBiAjsyBy6b8XSD2Gwam4P3/st/+S/nShwbjQiQHYgWp7DPkcLZAslz3tABYfWdf1dJb29J6NqKEZAKI174qdVTe3euTz2qDRmAmmwEKt27u9pPnwocb1P05VgFdOWB8yhnc05fGg8aEVnOv3vUM6gEX5UP9zk52zAzrMWcGbxGYDy/Gr+WGbe6rmXW29B3Q1SVIb7pPdvxcF0TkSIb/L3hld1HS7dFS+XF8jdnz+kDDJo+OAye5Z7u5yhNq+yOEsPb0TtylKbtPI+fjazoJIUDd5MLwlN1GOiKDTWhhzGb14bRtsO8nYtG4cbos2EvOpB+rR4pVG5sN24UCIzNGq1csYiiCcq6i0/5j3GplSv+WdiBwIF1+rKXGialXspDEbRHIxACCkcllf6q3Oa+6Us56sAXH/nIR85w0rw74XOf+9zp137t105/8id/cr5m3kswVQVz7UQQlBcFdISvlhHQa4eoWhmuC045Fmcs7cBtojfMr8+5xuYzr0EtVtq1K2O2ugw2rSQPHNeSOPxhjepZli7W2/MIfo/AEME1gqlwTFO/XZwcVDM/h5ckoCkl/LLLPXczx9LX+Hv2j2utd3ce91gTuakWN9QA1Ks+ijJbHdeNdxpF3F3zY0i9vbC7/zkkhZJarmoN5lBG8J89Mk2sdqNklV3pVuUP5rTeNX4MAaQBLeTJjni/jmmPttCPa+xknvlMab0k/He+852zPFSX7EKWTfvmQeYaBSqFrEWrnLWiHTW4dZZ3rm7/vfzRM9bwNAPTyPJGjYKGsFUaR6EQLK4Jth3aHoXpJlz8kcDtCbKeVaYYoN5wvVser/tLOItKSdvfMP92vAfGH0PRyo4xdsNQhbSasGyuoPPmLWwl0NCxURDa9niPKu4qje1Vlkn1x8COsYSxd+ema7WulecT6Gkip4b73TSmD2PunH3Xda5RtTZ4ZG+KNG/fUbZow0hY331/lW69uc7F2AsXmmO9wdKp0USN/nWevfH53lhqYDcExyBVPsxtK9DyVB08/TQfYA1Ead63rNjEG9GMU9sGppH5jsBcX295y840e1Imb6gvkWejtirW9mkNKGYOTg3Gw/BXDfh2FjY9dxRVGSRnxseoGU/vb1TEcJSvrtPJ5lH94jv93LhRKK7loTO51ru7bod6ncw2CjsE5AlYFMK3lVonWcOgn5YjFk7yrFYGNWTl1TmqmYczEJLx8rqdnTJ9TRJ6vNDxMjAqL2gbtCaNdrVCFbwxl3kwFWYFW1SwO8/ma9CxUQevzpvupm+J4x57sJVZjV89v+6NMO5CRTs3US91f6Y1kStUrhI6Co3nXvc1z8Oj7/EEjbZqEOpF19NkFFSp4Z9GL1W6ZMJalW6eWXnyaYUYGWhuYkMT5YcaCUUb9dp73/ZkfSdh6fu+bnP65Cz1DXSFjBtJFk7bzk95ovTasOhcR94UgKhmc8ZWlem06gjyXr6bf899MwdG6Cc5FqUR1h5/HbD2W6fOOPCMdeGQbAewSIC+Gz2Rq+rj6r9tGIz71oxCQ/5aUx6rcK0J5cIjVWz1bjbW3ok6cbCKW6iPSXvEMJy4kYDF6YFQxrBDVv0I7VVY2b07eYUxDhNySnhOH17g8+qrr56jhWHUqYhpyN8t9L4nNBVMb3AjyB1nPVuMNH9zjtGMdyAtUBu4ptFBGXnjuOg8dGdIKUf3d93rNWFmjIiOrevnpVdBlu7bg9Y3hdwSOwJTmBENvT1urqvHXbptY9Hv5zu06/ga/vfsevxSD7gFET2BtdBqjeH2GK15r99RbaFZdKvTUShm837XqwUiPuAIOQHrN6+5BS05dVi/hVMa8eBxkRvHyxzrFHXt0XrG5wVZYxSmH0dDiOiPYNc6oDvZLw818rrbo7w2d8OU2xBsB8C4W81U57LrtiP8ymB1Xdd2IzI7p1PjI6fXaOvG4SOD9OB6ofUA69037NlhXBN7R4mb/ez2U++1SgIDtMqpFh5Bt2HasAGBIdRTEeNFOKPQvQzHm43mmZi0eKNF8w6E+X0My8BP5l/ccCf3GvL2hTuld3eUT2htLwBI6MiLxGgEc3vyNeiN6MqQR3BJmXcbiu0pwl7RrQLnU1igXlThikYl4I4KsfFVGD17h9zm0TLTOg7m013Bu9X7n/5aSdekZQ3Jlo3Ox3PrQaJ1jUl5op5oHTRrQy72exC6QW9HDTVU1hSdGhG7lkHueKz7jn7J3hH0Qhb22Vt1qhiibcS307n1yJHnffeSzvirEVR5u+tQvqlstHV+dE7527NrcMofG9IsfMxZr7z2/Laftv1PGYUyJ+HrZErcKo0d6s/fZzJlMH/frQqhjFvFaeGbha+3UGaZVm+1lrlK0X2YUeTgmIz5zHO87KaCUW9BrbykYhmn+G3DvArMPEOiVXIdI0xzVDQazPfq073xzcczj4xC6VcaGVeTktau4XrXq8JHAW5oq7BiHYwKRiOZRqt1NvRXntvPaZKcUdhwT+/d+G7nWWeiArrnUyepUFTXojSusd307LVksfde57nW6zeuGh3OwB5nPes6L91fQOEbQw1/83zXrVt5ZFoNR3nFv4+OQK/+2TJeulU5dl9RHYtprt+K3xjKm67388igt22ndhsxjkv1645+ahy2A7mdr67tT9v+ysdcTKs3cO4kzM5jcHpnQ6CeyqlVqVcJIMAzg73ENfd7h1viSNBaruY5Fdwaph0a1pMqTEZ588AHUhpFPUp3jAPBs4HO4lXREMiddDZez6O4hIQt00VDi40GQvq+wlQp4Hw3RmIiHAppmuf3+Ap9+xRugaOD7ISoPZaYwG36mddWeGjWyNHctqDPRw6rxrWKoYLXZ3Q9KIkKWA2XXJY1gLd3g5b7u74EtJHTkQIh/KIVa1AIpHCLRvApDDJhHDu3pK+WoW5vspGdk3RtABUNTXTcCKdrqhWqad9dl9IYrZQHo7W+ygv9nX7ZxnTPpcUFOweHT8kV/nt0GYF0bvraCt5326FoVOGa8sd1kFN5tPyzkZWt4Ku/8GjzUdb+pzUMfyWj0LC8glDrX2XbM4haStqXVWgI0Rr/ThiuKo/gvarT9yhoDDCtVrJebXHTeuRdCF5NowTE7VjqYc+/B5dk+LxakjLelVENye04xeSeY8z2aihzVUooIYzufe9wve0yy/xsroWR25VW6DLXeEVpa7i1eibeGUxhtby1a1vhbWRYiMCHkug+A0JSrJkH13AaH2xIsj83HFZlN//uu3p7Tfm+NK+y3vDEPmqk1S/G4nmF6noUiH5b2DEOkoqkHlvf8dXLNlYGCZ+Sq4FCOTfbAepJnDsS297sUbS5FWPLykszv5fX0KTvNO5akH98Sgm6tpsa8VblvFHE3QUdl1/7zDrD9cbpmg3/7AhiK+lGboXZtnNTfbbp0/lZB9BheeNGjUI96iNB2xOv900hNDSqFdyEnra91X7vmlYBNKwvDrstd3/f35dZumD1FDzH3x2lO83mLYq7xsO4KYFh8h4L7VmNAOYaCrAVMz2V02Yvie8mymDG6NsxdN4Yayty9dzzOcJoMWGNWvs74g/3Fw5seWcrZ+pNN2Q+Cv03BFCF1P6qDLbhLC8VyuucN7zoPuPateJtjVitQz1qz6uRM+75eCObKGGuaYVPlVxlrFEIHmd4RaEMP562GbAbuDr/GgRKDA2m9ciXLbuF8jrn8kA38HUfTx1O/aGH93vvNVIOvfmT81iv/070z845bl6mmza003Xf/e4oof1p1qF9H0UYR/q2+pJcHT3zRoxCw6parR3CbebbMAIlV/xsC8IOu1w/9yufrPB1HDyjLkAXtkzAkm4LjJFUWVzHFJht+txJHSWUvKwKS6sn9MurQ4vpu29VU/GEYdCr+yUcJzDfj8HZh8LtSjBHSZSJKWoJ7blWZGMtzY/gGAeFIhrxbwrQ3zyDIAvjVf7w8OqhdVdshaVOByjM3wpteuMcz2noU2+cwiBMxky5NSG74VS07G5wz+2LW+pMeDERepaHGVtevLHPTnue7MiBNbYJsca+ETR6eAZ+QD/RPDqqzmkJ8PZg3ctoOfxQBMCgTCSJPr43xu5BIi9gUBGoyjutjib9QQc08V0F2dfRFjLtet5PBEFO8cf+roZ8v7+gTsJ2FLby7+/6LQ/U0Lie3O3EfD/b+b0Vo1DhbHiIkXZ43/CpXj4lw+JX2c7fhJXCQExKKLv3oOFRhX9+VhDrkW0PEWNZjC4OISo8s6GG4tDO7ZnrJxSfn17IA6ukWCwqA1YPfBtDdKRcu1u731VwCUAVUGlm5zYhpAi7Ft4Z7Dvr0TUjjF3vmbtyuB4fsTdkubdHO/OE92meO4RHc0oW32xMtsreuhKi7YERvL3D2Fx7DpCxl6dqWIcGSotBGbsabMMI1mfu+/SnP32Gh+D75TlrxihQ3jt6M/9WdnFijMEpv44o4QjMc+e9G6CkRu11CLvRcVfCeMZWmBuC5XA45bZHsRSCtrai1hpxkbky2UbojK71K++SxeveffFCDj3cDubmnc17nlM+6rPLly03L3KyZcs1zY9Vj3GuqgPozVuJFHZI1pC0YfERJNPPERRFsPSDeRmFtkYRMNKjRWko53kb5/fZDLyJXcy7Rso9xj5MPa34r01sGLsKUf/tr61R0/YCCWWjqyZAj4wcZqOwHJdhV7M9DoVUGPCjDYC8RMqt2Dq8u9VNFebNB/UmJbSbJCycQzk2OV+4RWNI9W98R7zbcRMsAlWeMYYqhka/o7Sc8TX9uP8omdx1qseqymwci/YhMoCrv5tctLXv7ulgiFW27UjHXI9kvA5SHS3rULitOqMw0NwrYhad1Ni7v8q39Kqi3HqqBuDIA/ddc2CPFjy69dl2ijatjtZjGwStY9kRQ2nWcXQ8vcf8t8yX1rcSKVTBGvBmtp2onVaDQBEWO27IRXl24YSoVX6FEVjzjb9RWqw85h3Ga8VNvb0KVRekTAFWqmFBl+KQIh6JYtdMAwvMuPdhbF3ULnw9FCH63q3a+zeuyajMNZTA0GaSyX1Hxnyca7MVeWlPefGGRT08U0aLQpQn6VxVL821vFQGa35ShoTaGs+/Z8wV5r0W2+A0eiqtK2jgHjvV59qJmBwBspO5zb+AZCZKmA9j73hu461jcJ1hqMIFD804pqihSk9p7VaMdaRqCPrK0aHvnO3l0Me+95eM7EIJMkgn1NHp3ohWRZWXRbXlE5ECOeiabUO06dXvy/e74MDvaLNpJWJ5tN6ottfD9VsPdY5Hkaq/0yFtNaA1atW71tB4tvHqfD2j0fSGtm/MKMwDHUBXhdXQpsqpxMJYW8Fuj6BMWMEmAMPIXuhTrG0rdgqrEM9RohRDH0Fa7bvKdntRTSLzioVrXkDkBEkwQqt1wCnzvPa1Q9aGtBSQn+bR+TXRbf59Xjf5zRjnmhnblCAO3DQ/hdRzjUSkMYF9RrHYtzAGZU6SdVwAAZznDR6OZntjDR7ZZZ8UaQ0T54ESab7KWLs+hLfwAf7cnt72Jud6hrfRRmlJPvoq2O6IViZs/O7tngnQDZ4bus+pvANHWsu9S31HN+XVrYwaRZnDPGPWeMY9RmfWE/29b73l3Y220bZ0rGLusRxd57nHS+b1XafwCGkoQtFd7DXKaN037VV+64hUtzSKnYY/KpONMPFRHc7qr6ITNT7kcNr2+OvMttXpln8r7xc+q1EpfbYhv/E3r+2D6SoYRwMoPNOFqFcEYjChencb30NgSpE3SdjnnkYB9kpUSDrmLjxrvEOywgU1hBaqYWkFUvUEL7hQy/zeM1Ya+m2vf4fw6Mvb614G40GzubZee5mMAt7rZyMejLlVJ6AM64v+3gfs3CQnRarI2lDXNN6hvkVTVdpNPDYEphxqFLpOxlhB+Mu8tf6tkBFa1ZBuxYXejPJcyym4LtKyji3NHPqCwWw6PFJantuzkraTdl3Zd3m5+YbCcZL8VTr4sV56aVh94N+MAdqUZnUYt1zt9aA4NwS0165OYQ0M2TaHOhI7Am3bTkPHs41ijRBaTDuClzzvqFKpumlHhNVPNQStKpy/tQCnTsyNG4V57eaErnM8dAffhUKECnYXHLFqIWtA6tW2YeBi8CNIjpmAhc41YBC11YSmxqwEb2hNiW2jQAl13q2G2ImtMqgkbo+6Fo2ABTYUViasAW3IWkiu4WVhsjJYk8gUnXG3PwZmaDWwUo94EPHoq8qMUZi+Zk6qT7qhqoqpp98OHZqsRLvizN0FbD16plDhn+0luecoN3Uk0Oa8lT86+3udmEI425NmDDtGNOlHHgVv9f0QGvpY43rbndeulsFLVajNBXBOmi8rXzRn4BloclQk0THXUBuXT7Hurl91S/l8P6fP2GiA5xVe9l1zVdb+XpyI6gj0rPNa53Ing4+MUmH1aeWjbUy2MayOqiFoXzU6/Tf0YuurGzEKn/3sZ692OYIU6vUYcGGieoaE1+aMEgqxGqKVUabNd6osRlHAQedvo7zGOEw0M4fVzThGMU1oPNcq/2y04FNP6chjMFblsBikx0rriwHCYL6fvw2sQmlX0ZYmhAQTS7i26qfXSdK1AmtXLPhdsrtMO813TTLWg4KtHykGcJPXrgrf+2pW8JZqMMbAQWQ1hNNg59YZhNXqqkZlpUnr7qvseVD7QL1i4W2NaN/NqJSXSlfXdVyFB+sc9Thwe1Ikf4enh5+9f3o+eHmaaAxNWsoLXigPFHKaJrLW6nTgB07G/LT+NXDdR1L5KuxEmdfx01ejOk5JIyhzcxrqfPSnbRzdM7sXojpmG4+u+d0Y7ir2o5L3zqXy1iioTtfWdRs12TKraGEbNNFAjcd1UcwuI7/xnMKGh3Z2v1a34eYWwird68Ivz9FnE4MMhPtHmIZpZoF4s/OZ3zEGxbJPPoSF8xCLx9XrLATUA862l1b8vszeuv/p13lFPL+t9OcjZ1BstsqQQpdsVPLJs+gLTAq/1DthGNGyL6Cvkcdg1sDJmYxcFSPBRre5BxxhHObpuX7OM5xKKzm7veD+jlZKdNtnDV+FTdvr47sahRqM7QgVimguqs9Euyri8pXfd+7HWkhMM7QzHkbCsdUUiD0AYL0qkU0n89myYDzz9+7P8dNmqDpS1oKBqBE48uinmc84dsbdyKsKVwTq2TUqbdUh1Ukbzdj3bHjnCAnZSrUGY9+7o9Xqj0Y00/rs0pou6Lvkt27aOVX9kUUwqMjoVkpSKRvhcQmyJ9SBYsodKvXabRiOFquLKrFHKUkwzd97xG4X0Bh2Eq7H2vazFTUF3LrxjlU0QQlvBukYGInObcMgzRd0wRmc4vQ78UlR7P7NpVCBdZprNqOBFdBJ3zVwmE4yr8+YJkHakH2XALpu1pRRUB67PS3N3ylC4+xhc8Wzj/YZtI9GFZRBa74pPAq285BILl+h4VFV2bQq1Q0Vmner+vCB53jjnXXrfPAiGjT6pJw4V92gVSPlU0O4jaFxb37Dr12rXqfcdiIh0aj1t09hF0jgq6NKmq2Yt7fu9yOdc2S876zX5W7YzO/44CgC73rWAdyefXVNdRz5wyuF9ORiNyxlPOXNoyj3RozCLOIs3giqd+NW4BpmY5gtxIxDiWiStcpdUNfYZLMbSAAsMd7TRAgf/vCHr/rFXBtn5Y2xok2O7g00IBA7bqvcLIa5EOImtGwyYriaZC0Nm8gsFFQG2tdZh25oOyonrPdj/n6n2OCP5gG337DYPLP4N0UuvKfM5Hlm/t7StT1B68d4DN2LlxpzI83OY1oNXAW818334Kzh5b7EyNx2rsb3hLIGzzpuR6cKExSD3jWO08ozXtw0P/3e85EKA1iHJps7hv22NO/psDlw+pn1mgqnvpDK3MiFta9SrMKsMayB28ZCJDOGYKrVrIM+7GB2Ftj83E5EIV/jOYLGSgO02+clNaqsjNw5OKX3SGFbhyP4UMOrnKY6VTvK2IhK+a79VZe2oqp8615R5vx+KzmFYbDB7IfBpuRwDMPseFRlMQ937si0Vo3UKpaI7iNsJUwTUoUjEGTDN/OZZ8647BwVLWwctQtRJYOQmn9TsNPvUWhY76mwyD6tsHsV1ITXo22EgQYgg86jHv+0eq89ddL1xrYrStBE6N7x1IuvgFvDwbabS2nSuMqgZaY9XI4B2B7nFsbCPQwgHvCzxrmCxHi2wscZP1MqPGvQ9a3y8tzSoU4L414PHT3m9+49Kc9MM57yGeNZL7mKE54+/A0KdV15BS8zFIzt3LtfwmIXcSOC7bk20qlzUcfP/EWPlVEGD03nwwhN6ztIwLstvS30Um+5ir+frlUjsa2AKUttR3N3FqxT3dTooY4V2mwepedqUOv4ld+NdcNDlcWuS3UF2ayRK8pwa/DRvGXMpMb7Q8wuHoEpjmXCGLBE1H89DITE7LWSNSr1CnliNRpKHTdhjqCi3S+h3gyzvRMM5ncL1tp0nlsrISw4wW3ScTPebmWOHaXIQ9TLRpcmC6ukahQLgxyF0/MTtFNvv4JIQM2r72jmORWHL7wmwtiKqh55hfYo/C6MwiArY6Ycu276a+J702NHsvVeG6nsZGbHWz7ZoT7PeD42/aHZ0HvkbQoW9ruq9buhvx0xVXFQHkdrjcal9/aYC6+hc/exdANqHbo+c8bAsDUqqJJt1NaNh5XhLRObb41pf189s++5s6r/9r2lA1psw7PRkv6s7tiGuE4Vg+EZR/qyjlPhssrMrRiFYcYRqClN9b4AG4skM1qCuIlbwlYAi29WobQihrGZhpkbSh8Rl2dk4cpkGKHeIOXWcW7h008ViedT9hSaE1ApY2c5TfQyb13rMcWgJT/NT6Jv020LQ5mBwt+RScfVk1PlCnoUdZVTGc5987H2FaTSgtLF0PNc0cWG3SStm2Cvwdmw3BayGnTKr0c5FE/nTfewN4rKd8bGe+9O2z6zEJ3nb8/atdu4i4AL8dWQqMAyJgcrHr1cxjPsLiYvnsk5qWNV+WQoen7StCr87TgxCGDVHg3iuT0O/Dq4pHTkePaoDc/fNK9MV+mX7u7dhRo7mmzO6W6i8UJO1QHlg03HzrHj21F9jwyvMd48Ugezhqg0bNS5dZ1rbiWnUMs2eD0oaZTd4JLzce6PAXeAR96u7/zcHngXGlPDgytE9ei7KGAk4zF+xyg0udiF69jKFBbvSDlhPsI5tBjBbu5AMm8w1am6IPAOzaMEhdF2wuqjm5SqBHf4PNebW8tgZzwUvsQsQZPYNGdMzsuXLyhs0/VDY55cN9OVf4pTF+fcHg1eKPQzzsiuINprO9d3E9j2hCtklKAxgrmcvc/hadVWnZhdGVVvd0c3zQng1R61AnrcUQR+g/OPzFUm6vUb1/akC8XV8xZFWbOjSHF7wi2PFoHiuR0RoMU+y780k9/Ynn2NA9oak3XeRoZRERWC3mYsw/v1ohkMZd+ue/PSWQBhdbxHThmZqz7SvzVr2e1GPuiL0pt89RC7QsHWuQ5AnZPqskaiN24UbCSyMWmIPh7vDFyCs2/22idilpF4Gv1ZT7gE2NEGL9iEEWF7zrXuGo+o11OeVSLut7ANvbeX3kVS9dITPusFtgqHIaEYh6aFVWzoKj2b+K433/nCiI233i9l53kV7Iat5qWqq+fqt1XpVLnWCzT/LcBbAe6IUv8bjz/yxrR6hr5vJNAxdW2mFdIrn+4ot/TeuY/Wk5dGez6l8YZlfGqwCgOWblVE24Gqcqmh4jV3TpUrxmhDmHWetkNQJ6UG+yhC2ut7ZIDa6qhw6PC053fOzfFY6x6nbq1F0s4AK19sDP/I+dmt/Kl/J/8WxSj/Vnd0DtehAV2rOqLystv5qeP407a/klFw9PI0ddBTTjaTn8hhNpC99tprZ4s8n77C77owGoPVOywBKrQbw69RqbB18XeI6W97w1p38V4XJhYSqVdfXJzSbX7A2Am6c+8nUhBCtrKqRxv0xTY2c+0EYqMInm6PF69RmO8wU5WcCGD+XQhAcnPPcyvw5k8afpeW27uvN9gNP3USqsTxh+RulStj36KFevp4sHmEwkEtkqgCwh+73NQ9EtVyAPi31WmMqzFvQ1fF21wEmg799VvFzVuusdCPZ9Z7rMHePwvbaeWtGoXy89Fc+vdtdDrGDSNZo0Y501ps0g117jvKRYh++z4GVWKtgnJKMHl48ODBWTa3977HXyXb+ReJmGqvcZpFNGSoBRbWunQmn0eVRNWbIvFGzpzNyl9hqxs3CjzQUWqjnAYCmTPfuwllCCqiMNlh7A3R1OsuIVqXXw+y4VmvV5JX60gIWvZXXHFaE0C9dhN9Ftdi7lLJvbFGf4TL+MA/NarDMHMfT4L3szfwdJOcudVoFMvmnZQGDIf5UHwbgpn7GDGVLTvBznhSbrvywd8oM3TE0CI0+PPcQ8j7fojpnzHqxp0Zxwh5nQPj8izrXKPfs5saRdQgFAKwthrlr4KnCVQVTLN+U4BR/H8OlJvxzrqPXLRap4awcMk+1E7RwPRfBWJOIsLeq89WrfVVmloVJ+U31/egxeFP1/pZB6EyVG+ffHqhUffTzKdvc+tpqYyv3JvNpzV+ldfKLL4mF97N0Nwjr13fxuQcsjcvd4xzklq5UyW9N2vKqwy9BlZX/ttS5LkXemDOhQDLi3SUeaFzcyvG0aNfjLURCF6+FfioocxMbhj9jTfeuFI0MwAWGFTBCFSx7FAKc/m+yp/XV8tXgeHdl0FraTfD6LutibN6BUJhz63h6Vw21LAhkj6bBzKGdf4+zOEI7SaGMWBxXh5dNzB5zjaa5kBR+L1n/tcTJ8gVvNL7KJSt57Q34rXV863XWrilfIFuFJQ+rMfON9XTPuKZRgTG0vXR3OdePNS9LcZhHo3IbLqa76tcOFPlrYb95dsaOHTlIZtLN3T5mwi5xn7DRhSKBHSjS31R2M6zcvpuab6TyTWujdg33Nq51ohUTkZZe3vgGNwe4bHPyqou2BFWK7nQnbNp/s31eT/5jy93iuOFI17GO40iOIL2cqn+I+/ozMlpJV7164aoNoRXo76T5keyUefnaD43YhQoLNUn80A5BpZxmAn0gDmaOa8BKDEq5FXE0xpp8JRb/urTkIoQdNyUxlaIXeyOpYnKenX+TbHtSKOL6BrMMw0kUK+h9fRKJ3lk+u58i1tTVJRVE4nmXrqAYTr3CnnnUCOI+eZv2+Dw+im70td67pLb7XlVsdeoGeuOEjZsgCZdt9Kp12yo6yg6oEhKw0ZoPbqjAurYFbxaL654tnlQ6lqNgk8FfXvN04a23WW+obsWcbSgoRVl5NbxKPB28I2xN2Lg5dbIoxferDx7xnYQwDqDQDj3iVIFibZAoPxVY9EKQrScT0uR57njtFKacmc/unxfepVvZazRUJ1JRrfwln67Q7vwb3VKYfPNq+XfDbvVeeO8bJ26HY4bNQoWoWGISbfyhxc/IZQBloEsVJX1boSnk9/YWTftbK+8mX6ha72w1uVXCZbg9Rbm5zCpheEFdnOa+5ogpKDRQ1ip+omHDTohdC2Ns6AUTBd9nsHD8UzzVS64vWlJa5VIzUXAJM0FrevZmU+ZemhBee2jO+qh901p+vf3QhI7d0TQ6qFuRUMRguqsdUtZCZ+5wPoLFfI2VaFUudfDo2hEfhM1V/DMQd7oqJYfzg2C6DzBZiAVSk9F2y6FneZdyHi8+zP8fX52I5moXi6QVz5FIyLaGffw7ihrL+Op87EVTz12JwH37XV4eO4fuZo+x5mcn+jREm0e/BEfNYrfET+osm8Y5Nyg4d5AeT+b5Grwqh+2TqTs7SMpX7uP/uo6bAVf/i+f9nnajrArZ+2HfroV+GiHrIRY6OR9xAQKRmdArOMOR+ulIyDPwd/rdWhl/jIjRWcheMX+tu8psbrojRCE1b4HbUg6HyXyavR4nkMj792tIdgLjxnrAfNmjMlaNLLZ3qPoiNdSHFMCdnvw7+ZdFPpwTIRnlBE7Fs+ej1zThtl2lNW/lYZNSNe7paDKOzUseG1DCoUwamDqdIBG8a6IS+WKe/cejG0gOv5GJ3uejKuouJVs8nXFycu3jaRaHopnydEu/Z7+OBJVsqXJKDwRhn0lldNpO79H+YJOGsky1D2dt6/i7I7tGuJG6l1DdBClTmvkWiSivGe9tld+J85JDc12XEp/hqF8tOHHymv5ow5oIxJ/287akQNiPG1dixs3Clq9xuK1MLVWilTx+xx5FgZfr7aE2opje5N9The3/YE+KJjd/1bM+nJPt91jvmkbctG2Mqv3JlrAsLxBEdGOYKpcGx5XGVdI6o2hneOUt4c5n5YPG3txYYq+XjXvDtTQclmOQ2Gt7gsAq+n33cL1rrmfnVe9RXRuGaBW4e/fus51LspnjVytnQoTim9aj/iugJZvylsdj2dIWna8PeEXD9RhqTxUJjZ/bhruiJ2CrzHoz0KOjUBqRCrrO5orvzavom/YvqisBrxz4s1XEVZZ+mwo+d10y446ph0ZBb8fQT6grBrG3l+jMK3OSeWhNOxabaPWn1un6X+v/Y0aBXBHFWV3L7dKpOWJtZTbQleB8367qam4axehhmaYqJVKZZ56Cdvb6ImnjX54bxRrqx/qWRdD3th2cwPmPOOcVyvaqSoMb7VMhaWeG6NLKAfSqFIoPGLsvEprUiikUFEhjmn1kNG9EdJEOVNp8xu/8RvnkuQxDNPnbF70LoQm1JT4MQhH4b7ndf12ZFpvvUxfgzI0m/F89KMfvYIMbQDkDXd9i6cTdPg5DNoZVXhm+h7IY0qwwUcztzkHbGgwz+vrN6sQ6pGanzWfqGNoi+enzyOFxzhVkW0YlpJFx/67BsCOan3UIalC1o/5iJ54/ZXpftzbUldRs/UG04GtejSMcXYTW/uvzNS4+dnX1BrL1kF+Z9wfHbwxrTLW67uuR559N9iV52vMGlFXv6FzIeMacVCxfo6cAGOtE3vjp6QaZIWZFzPCvxkCI1KO27p3sFX08wzvca1nf110QLDBQjVanoWJwVheO+nUyKNEDcbbJWjbqluUjnPDZDVsjnzoMRYbOmjOxstmYJcVcAxr3JRdw+8ave2BGLv5WDcGcntZxjNGbb4fRTbXTwnmKMOZl7WDB+9qC0qqAqeM1xpWeWo78nRtk6TmSCGgFxpvXtJXc1FzrdJMx6Sbv9erzr1jBOczc/RO4x4IeCVoB2//Yrhb5dQEZPsuvDet0RYZ2vh+c2rXReaFc5RHg6lmHTduj9aFHncOr7BSk67Ga/74i1GlkFsgYpyO+PDv6hhG3Bgqp3i/CrPQDnq6/4VUM1ZOOp8qYdc1gbzl6joYakdU1Tu9h0ElExvF8Kwjw+T+WzMKiF4MvqHlVpzdcKMMrBHDhkjaWOISrx7AddDTDrfcg6Hb7xETbYIeeRU8E2M7ant+7tGnvAuBsWiNDihRZ++MwuVt1zPE4BhFDbhIgbBteleBGEPnWk+sQiU3MEqQJz7zGadAXX4jhX2URD2dGm/7XXat/sZ7t0e1lTtc17ELna917/qbb726KpJGIiIukNv8tG9n5l0+2vQrjFgDRXF7fufRCMl8/dwQQp+1nZGuq2dUbgoVGlcTu/iDAUGfyiYe7x6UXWHlw/CAieqUbA+60fuWsdKWrG+4qk7ojtKsbav0Hi34uTza6i65tFYTHeV5jtrWGzUGW7f1bzVYosy26kDz9e/rdNVfyyhghIb9lL+SxIafzkEaxhbKuQ+DFX+b1gRwBYwyrzLc4V2vMd4Sds9ln2tigRtubaVSmIqn1cXwLJ4nxT/3jtKrp9ikXJnbS+8LyzWXwKseBp3n8OqE4VWkGLZeZZ+HLpi63m2FAZxVBh24ZN7XPb8XkuLVVvC6bg15Yb4zH3CaypjyUY1Mq1qO+q+DIoT3Ypkq5g1R9ZmiDkatSeyOoZV35kMx+VsVFloXCjN/VUlNVtbjb+vmLc/iKe53MKiw2grwiMfr5beUXF+Nand0wKlRmk4fbCO1ZdEGOhFoIVpVZOZYvm2USea676LOVg1GjcJen8erRNv35tW3OloHu6a7Nhse3VBVnZCNTtCZxrh1TnmWbkUH/TUaUnq7jeqN7WiuNTXBKkYQE0Xi7UpHL+yY6yUp+/cy7JH15KVtSMa/q9ya/W9ZKqUCYqnQNlQuAzY0nk9L2syZcFtAzFIPae7p5rE2jIsReFsUJcaiTFV1jFHgsVZ4C9dtb93zMMyuHEHL/tv6mj8Ba2kf5dT5VcDqlXbneo0yo933DUtCboNTb3fDd3jItXUs8N6OII2ZcfGuY3+vkquS6fc7+utO/Q2LWUvP214xge+a1ovuevoej3V/w/Yyt9HhaFQO5m/kpOtaB6C7n829u+43dFRYd57f6xxkSK+MEu4eBc7OzumVJwrFMPQ7Md+XUc3fN9z6ZG14azXYfN+y4DpedESjvM03hbZqWI25+ssct0xVb5gTvuAQkLOO4caNAnx/W2rMiOEq+LVcPKztSe7aeH0T6M30R8p0h1f6IfQd8+6rpbI1DtoWRkJm4esRFiaqIBYys9har9lz3N5KlU8NW19UspVlQ8qORd8b6yztfUfxN+oo3a9bm9K83uU2+ASTkmMUWs7IKHR+m282LGKdtlIynsKRNZjzaclrFWohiSr4Rl5Vtj22ZcMC5bF6f/ViCfaOmCtbm18rB9f9rZ42xS6/hgbznRzKLudtdLt53jM5Dq2G88zqEvqip4cyMI1afLoWlaENkZD/PkM5OeXZktcnq/KoRTJVzo1U8Ujb9tgLw+2199yjddpreMQ7W7YblTU6vhWjwGOyeE3ubCU4zcLXq2WNa2XrVZmwyW1iHxFpe/klvJCz0MIWoi4C77xwlAW1+DUIna9FqNLYc9iGrjTbC+ne0nOaRB9FKW+wFRgm2QKJvvWoCiMYS8dvznMPzwkkUzr2p2ZOjQ5qVPSvLLYeoe8YjO15dj4VQrywE8zCfn2D9Oqp4QEJ0GndLFXvrR7clgWeumivEYl1ahRTvuo+m13ZV8fDHpztWFjHRj+VDevhGPpZy6HFeOb67pEovN8dbYJF+0a3RiHGfLR26ONYix4o6P5WD3EU9LfLizsmz2VAGQIVZX1PNTlqxHonRr39NZl7nTM3DW+S1+1U6nvL4jaqR+u6HbGua+WW7p3oS4R/40bBO1NbXkYBVvlXWIt7Tit2SggmFOPpqqqxuBYeYUuUo5Conh+Fhhm7cASLkjL2I69gh/tVchZOX3aCbq9x/t3dxfqtcqNAvHyHdwa39MYtykqljUjhKPqY+RCAemfTCm3MM82BZw7rLZ2v844rDI1oCAHagwvQBS12ZdT2eloWu42x59SDRr/O8ai6jHBuDN57gtG2Sr/PpAi34Crd9dpP5cTT31SRFSYqrzT52jnu5Kn1M6edHK1Hj8e2EjV/u4aHv6qcHZPf16jWqG/YYn63odF6Ud5gmW1QyKiqNeN1jfVWhcexLG26LtYPPaYPVWQ1eJwQ/NcKnSfrHDU0bw4LP9ABnK/qm/J/cwfkZMPVnlP+7hru5/YIlKF7x9x9NFM27j0ktwIfWVRVBVUGhY4aLm9veYdWcEzRBGZoiF6P8rpWiODd4JodjdSj2ha75ZxVcLsPRkJde72jMleVxzam9aYxhwoiRqARVoVjv1+CQduhesc6jOLojTlvpripstJRYN2JeoRtdj79uRm6XqSx+Rth3wqhfODvNUT1vrsu9Qr9rEFE+/Gi0EcUi+6NBtv3Xrvypb/P8xxpomKlQr8x/RqGRhvlbeu7q/8oq53gPMKSN+xQz7fRwFzXt7xVUbq3tC9EJNHcvFmNADp5rmdsrx9/XBc9bshoQ3d4vcfK1EHRd6OvaRt+rUPY52qcmvZ3NK62PrcGtjqrY+i/3Tvj9b7x4bU6Ok6XEAVyem7NKMzgW9EAoqG8hd9bwRWuaCOUBLeEqOKu9ayg7muPksZ9bpV5PQECUsYvw28PYnv4DcV3VYK+er8qkf3SkCrPEUwlnn0lZOkOBmiEsxNr9crRfKp9vEFvfloHew7GMIwgKYW152Ab+M3M/l5Pr/mBQgjoziu3PvigSfejnM82UO73ghOfninUCEFiU1/yXTtRWGXS8HxDVv7eAosml9GALBSead6oEcR2burhznUiRobH+CtvHZ9WnudBV/F2z8de68qVMe1X14qM67VXdrpHoXtJek2dkCrcrZSPeJIeqoNQ2dkIACMyrQhHYR/3+/vR2I6ciGlHyt56NBLGn3u+/o13h8cmwufcodvw2/wdbFljdeNGod7WDBIMAHflbc13M7DZ8SlkqpfMYPQwNwQbBdkz1gkIpm89dz0NEy7GWkNEeW/vnHfUMsEuWompwkLlQhmvVRVoU+EkeObg7JhCV/WajUmUQJmU4ctI24CZN4WEGWHTqpWmpHR2J3/84x+/Oo9p+rQZB4O2SmKvpdCcNza/i/DmeWNgZg/DRB0gSDTBT3YNF1Jj8NC/xmQbuToT9kzMs2eOKrf0UcfFWOe+MX6lN8WkHNdzmxfayoNQzjN52tN3q6fqERN+PFoaKtGdjyqs+XhnCZjJuwBabCCiLCzV1ki4iewq4UYNrWTqvOd6/G+tjKelr/qoUel6GlMPmCQvlXP37fcbN5IFF6Kldbe5Fu+S7a7fw1VcsJXyjh70VcdiR46l+REC0jzARjBarTi6Z5y3UfjzGVjIdeSV017ofMv+jR+dbZEsXkPKTqyMM9czHIgkJG2d7cbpCSflWK/NwlCeZRCtYzGeLjYvdMNDNQpdcJbXQWiUeXcTz8d4eoSG5xkHZeG43iqtlnpuKKi0qlJsVLBPRt2elflTLnbMjlGwyxuW3Eqx+ewXufDEBn6CoY9Cc8LlGJ9RtnDrQglHCr4RVaO97YnX6yz/GSfl22PJPQcNCZy/t7KpO+OLoW96thS3f5t+6jhUFuoRVqmpzJv7GKiJNuZjvHNt4VbKRX+cgOmLAd7KYuPZldeubTHoJkULixQnb/RHPuvA7L4Zz0ZQdvnXyLZtqMXfeMTVH0e5xOuMQn9/crCPp3Kzo4YtZ+XdXlfYD72NFx/UKIAgvdVyjleZqL57mGxUpcv0xcGrUzHO2a0eiEdZ13sqs9STbzVFQ2EExzR7B6TJzL09swaReT8NtTfDVpB3Iq4L3SqVts6PQei7IxiyMgiLzBvFbD0D/ihHYWzXYetVMu+2Hb/zPsoBdJwU0fx7lIgjkUFVpUMrs/p3CoqBmJ+8RecA8WSMrd7UHleF0xxcX8avctu02kqBUuzvlDee3PzcuW3DpVHmPDKNB96SVOtX5VIlusubC6uJpGocaxDrcRo7hYF+VaiUtOdbhxqPykIj0vJmvfytIDu/8u+05tEYZBAlWjdKr8I07j1vfLErlKoDNt9t2OdxZLKK2txbybd5okah3xft6LP1U/iQLgRDT7T42c9+9vxaz4nmJ0KgS0Q+lSv9qTjyPowe6X2jRqEbhwiUjVtKvgaKmMFQELxeHg3mt5BC8zJIlT+PYixfK0d4BtP/WMAeNYCRGvZvb7lMASrYkcs0Ywf5OFO+5bgU6dw7Y6AQ0aZQSJmhDE1R1uM0xkYHvNYqNQy372E8+ncbthhazMyrbHFA7zferr8D22ZcAw2JNIYe8+9h2lkbNPVWPkIydCqcRBC7obFK0Jhq9MyLoectb6xeq6JpZOk+v+Of5g2q/K3JjjxLt4mehPle1TnfocsI6XYUWvvOWM/fvMObMW9VWp0ISoJB3tF1eauRxea57WHvnECVa6Pa+duu8KE7+pbB8Xy9I1lJqOiSUqfgjaFOUedgPI3GjL1yVljN913Lna+6s/pujml/Xx4oHSnwzcvgLU7mRAHDI0OXV1999WwAxiBU74mA5fbm8EUQJXqJLlQuDp995zvfOUdgcxjnrUQK9cAJDAbp6zfnJwVdDxxzdit+lVD/DXs8svAUjdzFMNcQDJZLuLYnXkVsERvaTqvCbx6gJ5fa7u77Vq0U9moIWgPBq2keArP69zR02hUq2ytrYurIo3FdI7V6OULQHYk08ipsR0imFeJDt72RrutYDNfzGr3VAwW9dLzbG6vBKC91DRsl7MhE363emdbDGPHmTpril5Y9gtDGIDCE3lbmGaBFxt2nkFWjKnk3a9tPsfCjXJb59d97DqWr9m4OTI1MI5CO209OSFGDKvnhm+ZfQHedf6ukthGr0mzCelp5YfN8DV+f+Xglk9F4lwmXB/d6bGjKWPqq0TEEo7vGGPzKr/zK2YnAK/jFaQUiqVYijnPR3Jz8JKTCHDgRjXBvzCgU92/IiwGbHB0vqInRHiR1fnBC6eJhW9griJ2oBXSPMH0I7t9DjDK+0HCHoFWWGFt/hYjMw8tyGA/KsRHUTkRtjNL4GZsdPblv75/YuYb9zCpfc6zg1xPaoS9vowns0qde0xZOzLcVRq/Z+C2B3qH2VlBHEJvv0XAnNSmCd1MKW2mWDhvC6N+6fo1yvTnMS+H7IprmDPoO4CPcfgtvabbHXigIjXt/aXek8P19Qx7lIbx7XbS912obkA3DzNid7UTx1cB03YxHQUgjn8oXXqvRwV8dY2m4+XI7Do9X8cZRebI59XSDLYOUvGqh4Y0xBB/72MfORmGMwac//emr/SwtIhiDMMUg4xT0xNy+wIyeoKsYr02fyv6NGQWbJGbwlJHQD+OCicaKTaQgT6BKoRU/22tEwCNmRfit+PYiscZ9v7G/15uqUqpSqccg1GUc/G36nsWlpGeufTnIHjfh2eEthTLPbKVHz58pjUBdyvj0xQMtHdFjl7rVSJRxGlk0MqkXv7Hn/qzR7vOtW4Wkz1EdwiiKtAonbdioQoy/uqFS/+ZQo1aPH5xQr7JORq+lxMsD3iOMhySF8UpzKvWSHRRZ5alPz1MAsA0XnjVWvELwbfKaZw5sUP5vvqTKu/mT0lf0u41719Z43Y+vQRkaKBgdwF7WecN92zGctk/bre7gkBYeMrc6Ghv+aaTsHu0oEp3W6Eh0Uh3oPvw9ieJR/J/61KfOieJxHAZS9Hrf6Q+8NvePQw2CFikMvRRt7OjD2Prq0TpNHOVt0G/MKOi87xGuB1vCYSwKSxXIfJwj3z7mnpbOba+a11wlsze0TOvfWjUB029SWS6khN0vP58m2de5mOs+ZoLxqcLRGgGgTQ1rw+pi3tP0bV4VMkq1ys/9DWW3R1hDsXHieo01AO2DAOMHvNBNdtuoaDvM3wJrTXbk0n0tvORW2Mj/oBnPvN5q56XVEDY663pIAjrNlcBN60t15vfJq1TYPa84eXlcdIqGG06qLFAAjphAA8pj7nH0NfqWB2tour6uw6OFMrvmYE0wh3GSJw5VHQx7bWZ8eHjDnHutt8dbJ44hcFAn56BOxFF0tfm5UOi0DRmSrZZ3NippJebcw3FWOTQRwUQGAxd1P9HkBLoWIgBRAeNeh69FF43E8Kv1k2BWEDP3OXH2xt+nMIPYC9lcwA71t9dcfNBEMR6jssPObZD2dvmGmZsJ+vwyHEKKfjASCIqHXO9EiDhNvmCugYk2l+DjWdtLB51N20atc9h/36Fx4YPraNKorOtSI4LZu86lZ5X39sDdUw/PGDZ80jFgcgx+BLkdjXPz0s7TUKq9huBuSGTzatfK31RW9eA4CnFa50XhD0/YK7FLEeu07Gc32V+YtPQEXzJKIkh7FuTUqsy1LRflxcqb8ewxkhFJYtFNYWKKqCeRTvMGPkfDb8O817cyUKVbXms+QSu/9P5W4uG/HYk9OThksRFJlbJIZz52Dw9dFBZMJDBGoZCiPhoRg15FB3UUx0BU33Z+jfD6oddaunqkm2/EKFjg7jnYG8ksXq01oWr4bxHlHVTDEEJek0WgYHmh8zzhGS/KQlVJdEwIpbzVv2chEbhnpdfTpdQwTktNlVw64rdn7G/vs4qu4WwZvJ71TtAW9mro2JLFKuf9PoZtOKoEa7S2V+WebtQ7wr49t3AIJcUTMscKK3ofjc18PbPJ1RqeRlflgSZgW/LZKhn8vGk3zdlQSvz6HeFt9deMURUamuu3c9/Gwpx2ngk8gvYzjsGiHXJmc+A3vvGNM2TU9xKU1/BQ81fmzQCUP3cug2OmwmVowaEis/aq7BMNREwzj+4uNjfrvnmwSt1ag6fIvagQ7TfkWt3QxCyotw7E48t12WtF73Snu/WbeQ4sNBHBJz/5ydPnP//5K2MwuqU51yaNGYNZr8kb2EFuLaoDNs/u6LH8S4dZwzpit/I+hSZB59Nkco8IroBVMCkZCwxPRyD4qo/wVJLOBBkjk96YpiQwQ8ObYhxGqK4bN4/fImmUfndWVrjLwASp+y+q4Gsc65GbW6GRlv9WgRG6LdxNgs/1klNH7yIo89czZaCqXDE2eh95How6YQTf+PRsKzxE2bR8tgnCRl3b4cAbmnvGUFeJOM6ihnl7gXasyyP1sDE0BfvhZ0pyxuScKl5fj/Sw3jzlzSOqkUaZ8CprlBtdKL2uUjk6gXgbxh11lg5VQtYHvUBCYLP5ySiJqrUehuc5ZLdOCcdr7sXXnL8ejS3KnX/Pc91TdKFrz3HAJ+CaaUrH6YIqXLR851Lxl1YdS6GnyROMMZgk8W//9m+f9xIMXXoW1Rhqz3Q/w8KZZMDJtHmAQemB6o4tQ6A6a9WqSX3eSqTQNynVe6z1qtd5lARrtVKV0zYSFr/KvhBQy0b7zIaE2+N0r+f4e2EhSrShW8PN7hAtg7j3yEOp51+vqt+1L0xL6TSs7afCUCaA6c6/m+vx7xpo/RSWsr5lwjKgMWlHnn2ZuNf6e+c1bUcd3TDmGdrmtfbb8aBzCxxq8Kw9IwYiauVZcXXRTt8C1/xWy6CtQXkHvzfKsgdnFOx4lqNoPHcfZeH3wpQUGb7r7uoa/NKmtN8bQvHSfJwbxVjanwNiZcy3Ym6frbqa7xp1mUON2mDp25DW+2+hSOW8eqlIRKNXjt/O1xTReLyi8/7kQA49Zq1EBJMrGMho5mT+Peur62P81k0ENs/fEGvnZS6tsjPHIhEbjfB3RufGjUITRxX0nhVfYrfGfj68p2nb2yaIwrqG0oWfKISet1KFVG+2OCQjoFU49imgXg3YjUGY4gh33Aq9hmR7GOCu5kgavs7vngseMdYmko4YvhAK2jTsL/xiXuaxqye2UajhNe9+Z52Mq8LU8dfA9BlHXlAjIHMv/OXvmjWy3t3EtqGo7TV1Do2WjEF0QEGDAGq4GP0mYs2nPN2oBwY9SmZwaAebzfpMFUqhSHXq42H2laCNAnY9+jYI6FnnozyNNjP2Ud7wcFFCZbCRVp9BThqdNmqeviSKGYLhec7Yzn1phZsK5xY/r3Hbjof8S2EqThoddjdnDplfI6ehyRjuMQh/5+/8nXNkIIIRKUIYrEsLHXzXaieVc3tenmnujUoLe1U2jxy2I0fuRiOFXfnRbHotOu+0Cmo8IkmZnq3D6m1FVWhnmhCeQcD0FUYLX6zSdfWGK1B7c0crWeptYx5jsDDDzM4R2pUmXt6xw7rt5RpjI6fSpd49Rq6CLgNI9PVohUYolFa9ivl3sf9GQ1UWjW5AFPih+Zfeay2Nt55XlTzBdH2NUfNM2nVGoQJS4+051rbORTddzYdTYO4tBbYe26vb0QX6z3fD++UbNJAPohh4kGMQvvSlL12VdoMYCsU0sjPPev2FcBuZ7pr77r0BCc3PUX4ctQ03NXHf15X2OXsjWUt5N92tr3ylyB2M5vnGNvTU6oXPuPC2CKeOp0jv6OQDkdZLl9U65uQdMJ/5zGfOu42HLhMdqEacd5WPPoMiGG+h7WngvcpUoSXjbFRTo1jn7zr9USezeTd67VZyCh7Y3csWoWcXYZ4ysoE3cSJnwIOtwBKeJnglL5182ailfRSzLXzj2oZw7qm3aGw1HoVoCkXUY9x5gnrGnksZ1Gj2vlZmVLAaEl8Hy2C+Hstdb75HdFdp93TN5i4I+bQZBwPdpBemK4RRA7Zhwm3067k1Kuu8ygeNPnfksh2S6ZOCYVy00tB61zAUnthra03r9PT0XGNpxFwjjCcZYbSwFl46IyqpckXrepVHBhC9N41a8eVwR0d9O5m1JaVHBrZQahUd+e3zytf995HRp6A3dKzfGt4+w/X4VbnuzGlX++wEf3OPjx49ujIQ04Y2kzcYQzBnEDnJYO6RJ3PETg2teda58p2xMa4qHMtXaIx/yUV1T3OhlaE6cdU/dahu9OyjTrphmfxB4RFKAm5Yr7AeVq0qi07RVKEgVL3TekOEpcbA/d0oM39vUq4eZmGaCncrErQNqfhbFS6FgdnNV6tBqyKpABYT3MpvP7MGsPCSsda7r9Ei4CKSYq0b5qkxQ/s+sxiyZ5vfxvRraHfko6F96XoULhcqaBSyS4Pxib6tf2l19KkTUqjB2oIR9hxKA7BEN1vVSaLAnAt1FBWgPz6u0asyKM1LH2souT1et2S6t/75tABj5wEZmMqy55Qf9/rUI+735IUhalSNPnXayE0VIqNP8c4HzSnuQtx+1pm9HwjRPoNJIk9lETrYR9A9BZXHI6eOfnSGGnnaBS2lDx7dOq1RWfVMI+Wtq1rIcWNGATFb2TIEaqJorhGCToODjtfTs9IraPIMFmR7n7X0svWzGM6VGVzPQtaAIDAlJY+xcdDCVPWszwQKoesdNcHXKhSEJ0BqyXkthMOcqozLDISSQXFwWLHkMnIFv7kICt6YHNMNatsblPRhbXi4O8LbiT1/d691q/Mw13t/wTR0m768PwCtSkeheaO2YsuafmtA+vzeW0Wkxry74BlhxoXHD+ap0eUUTR+eyftHz4GBrHXpVtig0M6O2Crs4EH8UD5ndEu/VraIaPDlGITJaTiV07PAWk3491Rim8S2Q7IPf2sFkzHNnEeGG6XC4vF/nQ080kis+qJKsQcHTl8Dw9XQ0mEqzJqDnPbiiy+eoaHhxdErYxDsCaH3Gg0Pb05JcB3mGu4iCzP+iTo4zjM2fcxGxyIc1pqcFnojk3hweKBVX+ZEfjnoO0K6sX0K20OrN2hHZbG9KuntJRx52hW4EslCY4b5GyOBSTGdPpvM3TjcPlPIM7qj2rMsDoWyDY+67Sp2i2DRpvEQekaJ8NtCOt6AYkGPwkrTKA/zrWA0nCzmbp5VXNMwnr0O2+vp/VqjkhqA/t61q/Kocup3fp/v7B2ZNr8Xe934PprUg2XI5vddn971I2zdAW1OjFyT6PVG/Zs33Z2nLUetstzFA41sC5FwBDZM6LruF8EH8/sYVDzQss35yB3Ib9iM1/07+/Wk3QjXstjmJXYBgb83N6eaCQ+Ok1hl3AjG2jXa2wa+NPM3hkdE7F0lTfIXuqqR5ci+8sor5+hg5HR+rxODHtPv7Ad5/fXXz4rdwXRkUEIetK7vicKmr7l/TiydHc2KWtCLw9kqJ5VNID3yfuR4bd7rdUOLWzEKDf8b4mCafT6JazAoj7sh5cbCNp7caxuyIqLEUDe1YK4Sp0p1V1FUibmnXtYOn6sUKI0qlJaeHYWR8FU0KjzVyizz9pw9ttKmjF5Po0qlirM0pUinD8Z8Q3fme/RpPxvK6Nj83KXN+IfSr8HrGhUe8x2aWqPNN1VaVehzvWMibBbz4WlZq459w3uN9IytglnDNB90Nvat3PqsvVbo1LwXWkgWb6Pgw/CPctqljfiLxznf1ch5bp2ejrX0Jr+FHjvH6dfxDeZiro0y8Fvvp3zLb4Uy9dN8TeWuuSb3eNMdp+3DH/7wFa04b6rOvLFwjMIo9lHqop7SvJVW3f0NbproYqIDNN4yTV85RE8fXdOiHi2Vr+5gWKsD/lI9/z9Tkgry6QAMtLW5vFulXJ1E34VbL7fJPgxU2GIao8CjwGA9sbLePYaoMGzl47nTfNdXghbfswC8K3XXlJIIwFu0Wo42zRHTO6KwcJTyVuAWudUS21tA8wo3JtvP1C+mL/RQ772YcWEIvxNMa7W94H3/NPdUacDQVYdUyKsY0NfaFBMmIAS1UFwTwj0qgjKyq7Qbz4zbWJobcl+j5U0z32mEuf363X2loXvKg4Xv5PJ4+c7fr2L2fQ9M86wqpXmGKLVKp2O3nnU6wLM86W1M5x5JWRHe0Bhtysst1exrVMnlRidARiKnGYtn9R3p+mMwGQCQDHjoxUv64PHpZ6KBUeJf+cpXzoaghxxWJloWbt/J5CJEp9PP1772tXNk4QU5WnXczEWeZ8bo410kdNNZgV+Oc8uaNVf+S+/cSqRQCGQWBx5GyWOGwjm8YBMQJlKwNQi7qoBHrW+CRBhhciKGln1SgsbeSgsHT7Hcdtq6z1w3fm1BwAv1MCmblh2aw7R92Nn2fDeOX0XfKKmh+hbWMtr8vZUchUPq/RI492yho3ga0dVbm98dXeBv3SuCSTeksSu/0L8wAkVfb5WR78mojEWhH4nGCb/LF50HpTXfDW8w5voqfLRhH4bpOgW/19S9O0orTesxdz9DIZ7KSg9zrPxQMI0amqBt9DmNMmmkXLhot735k8etYm/u20e+NB/WSG/DjV2j0sm45jsK3Tg4E/aP1HHsznSKn9KWT0KHJ5fOyegER4fMT6+W9VIo66Ivp556DSbeHd2opNhPPFOZtcZz3+QdvGvBDvdWtZmPfR0MMmMEsuIIoOmtvKO50JHfMV63hyPYDvFqUZuwaX/1DKfxFBr2+7u+azCE5lrHQ2FsoWw0QuB8794ajMJQc98wI0Nl0SiChs1oQtkUJqiFLySyoYUqntKsc26eZCdiXWcttpL3vHpozSWVLhXUI0hpP7fRVmGIGg6Ye0t3C8s1Mt3edCMRxkyCvxh816GG19qPoijssGm8x9x5Fk6pZ1/DfB1tjmDBwhIgDV5tk7eN4LTySPm9sGWjBU7PdlbMhaLFU+Xdrkfn0XVuTs7fyeURrTZstvkQf8/Pbi60Zi1drnHYRRKQDbrgO9/5ztmrn5+D+++XZhWmlisYRS7iQKsenU55G1vXX3TPqR0DM8aAkSnPVubqwHFIOb6FEYvG3NqBeEI/SauZwDSJ5lYIFTfERM3i95A0i7xxVMyyQ/J6eqx3PZjdj002mNpCdcchj0e/hQ7md/mLeiPDMOMR8EaU9fEYKgxNeBaGKXZvzlXS12HOzV9UkRA8m+koixqCKjHKdxuhrfB7zXYCyugEcldKqGmvQai31Dk0stwJWTxRZdIxwGNBBo2uyhvFzefvzvJRsXGkQBlsvFL5aAVIadPotTxaR8jRKsZSOBTu7Y1uVYzgnF32XGXb9aIcyJ+qnCrHzfvTGMqWcTeCogMoUOOqF97qrk0fOHz7MocqdzIlmqNs8QHlWOeuThb5hXSIdkSJ37iMDuwcr96SRJ7fJ9LwwhxFAdO3SKPnGlH8O1I2f7kD+tR+EdAQerVggZHCG2BsmxDxYdfjp9Lzp79Cmw0cDpWawU04NZZ0GhxsLOYMbiYw3zekwxRDtIat9Yzq8W0lUcyuHmQPKJNwFlp345Bt98rUqqjr8WEEz23yyviU5FUxuoZlnlbMGdyhz24wa1VBw/Z69E2cdVPMVppwVfOth084jiAUrdAX4ZtWL01//t7d7tuDJ6yeSeHCkimgKsEq8gpP4TN/a9Ta59RT2jkBa0roVH2V9vXuS786J8W5W7xwRKft3dZrB/WNQFNAoxg4DXI+KrOK1bfGncPTaK5yNv8e/scno7TAp3vHbZ2PRubdudsIC0RWOdGKAGxHY79ytmW5+BWP0B+l79YXkvrllR7Z7cMZBHNxEH+yTrftmoJkRhdOvkAEOjQdOs5HjtP95ektH2jHgekJsvvMpM2jYwi8B3wMU3M41W349Vb2KdSbmsErc1JxpOSpWCMLWU+0REG0KrgNP2DuHWL237W+FHNhkHrAhbM2XLW92BoH31M4lAzrXwVbQ1P4iYGygPUUG1YXd/U8DFhPvvTBPISGYayiLAxSPHsbjnrPG27bbSs4fzN3ysKaWW/RX2nXNWmfjMTelXkUVW0Yq/1IMnaHseRn+ac8suEX4zO/Gsedsyj/lM9cL/lrPK5tLkeUW+epdKtHfFQWvSPbOg89xnkbvMojWjEKPZIGn5hPI5HuL2nRxlZQXTs0KJ332CqTrm0eyvPLu5SyuTJufRfK25eRtb42z1sXMBHHy5HlNdLVD5T/zm3RZT0VutEeBxAt5x78OzkHUUF1SNd4mv4KJd+YURgCKLNClBnQhFrgIm/3sfC8dQmP7dViuB1OTjtSRlVqZQYMzOOhnDGBhHW99o0tboNQD3ULfH/fCr1GYSsIuGHLPnl8hbYawYh+Wv21PZhGEoXBKI0qJeNt2L2VGAVCwAufVJC1QhUUzvbid25h49F7vdGg3l0x8w3/9N4KXZ8L4lOxgg6MbeE+9zBixtRWj7XOyjbAFMy0Jo1HsJVDOmWz80PzvpvXRlA05pQ0Wi40O0qrJaCVw1ZwbUW4jzshZ4zCjiL2q2R7ThRliSc2pLRpWTSg/FBa9/l1thiqDatu57EvtKnxurtowVFAa4pbZDHQsY1oeMgat5Jp+G28+h4H1PmUL/DbhvT6Mp+JEtBh74iuTHtWr7kxozBQkVMNlfPNACfMVenhbVMYsUzV/QP17Bpqbo+x1T9CyXoZrm+YtT3gGTPlVoyTUqT8GiLWmygj63eeU/gH0yrLa5lnIwOM6Dz8DTk1QWZeqqTGG6nilUilVMAvTXrzQvTn+cZgnISh3k3XZENNW2lM61r1pT9yUJifsjyKJvBCcxKOb95RAnppO59EGAmFirJRxJwCmyyHn2f3agW4UdqOZLXOvwZvR6kb7ig93FM+dw0PGyzhdZs15vjNO3y707sK1brXy5/ne3FQ57idJQ2GXZoo6/Qxp1ZGlQaN3q6DcOc7esRz6xDB9TmpzQM2D3C0AfDI2eQg3k8JuaIH0K7xDb1n41qrqabhs8pio2B8xSksVLbRExWedAsHqOPnMJGLlrZzMPsOEyXxN2oUWE04s4x5w+wROIwHq0TkLkqTjBtmqTfbYwCa9NoKCxO39M+ilFgEoUqQZ2GMDZFb57yx6woRWjCSFnt7ZhsaqdHsPIyfIIAQ+qIhc+lxFw3DSy9zwKzdVc3jMZ5inxsaYVDn2uYARIKNsKxvj5puxNeoq1GQcdYrYyR2VLbx3kYFO1IDbyjbo2j01WQwJVGeJAPl0VbiFArs+lqPI3iskBKnprAPo0C466y4v/s26p32he32BuwXAG26oUHLVykc9zEqHbu/2adAPnvibmGYGtiuU6Pt+V7iuc6VCptG+xQm2bC21qi5PTJBUfdvT6IvGh1sx0BOrKdEG+codDw2/270zsGRX8QHhY7kGPF9q8PqFOLNwrwcU3RvCXd18I0ZBUSXkKpSImyTbFahM98LIXnrZZiNI/p9wxxb+LeH2JC9ZWtd6DKlPisAvUbYqf5XwyCiA31P83fRg/C95Wx7DDUIOwqhhOUEGrZXsBjOJmYbKW26UnroVsbeFSONCrZRmFZo0GFwjEJpqZKDU4GW1oiwF+snFD3iW/8EtrBDHRM/C4V5pnk3Mmy0imdqvNy7owTr2PkUr98OTeGlesqNFLzas0JdhVx8Wf/d76E00cYnY5IEHaU99JSjwLtoVmNcrLqnHPM8uybdv4NudZzw+1ZMldkqNjxbx6P8qkrM/Opkdm9Oo3FjqbEv1FN+eRD64kH8bO2c0UV/mLMdyPhZFeZc070S5bEaCz+rEwpHo1sj80YdnIgWTFRX3ahR2Lt+q9QlOCeElYixNdsGMwwD0ii+ZyEwWZU/pkXAWvhCDTtELw4quik2iVlKeB7VxpUphRkrJiZA3kpVw1CFY6EGd4QNg6zcT4DnGWjFy6ZMQHQaRixe7e88hPkONAVKqTCfmWCdQyTsttY8fN6KhJlqtAoUOKEhLOM2NGr1RNfB2jAwhKOwACYXLs/PniRaAyNymXuEzfXaWi68ecK1Ciq8C7mtBqaevXn1ta3Nl81PUVOrurpuVYrFxnfS2DXmrEScp0kud4LZ+lZBen7fqYFH5+8gzJY4V4nWG6/yN8YN7aFh5Xd+RxOyT4dQsI3Q6KDuPp97mu9AA/TbUSPokAGcVhrsCHKa8ctN+cl4yVfREzVYDI3f62T24DvPKdRVqGkavbmh8zpBTbzfilHAJPWuVW5oNnJRdgbTUrcqdGFeB70x5w09FXZpKFfvtopxmjHVctbAHHkUu+qEcq0HOJ9R6M2ZFKoSDs7vI7At0eVZ9G1Uc914GjyVQi4731CG2NEBWnRTi5BVtFcYQKljoyFKSSKOl1rDx6gbR9elTI0ftrImePWC4MIamkoKtn8e73wcWTGtCdfmo+Z3hhafWYceg8AzJHg9HbW7dKsA8fmMfQx7oUON4kWrKstdJVSebx97134jW5AteNdaixJadqpvc+Q4VWnW4y6/+XvH0dwB+UUDz2qk5e8MRaMV8oMmhV439Fa9UYiqhmH6HPkrFORa9Nv5pPvraGqRQaNSERWEhDHoOBstVUbImPxec3FkAd3NrwiF+XU/R6MrdK0uuRX4yOAKI9TrI4TFLC1uW0P1/e8N/ZSRikW6rx5/FXuhj2480Udhhx3mtu9p+vJcQjgLS6gscj0iz3aSKgxf2SjGau08b0f43fLUwiMbp90NM/fMmyqb0rA7ZCmdaTx94+Y5uR5tqsha5VEFUqPUSNM13VOCX8zbdTx9nya7GwG1lK9KGwSzeVk4Xzp4hvkcHeVd+GeaI6CdAlqIoJ5olR7nowrwSIHWgPWMMPzH0FsrUaL69kYbVdre/+zjOY2KKyMcqzp2hcXwf52jvUZdQ/dU0TUiYNjaD5ru59dI9DveOEPXvj2XvNxde6H83jxBHdrummfQin40J1B5bZ6ie6OKjDQnsOHbOoGVi9IB7Tb0fKOv4zQoHgJCYEaEBH0cedA2E3Wx9yLWSOxQFDPwWOtRuL7KtInT7isoU1JU9e6qTLpY5k0gpyqLh++ERc+fTw9gwxwiBQoJDmhHePH9Vltt73QaZimDmAsa2qyzPe5CcSIWO7J5vujGA2ryF+MzLDzuJj9FKuhupyfYBz7rwMJpjgagWD2/MGHx4x0J7ZxNo8I6DA23G87bEVqsFu+27zo7FCG+toMebfTNu68zVRlwXSOnHiBXYzh/H1hStKYPvClyYQgYZzLDiO3oltdsvOizo/Z6sSKKRtuFcV03f+vO9rZ61NdBJyJg5/vIL1QZe25f+tXcoblpne+0Rk50HAjLWjWf1qqr4V07mjlSfcaGv9GwtGxRRSHf+XfHirZ9XSuZqpzf2oF4klQz6CaeimlVSCirvfW+i9swFeNUWBEDMwnv4MpzHayz+xMKH2Fsim7aVAgNJj4/RxnNtTO/OcXw61//+tVJhpi31rrzE75NrbLTPdUi++iDghU92Mo+zGYnJQwdzNSdo5ROvZp6A6UbpYI+7aM0rWLCmNMvJsfA1p1H2iQWHLTj4pXU6Br/Nrxwdh5dIy6/+7sXFYkappWmlCbopMqpEEBhUI1h7DsHismazzbK9WqVhc4zHBQ5a8iQcqxaNopu5kqgm1wu5OP8/hqgo+R7DQ/61+unrLp29ZL33BsdFBrpNZ1T+UuOoveXH/XVoozKHXiTTHUdrb0Iw1i7Wawwkr+X3sX937ksU9avNduQ40T++LJj5ww0Eqhj0D7MEUwsaWxsdCq9R+dxOvDblKs3gjXnIiO3YhQqDDu5caR0NiEJYMO7HRL6GyFu1NBwjTfeox9KAGMzpm5qAwnw3qeMdloTgxihRwB0fhWiCjJoSNjYioAqo3kGYfRvHpDTG1UvNTlViEZU5rnbM9tGlpdxFG7335QQoW7VCzpv6O/dQnd9Wo+dJHUdb5Vh0x/D6V0AWzAYp8I8O7/ke9ElxVAvbK5roloUUqhuwwA1el7q4sUpDHodmTpAlKRnekEOj3f6wgPyAZROD+zDY7t6rK1zrKJqRKLVGSgUuuW7uY6da2wUsNfUeMpzrpt/8/zNwVhanWNvhftL1671rlzTh5cJFUZrhHI3Zc6FxraDpt99v3E3Atw61DW+Ly95fo2viBEPckKHT0SLO9povvZWTkntAiHATiALTRuGVvg3fIMIDeswjLLEKvKeAsjDBGmIFihwiqfGQ78bHqKwnX8+Z4k4KXGssUigzFxD1ZDfOGax+srLboKZPqa/nntEGY2RQhfH7aovN6dufnEaY2GNGqt6eA09a9AL8czfnRcPAqrS6bEMDHAjs645g8xIWksGqrACr1rIXT4Ymoz3PgazAvbVr371Co5spU3zRYW2COCM3/HLVU5oItJphGQNhh/qFHVfztCNsE5znlFf5sPpoHxmHMPTw3Ote7fuchQTIQxPvvbaa1eRoTEzFk2UTxNtN4Kv992IsrmryvK0DedQhhRj6+vRpm9t29BSIb0qWmttx24b+okUaqjJWDeGVeHjC5HGPGNHCvjw5UROvZ9co/est7m5t9BQaTWtCeFtcGqsG7n0dy/nAb82j6TAp8UH069chd9v5UA8yreef0NWkyR8hR/KCBYJI7JqVWD6xJQY22KO1/jxj3/8TJRR2vOZF6XwooaxMNv04yUkDrMaYQRDITzFNPeoKiIc8LlCFPNRE278DFitNAXbkLv7C9Bw7huGBWsJmef7EZh67DUATe7W+ytMsbHqeoHmzThZK15+N7j5fTziaZRoPeh9hpD1V95J+MyFwFUQ0HoMv+qRaQPvzfef+tSnznQaBTzCImGt/x25TB9D01Z67dyLMXNcer4XZXAWnBypwCgoR5zf5zmiTG/rKr0bPYuCZg5256oEwxNq82cMYzzMqxvKWqIoomNYW2TRvTMcJXMv3b2oqMZyz71VapQO+qv2qVOn9cynognzu9M+veK2VXhd2/IKvYIfCz9yXoamFLEImHxW5zyIjBU9qBNl7TYESkG7bkdcfqJrHeg6mpyoGgIR6BF0aW3IZyMX+qEFFjdmFEywitZDa+VMlLXaoWeNh+sQq8kTjGqCnuEIjUIDCAtrbMjV5yP0PKPhlzn0va4SwlUEBMZz3Uchdfzm4PcRhFYCNMdQYaw33ZfB88ILP6BRE6hNGpb+9TrKVH7qDwZeo+C7QkGtCKkXiI7+NjTB9FXCjbgo6Q2TVXjmJ+zU2OqRGfOGzeS1VDfV+ajhqNKm6ObTF763+sRzm5BlwOtIFGapMqsC8xPPgTop7u5q7jNbKcUANx9QZVQlUvqUVxiOyqr7qsAa9ZJb69wx1BtGO4awzoe+RdR1sOiYKkPXbyjL+tFTTezWISrPlt/urp3Vjb63HuKYFVYkF4VL6Ql0QQOGGu/rQ4Q4/Yx+muiwJwJUZxhfdcNed3RvtHjj8FE3ZzU0LFZcwtaQTKtngBhl6pZosoxbmAjrKIjxKIRlwkqLbkyFu9Rzw5X7cu6t9OrBbkY0D17S/L3ha+mlAqlvo+KpFKMHG7D4sP2NcVpk9G8fPP5imoV5/G0LwWb4es+e03C6wuk7/eySTbh8y+IokSPcvkbBGJx1P32o1+4zJOmFyvpq5Q9amHv5qlAAwzbzGA+NwvfyEjxpDSgu41Hiynh3PlUupdc+yrlRGj52LyjVOtRZqGGsY1AlUhktD9UoVGHX6ywdqngYXc/tzuL5CULrZrQmY6vA5m/yMt1HgZeaP0THGog6P4UOy9+FghjvO+tY9spWeb8J8Ubu6GwPTkt8Rcuivp5ZtqFC99tfUgerzlrzSGjTcvH5m/zJrRgFoSbIpRCPBa2C4e2oHNjVDIWgEHsgIESb8k644n5pT8OrsaQVCETrWTGY1KIxDl6IQXAagu9NId3MY3Eb1cy9g/vahEJxlantV5gIYCtpEBMFQhk0D8D41MNBC16JOYpwyuie18SmqKlnFIFDKqQ7zO7a793uFLMEO+O5DWu9uG3MCfb09yd/8idXNPrVX/3VM4Qy7b//9/9+HrdIxPoUvqqRo3x8vMd3vu/5M4RIH/M8tK2CNqZ6eI2qQGaNjnrUR48HEQngFY4ERwddZsygxK5Xj56xdhTY3EM5VVkXxsITZKmRQ73URilyJjsy0dCqkRFlSnlVuTXi9TEH86veINeqibbXPQq2BQa73ypyv99bR9z3+RR9T4DtHg86hSPpZNSh0UCdAw17/8H8e9bcaz+ntH102c4PNooh03VE6BpGBk9ZP6ct3Mo+BQLB20EQf6tC3kmTQkQNl6u0qshNXiXCEYxESTE+G79D0MJMfU7x9t5TxVUhq1eLcTCb+4pjFmaYBpdmWHdCDJbdqATNKe2dcykdKuCFRqqA9zjNZcZTJbyfUa8Jw/rZ5zXkZnB4KgoUGu6aexOnFVyKwjo4kXeug9lLNFtvSge/FMJp+N3oZEdKHSceQ/8WSqCPKLcGsCWy3SnMqTqKTPEwBQouqjNkPw6j0lN6q5jn06iDculGzuL80xphFPMfZdb5SurO8yd3YJ6tkup+GU5i4RK8zJCioe/pmRYf4GN05gA4iI8i10Rr+q5eMB+yvdfjwaUc1Mnt2xo5AT12BN+Bh7xneQyBBLrxecPb5AzeeOONswEDVTYKqm4tAjEO89BeHqo81ajBbutbMQoNk45KsEzC737WKOzrtnJrOE0oMABvYnvYvbeeIKZoyO36Hm9NqVT5F4Psd8XtqlALibmOoHQc3SXazYBo0UXn8fBCavz6PPf6FDMvbLGfVUNSz7jlt7vtSKH9bMy3yWU0LRRSB6IKWWt0QpFNgcD8PvTwBr0qW7Qqv+4TRtG3eyJ6/Y5mwUIz9vmdo7Idhx6GCMJrAcA7d945vXX/rdPpyen0+Mnj05PHF2N568lbpwePH5wenh6e7t25d7p/9/7p5Xsvn15555XT44dPK8Ba4kxh7zr8jh1fdxw790ZBbadrrrNuooHyMTiIUqJMG+2C37q2aNU13rtxG4Hv/Js5UvYMsDEfvUSpkUrlqlFH6fBOEvd1JjgGqtAUILQqkf6woe2jH/3o+Z3LQyfFA4oXxihMjmw+LZCpQ8d5soZkap4xfU/E4T3OzUVwXhQtDE1vpfrIJrGNV7Z0rdaIEoKTW1gMZNL1wOuFNVSf1qx6LWHLYJvX4HXvKoLtbWGGaUozK/T1suqlFFNuSadn9mwf84GjC5u3x035VfmiSXFotC3WuyMv60GIhfmEsZ6IdWR8KU99NeKbv6mYEbZvjJwiBT0oHW7VlOeVvnjA7/OsoaOQe37OnMYg/MEf/MHVRrNXX331/D6EEbSvfOUr5/sYCB51IREftJ5xq7Yxxgpg+cC8uwFqR1bTx3iBI/wDic53X37fl0//7oP/7vT40VNs+mpn75Nnq67u3rl7+q3/+Funl358AQFVqfHy5cMK3WkiqaHXeJQzf/0PPSmM+V70RwGLfue7vu/Y/Clxz+m+nHmmYgCv3S0c1fxbeboK30ZGzyRPqvV2EURh0rnWIXqFwmZOIhpyURloxPGdy7eo0RHoMjxHpilghmz4b5T/fCYymDEMzceJIevf+ta3Tl/60peuNsZ6WRKHpUbdenM2QOrzuuORg/k5z2KsvvnNb17RYXhiohIlwvKPt2IULDChxxR7Ufp7oZtavCqwVoe033rl+sC87XMzlfu7xX9DE55NyKpU9W8xNla6E1LgAcqXUmu+oXSykDUsjQoYXh8eYr0tDLOTwf2dALp2nrkhMK2Ju9K93hZFRpApD+vammleIq92e3Xm3YoUa1KFQ4k7fmPuHcU/IXeVRg3NCD8P1LzwXCOxKqzH9x6fvvALXzg9OD37zmX33L93/3Tv/qX3defl0/1H90/33rx3evJm4K5Hj68igLPyfevN04N3HpzeefLO6cl7npx+dP9Hp7ffuVAkaPn2g6dOg3am9+nx6Y8++0enu4/unvuzLu+7+77Tb//ot0+vvPfC+5vxUFqFSPGY/mqweNMMO6eKwUCf+ZuTj2s0HLmB9mP0Cp/MPTB3DhDjyyGr/DoEDs82AjcWcsmr76ZDJy5Xn8ip+DvvHA1EBMZD7n7yk59cvSis+Z1GkU5FFi2NAv7kJz95lStktOZjn9F8JmcwEQEHmcLfcGKj3/l+IFNl71X25E2lX6OobrrlqN7KS3YwyvYii68e3TOtYWzxdh5PPf4jGKgwSK37/u463LDj6NiP4JaGlTUKXTjj089OPhZyMmb9Fz5rK3TWUNS1MHlzOxpTPasm+zeW3yhOKL6hqMIONRAN3/ezNy+UJta2NNiGf0c7dRrqrc7fvdBJTueIF8svj+49Ov34PRdHfpz7vXf/6vP4hcenr73va2cFfr728bOvF33x/oun+y9c5pXu3DvdeXzndHr0tPpprn/08C9WFJ15+fTkdO+Fe6d7d++d7j9+SncRQvH05n2++3PfPd05PXU+zut/58Hp0RvfPb3z0lunx/fun348xu+dt8/Pv1L4b907ve+H90/3ewzIKJ5ZVxVQH/nI6a0kkitLIiVvUrSzuka/hpvR8Pydr8MH5Rf/3hFBlboozNhAQv3OZ+cZ+5yjPBGHiZETAbyVo/O3I6aKsEdfjKKeyGD2S3UPBKh4+mIYGBv8W4SjfCuPZg+USM8myOZijhzfzpFzOz9vLdFcGKUeJ0I0WdSDtXj07pUg63bzaS33wkzN8DfEbkIRQVszXoYrPEFJlnEtjtBcJUbLVcFfxtWSysIgPdJCg+VWYe3kkRAPdu3+MmErTVy3E8vFh7dHXIEBPWHSQlKN/tC3SVA06NHehbtsPNpn3jS5uyOw0sV40bXJx09/+tNX4+8L1+dvI4Czua1nY4EKvvvKd0//7nP/7rDS6+6Tu6d73793VsJnb+3R5amvT559Cco5YsgcHjx8GllcaNyLzxiCOil37l5663dOZ+Pgb/feuXc2JldK8e5lEcCL4a07l/maO6fT44dvn373rf/X6e7bF/ef18v9Ty7W4W/8t/effus/fOSC34eWQ+fhpeGRkZcHD05/9Ju/efrxz//8lVOGR0RYM76/9/f+3hnuGDhuK53ybvmvEIW1o1QpVLqgXn8dnO0ocM7qUbfUs/uSjNMO86soLqcl+L476MnT25d8JI9CP5FFkNp8YPfexUBvOQxvDI0j1NHASa2MAlkkb3Jjox+nXzkDjlgrnoy3uVGGmU6ubN3K5rWxhtP2yX+ErFh/hXpXFJg82MH7SCUKTRCDsrZePlMFtj1R4Vc9adfvcR1ZaYYEti+rz4upIbFI8zfJLQtuEdFovpswUNLHIlngHsNR/B52abxNtlcZF67zt+Y/NvTlO4aK0W3OpvSpEu26Ymp/L1RAaQtlW31lk9Led2HuoiJ0HLgI33WOaKYiiVNhvD++++PTF37xC2c45uHdh6cf/+THpw9961un+wO3PB5F+uTKez7P9cqLHwV4wfd3CgXOsd6jjJ+c/z/dOz2rIEuzi3vx/MWzrsY/9z95fHrl7JE+OivredBFP6LMMR53T3fP47oczLnf6efJaWzA9PFoYKsrCOrJ6b+/+r3TN/+32W0+zz6d3vvOC6f/x//n4xcRztkw3Tl99g//8PRo9ltcyvb3P/rR0zd/6Zeu1k2eSHRQnqpcUdzk2REyhUhbkUXGODmS3Y0CtvOiFT5utFJHtZAvWdLPloF5Vvuo8Xj5ssxz+tqRXKNYhrA50qIF5lmd1Yi9fbbAxXymOchuV18yENP6Frg6o0UNbgU+GoU2D+xhXFUaDQmP4Ih+imlXIYswhD6Sfz1ttKGR53bB+8zi7ht6qidX40XB961fuz6YIPAqGh1pO3wlIBilMIOjHDBOk6SFw8osFZhCelXaW8CK/TbKoYSP6IgRS3P9N3mPmWGi5tXz+gnu0LihcIXWXAsRNlGtKsa9z2DWP/vg9MNP/vDsXU8fPzr96PRnL//Z6cW33zrde/Dw9OI7j0/3JwH6zoMrhXieZ34/89jFb0+/PyvTu6fH5/H4+4XSfTJ8MH8/j+fuRQRwZSCeKvWnxt6ptE9Od0YJnauQnsrAnTuPT3fHID689J7P43kKCzx4Bir8i+96fnj/4elHH3j7anwvv3P/bCjuj1GYcd29c/rYtx6d3vvDp47Lo4F9JiqeMtaf/dnTk8tKGecMkdfCEIUZy2vWskiB3323dYHv/zJItKXw5N41nt8zjaobClF2vIVXpzEshYPI3pbp/tSMgfNjrEfwGSXe3d0djyigzq9xMkT4X35uWh1HxuNW4COh1HULNK1lnCVYJ1VmmdY6cnXomEOFhzpklSx9QxXGwgjT3F9GM04LYgHqtQrbeC+NXLY3rW/wjoVhOEqXuU5984xTyRoGKAwyz5esLQMWo+Xdb2asUGCOroOEpLlXAPSh7yasK2DbUPEoW1VlToM3z4fy9lLzljJOvz1XatpTz/eCpxrqD4Y7+YTzZqTT0+vGEPzkUz85feuXvnVhUC73Fzz6w4enV7773dN7zwlSXvqF4r9wnGMSLv949u3/whkzQ4NLhT5oziUcdEWT01Mn456zvu48vjAYQ6uzURDpNJk+fVCsyksvgoJzJPD40TmJLXcxRmUbghqqu5dQlXk9uPPg9K/+L1873b0norl3+n/+vz95+uibL5+hpxdfeOH089///ukTf/RHZ6PxrV//9dP3f/EXzzLicEbyMGs6lS6NikTTO1Etkc0RomApOpFg4cJdzNDor4qu0Sw5mH6qKBvF1DnSeu5SIdKXkngnL55Zule2t1y0JLbvR2l1JGOgalGf3ffQeyp/GhqPXDHa++C+Sfy36ORGjcIobIlPCqznwlCQTRpTot7FUOiCYWgt+UyqL762pX4Uid3Hk8GfTD5YAjNZfFZ978ytQasnLKGjwqUYqbnNB3PCHXm8o+DkIhpV1APiJcEbp7zNphMvdMEc828GaOagmmMr5UYljXi6sQdz+/SF3jUs7imMJ0xv9UVD4BpJwmgM0zB14bgppXMwWaOIuVZkdvbwL7f39/Wu6DjVLmfBf+H+6V998F+dvvfi9y6+e+H+6SePLrDcUfkvvv766f63vnV6dZTYw0enR5eY+wXKchkNXGL1Vx7vePoXuvUMDrnkrHyvIoi/6MlKKZxpfvfO6f6lASncMl79xTr0XcY1PmeLdMWXF4bh4przejHul2O5uOPZQ//GuJyRqMt7tbdPb5/nNl/MeP6Pv/nHp4+//+XTb/7OB8+49fvmCPkPfehsSN//7W+fHn3hC6d3/sbfOOdvPvGJT1wpzJG7eeeIaJc3be33Tn3yU1iV44BHCoOAY429DmXLSAsBazxvBsS43EPWOYHNMTxjRB883WNCrq1hHUQ6p7AxI1k0oPsZCr3XKJEvuql6w1YAsmutySl5qWGrDJY2N24UEI+C7VuNukHMYjV5RXFvS1/lxWIPAXaiWvJyiDs/5zN5hsno9/iLDa/U2ja83FAXw9QwlNVmCHoMgTDaYpvn3OegOAvRTVJl0IZ0Vfa8c8q2CfzSqlFC59wkccNoTFcPs1HAETM198Ow1aj0+zKgMBb9C5sxtvINBI2RwwPn+T95cHrtI6+d7r7w1Nv78zt/fnr57ZdPd9+5e/rinS+e3nn5nYuSvRd/5vT29//89PYbb5wV56Pvffd0Z445SILtSolcwPxXMNGZV8aLP13S1GXn9bi45uL/QEdRyvTvhfHoIYQX0NDFY589pND1T3/nhWYIl+M45xAYpmcu+IvtSk8m6jknvy/vfzQJ+Rcfnr7xocenP/wbd0+/8cZLp/c9eOW8ht94443TKz/zM6dXhg9+//dPX7lz5/RnSf5TcJwf60buNyRcxwQPFhqtg6bPKje/FxvHqxuixoONbGq4C6NWKbfK8M7SSQxL5aR9+K55PzKH1+u5774rc5UZfZReGzI/SurTu0ULCrHduFGAe4NKpoEftiWzcIVYKNXuLp2PDRYUq00j4By157zd2RAyu/m852CqTeb3MQ4lfEO8JpFa/WB8lPt48PVA1DBT3lXqcO5WLDEK5myxMVcZtBFXvahp2xBtemLIjcUTrGKkrq03vyummr9oomp7ZNZmC+Y2Ct0UBvqzvmjZ149KphnPnZcvE3Mvn05f+aWvnMtJpxGSR+9McvbJ6c5bFxUdc9/PzHEP3/726a0//MMLPrpUkGfv/xkc+ywq8cInaXu5gewSXrqQpgUt+fNVUvrOX4gg+PrnvQV3pnRp+I7RHjrN5T3imXJ56sRcrVvGUcO0RnNlBEQC5zHPDQMjGe9dDgmF9uT0vQ88OH3hN79/+vj//p7Tz735/tOjhw9P/+NLXzp9/GMfO71niix+53dO/+3x49MfXHq/xbx5063M6g79DdOCYrqnonrF9Y0SCgeVNxiKXTACot1y2nUjF9MHR2XkVORwb8FMHBQ6yzhqzBoZGUMTvpwezlH1k3s6hxrA+fQNfGgJRTDPVpBVdmukjf/GX8c5HU8I2USzBW1SZ9rRaarCnoaHhVtARq6hlJuIme9m9+qcpz/3zA7EqU6ZzxgI43S8r2dQRsajjti+AIqrSrA4ZiMR28eV2dUTkHB1qidD6jWd84yZ10Q5lKtNL4wn3JUXY8GfhQqO3wJXuIgwYtwqce8zmPm31txa1GvCWH7nkeywl1ExVmsLDjKGbZwx+zkSfc9Lpz/4rT84PXrvZb32iy+cN3Gdn/Hk8VW56Che/b8zVUh/8Aen0599+/TgwVOlc+UtXbn+lxU+g+Hfe7qR7RwhjPK+LP/sR7vo6zKRek4qnJ6Box5f5g0G0388BvDJU0N+hpey/+VCSB0ONzmDRzFIPLzL/kUaE4FcGpHCHXdOYwyuRvmMzF6Vwp7LUy8VxDm6uZDPD33gg2PBznw6Dtasx9dfe+30Z3/+56e/87f/9unx2aBcyNwof3xdh6v/BhdpPcWgZa1kv46Re1uS2uta4VMF38rCRuUUunHa/DUO5vy+4VZj/P7la3h7/LvPngOIWB4SH1PCHNsq80Yc1S9k3ouaavyadyRjKhlViqFNT2uoYWhO8saMgioEC8Xy7HJT3zXUudrIc6BYVO9sy8a68sopKPd0n8CMDYGdUjitXvOzofpF1ZC+nob7T8fe8ZtnE2Olwcbwt7dhccFYxesJFuNhfEcwTL1xjFxFu/HJKno0rXKyDtbEXOoV1eAUl2RYm1sytobVPJ1CjI9ffnz61i9/66LW/snpXO9/ZVTu3zv95P7F8eGnd06nJ+88OSdExxj0qJO574M//tHplTffPL1vaH4+VOjxU2wo+PxTZXnpjZ9LROd5F0ld8z7T884yCgdR9/lPEw1cJYwv/gpuYuyv8gH7/RaXVUPnNQVNXJbHPvOMpynpZyKHrs0VRORaYz9H2xcO1o9//JML4/rMHp0HFydyPn75NLb14XqX8xiDF6ay5fJkX9WHlQnjwB/N1e0ovd71/ntlvVFoS6p7L16nlMnKrt6jRBni7sguvDINXb773e8+80rV6jJ8MnLqZU0tq62CrpwZW/VhjVxPAlB6b554hiPXqiVGtRDdzu8xkreyT4HF8zGILhBri5gEgsdarK2KzeIg0g51GlLO/VWiiGR8YyBALxRvFXktvWfCMo3RNRtbLw5YrLFGsRVR9XaEtpLr3Uavegc0h8mbY6hR8Ezf6ZNX0f0MHVf3dJT+2zBsDNX8d6LZJp3xrlrZ5Fm8mwsl9eT09otvn+48uXPeOfzfPvTfLph+VcuY1+N3Lo+MOFfcPDwbhrOxf/jgUvmfTq/86Eenn7177/Teocfl+5sLq5zndQmrXHLSlQI+PZqxTnRwuRHs/D8DEqX3DGxzBRBdedwXOQnflWmfQkI1TOfcQY3CZRL5/F20+7O9LUhpf8cwXIQk55LYMaIizVFyzQtNe/jg4elHD+aY5ikBn41xD8/3nze6JZmpfLjecHNTVW6V2/IQXtyO2ZbH8mzh3fKpcbWcs84aY0D2W4kEclEF2GfSUd/5zneu+LrO7Hw4ohNtOH1U5SJHtXNtJG/OIhiRiPH06PrKm35qXDiY3bDG6LZct7nOW6k+mu3Wu+Sy5aTz8WDhDuZiWZtAMVlJXtazpZ2u6SYQz9OHhJEzSaaaAhbX4215IHA/+Y35Xfnp0SJqe6OVhZfL2IvYjXl9F4MFH89LyRjIiKHoRp5WKRhTjUTDWv/e8yhDGl+x/uKarQAxD8/oMceqwby32Ni3Ub3y9F5+fPri/+2Lp8f3Lxn2nXvnCOH8+93AdlfJ1cv5TJTg2I4H75w++f3vn36GAZr44KWLiiFlpOey07NRuCw5lodJv5TyBYPmyJYrZSVX8ORALxdSCt7/VCc/7ffURDG6XP68TB7vZzT5vdtlOuAM+XTsNeqvvO/i7P7XX3v9rPjfvvvOM2f/dC7TwcV6DtR093R/lN5UwF2+C+ScwL88TG/WmOdZpwpEKzJsMQbeqmd7BIFaa3BxHa4jb1xOk5ddh6e6pIpRDovs8Ny9q6VVdk9SrTQNbVUujS787Gc/e/UOA976pkeNE2hI/rLjbJUfo0ePVu69r4HTV3SgRrfGW+RxK5vXRul6cYxJz7+vKkWSRKpyotgklLdRcD1m8H1LWJvUbDKofe1rwEKjkL1vGXGVQ3rLmYXvoXxN+DTaoLBbjimphoFd052RjYqU2k6bXINX7vUlOqIIC19PuknpbSS2MqmxqOfTvgp/bUPivllb0Nx8hsGbPNS6Rnfu3Tl99Te+enr04qPTk7tPTg/vjDd6oZQmWVzc40pJnDd/PYURz3R49PB098HD0yd++IPTex5ceLRuHcMyCusclZxD5AMQJsrzrHjvXvLe5fdPnYBWljw+RzXUtqStiMLvVwbwfCDes8niM12fDF2fQqYTDpxzF3cnCjpvS36mtNS8Lz5PjUzX5Uzfq+TxhRIYPhov9+233j794Ps/uIpOHzgG5hmjdhFZ3L2E68YY1Bt9/PLLpy//r//rRYRxmTMQBVQWqgALWYp+W07spU7NOZExslEHbsYz9+yDKd0rCq3OqfeMTo1i/J1T07zDXPtSTnyeJgKYz+gQ+2ucTjD3DdxEjzAknjcywhD0nKK9x6jrThcWXdEazU/r7v3qMQZRn53TjRoFiraKHGPAq2rVGh7WY9hKaWOL82noyDNX1eP5FJooovdMa5mqMFprxAJyMccmnUpM4yx049MEVMfdklp9GI8cDVrwWERPLUltsr4GYdpOhpX+O0Sv0DbUr2EobEVQ5QbUTDtbphBBS3zPc33p8entn3n79L2Pfu/08KXLfMPp3lnRokXH6bygMQhPqyienF6Ycr/JRTx8dPqZt995qpyzLlfnZV15zHlL3JYHm9OSgH6mUlV10uO7z0YFyyjo96zgB5Y6Q05/8UCycyr4zsUxFs90pqz16bYDU76Eni7/uV6UNFHHbI4biGgU/ux7wLtnvh947c1nnYVnd1hctBcf3D194Psvnl54ctHXBdR25/TOe95zevNnf/b0w/e+9/TDSw+2mH7hnxoFfFUotlFuj5cXUVcGp4GFOXpOF2hxiohEdF0PuQUPNUB1eCq/ZLE7kO+lyAI8NJ9JUo8x4OQZwxjikQv9kfUZl82bDELHuh2xzTcdL53V6qKjfM12mjXO+K28ZKeTroLj0TZDLmR5Jjm43icLs9Rfw8YSrYzIgtroNTtcbQQTNhWnm9aXTTSxTMF2K3jzDN0wM22Px3yMzbgZoeL+XSBwWjeszXjrWTR5xLgVUusuz9Km1xK41i43ZCXAPBwM1ZyEzXNgrs2I0yqEoLgffOQHp9d/8/WLqprzhqo759+vzuDJeS5XbQ4fvfM0grj7+PHpM9/5ztTXUN9XVUNXt1zCRC0/vfziStk/u1/g+nYWxPnv3sXx1ejtkDse9zOlq2kXtHnW4z/PexmyZzetMUrmdaHCz8djBIOnTN96860zxDPe/ZOzV30hD7PTWHsLfpw9DeZ2ftK9u6ePvP6e0//9X/3cTmefXnv11dPXP/vZ0+P/8B+uFBN+rkIvMmBu9u7w1kHBylbdvz1/jhy4pQ4dPq7H3Qi/+bdGJkpOdxJYvyIX+qzRxQuX99pEa5OqPU7jEM0mvonwxyi04AQf1VkhS2Rxn/or+S1yQReQeOkjmmrxzUYR6rjjy1s55uKP//iPzyHUWMt5wcOEq7NfwLEU82BH7Q6x/sf/+B+nP/3TPz299tpr55K3KrR60u6v914P33X1fBtpzKvseBMzPsyHcevdey6LOwtiQw4vp4mrTeji9ZTifmHPLBqGalVQw+d9gqw3Mw1tGQab8zzflnZj75lCmHmuVfvffSH1pBwXAQrateCF8opXwjBdV4xYhPTg5x6c3vg/v3HxrJcentXbC/cvK0jOdfNPPexJIEsGNPcwyvBTP/zB6d4ltHJehUv0Y8CcXYQwZwU9fjyG+N65cmgr33O56JPLnaDznwPtLk8WpTcZFmWnhZ7cW/6TE+D1P+XJ7jvwfuhZs4s+wUJX115BR5fykQOzh5/f/4H3n3ncycLfeOsbF/jw1Qm1f7Fs9gpluNxwJ2I5J6Hv3T39X3/3504ffePlc77l7Hici6kG03saRe53kItWt0yVjxvBzvWcnh6L33JrsoC/4O09xbRRM9kdOnSdOWKOfChiUCeG89MEtvvokJcvDVlPJh5ZmZfkkCfvmaj8dA4agwh6bxTOySKrW0+hp/WQf2zlUqMgfLkhYFHXrSSaHUXLe+5mNQrL2d+zMMXpZuBDRAkWg6fse1YIZtrh3MbjKKO+n3XGBoesQqtHyjCcZebyft8LhQtFFa4qE+5wj8KQuPYijdY8t66YYWltdT2negH77xS2MVH08/wxJrz7nqNSeK6nljbSmFZvqtgvhtUazhrjg5cfnN78+QsGv+jUxdtTfnL4efHxk9Mrjx+e3jsRDrhil2fuzV3n4qKnUMDwzk9+Mkm1p3AHDx+mf/nFBR9lPpdDjYf+F3H+89xiVC7gsGeBpovxqIB69jiGC959Kld1cM7reu/u6aUXXzq/pKc5Cut3Tg4/c/pnxn5pFK6OuWj+4/LnfD7wvRdP7//+Cxd5iXnm8P3sFv/gB09vXjppoJs6Ue4vz+MDyrU8Wx6ucqY48XULGXpuTw0QHQGGMufCJq3ew8vGyHHpprVCR8byYt5k57WbI0+TO2Cw9lsVrUVlx7w9wxFBonS5iP3SoZbhdjczGTen0vfIYa4jeGtGwS66CZfG+5/BD872mc985gzhzIYyHq/XAH7+858/e7sTZXzxi1883/fVr371aoANcYYgQrWGa9Pm+jnziIXe3u185BwYLvkLBN2LtXF4Y2jIXuNzlQi9ZEaeDu+pyXZzGlp5QYZ3tcIknfYJt8SIPSelVUDCTM83r7l+GMzx4kPv1n0TSEzVMdYrKRZpLAS2cM8zDBTIaNTiO/efRiXTRiGBj46YlSG+KOh/cnrvgwenT0654PlmZYiXD7s6r2iX7NtUNjDhe04feP/7Tz/84VefHl6nPdX+z/bXsD9lo83FdE7PHn9xCSV1JJdQ0Pk9BqNowidP4aXL6qbLvQ7WYdrww8996OdOr7/x+uknP7kw7mf45Ac/PP3ohz86VwnNBjnHWDybL3i6a7vG5qw0p1arlXVySaCGO3dOX/y1XzvdnYjk8qXznCMQb+FQsgXqVJlUh8s1YFmKfzbAbi+73vzVkuU1tSNDSkHtmK/s4dernFb2HFHOdMvI4ugnhm9kpzuX37z04GecFPfoHdE5RYsmddgYRvCPiIOnP/I5UN986J7Rl1AOm0rnGX0xTyH1GuBpLQsuDF853xH2jRiF119//So5OoOZwTqgzhuC5ggKizcTtQBTJjoHa00ff/RHf3QVik3roXXDiA7EGyhl2hBn4KjuPOZBWEAM5j2qwsCNrWGaJp2r6K4E5uBkxAqUyOVMxMuQuZAYhTKMNAw33w2DqV5wyF+9As/EhD18yzjqHdWDL864X3LeJBZGFrJjsF15tI3hUT+F4ubz1b/91dMPfuEHV6eFXtHzydMXwZz/uzxSQt+vPHly+tSPfnRWsvN+gsuVuJYPL2CobBk4V2g+Pj18MljvD58axKtupJUvr00+wF+v6LsefQF38fyf/vXqvKSr/EEGc/nv8cBnXI+HN9vnzPnyUMA//7M/u3rx+iiA6XNyBgMXOWL7yeOn53ZdjeoSdrs4zSJRwMUEr8bFgMx6/J9+94OnT3ztPef73vfmeN0XCuY//y//y+md973v9MKLL54+87GPnV655FEOVp0HysaaMxp4hwevuqfVajtPRbEqvwSjjnL8/7b3b72Wd9d957eqniP58HwmJUumbNpSpHbiluA23G7YQNBWG8hF+iKGgdw417kJ8i5y6Zfg5M4vwBdtGDYSCAZspGEZlinZgWnKkkjxIJ4pks+hgrH2/u79qcG5H5FSFdBIagKr9qq1/mv+5xxzHH7jMOdf9F7l4tAsPlTx93/DN/FonkO/75TejkYZXTH6a/RR1Yhv8nyTPk8eXcMUfvsUWh9DzzO+a0XYbVJ675Y2GtLJAvNKTk2UF1ExshBty+ME/CwNb0zPxSikvDs+YtrcaCY6im/Q6hCgvMMYgTEGHYc9J2SGmObziD2/iylKvs51WTmPowg57ORvjFn88aTQYnLj5U+73U8/wnOHhnZlVf1blWEZ7lxvuMta5eqbMwr265OUrHhKAHbuxXLAkNZ2rWsxV3Pe1RkbEfve/+u2Nucfvfqjy5uvvXkTpiF3sNG2a/fBt968Pmjm1TuGvWaLn7rX3RB6nOTlYbvh2T731UX34aNCKruDp+d9H/r58b9df785rt8/OuQfovFUBN14h29cvvOdb98lvedO8xzntx/Dd7d5k5ujLZr603yaYbof022egvLV2YR2H2J4dHnfW69ePvT91+49hJdujvh+5aMfHah6k5P74AfvijZC4dMqcUx+kouAkyBkgxv5NL4NkAxtQv7lA3r+cffLMOyEsHycDG2eTeEmV1UEXY3vraIfZe0+myck0Su7DjjeeV2HZyD0XfcyTJtH7ykGHsint7TnZHhIT60qrDyXXX1kZeBJlp+JUTABrDUsfj0DHJeoI6iti8+VqtJmPIoh+JxXlJWcVjzQ6hjPA4mZJM5OHjXOGKo44bRcqubQ4p4Qcv+PoFv51zI2LaZJrnmf0o4p5n5Ds5Jbu4RMIdKoRcfG4B4B73/yggx9baRvjiWhVXlvd95YpgbLaqS7U0iXEchDuPbz5MnlI3PqraeYpqDv73h/bpAX3X/NZ/exbcd7/VtSuN/cov/ocbPTubDOfZ/3yu42pu6OtIxf1/Ldtd/q1udsrDd/dHnttZucW+dM3fD8zYOk4qO7iqn7mlnKZknUM8wfN2a3R1RMHPvRy5dXntw+1vWlGxkZD+Ya2hqU/573XD704Q9f3r49Fj8PJr6Nh3zIUXwXj3ZdPNpne09M/JIMh7KLJFyT6rdH1+88mQDMlyBOhajyzpMeuge4JsLR/xunyd232ZyrXNWvR+zE48lQxqQQlGFqdZLG5AQo9/fOW9l3n1Z07Xp14XPxFIpzz0RL9syidi5KRGyH65RsDQqYkNDnPve5y6c//enr/4uvRahOKGzQfZcHkqW1ftgYt2VxlXqK1E3USdwWuH0AMYVJL90wkXXuqsaiVjLZg7LmsxLshZWGMTNYGaaYI8apykLluj0kDXQ0MNbY77YS1/3X3fWcIvMJfa934XXXUtHbSqI01k1M/d6QzUau+f7lt966/MU51vrkidwdUX0v7CnyH2tPffTk8vqEID/0oWsY8YYn7q/DrNzuXL4PJZ3q+DNqnYV0nUvG4fbMoZduvZqbMtUn11LRq9f05o1XPZVXr79+U9M+oa3vfe/mGSA//GEVa/e5h5vjPihLBRHfFsre3vd+PoY1b/izar0bsPNrv/Xxy3/1Ox++Ppf58oN3LpeXb59xMXX2P/uzly//7b99+dD733+dvfI3Yxz56/Th6xlJhzPBrmt566VP85nd5qpC+1XiTA5yDMC8JpKQIdDoFMKZZli2zw2pNqb0RHRLh1RhqN5pHc1DPMHA7O+3km5PUfNs7B10GUB0s6v6S8/AQhPvM00ja+7Agy6lc3Tc81SOn5lRqKpG5DrvewrWfFepY7H0nndQHXW7Aj0jJAZqUXZs7JQQlmnMF0TQ3vedKF83asfJTUobS/W6jMaOt9a/DGu8dBS8CEerX9hnV2445j12m8ypURg66C3I9HlX5V8SDA+x6wTM7aJPk+F2svpOWV2LSJ8OHX3ghz+8vG92u96FXNj3MfqfOv+75wBwnMRdrf0az/zuisyeClfxG6t07v41VHZz7Z0x2PTOeLD7ek46fd/73rhWC339j/7ounfgZlPZmzenuM7fP7454uKaS7m88xRdrjqek0zvj+h4WjFd0f+dMWp82cmbp61dN/1dDfw85Ofx5X/zP3/w8qkvvXK5fPety8vX/R2vXB6/fKPkvv8rv3J58rM/e3n/xz52F4aw9r9YeIh3ZNgEZuMKKRtG8+FYGYz5vKKKMQo9sMtwTiEn83its6WZyZ7VOnogHW0z455IxC75VAYMxdYeo0MM7+r9WMihks+r2gZke/oZjJo5CSMHgkHpvz3zdLH06vPWa4PXZ7Z5rfhXRCwU0yFRc+Pcl8pPK5GcRGsJ6ckvuDs6QjUJM/wiaL/3fBMVhPE9FauIqvvZ6jsLHKG1vrplurXGOzdDN55K0jQsu+rirpKHeK2LLYJI4EwYp+SfVij3SjSauFdi7jfrYvKqktrimeZtEq5QXNe8fItS75B9dL1ViPOa5yS//4c/vHzoh09vpFEI5InTOnmN6z7FpX88Ibof3JQom02+7l8wDGMo5q7f24okS09vFbDKeNpLL90I9Zw0+sorNx7hKKAbxD8PTbid91sDclI4tzxxPaCvT+771mO5OxYDGlwTyne0aPf0/aF/Q/v3//CVy+PL48srbz++/OLnP3B59UePL29f7hOar8wZXB/60OXbv2asIcAAAK2OSURBVPzLl7c+/vHLay+/fAVuefceNdNpoSVGt5cd/yhXhaDmNSEhPdC85w7Yq0gkr25koFBaSrPnBOglJyfuYVLx5dlMvzOHQFcKuf6NvcsXL7EvI34zXJtHoFHQc5przdPFvxuYZnCag3KqLjEkt0O1D8nL1n0/TfupjEIHUVkKNYv6hS984W6Pws/8zM9cF31yBpWIzqA6EnbaPPNgGGZcx3Ejd8K3pJL5C90lN2Tl2kXAFFoM40J0XUYlIus6GqM3xNR3KgwXfL5LacfIMXMLaL1y87NMNEORoZ2+24ndQX97Y13Xt4ekeYpQ+r8x4zyYaDmo0PxC46npCYg+RGl3z5oV6d9uUnvzMmczv3n5i9/65jWXcMu+90rwshOo14Owb2n8tHG799hao5uyyiuSvg3BXJE4R2C7iWsQ9VVonjpk8P6QvJT0K49vd+5fzzS637A2beg4wOYLX/jPl29985uXb99uMpwk8lPJ7rUT/n4eegb3B+ZN7uLk5l8fxTnPWL47v+n2TJ8rrW4SyfP5//A/ffrywe+9dvVWXnvltctL772vEJuQ0ZNPfvLy9f/xf7x846tfvXzny1++GoSpvjkdwxDoCv2maGaNSwhXMLGrkeI1Ua8l2MOvw3PzmjEk81ULxUujI9I5AdIASXI8xniUf6WeU+FYqPuq5DiPTC/EPRii9kfE9XvMpaHUaFAyvlBztEtGAliCPz2QAdHu9H5KZigeyfNxE+o9OLkPZwfYdsmsj0J9LmcfTfOwpSY/n411nhKulEclocM0HgY1n837WUif5pZbGVMMQ6SkO3On/1ctEKHuhGedpyJqVqFqXFz0xq6b6kKkAM1DGFJrQTci731KwQRQtM34+bkGQI9Cl3Y+79TIjVwSpO6hUdS4ZXS7rztJn2KYtRN0x5efqqC4ReLz2ft/8IPL+773vetTj++VO5VFJJfvjMD18/uKohLDlV8+ftwGudvyzxXaCUHPwXPX3bq3d3BN37nmBKrrx/hcSw5v8jnf++737pD4eAXfueaDbk7bvMmf3PLFOx4NfUqMP20Qnm7kD+5CR/cZbQ3FXZjr9liPWYuPf+P1y//6tz58ed8PXrm88miU3CuX14bv4qt33rl86ed+7vLtT37y8o0vfOGqjMv/uUtWRKpHOsrf8GQKrRJPQ7fJUCcDG14Mmefd+gyR+SyPpO+V7b6fMU/Jbjv3R490Wq8Pc0omTMAaina8gZs3OSm5expOtiCj0LXymvzu8FHjUM7VWcqya2CYWqB29cw5STlD1O9P0ZAT2PgzGwXPCzfO1STbWOXZ4p41nlFwh+0sYn3GQCGNDsaa1yxo7tu85poeSuGGF0NOMZ2Jrt5rABqXCxnTbMT8VGhhEVqEZbgqhti/b/FPMfvoK8L0nttYeSigDGRozoTajttmMLz3Q/NzXDeK9Z3L9z7wvcubj59+hkNG4Ro6eOutywfGgD91AN39cQ8VY97ch+TyndAUKpk1uvZwe//68Uloy13epZ23RmaU+OxGvqHvbQ7m9qC5eeBMZypd0fjt/a50mk16P7rhmbtjK269jPt73yB4zxzaBuEUIrsn99OJwTtewiC88vZLl49+9wZBf/qP3nv5S3/w4Rseev8bl7c/8IHLm5y9NU+m+8oHPnD5+uuvX777la/cgSqLKfaYDM948q9nAnX0huGS/m5DYS4ymXCnr8ovoBnab4xt/poilpLgJpHbJNeYBQgCmh3a2Qj8HZ6TvJVt+sHvWiPzmCdUb7it+xgOt6T+1MeJv0/zcN4/qTG4W/ef5uIpHZuJtRjG1brxeAuVmvX8hWKIxsNC6LldfVZGf5qnorYTsV2B06p4Mpanm5U76tbx7q+yVyFOy8gNs3bAn+GijE0LUn8aCxGTB3T5mch6C1J9x8CbYUU701dH+ZbMbkPfjE1PxmdIVAY8n3f+1LSEK2aV2fRaMtLffe27l3/71/7tzdPT3rwVkltleKcw3857eLqW/6YW/8fDSRo9W884ls3vzlTK+7g+ROf+KAmRd6GhjEwG5/Gjm+MlxjuYtR2Pd9hsLm9tbyqIhvduPIFOJz2N9cors2ns1sO4nrfEVE36meu4ov8rouRojENIePr8+Hffe/k//PNfuJa6XvnrozchiG9+7nOXr/zqr96h2U7yvPLEH/zBU6WeoV8Twq3zKPz2LHQshN5xfFxuwZCmPLoTttOSB8MwoezkKE8gmc2rGf0zYaIA4R29Sd42TsesxxJ4K6+hzD5aVT/qF4FWcqEh9LfpNA2jBwEmj+mw5HWHmQpJpXMaR/PW239oXH32XI65mEH2HIAZ6M7qR8gUaQzlXgAHGHotblh8LWWrIq6qYRi1ioJ2TUYUEcK+p+GT/YjIU65g+uoQu4gf0hYZNd8de0xpd65850MpHL3fbmALPt+L5JpTFSONc/othNdBW9HPM+nrp99ktCvjnea+EHekuhNTlPSDd+7PV7oqYyqEXnr0+PKz3/nm5bXCUJSG3iV/LTboYLnbPMBWoNc1evs+tHH31Lb6vEXRb7z3DY4JuQXXd0ljn+D3o9vNlh+8fOkPvnTnMd4o1Juy0aeNy7zGo738+H3h651zeqqiCZl6SqFQIXVnxKLZbZjrPT946fK//X996vLeV1+/vPfx65f3v+/918T2H3/sY5f/8lf+yo3Cf+WVyx/fngDgsec+9zeeFjAlQymt+CavX8VnkUI8eeWFWxDVfeLpjYQ7P6iQT/fs2oCWcfRphm73SQJ3/MHzj831bd2jl27u4y1OZ20d88DvPK9bjyQD2ZrrOUzz/CjDrW1m2963Y22u6iZD2jtkrQ5urILK53JKagsbM1s7rLsjcUMkKcgdJtmuVKEhlbmTFwGkjHXZjNuJsDeCN+m00YBj1GK3qMbzGlfMPNdbxilD70Xfi30KJ/S9ybWYwEPFYtxrueHt7u9yChmQ/SyM/t8aqihy6Q31iWZk1h++fJtkK6a/Qh/vGbQ48fYHOevHv3no2rtdu4WLntawd7R79ZWb0GP8Ol7AzTlMPJPipZcvP3hy76leker1AT7d68ZoXc8ZIr7f4zs1Ck+Frq6/b3BPb2i70p+w2X5kaGTTs3np8ujy81/9wOXly0uX9/zo5cvPfeuD1xLYl9773sv3f+5nr9d/74MfvHzrAx+4P5vndieuBt24eIrKw98afzxvwYJKZseyMwjJo6Xk8sEofyt4MlhVuTUujYJyYTz/6Jk9UIVTU8ZPctn8317hYvWBYfOacf4+TwdlUKOTwNF8wQ5vqxtOfwUfyqJz7/vGt/ODz8QoWMeclXWXX4TZg4oRjFFar9uAK0eb6wsXpfCLMRpqOSl4mwQzv9CGsBi45JRMo6GZlpu80UVoqRK7jtnVonedx/HKIJbM5U6fYoFZ+m0k5jUVJIaerKoYuuqy3i3+rbcwY59rPHYjwzdzztgl/Arsdc6PbuK5V8WbAN3p0HXEBO0GNbtJ6+n9aV197e8p5X/7Z+1vuDFG9+W/V0/qVilPgnj6nvV5+eX7PNNU/Hz729+6fPc737nJU2lo7xLak1e4n8/dcRvxPFugbz6rAuVeuVzPILo1Jq2hG/xuQkf3Vi5DMZ7Wa09evvzv/s0vXN5457Vr4vit99/0+8MPfvDyu3/jb9zxxoRVJt4uXxVOzei35nnkJl93LNv9M+2z0XOI/u4f8DG3nt81f6dKyLO5Tkp0G6itJ0Ta3fehXMYO6wjALAYRvL29nmPe2Pr/9gaaf+uYoc2Dsmy3dU/2W5dC3YacW5Npgtan+GXtnTC0p6ymNzR2z9RTMNmkK7XduhYmS+UzB1JEbZrSWKTgC4P4XOQI0vVN2CqinVQOIenS1s+0yutSIh2KtZGOltskVC5sYabpa0pHu97D+kLYhbYMFWlgpG0tOsaAnkZZ216HjGTVReswNGhX9QisjFu7Q9C3Al/Yrdc1N/L6OzfI+Ta2fx3rO29fn6P86e99//JoaLmqg67jXcdS39z7aY/zzoiBxJ8yLne7jmdNb1D8IPtvffvb15DQxz/x8eupvLPBbAzGHKnts2rvPNtJiM8x2FWNURp6c4jffUXVNfx0PUrC5O/9Jrv468mTW/G6LYfdm9Bu5nGz/yAPYkpSrwDm5Vcvf/9f/+LlQz+8SeK+/72vXr79K//V5dt/8S9e/vg2FPSDOTn1dnNWp3gqZ4KgWb+967UQhog1BdVufB+MY0lpMh9Iak9Aij9581TRwEV7FaJBx9dkfETtKju9VBXxvDRq8Y0Rg3ntTand37zhE0q601/RLQUv0J02n/kArw3A9DasZlIPJWuNW4VuCKu8grLZeguwNdTqm2duFLrxjnup8FLWWU3DPhFd5eh1KiWv3bG0xiLj6OKJQGLGqhi6Txvs5mW80/zCQ+5an8XkKdoTijJW2BxMjpuo123fTGWYq3E0H6/dSaft6hp7VbjcG+E9Gut2dxvzlRbff3J549+/cfnhz//w8tb7bsIvk1x+9PZN1dF1D8CtFzAPjJkQzSSlfRhJ42/shU/uGvsM9CjuDMs1oX25vPr665c33vfG3R6GUTijyI0B34zHA8Zue+q+f0I+LsU9yeCnY9X3+w6MbT095lt5uDy+5lTajfzeH758+ewX33f1KF6+lnO+fnntY798eXJ57/U5B9+YYxU++tHL91599fK9Se5PAvn2tFG9gcZzAjOun9eIpislHaU9xQt5tqJ4zxHKGxkPpZcGoxyUJaCnEKpI3bEHlgpnnsBnOkfQ0++tBFSO1S17o+wjeLvXDqUZt69PvbCus7qr6ERjVY5cjx3O3qGi2g7bn8JYPmN6e+rPxCicFjRrFmH9zpiapawtRBNuYVXCEcmFFnEYGxUBpdT7XYxb7bIeSYvbrk3PFimEYlWR6LsxTOu3Hc87rxa7JFT/3yVnfSdtQwUq8O1ONk9d5v6GNDaq3iWpGfT6VTkkfM2t/qo9txjgne++c/ngb3zw8tU3vnp5+z03Qu3ZRSndUaZTwXYtDvjuTTLcpnB4PEY0eBoQ/HiSd8bYswh++KMf3davf+f63dxvLr9xza9XPzW2a+VT+e3Z9PZjR2Hfb6IzBHpfJdSu+8BLv7unwWyreDz3vo823eQsHj2+fOT777n8zX/3566eRKGaL//v/+rlm2+88ZRyeuu73717Kl/VOHp/VsUJPCzaSFbcTBmN290+r04dCNCUA+gpZBV5NJY2WSnDyc80lbhx8/g7uZIXikqkP1KohWzzhjxmPl4wQjD/N2Yf2hcYRZsn8Fp0O4Wn71YY8NceDsHo3pxqdZYyfzIKGsg9hlPuQZDcWnbcyHMJHzUpPQCJovuX9W5hdKEUKhdo/saEc+0+wbDPMzLbSEnYFHrWujOYGodVQG6smzlabVSuQUY1jjitBW4jzX4WtAq8UtR9qFeLHA3LPxTaCsHFoCKDWvTNECX4xnsd996bIJK09M58Qs+PdR3v4qEvvXz/jORRwBOC6VnDa6fonWdHruHeQyCEdfdoy/t5Tnhu+v7a1792rTKa84ZmHN/61jcv3/7Oty/f+/737xKWNzuFq2yafu6P6L6pQsogt6v1fuNEYZ45ZM7nEswhd9d5XJ8VfRfXeoq24zFc59jzox8/uvzS/+dDl7/2mx+7peXNDua5z6uvvnJ5+6Mfv3z1//h37uPSs9YTZiVUWvXQ8GvhVUOdVevEC/FPzxHoWQWdSFrsun7n5WNiK1qY1xgBn5w4OayMkuePyS/ymOGY+ojP3FMT/4vWLbDwN+oiAZuGUHpYFVlYKANcGPidp/aa3J9y3D0txU0vzTVV783a9EyXDGj3V2+qK/sso7YjHoaYfekRWDxg+apA8rk8ea1YYKEXkzVZrSYcsSLyXGsyqQVxQ4kEy+qK6O23A9y6rwwRQR1PhsTQSP2Ghk3QdY0o+RQnPBmKyjnNmZgryJI7Vue2y05jYD0BDXG/S5BV6irw4qp9nwBXC71DZ90vhVHNu8n7aHD9/799fHn5qy9fvv+/utnEeD0MjlLTpzyB8g+D2A97a268jSt1rv++7/Zspm9+61vX0FAb2e4N5A2iky8n0atB8JkI96Gcmzj/TVz/SpE7i5BSj67XfQflG546xO7WV3n06PK5L3zg8sGv3yiSqxGZvue3Y8y+8drlpR8+vnz5c5+7PKK2/0r/KVQYEDH8PHSd3wzNb9FsB0zOqycQ5gUnT8NrczhlObs5EaAnlbWJ1P0yKpW8+mmVNGd0Ajt5BJ0rlDLX0MujyvJJeSujei8qxRSyobGTHNZXCF207fW7bQT+5PAwreY0LTlLZppbxms/NVEvTnl0nuka6bX1VN/5ufJfX4appEcg+bkahRTF3MhwhQSV8WSWFLQJ5u1GaTxC1jGEm9JMyhha2nG/7isCzvqbEzE04wLE/MYcW6iYqd9EEwU2oXWhRZaOMYabVnzWqoZNJ+vFU+J5BYXMWo9574a0Xe2xjU27yiv97f0WpOsYf+ely8vffvny5ufucy13exbWM5rzJu72JayTQeeTmyOlh8FvQnPz+vZ3vvNUKORKw/nJm/dhpesc7hAfsZq7e/f/1nDvKL4xDDcK/ZYPX7l/fvj87tW3Hl9ee+tG2d8UVz25vPPW48tf+OIHLp/5L69d3i6UOjw3XuntSH7wnpcuf/jZz15efuONp3ahX++PYW48oc0vf/nLV0U8xiGFHG93PPvkAObMsY6jns2jPeFPxOuDbwr9ds95PxvdxgiMd9CpAYWKxiiM1905ZiVZd0XhPa3uUfE2CH1nLs2DJU/5vVO4Rf7V8zD8siMb/TUs7Hgerw1vgqRd+BKv550EnBqv3rhGJt2mHO22x72vt7IpMKRX1XimPRej0FknI5wRP4VeNUoMdgozRYyQjK6Y1tyQk83FK7Y9vzOxUxVGwlRlhrX7O1SyGTVXct9bRCIzOcf+33eVg+puxhjNP+Vwig+KNHLvqwDxELFxX2OQQjytiR5aO55jYpF+80zpTzNHMYqmJ1EVK/2xuOzrjy6vvvbqNcTynjdfvrxy+0jJa1+PX7pD+PN+9hJ0zHXe0M2egBtl+OEPf+ga6vhP/+k/XX7wwx9cPY+J4Zugvl+f0Natsnn8cmmDm+97JrLnG2Egrubj7sTRm4fqNPcxCDdK4H6vwl/+wgcv/+2/+eRdGe6Vb99+5/LWPEXtlftjV77zqU9dvvjf/Dd3z1mY10d43kdrOy2FrTLplOE5YXiMQQe0+azhOVRy1mbe/9zP/dxd1VAx7UIahUl9znf80oGV44VkFEoaB7YCT/NZ8je8OLxXuNTzjlpXQxfmARuDIMM4+w6vyLfKXvrGCrsdYzc30O8Nt4TC37xVnKdyUmW8extaEhh79Idzq7+8Ab2l3rcptWjJrKeoX13a/Nsb5RgNoTm3Z/48hU7jNLZnLFDL3kRrG4kXNxcZ6VKdwhl36PDWMHQ8gwo7orVolq6a7PH67t1vDLHUtvL0t9uit2huDhLpNG/DVvWzQ3G9DwH1N2M41xd3PVVi7JzINJGKhujKFDxo3rWNCc2HuD7XGPXrb18++dufvPzeL/7e5a33vXn55vvff/nYN795ecmjPNjy/85TKPB+fHPc9P1+jzFUcx7OrNk9ja9/b/+5R/s31TyjIKuV/9a3bh5/eaXBXXL6Jp9w29utkF+54M5Dup6DdK0weuny13/rE5cPfvcmRzSvD33ntWsF0eXtm1LWGdj8fPYVPL5Vel/+pV+6fO/jH7+8/t73PoWeM+SGCfV0482MRPuDKp/uITUTKhrPoEMkfWphx8GMvLYPR7noXiL/MRxTUtoDoNwcmaerdyq6N6zSPdIT5sNU4EYUkhFBYryrrAnCTmFnr9OIbBnbeckdIn55hdnqd18vem8cO/YfqLIUdUcY/J26TAMXLZ2rkQ/l3KpN9dEzNwopsSp5tJBNygXZSRsTpCW5Yvb6P8UfT8rXeKHMYR+Ox1ijFQD1KWLW4Nm21xOxZXDHk+JNQKxDNhZpKGajkj2u6GHYrTzINooywRYgk9AaagWjtRKxxdy7eMD5zIPnp+z00cuPLh+d869+9D9fLm/96P7et4L/nveO13IrWDOHNwfR3OcAPAX37befPin0liPhzXslP2N53xvvu/zg5TlGYD4Zo/AUUZencNPXU7R7+eXLx9983+W9P3r18tLjly9/+Wsfu3zkmzdG4c6QPb7P3bxzu5msTWpXT+2zn728/cEPXl4jj7RDENFUntY4hNQ7kmT6nfBQxmAqhEKl0zxSOqOQx2yopj0KPVu9B2LNe5+t7L6k9iwEdJSbPafWIX5yw6ZHpST3O4y0vXLlRBC5QdoGhX238ws7n3kHat6+MRy7EOZ0L+XxZKiaU+MRiCrX0cjf7hC2cqwOVEfuqIKG7t3yKn8mozAoZW7kjt2sVwtqPfFe/FqJs628m7SJWd3s7WK2O3LGk1XvN53zU0Iug+bCnpjN705GwThjzGT8sHPkE6KYKi/FU1tVCm3g2R7WdqOjl8m40EfjbmeySCOE6r3bzSoDzT32AWddn/HWC9HNra9Zk89+57OXn/nQz1z+2md/7fJ/f/P/fPnum1+/o+NU28xr9hNMG0Mwj4ucky+fqpD4sVi/a/F0RdJNP+889RyFm3JPY8I310X3jMhdhdJd+mGUxkuXv/Mf/uLlV/7ok5fXXn/t8s6rb1+efPzGIMxYr6GZ8USq3Hn99ct//u//++s+ieuu9DlJdOL9twlIc2J6WxkBaeqGqmnDR3/+z//5Oy/BZ3DPb3oq2vQTv3euTvSzAq88QZ6UmxF78lm8nCyWxC5stat7LICITzUg01+A0ofNN2/Dm4G3kzcq2Iq3T6Gj6Li9XQ+nrB8rBd+8Dbkp43o4guD4f+dFW+e+V88YQVCGHa9lvSr1DZYdg9EPPabmVz7wmRuFnqXasbsb4abcG3THQhgjFYmLeusjJmgCuqW5ciraeY3bKyO2kCHavJF5nc7u0c0U9btQtRCfTFAYJiHVG7G/rfRP1nsjhivyvo0zKzzGb1PwPf+2fI3xzFxm943ELN0n9KLQyORtItpeQ8ohIR4FMuGNSXTOVuP3ffGvX77z5P99+eZ7P3/58Ic/8pQCuqH/k2ti9nrK6pMRoKHNVaXfHQh3Q7enj8SIjje8c1+xdH2Iz20eeaqEUlbXeVwrn+4fSjM/mMcuzzHUv/4bn7m88fJNPH4M+2fefN+1Ourt8iK3iuL7v/7rlx/MYZATox9EPet9mY15H7rzIn7AKaQqqUI2yk7XuAltxuYDZnqEbaFC+bO1aD9OfJ83YKJ4vh/j8BAIGaUsr8dvnjyg8p9WuKr/B0gyboZvG1vRgmRWZJ+n02/iP2V7GwJDMJs2KnZlOgPXw4AyRC+th3OJxjMA6avdvxvV0nnT/9CvY3tmboXryvN4j2RVMJxOUV/sPIb6ZIevflIv4U8VPgoVpqBjnk28CLjdtohpAkvFaT8lVuf/ouWMRy+T0lrrhOKEiPY+AxW/7x/6zDiiDNB9N9Loc42hCCAFLI1EBtNEAjuJPHTqs/l/rn79n+4jitKljfG3Udj9iNymFWrqNNibBNnl8ug7H7hc3vzI5ckff/jy6MM3190ZhTlWewzBlJnOLujbbWvtCL6+e+Ihchrpnowzf26uv/9VLY/g1sO7NQrv/eOXLh/7o5u8zlwzj6/89FffuLz/1fdeXn/Pey7v/9H7LpfPfOLyvXkuwRwcGNiZYNSHP3z54zmZdBTw7ZHwN57GTdVTAiygkKd9gLzfKQsZ4L3xMzobmuizjEIGuhNI3U/gbmTXr7VV8SoXJsEDKG5ou6M2z/5WTt0HNH+VjWRHj3qHd5XrlO/28HcYWK/l3lt8Oq+Tl1C/j5Y8q1c0hN5Pj2QraaMeJYwN95jv6F7uFdHjkFfSqeki5VXdcQplPVOj0Masap4ldkJuFjxEL1JtsinqzmuR4MZW55URMpZpPF60EgKqFMunSrn9Pqvbwu0Y/UZQ+33jywuRkdwd7fnpup87BOXiO67GEyJXuLyvntJUkExFiLXqlcMqpCl2vZBKDE2Qy2yFCzfCay5zn1/4hV94ioGvCcs/+vjljSe/dnn0F37zNlz01jX3cE3S2m6PtZbm1xcni97HeW6VwRiEG2vw1C7ouyMlrvN65VrxdJ3H5XL5c1964/K3/p8fu6L8Ozf91dk3cdPrcNW3fuVXLm/+hb9wF4pM8X7nG9946rkdxtflXVGr+ax40uRnc/X00tZ+ru85xvGIoZ0UTPIU30/SeB+lvpOuhmmtuIkvk5sxLtNXoHBa/OyRzNvTPXndApHGHn2UvWmFYKNx498b3nZIdqP7XhnaPO3AbX3+kI1y9RF/V8RxApGuTZ57VYHRNy/R52G3BurMdpRbstx6+PRJjckODeulZkBOVZV/ZqMgw+taViY5Ny3fsOv+p6V4cqGqrMgoRFTRSCcqjlB42FSL7O7fvs891wW1lGtbzeagktzobTOg5WwZvxikuVb5oZCoUHXrVO6GxkScxnoNP+VOixAzwGPAxzD0oCOFVCSSksut75GoPj9WdJNx0NBPH5P4/Pmf//mnUMwXv/jFa5nja6+9evm/fPb/dvnt3/7ty+98499cvv7k/3Hksw7O8/C8DqK7eazmzSfTxguYtZ851gyDvfaBD1we/+IvXv76H/2Ny6f++FPXsc/933zzB5ff+K+fPtJgemx39NXV/+pXL4++/e2nwiU7FGHMu3uL5ixY2HwXGNHjFVTptbWzvbUo3DTKvuqiksVuoLJcWDRpTqj+4jfBSv0khykwQ76iaGPlG8XHQ9Imz1ak/RQvHMBZdHcTZdGEFL7z6vP2UwjQ9rEcj25PO3CchgAzIq2roDfgWpXWXJdBrnlq7ClaEO9pEDT86YxC1spzcmneQ+/vueQUKket9K1XDOOAZDIXr5YSK+Z4srwyScZoI1PjnSnnLaS6qS2sjCAS3u6sTKl7Wt+9994tju5v1xgi2n1ojDQEtj0G6WXrd5UVthPV3+/8S+g1ptu12noVMaR8MJ/NPX7jN37jrjpm8gox+qCfD776qcv7Xvr65f0//PDlF377tetpqj94453Ll/7CodLr7jjs293N1+TxzPXR5c1Hjy7funoql8uHZ9PWZz/bLy+vPHr58ssv/dfXfMbbjx5fvvP+j14+d/lLlw//6MPXOXzxt79y+eE737x877UfLw1s/b8/im8M+u0+EwFB/LLXUp4VkSfM0VEwIF/F461lFUfzd4xeirhjIlLWPhBpjEIhHQ2W45Qn97hFxyFoFbVjjD/1ut+NNwVO8tNuO4wjnUXUId/WIyV6CntqLBz7lvFpGoJt9KdpMLbnk7EQBDZHPX3zA1umN01PNEpGe++amePc/PXMjUIoJGRu+EhL1kKK0lVuJmK1aluxbUJVPSSTz3tPAhyCyLQtiqGWd0MyW9HvMT3kCrs4MluM2qvrZLTGY2hL4Xy3KgdDaLq5eh1jzO9CJLj3el7bmCmUxid3NYi0a36f//znL7/6q796+aVf+qWr51DCdNBua/K+t1+//JXf+ODlzR/96PK1T715+dKfHx54dHny+Mnl8lJHivaosxuDMGGnG1Z5cvnhSy9dfu82Kfrkwx+9/OXP/fKdZ/GeR++5/Lc/+D9dXn7nHtW9876nH7IkfzwUttwKTmPaepp4T4mGgHfZrmuooLpm8fj8fzbujSHt/KKUSgag3c09vKZ8QQa+9d7Jxq0EtyGQlwVOfS6P6jWeaLURtzylLKnERbnqE3XIPt/L0Ikg0LWqD3MW3qv1e4vvTnyw+d8Cm9bfYo1oYMWZMraVduG4+KAc0rvpx2gifzf+6PZcjEITjTl1qUTuEq8F6Bz+06K48Bvtb8OghVaAI1JEicgbCWyFtxHOyWUUMYsgEv5TWCBalFNwUbLyMaKhohig16kyK+Rzyo90r+iry7nH4HEX/c65nJS/OzJl1LmH5Ymbb+baCV8NsBiafOizn7184e///ZsyyR98//L+3/rWdTzf+sw3L7//q39ws/Z3D7kBzU8y+nrA3OPLx0cxzKM3f/+Ny/f/p/tz+6/u9v/1yeXLX/vy5fd+7/cu//Jf/su7OUY3FUYe7o4X7+RdY5CPpZfFDwIkS6XNhbkWc11hgzapVXE0v5n8QK858mLCcW5M2/3tEOf2YraxUnZqei3ywq6wSTa65+YZQ6aO4eQNFO6RLoZVTjKrkd3GTMNkoYfrHd3KtU3b0YX525HiJf+TST3sQtHdt5MV8t7USfFheqJ+pefmvR0BMSndNR6jPqAi4PJcdjSfkPC0HdvaVsqKir1wEWejTt+7qBE1hRpR68tTVSPWyX3azN4ibouswdplYjumuMdeaKuF3fsBTt7JNgonJR1tvY+GUu/N+en5qECc83aVvXdrqQGveTTGfO7ZSxPe6P1v/uZv3letTJxzFMXbr13eeOeDl7cev3V56YevXV7+ws2plcZUOz/p6n29dH+W1BxB8Z5X33P50Kc/9HTS89ZrSCG3VsWwe58AbR7U6G3+jv55wa6d668ntmPH9W+Z58zTx9eOAaiiqOMnemZBpacJegrCpHfzkad2qPShV7yvvGxFq+ekx7lBVb/Tg5fHROsWlKRgt1fWb/qdc25sjaNrjU5UAbaBWL97lSR+a2Ss32o7ZWAbuABc4e35K5Ao2Z2xqa8NUDYYzkha9DN93j+T/N4DNrrwXDwFFcNmlpTRFhqVZgIgAjEckddg3zKOdbkn70JDZOhG91OGfcgdUyhE/R7it1Ghvzcs5BHd/k6haqzR6SEjI6PXXwu/lf2ftI793QZTmmx6hBKle+PKKGSoPcd+jEKJ7PEYE3q9nM5keu8777185Pc+cpfoTmi8V2jqjcsbl9cvr18evfbocvn5G6WTsow+nW/vE/D0YOU/ldtJIZ68yTY6xcuG5hRKwxihQj9vLTuJtEdrtst4Dqdrd7KIT5RZcrIxuybxY4p3Aw3Xvvmo8DSMDynCrlNhy+MPgT/vfd3pfqvoer8TyNG99RNN2/QA4t14oA18lgEr769Az8Yynq4GYctitGkt46m9D6P+B8W3V8Lz5Dp2pLEanaj/GdPwdc+UEGRvGp9o88yMQruQU2JZ82KnCUML4gY3iZNgWCHUpHa52TY0Wn+Z3KoK44IJ7XbBzMTrrs11mxn6rYgmpZVQy4inUr2Uigq8BZvPUpqhxb5TgGPqfuM+hHIpu9olF3eH2Ix1KvDb8O+kap7XNCuzdvJZWlVS2f+jmc8K7gRekXSCeaomab0snR1hMsbt2A1b+Gxr3X6v2+GA+GArGoVRD27+38F0Jdyt31cRz5r24Jrf//3fv3oE837+ZlzdixP6bPf83tSlkbNaZnvz0dN9NfvcoeRoGx8NqycFuJemRHnjsvDEahvzfRmCnvw2iq98YWN1s1dAICNRqXV9b33UA7X2BsL46bVb1N49pYeGaB/1El3aaCg6r8/hgZmTmxDzVqsis3DA0vN+U3XT9Nd9pvkQMSvUovv0czpI8pmUpG7EqkApgAlOSicFIsN1XQotd1iB0ytROdm25+L7hxCOIRZDThvNT4vJEsSd2N6xv5impKBuvm68Ctb5neqJG5+oIdTe/fWA9HYc276fykGEF622QTQUZcxcAfO7aSGejO6uRtuJ+YyEfNO9db8r90tg8kikw/z1OcQqcMe8jaNhA3nFJOump0p0vu+8oW1YLbKoYqgTSivmKBQQAOngR2m7FUDjk89Eszvcovz6t74EexpNIwDSIZppOCvHFGjEM3mB7YtJiWt84p9KrSu3HXq590PlbJipMFGHee76/n4X7d5kr5MRB0FUn3XkSHuCNr80V41LuYUZwwCl9i3M2Ha5aoZ17yaPRtPkNwGqeS/D6c/tcZwKV5l23UgJ0uQicIwhg+xYZM1F2CGL/f1DzYWfpteg4uhaf9P1IZkWRC+hhVJQm1/b2T1mWqbS1dcoWR1jqMkxbiVnXsF5ti475rq9g02rfmOYwf5DjxqPk+vaWEWqXpcitWojkKArXtux5IxC7/OkOunTAocdWpMe8uaJ101Qiqw17NI2VOrvUrgJftVCoxzypuKR5pei9KFSJxoaOlDRaQD7fIcn5Q9/o3cbjfe9/f3mg51D2IBi5jXKtM2VhtgajxtPQ9IZBuU3WiWLyaAPvuk3JznZuZ4nywt0/BmewjfzNyU911gOrEHJQFWgMjmjjMIuFpBGRS7UQ4GLvU7pWnWcvPpcnqcwHRs2yPI2gR5Ll1D5BCI9gD0hF3cznZMW7acMJUCCrQI4LboJcK+r35RU1Szu4DauGZMkOEOjnm2Qog4VuqnIxOy0HmaTwhBNKkwloSzPTQBEu6fKBb27fqNQaNC3gEWTvKqqazQ80kz0727yBEUvYZqb+RrfDhOZk2oM5nxa9/n/v/pX/+rHdtmr+LcR38o2IdJ4t5ate7xq6GE+zyD0IBoRfXTMe3IueQUa8JRCj8+cpgdaiLLxRFPLUk8KXI+rdTdf1L31ku1fnhLQxR9WBUrf7pWHMAp1Dtrb5Zvt/i32n3FvfD6LWuOcXLoPqvGObDZOK6hE/a/fInPzJPJ48j1ne03JcKFNn5ldqDS+Tr9F30BD+76mechhek1jnFGYVqI8T3I+r1Jt2vRtWar9PZfqo5hF5pKxZ7Chm7L1WWyPathIpb9a8o1apjU5wyiOrfjbQ2V1egUKwEZL9a/Vb94pujsikjA0mepO6+r0PQzO2Lbjc/FSACkRGV46Well7sFEe/OUrtFuh780GNu49HIdo1vr+Fu/9VuX//yf//Pln/2zf3ZNlIaEGs/2LIy1y8jx0iiQEcZh/gxDpc7et/n863/9r+/m7Z6aFGyGXpBiIYNjy5hEE0MF0kVUqxGca6SVnprn7ugRytvT53gUXbdBgyBMz2bPw6oac2/ygI+P3Sf66nEopx7ZsRPb/a3P5HfWoLCLwK58RfIz6174R55XXgJbJo3j/bmHLRBbmHGuqxjBBwW9so7CaPzu9C+klYI3RxDdM2SN11BVilu95tgDQ5a4+jztjEalvoEfc6+CtedSkqoi2WhCJjE5pQJSke/Yt4IhsolIIpKTgtrhktoOd3mv/XcLreOcflxg45jFUTWOhkyy5oWcShRtD6r7iqQNPXnmiUmvFrz3xdCtVhAVnubvOsw1e0x7HXYf0nzaxMYHMelNmkvQKNSvPCZaP6Hxjfgad3OZ+1sI0PxUoLrb0zTIJ57VUNWPce3WSO9OYyk/b8/XeUuX3u+TAhyba7FDot5Tb1nlvkM6KRq9L+XBmHyfG7/2vvZrUUEnh+qFpSwFi9F7g6d+0189ZY2M612fef/JbnkBj4Z5/dZjqPpp53MCjAG1XX3n2NRzroV84dr4f3lAvbJ1mTyh7P5p2k9lFNzsEUIZSz8LnHAV9xsLqvvY4GOqCBSq3wm8BDCC6lo+hOxVLrup2DYi3knlrQxTKlUFaZj6fsaecdjI035CI7vETuWyad59ujb30aMOTLBWupgnouKRbipAxzpNNKpxnHZyretHhaSi7FoFZ6/FSXlG7+Y3fankVaSFjgovhPi2AU+IWk8Vsci4e2h48lwCPyWGUwoCE70f0Z/j1sB5IJuhxcbYelQZtfn/FNtXMe/qp74PjXZkeP14DI18qeKJH2o7p2il2aDxzuCq0mzuI4Lt5N/uY0i150Y0v+hWMtsQi0qxcbQG02a+462E/KXV+293kHcoXf0J0HZeI56LP8wlbc+3+xj62x60a76P1pbm6i/vlRxozH5SI/Gnqj5qUKJZXaLicyosB7zdox231t2R4WRwmVrC7Li/L9HZFhrRpu9jNBHqVkwpjT6zWsCn1G1loUutQNs0gAlcQml+QS8lxs14dG1CJfII2VoX7UNGal2vZ6H3sT0yd4+6bnqVrkehnb3L2JK9eQ3YiLYbwakgKzlM4aUYWpsNIPptym+jy+a0Y/W9tkLW6G/Pxgo7QwPS1d9sRN56FPrYhr73p82eW5lLu7kuHskQ770O0quXuQd51gq91qoSUvNPnezq/pLG5t6R7b3G9wIn7x8vRZ+enTDKfkpDrVIyVPnaraxrGA0LdX28HJ2N/ffdjhA0D/fxbKAsHxtxiX4a83i58+eUVfV1/PNcPIWa8c6NRBUMrVYoqMlGwBKzueMpg+LuG7FuQRE9yOQ79+DvZGqrfXZ4JYKaYG0hVOgpe/MLxb7nNxmHmU+5BpNbHrGtcVDxWs+tcKiMr4tKrLL3GWCvjcEMn0QbK0HcRGMOR6V8ipsqzIZdVIAqMY2CiUB5yvtpVEwY6ymkmHT7854EJwmcSLB7auS2N6dxFMnljcinrle/3cl+K2/6TuOlIi+cthP0Gh/5XbQpQJMHjIdvIKfSVdY8wuPkmTSmfRZU9MwgpAClj7Fz5SL+2jnEeD0g1+auimDKc3pkhmOelsIOSGnEpXVr1v1dF/WJ1UPROdmRHwW60cC16buaYNOIykPy4r6pZ2YUtJQyu5uoVDoRYt6XEAy5RuT5vgeP53blYUyCss0mxqRrKjGVhK+uM7mkUjqFClxU3cCUpRtJNAK5yX3eYlhSpwGJSUu6paBiso18Nsp1p7AuuKi2KoVtODQq7hFpnhYTFKYyWSXtVNIao/gjmpqc3QZwrhVxuiHKCqPtWbm5aFrXuOlph/Uy7Brkua45tqM4wdyxddeltpFstCyEJhKUFoVhe21DKx/2+xBtsXlLDVvzmUPzzVPQONRf447HVTynMISRgmhttU68rXLMY/VYfXlRr3n6ilf1jJK3mgbdkNFc33q2wavcQElnDV7rmxF/hyPJ2z/Q/ffu+u0ZPORFGbJzPVqTaHbKBagrN2AUpG2D1Zjru2ueS/ioSVm+Nq2FsJogBW84IvScMqvkbE7SbOfnKMm5dsq+quOdpGVnvnQImEpsJxCtFNCF1K1qAaxgEWW7wM3fuuf53d4BmdUvURUj2WfKuH5mbl079JsSPRkwIWnDTsyckp4xTR8+e3eHfjQAjUWDEE0tMRa5FurYzJUika4bParoTBpWIWW4JJorDHqVPWrUtUxgTBBWGq1nlaC4czoaVEZaaeGu8FGRGe50HPGi/OL4LCCwgiQDscssLUfMiPns73ggPupoDMM+0U0DE5/v1hj1dAUTzk0gKNreZwO5WUxApRJtbt03IOEhctG/tZ1y0J5Z3cY+eTKj0cOlkjcjC3kAyVD65Pu3+iDvNdkMuKl0VdKtaV5m3qe6Rh6PvoZ886o3GBAkdM/krDGqWywKaL/OgOznlmiWQRqohM0yD4qZBZvfhQKLCZu8i4h9NsSvLloUMn0M889nxSFLaOsS29w05PcKtoulq97ibe+o6+q7sNDMq1rlYomGJ6zFNwxRTHC+7+TLmL3ySd3C4rJ6UCH4bdTqPwbpffc3LNd6OubtzqtcvI8KwvcaIBXMqY8dnvC9oRcVl783NFCCsLk6rsZhtdC83w+2N/Qor3ishPNw3M5JmnpchujPPuTJTasUbXML1fbXeL3hEVG5Gy/jxb63YitAEu8YA8+o7mNe9j1TcBk20bVrvL2lDEiAaq5pZ7cbxk6b6soJpJRV1pbGm/dybu+A3gMaGbuHjKSejYZAmhgCFkwoh/4+uqQLtx7zZAXDcb3SyYKc5+IpnBROk3AR5v+D/o2DX294u+BZRRcnVDDfFVIRfeTiVyY2Ajzf74eQ79zBFlxjbtuN3UrqZBD6LsOQ0okBdgggBs+jcAGnmXCf345Fn7mPUZ1rqoJI0c1nbY7a7mi0Os2j/M9pU1MCntJ3Do015pa+9b+byO30m2jaX9dAl3fHSVM0VcpoMFIixXCjb8LQfeI9dxbnsaVgDV81Bu8l0jMc5pycT8rTajvpt/n0lL/ZXkheQsBoG149DZVMis5Yc2OxLj/Zlo7xvHMyV6XnFx8KIA19bQ8xPtwhkvoKZGr0lfdeemRu8jNPmfEUeTeeV1iraFUYXGC8wzyum+spyPIcL4tDpEGyll7QQ7F4wNJhdVFr1nxPDzJ7ZkZBpeSCGMIJaY1i++pXv3q16KPgx0BMOGjCQ/N9W7yL2WUMKvGbvxNOciNJ5WzTx6c//em7UFLHBITST7mHFq0Facwxg8jYRTK5nXCaVKvFhLmpNQ2mcXoVwn7c4nw28597fOlLX7qj4cx7h01UIhqmjboM9ckwIeXdp6E46egGIpVZIb6Uqrt+nXeILUEVWUan6JPiKSlY6CfAMGG28gWVmKr0d4inssbmXdio9bXKxHN/fLKfsfXmF33zXFTOJj138UGyo4Lvtzt307q1dqJMvUTHOHTqNQ87apzzu9Zp6GGIz5yVmyXlkVq8Iso98Z5xd+mxk7L1qUcRDebl6anxbcrRij/D0j6j3fCRXlq/T888BjT2eeBIjya+i5aCTvtwzumejuvQC9Iry3B2qOIOOxZeqyxWHVTkwgT5zsk8M6OgVermxsBizBRsyqKYtZ83CeNyKY2IPe9NGsUU7UAc5DCKYQxOcbNiwsYyE6QdBqmpjBqLoZAU4lbC0UCj0bxERs5PNKHCCtltd3yMw5yW2WmbKR6VYAtucj3h3IdpJfwJpe6mZYKukXHjUGFKOx6Y//ds22kpiJCh4Q8NTmPK+Ota9/uZdyHF/lq62troLWrAVXIh65OSqz/X19BP/Lv/70vEvqvRDINGD8NXebxWDm0e3MlXDU5yUYhlZCPl0skChR4tUjBspRcpSp/7dP/2EvSbxtfcnHe030ZDj6c+AhCCGPnbJG85imR1WkY+416uJSM/89V7972nFTxZx0JssNRc9eT8XAQvHcyxBIiUyXhfI9rvBBL93/VJ5szF7BD1T9p+KqPQBAzLRMjtCodIRI0S6qEESpNOaId4bkDqd6KzEk1twIkRTB4ZEtiuX+NQqfdXpBxjawSMKTZvDYr9bve+ljAa04y+c7+Zz/RZ3mGaYbqt/FVSO/6r5+UxD9OMte7wiahKT0EPqmSXIUVRlaGWaGQC2c18liKOoptX1VoZRsea4J+8umnxg3FleVCF31r33Rba7dn0ncp085d8J4oUnMT3Vuj0fePznhrd1nYMwdCpl/yZPOUt5XE4nr0BKgUfzZPVFJ8IeJp5NJXqjpM7H5XwRut5DoHDLWsa1+6TJ6r8p1SVcT0SAdu0+t8RBj1ZvY4dIvOlwXV/gl6UNPNpjf1mF15swJAByBhakKJ+feZGYRPVmxknM/4s4ty/vw6A2OUO+9SXx+VGaENYuVkjBD/7sz97d6hYLlpu8qBuUcMWPhGZc268xgO3Yhf9qEytkQ/hV7m1+0tgrD13jIXaXNx+k/E0oTffeXyzSHtaCKbfhPRDrdIqRjx5Pn2e99aayaQy9T7yQIGQrlZjVXVknLhz51MAlky3dilajfFGUSodQ2Iq3/rzHiomDYEoeyvubdRTZBm4fb5Pv5sQkEbOcub4PV6tzz/8wz+8Q80izjb2ycf9Rt631DNa5WXmkVQBZGI6+pn4jr/NKbiHxA2YyYfGY/Nba2H4Uy+1flrfxr3BmGGyxvfWrQFrvoaWlbvT3p1eRTs0Aum/bTx2iLFQ5uZrAYJ0KxTs+U8bzAion5tRKHww/4/YIoL5riRNlv8Uj/Q1/cewfaYCMhQkkjCJNPcvETWCU7J7Xp5VkrD0f8MGGoxCNC1GyEKFbphoXt2nhW38xS6Lbzt33VnjlnMfBUam7v7RpF2NIS8Zb96PUZmqrZRt571kQLZbnyAZOtCNtVyzung/fyisY5hMxCh/tIYVF0RHDXpMnuLXU7Cp6B2XvFjyNMWgd7QRvWCn+UYT1yQ6DG00MCcvQj7qfTm08gLmnFrT+e0YR43u3LPKPI25SlBvoLUQ8bdOrpHoN6U0cxyw1W+2R5VnZ+hnA6KOG5H+ylTXbFk0/+G6b8Dm+skLhkpV5i+zL8bQzJ9ksAXGgqXmqhe/Q1MZAj9LjpO/+MvcnrohudrANd40LP3MjIJIRSbXndoL79O1tgEQYYmudI9ECipGjYLZ/ix+iHR+07hFpypbE3fmMzIKjid3z1CJVrk4/T4fpUVpvIYwTowobaODrm1NQe+9ysnrNjKdl/FuE+i6xvUp6u6eGdZdAXMaa3yjZ+n67/BCvFACNrq2JtHdmLUhuu4v36m4DPNtum8PeIeGtsCd5iF/GtvdIaBeJuTnb5U2hdZaKw1cXrDhMBGmYcRTqCOjsEM6ynjXWm0kCHKtNSLJmvKiLmnd5LFT6LZxG4KKVjvEczL4mx82T3jfJ+uASOnmPNMne9+I42ie0lve2Lk8x7w9XtfOa/os/VoTkLnWz9wojEXcDO1CiNAiXNarsqppMbDu/UbMEd1TCi25kjDGDlPq9T0VMcbct0KdJiNOM0tvPHJeIiVbc807ajENYSkA5QrcgKdClBkt6xXFnpLEvVfRFAYw9t5j/zJyIrmYSgO5EXhCGn082jgm1aDHEylclan0EwEbPsz4KEAzZhWGHqYx39Y2ZbINvAIjyhWMePyFIaTtlcgPIn8rTVTwhpY87kUFO3/dtZ5BnlfVfq294zeHFD9u5SjdDW9FU9c+3jgZkfqxECBvQgSt8nc9k2298Z3Pa50MdZq8Fuyoj3by/CFjUT8vczSHXpU5lLy3rtWL2OdR7TDmzh01PuVvGy31k0bafRrSUoMRGI1/nqlRmHh9ilEBbnIqv5hoXglVll6rlzehsm5xrDiyLFAlHwoKQVoWWVzc7+1fD8LYW000GEP3uxmX1l/B2gbzhBSiS4vYgon8Q3xbwTdnw2H7XKmYRze7ypOMw0ZFW6k2jl26Gk08J+cU+to03agsY+f9LChwXNFxKwsR+K5yUiBV8hmdFK0KfntmhsM0wiJW0V/0rgIoxb/jz6LpnVORDq2z69sc5p6FAQUM8VTnbQk6ooGJ3eRomgrFHENHasz99rOTo51yHY332sc37i2a6zPwhh71oPfZYNI8vmv9TEhvGVbHbHQfL76NcbIiTh5vXQSKzjPeMq/g4YLbu9wergbIc5qkb/cTELe2HuoXkHkIwPyZn7y2wzq5LTPZWQzP8ldZJIRbMKxZDv066RYzBWgJV8zqERudzppQ7E1yClX33AlfEVX3acFkFhl0VzKoJHTT9bJk2B3rjk6nnEbjNJErWrQf0WpCM/cqoaaXJ6Ixb1CiWA9t2jaip5DIvqbfeU1jsw8Feod9trDXpwZmtz5PaW7FK+qMZiL2xhRPKrzOy2qqnj3c8Scibo2P95QP5ce9P0Te8/PWqXXepYsqlq1ctxchv/aQKIGaRkjPLNCi8dTzyCgY+nBOjVdwI0CYZrj0VIK5wVW8bZMe/uadtSFRXvca57flWYWv/tnfPaRz8iBLPm++b256R/KTdPdez8Uo5PZJuAQjhtFyRVSTu5aoJjwbUWUBC7Mo1LmPbXufZHJuchu8XIwYsbi3iKGmcjQM4pZ5jVyLJ1pR4Fxw32eMFNKYXDe1xTX3cIotznfFV2MSGWEjouuis8mnfruPdJL5/a2CIIpXwYmqpIPCpnHXfU4hqBQ2SlOp107GZHsOKacU7UmhGQoMbDRW+b/xtSa69HkKJodrejoqAqtxLANNAQhA/HxCSMlVvCut5DuB1w5VOD5Dv24c1TtIrnyWh/ytgY5u5qGkdW0rMsepAtRrc947RHsCEMrrBn3voOw1TvGHnrD3yBDKF3rOO+QtcNnzjfc8N81+A257P1ZrM79vrvL5czEKlcF1oxa4qhfLqkKiKaB25c5EZjNW5YRTuTA7n62A2EizlwhPReSGmY6EUOFEeMM1GSYFQ2SxrXkEtu3xpei2y6kr2FgNmRkHnKZyVYg8NEuFpEcxL5ljV4b5aE9Rdqi28sUEXQOnYus+Go5tDBR6Ube02TTqOyuMjKWXY9AAirq3F6LXpDA2lppz3QrCncby3/ZuDKvOb6bSayPyeVWRZ2luyL7CBJHtDhcYcrQmfXtLhmdau+TUPUObj82HGOOP5jNGxyN/eKifgCnkK8JVERoRaNyjK7yHc0xuVOJbeW5PSqU+zRCqBSTvec977u4bHxbKKrFcibRGSb4yHBRPFGmRjzRurldnoE1rfc3hdb15KfN7Grt0y3PJKYwyH1SeMCXwLY5xz+0mlamP+TUs0wxlNFGTXjJOCrK+RXGNyVBOfUTM/qqYFDhdfVGyArpdNBWESE5lkTJIWW+DJGrc5XDSy7i2CqDfnvpKGUQvvaFQaiisQwxbY6tALL9UYE3wpeR3NYte1A5V1H/XifxEVRoW+cM1mPc7Zq+Bsb+HPICMoiWFOzwQfVyvhLB7qYz72ybEPIr6iI4qNnlu319vSaWulyzQyJveYUyNvWvivQbEqWzzTpU383Q79KJytt/4tvch3x32OHmS0sHvtmzG/x0sp0xsmX6J477VMxlLvbMNIqTp9oybh/NVx1hqvfWBem+HmaO53lb6VPrNGE4Rkj+zUfja1752HZBVEhHRielSuaj9ZjyGEJiWuMUQGbVoKr+8k34nYyeIOzyhsG6Etz2K/vabmsLvIjRuF8DYbgvnYW39vu/ty/DBqRpkK8qNErtexlEIOqZgh0ua86xP6+fOZ3M7ek2hkHIPcx89Pscsgmrc03T1RTfb1TassQ3+Kf/S/d2M1xhV5CplEdl8HyKLrxq/fFZfGWzLJ7eH5b3zWJ2HBkdFpzKwubbxQ6/uFRDxYEX5WkW0x5uRtEqmQg8T1ebVTJzrqarcrCTzGo2z4EFP0rylSnnH1DPsO3e5PaTo9tbtnpuqBg1ztV4Clr6TBsqfcqiX5Pzjzw7rc+6tu17UXvfWWFrXT9cFVJ+LURiXxhDNZsgGEWGmRegYabyNee9hUqLhCKXync/GOrszOYbe1SgRRxfXeOTJGsd4KULnJrqJwM2l63aybHsd87ddh10Xo3W/lKjeiWV9Km6RoKgpGnZ/jUCxTd1PhU5XdJ+WKaqKadux2v16iMlJQemmS9cURInyxuEzDzzu2JCkcVzDQfO5/JkLn1vtJjdjvRoIeUcQ0fr7XXTWEAlANH7Rp9cg8E3/+NX7Fd5Tge/QiWOd3xXujVcFDDY9Bvs2DKknKWINNZfbmnuZ6N4H6nU/PaJo5lh2GGiHIQUFRREajyDCvVI9Y0OgGA/0bPkf8DAgDZbel4arsVXkUohYL6l7eATFzmdpCDe/7DCZNGp8VgYaAUjmn1v1UUKV8FiCKSJWYO9uRAVMaMQcgii7iZlE2Zn2EPx2UVVaEld0EKJTkCRoC7SRWuNvQXWZ3dgTTR6q/ZfZT+7wtPqesRR2sswsxRGjZiRVFtOi4QmRy2DmPDynXoTcXOrfGL77GQr/OLbGreI2bm6o72Tcd8J6V5m43ttbSuGHFOWhDFq/Lx7sXKJrf7cXu9Hm9oi8Zitw48iGXEOh/X8AhahcRamnoec3hsSwreOSL3e4RQPeXPXclFM9/tZXRdjv+k6Ftr3bDJnhyuS8kNXewNcYBBe7PDOlOTke+Sv+s+z6rXU0th7O3tGsV2K4UN5MBqTHziFsULdD1hu8Kr/9f7+XTwxnPjej0KIbo455WgSbitXwS2hEBW/dc4/iTOEVNthVSgrqRqn73v5fBaPnsMMbeiIqh5RtMeu8GoVMV9pF1zC40HoBftf8XeyH5rkV1Wa87is6c6e3nouK37Xdhk1jZGw4Yd30T2C2B6Eh2DRMaas87WvPve9E4W56Kkez110PpvnsvvWwTveVvttLEOFpYAzzyTca6D57KIwpOMm7yHDs0JbrJ7/ssWrgNKDKj8ZNXthKSn7unoYEt0ekIu6aQJdy6D6kzVsZl5TzfLcLGTy54KUVeei3RicCtK1XfzUCyoFKXzo6Rj0XAY202utz0rHp0fg0Gj6XnMK4WLlAodfcphbJQ9t0P8slzKJPJZJoQAIoTBF3FmU2pU34atzt6WOexxBCqQ+TRVsp7lBJSkbF36L2O8tqC/PoZqtQFFIPPzO5vJNBjiWFuD2kKl/6zNNQU1omeKe/nbuQ2XYiU8aLiZvzDs3FYCHsSiGtkKov7xNNT2hbo2PyfVr3L5S00XSKMh6JH1IQ5ozcQZwwb09XGnUUe33pyaRI9mGBKumUWL/xiWghzD2uvefG53Y7NvfreMTCNEtaDWc17uLX8e58tjde9nmhDpHtRq3NtfHtmLfJbaMF8v7Ms2dktCk0me2e8rj0U1d0KOS0QkFVRoaYC1d7Suwez8sUimyDl3x3JlUAypxq901GpLX6zqiK88346JFEE9eqz+ozOQlENP5dafnMn7zWwD1/xmcRO1CTdy1I8WIP+JIAESGGKhY4+w8+85nP3D2AZ4xCz6QdYyEDbyNRU2ntuOJm+IyaFn7uYaKq9zv2mIC3b8OF32ggxSBDWtJmOKHDAuvf8YcCQmUpH4XWeaqg+1yDdwp7te72Ud/7uN7GYjPkZmz+KYa8VdrmFHZyrnvoEitkPtdhh2/2/U3oq8TnPhmZ6N79RNwCmeTAvqRbfNeDUzpt1Eotw3SFInZNusYkhREPyDd5OyJ45xC9M3jNR8PoESMCH42k8uq4zIdt78J1mVZy15DM9sA0AHNd9OgZGeUD3EBr2NncpbpAXn2b8I1gckc6AnEBnhLFPTjM89O2hxUfPOSJJbfdU5lSd+gBT542ek8LHCkvz8Uo1Ha8M0YJtex4Wb+p+iM0uuPkurQl63yg/XgIKdr5/xB/jMJ877N1dQ11WVvEHS44tRSIyGkbDcMvMo5u3EM5lhNDTNsGZKMLx76Fx4VvrifXtetUnF3f//ve8IAx+Obd/RTg/d12c6WN1/gQchFwY3esfb4VvveRB6VbfUmrHcYS9UtHQ0LNwZLj4c3QZPdLOfc7c0TD06J516T7xjvJlp6AIGxaCqNx6w0bmqsJ3LY34qNJ9ai3B1k/GWRpIgreRsG16v7yh6Wz23uINiW63RirUs+guQYapcZee7JkTJn1++QhmmkQJprhfPyt67vpcQoVyaPxfC3DpJ6J75NVj9b4SdtPZRR0Q60Vj8Hb9JEVzjXVwreQQ7gmowudm1cf9T2eQjuXC0PFGH/uz/25a3+zIPMY0B7POf/XPQx17rCTivXksbQoJkwTzJj+RKPm0BxlqOa5jVP9i6RkYPMKjU2lkhApiDK5cxW1WCKrojGBXSy6PkK4KXRRqcIg81+ZDmQuymzHbOfgKMgaEZOBon7zRHpYIjbH39hrhjlcKwW8cFZh0B4gnzETrTV3K3V25cnwqWPdYMp+ui70uz/f4GGvf7xRSaoesGh6K5OZdztsK0hIJvre01A19n4vUBBsaJDi59ZAg1Xl4bxGzhtzR04rl4aAo4PIWmNTUzm/vSp+UrauXfpgWgahCsl4fXtVKveTkZQ305nK6TYK9VvYKq/UQ0INiT9zozA3LXQh8YrbTat0LZe3ycoUhTfcHGKyydhaizehohHElEdEEaF94hOfeIqxx1DMAkWw4ropCF1Jn6HQwu84uYTV3d9WuL7n98O8KUFL1bbQt3AxREzj4s7LRGIKqOujr8m4vc9BBKTSmLGKNhTYfmf8XyQXw3af1rjx6MIr6LtaywqXhKI+OnKi61t712bnN9wIlbLYxzU4J1Gc/RT6aV6VZKcoLU3WmPqAp1EYCauhJBXGVuonD1oPVaOX0hfEuL7bS7X6Rn6Y35fP2F6dpbjbWJvfsaKrMXeN/K4xs7Jw1jX9YQhvNs+GyPeBjobgNLI7ZCwwai7Tdrhp2lbWgq8xTIK5eDrgFN+egEetNTmh+AyyhlkZDNT5nIkNCBp3ObSf1Fv4qYyCSDDiJPzF9bYSalIaDsMjWcKYy6SixExI+72lb30mgzaOYo9tTdftFAkat06ZdNJq19QMVWwLnwC0iP4uodquoQwqMojWegTOT2F8yB3uPieEUpP5Mk664Hvc/m6PtetUYDs2XNthraqUhu7u+8iopoibe0d4aEiMSbsWVh9ZU67xUqCsze8+9ZkxEZXFiwKaNiO1n0PUGl2sBNqxX3MuO9Tl/1vTXbG2Qzab74yPP9T0jJXbzfeNf4+t/5+UrTpA4BN4i4YZ2JK2hrNOPKkyV5dsfhSgWEL9DuugMa3kVBoocxoB5WuHkfY49/pIS+/jveWXxmpfgrUM5nMxCjtpktLvGcIhlQRY1O8Wbq2nrt383ioEvYtNMBWA7nEL2f9DoSVmW/hhMBWfCE/UMN5G1QRZX+lRnNk49MkbOLlvMqpKpcWUnqK1nZQ0madApBii0SmvYEw5od1xczfzdZ2G0rmdmP805+htctr1qApHT6K59lfk6tw0xoba9m8UtuhnDN4wQ+tpvFZlXBjDUEiboHa83OO2zZWE1FvrHXJRGTumxm7IRx7Qi9CwmQuJt/SY7Ss+kWc3sNiJd9d5857rpifZcz5Gp0x0oLOg7FdQuJWy9Nkv7x3tq8byfKtHjH/zlMYmXtqhyIe8tG1AVfzbg9nr6FoaEu83KX0BUt/tzYvP/MlrumlzEw+DiuHbPXpi6pIyKrAI3J4Fn55WU3mlNHIb9wNvZGSZWaYetKgBaKENKVhdVC5i16+78IZidhw3l12lKBNsdKXCbY4lYFsHjdQ2bjKQLq1lnwq+TKTAqYhVzDsk4X13rNiwUKEtT3PMK2vd67/w4SgJx9+DXNrotD1Q6REqFxEX0ik0kVLaSNrYsUDIJp8KTOQhjVsGzmSuHoR5msJMteTEwxSjoRuUGs8uNEjxF0KLn6L30ONUOdM8u//2sHZsfBtLZSODGsjqs8ZamE2QopJuLcvhWH4ZD8ivjS8jbUI6QLKR/JMH0PvJCG5PymiBIVp5RHr22Q4fb12gUU1GO5RvG0iNp0Bg8+4zMQpVAu3EyQ6tyEBe5yYcGSnPwuoNw0PFzipZK1fQ9T1kRIWrlQ0puyha2u51QqO6zJ0QuxG59yzHYr5ChbLd+e1ybkRmEj7B3YxvLmA33c3Td3vdoofMJG0VbuOWvnRVpa/oe74voRkQsD83SmpAR7l2ZMrwgPsMBCE7LJWBCf11xEohnpCi8zgp+6vQwC+GqzYtLc1MgRXWLBShJ/cQLfUauqdhql564/GiyetaCnKuHyUsj2cARcQZ47yLxqLnJL+br0heQuTRPSApjyY7O8kt3dMTk+BPV0yz3NQ8i+HhjIKFLK6vY3lnhchc2+iloXLN6keglB6yeU/lzdxF6xV9DKda7r4BjXPxPs/NKJgskQmb6I5V9p114BIuoancdHsWp6TvVBiVdO7kVuNo5hVc/O3KuhCGpLaVnVZsuXtsZN2YPe+lZxPkaewSsW3IGmf3N8dS311naGWjece93ViRZDSwymIbdJkqIWs9trLfhinDtsNcmyb1JV/IY4aMRqnkMZhbCfU2dj0519+1Kd4fYnfOGl2PZ9eQW8K65cDSTBPSgpYZi0bU7zKCluhm5FLgzcFS7If4vPvMZx1LvQ3hDrU1/vIwApR9lIn8rjHq2gkH+UCok+epZ6OcNf7KeKcaMa85xK7c7fyg56yZmD8BgLcPZ1ZtWd/vT3ot+m8AUdshn+4T/RubdNw8tWXNtU/G++4hcPhnPuZCAslUMbgnCErc+T4r/+EPf/iuPlsmn+YxC9NCQXOtj4V0Z+IggMai8dCIhdS2wt/umcSb73YMX4+iRZv7tVhtSFIpl2ycSqR2ASsIKceHYoWWORrLjnYKWIqql+fb64VcF5/HmcZA9Wus29jnSegfUi6GUqo4y7AZOum3VlYZakiB1df8f+jczvqEyFMwC/upJMptOZ/4eB9iZjI/+p/mpAvfmoZ4C4F0fz2FFKCnBLsmCX5r5mkCU4UT7VwLj+2YlyGrkH7vVWLNZb7T0O6cSp5AJaFVVZWfE7TscJIbD+NBvZn4SMMbHaJ5YccZr3m+oUWeT56fucqa928NtvJ+xH3THX3uM+O3IcvQaJQzPBnT9Fpz32E6dYate7Z2hqNrGY/kSnBjGPSZG4UG0h4D0Zvx9xjUiqMG1YJ1pvxOFhYi2p7G9FMp6g4ppNgiUoscgmhxTkp9u3S6kvWVwIqgRPfNd35X0t3EcwxdmMsYewvZHAz3pPT1HFL60cHwwjZyKYmNmGX+PU+NgmjWdRWB1jJMIieFr7Uwf5Biay1TnPN/FdkIxfb25m+VKRnOjHj02fMxvp2wWuq6wwWGEePF+jW2vfm/cZhTqaZdmotKo3U7hxtPSjYQVKm1v9uecZ8bBmwcImAVYPTJKzOMkcLJGxlDMJ76acfsVm7KjmFEwzx6z83d3IUyEQ+6pnmb8bvrrKxOy8hqIETzr7zyyt1jRwOxrdX2wJyD+Q8B3Q79KePSJhAWbwkMAjuupaHp7WV67FD3aj2fy+a1GLWbiKLmrwuyFYTErOa+PMOegChBprcCRyHbi6uycUFVVM6rtvtMkLaLp2CbpDSEFZOdtv43hnlFP5l0M12036EYGae5us1fpLqrQ0RBG7FJJ8MEp5yKxmG70yq+abv80DH1e0M12zXfMeyEaLvsGgTHqNBa5jqAYyM1PZ+9Zq3xdtm3kuw3KmT7bmzSUy/H/MfeN1E/8sJGqfKoqFa5EiUrL8qC3nkbtFQ2elKnppFJTyiH0mZa8m7I65SYzvvb1VKn114X5T85ff3116/h6I4czzh3H/c6bTkVcKrY4xP5Y+fj9FKNlnhkigYhYyp9m4uG0PD+cwkfGcLQPVORG1bq73znLshhqM6Rt++NvOxnWt+VS6jWXJd3Yo3Gq1Vi06yXVuD7vWjLpJuCZexZxRwqUADH1XexTNZFj+i5wwAmy1RyMbHjUuhiquabIuksG1GZik2PLIS0UVlzmaYhaSeyqDoalsRt7PGEiP7KjLdrO+vZc7t30n8bnNag/yewVr64Vu7cjhfjF4VZZDb/P1VuaNxaL8FAiK21SpmdAIpKsc8FBTZ/736O6G7CV2Vy8nh3OMvKuc17Ai3zCzunZhx/h4w0CipyDZIg61RA4Vg28EsOmo+lpvXnGsVzE9Iup/nK7SGS5V4aayErFfKJJzVebfI7IXrXoPD2yFHnYQXALXXefWU0ZtzJVnvGLOBoPM/cKCTUnd5o2GIjJtFjCymDbcTkd7peO3Yfw48wx9yjQObVaYuj1OZ3xt81Dlrs7X6nDEPwhTU2ulIwDVOpeFKUKq+dJzC81X1LyOkWb0sf8ym8JrJEfj4nQS9iu5gmMFuH5lNfKg29qOaxw36NUUHcwtN4dwx/ewgb6ehhbEQobeU3+9AwuXt+G8ppomE9sDZURVPDhho948cPufE7Z6HXbd6ta01Gbi/HdRXgNBe9cBVOv3tofH2nF+O9tkF2DNGlU0Y3gk7Z6m2elO3WJYZId37QAwo7EcFCBL2zef99Dj90Hs11/8ZX/LKjHPK4BlmPWP5qHBkiQawGWOCSrogvlTvp91xOSd3xMpO3Ekbr328NHYkQNBQtbtdq2SWuyENXrv6ytFrxxndKkHrd9iD24kdowykPuYNbAag0ijW6uCnW4rchhd7LQNLViorG0Zy7VmPUeE+oNUGIuRWAxljzfvW1w2sqrU1DFXs02DTbaNBmP/vl722n9XXtpavoLsVWjsBwgp6zwruV+vRjBZLKWEVShU/X6LVqXBur77fylD9cv2i399VEB9f8ZHS85w7lKKvNx9OUO0ZjmkY2wLXXwnucwquuu8DCp89V3BLAdJ+Sfb+15Fr9tHXbiS7yumsczzU+Q++tS/fzqBaBsjy2aWMER3o4p+e2o1lGmL+VhkV8GW97FPO5J6XqIo11nLCSZ9ZEXD0SBXi+K1RUVUShpVPF0bSN3FUKHnKVcdFFN2ZqaEYm9fzynQNx89Y+z6c27mMLOn2N59BhYKGGFIuhMhVs89zGKhqksBpz9duGUva6xdwaPPvdwiyvyMDRwBLlk+ejm70Fr/GpfA1X+Hu9HnnBWu8tZHpSjrFEeUahNc7QBng2jzfm6L9DnCmz6LqNlXS0FDk+7B7G25VReUB6G2oSkU7fyU//dy4i3gyeHpPGqzh9ZaTF6XdyOJ7oPvLlLpjY660HPvIzxmDuOYdldkpCCHxk6Stf+cpTin+P+yXKRVWoOze0lf5G5v42I5AXub1ted+5amD0ug3BbcPTuN0o+FyqjyJWizU3njh1tdRD/FkQ0U5CU1lViiaG60TMDMI8G2GU4Lyfvx6FG7FFflrwGLwzmDQKjd8EZv3lqlsyqDIxj+GRDzGU6Ghb+eiUwk6QKqVswQ2d7A1r0c8dn8UMd0hlt00fmVmBLASmwrRkVZRr/qd7JLhe2332eCpJtcSwl0KqAXTj40av0W/Wp3XbSkTlam5Er1OEf0KEjq33KuQtjHrD0xxrn7lJLxQtetzyNy+v2Z6vdeyFPFU826utNff6am7JQGupgmqNooGVYgG5gI/H1kzbSL/wh3tG7Du6xZvdL+NV+PijH/3o1fh0qN/QKoU4+b0xBlM5Nc9j2ZV97iZ/Z23MK8FuCbWGUbnQ8G5DHO+5ZtG/9VGGvI85I0GHunmaxtbw8ykv9kxyClshn0IJMewQquMu+hs60x2fz3ue7CxkG3LGKFR2aEzWie57KyQixOtkMUi68CKmBK6+nKPoTeVqGeT8f/rYh3ipiLYrV9grBjMOmlKe34Ry8qqkgeV+O9Qj+pVmCmbG0fsbQ08QdF/1CLerrSKUqbdS77fxjePfCMo1UdDqz/Ux/GKMd77b85ZXGrPz2ghQ0NNntVBw5dOO37Br9BogFV8EOLyX/C0N5XWVs8rE0J+8cKqo6579JjpIC0GDhlPFmGeZEjdunmIKIRsezSjsfQbxRSDParteozvyBqocaj4dqT9/xyiMt50MJXfRXF5454FnKdikhzmBE/22Qbb/7Yl5X/m8783nuH7RNl4wv/PcjMJDE8mSNlBd9QgVg4ToqnCZvx/72MfuksRz/HWE6CyWlOG85n1nqhsHPBFxbwhr84lCt1206XMngXPz57oUpr/R0MRgMbgxwn6z3ft9PIGCtMNuHSecx5AC2L8xF3NK0p6Y2iTgLqUT0cULIS1DB4ZedOkL51lDXQhGvtJw7HE/5BXFhyHHaBBt4jNLHCuxHDrm5WwDZPVSY854uP9EI9Ya5KVOi3aON/q7ToYsNFqtrx6EhiCQlKxoDAvnWq66Y+kaesOYJlpbm17SyVxBHrBgrOsEdhqDDEFrIp3cL6AhGG/gQx/60NUgTOWQFYgdXzKg8nd/93cvX/3qV6+egRWPApOTMXiyStAFAXrNJozfzUNoLS3ykO5dt0NENT2znciXX3fO9mSQnrmnsFHivBSMBG6jYVFOMf+Yp/OLxih86lOfujMY8/9Z+Fn0QkwpxAkzZSjaSBMC0oUTJUVYY/4Se8Y7aMJyu5hAV9qErco0L8g4dYjf8ri5jyGiykcVFp8zYViqGKvznetEUTGsMX/XMGOUwo+pRBeGUUSLu6pCg2HIZppVHwn1ru5K+VtUkALTg1NpW1PuxqD4b/oOAKhMDEMZrjJU0Pv9DF/XSgWyy1LjkXhAJRL9dzjGNTl5TTtcaQmsXu3MVY/NZmGBoQgN1JYHDbZjto/k2f04O7TX75pX8wnlu8s8ABG91RMmaDv6o/UckDhrNsp/9EGGoZ3gQy9BmwBGsPNo5QFb++6vMtag6+FKJ+Wg/qV3zZzGyWPQiMnrJzrvsGOyphf4TD2FvYuuzzdBTtY2hFM8vN8UZimXMAZiGG3ig+UipuVu+rzaTbhT6KT7x/B5EF6nAuq7XeEjAt4JbIWk+Gmo2Hh9wtlf+0jRlRTTkOWFTb/zt6c7RQPLdacZ/qltYx5SVek3tuh2cmWNC4uaNBSGdfIiW7/GJV0N9e1xikxFaHoz0SIeE3FvhXwKU/U7Df0Orxh+KoypTEw7hRLeTR6am4JeP/72hBK3526837XN+Pc6eUCucTQqBNZ4VDaGwordmzNo7M3H8OPQb65t7fXqXFcjDRr0Pg+IjAHoaYtjHNro53PDo3E8caowal7v4O3KdxrDLZ+bds5/A1RlaXunW6ELQOTn+tWD3XzQPc2Hfv7zn788U6NgEspJVLFzskZ7kCFeK1wKi8z/x9KHtmeBqy2evkNIxiD36Zoapx17lrAaJRHjqVpDF6x7GCbbbnKJtZJdCqfGSrQRMumvSk2FXyzWMNVOqhZrNGmWUOjmNv6KB5qDyn6HdpxDBsjw4Kb1vDq7qFDbfj7DFlrHlxE4IS/j7wpLa5/CrnWfbRg1TtHjFAaJP3TPDeNcBWopNddxhyoNSURf5UbPoPCK4dLNS9Gs5qmxKsMNpFozvZiUiUpYflDeK/t0T87J4NeHekSvNLps70kj3nXKwkQNRm8USWhdkgNlT75obBZavPSAkY4mgqhtnE+FBAJJeVug4vrttunl2p8q0AQDeWMTbZnXrNNP0n4qo5CbaImYCiSEJtrairWm66VgtyForp14YAogl3ITdBNqK2AFbY+h36tYUwx/Ul97IVWiua2Vx3nssEpGpVNIaNNHFzr0WiuWXMWGFQchodCSNItWO5RySlhuEKASk+E3urOJoBqTBqqXcXQNQQhSLy3kKL0MJYk6uy6+Lba8+/I5BT7nwGqOPrNNP3m3Vqg1n0BPv3dTpWWr0d41FMmKVgU+Vuh1mmr0kMf7bUeixNMqkY30XfsdGuyIkAFu/W7XyuuB77Lpk/ekhyZI0xDNvWZ9OkJ/vAQ9LGkoHziXHdbawO/l9QTHaXqHGldDcF3n/6WFdLcwQs/lFP6JD7pfRmaXyGakJ+E+uufjH//4Nf9SleczNwoxQMIzg+ykxIRlh1JOSH270L1UEi5YFj40tq1qSmgrcg2OSmcLmWPTgIm2t7snMlCY+n3MURJNBbRd4e3C188OTXlCom6ryW+9C0v9mneGW2ExzmriW4MrvTZtp2lQzWe49tuj0yjqgZXsd/7SPiUtrefaUch6W6JehW+Ht7rO8TR+Q1EbbetpxA/JgHy9kfb++25hJsfl537vYX7K3lawvteA6wE4ruYSDZuLecHyOnqP8Z6l0+Zc4oEtL5vPlNf9qkKxe0Uf+TcvpO92BMD36p7X1xHselGtt7yvNx4NXDuVvPcONGfADRPLX41fHaP85IEHoItQpK/3htVnfvZRR0OnhJpYG3p2LPBkFLb7G9PtOPFm0r0IDyH63fZn253f37kgjU2r30ulczJmGbJ5zXdDHzfoiH5r20Bs4TUktJVsyEPUOQxhAnnHv6N5Cs3adq/vfqI1BUZjoxKev1sRNuadqOv6BH9vHFSpbfSV8tqe5UaCOwm7+3PdXcvNIycFnhGWLy0k2IrZ357WOR4TrDhm6ajCdl1PylDaWx6795oUUklpupemqMHe3Kj8eqKuSFge2J6JnpHAxOKKvGO9yppr6bg9jn+vpTz40jrFwHXa+sy/J8C5dZLyYVgtWRRs1k6gRU+wNfEAv/2ExvTFcylJHY8gS5g1nVZ4Y8d+T4hnmsR24saIYw4VmDE0F8RmvPC0MDK8/ddExyrazQzN19DXRh/zcid29w+9h+osaXvIa0hJJIAhCucZg2xkHZLoOQV7XWKyBL4Q4dBohC8mVjD0VkQgKpEd5lCRbwEofNWc5vOQaMcTiKgVxvoa9JhQjNvctftgROeqQUsJSt/GtDcKNh+PtJZvChluw+vYm6OKPN7sGQHmKzaNt2yNonaTqInpaGpIMuOpQhIsZZij1emwygyhx6G3D2D0Rc9Y3jIWUBIUJbu7wq7cgeuop2sfyVPf94S2qtEyUBN66vnr0TQ5eHQLkArL9V382D13OFB5q8+TrorWhid7JkXji49cqyoyC1OWr2zMW392z+hWbu+ZGoUUZEyroksBxgAbcVu2GSP2exOpu/52I5uIIAF9GpmuokxuvFp3/+QBSFAFVqWYYdvejW0btOKaehC9uo8KfaMe8yqirx1rdPNZY3VsxkRV1BrMvt/Gc3tjJ7Rr0wOIFntuzac5pWB7NsXEjKWPhsk+MuJ7T4mntxpOSKBF7xr2+Mb4fjSpyGEfMJjx9VkNIraN+DeSVF7aod14DIGZKDXEGD/t/n3M7QYhO7SYMtohTg2khR5TNZhx1NNQxvRe9yFv8rv3yNDEj6L/0HAgwH06vSr4iG7d1xLnmd/8Pto/WWGr0Hz80Byn+dhd5/qQ5yKvpve8b3qi/FRVQ+3B2OW6AphCr9FUnm6t9snUz+whOw1CJdAAzczHBBFCRrN8bVtcheyh0I4Cq6VuTA+5ojuBqhJTKW4GCcV2vb/biFvhVSGqGBPs7bVo9TVqCUNGSHfQce9xncJqCb/Cq8Hc4Q1DD67D9rA2ive3O0SkIfa+J2SrUZc+9hF9TJbP9Zvfel8yNsPuuB1j9DEnY5glD6GWUHe/7nnKHXXfbdTkTWvb5bsdjpG2GnB53IotgYfAIuXSPbdh7L67+q+NlMqXOiO+i156uAKS3reGel/m4lKcVTz1t++3nLZmjfs0Vg3Z2yvn2Fp5Ltp8for977Dq7nfrsWiURzBzmSTxzK9Nl20mNVfXWm+9Jc1dux6D+pO0n7okNbevxbHEsE1CDSr0kFsZQo5oTbTyzWnjRlVNI8MoSCdUsRfSVj97c5WLuFGrC1pYQaHq+5SCG6p04WWS+jmNa8fXN7LIkOi6K1hdoyCoJGTS7rm9uV2tIy0eok10nCaaa5319KwACcEknM65sTcez4lScegl6U1Ov1OmqELMa3Dj5E7KZiym7ZLF7tV6p3DzBtqkp3fQWqXkatsQ1/KET0bUtU3WmrfrcyqMUCGpbDX426PLk/LBOnoJW2FOK3fS3EwEB/bk1fiwnf/RVLqEjmfdhr4pSU9FUAfNq+eGzKvDJOezOSzTNTB8s6t4Hh1CdCcP25BcvGTV2I58bB4v3DUVQrMvq826GbddtNHa1K+h8u3N9320KFT2XHY0ayVV1CZBEur+ziRzBWehRE2GhQyBuENThKFi28kxrafEUoHtyigFKOW/BcRrTNbWir2raDrTSQWkIm7cO24ss+0qCNFGbRuRoZPz28Yy+qpoRFiiEF3tjapccxXVRn/TfHavXoi0dI08ssK8zjaA5mxC/sXCN+qfe7XDdVeBzcv9H9LUeexkpTKRAjXMIyo8eZmGr6ZlYDJQ8nG/bc7TNsgRNJwOPJRf4vXu436IkrnxqN5u61LbivLEA4V8t5HdHm5KsoKWHn4TWla+us8ouwkxzt8O0mze28Pb6Lp5e47QS6tMV16Q/1XU9qV8KluGfeZVvmPmNsZAj+cUJt2FH0YcLAqIB5qLAPW5HJ2diyuxtVy5oDsEYixPwm0FKMoyLFUSToWlYPqqae39228k4kZcoi3f2/ZnO6wR0rLSw3GevJvo25xDQnuMWwilx06Ob9QoHWKYyl1F/Sm17W3Yl/3LwCKiU2jOtbTPHb440XgXNHj/+Mj1FYEX4tFD2KGSxrF5ob42amtd9mMyd2hoK9SAgXI0/y/R3xhUnBUc9Lk5nw1ktozaNr8FvDIEDynKxqAS0ihoUEXK23ipvJxbXsEoyFGaVTpu2TFKMIagjWudj+a89fh3vmDLxOMFkFyDDUh2/u/Ek9sbdc9Rh/fl9cSXD9HOdW4MJ72n8WpN2zv1zI2COwS1ZCGsMvMqxk18J+cEmmS1xRkIBSnXssTfFk4ZbLcYyftqcGQ2EYyum4hfN13LPE0lOIuhi3lS0AqJiiu05BHgjW+X+BmeMBatwtU7ke4m55rLVpTRbBtg57CNrujzod9sg+KaCC5cW9fEfhXWrcgVzvru/Rasbew0VM5R3pIvm9tGe1tpd59QbMBJhSM/ONauN3yqwhDVq0C2XO5nFhQaqm2E2b29l/yUt9i89ma26O4+lLyj+dvx+4VhM4KFoJpviq6D73zYkXPUOG7vYfNV43qVneDdWxCXzCj37meRp127Et9FQWae3k85dq9HhRPTnycobz0iQIn2Qx+PAHluZx+JCE7NxU4wNjJWWDaS3IKc9Xb7eERXmYawY2LRwrx03bZyN7kZsZ1Pi7p/J5Kzeihm2sdbW/0iI8U8c4+STPt8fV3wrYB3uEakrtLLsJTnqYrMPIKKeBtxK5pct3JGzbswhDmDHZaZ37u+KgqNe+t4ymVJ6zzZEpEnHtUzLIzWdSpAPVJDl6dczPY+G7NKcHsdNZX56QQAPW2Rq/yZsZP344nTfhOrl3boMvrpURmuka+lubx/MvyicA8r7GXYJOM0R1eUxO5V0tSHE+113uGhDRqSt/6/TxV+c22067cWKGxg4v0En4HlPKAxehuA7fXI62nt6qdHDnSgZ/cWJMiveXs+r/m5ho8iWG0r0eKUp4qalMQWgH4rooooMaLKQmWz+xTdO8a+M0wlAt9ucwywa6IVvv66iCp7jZyC5m8VPveAOBbDLQlDn2/EnDDs8ExMu702Gbk+7VtUGO2396cCcuOSY3JsCp18pXcyn6Us9/f+XuFPMOQ9ebM2vzH5tj0+vR09rN2H73dIQkWxwybx9V4j+cdxa1i3MZq2AYChkq0oRb0aIxWWnzu/DeDkT70jD9STxgEs8xmDZKNTpwB0CrJKUy95Azxlfq9FcxYUaKzkr0frM9fBtX63tdjNPve6a/z1rlp3DcjOQTW3TR9zQz4Z8rlUH+2JbyK0yL1Udi6QSjelIOLYxLOuWeRi2GIbBkMQOwyxn3Cmi7mNgui1MZwstcpMJKqgWUMt42lsVJA75ryNwg5LdG8Vg217FSqPE8NrAE8IVkZ0s9E2Miqr7blspFV//d7Eat9nyFvXPafxXFpfeWKj6V2a6Njke4XUtVMmdnjN8NBG9iels3+7vQvBhb+XLpsOWzE6rh22VP56+ZudqK0P5SRPbldz7TG07iktq5zyDgoXbcQuXypTJwO2+Vteljc17i+hf075NK81zHTyTE6GW361hNrr1Bfx/y6PPslh862oJ5ncc35mRsHdfDFkqDNidt7KfKa12slPXU0XcV7GuItR6ro3cRO4p8VVgAy96OJtQ+FJj7qJhZg2So8G9p1Bmr4mmVSyeM9zM5wJKRVjjKYXMm3XyG/vq2tF6yoAD9iTmR8qWex9YzIWvZOsVqeoELey26i0MbQpycPb+r2CJt29R/zSfU4707e3G58pqHoH8ZolrX63n+3gfTRy7l1oXU8hHtHlBjcPlWF7XbQIOUpzj7muiKPrNo22RxC/xa+WYLsnpPN8ygeUEPYBUdtDmpZOMfG6DYF06ZoTCDKHsI3sXv/k41VAiDxmSEn955gb667mq+qyDWTJe9dY2uzadN/4w70ejsfQpwZ4WqcCzD3+/b//95dnahS8YRPqoSkb5aY4TdqKZlWGWn9PE23Bm7SIfisqwxx9JgrdLrSGYl4byaug9Vq06tJAJkpgrI/PU+q39rWV9i73e4gppduOh0vjHXpRwEQPJ9ShQtN1T+lu5LOV/h6rvHI6OVYEXtFB3tZW6u40Pq39DkU2xxPijfa1nTPaBncboc3LKSrde+mvYtrhjU2nvb67X8sSRfZ61/KrY83j2t5N91Hx7o14ex4+zKbrWqNRZqMQzc/UtqI3oS59Tkh3I3ir5pynJypYtLK9s3cAa9vzc/3fzcOrmT98SCb2+2nJluAmfg1om8/Z3oqbKoeuA0zndQrnPfNnNIc2ReO1FjFG3UIlypHxTPp0DxGNCHobjgisMOmm+b2xfhckgd5uqYuX0tJ93V6Qr+ihUk04TiWF9qcS1iAlPDFd67Pd1c3ICtdGfzscpLIxtLYNQH2Yq5BWzkeaWa2m4OlFbv7Ya3rKhWzFJ2qO9tvAb3S3cxFb8WiQ/d4xPJQINByiEZXfd/4qIKP8NBc3YVnGmDcdH3vPDNBJwTtvQ0oWPdjXNmzKgnslOsROQyw/mHuU3htsyOdbNxlRUBYrPgikySMa2B/dJrJ3vH9fu8ewx6mOMBqhTDp2IxjKnzyjgdhyEcAVeKafx0vodOufpP2pPIUtEFaE5Ipm1XTbXHgF2wXYCLg2//eAsYc8DSsZCo/IKNsdd0HNXTRXrbHhKjeeqbgTRJFVfRU3FYnILMYQ+01jN9l2EiqNgHTTaMiAosldphcdtgewk6LRrvtswVX57xzOTqjv9TyhzW3E6t/1396ENFTwBRdbgehh+td7OF5p4v3dD6GntTdhtm67KGHn1rYCdgyncUZfvZ6NopPLcgB7h7BhjMa7j2PXyHVt47F8VaMmaNIzzljVtnGUb+X55FakP5+3B6BH/moALQU11P2Yh2j5/IR9Blb33nyZYZu/8Z3h3a17oqP00RtorvGI3rOG1FMElLEpfZ33z6X6KIXnCZAR1ThgA+t8+41+6yslbUxwC4WEl5Aqb5VNBmoLlcJ7QtGirY2EVQabaXeLFoa5GrOu/nY/T7QuhuhTt2zbw9k0UulM2zTRkCngD7nHJ+Xf+u7Qguuxk+3O19CUwuxZPQGNxlxTwDXaxfpF09J9h7+2UdgeybsZhd1ckxSLhk+ltT27eFo+2wrfsez1t/hCD3uDEPlfJbOfezzXdzyFYGYbohPP2P9DBkse2bKj4q0v1851E2TO/TKGPQM6XtrGvjlV4pri/9Etv5Qvc97be7P53Y42JBPNMz6WjhpgjY98rqE2CuM6B0i7tnLx52IU9kKd3NGNlD0YbKOOJrmPl95MvcdgUk4i6NrWv7FKGbT7xGzzPjS6UZnWvTkWytqKMzeuMTiHrRxOAtb3IYSTUTi5n3pA01R8KnSR9VY2J+HeSGj/TQD0FBP0naNpLTbaPYUHDEXs7xqXn4XCXSNpoFFobbZn2Lq2bntcXbNBwab9Q4Z5r/MpPNXvNi1O99tr4+eGVE9G/iRXelTTPPZi/p7Q8X7VtsfaZyekq7LMIJ68EF8no2goynxecr+f7xBfuCfgLTxnQ6gnGXO9t/IWHOmp7Tk4/nRNf0881VrZ35Zl17N1jHef2z6FLE5CriuXYsxKpSjGfev7HfMq85730XUqKZFTbp7W3DJSFUd9ihb0WDREMWfu/skjiFFFn/3ekFh979yCCu8Uq7fCaCukjdj9bF662jVRR6iosYnEd7y6NVWRJyR6cAmiRxgbemgezdX7CDJM6G9PQmW0wxoZ0EoYLYc90W8+M1xxEszWeQumSLU1EHAITAIXra/G+XTv/i9tuucOCWwP2PCCAEalscMvKo/CQZ23L6/ovTnm7W302c7FdO/CU23IHJnXePa+vgo/6zk0joCNfL73kfRSNwiwPCm1ccqT7xwAsGsiyNkAQtr4uw2G0jk7zHxaX41Ubed39Gj0CvKYZuPcMzcKMZuoLDdNwjWw2V49rksHwyX4Kp0MR5a9re0qogTLcZziiypcwzciiATHeuodDtguoALW4s1Ydct3jHUjApX1Zr4EoJptywdTtCfEuwVV9NgDZGacJowfmuc+iVRDsunufOxDhbWFbBuzaXsu3t/9A65FRsl7Xhl5HYuhkpBWxYmjg33vHcW7ndBvTfCy12Yn009ewSksJB+JGKVx3s2Wi5Dx5jXHK+84P8fk5/vVbz3GwTN8HIsx/1mbMUAq8XRAu3b7bodiDUdvA9V1egGb/6Jbpc5eu2Xp8doUm3Hbewc0yoYLG/tez9r0tX9fn9LNcNoOcSaj+wiido3PQXuf+MQn7g7mfOZGQZdvo0yZKAK0SFl8HxKz0eD0OchkmMU+VbwbDXkfF1/EbhhJFGfC04W4EmXlJ2oJp15FY9nxcpWESMHvTiGqnUifttF1fWkETq/GV3zY2Hxz2eOPrhYM7HHs8MVW6N5jG5YdfpFeWxg0CirUPttC5poUxhPZ95333uGGE18Z/pm2PSWF2bXxnoYud+noRpcnw3Ra0/hle0N7rjvMse+rQjvlJeTNvd4pID0AjaAPyfGoEHN3Ifr25wgMNO7xcXwkf3lMxCkn0ZyUS0NGJ5D1eNG3/29gEN30vqSrOYWtp9QD3duxuJbbGKs/6r+ozBiDSTB3JHfA8pkbhZ4ApNsUc2zFrJWb96PwS1CHflskEY0M6l/dq614RRMyup+5oFupbZfR50O4kSQPo/OJdqnliWkMb7k5yUqiHR4pJGfJZN9vZunzjdC38Eavjfy31+AcTkh/o80NBDaTb4WnMdpoXGPuOm4h614hvcbteUgKvMe8p1w28kuYWrtCUpYNqzjlIZW94xTVSp9dahhtTrzZfLd3lBx2fxWihtO114PYm9/q2yIN30crad84Ou3TJyrONRMl6JGcAb499+493ws2pev2rOY7y4p3NZQysfWV5bGGj7bxmyYgmbb1netcjjHU3rijUd5F62RFXePyPuZbBEBGGzRmbVAbT22MwM/8zM9cjx0fo9DYZvPcMzcKO/7l5z7A2zCKhGoRhzlCFO403Yh45yr6a/8pWBVowrQT3IWgJG7/d4OIin3vMhQtqlA0Zvvxj43ZhLHewQ4tbSGQIdpxvRHspo+GwUoxBaT+VSqh537TrlTzOAqIfUl7lb4KqWv63c7D1Pc2CH2vQvdI8XntEz7lP3MT3UNe24ZnKyR5tL6nyYd6b3otgpSNZDeNQn3mwTpd09yUYZLtyXg/gZPGTdnTEMXTp7i2O+j3YyGjb0dW+GyD02Y17733h6QEU/gaTkHRDhOnh4xGCMBMHG8wJs+8BS9q3De9XMcqmeIBc6mbxnoW8mvru0GzOQWN2LzGGxiv4Od//uevBqDDNNXF5YYMwT9To2Ac909CrQqJQrCRqwhLBSPRDWOoFFvEHc+PUXd56l4IhfGEbo3HawxnnB26Jh1SVlbcONcTcu77aNezrne+IzqakN6KxbaRhXTf4QPbfOfhgxtxu6ZbWdb/KZ67PYtTOOMhb6hxxtgZFJOOJ9pG9x1O0NA6jo3w5TN58cRvW5HmJTqfjK4eROMVIBgOMLSngvbvaR0FWir6HUp1jZRx+d0QTfyRXDhHj2Hwwffm8zI+RgH6vcpvJ4Jdtx0ZECzIL9sAbwXttcrZtFMEoP4fWv8dOZAfdxRBGZy+9n22bM11+5TgMQLjIYxBmERyJcWnkNQOpz2zRHNMauuGm5gnZNZ73XRjrCI/BXC7V1tIRZQq9JT5zvBvlO3Yao5h7u/YtmvuvE/7JKbtigXpF8PunIJjDp3kdShE72agHav30wgqsAlk8xJt6xHt39m/7rzGbyuw/Vce2rTWY9Dob3raz7TtCbje9peRERU2Bs94Cr3uvjZ/7XBS6+ua+DopFZWCaNzNVhpgf7tDFzuh3lh35U7X6f1vhJ3yn+tNGu+6fkMg8omyJN9oFAzZ6aF5jTyoInasJ4Og0dPgPVm5nW2o9xiU3ROgSdmnWyy/FxBlWPe6t1atp48kdVNoCf5t5B3TczEKop+aAiuCT3HJrCIVhcRF1EU9IXvvqwWtWUGyFeIuVdxCve+1x3yqgNpGpPmIgjR4vUrM7br+EqSOzfn0fs9DBk2YpIEeVb9TccvwMajr0lg2Et9Ml4C19vV9Agr185ChEqV1rWuuxxT61DvbIEVQUR89zHyumfdt4BrUZYm0xzVMs0Chvna4yR31IltLh3cVzU5Cv5uH0rhb5+L6VtaJwE/GSsO95UVZUOHL672c/8lrcwzT3Gek99na7LCnY5rrC2tGi5143zKzZVZ6Gnp+vO61+98gr+az6QWmhunSnycA1zXT56D/4b+evzD/NxcrPTdoEhzvkNlP2n4qo9AJiiojCanlLY/gdSGRCHpy7ySYTKJC2cp7u2n+3Yzta1t2CSuT5q41ZoXpJCiish0+UfGVv4huIp1t3UMZxtHt81S77byivfTejKTLaWjuRPfT7w0z7WSb62hfro902kpgr6sGqvH8SQhT+jsP13S8gBnvJEgfMtSbl6Tzif9EhtFWPjgBnK1UVZYibwHWzhM4ZsHACfzoEWxg0f89xnqHa2ybxieDo9xJy+0BbHS/vavtTdnH9iRU4jvhvfubtr02Dfj26k4AVsOp3jMiYBhoP69Zed8hpYforSFo7ukh8zrP1CjMoDaacZIOYAtSKKKmYhEZb4XfgjhxhdHF9nPv23e+tsu3FZTeTMhLZvNMos0E/d9+neuuaBGpNKeNxpubFQl6IY11K17DCidUNr95KNG7PYbo5vfTMpAaBb/fNNlNBeT/T2uj0DpH+WMrIvl1N41a98w4xNdbEXWfeHorLXnIOe/8xLSqelQu28Ao4O8Whtohjm0It0w4Nq8VaGnwT57A/q1zcx6nkFm/zXM4hWWa71baez2c9473bzC7D5bblYSPlqftGGqOaetDf28fRgZ8PvNUCo1XMOGhMQoad42c9Pa+lu8KVAOyVdM9c6NQ2di0HWOMANZ6i7D6zbRCRC6GjCXRPS5BgyITujhux+8eXa+QqEC3IRJ5xXC7cmFoUVy339Tfrgbpeys7toEygboR0qZ/dBG5yIAyuBUqO16rEtSl3nFqj/HVWJ6MnOhXlLq9qTwwn6Ng/9uIKODulYmW1r43Dl31E/LeSmrzy851NQ75KH7PQ6zPU1HBtB3y2oZ+o3zH2/utUFVI+37b+G96yBOGSZLXrZAM521EL++JrDcQOHnPrpt8EC9UvNE8Rb3xmny9gZjzrMV/hXEFDY+ZZzSp3Ll1FExYFLDBZqXthYX0CEoUd2jdBs3Dw8qmvO55VNI4uUiW59nMk/f5xje+cXkuZx9t5owo01IeEmW7rFuhZCD8XiUVUYYACp2KW5dxG44tMCd009xEfSqdjSA80Gt7LXsutWghunQsHgq2Xf0T6ijJV9/TNHQalIS6PM8WkI3SRd1bMZyQvAp9mt6SvOO8tnt/AgaOv9+e5nhS8CcluUMA0r9x73U0Fu9nrmm0N4TnMdOtV69KZ6W3Jbc15+e4Hbt9+P8TOjcntRG1Xlbz27K7QzX1IwJWKeoBnEDZRvmNN0MbcKi5n0nQNi89jW0w7CvD5UY7vau3OEoiABIAM1KQ3qpfT2JQZue7UfhjBObv7Okon2jpuvrLeez8j89edq3rI48g0Dp/52l2c/2ERJ/LKakKXYNKgXeNIQqZqglsBbCrFeyvxWqhZTwVn8kuhVUFZBMVOM4TSrffxr4Nkp7LCeWflKffiXakozTvfht5NUYFTe9JNH/a5LONgmuzr1Hg/NzfKxQa+DyXfY99fX3v9Ys2KvuHxrIV/+7X+59+uwGE9xA4tJu3ROBGzfJTr+agscvTUnGfaHua20bdXX9C6BsoyDebn/xuz6N77LCInoZKTvnYfdm2gX8o96hhEtXvpK1zS0lnFEwA7zWZlndgibne9LTAo0ahz+OPjELPNVB/TTMsp1egPogGGYR5yYt9N682Co5R6El3nm31zA/E28okokxTuW802G9kgm009nUtdAqtR/jtyooWsAV3o9y+V+8b7646UJh2bNTjnHWhPadHRaIA218KfnsgCrsx+vqK0Ry/KLN57BCSKFBDvo2r6FpFoPGLB+rHuPveZNNvd/x7G2xR7fZwTtUTG0zU5BeT9w/x2w4VOM7Nj4bmUiiFBE7VPt5jh93m1dp5kN8Oq1qO2BhcN3l4Ax/By+ZngVsH1Z1CSxYLdH+/Vy62MYg3ek6zoGfTYtOrta3sdeuIvpdfDOONEi5Ek8I08dpnbeqSFi/zuNU2n+3yVY3USe7mN/Nql7GnB0/zQD71neHQjERVTYJEdVv0s0/3sMwc5wy6NhM+l/BRA9yWvontss8WQe/BJrN1j2LdG+2kKGeComEVQ8IpOt4MJjFPirz7b6U2LSHeY3sIaW7DpICcDEZz9DfOf3thomjR255T1xpvVRG6NipiE3JboD17v/7iDcFAIcCUnX2dDFZ9RatRvM2xz7aCUvkm2Nt4bO9weyaWdRpaUDGfkGz8vfcvqEA0mO4LSPEaKonuhQhTKPPbQiUq+12kcBpnctv18tAOvZ7WWjppxA2zPiQPNddtI3R52XVsHSwPjj8EJHlsJWvzMFL8hh/1Ivb/XzrIQy1apYMmLCNI2mHa1tHc5DameSKGzPQWUupzr1Hq81dA1tp4lE7XTon1vO95Cs9lR3OEUbh2ouOE/CNCTQa03/3/mNfvU9iiYe8vMt5hh73Ip/s7jhCniPbdPCAVR00FeXKhd5+n0I40FAHWnwK21yd677733LeS6Nqd39jjcD66+zvEsw3mSSk/NH69lu1NbQ/ndK93W3PXbpBlsd7Qs/zlWrhmekC7AGPzS7QSWXeircZNL7E1dK4agBONNmCbpqfR5zvEojE4rZ19q1D3WjqWE8DbaxDfbH4sNGe4Z4/BY7nb1NVcLOpIngV7jrX2+GAcXRcfvtNLILgNgJ91L4tF0hEC6pT8KPU/+qM/ulPw25v0+l5dW/iofIv89MyMggp3K7gTMoggm9AnpSVBTwZGoej/GYYdKvEwNJuL5YKfDIIorHGdKmKaxy496xqPSlDBNp7TfH2/UanCXh/SxTH3fivofQ9Rt+EF77H5IEauwkflUkLuBBY00Nvb3IjfsIjz7K/C2O9PvNP6hDj3PFISo1D0DLu3IbwT6Gls2yPwOpXZKf5ei29Do3vDoevavXfFz0b20SNEv88aipd3UYFJ4ta4SiB5xvv0PqW1PYiH9Ibjbw6G6rahtllB5Lia31bG9pGyVEafrDCVqL2D9HbIWDooQ8pFRs6S1GhfDqB8wLzmXp0f1Ri3rvVIEfVe69kptc/NKDQJT440HKEbdrK+G8FtZNd1DyEXGar7l3DZ/bTgtRN6qbmIe7NWLvtGuDavT5n0/x02OxlDkdtGGTH1vNztvY2UqMFwUkhq01MFvZF+Cs5r68vnR28PTAXk/YdvQkXNY2/6KyzS/WLgaKpB3EZVflHwNXrtBvW50NE3ReR3GnHP5nfMe+3rTzp6n83j8pU8qgFzTRX2bZSmpRDk8e5jQtwqvv07kf+E7TbvbsO952MfJdpbzxLpKUSNo3rB8e/y6o3KWysV8KalBse5tK49jtPwbC16h8ANp+6KsFrjm2snyevehIzG9DkloiWC5xXPWakm0t+gRyPgsTTTrF6KZtuYPrOcQgNq8n4uqjstQr/ZSuTkRZyQzA4R7P66Toapfw2CfW+B8ojr+ohRdN285wnx1lzMk0E5eVancI10EvXUp8ZgJ5638jmNSaUV/bcSnGtKfGU49rz6zf5cpkwpibbq32u3V7H5Rho+ZJiaq2sq3RLUrcR36NH8y07suk6iU9vJ07GPacbIXe/uoaB7MvCprz0uabS9LNegtTkhcu+zyz6lW/woj1mk4amvGXnlW4PgsQ4nxbgLYAQw/T4wIugKRRdiGYUffR8veS5slILWcGjU5LUMYGspmO2aQjyhfH/f5zMu98tIa8NXG8TJo877mRuFElynzhtQxDhVyrjgJicVRplVYZ376trFjCobXcGT8dgIxEoiz3QSCalI/UyXfSentoeymflkCPq7BSQEZLJbNKmCfkhRbUWph2J80zGYfFTIrL/fxitjtPMWKtjtvnsS5q6uqe+HlJv/ly/3WmkMRtBcu9C482kOeo3yqZ7D9uq2MpHnNz80TtfU49h3DD3hF7W272QrBeVnV4BpPKTtvr9gw+sNL24wYB5wg7vmZPnuNMukG7sGpL70kJQhq+K6f/ea/3fPfjd9Dd1GKY+HMCi9MMs7h6q5eGFoXrGK+YCujS4VCCivIvuS1PM68VdVQ4aFNAryk2uvN7t5YK/7M000n9pGcRJEptM9S0h182N4FdeOlRpCqA+VVzF8iV2zBEwhUsHKWLuMzaomlbZIfhuI4ust1MlQ7p23LeBJeHdoTbq3+G6ySXFs78DY8Ea2IcbeOzc3E6mEDCnunMQwuHHh+jRW7zx2yM3mPHcupPeNX0Oq8nUzkjXoejh9loGUX7bbvuVgI/Dex7vG9H1ex+khVs1pG7xB2vZ5kkdBwLweqhKShhr0DaREu1bymX8xjLN33cuT0mZXxGmU4pGTd/LQWAQVneCaYi8SMAreZyD021dv16Nx7ZfGLS+gUI9hrDxQCwbmb3sGqlTTs4zPMghWFKUX8nrm2hLPAqt4ykccR8eez/7ME81bKc8g9zEIGwFFkI2cNpq/DojH2p2QdX3LaCq17YZGqO2KN4fKxxTimNpjbmVMk3F6Nb42MjtZb8ejm2dcWiHb9ekaUNueqwbMtdSrO6HvrQy2J+ITzRSuxuraNd+qx3q/0W10dt1U/vvlRiWNcb8/rctpfiqmfQ+NwqZ1a3RC/e16FzF6T4GR8fdtWE/jbZx579vgqOwda9/pFT10n1N4Mtlp/4HrKvDRIEvfU1jDZ7wrGye+3p6s/ejJaYAMu/WqZLT5uO5v3oI0XyfPzcjCrhQzrNffueckjgUV8nhr2//NaTVP57aPuciYljtKxjMcz8UotDAb1cYU2512UWVyBSgl0csYuCGBE4N43R6TijolpTCKpvbeihbIJFdK0PGrOBRYhW6jKL2aTSsVaPPbTK+BkuEVbGnjfTQMjbEY6jYMp3BYIYxo4P1rp9BWn8ekKj/p4jj7/Q5t7eR035+Oit7rLyrba1KftY3yFW7XR+HVsFyFi1MwNQwaUWm9FXVz7T4qdAGKyFxZUl43/5wMoOu0wcLmL4+MiBetRGtMOywkjV2//bmKeo873tvy13s3rxqa2qEW56ueens9enUbOddHvbFBRvNvLO5tENzutXOe7mvpvq6/PK4cpANNVj8Xo6BClaAS73TWSW0riAj60AYvEa9KIlfbfIPKoGZMWMXgvXfTRfS4bJW5i9OYVRQqkq0o9m+j62ZShfnEBM2p37sm3k+Bd3y1jVJUvBt5PoSiNIYndL+bxsD3rrthlerOpau8sJVl92y9T2GTBMZdu/Kxv1EptM6NRUVTXLr/F6KwzHL/fitjDdEek8a03xjXnr8bfW6eE5hpGHZ/WzlNa/4+C7t5t2YCku1dzGc7jKiCb80s24xfiukXUkm20jHKugZ95xgb396Y6PevsgPZiMIuRbW/Ta/4wh3rHta5k/qNu3mWvzDX4dr1Pj6tumz6LUzVeI2EPLfNayqtbqaCUCGefu8AVf4bocrU/TZ3SBQmKhVVDpEkpEqhe/vdvHL52xBjjNeKhQReJj3Na1cOnIzXQ8hcL6brRMi+9Lh2X1sRnATdKolTWKfrdxVPc7XuXkFL2ffdNJXFXpPG7zpomHfFTSXJ2/Oa/3tI2gYkzdX7Nj9de+ljvLp57Pi4CqP/xy9eo2GXdhtwnYQ52m8P+MRTNY2iYCu+bK6b508Ar/XdY9kIv/FkZJNVT/H0eIYd5kmZmmAXRGxPYSfonX/fZ8h36GV7WDXlpPeGkPUsmnM6osomgYLrOzyhB2eZv/mJDULUt+YEi2TsE4PV1c+lJFXBe4hBZL7t3nWdCkFFso3C/k3j2IhVhdu4TotcXw8pkv3Sxe1Mk5JBJYT668YRGerkXm46PDRWm9epZDctTe4p0KeX87TtGHstz8X/bzTr2nvNDpNsfvF6wxfbMKksRc1+X39e03d6mA8hvQS4vEtGYm+QsiLGeW2lrsBnwOUt/7oWhiGlo69taE5845z7jWvQ/dvA505bFfymsffQE92K2h3JXTMy7FhaKw3tTi5L061b8gp9+pyAsfynlURbVp8cni++eWMraA3nvEL6bXbbnsWJdq211yo73d/8bd/LJycDrhw9l1NSG5zVQCeFtpX6VmKnWnqRmC7oVqJaY8MDW7GpPHeC0eY96nOunwW1rnqOve3ReNNHQl4NcwaiqgAfR6prGz1OqKdxn9CLCnwrpx3KUniMSTpn1zNEsdGngjH9Dh36XMRyMsr1dUI2/n+Xs6o4T2vWexGVLT5o7X1a3Ub/9RcNurcKfxsfQ0HbyCsPO6QXHRuvSmXzaQap7wujdS6TitUqudZOGswrRdn/5XnP3xmjsOXCsW8A0HyimzTqaWK7ss/d2noFI28T9qgyZ34z4/FhNN3P0Gx9x08dVTL398iLuTYAN99bMSTA++NbRb75Tm+l9yaunYsbNDUs6rEdWt4hyu4v/+oB5Akbft061Tk8l7OPumnCuFGWcWEHa2vhEsg9ga28t0KUoCaNZAqt664K6H4iiI3AjTfqas6r0w/bfJO7OkzWQmkgDG/IECpyEcBmlO21bOZqXluBbyTcvN8tUd3v9jEIGgv71+ipxDVuhdD6fJ96KeOqYHYSTT44eTC1EOLpSIR9z/rbrXv03QlUbE+mUNbOo+21tPa+7+srpR+63mjeZPrOnTROT/g08WhYKEPsfAQQKqN9Po/gZc9BeiU7HeAmv5kfSIkaim3MI2PzRLJkLl4KiJWXmHu7Q74w1bTWIznuuu25du2btwZLT8WwVn99yI3GYucwtkGQZvK3tNYI6AlZ8t19BDrbg9KYq/+eqVFooDvr7kR1Y7dAGCbqM5lIQdNTsH8F+2R4YtCuebe2haKWAtRwOJ4srhY9NClTbCN1Qr3byG2jcEJrNmmhAtmGyDWQTo0770+m3EZ/r8cw8Tw9qpMp/8N/+A/Xpzw5r/nNr/3arz116Nuez5Tp/bt/9++uRx5Pf5/61KeuAveHf/iHly996UvHNdvv+/9D8f+HaKiHZTHDDrnJr95XT3Dnf3Y+QkPr+rUu+wwfQdDmt+4vupzfDzquJFGjsMN7eqh7/I2xseywTUBLL+rktW0gpIL1WIloPfcZRZ9x7Ell5pWioRVL0qO+A2WGp3ZYyAqlOV9oDNX3b3c372vc42DSWW9ffXiScWUx+WldBAM7vKcx6LXB5envn7b9VEZh73rdg5qm9TKubJXIFtRpCc8WIBlPplNZGwZpcRKSrYy1rFuhOxbRVb9zl6dPMXJ8nk+kkr4Sm6dTpST9/Y5/xxAhHKs0nMc2bNtDqK9a15uINwHo/gyF2XBKv/vc5z53+eVf/uXr6x/+w394+frXv/6U8Zj3/+Af/IOrwi8+b5vvP//5z19+8zd/8/Lxj3/88lf/6l+9/N2/+3ev9P3n//yfX/7JP/knT8Xg5SHXcAMA6XTyLhTkFLj18hYPbCXo7+XLdrIGKjqGu9NXT/Fk2w6Fbv7fnot8Oms29/noRz96Vaan3ECvhypium+GxOPHTQgbtrDKRvT8UHjx5JEo93PP4ZWZ08wj+Taslz5pfdzk5UYyvdcdHcjb6IlkcxJpc3gHfWbf5SF2LkFelie3ThLQFl5r7QybzzUevKdHLlBQNrcxUi+ob5+5UVCJ6C3oviqcurmb8WR4r1f4uyYiGtfVQKgYLIuzT0NWKv+UoKEo0YjjFUGHSKos2TX7MsBWaL105zWgLmKMbMmhi+89pYH11RvJ9H6XDxfq2usiDTZdez/MPTmXeYkcNdrbINj/8Nbf+3t/7zr2f/pP/+nlb/2tv3X57/67/+7y2c9+9vKP/tE/eurxh66PYzHpq/Bo/JvrRlMCA4VNBG3fKv8EsPmPsPf83WL19blDYztsEI8ZPqplDCyZlN+34nPdDWfuA+CU2T4rjKIS34jX7yyyiEbN7eTRCf4MVzbP6Wu8TudgDs+cxI6tG21wbVPqKdvWYof93iI85AZNdVg6SCUcXewr3tPoZcDHC2odM2YZH3WKNJX2yvz+/y5eiAeeyympCbnIVnT7kHU8ueIKlS+Z+iHXawuCsX2Tdjs0VUsYNDgSTldfRa5wqyCc90PhhpNClWa+13XsdUIENQ2Dxm2Hknb/Iufeb/RhOGYntxUWx6ZyHbQfIhovYLyJr33ta5ff/d3fvfY3KG3CT1/5yleu13/hC1+4hpyG3z796U9fvzM3I2Le/LRd6JO7vWng/KVT9DP/5b1S0Cn1Ge8Ieih3x/AblyDFEEJ9xbOOW7S9UeVer5ohyTyDlKhe58mbPjVlSVAXms3gGA7awGeDvh0ii+fr2zns40U22JEWymu/6XhqDULjF+S+SX7gBAikxQYWRkrMA82aFRoLKLSvYPooUV0BjWt/8oLfTddsXarxe+ZGYaxboYUMgnX6GglLMxusA9cF3g853+GU7aI58crdssAlgLWSMqNIWMZp/J170sKr8EV6O9y0+5bxnesOAewF716ieZlYxrQvUZoKVMEURW4jpDJVGFJOxdn1thI4FXC/Ezj843/8j69/R2H+nb/zd655gskh/It/8S/u6tfnu9/5nd+5CsSXv/zlq0vfJqcxCoYC9lhPhtkNO3uvyEbTG2V2zUmhbf4tVFPxgQ9jV9Ftj3MnceWRadvDluanEOVGqNMEFHsDU2sbDXaYZyc6m7eeSq3wUdV68o7GzxCytNlPR1NB70dLnkLIG0EbZjIxnKfgHoP4Q0PwJlU6J0B60iXmK8zllCQvR+Ix8o3POfbaOmjP0fV2LbdHvw3Oc/EUKhETLbSRq3IyY4q2UwhiowkNzkZxKuEEMKWxT1W09VvdMQnodxoz5xjzppz3zsbm56F5O2zUnB3XDse5wKHC+tkuf675vC+0t119Y92dk1PfrtNp34e0a3witFzy+p1k3XgAKtl5X+VI5Y5D1/nsE5/4xFN7Kn7/93//Kjh/6S/9pet3k2iefEPKpWZITCVu3D5XXGFIIVcmuc9NEkTsENz2fhxLdIoermu1/9bOl6tqDCJUD0zrSIQdmlGWNFpuENsbubYnkNHaCVPB1lZ+8sRWov3WkNHOEbbOG0QMgi+0lS7ZiltELLDJCDgef+N7IwN6N+ZBnhyO1ei+5mgCr41xG33H2voKmkxepzszDg/pyw2Wu8Zx1nfeksBtR3SeiVEYJm0gMluEms9ONfEPWdv60vrpXlszLZptgWPOlPX8Rivv9bqiMkn32nHLxrgFoeseqjKyxl+U5fj7zEXaySsNigZWQRXhqeDt1/mdQgz7nqfXCZn4cg6nChyR917P8g7NJ+Mx70d5fuQjH7kzwvKHfKBCbL3kH+mpUk4xq7hUuqewmWulZ7zDECmHjMK8RJDd78R3jXPAzm7Jm/kwwwWCkBPC7H33ThGnpJTNLbNunDKHJj2Ut/rfvCI/ZQgzBh5Ut43YSTFGdxWfvOWYtjLeSeM992nKYYb0FD5+KBqhQo+HlX8T3uoneXx7s9P2fbZ+rD13ozAWvYnvjHloVSupkEWYHVKattFQk95ldIam6q+aZ1FAxJJZWxQRhIvtGBVsUYNEt68UmsJ6Up4yRAu2heiEalSA/e6hfrYAJvzSSwHofju09dC8N8M5r/3/7QXu2LyI2tLHAMj8ZiqSXJcE5o6BOavIqqlodyoH9WydHfeXR+1btKtScid7IbZ+Px5Jnkmh113qrLC2DlXWOGZlTWO2x7YBWGtniFeem+ZxIF6z+zG+f0Lyu38NxuY7lWsRhmh5CqepAA2n6iXsuW0QY1npBq8aoVrvd2h7K+edC92/3+OWVtFIwybY27Lnd/HiXrut/FtfvZBnahTanLXrqSOCCsBa4h1GqcmcMvW0rQRO+YUUyLb4egcSSmNl+KjfmfzT4KmQG1NM7L6F+X9x5YdCRi7iRu4qte3K78Xfv9NgGuba9Goc9uVT5VQwJ+Fxrbufikk0W1hHWliPryFt3JNonv//4i/+4rX6qAKHE71C/cZqu+cpjJKy3Qi0EMCu9jKGLh/YFGy9hXIHM7YSz9v7MDSlIdCgBrgct8ppK2KVg2WaFizsjWQmcg3r+HSwE82216Dydzzmfvb+kZ56Fs3aeGj4owfiiKYFezt8pJw3Nh9Y41pPazyPV5XhVuBdo3E/6ZATsErG9A70Erc31b22F6Mc6/kopwLd6eMn9RKu4/+Jr+Q8nIi00V0DcPEljKEElaaM2IImmBsVKjAtZLFBk7IS1TCITZdLxSrxRZUb6baww7AxW1ZZRbcV6Va80ugho6kiScg2smi+jXl7Zd5zI/9tbDfac5wa8gRorhk0PDXmIu2OZZjfTTgkvplrCw01h9Ztxvlf/st/uXzyk5+8GoVJQvd8cL0QlX+hKRVFCqsY8lam05dKukP4SpbO9QmwfLQNwzZ4GZEqTUo2bqNQP6cwifTeBtE12OEUK3RKrO4kq+WW7VnwofHuR3io5t+Xj8wU3W6vQ+9KUDR9CxCkh0bNU2jt37zGKWSkst5l6b3XO3nMM0t2/kj5TFeI3ptnsrlDWxvY2N/JI48ndhRkrvVoDT1U+Wf39cyNgg8Sb6In9N8ANAoylAdVScT6VBC26x+RNEgtqteqzE6v0+I4Rpm8e1pzrVcw11vqthdm93XyULZROI3Z3+o+bg9J+u05aBz32vj5Fuw+l7bzeahurv3MZz5z94jBQhajaE6J5mq13Sw0RqNkbch67tkhhBvpm0fQa9mKoTE3LxWIXq3oyjXc6yI40KMTYe7dxLvKaK9z9+j9yRDvcaVQe7nBrMdNWtFiJdLes5Dh8GleJzqKkn39SR5MY90AYMuFvDfvLXXdCeFtFHf46KRcpZ/3ad1eepdnwivLytteG43AqdrJ8ZzA2tYH2+BoCJVF9cQe157/MzMKUxHSDkDrnLeC93Mt73ZvnGyTs5zSuK9PsQrB6n5XlroZb4c/vE8WVqIV2ti5hpPBKKwx6DhkFdI6GRzfy3y7skRFsJncpOK0vtvhAZF+fTpPlZiJVA38Q0YytDn9zyatUPyUm/7tv/23rzSca/7jf/yP113JKcRR9Bsc9H68gV//9V+/KqbZ3fwrv/Ir1749hO/ER9JQRTbNeLwGUbpIw5CXoaxTiaJG2Zpzw0uG8rqn/Gp/hmGcz0MozzlspV58ft7P8SGi3X4n6t77F07KK1nMA6oE17k0Zh/9egpROp/WRdrN91XZ5e3so8eV5Q2I9GLlW6/p+z5L7neo5vECbypdZVSPIDrWj2PY+cYdOlQ+DV9uWmgI5I3t/fR5fW3j9cyOuSjx2aFvboQJDUSMHTt00iqZbelbkCqLVGQxpyWDD6HpnQ+IEUN7LmK/q95cg9Z9d4LZMaXkBu1aHqpBkNl2ctPKJq/V+9nVO9FZ5jVGuWOND3lLofA9Nmki2lXIxyB2euUcsWC/U55aJZH0l4kTilFmk0uYxPLf/Jt/83rd7Ff44he/eOW15rq9GGnhffaRLBYnbKXRXEPYxskNhYmG7bt7et5QhuJUo984XIdtCKJv67nXS2Xkw2dEjw+BjICDsffktTCR3kEAwrOQLMbQA4oXmmfKsrEpoyrXrvGU4e2xqECV6R2qbo12qGqDCeVbfXTiNfXL9kI0pAHUbSz7u4GW+kn+aOxuZttGcHs+9WFUY9o2PM/UKAzzTXPBtP5bUHV7t4JUMWxXTQVXM1E199RV9z4y6CbaZkTRtguekhQlbMF07NsgWTHUXDezFa5o7JtxN9KoX+cjUzkXk35WdO0x2+zH2Hc5iuhZ39FoGHaUv4+c7J7f+MY37hRN951D82YH87z2forf+73fu0O90//scJ6XpZLbg9pIeoc4TqDktB4qJmvXu8bjJHY83P9Hp/YlnGLlW1YMgygvepBbTuRBFcbmx65xnDsun2xsemTE51UiX5Cyw2G+V3nLw3vsjU1vJ8AZHyi/J97f4bnWyEjApof33/LweD3PYufV7OPEW6fw7lbImw99L1itCGCv6/bgN5jc3ox0/5Paoyc/wZWzKWnOdBmXfm6yn5QUIQ1BxFASeCtuGd0Fkaj97pT0kSk387ko3SfmqcLBRVAg3QhnhcFG0t7zxCDOafdhhdOJ0U7MuKsa9r1tJyboN/tejVF3XoUWY1WR4pkw9Ss6EhmlYBXEHcpprlbkeB7OieH3/w2rWW2057/pJe2rtkkxSXc3bGrkokUKTRTnep/WwHU6AY69zjvEmMH2uOwd7ki5VEVkOWaK1txA/ZTE7+VzEbZCdj4CkhLXJl0FK73yDgqFeZ1NmRMUyjfxVvezYslw3q7GkWYvM0+Ny2lNVLz1sxF/v28T6UPezbQZt0UBhRTlm/371nnLsrLenOc0gTlTajz8Z+IpTGciCqthnJyKWneuAVq2FyE2Gt6x15oITebc1vGkaBtXgiwz7bGWjGssVpX0/0JXO3Sj8VO5ifR1J3d7KKRQRZHzfsgontoWhs1k5lT2me6hPndsT8gngZ/4tWPWGJvj0Lil8FWIGk3XxbWUnq5DtHm3fMGOxSrMGbDCSFsJP2S8d6juIZwVfdu/YFWbcrV5oHvIZ+baPHompW+ieZ91NOPodx7e18vd1hpdaaF3kzIP7SdfYxD2s0X2Rq34p9/oFbb2O3wVX7h2rUVrL90eqko0yrBl5sk6nTbv/2So99orm9N2cnwDAL0ojafyoNGz/+0d9iok3lz1TJ95SeoJoZ6MwU6E7gz5DpN47QnRbSbw/TZKD6Hn7aYb79W9316MCq6FGaKflJYL3bUKgEx5qgbYc/AaGe1Es5jo5Nq+2/9TiJ0/P3937D/mL6wSwjOcdAphbI9l+qzEc6Na55kS1CjpVfZ7z3VSeHY59EOVGv1fRKdy2YonGku7nfhznfbYvf9G3dFn88Jeq3i59XBzkghz75nIKI3iLxc0ObCJAnRkjOWle9zeXwWf8s/D2kdWaGQbmwUh06L3DkX1d4cDHY8KdusYwcDOoZw8sIdo7ed9tnWb4UDl8ETDrbe2nAuiNgDcHv/pNU2Qe/KOntkzmnWLZOQmJgpU6HaFTRPaQrANhoITwU5xVo3VFuQ9h/6OgKTo91x6Xz8pDRfH3zmHvp/fbeMoWhOJ13TnT16MfUnHE0OcaLyZvbl5MqP328bRw9j83JDEaV2l7clwn66pqUhOhnWHEAzPiSrlmZSEVVt6ENsAS7O9Dgq4IZjo19hVtg95E3uc28D629at63aOT3r0fPF5TUHAxz72sbuH2BQaE/kWz3afQuMzjDgGoGMq5jXRBPdAGEr09yrIkyFwTbcXXx8a5RO9ookK23udwngPAdX92V572/Yot/HYvNQ4dl5k00d9Yx8b6GyjEB8+F6NQRYcJHM+A39Zr2smNMsSy23aVVA4ZBFGx/br4EcXfbkUToWI2908Yxuh+Vg84340WVC4ye/dpPKJbGU3h2DtZnbfxc+d28i5O6E9EWR34rvponfc8Tn0rbNsQ+X57BhoS7yOCP5X77X6knWE7hWP+rxIRsW5D5m93nNnfKISbXo61+6ZwC/+0sc2zm7Yi0kCLtOPJcgATCqqCzhODPaVzDIFPNLPyZ/KH+zkhyXvv57tON8gj6Dcic+Wl0GlgsrVKDlT6p/zAvPRMU5Zbge6qK48+EVC0DtuDn7ZBhB6F+kU522Hjrbzn9+6qN1/QnG2GzgSW5hjqZxeT9H2/0WA+c6Ng0jXBEAXtmJcL68Metit18gy2i6RV3mh2K1Wt5kmhqdRO1ncT088cW8xkvFLG6DqF10Wzyskk/TYCKRpjsCmknVgVpTYO59fvEy4FXTfbEMdW5H0urRuLaG7TcBuPnTg/fbeFfns40sNkmzzl74xZx5/1dYr9yu8au2389n3ab+N3m6+Tn+h2osc2gI0tw1c+QENwqniKL+a3JZ27h+EeD8dT6RQmKnncLn6v3UZ2y9424A/JmQBGvnfPkTTd6yKtBFEnHup++/2jQ2WQ8rCVrL+3f0FYukL9dwJS6olTuHPrKPXH5pn+bqD2zIyCCiwra3Joo9+Skn7WoqU83q0KQAbYrpfhHgmiwjsh9h1PVOm0eNsY2U5oMxo0tsbT382AjrWxqdQdlzRJiYtu9Gg0Co5VodADsFIkBLINswIjDRq/ytPvok3rsNdg0zOloVGw5l9Uuelh+KT3u7bbaxQkk9TWtO8Y+ok2J0GTj7ZSUYZOYcmTYtxAIr6KLvNg+wkHZRA6kFLU7FpY99+rMJFnAzX+lH6b4aoU8rwx56UCewiMhfKV7y17frcNgkBl0/XkNex1VKY2CKs9xPvvZshO6FwPQj22jeZDvLT14Ikfk4uaa6DsnebyZzYKhVqm7TBCkxeJqaB37b4tZhJhnYisUXLS3tM+JdBJUHULE5gRjBRrVTj9/qGdiqe2heHEnDJIyd1CdG52MpQ0qPAhVNY4VYgb/W7kEi02zVXctWgVXd3pGwptzHuu+znI8YpPunNdMgidGNoOWg/Ts0IpJeNapdACL+04L/Sxvbu5R3OzGia+EGWKwB9S4PLrVjp6J/WZQtthLwFVZylN+GeSxHN+1PCE44if8wB30lcQczIazbnkcXkDj5lo7rtKTF0w7aG8m/pgj2HTaXv/G2GfSpAb4ylyUJ/9vhL1DRDfXk980zON5x8yBr5s0mOXpHrfTasNJlsHeWWD43TErtZ6pkYhxeVATiElBybzbdR6WrB+1zU2BUfmOQmjAlVfLWyMcEpENqbmYkx/rlXZes8d158mmm8MMvW2+rrsKoKdiHMPRb/dRmB7VQ8xhIK1Ddhu3se1nWYMWeG0r4R0ewt7jBpgDf/MOSHdG5YecvcVwGk90N48RePcYzffYsJVY7xDbd7/ITooIybKd35uK7nWvqe9ZRz1+B7KE3k21z7XSAVoWWlHZuyS1mRBFFtf26PfFYun9ZrrPZ1AmqXc0y99btXZ9o6kh7Q2pCZS9/Np0nA/5+Ah70KvZAOGDdqmPcQbfjbNe55Ar79PJ6qvdt7luZ2SaiLIxd5IPCKIGrp2o4TdHvpMlHay0i3C/t4+YhoXVgXk4kncjTZ6qZxqKgzpcZrjRkbGo7cghaATjMaf4txKSwO0Ucwe16al95d2jl2lsply036vzbR97ckDVAE3hh1/d51SFhoshTGFMn+3sDv+FMsone15pDgyFpsue01PQh04cZOYj6aVJuaf5v95aXoaeV6NaxcO7DyBvN5nGYV9+q9e4AZ23b9xbgO4PabNa9FDHtkyuI2+NJKvt/dsVVreQHRrrLufN28NgmW9D/HI1hub35VPeePkOZ502qm/h76zL2U3wLe9lmdWklozfviQBZVJSqhZGeIET8iq+zRB0fl2yQ1fOZ6diFWJNUbRogRN+OvDexoDfiistlF7qGQjyv2SCbc73a7IQXEmFA2RGOpwTZqjY9L7OCkudzVfGeawf0Fh6ncqAum+Nw163Ed9ivJKiOYdzOeOQWVfuK8d2V2zz79pXIWL9j3lA+cvfazR38pXcCQfS49CYyWJCwtVLdMYND5uRLOp2OVvN21tnjJGb4HBKXdnWOLEq/bvnAWBnQtlWHeDE4GV/SY327PXo9khq554V76lKq/mXtJcryDZ+RFPi7MAZNNAWp88nK7d+jG58vpt9OxP3tn3UI43wJZuz80omBCLYMW+VQ5N3nKqzXgyjEyyDUUTlpAp++5n5UxMoeBt99C2DYEIRDQ7bSfoNDzNoZ2EJ2apj/pU+DU2O7YpKt/u4A5rSF9RwvYUNhNv9JOSSYgUWI3tKOATg+551Pb4E0YNZmunYOqZ1jTOJkTLXejhSNv62eh+x16lxaZf95trQvh6bltxbNTrnAQnrsNW7inBciImxV0v76eCcr29LjrMPT10cYf4bI2v3wucToov3j/JRP1N2zF7S4uVM0OX8U6GfiqyJt8yG/Q6zmGurepq51QCK5ZiP1l5zJPCFpCckPuJd5rD/F9+kd7bG3Hddn9+py7bvP7TtJ/KKDRgB5ihSPD2BCRmn0f0rSA2SpO4W3FqpVVI9nmKX576VemeQkr7tV3Jkyt4Ynz72DmJndvYilYBqG2lcVI+zk0kKA3qqznt+24jf6KrSlYF/BCdHUN/C5HsM3xk7B2m2nxQXyP8hjYbf8bG9Wgegg7bic+6l0rL0M80gctOam9v0fsIiFyXxmyYyDVV6SZ7Jz7cvOgabkR8eu+4N5gR7G2Z2LywvVJlYdr20KJnfVdcYO6t0tz523lcO+luBd8pTPTOAzvyRdsnHv6TWjy2FbZzlx4PgeYNWlzPvV7xy9Y5z8woWO7YQIfQIjwF9eQaGoNU2Wix+81WWg+VnmrRDUdspux3KRqJGZPu6qnGeRIQ49en0Jf32woxJgydxcDOa4e15uVpnSYWc3llpGkyVfd0PbunO5WNU4uGTHC3Zlsg9jy3IMnQG4WJ3F3r+GYr/y0wolB5Lxe68Td2Pcs2km1QEI+rgDWQniDrYztTWhsBu76bLvXtHE7e1/y/Nddz1WDJg5v/5OON5vd4uv7kQQtm9Hq2J62cNy/lbAPHE9jafCPfBUzj0da3DXjJyLxvXCXiPTTv5BG+8y67z+XDhwCitI5Htpe4QehDxmaPy7Vyj87+XXPbYcdntk/h1HYsuaZ746B3aCnmnL87ztv3Dyk4F0amUIjq7+QVpFy9pwurotpoaLvPKvWTQYl5zAM0ppLL21vYxsbnS+gpbPrGKIUkNg39/oQwoqGnnzbOXUZ6Wm+VgU36mlNQmKefDiPc/eo5qGi8divv7UanTPdej0JPCuv2sOK9vp++fFSrXoeocPhaoT4dDpcBmvftC+hpaPucqe4j/Vynxm24SwW3w2TS74SQd9vI1LWp/y0XKqVTfq68mOui5+E6asyae/zUGu8zluQNT2TdeyBeuS1AMM/UmDe634p8e5/OtXmeQKa84e+3d3UCQOqK+nWTnCDvmRsFmaSby2jbqs7/JV5/VaSim20oTkZIZvT77Vn42Xa59ndbEW+Ftr2e/jb2ktGbJltwXDjvq3HYjLERnm7lSZmLpDY97OehNVVhn0JArvFDaPTd+MY5SBMPGNTwem9puwVOep/GpdCqKPZ66Pm5/uZXHoqN79DW5n0Vn89F3nmAvVmsk0a399PcN4qXj+13h75OcpJh3tdJI/niZJg3oNlKbnsAe/5bB6hAHZsemcZfPjWsavK6UNIOOz5eqD9QtRX95v+HQm/7esvi9zXOTXpvep2M9tY/Agj575kZha3QHYCD3Yiuv/sa46Y9unE/y9bf2Oe+z7bY7q7e9/c3W7lsa7yrDk7KRoQng9YUxvoSsap0NgroemmxE5NbUZ9odlqTh9oO5zRHkcxOwu17PoRqmoubnfp8G6bhATcTyTv7PirEE9373IT75j+/20YxujinHZeuTDglsp9FIRJ2A12Pzdw0S2lV2dShdzWN1hb0k4zIa32/vXBBkOvxkOE3JOf67Li899nFJbv4ZPOhIV7RfsbOtRdgmWPxHpZs78MD5bVHrJnyJk/tnOAGAvs3J29t/16lLh86zxNwTGb6rvnte53A3J/aKAximfbNb37zJ7n8RXvRXrQX7UX7X2gbfT7Hpf+Znrw2FucP/uAPrlvrN+p+0V60F+1Fe9H+l99G1Y9B+MxnPvNgfvgnNgov2ov2or1oL9r/f7SfblfDi/aivWgv2ov2/9PthVF40V60F+1Fe9Hu2guj8KK9aC/ai/ai3bUXRuFFe9FetBftRbtrL4zCi/aivWgv2ot2114YhRftRXvRXrQX7a69MAov2ov2or1oL9ql9v8F+Z2uQXAyQfsAAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "def visualize_predictions(model, dataset):\n",
     "    \"\"\"Visualize model predictions compared to ground truth.\n",
@@ -2358,22 +1141,267 @@
     "    with torch.inference_mode():\n",
     "        sample = dataset[idx]\n",
     "        image = sample['image'].unsqueeze(0).to(model.device)\n",
-    "        mask_gt = sample['mask']\n",
+    "        mask_gt = sample['mask'] # shape: (H, W)\n",
     "        \n",
-    "        logits = model(image)\n",
-    "        mask_pred = torch.argmax(logits, dim=1).squeeze(0).cpu()\n",
+    "        logits = model(image) # shape: (1, #classes, H, W)\n",
+    "        mask_pred = torch.argmax(logits, dim=1).squeeze(0).cpu() # shape: (H, W)\n",
     "\n",
     "        overlay_mask = draw_masks(image.squeeze(0).cpu(), torch.stack([mask_gt, mask_pred]), alpha=0.5)\n",
     "        show(overlay_mask)\n",
     "\n",
-    "        yp = (mask_pred == 1).sum().item()\n",
-    "        yg = (mask_gt == 1).sum().item()\n",
-    "        tp = ((mask_pred == 1) & (mask_gt == 1)).sum().item()\n",
+    "        yp = (mask_pred == 1).sum().item() # predicted positives\n",
+    "        yg = (mask_gt == 1).sum().item() # ground truth positives\n",
+    "        tp = ((mask_pred == 1) & (mask_gt == 1)).sum().item() # true positives\n",
     "        iou = tp / (yp + yg - tp) if (yp + yg - tp) > 0 else 1.0\n",
     "        print(f\"IoU: {iou:.1%}\")\n",
     "\n",
     "visualize_predictions(model, test_dataset)"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7cb374d2",
+   "metadata": {},
+   "source": [
+    "## 7. Model Deployment\n",
+    "\n",
+    "For production use, we wrap our model in a **Datamint Model Adapter**. This adapter:\n",
+    "- Standardizes input/output format\n",
+    "- Handles resource loading from Datamint\n",
+    "- Enables deployment via MLflow Model Serving or Datamint's inference API\n",
+    "- Returns structured `ImageSegmentation` annotations\n",
+    "\n",
+    "### 7.1 Create Datamint Model Adapter\n",
+    "\n",
+    "The `DatamintModel` base class provides a consistent interface for model deployment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "53379296",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datamint.mlflow.flavors.model import DatamintModel\n",
+    "from datamint.entities.annotations import ImageSegmentation\n",
+    "from datamint.entities import Resource\n",
+    "import torch\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "from typing_extensions import override\n",
+    "\n",
+    "class UNetPPSegmentationAdapter(DatamintModel):\n",
+    "    \"\"\"Datamint adapter for UNet++ segmentation model deployment.\"\"\"\n",
+    "    \n",
+    "    def __init__(self):\n",
+    "        super().__init__(\n",
+    "            mlflow_torch_models_uri={\n",
+    "                'unetpp': f'models:/{PROJECT_NAME}/latest' # URI in MLflow Model Registry. An efficient way to link your new model to this one\n",
+    "            }, \n",
+    "            settings={'need_gpu': True}\n",
+    "        )\n",
+    "        self.class_names = CLASS_NAMES\n",
+    "    \n",
+    "    @override\n",
+    "    def predict_image(self, model_input: list[Resource], **kwargs):\n",
+    "        pytorch_model = self.get_mlflow_torch_models()['unetpp']\n",
+    "        pytorch_model.eval()\n",
+    "        \n",
+    "        # Use Lightning Fabric for device management, instead of L.Trainer. Lightweight and perfect for inference.\n",
+    "        fabric = L.Fabric(accelerator=self.inference_device)\n",
+    "        pytorch_model = fabric.setup_module(pytorch_model)\n",
+    "\n",
+    "        all_predictions = []\n",
+    "        with torch.inference_mode():\n",
+    "            for res in model_input:\n",
+    "                image = res.fetch_file_data(auto_convert=True, use_cache=True)\n",
+    "                # image is a PIL.Image object\n",
+    "                original_width = image.width\n",
+    "                original_height = image.height\n",
+    "\n",
+    "                image = np.array(image)\n",
+    "                image_tensor = val_transforms(image=image)['image'].to(fabric.device)  # (3, H, W)\n",
+    "                logits = pytorch_model(image_tensor.unsqueeze(0)) # unsqueeze to (1, 3, H, W)\n",
+    "                pred = torch.argmax(logits, dim=1).squeeze().cpu().numpy()\n",
+    "\n",
+    "                # Implement here any post-processing if desired\n",
+    "                # reshape prediction to original size\n",
+    "                pred = cv2.resize(pred.astype(np.uint8), \n",
+    "                                  (original_width, original_height), \n",
+    "                                  interpolation=cv2.INTER_NEAREST)\n",
+    "                annotations = []\n",
+    "                for class_idx, class_name in self.class_names.items():\n",
+    "                    class_mask = (pred == class_idx).astype(np.uint8)\n",
+    "                    if class_mask.any(): # at least one pixel\n",
+    "                        pred_ann = ImageSegmentation(name=class_name, mask=class_mask)\n",
+    "                        annotations.append(pred_ann)\n",
+    "                all_predictions.append(annotations)        \n",
+    "\n",
+    "        return all_predictions\n",
+    "\n",
+    "adapter = UNetPPSegmentationAdapter()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c3c4d082",
+   "metadata": {},
+   "source": [
+    "### 7.2 Log the Adapter to MLflow\n",
+    "\n",
+    "We log the adapter model to MLflow, making it available for deployment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9c8b361e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datamint.mlflow.flavors import datamint_flavor\n",
+    "from mlflow import set_experiment\n",
+    "import mlflow\n",
+    "from datamint.mlflow import set_project\n",
+    "\n",
+    "# Set project and experiment context\n",
+    "set_project(PROJECT_NAME)\n",
+    "set_experiment(f'{PROJECT_NAME}_deployment') # Arbitrary experiment name. Create or use an existing one.\n",
+    "\n",
+    "adapter = UNetPPSegmentationAdapter()\n",
+    "\n",
+    "# Log the adapter to MLflow\n",
+    "ADAPTED_MODEL_NAME = f\"{PROJECT_NAME}_adapted\"\n",
+    "\n",
+    "with mlflow.start_run(run_name=\"unetpp_segmentation_adapter\"): # Create a new MLflow run. You can use an existing one as well\n",
+    "    model_info = datamint_flavor.log_model(\n",
+    "        adapter,\n",
+    "        registered_model_name=ADAPTED_MODEL_NAME,\n",
+    "    )\n",
+    "\n",
+    "print(f\"✅ Adapter logged successfully!\")\n",
+    "print(f\"Model URI: {model_info.model_uri}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "18dcee15",
+   "metadata": {},
+   "source": [
+    "### 7.3 Test Local Inference\n",
+    "\n",
+    "Before deploying, verify the adapter works correctly with local inference."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "459f75ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import mlflow\n",
+    "\n",
+    "# Load the registered adapter model\n",
+    "loaded_model = mlflow.pyfunc.load_model(f'models:/{ADAPTED_MODEL_NAME}/latest')\n",
+    "\n",
+    "# Test with a resource from the test set\n",
+    "test_resource = test_dataset.resources[-1]\n",
+    "print(f\"Testing with: {test_resource.filename}\")\n",
+    "\n",
+    "# Run prediction\n",
+    "predictions = loaded_model.predict([test_resource])\n",
+    "\n",
+    "print(f\"\\n✅ Prediction successful!\")\n",
+    "print(f\"Number of annotations: {len(predictions[0])}\")\n",
+    "for ann in predictions[0]:\n",
+    "    n_pixels = (ann.mask > 0).sum()\n",
+    "    print(f\"  - {ann.name}: {n_pixels} pixels ({n_pixels / (ann.mask.size) :.1%} of the image)\")\n",
+    "\n",
+    "print('Ground truth:')\n",
+    "gt_annotations = api.annotations.get_list(\n",
+    "    resource=test_resource,\n",
+    "    annotation_type='segmentation'\n",
+    ")\n",
+    "for ann in gt_annotations:\n",
+    "    mask = np.array(ann.fetch_file_data(use_cache=True))\n",
+    "    n_pixels = (mask > 0).sum()\n",
+    "    print(f\"  - {ann.name}: {n_pixels} pixels ({n_pixels / (mask.size) :.1%} of the image)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8bcf920e",
+   "metadata": {},
+   "source": [
+    "### 7.4 Deploy to Datamint Server\n",
+    "\n",
+    "Start a deployment job to serve the model via Datamint's inference API."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4d3d0968",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Start deployment job\n",
+    "job = api.deploy.start(\n",
+    "    model_name=ADAPTED_MODEL_NAME,\n",
+    "    model_alias=\"latest\",\n",
+    "    with_gpu=True,  # Use GPU for inference\n",
+    ")\n",
+    "\n",
+    "print(f\"🚀 Deployment job started!\")\n",
+    "print(f\"Job ID: {job.id}\")\n",
+    "print(f\"Status: {job.status}\")\n",
+    "print(f\"Model: {job.model_name}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4828d15",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Check deployment status\n",
+    "job = api.deploy.get_by_id(job.id)\n",
+    "\n",
+    "print(f\"Job Status: {job.status}\")\n",
+    "print(f\"Progress: {job.progress_percentage}%\")\n",
+    "\n",
+    "if job.error_message:\n",
+    "    print(f\"Error: {job.error_message}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "01c339a7",
+   "metadata": {},
+   "source": [
+    "## 8. Summary\n",
+    "\n",
+    "Congratulations! 🎉 You've completed the UNet++ Segmentation Tutorial with the BUSI dataset.\n",
+    "\n",
+    "### What You Learned\n",
+    "\n",
+    "| Step | Description |\n",
+    "|------|-------------|\n",
+    "| **Data Management** | Uploaded ultrasound images and masks to Datamint |\n",
+    "| **Custom Dataset** | Built a PyTorch Dataset for 2D ultrasound images |\n",
+    "| **Model Architecture** | Implemented UNet++ with combined CrossEntropy + Dice loss |\n",
+    "| **Training** | Trained with MLflow experiment tracking |\n",
+    "| **Deployment** | Built a DatamintModel adapter for production inference |\n",
+    "\n",
+    "### References\n",
+    "\n",
+    "- [Datamint Documentation](https://sonanceai.github.io/datamint-python-api/)\n",
+    "- [BUSI Dataset](https://www.kaggle.com/datasets/aryashah2k/breast-ultrasound-images-dataset)\n",
+    "- [Segmentation Models PyTorch](https://github.com/qubvel/segmentation_models.pytorch)"
+   ]
   }
  ],
  "metadata": {