Repository: EIT-ALIVE/eitprocessing (language: python)

Issue:
222 pixel inflation



Discussion / hints:

Fix patch:
diff --git a/eitprocessing/features/pixel_breath.py b/eitprocessing/features/pixel_breath.py
new file mode 100644
index 000000000..85453561b
--- /dev/null
+++ b/eitprocessing/features/pixel_breath.py
@@ -0,0 +1,224 @@
+import itertools
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from eitprocessing.datahandling.breath import Breath
+from eitprocessing.datahandling.continuousdata import ContinuousData
+from eitprocessing.datahandling.eitdata import EITData
+from eitprocessing.datahandling.intervaldata import IntervalData
+from eitprocessing.datahandling.sequence import Sequence
+from eitprocessing.features.breath_detection import BreathDetection
+
+
+@dataclass
+class PixelBreath:
+    """Algorithm for detecting timing of pixel breaths in pixel impedance data.
+
+    This algorithm detects the position of start of inspiration, end of inspiration and
+    end of expiration in pixel impedance data. It uses BreathDetection to find the global start and end
+    of inspiration and expiration. These points are then used to find the start/end of pixel
+    inspiration/expiration in pixel impedance data.
+
+    Examples:
+    >>> pi = PixelBreath()
+    >>> eit_data = sequence.eit_data['raw']
+    >>> continuous_data = sequence.continuous_data['global_impedance_(raw)']
+    >>> pixel_breaths = pi.find_pixel_breaths(eit_data, continuous_data, sequence)
+
+    Args:
+    breath_detection_kwargs (dict): A dictionary of keyword arguments for breath detection.
+        The available keyword arguments are:
+        minimum_duration: minimum expected duration of breaths, defaults to 2/3 of a second
+        averaging_window_duration: duration of window used for averaging the data, defaults to 15 seconds
+        averaging_window_function: function used to create a window for averaging the data, defaults to np.blackman
+        amplitude_cutoff_fraction: fraction of the median amplitude below which breaths are removed, defaults to 0.25
+        invalid_data_removal_window_length: window around invalid data in which breaths are removed, defaults to 0.5
+        invalid_data_removal_percentile: the nth percentile of values used to remove outliers, defaults to 5
+        invalid_data_removal_multiplier: the multiplier used to remove outliers, defaults to 4
+    """
+
+    breath_detection_kwargs: dict = field(default_factory=dict)
+
+    def find_pixel_breaths(
+        self,
+        eit_data: EITData,
+        continuous_data: ContinuousData,
+        sequence: Sequence | None = None,
+        store: bool | None = None,
+        result_label: str = "pixel_breaths",
+    ) -> IntervalData:
+        """Find pixel breaths in the data.
+
+        This method finds the pixel start/end of inspiration/expiration
+        based on the start/end of inspiration/expiration as detected
+        in the continuous data.
+
+        If pixel impedance is in phase (within 180 degrees) with the continuous data,
+        the start of breath of that pixel is defined as the local minimum between
+        two end-inspiratory points in the continuous signal.
+        The end of expiration of that pixel is defined as the local minimum between two
+        consecutive end-inspiratory points in the continuous data.
+        The end of inspiration of that pixel is defined as the local maximum between
+        the start of inspiration and end of expiration of that pixel.
+
+        If pixel impedance is out of phase with the continuous signal,
+        the start of inspiration of that pixel is defined as the local maximum between
+        two end-inspiration points in the continuous data.
+        The end of expiration of that pixel is defined as the local maximum between two
+        consecutive end-inspiratory points in the continuous data.
+        The end of inspiration of that pixel is defined as the local minimum between
+        the start of inspiration and end of expiration of that pixel.
+
+        Pixel breaths are constructed as a valley-peak-valley combination,
+        representing the start of inspiration, the end of inspiration/start of
+        expiration, and end of expiration.
+
+        Args:
+            eit_data: EITData to apply the algorithm to
+            continuous_data: ContinuousData to use for global breath detection
+            result_label: label of the returned IntervalData object, defaults to `'pixel_breaths'`.
+            sequence: optional, Sequence that contains the object to detect pixel breaths in,
+            and/or to store the result in.
+            store: whether to store the result in the sequence, defaults to `True` if a Sequence if provided.
+
+        Returns:
+            An IntervalData object containing Breath objects.
+
+        Raises:
+            RuntimeError: If store is set to true but no sequence is provided.
+            ValueError: If the provided sequence is not an instance of the Sequence dataclass.
+        """
+        if store is None and isinstance(sequence, Sequence):
+            store = True
+
+        if store and sequence is None:
+            msg = "Can't store the result if no Sequence is provided."
+            raise RuntimeError(msg)
+
+        if store and not isinstance(sequence, Sequence):
+            msg = "To store the result a Sequence dataclass must be provided."
+            raise ValueError(msg)
+
+        bd_kwargs = self.breath_detection_kwargs.copy()
+        breath_detection = BreathDetection(**bd_kwargs)
+        continuous_breaths = breath_detection.find_breaths(continuous_data)
+
+        indices_breath_middles = np.searchsorted(
+            eit_data.time,
+            [breath.middle_time for breath in continuous_breaths.values],
+        )
+
+        _, n_rows, n_cols = eit_data.pixel_impedance.shape
+
+        from eitprocessing.parameters.tidal_impedance_variation import TIV
+
+        pixel_tivs = TIV().compute_pixel_parameter(
+            eit_data,
+            continuous_data,
+            sequence,
+            tiv_method="inspiratory",
+            tiv_timing="continuous",
+            store=False,
+        )  # Set store to false as to not save these pixel tivs as SparseData.
+
+        pixel_tiv_with_continuous_data_timing = (
+            np.empty((0, n_rows, n_cols)) if not len(pixel_tivs.values) else np.stack(pixel_tivs.values)
+        )
+
+        # Create a mask to detect slices that are entirely NaN
+        all_nan_mask = np.isnan(pixel_tiv_with_continuous_data_timing).all(axis=0)
+
+        # Initialize the mean_tiv_pixel array with NaNs
+        mean_tiv_pixel = np.full((n_rows, n_cols), np.nan)
+
+        # Only compute nanmean for slices that are not entirely NaN
+        if not all_nan_mask.all():  # Check if there are any valid (non-all-NaN) slices
+            mean_tiv_pixel[~all_nan_mask] = np.nanmean(pixel_tiv_with_continuous_data_timing[:, ~all_nan_mask], axis=0)
+
+        time = eit_data.time
+        pixel_impedance = eit_data.pixel_impedance
+
+        pixel_breaths = np.full((len(continuous_breaths), n_rows, n_cols), None)
+
+        for row, col in itertools.product(range(n_rows), range(n_cols)):
+            mean_tiv = mean_tiv_pixel[row, col]
+
+            if np.any(pixel_impedance[:, row, col] > 0):
+                if mean_tiv < 0:
+                    start_func, middle_func = np.argmax, np.argmin
+                else:
+                    start_func, middle_func = np.argmin, np.argmax
+
+                outsides = self._find_extreme_indices(pixel_impedance, indices_breath_middles, row, col, start_func)
+                starts = outsides[:-1]
+                ends = outsides[1:]
+                middles = self._find_extreme_indices(pixel_impedance, outsides, row, col, middle_func)
+                # TODO discuss; this block of code is implemented to prevent noisy pixels from breaking the code.
+                # Quick solve is to make entire breath object None if any breath in a pixel does not have
+                # consecutive start, middle and end.
+                # However, this might cause problems elsewhere.
+                if (starts >= middles).any() or (middles >= ends).any():
+                    pixel_breath = None
+                else:
+                    pixel_breath = self._construct_breaths(starts, middles, ends, time)
+                pixel_breaths[:, row, col] = pixel_breath
+
+        intervals = [(breath.start_time, breath.end_time) for breath in continuous_breaths.values]
+
+        pixel_breaths_container = IntervalData(
+            label=result_label,
+            name="Pixel in- and deflation timing as determined by Pixelbreath",
+            unit=None,
+            category="breath",
+            intervals=intervals,
+            values=list(
+                pixel_breaths,
+            ),  ## TODO: change back to pixel_breaths array when IntervalData works with 3D array
+            parameters=self.breath_detection_kwargs,
+            derived_from=[eit_data],
+        )
+        if store:
+            sequence.interval_data.add(pixel_breaths_container)
+
+        return pixel_breaths_container
+
+    def _construct_breaths(self, start: list, middle: list, end: list, time: np.ndarray) -> list:
+        breaths = [Breath(time[s], time[m], time[e]) for s, m, e in zip(start, middle, end, strict=True)]
+        # First and last breath are not detected by definition (need two breaths to find one breath)
+        return [None, *breaths, None]
+
+    def _find_extreme_indices(
+        self,
+        pixel_impedance: np.ndarray,
+        times: np.ndarray,
+        row: int,
+        col: int,
+        function: Callable,
+    ) -> np.ndarray:
+        """Finds extreme indices in pixel impedance.
+
+        This method divides the pixel impedance for a single pixel (selected using row and col) into smaller segments
+        based on the `times` array. The times array consists of indices to divide these segments. The function iterates
+        over each index in the times array to select consecutive segments of pixel impedance.
+        For each segment, the method applies the `function` (either np.argmax or np.argmin) to extract an extreme value
+        (local maximum or minimum).
+
+        Args:
+            pixel_impedance (np.ndarray): The pixel impedance array from which the function will extract values.
+                Assumed to be 3-dimensional (e.g., time, rows, and columns).
+            times (np.ndarray): 1D array of time indices. These times define the start
+                and end of each segment in the pixel impedance.
+            row (int): The row index in the pixel impedance
+            col (int): The column index in the pixel impedance
+            function (Callable): A function that is applied to each segment of data to find
+                an extreme value (np.argmax or np.argmin)
+
+        Returns:
+            np.ndarray: An array of indices where the extreme values (based on the function)
+            are located for each time segment.
+        """
+        return np.array(
+            [function(pixel_impedance[times[i] : times[i + 1], row, col]) + times[i] for i in range(len(times) - 1)],
+        )
diff --git a/eitprocessing/parameters/tidal_impedance_variation.py b/eitprocessing/parameters/tidal_impedance_variation.py
new file mode 100644
index 000000000..70db7443b
--- /dev/null
+++ b/eitprocessing/parameters/tidal_impedance_variation.py
@@ -0,0 +1,272 @@
+import itertools
+from dataclasses import dataclass, field
+from functools import singledispatchmethod
+from typing import Literal, NoReturn
+
+import numpy as np
+
+from eitprocessing.datahandling.breath import Breath
+from eitprocessing.datahandling.continuousdata import ContinuousData
+from eitprocessing.datahandling.eitdata import EITData
+from eitprocessing.datahandling.intervaldata import IntervalData
+from eitprocessing.datahandling.sequence import Sequence
+from eitprocessing.datahandling.sparsedata import SparseData
+from eitprocessing.features.breath_detection import BreathDetection
+from eitprocessing.features.pixel_breath import PixelBreath
+from eitprocessing.parameters import ParameterCalculation
+
+
+@dataclass
+class TIV(ParameterCalculation):
+    """Compute the tidal impedance variation (TIV) per breath."""
+
+    method: Literal["extremes"] = "extremes"
+    breath_detection_kwargs: dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.method != "extremes":
+            msg = f"Method {self.method} is not implemented. The method must be 'extremes'."
+            raise NotImplementedError(msg)
+
+    @singledispatchmethod
+    def compute_parameter(
+        self,
+        data: ContinuousData | EITData,
+    ) -> NoReturn:
+        """Compute the tidal impedance variation per breath on either ContinuousData or EITData, depending on the input.
+
+        Args:
+            data: either continuous_data or eit_data to compute TIV on.
+        """
+        msg = f"This method is implemented for ContinuousData or EITData, not {type(data)}."
+        raise TypeError(msg)
+
+    @compute_parameter.register(ContinuousData)
+    def compute_continuous_parameter(
+        self,
+        continuous_data: ContinuousData,
+        tiv_method: Literal["inspiratory", "expiratory", "mean"] = "inspiratory",
+        sequence: Sequence | None = None,
+        store: bool | None = None,
+        result_label: str = "continuous_tivs",
+    ) -> SparseData:
+        """Compute the tidal impedance variation per breath.
+
+        Args:
+            continuous_data: The ContinuousData to compute the TIV on.
+            tiv_method: The label of which part of the breath the TIV
+                should be determined on (inspiratory, expiratory, or mean).
+                Defaults to 'inspiratory'.
+            sequence: optional, Sequence that contains the object to detect TIV on,
+            and/or to store the result in.
+            store: whether to store the result in the sequence, defaults to `True` if a Sequence if provided.
+            result_label: label of the returned SparseData object, defaults to `'continuous_tivs'`.
+
+        Returns:
+            A list with the computed TIV values.
+
+        Raises:
+            RuntimeError: If store is set to true but no sequence is provided.
+            ValueError: If the provided sequence is not an instance of the Sequence dataclass.
+            ValueError: If tiv_method is not one of 'inspiratory', 'expiratory', or 'mean'.
+        """
+        if store is None and isinstance(sequence, Sequence):
+            store = True
+
+        if store and sequence is None:
+            msg = "Can't store the result if no Sequence is provided."
+            raise RuntimeError(msg)
+
+        if store and not isinstance(sequence, Sequence):
+            msg = "To store the result a Sequence dataclass must be provided."
+            raise ValueError(msg)
+
+        if tiv_method not in {"inspiratory", "expiratory", "mean"}:
+            msg = f"Invalid tiv_method: {tiv_method}. Must be one of 'inspiratory', 'expiratory', or 'mean'."
+            raise ValueError(msg)
+
+        breaths = self._detect_breaths(continuous_data)
+
+        tiv_values = self._calculate_tiv_values(
+            continuous_data.values,
+            continuous_data.time,
+            breaths.values,
+            tiv_method,
+            tiv_timing="continuous",
+        )
+        tiv_container = SparseData(
+            label=result_label,
+            name="Continuous tidal impedance variation",
+            unit=None,
+            category="impedance difference",
+            time=continuous_data.time,
+            description="Tidal impedance variation determined on continuous data",
+            parameters=self.breath_detection_kwargs,
+            derived_from=[continuous_data],
+            values=tiv_values,
+        )
+        if store:
+            sequence.sparse_data.add(tiv_container)
+
+        return tiv_container
+
+    @compute_parameter.register(EITData)
+    def compute_pixel_parameter(
+        self,
+        eit_data: EITData,
+        continuous_data: ContinuousData,
+        sequence: Sequence,
+        tiv_method: Literal["inspiratory", "expiratory", "mean"] = "inspiratory",
+        tiv_timing: Literal["pixel", "continuous"] = "pixel",
+        store: bool | None = None,
+        result_label: str = "pixel_tivs",
+    ) -> SparseData:
+        """Compute the tidal impedance variation per breath on pixel level.
+
+        Args:
+            sequence: The sequence containing the data.
+            eit_data: The eit pixel level data to determine the TIV of.
+            continuous_data: The continuous data to determine the continuous data breaths or pixel level breaths.
+            tiv_method: The label of which part of the breath the TIV should be determined on
+                        (inspiratory, expiratory or mean). Defaults to 'inspiratory'.
+            tiv_timing: The label of which timing should be used to compute the TIV, either based on breaths
+                        detected in continuous data ('continuous') or based on pixel breaths ('pixel').
+                        Defaults to 'pixel'.
+            result_label: label of the returned IntervalData object, defaults to `'pixel_tivs'`.
+            store: whether to store the result in the sequence, defaults to `True` if a Sequence if provided.
+
+        Returns:
+            An np.ndarray with the computed TIV values.
+
+        Raises:
+            RuntimeError: If store is set to true but no sequence is provided.
+            ValueError: If the provided sequence is not an instance of the Sequence dataclass.
+            ValueError: If tiv_method is not one of 'inspiratory', 'expiratory', or 'mean'.
+            ValueError: If tiv_timing is not one of 'continuous' or 'pixel'.
+        """
+        if store is None and isinstance(sequence, Sequence):
+            store = True
+
+        if store and sequence is None:
+            msg = "Can't store the result if no Sequence is provided."
+            raise RuntimeError(msg)
+
+        if store and not isinstance(sequence, Sequence):
+            msg = "To store the result a Sequence dataclass must be provided."
+            raise ValueError(msg)
+
+        if tiv_method not in ["inspiratory", "expiratory", "mean"]:
+            msg = f"Invalid {tiv_method}. The tiv_method must be either 'inspiratory', 'expiratory' or 'mean'."
+            raise ValueError(msg)
+
+        if tiv_timing not in ["continuous", "pixel"]:
+            msg = f"Invalid {tiv_timing}. The tiv_timing must be either 'continuous' or 'pixel'."
+            raise ValueError(msg)
+
+        data = eit_data.pixel_impedance
+        _, n_rows, n_cols = data.shape
+
+        if tiv_timing == "pixel":
+            pixel_breaths = self._detect_pixel_breaths(
+                eit_data,
+                continuous_data,
+                sequence,
+                store=False,
+            )  # Set store to false as to not save these pixel breaths as IntervalData.
+            # Check if pixel_breaths.values is empty
+            breath_data = (
+                np.empty((0, n_rows, n_cols)) if not len(pixel_breaths.values) else np.stack(pixel_breaths.values)
+            )
+            ## TODO: replace with breath_data = pixel_breaths.values when IntervalData works with 3D array
+        else:  # tiv_timing == "continuous"
+            global_breaths = self._detect_breaths(
+                continuous_data,
+            )
+            breath_data = global_breaths.values
+
+        number_of_breaths = len(breath_data)
+        all_pixels_tiv_values = np.full((number_of_breaths, n_rows, n_cols), None, dtype=object)
+
+        for row, col in itertools.product(range(n_rows), range(n_cols)):
+            time_series = data[:, row, col]
+            breaths = breath_data[:, row, col] if tiv_timing == "pixel" else breath_data
+            pixel_tiv_values = self._calculate_tiv_values(
+                time_series,
+                eit_data.time,
+                breaths,
+                tiv_method,
+                tiv_timing,
+            )
+            all_pixels_tiv_values[:, row, col] = pixel_tiv_values
+
+        tiv_container = SparseData(
+            label=result_label,
+            name="Pixel tidal impedance variation",
+            unit=None,
+            category="impedance difference",
+            time=eit_data.time,
+            description="Tidal impedance variation determined on pixel impedance",
+            parameters=self.breath_detection_kwargs,
+            derived_from=[eit_data],
+            values=list(all_pixels_tiv_values.astype(float)),
+        )
+        if store:
+            sequence.sparse_data.add(tiv_container)
+
+        return tiv_container
+
+    def _detect_breaths(self, data: ContinuousData) -> IntervalData:
+        bd_kwargs = self.breath_detection_kwargs.copy()
+        breath_detection = BreathDetection(**bd_kwargs)
+        return breath_detection.find_breaths(data)
+
+    def _detect_pixel_breaths(
+        self,
+        eit_data: EITData,
+        continuous_data: ContinuousData,
+        sequence: Sequence,
+        store: bool,
+    ) -> IntervalData:
+        bd_kwargs = self.breath_detection_kwargs.copy()
+        pi = PixelBreath(breath_detection_kwargs=bd_kwargs)
+        return pi.find_pixel_breaths(
+            eit_data,
+            continuous_data,
+            result_label="pixel breaths",
+            sequence=sequence,
+            store=store,
+        )
+
+    def _calculate_tiv_values(
+        self,
+        data: np.ndarray,
+        time: np.ndarray,
+        breaths: list[Breath],
+        tiv_method: str,
+        tiv_timing: str,
+    ) -> list:
+        # Filter out None breaths
+        valid_breaths = [breath for breath in breaths if breath is not None]
+
+        # If there are no valid breaths, return a list of None with the same length as the number of breaths
+        if not valid_breaths:
+            return [None] * len(breaths)
+
+        start_indices = np.searchsorted(time, [breath.start_time for breath in breaths if breath is not None])
+        middle_indices = np.searchsorted(time, [breath.middle_time for breath in breaths if breath is not None])
+        end_indices = np.searchsorted(time, [breath.end_time for breath in breaths if breath is not None])
+
+        if tiv_method == "inspiratory":
+            tiv_values = np.squeeze(np.diff(data[[start_indices, middle_indices]], axis=0), axis=0)
+
+        elif tiv_method == "expiratory":
+            tiv_values = np.squeeze(np.diff(data[[end_indices, middle_indices]], axis=0), axis=0)
+
+        elif tiv_method == "mean":
+            mean_outer_values = data[[start_indices, end_indices]].mean(axis=0)
+            end_inspiratory_values = data[middle_indices]
+            tiv_values = end_inspiratory_values - mean_outer_values
+        if tiv_timing == "pixel":
+            tiv_values = [None, *tiv_values, None]
+
+        return tiv_values


Test patch:
diff --git a/notebooks/test_parameter_tiv.ipynb b/notebooks/test_parameter_tiv.ipynb
new file mode 100644
index 000000000..8f362e99d
--- /dev/null
+++ b/notebooks/test_parameter_tiv.ipynb
@@ -0,0 +1,426 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "58e6580f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "%matplotlib widget\n",
+    "from eitprocessing.datahandling.loading import load_eit_data\n",
+    "from eitprocessing.features.breath_detection import BreathDetection\n",
+    "from eitprocessing.features.pixel_breath import PixelBreath\n",
+    "from eitprocessing.parameters.tidal_impedance_variation import TIV"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef0e15e3",
+   "metadata": {},
+   "source": [
+    "### Load a sequence from file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "00f8acd0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sequence = load_eit_data(\"tests/test_data/Draeger_Test.bin\", vendor=\"draeger\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8f89324d",
+   "metadata": {},
+   "source": [
+    "### Select a small portion of the sequence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "58b7f389",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ssequence = sequence.t[55940:55970]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b98cfc3e",
+   "metadata": {},
+   "source": [
+    "### Perform breath detection on global impedance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "62913fd8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bd = BreathDetection()\n",
+    "breaths = bd.find_breaths(ssequence.continuous_data[\"global_impedance_(raw)\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "38e86661",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "continuous_data = ssequence.continuous_data[\"global_impedance_(raw)\"].values\n",
+    "\n",
+    "continuous_start_indices = [\n",
+    "    np.argmax(ssequence.continuous_data[\"global_impedance_(raw)\"].time == start_time)\n",
+    "    for start_time in [breath.start_time for breath in breaths.values]\n",
+    "]\n",
+    "continuous_middle_indices = [\n",
+    "    np.argmax(ssequence.continuous_data[\"global_impedance_(raw)\"].time == middle_time)\n",
+    "    for middle_time in [breath.middle_time for breath in breaths.values]\n",
+    "]\n",
+    "continuous_end_indices = [\n",
+    "    np.argmax(ssequence.continuous_data[\"global_impedance_(raw)\"].time == end_time)\n",
+    "    for end_time in [breath.end_time for breath in breaths.values]\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "422e90a3",
+   "metadata": {},
+   "source": [
+    "### Perform pixel breath detection on pixel impedance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "b742f5e9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pb = PixelBreath()\n",
+    "pixel_breaths = pb.find_pixel_breaths(\n",
+    "    eit_data=ssequence.eit_data[\"raw\"],\n",
+    "    continuous_data=ssequence.continuous_data[\"global_impedance_(raw)\"],\n",
+    "    sequence=ssequence,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7d4cc5da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pixel_data = ssequence.eit_data[\"raw\"].pixel_impedance\n",
+    "pixel_breaths = np.stack(pixel_breaths.values)\n",
+    "\n",
+    "# Handle None values\n",
+    "pixel_start_indices = [\n",
+    "    np.argmax(ssequence.eit_data[\"raw\"].time == start_time)\n",
+    "    for pixel_breath in pixel_breaths[:, 12, 13]\n",
+    "    if pixel_breath is not None\n",
+    "    for start_time in [pixel_breath.start_time]\n",
+    "]\n",
+    "\n",
+    "pixel_middle_indices = [\n",
+    "    np.argmax(ssequence.eit_data[\"raw\"].time == middle_time)\n",
+    "    for pixel_breath in pixel_breaths[:, 12, 13]\n",
+    "    if pixel_breath is not None\n",
+    "    for middle_time in [pixel_breath.middle_time]\n",
+    "]\n",
+    "\n",
+    "pixel_end_indices = [\n",
+    "    np.argmax(ssequence.eit_data[\"raw\"].time == end_time)\n",
+    "    for pixel_breath in pixel_breaths[:, 12, 13]\n",
+    "    if pixel_breath is not None\n",
+    "    for end_time in [pixel_breath.end_time]\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1dade889",
+   "metadata": {},
+   "source": [
+    "### Compute TIV with different TIV methods and timings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "be28cb94",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TIV of global impedance determined on inspiratory limb of breath\n",
+    "tiv_result_continuous_inspiratory = TIV().compute_continuous_parameter(\n",
+    "    ssequence.continuous_data[\"global_impedance_(raw)\"],\n",
+    ")\n",
+    "tiv_result_continuous_inspiratory = np.stack(tiv_result_continuous_inspiratory.values)\n",
+    "# TIV of global impedance determined on expiratory limb of breath\n",
+    "tiv_result_continuous_expiratory = TIV().compute_continuous_parameter(\n",
+    "    ssequence.continuous_data[\"global_impedance_(raw)\"],\n",
+    "    tiv_method=\"expiratory\",\n",
+    ")\n",
+    "tiv_result_continuous_expiratory = np.stack(tiv_result_continuous_expiratory.values)\n",
+    "# TIV of global impedance determined on mean of inspiratory and expiratory limb of breath\n",
+    "tiv_result_continuous_mean = TIV().compute_continuous_parameter(\n",
+    "    ssequence.continuous_data[\"global_impedance_(raw)\"],\n",
+    "    tiv_method=\"mean\",\n",
+    ")\n",
+    "tiv_result_continuous_mean = np.stack(tiv_result_continuous_mean.values)\n",
+    "\n",
+    "# TIV of pixel impedance determined on inspiratory limb of pixel breath based on pixel breath timings\n",
+    "tiv_result_pixel_inspiratory = TIV().compute_pixel_parameter(\n",
+    "    ssequence.eit_data[\"raw\"],\n",
+    "    ssequence.continuous_data[\"global_impedance_(raw)\"],\n",
+    "    ssequence,\n",
+    "    tiv_method=\"inspiratory\",\n",
+    "    tiv_timing=\"pixel\",\n",
+    ")\n",
+    "tiv_result_pixel_inspiratory = (\n",
+    "            np.empty((0, n_rows, n_cols)) if not len(tiv_result_pixel_inspiratory.values) else np.stack(tiv_result_pixel_inspiratory.values)\n",
+    "        )\n",
+    "# TIV of pixel impedance determined on inspiratory limb of pixel breath based on continuous breath timings\n",
+    "tiv_result_pixel_inspiratory_continuous_timing = TIV().compute_pixel_parameter(\n",
+    "    ssequence.eit_data[\"raw\"],\n",
+    "    ssequence.continuous_data[\"global_impedance_(raw)\"],\n",
+    "    ssequence,\n",
+    "    tiv_method=\"inspiratory\",\n",
+    "    tiv_timing=\"continuous\",\n",
+    ")\n",
+    "\n",
+    "tiv_result_pixel_inspiratory_continuous_timing = (\n",
+    "            np.empty((0, n_rows, n_cols)) if not len(tiv_result_pixel_inspiratory_continuous_timing.values) else np.stack(tiv_result_pixel_inspiratory_continuous_timing.values)\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "283b0e1a",
+   "metadata": {},
+   "source": [
+    "### Visualise global impedance TIV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "2f2bb839",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2d225f850c214596bc942a2fd702530a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=640.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "## Plot results of inspiratory TIV method on global impedance\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(continuous_data)\n",
+    "plt.plot(continuous_start_indices, continuous_data[continuous_start_indices], \"*\")\n",
+    "plt.plot(continuous_middle_indices, continuous_data[continuous_middle_indices], \"o\")\n",
+    "plt.plot(continuous_end_indices, continuous_data[continuous_end_indices], \"x\")\n",
+    "\n",
+    "# Plot vertical lines at middle_indices\n",
+    "for i, mid_idx in enumerate(continuous_middle_indices):\n",
+    "    plt.vlines(\n",
+    "        x=mid_idx,\n",
+    "        ymin=continuous_data[mid_idx] - tiv_result_continuous_inspiratory[i],\n",
+    "        ymax=continuous_data[mid_idx],\n",
+    "        color=\"r\",\n",
+    "        linestyle=\"-\",\n",
+    "        label=\"TIV\",\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "68dcd6fb",
+   "metadata": {},
+   "source": [
+    "### Visualise pixel TIV based on pixel breath timings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "1231ccd7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d4ea083511c3435ea1453079376c5799",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=640.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "## Plot results of inspiratory TIV method of a single pixel\n",
+    "\n",
+    "pixel_row = 12\n",
+    "pixel_col = 12\n",
+    "\n",
+    "pixel_data = ssequence.eit_data[\"raw\"].pixel_impedance\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(pixel_data[:, pixel_row, pixel_col])\n",
+    "plt.plot(pixel_start_indices, pixel_data[pixel_start_indices, pixel_row, pixel_col], \"*\")\n",
+    "plt.plot(pixel_middle_indices, pixel_data[pixel_middle_indices, pixel_row, pixel_col], \"o\")\n",
+    "plt.plot(pixel_end_indices, pixel_data[pixel_end_indices, pixel_row, pixel_col], \"x\")\n",
+    "\n",
+    "# Plot vertical lines at middle_indices\n",
+    "for i, mid_idx in enumerate(pixel_middle_indices):\n",
+    "    plt.vlines(\n",
+    "        x=mid_idx,\n",
+    "        ymin=pixel_data[mid_idx, pixel_row, pixel_col] - tiv_result_pixel_inspiratory[i + 1, pixel_row, pixel_col],\n",
+    "        ymax=pixel_data[mid_idx, pixel_row, pixel_col],\n",
+    "        color=\"r\",\n",
+    "        linestyle=\"-\",\n",
+    "        label=\"TIV\",\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d90dcee",
+   "metadata": {},
+   "source": [
+    "### Visualise pixel TIV based on continuous breaths timings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "ee772f3f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5a521699adb94b11bbd7811cd69b2ecd",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=640.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "## Plot results of inspiratory TIV method of a single pixel based on the timing of the continuous breaths\n",
+    "plt.figure()\n",
+    "plt.plot(pixel_data[:, pixel_row, pixel_col])\n",
+    "\n",
+    "for i, glo_mid_idx in enumerate(continuous_middle_indices):\n",
+    "    plt.vlines(\n",
+    "        x=glo_mid_idx,\n",
+    "        ymin=pixel_data[glo_mid_idx, pixel_row, pixel_col]\n",
+    "        - tiv_result_pixel_inspiratory_continuous_timing[i, pixel_row, pixel_col],\n",
+    "        ymax=pixel_data[glo_mid_idx, pixel_row, pixel_col],\n",
+    "        color=\"g\",\n",
+    "        linestyle=\"-\",\n",
+    "        label=\"TIV\",\n",
+    "    )\n",
+    "\n",
+    "for i in range(len(continuous_start_indices)):\n",
+    "    plt.axvline(continuous_start_indices[i], color=\"red\", ls=\"--\")\n",
+    "    plt.axvline(continuous_end_indices[i], color=\"red\", ls=\"--\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "cell_metadata_filter": "-all",
+   "custom_cell_magics": "kql"
+  },
+  "kernelspec": {
+   "display_name": "ALIVE",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/test_pixel_breath.ipynb b/notebooks/test_pixel_breath.ipynb
new file mode 100644
index 000000000..5a12e884a
--- /dev/null
+++ b/notebooks/test_pixel_breath.ipynb
@@ -0,0 +1,175 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "%matplotlib widget\n",
+    "from eitprocessing.datahandling.loading import load_eit_data\n",
+    "from eitprocessing.features.pixel_breath import PixelBreath"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load a sequence from file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sequence = load_eit_data(\"tests/test_data/Draeger_Test.bin\", vendor=\"draeger\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Select a small portion of the sequence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ssequence = sequence[0:1000]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Perform pixel breath detection on pixel impedance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eit_data = ssequence.eit_data[\"raw\"]\n",
+    "continuous_data = ssequence.continuous_data[\"global_impedance_(raw)\"]\n",
+    "\n",
+    "pb = PixelBreath()\n",
+    "breath_container = pb.find_pixel_breaths(eit_data, continuous_data, ssequence, result_label=\"pixel breaths\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Visualise start/end of inspiration and expiration based on the pixel breath detection"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7fbea82b1c90>]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b01d2eb9fc9b422f985176211e1b6650",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADrR0lEQVR4nOz9eZxlVXkujj/7DHVq6KrqkR6gu1EQUIamQUG4DhD6iq0hKkYUE1GM5ia5xuT2jSH4S5Ak5hKTe9UYENSgaOKshBBjyBdIFA0gNtAKEpShJ4Yeqqeaz/z745y19trr7H32Gt5dXYd6n8+nP13DqVW79ll7rXc97/M+b9BsNptgMBgMBoPBYCwY5I72BTAYDAaDwWAw5hYcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgIDB4AMBoPBYDAYCwwcADIYDAaDwWAsMHAAyGAwGAwGg7HAwAEgg8FgMBgMxgJD4WhfQC+j0Wjgueeew/DwMIIgONqXw2AwGAwGwwDNZhMTExNYs2YNcrmFyYVxAOiB5557DmvXrj3al8FgMBgMBsMBu3fvxnHHHXe0L+OogANADwwPDwNoTaCRkZGjfDUMBoPBYDBMMD4+jrVr18p9fCGCA0APiLTvyMgIB4AMBoPBYPQYFrJ8a2EmvhkMBoPBYDAWMDgAZDAYDAaDwVhg4ACQwWAwGAwGY4GBA0AGg8FgMBiMBQYOABkMBoPBYDAWGDgAZDAYDAaDwVhg4ACQwWAwGAwGY4GBA0AGg8FgMBiMBQY2gmbMCeqNOh7a9xD2T+/HisEVOOuYs5DP5Y/2ZTEYDAaDsSDBASAjc9y18y785QN/ib3Te+XXVg6uxB+d80fYtH7TUbwyBoPBYDAWJjgFzMgUd+28C1u+tyUS/AHAvul92PK9Lbhr511H6coYDAaDwVi44ACQkRnqjTr+8oG/RBPNju+Jr33sgY+h3qjP9aUxGAwGg7GgwQEgIzM8tO+hDuZPRRNN7Jneg4f2PTSHV8VgMBgMBqMnAsB77rkHl1xyCdasWYMgCHDbbbclvva3fuu3EAQBPvnJT6aOe8MNN+D4449Hf38/zj33XDzwwAN0F83A/un9pK9jMBgMBoNBg54IAKemprBhwwbccMMNXV/3j//4j7j//vuxZs2a1DG//vWvY8uWLfjIRz6Chx56CBs2bMDFF1+Mffv2UV32gseKwRWkr2MwGAwGg0GDnggAN2/ejI9+9KN4y1vekviaZ599Fr/7u7+LL3/5yygWi6ljfvzjH8f73/9+XHnllXjZy16Gm266CYODg/j85z9PeekLGmcdcxZWDq5EgCD2+wECrBpchbOOOWuOr4zBYDAYjIWNnggA09BoNPCud70LH/rQh3Dqqaemvr5SqeDBBx/Epk2hBUkul8OmTZtw3333Jf5cuVzG+Ph45B8jGflcHn90zh/Ffk8EhVedcxX7ATIYDAaDMcd4QQSAH/vYx1AoFPDBD37Q6PVjY2Oo1+tYuXJl5OsrV67Enj17En/uuuuuw+joqPy3du1ar+teCNi0fhM+fsHHMZhbFvn6ysGV+PgFH2cfQAaDwWAwjgJ63gj6wQcfxN/8zd/goYceQhDEpxqpcPXVV2PLli3y8/HxcQ4CDbBp/SZsXb4an/vx3QgKE/jqe1/HnUAYDAaDwTiK6PkA8Ac/+AH27duHdevWya/V63X87//9v/HJT34SO3bs6PiZ5cuXI5/PY+/eqEXJ3r17sWrVqsTfVSqVUCqVyK59YSGP+vQJAIBXrHoF2ajcYo7BYDAYDHv0fAD4rne9K6LlA4CLL74Y73rXu3DllVfG/kxfXx/OPvts3H333Xjzm98MoKUjvPvuu/GBD3wg60tekGg2QzPoeqOJfM6freUWc4xeBB9aGL2Iux7bi10Hp/HeV73oaF8Kgwg9EQBOTk7iySeflJ9v374d27Ztw9KlS7Fu3TosWxbVlxWLRaxatQonn3yy/NpFF12Et7zlLTLA27JlC9797nfj5S9/Oc455xx88pOfxNTUVGLQyPBDQwkAq/WG94YnWszpXUZEiznWFzLmI/jQwuhVvO9LWwEAG9aO4uz1S4/y1TAo0BNFIFu3bsXGjRuxceNGAK3gbePGjbjmmmuMx3jqqacwNjYmP3/729+O//t//y+uueYanHnmmdi2bRvuuOOOjsIQBg0aSpxWrTe8xuIWc4xeBPfFZrwQ8NS+qaN9CQwi9AQDeMEFF0RSiGmI0/3Ffe0DH/gAp3znCPWGygCav5dxsGkxR6k3ZDBckXZoCRDgYw98DBeuvZDTwYx5jSMz1aN9CQwi9AQDyJg77Bufxb1PjqW/0BIVhfXzZQC5xRyj18B9sRm9DJWA4QDwhQMOABkRXPT/vo93/t2P8B8/p22JV66GQV+l5hcAcos5Rq+BDy2MXoaawRmf5QDwhQIOABkRTJRrAIA7H0tmK1xQroV6PF8GkFvMMXoNfGhh9DJqagDIDOALBhwAMmIxW6EtoCjX1BSwnwaQW8wxeg18aGH0MtRDu+fyzZhH4ACQEYuZapYBoB8DCIQt5oYLyyNf5xZzjPmIuTi01Bt1/HjPj/Hdp7+LH+/5MVfBM8hQ46jvBYmeqAJmzD3IA8AqXQpYYNP6TXhqx3r81ff/FUFhAv/nkvPx1lNf4838sVEvA6CfB+LQ8pEf/gXGa2Gh1crBlbjqnKu8Di3sL8jIEuqa3WhwMPhCAQeAjFhME6eAZwlTwComyw3ZYu74RRtIDKZ5I2VkNQ82rd+EfXtOwJ/82z8jKEzgf75mIz54/sVe85ZN0RlZo6oEfbUGzQGecfTBKWCGhHrKm+0BBhCICpKnKzWvsdiolwFkPw9qjQD16RNQGz8TawfO8E77sik6I2vUlDWbOh1cqTXw2Xuewi/2TpCOy0gHB4AMCeqgT4Vq/eJrA6PiSCQAdL9+3kgZwNzMA3X+1zwPQ+wvyJgLqIf2KnEK+Kpv/xT/57uP44NffZh0XEY6OABkSMxWs6P21SKQGuECMj4bsn4+ASBvpAxgbuaBKoHwfRbYX5AxF4jMWcIMDgD848PPAgAe38MM4FyDNYAMCZUBpGTpgKgPYJ1QQ6KmgGc8UsC8kTKAuZkH1TodA5i1vyAXRDGAaNqXK4JfOOAAkCGhBmll6gCwmk0RiOpK7zMuG/UygLmZBxVCNlz4C+6b3hebtg4QYOXgSid/QS6IYghUG43Yjxm9DU4BMyRmKuGDXSbWA85GGEDCAHAmZP18xmWjXgYwN/MgwgB6Pguqv6B+zT7+glwQ1ZvIyguyWsuuCIRx9MABIENCDdJmCRnAeqNJqntSEWEAPU6m3F2EAczNPKgQpoCB0F9wUWFZ5OuupuhcENWbuGvnXbj42xfjvf/2Xlz1g6vw3n97Ly7+9sUkwbq6ZlO6OFDrCRl24ACQIaGmpigZQF1PSPXQ1+qNSOGH78lUbKTL+o+JfJ27iywsiHlQwtLI16nmQaSikohN2bR+E84vfhzTO9+PmWffgQtHrsEdb73D6Vq5IKr3kDVjG2kFR3iAnyqH63c+F8+6M7IDawAZEiozQakBVLWFAB0DqHcroWJTVuTOwqVf+AcEhQm84rj1+Ie3Xs7M3wLDpvWbcFYwgrt33I+gMIG/uOR8/CpBlxkgeiCi3ExrDUhT9CW59c7XygVRvYU0xjZAgI898DFcuPZC5zmRVQZnshKV8DSbTQQBB4JzBQ4AGRI17SGv1Rso5P1JYj2YpGIAddsaqoVpqhJ2FynWVpAFf1xR2VuYrjTlPHjJ6Jlk75W6mVIK6tUDUcXjGeOCqN6CDWP7ilWvcPodtQhrTTdnp8pR54ZyrYH+Iq+JcwUOABkSemBWIQoAdYNpqkAtq3EnFW/BWaKWeFxR2XuYUDanKiEjXsmoq8KMciCq1PwLorKoLGbQY06sixrZ2MBMagHgTKXOAeAcgjWADAnd4b1MZAytM4BUaS89tUx1Mp1S0hJ6mtkFXFHZm1CDf0rrompGKWD1en0YwKwqixnZYC4Y20gruIx8XAGa9ZZhDg4AGRI6A0ilA9QDSToGUE8t04xbVdgT3wWJKyp7F9H2V9kwgJTptEgKuOY3n0QhzIpBLoia75hr6yLKw9CeI7ORzzkAnFtwAMiQ0AMonWFzRUcRCNECklUKWN2gZzxTwFxR2buIBGqURVHVrFLAtIzlpvWb8K03fkdWFk/vfD/+9dJ/5eBvnmEurIvKhP2rVTynBYBUWSeGGTgAZEjoLAdVb+DOFHBGRSBEC5N62tWDTFvMhT4nK/PXhY6sWA/1QERZUakeVqhaOdYbAerTJ6A2fibq0ydgsswb9HyEYGwHczRekDoou9eo2HNkJvI5ZXqZkQ4uAmFI6GwEVXqqQ6s3z4tA1L/bNyWRtT6Hi0uyQ7QqntIWKRs9lfqcUQWA+jgz1ToWk4zMoMam9Zvwn4tX4UsP/zuCwgT+52s24oPnX0yi1SxnFADumyhHPqc8aDHSwQwgQ0IP+HyE5Cp0po5K+D6bURGIugjNVOtoNudnizkuLskW6vynCqgAPZ2WEQOYARsO0GUFAGaus0Cj7QVZGz8TxxRPJSvU0b0rfdZEFdMVei9XhjmYAWRI6Cc7Kt1TdhrAbAJLdbFrNltWBcP9RaexhD5ny/e2dHzPR58zF+avCx1zkwKmecaazaZWBJIRA8i2SPMaFWWe6h57fuNG50G13kRfwd+wucMjlpBdZKSDGUCGhB7wUW16nVXAVMyizgDSp4AB4Ev37fQaT+hzhgvLI1/30edwcUn2qGaVAs6gCKRSb0DdO6kYQH2D1ll3FzBznR3UtUtts+aLjnaeRM+D3nKUsiqekQ5mABkSujaPTgOYlQ2MrgEk6jGsXd/BqYr3mJvWb8LTO9fjY9/7VwSFCVx6xktx3RvexO265ikajWaEUc4qBUymh63oh7eMUsCeDCAz19lCTaFSHQKAzvlPddjuWMNZAzinYAaQIRHXCYQCnSlg2sCyVMi1x6VPAbd+D81JuloPKyqHmid7bXDcritb6BXxmaWAiZ6Fzr7Y2TwLvgwgM9fZQp2nlJYq+jxoEHu59hfbazhXAc8pOABkSHRoAKkCtYyMoEX6YFGp0B6XlvUYaLckolpI1dPuEc0B3xZzYf7aC8iqkEAP+KgCtWazGWEAqXSrHQEg0bOgHwJnKn7jMnOdLdQ1m+rgCnTOA7I1vBZdw7kKeG7BKeAexHSlhs/dsx0Xn7YSp6waIRtXD/ioAkCdNaCrAm5d36L+Ag5MVeg6gdTDcWeqdbKOKGoAqLdAskVWxSW9hCwLCTr1sHQV5moBJdmzkBED2FkFPL9tkRY6ogFgdgwg3bxtjTtUKmBsssIM4ByDGcAexM0/2I5P3PULvP6TPyAdt8MH0KOhvArBoAlGjboTiDw9kvkANiPjUp2k1arl8Vn/Cj1RXDKQWxr5+kJo15V1IUFHCjij/tV1IjsNnQGkCljjfAB9IJhrLHDmOiuozBxlANip4/Yfu9lsSnKAGcCjAw4AexBP7Z/MZFz9oabqfyoWj6FSPvb3uEIEgEMiBUy16QkGUAaA9AygL5MisGn9Jmwa+pRs1/X+E/8Kd7z1jhd08DcX/ZX1jYjOEikjJqVdnCH0sFTjdlQBe87bsG1ZlAkFaJjrhe4tqAbseoWt17ja2kqxhKtsuJTxcAA4p+AUcA9i1eiA/Hi2Wkd/kSbNl92mFwZqY5MV8vTBcHvxoBq3qgWsZBpA5X5SBYAAUGubvwLA0vzLXtBpX8CukOAVq17h9DuySgFnFQAKZm64v4jyZJmMsewsiPK/D5vWb8L/OOVPceMjH0dQPCK/vnJwJa465yrnwwt7C2aZAqbXmKrSIGodN8MMHAD2IETFFADsPjiNl6wcJhlXZ9DIfABFQNVHS/PLFHC/GJe2CGRRqWX+TJUCVk/kvqk0Feqp2be4pBcwF4UEnWw4beGSAHUAONJfwNhkmbAvdvT6qMyFT1v8Kkw9WUR+cDuCwgS+9O5NOHf1y50PL0ISoLPCQhLwQpdECNQysi7KQgMo1u8gAAY5BXxUwCngHkRUS0a34eubHJkNTDXKqJEXgcjTI60GcLifNgWs3k/fakoV6vu2EALAuSgkqNSyYcN1c16yALAiGMDWnG00aaw6dOZnv9a71RWtZywnbZFeunijV9o3a0lAryCSAp7nVcBiXygVcijmWul/bgU3t+AAsAdBaSeiopMBpK0CHuyjpfn1IhDKrgrquFQBoHp9pClg5X06Mk03H+arnmouLHCyqoif1Bg06ipgwYYDNJu0vvHvGZ/1HhPovJ/6fbEBewuGyKwIJIO2myJA7S/mUci3A0BuBTen4ACwB6EGD++9ZSuZKacIUAb7Widxah9A6kCtrBWBkGkAFRsYgNIIWmEAq3Wyhupq2uTwjH/XEqCVUrv42xfjvf/2Xlz1g6vw3n97Ly7+9sXzok1XWEjQCSoLnI4AkGhudQSARHMg1MOGPaspDlpibh27uKU73nMkmwBwquIeALK3YIisNIDTFXrmWszZvnwOhXwrFOFWcHMLDgB7ELp+jOpULk77g8RavbJkAEUVML2HFOW4VZ0BJCoCUa+v3miS3V91o6dghHuhV6uwwFnWf0zk61QWOFkVRAkN3TDxYWgmhgGkmF8iiFi/bBAAZQAYvbYZjxZz7C0YQp1PlClgPUCnZJf7IilgZgDnEj0RAN5zzz245JJLsGbNGgRBgNtuuy3y/WuvvRannHIKhoaGsGTJEmzatAk/+tGPuo557bXXIgiCyL9TTjklw7+CDvpi6ZM+UVGRmrp85HNfhDYwtExd6CEltIVEwvdaNhpAPcVOVQiiLpqHPVPAvaSn2rR+E/7m/G9KC5yz+z5MZoGTVQp4ov2sjgy0mLoGEQMonlVxyAJonjMx7rqlrQBwolzDBIHuuNNg2v3+clecEGrKnrIVnDi4CC9XirklDlV9BYUB5CrgOUVPBIBTU1PYsGEDbrjhhtjvn3TSSbj++uvxyCOP4Ic//CGOP/54vO51r8P+/d0p/1NPPRXPP/+8/PfDH/4wi8snx6wWkPhu+gJi8Rgq0VbVlrViDTJtoe4DSMUANnQNYDbtxah8utT7OeFpMN1reqrpSlMWEgw2TiKzwNHnKNXcEhvpaDsApBpXPLv9xTzaZAqJoF7ch8WDfZK13EuQcaDsMKJKAvQgcKF0xRHIIgVcqTXk2jUyQKfjlgxgPhdqAJkBnFP0hA3M5s2bsXnz5sTvv/Od74x8/vGPfxw333wzfvrTn+Kiiy5K/LlCoYBVq1aRXedcYVZjAKkKQSq1bAJAsbgPUlcBixRwH206raoFwlRMqL5oHp6p4piRfu9xKft/9pqeSrUl0XVKPtDnPtUcmJyNBoBUz4K4PqGnqtQaJLrFisLSrBrtx8S+Sew5UsaJx/hZT+n307coSkgC4nwAfbwFs0C9UcdD+x7C/un9WDG4AmcdcxZZcKqugVRzdlpJ/470F7F3vEzKLreqgFtcFFcBzy16IgC0QaVSwWc/+1mMjo5iw4YNXV/7xBNPYM2aNejv78d5552H6667DuvWrUt8fblcRrkc2iCMj4+TXbcN9NTh4Wka4X+lg6nLxgeQTgMY1T3RGUFHi2GEpUYuF59iMoUeoL7uE/fgFx/djL6CHxGv3k8fLRXQe3oqVZtEGwBqGkDiKmDqAFA8Y8V8DoVcgAqAOsHzq27Sq0b78cS+STx3ZMZ7XP3+6v3CXbBp/SZcuPZCnPTRGxAUJjCUX4I7PvQ/5hXzl7VZdUU7DDabTQSB37ol5mxfIYdSka7TTCWSAm5dI1WxFcMMPZECNsF3vvMdLFq0CP39/fjEJz6BO++8E8uXL098/bnnnotbbrkFd9xxB2688UZs374dr371qzExMZH4M9dddx1GR0flv7Vr12bxp6RCBD7HDJcAEDKAOvNFVgWsp2r9x202mzGBJa0RtKqnotCmxI2x6+C0/7jKZupbXdxreio14KW01skqBSzYFJFKI2cAC60AEKCZs2INKOYDGbRSmEFTagBVNJqBlAQ0pk+Yd8Ff1sVVKoPWaNLMW3GwWlQqIJ8jDADVIpA8M4BHAy+YAPDCCy/Etm3bcO+99+L1r389LrvsMuzbty/x9Zs3b8bb3vY2nHHGGbj44ovx3e9+F4cPH8Y3vvGNxJ+5+uqrceTIEflv9+7dWfwpqRAPzgrqAFArAqHufzrUDqgomAlV3yIYSzLz2/b9HSgqnmoE1xw3RsmT/WuNG130fZjbubBYoYQaSGSRAhbsLHVBlKi0JwsAYzdTwk06H45LUgCgF0QRvXfqHKA6wFJgLoqr6o0m9LeGQgcoGMDBvrw8XJAYQauyBa4CPip4wQSAQ0NDOPHEE/HKV74SN998MwqFAm6++Wbjn1+8eDFOOukkPPnkk4mvKZVKGBkZifw7GhCBmQgAyYpAOlq2ETN1IrVM6CLfGlepfCSoqoxjACkWprj7SXGP9cXYt7pY6KmGC1EGncpihRLq376PyA4JACrt93soI09MMbeo+1dH0mkE1xwyi3nkCTf/LFLAQFSvVq41yO6vL+aiuCru/aYoNJtud68Z6ivIOUCfAm4fWubJ+7VQ8IIJAHU0Go2IXi8Nk5OTeOqpp7B69eoMr4oGkgFclA0DOESoAVRP4ZQ2MGLDyOcC9BdprS/E3z1AnQKOuZ80mymtoB5oBYG/fuxnpMXK65deS2axQgk1MB+freG7jzxPNG6UqaOu1pUBIJUNTHvcUj6HAmWaLia1TFldLECVAtZb7Y3Pk9aIc1FcFRsAEjCA4kA50JdHPqA7BFQU3WpRdgKZP6ztQkBPBICTk5PYtm0btm3bBgDYvn07tm3bhl27dmFqagof/vCHcf/992Pnzp148MEH8d73vhfPPvss3va2t8kxLrroIlx//fXy8z/4gz/A97//fezYsQP33nsv3vKWtyCfz+Pyyy+f6z/PGhWdASRa5MqaATJFCmU2hqmj2EBEkNNfyMlTKeDPetQbTblxFolTE+LvvuK89crX6FPLVOm0chVST5WvvGTepH1V6IH5H9/2KM24QgbQRy2HEJtpeBii6AgTJ6in6QQSagBpGUD6QwsQZQCB+dMbey6Kq9QDpjhgUASAcq0thnOLwnNVlS2IQwtV4SHDDD0RAG7duhUbN27Exo0bAQBbtmzBxo0bcc011yCfz+Pxxx/HW9/6Vpx00km45JJLcODAAfzgBz/AqaeeKsd46qmnMDY2Jj9/5plncPnll+Pkk0/GZZddhmXLluH+++/HihXzo7qxG8SDI4tACKqAm81mJjYwYsMLgtBElGIDEYFlfzHUpQD+rIf6NxfzAWk6TaS+3//qF8uvUWzS+hhU6TR1HKpuM9TQg9+VBLY6QLgRyRQwVbWutC4Kg2mKoWOLQIirgLPQAIoCVaoAUGcAqQ7HvpiL4ipxwMwFagDof1/Fe1NSZAAUioiqMrdCH0BmAOcSPWEDc8EFF3Q9Jd96662pY+zYsSPy+de+9jXfyzpqCBnA1mZHccpVNwvB1JEEgFX1IafTeYSn0nyEAfQdOxoAtvypZtEguWaxuJUKOaxdOoDdB2cy0VNRMYCq3yRVCzBq6BvGsYupAkCNASQ2RVflBbVGw5tdLUumjjgFrLA0edLAsm0s3F/EkZnqC54BFMVVW763peN7VMVVFWUOlAp03ZzEnO0v5uScImUAIylgZgDnEj3BADJCqJVelClgNd0rfQBrdJVepULI1NE0Em+fSos5BEFANra6uRXzdCfThvK+FZRNmrK4pK8dYFO1mFPT98/P0wBQZ+aWt3Wx3uPqfbGJU8Ci0AoAKGRPsZ5qhEUgqhyCYvMPO4y0rGWo2llOVeanBhDIvn+1WEtaAWBrLaBNAdMWAkVZa5ECZgZwLtETDCAjhHqiU21gfI2K1XGzSAH3F3ORCjJfg1LRDq+/fdLN5wLUGk0yBjCfa2meZI9Kz0BN1aoV8gGpoF4s/MP9BRyYqpD1AFUDSYo5BtB3QVDTXo0mnV2LeL8HiVPAcT17Wyl8PwZQPQQUCG1gqiqzSMjSVBUZy84D0zg0RROoTWuBpG9rRGpsWr8Ja/pejks+9yUEhQmctuo4fPutv06ir1X1msK+iGItKCtrrfgdFIf4shIAFrkV3FEBB4A9BpWpEwFgs9lq0i6MWp3GbT+MhVwgT48URSAqAyja/QCtTUQ89C5QhclA67rL8PcYDBmP1rUV5YnX716oC1sxR5sOF8Hl6EARB6YqmCBiU/S03GytLhkxF2TRBSEM1AqYLNdkKtQXeqBWrTdIuirEpYCpq3WLhCyNGKOYz5GaAIv37Zi2jOUQUTejDgZwdv4wgAKNRsusGgCCxYvJiquiKWDBABJqAIs5TFez8JjMhwwgp4DnFJwC7jFEmLq+vCysOOLpBRjZQPJ0dHwoIM4hn6cr1lCFyQCU1IRnoKZseADIGEB1wYwwgJ7X22JTWx8vW9QHAJgg2vT0VLIusLdBVl0QxP0TgRp132YR8DabtKyHGkhT91WlehaAMPVdVOYshQZQrC3UXqY6A0iVAq436vjxnh/ju09/Fz/e82Mvw2Z1XaXoqiIQTQHTVQGHGsBQxtPIqnKdU8BzCmYAewxqqicIWu2ZZqp1HJ6pYB0Gncet1FsLWl8hJ9MHFAu9ZACLuUi1brXeiPj3+YwLgIxR0/V0VAtTJAWcU6uL6YpWlg61AkAq4buePnItLknrghAgwMce+BguXHuhNRsiNr2hUgGYKNOlgLV+0EBrbhU8yZqywlyLtHV2bbUo2OXWGIWcKuGg0wAeM9IKAA9OV0gYVp0BpEgBUzPX6hr1i72T+NoDu/COc9Z5X6eaAhbrIiUD2B85XBCz1oRzlmEOZgB7DOpDA4Qiat9NX23LIxlAitOjrAKmtWtRT7uAwgCSpYBb44q0te+CJ66rkAuIi1bC92hZuwBifIYoBaxtHtNVt3Gz7IIg3hdqBjCuGwy1JEJW61KyKXnaIpCwJV5AWqkZagBbKeBKrUFSvCSqgEVmxDcFnAVzrb8vf3TrI17XGI7bXmPUFDCBBjBMAdMW8oVzNiDtX80wBweAPQb1lAcAI23dn28KpRIjyKV4GMUJtNRh2OwZUDXitXpUAVWx0BqPajMVPy/Go6p6U+/j8jYDSKV70hk/1xRwll0QBDMrqmqp+r/KftBKqtb3QFRXipRKhRyEJJZETyUOLoUc6SYdHlxCDSCN/qs1xuKBotTx7hs379yUBBGsCGbRhwHMqn9vVixXNaIBbB+ICM38I/ICSg1ggbZwiWEODgB7DGWdARygYQBVBqGPSPcGRPUjWdi1iEAqT9T9oKoxi1QLk1ycc3pqma5qefFgOwAkSgHrDKBrCjjLLggiRTlYItYA1sNAjSrtpV5bSxLRmgu+eqpmsxnxVKMU1KsHF8rAUu1dfNySlnRl96Fp73HFeiPsgHz0sFkx13FrVIOkYCdk1CgZwNDJIU8qA4gjHVgDOLfgALDHoJ6agNCyRTdA9RlXdfz3XezLijgdICzWEBtTLsqoUTGAfTIFTFtcEjKANJupWrU8QnQYEJipiOC9dS9c51iWXRA6GEDiFHAxH6Y+fcdW9Vh9+ZYGEKDQrYY/Ty2oj9rL0LeYK+QDrF0yAAB45tCM97gi4FnSPgz5pJWzYq7jDtaTnus3EJprF/I5Yg2gWgRCd7jgKuCjDw4AewxVTaMmCinEZu2KyGmsEE4L3xRlWakCBgCq3rp6QEXG0tSj95e6WKOgVxd7bqbq9Y70t4IgKu8z8d4tG2qxKa6bqeiCEAffLghiHlG2vmqNQ18VL8YU/pJiDviyP2qar0SYAu40LydMLbfH6MuHDOCzBAGgYK2FNtqnK05WzHXc2ufr4gBoPoB5OiNo8UxRM3XMAB59cADYY6hoDJXY+HwF1OpJX/Xno9r0hCaFqlq3pgieAbrAUrW9aP0vrteXsQw3PHV8KsayVMjJDi5U1hJiTi0ZKrbHdZ9jS4OzMTrxG+hrLol8fVn/MV5dEARjIJhwKgZQsKijA0VlDniy4YqWCgByAX1qWTWCpjQvL+YDqQGk7DFczOekfymFfZG4x0Ia4xMAZsVcx62pFDY4oS46h1KRzgamqqxdRUJ5UNQGhjWARwNsA9NjqGopYFHt5ttLM8J4KIbN/mmv6PVSsQhyscvpDCCNBlAPLKmKVkLGkmiTroWaxUHCALBWD/sfL20zgD4yg/d/cSsOTJ0I4EPID25HUJhAszaMwSUbsGn9a72uEwj7V1MVgQhj4tGBPrIUsLBaEgEgVfcD1cQ9lwvI2JSOtoiUGkCFuRam2NMEPawFW7VkyD8FrPbvbTaBOIcaF+ZaXcPFe3d4xt8IW10LQg2g/z1VPSZJ2wxGdKtcBXw0wAxgj0Et1gCgLJ6eGkAlUMvlwlZCs76bnhYAhg3liQM1RbfoN270/tIVgYQ2MICiLfS8DyKoKOZzWNQOgnQvNBeo7/sysZl6jHtgSmxwOdSnT0Bt/EzUp0/Az56d9LlMJQXcCn4pGA8gZGSWDBbJUsCziiUSELLL3jKAjkMWFcseXpfqXUmpAewrBBgiDQBb4wpW0Tczsmn9JvzVq/8vmrXRyNcHc8ucmWvxvrzmJctx7ouWAqBhAMtKCpiyF7AarFP69bEP4NEHM4A9hopWpSoYwBnPaq+41HKl1sCMZ2BZ1TR1VOk0WQSiFVXQaQCDyP9UKWBdW+if/hPjBjINOlWueZvqqsGe0FP5BJb5XJAYnNcbzYhFkA1E8CRMsCfLNcxW614m45VaA5NtFnXJYB9dClgL1KTdEhGz2OGJSaQvDYK2bpHQAkStthfBu+8hFgjvsSgCma02vHtYn7/mQkw9WUZ+cDsuOm0Adz86g0s3XIhN6093Gi8sYMvJZ+swQeGWWKsH+wqknUCysgiLYxZrBH3iGeZgBrDHoJ/2BQPow87EjlukOZXrKWuqCkVZBKKlgMl8APNRNoVKT6WngKlsYPoKeRkA1hpN74Vf7bUsKmx9DgN5bUH/4C+dKN+zsUl3/zdx/1aOlLB4sIhmE3hqvx+rKPR/QdDy2aQK1FRPTABkeqqkwNK70EoEablW16E8EbMIhMFlgTgFLObtksGwL7puZ+Q2Zg6NmRNw+ugFqE+fgHLN/R6E2YsAiwfa3XsIeiGL+zfQl5dVwBSaWPVQTLUequPqsiOK+cUwAweAPYasNICZB5ZaUYWvVktq6oSvHhEDKItAqANWzbeQilkMU9aBDNQAfx1gGADmpceezwad01aaoVJBpv58qparCpvykmMWAQCe3OcbALY24+FSAflcoKRqiSyRinoASCOH0GULVP2rJctOVLjUGjsMKqgK2YDwHgtLJMA/sFSLdwYIrlUt1pAMIEEKWKzVQ315JQVMpwHMqgq4qFgMtcbmAHCuwAFgj0HXAPYXaTWAYuEQi/K0b2DZwagRsxN5nQGkYRZDH0DalLV+vVQVoMV8tNPKD58c8xpX6NUGinkMErDBOgM42JfHcL+oLvbp1hAGKStHWm3FDk75sSmq71lrbJrWiOUODWC7uMRXB6o9uwWiZyHx2fWcs3XFXqaPugikqrBg7fvhe4hVD0MUB+OqsnaNEqaAQwaQNgUc9YLMqgpYcZ7gQpA5AweAPQadqROB2kO7DmP3QXcnfV0DKLWF3ingqPZNXDd5EQhRta6uASRrBdfQGUCRAqbdpAX+19e3eY07ozKABBqtnBYAjgwUZeXupEcAqG5OoR7Wb86KAEfOWaI5IN4rPQVMVQWsF4H4MpZ6u8U8UeGSeh8jGkCC6nXVeF6sjb7ZEXkgKORJ5phqYSVSwBQMoAgAB/vyci5QdAKJK9bwfRb07jWRFDAzgHMGDgB7DHqAIjYTAPijW3/qPq5mMD0gdV+eAWCHPokoPSVTwFFNnbcGsBbd/Kk26aSiFX+D6TZjWYg+ykIE74pZxcCbIgWsnvABYNVIv9Qs+gWA4d8v2JlZzzmrs7VkKWDNFJ3qMCSKQMh1tnrhEtEzVukIAGmyDc1mM9J6UgSWPvMLCDWE/UWaoDJsCxlIreIRAhuYmaooAiFOAUeqgGnttoDQeUJ2xmEz6DkDB4A9Bv20/7I1I/J79z99EIcc01+6kFym/YhSwH0dTB1tEUgxT5Oe6iwCoal669xMsyla+fM3nwYAOO3Y0cSfMcGskkobJEjR6X/nqtF+EuPqsnJwoWIA1QIF9X//IhCdqaNNAevPGFVFvK4BpNLZAlENoLdWTzXELoQG077pVTUF3E8wx8KCsFyYAiZgAIVR+0AxT5YCbjabkUMWVRGI3r0GULsjMQM4V+AAsMegb/jD/UVsv+4NePHyIdQbTTzy7BGncfUew6HWhcgGphBExifrBaxZX9SJ0lN92qLknabTexcTdRgJDwStcUU7ON8AW6aAC3kMFP1TwPpGtHKEJgBUnweKzRnoDNapUsB6VxzqFnPFPO2cVauAAVW/S8P+FPMBgiCQ96NSa6DZdL9mNd05UMzLDjaHPStspX9jMU/ijlCLqQKmsYERKeCCLDTyLg7U2NoilSSmFh0XoPNGZZiDA8Aeg84AAkAQBDh++RAA4NnDbv009VRtGABSsRNtQb1g1DxsFIDOIpDMfQC902n6Jk3Uuk4bt48qqBBFIAoD6CMH0N+X/mJoWzNBEABGKjQ956yufaOrAtZsYAo0zKK+JlBXmHf6C9LMWb0i3ndsEfgX2pXbQgZxcMotuPrpM4fx+197GDsPTAEA+gs5Wbg07hGwybVA8QE8Ml31Cn4BYDomBexrA6MyfSVCw2b1fRapX8oCE4YZ2Ai6x6B3qhA4bskAAOCZQ26FIB1G0DIF7FldnKinoi2qINMAJvkAegvqsw1Ywx7DNIvojOoDWPKTAzSbTfm+bD5tFX73l14CACQMYCUmBezLeuhdW6hSwHqg1idZYKq5RexdqaWAxfh0z1j0/oqxXT28xZwV80AEgK4M4B99+xE89vw4btv2HIAWA7hypNUWcWyygkqt0aG9NUFVeb9EAFipNzBTrUvdogsiPoBEKeCKxtRRFcU1muEzJkyfqQ4uDHMwA9hj0Dd8gWMXiwDQjQHUrSSofADDFLAWoHguTFl1AtGLQKgE9Z1Vy0TV0OJ6tQIA/7ZlqvWFqNJ0mwtqIPKXbz1D6lZFi7m9425G0I1GMxJYU2kAO7vXULUvjB/X2xNTD6io+m1rqXA6BjBauFRQ7It87rEsXJIBYCu4crUF2q8ZlI8OFNudYVrXu29i1mlcde0aKOblWu6rA5xRqoCpWsGJ9yOfC6KemEQabtW6qkBkjs8wBweAPQZdSC6wfFHrZHrIcRFJMoL27gTSDlBK2qZHxXpIBpA4pdqnXy9RFbCeWvavqGxXgBKngFUvPMEGV+oNp0BY/RvVzX7dskEAwK4Dbqy1yiL3FXLoJzq0dGoAqZk6jQ33lEN09sWmDli1QxZxIKzOCZ/nTDKAfa1xlw+31sTnHGUxq0f7I58vHigilwtwzHDr664Hl5qmgRSm1fsm3DviAFEbGKEB9K0CDhl22mK7usayA3TzlmEODgB7DLqvnoBYRFy1KXoRyCBxRWVRK6qgYj10BpDK/DYclyYFnJSyprKBkQt0gWZctQhE2MAAbmlgNVBT7WDWL2vpVncenHK6Rj09Rc0A6tWvvnoqsfHnNS9I3w1PmmHrBUbe7Qv1OUuts42O2/qdHgxgJZoCPr1dCf/w7sNoOFzzgJaLFoziMe008H5HBlC/r4vaz9ebb/hP3P6T55zGBMKDj2oEXa03vQ6ZnS4OVBrA1rhqj2aqntsMc3AA2GOo1KKeXwLD7erP8Vm3ALCsFWtQt4Ij99Xr0NTRLB5JaTqqIpBOSw1aXRmVzc6swqb0KV1GXNLA6nutGr4K3ere8bLT/Y14iWWgAdTnrO+hpd7BAFKZjGsV5lQWQ1pbRDINoMYqBUFAwojrGsBT14yikAtweLqKvQ7BWkkLAEfbmkLZG9txnul/vyiGAoAP3/qI05i1ekPOz8FiPuIP63Nw6Swwon0WIgwg0drFMAcHgD0Gve+nwEi7Os21r2pnCtjf+gPoTKlSWWqEQv1o2stfoB69v2R9VTuE+tn4AFKxSrMKAxgEgdIOzn4+iCA3CKInfnFoAUIPMxuE1aQBcrlApv78O4FEN2hhL+PbVUHVU7XGp5lb9Q59KZF3pbgP0mw9ZAB9KlbjshhhlxH3cfUWfn2FHBa159ikw7qo/42L21mWfmmx4nZ/a4oPIBB2cwIgC65soTLzg6VoAOiTBk7sYe4bADajbDhAx1wzzMEBYI8hzgYGAEYG2gygawo4wQh6xnPTC1PLWkUlcWcNcouKjuISms2/o7KUyAS4s9We331QjaABeHUD0f3kBEqFsGXVRNl+3up/u/QBJGpfKDY9qtRyvRHPLNK1GYwGlv562NCvTh0f8Du46IcWIJwbPvdCbV8oMOTRDUS/FlGxW/JkmvUqczXOXFRyqwIWcz6fC2TPXrEm+hSChKbVtPKCWowGkKuA5x4cAPYYknq/Cg1gudZwWph0uxYyI+iEFDCd7mluGDWyBa/D9JS2aCX0WfS7vzNaRWXYD9g9ANTbwQGhcbULc90xZ8mMoKObnmB8ykSpZbExU7WCS5YXEFsiKWuOz9h6cUlrbPoUMKBaDdm/d/q1rG8XLfUXRADoxwCK919Npx6ZcVtvZQFIMS9tVWQlsMchXk/VivesTLR+52NTwMwAzhU4AOwxJDGAi/oKaD/3bptpgg2MdxWwZvlAlULQT6Z5Iv1Ih8E0dUVlTDrNb1z9/oqiFZoqYLGZivnx//1sj/01aho1FYs8+gGHXVuiulV/DWA0qKZjAOO1er7FJfomHaZTqZ6FzmpdPwYwLgXsz1zPVqKsNRCmVKccDrL6tZywYlF7fD+pgc4wq+//gamyU3pdSDPUv52iH3CYEcm1x6Tp2hJrA8Mp4DkHB4A9Br1VmUAuF8jNdMKhEETv2EHR9LzZbHYwlqGImMijjJoB7GAWaYpLksTU3kUgeicQ4hSwYL/EvPuHH+20HksGKPnO5WZYald95myUAazWm14Bu5769E35yXG1QC2OAXIaV2eXiaopq5oWUt2sfTbpuDWMIv0XmwL2MBtX15K/vPR0yawJBtCVEdYZWzVF22y6MYuqBYwAhRm0frgQ6wHgN29VI2gBKrkNwxwcAPYYdF8mFT7pDn1Rpuh5qQYh2Rkra9oU8spHmuvVbXaoWsHp80ENhF2sLwTUIhAAuOzla9u/x37J0PWPKsJDizsDKN4rdeP3CdakSJ9aAyhSwJpm0dest64Va1BVUwp/Qr24BPDbpONkLBRpa/3QAvh1mxH376ZfPwvvOGed/Hq/54FAdzDQGWAXtnJasYARoPAC1OUbIqhsjes+B2r1ZAaQU8BzBw4Aewxi8SwVOt+6IY90WkcRiKL5cg0k1A2I2qhYr9Qk636gb6ZEi5J+f6mLViSzqMwLnzTwtJZOe+MZqwHEz7s06KlEFbJK02nORiu2S4WclEH8Yu+k9XgCelq9n6ggSm78uahGi4pZzGusNfWzEASBnLcURSCRAgACf7k4DeCgLAJx0K62/0ahrxbwrQLWU8AvXT0c+b5LEVM5Jvil0ADG9W0Wz5jPvI3TABaJpAsMc3AA2GPQiypU+ASAZS2QEFXFADDh2Ks1EgCK/qdEaS/JphCb1CYWaxClavWevVRdFfQAu/U993shGBPBoIQ+ky42MJ2LvcBwyd2mQ2eSgiBsB/fWG+/F0/vdgkA9QBko+qX8BMQcyueibIovA5hUBOJ9aIlh6qTW1icA1Fh2dVyf52E2tgikrQH0SAHra61kAB2ZNd1p4P+85XRcfs5a+X0XBjA8XKgBoN91Ap0p4CAISAJL/VkAlHnLRtBzBg4Aewx6KlGF62LXbDYVPVUo9hWnSV9rmVygbnr+iwfQzfyWSlNHa3uQZNjs31UhWajvUwksDhFDMgBsN62vNaxTSnqAoiLU19lfqwjI1GdB3fz/5afPW48JdB4CqPwF9YCCql9rTdukqew09Pug/o66lwaw08uUQsIxE1MEMlhyr15Pki54p4C1wPqYkX5cd+kZ0hjd51rVgGqQoJBP6laVZ5dCuhBrBE10KGaYgwPAHoPufabCtaIy0lFB2UyFufQRz/Zy6rXSsR7RzTRP1aJID6jkqdQzsNQCbKqWShWNTcnnwhSNa5q92WzKOSSYP9WfzFavF8dOCMh0mgNLIQIyVfiublS+zHWfpnvy9xeMbtL9VMyiFqiJZ8EnSGuNG2PXQsCI68Ul6sc+4+pG0IDfwVA3QRbwlQQktfOUHUYc5lk9JlAb9rBYCseNW8P9tYXdU8DMAM4VOADsMeipRBWuFW9qOlbVeI169hfWtVTq+D6LR7PZDFmPDsNmGt2TGJdCmwR0avWoWsHpnmpBEMhrdk2zz1YbELdRzKl8LsBQO9CyTdfqKS8VPmxKXMpP3TwPTVWsxwQ6q2qp7GX0VnChSJ/GBkbXw3ofWmICFXFPvDSAtZhxCTzg4qqAfaQh+hojEGoAXYtA4plFMc9c0tVxOttFHvIKAd27ElBSyyT+gp1zy3feMszREwHgPffcg0suuQRr1qxBEAS47bbbIt+/9tprccopp2BoaAhLlizBpk2b8KMf/Sh13BtuuAHHH388+vv7ce655+KBBx7I6C+gQ1xQJeBa8aZWoamBpQgAnRnAWmew2u+R8hNQF/MisQYwqcWcr56q3GEDQ1sEogbu4ppd11HRlSMIwo4wgGrZYje/4tI9Aj6muiLY61cYQHWcnQenrccEwsNJSSsC8ZmzgLqZailgIt9CvcWcPxveGbjnCQK1uE4gFIx4XBGIT3FYUqA25NkmM6koSjDZLlKDOK9NUWDlyoQD8YEaxSE+ThccOi4wAzhX6IkAcGpqChs2bMANN9wQ+/2TTjoJ119/PR555BH88Ic/xPHHH4/Xve512L9/f+KYX//617FlyxZ85CMfwUMPPYQNGzbg4osvxr59+7L6M7xRbzTlA9mNAbR94EWgJnqqCox4BoBxCz1l+gAA8prw3VcDqBdVUOmpdOaWKmUdVxSU90zTCRuhob5CZD4MOprq6oyaCp8uGyIFFw1Sw1T1zgNT1mMCYbAumA5phl1veDFfepqOygZGT7Grlip+PXs7D3AU1fZxPoAUjHjYvlB9FtwZS73HsoAokHNNrSYx4qJi2cXGK54BbK3fPgxgLUYHSakBjHYCYQ3gXKMnAsDNmzfjox/9KN7ylrfEfv+d73wnNm3ahBe/+MU49dRT8fGPfxzj4+P46U9/mjjmxz/+cbz//e/HlVdeiZe97GW46aabMDg4iM9//vNZ/RneiKuqVeHLAOon0qVDfQCAscmy1Xhy3JiFniLtpd6HsAiEVgMYppaz0epRebXFeqr5sB71hjRl1vuSulr4JDEpgJJe9dAAqqL/D7/hpfLjveNlJ5YmDADbKWAif0G9qIDKBkZnU8g6dsQK9f0DtUpMUEFRbCUZYSIGMKmDjdBGu0pjkjSxoohv0qEvdlxQOSwtltyuszVuZxqcssUcVwEfXfREAGiDSqWCz372sxgdHcWGDRsSX/Pggw9i06ZN8mu5XA6bNm3Cfffdlzh2uVzG+Ph45N9cQg2auhWB2J4gK/XOakoAWLuk1fty98EZq/HkuDGm1bIIxCcFHGMwTZYC7mh+ThSo6UUgBL1P1XHj2mrZ3ot6o4nNf/MD/Mr1/wkgbKMl4Nq7NslOA/BLAcdpAN969nH41m+dJz8fm7DXAQo2UhxW1PS6TyWwvullZwMTXq/P8xCOG5OqJekFHI5LYbckDhFqAJjzWBeSeliLzMj4bM2JYQ0Pg9Fxly0qAQDGJu3nbFxK1afNokDcs0thMB0nC6GyxmKY4wUTAH7nO9/BokWL0N/fj0984hO48847sXz58tjXjo2NoV6vY+XKlZGvr1y5Env2JPc6ve666zA6Oir/rV27NvG1WaASCQA72RRXH0BdnyawblnLluDrW3c7LXRxC71P1acct71JBIq9TF/B30es3mhC/JlFaXzqv+EBnVo9dSP1SdPN1kTloz8D+OyhGTyxL/TO0xlA2cavZjdunJBcoOQhqBfsnrrhA8DLj1+K5Yta7PV01YcBbI2bywUkbF1N20zFmLVG02veduvZS9ESry9OXuDB1NVidMwUB7iZSutvpdAARgrNNKZOMID1RtPaYqVWb8hx+wvReXvMcCsA3D9hn3Gpx7CKFFXA1Ri/vn6KQ3xsCphGb80wxwsmALzwwguxbds23HvvvXj961+Pyy67jFzPd/XVV+PIkSPy3+7du0nHT4OqyRF9KVW4+gDGLfQAsG7pkPz4ez9P1lMmj9tZoEDJAKqLHUWPYXWz1FO1dc9ArbMXsH+artEI/RspKh919mVRf3wK2La6OM5ORMCnClhu+H35ju8NeHig6Slg3+sU0M1v1ffMq62WNi5ZCjgmrUihAdS9Nlsf+6eA4xhhVz2s+vd1+gDm5LWPW/awVt9n/eCyoh0A7puYtRoTiH+vSBhAebhQsjgkDGBnYElRYc6wwwsmABwaGsKJJ56IV77ylbj55ptRKBRw8803x752+fLlyOfz2Lt3b+Tre/fuxapVqxJ/R6lUwsjISOTfXEIPInS4MoCVmA0PADauXSw//s8nx6zGbI0bkz5QikBcA6pYDymCFnOx2kKizhq6Vk+9dlfWI2kzcS2I0YOloT6NARQpYMtgpZrApAB+FbZxG77AYNHdU02vAlZ/h5f1hXZwUZ9jvwAwuknnIwygP1MXSQETaADjfPAopBZxmtAwYLUbS30m9RRwEASKDtBurVUPEPp6e8xwPwA3BjC2CKSfwAYmZq2lkC7EVgETdV1imOMFEwDqaDQaKJfjH6S+vj6cffbZuPvuuyOvv/vuu3HeeefF/sx8gO75psP1xJcUWOZyAT5+WUtHuW33YasxgQQj6PZG2mi6b05xp12KADBOW6jea9eFqdFodtj3qMGQ64lX3Uz6Y9tq2Y2rM8dJDKDtPY5r/SUgrturCCQmAPTxVBPsdEkZV6TYfTSA+maazwVyfnlZamjWRUEQjusXqImMg2oD48/UdatcbzgeCqtKhXYcG257GIoEgDEHl2VticEzh+yshmYVLXBOYxaXDLWCykPTDkUgMQUrw6IK2EsDKMbtPMRT9AKOKwTiFPDcoScCwMnJSWzbtg3btm0DAGzfvh3btm3Drl27MDU1hQ9/+MO4//77sXPnTjz44IN473vfi2effRZve9vb5BgXXXQRrr/+evn5li1b8LnPfQ5f/OIX8V//9V/47d/+bUxNTeHKK6+c6z/PGElaPQHnKuCEIhAAeNmaFsv5870T1oxdNeZ6SxHWw9VItfO0K9OTBNXFaus6deFzXZjUlKm4FxQMoAiaCrkgvl2X5bi6vUtHFXBbZ2mbAu52cAm7Ydi/b4LdKxU7562Pp1q3FLBPNxDdsLn1Oyj0VJ2bP4VWL465pTBcj5sP+cBvXPV9VvWwznIINRsQM283rl0CAHhgx0GrcfUCIxUDHjKDOLaWggEMDxdZ2cCoMh5/HTfDDoX0lxx9bN26FRdeeKH8fMuWLQCAd7/73bjpppvw+OOP44tf/CLGxsawbNkyvOIVr8APfvADnHrqqfJnnnrqKYyNhWnMt7/97di/fz+uueYa7NmzB2eeeSbuuOOOjsKQ+YQ4/ywVQ65VwDGGzQIvWj6EXNASEu+bKGPlSL/19RZjLASA1gIybHWl0XEjFWQF/xRS2Peyc1EC3BemiH1PjFDfnQHs1P8B7lXA+rwZSiwCcQsA9ZQXACwZDK2G6o1mbKGIy7iD0qyXKAVM0A0krl9rfzGHybJfUVTc5l/M5TCLhl+gFsPc0moAO1PADddnof0+54L4ohXb61UPe3H2RacdN4qvb92Np5SiKaPrTHhm1a+5HAbi/PoWKb6w/7TtWbzpzGOtx43z8KToYa33r1Y/ZhuYuUNPBIAXXHBBV/bp1ltvTR1jx44dHV/7wAc+gA984AM+lzan6NYHGAhPfJV6A+VaXbILaejGLJYKeaxbOogdB6bx9P4puwAwhkEIggADxTxmqnVMl+vAIuPhJOL0Lq7BSXTc9v1VFqUgCJDPBag3ms6baVynlVy7Z2+z6R5YimBED4CcGUA9BZzoA2g3blxLMYFjlwygL59DudbAc4dnsHbpoPG4cVXmAoMURSBqCrjgzigKxFpqZFVRScCmCGaxGDcuQWo53rzcjwEcKOYjBXKutjXq4TWu4E50SbJNr4ZWNckMoDActzkMxbWtU03Rf+9r2/DfTlyO5W2rGVOEvYDjfAD9n4VcTAqYGcC5Q0+kgBktdOsDDACL+goQa5VN6X9acYlYNA5N2/lTNWI2JkBtUeRnpKqO6xqcqEjqWOFr2qwa36oLXtHTU00EgJ0MoNtmOqUFSx02MAU/BjAuUMvnArxoeava/ElLNqVbYCkDQMsNutlsxhZFCQaQono9KqgnYFNimHYKPVUcs0ihAYw7wIkUsCuzGFcAAijaQucAMEluIzSmdkFQeGhLZgDV15ki7p7qB0MXQ//YIhDCdp5RH0B/2QLDDhwA9hDSUsC5XIBFffbeT2mB5eJ2ms42AIw75QGKQ72jNiWuR6mrSbGKpEXf16IiKcB2TU8JzMpihSQG0O5e6Azg4sFi5HPvIpCE+XXK6pYQ4CfPHLYbt8smLW1gLDdSNRCLqwK2bYOnotbonLclEnuZblo99+ch1q6FtBVcZ3GJ97OgBVaumsVUuU2fo+eqTAHHZVvCr9nOh7giEJ25POxQXFLvElj6FC7FkQNi/nIKeO7AAWAPoZtWT0C61Fu0KUpjAJeK6rQptwBQ19AMe/pTxbVSUg2bXXVE4Sk6er2+aa+kzcRXUC/TSQUaBlBPb1700qge1jXIDg8Y8Smtl69vCeof3HnIaty4QEJAbNC2RRtqAKi+X0scnwGBRqMJ8XbEVVSS6Kliq+KJmTqCIpA45lZ86BIA/n8/24Mrv/AAgBgG0LHjTtlQbmNvuh//zAJRw3FbqUEcWwsA5xy/VH7sEgDGGUGXCIpAYjWAXAQy5+AAsIfQLeUlINg1G4PStMByiWQA7RaQelu3mdNOoos8HerjbWAU7zPXQC2GoQGUk6njZlpOuL/h5uR2vUlsgrPwvX2d5714GX7whxfGdAIRliV0KWAAWL+slQK2bYHVjVkMjaDdLJGA6Pu1YlHbo82xL7YaMMWngOl6DANh8OqliW103l9KDaAaCLsWLgHAb/79g3Jt0i2BXKuLk8zxBVwdF7oVgahft02v1mK0egBwy3tfgZeubjk5HJmxP7zEHeIpDi3SCJrYDJxhBw4AewhpTB0Qtimi1AAuGWoHgEQMoFqd5oLYqkcCw+akgMJXm5JUvOPLAJZjep8C7hYg4jrOXr8kthjD1WtRGoInzC/Xk784EMXNW6EB1HWNaVBNxtUUmujS8NUHduObW+07AKkBUzEmBeyjLazHpIApfDHFvI12AvHfpOOYW4rqYqAzAHSVQ6SlgMUaNl2pW11zqNuNH7ffsTViUrvFwb4CXrqqJbFw8Rfspi2kkC3kg8454HqAZ9iDA8AeQhqTAigMoEUKOG2xW9xOKx+2GBPopgFsV9C5agBjqhMjAaDjyTQutQwoXQocF6akTiu+Xm1JRSCum2kcs6rCNQVcTdGYuvZbNqkCtk0Bx7FpAGRvYQD40Ld+ajUmkMwA+hhhy7HlgYiaAex8HigCtbiDVs5xXJ3h7U8oArEdNzy0xT8LqkWSjS5U7zOtw9ULMK4XsMBoW8v7jR/bH1zirYv8U8CNGHKAGcC5BweAPYSkQEKF0AAesGDrhOiWWu8SsinaeIIBtOyjKVCN2fDyuUAuUrZGxeG48QFQ0ZP1qCRqAGmE750pYPqACnA325bjJsxb8b5RBpYD0gfQbc7q90AwgK6oK3NH3aQpGMC44hKhtyQpiipEnzPAj6WJk7K4suHPHpqJfC7sWeS4jhrApGdWoFTIyWu2SQOnZVtcU8DdDm/nn7AcAPD02JS11CDevNxfthA6OXTKC3zmLMMOHAD2ENKYOgA4aWWL7v/uI88bj5uUqhWQLeYsGbu41BSgVAE7F4F0T9W6sh5JQmpfcXJiEYinnkoygAmVj9btrxKKYARcCwviWopFxnUMhLsFrEOODGAtRvQOdAaA1l1x2uMGQZQR99VTJRWXSAbQcc42m2H7wkLMJl33KS6JeX5d7Vp0Gckpq6LW8s6HoZQikCAICzZs1hsRNCWx4eJAQFUEAgC/dMox8mNb25pqTKBG4V0p94Y4eQFXAc8ZOADsIZRT0hIA8N9f1nrYd4xNGY8bR/OrkIJnWzYloQjE1wYm3Jg0ps5T95QUqPjaEyQV2fingIUNDE3lY5xxtwpxf22DlbSKyvDkb369aoAS9zwMOGoAk8bUDXRtN+ikFJ2r5ktAZeKiDKBfClidO0XiTboa8zy4Vhfrco9T260r5biO/oJx3Up0uFxzGgM4WHQrXoqTxajXKSQR9of4zj2Hoi+2uGfq3sCt4OYeHAD2EEyKQEQLLJvNNDyNdU8B21a8NRJTwG2rGmcfwPjr9TWDTgqAfBempADIV0+V1FXA2fsspvVX3LgNW/YrZTN18axT3+O46x10tIFJYq11neUBy4rlOBNoIGRTXDWA6tyJ01O5yyHUALAzUPPzARRFQXFFILbVr9HrOHXNaORz58CyS5tBAbH+2NyLckoWZ9TBxgtINrEXCAvv3MZV561rBbSKuKwThXk5ww4cAPYQTIpA1NSPaZoqzpNJxZCDubQ6bl7bTENNoWsnkHgm1JcBjDOYbn3utzAlG0H7sSlpnUBsN+luLALgLtSvxmi+VMiN1OL+xvVXVjHoaAOTxoYLHLSsiI/z6gNC0b9rOi3aszYmBezIACYxi76Vms1mU+mMoxSBCKbO8lHQA1w9Ve/aY7ha6z5nAeXgYnHRaYd4Yb5u69lXizGCVrHIMetSi3mvXDXhKtRqewEK83KGHTgA7CGYMIDq90xP/7WUTU+kbMu1hhULllQE4msELe0ptMCyz1OcHGd50Po9fgtTchGIJwMoikDIuh90ZxHEl10ZwDjDZsAtqFADQMpewLLyNSatPKL0Vt19aNpu3ITq4kHZUsztWUhiAF27tgioqdVIFbBDsK5CnZNq4B4Wa1gWPyjX+cFfOrHj+64MYFketpMPAi7Pb1oh32JHz9W4SnAVrmtuXBGIYACr9abzWhunAeQq4LkHB4A9hDQ7Df17poxVt00P0CwPLETEMgAk1gAmsSnS+81S6CwQ1/qq9bnfwlRNCNzDIhC3ccsJnmKubbWqKZueax/YUAMZb30RFtlYbKTta80F8QcXkQIu1xpW96GbmP7f/tdr5Eb69H5zjS2gztnouEN9oZ+cC2rKfVCLS3wZQLXfdi6WpXF8FtTAXTkQ5By1emKNO/dFS7HldSd3fN/ZEkk+s/FzFgi1tjYHQ2MG0NK0Oa4doApX1i4uBSzmLOBv5RVhALkKeM7BAWAPIa1nLxBlQ0wX/3pCqlYdU5xYbTQkoggkKQXs2gmklnAfQnNW3x7D8YGa68KU9L656p4EZhOMoF036SQGVEAK6p01gEkMYJgKN5UtpKWVBxU/OJv50C2Vtnp0AL994QkAgKf3TxqPCSiBZYdRr1+P4WpCYBlqAP0CNf16875suMosxtjAuB5aEvujB27XmzZnATcbp9S+6wOOKeCU6w2tt/xtkXK5QFbZu2Zx4siBIlcBzzk4AOwhpHVUAKJ+eKYBS9LmpEKwgDai+uQiEL9OIHE+gAAwKNMcjmyKrNSMrwJ2XZhSq4DJfQAd02kpOiJXq45ySnGJummZbqZxlaQqSoUcxN5iM2fTUmkvXr4IAPCUNQMYL7MQz9W045ytJzy73hrAhFZovrIFUZXdV8iR9BiuJASqAs4+gAZ918N1lj4FvOfIrPGY6jUkyTeGHFPAcb2AAYJDfJwG0LPjEsMeHAD2EJL873TYWkDEGcnqEB0LbEr/Zam/tniIRa5Sazhpn0KWRmcA/fRUSdYPvlXASWkf37ZaaZ1AnI2gUwybbccVgepgX1IKOPx9pmOnXWsQBIqlhv2cTUqlnbCi1bf46f2TVl6AtRgmBaBgAOMDINeuLQJpBVGuc1Y8m0NEHTvSCuN8x+2mt/bRACaNu3HdYuQC4LHnx7H7oLnONK0IxLvDiDYPfCuB4zSALgWMDD9wANhDMGHqALUYwi4F3G1c0WLJxqE+rt0P0Fo8xAKyZ9zupAskGxYLbYqzwXSiEbRfFXCS9YMvA5jUVkr6ANr2Ahb3NSH4cS0CSTKsFlDnh2nAkqTXVDFYstfXpaXS1i0bRC5oMVn7J8oW48bbwAw5XKOKpM4lRctDoI4kRsmbARQBoKIrBjwCtVTrotbXG0075jquW4kOl3R4WoeRlSP9eMkxLTPrHQfMWeY05tq1w0i458TLbbxTwBGDafsCRoYfOADsISSlkXTY2qGEQt/k6SA2bycGMOi83lWj/QCAXRanXIGkzWmISAPYUQTiqXtKspTw1gAmFIG4MoBpQZVLEUiz2ZRzZiCJAVTms3EK2GCDdrGCiUtNqSgV8tKrzaY3dtIhKyxccpVDxK8JLl0q4sZNki24mqKLAi21kEAd17VyPSlVq94XG+1q2Au4CwPo4gOYUhAFuPmupjHXrobjSfPL1womznpMPcj69BlmmIMDwB5CWqsuAdvFP4nmVzHQZ59CEAtuN2bxyi/82Hg8gSS/uqGSXxVwkhG0S6cKFZV6qHuKG9eVARTatk4fQLcq4G4VsEAo2LZhAKv1prwO/TrluBEG0C4F3E2jNeCUAk7f+Icc0l/VBJmFfxVwEgPoV7iUJAsp5v0OLZOSAYyXLdjqS9MPLfaHC8AuBWzz/JZTUsCAqtejY679U8DxDKCrBrAeQw4U84HU7fq0mWOYgwPAHkKSsbIO28XfhFl0OUE2urApas9OWy+pNAbQ9VQappNodU9Jwm+XKkIVopPKSH9RG9e1Crj7JiKmnc31qozxQEIAGASBtddiWq9WwM0LMKnNoAoRtFlZIiWk0qQPYKXmpHtKYixFYFx21q3Gb/yuVkACgo3tTAG7FVqZdpmxHTutfzXglrY28XIdcmCuk6rBBfodA8AkBtDlEKQijhFX+yu7+gsy7MABYA8hqQOGDtsKQBNtoUwBOwjq9SIQAPjom0+TH+864Giqm8CmuC5KYRWwxqYQWV9Q9gI+NFXBkbZX2OhgNAB0rQJO0z25BKxiw8nngu6WGpYVgJL5STCXBpTK9ar5fEizRGqNa1+4kSTSF3O22bTXZwHJz4LQxOm9co3HTbheXx/AsAhEDwBb/2dVBGI7tkmgJg3MLYLsSjuw6cZcuxxk5eEtSbrgqAFMyg4JP8x/2vYcDk/beRaq4+a1cUUamFPAcwMOAHsISUJyHbIIxJgB7K4fAdQiEHsGMC6wXDzYh9OPHQUAPD3mZqqrB2qyrZan7om8FVxKJxDbwPLvfvA0Nv75nfJ61A4V0XEtGcCUA4bcpC2YKnFgGCjmEcRoQQVsPcBMNIBiPtgwdWksKOCmNU1rBQe4VQLXE54F6QTgXAWcxAB6BoDt+ZDEALrKFpICNdVnzsWvz6QIxMkHsEtgaVth22g0IS4hiQEU88xGww0kM4tCA/jY8+N4j5OMJ35vkAwgp4DnBBwA9hCSGtXrkEUgtkbQXW1gxAJi/mCKQCGuCAQAXrS8Zamx3TIATArUSo5CZ33cjmINbxuY7pWatoHlvzzyvPw4F4QbhoBzL+CENGX4u+wZyySzah2299ikL7ZIAduw1ml+auq4dhqt+HubywVhqtpBu1ptxB8KfW1gkrR1ri3bBKZSNIDWfn2psoUA4tbYHLRM5pfLQSvNBxCw1zKrvz+JHHAtAkkqXlpUCrMO23YfthqzNW47tRzEr+GcAp4bcADYQ6h2YdRU2J7+k1z/VQz02S8gcQ2/VcgA0NZUN2GTdtW56ON2VgG76ZMEEhlAR6F+pDdrLtfBrHlXAadaatgzgHqlsg7BAFEWgSwZavlNjk2a27WYWCKF5s3+DCAQtq1zYQCTGEtbL9DOcZNsYHx9AOMZQP+OHcRMnUkK2KEK2CwAtGMA1XuWFAiLA/ysxXxoNptdAsBoAG+bBk7SrnIKeG7BAWAPoW5g2AzYn/5NmEW5gBAGgC9e4cYAJlUBu3pdCaRXAbsygPFVwBTNz+OC/LzYmKx9ALvriHyKQJIKQATC6lKzsWV3kS7PwnFLBgEAn7nnaWM9VVo3FMBNa1rrcsgSjI+LfVFSKty/F3CKbtVbA6gxgHlRYW43XpLFkgoXrW2avQzgxwB2LwKxOxCoh6akNVy4OJQt1u9u4y7SZCc2npiAIg/q0AAKBpADwLkAB4A9hLQUnYDt6T/OlV2HWEBcfADTGEBbDWAlgZ0Qi8esY/og0QeQqApY30xc03TTKUUNLhtT3UBH5MKkJHUr0SGDbNMqYAPm57glA/LjL9+/02jcNCscQGFoHAqi4p6FQYeqYoGk++DbC1jMWX1N6Cv4ySGmEqqAfRnA7oGaPXNtpQG0KQIx0AAOWB5k1fcikQFsM/A267f6nOvzYPmiUuTz8VnL3sUJxVahBpBTwHMBDgB7CN3SSCrCjdps3KR+jyqG2yc+mybl0gYmQQN4fDsAHJssWy0gSYGaCDJcBcSJGsCcXXCiI1z041O1tkJ91dbk4lNXdnzfpQq4arCJSJ2Wg6FuWgrYNrWY1gECANYtHZQfpxVOCSSJ01W42MuE1bqd1yvYsCs+/4BDD9ikQE0cAv36YuuHTfFsuDI0SVXAoQ+g3XiVhL9fhQtraVMFbDpuo9E0YhZtr1c9XCQVWpUcMjjqeqc/P2etWxL5fHzGjr1OSi1zCnhuwQFgD6FbGkmFrVBbpAqTWoABrRZFAHD7T57DPsP2bSJQSNp8R/qL8iS5w4IFTGJC+z0FxIntrzwZQJGm0t3/XZlFoas7ZdUw/upXN3R834UBVF+bxHoIlsau6jE9RQfYV0SbbKQvXT0iP+62kasQz1i3gNHFq6xbYDmosGF/+s8/Mx4TSGbAXAuMOsbVDi19clzXADCpCthNZhFmL9IDNRcj6G4SA1vvQvWg111baLd+m2i4F0ndqr13JdD5/A6VCviNV71Ifu7KAOoFgmERCAeAcwEOAHsINYPFDrAX1KelagHgmOF++fGffecxo3HTNIAAsLrdEu7ApLmIuJpgVxLqFP10T50pYLf0lEBS2sc5BdwOAK9/51myLZkKl1StmkZK2khcxjUxbAbsg2yTXsAA8KYz17Suw3Bck644LkxzN52tqoezrahM0gD6t4JLYADFuJ4p4EGtiMD1WTBhbIUPqZ0G0CS1bPc8GAeAluu3SeGSbN1WqRl3WxHrbBDEr+F/8ssvw+bTVgEAxi3aIkauOVEDyCnguQAHgD0EE8Nm9fumC5NJannlSKj5+PmeCaNxTQJA2VLISlAfv+n5VgEnbXq2C7KOpHSSewq4vYkm9NZ1SnnVuy/26rhuTAo1A2g6rltBVDcjaGoGcLFi5G1TsQwkp4Bt+4HrSDKY9q0uFilg3brIlbE0YWxdGECTFLCwzTI+tCj3zCQFbNsXuxsxIO53s2leXGISWIouROOWLeGS9gaZAmYfwDkBB4A9BFsNoLGGxCCFIFLAAHDSyuHE16kwCQCl673FApK06YkUcK3RdBKpJ6V9fH0AywlFIC4p4Gq9IRf8pADQZcOrKTKAJB2RTwCopxJ12HYCMQ0AbYsWTBgll2rzsLikc9xVI2GximsrtKQCI3cGMK1wybEKWBhBaxrAPkdmsWbA2Mp5a9nDujVu8vwqyufB7JrVdaCrKbplj3CTDlGlQk5+37Qi3qToUGjDnRnAJCNoTgHPCTgA7CEktWfSUbBcmExsYIZKBaxf1hLVj8SkHbuNm1QEAoQLyGTZoggk4XrVSlMbvys5bsKib7sg6whtYDSWxiHtpRYeDGqbqIBLX9VuAUo4rkMRiKEG0LUTSJq2T8wR02pY2aSeXAOYbgMDtBgam6AtKVARc9a1F3A1YT5QMYC6EbTav9ymJ3LYHckkVWtfrdu9CthSA2jAKrbGtTy0GARqQRBIFtD0sG2iLRR7gb0GMJ65ZSPouQUHgD2EusFi1/q+XcAiuwmkMIvvPGcdAPOHU3YCMUgB23VViD/xquaqLmngxFZwlmlEHVIDqBeBOAjfxb0PguSNJLMNrx3IN5sw1xGZpmotvRYrBj6A6u813UzFnCVnALvod3VG3SYNLO+vXqyhHC5sAqqOcfXA0pGpm6nU8Se3PSoPMHoRiAgsm007htkkTeniA2hmBG2pATQMAMU9N08Bp1dCA+G+8bUf7zYa18QebEQygMQpYGYA5wQcAPYQTExqAfsFJOwn2n1cW3reRFAvxclWKeD4zTQIgtAL0CMATGQAHdJejUZTBgoDffFVwDZebUm9X1W4bHgmaSR1sTZlAauGgZrtNVcTgmodRcvAMjxkETOAXdiUV79kOf5o8yny830WprohS6MVgbTvS7PpxlyHqVUtBawwgDaB5bceegZ/r3gx6ilg9ffYBJdJTJIKL+kCoV2LSRcQdVzTOZv0XukQB4ubf7jdaFwTbaELA9jNDod7Ac8tOADsIZicyAC7hUlt95PmlVayrH40Sc+EDKBNCjh5Mw0bqdsHgEl6Ih9BvRosdwSABTt2qvXa9PfKyfbCoqOCzdimDKAr66EzX0njUlbEl7wYwM5xgyDAb732BJx2bMu25uCUTQAYnwpX74vLvE1K/6kbtk1gqXdN0X0h1esXc9EEZhpAe0mEyfwqWKZqK/X4jkBJ4xoX8RmsCS7IqghE9RfUfTxDBpBTwHMBDgB7BM1meGpK6wRis4Coi2LauLbMh40/lakwGUjW6gFKUYnFePq4+n3o8xAmq+299HZoLilgkyIFJ9G7QZtBlwDQ1gfQvBNIOhMK2KeW6wYsuxsDmH4YEpY+RywE9UmFS2qg5qLXSwrc1eDFZlz9dib1rwYsGUAbDaDh81BXGCoRkMTBlgFMKgbTIS2RLItA0jJDv3zGaqPxBEzWBMEATljN2fDv6mAA2QdwTsEBYI9AXQvSHnSbdFq3dj86bPUZdYPUxJCDBrCb5sUloEwbV/q+OSxKovVSXyHXcUJ3SwG3U15d3itbbRIQrQJOgmraapwCttQA2qaA0+asbaW1eFk3NsVLA9hl3MUDfQDsuu0kpYBbXSFaH7t49oWHLH3OujGLEykMURAETibTNhpA097YamDfrYONtQ+goQawYLF+q69Le8aEzCAtBa2P240YGBloawAtUsDqwSHJv5IDwLkBB4A9AtUfLW3TsykCUE+ZqSlgy4dTLOTdxhVWJjOG3lSAkvaJWZjCFLB7AJisS7FPSwgtos7+AY4pYKMNz81eBui+iai/07YIpC91ztqxHiYbP+CgAcyMATRnU6wYQNFlRtvUgyAIjdEr9ptp2GItOm4hn5Nsng0DaGITYvteAWa6aNvOOKrEpRsDaMvUWVcBExeBCN1ludYwWnNMmEWZAp6pGWtC1X0h2QeQU8BzgZ4IAO+55x5ccsklWLNmDYIgwG233Sa/V61WcdVVV+H000/H0NAQ1qxZgyuuuALPPfdc1zGvvfZaBEEQ+XfKKad0/ZmjCXUzT0vV2mheTDpACEh63vDhNCkCEbo4mybl3SxLXIpKOseNt5dxYgDbm2+cZ59TCtjgVO7T+so0BWy7OZkzgHbC97SKeKkBtNRTdatcVxlA003PJGAVhtBWDGCX4h3Brpsa/6oQQVB/TLASMtcWAaDB8+jiXWiii85ZPg+z7cC+mO8MUFTYPmcm3oLi97bGtSwCSXkW1O4r0wbrrYm2UBxaKvWGMSNe6ZIKZwZwbtETAeDU1BQ2bNiAG264oeN709PTeOihh/Anf/IneOihh3Drrbfi5z//OX7lV34lddxTTz0Vzz//vPz3wx/+MIvLJ0HNIlVrkwK0YQDFxme6QEt7mS7jCmZM9bfrhmaz2bUB/JBDZxGBJDbBp7J4xoABtDHVNSnYcekEkhT8qmgdlFofmzKAFVFckmZ94coApj4L7XtsOGcbRjYw4d9ibKpr4LUpNIA2prrdggrhtTftEABK5jrm4OISqJkxgPaBpY0G0LTLjAh+u7F/rd9p95yZVNq3xrVj8E0ZwFIhL3+3SYbESMLTl5f3wTQN3K2NI/sAzi3inWTnGTZv3ozNmzfHfm90dBR33nln5GvXX389zjnnHOzatQvr1q1LHLdQKGDVqlWk15oVbJi60EbAXANYyAVd3ekBHxuY5AVEMGOzhgGgGtTSp4Dj02k+3lRi8+2PCwAdNE8m3WBcfADNU7UBqvUmuQbQtq2WSSocCP8e083fhFlcVCpg7dIB7D44g/ufPoj//rKVBuOmb9JORSC1+FQtEKb8bPS1AoIFi5u3pUIOE7AL1NI0gIBbOziTNKVYDxuGczb82021enaFS6ZFfLaHIZMq4MG+Ao7MVI1cEkwCyyAIMNJfwKHpKo7MVCMdo9LGjUuFsw/g3KInGEBbHDlyBEEQYPHixV1f98QTT2DNmjV48YtfjF/7tV/Drl27ur6+XC5jfHw88m+uoD7kaYGaTQBgotMTsCnRV+1lui3OIgA0SUkA6UzoojbrYVsE0u16fVrMCSYlLgUsewE7pLyoGcCqAUMFhIUg5oGaWWBZtGRp6gb+b4B7J5Bu8WoQBHjNS1YAAH6846DRuCape5cCpm6Bu2QAHQ5DM5XkAFAGahZ2LWpHko+99fTY16jm1aYwYYJtiypmjRlAy2rdLsyXCtsiLtMiEKDF2AFmrLCpztb24CJ1q91SwOwDOCd4wQWAs7OzuOqqq3D55ZdjZGQk8XXnnnsubrnlFtxxxx248cYbsX37drz61a/GxMRE4s9cd911GB0dlf/Wrl2bxZ8QC5N0qoBNAGDC0gmEqVCTwNJMsyg2mBlDBlDdHOKuefmiEgDgucMzRuOF46qBZTwDCNifTGe6pNLE/XQxvu0uerfz1APMihTU32te+WhoA2Pr12fIptgW2pikFAHglNWtteXJfZNm4xpspmHK1qIivsvzO9jnXhEvnvG4ADDs22tfBHPLla/A218Rn5URgZHNgcimKMp0zgqNc8mQATTWABqu4TKDY2qJZGgDAwCDFocM00OhLF4y1K6KeRMnC3HtCc1wwwsqAKxWq7jsssvQbDZx4403dn3t5s2b8ba3vQ1nnHEGLr74Ynz3u9/F4cOH8Y1vfCPxZ66++mocOXJE/tu926ylDgWEhUFatw7AzQfQJLAsWKTTTO1lBpXKNKPrVQKEuE1PtNX66TNH7AIg1Zy0S4s52wBwuguTEhYTmG+kIUOV/OjKdCpx54PW73WrUDT1ATRu2WY4b20LbUxawQHASccsAgD8Ym/ygVGFSepepGxtija6pYAFo2gTUAqIORlXBCKriy1YGpN54LL5mxwExK80nbOij3h/CgNYsHzOwkOWmR7WtOWiDQPYZ3HQMj0Ujlp2A+l2KPTRWzPs8YIJAEXwt3PnTtx5551d2b84LF68GCeddBKefPLJxNeUSiWMjIxE/s0VqoYpr9ZrbKqAzTY89XebBFbq6dXEBgYwe+jFuEEQP+7Jq1oB4K6D07j0xntTx5Pj1pIDy1wu9CizXZhENfJwqVNuKxgGm2pSk/fLrQrYrKhCbNKmqdqwo4JhFbCxoN7UBsaOWRT3LJcis1g9OgAAODBZMRq3ZiC1EAVM0w6emHEpYPFsuVQBdysC6S/aPwsmQUqYWrZnxLtX62bDAIbroaUmOo0BVL0WLWQ8ac8uoLa1NLcIS3vGbO2Luh02h9suDiaaUYY/XhABoAj+nnjiCdx1111YtmyZ9RiTk5N46qmnsHq1nVv6XMEmVWvHAJovHvnAfNx6ClMnUCrkZGWpCVORZli8erQfZ69fAgD4ye7DxsUgIlVbyAVdT6a2DKBItQh7GhVqZbDpuCaMrRqo23pzpbETYjM11X/JANBQq2euAWzfB0M9lW1fVVNLJFO2yqRfqwzYbDSAXcYd8iiIEs9DN+baxrrJpKuEUxGIwcHFthewMQNoXa2bXmnfGjf8W2yyOGmpWvV3mzwPJs4AADBiGbR1OxQuHWpJeI7MVJ1aGDLs0BMB4OTkJLZt24Zt27YBALZv345t27Zh165dqFar+NVf/VVs3boVX/7yl1Gv17Fnzx7s2bMHlUp4Or/oootw/fXXy8//4A/+AN///vexY8cO3HvvvXjLW96CfD6Pyy+/fK7/PCPYFGu4aABNFo+wmg6pgUUaUycQBIEMhEx0gGkLfhAE+Mr7z5WfP2Go0epm1wKo/V/tGECxKA7HBIDq5moqejYxKla/R92oXgZUhoGaaSu4YkZVwLadQBqGgaVgL+qGhUE2DOBUxcJUt5acWhWaQpe+2CK9G/c8OHVCMeg0Y9sJpNlsGgU/toy4TH8bM4DERSDK32K3hpszgGYOEWbawoFia96aHghCH8DOcUcHipIQODRtxq4z3NETAeDWrVuxceNGbNy4EQCwZcsWbNy4Eddccw2effZZ3H777XjmmWdw5plnYvXq1fLfvfeGKcCnnnoKY2Nj8vNnnnkGl19+OU4++WRcdtllWLZsGe6//36sWLFizv8+E9g85GEVmXmxhk1gqV5PEmxSyzapKhPBc6mQx/kntFhgU5G+rHqMSXm1xnRjAEUAuKhU7PheMR+2h5s19L0ysoFRggHTwKcsA8DurIdtQGWqI3KtqDQV1NvawKTay6g9cQ0CFpPnVwSAjaZ9t51unpi2DGCz2ZTzMS4NKgIjKwbQgKmz9Rc0bY8p5oApW2v6LIT9q+2KQExtYACz58wuBWzOtJsylgN97flgqDWtdNGD5nMBlgy2WiIemjK3Q2K4oSd8AC+44IKuJ2KT0/KOHTsin3/ta1/zvaw5henDCNilJkwNdYHOThDd1kcbZnG4v4ixyYpRCsFU8HzckpZGa88Rs2rgdAZQ2BOYb3rPHZ7Btx96BkA8Awi0RPZTlboxs2hyX1VtTaXWiNVx6TBlAG00RIB5cYntuKbzq6Cw1mbjtgNLQ09MoHXv2ntWIkyeX3XuTZZrsenXznGT768oKrEtAinXGhBLatzzIL5m8yyYmCDLKmDLuQV0Z2xt7WWMNYC2HTsMA7VcrmW43myaBWo2RSAyaLX0iO0GUchn7uTQtoFJWGuWDvXh4FQFB6bKAIaNxmS4oScYQIYdA2iTmjCxFdHHBdJNVW1OpaGGJP3EZzruqrZI//kjs6ljAuHiFefXByiVj4bsRLlWx/l/+e/y88QA0FJPZdKeSd1ky4ZWHcLbMTUFLH317GxVTHVPxi3bDKuAc5YMoGl1sdoT14StM3l+87lQDmFaCNK9E4ibDYwqR6CqXpfVyl0Cdltj9DRTeAFbZtH2cGErWzAJ1IoWhSs2NjAFCwbfdFwxH0y9XCtdZAsAsLR9mjo4xSngrMEBYI/ApljDxkne1Pes9RpzbZlNwDrcb24jYCp4XtV2pN9jGgB2Eb0D9gzgz/dE7UHSAkBTPZXJfQ2CwHrTM21Ub6vV69arVkVeaOosq3XT9VRtBtAwc2/DiIsUock9Nj1o2fbv7ZoCtjD9VSGehXxCQZRbEYhBCtgyADRtYynGNX0WTGUAttXF8r2y0XEb2bWYZ4fk82vBLKaNKw7Ntl6uSVmBpUMiBcwBYNbgALBHYBWoWTjJm26kQDQtluZPZZOyFsHRN378TOprTYXUq0dbAaAxA5iSArZnAKOvE0GujpKlpYYp81Wy3PTKxkUgljYwhkbQtp1ATOw/1O/bagDTbGCAMFg2YQBNtJuAff/erilgqQG0SwHPpj0LTkUg6VIA20OLaXtMW39Bk8pi9fu2HTvMZDw2h3izNbH1GvN7bBoID1gywt1awQHAknYA+NNnjhiNx3AHB4A9AptALdR5mD/ktkUglAygSNPd9/SBVBbQNLAUHUFM0wizKSlgWwZQX2BPWLEo9nW2i6cpE1yUuie7KmBTBtC4Y4fh9dp2AjFN09lWatpoV8PCIIvq9ZRxBy3793bTf8kqYEcGMKkK1rYIpNFoSg1mt+dWBieWcyAIwjUkDvbMohlTZ2uKLnWQxIV8Vmb+Vh6xZs/ugCXTXK51D1iXtQPAbz74jLHROsMNHAD2CFxsYMw6a5inJYIgkLqnVAbQImWttm1Lq1g0XZyXDLUYt4PTFaMiIbF4UVUB62yDSGvosGVTTJlg27SXbRWw6WaapvcRKDgydem9gN0CQJPnzIaxMmUsZdrWULcnKypjAncRTO48MI1/fPgZ4wKb2RQ5hDXjo7ynZj6AdnM2rcDIhqkFVLbWbM6ap4DNGUDxfJt17LDQFloUW5ke4qWNl+EaltYVRvVMfd0n7jG2RGLYgwPAHkHoIm9eBUxtIhoZO+WhNPH9ElBTTWk6EtPWYsvahqKVWgNTBtqUmS6+Z4C98F3tZvCbr3lx4usEm2LCIgHmi7Jtv9ayIQPoLHxPE9RbagvrdbP7IFK5piyNnQbQPLAwNXIPNYB26bQ4VmmR0n3mf339J7jzsb1GY3brA6x+3Zi1Vk3huxWBFNrsMrFswTW1bMoAGjOLVqla8+DSrgjEnME3DVhDDaClbCHhfdO1f7/Ya2blxbAHB4A9AtNG4uprrExEDRYlABDrd9pGbcp4AMBHLjlVfpzGhJm2LBvoy8vgykRMnGoD48gAnnP8Unz4DS9NfJ1gL6zZCcMA0HRc0ypgydIYW1+0A5+CmaDethVcOgNoJ9S30wCaF4GY+m3aaADrSmo1LrDUC49MTdHTjJBL1gFVeO+7PbclawZQ2LWYsdam12u6xlgXgTis4ZQdOwD1OTM5tNhVAdsbQcdf76VnHRf5XM0QMWjBAWCPoO5QBWx0erRILbfGbk2ZNBsYm0Xp5FXDWLd0EED6ImLDLNrYCYhNL9EGxtL7TNzXNC8xe+sLs3lgmwI21wCa20g0m00ZCKcxzM4+gKnVxXZpuoZhgA3YMUumGt5QA2hgiq7cq7gU8OLBPmx66THy8z3jZgVRaUUgtlq9imGxRjiuHQOY1rHDtggklAEYstaW5uU2RSDUhXx9FtpgU+Pq0XYv4EPTVcM9pzsbfvKqYfzowxfhNSe1mjI8Z+jlyrAHB4A9gqphyguwq3y0Eb0DkBpA0yIQk0UJMNcVSSF1CqMEtDZAwKylkNQAEjGAovrVVJ9kmvYyZb5s017G3Q8seutGfNpSO4G4CepTq4At+lerv9/kQGQzJ0wPWiJta+IDWDUIrD79a2fj0rOOBQA8b8ikpFkihXPLrnCpmA8QdGFWi3Jcs/dK+BWmzVlrxtKwWMNVX2pWBGJRrGGRbbEqEDQsAlmzeAD9xRwqtQZ2HZxOHbdbJxCBlSP9WN8mBZgBzA4cAPYIQsbD4PRowXqYphTDsdsMYMrYFUtmsd/QS6pqWE0JhNVpJhv0TKUR+RkdYpMxTqkaahX7LFkP04DddlxTBrBgIU5XX5PeC9icWYxUlZpWARsKyW2KQEoWOkvT982qLaLB/e0r5PDmM1sB4FP7p1LHBNI1gCFrbWl/ksoCO6aA0zSAtlXAIl1vfGixTS1b2MAQduxQf7eRv6DhuPlcgJcc0+rY8fjz46njVg3XmpUjLR33/oly6pgMN3AA2COwqdZ18ZBKW+wETEX1pi3ABAYMrSVshNQ2DE16CjgXeV0axCIXl5pTYb2ZWjKA5JtpwTxVa1r9CaidQMxtLwBzH8BmM/3Q0hrb/DmT+s0U3Wqz2TT2ARQVkEdmzLvi5HNB1/uwcd1iFPMBdh2cxlP703WAqaboloyaafce+zlrVgRiqwE0Llyy1pear102wWW4JhhUAduMaxGwnnHcKADgR9sPpr62YriGC+9UkxahDDdwANgjsPPray9MFqc8k7QEYJ72SKv00mGaAjbVpai/20S3l77p2TGApgFwVhWK1p1ADN8vyQCaaH2U301ZBazOPdNKTSD90NJshsyild1SCrtoc72ig81eA71e1WIjfenqEQDAdgMWUBaBJMwFW6bOtAVan+gFTCxbcLWBMT1cVOtNI6sSm+yFCLpsNIA2DCBlL2AA+G8nLgcA/HhHegBoujcMyxahHABmBQ4AewQuDb9tqoBNTo+t15kFgGmVXjpMrSVMdSmAHQMoNIDJNjB2DGCYUu1+nbbCd9NUrW0RiKlm0UYDqG6k3Yx6AVvrIntmEUgvXIoGanRSC/U5TGNTVose1odNAkDzgigh1DdptyiLQBLYcNvDhWkLNNtnIa1aWcC+E4hZYB2dW+bj2mn1TLI45uRA0eL5tennLoz3pw3siyqGa03IAKbPWYYbOADsEbh07MhCA2jKelQsAlZANRM1rAI2GNemV2uaD2DJ0urA1K/Q1vvM9L7asx5mi32o1bPYQKz8yeyKS0w1gED6gUj9vsl5KGdYYFKzYADVFoZprJKcYwYs+4jot22QWhYVyKIiWYcIIkwDqrSqz3Bc1xSwGQNomwJOOxSrshmbgjubFLDNgcjkObPR2pqmwlvjmj+/JkUggMIAGpqiM+zBAWCPwEb7FtoT2Og8LAPAtBSwIVMlEBaBdL9mG9NTKw1gSis4m+pMIAzU0k65tt5npukTW9ZDbI6mdi02RSAmLLDcmCwOLUBYlZ4ENQBMm7MqQ2jEABo+C6oUIzUFPNqPXNA6aOxLEb+H71n6szAy0Jq/4wbpNOGbuXQovn+1q2whbe2ysSgBQmlHmtWSLRtummVQAyOjVG3Tnqmz0wDSHrRsxrUJ3k310ZwCzh4cAPYIXPo9NgyE7zanR/X3p6aADU95AqZ9VW2EySWLLhvT1e6t4ESHBhN/NkBpgWYqUCdurebKeqSmgHPmC71Nul6K3i1bVHWzFQFCGxj155JgU1wChP1nUw9DyiaeNm5/MY+TV7X0eg/uPNT1tWJeJ6VqVYxYpNMOTrdes2Qwvn2hbVWtafWre/tCs2fBXrNIpy8FzKuhW2ObM3WmXWaAMGil7AWs/m6T6zXVR9vMWYYbOADsEdj49bmkvYw1gIZpr6qhBk6gYJhatmFC+/IONjAJKeAhC3sOwCYFLDY9M9bDmAF0tL5ITwGbF2vYHAKsNiaLw1AuF0DEgGlsisrUGUktArM5axOwAsCZa1sVlY/vmej6OqG3SpqzKkaEBnDGhgFMCAAdffXSDpm21cXG3pW27QsN+22rf49JwZ2NxVDRJgVsoQF0YQBN9hwbWUBYcJZWvNQ6dM9WG8ZzgmEHDgB7BFb9Hi3SXraGzcYpYEsbGMmmpCykNlXAkgE0aFKe1v1A9mg1TAHLTiDEgVpYXENbBVy11AAa2bXYFC7ZVAFbmKKrr0u7ZJvUMhBecxrLbtttR8gN0pjr6RTZggqxmZoUgQjj9MUJDKCrD2DaPLBh7NXXUbcvNDVsjh4uaANAWWFsZeZvPm5aQRSQHQNomsUYUnpZm7RGZNiDA8AeQd0i9RllAFM0dZabk2kAaGqELJAFA2hq1FurNySzt6g/Xvg+1BbEj02W8af//LNUw+pwkUsJqBztWowNpg3blInbnm7XYiMit9CtWvme2c3Z0Luy+9hiUzRl6kw9MW1SdOrr0t47MQdNUsCmeqob/uNJPHOo1XkhlQGsNwztT8wCCcHkpfUDFzA2L7c4XABh0GVTrZuVVs+mCMSqT7xVaplYA2iaHcnn5O82qS5m2IMDwB6BTbWuCwNoyqYY657aKU2TCkXAIrVsUbQivftSNpRD01U0m0AQJOuehkrhJvuF/9yBj/7LY13HNA/UzFMygIUNjEURSKSlmGEK2Kjar2Z+aJEdZgx0qzZdcQDzYg2bDVp9XToDaDeuKXsbpoDjDy0qxGu6MSnjs1X89b/9XH4uKpJ1qHPayKbEsJrUVAcc/m6zZ6ygyAtMAlabgN0loDJbw+01gDZ94k0YwKphKlz93Sb32EYaIirROQDMBhwA9ghMbToANw2g7WZK3Qkkb+gDF1qLmNjAmFUBH5hqVVsuHexL3KTVdAQA/OPDz3Zd6EyDFNtqXdNNz8YGRn0vTTdTs43f3gYGSE972QZUpqx13XFcUwbQ9JBlHgAKu5Z0BlC8pttG+mOti0NaJxDA7oBhygAaWxfJ1HKKHEKZ0yapWpv5ZeNfaZMCdmMWLYpLLJhFkyYBNocCobe2mbdpGReGGzgA7BHULHRPQRAYb3o25qRAyNSlnSBtO4GI9SP9es3TEn2GjMKBye6id6BTZzRdqXetCDZlbG3bVElrFUIj6EjHjtS0jPnGZDMH1PuUxnrYBlTGAaCFTQdgXgRiY6gLmOtCZyw0gCYBoDqf//LS0xNfF9nsTeaXtQaQVg4ROVwYVZmbv18q85UG03aAgPnhArDVAEZ/phvsbGDMZUdT7Xk2lOAzqWLAsviOYQcOAHsEtkyd6QLiagSdNq6pBi4c15ABlIuzOQOYpik60K56XLYoOQAMggDHLh6IfG2sHTjGwfS0b2t+a9phxcb6QtzTIDC/XjO7B/uUF2AyZ211q+25lVqta2mJZFgEYlPBD5izwtMpHTtUmKTSxPv12pNW4B3nrEt8ndp72IQBNNXtiue13mga2QGZWkJFA0DzqlpKL8jWa9rz1kBfKlvBWTxnVm1CbWxrLHw8gVD+E4d6oynN9FVZTRJEkMgMYDbgALBHYNoDVkAuTKZsimVgmbbp2foAmp5MBTuQ1KdUxfLhVnuinzxzOHEBGZss44NffRhAdwYQAL7+P16JT//aWbLt0dhkslGvaWDtmgKmZAAlq2qh9THb+M21VBEGIWVs26IK8bK0oNVaA2hYBGLD/ADm750LAzjThUmxs1gyr7A3rdxX7VxMWMBQZpJyaFEPFzb2J1ZMHXERiKwCNg8sbfTh5D2Gldd0k3CoGlRdVhOHAQPmmuEODgB7BO5MXfeFySa1HB2XNgWcM0ynhZte+uLx6hOXY9VIPw5PVxOblH/yrl/Ij4XxaBKOWzKIN5y+GuuXDQIAxrp0aqgbslRSp2hY+Vg2tFCwCSxtusGE4nS6aj8gKlsw9640PQyZsR42fmrq61LN1i1lFuJ+pQVBNs+CTAFX64naVRuLJRtjdFM7EVVmYRYAmh1ec7lA2vpYGSBnpAG08XKtWwSWJod408p1wE66EASBUYGYCORyQbp9D6BKFzgFnAU4AOwRyM2JvPLRzQYmlQE0DFQETItLhH7EJO1VyOfwyhcvBZDcVeGAksYVZrlpWN5OFXdlAA3TSKY9kAWqhiyNjQ+gjcekMG+l3kCA7IoqTPtXhzYwtDKL0FfOLgWcqgFsz5mkYg0V4nlpNpODKxvft5G2rczbP3MfPnbH411fa8oE53JByCwaVALbHDAKFlILm0BY+vXZGEEb2apkowE09a5UxzVfw9PlIVL/VyoYWS1J5tpwfWTYgQPAHoE9A2hW7eVqBJ3OALaLFYhTy2IhMEl7AcDL1owAALaPTcV+Xw2Qhw1SEgBkCni/kQaw+1hiY561DABNDaatUsAmG6lFFbCp+F9AVBumsYuudi3kNjCmBVGW45oG7zYsu8oSJqXTbObBcPuwNFGu4cbvPdW1Ir5iwajZMOI2PpPiecjKVoU6pWrTCs5m3toUl9h6xJp0AxFG+iYFIEA4b00N+Bl24ACwR2Dbs9e0/ZGN15M6blpqwpYBNA1Ypy3SXkCYqkoKsNRfN5xgAq3DRgOYdl8lA2iocbHtBWyjpbKpejRrJWVXCBSyNMTFGqZVwLYBoKFZb93yPsjgPeUem2rggNbfJOZEUjrNhgke0Z6ViW4V8SKwNAhUbSqBpdeoTacZi+p1G0Ytbdxms+lUVUseWBr6rQLm/o0CJgVioprXpAAEMNOuMtxhtuMxjjpsTqWAuQbQNp1muklXLDWAYg1PZQAthO8A0C+6CyRsKCp7Y5peF8Ul3TWAZvdVTQE3m83UtIixDYyDEbTJRhoyKXT2HwLGsgVLrZ7puNYBoKGeKisj6Irl/R3qy6NSayR2A7Gp+tQPS2MT5UQNrY2fXOgFaJACtip+MGeu7bR6ZhpA9dsmVcCm63ez2XRqMWdVtGK455g4GqgpYBO865Xr8fpTV2FdW3fNoAUzgD0CGwNkwPwEaWMwDShpOkMG0DwANGMApyzMb4FQHzWbwLBFmEEDd3wAWGGiATRclPvbf0ejmR6sNZtN8w4jFjYw8qRvpaWy0ACassuG7KKtrYoQvpuPm40eVq1y7YbwvUsbtzV3TQPAFy0fAgD8fM9E7PdtqoD1YK+bJZJpsQZgbt3UGrd9vQZrjE0HG7uiKNPCpfD3mgRUphkcdX03sq2R+0LqS8P5YEwOmBeBJPVc1/GSlcM4/8TlOG4JB4BZgAPAHoHr5pS6MFlWAYcPuVkVsLm2sPV/mp5q2qL/KQD0t1NKswmMwpQSGBpkRQAAS4daDODBqeRNr2HJAALAbCUt5RdeIGUvYKuUlw2DYDkHCoaHAFutnggQTG1gcgYMjfr70663bHkYMjUHt2VYzzhuMQDgp88ciR/PIrDWGcAPfOWhxNfaFJeYmre3xjVPUZquW4Cd3EbKC1LGVR8Xs9Sy3bMAmAWWYQo4/TAkhja1COszOBzOWnhXMrIHB4A9AvuWbYbWF4ZaNQFT42LBVJmU+qu/v9smXW805aZoKiIWAVaSBlDtZLD59FVGY5pUpplWVxfzObkhpFW6qQxhahGIRRWwi+GryUZqm6KUlY+pRSDZsNY2HSAAhQFMObSIYMb0WQgrYU2LQMyu94QVLQbw2cPTsd+3CdhXjQ6kvkaOa6ElKxXN+ncDqteogabO0L6oYRn4ODGANgctw4Io9We6wdbGC7DR8KZfs1iH+w3ZcEa24ACwR5CVX5+tttC0E0TYscLsQTdpq6WK101PkKUUmxWx0P3dFS/HMcP9RmOatNWyua8iSE3zurJp2WZVBWxRpGCXSsvGBsZaA2jI/og/ibq62FYOYZq+ty20EsVLBxLStVWL1Oe5L1oa+bzbe2ZTZGTavxtwO7jYMGqURtC2qVrj9VuZ0za9i1O9K5Xvmx/g0nXHIrXPDOD8AAeAPQLbbgJy0zNkEWyri7u5vavjFg3ZCZPN1NZEFFBSwAmMgrjOJUNmHoCAmXWLDbMqdIBf/tEufPWBXYmvU20Z0hZ7uyIQ88OFTSs4cQ9MrYBMx7aVQ4SbvyEDaFkEYtq9xlgDaJwCtgsAl6VUr4epz/TxXrZ6BJtPW4Wz1i0GEIr7fa+zZJECDqugbVLAZuwyYFcFbJppAQCT6SVbwVkwiybXK97aVAbQ4rCp//5ujLhkAIsceswHcBVwj8C2m0Cf8aZny6aYbdJS92TpA2gSAA72mZmIAkoRSCIDaJemBELGrlpvolpvxP6sTZAixrv5h9sBABedcgyOGelkI8MuIOZaqmq9iUajiVyX67Az1DXXAIoAxvrQkta9xrIIRB5aiDWAOUsGsGS46Znay9jOXWFgnsQA2mQZcrkAN/762Tg8XcGZf3YnyrVG4rMQ+gvaVAFbHFyM7IvsdKCAYVGFoV+fus6arF2mc9Z+XLPAUqwJucB8bxDPQ7d7ITIxpochRrbgMLxHYOvKHtLxZgsItU7Llp0wseqYtqwABtI1gLY9i4Fo+iIptWxTqLBIs0TYfSheo2XDeKjpxtSAytEIupv5L2DHKAGKpYbppkdoT6GOaxywyg4j3V8n2CzTw5BpoY3NfABCBnCiXIt9Hmx1xkDUziOJBbQpLpE+gAbG6DZrjKkOVA1eKHvrupuXmx2GrMdNeXZd1kUzBpBTwPMJHAD2CKqGRQUCRdNuApbjygDA2PrC0KrDYCG19QAEQgawWm/Gjm0bqAKtDVfcriR7GRsG8MVtcb7AzgPxAaCNt6IaFJimEo2qNJVx09NI7RSwafWr6SbtmgI2ZlNsWevu1ysKGowZQLmRomuQbSuzUM2b43r42lZtt16bk+9vUl9gm3HtNIDm45rqQMXcywXoypoLmGr1TF0BBExbwVn7uLZf12x21wGKZ8X0cAGY9RkWbgxcBDI/wAFgj0CwIsb9RE091RxtYLoxgKqFAC0DKCwEzJULqtYkjvWoWqaqgVbjc9GJJLmtlnlgfdLK4cjnuw4mMIAWnQ9sAkCblKoabKTNLRujXsCmWMPy0GKs/2oHgIbxj3ERiKiIN5VDKKm8bmNXLOduEASKVUfnvahaBhMCgsFOatdlc8gSBzabFLARA2jIApv28BYINYDUTJ1dyto2Tav+bBxs+3ir19BtzrIGcH6hJ96Fe+65B5dccgnWrFmDIAhw2223ye9Vq1VcddVVOP300zE0NIQ1a9bgiiuuwHPPPZc67g033IDjjz8e/f39OPfcc/HAAw9k+Ff4wbWfqOmmZ2sw3W2TVgMOU/YnZ1EFbMUAFrqna+UmYsiiyHFTqottzIpPbfcrFjiU4C9YqbdTiQb3NJcL5EaeVghix9Ao9zOlfZ1Nahmwty4yZz3MKkCtGUDTIhDJABpWxCvvQ7fnwUW/Kvu1xgRYYdW23bYg2nolMYAuRtBpRSDNZjM8YFgwi2mHIfuOS2a2SLaHlqLh4cK2cEl9XbdUrUsK2CYA5BTw/EBPBIBTU1PYsGEDbrjhho7vTU9P46GHHsKf/Mmf4KGHHsKtt96Kn//85/iVX/mVrmN+/etfx5YtW/CRj3wEDz30EDZs2ICLL74Y+/bty+rP8IKrXYsx+0Oop3IJAMXv75aWmHZIAedygUzX6guTTWcNHQN9ucg16bBpo/Ty46OWGkdmqrGvq1gwgIC5F6DNBp3PBfL03s0GB7D36zPuBGLZv1r45KVVxNum04yLQCw9MdXf323sqoUkQKDbwdCmWEOF8ORMDgDtDxhpPoD1RlM27jFhQEspWmCBqgVzD9hrAO1tvMyeXVvZgnpNcbA9vKljdw8AW38Pp4DnB3qiCnjz5s3YvHlz7PdGR0dx5513Rr52/fXX45xzzsGuXbuwbt262J/7+Mc/jve///248sorAQA33XQT/uVf/gWf//zn8Ud/9Ee0fwABbO1aTDyZAPvqYpNqOvV3Gm+mBvoRlwCwdQ05VOqNjoXJxetKYLDYenQe3zOOs9cv6fi+TTAxOlDEu89bjy/etxNAcgBoK/rvK+QwXakbHALaG7ThezXUV8BstZIeAFr37DVj6lwZwDTdqnVFvG0RiCUbrl6TjkajadXCTyA8GMboYS2zAQKiECSJEbbRk5lqAKN+fXTj2hbFGRtBO3pXUmsA1d/frdjKtpOTeg0mDKCpHpaRLV6Q78KRI0cQBAEWL14c+/1KpYIHH3wQmzZtkl/L5XLYtGkT7rvvvsRxy+UyxsfHI//mCrb9T+VJP2ahjxvXVFtoItRXixVM7VpMFo8ZxQbGBuJP08dWWRAbDSAQpoy/ufWZju81m01rbc6fvuk03PTrZwPoxgAK0b+pDtRs07NNJQ70mRlX2/v1mVWY21sX2Vau2zKAhkUghAygWtltW7QBxB8MbY27BUKvze6V9kaBWspY+pgArb1M1TVQS+sw0rTUFmakAYzoS4lTwCYyHiGZMe0FzMgWL7gAcHZ2FldddRUuv/xyjIyMxL5mbGwM9XodK1eujHx95cqV2LNnT+LY1113HUZHR+W/tWvXkl57N9g0KAfQVeytQmoLjdN06ZoXl8IKk/TBVDvgsNWPJDFLanBsm/Z685nHAojfUNRfYyOoHx1omVEfTmUAaXWgtoLvoZQCGAGxEdimp1Kriy11T6ZdIGwD4VAD2P11NtXbgFmazqYvtIqSUQrYUg6R6rXpkAJOYwDVv9/EbF3Yy6RoC8MDsd06m5ppcWSXTc3LbQ4t4hK6je0yF0xMsWUKmAPAeYEXVABYrVZx2WWXodls4sYbbyQf/+qrr8aRI0fkv927d5P/jiTYNCgHFLG3qfeZtT2BGQNoChN/KskAWi4eScGluM4gMF+YBc5qp33HY4I19d6YWEkIiAAwbkzA/r6adpSwXexFAN6t+wPg0bEjTVBftzu0dCt8UBHaqthWrpsxgKZtEYMg3KSTNLEunRrU18bpIW0Da4G0gii3FLC5Vs/kGROBZVJHIDmuKNawPGSZFpfY+vVRp5bV15roS02fBUBhALuMW5ZVwBwAzgf0hAbQBCL427lzJ/793/89kf0DgOXLlyOfz2Pv3r2Rr+/duxerVq1K/LlSqYRSqUR2zaawbVAOmBWBNJtN6026YFD1ZmtPAVh2AinZTduksVV7CtNUtcBIfytYm5jtDNaifT/NxxXt6A5PV2O7d9j2fjVtB2e78Yuqz6QNX0BsTqZBsGmbQfcqYLMA0HTe5gw3aRHM2FhfCN1q0tiCITNpC6hCSBfKGTCAaf22TdauMJg0ZK0N/3bTwFLeA0upjSljaau1Tq8Cttdt5nNBoi+qgFwbLeaWkYyHU8DzCi8IBlAEf0888QTuuusuLFu2rOvr+/r6cPbZZ+Puu++WX2s0Grj77rtx3nnnZX251lA3AUobGNu2R4CZ5kXqRyysVexawdEwgLYbvgphqjtZrnWY9bq8XwCwdKhP/nycDrBqwaQA5uxEKC8wZACL3X3fBOpNy0BNpJCMewHbWRelMYsVi1Sl+rq0Tdol7ZWkWxUQFbdDls9CXzcG0LEiPmy3GD/PqhZpSvFsz6ToS22fhbDDiFlBlHnLzdb1UmdaZAqYWAPYGjs9uKw4HAZMquLZB3B+oSfehcnJSWzbtg3btm0DAGzfvh3btm3Drl27UK1W8au/+qvYunUrvvzlL6Ner2PPnj3Ys2cPKpXQT+2iiy7C9ddfLz/fsmULPve5z+GLX/wi/uu//gu//du/jampKVkVPJ+gPlDmm1N6AKiOa5tO68Z6ODGABukDFx/AbmO7VLoJDLcZwEYTmNK0cGoAY3MyLxXyWDzYGnf/ZLnj+5U2e2FbBJIeANrdB8EAmhaBUHeZsWYADXSrgJ3RNmBu1itYJ9MiECB9kxbpd72NYBqKXe6FbQAsICQBiRpAi/saFhilMXV2ulVhOzJLfBgyPmRZBpamNjC29mAAFA1g8rytOaSATSqiWQM4v9ATKeCtW7fiwgsvlJ9v2bIFAPDud78b1157LW6//XYAwJlnnhn5uf/4j//ABRdcAAB46qmnMDY2Jr/39re/Hfv378c111yDPXv24Mwzz8Qdd9zRURgyH6CmxMxPpukLU5QBtNuku43rwiTYMIC26YMkfaGtr56K/mIOxXwrlTI+U41sxOp9tZRTYcWiEg5PV7F/otzRIcSZAUxhJ8Rp3zRYHTTdpGVnDdqKyrqlTsu2t669BUj3cV02vTQNmCiIspVDhHMizhTdftMHlLRtwnywua9C3ztVruGTd/0Ca5cM4q1nH9fxOtsqVdMew7ZMnWkA2LBkw4uGKWAXBtBEa+uSApYtDBOuudlshq3gOACcF+iJAPCCCy7o2hMzrSk9AOzYsaPjax/4wAfwgQ98wOfS5gR1y4o3wKxjh7rRUlZU2vYBBsxOvGKDGbLc9JLaNbmmvICWUH+4v4iDUxVMzEaZMJX5stUWrhgu4Yl9k9g/0ckA2mr1+g3Nb2uWKfuwUjNtM7UL1Gw3PdtN2rQa2rh3sWHRigsDGPYDTmIA3Z6FMAXcOa5L/1fAXANolgJu/T07Dkzjk3c9AQB44xmrOwIGW72iuQ2MHbNo2mHEVg8r3v/U3sWWWkjA0Mzfxwg6Yc6Waw1p3s0p4PkBfhd6AGLjDwLzBaSvkK5NcdGqmXi1yRSwxYanBpZJAf101c0GRjBQ+kbtkwIGVCYsGgD6aAuXtHWAh6Y728HJvs2G17tksDXWgYTWcgLSUNjwcGGqpxJTxNakNr2tlp29jEnhEmCfAjXtXOLFACZcc5gCtnsWuvkAuh6IBlK8+2zsdeKe7f96fjxmTLv3SgRqaYchW1/UPsPiElcNYCYMYCF93rp4QqbJeNT1ghnA+QEOAHsAtosSoDKA6RrAggVTZaKncjERFdfbbCYvINNlTxuYhGIN296nAn0J96LsEAAL9Hexq7Dt1LB8USsAHJvoHgDasx5mbIpr/9O0lKq9BtAstWzrA1hM8JdU0Ww23RjAoDsDGBaBWGoAuzBWYZW5mw1MUnAlO82YpIBjA8CJjq/ZtC9Ur9G0w4jpUlsylFlY+wAa2G0BblXA3XSgAmWZxbE5tHRn8EX6t5ALnLIuDHrwu9ADcPF6MtGm2Pa9BMx0Tz4MYOu6EgJAx04gSfpC21O5jqRUisuGL9Ctq4LtqXz5opZl0VhMQUl0XLvN1DjtZa0BNGPq6pbPg0nhEhBWxhprAA2qi6v10MKpRKkBFAGgawo4lgF0tIFpB20/eGKsY942m00lWDOvAlYRx4bbspVZtYIzLbSyDdRsO4HYMHUmTQJcqnXFLUsKAIWEh9m/+QMOAHsALg+5TRWwi34kbdNTX2szLpDsAzft2AkkKQB0SZ+oEKkU/fTvEgALSDYlJqVkuzktH24xgLf/5Dlc9pn78ODOQ7Gvs+0FbOqpZluhaJpStWUATTwx1d9rmro3OQyp98iqCjhBtyoQBoCWNjBd0n+2GkiBZUOtg0a51sAffuun2piqg4FbCvhwTABYs7CWASx8AC3XhKyMoNVewN007nUH826TPvGz1ewYQNb/zR/wO9EDcBH6hi2KuhSBOKRATTZpYVdixwCGf1ucR9n+iTLGZ91sYJL0NC6Lp4qkrgp+AWCyvs62T6lgAAHgge0H8cm7fhH7Ott0mi2bYqrVE5sNtaVGUitAHbb+leJ+NZrJlY9iIw0CtxRw3GP2sTsex6f+/UkAwKJS0XhMIDkYbjSa1oG1wDEj4Ty7/SfPRb6nBscmgbX6GnEdh6c7PTFtK/hlCjhVt9qeW4astakRtL0lUvi6bjpAtyrg9sG1yzW7mJeLtyLpOXMJKhnZggPAHkDNciMFumt95Lh1BwbQYDOtOBRBBEHQ1UfqldeFpt3CMNkUSQalLql1FUlaGpe/XyDUAMakgC2ZutWjA5HPnz00E/s6e0G9qQYwG0sNW2bRpHBJ/b22KWAgmbVW5QA2FeHdquJv/N5T8mOh8zRFMeFgqF6/rQ3MyuH+xO+p1cYm75d6j95w+moA8b2xbVtjlox7Abf+t7bbItYAmvSDBnw1gOkMoF3hkjgQJWm43VhrRnboCRuYhY7Q8sD+lNe9E4iDBtBgXFu/OnXsWqPZEQBMlmuR4M1WQ5LMANovniqStDRledL1SAHHBoB2TN2axdGNeefBaZRr9Y4TuLWlhuFmKgX1hoGPbbsu4ypgUyNoS12ZWpRVqzcRJ8dzZT1CT7Xur1sxbNeaUjwL+iat3hvb53ZkIHkbUQNL02Dt5ne/HM8dnsHSoRJu/8lzOBLDANqmq+WhxZABNC6IKpqx1rbZBnUOdjdsdteHd1vDyy4awCD5AA8ohUuWulVGdmAGsAfgEqiZCH1tNWWAGgAma1Ncq2CTPAaf2NtZBWiDJEF91SF9okKmUnQNYN091dHfl1wFLBgs0+vVi2XqjSa2j011vM7WX1AGaqmbqR1TZ1pRGVbF01YX2x5c1L8rSRPrkkoDzDtBrFhkFwAm2cuo7KhtEYjK2q0ZjR46VHbZlAG96KUr8a7zjpddcQ7PxBWB2LHL0gbGWANIWwRirS1U3oNuY7vouLt5QQrMSubafA0Tz0OSHEKYl9t2r2FkBw4AewA1h0BNnvK6VgE7nB6Va0jSprj6iSWlJp5JSF2aIslU1/a0ryPper00gO2fueNne7DnyGzkey5M8DEaQ/TE3smO19gHanb9T03nl2lgaXsgKkrGg5YBLETSdPHX7MoAmvrALXdkAPXiEvFe5gK3A9FNv342AGDxYDQlbdteT8XoQDsA7MIA2moAq/Vm13sq56zhLbDVAJoGarlcKInp6uTgQA6YFIGUZQrY/H3LpTKAbfNySxcHRnbgALAH4ELzmzzkLqfHgkFqwjUAShInq5vrhy4+2WpMILlnq4sGUkUxIcimqAIGgA//4yOR79UcUtbf/u3z8Zl3nY23v3wtAODJfZ0BoG1Ktc+SAbQV1JsGlsbVxdJgOkUDaKmFDIIg1a7FJZUGJOtWdaxZPND1+0njdrDhjhYwAoKt09P31YbbYVAd8/BMtSPbYN8JxI5RM30W7Pti2x/iu16vpTk8oB6IumgAHVq2SXlBzJx99vAM/s+//BcATgHPJ3AA2APwsWvp3gvYngFTryFpAQntNOwCq6QUsFjsz16/BP/zwhOtxgTC07xuBO2yKKsoJRpBt6ugnXoMhwvuT3YfjnzP5f1au3QQF5+6SlrCHIkR1Nv2KTW31LBjJ0x1WrZpOtOWbS69cNOCSxdDXXVcPQBUN9cvv+9c63Ra0rjiEOMyZwFVuxq9Dz7ddgSbWKk1vMdVA8Bu89a2EloEM9V602hcm9tr8pz5VAGbFIHY6JiTDhcA8L+/sU22CrTtXsPIDhwA9gCqDht/UpcKFbbMD6CJkxPGdmcA40+mIkBZPGBneSGQ5E/lanshkMSyyk3fwe9KvcbRwejfG+qe7McVesA4psJ2E1GrgB/adQjf2Lo79nW2TJ01A0jcVUGkK22CoLTg0sVQF0jvXgMApx07ajVma9z4Q5ZtNxgdScGKLVOnYqgvL99j/eBiewgo5HPynsbpawXkodDwPqjpzMnZZBbQhwHsll52KWQz2Rtk9boDAxjXC/j+pw/Kj5kBnD/gALAHUHfY+E0qvVyYxXwugMjoJVlf+KaA9Wv2NWxOqwI2Xex1JPXU9LGBmZgNN7r+jmpd90067FucbDBtb6nRwKWfvhd/+K2f4kdPH0gc114DSGvWa20E7WDYnBRcujKAyeblarGG/TxIStO5tG9UkeSzV/GYs0EQJBaChAVs5uP22zBqhrKFfC6Qz9ZUmY5ZBMwORC7jmjwP0gbGYt5K2UJMYHniMYvkx+wDOH/AAWAPwNbzCoi2v0qqynLpMAIoXoBJDKDjZiICXP1k2vAMANM6gVC3gvPRAL7uZauU64sPhF2ud0gygMn+gqb3V2wKM8pYT+2PVhc3GmELtMw0gMZVwPGslw6XeZs0ZwXcGcD4Z0z9PS5McGJFvKcGULYw1DWAlt6KOkYSCkFcdNElg37ALmuNYLSEzUkcbPtiA2YVxnJchy5R3TuB2M/bbgzgySuH5cdx32ccHXAA2ANwagWnip4THnSXDiPqdSSxi84MYEFserQMYNKm57Ioq0hKpbja4ACttO9X3n8ugC5FKw6b6UBfsljdlmEWwvcZhanTYzx1kTcd11wDaPe+mfTsBdz0amnVut4awATdqvoaGyQdhlzbwAmIv0+vshXPnKu2cHFCAOjSxUcwzI89N47f/erD2HVguuM1LoesRUYBIKzH7TMwXLe1wwGUzEWXcV3W8LB7Tffn7NfPXWc8JiNbcDK+B1BzSQGrvXXrjdhqLtdAJRS+E9vAJAjqXVLVKkJT3XjWw1sDSFgFDCibaQcD2L6vDtfbLQVsG2Av6u9cNvSfVDcBU3ZCap7SuipYPg/ywNJooNlsJvrRuRiYpx2GBJNiqwfNJWym4nCUC8KUmw2S/AV9ijWAKFNUrtWl5tQnBQyEhSBHtBSwS3ckEQD+/te3AQDGJsr46m++MvIaF0ZNHIimiBnAkkEVsMtaa+IRK75n1b6wy2FIjPcXbzkNx4wkd45hzC2YAewBODGAkQAwpVjDMlATG3WS7qnisHgAyW2qxILisuEB3RhAvyrgpBSwXDwdWQ+xCetaGh8mdLBLCtjFB1APbnWW2YWpUje8JJNxwEED2H5/m81kdqLeaCq6MocikIwYwCTzchcWWB23kwH0TAErf59aZOGbAk5mAO3XxAHNf+4XMQbzthpAIJRXdGMAXZ5dExsYnwCwW594l4KzbgGg9LJ1XGsZ2YDfjR6AS6o2nws9ypIWkHLddXNK0QA6LvpJKeC6pU2JjqT2V94awIQikKpHqrZ1Pe3AMsEOx2UzlQxgzCblsjkNa5V8E1oFpBq4mLaC6zOQLQAOvYCVcZMCNfU9pLSBcdUAhmlrjQUWGz7xYcg3UMsp6416L3w3/lHFC1CFbZtBoNMUPa4ateGwJogUcDcvQJcsRtgZp0txiQNrbeIDKPWwFs9Ctx7DocWS27xlZAMOAHsArsxPmt+Ta6oyVQPo2As4MQXsIPhWIf2pOphFv/RUkgbQp1pX/Tl98/ex6pCGtTEVtraGzUBnGlhnP3wYQKC77sn2QGTjXQlYagBTbGBcGcAkexnbftA6xNxJ1AA6jgvEB5e+G//igVYK+I5H90S+7hJQ6b2xnz0800VvbJFaVqrik+Ayrngvumlibc3LW681TwG79J+PO7zJtYsZwHkFfjd6AGFAYZmqTan28vXro+8EkhBQUdnAEDOASa2afFmPQmLA6n4fRPprqlzr7KrgoE/SDYh1DzRxrYGFVs2+/6nZ/TXxrlTnnM37Flbb0zKARUW3qMK3e02SJ6avVk+9pkYkAPRLLQ+3Dxrbx6YifaxdnoVVI9GuKfVGE/smyh1fA+zug0nxkkvHDhFYdmPDXczL+1IO8PVGE2KJoGIWXdpYMrIHB4A9ANdAJU1D4swApqS9XItAkphFkbq1YahUhIL6JGbRlU2J10L6bqYyEE6wgXHZTJcv6kMxH6Bab+LZw9HeyuLX2FzvsMYA7h2P9i12YRWDIDAyv5UHAsPrNfGurCqsoo3WNM1TTfwdNi21gHBuCXPqjut0nFv5hH6tvoEa0J0BdGV+1Kt8VukJ7rImrl7cWXzwnPYsuKSWTTp2iMOnzbgmNjDyfXMw86/Ukg5DjY7XmqCUMGcBRbvKDOC8Ar8bPQCXHrBAeDKdTTDWFdoS27RPWtrLNbDsS0l7OQdqCbonfx/A7pWarptpWprO5XpLhTxOPKblxfWz58Yj33NhAEe1riz/8fN9kTSwy5hAuImYMYAuaS9a3WopJWCVVcC2bHhCta7rWiCQZgPjEwCGBSZKEYi0l3F7xn71rOPkxyqD71Ktu2a0s29y52HIfm4Z9ez1GLe7DYx9ij0tBawyji7WY3GMpa8shpENOADsAbjaoAjh/0xM5ScQpizsq3UNtYWODKC+gITmrFbDKePGB5Y+KdXWzyVpAP3SHaGYvhlJ17q0fVKxcd1iAMB3H3lefk01bLYZ98UrFkU+r9ab2K+k01znbKinip+zzWbTrf+pTKunsda0LLsrA5hk1isCH9e5lVhd7BmoAUkMoB+zODpYxFnteaseZH0ZQCFhGJtMspdxYQBNNIAOqWXiKuBiypxV/QFtmMVujCXFAYNBD343egA1B/0I0N37DVBallkGgP0pC5OrqWzSydSXASwmFFW4dFiJG7eDTfEM1NRFtx6zmbqeot985rEAgPueCtu2qayKzeb06hOXy49XtX29VB2ga3CdlvZSb7XN+1ZIYQClB6Aja52k03JlAJMOLVXPgqi8nLPxleskKeC6Omf9xf8ieFYDQBcLp9WjYQAojNH17IiXBtCgY4edbY04wCdXF7u8b2kaQNUf1UkO0VUDyCHHfAK/Gz0A10BFLCBTCQtIRVYo2k2DgbTA0re4JIGp8zZsTmDqXHsBx9leAOEJ2rcKGIiyKTVP9mflSMsGQ03VunaWOP/E5fjMu87GXVteI/WAah9j1wAwrV2XmhK1YgDT0l6OKeDsGMAkGxi/jTSpwIgmBdz6WdVuqUbALMYFgC4M4KDiA7hmcSsdrGdHxPyi1gC6tK4bKHZ23NHhUr2d9iy4zoW+BFssINTecgp4foE7gfQAXK0fhEFpUgrYNVCTliJJgaVjOi0ptexrBB0GlvHjulcBx1dUik3E1VIjauIddnHxLVpRzaAbjSZyuSASYNoGaxef2upbLALA8VlVA+h2rWkMYDRgtRCot+d4sh7WLwBMCljLrhrAhEOL70Yqu+JoleC+PoDq2Oqcqkg2yYcBFO9deI9draFuufIV2D42hT3js/jJ7sPJDKBVj+H2HOhSBexSyJaWwQHC58SlSUCSEbSzHCLf7mAU8yzUHIpVGNmD340egGvP3jSmruxwegTCQGKq3Dlus9l0Ti0nCfV9jaCTAktfQb2shk5qMefJ0gBaCtgzZa1atwg/QLXbiOu4w/2tgpA4ZpFaA6jODZvNPy6IiI7rtumJ9B99FXA8A2jbt1lHchWwWAv8bWCisgX/wLI/ppjN1RrqgpOPwZX/7UWJ7JoLcy39+rrYtbhc70CKhhtw7ASSYgTtKgcQhSjxPoB+8hVGNuAAsAfg0goOCBnARKZOMoB2m9NgF21KzdFDClB1Wkl2Lb62KgmpZWLD5hoRSwNEAx7f9F9/MQcxtOgI4ppSVbGIMAVsxwDaBIDtICIxsPSrAk66XlcNoKyIT2CXnVnrBN1qxfPQAsQbrsuKeI8UcEmmgBUG0LHKXKA/IQB0WWulbKHawFS5hiNa27rW9dqPK4LUbgygizVUZilg5QCf5DXKPoDzCxwA9gBqjqm/rLR6kgGMGVddVOwF9d2ZOmcjaDGutkmL3+NuMJ2QAvZMdwRBoFRrtq7RtfpVH3dIe+9kej1ofd8FI+0AcDI2BezKAHbXANoYTAPhhl9OSAG7Fi71dbG+ADwYwFw8m+LLpIg1JBsNYBwD6J/6k+xtzU8DqGIgRlcIqM+Dmwbw9X9zD179V//eceh2WcMHUyQ8QLim2Ry2ZaCWUsRnG7SrZtQd85ZAYsCgB78bPYCws4R7FfAjzxzB80einlfOGsC+ZA2gyoS4M4DRzcnXCDqpc0nFMQUukGRcTdJVIR9lU9RN1ecUPdjWb05JBtBfoyVSwOMxDKC1eXm+ewBYb7gFFP0pgaUwxXVlPZICS/8q4Hh22bcIJLkVnL8NjFpZ7mtcDcQXgcg1wTsA9JeFCBnA7oPT2H1wBuOzNTy+ZyLyGpfnQWZauhSBCObWygdQpmq7V8S7PgvqGPJzzxaGjGzA70YPQGwCttWqotn5z547gkuu/yHOu+7f8dT+Sfl9obOyDYBkdXGMBlAEP0Hg0rs4zQaGVgPoyvoIJG2mFJYHIsARf7savPosomJOiADQ1wsRAFYsalUXf+m+nXJOORtBK5Ya//74Xjy5L7qRulRTAvE6MhWuhUuljBjA5D7TfsxXXKGG+nuojaApnoXwvesc1/Xg0p+gr2s4PA9iDuw4MC2/9swhvcOIfXXxQJeDtoCLzU7YCSRFDmF5byPFa3p7TDkmp4DnEzgA7AG4sh6CqfvxjkPyaxf9v+/Lj8WmVbLsUyqCiLjUskgDDvUVrFOKgn3Qux80HPQzKpICS1fDaoEkxrLmGEyoyGv6wkgA6LGIhingaADoM+bKtr9audbAzT/cDiBsL2etAWxvprdvexbvvWUrNv/ND/DMoXBjdb3e/gTGRyC0RLIM1LpUATebTQ8GME0O4VgEEhOkqb/Hpqds0tgRDSDBAWOgr5Nl9T24JBWBuKSW4w6QO5S+xQAgbokTA2hQBOKUAk7qiuOYAs7nAvl+qAeiiNk8M4DzCvxu9ACqjovd4sG+rt+Xm551FXA0jajiyEwrDai3CjNBQZ5M4wXENqfnyLgJHTtcU+DhuAnpNIK0qn7NairQJ1gb1Nhb2766cVANdv/xoWfb47oygK2/WxxaqvUmntgbstau11uSVcC0ethuPoA1ZeMrOXYC6WiL6Hm4yLYVXKcm1rdoBYg3WqbSAB6ZqcZ223Gp1lWxp6M3tn0WRxaBGPgAUraC89HriXmpPg9q/22uAp5f4ABwnmKqXFPSdG46mtHB7kGY66YnBfUxKQQRAI44BIChVk/362v977rYJxmUln0DwATG0tVSREVRG9vV/kSHbgFBwgAOhwGgMNh11gDGvBf7JsLNNCsGUMxl62rdLgGgGmxStVukshjKQgMozjsR83LKDiPKc1b3PLgIVnH72BSuvf1n8usujOVIf+dap7ZFBNxS92lFfM1m0yl1H64tTZldiVyrQ2WxQFxnHHXtYh/A+QV+N+YhKrUGNvzp/4fzrrsb9Ub4kNsySotTgrByBmkvEQCm/e44JBtBtxlAz2rdDmGyJ+tR0HR6AhSbXpgCjBaBFPOBc7Wuek3iGl2ZOhXHLRlQxo8GGLbjxjHH+8bDzdT1eqWOLEH35MwAdilaEV8LAocUsJizCdZFrlqqJA2gaxGMiq4MIIm/YPg1Xwbw+GVD8uO7H98nP244jDsy0NlPQQ8AXZ4HUQVcqTU6AnYg+h669AIGouycgKs2HIj3GFSzF2wDM7/AAeA8xK6D06g1mhifrWGqUnNmPUxTwLabXjfvMyF+dkkBy9SElgJ20c/EjptQreubAk6y1PDZ9IraZuprWSPHFSmaDgbQfSnI5QJ85l1nAwAOTFUi49per2AQVexTNlPX6+03TAHbBmoitRv3LAjtVqmQsw7axSbdYV3kGbAnHVrCOevP1NVjGEAfhjlOt+jrA7hsUQk3/tpZAKLvucsBw4QBdJm3g0pqOa4SuOoYWHWr1gWAmUpr3LjUtunY6hpOlb1g0IMDwHmIg+1NFGgtoK4BRRILJxYj7wBQC6hue/hZ/PW//RyAowZQdtaIZwBdFw+RAtYtNfyLQOJTwD4pFIFQUB8tAvFNoeht8ShE+gCwbKh12DgwWfEa99iYAFDdTF3HTU8BO7LhMSkvgYl2QdRwTICQhmJM2hNQAirnNoNhkBbfsYOCqVPGJThgxLGWch54sOGr23MtajDtwtR1zpn9k+WotlDa1phfX+vg0Po4rhJYDbKsOoEor42zLxLB5oClbhUIDy6VuurZGM4tn+wFgx4cAM5DqJqnar3hzKYk6fAEC1J2ZD1Ez0ed9fj9r2+TH6fpD+NQjEkfAO7WHwJpRSC2f78+rsoANpSN1Yf1kBXGDZEC9mcVgc52exTXCnS2g3Nl6o5d0hkAHpyOHoha49oGgJ2VpCpc2eBubLjojCJ6JdugkFERiPr3VSM6Lb/DEJAQqBGw4XHMom8XHyDeDNrlgBEX1FRqjWjRioMRdBAEGCwmVwKrhw6b5yGXC+Q8mO2iXXUKAGMK+XwtexjZoSfekXvuuQeXXHIJ1qxZgyAIcNttt0W+f+utt+J1r3sdli1bhiAIsG3bttQxb7nlFgRBEPnX39+f+nNzgT1HwgCwUms4M0r5XCC7NKiYrtS9evZ20wAKOKWAE7oUUBlBJwnqnTWAiphanPZV9tLHUkMKtevRIhBX+w99XPHei3vtqq8U0DdpyhTwYTUAdNUAprSCc2WDuxWBjPswgNr7JODL2KrPuvr8UvgAxqVqKYzG47SF4fxyHzdOFtAguF6BiVn/3tjdCkHEs9CXt5cY9LfnQVxgKb7mkwJW5y2FMT4jG/READg1NYUNGzbghhtuSPz+q171KnzsYx+zGndkZATPP/+8/Ldz506Ky/VGJACsN0IjaIdFP04HOFutRxZ/StZDwK0KOJtNL6m4hMoGBggX+BpRxZtMh9ej4/qKqHVmiYoBFO9NwzMAXFTqPLAcmvbvMRxnJqzCtwpYr4jffXAa7//SVgCIPYSlIdEGxlNeoAa4EasOSh9Acgaw9X8sA+jjL6h4AYoDHIUkQszhybJ/a8SBLt1AqjX3NUGMG6eJFb/L1rwciNeuijnswy4zsoH9ynQUsHnzZmzevDnx++9617sAADt27LAaNwgCrFq1yufSMsEfXHwy/q5tqKumgF0e9MWDRew6GP3adKUeCbIorC/05t9ODGBCCtjFnT8ybsxm6sOACqg6rFqjiUI++jv8Kh+1IhCiFHCfxobWPVtqCRS0zZ9KWwgAh6YqaDabCILAOQBK8wF0tQRKOgx9+B8fkR+7pICTWWs/X70gCFDMB6gq2mJ1XGoNYM1j7RLIxxSuiI9dvUGBsICn0WwdtPoKgfMB49jFA3j2cKsAbri/gMlyLdIbu+7ohzhYbJvul+v4wRP7cebaxZJRrngE7d2svHw0gKWYeUtRFMfIBgs6JJ+cnMT69euxdu1avOlNb8LPfvazrq8vl8sYHx+P/MsC/cU81rTNdau1plf6T61QE5vbdKXm1bO3TykCEcGZng52CQBl+kAbS/Ss9PXri0tLeI2rLOZiQ3LV5XSMrRWYUFTrAgobKsf1CygERApZBJQ+44p58IbTW4ezWqMZagtdW8HF6L1UeBtBa4Ga2gosrko0DYmdQDyLQID456xKwNLkY1K1rhZWKsQcasQYNvsElmqAI4Ie14PLr5y5BkArrSwYwAmlN7YMWB0ZwBv+40m86+YH8NHv/Jf8nksbOAHBiIuKXxWzMgVsP27YZ5hWBsDIBgv2HTn55JPx+c9/Hv/0T/+Ef/iHf0Cj0cD555+PZ555JvFnrrvuOoyOjsp/a9euzez6isrG4uP9pS6aosJyuhKmgF30IypjKB50PQB08QEMNTnRscL0nP2JFAg3tVrMxqR+3xaRAFBW1YaBj0/Fm95mzpf56Ri3Fk0tUzGAegrYRVv47d8+H1ectx5/8ebT5SZ9aKq1mbr6v2VdBazPf1EVDTgygEkekwSpz7igVQSDFL2A1WumOGDEtpgjsEUq5gOIHxfFQS4+gADw+5tegv+16SR8+7fPx6L2+33rw8/K58B1XFFhfN/TBwAAX9+6O9Qbe5h39xukgP2KQDp9ANkDcP5hwQaA5513Hq644gqceeaZeO1rX4tbb70VK1aswGc+85nEn7n66qtx5MgR+W/37t2ZXZ/6IPl4f+1VWhKtWFQC0DJr9qmA7YsLALWFJM4aIQ2lQvyiVK56VuvmQ2ZCt8AB3APAfAwDSGECDSg2IFqxhm8vTT21SMUsilScngJ22fhPP24Uf/am07BkqA9L24HUoWk/f8H+BK2eAHUruKVKAPjiFYusxgRCJqWTAfRPp8VdM0WaTrLAcT6AxP6Cvr2AgVY6XO8J7MoAlgp5/N6ml+DUNaOSAfzWg8/g3362x2vcuCBsb9sYXRbuuKSAZRUwrQawWycQ7gM8/8DvSBvFYhEbN27Ek08+mfiaUqmEkZGRyL/MrkfZqEPLA/u360MXn4xCLsDfvONMac2yb3zWqwAiTkjewYC0g00bhLqURkRTKBnAott0VU+eYqMT113IBc4VsEEQdJhBU+ld1ApjgK5Yo09LLVNp9dSfV61wfMdd3J6zn7r7CQDunSVKKQygbwCoz1m1COoNp6+2GhOIWhep41L4QRZjN2l/G5g4BpBCuyoDwFhfPb/5pTPDFPNWDdp+svtwZFzbg1ZcJa7wxfTpZNTfxV7Gpwo4rgiEos80IxvwO9JGvV7HI488gtWr7RfrLKC21PFx03/9aavx+J+/Hm8681gsaW+m1/7zY7jl3h2R32ODIAg6Ul8qs/Kl954TYUBM0a8EeGpAGTKAbilgdeGpaQygq/5PQNfqUdhpAKrHoBiXKrAU7I8WWHqOq7OhFKlKIJwHdz++DzOVurP9h/QBTGAAXauA1TlZjUlR/s4FJ3jpYQFdU5cVA0hnA6P2lxWaTYqK+PgqYL/nrL+DAfRPWZ/zoqXy43XLBtFsNp0PWnGZlANT/gGg9ECM62BDUgSiHlo4BTxf0RNVwJOTkxFmbvv27di2bRuWLl2KdevW4eDBg9i1axeee+45AMDPf97qRrFq1SpZ5XvFFVfg2GOPxXXXXQcA+LM/+zO88pWvxIknnojDhw/jr//6r7Fz5068733vm+O/Lh59igjct5+m2PRVS5ivPrALgHtatVTIoVJvYKZSx+98+UG5mawcKeE1J61wGlNNOZSrjQgj2Pq+KwMY/ly11gBKSgUdSaDW6GQAvbV68SlVsk4gWTKAzaZ35bbA+EwopD84XXHXAKbYwPgaQYsxdI/M1aNu3qKFCGvdqjAHaJjg+CIQfxuYeAbQfx7kctFDlvo7fOeXWsXdbDYhLt1n3Pf+txfho//SKtao1hpQbodDANi5RYtOUT6V23HG6M1mE3/5r4/jp88cAeDXzjM2Bcxt4OYdeoIB3Lp1KzZu3IiNGzcCALZs2YKNGzfimmuuAQDcfvvt2LhxI974xjcCAN7xjndg48aNuOmmm+QYu3btwvPPPy8/P3ToEN7//vfjpS99Kd7whjdgfHwc9957L172spfN4V+WjKLCsFE5qcf5kbkyYOLnHtx5EN99ZA/u+q9WQ3VXlg5op2Pba4TQpjQaoV2L69j5XCBbKomUFD0DqAVqRAyg9AEk2vB0T0SqKmC9Iprqeg8rHoCHpiruGkCtCvihXYciBtNSE2tbEZ/gqyeLShxYFEALABsxm6nH/Cop2YVwXH+WJq+Zl6sfU9jLiNvQaDQhssFk1etaazzf3thv2XgsgNb7pY7r6gOoQrRbrNTc15q4FPCPdxzCZ+55Wn6e1ks+DrIKOMYHkDWA8w89wQBecMEFHT5zKt7znvfgPe95T9cxvve970U+/8QnPoFPfOITBFeXDdSWXVSbaZw5s2sAJDYRvem5K6MItFLL/cU8piv1jnZ1vmMX87lWQU09atfia05a0NgJqoo3vRMIhfi/NW40BUzhp6b/vLqZ+h5a3v+aF+GG/3gKQKsQpObIsArGo9Zo4u7/2ovf+OJWbDhuFP/0gVcBUAM2u+vN5Vo60FqjGUkvi/nrOmdVpjdiqksQsOuVmvVGyHz5PA9xlcuURSA6aw34d7BRLWai43oNGymGiAaWlgxgzAFirCMF7MIAdnbG0dfyJQ7tPEWbUPVwwSng+QsOyecpohpAmgfokjPWdHzNlVUTNgLPHp6NfN21UEOOq6V91U3VJwCUVjBaEYjPmEBnP+Cw7ZHfuHpXBbLqYi0FTKUBVDe2BiED+MGLXiI/PjhVcR5XlRfc+L1WQPmTdqoLUFvBOVQ+xmjqXG1lBHK5IKGzhv880G1g1M3aZ9w482oKLaheBaxaW3kzgEr1OhUDCESLg9TUNQUDuK9dBRwGVu4MoCqJqNSj+lg3M/9OBjAsuONwY76B35F5CrVjA9VmumSoD397+cbY32OLQRkAzkS+3u+RAm79fNueQGMA87nAK6jSjXWpKtOSAjXfjSkrrV5nCtitqEKHysTUGs2wf7O3RiuPN7araNUUsO39LRVyUgbwi70THd/3kQTEdQPxrVwH1HaAnWyKz33VA9aIeblPqjbGvNpXvwwkd5kB6LSrjUYzUmXsO656j30YwLgAUKy5wsvTZQ3X7W/EtapwWW/jOoFQyWIY9OB3ZJ5C9sWtNUgfIJ3xck0BixZFzxyaJhlPQD+Z+noACqgpdYBOA9iRqvU4lavQ7WWo0ij6faCyl1HHaDSbZAbTQGikPDFbcy7eCYJA+rONKy26hLSk7MEI64UfQDhvfQ5Efdp7BdD0hNa92tQUs0+RUciyt66x2WyCohOI3mGkXqdjANUDHOW4agDoE7DGVQE/f6QVAFY8ZCH9Ma0RJ5TnwpUYiCsCYSPo+QsOAOcp1CIQKk81oFOU7hpYiZPps4eiDGBc1ZoN+joYQHdTUhVFjU1x7f2qQ2cAqwQbNBDXCYRGU6ezSpQ9e3PqZkpUXAIozFKjGbIeDu/bcKlzbk63RfA+B4IBKVtQNIAUDGBMUUW14T8PihoDqFZp+mjq9JaLKvPlVVwSRFPAPinVjrGV9DKltjDOxzUXwLo70EAxnLOnHTsCAHj+8CwajaZXFkNKbRT/Q7XgytlzNeYwxEbQ8xc9UQSyECEfJOWE5msBAhAygH1RrZ5AXKWxDfRqzVkqBrAQDaioikCKGutRJdIAig2zLrV6NAFVUdGWtsalYwDFRq1qAH2LSwD1HjdQD6Jfs8Gi/gJwJPq1IzNVDPblnW1gALWispMB9C1cAuLZFJ+UqkjThQEgEWutPQtUqdq8VmnvE1B1jK2w1pTPQikmBewStKsM4KtfsgKPPjuOWqOJT971C9lyzjcFfO+TY3jfl7bKw1Dr+t0O3HFyCJm9YBuYeQcOyecpxCKkBlh5AgqdKgBMcol36XuqIjTsjRaB+BdrRJkv2fuUjAEU1bo0DKAYt6oxi1TFGiKmoEzVqlotoQGk2ExDPWSYUnSZt4tiGMDD01XvSnPxLKh6Kt8iEKDzcKGO68Nc92mHAAoLGCDqXQpEA0CKHsOyz3SThg0HwkNLTdEAUjwLaprd5xlTDfU3rl0sP/7Uvz/pZd5dUlLA7/y7H0WCP8B9vdUP8ADd2sWgBzOA8xRisVAfJJqTqZ4Cdtugknr9DvfbV46p0BcQn76UKvQKRYrWV0An6xEaQVMxi9HAkqq6mJpZBKKeanLTI1j01eBd6PRd3re4uTk2WcZxSwfk504MYCEuABTzliAFrKQ8KSQRehGIT1CtQnpXyoIopbiEoAq41mi1xSM9tOSVIhBCw2L1Hvu0wzt1zQj+/E2nYqZax0UvXRn5Xmje7W4Ds+vgdOz3XVPAobawsyLed34x6MEB4DxFQQaANIuogP5gu570krR+PhseEF6PaFEkTqZJAacpdDaFygamqGxO6v/URSB0hs0hm6b+71sF3Bo7DABJi0uU906wNM4pYA07D0zhZWtG5OdO6bT23Jxtz9Vms6lIF/wZQOHZCITrgU9xidQXE1fE631gyVLASpq30aSVLag2MBQV1gJqYZDP9QZBgHedd3zs98RccDlsihTwM5qGW8B13g7EMIDiY199OIMe/I7MU4gNWRWWkxSBEGsAgdZ11bWAwhWhOLn1d09Xau3f5zdVi5pAnaoKuDMFTJNOk0UgIgVMZKyse6pR+QACWleFJqEGULnHMsXuwHrEFYE8vOswNq5bAqA1F1w0ZWLTm6rU8Iff+gnWLxuS36OwgVEZwNmqP7MoU8C1qB7WOwBMkEMUcoGXVk9lkdViDd9CDUCzgSEsiFIzDlS6YB0Ts62iDR/dahKOXzbodE2lGIPpWaIsDoMeHADOU+gMoO8iKtCZAvYPAI9fNoin9k8BiPo/uSDs2SoCQBoGUE/VVogCNbHQi82jQpSq1YtAyALLDnsZukAtrqsCJQNYrTflfXBh6uKMbW99+Fnc+vCzAOzbwAmIjW3rjkP4l0eej3zPy7w8pmWbLC7xSQFLfVrr2RKMHVWXmWpHQRTNnAXo2eWIDUyTjg2P2MCIQwvB9V75347HF/5zB4DQzsinF3AS/vRXTrUeE1DkEIqmUHzsmx1i0IPfkXkKsTAJBpBKQKszEq4aOFVP9aLli+THq0b63S6sDb0IZLpMEwD2aRpAagZQ9uwVgRqRPYXeC9h3HiQygMTptLrUAPovMarXok+17nFLQ1bjmOFSx/dd2bqBvtbP7ZuIdsUJAs/WaloKWO2L3U8QWHZoAL31sPFFIL7uBerhpNagtcWSFjOKtpBEA6gWgTToGMA/fmPYq358psUAujC3A10OEDf9+tk4xnEdj9MACm1st9/JODrgAHCeQmx6PjqPOFClgJcO9eH04Gl8pfhRnD+wE5+74uX4tXPX4bJXrPW6Pr0IRDKAMek7G+gdMEIbGF9tocbUEWkAZV9VrQjEl53QfQspN9NCPgwuSRlApSJaBEMu93e9EgCuXdqZ4nINgMTGti+mL7YPax8ehjr7YnsVgWRkA6MbQYtnwrcQKNpmkNi6SC0CofRbVYtACKtg87kAy9qVweOz7gFgt/njw1oPSHuwzhQwB4DzD5wCnqfQNYAUixLQucm5PuzLF/Xh0vwPcH7+MYxO3IlTX/ZW/PeXrUz/wRTIIpCqKAJppTmGiFLA1J1AdKaOLO2leZ9ReWmFhRrRgJXSB7CutoKjSC2L967W8KreftHyUJt3woohPLjzUOT7zpZI7Y1t73iUAfQ9tEmvtorwxAw3VYoqYN0Tk868XDeYpnnGgLYOlCiwBKI2MJSm6OrzG6aAaQ7x4r0/IhlA++sd6dLn12dNDCU8qm619XGSdRjj6IEDwHkKXQNI1UYnCAKUCrnQp8x2Izm8C5g+gNVTs1ifvw8AcOK+fwOe2wagCQwuAxavc76+ksYATrUDwAHfDiNab10ZABJtejXiikp9M6W2gQkZQLrNNGIDQyqoD6/Zx79x7dJBbPnvJ6HZBP77y1biG1ufiXzftfKxv69z0wPCueuKfsWsFwiF9cV8QNILWKwBoXcljW61SuyJGQQBckFYASyZOkrdKrF3pWq35GMDEwcRSI3PCA2g/fs20l9AMR9E2gwK+DCAcT6AYv76VMQzsgEHgPMUugaQigEEEAkArbV1nzwdALAGgNju+soHgc++NnzNtUecr00uIO3re+TZcQAUDGC7Crg97lS5zSx6ppY7GtUT6YgKmlaPiqkraH1Vs0jV1tVWcCQ+gJ0Vla6B+wcvegmATrYO8OmLHT83m517qxUGtACwTGAtA3R2GKl66CrjxhXVxZSBTyGXa+vpaFO1avtCWlP0MB1OdXgTEGu2Two4CAIsGyphD+FzAISyhVq7VV0xn5MMNjOA8w+sAZynKGSkAQSirJ+1vcqlnwNyrZ8R66RcLnOF1vc9IHVP7RZFP9l9uH2dfotHSWM9JtsBYJw3nA10Xz2qvpeFjFLLSW21KCofczGCepLqYlkE0vQqAlER17HGdUxf8/Mk6P6CswTm0oBqAxPVw/qz1lEbGJ8WaDqKyhygHFe2L2zSBpaR6mLiVmjikBxmMRxlPMN9sV/3OWCo0oSwnSdrAOcrOACcpwgZQNr0ARCl+K2ZtTMuA953d/z33nd36/sekBqSWgNf/tEu+fXTjh31G1fzF5QBIBEDqDeq900tF7WUdejXRxNYZsIAKgUx2bSCa4QpYM/7ELcZuaa+fNsfJkFvMUdhLg1EK1QBulZwxYTiEpI5UAivmVJekFcCS0oj6LA4rElaBAJ0zl0XT0wAWDYUVsKrhx+fw1Wr8Kn1sZivHADOX3AAOE9R0FLAFIuogLrR+dHyOe1/f6g9Kh99rpVK/rsrXi7Nep3H1RjAKaoAUKsupjJ9VVmv1rg0AZVqA9NsKnYthDYw9QZoBfUKG0rVwi8IAmxQeqsC85ABbG+Y01oRCFW3HRmo1WjmbFHvMkOY+lRlAFnZwGShAVSLVnwPLQJ6oO467pLBcN6uWBQGgz4aQKExBxQnB6J5y6AHvyPzFLIKOIsUcMEjBQwAQyuARccAazYAv/yJ1v+Ljml93RNi0zs4VcHOA60+lWet9wv+gPBvFgHgBLEGsN6RAqbR6ulVwFTaQqAlqs9OA0jHegj2p9YIfQBdikB0fON/vBKvfsly+bm7J2ZGDKCmAZyYFbIFv4Czk6mj8QEUTJQI0sUcoChg61MOWqQMoFIEkoUGUGUAqXTc+l7gujeolcArhuPZQBeohSCz1ToOT7e0issWdXpvMo4uuAhknkJsphUi7ZcK1fDWSVs3eizw+48C+b6W2+3ZVwL1ClDwf8BFQLZjrNVZpL+Yi5xUXdFfjJ5K6RjAqKVGaARNxQDSVmrqlhpCn0TRVitSBUyoASwqgnpRYOAbrACtQ4G68bl019j/t9djoFIHcCJOD57G1YWv4OFTtuCvHxnEH+3/T+z/2+1Y8bsfcLo+qQFsz9lDUxUAwFLP50HvMEJmA5MLn4VmM2RrSVKqinVNZp1AKLWFCmsdFobRHOL1vaDPMQWsHlxOWLEI29p6a+8AsJAHUMVstYE9R1pFJlTrOIMWzADOU+iLJmUKWA1OnIsrCiVIsUcQkAR/QBiQiVP+8kUl0hZ4sghkljYFLAKpKhHroReBUOmT1E0oK8PmaDqNIP2nsD9UFasC6vx3CirzOVQ+dxMuf/xO6Yv56wP34faRn+O1//mPgEeg2q/5AB6cbgWASwbjxfum0G1gqI2ggaivHoX/ndpbl9S8PKZ9IUWcprLhYQqYigGkSQGr0oV3nBMa+Ptq9QaUKuV3ff5HAICVI/0k6ziDFswAzlPoDzllI/GG4k/hlALOEHpARpU2KCldFRqNJqbam6pvFbDY3Mj1VFoRCJWnWpQBVAybKdkU4jRdrA8gmaVG+P67BJUr3vnLaIw/jytu+RYGC2XgNKD8rX9G8aECll/5q1jxzl92vjY9BXxIBIBDngGgVgRCxS6rzFRN0WuSyACUALBGaC8jbWDq2Rxaao0GmTNAOHZ0HNv3bf/fXg/kc+jfsFl+7aRjhvGd330Vgr//PA5/2p21BkIN4Z2P7cXugzMAoibsjPkDZgDnKfSNk9IHsK4EgPNNmKtr8pZ7bnYCqkP9rNKmiMpeRm6mVAygXgRClJ5SDxZ14vSUDFrrtBpA1VONKl0poLIdTuL3T56OlbOfwvLTxjH9aAmPf2M1DjxUwPLTxrFi5lPSN9Pn2mbaOmCZAvZ8JkqK1RJA7wMItDwAKZk6tZWjGJdCXqDawGSlAaTqDy7gXQSSz2HsU3+LY//5q/JLi/oLWPlPX0buls96sdZAyFw/e3hGfu332v6bjPmF+bX7MyT0jdOnMkuHEJMDmHe0vM4ALs+AAVQ7NnhbaiSk06gCNeqOHblcIDP31Ka6KrMkWBpKH8CsU8BOz1jbF3PFaZMIck00GwGCXBMrTpv09sVUfQCfOTQtO5cs9tUAagwgVVCt/ny11iBjFtUxKjVa2YJarZuVtrBGeBgCOtcW2/dtxe/8DpZ/8Hdx3G1/j8sfvxMAcPCmGzH2qb/F8g/+Llb8zu94XZ8gFYTZ+pvPXOPt4sDIBvMr/8eQ0I15KQPAXQenycaiRn8xJ9s+AcCyRTQMoLSBqTaktY5vSy0gDEQqWlstsipgPU1HkZ7KBVJMT7mZFpXignb8R+oDWK415LygKAIBNA2gyzN2xmXA8pOw/4NvlMFfsxFg/6OLsOJT/wKsOdP52tRWcH/4rZ/Kr5+wYpHzmIB6GGpEijV8Dy1BEKCQC2TQUyWqXAdUGUADDULz8tAWCYoGkE5b2GyGawNdCljXhztIF37nd/DUvklc8bUv4PJf3IWxRp0k+ANC5vr5dgHIYk/NKiM7MAM4T6EvmpR9FEVQMR8RBEEkDUymAZQG03WyllpAMgPoG6BI1kvay9DpnuJYD4pewGqajtJUVzwL00pvXSoNoNpj2vWQtf/vb8XYoyNYftoETrnseSw/bQJjj45g/9/f6ndtSgB471MH5NdP9zRFL+Vb4zbbNkCCEe8nMOpVWy5mwQCqNjCUTF2j0ZTSGJJxledJVHHTpYCj99PVy/Wcaz6Eer6AYqOOoFgkCf6AcB7tnygD8GesGdmBA8B5Cn3jLBFq9W769bOxYriEL7/vXLIxKaGmgZdTMYBFlQEUASCNlQigFIEQdewI9XR6Wy1ifRLhuDK1WKPWf0WtdgC6FLCqAXQZc/+nP42xL3wTy8+uY8XrTgR++RNY8boTsfzsOsa+8E3s//Sn3a+tL6wCPrNtWr16tN/bu1JdS8q1hqwy9tXDAlEzaMpCIDG3qrUm6aElYgNDaVujsHIiACRjALXrc33fDtx0I/L1GoJiEc1q1WuuqtAPEr5V64zswCngeYosGcDXnboKrzt1Fdl4VBDVacsWnY7l44/h6sJXMFT+CwDHthanesO5Ok21gSnLnqp0DGCYAqZh6kJ7ihY7QVlJGNenlDJQqxB7tcXdS99xxVwb/KVflf59Byb/fwBOsJtr9UYrdfabvxHxxVzx3grw2ZtbuUVHDCqt4MSh5bpL3YtKBFR2ulJryCpjilZdxUIOKLeZOkLWWjKLaoU5hb40xgaGklkElH7uVBpAAgZw/6c/HdH8ic8BkGkABZgBnL/gAHCeooMBJNQAzlu0q9Mufc1bERzzC5yffwwHd/8z9j/4uFysXCEWpelKXemp6n9P+6Q+rbWJUmn1VF1PTfESo+7YEW56BPei0Jmmo6yoVH+Pd/FSe64tPjiDS/M/wvn5x/CLfd/F/k/vspprsUFi2xfTfyNtbez1RhMHJlvptNEB/800lwtQzLd0oOVaXabW/dpCthD6V4ZzgNoHsEEYqIkiJbUgilIDCEC6DlDch9Y4GgNoGbjrwR8QBn0UQaB+sKaYs4xswAHgPIW+6VGwVfMdK975y8DE8zjvC9/C4GktT7Xard9p2Wp4eqqJNMSRmYpMyVCkEUU6TVRSVokqKiOeamqFImXaq65WAXsPG27StQZpVwX9XlIUgIi5NvaFv8Mvtefa6L/dibGH/8N7rlFBZeT2tfVUI0SbaamQR7VeazOAjY7f5wo1XU+pW+2Tkgja1HJWGkBRbd9shkbeVLpVlQHsK+TsswKCtdaCPPm5p0Zcn0ecAp6/4ABwnmJBMoCfPB0rAOC0RRh7dASPP7YazUageKp9Crj2iNPQYhGq1ps42PZTc2n9paOk91Vt0FT8qZtmazMlNKmNadlGUVEZ16+VpKtCh/EtQSotw7lGBVGlLoJpgI5N6Wunasu1BmbbAQoFAyirdesZ2cDUW5XLQAYFUYTPAhBW209X6A6cQHT+u+j/ukkbKKuABTgFPH+xAKKK3kSHD+A8M2zOBBl7qok08J62P1U/RQpYqwKm6tihpotqip6KIvjJq5YahKyHukk3CBlA/dpINtIM5xoVgiDo2EyHPTvXCKi2SNNVuhSwOgeo2HAAKBZiDhcUfaYVw3VKDWBrHCE7ad1fqgBQvT7b9O9cQJ9HbAMzf7EAoorehM4A9hMWgcxbnHEZ8L67sf/RRR2eanjf3a3ve2BpeyESDcpJGEC9CpiIqVMNm+vEFZVxVcAkRSBKMEzbCk5nAAmWrYznGhVU6Ud/MUdWDCaLl+p1zFToUsAFJVVLWbgk5qzaCYSkcl2Zs5SV64BqX0TLAKr3c9CzIjwLqO0VcwEwPA+vkdECB4DzFLrOaUEwgMjOUw0IT6LPH2m1KCIpAtGqgCs1sdjTWUlUlUCNIvgRG1yFejPNR9lQ9Xf5IJ8LoA5DZQKd5VyjgprioxTTqwyg0MRS2MD0KeyyKFyi8L8LC4xU3SqFbCE8wNUJ+2IDIdMuqqxLRPPWNwWcNfQ5S1FUw8gGHJrPU+gPNqUNzHxFxFPttScCZ12BFWu+BJSew9gXvgkMr/LSqAgtyt7xlqCe0gZGBD2iGITKZLpSb6BcrWcSqLXMegltYNr3QojeAVrrCxFkUzApWc81KqhB30g/XQCozltZBUzIAFZqTSUFTFcIVK03ELR5C5LiEnEfiA9D6jhTZWIGUAl8Kd4zaqgp4GOG+4/ilTDSwAHgPIWuo9C9lV6QyNBTDQiD6iMzVQBURtBhMNVsNolNpnOYLIcpJIDWrqVCXK0r2J9Ixw5C64uK+JiCScl4rlFBDQBpGcDWszBRrsn2ev2URSCNBmkKWLWBEdo/EoPpgnoYok4BZ6QBVAJfvXf6fIBKXqwc5QBwPmP+zR4GgE7NH1Xaaz4jS081IGz7tX1sCgCwdMhfnBxqqRrtCsXW1ykYQMFQTpbDgIqS9YiY6pK0ggu9FsOvUZrfhj2cfZH1XKPCqFJBSWUBA4QHlLG2vQwADPX5bweRlm2URSBKJ5BCjs4IOmTD66Sm6Oo4UgNIlgIOx5mPHntqALh6hAPA+YwXflTRo8jlggjrN0yY/lmoGNBY1A3HLSYYM1zsxmfCQI3EY7A9xuQsbQBYimUA6TbpKSVgpdpM1SCCiknpBWTFAIpNeu9EqyBquFQg7dtcrTdlW0TqFDBln+nYwxAVA5iRk4P6rFIeCqgwUAwPEquYAZzX6ImV9J577sEll1yCNWvWIAgC3HbbbZHv33rrrXjd616HZcuWIQgCbNu2zWjcb37zmzjllFPQ39+P008/Hd/97nfpL94DanBBwVYtdOh6mVNWD5OOeXi6Ij+mMZlujT1FnFKNaAAp+7VqGsBiPvDv2NGGmqLuWwB6WIGoBpAuYSPY5b3tiniqQEJlAKs1OiNo1V5GZOcpDi3qYYjSEgnofKZ8GcD9f3s99n/60yjmczg9eBpfKX4UL6k90frepz/dam84D6AygCev8l9jGdmhJwLAqakpbNiwATfccEPi91/1qlfhYx/7mPGY9957Ly6//HL8xm/8Bh5++GG8+c1vxpvf/GY8+uijVJftDTWNuITNNL2ha5wWE7XVEgueMJgWBr6+kAxgm1ELApo2VYKJENWJAG06bbpK2/kAiAYR89H7jBpis188UJSb/anB063vEWz2kgFsF0RR+QsWFRuYLFrBtbrXtBlAYjac0hQd6Py7vQ+F7faFo9/8Ei7N/wDn5x/DhoN3hH1854lMaIlCVrzmpBVH8UoYaegJDeDmzZuxefPmxO+/613vAgDs2LHDeMy/+Zu/wetf/3p86EMfAgD8+Z//Oe68805cf/31uOmmm7yulwoi1QGwmSYFBovR6b6IaNMb7CtgulLHoelWcQmV1kdIAERKlaqgQlxfJACk1AC2qx6pmBR1bIDGsHjeo73Zv/Rt4+jLP4Tz84/hiYN3YP+nn/Huiw2EXm17x6kZwDBVm0UrONUImtIHsBLxAfQeFkBoXq3/LleE7Qtvlu0Ll911F8a2fX/etC8EWqz1N3/rPAwU8/OySIURYsG+O/fddx+2bNkS+drFF1/ckV5WUS6XUS6Hounx8fGsLg8AMFsNA8CFpHvKCgN9ahqRzlRXsCkiBUxhMA2EDPCkCKiICir0VC1ApQEM/QXV30MB9foWUl9sfOGLWN/e7IfvuBNj22h6FYt7KLriUOkL4zuBEDCAhU7vSopOIPEaQHq7FoDAGaAH2hcKvOL4pUf7EhgGWLBRxZ49e7By5crI11auXIk9e/Yk/sx1112H0dFR+W/t2rWZXqNa/cnwh6rXo9RTyRRwOwDMigGkEqeLTU+t1qX0ARSgsJaRY6kM4AIIAPHJ07Fi5lNYfto4ph8t4fFvrMahbQVlsz/da3gxZ8UcoPIYjLNVoagCzqwTiGQWmzLjQsVc6+uAMJ12Rg+0L2T0FhZsAOiCq6++GkeOHJH/du/efbQviWEAoafqL+alnurs4o7W9wj0VEPtNMfhdgqYqtpPMIAyBUwUWIqNiNxfULs+KsYSiAYRKpP7gkXGm70eRI8M0ByI1ACwSugxWVQCNZmqJXgeVJZaMOJklevEKeBeaV/I6B0sgJU0HqtWrcLevXsjX9u7dy9WrVqV+DOlUgkjIyORf1niQxefjFIhh2/8j/My/T0veLT1VGtu/6oUT7+xeQ+ZeFovAqEwgQZCBlAwwWTMhEwBhwwzxdD6BkfpXan+7QuCAcx4s9d1lFkwgKIKWGeG3cZtG0xnpAEEwgMRnXURcREIeqN9IaN3sGA1gOeddx7uvvtu/P7v/7782p133onzzps/wdb/vPBEvP/VL2b9nydCPdUXpHj6rAfvxdgjW0n0VLoGkOr90hlA6gBQbHiFHI1di77hUTKAagp4IWgAgehmv+K0Cex/dBhjj44Af38rVlx1ptfYnQwgTQBYUjSAlL2AQ22hwgASVq4D4fNAxbRTawB7pX0ho3fQEwHg5OQknnzySfn59u3bsW3bNixduhTr1q3DwYMHsWvXLjz33HMAgJ///OcAWiyfYPSuuOIKHHvssbjuuusAAL/3e7+H1772tfh//+//4Y1vfCO+9rWvYevWrfjsZz87x39dd3DwR4CMxdOig0LIANIEKB0MINHGJDYiUQWchVlz63O6uRtNAb/wA8CsN3u91ziVJlYGaooGkLoVHKV3ZRAE6Mu3em5PSqkF1UGLOAXcI+0LGb2DnggAt27digsvvFB+Lqp33/3ud+OWW27B7bffjiuvvFJ+/x3veAcA4CMf+QiuvfZaAMCuXbuQU05k559/Pr7yla/gj//4j/HhD38YL3nJS3DbbbfhtNNOm4O/iDGnuPRzwG2/jRWnTeLAY8Odeqo33+g1vKj6HW937KBKAWdWBay1bCMrLulgACkDwAVWBJLxZj+k2XNQMYB6a0SAqhVcaC/TEClgwqp4NQDMomVbEPgz+L3SvpDRO+iJAPCCCy5AUzRZjcF73vMevOc97+k6xve+972Or73tbW/D2972Ns+rY8x7nHEZsPwk7P/gGzv0VCs+9S/AmjO9hhcB38Rs2weQXAPYGpfMB7Cg+QtSFZdofzdF6k9A1agthAAw681et33JtgqYkAGs0baCA9rXXA6fB6rnV/27+/I5sq44DAYVOL/IWBDIUjwtNGmiFzA1AzgxS7sxyQCwQhsA6uNQjCsquJcO9ckK7hUTj7W+N4/aX/UaOgLADKqApa0KaSu4JqkNDNDJiNM9DwuzfzWjd9ATDCCD4YOs9VS6po6qV61kAGeJtUl5wQC2r5do3EyKQNoV3Ge/8QDWDzyC8/OP4cBz38H+T/+cpCPGQoWe8iVjAJUikEqN0AhatIJrhBpACiNoIIa5zuBARHUoZDAowQEg44WPjPVUuu8fNQMoe6oSp2pFYEml1dMDVAotVVjB/RWc0a7grt/6HRx4qDCv2l/1GvSiD3INYC3UAFLMgz4lBVzPQAMY/Zz+QERpicRgUIEDQMYLHlnrqfSqX7IAsKhvTLQBIKVIH4hWVAJEG3QPtb/qJehB/zBRz9aSGgC2GUCK56Egi0CapK3ggAw6drQRCQCZAWTMQ/CsZDA80Z9RoKYHllQsQlYpr9ZY4aZMwixy+ytyCF0lAKmrzD3/cOt7nrrKPkUO0Y7TSJ6HYkxqObPngYwBDMehsoZiMCjBASCD4YlOBpBWAyhAFaiVMijWkGMViNNe3P6KHm1d5eWP3yk74+CnXyfpjFOU+tKwywxFABjXsYOaERfIQgPIDCBjPoJTwAyGJ/QUF10ruGggSdFSC4jb8Ch79uaUj2nGzbIjxkKE0FVe8YVvYbDQ0lXu//t/xNhDeW9dpQj6ReW6+jUfqNY/4zNtWyRiY3SBLHwAOQBkzEdwAMhgeEIP1OhSwNlsTFmmgNVrpPDr4/ZXGSBDXaWYWxNtBjAX0EgB+go5FHIBao2mHJusKCqDnr2AZgPDRSCMeQgOABkMT8wVA0hVnZhpAKiMPdBHsLxw+yt6ZNgZR8gfpE6PkPka6MtHmUVOATMYXuAAkMHwRFYBoD5OVowHbQpY6dlLwABy+6sMkGFnnCVDUTsZSuZrUA8AM2PEM7CB4QCQMQ/Bs5LB8ESpmFURSDZVwPr1UjKA6jUP9nHl43xFVp1xlg2VIp/rc80HgxqjTFWt23kgonke1PnPASBjPoJnJYPhCZ3p0v37XNHBAFKlvPQNj3BzUje9AQ4A5yUiusrXnQj88iew4nUnYvnZdYx94ZvSIsYFfYVcpM0cJQOY1YGowwjac1xhs7N8UUna7JxQ+UXre9y+kDGPwClgBsMTaxb3Rz6n2pg6qoCzSnkR9VQFoiwNRQqYkQEy1lUuW9SHI+1KXcoWaDqjnEVVfCEXIOf7PLRtdpZPVnBp/t6Wzc7kndj/6YPcvpAxr8ABIIPhieH+IlaP9uP5I7MA6BjADmZxnmsLgSjrxyng+YmsdZXLF5Xw9P4pALSpT30+ZcEAUjwLwmZn7POfwS+12xce/4PvY+wn93L7Qsa8AgeADIYH9v/t9UA+hxOPORvLxx/D1YWvYGj8LwCsbKXS6o34DdcAuVyA/mIOs1Xalm2ZpoCLnAJe6BjKSPumH4jofACJr5fbFzJ6BKwBZDB80E73vOHh78quCi969jskXRWAaEqVasPL5QIUlDQXbQpYCQA5BbwgEQmoiKuABfK5AHmieauOO0RxaOH2hYweATOADIYHRLrnzC98A4PtdE/5m/+MsYcKJOkeNYiiZFP6CjnU2i21KAJLwYQOvviXcHrwNK4ufAXLjnwMwGu8mVBGb0GVQND6AKqHIbpDyxB14VKGNjsMBiWYAWQwfPDJ07Fi5lNYfto4ph8t4fFvrG4FfzLdc7rX8BErCUqtnhJYkqSA20zoy+78pmRCj9l+GxkTyugd9CsMYFZFIJTPwlApDCx1qxlXZGWzw2BQghlABsMHGXZVAIBBZXNaVKJ7XAf68kBLp0+SAhZMKL7wFZwhmNBv0TGhjN6BygCqljC+yMpXTw0AKRhAbl/I6BVwAMhg+CDjdI9aVLGon+5xHVKYDhKzXha+M9pQWb/Fg31k46rBGWXluvoskFSuc/tCRo+AA0AGwxNqumfFaRPY/+gwxh4dAf7+Vqy46kyvsdUNiZIBHCwR27VkzIQyegeqf+XiQUIGMCM97BDxs8DtCxm9AhbmMBgeyLKrAhBlPYYJGcBBar++My4D3nc39j+6qIMJxfvubn2fsSCgMoBL5jEDKDp2DJUKsmPHSfUnW9/jjh2MBQBmABkMH2SU7hFVtUPHvEpW1S4+9HHgmPNIqmojHTsyEL5TM6GM3kFWDKA6T/spzNbbhUul2Rouzf8Q5+cfQzBxJ/Z/+gB37GAsCHAAyGB4ILN0T3tzeuXmMZwy9CjOzz+Gyi9uxf67HybZnFTri0ECDSAL3xkCWWkA1Xk6RHBokR07Pnuj7Nix7vvfw9hP/5MLlxgLAhwAMhjzEGJzOuULX5X+gke++k8YeyhP4y/YR1v5yMJ3hmCtS6+4RLLWa2b/CsAKItZaCQAp9LBcuMRY4OAAkMGYj8hoc5Kp5XUXyE166fhfAnit1ybNwneGYK2XX3oEl+Yfxvn5x1DeeTv2//AREtaavM80Fy4xFjg4AGQw5iOy2pzam/TpbzyAYwcewfn5x3Dw6duw//6fse6J4YXQC/JLOKHNWo8TstYq60eRAuaOHYyFDg4AGYz5iIw2J9WwWaSWa9/+Dg48zIbNDE9kzFovveI3JGv9SHULgDO8U8tcuMRYyGAbGAZjniKTdlIxresOPEzXuo6xgHHp54BcAStOm5QHlghrfenn3MZts9aNL94s2wyeOvav3m0Gs7ZwYjDmO5gBZDDmITKrqmXdEyMrZMxaj/3t38pq3eN/8H2M/fQ+P9aaC5cYCxxBs9lsHu2L6FWMj49jdHQUR44cwcjIyNG+HMYLCCLtFdmcmk2gXsH+9ubkXFH53Dbs/+AbMfboiNykl582zronhjf2f+ya1sElklIdxvIr34YVV/2Z26DXjrbGfnRR55w9bbL9Gq7WZdiB929mABmMeYksq2pZ98TIAsxaMxi9BQ4AGYwFBDZsZmSGrFKqXK3LYGQCDgAZjIUE1j0xMgKz1gxGb4EDQAZjAYENmxm9BmatGYxswAEgg8FgMOYvmLVmMDIBVwF7gKuIGAwGg8HoPfD+zUbQDAaDwWAwGAsOPREA3nPPPbjkkkuwZs0aBEGA2267LfL9ZrOJa665BqtXr8bAwAA2bdqEJ554ouuY1157LYIgiPw75ZRTMvwrGAwGg8FgMOYHeiIAnJqawoYNG3DDDTfEfv+v/uqv8KlPfQo33XQTfvSjH2FoaAgXX3wxZmdnu4576qmn4vnnn5f/fvjDH2Zx+QwGg8FgMBjzCj1RBLJ582Zs3rw59nvNZhOf/OQn8cd//Md405veBAD40pe+hJUrV+K2227DO97xjsRxC4UCVq1alck1MxgMBoPBYMxX9AQD2A3bt2/Hnj17sGnTJvm10dFRnHvuubjvvvu6/uwTTzyBNWvW4MUvfjF+7dd+Dbt27er6+nK5jPHx8cg/BoPBYDAYjF5DzweAe/bsAQCsXLky8vWVK1fK78Xh3HPPxS233II77rgDN954I7Zv345Xv/rVmJiYSPyZ6667DqOjo/Lf2rVraf4IBoPBYDAYjDlEzweArti8eTPe9ra34YwzzsDFF1+M7373uzh8+DC+8Y1vJP7M1VdfjSNHjsh/u3fvnsMrZjAYDAaDwaBBzweAQsO3d+/eyNf37t1rpe9bvHgxTjrpJDz55JOJrymVShgZGYn8YzAYDAaDweg19HwA+KIXvQirVq3C3XffLb82Pj6OH/3oRzjvvPOMx5mcnMRTTz2F1atXZ3GZDAaDwWAwGPMGPREATk5OYtu2bdi2bRuAVuHHtm3bsGvXLgRBgN///d/HRz/6Udx+++145JFHcMUVV2DNmjV485vfLMe46KKLcP3118vP/+AP/gDf//73sWPHDtx77714y1vegnw+j8svv3yO/zoGg8FgMBiMuUVP2MBs3boVF154ofx8y5YtAIB3v/vduOWWW/CHf/iHmJqawm/+5m/i8OHDeNWrXoU77rgD/f398meeeuopjI2Nyc+feeYZXH755Thw4ABWrFiBV73qVbj//vuxYsUK4+sSXfS4GpjBYDAYjN6B2LcXcjdc7gXsgWeeeYYrgRkMBoPB6FHs3r0bxx133NG+jKMCDgA90Gg08Nxzz2F4eBhBEJCOPT4+jrVr12L37t1cbJIh+D7PDfg+zw34Ps8d+F7PDbK6z81mExMTE1izZg1yuZ5Qw5GjJ1LA8xW5XC7zkwNXG88N+D7PDfg+zw34Ps8d+F7PDbK4z6Ojo6Tj9RoWZtjLYDAYDAaDsYDBASCDwWAwGAzGAgMHgPMUpVIJH/nIR1AqlY72pbygwfd5bsD3eW7A93nuwPd6bsD3OTtwEQiDwWAwGAzGAgMzgAwGg8FgMBgLDBwAMhgMBoPBYCwwcADI+P+3d/8xUdd/HMCfwHnHMYJDiDsxT6mcVFAjSTq1+sNbpCz7tbbc5ejHahYuqGZazv5pBKutrVrZjy37I5PpppZObQxMY0N+BehpoU2L5jxY0QlOS+Ce/VF+8pPWd187uDs/z8d2m37er93e7yfbh+d23kcRERGxGBVAEREREYtRAYxD77zzDmbMmIHU1FSUlpaira0t1ltKKLW1tbjllltwxRVXIDc3F/feey96e3tNM7/++isqKyuRnZ2N9PR0PPDAA+jv7zfN9PX1oby8HGlpacjNzcWKFSswOjo6kUdJKHV1dUhKSkJ1dbVxTTlHx/Hjx/Hwww8jOzsbTqcTRUVF6OjoMNZJ4uWXX8aUKVPgdDrh9/tx5MgR03sMDg4iEAggIyMDLpcLjz/+OE6dOjXRR4lbY2NjWLNmDfLz8+F0OnHNNdfglVdeMf1fscr50uzduxd333038vLykJSUhK1bt5rWo5Xr/v37cdtttyE1NRXTpk3Da6+9Nt5HS2yUuFJfX0+73c6PPvqIBw8e5BNPPEGXy8X+/v5Yby1hlJWVcd26dQwGg+zu7uaiRYvo9Xp56tQpY2bZsmWcNm0aGxsb2dHRwVtvvZVz58411kdHR1lYWEi/38+uri7u2LGDOTk5fPHFF2NxpLjX1tbGGTNm8MYbb2RVVZVxXTn/d4ODg5w+fTofeeQRtra28ujRo/ziiy/43XffGTN1dXXMzMzk1q1b2dPTw8WLFzM/P59nzpwxZu666y7edNNN3LdvH7/66itee+21XLJkSSyOFJdqamqYnZ3N7du389ixY9y0aRPT09P55ptvGjPK+dLs2LGDq1ev5ubNmwmAW7ZsMa1HI9eTJ0/S7XYzEAgwGAxyw4YNdDqdfP/99yfqmAlHBTDOzJkzh5WVlcbfx8bGmJeXx9ra2hjuKrENDAwQAPfs2UOSDIfDnDRpEjdt2mTMfPPNNwTAlpYWkn/csJKTkxkKhYyZtWvXMiMjg7/99tvEHiDODQ8Pc+bMmWxoaOAdd9xhFEDlHB0rV67k/Pnz/3E9EonQ4/Hw9ddfN66Fw2E6HA5u2LCBJHno0CECYHt7uzGzc+dOJiUl8fjx4+O3+QRSXl7Oxx57zHTt/vvvZyAQIKmco+XvBTBaub777rvMysoy3TdWrlzJWbNmjfOJEpc+Ao4jZ8+eRWdnJ/x+v3EtOTkZfr8fLS0tMdxZYjt58iQAYPLkyQCAzs5OjIyMmHIuKCiA1+s1cm5paUFRURHcbrcxU1ZWhqGhIRw8eHACdx//KisrUV5ebsoTUM7R8vnnn6OkpAQPPvggcnNzUVxcjA8//NBYP3bsGEKhkCnnzMxMlJaWmnJ2uVwoKSkxZvx+P5KTk9Ha2jpxh4ljc+fORWNjIw4fPgwA6OnpQXNzMxYuXAhAOY+XaOXa0tKC22+/HXa73ZgpKytDb28vfvnllwk6TWKxxXoD8peffvoJY2Njpl+GAOB2u/Htt9/GaFeJLRKJoLq6GvPmzUNhYSEAIBQKwW63w+VymWbdbjdCoZAxc7Gfw7k1+UN9fT2+/vprtLe3X7CmnKPj6NGjWLt2LZ577jm89NJLaG9vxzPPPAO73Y6Kigojp4vleH7Oubm5pnWbzYbJkycr5z+tWrUKQ0NDKCgoQEpKCsbGxlBTU4NAIAAAynmcRCvXUCiE/Pz8C97j3FpWVta47D+RqQDKZa2yshLBYBDNzc2x3spl58cff0RVVRUaGhqQmpoa6+1ctiKRCEpKSvDqq68CAIqLixEMBvHee++hoqIixru7fGzcuBHr16/Hp59+ihtuuAHd3d2orq5GXl6ecpbLkj4CjiM5OTlISUm54FuS/f398Hg8MdpV4lq+fDm2b9+O3bt346qrrjKuezwenD17FuFw2DR/fs4ej+eiP4dza/LHR7wDAwO4+eabYbPZYLPZsGfPHrz11luw2Wxwu93KOQqmTJmC66+/3nTtuuuuQ19fH4C/cvq3+4bH48HAwIBpfXR0FIODg8r5TytWrMCqVavw0EMPoaioCEuXLsWzzz6L2tpaAMp5vEQrV91L/n8qgHHEbrdj9uzZaGxsNK5FIhE0NjbC5/PFcGeJhSSWL1+OLVu2oKmp6YKPBWbPno1JkyaZcu7t7UVfX5+Rs8/nw4EDB0w3nYaGBmRkZFzwy9iqFixYgAMHDqC7u9t4lZSUIBAIGH9Wzv/dvHnzLniM0eHDhzF9+nQAQH5+PjwejynnoaEhtLa2mnIOh8Po7Ow0ZpqamhCJRFBaWjoBp4h/p0+fRnKy+VdiSkoKIpEIAOU8XqKVq8/nw969ezEyMmLMNDQ0YNasWfr495/E+lsoYlZfX0+Hw8GPP/6Yhw4d4pNPPkmXy2X6lqT8u6eeeoqZmZn88ssveeLECeN1+vRpY2bZsmX0er1sampiR0cHfT4ffT6fsX7u8SR33nknu7u7uWvXLl555ZV6PMn/cP63gEnlHA1tbW202WysqanhkSNHuH79eqalpfGTTz4xZurq6uhyufjZZ59x//79vOeeey76GI3i4mK2trayubmZM2fOtPzjSc5XUVHBqVOnGo+B2bx5M3NycvjCCy8YM8r50gwPD7Orq4tdXV0EwDfeeINdXV384YcfSEYn13A4TLfbzaVLlzIYDLK+vp5paWl6DMy/UAGMQ2+//Ta9Xi/tdjvnzJnDffv2xXpLCQXARV/r1q0zZs6cOcOnn36aWVlZTEtL43333ccTJ06Y3uf777/nwoUL6XQ6mZOTw+eff54jIyMTfJrE8vcCqJyjY9u2bSwsLKTD4WBBQQE/+OAD03okEuGaNWvodrvpcDi4YMEC9vb2mmZ+/vlnLlmyhOnp6czIyOCjjz7K4eHhiTxGXBsaGmJVVRW9Xi9TU1N59dVXc/Xq1abHiijnS7N79+6L3pMrKipIRi/Xnp4ezp8/nw6Hg1OnTmVdXd1EHTEhJZHnPeZcRERERC57+jeAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhajAigiIiJiMSqAIiIiIhbzO7l67DAkr45HAAAAAElFTkSuQmCC' width=640.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pixel_row = 8\n",
+    "pixel_col = 8\n",
+    "pixel_data = ssequence.eit_data[\"raw\"].pixel_impedance\n",
+    "\n",
+    "pixel_breaths = np.stack(breath_container.values)\n",
+    "\n",
+    "start_indices = [\n",
+    "    np.argmax(ssequence.eit_data[\"raw\"].time == start_time)\n",
+    "    for pixel_breath in pixel_breaths[:, pixel_row, pixel_col]\n",
+    "    if pixel_breath is not None\n",
+    "    for start_time in [pixel_breath.start_time]\n",
+    "]\n",
+    "\n",
+    "middle_indices = [\n",
+    "    np.argmax(ssequence.eit_data[\"raw\"].time == middle_time)\n",
+    "    for pixel_breath in pixel_breaths[:, pixel_row, pixel_col]\n",
+    "    if pixel_breath is not None\n",
+    "    for middle_time in [pixel_breath.middle_time]\n",
+    "]\n",
+    "\n",
+    "end_indices = [\n",
+    "    np.argmax(ssequence.eit_data[\"raw\"].time == end_time)\n",
+    "    for pixel_breath in pixel_breaths[:, pixel_row, pixel_col]\n",
+    "    if pixel_breath is not None\n",
+    "    for end_time in [pixel_breath.end_time]\n",
+    "]\n",
+    "\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(pixel_data[:, pixel_row, pixel_col])\n",
+    "plt.plot(start_indices, pixel_data[start_indices, pixel_row, pixel_col], \"*\")\n",
+    "plt.plot(middle_indices, pixel_data[middle_indices, pixel_row, pixel_col], \"o\")\n",
+    "plt.plot(end_indices, pixel_data[end_indices, pixel_row, pixel_col], \"x\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ALIVE",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tests/test_parameter_tiv.py b/tests/test_parameter_tiv.py
new file mode 100644
index 000000000..ee811d968
--- /dev/null
+++ b/tests/test_parameter_tiv.py
@@ -0,0 +1,549 @@
+import copy
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+import numpy as np
+import pytest
+
+from eitprocessing.datahandling.continuousdata import ContinuousData
+from eitprocessing.datahandling.datacollection import DataCollection
+from eitprocessing.datahandling.eitdata import EITData, Vendor
+from eitprocessing.datahandling.intervaldata import IntervalData
+from eitprocessing.datahandling.sequence import Sequence
+from eitprocessing.datahandling.sparsedata import SparseData
+from eitprocessing.parameters.tidal_impedance_variation import TIV
+
+environment = Path(
+    os.environ.get(
+        "EIT_PROCESSING_TEST_DATA",
+        Path(__file__).parent.parent.resolve(),
+    ),
+)
+data_directory = environment / "tests" / "test_data"
+draeger_file1 = data_directory / "Draeger_Test3.bin"
+timpel_file = data_directory / "Timpel_Test.txt"
+
+
+def create_result_array(value: float):
+    nan_row = [[np.nan] * 2] * 2
+    value_row = [[value] * 2] * 2
+    return np.array([nan_row, value_row, nan_row])
+
+
+def mock_pixel_impedance():
+    """Mock pixel_impedance.
+
+    Each pixel is an identical sine wave with a baseline drop to create difference between
+    inspiratory and expiratory limb for one of the breaths.
+    """
+    duration = 10
+    fs = 1000
+    frequency = 0.25
+    amplitude = 1.0
+    baseline_drop = -0.5
+    # Calculate the period of the sine wave
+    period = 1 / frequency
+
+    # Create time vector with extra breaths
+    extra_breaths_duration = 2 * period  # One period for the extra breath at start and end
+    total_duration = duration + extra_breaths_duration
+    t = np.linspace(0, total_duration, int(total_duration * fs), endpoint=False)
+
+    # Generate the sine wave
+    signal = amplitude * np.sin(2 * np.pi * frequency * t)
+
+    # Apply baseline drop halfway through the original duration
+    halfway_index = len(signal) // 2
+    signal[halfway_index:] += baseline_drop  # Shift the baseline down for the second half
+
+    # Store the waves in a (time, 2, 2) array
+    pixel_impedance = np.empty((len(t), 2, 2))
+    pixel_impedance[:, 0, 0] = signal
+    pixel_impedance[:, 0, 1] = signal
+    pixel_impedance[:, 1, 0] = signal
+    pixel_impedance[:, 1, 1] = signal
+
+    return pixel_impedance
+
+
+def mock_global_impedance():
+    pixel_impedance = mock_pixel_impedance()
+    return np.nansum(
+        pixel_impedance,
+        axis=(1, 2),
+    )
+
+
+@pytest.fixture()
+def mock_continuous_data():
+    """Fixture to provide an instance of ContinuousData."""
+    return ContinuousData(
+        label="global_impedance",
+        name="global_impedance",
+        unit="au",
+        category="relative impedance",
+        description="Global impedance created for testing TIV parameter",
+        parameters={},
+        derived_from="mock_eit_data",
+        time=np.linspace(0, 18, int(18 * 1000), endpoint=False),
+        values=mock_global_impedance(),
+        sample_frequency=1000,
+    )
+
+
+@pytest.fixture()
+def mock_eit_data():
+    """Fixture to provide an instance of EITData."""
+    return EITData(
+        path="",
+        nframes=2000,
+        time=np.linspace(0, 18, int(18 * 1000), endpoint=False),
+        sample_frequency=1000,
+        vendor=Vendor.DRAEGER,
+        label="mock_eit_data",
+        name="mock_eit_data",
+        pixel_impedance=mock_pixel_impedance(),
+    )
+
+
+@pytest.fixture()
+def mock_sequence(mock_eit_data: EITData, mock_continuous_data: ContinuousData):
+    """Fixture to provide an instance of Sequence."""
+    data_collection_eit = DataCollection(EITData)
+    data_collection_eit.add(mock_eit_data)
+
+    data_collection_continuous = DataCollection(ContinuousData)
+    data_collection_continuous.add(mock_continuous_data)
+
+    data_collection_sparse = DataCollection(SparseData)
+    data_collection_interval = DataCollection(IntervalData)
+
+    return Sequence(
+        label="mock_sequence",
+        name="mock_sequence",
+        description="Sequence created for parameter TIV testing",
+        eit_data=data_collection_eit,
+        continuous_data=data_collection_continuous,
+        sparse_data=data_collection_sparse,
+        interval_data=data_collection_interval,
+    )
+
+
+@pytest.fixture()
+def not_a_sequence():
+    return []
+
+
+@pytest.fixture()
+def none_sequence():
+    return None
+
+
+def test_tiv_initialization():
+    """Test that TIV initializes correctly with default parameters."""
+    tiv = TIV()
+    assert tiv.method == "extremes"
+    assert tiv.breath_detection_kwargs == {}
+
+
+def test_compute_parameter_type_error():
+    """Test that compute_parameter raises TypeError for unsupported data types."""
+    tiv = TIV()
+
+    with pytest.raises(TypeError, match="This method is implemented for ContinuousData or EITData"):
+        # Pass an unsupported type to trigger TypeError
+        tiv.compute_parameter("unsupported_type")
+
+
+def test_tiv_initialization_with_invalid_method():
+    """Test that TIV raises NotImplementedError for unsupported methods during initialization."""
+    with pytest.raises(
+        NotImplementedError,
+        match="Method unsupported_method is not implemented. The method must be 'extremes'.",
+    ):
+        TIV(method="unsupported_method")
+
+
+def test_tiv_initialization_with_valid_method():
+    """Test that TIV initializes successfully with a valid method."""
+    tiv = TIV(method="extremes")  # This should not raise an error
+    assert tiv.method == "extremes"
+
+
+@pytest.mark.parametrize(
+    ("store_input", "sequence_fixture", "expected_exception"),
+    [
+        (True, "not_a_sequence", ValueError),  # Expect ValueError because a string is not a valid Sequence
+        (True, "none_sequence", RuntimeError),  # Expect RuntimeError because sequence is None and store=True
+    ],
+)
+def test_store_result_with_errors(
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    request: pytest.FixtureRequest,
+    store_input: bool,
+    sequence_fixture: str,
+    expected_exception: ValueError | RuntimeError,
+):
+    """Test storing results when errors are expected."""
+    tiv = TIV()  # Ensure that breaths are detected
+
+    # Retrieve the sequence from the fixture
+    test_sequence = request.getfixturevalue(sequence_fixture)
+
+    # Expect a specific exception (either ValueError or RuntimeError)
+    with pytest.raises(expected_exception):
+        tiv.compute_continuous_parameter(
+            mock_continuous_data,
+            tiv_method="inspiratory",
+            sequence=test_sequence,
+            store=store_input,
+        )
+    with pytest.raises(expected_exception):
+        tiv.compute_pixel_parameter(
+            eit_data=mock_eit_data,
+            continuous_data=mock_continuous_data,
+            sequence=test_sequence,
+            tiv_method="inspiratory",
+            tiv_timing="pixel",
+            store=store_input,
+            result_label="pixel_tivs",
+        )
+
+
+@pytest.mark.parametrize(
+    ("store_input", "sequence_fixture"),
+    [
+        (True, "mock_sequence"),  # Result should be stored
+        (False, "mock_sequence"),  # No result should be stored
+        (False, "none_sequence"),  # No result should be stored, no sequence provided
+        (None, "mock_sequence"),  # Result should be stored
+        (None, "none_sequence"),  # No result stored, no sequence provided
+    ],
+)
+def test_store_result_success(
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    request: pytest.FixtureRequest,
+    store_input: bool,
+    sequence_fixture: str,
+):
+    """Test storing results when no errors are expected."""
+    tiv = TIV()  # Ensure that breaths are detected
+
+    # Retrieve the sequence from the fixture
+    test_sequence = request.getfixturevalue(sequence_fixture)
+
+    # Run continuous and pixel tiv computation and check the result
+    continuous_result = tiv.compute_continuous_parameter(
+        mock_continuous_data,
+        tiv_method="inspiratory",
+        sequence=test_sequence,
+        store=store_input,
+        result_label="continuous_tivs",
+    )
+
+    pixel_result = tiv.compute_pixel_parameter(
+        eit_data=mock_eit_data,
+        continuous_data=mock_continuous_data,
+        sequence=test_sequence,
+        tiv_method="inspiratory",
+        tiv_timing="pixel",
+        store=store_input,
+        result_label="pixel_tivs",
+    )
+
+    # Check that the results are stored correctly based on store_input
+    if store_input in [True, None] and test_sequence is not None:
+        assert len(test_sequence.sparse_data.data) == 2
+        assert test_sequence.sparse_data["continuous_tivs"] == continuous_result
+        assert test_sequence.sparse_data["pixel_tivs"] == pixel_result
+    elif test_sequence is not None:
+        assert len(test_sequence.sparse_data.data) == 0
+
+
+@pytest.mark.parametrize(
+    ("tiv_method", "expected_error"),
+    [
+        ("invalid_method", ValueError),
+        (5, ValueError),
+    ],
+)
+def test_compute_continuous_parameter_tiv_method_errors(
+    mock_continuous_data: ContinuousData,
+    tiv_method: str,
+    expected_error: ValueError,
+):
+    """Test compute_continuous_parameter with invalid tiv_method inputs that raise errors."""
+    tiv = TIV()
+    with pytest.raises(expected_error):
+        tiv.compute_continuous_parameter(mock_continuous_data, tiv_method=tiv_method)
+
+
+@pytest.mark.parametrize(
+    ("tiv_method", "expected_result"),
+    [
+        ("inspiratory", np.array([8, 8, 8])),
+        ("expiratory", np.array([8, 10, 8])),
+        ("mean", np.array([8, 9, 8])),
+    ],
+)
+def test_compute_continuous_parameter_tiv_method_success(
+    mock_continuous_data: ContinuousData,
+    tiv_method: str,
+    expected_result: np.ndarray,
+):
+    """Test compute_continuous_parameter with valid tiv_method inputs that return expected results."""
+    tiv = TIV()
+    result = tiv.compute_continuous_parameter(mock_continuous_data, tiv_method=tiv_method)
+    result = np.stack(result.values)
+    assert result.shape == (3,)
+    assert np.allclose(result, expected_result, atol=0.01)
+
+
+@pytest.mark.parametrize(
+    ("tiv_method", "expected_error"),
+    [
+        ("invalid_method", ValueError),
+        (5, ValueError),
+    ],
+)
+def test_compute_pixel_parameter_invalid_tiv_method_errors(
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    mock_sequence: Sequence,
+    tiv_method: str,
+    expected_error: ValueError,
+):
+    """Test compute_pixel_parameter with invalid tiv_method inputs that raise errors."""
+    tiv = TIV()
+    with pytest.raises(expected_error):
+        tiv.compute_pixel_parameter(mock_eit_data, mock_continuous_data, mock_sequence, tiv_method=tiv_method)
+
+
+@pytest.mark.parametrize(
+    ("tiv_method", "expected_result"),
+    [
+        ("inspiratory", create_result_array(2)),
+        ("expiratory", create_result_array(2.5)),
+        ("mean", create_result_array(2.25)),
+    ],
+)
+def test_compute_pixel_parameter_valid_tiv_method(
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    mock_sequence: Sequence,
+    tiv_method: str,
+    expected_result: np.ndarray,
+):
+    """Test compute_pixel_parameter with valid tiv_method inputs that return expected results."""
+    tiv = TIV()
+    result = tiv.compute_pixel_parameter(
+        mock_eit_data,
+        mock_continuous_data,
+        mock_sequence,
+        tiv_method=tiv_method,
+    )
+    result = np.stack(result.values)
+    assert result.shape == (3, 2, 2)
+    assert np.allclose(
+        result[np.isfinite(result)],
+        expected_result[np.isfinite(expected_result)],
+        atol=0.01,
+    )  # isfinite because first and last breaths are expected to be np.nan
+
+
+@pytest.mark.parametrize(
+    ("tiv_timing", "expected_error"),
+    [
+        ("invalid_timing", ValueError),
+    ],
+)
+def test_compute_pixel_parameter_tiv_timing_errors(
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    mock_sequence: Sequence,
+    tiv_timing: str,
+    expected_error: ValueError,
+):
+    """Test compute_pixel_parameter with invalid tiv_timing inputs that raise errors."""
+    tiv = TIV()
+    with pytest.raises(expected_error, match="tiv_timing must be either 'continuous' or 'pixel'"):
+        tiv.compute_pixel_parameter(
+            eit_data=mock_eit_data,
+            continuous_data=mock_continuous_data,
+            sequence=mock_sequence,
+            tiv_timing=tiv_timing,
+        )
+
+
+@pytest.mark.parametrize(
+    ("tiv_timing", "expected_result"),
+    [
+        ("continuous", np.full((3, 2, 2), 2)),
+        ("pixel", create_result_array(2)),
+    ],
+)
+def test_compute_pixel_parameter_tiv_timing_success(
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    mock_sequence: Sequence,
+    tiv_timing: str,
+    expected_result: np.ndarray,
+):
+    """Test compute_pixel_parameter with valid tiv_timing inputs that return expected results."""
+    tiv = TIV()
+    result = tiv.compute_pixel_parameter(
+        eit_data=mock_eit_data,
+        continuous_data=mock_continuous_data,
+        sequence=mock_sequence,
+        tiv_timing=tiv_timing,
+    )
+    result = np.stack(result.values)
+    assert result.shape == (3, 2, 2)
+    assert np.allclose(
+        result[np.isfinite(result)],
+        expected_result[np.isfinite(expected_result)],
+        atol=0.01,
+    )
+
+
+def test_tiv_with_no_breaths_continuous(mock_continuous_data: ContinuousData):
+    """Test compute_continuous_parameter when no breaths are detected."""
+    tiv = TIV()
+    with (
+        patch.object(
+            tiv,
+            "_detect_breaths",
+            return_value=IntervalData(
+                label="breaths",
+                name="No Breaths",
+                unit="seconds",
+                category="breath",
+                intervals=[],
+                values=[],
+                parameters={},
+                derived_from=[],
+            ),
+        ),
+        patch.object(tiv, "_calculate_tiv_values", return_value=[]),
+    ):
+        result = tiv.compute_continuous_parameter(mock_continuous_data, tiv_method="inspiratory")
+        assert len(result.values) == 0
+
+
+def test_tiv_with_no_breaths_pixel(
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    mock_sequence: Sequence,
+):
+    """Test compute_pixel_parameter when no pixel breaths are detected."""
+    tiv = TIV()
+    with (
+        patch.object(
+            tiv,
+            "_detect_pixel_breaths",
+            return_value=IntervalData(
+                label="pixel breaths",
+                name="No Pixel breaths",
+                unit="seconds",
+                category="breath",
+                intervals=[],
+                values=np.empty((0, 2, 2), dtype=object),
+                parameters={},
+                derived_from=[],
+            ),
+        ),
+        patch.object(tiv, "_calculate_tiv_values", return_value=[]),
+    ):
+        result = tiv.compute_pixel_parameter(
+            eit_data=mock_eit_data,
+            continuous_data=mock_continuous_data,
+            sequence=mock_sequence,
+            tiv_method="mean",
+            tiv_timing="pixel",
+        )
+        result = np.empty((0, 2, 2)) if not len(result.values) else np.stack(result.values)
+        assert result.shape == (0, 2, 2)
+
+
+def test_with_data(draeger1: Sequence, timpel1: Sequence, pytestconfig: pytest.Config):
+    # Skip test if '--cov' option is enabled
+    if pytestconfig.getoption("--cov"):
+        pytest.skip("Skip with option '--cov' so other tests can cover 100%.")
+
+    # Make deep copies of the data to avoid modifying the original sequences
+    draeger1 = copy.deepcopy(draeger1)
+    timpel1 = copy.deepcopy(timpel1)
+
+    # Iterate over both sequences (draeger1 and timpel1)
+    for sequence in draeger1, timpel1:
+        # Select a subset of the sequence for testing (first 500 samples)
+        ssequence = sequence[0:500]
+
+        # Initialize the TIV object
+        tiv = TIV()
+        eit_data = ssequence.eit_data["raw"]
+        cd = ssequence.continuous_data["global_impedance_(raw)"]
+
+        result_continuous = tiv.compute_continuous_parameter(cd, tiv_method="inspiratory")
+        result_pixel = tiv.compute_pixel_parameter(eit_data, cd, ssequence)
+
+        arr_result_continuous = np.stack(result_continuous.values)
+        arr_result_pixel = np.stack(result_pixel.values)
+
+        assert result_continuous is not None
+        assert isinstance(result_continuous, SparseData)
+        assert arr_result_continuous.ndim == 1
+        assert np.all(arr_result_continuous > 0)  # values should be positive for continuous data
+
+        assert result_pixel is not None
+        assert isinstance(result_pixel, SparseData)
+        assert arr_result_pixel.ndim == 3
+
+
+@pytest.mark.parametrize(
+    ("bd_kwargs", "expected_error"),
+    [
+        ({"amplitude_cutoff_fraction": 0.3, "minimum_duration": 5.0}, ValueError),  # too long duration
+        ({"amplitude_cutoff_fraction": 2, "minimum_duration": 5.0}, ValueError),  # too high amplitude cutoff
+        ({"minimum_amplitude": 2, "minimum_duration": 5.0}, TypeError),  # unexpected keyword minimum_amplitude
+    ],
+)
+def test_detect_pixel_breaths_with_invalid_bd_kwargs(
+    bd_kwargs: dict,
+    expected_error: ValueError,
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    mock_sequence: Sequence,
+):
+    """Test detect_pixel_breaths with invalid bd_kwargs that raise errors."""
+    tiv = TIV(breath_detection_kwargs=bd_kwargs)
+
+    with pytest.raises(expected_error):
+        tiv._detect_pixel_breaths(mock_eit_data, mock_continuous_data, mock_sequence, store=False)
+
+
+@pytest.mark.parametrize(
+    ("bd_kwargs"),
+    [
+        ({"amplitude_cutoff_fraction": 0.1, "minimum_duration": 0.5}),
+        ({"amplitude_cutoff_fraction": 0.2, "minimum_duration": 0.3}),
+        ({"amplitude_cutoff_fraction": 0.5, "minimum_duration": 0.2}),
+    ],
+)
+def test_detect_pixel_breaths_with_valid_bd_kwargs(
+    bd_kwargs: dict,
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    mock_sequence: Sequence,
+):
+    """Test detect_pixel_breaths with valid bd_kwargs that return expected results."""
+    tiv = TIV(breath_detection_kwargs=bd_kwargs)
+
+    result = tiv._detect_pixel_breaths(mock_eit_data, mock_continuous_data, mock_sequence, store=False)
+    test_result = np.stack(result.values)
+    # Assert that the result is of the expected type and shape
+    assert isinstance(result, IntervalData)
+    assert test_result.shape == (3, 2, 2)  # Adjust this based on your expected output
diff --git a/tests/test_pixel_breath.py b/tests/test_pixel_breath.py
new file mode 100644
index 000000000..90eb0b109
--- /dev/null
+++ b/tests/test_pixel_breath.py
@@ -0,0 +1,393 @@
+import copy
+import itertools
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+import numpy as np
+import pytest
+
+from eitprocessing.datahandling.breath import Breath
+from eitprocessing.datahandling.continuousdata import ContinuousData
+from eitprocessing.datahandling.datacollection import DataCollection
+from eitprocessing.datahandling.eitdata import EITData, Vendor
+from eitprocessing.datahandling.intervaldata import IntervalData
+from eitprocessing.datahandling.sequence import Sequence
+from eitprocessing.datahandling.sparsedata import SparseData
+from eitprocessing.features.pixel_breath import PixelBreath
+
+environment = Path(
+    os.environ.get(
+        "EIT_PROCESSING_TEST_DATA",
+        Path(__file__).parent.parent.resolve(),
+    ),
+)
+data_directory = environment / "tests" / "test_data"
+draeger_file1 = data_directory / "Draeger_Test3.bin"
+timpel_file = data_directory / "Timpel_Test.txt"
+
+
+# @pytest.fixture()
+def mock_pixel_impedance():
+    """Mock pixel_impedance with phase shifted cosines for testing."""
+    # Create a time vector
+    time = np.linspace(0, 2 * np.pi, 400)
+
+    # Create 4 cosine waves with different frequencies or phases
+    cos_wave_1 = np.cos(4 * time)  # Standard cosine wave
+    cos_wave_2 = np.cos(4 * time + np.pi)  # Phase-shifted by pi
+    cos_wave_3 = np.cos(4 * time + 0.5 * np.pi)  # Phase-shifted by 0.5*pi
+    cos_wave_4 = np.cos(4 * time + 0.25 * np.pi)  # Phase-shifted by 0.25*pi
+
+    # Store the waves in a (time, 2, 2) array
+    pixel_impedance = np.empty((len(time), 2, 2))
+    pixel_impedance[:, 0, 0] = cos_wave_1
+    pixel_impedance[:, 0, 1] = cos_wave_2
+    pixel_impedance[:, 1, 0] = cos_wave_3
+    pixel_impedance[:, 1, 1] = cos_wave_4
+
+    return pixel_impedance
+
+
+def mock_pixel_impedance_one_zero() -> np.ndarray:
+    pixel_impedance = mock_pixel_impedance()
+    pixel_impedance[:, 1, 1] = np.abs(pixel_impedance[:, 1, 1] * 0)
+    return pixel_impedance
+
+
+def mock_global_impedance():
+    pixel_impedance = mock_pixel_impedance()
+    return np.nansum(
+        pixel_impedance,
+        axis=(1, 2),
+    )
+
+
+@pytest.fixture()
+def mock_continuous_data():
+    """Fixture to provide an instance of ContinuousData."""
+    return ContinuousData(
+        label="global_impedance",
+        name="global_impedance",
+        unit="au",
+        category="relative impedance",
+        description="Global impedance created for testing pixel breath feature",
+        parameters={},
+        derived_from="mock_eit_data",
+        time=np.linspace(0, 2 * np.pi, 400),
+        values=mock_global_impedance(),
+        sample_frequency=399 / 2 * np.pi,
+    )
+
+
+@pytest.fixture()
+def mock_eit_data():
+    """Fixture to provide an instance of EITData."""
+    return EITData(
+        path="",
+        nframes=400,
+        time=np.linspace(0, 2 * np.pi, 400),
+        sample_frequency=399 / 2 * np.pi,
+        vendor=Vendor.DRAEGER,
+        label="mock_eit_data",
+        name="mock_eit_data",
+        pixel_impedance=mock_pixel_impedance(),
+    )
+
+
+@pytest.fixture()
+def mock_sequence(mock_eit_data: EITData, mock_continuous_data: ContinuousData):
+    """Fixture to provide an instance of Sequence."""
+    data_collection_eit = DataCollection(EITData)
+    data_collection_eit.add(mock_eit_data)
+
+    data_collection_continuous = DataCollection(ContinuousData)
+    data_collection_continuous.add(mock_continuous_data)
+
+    data_collection_sparse = DataCollection(SparseData)
+    data_collection_interval = DataCollection(IntervalData)
+
+    return Sequence(
+        label="mock_sequence",
+        name="mock_sequence",
+        description="Sequence created for pixel breath feature testing",
+        eit_data=data_collection_eit,
+        continuous_data=data_collection_continuous,
+        sparse_data=data_collection_sparse,
+        interval_data=data_collection_interval,
+    )
+
+
+@pytest.fixture()
+def mock_zero_eit_data():
+    """Fixture to provide an instance of EITData with one element set to zero."""
+    return EITData(
+        path="",
+        nframes=400,
+        time=np.linspace(0, 2 * np.pi, 400),
+        sample_frequency=399 / 2 * np.pi,
+        vendor=Vendor.DRAEGER,
+        label="mock_eit_data",
+        name="mock_eit_data",
+        pixel_impedance=mock_pixel_impedance_one_zero(),
+    )
+
+
+@pytest.fixture()
+def mock_only_pixel_impedance():
+    """Mock pixel_impedance with phase shifted cosines for testing."""
+    """Mock pixel_impedance with phase shifted cosines for testing."""
+    # Create a time vector (e.g., 100 points from 0 to 2*pi)
+    time = np.linspace(0, 2 * np.pi, 100)
+
+    # Create 4 cosine waves with different frequencies or phases
+    cos_wave_1 = np.cos(time)  # Standard cosine wave
+    cos_wave_2 = np.cos(time + np.pi)  # Phase-shifted by pi
+    cos_wave_3 = np.cos(time + 0.5 * np.pi)  # Phase-shifted by 0.5*pi
+    cos_wave_4 = np.cos(time + 0.25 * np.pi)  # Phase-shifted by 0.25*pi
+
+    # Store the waves in a (time, 2, 2) array
+    pixel_impedance = np.empty((len(time), 2, 2))
+    pixel_impedance[:, 0, 0] = cos_wave_1
+    pixel_impedance[:, 0, 1] = cos_wave_2
+    pixel_impedance[:, 1, 0] = cos_wave_3
+    pixel_impedance[:, 1, 1] = cos_wave_4
+
+    return time, pixel_impedance
+
+
+@pytest.fixture()
+def not_a_sequence():
+    return []
+
+
+@pytest.fixture()
+def none_sequence():
+    return None
+
+
+def mock_compute_pixel_parameter(mean: int):
+    def _mock(*_args, **_kwargs) -> np.ndarray:
+        if mean > 0:
+            return SparseData(
+                label="mock_sparse_data",
+                name="Tidal impedance variation",
+                unit=None,
+                category="impedance difference",
+                time=np.linspace(0, 100),
+                description="Mock tidal impedance variation",
+                parameters={},
+                derived_from=[],
+                values=np.full(100, 1),
+            )
+        if mean < 0:
+            return SparseData(
+                label="mock_sparse_data",
+                name="Tidal impedance variation",
+                unit=None,
+                category="impedance difference",
+                time=np.linspace(0, 100),
+                description="Mock tidal impedance variation",
+                parameters={},
+                derived_from=[],
+                values=np.full(100, -1),
+            )
+        return SparseData(
+            label="mock_sparse_data",
+            name="Tidal impedance variation",
+            unit=None,
+            category="impedance difference",
+            time=np.linspace(0, 100),
+            description="Mock tidal impedance variation",
+            parameters={},
+            derived_from=[],
+            values=np.full(100, 0),
+        )
+
+    return _mock
+
+
+def test__compute_breaths():
+    """Test _compute_breaths helper function."""
+    time = np.array([0, 1, 2, 3, 4])
+    start = [0, 2]
+    middle = [1, 3]
+    end = [2, 4]
+    pi = PixelBreath()
+    result = pi._construct_breaths(start, middle, end, time)
+
+    assert len(result) == 4  # Two breaths plus two None
+    assert result[0] is None
+    assert result[-1] is None
+    assert isinstance(result[1], Breath)
+
+
+def test__find_extreme_indices(mock_only_pixel_impedance: tuple):
+    """Test _find_extreme_indices helper function."""
+    _, pixel_impedance = mock_only_pixel_impedance
+    # Define the time indices where we want to find the extrema
+    indices = np.array([0, 50])  # Indices between which to find extreme indices
+
+    # Expected min/max indices for each wave
+    expected_min_max = [
+        (-1, 1),  # cos_wave_1
+        (-1, 1),  # cos_wave_2
+        (-1, 0),  # cos_wave_3
+        (-1, np.sqrt(2) / 2),  # cos_wave_4
+    ]
+
+    # Create an instance of PixelBreath
+    pi = PixelBreath()
+
+    # Loop over each wave, defined by the (row, col) position in pixel_impedance
+    for i, (row, col) in enumerate([(0, 0), (0, 1), (1, 0), (1, 1)]):
+        # Call the _find_extreme_indices method for min and max
+        result_min = pi._find_extreme_indices(pixel_impedance, indices, row, col, np.argmin)
+        result_max = pi._find_extreme_indices(pixel_impedance, indices, row, col, np.argmax)
+
+        # Get the expected min and max for the current wave
+        expected_min, expected_max = expected_min_max[i]
+
+        assert np.isclose(pixel_impedance[result_min[0], row, col], expected_min, atol=0.01)
+        assert np.isclose(pixel_impedance[result_max[0], row, col], expected_max, atol=0.01)
+
+
+@pytest.mark.parametrize(
+    ("store_input", "sequence_fixture", "expected_exception"),
+    [
+        (True, "not_a_sequence", ValueError),  # Expect ValueError because an empty list is not a Sequence
+        (True, "none_sequence", RuntimeError),  # Expect RuntimeError because store=True but no Sequence is provided
+    ],
+)
+def test_store_result_with_errors(
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    request: pytest.FixtureRequest,
+    store_input: bool,
+    sequence_fixture: str,
+    expected_exception: ValueError | RuntimeError,
+):
+    """Test storing results when errors are expected."""
+    pi = PixelBreath(breath_detection_kwargs={"minimum_duration": 0.01})  # Ensure that breaths are detected
+
+    sequence = request.getfixturevalue(sequence_fixture)
+
+    # Expect a specific exception (either ValueError or RuntimeError)
+    with pytest.raises(expected_exception):
+        pi.find_pixel_breaths(mock_eit_data, mock_continuous_data, sequence, store=store_input)
+
+
+@pytest.mark.parametrize(
+    ("store_input", "sequence_fixture"),
+    [
+        (True, "mock_sequence"),  # Result should be stored
+        (False, "mock_sequence"),  # No result should be stored
+        (False, "none_sequence"),  # No result should be stored, no sequence provided
+        (None, "mock_sequence"),  # Result should be stored
+        (None, "none_sequence"),  # No result stored, no sequence provided
+    ],
+)
+def test_store_result_success(
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    request: pytest.FixtureRequest,
+    store_input: bool,
+    sequence_fixture: str,
+):
+    """Test storing results when no errors are expected."""
+    pi = PixelBreath(breath_detection_kwargs={"minimum_duration": 0.01})  # Ensure that breaths are detected
+
+    sequence = request.getfixturevalue(sequence_fixture)
+
+    # Run pixel breath detection and check the result
+    result = pi.find_pixel_breaths(mock_eit_data, mock_continuous_data, sequence, store=store_input)
+
+    # If store is True or None and sequence is not None, check that the result is stored in the sequence
+    if (store_input is True or store_input is None) and sequence is not None:
+        assert len(sequence.interval_data.data) == 1
+        assert sequence.interval_data["pixel_breaths"] == result
+    elif sequence is not None:
+        assert len(sequence.interval_data.data) == 0
+
+
+@pytest.mark.parametrize(
+    ("mean"),
+    [
+        -1,
+        1,
+    ],
+)
+def test_with_custom_mean_pixel_tiv(
+    mock_eit_data: EITData,
+    mock_continuous_data: ContinuousData,
+    mean: int,
+):
+    mock_function = mock_compute_pixel_parameter(mean)
+    with patch(
+        "eitprocessing.parameters.tidal_impedance_variation.TIV.compute_pixel_parameter",
+        side_effect=mock_function,
+    ):
+        pi = PixelBreath(breath_detection_kwargs={"minimum_duration": 0.01})
+
+        result = pi.find_pixel_breaths(mock_eit_data, mock_continuous_data)
+
+        test_result = np.stack(result.values)
+        assert test_result.shape == (3, 2, 2)
+
+        for row, col in itertools.product(range(2), range(2)):
+            time_point = test_result[1, row, col].middle_time
+            index = np.where(mock_eit_data.time == time_point)[0]
+            value_at_time = mock_eit_data.pixel_impedance[index[0], row, col]
+            if mean == -1:
+                assert np.isclose(value_at_time, -1, atol=0.01)
+            elif mean == 1:
+                assert np.isclose(value_at_time, 1, atol=0.01)
+
+
+def test_with_zero_impedance(mock_zero_eit_data: EITData, mock_continuous_data: ContinuousData):
+    pi = PixelBreath(breath_detection_kwargs={"minimum_duration": 0.01})
+    breath_container = pi.find_pixel_breaths(mock_zero_eit_data, mock_continuous_data)
+    test_result = np.stack(breath_container.values)
+    assert np.all(np.vectorize(lambda x: x is None)(test_result[:, 1, 1]))
+    assert test_result.shape == (3, 2, 2)
+
+
+def test_with_data(draeger1: Sequence, timpel1: Sequence, pytestconfig: pytest.Config):
+    if pytestconfig.getoption("--cov"):
+        pytest.skip("Skip with option '--cov' so other tests can cover 100%.")
+
+    draeger1 = copy.deepcopy(draeger1)
+    timpel1 = copy.deepcopy(timpel1)
+    for sequence in draeger1, timpel1:
+        ssequence = sequence[0:500]
+        pi = PixelBreath()
+        eit_data = ssequence.eit_data["raw"]
+        cd = ssequence.continuous_data["global_impedance_(raw)"]
+        pixel_breaths = pi.find_pixel_breaths(eit_data, cd)
+        test_result = np.stack(pixel_breaths.values)
+        _, n_rows, n_cols = test_result.shape
+
+        for row, col in itertools.product(range(n_rows), range(n_cols)):
+            filtered_values = [val for val in test_result[:, row, col] if val is not None]
+            if not len(filtered_values):
+                return
+            start_indices, middle_indices, end_indices = (list(x) for x in zip(*filtered_values, strict=True))
+            # Test whether pixel breaths are sorted properly
+            assert start_indices == sorted(start_indices)
+            assert middle_indices == sorted(middle_indices)
+            assert end_indices == sorted(end_indices)
+
+            # Test whether indices are unique. `set` removes non-unique values,
+            # `sorted(list(...))` converts the set to a sorted list again.
+            assert list(start_indices) == sorted(set(start_indices))
+            assert list(middle_indices) == sorted(set(middle_indices))
+            assert list(end_indices) == sorted(set(end_indices))
+
+            # Test whether the start of the next breath is on/after the previous breath
+            assert all(
+                start_index >= end_index
+                for start_index, end_index in zip(start_indices[1:], end_indices[:-1], strict=True)
+            )
+            for breath in filtered_values:
+                # Test whether the indices are in the proper order within a breath
+                assert breath.start_time < breath.middle_time < breath.end_time