From fe951d811e1ac35001d213de1fd2c271447be0fe Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 13:38:37 +0200
Subject: [PATCH 01/47] New function in plot: plot_power_distribution

---
 nilmth/utils/plot.py | 33 ++++++++++++++++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/nilmth/utils/plot.py b/nilmth/utils/plot.py
index e9e4a9f..584b0bf 100644
--- a/nilmth/utils/plot.py
+++ b/nilmth/utils/plot.py
@@ -1,5 +1,5 @@
-import matplotlib.pyplot as plt
 import numpy as np
+from matplotlib import pyplot as plt
 
 
 def plot_real_data(
@@ -66,3 +66,34 @@ def plot_real_vs_prediction(
     else:
         plt.savefig(savefig)
         plt.close()
+
+
+def plot_power_distribution(
+    ser: np.array, app: str, bins: int = 20, figsize: tuple = (3, 3)
+):
+    """Plot the histogram of power distribution
+
+    Parameters
+    ----------
+    ser : numpy.array
+        Contains all the power values
+    app : label
+        Name of the appliance
+    bins : int, optional
+        Histogram splits, by default 20
+    figsize : tuple, optional
+        Figure size, by default (3, 3)
+
+    Returns
+    -------
+    matplotlib.figure.Figure
+    matplotlib.axes._subplots.AxesSubplot
+
+    """
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.hist(ser, bins=bins)
+    ax.set_title(app.capitalize().replace("_", " "))
+    ax.set_xlabel("Power (watts)")
+    ax.set_ylabel("Frequency")
+    ax.grid()
+    return fig, ax

From 223a027e0abd7370e21de8daec87943242072cf4 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 14:07:51 +0200
Subject: [PATCH 02/47] Threshold returns info when called

---
 nilmth/data/threshold.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/nilmth/data/threshold.py b/nilmth/data/threshold.py
index a53e35e..39bd2aa 100644
--- a/nilmth/data/threshold.py
+++ b/nilmth/data/threshold.py
@@ -41,6 +41,10 @@ def __init__(
         self._status_fun = self._compute_status
         self._initialize_params()
 
+    def __repr__(self):
+        """This message is returned any time the object is called"""
+        return f"Threshold | Method: {self.method} | Statuses: {self.num_status}"
+
     def _initialize_params(self):
         """
         Given the method name and list of appliances,

From 98bd9ba673412ea30c7c8aaf9ff1538fb2d78169 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 14:08:17 +0200
Subject: [PATCH 03/47] Dataset returns info when called, add datapoints
 property

---
 nilmth/data/dataset.py | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/nilmth/data/dataset.py b/nilmth/data/dataset.py
index 217c69b..8d18ffd 100644
--- a/nilmth/data/dataset.py
+++ b/nilmth/data/dataset.py
@@ -11,7 +11,6 @@
 
 class DataSet(data.Dataset):
     files: list = list()
-    datapoints: int = 0
     appliances: list = list()
     num_apps: int = 0
     status: list = list()
@@ -50,6 +49,17 @@ def __init__(
             f"Dataset received extra kwargs, not used:\n     {', '.join(kwargs.keys())}"
         )
 
+    @property
+    def datapoints(self) -> int:
+        return len(self.files)
+    
+    def __len__(self):
+        return self.datapoints
+
+    def __repr__(self):
+        """This message is returned any time the object is called"""
+        return f"Dataset | Data points: {self.datapoints} | Input length: {self.length}"
+
     @staticmethod
     def _open_file(path_file: str) -> pd.DataFrame:
         """Opens a csv as a pandas.DataFrame"""
@@ -85,7 +95,6 @@ def _list_files(self, path_data: str):
                     files += files_of_building[test_idx:]
         # Update the class parameters
         self.files = files
-        self.datapoints = len(files)
         logger.info(f"{self.datapoints} data points found for {self.subset}")
 
     def _get_parameters_from_file(self):
@@ -160,6 +169,3 @@ def __getitem__(self, index: int) -> tuple:
         except KeyError:
             s = self.power_to_status(y)
         return x, y, s
-
-    def __len__(self):
-        return self.datapoints

From a1390ca6ee4fa293f123ec6e479060a7110571b3 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 14:08:41 +0200
Subject: [PATCH 04/47] Dataloader returns info when called, add threshold and
 appliances properties

---
 nilmth/data/dataloader.py | 23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/nilmth/data/dataloader.py b/nilmth/data/dataloader.py
index 986b387..c35482c 100644
--- a/nilmth/data/dataloader.py
+++ b/nilmth/data/dataloader.py
@@ -4,6 +4,7 @@
 import torch.utils.data as data
 
 from nilmth.data.dataset import DataSet
+from nilmth.data.threshold import Threshold
 from nilmth.utils.config import ConfigError
 from nilmth.utils.logging import logger
 
@@ -28,11 +29,23 @@ def __init__(
         self.path_threshold = path_threshold
         self.compute_thresholds()
 
+    @property
+    def threshold(self) -> Threshold:
+        return self.dataset.threshold
+
+    @property
+    def appliances(self) -> list:
+        return self.dataset.appliances
+
+    def __repr__(self):
+        """This message is returned any time the object is called"""
+        return f"Dataloader > {self.dataset}"
+
     def get_appliance_power_series(self, app: Union[str, int]) -> np.array:
         """Returns the full series of power of an appliance"""
         if type(app) == str:
             try:
-                app_idx = self.dataset.appliances.index(app)
+                app_idx = self.appliances.index(app)
             except ValueError:
                 raise ValueError(f"Appliance not found: {app}")
         else:
@@ -48,7 +61,7 @@ def compute_thresholds(self):
         """Compute the thresholds of each appliance"""
         # First try to load the thresholds
         try:
-            self.dataset.threshold.read_config(self.path_threshold)
+            self.threshold.read_config(self.path_threshold)
             return
         # If not possible, compute them
         except ConfigError:
@@ -59,12 +72,12 @@ def compute_thresholds(self):
                 )
             logger.debug("Threshold values not found. Computing them...")
             # Loop through each appliance
-            for app_idx, app in enumerate(self.dataset.appliances):
+            for app_idx, app in enumerate(self.appliances):
                 ser = self.get_appliance_power_series(app_idx)
                 # Concatenate all values and update the threshold
-                self.dataset.threshold.update_appliance_threshold(ser, app)
+                self.threshold.update_appliance_threshold(ser, app)
             # Write the config file
-            self.dataset.threshold.write_config(self.path_threshold)
+            self.threshold.write_config(self.path_threshold)
 
     def next(self):
         """Returns the next data batch"""

From 8f22e365ee0974d63d01129e649b3600f6658158 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 14:10:25 +0200
Subject: [PATCH 05/47] Dataset add property status

---
 nilmth/data/dataloader.py | 4 ++++
 nilmth/data/temporal.py   | 4 +---
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/nilmth/data/dataloader.py b/nilmth/data/dataloader.py
index c35482c..f2a955b 100644
--- a/nilmth/data/dataloader.py
+++ b/nilmth/data/dataloader.py
@@ -37,6 +37,10 @@ def threshold(self) -> Threshold:
     def appliances(self) -> list:
         return self.dataset.appliances
 
+    @property
+    def status(self):
+        return self.dataset.status
+
     def __repr__(self):
         """This message is returned any time the object is called"""
         return f"Dataloader > {self.dataset}"
diff --git a/nilmth/data/temporal.py b/nilmth/data/temporal.py
index ff11dd6..0abf9de 100644
--- a/nilmth/data/temporal.py
+++ b/nilmth/data/temporal.py
@@ -44,9 +44,7 @@ def generate_temporal_data(loader: DataLoader, path: str = "data_temp"):
         for m in mat:
             df = pd.DataFrame(
                 m,
-                columns=["aggregate"]
-                + loader.dataset.appliances
-                + loader.dataset.status,
+                columns=["aggregate"] + loader.appliances + loader.status,
             )
             path_file = os.path.join(path, f"{file_num:04}.csv")
             df.to_csv(path_file)

From bd90c52a39eba6b94f58d7e8c8057646e0aafa62 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 14:14:03 +0200
Subject: [PATCH 06/47] Dataset add properties border and files

---
 nilmth/data/dataloader.py | 10 +++++++++-
 nilmth/data/dataset.py    |  2 +-
 nilmth/data/temporal.py   |  4 ++--
 3 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/nilmth/data/dataloader.py b/nilmth/data/dataloader.py
index f2a955b..f548015 100644
--- a/nilmth/data/dataloader.py
+++ b/nilmth/data/dataloader.py
@@ -38,9 +38,17 @@ def appliances(self) -> list:
         return self.dataset.appliances
 
     @property
-    def status(self):
+    def status(self) -> list:
         return self.dataset.status
 
+    @property
+    def files(self) -> list:
+        return self.dataset.files
+
+    @property
+    def border(self) -> int:
+        return self.dataset.border
+
     def __repr__(self):
         """This message is returned any time the object is called"""
         return f"Dataloader > {self.dataset}"
diff --git a/nilmth/data/dataset.py b/nilmth/data/dataset.py
index 8d18ffd..7b99cdc 100644
--- a/nilmth/data/dataset.py
+++ b/nilmth/data/dataset.py
@@ -52,7 +52,7 @@ def __init__(
     @property
     def datapoints(self) -> int:
         return len(self.files)
-    
+
     def __len__(self):
         return self.datapoints
 
diff --git a/nilmth/data/temporal.py b/nilmth/data/temporal.py
index 0abf9de..ce4815b 100644
--- a/nilmth/data/temporal.py
+++ b/nilmth/data/temporal.py
@@ -22,14 +22,14 @@ def generate_temporal_data(loader: DataLoader, path: str = "data_temp"):
     os.mkdir(path)
     # Initialize the file number and the list of files
     file_num = 0
-    files = loader.dataset.files.copy()
+    files = loader.files.copy()
     # Iterate through the whole dataloader
     for data, target_power, target_status in iter(loader):
         data = data.cpu().detach().numpy()
         target_power = target_power.cpu().detach().numpy()
         target_status = target_status.cpu().detach().numpy()
         # Add the border for appliance power and status
-        npad = ((0, 0), (loader.dataset.border, loader.dataset.border), (0, 0))
+        npad = ((0, 0), (loader.border, loader.border), (0, 0))
         target_power = np.pad(
             target_power, pad_width=npad, mode="constant", constant_values=0
         )

From fc263f9bf735b1fb705b0bef2a0581612868869e Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 15:54:27 +0200
Subject: [PATCH 07/47] get_appliance_power_series to get_appliance_series

---
 nilmth/data/dataloader.py | 31 ++++++++++++++++++++++++++-----
 1 file changed, 26 insertions(+), 5 deletions(-)

diff --git a/nilmth/data/dataloader.py b/nilmth/data/dataloader.py
index f548015..e90811e 100644
--- a/nilmth/data/dataloader.py
+++ b/nilmth/data/dataloader.py
@@ -53,8 +53,23 @@ def __repr__(self):
         """This message is returned any time the object is called"""
         return f"Dataloader > {self.dataset}"
 
-    def get_appliance_power_series(self, app: Union[str, int]) -> np.array:
-        """Returns the full series of power of an appliance"""
+    def get_appliance_series(
+        self, app: Union[str, int], target: str = "power"
+    ) -> np.array:
+        """Returns the full series of power of an appliance
+
+        Parameters
+        ----------
+        app : str
+            Appliance label
+        target : str, optional
+            Target value (power or status), by default "power"
+
+        Returns
+        -------
+        numpy.array
+
+        """
         if type(app) == str:
             try:
                 app_idx = self.appliances.index(app)
@@ -65,8 +80,14 @@ def get_appliance_power_series(self, app: Union[str, int]) -> np.array:
         # Initialize list
         ser = [0] * self.__len__()
         # Loop through the set and extract all the values
-        for idx, (_, meters, _) in enumerate(self):
-            ser[idx] = meters[:, :, app_idx].flatten()
+        if target.lower() == "power":
+            for idx, (_, meters, _) in enumerate(self):
+                ser[idx] = meters[:, :, app_idx].flatten()
+        elif target.lower() == "status":
+            for idx, (_, _, meters) in enumerate(self):
+                ser[idx] = meters[:, :, app_idx].flatten()
+        else:
+            raise ValueError(f"Target not available: {target}")
         return np.concatenate(ser)
 
     def compute_thresholds(self):
@@ -85,7 +106,7 @@ def compute_thresholds(self):
             logger.debug("Threshold values not found. Computing them...")
             # Loop through each appliance
             for app_idx, app in enumerate(self.appliances):
-                ser = self.get_appliance_power_series(app_idx)
+                ser = self.get_appliance_series(app_idx)
                 # Concatenate all values and update the threshold
                 self.threshold.update_appliance_threshold(ser, app)
             # Write the config file

From 5ddb3e9bd56a85046bf6c2ae7581b87177e78814 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 16:11:47 +0200
Subject: [PATCH 08/47] get_appliance_series can return reconstructed power

---
 nilmth/data/dataloader.py | 31 +++++++++++++++++++++++++------
 1 file changed, 25 insertions(+), 6 deletions(-)

diff --git a/nilmth/data/dataloader.py b/nilmth/data/dataloader.py
index e90811e..f19631c 100644
--- a/nilmth/data/dataloader.py
+++ b/nilmth/data/dataloader.py
@@ -37,6 +37,10 @@ def threshold(self) -> Threshold:
     def appliances(self) -> list:
         return self.dataset.appliances
 
+    @property
+    def num_apps(self) -> int:
+        return self.dataset.num_apps
+
     @property
     def status(self) -> list:
         return self.dataset.status
@@ -56,14 +60,15 @@ def __repr__(self):
     def get_appliance_series(
         self, app: Union[str, int], target: str = "power"
     ) -> np.array:
-        """Returns the full series of power of an appliance
+        """Returns the full series of an appliance, being it power, status or
+        reconstructed power
 
         Parameters
         ----------
         app : str
             Appliance label
         target : str, optional
-            Target value (power or status), by default "power"
+            Target value (power, status or reconstructed), by default "power"
 
         Returns
         -------
@@ -79,16 +84,30 @@ def get_appliance_series(
             app_idx = app
         # Initialize list
         ser = [0] * self.__len__()
-        # Loop through the set and extract all the values
-        if target.lower() == "power":
+        # Set target string to lowercase
+        target = target.lower()
+        # Choose the target, then loop through the set and extract all the values
+        # Power
+        if target.startswith("p"):
             for idx, (_, meters, _) in enumerate(self):
                 ser[idx] = meters[:, :, app_idx].flatten()
-        elif target.lower() == "status":
+            return np.concatenate(ser)
+        # Status or reconstructed power (taken from status)
+        elif target.startswith("s") | target.startswith("r"):
             for idx, (_, _, meters) in enumerate(self):
                 ser[idx] = meters[:, :, app_idx].flatten()
+            # If status, return it directly
+            if target.startswith("s"):
+                return np.concatenate(ser)
+            # If reconstructed power, compute its value from status
+            else:
+                ser = np.concatenate(ser)
+                ser = np.repeat(
+                    np.expand_dims(ser, axis=1), repeats=self.num_apps, axis=1
+                )
+                return self.dataset.status_to_power(ser)[:, app_idx]
         else:
             raise ValueError(f"Target not available: {target}")
-        return np.concatenate(ser)
 
     def compute_thresholds(self):
         """Compute the thresholds of each appliance"""

From 086f4668a602c5ac5b6317ec4be6c1e70a8e914e Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 17:05:12 +0200
Subject: [PATCH 09/47] Threshold method to set threshold and centroid values

---
 nilmth/data/threshold.py | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/nilmth/data/threshold.py b/nilmth/data/threshold.py
index 39bd2aa..0514b0a 100644
--- a/nilmth/data/threshold.py
+++ b/nilmth/data/threshold.py
@@ -20,6 +20,7 @@
 
 
 class Threshold:
+    num_status: int = 2
     thresholds: np.array = None  # (appliance, status)
     centroids: np.array = None  # (appliance, status)
     use_std: bool = False
@@ -314,3 +315,29 @@ def write_config(self, path_config: str):
             config = dict_config
         store_config(path_config, config)
         logging.debug(f"Config stored at {path_config}\n")
+
+    def set_thresholds_and_centroids(
+        self, thresholds: np.array, centroids: np.array
+    ):
+        """Change threshold and centroid values to given ones
+
+        Parameters
+        ----------
+        thresholds : numpy.array
+            New threshold values
+        centroids : numpy.array
+            New centroid values
+
+        """
+        assert len(thresholds.shape), "Array must have two dimensions"
+        assert (
+            thresholds.shape[0] == self.num_apps
+        ), f"Axis 0 must have length {self.num_apps}"
+        assert (
+            thresholds.shape == centroids.shape
+        ), "Both arrays must have same dimension"
+        self.num_status = thresholds.shape[1]
+        self.thresholds = thresholds
+        self.centroids = centroids
+        self.method = "custom"
+        self._status_fun = self._compute_status

From 510e54fcf187e74d287cc8ea4a3647fde53ed8ed Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 17:18:29 +0200
Subject: [PATCH 10/47] Change param name length to len_series

---
 nilmth/data/dataset.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/nilmth/data/dataset.py b/nilmth/data/dataset.py
index 7b99cdc..11d6703 100644
--- a/nilmth/data/dataset.py
+++ b/nilmth/data/dataset.py
@@ -32,7 +32,7 @@ def __init__(
     ):
         self.subset = subset
         self.border = border
-        self.length = input_len
+        self.len_series = input_len
         self.buildings = {} if buildings is None else buildings[subset]
         self.train_size = train_size
         self.validation_size = valid_size
@@ -58,7 +58,7 @@ def __len__(self):
 
     def __repr__(self):
         """This message is returned any time the object is called"""
-        return f"Dataset | Data points: {self.datapoints} | Input length: {self.length}"
+        return f"Dataset | Data points: {self.datapoints} | Input length: {self.len_series}"
 
     @staticmethod
     def _open_file(path_file: str) -> pd.DataFrame:
@@ -105,9 +105,9 @@ def _get_parameters_from_file(self):
         self.appliances = sorted(appliances)
         self.num_apps = len(appliances)
         self.status = [app + "_status" for app in self.appliances]
-        self.length = df.shape[0]
+        self.len_series = df.shape[0]
         self._idx_start = self.border
-        self._idx_end = self.length - self.border
+        self._idx_end = self.len_series - self.border
 
     def power_to_status(self, ser: np.array) -> np.array:
         """Computes the status assigned to each power value

From 3f7dc85163df172acf44e059a5aaede95bfa2299 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 17:48:33 +0200
Subject: [PATCH 11/47] Optimize status_to_power method

---
 nilmth/data/dataset.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/nilmth/data/dataset.py b/nilmth/data/dataset.py
index 11d6703..fed8179 100644
--- a/nilmth/data/dataset.py
+++ b/nilmth/data/dataset.py
@@ -140,10 +140,7 @@ def status_to_power(self, ser: np.array) -> np.array:
 
         """
         # Get power values from status
-        power = np.multiply(np.ones(ser.shape), self.threshold.centroids[:, 0])
-        power_on = np.multiply(np.ones(ser.shape), self.threshold.centroids[:, 1])
-        power[ser == 1] = power_on[ser == 1]
-        return power
+        return np.take_along_axis(self.threshold.centroids, ser.T, axis=1).T
 
     def __getitem__(self, index: int) -> tuple:
         """Returns an element of the data loader

From 39589e5b0fa967ccbc74c6c805696d1c6ba9e9e4 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 20 May 2021 18:02:33 +0200
Subject: [PATCH 12/47] Dataset takes the list of appliances as input

---
 nilmth/data/dataset.py | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/nilmth/data/dataset.py b/nilmth/data/dataset.py
index fed8179..56ba9bb 100644
--- a/nilmth/data/dataset.py
+++ b/nilmth/data/dataset.py
@@ -12,13 +12,13 @@
 class DataSet(data.Dataset):
     files: list = list()
     appliances: list = list()
-    num_apps: int = 0
     status: list = list()
     threshold: Threshold = None
 
     def __init__(
         self,
         path_data: str,
+        appliances: list = None,
         subset: str = "train",
         input_len: int = 510,
         border: int = 15,
@@ -31,6 +31,7 @@ def __init__(
         **kwargs,
     ):
         self.subset = subset
+        self.appliances = appliances
         self.border = border
         self.len_series = input_len
         self.buildings = {} if buildings is None else buildings[subset]
@@ -53,12 +54,19 @@ def __init__(
     def datapoints(self) -> int:
         return len(self.files)
 
+    @property
+    def num_apps(self) -> int:
+        return len(self.appliances)
+
     def __len__(self):
         return self.datapoints
 
     def __repr__(self):
         """This message is returned any time the object is called"""
-        return f"Dataset | Data points: {self.datapoints} | Input length: {self.len_series}"
+        return (
+            f"Dataset | Data points: {self.datapoints} | "
+            f"Input length: {self.len_series}"
+        )
 
     @staticmethod
     def _open_file(path_file: str) -> pd.DataFrame:
@@ -100,10 +108,16 @@ def _list_files(self, path_data: str):
     def _get_parameters_from_file(self):
         """Updates class parameters from sample csv file"""
         df = self._open_file(self.files[0])
+        # List appliances in file
         appliances = [t for t in df.columns if not t.endswith("_status")]
-        appliances.remove("aggregate")
-        self.appliances = sorted(appliances)
-        self.num_apps = len(appliances)
+        # Ensure our list of appliances is contained in the dataset
+        # If we have no list, take the whole dataset
+        if self.appliances is None:
+            self.appliances = appliances
+        else:
+            for app in self.appliances:
+                assert app in appliances, f"Appliance missing in dataset: {app}"
+        # List the status columns
         self.status = [app + "_status" for app in self.appliances]
         self.len_series = df.shape[0]
         self._idx_start = self.border

From 9e9a4ba433c79f2838dd9ed238da2765fb8dff68 Mon Sep 17 00:00:00 2001
From: Daniel Precioso <danipg1409@gmail.com>
Date: Tue, 1 Jun 2021 17:08:13 +0200
Subject: [PATCH 13/47] Rename class according to script. Make abstract method

---
 nilmth/data/preprocessing.py | 8 +++++---
 nilmth/data/ukdale.py        | 6 +++---
 nilmth/preprocess.py         | 4 ++--
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/nilmth/data/preprocessing.py b/nilmth/data/preprocessing.py
index 519eccb..18ef06e 100644
--- a/nilmth/data/preprocessing.py
+++ b/nilmth/data/preprocessing.py
@@ -1,5 +1,6 @@
 import logging
 import os
+from abc import abstractmethod
 
 import pandas as pd
 
@@ -8,8 +9,8 @@
 logging.basicConfig(level=logging.DEBUG, format="%(message)s")
 
 
-class PreprocessWrapper:
-    dataset: str = "wrapper"
+class Preprocessing:
+    dataset: str = "Wrapper"
 
     def __init__(
         self,
@@ -64,9 +65,10 @@ def __init__(
             f"    {', '.join(kwargs.keys())}\n"
         )
 
+    @abstractmethod
     def load_house_meters(self, house: int) -> pd.DataFrame:
         """Placeholder function, this should load the household meters and status"""
-        return pd.DataFrame()
+        pass
 
     def store_preprocessed_data(self, path_output: str):
         """Stores preprocessed data in output folder"""
diff --git a/nilmth/data/ukdale.py b/nilmth/data/ukdale.py
index 6604374..a2e6fb8 100644
--- a/nilmth/data/ukdale.py
+++ b/nilmth/data/ukdale.py
@@ -4,16 +4,16 @@
 from pandas import Series
 from pandas.io.pytables import HDFStore
 
-from nilmth.data.preprocessing import PreprocessWrapper
+from nilmth.data.preprocessing import Preprocessing
 from nilmth.utils.string import APPLIANCE_NAMES, homogenize_string
 
 
-class UkdalePreprocess(PreprocessWrapper):
+class Ukdale(Preprocessing):
     dataset: str = "ukdale"
     datastore: HDFStore = None
 
     def __init__(self, path_h5: str, path_labels: str, **kwargs):
-        super(UkdalePreprocess, self).__init__(**kwargs)
+        super(Ukdale, self).__init__(**kwargs)
         self._path_h5 = path_h5
         self._path_labels = path_labels
         # Load the datastore
diff --git a/nilmth/preprocess.py b/nilmth/preprocess.py
index e745c27..b6df9b7 100644
--- a/nilmth/preprocess.py
+++ b/nilmth/preprocess.py
@@ -2,7 +2,7 @@
 
 import typer
 
-from nilmth.data.ukdale import UkdalePreprocess
+from nilmth.data.ukdale import Ukdale
 from nilmth.utils.config import load_config
 from nilmth.utils.logging import logger
 
@@ -13,7 +13,7 @@ def preprocess_ukdale(path_data: str, path_output: str, config: dict):
 
     path_h5 = path_ukdale + ".h5"
 
-    prep = UkdalePreprocess(path_h5, path_ukdale, **config)
+    prep = Ukdale(path_h5, path_ukdale, **config)
     prep.store_preprocessed_data(path_output)
 
 

From b8492d10c388e0b3d33b28b32965a683d6778a9d Mon Sep 17 00:00:00 2001
From: Daniel Precioso <danipg1409@gmail.com>
Date: Tue, 1 Jun 2021 17:18:56 +0200
Subject: [PATCH 14/47] Homogenize label outside ukdale

---
 nilmth/data/ukdale.py  | 8 +++-----
 nilmth/utils/string.py | 6 ++++++
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/nilmth/data/ukdale.py b/nilmth/data/ukdale.py
index a2e6fb8..67147bb 100644
--- a/nilmth/data/ukdale.py
+++ b/nilmth/data/ukdale.py
@@ -5,7 +5,7 @@
 from pandas.io.pytables import HDFStore
 
 from nilmth.data.preprocessing import Preprocessing
-from nilmth.utils.string import APPLIANCE_NAMES, homogenize_string
+from nilmth.utils.string import homogenize_label
 
 
 class Ukdale(Preprocessing):
@@ -76,16 +76,14 @@ def _datastore_to_series(self, house: int, label: str) -> pd.Series:
         ).to_dict()[1]
 
         # Homogenize input label
-        label = homogenize_string(label)
-        label = APPLIANCE_NAMES.get(label, label)
+        label = homogenize_label(label)
 
         # Series placeholder
         s = None
 
         # Iterate through all the existing labels, searching for the input label
         for i in labels:
-            lab = homogenize_string(labels[i])
-            lab = APPLIANCE_NAMES.get(lab, lab)
+            lab = homogenize_label(labels[i])
             # When we find the input label, we load the meter records
             if lab == label:
                 s = self._load_meter(house, i)
diff --git a/nilmth/utils/string.py b/nilmth/utils/string.py
index 8e814ec..fc04488 100644
--- a/nilmth/utils/string.py
+++ b/nilmth/utils/string.py
@@ -72,3 +72,9 @@ def homogenize_string(string, remove_dieresis_u=True):
     string_low_deaccent = deaccent(
         string_low, remove_dieresis_u=remove_dieresis_u)
     return string_low_deaccent
+
+
+def homogenize_label(label: str) -> str:
+    """Homogenizes the input label (which is the name of an appliance or meter)"""
+    label = homogenize_string(label)
+    return APPLIANCE_NAMES.get(label, label)

From a170a7274054a65a133424538a816481cfcede93 Mon Sep 17 00:00:00 2001
From: Daniel Precioso <danipg1409@gmail.com>
Date: Tue, 1 Jun 2021 17:21:31 +0200
Subject: [PATCH 15/47] Optimize ukdale for loop

---
 nilmth/data/ukdale.py | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/nilmth/data/ukdale.py b/nilmth/data/ukdale.py
index 67147bb..638ba71 100644
--- a/nilmth/data/ukdale.py
+++ b/nilmth/data/ukdale.py
@@ -78,17 +78,14 @@ def _datastore_to_series(self, house: int, label: str) -> pd.Series:
         # Homogenize input label
         label = homogenize_label(label)
 
-        # Series placeholder
-        s = None
-
         # Iterate through all the existing labels, searching for the input label
         for i in labels:
             lab = homogenize_label(labels[i])
             # When we find the input label, we load the meter records
             if lab == label:
                 s = self._load_meter(house, i)
-
-        if s is None:
+                break
+        else:
             raise ValueError(
                 f"Label {label} not found on house {house}\n"
                 f"Valid labels are: {list(labels.values())}"

From d5a6345594efc1bcee7dcdad031e56751d9d386d Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Wed, 2 Jun 2021 13:04:59 +0200
Subject: [PATCH 16/47] Hierarchical clustering class

---
 nilmth/data/clustering.py | 112 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 nilmth/data/clustering.py

diff --git a/nilmth/data/clustering.py b/nilmth/data/clustering.py
new file mode 100644
index 0000000..0d078a1
--- /dev/null
+++ b/nilmth/data/clustering.py
@@ -0,0 +1,112 @@
+import itertools
+
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.cluster.hierarchy import dendrogram, linkage, fcluster, cophenet
+from scipy.spatial.distance import pdist
+
+from nilmth.utils.plot import plot_power_distribution
+
+
+class HierarchicalClustering:
+    x: np.array = None
+    z: np.array = None
+    thresh: np.array = None
+    centroids: np.array = None
+    dendrogram: dict = None
+
+    def __init__(
+        self, method: str = "average", n_cluster: int = 2, criterion: str = "maxclust"
+    ):
+        self.method = method
+        self.n_cluster = n_cluster
+        self.criterion = criterion
+
+    def perform_clustering(self, ser: np.array, method: str = None):
+        """Performs the actual clustering, using the linkage function
+
+        Returns
+        -------
+        numpy.array
+            Z[i] will tell us which clusters were merged in the i-th iteration
+        """
+        if method is not None:
+            self.method = method
+        # The shape of our X matrix must be (n, m)
+        # n = samples, m = features
+        self.x = np.expand_dims(ser, axis=1)
+        self.z = linkage(self.x, method=self.method)
+
+    @property
+    def cophenet(self):
+        # Cophenet correlation coefficient
+        c, coph_dists = cophenet(self.z, pdist(self.x))
+        return c
+
+    def plot_dendrogram(self, p=6, max_d=None, figsize=(3, 3)):
+        fig, ax = plt.subplots(figsize=figsize)
+        self.dendrogram = dendrogram(
+            self.z,
+            p=p,
+            orientation="right",
+            truncate_mode="lastp",
+            labels=self.x[:, 0],
+            ax=ax,
+        )
+        if max_d is not None:
+            ax.axvline(x=max_d, c="k")
+        return fig, ax
+
+    @property
+    def dendrogram_distance(self):
+        return sorted(set(itertools.chain(*self.dendrogram["dcoord"])), reverse=True)
+
+    def plot_dendrogram_distance(self, figsize=(10, 3)):
+        # Initialize plots
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize)
+        # Dendrogram distance
+        ax1.scatter(
+            range(2, len(self.dendrogram_distance) + 1), self.dendrogram_distance[:-1]
+        )
+        ax1.set_ylabel("Distance")
+        ax1.set_xlabel("Number of clusters")
+        ax1.grid()
+        # Dendrogram distance difference
+        diff = np.divide(
+            -np.diff(self.dendrogram_distance), self.dendrogram_distance[:-1]
+        )
+        ax2.scatter(range(3, len(self.dendrogram_distance) + 1), diff[:-1])
+        ax2.set_ylabel("Gradient")
+        ax2.set_xlabel("Number of clusters")
+        ax2.grid()
+        return fig, (ax1, ax2)
+
+    def compute_thresholds_and_centroids(
+        self, n_cluster: int = None, criterion: str = None, centroid: str = "median"
+    ):
+        if n_cluster is not None:
+            self.n_cluster = n_cluster
+        if criterion is not None:
+            self.criterion = criterion
+        clusters = fcluster(self.z, self.n_cluster, self.criterion)
+        # Get centroids
+        if centroid == "median":
+            fun = np.median
+        elif centroid == "mean":
+            fun = np.mean
+        self.centroids = np.array(
+            sorted([fun(self.x[clusters == (c + 1)]) for c in range(self.n_cluster)])
+        )
+        # Sort clusters by power
+        x_max = sorted(
+            [np.max(self.x[clusters == (c + 1)]) for c in range(self.n_cluster)]
+        )
+        x_min = sorted(
+            [np.min(self.x[clusters == (c + 1)]) for c in range(self.n_cluster)]
+        )
+        self.thresh = np.divide(np.array(x_min[1:]) + np.array(x_max[:-1]), 2)
+
+    def plot_cluster_distribution(self, label="", bins=100):
+        fig, ax = plot_power_distribution(self.x, label, bins=bins)
+        [ax.axvline(t, color="r", linestyle="--") for t in self.thresh]
+        return fig, ax

From 2c853f39bad3d96702f53b547cc9f60dc2b3c841 Mon Sep 17 00:00:00 2001
From: daniprec <daniel.precioso@uca.es>
Date: Tue, 3 Aug 2021 17:18:44 +0200
Subject: [PATCH 17/47] Ignore ipynb files

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index cb7a515..b81b090 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@ notebooks/
 plots/
 output*/
 *.csv
+*.ipynb
 
 # Log
 log.out

From 3ca8e417f84dd0352de9a2046f154cbf504201af Mon Sep 17 00:00:00 2001
From: daniprec <daniel.precioso@uca.es>
Date: Tue, 3 Aug 2021 18:01:49 +0200
Subject: [PATCH 18/47] Docstring

---
 README.md                 |  8 ++--
 nilmth/data/clustering.py | 79 +++++++++++++++++++++++++++++++--------
 2 files changed, 68 insertions(+), 19 deletions(-)

diff --git a/README.md b/README.md
index 6d415bd..7266014 100644
--- a/README.md
+++ b/README.md
@@ -106,19 +106,19 @@ If you want to use your own set of parameters, duplicate the aforementioned
  configuration file and modify the paremeters you want to change (without deleting any
   parameter). You can then use that config file with the following command:
  
- ```
+```
 python nilmth/train.py  --path_config <path to your config file>
 ```
 
 For more information about the script, run:
 
- ```
+```
 python nilmth/train.py  --help
 ```
 
 Once the models are trained, test them with:
 
- ```
+```
 python nilmth/test.py  --path_config <path to your config file>
 ```
 
@@ -136,7 +136,7 @@ models are stored. Then, the script `train.py` will be called, using each
  configuration each. This will store the model weights, which will be used
  again during the test phase:
  
- ```
+```
 nohup sh test_sequential.sh > log.out & 
 ```
 
diff --git a/nilmth/data/clustering.py b/nilmth/data/clustering.py
index 0d078a1..48dd071 100644
--- a/nilmth/data/clustering.py
+++ b/nilmth/data/clustering.py
@@ -1,11 +1,11 @@
 import itertools
+from typing import Optional, Tuple
 
 import matplotlib.pyplot as plt
 import numpy as np
-from scipy.cluster.hierarchy import dendrogram, linkage, fcluster, cophenet
-from scipy.spatial.distance import pdist
-
 from nilmth.utils.plot import plot_power_distribution
+from scipy.cluster.hierarchy import cophenet, dendrogram, fcluster, linkage
+from scipy.spatial.distance import pdist
 
 
 class HierarchicalClustering:
@@ -22,16 +22,24 @@ def __init__(
         self.n_cluster = n_cluster
         self.criterion = criterion
 
-    def perform_clustering(self, ser: np.array, method: str = None):
+    def perform_clustering(
+        self, ser: np.array, method: Optional[str] = None
+    ) -> np.array:
         """Performs the actual clustering, using the linkage function
 
+        Parameters
+        ----------
+        ser : np.array
+            Series of points to group in clusters
+        method : str, optional
+            Clustering method, by default None (takes the one from the class)
+
         Returns
         -------
-        numpy.array
+        np.array
             Z[i] will tell us which clusters were merged in the i-th iteration
         """
-        if method is not None:
-            self.method = method
+        self.method = method if method is not None else self.method
         # The shape of our X matrix must be (n, m)
         # n = samples, m = features
         self.x = np.expand_dims(ser, axis=1)
@@ -43,7 +51,20 @@ def cophenet(self):
         c, coph_dists = cophenet(self.z, pdist(self.x))
         return c
 
-    def plot_dendrogram(self, p=6, max_d=None, figsize=(3, 3)):
+    def plot_dendrogram(
+        self, p: int = 6, max_d: Optional[float] = None, figsize: Tuple[int] = (3, 3)
+    ):
+        """Plots the dendrogram
+
+        Parameters
+        ----------
+        p : int, optional
+            Last split, by default 6
+        max_d : Optional[float], optional
+            Maximum distance between splits, by default None
+        figsize : Tuple[int], optional
+            Figure size, by default (3, 3)
+        """
         fig, ax = plt.subplots(figsize=figsize)
         self.dendrogram = dendrogram(
             self.z,
@@ -61,7 +82,14 @@ def plot_dendrogram(self, p=6, max_d=None, figsize=(3, 3)):
     def dendrogram_distance(self):
         return sorted(set(itertools.chain(*self.dendrogram["dcoord"])), reverse=True)
 
-    def plot_dendrogram_distance(self, figsize=(10, 3)):
+    def plot_dendrogram_distance(self, figsize: Tuple[int] = (10, 3)):
+        """Plots the dendrogram distances
+
+        Parameters
+        ----------
+        figsize : Tuple[int], optional
+            Size of the figure, by default (10, 3)
+        """
         # Initialize plots
         fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize)
         # Dendrogram distance
@@ -82,12 +110,24 @@ def plot_dendrogram_distance(self, figsize=(10, 3)):
         return fig, (ax1, ax2)
 
     def compute_thresholds_and_centroids(
-        self, n_cluster: int = None, criterion: str = None, centroid: str = "median"
+        self,
+        n_cluster: Optional[int] = None,
+        criterion: Optional[str] = None,
+        centroid: str = "median",
     ):
-        if n_cluster is not None:
-            self.n_cluster = n_cluster
-        if criterion is not None:
-            self.criterion = criterion
+        """Computes the thresholds and centroids of each group
+
+        Parameters
+        ----------
+        n_cluster : Optional[int], optional
+            Number of clusters, by default None
+        criterion : Optional[str], optional
+            Criterion used to compute the clusters, by default None
+        centroid : str, optional
+            Method to compute the centroids (median or mean), by default "median"
+        """
+        self.n_cluster = n_cluster if n_cluster is not None else self.n_cluster
+        self.criterion = criterion if criterion is not None else self.criterion
         clusters = fcluster(self.z, self.n_cluster, self.criterion)
         # Get centroids
         if centroid == "median":
@@ -106,7 +146,16 @@ def compute_thresholds_and_centroids(
         )
         self.thresh = np.divide(np.array(x_min[1:]) + np.array(x_max[:-1]), 2)
 
-    def plot_cluster_distribution(self, label="", bins=100):
+    def plot_cluster_distribution(self, label: str = "", bins: int = 100):
+        """Plots the power distribution, and the lines splitting each cluster
+
+        Parameters
+        ----------
+        label : str, optional
+            Label of the distribution, by default ""
+        bins : int, optional
+            Number of bins, by default 100
+        """
         fig, ax = plot_power_distribution(self.x, label, bins=bins)
         [ax.axvline(t, color="r", linestyle="--") for t in self.thresh]
         return fig, ax

From e4207dd8c5407e3c91ed3c9aa3f2fed2745b6ffc Mon Sep 17 00:00:00 2001
From: daniprec <daniel.precioso@uca.es>
Date: Wed, 4 Aug 2021 12:48:30 +0200
Subject: [PATCH 19/47] Move plot_cluster_distribution to plot

---
 nilmth/data/clustering.py | 14 --------------
 nilmth/utils/plot.py      | 34 +++++++++++++++++++++++++++++++---
 2 files changed, 31 insertions(+), 17 deletions(-)

diff --git a/nilmth/data/clustering.py b/nilmth/data/clustering.py
index 48dd071..026fc84 100644
--- a/nilmth/data/clustering.py
+++ b/nilmth/data/clustering.py
@@ -145,17 +145,3 @@ def compute_thresholds_and_centroids(
             [np.min(self.x[clusters == (c + 1)]) for c in range(self.n_cluster)]
         )
         self.thresh = np.divide(np.array(x_min[1:]) + np.array(x_max[:-1]), 2)
-
-    def plot_cluster_distribution(self, label: str = "", bins: int = 100):
-        """Plots the power distribution, and the lines splitting each cluster
-
-        Parameters
-        ----------
-        label : str, optional
-            Label of the distribution, by default ""
-        bins : int, optional
-            Number of bins, by default 100
-        """
-        fig, ax = plot_power_distribution(self.x, label, bins=bins)
-        [ax.axvline(t, color="r", linestyle="--") for t in self.thresh]
-        return fig, ax
diff --git a/nilmth/utils/plot.py b/nilmth/utils/plot.py
index 584b0bf..999a690 100644
--- a/nilmth/utils/plot.py
+++ b/nilmth/utils/plot.py
@@ -1,3 +1,4 @@
+from typing import Iterable
 import numpy as np
 from matplotlib import pyplot as plt
 
@@ -69,7 +70,7 @@ def plot_real_vs_prediction(
 
 
 def plot_power_distribution(
-    ser: np.array, app: str, bins: int = 20, figsize: tuple = (3, 3)
+    ser: np.array, app: str = "", bins: int = 20, figsize: tuple = (3, 3)
 ):
     """Plot the histogram of power distribution
 
@@ -77,8 +78,8 @@ def plot_power_distribution(
     ----------
     ser : numpy.array
         Contains all the power values
-    app : label
-        Name of the appliance
+    app : str, optional
+        Name of the appliance, by default ""
     bins : int, optional
         Histogram splits, by default 20
     figsize : tuple, optional
@@ -97,3 +98,30 @@ def plot_power_distribution(
     ax.set_ylabel("Frequency")
     ax.grid()
     return fig, ax
+
+
+def plot_cluster_distribution(
+    ser: np.array,
+    thresh: Iterable[float],
+    app: str = "",
+    bins: int = 20,
+    figsize: tuple = (3, 3),
+):
+    """Plots the power distribution, and the lines splitting each cluster
+
+    Parameters
+    ----------
+    ser : numpy.array
+        Contains all the power values
+    thresh : Iterable[float]
+        Contains all the threshold values
+    app : str, optional
+        Name of the appliance, by default ""
+    bins : int, optional
+        Histogram splits, by default 20
+    figsize : tuple, optional
+        Figure size, by default (3, 3)
+    """
+    fig, ax = plot_power_distribution(ser, app=app, bins=bins, figsize=figsize)
+    [ax.axvline(t, color="r", linestyle="--") for t in thresh]
+    return fig, ax

From b5be502c85aa433c8aa4af7d46bd75467af3c516 Mon Sep 17 00:00:00 2001
From: daniprec <daniel.precioso@uca.es>
Date: Wed, 4 Aug 2021 12:48:44 +0200
Subject: [PATCH 20/47] Script to compute hie clust

---
 nilmth/hierarchical_clustering.py | 101 ++++++++++++++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 nilmth/hierarchical_clustering.py

diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
new file mode 100644
index 0000000..7dcc1ee
--- /dev/null
+++ b/nilmth/hierarchical_clustering.py
@@ -0,0 +1,101 @@
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+import typer
+
+from nilmth.data.clustering import HierarchicalClustering
+from nilmth.data.dataloader import DataLoader
+from nilmth.utils.config import load_config
+from nilmth.utils.scores import regression_scores_dict
+
+LIST_APPLIANCES = ["dish_washer", "fridge", "washing_machine"]
+LIST_CLUSTER = [2, 3, 4, 5, 6]
+LIST_LINKAGE = [
+    "average",
+    "weighted",
+    "centroid",
+    "median",
+    "ward",  # Ward variance minimization algorithm
+]
+
+
+def main(
+    limit: int = 20000,
+    path_data: str = "data-prep",
+    path_threshold: str = "threshold.toml",
+    path_config: str = "nilmth/config.toml",
+    path_output: str = "outputs/hieclust",
+):
+
+    # Read config file
+    config = load_config(path_config, "model")
+
+    # Create output path
+    if not os.path.exists(path_output):
+        os.mkdir(path_output)
+
+    for app in LIST_APPLIANCES:
+        config["appliances"] = [app]
+
+        # Prepare data loader with train data
+        dl = DataLoader(
+            path_data=path_data,
+            subset="train",
+            shuffle=False,
+            path_threshold=path_threshold,
+            **config,
+        )
+
+        # Take an appliance series
+        ser = dl.get_appliance_series(app)[:limit]
+        # Name
+        appliance = app.capitalize().replace("_", " ")
+
+        for method in LIST_LINKAGE:
+            # Clustering
+            hie = HierarchicalClustering()
+            hie.perform_clustering(ser, method=method)
+            # Initialize the list of intrinsic error
+            # per number of clusters
+            intr_error = [0] * len(LIST_CLUSTER)
+            # Compute thresholds per number of clusters
+            for idx, n_cluster in enumerate(LIST_CLUSTER):
+                hie.compute_thresholds_and_centroids(n_cluster=n_cluster)
+                # Update thresholds and centroids
+                thresh = np.insert(np.expand_dims(hie.thresh, axis=0), 0, 0, axis=1)
+                centroids = np.expand_dims(hie.centroids, axis=0)
+                dl.threshold.set_thresholds_and_centroids(thresh, centroids)
+                # Create the dictionary of power series
+                power = np.expand_dims(ser, axis=1)
+                sta = dl.dataset.power_to_status(power)
+                recon = dl.dataset.status_to_power(sta)
+                dict_app = {appliance: {"power": power, "power_pred": recon}}
+                # Compute the scores
+                dict_scores = regression_scores_dict(dict_app)
+                intr_error[idx] = dict_scores[appliance]["nde"]
+            # Initialize plots
+            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
+            fig.suptitle(f"{appliance}, Linkage: {method}")
+            # Plot intrinsic error
+            ax1.plot(LIST_CLUSTER, intr_error, ".--")
+            ax1.set_title(f"Intrinsic Error")
+            ax1.set_ylabel("NDE")
+            ax1.set_xlabel("Number of status")
+            ax1.grid()
+            # Plot proportional reduction
+            rel_error = -100 * np.divide(np.diff(intr_error), intr_error[:-1])
+            ax2.plot(LIST_CLUSTER[1:], rel_error, ".--")
+            ax2.set_title("Reduction of Intrinsic Error")
+            ax2.set_ylabel("Reduction (%)")
+            ax2.set_xlabel("Number of status")
+            ax2.set_ylim(0, 100)
+            ax2.grid()
+            # Save and close the figure
+            path_fig = os.path.join(path_output, f"{app}_{method}.png")
+            fig.savefig(path_fig)
+            plt.close(fig)
+
+
+if __name__ == "__main__":
+    typer.run(main)

From e26a0bfd0be85c9494a798530d914c703f302474 Mon Sep 17 00:00:00 2001
From: daniprec <daniel.precioso@uca.es>
Date: Wed, 4 Aug 2021 13:18:45 +0200
Subject: [PATCH 21/47] Move plot to hieclust script

---
 nilmth/hierarchical_clustering.py | 88 +++++++++++++++++++++++++------
 nilmth/utils/plot.py              | 28 ----------
 2 files changed, 72 insertions(+), 44 deletions(-)

diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index 7dcc1ee..13964ec 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -1,8 +1,11 @@
 import os
+from typing import Iterable
 
 import matplotlib.pyplot as plt
 import numpy as np
 import typer
+from matplotlib import pyplot as plt
+from matplotlib.axes import Axes
 
 from nilmth.data.clustering import HierarchicalClustering
 from nilmth.data.dataloader import DataLoader
@@ -20,6 +23,70 @@
 ]
 
 
+def plot_intrinsic_error(intr_error: Iterable[float], ax: Axes):
+    """Plots the intrinsic error depending on the number of splits
+
+    Parameters
+    ----------
+    intr_error : Iterable[float]
+        List of intrinsic error values
+    ax : Axes
+        Axes where the graph is plotted
+    """
+    ax.plot(LIST_CLUSTER, intr_error, ".--")
+    ax.set_ylabel("Intrinsic Error (NDE)")
+    ax.set_xlabel("Number of status")
+    ax.grid()
+
+
+def plot_error_reduction(intr_error: Iterable[float], ax: Axes):
+    """Plots the intrinsic error reduction depending on the number of splits
+
+    Parameters
+    ----------
+    intr_error : Iterable[float]
+        List of intrinsic error values
+    ax : Axes
+        Axes where the graph is plotted
+    """
+    rel_error = -100 * np.divide(np.diff(intr_error), intr_error[:-1])
+    ax.plot(LIST_CLUSTER[1:], rel_error, ".--")
+    ax.set_ylabel("Reduction of Intrinsic Error (%)")
+    ax.set_xlabel("Number of status")
+    ax.set_ylim(0, 100)
+    ax.grid()
+
+
+def plot_cluster_distribution(
+    ser: np.array,
+    thresh: Iterable[float],
+    ax: Axes,
+    app: str = "",
+    bins: int = 100,
+):
+    """Plots the power distribution, and the lines splitting each cluster
+
+    Parameters
+    ----------
+    ser : numpy.array
+        Contains all the power values
+    thresh : Iterable[float]
+        Contains all the threshold values
+    ax : Axes
+        Axes where the graph is plotted
+    app : str, optional
+        Name of the appliance, by default ""
+    bins : int, optional
+        Histogram splits, by default 100
+    """
+    ax.hist(ser, bins=bins)
+    ax.set_title(app.capitalize().replace("_", " "))
+    ax.set_xlabel("Power (watts)")
+    ax.set_ylabel("Frequency")
+    ax.grid()
+    [ax.axvline(t, color="r", linestyle="--") for t in thresh]
+
+
 def main(
     limit: int = 20000,
     path_data: str = "data-prep",
@@ -27,7 +94,6 @@ def main(
     path_config: str = "nilmth/config.toml",
     path_output: str = "outputs/hieclust",
 ):
-
     # Read config file
     config = load_config(path_config, "model")
 
@@ -75,22 +141,12 @@ def main(
                 dict_scores = regression_scores_dict(dict_app)
                 intr_error[idx] = dict_scores[appliance]["nde"]
             # Initialize plots
-            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
+            fig, axis = plt.subplots(2, 2, figsize=(12, 8))
             fig.suptitle(f"{appliance}, Linkage: {method}")
-            # Plot intrinsic error
-            ax1.plot(LIST_CLUSTER, intr_error, ".--")
-            ax1.set_title(f"Intrinsic Error")
-            ax1.set_ylabel("NDE")
-            ax1.set_xlabel("Number of status")
-            ax1.grid()
-            # Plot proportional reduction
-            rel_error = -100 * np.divide(np.diff(intr_error), intr_error[:-1])
-            ax2.plot(LIST_CLUSTER[1:], rel_error, ".--")
-            ax2.set_title("Reduction of Intrinsic Error")
-            ax2.set_ylabel("Reduction (%)")
-            ax2.set_xlabel("Number of status")
-            ax2.set_ylim(0, 100)
-            ax2.grid()
+            # Plots
+            plot_cluster_distribution(hie.x, hie.thresh, axis[0, 0])
+            plot_intrinsic_error(intr_error, axis[1, 0])
+            plot_error_reduction(intr_error, axis[1, 1])
             # Save and close the figure
             path_fig = os.path.join(path_output, f"{app}_{method}.png")
             fig.savefig(path_fig)
diff --git a/nilmth/utils/plot.py b/nilmth/utils/plot.py
index 999a690..9a120a4 100644
--- a/nilmth/utils/plot.py
+++ b/nilmth/utils/plot.py
@@ -1,4 +1,3 @@
-from typing import Iterable
 import numpy as np
 from matplotlib import pyplot as plt
 
@@ -98,30 +97,3 @@ def plot_power_distribution(
     ax.set_ylabel("Frequency")
     ax.grid()
     return fig, ax
-
-
-def plot_cluster_distribution(
-    ser: np.array,
-    thresh: Iterable[float],
-    app: str = "",
-    bins: int = 20,
-    figsize: tuple = (3, 3),
-):
-    """Plots the power distribution, and the lines splitting each cluster
-
-    Parameters
-    ----------
-    ser : numpy.array
-        Contains all the power values
-    thresh : Iterable[float]
-        Contains all the threshold values
-    app : str, optional
-        Name of the appliance, by default ""
-    bins : int, optional
-        Histogram splits, by default 20
-    figsize : tuple, optional
-        Figure size, by default (3, 3)
-    """
-    fig, ax = plot_power_distribution(ser, app=app, bins=bins, figsize=figsize)
-    [ax.axvline(t, color="r", linestyle="--") for t in thresh]
-    return fig, ax

From ff1b687999acc2b432e96a2d6af267468be04dbd Mon Sep 17 00:00:00 2001
From: daniprec <daniel.precioso@uca.es>
Date: Wed, 4 Aug 2021 13:39:48 +0200
Subject: [PATCH 22/47] Improve plots and add docstring

---
 nilmth/hierarchical_clustering.py | 33 ++++++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 5 deletions(-)

diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index 13964ec..76a7002 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -79,12 +79,14 @@ def plot_cluster_distribution(
     bins : int, optional
         Histogram splits, by default 100
     """
-    ax.hist(ser, bins=bins)
+    y, x, _ = ax.hist(ser, bins=bins)
     ax.set_title(app.capitalize().replace("_", " "))
     ax.set_xlabel("Power (watts)")
     ax.set_ylabel("Frequency")
     ax.grid()
-    [ax.axvline(t, color="r", linestyle="--") for t in thresh]
+    for idx, t in enumerate(thresh):
+        ax.axvline(t, color="r", linestyle="--")
+        ax.text(t + 0.01 * x.max(), y.max(), idx, rotation=0, color="r")
 
 
 def main(
@@ -94,6 +96,23 @@ def main(
     path_config: str = "nilmth/config.toml",
     path_output: str = "outputs/hieclust",
 ):
+    """Performs the hierarchical clustering on the given list of appliances,
+    testing different linkaged methods and number of splits. For each combination,
+    outputs an image with several informative graphs.
+
+    Parameters
+    ----------
+    limit : int, optional
+        Number of data points to use, by default 20000
+    path_data : str, optional
+        Path to the preprocessed data folder, by default "data-prep"
+    path_threshold : str, optional
+        Path to the threshold configuration, by default "threshold.toml"
+    path_config : str, optional
+        Path to the config file, by default "nilmth/config.toml"
+    path_output : str, optional
+        Path to the outputs folder, by default "outputs/hieclust"
+    """
     # Read config file
     config = load_config(path_config, "model")
 
@@ -122,9 +141,10 @@ def main(
             # Clustering
             hie = HierarchicalClustering()
             hie.perform_clustering(ser, method=method)
-            # Initialize the list of intrinsic error
-            # per number of clusters
+            # Initialize the list of intrinsic error per number of clusters
             intr_error = [0] * len(LIST_CLUSTER)
+            # Initialize the empty list of thresholds (sorted)
+            thresh_sorted = []
             # Compute thresholds per number of clusters
             for idx, n_cluster in enumerate(LIST_CLUSTER):
                 hie.compute_thresholds_and_centroids(n_cluster=n_cluster)
@@ -140,11 +160,14 @@ def main(
                 # Compute the scores
                 dict_scores = regression_scores_dict(dict_app)
                 intr_error[idx] = dict_scores[appliance]["nde"]
+                # Update the sorted list of thresholds
+                thresh = list(set(hie.thresh) - set(thresh_sorted))
+                thresh_sorted.append(thresh[0])
             # Initialize plots
             fig, axis = plt.subplots(2, 2, figsize=(12, 8))
             fig.suptitle(f"{appliance}, Linkage: {method}")
             # Plots
-            plot_cluster_distribution(hie.x, hie.thresh, axis[0, 0])
+            plot_cluster_distribution(hie.x, thresh_sorted, axis[0, 0])
             plot_intrinsic_error(intr_error, axis[1, 0])
             plot_error_reduction(intr_error, axis[1, 1])
             # Save and close the figure

From 8fc1470381bd88e9888c06363337a549da1b5a50 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Fri, 3 Sep 2021 13:18:43 +0200
Subject: [PATCH 23/47] Update README

---
 README.md       | 107 ++++++++++++++++++++++++++++++++++++++++++------
 images/logo.png | Bin 0 -> 108608 bytes
 2 files changed, 94 insertions(+), 13 deletions(-)
 create mode 100644 images/logo.png

diff --git a/README.md b/README.md
index 6d415bd..c0d7bcc 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,66 @@
-# NILM: classification VS regression
+<!-- README template: https://github.com/othneildrew/Best-README-Template -->
+
+<!-- PROJECT SHIELDS -->
+<!--
+*** I'm using markdown "reference style" links for readability.
+*** Reference links are enclosed in brackets [ ] instead of parentheses ( ).
+*** See the bottom of this document for the declaration of the reference variables
+*** for contributors-url, forks-url, etc. This is an optional, concise syntax you may use.
+*** https://www.markdownguide.org/basic-syntax/#reference-style-links
+-->
+[![Contributors][contributors-shield]][contributors-url]
+[![Forks][forks-shield]][forks-url]
+[![Stargazers][stars-shield]][stars-url]
+[![Issues][issues-shield]][issues-url]
+[![LinkedIn][linkedin-shield]][linkedin-url]
+
+<!-- PROJECT LOGO -->
+<br />
+<p align="center">
+  <a href="https://github.com/UCA-Datalab/nilm-thresholding">
+    <img src="images/logo.png" alt="Logo" width="400" height="80">
+  </a>
+
+  <h3 align="center">NILM: classification VS regression</h3>
+</p>
+
+
+<!-- TABLE OF CONTENTS -->
+<details open="open">
+  <summary>Table of Contents</summary>
+  <ol>
+    <li>
+      <a href="#about-the-project">About The Project</a>
+    </li>
+    <li>
+      <a href="#getting-started">Getting Started</a>
+      <ul>
+        <li><a href="#create-the-environment">Create the Environment</a></li>
+      </ul>
+    </li>
+    <li>
+      <a href="#data">Data</a>
+      <ul>
+        <li><a href="#uk-dale">UK-DALE</a></li>
+      </ul>
+      <ul>
+        <li><a href="#preprocess">Preprocess</a></li>
+      </ul>
+    </li>
+    <li>
+      <a href="#train">Train</a>
+      <ul>
+         <li><a href="#reproduce-the-paper">Reproduce the Paper</a></li>
+         <li><a href="#thresholding-methods">Thresholding Methods</a></li>
+      </ul>
+    </li>
+    <li><a href="#publications">Publications</a></li>
+    <li><a href="#contact">Contact</a></li>
+    <li><a href="#acknowledgements">Acknowledgements</a></li>
+  </ol>
+</details>
+
+## About the project
 
 Non-Intrusive Load Monitoring (NILM)  aims to predict the status
 or consumption of  domestic appliances in a household only by knowing
@@ -14,10 +76,10 @@ deep learning state-of-the-art architectures on both the regression and
 classification problems, introducing criteria to select the most convenient
 thresholding method.
 
-Source: [see publications](#publications)
+## Getting started
+### Create the Environment
 
-## Set up
-### Create the environment using Conda
+To create the environment using Conda:
 
   1. Install miniconda
      
@@ -122,7 +184,7 @@ Once the models are trained, test them with:
 python nilmth/test.py  --path_config <path to your config file>
 ```
 
-#### Reproduce paper
+### Reproduce the Paper
 
 To reproduce the results shown in [our paper](#publications), activate the
  environment and then run:
@@ -140,7 +202,7 @@ models are stored. Then, the script `train.py` will be called, using each
 nohup sh test_sequential.sh > log.out & 
 ```
 
-### Thresholding methods
+### Thresholding Methods
 
 There are three threshold methods available. Read [our paper](#publications)
 to understand how each threshold works.
@@ -151,13 +213,32 @@ to understand how each threshold works.
 
 ## Publications
 
-[NILM as a regression versus classification problem:
+* [NILM as a regression versus classification problem:
 the importance of thresholding](https://www.researchgate.net/project/Non-Intrusive-Load-Monitoring-6)
 
-## Contact information
+## Contact
 
-Author: Daniel Precioso, PhD student at Universidad de Cádiz
-- Email: daniel.precioso@uca.es
-- [Github](https://github.com/daniprec)
-- [LinkedIn](https://www.linkedin.com/in/daniel-precioso-garcelan/)
-- [ResearchGate](https://www.researchgate.net/profile/Daniel_Precioso_Garcelan)
+Daniel Precioso - [daniprec](https://github.com/daniprec) -  daniel.precioso@uca.es
+
+Project link: [https://github.com/UCA-Datalab/nilm-thresholding](https://github.com/UCA-Datalab/nilm-thresholding)
+
+ResearhGate link: [https://www.researchgate.net/project/NILM-classification-VS-regression](https://www.researchgate.net/project/NILM-classification-VS-regression)
+
+## Acknowledgements
+
+* [UCA DataLab](http://datalab.uca.es/)
+* [David Gómez-Ullate](https://www.linkedin.com/in/david-g%C3%B3mez-ullate-oteiza-87a820b/?originalSubdomain=en)
+
+
+<!-- MARKDOWN LINKS & IMAGES -->
+<!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
+[contributors-shield]: https://img.shields.io/github/contributors/UCA-Datalab/nilm-thresholding.svg?style=for-the-badge
+[contributors-url]: https://github.com/UCA-Datalab/nilm-thresholding/graphs/contributors
+[forks-shield]: https://img.shields.io/github/forks/UCA-Datalab/nilm-thresholding.svg?style=for-the-badge
+[forks-url]: https://github.com/UCA-Datalab/nilm-thresholding/network/members
+[stars-shield]: https://img.shields.io/github/stars/UCA-Datalab/nilm-thresholding.svg?style=for-the-badge
+[stars-url]: https://github.com/UCA-Datalab/nilm-thresholding/stargazers
+[issues-shield]: https://img.shields.io/github/issues/UCA-Datalab/nilm-thresholding.svg?style=for-the-badge
+[issues-url]: https://github.com/UCA-Datalab/nilm-thresholding/issues
+[linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
+[linkedin-url]: https://www.linkedin.com/in/daniel-precioso-garcelan/
\ No newline at end of file
diff --git a/images/logo.png b/images/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..07dbbaff4d7aa56dbefd08c6af8389fc60a98976
GIT binary patch
literal 108608
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
J0@Wv>{~zw;>P`Rv

literal 0
HcmV?d00001


From 17df2749aed3291e3cd8f1caa31e6dbf6bcf44b6 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Fri, 3 Sep 2021 13:24:21 +0200
Subject: [PATCH 24/47] Update README

---
 README.md | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index c0d7bcc..62e8b4e 100644
--- a/README.md
+++ b/README.md
@@ -39,13 +39,14 @@
       </ul>
     </li>
     <li>
-      <a href="#data">Data</a>
+      <a href="#datasets">Datasets</a>
       <ul>
         <li><a href="#uk-dale">UK-DALE</a></li>
       </ul>
       <ul>
-        <li><a href="#preprocess">Preprocess</a></li>
+        <li><a href="#pecan-street-dataport">Pecan Street Dataport</a></li>
       </ul>
+   <li><a href="#preprocess-the-data">Preprocess the Data</a></li>
     </li>
     <li>
       <a href="#train">Train</a>
@@ -105,12 +106,10 @@ To create the environment using Conda:
        conda activate nilm-thresholding
        ```
  
-## Data
+## Datasets
 
 ### UK-DALE
 
-#### Download UK-DALE
-
 UK-DALE dataset is hosted on the following link:
 [https://data.ukedc.rl.ac.uk/browse/edc/efficiency/residential
 /EnergyConsumption/Domestic/UK-DALE-2017/UK-DALE-FULL-disaggregated](https://data.ukedc.rl.ac.uk/browse/edc/efficiency/residential/EnergyConsumption/Domestic/UK-DALE-2017/UK-DALE-FULL-disaggregated)
@@ -131,7 +130,15 @@ nilm-thresholding
 
 Credit: [Jack Kelly](https://jack-kelly.com/data/)
 
-### Preprocess
+### Pecan Street Dataport
+
+We are aiming to include this dataset in a future release. You can check the issue here: [https://github.com/UCA-Datalab/nilm-thresholding/issues/8](https://github.com/UCA-Datalab/nilm-thresholding/issues/8)
+
+Any help and suggestions are welcome!
+
+Credit: [Pecan Street](https://dataport.pecanstreet.org/)
+
+## Preprocess the Data
 
 Once downloaded the raw data from any of the sources above,
 you must preprocess it.

From cd0b6227fc07978d20b6b2153d13bf16e3e1b6b9 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Wed, 22 Sep 2021 12:59:22 +0200
Subject: [PATCH 25/47] Change url of image

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 62e8b4e..84181c6 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@
 <!-- PROJECT LOGO -->
 <br />
 <p align="center">
-  <a href="https://github.com/UCA-Datalab/nilm-thresholding">
+  <a href="https://github.com/UCA-Datalab">
     <img src="images/logo.png" alt="Logo" width="400" height="80">
   </a>
 

From 33f7d9c93eda3b8d4a75d938b27ca04cd246b3bf Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 23 Sep 2021 13:54:58 +0200
Subject: [PATCH 26/47] Move part of main function to new function

---
 nilmth/hierarchical_clustering.py | 110 ++++++++++++++++++------------
 1 file changed, 67 insertions(+), 43 deletions(-)

diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index 76a7002..cc2cd88 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -1,5 +1,5 @@
 import os
-from typing import Iterable
+from typing import Iterable, Optional, Tuple
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -23,32 +23,36 @@
 ]
 
 
-def plot_intrinsic_error(intr_error: Iterable[float], ax: Axes):
+def plot_intrinsic_error(intr_error: Iterable[float], ax: Optional[Axes] = None):
     """Plots the intrinsic error depending on the number of splits
 
     Parameters
     ----------
     intr_error : Iterable[float]
         List of intrinsic error values
-    ax : Axes
+    ax : Axes, optional
         Axes where the graph is plotted
     """
+    if ax is None:
+        ax = plt.gca()
     ax.plot(LIST_CLUSTER, intr_error, ".--")
     ax.set_ylabel("Intrinsic Error (NDE)")
     ax.set_xlabel("Number of status")
     ax.grid()
 
 
-def plot_error_reduction(intr_error: Iterable[float], ax: Axes):
+def plot_error_reduction(intr_error: Iterable[float], ax: Optional[Axes] = None):
     """Plots the intrinsic error reduction depending on the number of splits
 
     Parameters
     ----------
     intr_error : Iterable[float]
         List of intrinsic error values
-    ax : Axes
+    ax : Axes, optional
         Axes where the graph is plotted
     """
+    if ax is None:
+        ax = plt.gca()
     rel_error = -100 * np.divide(np.diff(intr_error), intr_error[:-1])
     ax.plot(LIST_CLUSTER[1:], rel_error, ".--")
     ax.set_ylabel("Reduction of Intrinsic Error (%)")
@@ -60,7 +64,7 @@ def plot_error_reduction(intr_error: Iterable[float], ax: Axes):
 def plot_cluster_distribution(
     ser: np.array,
     thresh: Iterable[float],
-    ax: Axes,
+    ax: Optional[Axes] = None,
     app: str = "",
     bins: int = 100,
 ):
@@ -72,13 +76,15 @@ def plot_cluster_distribution(
         Contains all the power values
     thresh : Iterable[float]
         Contains all the threshold values
-    ax : Axes
+    ax : Axes, optional
         Axes where the graph is plotted
     app : str, optional
         Name of the appliance, by default ""
     bins : int, optional
         Histogram splits, by default 100
     """
+    if ax is None:
+        ax = plt.gca()
     y, x, _ = ax.hist(ser, bins=bins)
     ax.set_title(app.capitalize().replace("_", " "))
     ax.set_xlabel("Power (watts)")
@@ -89,6 +95,52 @@ def plot_cluster_distribution(
         ax.text(t + 0.01 * x.max(), y.max(), idx, rotation=0, color="r")
 
 
+def plot_clustering_results(ser: np.array, dl: DataLoader, method: str = "average"):
+    """Plots the results of applying a certain clustering method
+    on the given series
+
+    Parameters
+    ----------
+    ser : np.array
+        Contains all the power values
+    dl : DataLoader
+        Required to apply the thresholds on the series
+    method : str, optional
+        Clustering method, by default "average"
+    """
+    # Clustering
+    hie = HierarchicalClustering()
+    hie.perform_clustering(ser, method=method)
+    # Initialize the list of intrinsic error per number of clusters
+    intr_error = [0] * len(LIST_CLUSTER)
+    # Initialize the empty list of thresholds (sorted)
+    thresh_sorted = []
+    # Compute thresholds per number of clusters
+    for idx, n_cluster in enumerate(LIST_CLUSTER):
+        hie.compute_thresholds_and_centroids(n_cluster=n_cluster)
+        # Update thresholds and centroids
+        thresh = np.insert(np.expand_dims(hie.thresh, axis=0), 0, 0, axis=1)
+        centroids = np.expand_dims(hie.centroids, axis=0)
+        dl.threshold.set_thresholds_and_centroids(thresh, centroids)
+        # Create the dictionary of power series
+        power = np.expand_dims(ser, axis=1)
+        sta = dl.dataset.power_to_status(power)
+        recon = dl.dataset.status_to_power(sta)
+        dict_app = {"app": {"power": power, "power_pred": recon}}
+        # Compute the scores
+        dict_scores = regression_scores_dict(dict_app)
+        intr_error[idx] = dict_scores["app"]["nde"]
+        # Update the sorted list of thresholds
+        thresh = list(set(hie.thresh) - set(thresh_sorted))
+        thresh_sorted.append(thresh[0])
+    # Initialize plots
+    fig, axis = plt.subplots(2, 2, figsize=(12, 8))
+    # Plots
+    plot_cluster_distribution(power, thresh_sorted, ax=axis[0, 0])
+    plot_intrinsic_error(intr_error, ax=axis[1, 0])
+    plot_error_reduction(intr_error, ax=axis[1, 1])
+
+
 def main(
     limit: int = 20000,
     path_data: str = "data-prep",
@@ -120,6 +172,7 @@ def main(
     if not os.path.exists(path_output):
         os.mkdir(path_output)
 
+    # Loop through the list of appliances
     for app in LIST_APPLIANCES:
         config["appliances"] = [app]
 
@@ -134,46 +187,17 @@ def main(
 
         # Take an appliance series
         ser = dl.get_appliance_series(app)[:limit]
-        # Name
+        # Appliance name
         appliance = app.capitalize().replace("_", " ")
-
+        # Loop through methods
         for method in LIST_LINKAGE:
-            # Clustering
-            hie = HierarchicalClustering()
-            hie.perform_clustering(ser, method=method)
-            # Initialize the list of intrinsic error per number of clusters
-            intr_error = [0] * len(LIST_CLUSTER)
-            # Initialize the empty list of thresholds (sorted)
-            thresh_sorted = []
-            # Compute thresholds per number of clusters
-            for idx, n_cluster in enumerate(LIST_CLUSTER):
-                hie.compute_thresholds_and_centroids(n_cluster=n_cluster)
-                # Update thresholds and centroids
-                thresh = np.insert(np.expand_dims(hie.thresh, axis=0), 0, 0, axis=1)
-                centroids = np.expand_dims(hie.centroids, axis=0)
-                dl.threshold.set_thresholds_and_centroids(thresh, centroids)
-                # Create the dictionary of power series
-                power = np.expand_dims(ser, axis=1)
-                sta = dl.dataset.power_to_status(power)
-                recon = dl.dataset.status_to_power(sta)
-                dict_app = {appliance: {"power": power, "power_pred": recon}}
-                # Compute the scores
-                dict_scores = regression_scores_dict(dict_app)
-                intr_error[idx] = dict_scores[appliance]["nde"]
-                # Update the sorted list of thresholds
-                thresh = list(set(hie.thresh) - set(thresh_sorted))
-                thresh_sorted.append(thresh[0])
-            # Initialize plots
-            fig, axis = plt.subplots(2, 2, figsize=(12, 8))
-            fig.suptitle(f"{appliance}, Linkage: {method}")
-            # Plots
-            plot_cluster_distribution(hie.x, thresh_sorted, axis[0, 0])
-            plot_intrinsic_error(intr_error, axis[1, 0])
-            plot_error_reduction(intr_error, axis[1, 1])
+            plot_clustering_results(ser, dl, method=method)
+            # Place title in figure
+            plt.gcf().suptitle(f"{appliance}, Linkage: {method}")
             # Save and close the figure
             path_fig = os.path.join(path_output, f"{app}_{method}.png")
-            fig.savefig(path_fig)
-            plt.close(fig)
+            plt.savefig(path_fig)
+            plt.close()
 
 
 if __name__ == "__main__":

From 0fecba9969c916fb841e72bc08cda9ee4ae1a4ec Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 23 Sep 2021 16:03:12 +0200
Subject: [PATCH 27/47] Include new plot and improve all

---
 nilmth/hierarchical_clustering.py | 114 ++++++++++++++++++++----------
 1 file changed, 77 insertions(+), 37 deletions(-)

diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index cc2cd88..f2a8fa1 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -1,5 +1,5 @@
 import os
-from typing import Iterable, Optional, Tuple
+from typing import Iterable, Optional
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -23,6 +23,75 @@
 ]
 
 
+def plot_thresholds_on_distribution(
+    ser: np.array,
+    thresh: Iterable[float],
+    ax: Optional[Axes] = None,
+    app: str = "",
+    bins: int = 100,
+):
+    """Plots the power distribution, and the lines splitting each cluster
+
+    Parameters
+    ----------
+    ser : numpy.array
+        Contains all the power values
+    thresh : Iterable[float]
+        Contains all the threshold values
+    ax : Axes, optional
+        Axes where the graph is plotted
+    app : str, optional
+        Name of the appliance, by default ""
+    bins : int, optional
+        Histogram splits, by default 100
+    """
+    if ax is None:
+        ax = plt.gca()
+    y, x, _ = ax.hist(ser, bins=bins)
+    ax.set_title(app.capitalize().replace("_", " "))
+    ax.set_xlabel("Power (watts)")
+    ax.set_ylabel("Frequency")
+    ax.set_title("Thresholds on power distribution")
+    ax.grid()
+    # Plot the thresholds
+    for idx, t in enumerate(thresh):
+        ax.axvline(t, color="r", linestyle="--")
+        ax.text(t + 0.01 * x.max(), y.max(), idx + 1, rotation=0, color="r")
+
+
+def plot_thresholds_on_series(
+    ser: np.array, thresh: Iterable[float], size: int = 500, ax: Optional[Axes] = None
+):
+    """Plots the thresholds on a sample time series
+
+    Parameters
+    ----------
+    ser : numpy.array
+        Contains all the power values
+    thresh : Iterable[float]
+        Contains all the threshold values
+    ax : Axes, optional
+        Axes where the graph is plotted
+    """
+    if ax is None:
+        ax = plt.gca()
+    # Take sample of the series and plot it
+    idx = np.argmax(ser)
+    idx_min = int(max(0, idx - size / 2))
+    idx_max = int(min(len(ser), idx + size / 2))
+    power = ser[idx_min:idx_max]
+    time = np.arange(0, len(power)) * 6
+    ax.plot(time, power)
+    # Plot the thresholds
+    for idx, thresh in enumerate(thresh):
+        ax.axhline(thresh, color="r", linestyle="--")
+        ax.text(time.max(), thresh + power.max() * 0.01, idx + 1, rotation=0, color="r")
+    ax.set_xlabel("Time (s)")
+    ax.set_ylabel("Power (watts)")
+    ax.set_title("Thresholds on sample time series")
+    ax.grid()
+
+
 def plot_intrinsic_error(intr_error: Iterable[float], ax: Optional[Axes] = None):
     """Plots the intrinsic error depending on the number of splits
 
@@ -38,6 +107,7 @@ def plot_intrinsic_error(intr_error: Iterable[float], ax: Optional[Axes] = None)
     ax.plot(LIST_CLUSTER, intr_error, ".--")
     ax.set_ylabel("Intrinsic Error (NDE)")
     ax.set_xlabel("Number of status")
+    ax.set_title("Intrinsic Error depending on splits")
     ax.grid()
 
 
@@ -55,46 +125,13 @@ def plot_error_reduction(intr_error: Iterable[float], ax: Optional[Axes] = None)
         ax = plt.gca()
     rel_error = -100 * np.divide(np.diff(intr_error), intr_error[:-1])
     ax.plot(LIST_CLUSTER[1:], rel_error, ".--")
+    ax.set_ylim(0, 100)
     ax.set_ylabel("Reduction of Intrinsic Error (%)")
     ax.set_xlabel("Number of status")
-    ax.set_ylim(0, 100)
+    ax.set_title("Error reduction with each subsequent split")
     ax.grid()
 
 
-def plot_cluster_distribution(
-    ser: np.array,
-    thresh: Iterable[float],
-    ax: Optional[Axes] = None,
-    app: str = "",
-    bins: int = 100,
-):
-    """Plots the power distribution, and the lines splitting each cluster
-
-    Parameters
-    ----------
-    ser : numpy.array
-        Contains all the power values
-    thresh : Iterable[float]
-        Contains all the threshold values
-    ax : Axes, optional
-        Axes where the graph is plotted
-    app : str, optional
-        Name of the appliance, by default ""
-    bins : int, optional
-        Histogram splits, by default 100
-    """
-    if ax is None:
-        ax = plt.gca()
-    y, x, _ = ax.hist(ser, bins=bins)
-    ax.set_title(app.capitalize().replace("_", " "))
-    ax.set_xlabel("Power (watts)")
-    ax.set_ylabel("Frequency")
-    ax.grid()
-    for idx, t in enumerate(thresh):
-        ax.axvline(t, color="r", linestyle="--")
-        ax.text(t + 0.01 * x.max(), y.max(), idx, rotation=0, color="r")
-
-
 def plot_clustering_results(ser: np.array, dl: DataLoader, method: str = "average"):
     """Plots the results of applying a certain clustering method
     on the given series
@@ -136,9 +173,12 @@ def plot_clustering_results(ser: np.array, dl: DataLoader, method: str = "averag
     # Initialize plots
     fig, axis = plt.subplots(2, 2, figsize=(12, 8))
     # Plots
-    plot_cluster_distribution(power, thresh_sorted, ax=axis[0, 0])
+    plot_thresholds_on_distribution(power, thresh_sorted, ax=axis[0, 0])
+    plot_thresholds_on_series(power, thresh_sorted, ax=axis[0, 1])
     plot_intrinsic_error(intr_error, ax=axis[1, 0])
     plot_error_reduction(intr_error, ax=axis[1, 1])
+    # Set the space between subplots
+    fig.tight_layout(rect=[0, 0.03, 1, 0.95])
 
 
 def main(

From a40d96a34d9de1f49789891836111d4b60eb0a65 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 23 Sep 2021 17:48:26 +0200
Subject: [PATCH 28/47] Change the range of power distribution

---
 nilmth/hierarchical_clustering.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index f2a8fa1..0a1d294 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -47,11 +47,11 @@ def plot_thresholds_on_distribution(
     """
     if ax is None:
         ax = plt.gca()
-    y, x, _ = ax.hist(ser, bins=bins)
+    y, x, _ = ax.hist(ser, bins=bins, range=(3, ser.max()))
     ax.set_title(app.capitalize().replace("_", " "))
     ax.set_xlabel("Power (watts)")
     ax.set_ylabel("Frequency")
-    ax.set_title("Thresholds on power distribution")
+    ax.set_title("Thresholds on power distribution (>=3 watts)")
     ax.grid()
     # Plot the thresholds
     for idx, t in enumerate(thresh):

From 3d24f8558f9ad8bfd97f736bfca225e919093567 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 23 Sep 2021 17:53:03 +0200
Subject: [PATCH 29/47] Typo in README

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 84181c6..fcf4fc8 100644
--- a/README.md
+++ b/README.md
@@ -175,7 +175,7 @@ If you want to use your own set of parameters, duplicate the aforementioned
  configuration file and modify the paremeters you want to change (without deleting any
   parameter). You can then use that config file with the following command:
  
- ```
+```
 python nilmth/train.py  --path_config <path to your config file>
 ```
 
@@ -187,7 +187,7 @@ python nilmth/train.py  --help
 
 Once the models are trained, test them with:
 
- ```
+```
 python nilmth/test.py  --path_config <path to your config file>
 ```
 
@@ -205,7 +205,7 @@ models are stored. Then, the script `train.py` will be called, using each
  configuration each. This will store the model weights, which will be used
  again during the test phase:
  
- ```
+```
 nohup sh test_sequential.sh > log.out & 
 ```
 

From 191ab0cc38e05c885a918fc129cee81eb0c93321 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Fri, 3 Sep 2021 13:18:43 +0200
Subject: [PATCH 30/47] Update README

---
 README.md       | 107 ++++++++++++++++++++++++++++++++++++++++++------
 images/logo.png | Bin 0 -> 108608 bytes
 2 files changed, 94 insertions(+), 13 deletions(-)
 create mode 100644 images/logo.png

diff --git a/README.md b/README.md
index 7266014..d6a8f59 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,66 @@
-# NILM: classification VS regression
+<!-- README template: https://github.com/othneildrew/Best-README-Template -->
+
+<!-- PROJECT SHIELDS -->
+<!--
+*** I'm using markdown "reference style" links for readability.
+*** Reference links are enclosed in brackets [ ] instead of parentheses ( ).
+*** See the bottom of this document for the declaration of the reference variables
+*** for contributors-url, forks-url, etc. This is an optional, concise syntax you may use.
+*** https://www.markdownguide.org/basic-syntax/#reference-style-links
+-->
+[![Contributors][contributors-shield]][contributors-url]
+[![Forks][forks-shield]][forks-url]
+[![Stargazers][stars-shield]][stars-url]
+[![Issues][issues-shield]][issues-url]
+[![LinkedIn][linkedin-shield]][linkedin-url]
+
+<!-- PROJECT LOGO -->
+<br />
+<p align="center">
+  <a href="https://github.com/UCA-Datalab/nilm-thresholding">
+    <img src="images/logo.png" alt="Logo" width="400" height="80">
+  </a>
+
+  <h3 align="center">NILM: classification VS regression</h3>
+</p>
+
+
+<!-- TABLE OF CONTENTS -->
+<details open="open">
+  <summary>Table of Contents</summary>
+  <ol>
+    <li>
+      <a href="#about-the-project">About The Project</a>
+    </li>
+    <li>
+      <a href="#getting-started">Getting Started</a>
+      <ul>
+        <li><a href="#create-the-environment">Create the Environment</a></li>
+      </ul>
+    </li>
+    <li>
+      <a href="#data">Data</a>
+      <ul>
+        <li><a href="#uk-dale">UK-DALE</a></li>
+      </ul>
+      <ul>
+        <li><a href="#preprocess">Preprocess</a></li>
+      </ul>
+    </li>
+    <li>
+      <a href="#train">Train</a>
+      <ul>
+         <li><a href="#reproduce-the-paper">Reproduce the Paper</a></li>
+         <li><a href="#thresholding-methods">Thresholding Methods</a></li>
+      </ul>
+    </li>
+    <li><a href="#publications">Publications</a></li>
+    <li><a href="#contact">Contact</a></li>
+    <li><a href="#acknowledgements">Acknowledgements</a></li>
+  </ol>
+</details>
+
+## About the project
 
 Non-Intrusive Load Monitoring (NILM)  aims to predict the status
 or consumption of  domestic appliances in a household only by knowing
@@ -14,10 +76,10 @@ deep learning state-of-the-art architectures on both the regression and
 classification problems, introducing criteria to select the most convenient
 thresholding method.
 
-Source: [see publications](#publications)
+## Getting started
+### Create the Environment
 
-## Set up
-### Create the environment using Conda
+To create the environment using Conda:
 
   1. Install miniconda
      
@@ -122,7 +184,7 @@ Once the models are trained, test them with:
 python nilmth/test.py  --path_config <path to your config file>
 ```
 
-#### Reproduce paper
+### Reproduce the Paper
 
 To reproduce the results shown in [our paper](#publications), activate the
  environment and then run:
@@ -140,7 +202,7 @@ models are stored. Then, the script `train.py` will be called, using each
 nohup sh test_sequential.sh > log.out & 
 ```
 
-### Thresholding methods
+### Thresholding Methods
 
 There are three threshold methods available. Read [our paper](#publications)
 to understand how each threshold works.
@@ -151,13 +213,32 @@ to understand how each threshold works.
 
 ## Publications
 
-[NILM as a regression versus classification problem:
+* [NILM as a regression versus classification problem:
 the importance of thresholding](https://www.researchgate.net/project/Non-Intrusive-Load-Monitoring-6)
 
-## Contact information
+## Contact
 
-Author: Daniel Precioso, PhD student at Universidad de Cádiz
-- Email: daniel.precioso@uca.es
-- [Github](https://github.com/daniprec)
-- [LinkedIn](https://www.linkedin.com/in/daniel-precioso-garcelan/)
-- [ResearchGate](https://www.researchgate.net/profile/Daniel_Precioso_Garcelan)
+Daniel Precioso - [daniprec](https://github.com/daniprec) -  daniel.precioso@uca.es
+
+Project link: [https://github.com/UCA-Datalab/nilm-thresholding](https://github.com/UCA-Datalab/nilm-thresholding)
+
+ResearhGate link: [https://www.researchgate.net/project/NILM-classification-VS-regression](https://www.researchgate.net/project/NILM-classification-VS-regression)
+
+## Acknowledgements
+
+* [UCA DataLab](http://datalab.uca.es/)
+* [David Gómez-Ullate](https://www.linkedin.com/in/david-g%C3%B3mez-ullate-oteiza-87a820b/?originalSubdomain=en)
+
+
+<!-- MARKDOWN LINKS & IMAGES -->
+<!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
+[contributors-shield]: https://img.shields.io/github/contributors/UCA-Datalab/nilm-thresholding.svg?style=for-the-badge
+[contributors-url]: https://github.com/UCA-Datalab/nilm-thresholding/graphs/contributors
+[forks-shield]: https://img.shields.io/github/forks/UCA-Datalab/nilm-thresholding.svg?style=for-the-badge
+[forks-url]: https://github.com/UCA-Datalab/nilm-thresholding/network/members
+[stars-shield]: https://img.shields.io/github/stars/UCA-Datalab/nilm-thresholding.svg?style=for-the-badge
+[stars-url]: https://github.com/UCA-Datalab/nilm-thresholding/stargazers
+[issues-shield]: https://img.shields.io/github/issues/UCA-Datalab/nilm-thresholding.svg?style=for-the-badge
+[issues-url]: https://github.com/UCA-Datalab/nilm-thresholding/issues
+[linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
+[linkedin-url]: https://www.linkedin.com/in/daniel-precioso-garcelan/
\ No newline at end of file
diff --git a/images/logo.png b/images/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..07dbbaff4d7aa56dbefd08c6af8389fc60a98976
GIT binary patch
literal 108608
zcmb5Wc{tSn*FTO3BT-q(5-KHY$&!7jD9S#>7)xbu$U63|q^y-hWZ!2P$!^9FSt3gq
zlNoCghB0FujO91)&wYQd>;B_@-`D*9Fc<!Ky`ImrJkB|fbI!arH8$V|2mzRwn7HrV
zy=~6K#5v8x#Jt6E{Gb19@;{*e;q89wmZ|&W$4pF8Zv)<H7#-8)i*3FAyx`O+x!bbl
zZlCW0Ex(yx$k3O2#9F8_uFNBmC5sZi^b4ROz|8ft%X(I4$m%nQm-P;BHAQg8<Mx;a
zlK0e&zLkTUHx?BAj_+HrO@0<;|0<<!b>Tc$f2n}p0~1!xA>E9(wO&~xHL3TA$yDJm
zxV-_WYL9j(TG@9F%<fP_Df6;TrZiGU;g6-K_*REEmYiq9XJ1LO^I=Sz|E?AO{?uI+
zU-{$_%RbyyikeX8P_ZC)D+t&)DD{3TccUze^+sotO}Un0X!SkbEBYKsiZXo9UKz?6
zx*XAtw}#(%|E;iZx+q36StNK(|F)bFE^)MC@!T%J(sDI&qqe5wmOa(+1Pc$6Hq7$?
zOtA@=OgV--(0uVS^rp<%zT|iJl?R(150(kfw*zjfRk`C;K6wGD*&pkNr_G<=k5u6r
z>>m0MGa%z;v-xGuW?@m_o#*=P^v^Y1PUF*<O}6U_ZW1}jZ3<ljoX_ss_%SgBT>IyT
zdGdyDKNFKU)4kiemO=I_lboMKKuw2h79g!ut(AmJ9nu^uEHQvfLHwo@vkFB1afyTi
zLA}doPTyvoefcysO6LB<J9eh0ej;88_rPNcRya;`if8eDc;noRI2;6zh_d|9hD?I6
zt<AZ9rKPCm0kvt15zc{BYEbeqW>!VHXTF}`AwE`u+Vs(j%j?W_+1N4bWlLH*zS2V{
zv0$-_ZDSz#`berXg+n}wiG`7mqT6jo-*28h&cd-NaqaQn3YTdrn6JQdP18HHj<hL2
zi?9&9BWy4LEm{~G@w+$*@CfOx99vdc-d)(-(eW5u6f$|?)Mz=VQ?wxV)9)x#2bSD2
z5Y5=D|2g6TpLiI~M9TP9-Wbabys`Us*pVEdhg4kO(C!<$xcp(S*^HN!O)ELBi0m-Z
zEL_S0L;7OE>!?yuuBDi=Zj<HZaF590Iq=pV1TZ)5C&I{;|4TGO&zWXX=N*HDqC+@p
z>-&XPX;bF`ec`6MjmP+25bi;b#Zv5wKHEvUxjwGxPAfcJu?+p8mEG!ft;$lGKOo5<
zpd~BdPyySK#PxR|xT0ZsU5Fuh|MT)BDc}zBly$aRsc|0Z{kVn{CGfM~R5vKYOO@@n
zzGY0{JRo2#gLdYN@Q*(gRlRjGPMV?ei3QGkZ+7a=JCr+4iQxr*fYmaVH_o&20-2Z@
z`B=XU+>!T|=?znqyyiDneuh6p!)mrZWk>gOdGB~9;j0yVRFc1bnXCMCSIwcaykH>c
z8?7d%)ozZq*1qdE{-Ivsw!Hykuj1{gql?x~K_S(su<ewA=v<Pps#jzZX~ToPe0bt6
z*91s<0xR<jmkN@6<;uUdVycX0e}58vd(ffYaZ1f(ds91y(Ki9b2U%W_*U`;C<N{dW
z{#4`GWn1OXDOZ1}*nyk6K&!(7jmsyI=1GInv*YY>m`EVWv-8o~`W>!?)?bsMK_?j!
z9bLrHXaFy!Z@E{o%98U(hMH#>FKZ<LAzD@S_zPcisMZt77p1|L_RSy=Z6HSnHlSc1
zDL;LYK@SvvW6j(S3x?SIO#?&^=1|zYSAJE;m4BH`=eHv0f_^JnEFl%z3_CIFfwc&z
zur1fDyA0kryd@oXib37;_B7KKQc)#7XHp6DBwU>X#I}#)Ew=AUuClO=C|0+u0Ci;~
zH2bmc$vi}w&Bnm)bnb~w^-n2``Z4eWE6236d)--27gm=6^{sF?N5ij;{cNM+eM{6b
zlv(zLEBL4WK;`RpiYMNd`eU1I!=6aeLce7A1y*eI7X-|og-Np+@3g-@T>M#RGOSYL
z3Qsa)l1s;~hO}2%ey!onfzLoncOxTa_nUaO{Iv%e*8zyG0~?51SGIcexf`xYW{Xde
z#{*+xhop6DN4b?|na9zj&rr9m9o<+;$&Xx(g_kc-^Xm+w&8Ve#nY*|DOQ10u-uPon
zc?>Mw12KNl&}s3#x@TEDY*`*5ec0(|y*Tjw@x=vn%KeO+K1=<olR@6b>ACI_3|f*>
z9$n4H?fgsZAk1v!ddr>_8eqDm^`We~%oX?98hssUX3cQXtGPTR4X59!fSH53pO6e4
z24M@RP1o`KW6_UyvRV1i1l!p!V$wkkCL-vXA<?g>I)u~tc@ivZYv<UR%d1o|Hi}o(
zi0@B11|QDE0y-leX02=}KkCK;m`bwFTVdBV4Z`7PAcYc}k1@-v6hKH=9!rqP)hKFu
z1Uk)vQQYIbTS*tns66*EqnftFk2Na8R`6+1C+dJ>YOBS(ihE|4W|DDpO@fWGx<t$V
z#Bk^Ws?#m9*bj0R6wk(o7DmoY#=?WBr($3S4rMr~F6sz#=JMgvhb(Vf{E^JF%M8n5
z=@ez;2A_TmaE}f1?6;E1S5%GV+Nwq8qtY7SIfEm%A2KIyg?8xYEI1TZhQd~kP-<rw
z2C+>JUX0P8?X`C&I1<lZ|9z9KrzG95_(Y;g_N@w5N=)0dm2Q`J`Ma54{>ksn7&SWa
zp&BN_!1mJ)84k3*<KGGks`<keb1gOL_zUnU?%BgKy6R%v$G(WPbQ7rPZIehel*9T@
zCF8DR71ax?+bU^D1eB>0_JsCu{6d6Z^$(m;<3!mf)en{W29re8)-AA27p!#|3{b#4
z6?)k4n7glVPC!bD2L=y<dGNB5zmQxwr$DaP`>XAAKj+B|cxyOst6-ZH8Go*LFmrwO
zgQ<-3it^VAp??nn@p4w3sLNS^Srk!j5kVMKsVo(r(kF-Erf?I1%W`I0Av1;yi{jEn
z;5_PyU6Y3~YwhHU+k^S1gH(eLh}!ulE=wO@vQgqYjk%N~n#;?VW;PQO-!hs4{-eQJ
zR1P$VjhWyT_ztgK{OD~wjB}a?Fg?CqQz}Dg)NP0O1T&Il{KqR_$^v)1dS2LxSFu1#
ze@q$rX^cxx`CO85#F7n*-*Lq_s%quDd+Kc`%CO<)bMaz?n<cD!%A@oguSlJ!cRu^l
zvIX%|D7{jrYG&?(GVz@k!+>!1J^i-2)oUeaE~)*xmcK!XpvN`vry}3EGHPPUd_hn1
z_aN(2n+#&E_%$VZ<hZplH>t+|nUb#OnDu4;DM|1bOOSeU$sUA6S~|txHS><>Ho52B
z`H}mA>B(?WeJl#Eu%nJ8cOj^QqY<o|uNV%NM|7m#8hl+NbQj3{*<@GuS~48A1@=co
zlm^^1*X`jZsscjv8Fm#{`u(&B6vJbH+WKro!;!;UHgW|(*nq?)jU{geT&bgC|9_os
z`k!m6{7yW6nj^-sfW-lI2afJCb6}pP${hsl{IDrqR|8EK=fN1Xw`ea`jynJ6?G{Ng
zdGWAZ(?!HkBg;}o6R1@t%}^!dp!PDM^s!|k3xir<ingW$yN{~4sld>O8ey5u0ALv$
zR!@>O2xoiBZTb4yvC8kdTcVsT45t<peYya>m1aL4=Qkblba)W%83QXvF>4o9x;`IG
zif3jNXq9T|cKgyk;_{Jt^mD$pjTJS*_WME%%i35CT(4}71i0-5n*KSY!EmUl;ujC=
z7LAT#b@}m0+1z2f8V<9h#|ODnSHl)|4=)3LlhSg`uAgR556rBeE{1hOqM}&&R`FI2
zfgC95N~d?HnYr|iN9<p(b1;1Q?Ha>A`syDYToe~)MpXQz9ZGS9R?j~T@!|w?aozTS
zY<p-p2U>*acim<5c|wpV3Z!tF`G<~xY2z|UVDmyyI#RfOtb^q(K;H||JvXAPuK%1t
z{~GF{8?aFD*2hrUA$*{r?pI{C+#lzpix8IifbqKy4aT^hv)l|S0eF#)Y@UCxuB+8i
zF|g%w=$#$;Y}FT)MtQe9Yc13bdde8Sq8a^)7m@0I5iM<(oz8l>NGQ~2hig4JXsxP9
z7;~ZRrMx`FctDUeWnzie7o>zo8l6kL5SBim@s;K6Jp2W?)bB+ifI(NvJH=KOhI@q=
z_~dXg?-{NU33;IP#9Z3+<TUhWVDC!F`;%{-7&iV4y73<eKP#c>Gqa&oBIjx}Qw5?M
z*Rzio0%Dh!)-q}n6MPuGpHe;jVO{o-F4K~qqx~#fjJEoD?-+kYnF$ptpJdqFiSqO+
ze$}Xri71!X3j<8w8K_s8zgr3nCXCMtO}_F^e#3AMrIblOkUrSwFCn|FXEo<f(<aBS
zu^RQv(aez>()uxs8)mG2j;5bMp6t-mG;A-kf~mQbDbnz)o7>n;M(v2V48@d2CSq7m
zh_kWy*eECab4iJ~FMqQw4*hsmlrgg&y7rHUxRif%Q(%$o3rIsCwtR&Yuts@k?YDb8
z%gV?1?l2mC93gb@oZ#VB$aBOIUmEl<MU9mgIoZxJTKNL=R_SN?=Q?>)EbyR)0?!jG
zZnosQ#qvmm;lq>nkV{J<jI#}SALtMBD1YEk&SzTY*~EQcW6-zAvaLQFTWwe=^8Wr3
z@SFf+B8mcb(35e`jAEC977k59pC|e~3p3Yrtkcdq0tB$QCiRlh{9|b7A7O{=enfLh
z{n{#mdiK6Gj_$=TF8c}1_AQA>7V0r5Yd586y}}0>yB8=S%pl9q`-5qtETNU?&ZT9O
zIhs1>!<~V#+obAUzlC4w411cmDU4Zq8XL}e7TChZw;FQ)D^iei5*sQRvf3(w2`yT<
zK~Fjv^tfm|or6JCs<sqc%-F=D4oQe+A%i_u*`QM5i?Q?frx(wjVpR5pfX}3-Le_^P
z&>UeEJk0*<Hs0Tu;MF_~AA&?!WpvH{b-b@2{cG#4sT3N-StWA+ii3qz9C^&misz4~
z%a7v>9$CDP<^3MKn<(lRm@2ID=+?rn95Di&&@N~9r)!CpgdMZMd)4NM<-5$@MHoLc
z2Ul*#;}Za{<Zx;x(izl7{29Q47SXUc5;bqqvJz2idQU4k8t~&&0P&MJhfBJle*fFc
zbenPaoN*Q!LH!-f-XJR_B~>$wf=IffdsJ_y{!IypEy?D~BtT}H8xVaB(wYr*r|$@>
zFC;ySu&|Cr)jeLis$)H1xTlNz_!eFp>r@&ODr3jHPk?G3ig^(WT9-Rp%MK<h!{!}U
z38nm=*E=hy`B69$Jfbwwn(rcbCZX_<#g=ChA1x!0P(Qz7u_bouBI6EhL=SAIVR{Mc
z0b=TpJnuAKUR-CFa-+(#k?I3=or>CFdsg{s1jDh+cYgAASHuK$aNTQo$A_sKEn5K)
zW$!Eey|fJY%y{R~oPP2lsy#@R=z)_dg2jOq=ZdwF6Q30jzbCUXWS!EXNqvEx-*;1@
z*d(xC7FdmKR^!1h*BH!y@@DBN3ur?i<I6L@1vUU7I8Mq@)hxfUKfCHP<l#v|Y<=-k
zbL?VsIZ`Df-cvvT!Mf8t<?Sv>Xb(JUj4d7?;90fcC0qCILFUFP_ES-t3E9|BAt#Z}
zgv_ZzrYY2ThzbNzz9n^)H`t<CztfFTJQsrGWo=p)rk;3qn5#YF_qZEv;nXl#hMzFt
z4<wYxJS)wc!~;C6?p2-~^*JKqn(He)<T9*fk>*kql_U}kz;<YfrR0drB>IJh5U$n?
zO7j6qPhpI@PlMU?VkH6)`bXx3(64B}M(dGkC5E$XAWOjA7xUi^8r9gW&#q~68iRUQ
zfzYcOa724HDbc3%Go-4v{!C?Mqx71MvbIJ$#VP41bZ-xe`?;55KRv~yFhKW$h|Is<
zY}hAFcL=NR3nN$rFcxRcgMa>}@}o5>A};2;GKee8tW#2L^)=o~O9vmnJFI=u*?Vs2
zl3jF-a0r*Oe$@~r=OKuzbE;H&S>MY~k&U(<4uV$Xv}VTyl`eht@gn|~sRgaF0cN!(
zG=LEfbY`jbxbCwmGCRubKwfnDDYIs*c;tuVpVt5kAIF|wDjoQ|$brQ|fK)g$Y2v?X
z!fzMaDqX~HcQ0Q<<BO$arQ+CK@SLsN&>gVU?O!F^8r1R5n#n(G!qmQtu2<?5GN@nL
z?Q!O7$U`phxUb5I4(E`t@B@Qy9E@5GZ%`$W>8=jzWd)Iisok$tQcgHz6y8fdem^K-
zyfMU12r;qs*m&(~+8RR09v3z?l2glGCNxEx%wgAB04z^0pKmQ~73}K_{)Y^VX}33!
ziYl#ior8NeWmpSbaRLuWhfyy=)k5zGbPr}QN@K6f(diG&7>roZVQ0FNqz4<Zl<<0r
zc1DOc0i4rr1-)g7HPdXJ#9|f#rxyUK#o;u}tM$$1`m7d<ji&EBJ;h_8kU9ZRrI+Nf
zP?1f>$!!=tz&2Y{FI<)rA!~=Ob{dXDkmSG>d=4nZm%lmm;7?_5mTeiy4Z>H(GUdvr
zzMq!$Ww8gB`w>SLl>0PYt{#=%4I;0re}6yNw{k32Y-`H|9tJb&jq9T@st+McItaqJ
zbew<E>?C%IH})UT@n**U^c8Im71eV_78{2;3HKkIW;@lobXnn7kp>d2B^Wz9h+SQ4
zW^oM8vcLTIF|(#9{WLl-(B<Pl#2FR2kZ}}cve_u&j|~Qnu9NnsUMwaB`aouDx&Tv^
z%T5w#Lw?P{qfZ-LI%z4;ds)l3qN^5^zjBp_S<{^DONo;ZcnB<jWB^QInB&?sq2ILA
zeYkyVvh4b_Kc>O-bxk$5H3?ZtbDoqA!nCH;7qoOea6bw%DP5QkW^2WOrPI!DhELb)
z^!L?%QA+WaW^K|mI_6Tr=qr;Xf%McS)G#!GD~1gJJ!vT@?dI%+(8s&f>rm0b@8bhq
z5;kJ`o@~b+qU8_^Qaf9<3&9T7eMCM*)m1~R2Ade!l4k$+a$6L`QZ*EJD;p0~9ly#2
zGtF2rj3pn+Ou3A;Td^XWQ;EK>^=SBtyx+QBRnIjWHogf@PDkYS4L_r;Xv{|FqIEc8
z<oJ${)N=j~h<t2GwmFyXUw4k{Z?<3P7P2>uQG?<w!vG&!W3q-ZHF{61-DR*XcGV(i
z1jYx0bYoWHnrXUbDnvS=`e@V+wlblIxje2c3~CKEOF6XWACG5MOocchLae3uEQ1uA
zjdi;b??_1qh6#~t{?T3B(*bPch(G&|3qcwnc;?oTSNyS{daWwGAk6gN%&di`!i7Iy
z;vc!XE)4RWK*4!gGkxW`_O~J@&!~^sRl@W1U<zdkH~2#AvQ4e+1Q^W6n4;mFe-y7_
zO9%dJt7=SJP>>X>7+APRK%|~zlxtPUp|&(wpwZQ8f1ripMqO~-94C0SNKU}ozoGbf
zHAbli*VFPI>X)YCo!H?abpI+COFHrYW&!ru{1)uq;&m0TF^uzLr`*uJFbjNxDP<MF
zMh^6mtj`o3HtA^Qr)YZD)7rWTFa2BIV}j|?brm->VA^|4KHPu}O_Y0Ya~v*BXQdj-
z<ls|jO{W=5dzo0i1C*?GynJbALGH`XbZ4_!$#DP2EkbP@b!;RXFGJc}P_r*wzL4aq
z@VbB!$_8?qD@z7i^XpE>zy`~S5JY`e9n@8gVH@jt0i1h5KB)tqz2=>~@to%j8nNE8
zOBAT>;PbLuDXAx0&z~noG<A}=)cFOnY^2jxs|}%+t-|<smizw8FG9ka;apQHwKD5o
z49nC*X6WWD%Iso^`XKF-41b-s8}zMkfhyNbtYj$>CcJc%O}?z~^g98~&l_r|TRn)-
zTA*n&qb1}&gHBmuQ3?ERnvt*4f0Gym4~|hg@v`8Qt;J`(1+M{9ki}1`ipEnmriq1n
zEIv#M{>Y))*YDiHO<E`S%V~X8X+3>|K7IYF2cFZMXL7eR$<H%ELv;bt)DfW7uOIYM
zW@wVUiTO_A`rD%ThUzEJux8zPdm?w}8teiP!VL)hUc%Nc7lYFG!v(F|WLAoj?VrK+
zi68!GR6u#?Z9fn*`ZB1MR%P8_A{m9t1zl4h)LZkDSAWh8mSxVg(l)dQ81AHqLs@pG
z1IIQn72>~g)&gr-$?sZ^q`Tfq&jha~&<~{j9cD{AZ&^o@W$VFs=_+bSOQ7*7mo&7H
zXV74Hx53pQ>flOZ&f5!&*1Htj=rB5PeOc@np#E)^lKnPvIm|kXHvI`S`-3fZcCWdG
zuyLT{3$tq|QOU-Yq=UVi)Fwi6!>e%HHDEU`tQOxlndwKCZOdM4W5>w_i#}S~=3h~S
zW{s2u#tl0j7|}uZTvc=Y>S?Gdp+HNXa|*kcT+5WxM2oHDYXj$WlU(`RWL9g)FB}pA
z?RfbDt$$xbMwJ5XE9)#K9VCNFtNIGA)yBhAi$dB?Fg}M6!SN@EU_*|y<6W86tIr~J
zhrgM)3Ly*{({JZ}51G0L38weHtKP?Vo~h*~HAv@c)aQi<XpM1BX;l!T;^@+*?NthB
zF^tuwTG3%vbZNV}E;M<U@s5`T(JZ9jg2>6|deWo`g94fQsB1#=f#XymYQr+SZ|wa~
zp8S-lwE@_EFAo625=7fmFN<>3;4v@;ufv%h1;w2QQ&zX{%St`J%^)oS%oAhT<(d{%
z>GSI_=*I@uoUwa&Aqba}CBA0S%<{(DM|UJ?HF^0kEhsWzaVDi<QfSI|B&jv`nonyf
ze_K}G{v=22fRHa2-jH&QgN2P;kh>I0@Yog$cqq`!@EOFfNAE*5G+a_!inq#d26dZ7
zMjLLS#Lt#r!k<uecgjC}Zs^6ju`tjC%tx6>JqxUg9b9oMg1SMGfb+JC&yqw0-Wz6H
zt$Eq_{<b^EaJ1Uv2-;dw$+u70{j%_~k_uT6)Fv5b)A`C*!ENaf)K*mk{?4oc#9+CK
zJuE4)C7(V^1eS?XF(Fw9+(lSE@B5{6T*)r$ad6gnF<>eiJ~T-^?jOyUy`Q2cH&xOx
zLD8GhC*Ja{c&T!kGRfh5FKg?UUSEC*q5SttnOlP`MRG_7={sJXTr!jJ4;JaMS2F>(
z7=?wqcf}oMQRN9!5~b7SNmlsR6o{T`f1bSOvYDGN(h`m5$Az^+lw_#IoF<=CTCRod
zPzJ9?!Qk+(P<!clzuq(tSfIn=8g@?+%+Ev?8x1#)Q`J&yExy+L9Xia{DC(cJT2^oI
z6$ZYOL(of6<-DkB<q${9k&y~(sJAW4sbRAJ8SGW3eb-@ld62kuB|e{)j%jt6o^CDq
zbN-=?zX^1>{=T~-qg-#aCg&g7u!fzm1$K+_ko0!&CidDN8ACVGJR+>2_}Tl{C)~S!
z*r24NU?q47z-%xakbYOE4&zpwnG3A~OUI^2g{U^v)NH(?M>=ycrBENUzT+JLFB7@W
z+n@#limy3)zTqQF&;#2GMyI50T<1x@<D{SBu)o>UZk3L+yG?8!tw6_CvhI4X$Tk&V
zG!e_wg}|xYTF$kk&YnqaU;G!>u_gcyquHmT^qXAD<oj(Xe@N4v@9F*T!}5s`A@93J
z*8}K5;RDKXkJDY`k@@3Hm2mx`iHZGbz)Zg-q4Enq)cgSZyBU&?8U}0y1fSLC5**N3
zn6=&1_@!<C)cagv+hjz@kwIEYXv%7rs?1aC&jfRDmpU6|?7UBxS9V@@>~e_uSPod*
zb<#pEu~a(5=Vn#SqM;#C4ip(Vw1KN2`l}{FA=_alxcOZ#)@1EISpP-+J|8-5Cd?67
z>kl#?i8Z{39Cbb73fU1WzU<&HIAAx~&mY8KKcXxXsPOh3e9J70>w(SaUzSLW;j>d{
zMAA-MX!ZNls!Qg4TKV-U@M$e|O2QMG=s&IN+gNh)h-`_}iw3A2sK347+)ZghpT|D(
zp)B&}P9$=zK_NrcARo7RUS`lU*l4E7gxIla8oLq*Vp1@bR8K1&$>^WfX4|T3h?+EY
zah=svIE*wFGlMv3f;wxw$Rjn@p7*VjZ@Q09zZ^C|PHPm0e~Jmjn`=%Gg1^e!RzUfX
z1WUj3k|RJa+}6TFH=VmbJ;IOB1CjT2(d>1|$T78srU7MYQ-W({Z{3;HTZ{l|bSBrI
zi(#tnUpWL>RlhMOy`ez*$pz8=ZtgXCd5VvV2T{pO(;_|K4gXboC$?Vdl7CUVu7Qkt
z?eqD#VYFyvQk6(EIKLYw{fhb^iApt`>WrNp4ysVEnuqK~WfkR%Ra82tR!>Iohb&9G
zl?oEqW(6PH44F76T`o1vOLA|*9K`0>ukZA&z9eB9W$Q|m!3*EHREM}>d3zd`(1LIE
zL$2uU4gRFMo66&&sd6joa#N~}n_qHhsHt@>wsoY{A~h$o|9LV)p;{crvelDoDdyi>
zK$Y%aH-ZE`6zRDOe*xMum<qBEQx2no1qF2SDkTz<;wZ#K5U01_;0BMG-r_SYnlW@9
z|5QQ~p=eDmJl$Bc<^~?`-h3R8)U}m8-<LjJ|0l*98yTg=R6abJgCE<v-Lij_c}&$M
zi3KKrt}*v>-)l=?-a2~fiFcVd<8KF-#~qbc=ctC^zhs4E*kf{Y(9bLu*bUtBlRxw$
zrTG^FNbKkVl0ama@GTz1_+&0K=3R2&i{gb%OztxK3QKIH1*H1=G*|x$BNy+91M)1z
zCO)8(Q=NdP_x*~EV_@zM&DPJaD_phP@M3dZy-$1Nc^#7qCcIQuRwf}Z6~j2%XuSom
z!e?Il;_;g+KF;a=m%2cl6E-@<=8bmIC@^*qOWeip`VHROQu$i-iSWhwD{Mq*>aiur
z>$!4#fbHy!KDXk7=K~S4zj<>MA7$r*^UWenB+#)JOXNbuUk4aZDqk5CTiq`y^!GEd
zAe1B8A;Ata9+mcC3LN7xLHY1mHR>^~hl}!VEjj_`PjE04Bo!szY~MGWew8YaXqE9>
z0BY7K10LA!Pm8}H>uyO8G!LIz?07jzcfBvrrL$9ALIYDC0_|C4z=@Oi^#FfKe;mXa
zeQ4Pm8tyiTsZz>{D7Ta*s++*8G&Z+XLx_9)GFB6`q^fM!t7W6-2M4@4^;J=Ye2rNo
znitJ*Q9gm~8tx^<lG9`s<qY7Fx2whnJRPck3i1$iEIUT8tmEoW=oqNZ>8=%DNRzIx
znn9wfK`d>UH-*nW;?=z7Wkl(0xlK2NBg?>6wl89stY$Zz{%xE`$8Rl>)DzInth6(s
z^sy78JPPFDejQ7Y*fYWY`vHvzT+^lfNAyY0iy$Vl9H4`gkK8tY=;f+4W#yncO1-!*
z{_2KHnj?fNp~*EKz&&cO5Jy$t+L6?vy=V`lE;nfeBoVd_rgOu$$0HrWoDAA;AO_|^
zBrkRlN&{?7E9y4`H*^^YJcljEf7`WeMF{1bcL1N5d<y#7=aANOmDDYx8D1~&)X!R)
z41^#$6H=4)R@E^G%JzNS^|`eGTy!^M^%c;YC75G6yM)qZ<MXW0DnDuJc5tOPz3uy6
zPr+<6(Rj)LOFq9!d+^DL<%Y|EwA7`BYTE>iXsL?5M6>D=?ZIdlk!I%6ft3Y4aknIO
zu2{ia$~JPWLk$;f+7>zM4Cw6LBYL`A-|zl68MIIrX2@LEghvKsVF8mMK&G?T1+5b|
zb5iVuT|krzRI>S^u~^{n7p~BoT3{0~9q&dNrQC8|6Kk2WJ-cx2R_^ilTzc|pt3x+0
zHzkkl$BNVhz^>UcQn@N#d_$s4`nb}N?xRQLAwSvav#x)0mW9fk?Zb2|>&iR$0-F>c
z7n+cswbDldt4yVK(hP$DxI2C63Oov^KLw-7!Fk6*Bb@qPnf0&wJ3~#zLgQ@eP?`%~
zG9b$PQ!-bL$E%x1veioh#@C~pi~sI_uLlLqBKCH5RHmdgxy!#d0_@S;B=fYFn(cD#
zEo#d4Cs-NsKXaLX4nDfAdNpvvwazC1@##Ij_`z=5@7rcI@CW>Z0fL{NN=Tn%-Q#;0
z;MJE^Yq5v}t*y>^z9*R9X|!V}ON*yT2X)keYwGh3pw|<%HGUU$pC_J?g<iRDe^W0X
zwE;1`X$Us<^uKD`W_>IuWoa<g<SJj7Cw}KF4@0GKkx^TH$q&jbxni;Za{P>vKFgI3
z87yfCinu4(GWj4=%%7%ia^Z7wRQ<=v>l_m)SuE5wP%l*3kTSqg@g<i(!LIzli(}KG
zd6ZeK%%Etib&1!Ti-Qz;hrxjGLMF%+B~dCBWUYHL;PLKM5H#TcN@tx*@9!!;WJK+}
zWlg~P4w%`FO6(;|Z8-wlz6XZrzI4rUM?StD7nlNf?1=^rvd9cV$1hSQK!6-l&6kl!
zZb|74bxb*Rpx#P%huQ49CJM+m*n809YN+$KUxOM7J9_9lLAHWJQAX0`i!^V6z&Ms5
z;gb7rXBp}X0^?b~h+;POA<c$*0kJ;je|k;#PJe!5WVhQpZ94uPN>k6q30ni1Yqa>A
zY5Db8liy=pb5^r=w%vz1{$iTXe$+LRcs31ULm#s+xgPNIHusJ!bO8^VSM29H%TB3a
zv3Dw1t*>e<9DF*1lG}m_9Al&e%R{n^b5D!HjCFkp2;WSQ2}0&VHji!_HO~EDO7n#b
zWlV%iDyShV2Bu?5@Tyxkbsu<&^*tvW)u_*ge-9wosiez9QFCm!b@DJJwN+Jb>k*j~
zA%JOT*Hd$HZU^7Jeq|h~=I#0_GGtRqiNL@PSnS^|{y%QtEi($8ybuw_qk5@1Ub=$>
zOfGq*_W0?C!Bab=n6~gzAO%SPHHa6mQNk2X&Olti8-byZT5>nh3R2&;2O2Z&tcFun
z29Tz(n$yV+KB)v%r0T^3hN^Sm9_trj%m%tY?a!|~&t>yKw)@kS*xXY#o$WWH8bFZ)
ze?N7ddRQHl@PMxw^$?n#1_4*74E$lgHe$%6KxvWVw?td=Q--%{l!_1J_Lz_KMBWYH
zof`9tg}F3jW_Ow@xO3MSB4vQ<|7b_e`v%BNXy8N5_vuTow|HI2PYE;6xL_-Gr{BNU
zbzN@n6NIY$pdR>fVW_L1Y%AF$aA5<#QZ5J}rLwyUg-5{-`x3fSNThu{=5O{)jN=VK
z7dO;6?${l`jGF5B1Dp3q$GPS1?^K2YhpAumi8yk>gIZBX3zz!q6}!VOc^$oD$#2KL
zlwVUkcG2aPGVj?_FDm<^sUOp_KMYvzAdiQ;v~Zai%J5r01)zD#Y-c{EM?@U#nYbI$
zvbJ{jr;&VdxG$j(pAGTYDn)nHXmIK$Gc=ZSkK>72Si{?T8Oik2ZxAztXBR?{y<*Jb
zn}>g8b8+q_z>P5a+_D84=&DwA=O^m064d!!dgf{vti2R=_Tb}T%Z;x!n&dNpN~nOh
zS{638A`#_DnCO`J6MOZp^5sSsJ0XUU`uHW&vqR(V>T2tJG2)@=C6ecM9@a*DXxTtJ
z?Hv^!KRlFfeLRc?Mh}>IJofi=Umm#0`^#?Cx$ZdaOBb!6{kDRdAo7`!u^IeTp)E_*
zCym1gfGIgeswtI?(0}s&HdgPQeGU1}hE<O0YVxToT8C|INb};FQu!~2AL6>cqAJ9W
z3wviRw_=08qLi~ezi3N#G1h;>p6c=18MyNpeya^cq|3#bf47;Za8_BYd(F?FG0$BX
zw16LpEuPFKlgnQ82e}evn#*K@1n=l-$`4w|sdy)0Fl8ILKh;v2uac-&6E_3}(++>f
zd!7#v9JIICQ2SHVA$&zy4O^{wi%^2W)@MlusW!$cH_#UmlAo@3#obX|=<J+3DIB^!
zSJ$d=u>mFEvw$43J*hV=(8k5bEyu6(+jyr}c{Qt)$16HWkRkl|V<?WA)fnW42~7O%
zsRtIBCM>Xk-q#Re-^IEIp}w(y8xVy&h<DgS06PiZ{TPy8jsQ3~C;ZqMi>DLF-G9ah
zd#{C8!Gor5wph;=w0HC2M@FXnkip-w>9ZKin>*>N^B`E0jEkS&Nk?TWKA?uj9W`2L
z9e~gB<sB1hn?Qua*(kDYzeE~uJqgZ0M%vWT7B@n2sOMuX4I1Ccxt$!lF`QBZYW17K
zApKs{e-BjHbZ_JQFTZ;Nbo}MI;DvPZDyq-VJY??0cc(3^klVIX%vTUqCB&h%>w3^M
z+j%m2JN*$TE)Xt2vX|Gfw~yGb#n^`GlkU-)_x5e-j=GtN8T5t5e=lar>i+>*L+$ws
zqh=)j{=ZwA2Y4i+-OhY2S1B?a)THq+UB?hA2C5dyCk8-f)ww3<bmU`ON$u=Y3$bI|
z+~cVNZA+`l-nY`A1c%ntiRm=Mn#n~coXjiON14FGVTgbHf%&^a!RU0shKdE$;)z(H
zxXw+r9*-@>$!`vdnDt5cqnOoN{)Fy>kkRicI&Xuz(@rL5dtUt2;BtV47X~fcG-Ss#
z5D<L?PpsU*f5p~oe9W=S70sJq>{La49ln0PYWtTh^pH7G-FD%Xk~|Idy|ouwj?pd(
z%vEOFkge_hKetVu=!tjCqVDe~_F!0>W4yk1R$f*(OWJQg1?Uem{{FF{^SeC4%39jv
ziKj*2a-w+^^=4*{{YXH3y-X#f3v6;Ay3+ppEBrI8MlZ-Az%yRQC;dmFXR{C5EN{l3
z+Y>bos~CRAiw-Rubj+zH!m^8dlHAs(MEEC_Admk#B5#yYm6V}Hj?2mT<X}^8lliQb
zuEdV!XqFQ{2}=6yuwxI)TI)z2*tf(}t7qG!)av3{iYEmooUv7kp^G`9g<r4GQdkrb
zBMWWT?gzVZ?BR-%elaXiFtHa^ZsWYrixV{u(jiP|cBc`9S!kKv79phbbsE^ig1|WZ
zbHF_4ur3iZ|9=h%4NJV4r(_qG-uxmz#P2V2wbAOJvb040@N<x{AEp&1^67QME9@H4
z>I-%REd0wtryg6fHA_2F3z}!eP54*RI|#D4>jxi*0U0SWEnk8rg6<up_&yQ=2~sAA
zNZ_0gVnFzaG<!uW5Qar9uEyl3+Uqc7RaDB3Ppa93A(vh8F(?fepPhj78*0R(BK4H$
zRnIFF)quKCQnOJ}sc-;@OWx;%-OT-#`NZhfB-jZ{AhR;pD_ilfM@^*CDsQ310P~PT
z7ol`z&<FcabcNcH&GclEi%wyKbfPPP;QN23YXSUpSd{lg{BCy^IVU)DK|g-#j*}nu
zvSPr`EWQYhTg-WdP?-^=G^{zKvKJ28t0so{IF?eF`@OxX<9@9~b)2lfVE+&QJ9+TR
zRQW%&srP?l8n$|U?W;3!UYnldm9F_+Z`r&Hl{*)22j4G$`}*K_q<=%Kq^DBU?dED7
zZ`p6cP0)!ou1}~kxwl@8QvU^fTAWg0^{MtXk#@d$nV`fP>7*pz#If7cU@w)0cbXN_
zQvvgV3GG4qa~1kc!Wmco9WAe({s;BdSngkKetTT!{Y_mpd~ie@yyKuMbUrP&k^D(z
zN3QsCLn|1!2RDbHI`dJcxGK=%>K2FRtstK-Ps3v=#<18DPI~|89<mTyKkTvixbyc1
zfx(32r5`_6i`>DcGCdEG5!CN#3&}d(-)g(xwUP_m`~-I*_G{7+7f((txsFf&3cka|
zW!-A)ibQ9e_~)=~rfhujBY_L6S{`ENv{!hQTP-fhQ{HJuQ)XTcqd39&EpYh3N4yFD
zw@`TlKWFLxBUgFz=sy|C!kqMNk#T`n>DSizJ`is4M9k<XVQgn>*#M;nK5b{Rns<U?
zC;l#l3pW+8O>LIhe?<kbdq4ghimfl?2C%y|>)=Fms?-i2wfX({Da@jyj{XjlL-ew-
z_$k$m-gnL>!j`L&3+9wRFDaj$IKIY{JGtS$vx^veF}M3o&|+RRg#xLwYdZO#yLqzm
zi3^up(JtFQr;PAbJzWsNnTWMHs+x%RMeC+S76qoo1es8m0iRv~yIB2mTbsgiOQC<_
zhzqN;wcPP*|7NcDIG?D7Ed;||c+;(j@wYBXehWzDFMHvqm!`9U21=lBLHI;wv{5_0
zf*&xe>MokU7MPO%tKD&@<w!{~;$@R*?8dObo(-7I<lYUPU$!IwXisB2;C^fE;O;!-
zMY=$WgTsh=LD7Vy!55axPqA!UTd8oBMz_)Ledmp84F<(Zh|gXJnx!Xn>vU`zBx^s`
zbj1e#_c(M}d=!h)Hv2+^hd?8(C^Ke7<QDJeqb{wy35@)-!_u0w2TqE&)`J5#U&&GQ
zVCE*bTSG0k;aqj(rk@9(yYtQeh+kV~IhFr!7T|xvR`hLF#ZPZ2IiQmTsYKZ83BkJ7
z#pc;sDZA<5uSZgO+Zw6?Yc^iJ?Uf-SLqA<@D63Cn!w3A$G6rTQo1ZrX+YVieujQ^h
z;%1|iY~E}TX{GPDunUAWScm{FMy4+sW_g<hkCwD0S=W8Nb(-{))LCw5E9@HbpFT~`
zmnc0aIS*I&lSWvibxo__X*6QBz}9i9o^%k6PhHn`kV|qZCJtmG=Iw#h>e%}!50-AH
zTuo6Z?s)w0Uu+i`z(%h+5(=*H*W2FlEp1l4Jy}(+@}gAE_M)mWbKMAEJ4#mqeS^Q9
z@Rxf|Set0cMs_L3XXk!|%0rXi4x5_YG~WPM$hoD2bfA6rzx6px4*w2}+qFO6S6B?2
zEkIt#&kYIoNr1YhPdMfF1y7uw_{--C(8|hvRQTUS*$F#fG@l9Sz(Z#Ql@2fWt?@j!
zlNQu1&N?;{S^}TEdXzPK(xRsFj~Z`JK@`-eCD@St@N!b0Ue&)5ZNOU`Phf;`sW5sQ
zcmdm0;+ysJWn=j1Pfwf^y5B)Zh~CA4%`pnyGB04oAuXeow!sa;+P{M;kCuEW1LoIl
zr1J&XDZk}p4dA`g)*xoGJ5)Cm8dFf-RBIhSRq<;Qg_DZxDfwAvBY>J5laenHd*8yM
z@Wn$R((tn@l+#Nmg>&09#YniI?poNr$tq+w@8W+JI>k{efM9OiVv1!}$@bXFz$Mj-
zxp^NS)_4Rh5SMrH@3vznek8wEifJo)Z!+8kd(hk6^Ka8+(QppB4_XuLRx{%iEU-0|
zpZFzu%_(qcBb>Nk`HNA#Sc;}Y8YL#R4!Zo)Yli~nvnN<fh=CA24=Knm{%aHOfg4=Q
zONUs2S}vUxb(e`;YMLDD8htyes$Q}m43z0i5F}a&Ppu?9gd}PgI9(RRY)qsA%F^uq
zur+bbjPL2s*2tel4uAS@4Q$HMhxyNDZ>iO#Vux*u;pEqUs3*XwO&&FMRtw9^P4rpH
zkJC$vHJTiY_LF)WJC3~z>k`7H5ji<`cW<6M&%$v@{GYEdC=3|Sz4C0SNL~$gIHAV9
z#`7qZ<xexmCCR+O)aBIXKo;D5%_U|_`PcMsnGl@0QFCPViT>*(7e#Hjg=_G_kVEv!
zOR{_p#FD=@?i2aJrLQB?^8=J%A44Mv)H_9moQ8b8ATcwJDny9ghck9Ql5)jEF(pvt
zbD%cQqsC>oa5XxUv^-=TQP-JLaJN<JLI6(2l0^YuX+?yq1kJ>E%K7PMqo0CUCKumL
zwPNjk?Q0_xaaAKA?#~FV-|{!Bji2X%|H*)(D>$V5AGP`)#@J@zU)r359ZMOhFVeb0
zx>Pxd+YG?y-5ON+%x+=Q&{i#E|7KO9YfeKSYTVoXovv^3bIi2qtRtC^Mpt~XMrWF&
z1@ACLdvH)}%(?F%>Dgt{g*I20!V0C0+u~}>+6M1x=6kut^B^2I!fww(*2c1JPC7Ve
zw94PAs;FZluk>`_!6*CmVs$Cn{oVB!`bhcC!ljagnw}3e$_|fdX4hc~zNoSd(ivgk
zpAT2>?%m(7Ip<yZDYfJ8X?z%(=Bs$I<Ubkho2aN5aL1@^z*4ctLfI*_QJdOVBm8!o
zKt|ZZ<sf~v+aDcac0$q7oQpZNM<JRKj$}AtygR)c+`v3^{a>;IQ?BS0E6fei!6Q_?
z>WZaq?PY*F_IF@@$`jTV>J@>N*T-Tj;SsQG__Sn$oSR}QooNgoB;}7|uAYn@uT}Gq
zb{wysW%EwdR-l@7!z71;yEo_Q^-}28E;`(+p0(-)x?@;o&*lJp!D|<@h*NGsEMMy+
zBL@44L*7EowIn%m#RzcSv?bu(N`=R`=}DT!fV8^}!5nH(*D@M-w)YPE?v&srX1Z*A
zTJF3V82Mpzd)$a!t?Nf?rN}iky)$Y?P{a?DSDcCbU(>PLrFB{$2L&@pP1?dm5sp!?
zV<fj@RtQf)?g6416<UQS?*(g@{@ZTUN4}oG9eDs5^kTuiIH;@Xm6FM2GVu7Mq-ptS
z0lqP74ziKgdQ1vR5_<385!#E05hD@!g6vCuU(z>WYEJw;|MDm6*3{bx4s@13>A7EB
zPY!>4(s{nAj_*zL8@(vG#$}2AAGQxt==pu-&{(f>c9)|D%3>AAv)!L`s69TJ^FDgD
zuQGu294kBHnszr;^E|FoPSZd3?`V$>&pn}ToYl=`$ewRbX83$hdRs~6KrFrMqG862
z2Cpk?xuohwSI~ENhw!<u7i7ht!s}1|_cCy?6<FVpEr$#?pG`)6$|bpPMmF8NL1mFN
zD&A#R)7g18^|yH){Q;PU+pZ;gvXY4n%~k=XVjoe+n+?vEj|yM43-euoyv>cZdi3+~
z)9ZHO$#>@zB>#5Bo&t(fSpZ+<KpG}c>jz_p6|EZi_Z*6sF`xsx+Z1^TCy13(MG{ti
zxPvgtF(qk`{ZfWpt~*h&g}I$n`C{br1@4<K*IQt2T_uM;5iW}Lk4^~w@0ILv**Bz7
zd}qzASP8H5l#1YEEbe@-&ba$1R^H<=9^S6$7`gf5Yw|q}m{&ysjPOCqT<u}IMC+he
z^*gWYqTnT~(2+L^zed<J$>iq4>;W!+BUr$%k@E6L?I~ZYLfN$Vz485EVs{@C{X#cb
z0G$VV&%;spj~>{Gfpt{#RH^@g;Em^RtD~jw{w^0qI89dt+I77gd=_{4S>jYg)!326
zEz}9JzN0CN0TI&wJjC^2O6fj?@L}R#<D?fGof@ujUPBA>#Xro>1sFB8;4&UYvNr2!
zTOD}CtS%kf+xSrNsqn<e&b9cdCu!uH#4Egkof;~X7B|#4eV?!X;g?ZjUHNsIBK7l6
z`3@dLj!k67EnQ=0<)trOu=r+sxVqgI1A%Q~-yS@`-89BoUWFuIV&!Ybo8u1B@SPsQ
zl0VsT_gmUrgl2jC73?Zq2*bYOrZUWgcIAZbKe8t?um2l!dcfZku_G@_pL|P+l&W}t
z05Cd$C=c{i1Dp1;$>1$i;f9hK3Eu>rX*xyskrwz{Pjk-pHkigG^><QeL-3&dG9Ia1
z_`1&!i$TKQPx}bg(-%?;RJjEW@_g8OL6nnk+e~F<vhzGEz3jd}aYg1~Ew`Sf;A!tj
zuMw`dXB?9@<R=BidV7M-xx8fa&uy{jn3gQG_*JZVn0PYR>EBM>!u3Qatf7eH{9sMh
zXD9hsG@9dmg=11fYkkfG6>-olh1iyQZa@y;m9x?-&@IFz6nv!sUPZV(p0b=#eIGm+
z(Y=cgQR#~_F9e*@E)u5FY;ul2Heib0<dRZ?W$UYXa$Ib&!ZkW`kQXYoI35PvsLNfN
z-@xiqp9z_$mPCOtG@VH?2W#P}4Avjb`Ybk8=hLz9aAjNj=Kp;TC|Z_2Tu?30lzUaA
z`emhSO_+@0b{&hAvyAzyu+Fc$)J@&sx3AmX(4`X)`@jqRE6t0C@tcuw;IDW4A_ZJ_
z<vVVd5!0RL%uwJtjcsAC?}=AZsReZF0Jh1!`zrd}zwy}{@*K2<L&|h3q9v>WZxEuE
zl+L?@=I|Ohc(<bC)z&1z=I>y$NF6zsyYH0QU6wc)J^OFModnPaAr{&RmT8ORr&<J(
z(8d!Nw)cmxC)g*8nwokLSB)E+KrIQs<uuiZlDyteMLIn{f0tRPy9EA#EZlNvjw95Z
zYZ@KQ1(CQqbl?#4s;vSCR$ez*W)QMwxWPf>TLly`?#aHUJvID1O7B86e%u-NAmnCJ
z>8Xd-j;i5)sMRc<_84Fq+aVa&7lQ5AWaU7hEA0Md6mb2*8+x(UooHPvu2ZlMvG+3i
zdy4BtJR;ajbwL%Er)Tr!ugrkw8s857+USc{Q<9#OIIJ9vJ|is8G4T*|@qR>TtrYrh
znn>hA%w?m4EoHPn`aHSc6XsE-11?Y~Cr)xLojqGfPe$~4O_|8nnG45`eOlHEnT}`1
z#EpdVng;c@2ew+(h+m2fSo-?96vh7wIEYuNEiLyU`x|{rea_p{_o1?z=g}(q-}d?L
zwg9!;Vb}dOFG96w{vsJYhHV$O8rY9jWC2C?tMlG9e8jApH~3hVKZdGm+`mDDkF`}v
zAd1v$`=pMmnFnyB@=VKptk%o@eq(cY-_q`$yiD#O<gwNuBn%U)@J~G#ZOgUq79~2R
z+_s_C!p_WAvOR26zeNrWy%}42YSF0eus-wy-nlt9lcxR=cWUtgkUBIF5>B2P_&(%G
zbJO<j9|}4r{V&<akV5qS3$nVc*jQqfPei`MnT1QN<_eAy#lWranvp4^DRn8#9;k7>
z8Pwm#yoX{7>%QwOJ_l-Cw?piq5fT$W_pD=A@uQxu#ACy2gW2%S*kXsWy+23IzjfX@
z@P_<TFHT84>k!T*(znV(!_x$5l6j`Dprjr4x*yh}tGE|xSKXs8V!u}TJ5=WS8`$aK
zSc1z#tZj<W{a0|RV*fJw6Me|}=SrCCMpA*Kye#r=cw=FtXNOIayrV=O5~5z?All}K
ziQg?>IcFfm`un$^Ef1T7C)E|$z1hd_MstY0H#cBm!|V;EAcIP~sA^EvK7nNSMyGSf
zSdy+jJ7OyB-~M%s6-@OfoVO(TYf;1NPTgwc^S(2)#X|mhrh#}UbhIb9b3Piw>OXyA
zL`~rLj}afsVEf?AGk*Vq9>)dCAd~`uAy50=ns!4Si@MLYoBCoLmt;)o%Wr@N9}58&
zbkXA{Y-DuB%FWD`_OT=4Jn{Kj=BU3?@vsORML<I*mRS>}#^uwAqS>7lou%umvYb2n
zpFFCHKgcCYT!EVsW~{&^#ri0+yZJ8ZzA5kByN(7B>hVcWZ{x*1JC#<JI5!Vr`gaYe
z<UaRPxl-~k-wD7i|7Hz1xNJopR=DHUTTs<xzGDVz6~=;8D(c7I9dFIeh)`x*86z1Y
zpaqGeA$zMjSag_N75^Rkvho*cnoe@Gk}6ezKR?DV-@e)kHCOO4dv#~GW^>ohoT&;#
zZCJR#ErGdC^tU{nAANXJHti5u>B0juvL%;~xGny(?eK~%5c~`Wr)OyDyh+x_eH9l1
zIi*f0o2MYnH8@h~n7g&*Ugz4^e|Wfy&OFF=0yT|0NLJtr4i0M9;~Jrr@S{WDLad7A
z$h5<xi$@lGez{dmIbT<VK-9u5=V&-??be(>`;8WC^ce6bAi*jNmzLC2^y6PzP3ux`
zS{+_gge+O9hW$tZ9jr=OOOG`pEzXlq{k2qOK9C=Y(arJJ9j+GAcj<uP{p!m$A+9sH
z>rX%p0rwrc=Rpt8G~E?@r>rfX+0-SfvA~DZ+`l?G;ouW-O%MB*c&05O5>qt0oYMYz
z2h2vk?1>mR@Q~Gm{fD6l;5Fswjd|Q^Nhm!zi9;D3oLgD7q{ZQNu;=9)BBjsPf608F
zT9bBZS`TVeM;Z+@CEO!b&Uf#^zfEb-8z^C^_orkQP@y_$*1`}V^}CAVP4Uu`>>d%|
z<poD~<Av_p|3UHm4_YVhE9<%-hPIs!IzWa;w~L5bx!nV2K74zeMJE7NB{M6))%a_!
zml_~!+NHi-@%fd`eJ`tzk~MK3T5lvy7}DBi1<H;TKXCO|n$I>V2b}AdEXA{L=z*lM
z3I{E0_|*W~O<71^R>$6Y8oQ~K<yVw9arqp*;Z~Kvp8cPm?5HI$p9j&qEnL@tt)1KR
zcZsZ@EDJ>8MLi<TX6C2sgyQ$i+o$AY8nSRC>t)BZ^@?wE8l#ur6LxHqDvb}GRzy@`
zC#ElE#SxW`H}}76^AU2fKZ-k%g<JD*=<PDUX86D7<iI>w^nNV)DMqvsCNsMBKyb%l
zSfF<IAh#mafw0$V%Q<}erw6x7>_!YXB=0C&Yc%thRqC44>=*Q*aX!E(52Dujm@~gb
z+OE<o{jAUMm*2g9V0*{nWqSR!^lMDFn8RWFlQov8ax4eZy_qX5djPYJA22_?+PbxC
z`U){4d9FR7s`7$HbVNlvMSE+@na<zG9Xqe#{U6Qr6am$Os2bc6>GzHE$hri9ZvyqS
zN<0~RXnV44>tH}AH{WMmprIj+fUBVS)>ToLW@*?J1ie#EaN?&RN9?BMo_DXSsQta+
z&pau-mjKrYT(maa;!pmmIe2$@!2&*iR^)#V4@Jh}xw9INliRDB-)TG~aAF>SlA7xU
z?u$kqJJBO;lxFBEGvk|f9^H|KrV^{6<hmpozRXX(`At25N53*{q+SMD*^>c-2{}aR
zsInfxKD!2I<bKAI0eRQ#ib9R!)9{q!F@uTfjb#7+ejTg)VU<Y{+Bg0s__=n(eY_VM
z7`c)bKe)IjC=*5nfl#3Z7^cntG^b5vqD9!r_U~tvJ#@@y#qF|N+&CU5UFB_q&Fzz(
zwhFZFD`b$yZIWr-gScl)wJia{+>5H2bFBX#UvC-JcDr;BLkJM0XmNKh?oeEc6-sd_
z#oZ+o*9M0I#idZ3Kyi0>DDLiF+~4%R&-4Fu&b!uc<zoU@=9;}{@0rQSotPB~>1I(=
zJ2DRd&1&cF7jqKd*vrrbZ3@YMKLMW5zXK79<{~BG3ZFiJP8C7~L)AV*d-<zF3;<89
ztgI_P-OHLBcZP^NTC9^AiX!+_JDNma`+H`!k{1rz3$tKxQ)8_51dwFN2$a}#Y}i?d
z{s1e)nm?S0-Z-$UELXH&>A#!2ar<N?`di&<`<uG0wwO~q{-bUd;@3SFuga4<52oxA
zwj>R@$zrpGiB<oy42!SJ4w~DeT2*ZQitD+k4~9j0XOghf$v&ig{%7Z%I1Pw#t2%Bc
zr6AlRBXw-rnxN##5Wegl`Jlv`#!7{+@37SB=~?a*6lVq7I!krZZ`JG>9AWNQv*Yf+
z(@1|&^%*ezI{D*BMBc4#?G@{K(`$AtssG-D`xlA%VMu&x*&@3*W|+g#XJPQJt%+)U
zx~<8$5T^R}biPruYUt!DNC@&MH@phmA3G#@*xo%|n!4u33!XQSXvRG7vT0&=<bIrn
zT9Jqp;yDPD%(HLWqE#qS=nmw4&&@e7$VjRnHByH={p3bIK+@FqYecef)v0f+<u_jH
zjmET+Mnf3JxXa?6i#PZYiNudip8#2KR`h5$Z|Ml3?dP!dYtikTjjXGyf-mQ~9vuVw
zC}genm);S7yBuO8{X3Np_Xpclhq^SYZmh@&iVX7GXQ~Dud8ftOP^R+f{<7&WnT6$Y
zMLwD%09&26^wwttHY#$~(d91@%HMZ;=8&1Py*|6NT+sx1d(Es|tEH8nJTX-9IrjeZ
z0sm$Ar<5i3^vpnH@@%NMxwbBl1pkcsPQBz|wOBb(;o`M_bKdM5c1wf2S%-+lglm^e
zxA)M=zSjwNza)8ttvdpJwVDoUawA(U1131C*D~xFzVGL1J7dbJef*tYwV<AmYY6zR
z%#ujGcz#E5MJ$!|WcXUkui>q|Isvp`%-`U$;aAdIT=&_ruIn$pE{NW8hc;DzJOZ5E
z@6Bpvi)Jr9aYPF)z8^ezedIkI`{G>yYnrF=xgPk}C2x4G`YTrlw@KkRgD7jwf#=y1
zwP<cO^sVVxI^5{=LS{iZg{F<Vmq(}?#_ZhjshNd27z4fK3qbDh!>hBl$!;UQ_h`RI
z%gHIU{@3abYxdZe7qvQ*-bqw9Wp&2Qf(2hyDhve&x-V%uGR1+ueL6>vMa-)i!r84t
z8<Z;}PH78o<(yJ689!dQg;?;}_rn?L{}`?vavigL9zr%v8H{g{6J>|32&!c=6FsOC
zuf1}xAcW4Slwr;|yhhl&3*2YlJ1QGP^jiFh7!c@z-(STnOEaB%sq+KVy-p#Efc^0N
z0(B8eDvp^R{!hH9!-rI{p816=JQHQ)Jl$Q>)ZC$_FUL&?(()ZS=hbJG1ZCMkZ)UU}
zzKWc_EA296_YU1T(;C@NHEmiyu)-e~HF~)mtTl#SITZ+1L(@Hq-TDq3zU{R555~B~
z7AXFAbb>YbKX-Y^PEULZs?8ELpel2jz7(_6yX<@Ru!}B6)z)SmXVW<FR_#c(vVWHr
zvXA7UKYkx5e55GmYQis4!Q!n&yyRB-Sf+408bR(v#!zBwQj7VtC0fKJN_=ZSslvvv
zI5uM;8g!dG<|X2)##i^L<=4nt^wN!}|Jxe$1^1V=Le}1K@awi~?kKzO0H&LKaAXlt
zYI^CnYcISF&zROXs*5bVL5DBmZzgYVru3iZU+NsqM}eh*xf-5jS5B!yOVY>RbUpMl
zPkrz2zY1L{C;cxcMgzD}sr$+)xW}RJz~Jiz9!Bnw=2g;CpmD2x0i!p}DjaL1gDQSq
z8n_w#@Rre=QN@ba_ybF(M`?1zr^e{?THBBv=ekZ0Cn~Av1+?xv?L};%NOFjXg$C$9
z6Q2Ef{*p>rlim3ij?R8l$*WMfnLg0UEAJ~)_m&kiJ#>nq>+be))me|y@)f^QFAuPR
zoW$-GEG2#&%~H#nEt<bx3VP{tks`U>`q7f%@xKc3D?H2ev*i$O#W#P<8$X<Dm5oc^
z7o^@8=>Hh`V7x+1AUmmHb#|lC)V%w|+o~y*Ut_Avyx;n&3B5Q}w+-zsvuR|e61ytl
zO5Lw!S3y?u@T_2BlDrCf^dFC}Kf}LM5!w2~r?I(iRydP@3ZK`MO`Iks@24H@9u#U$
zEmeh!GYY=vwOt&QooA*ot0Jl6!u#0k+*Xn&3bhqvC8^X9O#8LeioUHDc}dltMEUOs
zNU3TU(2KH~vh;1Ao%xnqCm>%~UmUKSnO~g_yn7di)>U2~y`QAH-B@n8HKtq6>!e#U
z0RTHmvVD<tX=@tHcWX+oO?%2+K<)In(gC=9Qje5;Lb~6%kMuYEcd$oZQyf0}c&aPW
zTIc>WJ%VS2jE%#*qrx<Vc=w>v`<-2?`Qw|K2QHqAqQ)4pgdgWzQwJc@vZ1NmgCB?*
zEPZ&>DTDsyT#~21?p*$tR|^xCf3xQmBQ*bXOJNQp+wc7C^X3<u<=xXv_Gc5}MPgo6
z(Xe03GCiI_t(xy0SQAe)Z;vQOZGN>Vu+R<W?5SwrdRH@KmWrOv>mDR!g&^sTR+q*%
z9BLO|E@xN~;r?f7Q?@Pul{M;jjc;+SL`_-BncH*G;Y$+0IDRTqvA#UCrP<bDc5Ah)
zRzM0waOk@tAhl^$C`C}%_r2=oaCdX;5dA6Xi+=f7&gNH@e!Txq&*1{@K|F@Hqv^uB
zr!YVSA@-8f`t$dblz%vXqk8s+*+=S_r_R*eDOT(7&W@nACEI`NYIGL50NMU6a;jVR
zlUGsC?5g?u7qhKuGnUu$&6#Hg<w{}AmSUBNLj$rW<{^}JHp2gz9{WT8OB#1UkS4y;
zTD^(o_RrVINdC#LgbU`H{nTKMgopP?^i?UnU<st&0jv_r?CkB##z;Fs{lm>aZo*Sz
z@&&DRgFmhWt{H`=avkpfS2t`Z?RfIKFwLRmQv?9~6*eg+rZ<jpM*hXEM2F5(;ZyuN
zdfiXEE4cFCFO#Ag987o-uWGJJHSSpwpL5sN%kME0qqyB39zR(y>25BTHInk;F@~u9
z6h7QVm6)miB=j$7p|pYz;d@*D7DKTyi&_6g#$eMiL_hkYR}t#$CJq8tY=g#iB{SHM
zxP9@!?V!)?6NPU1=zd*3;HvP81@5Cgf0e!m$%4J1$|V!bgBcv^`S0^+luUnz|5Gfr
z;7;R<7p}FmERE3?o|nvEW@_>H-46xJkz>@A5$)-$I*j}D5BvB8R%uFyb=Vl(wc&x8
z4=v2kqOo;MC6TLS#jWmj8lNLP-t5Thw<m8Fd;HKVUfaA1^N>gWH)Bqzio@p_OdEK;
zY9h7Ox;cpQVuqVBSTp-IyXAxMI`$>^%aC7@kAuGhv~PcR|CwAbCVIb$51_jmcd*Z0
zvwzIn@+cvOrr5N9gD*O}e6gIadsTqJ?)CAhQy=TU3;tO0AF?HWE47@EmeT!SF94Q%
z^$Jvauunth_{N51Ee>=*KCEy1ptY-6WNnmosDC9>XWE;3^1f`Nil7#%ighgfs_MAZ
zuAJn%P@+=PRED4P$%a*KzNoo|q3?$?7ycUNmCNatgr_||ow<pIPtlprx0BN?LR$ZR
zhuOXWRBLptQ?0^RC9910(-*u#HVz>M<Oj3!=?R7YGab+8<LlNI^a~T?>~B?)1Z?(_
z)=`=8Z-4e`#`v4n;hkJoeSV44EcgE<n2e14KQdh`6Kp42tv(r45zqBL7%d`6c$GPt
z=}{W)w1(eVKMHEJpHX1yQVQcl)E)!2c$_5@*fL_{e5Eg}Utg@JtjHR}5TZ46SS!O3
z+KReB*1ye|oW%?cT*o}j1Z{qsNqHDkTxRrGCfc*3F*yF4s$v-eJX0ezS`{xouNO(p
zne!Pano`l!aPt)7PFdfq@*-H=21@38p+DL+)6f8}=A7MYY|D;%3KoqF*>|-r^1gsS
zx;*Nm{r7K;SQWN$#B4%XH%lF{`CakewM^crW-mM=0BnGC?XbFO=h-DZh2cat+4kuo
zD=~V80j6*Sf)D4x2G07tY^V{bYo4ef3+ys~JcFN~Qs>xH?>H5`eUAIglAWs-4sI}e
z#-9YwG4}tR&I=$$VT`?$aC0+`Y9vwO$KOl+=|8)_ZT%sr0qOLewz$m&o10UDt}X)j
zdi5v*$9(ON8`ikRoZi%Nw~(t()X4+EmjkWx<$~Ggg~>w{F|mrHZ;t%><p2FY!z#@5
zrzRq`L2Rs5&DhMZUfpgs`ceC1Sz>YGz${Ozl-Mwr%n7enAd6^l-8p1MMUC>PsF728
zy@z-J8&&qC*iNU0-i_oP7g^slBAzoVUOC>~So}UMnHCxE(}d-A!)DTJ#fcx87q(3T
z(Lh86HPbdFLoV}slMEDh^()1(WI>iQk+Iq=VrXsVLg;l%s*jjL){yc&A?Pw5cmHBw
z$6T);3hElK<@0S_IyzT`EitM3@abRj;Y^+F*ejblNXL{J{X`Sq_1gIE<tPK$pQPui
z*MrW0+n$hv@TA>U9Y>Nf8K0wNR#lSnhlzrtpa(it@P>WXE2_Et1$sa9AEDpIsV>Dq
zRJ6eu`TQg%4=3IX`!AvyK#MFD2B^Eopf7^SzGf5m>C?*alGWAzNCxqu{A48%t00Xt
zf2+W=P{>!p4(mu5-TgU5qAJ|KnAPDTBAapk^rM;n>o>XKzv2pF;ZXkP<BtzyY#ky9
z6{LAahhJfdPRj&3^_}<E?$n00*s6PNyO8%u1L@1cu~-uy36XsdY4yrH%E%CU(mJ^;
zwvr%2W{@EYY=SMNszTG`O_$b>&M4rQ(G>3AjByD`@<xaA1<TbJsv03K+PKY8Ijz%Z
zbsx$G%vx;T<$tn#Cv=nKY&W+XP0U?pA(UY#h96;v;<T)ZH9oK@YtK4EVDo{ZnZA6s
zy-ZsPNwEn&UMHnWY?D-Egj6T2&kU>|X!0rNDQ5gS?e@;C`iX+n%Wr!yF>Ay+IeMT^
z5<n{spf#d|9{|>t<-4<o7|4k;Ue)JcPn3!PD*+;&F;424Np1o>h=68fqXKW?$R0-k
zgl@%Fn1RJ{Q}Hs4-OEjfcJb-;M?B-H_>Nsbq}$;tt_KlfChTqh*JA{P4?h(`n@q>1
z5U@~s%)>1KW8I|r1=(pmSX8c=Nq_hre%8&;WT$tMPX%nkeKriXGk=*R${&wm(6jeQ
zAAE7a35!qH9D1$SDLOBNFpo%6!E1T5PEpIpJ2h&noOdI4-Bdi@_d!}nDU5i;$%6WD
z88t&cl&}o>Xr3BB<}_V_-Xny=o+NpJBCx>_j1gk6xa-Yyl$6Gzqn0t5%36vrnyD3b
zcrP!bm$p?l5`LlUc$8aQT+A;Q)3WB7e!&|3f;)ds$!AUlk3$KMGoAq_P4v(qJ5T?y
zk2*yYGr)3-i7YBtIRu5${(__ReuEX8Y+utf;`gNL?w&c}@wxPxqkc_v0n1R+-gjeZ
zJAqx3;Sjlr>DFzx-F@qIYVWg^tPr5Q|Nne08N|;Geh?a@4KO<fx$Jyw*!PA9vN8ys
zgX@&=MHZ#O8!-?AuKC#yFClHX=`)FS0<%#Qhl@M2QOZIV$}MozHDnpu#{Th=5G4XB
z)Q8$*bJ#FkkyS|OPrGv78lf1ircr}wywUTh?^aA2eF~u(yqdR(1DBg@&}e+UmCq#e
zZj@gZQ6%ew+Aa7&E3{1p%G7b~-<XB_Brnnw%!(7zjqKgNXOMk*YK}a?GP{z~XHSv6
z&s}{6FR`O=QXJ_5saC|!7J_c?CK5+R9EMW`b4OyQNp{Bm4VXcYIQs8b8DpB};_J~e
zU=PL+j}WT;XXXulyiHrFInUP6T0_vHeQ*>DZ*>%XqO5qWriNNLY&V+4EI>q!sx|)k
zy<Fa{N)PCB*8hw^aR41|_H7xVsf%1|%p{Vqg>oBWaqL8F@DV1q;V>$;p^7U(pQ?PV
z@5#@2m-Wrlj0PGpCZwouE<2I>!P@8n3TN-J(5{1xM)ctgWx>eTMKd=)u!vDlh7vh6
zrmRlmDCkK@tYOR1rk*y-n&@kDcnuYcKxSX<W#Yq21C>=4T5|dzm}$c4Sib|Xb9+m%
z<=llK3(=BE4-%ld5Yw8Wu;Xt~JK=(Dpj!{>VRQ0otKI%5X^%h2qK3##2ONMHNMA;I
ziH)@(p{V^MS^wZoQc*m^n?JuP%Kwc>P;fh)rQ4>s?wfM8yUsy1EZA}YckN*Y4$?Qa
zA;k*dDI$qS=*A=9s&`an&FKlnv?l|Z@z>?6QZ@F3@l!H^8{(-0oU-%7DTIz9jO#zA
zj%|=ivcIAJ-=BbXQ1$U4f%e6BUXg-lPKJ4B;2%aZ<bVZSEUTYfL_<GKxmk(UE9RIr
zDwpVt{1)y|JDW-zZ80s}pF(uePM!UCr^J9>eL`jN!-X|U8(9}r1VOF`By)bX+#bPi
z7au|eVr@cwZn@m?TN=N8Fj_4f8vj=6vDRp`KbVYz4Og4EY&l$ieucFniq!WE_`K)|
zUXo0=4OuJmac`nT^e~VZxyr!Zq^oEV$h_%ruSf3H_rN&vL-HM#&}<g{8bg?9aMom<
zSRVgR`UgtDNk&rqFu<1C*H#IY-zpa(mQ7P&@YfzBzv=tYYH&Xt@QG^v^ft+5Eg9i>
z?PGN`f5nd^&%8^B=Na2*TT_CKw}{qlKi?4R|4;PMW{bkFRI~F+&qjY|^R@R-$#QOs
zhfqL{Jc687z27s$6^5n)tqJbZk!1Rys@%rxOI_cUY(9J&z>MQP(S)3qx$R61X;zsh
z3SRk%BQ>|qvHvml_gDmmFu(0O^Jimdc1fpa{240XBKz1Q#WJJ+O`+-42z0-z80Q2t
zjcx9owwaNsrA9aR;z%p<`7)l5oFCS~OcB<y9rBM1@9bM{k(uy9<zRQ}dNi6Q1Hq%k
z2sjs_yKdwu?l`(rEj&ED_tE6S&yB7^ZmS9JaK9%`5|q>Z6C7vK+3;HHb?NSABGSw+
z1sNJVg{%O`zA<DeT83uqhvxU`<Te6_@Ezai#`ab7d0j#vNB$OCY_YT%zt@>s@BBG=
z*~R9!$@aq!!#%32W4E6L79nroy{!~|KV3=~aO;(v&9Nv-+xNOT$XUF*ZZI9gt2q2H
z<*?=Sr<<kK+Jijn8yt!$N&-jU*7H;Nky#Wtfs6`2*Ox6O*`&FkOAQYgu*@kNWT{oh
zciKVvt)V+d5WXxW6&bP<=MN98k0!*TO||5KAFi->G$NZKKQ1PXuSBwb!-T%NYWidE
zS^PX>7G%J$uu{LepYGg~l~H_PKxHb7y-_ZeuI(M9B-_9v4bBN1Kv`+NRzGoTc<!M;
zN<b6VlBB%l0(zjSIegta336^y{o+%+&D94j1YA`3zk<(%*Be(*`gKfy%WvY1E``3s
zWL7A#yBx}PUuk82y!VmWhoLfRy1#%Ww4aeTyRI0;u5r~Br|YQGzU!?wKPv)N<04hs
z@(H8J^(e~8Pe1IMqG9{p5Q&FKu+F*>-s3krmm8Pmxr^JNJ>uJ22HST-B(;Wc7sP+>
zGGiPZkWg;(o2X(lYvg2k5XV+HhmbMFI<C0wr`|b|kW7ovRj&^6uNxZSr>NAwuX~=1
z=0j0Sy>K?~L@}QfWZz@ML$}u#oY}Ee9&+Al+e<ZP0w1aUZvrZxZs0y*OF9HIizz0a
zFA(s0#FM^nA-D`GrxW^=?fVUSy3VP!+IcZc<qexuK`5t%7exsc>5~?rz3DNFa4Gup
zC^|K(w%SgL`<WFDB|&n{HJx?(x>A(%=dDT*qszz?C5R^gh|bXN)_n%|+Z&2v<Qq06
zaYAAn*67s4e1j$JIEy(w<^}Th%k6-`68#e8QgQ>;wP}8)pbyPY@WQIo<Xq|u5lCWg
zfv6+Rv>R6~IYGP!OnogyL3H)17}PB7nq>Pf=cO*)RM%d2HLPzp-9`=q9)EN`PX6h#
zuoaOW4zw3)B<NTTo&hvRo?)Qq{oZ#_i-WD{l)VUAi$Ugp@yTe*yp3l!*Pu)1jAC2+
zX>u*^r~j%HkI0aByq(5tO<9>m&jF=0*Zq~0D?eNg&mG)tur}+8Vy)eXSp&DS<1A5m
zIz_*4k|3hq1V(q4xJYJ*SY|#yKku?=)n_4xL3gCszIQN=kgWv35_>n3Tx7<F+r8~4
zmAea^;8>grZ%_QSBR&<xQ)w+X9AQ9}|3#K2%~HV$ILdm$vpV*NcBY%qrbD|4Z>CW9
zFqojnqZJdGZw?Q>c`V)`DWcwpVTvNxJ_Gv4?vf*XsXUS7{KG}!Yg=z*_U6!gu7ij|
zb_v!?tJZkWNT4fC_5dkvN9h#V#hFz|l*3y6(d!H51GK_1?nN!~4<gb4S}XzBH4C6I
zN2WCrg)gI-`I?NuOz$tKiGW)xmFNW$&K?vEhN{we84${xP@O#~6aH-43)*OU1DAOD
zXX*aN>3K;>)Mf!6tMeFxD%rd0i2-c*6>7!8y&-TX*9~439TTx)Npbyz=<FNTxYOiP
zwY%NzPF)=@MO5+W3uon0%X)nggX0#}<0B@h<>*oN_f@V8_Jy#m!~+UYFTMh5?|=-T
zZ0Xj+anUB~ds=kGS^cS$6#-tl@!_~Tx<q6b7F+#sQke+d&-$oU@5L`MDE(w`zA0Jj
z(No)kwUYM|c5KeRCwee>L_XJ3r#6^EBNuawFtL1BxGSDsTLzlc)zga{cGfCg^^^uT
ztu2IT@bcblVwSKt;$F`iFK&4L3lwzNgrQaZZ}!92-haoei^2V@aAr_}oCw6)<mr~P
z=nD1A4W(;j?A@jk2-|2fmbY@o=#BF(xpG9@>DTn4&c4u<t}jsV_6T<D5=lTeVx`3*
zgm2C|4C}p-T*lQ{*$q2W>3(U%UxIVx8`8W3IOexw4lL1q!sz#YM|i467es)D!pLB>
zMjAh+<eamZwGG!9!+-wh`7y-;(<C|!^!*=3>P^?qJE@g!8wsR-=YJ?q+oe(<Me8p(
zgS>nkAOyN9D5P$dx~8*3TU`x)O&oq22oSXh_7+w-xEfvCw~?~tg$w*eM%f;?z}xbQ
zs~Q?JJJW5VK`(45%bSEZQ$sKZwg04I$<VjmoItzc@?FyLhVH{sOOUNcxj+$5>v^hg
zPgsM4@GN?gXm+mJ&eRy<VO_g%ethArgseY-Wqt>Bg}JSG<mR{YH+PJ+Ph<zfL`)Pb
z6{WI9QR@-kdHHM|4Q+mVW^=7yf5l>_*)e8P5)ah|NTE0C-Kief+VVf>tg|$?eYuU3
z6GlKn7a(?OAWS*&Wz1>fsh$5WAVa5lECU9UOCdE&RUjUd-<sI)ft6DD%y7g=FW+{9
z>HgM^rIK(t5pGUK&F0$DYrZ1gl*4awb&LYJkSm_yOq^&JvdBJCkS{zD+3Hf%`W&t6
z8s>zymybhDCsCW0f}H*+6J-n%D6Pn7PzB-}cG~F@U0-~_*%OC5UEY#SH|1HS&}ijp
z;w~QL9~8bF9|(Bm^w<p(WioB`9^i_-@6>}O6@?q3zrJhN0^pBTjKC`#yaS;7hTp1i
zRllW$LEw-#;y^E~uAr9iw=t*fRAP8XsS41S1N02_z7u~wNqRv1Hm%|=D+ttR{bdp4
zA8_j6O}_ei^$wlK!KLbuD$*r$P*dK-{G$Z)cdd^!a}8DHnjL6bLCo^>O!?N8J$)9T
ze0D9l8yT0t>d$X`?o4R=n4*(D*PIVh-iRF78}rJf`8tf-3y4Tjbx7edn*Ie2tPfCO
zFo~E|FogqBW4DJiBkctHIR$ej-s4LS=%{e<&NsNzI=E9)XC$V6rf69asJgc0KVCvL
zupXnu5ey}39JQT1uSc)aUK}@^PgTGyC%XROjldrpXzM{DY3a^M{6Z&ff%k1+Md72g
zM~T$PUB<F`9m8B?X9Yq9-l>c_y>h+R)x{n6KXt!917OoJQDwfjJFEh$QeKwmyCrrk
z`ffo^xVY3;>Qg+wFrjzICYDlaz){8n)|dCGpH$-Kk7E3!Ns5EVJEJz5oCEu9xPg`Y
zL)&Tla=8lhC8M>jHDSrOVBOk5zSNktJG(*;=Le;<&eE^!*cm2i{;j6+-xtu4s5|3r
zt8R><6KT9>X$q?Yf%23b0DbNZdJb^1jk%Fj<SRLUxLNEn8f?NH1%qzVc=q6vpf9Wk
zafRQGN3VZBKfUtP@`CX7c#vl&`V8=PnJp&WRMu?rg#;Be^?$<;GGcjvE^05lqpX>l
zzKW%)aD8WVB7bLos?#6n!R{Kd+2LGJ%Nh{K4#Zw5hDE#WEz5z~Xgc<L4=dsK{aA%W
z_v@di+DV8!mP@Eu6^%$VP|yBEMh&ZWolCQ3*uN7bkOF(SWKMbu28(e;2mZ3ffo<T>
z?>7IC!`!GxX6c1Z4g`zA<%X>BlBD|z`y6cblw^%%{e>=nU^tC`so|f1^R<mpjN?+d
z30xV<AL}y(xutOXv%mIE3#t4{3e+(eHt}G3K~L@&n)aCcS6+nI+O(g5j}e$pZ^TK8
zyFC!v9r%YOTC=XHV%2N`rz5`TZ8HAuq{X%`q|?+l{+RtUHtjOOVCvBp1nM8Xg_1v3
zw{h1<AEH0wWs;>rson9^2CfRJyW__I+JB2~@mBQqHpPWr310Ggb7z%Ue`MGlX$|Ui
z>+ZT;r!&B9CtXCe7$Eo+BVkZ=$WkgA<T5N}$<%rQ$9AS@J}dQMQ@)X}h}95fxU3CX
z=Pc8IO{I28fJE=lGiC0Y0({Bo;)Fu~7Pr8ZQhw9SYuKks9(v?WF1QxBEZ6VZz8vxz
zmKY$zuPpV3F1!t^_d+z6j07}mz;A~-($O}uK}W0e=`AYX?`c_?cNcPsQZhcUxoe4H
zP8KkyZL>kjA|2GF!IiJrX99|)sow&{PJ_jMA2`L=<n}Ls9rphzaDpX`(7(j-dp5ov
zFmwus{Bq@lxCbl3RrsM$XOoPVKm=SF^*S;$jAqe<2&G6+aRge{N;+D=XuWcJjR#!!
z;w0rJr7gkq?u@x9&TkTrJYKIRN^uy^ZurdUI_jJt4lF%<?p|W=UA~rV&ReU&A{goL
znk9&6NZyTw+tp4o5#N~$n7_vZ4<wnDcac75C29Qu!no)m$Z_O|>!&_<lXN$3jtUH1
zl4$<EK){kzfMgS&^G49gPkWucB}i+ppr+{>Q!5M3>-XFV?MrcgsP?BvQzr3+><{E2
zr&~LRqbfN$z1X}2?w2E`T`W4046|z=urJJtX_<yW58t!j22j{Le}nqDm66fuAy$ED
ze>F3SHh9(O#X|%MYJQS!dDwIvR|wj?v0-nvQ5MpwsjoP<iGFIo8BU%vcV_{enp4Fu
zwo)@Iejeq3{m{basa}R-h&=X@sa~U(Y*d5MF#oEzb62{JeYSQk$J<tgze3n5wtv5g
z)T3jxxxDWy_(AFs+Z@4l+*`KBN5tYco#XMJ(Rw`AV}f$Ly1&feGAQ=4;h6=*WQ044
zC*Gb2IFg3*f{S9Fe=(t<tcBjyI@%B(yes?`5}s!RsFclM!h6i@+e|F1lc4Qpk8>Y+
z<80v=?TOj|3HU0H*k*AifS^(9yOVSxy1petYlH!#VwuK0ypy<mhNdhqHkL^}<kpQ_
zYiSrPc#R8wBb@O_TEmt4TH!j?r4)_}M*Q2?74fl?g*RBhE*UO637*j;i`bp@QdF6X
zm<l;;XD;l>O^@b4@CR->ma-wnqo0uWvL~9+q%8Gu;k?ODFcfFTc*H|K>AS83k8U6b
z)b#l#JewLX)7fYW7fCPODRXUi=Vrpc4`r;~aBJ@hIJ4JO{7p2S`;4&a5FSIsZ&;gq
zhY;*R;*vK1L9QxoVk_JT`*B7#W4Xzr%}zFw)MvfAD83=%eUX6YTa;Mwk0|<ZeQsa6
zycnb@e8aVKh_yDK@ZssD#oNBp(C|3zXwPv2-Omy9l>y)SB5@r{^)fdlD8ArsN(S@z
zChCokfBe`?gwX;LTNe<%%$)ym4Roy1KN&rW(arLiS}~7$MG9K{se(9*Bx3j~V7!ia
zQE^g|vR!b8Wy@e9b?T<wjh>v2gnT!-95PRcQuq&Dde-Om=^5x%qJmW`v+_=4=XeEV
zQD(byRA=U-#gW+fr$B)|O_PF+{Gyw)a|Im6r1m8>Hmp9;!{IUt%=0Dke(yTuV3&ey
zLllV>Dexovlq*GUn!{Nm#59$v*rwNIz^IO}oUPNdTxj6C*yhr^`ey;isk_J0j8BGO
z7lRsD%idqeaMj@`$Mx!$Ok2>IJ*%|ENPpl>i)`iQz9t3sx&bK#i#SVacW<v2PpuG5
z<1G6h12Dh!aD7#5$Fb&A<e5rk1Lvl}zLa8e9_6@lfjSE4>|isj8(@l?FxB%PodXdh
zE?@oDaK=pUeT6I0!8m~aB5w~n89gbD$H|Lqt|E=Tc0BSCNSm7w&b2zGLbde(JQm%s
zNTaKDlMUOwfc>ClyYdCi`i_|DOCU2q1m6!-`qi91=M7+UNNx7IK&RH27=E;(oqC3X
zO%X{X#l%Fd33&#WgdQFT6a_as+^%{fH>A&v&@~k5M&0g4`^(ai3<Vu3_{zk$N0qK?
znWfNAHt%e-?aV3KOo!_t!!IbDEk)MIy~W$;y4<#f$>e!$za=|iKgvQ>)kan3fbOMk
zqXBYGIp~rkP$kDYmOh3<9B}X>BA;)p^a=e-e&}HEq6Hl_^?Xmx2WhZYfUO5uAD(JM
z;4FE&?vzG0Dy(ng9BrdwPG;Y=Q8L)%^>U(|&TW7hJ(?kPoB*-dO-TKDHB&r&vyS0V
zbLw9xETyL`T4CY&bH=}9ubFFUX@uI_wTl&Ih^#(3*-py2ZaKxkTM=SjP2=xWN#?sG
zft^5E={7i1^}zJULT)|mj)DK34z&s#|1c&na5YEaJKy&;(52)gLH0B8@V3-xQU7nc
zPYOmA>98bh3IAP?4<2uIx>>w($goEcpV-S?8qkWpmby<eSVp{&I*&)yYR?MG4L?Gn
z59KWjul7L~ic>(jY{Tfrnz!F|tln+y683m#M%xH&r?em4J2*l=;=e-q`0B~gcXD_E
z)<}IP<rc!7U6eN>pC$uNiHbRY&#P$zIeFV&+ayKV+_ZRlCJxrZj_G5NB-LE~4rNnb
z&v+l}0+1b`2EnhKSYE%!T6;nTi1<40;hOMC!5j)qcn}NiVV5AW=jHo3=RDc#@z*{e
zr2r<2+>Jx*!3fA{C{tY^(iTlNv)-aQR#8jZST<M8a=>A^1oTZ6S$PuL*hP!s@Zm6n
zf7*_4C)#{*+^Q-jf4b<za!(<3XA^o%+gEW$FFAUBsX4u0unQTut(SdObCwD@JHQT#
zI0LioXjiu1d56LH0RoJhB_amc<a1pf%{jox!6Ut{tCzl9xUAWASh9&%J3_<Prug|x
zLJJ?$UBbEyUi;GDMmP{YSol!9T}gMvuvZrH(2|G^Wz&W(hiX<X4^U@dujFOO>3$fM
zkN};^Mw6?fsA(fquBd?t)-G|d4c$prDU3-LLT+<U`{3RC^8b>j_K$#qPR9YsQbj=u
z0RDjguq2=atGymffovK9AX6X<E?GP@0@>YW!WmNoYT{pWp1Tdrr(+V{tZp=%egZNF
zOuW-6qtowHx1;pGQ8~<A0evzQ&pT5wP~ApqG;M$2-*AEmanDt)!Vcq+{-B}7%`p$M
z^hs6;$<scB0H(766<}3FHdxUr-Nu}$8eFCc6VNPiG0JEbf;&G+arE8iu7ql4!QOK8
zQ*&N5egkZP(jyNYGgA>jn~fN7(nZknFjC!^CFRZky1}?lB7FueusISm7Rm~4u=Pmn
z&ka=aVA1`ig7BC&SLGY$J-2NmfmDkM>M+mFWa;E!TC$$e>Mr4-w>3l4H6>cYVSl7}
zz7-~4HUD0!@J~v@@&sUglt-#qCl07bkc=<jsr;J1C%49&?D~`5{1{W%aHbnSbwYNH
zP^1tGw_Lid4v8=r(emLIZjpVe`s|UY*w$|d2Oa=!qg@=2kxqoZw<~-8{eQgxbi!{U
z$bq%~L^srLG1ty#!S5fU$;~IiKcF~9Cn~U3U-<cFl1q7?bZ>GDS71sWrjW(Kp}77%
zu>#AFZSB13ZooOe3D}9fj$%H-ZHNw57Ri2w$(9knHdW<vix+CBC{H8p`M6vnQ%)nv
z3wSbtIf~h{5E<ou06)q`HG=NsXfEDu{oBtH_#)U?y+0VcYa6NQy~(d2#Xll?k*S(X
zC<KL&IOn8MPdhW@1mVfa>%?1#0R7O;8vhp9pAzd|3zY7zuArX@qxLC<rDk*=6cN<P
zm8tG#AKr=}bMN<St}+}a0gm8z{yr~wc7Aw94+gw!dSjK+{&4oGLv@oc0bdZALp;9p
zK2j#r>74bNi^)$-D(EIA!4ixiYa^KmD$)~j1##fun3HP+#&Otd81Ik`PP56!{v2Kw
zr!N-?5uL@R=}cIaAFgOQ8)PYLlgK-JBSt?h2hB1W_AdAWsqn+$h=ubFxRTHNP=keG
z7maS1Rxr6Q^zj|p0&WeC#<x1&AHG2@Z@V@hz)!D42J3!^b@TJ3o$o0Y5!LQ_nsx}2
z>YR;=f2dgR53IxH>KWjJ%9?cy*>a*y7~n~Jz__%<*=PLPnU*gweE{&VhF;Nx)!DQ@
zK+C;y$3>`U`O^TY8Hyd`iM2*1YW6!=hK{F0{hymB3)r>Zn&QPO-=i-64MJ14dJktp
z8x<MFzdmP196N7NyBVzfhhHGV7y#)p=lC2;%}vW~V1#H=iunA_yu}4@_|vf~D46{S
zTykdRJ^c|-zxoTwHp$Hm#N0!Fk6ejFuOj}0Xzamta>IdEvctJaIw>MfHWJV4M1Oz+
zStd$0DR&bIk%M7IAay%0H)CZ$%@8j)N44$TUpi+vz|<6d2;sV15$YwywF`V~@eZ%U
z2W#{LOEXPguZD=E&XJ)cD;RC<RXkDREWEl_)Qk$ivcKvxalpo27pSZ@<5N6V-E#9(
zu3hN97(0K2PMGwGA^5CFVVym}s<*HRVf~LA@TMJl(Te7Ld{fKQ-+DEx%Pv?TXETG4
zvkzdz9KOeLvjND-nG>Kp2;;~AwPTr$!&7!7R;C=;isP9OHr3OF<us5TCr}ZrxF!s5
zNL`T|uV4@%c<my#BUNwsi~p}SefAYD_;p%NUdxje^hi^>nO4VLTRxi*Q2CUHu_1gX
zTkr^dmgkhcNN-0e9Q?vSw10xRB;1D`ki~qSQP1FQMuLq$1X}YcE;Zq5z1Q2(eZ3TC
zXKE;p?)SA%OuFMUuFn=JH>dULd^30E69Q*5Fb0>ZGhR6JZ|Z=@SxY6NTv|)pNhK07
zxmE?jj#Wnd_s#1vn)}`z;UU;Py$B{zJ4EM5qAycu9~A6$h;>ee*+;GlMtkGyD32Qp
z2v?X`i=qe><91+D^of}mM>PlR>6+SFAvQL)6glj<0h5Q_hS{IEd&Bn|3kDOt@{hN0
z<S%^YOSePg&$SuEYMp2>hW57B5-K;-BuZu6gqq}wft{%yXRt3cf&6_uNUXs8$g-}5
zbyyGGtGw^Lh2<+Nu|7AC<NC4$Wcwq8BF-YFQ`j%(pe2!Z2YsjWIhkaVsy&x+MOeY`
z9SlzS;58%@y{F7+a(^@28Ln~SXlKCn4tfb(PaX8(JvA5P_|Dr21F&$1R$U6111nXz
zCPT(=s`fUQvF`UvBh;(Xg}pNRUeWk_0h~`IfOPM3uK9<(Qy)a(bzY>s85S$6ET#Qj
zlyZ#{EW(fYoCObPAXavs%IDTNlmVlEE4|1_r@jVrVgfEN^c^8%W!8r1J+i^i9Pe9$
zmDV#>oS02B+*~3znk3hEY-q9602UZ;8A8P{FiTHnj#VJl&#0fr=fx)|jG>XgRLEUY
zPH4Tf%23O^$J&O9k=%6jNK(dvj0IX>0p&K&Z-LU_+0Ta~6b}KU8#S|(#=>HW?!Mu+
z&Pg3hFFkQ{P~s2V^9vdZbCS*aeko8hCt)G%vAMH1(jMxccQb$8T*647;h(M-Nju6i
zy?~qPLQ&e#)t>xu8E-ZYK*Jq%r^awdyqX;14AEaMN(rxwA}&s4d^X9$`Mz>R`8Nz>
zK4Sz3^Kfdka`xwBwo`F@HjptNM$7#)?@aXc$Qjuxv@dmwYJraiS`$5>ca)O$Xp`9X
zQ9v_BC7?wkkD!OaFAqv^n>o6q%ZsFK%z2$ott@~RCc_SL{(bp%aQJ!_+s8yb)J$J)
z(4Sx}ZxL~hFAXEfpVuXlzowH+;3x`M%>W0#6mx&Mf8mFPxQswG{sYTWBVz3h!_*(C
z(nK2?h8?LzpYd6%!kB1s{#JOt+ds$3kh2wW`sRqUfpPoslqYYqk_!gl+9WDyRT`4i
zj>@Pjg57(^)@!qBPWmK|)T(e9@!T4`c4BDz)eE(8884?v4QsiDxVIf{)^Kl^*zqK5
z8A%}0eqJsP$U(uuyA**{&=t`fT<{MRu>nn&)#*O!WKdPDKvjap2&C4^j8#zA(=#Z|
zM|`JggIDHcEP$hXM<M<(Z76C>7w|U|t#^o2*NNpU8tE7FohIZcYe7XcPWwZJO<>!=
zB-p#Yh81O+u>C{qP!s}tsYt&VW+Ixu^3EXa=&F?bzkC|yRX@GeHX)nEwvkL3gNbW*
zg=d5)w{q>_g0klseh7hVasCs)&=_L%ATe|~spKoH1E)&5BFM?lTdMj)bd|E>()MyK
z5qy&HXNn*;23L3GqCP772UP0j5U>b-PTex4uP~luv)IO+o@EJ4e&Q{p9*jr#JQk}M
z4%<T&-8qUo-1;)V!#7LstCX)k>ctX2dJJW<;HX?WM$*FwV&nhet6R)&I7Xo<_956H
zi54eJG}tYc^UB&Jp*$XJTJ>&b?JiQy<jow<pvayutnl3e?NMjT2R=sjPZV^S;rg$=
zt6hE6ntzqJ>hC>aJoG2+Gnyfa_+$OsGSRuiD>Fm>w&6p?M$*k^H+?Md&Iv%4EPdNx
z?RD!<7Wn4Xm|R2DhZE`JqLPg22%r*OyP&!CmdL!%o3byYoTsoh6+@V<v*tJwIYkM}
zl|_zUcUfoS&a`dDac8k#1&ZUA(i>fp=H8ATRJ_}j&lUi{ERp4(Tyff<iA7qF|IBDu
zRp)EV8iMtXgAt=4k;jfN8c&6sf2eXC@)m!|oQhw%(;S3-^Tg2meG&z=`YJ`rj~T<B
zlN*yAWc?aD!xmF7=rr10gL|=G0oKrI)q9ndosmR!@*pM>9ct+y=KZY=?Or(Fx<5w{
z?A^t0p<r2<le1xA<ZZ8_s?(V#!b=O_LZ&65t@T_1zAwO_;0#~Y#|RT`f;CU5%E5Jp
z)l59J9<XZX?Fv)Udw#;zvkdhFlK<}B3P_#9*5FnN+AKb)D(si`sOl6)vsfQ7h8Znm
zNe<kr5nq0M&Y#rB;RuA=O~(HGXHkBD{2sI0*Q1TZ+>6#o7{-8V<pj$8^tmsL*Conf
z><>(5ap?x*LKqZL{QmwGF6iH|@o~l@#5ac<iM6M2bMj8W`cj!RcsiI2$CNY)>S4l1
z{qJ`Km>y$XG&gEwn`_a(wkD#EO#MkXWHm6^%h~?onP0$r+vSJ}THX=Atuli-7>zlx
zxRmRh@Yug$eG#Y|?H%e2?-N+vTJdca9}tNX?h|+-E3^`oENWZykWFk5OnVQLAQqYB
zDMT@4>WCeN=q9XDFR7g5Nt<`ZrqvHPePSJB6zdCP=eI=C?oqA8da@>Sy{<Hl>B02O
z&Wp%N6Qt~~68sPQMY_{P0D%Kl6Vs*QO(vUvJ+AD`c1{k7q#N2-2TtRFAQZ^0eK4#q
z6O+XLcYAbyO6>9<twh43B3q>1Uk$5)7zH`SIHZ|KCrMo%&15E=0dOZ`^6sM#sww-6
z!TuAnn;^$%A_6Y4SB98TqT!s5CtG1!`iB->wh=(vzq-pzKmIns>~Idp`Oh+tBiVj<
z>~y&cS%pxus|o@@c9hfL?cQ%nUmhx30G7~IXm(N7W<Ea@(x7J~JgTf-<mzYJT5q`I
z=2c*#f(Z(lk<VLZ#$IZOT?#v3a?zrQ5ujM)sTB>!V&BP6Gw3sbU!SZrWo|K*kviVB
z-1Xt#X^zTzNm6KV=rJB;z|!|2sx5E4{wjtZ6Uu1Acl7XPF$1GE9PYieF|}kTUy)Z=
ze$(f}clDl^&au~@ZRK|wF)KB;@fBJd!j7!C%-$s0S})np@RtVg2LH&?ndNxqe6@6r
zrSg^!MoYC24r5>aZC&yI0$?cQr!wh4!*USG4P)c!QUdq|&9fEag^#StI=!f!7_QXW
zmV(3!^+tERyBqINx*cNHcAs9~u{DP@&9%dNA({(bn3S4HG`LnPU}n~>lE2HaMYcH~
zgWuQD9__uDz6eK(#0^*OP5BZjN*MD5_TPJS@T$KMTG>&}Vne%dzdPy6byAP`<|wq+
z3+5jz4ych)#$9{KNG;zhbKBe)dYUcI!E|l0p7cxg^W+Qk+M7r2+M{&M6vt6$u_LBR
z_cBF+fdwu|HP&hP7|GHJa!6`Q<?<`4U~(!vJf>z#kSp3u8qCO<t`}5b^TR#?(y*vO
zxAer!lFrR+JPN#YLFP&p4eBeHxM^Y2nlbo2r|JPZkUdo?4qBr7f|!$OQt|#EYOThd
zE2Ue#g##k`p(?Nfdj81w$k`-yNv)CD*PrRmQ(2fHzHZ=2+SM$?@K$E&e&cQ%rst?V
zQTZmHRI$Sd3<%rb$i%0fg`)dV)wetdyShUkfJFuMzY6eG`zbG^N8m~R{vxZL=$T*V
zV+4!S3{)nAX!spJ@}%tqw0Og?IzVK?>CEsM><A`I>=ecT;eh;MH4~ibh`qDOa8`_y
znpG`HbtW*73U<VVWk_{{ypwBdMO+z&5avG%*F$d7i{s-QiXcMnKE~E6)9(Gf-al4u
z8d2N_wR(aj_LdjJ3r&>2ypSZzzsjH^e_k3h=JX(WTp~$1PM3x36Q9RPsC;CQY*I3B
z5{V9zWzAAi8cnp}q86Pphg|$rwh|8Wu{{6aq2GuI^!+Lhxgi0apM)rnm1!M|fH+qW
zmAMa*_(qE3q4rSr+paT8kk?M2T#PGoUdCCO51ce40T0<eeAh47GM0i7Ur-Wzw^iT@
z$I;~bBz4NZ^TN&MTX#?;{<9=OlO^(B)9qGCymDnf`}q^9@bgxcgYBDCVCHoD@fDTr
zF*JZIjthQxHn2;M#rd8bB9_E>px4+!R-^X$Mb6@mg(tv(0M=`gS4mfAtEPl4Po?S|
z1r)(qBfS8PJ`bq`M_?LzUskSae31wA;I5_Wh?GDw26(xR;o18P%4oL7tL}BnXf(ej
zjarGfL;hku5={?1?sp|<M0v7KohZ<Qpci*E_q_h%qs)?3p?tmETJCg|G~evpw^7sb
z_)@pZmYjt2>^E73qbwA6v~?}2@9)38m04rRX*Nx(FaM;`IZr^{JmhqOTfg-VbWSf0
zsUxZFfu1kajm}CmU(>)2uD#cgX(Yr$Fj|lb2N<NccJ~SflLlHAy~Oi;z)mRCZP>OD
zo5oH#4w_V<FnDS;@2h!TYw=Hu-y(=KH%!WJ*qm*$n>6(^N5C#m#S=0NpXj)KQ7kl2
zBJc}=QCBWR_eoG`4ZL;VZ^fhY4xa(HM%L7$$-1|!e_e^SL>NqIImb2FzX#uQ^bQEc
zohL_s6NiV%TWB!NU((-(zE2_vhElF!j0X&kWMTK9>=y~#ao=c8k`Lojl+?#24>P*9
z6kd$q=Ex8x7R5m)jS=-wjmj~JBYHZ9Qe3LU!QZV9kx@Di#%1auk>Eudnw9JRY%NTd
zPxhG_9>|yM9-5d2m-z~5PX{D9yz{-zZ>*tKfviOQm2TG5adRjl`JY)v)$^58fJ6+6
zZvj{~b_nJ{GDZW&^zcL%IAW1^Bb=Z7Ua`O7nZ(sq{%f<4p-?KudBgGi+GJ6P)-U;~
z<!(&|4~eC%ivRe14_m+>Zs=3)D)Q^A<yJjxxM%$zWR+J(N+C~Ghtr@nDW-<=Nq?bW
zM;J?dWPnNfV(JlkOW3V2Y^gehVT-qUMV4z6PzZ)CRq8z6KWJcZPL^^8f?>-#2V(%-
zY#ff!`A3{Haq&YzbLcHb8;DNx8<VAhDdqwkb*P)FnWEacCtb8p#68gok}tZ(Tmksv
zF7fM{>@$uj<l!Cb&LfUjBYD`7liRm~A~W8O3}dK466fH2Qk4(gmOj>oMrT$){}MkI
zpcA`)>jn<!dGVcJ*iX;qGN)9(d?>$0=yU(CF9a!@Z)E7J$z;0ob%FbM(Q_CSD(#Pn
z!_-=yc6~dCrcVf2agdt@`o4u7!o&?dO>s|rVB$rAQtDaThqCR4e^8n;K*}g>!NIh;
z!}C>OQ4-IN^d#&^co^U~D?nj&8m2pvrJwr`%bG<%Xsyx)dU14%3Z(5Do-$8Wi|)WP
zU!G`+a#_&`qyKk|lb~uwzXFk{3T{wVfHxt$-##^pw;U|Gkb_{>Dz~V3)g4Y54WAr8
z$7+2vF!cMYc=1sGT9;wwb249e_pfWFULck0j!k<k0z1^(N>Q^qZPt@|)sF)V-qe)}
zG-;}`<7<tIPDkqc4??3aB+;Vb=u+h>Swi#j0UCt3Csko?VTQb;Z?Tp$5ZxbW^z=Qj
zO9wP7KS&SfH?5UnF;p1z_A5X@WFJjC5A}#VR6+~Sf-`wX<NHJTk;|87O>T4WLKY^D
zYheA~xg5RkdD%7%yrQWI6QBZWoFgU#5|Nhz-SRIpQ8m_H?G}{UWHc4#oLS<056eQ3
z0@EmgG4Gf?_`jLX6hxYj@>R^*7<mMyZg3>Er=TilmH&cm1Pk4RB5u^_Ij!l3T+5R(
z!hZW2ZlCyOW~+8lxsZXGFJw91KM__1mZIBes|@VY#;E%f;M-s4BEaHLNV-Ftq~4sE
zM9A;euFwYi7^J4xjn){xpy>zhxN~%mWFMCJSFAPL$WQ+AZo6;cI|gX5w)G>2wI6ay
zqNpVI=?(HfK<5mrd#of9`%Y_(l?uEhnQ9S7#YktBC46x79z_LUl0=7Pl>^)k@#0of
z(o9d>{z*1(li-bb-|cRAvWqL%wyQ(;%~2fQD0pJ|AYdR2)Wbh7M4&gNX>7CX<HT?`
zb5MVQB@Jd^&D7OuxpxzKjyyJ>?Omz|)@ne&BU{t}k(9RNlFE=1x+@yFp}GT|N?@e}
zQmC;qE@x#05eCsXAAoCRd$Q!{v=mp?MEG;%KM8OWMLb&#k>Yx`J0>J`PJ$a2ZRoWA
zSEb0qZw=%29V9NVOLJN;+*tI+idp+CHh=sMmA}dGVP_^fWo(YPl+V79z+NLo3%C8b
zFybRlH-M@w-);>HMkt1Z_NdbcdPH^plOx##4~Kb5k6U*sctZCAWXazbiN7l0s)Zc4
zL<@1u3?1M4qdok@*()7lTg6C}rHMx*(N0MnYHKIvPK%bQPlGpG8gPxY-fZJIs(!mI
z1b8a7TG76kHHMtHmmeQ5VN5J9_q%#v1zX}#%i|Iy4d|SN=OtXIRX%ihfZEaxs33PH
zH_W^6kTVQVSNV)RlWMj(2X~I0{#xp_I6<Q?*c6qEMdTP2rM7x~-{|~#ZIMeqf8{*P
zFp!emu@}kI#>EByGRT}Dfl(F+&K$0<$87tJpLqSBS|s=Jzm~fT3Tc6(s5+awo~ZTM
zdb@B51^T(gT?_TOk(!(lYU5iygPWriU@0sWn)^VcoK)Xte<95BEX7rDI0^<%!Q7&v
z=oV#Bmyv3w)VzmIx1X-&%{j27Nb@%-qTId{FA+5Vd26rz)E^F05HUmHcHcpiWNCz+
zoCAf!5(u2sywoxwnw5Gk_81+%KVF`LR$|H5cNsbIpuM4u%DU#$Pw;x>Z(|{Xa*(|;
zrY5R#MB=h<U9lGpf()H584_5uD|eG48G7vpa&-KJort-;k$7fn^Q&fF=s(7OHMTD$
zK&#{;iA6QJ_I~-p%~V#khv=Nz62F=cVMrXbrSX2;tJvhL7!bXOjlf{N10dUMT)kNR
zzspJV@8!fWkQ!!P9cgOlLR%+SC5mwroi62H;%<6PA2mMAnkogD!CE7&qEBcPsANNL
zpx7)<dV@59fpZoQH>)IORmp}0D~>xp!|cdF3CtO@GMbJ*W{0%dBc$9a-VA!fnwpw#
zg7MdhAxifaRnyxemb-50+ri*(g6wGqHeRGncx|@jo!1$0VD&~*YXg2$R}#R)ay%?#
z+|9k_K@lgK6pFBxG$>O6ptF0keP4~^Vfhb{o35FH>+)PVB{j5$?$F>3{&D5%ap<sb
zqpd;Ry(-F;MX6fak1iU!2)9Bk-eaZzkEpi}s_OgxhlwjGa4+56(nxosG)RMVNlSOb
zrMo)>l<w~Cl$2IFrKO(3`}_ILGs8H;9sl6&v)A5hz3L2l>E5)t8$5p5=2pxY3^#v;
zP81B4XDkrBw%2;NrxpOj+lJPkS@F-{<Ya`mH-a%wvi2^&lWxPE-JXpee_iYlJU}4j
zcS+abAxyu|q=v<Wft_SW5AsJkhPs{&-u-x6>ccGu_Ypw-J_QP)WPhEA5>KiV{z?+A
zT;1oAd?ef4zN~wNWXV1hg}EW--h{`&F9bs|qjKQPNF{lm@TW4VhW5mwsk)*+#cwZv
z9ZjH-=^NVIq-~CN(;T7tq!2i1BKU+z(#mUD)g&2f3%T&qigq2xsotk_2hvcavu@Q@
zlx^?hbSCj`tiH5&VoL_{nOa!eyl2jjVm9-h8d3J7lYFGs^ZeZAd{^DQt#ZF_<DtD5
z?r_1I9TiS-=)ihN2Es@}tb1n2zHA<6f-Bp<2ao{bW7%#!IL5m2i8%<-!q1nUN<5s^
zVh)xFeT*)zc8pYg%HQh{Q~;HM0Zwi>|54gitR*ZFy;#Rk1vTKP@dl2XiP-#IQiq9o
zK~dkdA(wuP2%AC}pnBeHp3`8S2l)TxGmp}G({&yby1A)Ts{4_f-=-43`J4rBGpk$a
zU-ZB)A&Q$8RJiusJ2sg5FWW~9E?n;{enz{ROd7;p*ySd7N0r-cmM5p{5K=`|(^OGW
z3ff3Kn4Gs2dYGTon?=-Zij}rvaBQGet4Aec4H+xH4Wzev$BZZ=D{Z837+x8JXT%ZN
z0jd>WfyI9qzp=DWJ0L(_QZ!`cE$uT%y<I`icm|dRBm*P9%~<cN>L7$|<3aPeqhXWa
zi@~Str_&-E?|D_I=vlK8-3DU{^RMWZCj5ZvX{ktHYS+e=@6eB5!!bQ_z{O<C0BWVM
z&m!SMk5eH+BfRk|2?GRQ>Gq@l5mfVQdkmlv%X5w)a164UUqX!unBJ707fuLap$mN%
zQ{`t7-p$yCb^?QRjvLb`>%X|9%#-Jpd`Sl#q@}2t%}@Zxj|>%Huj7dL{#G;H`pHx<
zP^6}o?r>CwH3@InCU;SB=S2&$k`ZJ3(TDi!nSY^@YXpQ4Z^T-T8U|VjCqO%cMbItN
zqnhY8ZA|7^zj#2*cZ~%Ax!J=OTh}5>A>jGK!UdtU<L=7&q1SQVNCC(?NdVPWyy@Rh
zDyLGREdz}FEVWa*4mqRtpbvV~!c4H3-H2*Lh4&B2)^Nw63W=ho0AVP_ef5KwES7y}
zyynM#-9|04!vqr%1rhzLu3^@lz>)ivC^Jn2NHd!VTA!JC|60D{jyv?;HXm}%w4l=K
zX`>@~$a6!ut}#(t&64+{_`2Q@L_I=50nJ53u0Oj=qdz-HiZ{iyu}$^dg;%r4?(YW)
zlSmtkgSWwX7s57wyiSKS=R^26s+s?I;#ajvNkzR;nGG0zrq!L6t|ea>GHu$7E_zY<
zs<ZokG%q3|LZR?Cj}Kt@s1EHWM-$XWC(4=aM$Z5M9z&J@PMi#31EURnS2Ux|65fL?
z7Nxg0pyUhW1x_@bA)jh4!@;#uA1<~q+Bkog*QN&bI|I6YbWKwm!{DqU<}h%pjMU^o
zfh{4m8ML2rBn$quYz}$lNnyiF;zS8RN#ixj1ESx0dsy3<t6PqVp&u9K#oSZtx)l8B
zbf*WK`fHZKeAkRWc}ON-Ts`&GFUwoywjE^}Lza~r<#D#s);wl=DK=8xOih^fNN987
zI#ueFwK+{hgsw~vq6BNL=AZG8B$+wge+C~t!}#7bEiX=b2klpreO`Ts{HOffuqM^N
zzlr%lza1lo%(ANFDhfCVq~Vqj9Bl6zq7gcU-Z(;kd;Dh%3`jsWWL^c~o#_7!dDc7U
z%4pfhErzp|x?ZUBve>~cO@!Eavv{Z8ZoE=XJ-|JJ8v0I`Sw0Vrbt81j<Toi5Dsr0S
zrVjpCmz;b=8cE~ViF&FSKGx=#B^)KS_AP$nk42Ux-+={Tw;gaRl#WfVcxP@bFrwf*
z{)+|<y0Cyt2Us0L_V9Auo|Ov`)@Kh~tf}VK+9k*D(XRN_nPrP4Ct_YGu!}2XgTf9q
z2D3R;&a{LJU7cRMMpw5dFWf23+wK$v@yOUQ%)IhtJ7+@A+VU5Q=NR4GMg<T&*tFmf
zf5sA%EZfBP6abeRz?wmp81h`@Y&Be@i&anl+yftZLU?g@OaBdyi9^FQ4@0P`xZE}^
zP1ZGg`RFeI_U}#}rXb4my+`2GL@giCr7*o-9B&3d3lc9)Cd3+yjX`UPqAH+T>)okH
z{&c!{{})iR`M;_6SGWLS9+O2<37io~G9YA-9QhSrF)(uJw&p~R>mx>VD+Jr|<JP<j
zIe9sES8TFdL!X@)^ycQ`p10Fh+xn%Q>=2VUZo@z=J%{Zmd>Ji}V)8Ei%?`WU*=Vqn
z5`ev~1v-QL*doYJWVBUu;`FU%Ty<%y@l&FgZglXmJ0XY?rNjK^J^xP&K#ZJkc4v8g
z%ntMwLIPkDUn(KyBK6l%DlXNZWxH+YQfDaW_1Eb)u%>E>tiq+(E><0XY|zO-fn(=-
zjWp`oiW7r!-_SI!qaWUS_2iFe@JU(7ic-O4nGn9AS}8t;yS0!cg6-e|hD>>^0&HX=
zfI1^KucSgioMM@4dEF46g=7KBdub`#0yg>dt1U4c6egM)S88am>onDECB8dW>XGE_
zM9?TVw?UK1(_iM?zbwO%l+uRu++hCBJbef51S2tRf5&C`f~;s7tc=R-pXA<Q8@g|1
zDkp8X(ZucPncaS}OO#Ijl5bSlb-r<%(n;HE%REN4rGv$U5(fkjy0>F<x0nC#W|W8f
z`>hQPJN+3~(sqjRa8<4ewO#M`4i_e!NhkF|;YPswklXB9mv$Sv@$uCFuz8^h&}8CX
zL-Mj;_Kf983jyC46jTd5?635e(*D-P=CBNd#FbP7%G&@^vdNE0Y2%9X0WN=n{iNS5
zjLf4R8gdvvV72z?qu*8>lw9%(4z^$E{85u1V-aX2eYPF<xYOFzu_O)0UGaSDgIi3A
zB(+(0`B5`07M>`P-jR=MW1ZY^iFF@_z3{PPKCXc&mt<|DVRHTall-1&7E~~G{;}K1
z+esK_N8jdjk#dZiYFfTBF7-%{lJIW1A?`GZ!b$)6BLu;`eSKWM`UN`U8b8P|wgXw^
zI)?Wy)d$BcG?RGTNSO9ZexVSG!rcHcRUJ=bu_rfTZ?KM9bjjKR08v@_K%<@Ftcx8f
zoSI|O@HkhQ0dCYQ_#pQST>f}X@E2CiGruwBrbmhx5{tm|%8nE5_&GlC^DjXF1|BGT
z`1WtFINb$N?AXO*-0^|CDMD7JL2Bm2V5x~(pAO>WNlELJY5r4P9YfnWs7g|=32)F;
zX}^XNa+Gz49!tr89Plr>N|4L$ZEu@C`E$h=TU)?IyTf~LoAEdqzmZ5U^8Lq;1ooGT
z4WDYE{|Nd-n8xQ-Y#@WtB9nC0bA8999XJfhw?Wl06^NiP`hLUylsZ0PFn^Q(a>d=f
zUdT9ld~;8V63&XD_afLJ3ylt)XFcAK#8UFIs_+@{I>_b;Db}EHRHzrHG{J}Gl9olc
zb*F|<{nX@2>?E?4;tR<kZmDizW#p(aAD{#*fE(x2z@{}&N@%bW9^4a7r29PMd-Asd
zYm86;<N0xhBlmAh;T0+M;<z`(fkTuvU_J^U1KM$3;}`x-epPHafYUendre(Q)ww<2
z$v#<gE`dEtJO?!9%R6z`l}#VSF(J=TBse(y<-dQC=85{qShH`TKzL`wK$gd}cSQ%L
zhj1E6nUjW52PIs)#;-<ym@1+ho0e7&4gK;j!<6^MA*^rMPthFF8zoY93kvJ|iH}2D
zme3Ss#JzdE`{|c`Kix1|gp<QUHuLQwHqt3A?=3)(X)|DH>yY;2t`(s|7P#CxuWBhs
zK%!CP4=?&DQPG<iX{HD+soLxB*c%_(6~(f(%6kOu)d67dBgl|**bE2mE~D@g<#0p!
z&shYX^2P<ZqV_C~=6NbB%Q2K6?4mgj$QxT*W2!PG{GFKW%Xx?X8moMD0DF=|dWIyd
zPaHYF@x^m)Y0TV95yo|z7$-ulO!ugv=i^1{_zLvzop*{YF~7|QT&P)bX%Jgt=zB=r
zOR`J?s90Kqy7$t45Dj@ClUx7dci$Se!EI^Z+xG_dlHuu2lZu#XJw0lp%{44d{-`ku
z^1-}_!gn}H0i>lCfitztbls6dSzk=MGeeGpCw@xc-Pb0Adw(&Xw655`BQXs&Tl3#n
zZp?}vZ>$TKEWj}Ch_*@>4<bfXu@Xo<Q2~|UKZpbZMinWVyQ@UdIL$e{f_y5*ur`1R
z$mUVQ4d>9F6{*`9@mEm?UGr%Nf1o7%C7J)BgvvLO{Bu%fHWLjPXv*#?^PJ#+m|8@7
zYNNy47OY4AW9!E;2!;hc4dbD{WK^IVQ{D==N(kX!TYgG*diNHjaofY!_|ctj=!)b7
z&!l`k`g)(sN1@0}1)xR}t&1skvaE{-1Gf2lT_kt5me=1`QiXzkpmN?n7o&=z7@#}H
zSkZI_y|=+YLgD6CmxbHPj!M-3QC3C+zutv|o*}=efYu-|v@@x|(wJd8=3cTwdDF!Y
zY!;e$SPYI9JMh+1Ctwe4`Y9ojl-cqpg*PK6X`Ul<Mg<h6f=O}{)^(K0sKw$IC-dY<
za0%Yv8^(SxscvRJ6x<g9sG=KC<4kvN6GbOf(p3*lYYv229o?PdV96<^SOF;E7!KRY
z?WE2TwpJ%Be;3peGM*WSXZD|6{LKje{d2GHD4X)YBXjO+;+gOKk;)6))`!F|xYc3{
zK|{4J*utW}V5gMCpJ;xVj+n4V!tCMir6E&kNOmn6cPvjxgeqY@7Dn#^gYgL0T=2{&
zz{1lz0{OlLw@9{ifNlv{Wz?SPjN<oR!Rn0YUYf?Xz&_H=z>P;uN($~yqx6IsMc`8h
zIcbtDc~Zm~p~Zq7^7YSX_Qkcl?_4LFDop_jUbUdF1m}#~ib_c5yM~#YRbK$>_@{J#
z9r9uEzis;<;mmtQ-x{lUm)h|=9ItzrV0SdNH)8|*BbR@%;@DXa1Wd;+|HT(#&6OzH
zP59Bq0!qg?ApFC57?{}mUum&8e>}Jnua@Bw>(emkiFNLZ>P*y^i|jk53opHp%i<g4
zcqzXn-}LV{saCgp&Cj=`PUP?J>&F}6I*4yNg3&*Vw-0V!$j)z-3Lvg95Z#9Sw?eG&
z4DHgU`uALi<>#%YO4R3oPcmJP6D<=%kCW>y{;T<i5PeLX){%rkQl@Ls9Yd@u&Dl)F
z&`F-?f+QGzP1MK`#TYIz(lT4wO~C1#Pjf2!36Z9fDOY6`Z#C^RS!|mwcY|megybn1
zbKTdOks`r1;N6bhhC7o_AJF^uwW2+oyHwdqB-OoLq`gRkMm)0|S#Un45Qf9e{9H)5
zm#?*xrkRXKvWZtT?{{M;nsm;3#z*WpAGT4Hs@<^yx|=Ob(FLk|0lyswuZh*wGLP85
z<gc(NHn~4nInQU|;%)}9F4M!5Isz6j`ZLB`gZ?>^AO!WiCljN-`)acf0Zw<bKS1U?
zLtK;ye{AmrU|nD(ZKc;Vht2!ja2huvFmT;^3QaQw>5VTqC-f)TgD402QjiyLv<yz+
zA~D{gkSH{S0o_rM@yKiO7560{L5l-MEO1{}?tU;NbO>0ozPuzuRq`|YddLP1W;hxJ
z^%AdHHB>SfoDhH#yLxlHtR`%#ry}m}!{@Rb)yfEMsw{`LwMCrAv<ethht5L#KQ<y(
zes|#M!*6v3I86xP(f&(a+;hDl8b!5JWkEk^Jsl36VtYxk2ni$9!fr=CcZuBeGQw!Z
zjAPG*Y<`=2I&UXCzN-Jce@J#h3CvFs-7xNj5`^aFopoQdW(WW!yT8qW7Kx61nQJ}1
z$Y^6~G2V!8iK@3|$TLlhW;!~@+XsqDUfic+GHHX1s|(0+Gw2$@d)UOA+wtz4$(s+~
zG0Fa`+)b~~`z?9ST41~yCq;qem{1Pei3+V8Bh7lw0VvFSX5+GzvDZ~Xr%F45qN|+S
z!N0E3x{Q*cCSb(fC|Do%LJD9<FWeGc-{|kHZXXur4$&$NLqe8kJ_!aloSXUJ_);4m
zpi;C8RHpX|;M|R!s)5|2nXO7VwoY-K=H^lr&osAcW@zwZRfRs=Ets{qz{gSwCzSgw
zq^g(<s&{WZZ+m^(w((Jxb7s30K#W~e=3%_}nxpti;TT~~8;xmS+!`41Pjmt&csYeb
zsJId?rEaDQK{LOR3u=soD)&1k#+}mXliAimL^ZBv<F8hl1YWLKOfNu-&}<~U7@E0z
zLIvxWBe8}z6eH?0w?waP&byZ;1RK3iEP!I-9w($yMAr&*T;IKdBbs8Z%`eK`i@Sg+
z^KMMd%vw+8)2zjYHr&Y>h2EGKl13C@XWg)*>J0KXg-2T0rj3+cL8bTvJ<A~c5*s~~
zrBdtjy#-VH9qktnMNu|7ZB#7wz0~B3yZg_CSX(5!^A@yIC902;$kUr=0)XML`)zes
z_o8sAwVJnuUpcA=y_24=3uXQ%+x*Kr!q<wSr_GZn)__#Cm!-kC0qr$g6ig%I8Z51S
z$@K9(%EL{CH4>7DlnKVeLS9p7<JjQb>d%>$AEcExvHoosy+aiab&tmL({2?=iL8%p
zh)*MU6x3}Sqihf61|9&`@MpmIv<GRjMjOo0KM{@3%o7DvO&{DsatmO+qU>LUCkN0<
zm{P{f-~0s$zC{naLLjfcv!e$h+kQ9bq9->}NUiWEad4etnn^Wq|M+W-r-urcsVc8a
zQEzFdK_!mlzWxk%=Scsm4`uM1TT&J%ou90UzC?-YX)+az;2pb3&=okp%Q)$5yj1FU
z6DkC6APvkXmf7xzbo30*m=wkz&SKHLii`5nx(6d3QcpL6?<8CnXwcYRG3x+K<kIn!
z8*ZEA6DnH<)b|d*<<V@W7eG)3Q^YXG6~g^kqm8`u#EXCl*wVB6xuWNa?nU$Yjow+Z
z!e@QI$dmdwr}4?=2u(<)3FWT({cU^)e0WX;z;qUOzy|{V)cl;_tfXp{>KE|>Hp5T?
zv&#qnTkvsL*e0+7*}&gx8;>N01PLN9)=i!JS%TG>{rQ~_7xlJXwrNM<`6OL6N@hGh
zEhpv2CcK;}y&2`U&kVcr&5x=rH#9A@nA=RE9}9|9zxyTij+{GrQ8d<)@yY#0E;7rx
zl^Fb)un<0MLIneSNj78~OmmCut7{FqA&<0IbI4yz(UkWdxjx40czt}$Fa<`sc8N$e
z0xIej_zzOtm0Ob2?Vn9iH8M9$gyCNr`w+P<$5Eq2aQocud$;XMv6Sz>f&8jdW>NOE
z80y~&@`yVft0ED$65&&3*x&*ejrl;CsdbBaN>mhH(yR6EU_7cd@Cd51#WAC`E&-hs
z0&T4SR{_eUy(vjT2_Z;akOf9n0=H0&{xx{hvf0MBvPReAzJb)_aP7MqMI7?YB2g`q
zG?5lITC?6E_<MZ&Gr;|eJS)$<64Nlz63hPlQWzq(g-?-w_Jfk5@@-g2d`JC&2(xvU
zjaYknyyCPaunhFzB}sTXhR(VF3wxk)AU;0HpEf7q7`WdR4h|lhURvwq+OMDpFX>M<
z<AMXL410yEF(Gh5I!^*HEY_Qrh6?oHgK+0j9sc^38sNG>lo&Gsp~W&%v=up}lf3KW
zeFM8#e*PeUIa%oq3lfcU&2jR7UU~z7u=+5y`v6>z`$mmb(;b6?2xGEl7NMB?2Qd^u
z$99=Stsh)EEQaUZlTrkqFF-gqdRB&jp(}<#*=-#NgR$MF);6FjlWGh%xY<Q9>@nvm
zRy@uF!KXaRHvRWdge^^*i`wNy)u<}(8q}EjA@Af?LE60oJ!cG8{6FJD9uBN2e!^S+
zzgtm<e?z~(FTHkbjvz%%%Zoa2*)l!hf|znCM<q(wr&N6dDCf3*j@ddg<v&3}p2(s6
z(670Z*pizU^fqg-*HUUW+`kkj+56zNe%wRSOsLYID(6*tF6Dq0wGO1kodrlsLg~Nk
z0q6gTIA*z+o=o5$qWlF9jQm7Hrx+JF^M<|^=$YYS(?ELpi#Axah&&j{TOirKWYHz)
z)ZAEb_vWLxw+vd$vq|A6R4EObf=^K;D1v%1Cl(JltAq0+SX}|+C+v{oaM7V%%4egd
zJ+GSc)sy`nV#nd}MowA>x)6}0_cCp_+-=`wF0Lc8(krzWP>pOu>>8GRbu0G&wm(1E
z-@#pu_*Vx&!;qwreb&ssxdMAWP|lMIxHbxG3*_x=?URm}hwzSw!;$rt=sV_$HVT@L
zNWj?qJ}VSbwx7D>z_<ql$>Vf!2;3(3#JZ>yMmGZRL*Gtmfh-Xr@t)-&E>7M?73=gP
z*?G$6jxIf!0wS+m!9Ag17SXRUF0e?f*1-91xyd;k)!L|a$+;paYKQuW?0pm(;qJ-S
zm`Osdo2cqua^FqgCm4S6(OZOQb;>T_t-Fbw70S-J>#}EKlC``5Pv-S0mgVO^L0QAt
zclwD~pQQ$^_*Vi%1un8}B-$0iu-t)x#UC_}wIthtOn^$?IY$kC9|U?!;ZQ6tpjmJh
zg7Sb-Zf$y*cw5|rupoAURu*M{p%Ln~Yd@WAt9|y2oQtqMcwV+;^uCUc?Mv{VT9V7R
zoI-59Unbe9da<M8Q>JQaz`VmLr%cqFbU@kr&b}{au1pVoBX8gY2(XDVyP0?RF?o%3
z1vZ6(DXGTzH1LzSw*}JfDQcZ*6sD$W#F6f5;Cw-?Pi8ygD-(Gmgfs+aTE}$c_Y;z)
z1a8@Lghbr*{P2KTbIOS6S%@@NH~mR*AySL!lAxypxcZ>;VTW4QjFM?q|1zvzj?vcp
zj`8DcNvwm;qJ>@?Yta!9H~oEtAxoTn<$s;FXeuZUrvj7i>BksWkieENbiNb4(&G>F
zQT6pPYn`J8x<mskSYg-;iuGxA%jsn*uS2Yv;<0AxL}!&)>zne?)+VoY_NU*#1VVY9
z;bMJ3eDr4i*Q9>kg?TL>z&6C>_%%9BT*aDU>u&R74wSlG0ncBCR!}t#=8OWnf9^tR
zvL;6Us|*kb(g8oS!U3sD*I5Y`WnZSeGJ)m@qs(F`6Y8crJTy48Et9ib&o#<NVq;1e
zM{b=C`?_5KRNUVH<y5nkqz`}5c8^*GXQr`CJ7j5frH(y2@>!BhT%}zs|7K{%T(;kM
z!EqocWAOr9IPNR7G9BH`Pl#WSEuLb}RUJeNtWBEOCR^I~uO}H62(<PZ#zMa6nw=*n
zUp6We?mlK|6YqJ8#@%8zCJk*4`!+)!qnXh|4iK9aB>g0Mk2&Fd9Al)&hX-0M4~U6S
z@`G%b)gsXtrY>`VoBt)9aFudV-bA8g#i5ew2UVWRi=NDTl+e!Nb5e1Fnl0iZBqgE?
zea3WejO_pnQ`8TMoO}()M!yy_GBZ<M`cJ0fi_;stMEzahnli7$N*F4jFiOUxk!@Z>
zCh5##5sYa{ZlX*7B21y29(EO{<#!1a`))u2q0#js)p_0hgR=~|tWgW}p4>yZM!foU
z5BR%+78bh;M7yvH1N{D@*$m(q0RZc*=IQMs3A1jSHhkHqL2dY35=7(hQ?}ns%uyFZ
zNG(>r^mfmc=Orzcjc~r2y-q0S-bf;QX&7K;o8Df&1u`T4(O%`5Z*c&%@|K{PV$E^l
zJ+*R1+K7u}qNt@g!Xjh>t{|1KJ#14#5HRD0lt$m3CU<qT5*K%DihEmpfox?X1?B~~
z-~7-<3uvx!|BG-Z{ngW%a@RFc-g0*r`7J2+Iyzzng|9NN!x_-jsl5CC)W!q|ZS?{j
z`QUd3GZZ4savID!<a|+a)r#eFETir95#D>j;hP3)a3eEDUT5!Bd?Xh@$Z(wBJsH7w
z{g0h59VbmLya{Q!v*ZJ6BMnrIa}c_3|HAg5S5Xx*{Fcsdarv_|c;h72-QHASpXE{D
zP1Wt`HnH006xQD)id)$tTchiOd${#~c77AT%gs+_*5Vxs)g_?k$KeKw-w2DRNCYT;
z&_@hTp!gw(C*_;`1^TkiY|vY<cNE;-(k)wqN~_S-uO~`M4-mn5)c9@^RyVcUcY6vH
z&)%Vn){kmj>Zh>4?A^u3u&RLY6Ls}xvVXrf4Yg)?S{+I4M)s%jY{0t=zK(YnG>X=G
zmot3#^=WQO@bcD}Z^@Z-dpQe>V&ylU4@0zQ8~Zt0PM7w|Pr=OB6HuHYPhz)iO5!3Z
z8`u*|qMPq|^Z#bwcoUJk{(%RD+HVs7Jlmn3EO9j}`%{%`67E;k7YpxD$5Ty0&$RU^
zfoPLKcX~TAi^&XNRo=npoTTb-54lP;=98_Ea{j~nzc3>1Ciu$q-9Z-9F@Q{X`>W^_
zfLyUFx^4dm1;c=yVj9GLN_*4oiq_xo_QOZYuX$=553a4^>FVe_lXR!Kbf&k8(X5aW
z#<t+dJ`P|S!O33Il3{0s9lQBN^sw2E7SU$$kZKd8{^od(>y#a{2VIhF%v5M>e8%(G
zpcQ^<qH})F`8G2}%^MHFyyIaw8g~4M_56{hqvD$jFatqorZwTax@Nl(URkv~K3G$+
z#0M(I0WJH&7YnW-AkCEDv`c`C$W7#lqktJo?HZb|OJrnYL?zNUhPXw0me5;rp&kp8
z-fmqL`b=~%#ydnw@~oQGWEGSBIbugJ6|@4(J|h>()WANF3XIsc0`5C}7bRgQl8fMp
zACW-Ev*aM{`wCF?P1GuZ&%7kHOpF80#YTGx=8Ee<Mt<rcZLA!*XgVY1Zep8U#R?<7
zi-GLQ5Vt1ro3@<@F7MGIWWS-ic5z9-99?gs1Ieu0?x7VV<1(A=S5mm_VfE?}Ys9)K
z<7+fwgH6Yx|NC(HA!se{0Ql-R!1%YS9dUL{VgPV!kJRL=6QhlFKStq9gCl3j?wVlU
zcWM^bm#&*@eY@m_QkzEZ_BpU#2qlx-0_k67G0&LSQkhS0hj}Jz{JU4?%gvmQC6UN}
z*hFCXASVNKs<LC|GQpxe=MHYcPdyp&VB0U6dNT6SS@y1%q=EMImpuJ^ySzH#XVmiG
z#9#9(E3M;2$9k0hBj!hm_CGe_{hE{AuErRiz-3p<;k<S0$uhG!Wp%luSq%mGjWRW#
zX%a`$OPgq_&C0B3=-y*Fvg9ZQr=1JWd7m$@SM^YQfX$iugl4Vit7-0M;2S;kLSQaD
z0T8KBgn%5v<_~}bRV)vg+7Kpy6MMB;)bS<X6(c|2d-X0~SzuygIsG1E)eCzY%C)(6
zf$Q$hVt4#wy>kgJDnuV<M>^|*bDkA7cSO?(82fo~KT;UZ0Bw#h+2@Ee;CTlFM}16?
zDlq*sg=jcW{^7^W)_T}tScHhs6RskhQ3QiqOQ&Ah6a@u^zqX@o@?*ZK6N2yY0`ph{
z@tdqa^}7Z38*e06SPCWnhSH3JsArO+Lfn6?vF!3A;*7zqPF41|NF;urN2ToMRA{E*
zmJoDDJ;WLKXLI3E8{%N%dQ!8b(5e9yZMz!_OFhHpPptyP1975Dpz7pY@8+t$hv;uc
z50lS8>5o(TUw>>I*0>M2Z~_;0nBj66l>ZcSaM$8~?&LL<rIP8HEa>Vl`L5*TAaU!d
zU|ToIRQ(L27;dQM()dwr>1#|nCWFFpy=6@H4`kI0qyL+3<XRd4%XXNk419CUK0Z#g
z?KXdbqeCEP^es5hWHtW}{S-Ti@LOFPa?Qysiom?@;6?8fV=wu&0WqMh+E!#t_QaX0
zI$~?}=7*{I$&ifPL>uC4F~5Ef`Wa}xZMO@5G6x`$IN77<a5GA?-{(j0>s}_z<L7dM
z$Lq?^PsNseNF{><Y);CBpz3IPQDmvA-WFQ(a2$9$n<nG7BeLE9rSS4YrYVlH&$TMC
zuvdT&@@Qa}HEP83%`S0nDr%3~rteXb5lnYjE@D;Lg^t$zAmv6XC~4@O+q?IL)g}q(
zjrfM}dugy@vlEhXyGy>q!t-)GjrB5KfYPJ^Bi<L`>%=@OZ3Hv$&3R#HU8h|7`%66<
z({I6og_piYpZ3yRw*`<XK%lBkBMsthf$T`6z?EQDD+ruETpRrIEXrzx9n!>_(Yr+c
zxjb7VtYOnGIpZ;t#bpv*%roVWFZg9u68$%*QCmFDxSJ!y)^zP&*xb1sE`R&0<Su?L
zIQ5vZyOTd;SCGzD6(AYL7!ns<wC(p5OzwREYMvU*0;^wpSc(he&}6^5liexuz8<Nx
z<W^5d&J-I20Y>c2zBR(Te2(Y*Rt%NkN4s^AdBvv_`P%zj|IFsc?f5ReNZS+Rtl<h@
z)ah;FcQ9eBI1=4ge6$AWn&}^!@dpKEsDO3gLJ3VT1^_TlyH1@6mwwGG6`QCd=#$Ex
z5U7DY<`?mt#u@^9&y}e)@Xl%b=yV*GHR#FLGo&xa;(AV!QopoC!Y4@R>yaaB(@%<3
zE7js176H!Zx4o;V|E<z^oeBB2Cm+w0<bJW-$TDSP&!m^KlK=TBmj1DtE#fwv?!FIG
z+x-DH&riLA1(8o~93ndG2&P2j|7-aCS<=rsXVBiB03*<J7)&GaKx%pxGmeh4h@@qJ
zcf3-*(l_UdzJ)qnW8%kp>_Rl*Tkz6ntLmpzF?TwHB{LOKm}4m>Z<HV2{yhn~z?AFD
zBB%p`1$Kg?RP(5sEcvV6b|}ySSOuZNx)bqAsz#~zl77uG!AQFLn(bkEF&$U~|8eM)
znf4U$gm5Z7L;U8um^G10KUY@%!R5r}{$vvZ|D4?(A^JoiE3#u=hoXrv(Pk$lEomd;
ztz{yyw(>0l1$MD)Y5N{&yzXHe-131|h9p?eSmJFutBP9n*=?Eyow34Q`==Kh5i;-f
z1se0lx`mmpalxLf0sJ^7Xryy}Jol^IDo4~!0m)%iTLBJ`b&9INS<pAW`vG`Xszrk7
z4CrG5oc&r6xPy&)YmA&RmC0VD+pyrjWKQ6IfZ>^X2~w+~|9eHBGsuTKQ2MZ6_r}S_
zz?5S4k567~ypb9}pJWh#mrCCQerd*dmVLU#_(1nNW6f8MyVUUhq6dap(7BXtjMcl&
z#2WI|DRDgq^g|BF_C7fZX4}_Za>346vMK-UfHnHc?_ZlFdfT#f$g8)L!uz)WpBCUW
zfv_B$kxrftHnXALJ}r*PT%U{d05>oPHlJvf{;KqcT7-P8DH~`0ZVWH|XaUB~?r=Vs
zy)02kr(T5sQFSoo)k;2g57yh^gs|!FC;@$S@ScJ6gx^1a2Q&l)tY>I3XzTnJQ<Vn~
zYbucVHk;9YfmQ6~)|HJ(95L=%X<=WN%i+HH*nPS?$xz-OUz}r|1T24)U(e6`P;sEl
zZ$kG5S-!i>9#@bmko9Yf6x)7Ji_Kr+G6dYjCLRoyA2uF1z#icv_kOjQ%B0b90rJ-(
zODp?#07M}1dqi|y;yjo+E|QXSs2+FYgQcU%2`LmMbn^g(1mw<V1SS;`6Vm1gd&2>8
ziY}fD)1dj4F>aUlY2!`A%KRX(B*rn3Bi>1xWaM_%{dz>P>^^Tn_N<NJ8!N%ZpI4dw
z@TY64)-9j@zVA42K7<*sYFX6tQ76}?k*iT!bm}?aGDVP&fQh8>1l9Hmq_f%^A6??i
zP>IIAy7K?;C(j11OB8i&)Na5FzDeAB;rQvRb>+O#(K6w5(uJYZ@|(#DqtYP1exXQ<
zw+(Cjbr95LSJxt!nB+6?p4R=_WjG`)wxJsn@(+1Pz%oSo_p7zi0$7Q)G;VH>OaJy}
z=mFtkJeyV60v>Q_hPEEX6ucj*$J_YO42~lrXW_+AO8qf8O7k>!<6FH4TDq28>>GI?
zkSkvJDXQlvit_!eRQT`Y%*{Ke<uf+v8{oBDPoo!jCjS68{VJYkrK4;~1O1HMI~~Z-
zy?&9xcgof=l;_U_kNgDU1%*aq?|g49biK65Ojotd1?!lrrT$TE3#2EfNxb}fO6H7g
zkND3`3*4*!{nS(Cd5$f6M1}5%`ri@rwpYMLa&lEu$YROkNW6y~O(XBAKAA<{%$X2s
zKHQqEs{e;F$zIk+ROu8t#ctk->eigLLbNEaMpcr(_DVs0<OR4V<S-{{Pe6I3o(5D(
zpM$hn3;~e0eG%aQ3n`$7m3;hO86?Ixqlj-pH;2bRdh<Z(D~v+W0*A96ZUE$oH%_nF
zt_J$0Eiy*QW-f<8&l2#drb8CQL+hMcKFjCw-xEchg&%x6EE)N9$WebAgS7KF8k(Bf
zMoByx{xCfx!rn9`vxem}mC0v9*cA4TGR_ddv^vTpG^Q!X|1bz+#kB;V6sV=iy_~mL
zam&1N3BHgx<}hdaU!9-B=%*1drvW4#{|O?$B9^axR$y=b_n$Bf&$}q8$|Ew1p%8>(
zka6I5W9V`--JKD+<dS6zh=s8UcC2!bxQ;20u-W90con1zYgYg(l99&)bk3ebLy||$
z<{9`6e{FX8RY^rYuf+o{kQjM+!Co(<f6^2G014-v;vkY;;~HX3PY*a#kXk%Xejyj8
z*0F&scGlPYo%~|RAcY6kp%ECd1A8zn<hOm*X!ELq-tWo;BQQ@B1_2fFTh+Jf8=VIM
zj?d4(ky8zV?;D8@4WpjIME5hZz)HJPc80qkmuw*v?ewaz3Q|&1yO2L7`=NFNT(v(>
za?&<5^QQ)Or766}daP-hJ7q8Q?~c`P(;n790>XWd9tsUY$GNYy!%vYHc~{wh_23TR
z&EzWp*m(TxZR&j~($Q>OGP?g6@gh5|il3;!BKUqic8@R!sQ@FV3_H{F+WHMk*6(ZM
z&v;C*zlP$=lW*UwMiNvw#iT>%=E~oD$DCLb+OH6i0?V~k6Qio6$61JNJG8}*S>Yb`
zhj}r+S{88y<BS3n(bPUz$o47${=iGY?SVs?M@7Mn4?i<flE5byu|X+l#hRLqI<+B+
zTb-E7YT&y9fQur`_F6b@*D_d##*T~2h0S#yxX7|M0?WNWmpdHI_1#1~3@3de1{~0L
z*TmA?+6;x?4ldNAp3|@P`Z7C7fjl_y-YH{+N7y9qg-1=J?@>EeLW6UL8WuMbuoAxi
zW&s2xzJe=VBre}`xn;^LO5*d`n2&Je>XA&P%4^k~=(|!2q*B)bdRR-^5N+%+UjW!}
zW|*R`oDjs9+Hv#I4sWp*v?XVuV5og}ZkP4u+=u0h`~Zf|407$i(QSxGnN@vHP$h4g
zp20_2hn5XA!WAGkEI)v=+eU3~NeRtR4(sRtY3xs4HTFWi8xKP+)ciH*t7?^0Mp(B^
zBEV6cY5}g$78+VfvKBK$tyVzVlx*Plm``)`8{D}EXA>h{OzD8hy_-lX@F+e?JA}O$
zUua3YhusK^cEI}RaT354!RQ}OJD+{A=rCPb7LGoV)RxVA2UpPcMZx&0^*~|v`xQ*q
zi?QZn(m(#jLLAsNzd9H6T>~Y-vq+t=7PZI~JgjOua}_h))dT7ALK@y@KHroU>eYU4
z*nEAH?>?6R>*aqYxA}}SOIpc%C<o+eiazEJ{xX#=u?)$6UAiR2yn-t^_cs9U^9K|Y
z;Malu?~b_N+@A5+V6l?sVND5}h;C<FYyLjs<h;%6-eI(!(%ykco|FH}jX3c=6GyBp
zf*{sVS}s6T_)W5l$cT#C5(o|<AOr_btN<aW#UzgNlYoL{C4^cw2=Eqt;OVt>B4Ovh
z^Y$|ly|c+Rk&Za~x`RMT3W3WO_;UP4Q-Z;bGKVaHA7;5x4>B8$uM{D8Rt_Dm^Z`cq
z#?4ku2OA1fdnqz9XII;}AuLA=0h{@j%I5B14Y7pA5?ks{rytv=gv<w5G3TRh7i)(_
zwabUpCTqH7U4yw2H0S6XPS5XhWRIh--__*+6A?KTwoF!hv}z-e=VfPqK=Qwn8#uo~
z;-c3J1&zpUk0`UumX`cK4&U0=($v_pbEtqEdF)0zcNRB|1p+YB0v7NPR)U_Ronj8i
zs1ljqJI2_u=)xJ3ysVg>*9*O-h{8*Zg}&y!z7K_6jJNF9PEG~*&3M)-gLMh|Sc5c8
zU4fxb8`D=bP&L}m7iS-^SjZ4-ew|vLD<c7~tht|ae`b(G8PO`Ym6KnFtMi$#3v0pL
z`=C)N<FNKk`TcRwo>zXy_aDJ-aBtdVPd`DNwyh2=y$PsPEG6F;vq#~5!s@z!gn-{{
zQ!RX_25Dh9en$dTHAb5^W%<Cb^1i6)Qd!~u|6kiu7DhM14x#Smlcf&oznE588dhIZ
z_{X=bf=Ran4j8B5j<p`m`Us0e{TP2;9ZNPnk;?z@1vHF@KG8bh5kAhINh?^zI*ljE
z64;h}cN&*83Z8)<0PVDxXMkyTY=381c_X0;bh{L>k#!!T0yIyj;oA<#x&#tQ%N}|~
zwh0id|J5i2>5sK{=ArMrC-EvCCBH`y4^qpSV)tb}a4U%;9s5S^;pOEZ8s*r~)C%OB
z1rEVGtl2BSgxcDsdXO>->)rh+x~>VLZp=z<L@_<N%zwvi1cCkFo+A0L&2)6xZeYCC
z4!1>Gvz6Sx;h3V_b}aq65>+{+J!@<M#f`Ktr7poI;XfszY#tk|oq%o{h5=1LDMUH@
z`qURX-Wfr7h54wj+}k3S!?=8A!=T$8zaGkW2|4zeX3M0qW;y*fikIn<-p07y%~u@g
z8T{|PdrUh0W6boh>MrA=yxD%?4Ey4^Y(Ic=Q}>oneyF56TuPncJfld0Wj&U&%`uU-
z7tpmNC%05^*KdqcueG(ISZ(#JsHI#O`yikzCYe05?ua*13B7Qkh=XiUs2ek-RLXsu
zBif!mqQ*jl1DiY%<#YzxShk4=4^>z&qkFY6TO_(aTSV%Avj&bwSFrNGkQ7&>#cFuE
zj@SJ8RG8ZI5urG>QQMO7Biq%<dU;|JmQ?#L78&&p*WAF1uaMw`gzwW=wb23SOx->m
zMFFld%chVGv`BiG$r>nvuxXP*mdR@9ICL%jwcZIFIo3W_rWeapS3l{=pj>X1J%cy-
zw=ssQb+&|pt7RV+W0Rf6e~i0559rv+B|BP3?4K?unFqW5l2^5TKYmCOenuRX#znF6
zYl&&h%9amwo-fH+*%f&t#fLr7!rk`g*m`*7UlyOnoGL(6K`||V_Mhea&we(K#fwc_
zUN#*?v;Xip<jH!2tKW|DSEnw#gjp7GK>&$wnqk4+mZAu;1<@9y+b2AAdR1WSx>Q{$
z%S0!nPtoLUwu$a40h*^eEpS<y!TtWD4}f&bTvUBioBYP^FbZtBuj(kB0qJ!KHYU@?
zN%n}d_r%cYRa;1Gi#6L(c4*JcFY1v9b;wZVK;>8_QO3}y{Uv#SE28#Ur}*)cUB-!(
zH2J&Qc58r;*!W^jIPss4P9OQx(HHzzH40L;|6zrseMqx>CvTr>nm@~`W{%2|yvb*-
zljm;AIG-N;*7x;70jpFIK~78s0h*hQR!%mNGbXI1%H84mhYG;*uV2)R@K>gDOF5|<
z06KLd-8I1-{sLXezpH&-NcSyi4)d+AM(fZ%^yM*bx&E{(#lC4v`vfFznrr=W1^e$E
zHSec2;ehu`yhuEfg%9j3Rq7zXMcRT^Z28)-JJ-xJ{jS0Qz5PeHR@2TSa~geqz;L0A
z32Q^q3d_RVTom~z;*s;BptHO!aej!3CMbZkQ>+0mFv`_ak5NL}&69Uu-1w`stmPS&
zYmM<N*-735iPFU1%84mp*animKRsjo>byw7o_d!GK!snC550hhG9MF@Odwik97=yi
zkp?O8*3jVreD`B`=0AsKCyNu>7^7c+Tq;0i=t&DlVx!%DkznN_AE1FLSf`ZZaQ{vD
znEx^!wkmmbDuZN9d|`;9Qqse6xz?--hd=f|5X_$zWO^h@@{yG!Dh~~)kx}F<6x2`a
z@E#aXB86Fjun6P=dC(^NneI;ntQ>Yx%)`9Y!f)Be0}#>bQg?loHmwBpAvEM!CMpq)
zxSbiiL-G$KMN)aTT!5URBL3$BD{%XT4z?NT$+Xw)B<BET<%?kEt5=BE`FE!ay;J#2
z(?YLR>E;7bGEYvQ<3{yo;ml@VL5SN?+!Hz_V_#HB%P2B*g(V#mHm6NY>eoU3FLFXK
zBP`MxX~^AQvKp<Z<uh>_GDQo@ACggt&<iw81Fpy}ir${d&p=x_N>yFdKIYSw;fHk}
znt&GXpAL%akU#awDqi~c2Aq6h-@F~<;B--f;JN#K`2x$54wk!<bcNe$OeCEu_RVmR
z0-`Jo0jg%feb<|%kQfEvmcz%9v*mD(xo&z->^w#URLXku1tSI^75DTvAEbGGPKh`g
zUrE?0quRp^CDZ;ArDvNc?fR*&7CxbBOJC?y@S}V#tBg|rHhXX_>Am;2u{{teZH=a$
zk6?zjk@*zIEnC>!3sAApumRW=4%l2j@~GJ}2}SAhlBUp1<I_D8$UWB5j%9-Cm8m9%
z)#uo_u&0dq0Q}Mcq(Thf@4h?TC_Sb4<V}ju^(|nA!|rCG8@-CwX8&4TYViq!$Dm7N
zo~P|POmv>Z`)kZSr`^)W3y^%KN%2JdHdPO22bj%P@cayuRb}Cb5EwBA`Y@~kC5l+Q
zZIU=3%wVYR6-n(X>$5m@i`AF_PJl;JQnSWXhqY7idPVYxH{C}@T;Q!9{!t|KJYJ&Z
zeHa;XrWPXyejjNQU(9X<<O-H2(Z;P97UeTJzK;l>?L&aZ>l?@!vQc5nV9@$nO@aZO
zks@4ioCf}B$I+rXjcqFWwHx0_MgB;76n<sVa5!;7`DdE?j0xVdNdn{~Nd*;QRmBrE
z{6f_;C;)0RF;5MKa0FQw`}6?Xbpv^qTj&vV9kMM1>ex|>a{2FXjzIQE+iN~pmvsPb
zVPB~k-HdgXQ;@F+MCIC9EgqOft2q~0!U1%#R#f5(xo%SJk{FN?F|gyf{PFIr)NOeS
z=k@A<BEjnSyFH4FOCk`jQ3rT~s?AD~9AZarb)ZALAxo(W`UjMq0vrM{@}|}q`&&|2
z6mz@kNRrH<SteO9Mp$gNG3negy)hQ^|2S<0)3`SZxN{;d7VGgdxMd>312*>328Zj}
z_ublUET{haaFm3qc%Vej&$fNN9v?RgNYb<7mc**8qow9lC%7PK;LMO30z0v}8dpZ@
zTj={v+sF<-a$~_&WCEyomx*m4b62K?7X=oWg2p(4WMmF)Nypt|c&$$0KPA09jCRiJ
zL-@0d{8<(Ndf)>RHzmJ`%jnG9iibQAt#bLswj=KtOn1W)01@l*OhowRSJt7+a!#65
z{<c9~z4=p=pin0!@t%bqbpQmmT7^FZn`hbrx)vvAuB&M4;!rV$4M6Gshtm|52DlJa
z;h4Be{*nd~o_1b;S$)lEYRcbIlCT>;fkd_-n=+eFz}ka=?@|hOxVc$?sp80n0qI1t
z!xWp~7s=n!9NsjIdES~bCbx3_Pfr{VqNXZ4?6tK}m+^l}^w)taDLYwjA)~Bi#aT7{
zdfN)HRej3P;wSXq(M}SGD__iChR}H;{suag)5{BvSisRvu>11;+S?>rCkE7L@Rp_b
zfc6zlkIvkQ<N)**0}(L#$mY3^eaX57kM@>K3@iY42yR&`S)zdYIT9sFfdO&29Hig1
zw8n3*ujWOQSP2C?@KhCVf*fqu<XzUTiFs&w!aYsM_U(pc7zi*V>!Th650dZP-sJf0
z6sZ~PJWe@0m+&HPoGbcmk5_6ka{F5z;X)e}V}`K2XcH^gqRS$zBy@w_FnRiG2&U-%
ztDg5{maMOxtG_>z;=(8S0u9HP;~XFz76NO7)5_VpuAy?<Vuwe6x^Z=C9{@k6vJ*kF
zjId*chs2PpZX@%3EtA?)E5csTPvu9Dpn)8mefN)!`ucIdLLhC`VidQH)^L_sE{fDk
z%&q*a)l}*%gJlXS0l1aO4{A^Tm!OwE)Dn|Mz%y5|%U@st0uY(0X7`%WjMp1B^&HV1
z4O@sydA)@}(1-$-6|@2pV5cLM)AVW)=2*<)Y8VV3;0dd>(iODBxF8lzlCwv-&?7@S
z@f3B|Jm{CSK%CK`Skp1D+-`rLF#c_hnfG2-ki`{2$q&!AJ#>dvqUe^9^kr|HgkU8l
zf7o{snyH&=+%y{ic2M67){76X+KTzuUesUX;$Urk)H@J~Ct}(x_Z~nR$Xh|bC9WoL
z+6>To`ZK`t^f-g>%)3uNkpBQpemcJ6*?%D&;KpAQS~#7m2_4($Mf|b}HSOY5@GjAT
zG5EM7O#jC;r;IB=N=J9E$}!92`LC(<00b!J5yAYs%I2jNU))9cRjTq5AY<z~DpIrT
zHDYV%XcUOvE+Y2q(Ff$5JvC@;X4bnve6bNmHp{=D&4STrmv1)*1&~f+E4Xx!MFE}@
z$;j;BY)-fK+`>>SJVoOwk#X~ysFev_%KjQ{ZKA0w0j$1m@^9CX<0*ZWN8vKPH%qr-
zUf}Zq$>F9dDlgfRIq+}3GXV=8!7yRcflG^QzUwoWpEfO3top52@uWhY<8suP7GmA%
zc24cWrf}>~k;IYTL;E+i)_ZyqA6$nYmw{2x-yReP(TJSI&`|a+k)pQ*AqPvq1Xhsl
zA2d679@VGnQjl7oUa5B~Gr^9KmIeVa@lj<)(1WG{!pa^GS|47sl?e^B-m(g0m4D!1
zC;3$)%Lb$33HA}yey;UH3hjC)0N#`y!1DP&oR{$ZfQw`hx#ToxZUK@`r*gOY4n<hn
ztX2CpWN6N2SiBDlYXSom*`02h+n+6EdwsQff3#<AArQun6=^%h|J)V~a%=!^h=CDR
z^ia0>5xMB($C|jTJ555)fA@PG0GOri7uk^_I)a-<DYxO2xMytf_7bBheekZ(_Bg@C
zhkV+OPS=T_ntXtdzYQC%vLjy1mQ(QSgLV}gj$T+)$h1iboqYQHErmC0b#nh5nvp<<
zI`p$A|K;uv_A1cJvITa()VYzsd{tL}=uBUpu)`Fu8kuDxM=8ZVP!KIbiTDT!cn_kX
zz@dZ-OuB-jq=x1r2a-coaeT!*vBZ=!x@pO|lBjhp)?c!hwU<oY%nkf**KhS(%-wd^
zou=+5h1}fEyw8X!*3lHT=gL$+Z>0RO51>ep@>U*281el_`p=BvXv@MQQ8?>gE?FP1
zhBat?L8r|!*(6FTlJ1*_M0Y(tCxc?Uhks!prQz)7%`+OYj`9t`ob-S9)KSucGQD|2
zEn*P16Jqx7f=<f0!-CJ{=s`K3ohriF=Rcaxp$1eYnRy;a+Cu#UkfJggk_m+#ypw``
zVEWsLrehH<ZSbM?<f{!-W!a{IWo-H(<a?>6i)7UAhWq(x;x0_}M=JMtj{>4@ZLiAC
zuY;zYDhau)+nyy6JjnVhq{tnz16oMPodS+zT<yWci5XPS@iD*~^g>hY5RGPwFm4h8
z!;iqQl!mx)XI~0Vl@+e?2qpcIsKZ28Xe<muzWXUn>Un937xOWw(}4s@bXFclSrO2D
z>56!B2)?L+M7F<e#A@YCZsVKqdkuYFlaH){y=e_h0W^6Q#Y)}0f|ww8b7{CjZgKY*
z%bf^$hF&L0CAUj-F{Lih%xDI_$!;6@X{;kUFCL9~XC!2k37QgRr(coa$&4zkY4gil
z=9{a4H&5J(bkHByywSa|q`Fn)tqLp$XRPA_+7*w0=Dm!9*tm;PP{*&qVW=C&uz%lA
z<hnCenp@SMjaOBN5uB7|SgQ*QuKE%ZeZu6<B#SdMTT;3)A0PoATb5q}f_bcVufA6>
z{OJ7_4g(>FQz6eA!?Mf`@5LV_hm-7n3sNR@mb3iVkkrsYSi~-TkC}~Cbafm*6OPIR
z<PsR1pKu1yI2dz*<lAg2%n=PVBgg{xTTt;$Jpa)^HHrtcOu$rpVMs+$FjM16B;c*T
zf}B*K!~$=MZl``cJspf)zJe03|NU>^wOu1_V!z0Ch#egHi@>x*5TppvbT2xl$%IVi
zl%J*AZ4_;5_)ESp!#41rkbgBOiYo6?4#q9Blm@l#xg=f)(;%R$DsCzN!NyRHmUu3Z
zp2{doVQN*=7kPJu=z6(3{#C{IrX)K%d$r*4IE6`sXu;!R{474X8p}XQY@ye0pbqmJ
zCM=~W2vce^T2iyD6Zms})@%t#c1wdotqtcn$*p{};e~8e#75JOlsz@hi35ZO!G@Y#
zl1eISk7MSDaN3^GD0cIq9IlB7rhzo8&iu{>$Y#1W5m_e@2Am-0P7fFJcR`t1apBdY
zzr-_hFYOZ3bF5<ZwX}n>ov7Q-_<R18^Qx1+VLIvTED|%gRGUaM@{DCENnD8P3U1Lk
z4R3~B64`ehOyjLTvB<hfCAsP6A6qLRA9O7%^uI&Vo@St@>mtj#b7_#CWBxKf{{74I
z-B2GRGUZ|>`DQdj%PI44c_Yfl4CC)gwbY?FQ}+-G@;~Nc3GLqZfB&FTVSZo-Ha<9@
z9^%ey`-br-(Yqv^suTeNC4vR77u7G%I9Bb5J)a3iZGkx<yo3)nn6(=X>EDGLXyIz8
z$iEdVLt!9L4A?ni8$)kpWe#97N#+><yZ;6if(R7YG_V9R|6rl^SOIZJT39C3?jgUB
z<CWazRnLvOW5e}0-k5`6x73nHABOIiz9h;h8Yo0(xbPph<E5X*z-m{hAbV8UwB{Gp
z=1{jM=ptgSyTwhM*>QQ^y!rAw%BAlg7O358P4&Qnd@UKv=4QAaSL6L&n55|c$Jkd!
zwH-a%A^`#v3GNOBio3hJy9Y|qQrx{r30jJ~yO-it8nn0+cPkQH3%%+8zPIlE_TKj&
zi<LPud-m*^Gbb>tCKAIKojSCFrMJtCBLpLIFm)F0>Qks;i~Q5Jy8kEM2NU}Wjck72
z!(SRFg^S+5f{mh16URI|VO-lX@$RvqJ^+bJiB$SnsS@CvB5V9Wj1&*>d|VCHzHWvb
zF)y>5oBM_^kG{-*BCxyJJ%I~4zENFfqQwtC*xB(?8mqua_d@xt%_P6VOb<0}G;+n^
z>|e5F^Fy}@=M|X&6@kzB{RSdvpBK3EJij&Vxg!8Ww1y+=Ot5wbMp!M|@EN)y45)tJ
z1=#9$;u^y^KEHBu_NSp46t$(7t2~@JzJCNHF>K7r@;XWb;D-QAL})_l#$pk%-7!Zt
z{uIg9uK<V%eFj2WHsnky5Rr8J)7VV_zl#VJ9pDFE6Dc*11B@YnpI0)?6mBd5#xx52
z7j^iC`{N>dfHs9~>R=V^q(Jy@I@c|0VR+Es^(odnL>o3)Fql}8zs-HS&MimjoTq^+
zWWKko*h4NH#07k3U)Xh0dk)p8iot8<NNLN=I;!hs*Kfr{lQvZ7t+hVDY6uZ%+C-Vy
z<qp`t#%ropm+4gn`i=)L=HqV%^=A7<>q`tS7E5;p2&@yb<O1RTlZ1g(U)tmdlkc5-
zV(gKD{~~o@sO=kLj=Po-rsX1bqyYWf>{bl23KC^ZRFT?Gqh)J?*#_HX7$?s?<0Qw#
zbYRpBA}|zzTt^#fq=dkqtr6n5pM?ASeEbz6Re6+5=z$XReM{E3huj;Vz@k@Rwf`V=
z3rV$qv{e?ZbdKFGiUZ`-$kdtU-F4D^Ve>h{4uc8p+JtI}Dfx1xYZ75FuWd*tBFn&p
zoaZY8MqJn^>Gr6eerNVCBUX%QH-x6=cogh!70JBc&>gSGk90pC^5X%zUMu%uezLju
zlj-{I#~HqSej|hnI|Fil!GoV84U!4nc@>k1OJOXPUIaWc?{S5&i+In`WC9U%nm7Ro
zcl;u`{rBIOGN8Zsq599PA|)Fje=H#WYwLZccqA~J!{Cl7yvD<f0D#$E`9J<FmAtu9
zCgK~N$;?Cvxuh5gPrqsARy_cM)q0=PQR3mbtLlSI@LK;)IgwuBROqo+YPs7WRlAZD
zE892x=gW|!|2qqC@>M|J*-5uIFC6ys-H(*c7A-fptmBAWt|L14>Stvs2ha)zq&)?@
z`Japg3i{u^G#trXtB)<6mDq)OE_&#Ct*pfAv^)$<&}=<}jL(^>R5c%5lDg4~7LPw`
z<hs97$z4yKJdnhpvk(Na#RyGY#7YTXVDG(+JMYh&<q(3o=hF%0{BsH`JfwQZqLZ|&
zLuvkh@PmkGOFJf8gKk?vQd2&hiYr9*bf%VSH1t_#xz%pUS>NTWsdnQ$*7Rq`+r+-U
zmuMs2aPGJ9Z{m3(xy#Bs?>%Zlde6sCsOb}8sKVHCGpCEo^X2mB;WP%5%<hQ78e(Uy
zcx+$H&;1tl!S#O5U%!I<Q&0o9BZDhO)G!mXD9c8DgqoJq=0^V^7R^dnDB5K%{jO*^
z<=@r{neRitBZXn`RZP~-y!*Y7_WJOgyDI;Ky>IjCy>nG<PEOG)%Ub2@qrwwu97=kD
z4BEYii^lX@PWwrdO~r@7G0#^$6CM5wF4r}majy=n|0MBTa5$B8ehI^SLWwqWMeg!y
zClhzlonQYD_V{zRitYG|yk`i`z+x|xhQ#SR+&)(X#P{@g=T)?Xr^joh!O1rhC>Ljc
zCMG5vrt75s0Rb-JDenC@CbA%Hd~rDJ(;!{YG)NAP!iJsYXjlLXLo!V;S9M3}u|-;k
zek!!={V|-=u%0r;vWL<#Zqks?J#!w&Q=IU;Utw@<ueE!ft!VlC;B(Ep!EXD+@*`F8
zAm!e}qjVaRO!yyGlUBZda2;&%xAlHRN?k{lYp2w!Y~d#nB#($~%^KZ1z93t#a@&tA
zWU?Il_J()9Ls=w0$%{)<MUd5=RLK`s`Bm}>iAPZ!U1$Bf@2N6>$g0zPsLJmfFDA}2
z=UiTRioU$R;bCTBZ%e2IDv|7Jy(cm~__?5=&wn1@0K3Qht#AHpOtYdc1K9^PH#qIl
z2o9tiej%VxNtv1@MZjAZuIdR!=68RT`)XArmb_U_i@XlT*UWWi&=}fC2|d8<kc#N!
zT}QvbK1ITXP2}){vkVx{rJ_FI!L24&Ab`}71Z%CTW!hkbQz$n;6nUNGydZuUNXyjz
za&2g8GIiYN(v3Zv5}2_+){5J}3zZ2Sstf~hu|tu_KgB{Cxekv6(_iK$UmH&`tJ=RM
z`ZMCefN8NX31!Qrhj2gNS`zW`utTfXX@PO-i2{MY5pcJ>Wh71aj?YjkcmJk-{>vZ3
zNUv@2As{I>X>X#I^Yg){Qx)YS`J)s>j6J+BZ_KNHdi#*Rh85mXya7;s;{yVEuxJC`
z59dYJzmNQbmP`vHvP~Azj?ZfM%PQy#Pqz!Ygv?xr7dnAMBIb%O6CPn?JH(l)hor*Y
zputXIA!H3*#`M9?o>uTfXlUG?+W1}wVBj*4-yP~0gmnu0dPJOaM-yYUp%_965Tp3I
z@0$DKtbX-OHP}hlBk`@acFz+R24RWIWAZl3hP&YoXzF9&H<3|fS4XidzJHX&0!Y)k
z_&pBo+CPF54uc?}f~LRQmMp(8RKwL(?b7txteTM#X9G!@GzP}imsiRj7##xDOgL40
zY$2H~yibc?UjCmk?Z9oouQ4+jDCoFwAQkvTL?Ro_y0~Pr=Yc#%TE|fR8TYry8-^sp
zjCVA-*Vzcw`P?!yZ=}7Au_Hw%P-(U(At5-ZnS0{67cZzO>sV7e9AB+uiuOdWgl}x@
zE5}1XRD|T9b4ch3aV*L8U*Eivl|F4=)NnNcoC~2YwY)D-slydjyXfyL^0>)YUW(yf
zO9)8oZaK!(*W!hb)y&dQ=Ow!3foSw~Yy=plbo8bu-c&O4+E*_L6o<^PH~1zOH<`7y
zwX+95Gu6|IeSpF#a5FZ8e6fCiD-d+Ff_hJF5n^2zV5HF_@JxK>x_HBq?H91ZSgxWx
z&ej69wtc)KH<rp0sDnsRaZ*GFzl^?rcljLfPh5;=;*1c20s#ViGGm%wYWzQ(^<zUb
z(2|50+yU@>!G*vD9VjT@FniRM%(s;;hGVAj`RmDKHeX{&@@7vs5xQOpF`gR!PZ~|q
z*zcq~CmpOX7Nr|owX^bBt#|+EKm)(NE3n$9*|g-9{)Nz8*=#VoX%(ZfB)e}$Kh0ac
zfdTt_$6`3ZQ?lvenc$HrjS;!3%ZROmy&a>T2@@nwUMwy3E9;kNsg1HYb^KstDI{Yd
z)Y)g)S8+Snez$W{k#=+MGMYB~015Xz$~SKVOat`&>$Wyy{ln%W825a%OX6)mX87(W
zkB(TMm`R-T8|6N~<u2i7r7lbycE*1x28cxScQ~_rECO+b42gW6k2>szpG!KXenAkI
zaxc-J<#|K_Fe78-Ye!x7HMrKR+5)(cl{yok?n|RK3~}D4w_5(;ml0h@3f_kq;<Lkp
ze86fPo|E%}J&rV=15;4qn>^pX?avoeY}&MYb{?M*9w3>0|JP2Me%7YuH>J$wZs&Bf
zx1r_B78XtGGm0HvH27PM>BRCJ?{|GO+s>EP{ny9aSJEu{Z^rS5mXK`IEK`-kix1S0
z(P7QcvFK010p<RLRb4E~DXXq{Hb#Xx`RIVi24kJyvPprXrE&3&^kqa+gWUyYj#;Fz
zKkao-C%@&C&&*y#g-kj1=-&cHIrvV)uPj-=sBB308mLTR6n+MXg`6Eyv9~GLr(OnO
zWdu_Xc8*0T@36sZr<l+S;GvGc0esIkD9i|ifUfv5VIjI8--SL2c)->=Nq8ZBpX5dW
zia|kK3JDmb6YiR-A`ah@SL7(f#={Rd=XXD4X?TrfN&*;i|C5_Amf9E3O++H1@hU7-
znVV=}{8A5UWCXa$(hT{%mss=eb15$`ro^6b3JT}3JveOw1kDJ3;>0A&Bmncna8u|v
z;<Fy?Y&$y1oLg6<>!clIzr7jDO&W_7N+H^+TlPL(P~_P{2Tf{|he~sUIyU0eeC=tP
z=Q`%gqJp|>XP;>fg#M0TvRQxp5d0Pwx9*+9fy$5lA2fe5?xaoYTzR&gUd8$#emj8+
z1H$$0LkMFYbLW^yc32tQr{Uk=_bC!kj8B}CU?!zztmwWke`ewhdvc_wx^bFu20p&z
zzLdD}{mU19tbn|Q!7LYPh>e4adX9A?nM@bvb%4=eMi*71nE8(p*&uiZb^&<)gzqR>
z?z=bJD8V$$FS7#+H4%^M@9(1;KY1&elfsqlUC$682?_Y+)roi(_X0WoXUjrK_1nC#
z4*T<QzA4on{e9tWavlv}gcRx|2x^pp^}W3Z#Ki@5T&Eq>>>=j{yCls|Ad>FZ4?B7h
zDEY+O@nrL@0eym8qFrqY;sR|_^i?XYhuLmCY||bwha(lMwsh(LYT2ER#Hr>o-c@q=
zD)k<Zu?N-)BFXe1JK&p(^SYhDpSe+d_vh1~4u?-viqPk`14{+;IcsfSRHsCC^m<-O
z3LJ~r97Tt1?88IvkcWM1t6#YoGJPxHY39+4@sTl-g8_om3#c*J@<%>Bw|s`@f^(pl
z_=mCnt<ra|x6sx3$N=I-{s#E=Ml}kbnc!33QVE)yQf1~?y4ZKZ@!w;mD1d?FPakfC
z0MV%qWaxLQw5NO5*PtY|q%fX~@)G}FB<P}&4$Y)sWqPV-f4E>_1Rw!hgXWwho-5NO
zn+ntyCdS$BQxBAgx@ywnjYSpVV#R4M+dHrcWFC@iRzpQDevF{cyqW;{P!7)JAKkMn
zB~`Aev_1H&=4<X9i0*Axig9B|kGXzO1m%VaC3+F{%MCPb>cOKU7{nY+D1iAA(6-Sp
zf<?mbftKW9PcLp1R65tJv7A}1diU^q`#R~wr}%9UJp?pcp7%E(X{aYQn0#z%L7~Y$
z(-@NaDwW=3Jpd+W^-d>ie_7$u93FxxGJVi-XE+5JjP7LGQ>y!H3=o(fyv#~R%sM17
z!1B|wl`^8u(FD-JckXOWgN9>GA{`F;u(gq;{9@@Fg0|m8nKlTodj256M5if#Qh<wl
zS1y|>`2XK#>5?7(vE7)=yP)-YJQFc(E&g!D)2>5S;SIgA&l_3>0VQI*ykokr+AmM=
zM|uT;9Fkg3RK%n?@{2)LMmjK+BjY9*UBtYj^ssNah)PxIZq*Qk+jDLle#x1*xL$X{
z-~KykA@Y4V*pR57w(mOKaZb%T9?g{|QG8>1`oabGoT>2Dsi@4rF;f-_k>k?fnX^wH
zT4}y&h};Iw(pg=b+Y95ars=*@mMkDfiVLvJA*>%WT#uSf`B1Y)pRN=pXC)61SU^ZJ
zIBYON7T-3o_Fcu)k^sT?Rwk6%J6T{nHn3L~mYH`jeT-8+&QK_LMNV&h@cPsgYBUq0
z*qi6TO+<wFzc7mJ-RH0WgHd+ig?|`j0mrCics0roX7ImUt1vc=Nb<(yF^)%j0*A7C
z836eQ=$b3MK1X)IpP`0tQhPtgWNIGC=If+jz1JjQ&s{|%VIH$Ct6iZ;nng>)Xn!S4
zTta=PpA?cetJd8!Ps&Yb9F%h<W%2xp)jJ<Q2xqSv5%-V@{opFU|A9|8K4ThJYV@`4
z+n*T=7(7eYDaTX@MN5=lnyT#ZEYeKBJ?o?qpLzv`=)fBsTQqDE@EL)3qW>Yb7)YA>
ze&R>zKJpGyFKM}azn4s4ykr?q)JYZ>o^jn+AG)w=R+cR=9Wuj!&L4x?bKm+eb`i{}
z8EV_-Dwk_KbVd1VGs1u;+d&mX^p=>FC}1{*(3~@JxMno|E$ofD738D5R{g_uxy8$H
zxIj&yReri(!mk6}HTKcve_1g|ak)GnPSmcjX_s+w6@H3Q*kS(#T&{7Lml{itHi&=L
z7wngB_e)(AN59>OVbjh2xOV5H>B<qV<Q0<H^p5mBH=97t207xEBw-R0XbDE;N-_J#
z8U`ZkNvRjbySV&bH=aTE+de|YUBatq)rTVl*zlrFz@*;0*)=30DvE<R;>@?(oeHDN
zwM&Rx%zdcW`Sh*Sh|MCQ2S>?=cru%}S{$Q>1zxGcSpzLnM`|7=lCu}RqS4`*S~kHW
ztRFb_qzT~hB<9xfL8-K40!^_#QBoC{AaN=QR-QVgG|k=U0;F=x$TxzPxYR7Li#h+5
z?K#K9h_c}E`ph>Fd&tLd&CZeQa&L}Clfu!=k?5~%S3HxTF^Z~oVPi2kHf6n68Jpwf
z`-kXqvOP~*OTuu0%-6QF6HkKLfNA}UvJa_sychnfP9=`ch(q@`qf=*u-hV}f57uvs
zR+yOIinZ$*G1umEGTO&g=tJg+;Ga7ilFoS)IQ7)jpE9hq<kHzSc}x)Gs3x0*Pv%H`
zrR)v;iMHgd`Asj2we;Pa%#E7YTeWf>5f7!kecjOriCes7=I1iYb^DM1sW5+neC6n$
zdn%JT^nOSHdMd({|1L;H|I(B4Zj{CiwspqT;sOB^`aoZvNzG)gdH)i24;wL_;a7WN
zB;tp4)2_CRZ88U2@Ibd$^;6gI5%Ixn7&tu8A}MWZ((7`Go(A*JHF=q>Px>c2|Dgod
zU;}uf%b<dXn@I-AKT0t08K$5{UO;A$iF!HisWnKJnk3ewQUdBM4J>n)h-TAW3_HAB
z<I<j9*pfg=o>V<rawhhE6;br;(WyG&oi=Cs>otz!`-_+(npI)@qSceAObN~u_tYHK
zCgq$zCT&QPh9jAj+Q>`J({opo;)Ibc^%0Q*)C^sWG6UaxLA3>m8E2PGU(|e<FU<Ub
z%alvg(;pDH+Dxg{E79R0mPSL9x#aBZ?!BFe!cI2gW75_y!6?;{TqEh^U}gL>4gu>L
zvwC0)w?XAU2yO#MaJ!1m0uoQ2Q?XxYnv#OhP-J;%Vjt}VC+G-+dPlm0d6bnKO6P_7
zab5}z<ki-n>c5eIdp2i+xt=S#<7%|Is_o18v1_b>lgVV8=e0_p;otB`i}NJcHp2Qx
z@PpwdONJ?olT=)KT}kng*RQ6`%AYqRdTN7ZuY*;UUNh2ewmZ?|Z`v_S2ROr|*DZ{_
z{%qSZ8a|gIB$F!6lUtEe=|`tDzrzu!I`cZU9zM8JBx;3y87nkVnwi1-%fsCUxf9f{
zbCa7B*=~9y#hp?xRPyabT7<dKR_?iP1rN&A+LQQw84qSgv*^I_ri!fz3HW|?{B|;D
z0<YORbk7W)@v3O8CJ~pv545Ukm`A<$ViE78RMHW_EvY(1>~ZBlGIcC^yvjNRrIVR_
zxrK}=jq(#AuHBY9Xx3t0xQ2kc^R<6SXQZM%WAlywIiQ<K=OzLr5$ICFqpqey`eof3
z^6*{tZu+|XjH*eh7m}Yz<lA70@0)N9*R><%X?EcH8QTf!_Mc!77a#PoTNe1zzYh10
z^*v6x*m-U9rFDj8JQkb1Ts@}ELWBx;L&T?D8{0n7x(!MLI|PQcWu{X53l!B!14Nb`
zPSrWW{uw#I`l`@=uYWPOdxtHe5GB9X@r}Wp!Rcu9wS(gv#A~|&*S4ixYCsgU+hQ)Q
z@g)2bWYM$<r?G?iI5Jdh$8~dP4F{-y0^IEF4|?FVA%tB8#*v6DJIa6r4?<gnuqXaT
z?O>*}@>mYN?;L>E***#}FKaVWqRECZp-y2`*ohw!8eZ5g=ok9aHRcGXsh9jL$HWiZ
zwI(zJl=Sz3;i0yKX(^jbUxPU(#L2#sTmcE9Kg#qCl3?1oC5}KEE0X49v7alWsht<;
z#_Y>ZdkCL=6Kwm(j#e`EJR-T%US7t+QJJ7dy*|MHVV@yOt;CdMUa2n8o}9hf@%A@=
zsZ9lu>{=;+zIBdrs9l)SeVC~(RkgE0ucjo-hh~~rO@nA?BFAMW^qGZMAoYKjhj6<s
z+}(!?{v6$!AD~V`<Z^YHP<FZ|h$Rwvj}$-Di3k1m;|z`QA!-^t4fkSDU1hhz;T#DY
zE)xaSqixjzFE@3kp4n*eIgFcjI~$H#jd{zy{)nZt!~fR|;tB2B;BUIniuWvJy`^cW
zMJ*GHQ~NB_*ZeiUWu9vpzLrqLuJ<WAY?vy%yueUU3&vI**cAqqBu$=xG{%IMWMl#V
zArIE&1rvB2%?R~XsU((L3JUAnhw+xapy#YUj}prmAsQq=Qy{!rru!vDFwKed-^O_v
z@!7~N(OV1UO`bkg+=KY+c{(#pU$+N!p!;6#mhb$*1Bh)b@oV|FqEPfm?jmq&pW*MR
z^)gQzCUp#|tVzJhw_pn@n4zgwcw%Hg$xam$k#>`?v5l9Eu~9JA6w@{)fI9QM?)k7d
z5gR4UrCg^`2-UV#^ul8&Xy|B^b<xnl1QIX*wP)Aceji_lX8pZl2${$Ps=||(CxH+0
z*4aVB&Js%c3oB7BbLzjGr-g#ZvSQ~n8yomdk_R8FmGIs27c!)klGe*|%wwH(VRvTS
z<`n5Cv}DXODLPznq#?aqr|Xm;mB9@@nAPYTiSkl$vtVKoRu}kn4ncrasu>RbUZvOU
za<Mk^I7u9m{Ak6;(0*=%F}6t<H&jg4ZcyrR7AQzsYr8P1R-AjF?UzSS6}H{b2ef^L
zOSLHLA~}a3#0YTBhA80gZs+{MGYH7{xf4ji#=ioiV#Pm~^8S!BuRoEAgS5WzJYnpB
zz_2=J;kofMuEJM{C0Kvk7YjG3mZoGpK?7wVsY3(#i(~cXZg8k`X1@JG=Q7uiM^`~w
zp?phf`<V)(#ox4lQsOw>rLCR>gRQgC+*c3}McZ7DgpyW?wvX+n($je-2r>4?ea%ZP
zp32DKE$?27pB%=;qRr-|IczCcUx;KAMW-~;K(J#<O3F@|$q#Uy`;N2utyx1$7F&<T
zzrIckX&5wPubhc$scrqo_GC#}-zQAL%@t(+>5q;^p$IVoG7>S*h-f%knfH-ZXw9Rt
z*b0{Lmy#3ckyz*&h!!Lme%u&ZJSKm!<l20~ccWdoqmDvl&gUj%oCWuDWiwVk>w<p6
z4UMbz>G#LbSnh?fm?Tavs0>oYlINo?Z?sVv_N3Yvg~<<!JbL}mt+8a9J`Xt-s1bu{
ztV|V+l?}wNL-yQ<o5yjX$BH8dXFs9@h$mxA*mZx20Zbhe4-ZY}<YOu4vy9LAkYvKO
z<x<bg4>7-%Sy{FAnIoQ?W)~pFfqyyVMH`Asp;fLIQ2z8zSs2FwYb@r-Nvan#o?01}
zzWa+q<yO@86{+x*%~z{Hj}()z$k%bbMn{-KnmJvpF>cx6T6bS;6o=BK6P}RPR{*<R
zH&RjLF?SuoQ>n2L`AvzPJ!Z-AY{n=40uL53{xrXo(`T=Ot{0_S0zfeF_!pe67tXF*
zqH7seLjid7$Ak(1f8{)ANcB(#sj5%C2wYG7rA1ZmD<XTQYf$W^Pa(B(*%$45ozCkl
z*GB*-k-NmoVt(Sf7Lvg?@2a|xf3-^dtWl3I#Nh{!N=k*4NNNP{O}&x$hz2X_va^GH
z^hQUy{^!&S>B80)V8}=KSU~%Ad9XyI41HdvLECgSNKCPd?#G87+)d$2bTbIIrD$|S
zH=UK+e~hisL(cD^n{>*7<W|i(C(U><aZFSN!PkjNJ^H!mf+H}j#_zs-;n>eGnJ&g?
zXdZUrvw>_}qH)MnBK|nIF|$?5gFIp`^zNj{pjLhSptm$<b>9w;Rk@R;Q$@*H==+tI
z?3WckhSbcgG8x`-&1c->vDy8-*AuVRM80B2w(Cm|;9ssO&<yc!J>5(#4z0l7nV|h8
zi>%#Evh>O9fiz7qT?+RyCpF$h+VYd1D%UN0*Dcd-SJ(@gg=r*gBOfl3*xjf93<j8-
z2qqJmK%|O)w8lDI(mpb%JBuMKjYiSXZzyIR%JPpZSP5dyrT22zjt52?tpQunLDBKR
zjPSnoruP@T`}|l00vDBDVJ>1KBR*u#1!Sxg@plWg7d>_F<)3lifYl5&v+L6<xrz8M
z;kgN<Zb<c<$?+mkKfycu7FPF;d@}juUc^DwFTs;`f<)E-z|LM=7d$>o87_FaHcUz*
zEaaiZbLmkP(;1jzAMWzk9m>+r8A4FSt)#w**^Pm8an^&F@E8!ZzSOMF%w)Ua_i<wM
z!$5mA@?J%A#fvVRu%MI6?(k7c_kobB$<Ho5Chh9t`QfAV3Kaa02<7s~+!_*GX(^F2
z`R2wfwxiX^VeOl{6mp?|xR7c!?jy}>V?sovJB}kMNQTos02olX$U$6$h$A#M9#5i>
z&ok>0{9HOQ2^;dgYRKjl;Sa!*x-j&_h{NK$2;qL|fenH`szO46IhjaE?j9aukC`kr
z-IpmTpeyjTzCp0;73{8GcUqK2HdD-NvWyhzJbv|!=Cm4n{qH|NkEIfKNWgGF<$?i8
zsKD!3Hv%c#`&h4a6{hpcd`D@-{oa!8*1Xf(6UM_zNS#4O%%gwfj0PnsrgsOtO61n`
z0j>}GXq+*8nWQc$aios*p%utl?F{GNYm*@n)`jbGNm-IFA2^W=DSO+xz0Mj`RT+JJ
z&{zgDo+mIJy%R?c`u5l=H(rU@O$V5m{@(TJ3*NB!(nq%UP#9f3h?DY>EB%R1Y2Gqg
zNARf7=&uQlZeG%rm_631C7mKX7fAtH<g5zPOyo-lVx&)p0iHO6loZLs4K@iM5mI0S
zMHv?lzh=pi!rA#kw}P=eW6V%C<9dTf8OmB#wzM`m9p3ccJjq*mL3|O{R&ot{w`H*4
zt;D;7`z7M1@6vnaDOG$)iy|LJ{5aPa_Uzvisy_uj5c_(;BsR9<9O&I%5!|aSs{o9s
ziRo0fX`7%Vaj#S`OhAabU^aJ29w=QjpMKc2ebxC&m(ZkIc6Vori<lzM?uo7Xp0G}T
zHh0<ybZpA844QEu8u`LWr}%Rj6_PnSYKJj$kI{QKRzhr*`KBgTPknZ7m=vuN1z+ro
z)CpUqss2PzNzdlV@QKfsxpfs_#NV(_QIk^su2<>G>kFbc1!A~iH|uD--t%_^<dX(X
z`I1DqMhsWf-lKwqZgC<`kdufU5<+d~ZRnB8=&S<vMK8uE4?A!XyivKgJ!llV-u;d$
zTsNUPS7&e0`i-c59b<yUBDg~ERV)8;9eSVr!9a<_U!WUwk8sfOCr4NdnLk=O`g!X8
ztQ0YA!tcxGMH~uCv=8UxZGY?^j3q06h!II7N6Swn_+_>YN<yBmwO<X8g1JMp^pm58
zjLclYkRKnNMcj`jJ>9;!>%-BoV?ItBj)nz;+<9;`oO!JVX_T<uij&6W5`&6u&<@Y;
z%&!b*>Tq0A*mj#XtC3V+5V&~J29^^e*&$J#9bY|&Cl9)M*56fkaowlNk8MT9B|X;}
zjT9Q%F<7=zBC-f$;;ny)fN})OI+-f|G(!vQ3>q_D@C`oPt2#UJNmxeCb^v#$77NJH
z-~qPpxft<&Fh>G?rTTu4`w%|;Jwc3Sh^ENiwJ{r00VwsvE!NWS5W<un`5D&z29(pK
zMZ_xv%<#3;nCgF4rM{j9s8k^Wm<n<D31U0JGuhlk_zk3lPVSH&dpuAhv*9xO^cOWW
zA5+7<OowWFr<ETbB?1zGi`4KD8vmUiB**dSmgotgBi#EB*o6WQ6CV;}j0fIV(2e~>
z-B9Fzt0Ew+s4lfoIk`ykb-<L8@dnLSG@!u3ok)dArd5rW#u!$z>Krg_9v*ZqdK&MO
zV=mRP(v~Cq*%)^1k$%sZZi#syrh0#PK<P+8g$R!puoC(at=55ugQjt6&?v-92p@T)
z7Xg6=L0L{(56D&z4pX!-AIv{b9!_Dvp=tynZovEhd^RcAy_({2zx*e^A!cbJ^c+k5
zh~U$@!ocz@z*q;h5z2Z!1f6e=O5D~3y`oP(QdPMaowUTyPQ8(smiyr{M=CcQZ=G(I
zlf8WQN%jNOh@#@HZW#(UQ5+nV8vC-cv>tikD-umJ?9043Zk%x^L6ce^tR#Ww6i4JV
zP@|2ubN#<SBV2GE47Uni^Zzu%nHrH-x#50k+=I9RI>sjVF^?m1_>_aL-f8}-aUU%r
zTJ$O-RCN`_P)G?mK<Dp7olkFGZ(pQ8Ub|X0-7gwXOck)3B?$ZEWOkQLgLqZ5IH#)j
zh6{-rEpH@NjwT3z`k;rXIZCqRI;C{{wQ%f?e<r#r<73~8*5dnBsCD5%`T4eym_p`|
zRI8<q``m9aESsHKZOqcHd)&}o6Po9{i`q@qCNYTzSxeq+@<4E45jZ`Nio;nD5=6+c
zi4vyDtrT;>)GAo$nS&F`1yx%md^~c7`%63%n9Viv^B2t!rnqml)feL}^Udog+rrye
zuM?``5hjy=-*Z8$!0?A=>8;!$4;``<8m(?Q)2x=iAbWJ(uq-M1IA+P}99VT({mF^f
zOB42;hON}o4#L~sD~wFS9fo7`!Z*j}yghkk-P-i_HDR_sqHw!3?$+d;{boWGZ9nZl
zT$R#ftRw^hA@EHf8c5`Qv6%`5wDb!bC7HReoyu_LxzWPD^K0K=|3i#;kT&Kkn)lYB
z!Z|4tNFrbIDB-L`L@eVr`g#q|2$@!R>?6DBC-}3WERlynx_Y!HGlFyx5vleu)!fi+
z83B5C_L#;t@gF2{<Xg6Tv-u<2E^CfrytN(<xDmby0O@!S32FEsPj7Y@_X4LJg%&0v
zrp@>wrOd{^CYk_}68-3)XzM*L?sgnkmAjuAjYxULmTvNF&EM9A!5_KuhPkgx6-xn?
zF;>mwh!>5kGY1sk^jIq``4Y_ke7YqPoggmUVKQg5|GFs9iIJv?RDGlE@11=TE;Yt3
z-`CL;koFk+_9niMHK^Blv3gkL+S2H{M8P14a4?3F5AF^mp;D#0Ct+k2%NUervr>sl
z`UpLpGMjIcF>W~3@-m)k|2pIpA|m18*E<zNSDgD@oAXWWAs*6bo@OoIe*bZbUdH;q
zW4+JfEbf5RRdJP?iW~ZBgT|riy)xtn7VZD?1O0z~Fq&%(*%HP>?S@S532!?fb3w)W
z2c?5(t(5<{!C`h_dCrbBkQ@rp4|4e&V~MYzkM8r3(A+z^c)F|q*w+}BCv!AyxuAbh
zU?@yskBT%<PZ27knk(<+5zu%|PT%6~E?R9?nD8~3|1OP7^vVw{I0Z*w>EBpZm&<4F
z7Df-?s|$w@IZL8}Roek=8m0E~54u67edxxDn=1%Xa7`!#xlkYI+xm5jjKov4VGl+~
zCNxlwai0Ara4uFT)1PQa1<JX`Gx_Ls%4W71+z(?&z==lSN=J*TSFq&IDbcg<jhO#S
zRE`R16q^2O+RDgH)cF~X4YE0hNZ0m7Zl+&JCe^A}Nk>WY=nFT;u5I(^*H<S=uA=Z2
zZxs4cNUnmSr?NZv9rquVO1&X6{_L#`xc3ZC=JYz*@jB6(7iLi<yCTg=&u5kXsrh!d
zoeY6rCdjr;X^p)J)_yQ9io48Ty!R|Aj!o3p%!pSvmf0sMv%3y65s~fWbz}WnOD3-S
z$+#JWXo~Cmok;ebA`|F5`(a|2XKZocyU6o^8<58(h~;x<f&!ZS=C1;L`aB=|!Al+D
zXd?o;OCMcBxym<uQ(>$CMXB<c=4i0xv6R`Pxtq|}j3pquYoB}__MkmGg0fO<b7KPb
z68ZOx0C5R1m7;M>FdHPjNpvxaM0GR((pZwD@s{$Dmo&%4^rL;53l)|<&SbLNy`7i9
zBnXyg5AhrNL@z1d7xmx9fO`at26F~F?w{`F?D^$hT&uP*E%o>HT+*{EI%=K?YdgH_
z9z8iLhs}c;Mg<?oVl>R<Jx~3?Nm3YC+0x<eo}F%7D05~rON@Atm{d!7&|I}!S6*K<
z2LawIgpxW2%0kh}XdALL%_VMyEwZ=Z5ki*Qu1Nl|gFx7vH>e_^3>YfcOslt|ihmPW
z+P5fo@G>Waha749`E3Ao++P-Tls0c6z`4i1u+miNVEf5I@qjVG$Vsp4Xk4<Aie}7e
zt~oXme1ZY*9MMgJU`$Qfs<JIzsVW6N{^qJ_!n9EYHwy3nGD@v6+$j8YkQv-OdhMc2
zM7V?=D4NN=Pu}FL*}x19+@P&d>LC}`ZK|i7|DvE?4j@Q-Kjps9l4N;_@=$OS5M1Lz
z(tKD~RLxPx8PjW4I}>%^7y+)P=R#;77E%2@Ntrw96Ka@Fb|qRTO7QgIou6g%QDSHk
zgSn46?zzCUrLm(DK#aa`+$XPaTM7$wZtCq_86|M9?NFHCj}G}VE|;%vMaf|;fmCcA
zjy;(8TAIs$K2RvYn5${=%}B2sdxMK=uyGv;_df|rwL6uECu9U=W)B3;i4q!t2(!e0
zY;IxV`1vie+t9@7O0w}TUuggvYJ|tU(i|nvotB|X0*;l=9hSMar{gkh22QFunUPk~
ziYd~4ob|UBQ~cAJ!M#u2%r*%(1=89-Q+Uj4&{zh-9~;yGqCX6mRnNh`%~xc;H07qw
zwbQ&6=PB51_~VRG7w4qBCA-(ispWcW9vJkPbP>0_WAetmUE|DSI8ZQyoX6c3jK`c^
zs}(xggFA~vpbD6glH%E5)Yf6fT4^hL2G*R;4%$f!9Si(nVlL6Wm3Samo+)Yug;fDV
z3xpBg|CYkWr(}$(aqPPr<2tM+Be6r?l0zoZHI!D#Ilc_oGHmSi`n6*CE>bxI%N>!!
zJ4k$x>}_MsPn1^jzJ1AJoYuZu%h%4xU^eSMb+d^k64hlCxKn@<eZ(JmEdpzk;DsTE
zAk+acnGDAjIf2P!tpr<m=Y^B}GkaX4ln?Mt3XI}_Yj5|s6UaM&3RcBN+%%uS+Yh7)
z5|lg^$ZL9sUcn32O26(F@zql@b@rywO04l2wr^|ra8hIsX&U|@peyXE;1L)lTO7FC
zDHQT6CX^EBEdHFSVRV^AxiIzV6<tFab#~)M{6t`Mjn0@g%q!Sg!|DV?qv-s(PsD7%
z4A6r!|BPq1({u}M1C%rS$bEA1;d~aGC|Bg4ieQbDLkJGUq&vfAVH!PxuTu=bM_nT-
z)n*y(z$5MoC~52YqKZ7LZ=Hb)%VOiw;>oc1TtYdF-A|&5=Z3u4#0JH?LjbdV7zUds
zy+8;p-b7xFw+zHLlJ$Eq82HxWPIxfnkduP9&c_Cv$86ZnDF@1TJGFWDWP5^)nRtGj
zT55QuO-2Abk}TP^f^U;ks)P51T(yPx7&af^&Ap4g+R#I1nCC{6<-u`jF0sq1`Y3<W
z$kq)~8Y(#Q4`y`xIXO9~0W-|-geQ8z7KkXh+lj;8FF$nYGt1VW_Ervp5R-Xndd32Z
z!(u%X#*KTS^lVDF3Vn}!En<SaRyQSuR)tIXk64IfJOx^LmZ7Baah|JnGcCyGnz~It
z@psSh7?NADJn0T+rhJ@>^5&Od^XEj7B>}U9x(=ieL5)n{^LX$P{XDOuNnba93)V@s
z9rKJ5L@~t_xs`&iz6o;sY)~Uxt!2jH0TRr>=qcW-HEgR<=kb(gmiM=HGtB`-*ERV#
z=3^=$EnS`tjV1dy%)n#xhZ!A#k7LoY1ss;QThwT9K4BxIj6O*vuBv24K1#*##9@6B
z!Epe5&|nfh-Z@FebA$^@M1XM-$zoaaCcOsIPkpoa-zWg{d$P9mKd)1o?L?)i{7L?b
z9nBv`LQhfL2L<s=;>O^F6H&{@NnNkU1Yf*JZ^sR&`edJ3Qu+<F!u)KTRg+!Vz>#TV
z7ZM`sf*`H%i0R4oW-QoiDr&P<^ut!C-3@Kv5GK+W)hkKs6AcR}InP@SGJhWEjFkCb
ze)jlAy-<5dDN=xQ+)RF>v{Q>!UZz4P=Z8JN1P1JO5auOC?1Va`@vxyqIi-}F=pK7Z
z_cHhMlSoq?VFnNTk5db#zEsso*T|k)OZ5fe(|DZ`FO6g7%3cA2juF1#QnxN_;IP3V
zTa^F<{ZlUX<NZv(S90Zmadlu?46Sn%4MNDCd-eDC5m?$8j(CWiz^)U!q>o@<_`?0U
zo1m)R!2{pi=;QnARcGAuKS{J+(DV-Z=)R-rSPVvGs{ARIY(r+SznVrj!)woW@{-LT
z+N5&ANAy}OAL?{t_mhu`brujbCyi$#=X@nOf-@003sl2$#Q=1Jo#M!!ramm2-zOa|
z5fFkQrNACnRZ}vs!}oC#)fMFFI?WJ;xbo>4-?wC^J$zpdgj1Lvvub~OFc3v^L2bh3
z)e6&~Miruw9G7b`l{YkICq-HtDeQKD4wXrwzJV3?7$)Q)fe<6M_F@s0GmjfTWho*#
zjDwQc(EFOuVYZIn@`l2RC6%fLU(J1RmCUO3bShEs`juH|v?SP8X=&7cYrQa|AheZ~
z0=uj#&H2V$0Rra^>)CMd6#FB>e3$SRBN*`!GOPBw>N6b@4frf#&x_Xk4`F1HJj(#+
zVW#iS1Ggh!H~bm1YvwP(1Q!BgZWHO*r{@<xEUqVZPhVAJ@gf~*ps&vsl5b)K;H^A1
zmnl~3dW0+fg~n?7ZL}<;u?C<m>1{#*em0_dT7fkFqSf$3eB{+`yD^8@m-X~;OY!E>
zqYAO06Z$0#M)82z1m69`bN&GN2&bTQ8+*qRm_ET8?eYe(YC)C}2)Yv_X)Dr{K2(Pu
zFXW@CJ>kE<4yBvj{S?7F|ASo7|B7~FkKzVlIF;I|AVHFlq8x<3>);?zjGNS~h$Tn-
z*I|A=dzsH_DaZQw>rba;jG*_|u$Bo*Z|AYqGW@9!NHAUx^|Z*hBc(1Mghy<4k7$?2
z>6$Wq3$f}-dq1z*lOmp2nsZOO>cek9r9aN7^qc8{cXj=(bp;|yaxT7GI#{Q|$bi^*
zzPUJ7MhL=fm@QE^&6b@LyN`UWAXboObd3)+Vy7g@C+hjS_)y%q^$Kx@X&*&~4ioA)
zT6!Z<3v4ruVw_}=E<S*Y68bXir~ra4f>0e_co1>8l3h@bL-{wX(dU7L`auh7w3|f6
zGPO;jx<(CYoHNI*gmc;wH!}DTKv`qmtjvczdXqL<FGk;l!2=|yQQ)sEhITwKj<o$c
zZOv{Qhfesh>qj+xUlBbX>P8*oj%@P#2w^m&b)qWQ(2XW=e#N?w_cXndZA_e*k1{c$
zX5iRc4EUah*DIUWy4U8)ll~{2h-#hhGVXR`+}8Z}+A33EFM-zz8e=(SSW*Qm?;mms
z%e~BgdH&o~@S+Yj5=XSSM6R$6B!9&6@;eYj#`tZBh2ll~(p}NB$%f!?L)PVk$(D>W
zPbGUhsVHEfyM{rxKHl1{t|+^ozMd;UV3)kq6yCQmo9{>28k|HJ5b$f{a{8_48t21A
z*|^Vkd)%}rpGV;z=bY+H4ZYWt0PLYAOLhAri|SEX5d+Ymlxt0d`p|6?-ve<S8fhEj
zgI&ALDzLA<%~^YKusZ?g0p4lqPGo6()eY3~8WSU5&{|ckICi5IBh4kw<(~pbtZcco
zhom_7wtmgu`A$p8Ax8>sJ!PZ5HKGE;pK11D2D2IX;uC9xFk!b#U|x>T4G~8<4R{Q?
zp+#xuA1IMri%r@={GvvC!o+QyJ)UZG3t_k&!#)XDgh{X*p1TBgb3h*j%V!$OuS`uF
zAD3IOz(i{XY?b(1zY-ZgXN{4y96c`V{Em@B>HTWcR=J0V`D@^?YvcCNT|7$I{jBZ2
zZ#Ef+1<&QLut%=haZVX~a=YtzkL8<n2>4w4B+r!m*!_U;aw7R-*D}>#*U&|@h*Xp4
zd#zKYx#fjQy*C|y-gG0^?>vjKIgE==kO|%Og!Y8U=JImn>l$vo3bay+@Sx_|`{|f1
z=-iuVkM*TV#QBz<W(gZkOO%1Ht}30ICofEJ(70uWBU5@TzIg+Ic#2151UJgqi1#4~
z2D2>3YwvM6$5LczlD}a0u^uxu>72?tk24#sY&&-cd{NjR4VGkf36jz<!JwQ_HBHP|
zNcS*R@*SVpK<n$<6Y2_-?7+5vPfZr(e*_v&i@wr%|Igu*vXIh-j2zqQy12m3c5>q{
zc`tk`A=WJinWU)V6Q{9oW#i-wEsuWWK94)?)r3f$jUPnbJvvEOQ6mkn+>*_{l1^AP
zKPYExk>wk~r@+_H&`=+9`w?-{$T~ZQ&7+-llPut0yqCw}4>{kQ;%D#03;p*q<#fR~
zH<ejQjJal+LYZ2o66Frvw|?qF?>h{h^BXMB6w@YzA96gnY^<1@B#9!87H7_?1a>7^
z@sD?h^dvh*o-T{kniN~X8kqa72K(Q8Xg4$8N2~djTm7mXPP>EO>Y80Xz*;$Lyim7|
zyN#&re{Y{0m@X8%u=!kA{5$`mGS$|%r8XBc;!*T+w&8&ew;`&mk!x`dDGYte2A`ep
zNJpkgZh1k6vmaf`QX!;Iz{+8=92na2_^KzsgkH^)`74{7($d{uhe*}bszBlaDkx)P
zeC8U`7J!Xx`o}?fF=qQJ)H{vI7}n8f2U%(xtNN9iOj2zV<jBbj)rpWu`*<{IWHqnL
zJgFxBY!hZ6rpV@2WC$O1@Rets`2cBD+L|*pQm|o55sl0tYq_=3XLU7s`zE!yuCX*h
zYKb@{bqZa*2j7$o%4PvXTG!lMFEs~r&9Rpt@#7|Ov8AmN5tCv%y_)^YPASQ=Nc}aH
zUk&OoEOv*IbT%>MckP3#9+K;k^M2r5pD{ZZcQ4X*agBj$R2+fFPQ*Gfmaf&jY46LT
z8-|fj++%oF4E<eRt)R}g0=83Wn7R|40}H}JmZqPc$Md$<`+1>AowqhX=ieTsi-8G?
z!9p=0PMMKoemy;&vKKNy7mZ{ZA73=9pFD!Z1`r(b+ba-h=S(5z&+9NRJkuf>=Pw)R
zv#y3nE4INb8Y?r-_4T?(OV15|vuC`~lvH#amljTZkYMRk`F$TR&>g_Jw~u{RPW?zh
zddnSyZ7&hOW_<>kH@>}tX1pJU<R&GP%uYx`xKGXSRA?W02?7<=_cI+*J0Uu02Qk`b
z7^Q6R0^=Md4?YwAD)$3EFCI8~jdoY+(uDdt@~d*stV8`yoh8t>eU<5Vv?Pobi$X^n
z_dHmawY^x%(-^4<U3DsIkayzf(t%@Gk<l4ZD;eTEEV!SF)L07PTO=yoTV;7-Zw*@H
zDR=O|UESZOyb-i*7bSEGQs7xu9{F{qDYUa6>ht+w(20_;DZe_Wp9V>#y<GB@gPu>z
zPnXAqC*G{fR^K%5)G=ne+T=j{)}iOOJpm)m9@UN^0_)Ss2v=B#H^o&ZS6HT?47BfL
z{5)srWJh>kSchb_7($++w3H@t-pGz0=y~AcUQ)i`O&5*yNE%?Or#=#1`&!_eZ)?d;
zTv%>x-wRx0?HEbfXEwBBKYJcB<GfzVLD8DHY|MHL=Ps)R7iqnb<t9Qg`!HhlKaBxR
z+xgMV2VS<fPcX*V%@O%3I`}vRE8l)^zlR(qH4n7KO;$|BmKjRdEsOA=QJXj?6=Ccy
zkQYyC#(EaEHlw94*+AO{A+*OPX}({!QGQ0C2KR6mY)<WIBa%1faIBZg+^FjlHy)M@
zdTpCYyK+-Xa%y5AAuoOyJK7t3@1pJW_oAlks|bg)NO6+kU8tuIk2iE#2fMXd<|;1R
z&G2WQD_!1+9?J*Jnd-r{Jm2TLh~v4R%*vhMukC?r6oA&emvOpxPUdeLg2iZ-+JC*0
z+dPUj#g14G21>jKCx%!RR6bWh#&svHr+z+TtJ(KC+p;Wk<d(KO&H(!s6|H|pe75)o
z_17V~Ss;Uv-w|;UT~2=>V-BXC$TR#`2o6FJ{`^5ryLTENy9Y^j;h_cZ%SjMv*6q~O
zd8zD%-{3PF3;g{UxBGee!nf)f%li!B4dcq1@L{WcKrddv12<*&D9P;fo9V;UMv^$x
z7LpP;qebACPrkPQv^mt}naHb4)zR{Nmy$7Ea&H1x-YY*QEWs`)roV?kxW)hAMiY_7
zH7dbycT)mft`SFRwV4urlBzK&acyHSnqv+QD>W~^g6k)f!+bX`Nfs|_K*x04?vm!C
zh|o6VJ+6!XPF^|c+CYaH>@`zk=rZx!BODImDUW5i80D8b8rtU#oXF~wa(oh=$hs-r
zbpmB~*`szaFJiJ*XCp8h-xpX?$@L>&345W9?r4}wbUNe~xC?8N1DevFIc7E}TP|z_
z2p)<wd0i$n=(P^Bo;5h4>(R7ru<~EF-M-_7CN4&drrc<h3t$b>n)7(ee;l*GZBf=6
zkQp{6vEeAsitf`VtLy@KE}5bQx%maZzHU=TGq+i==GvW<4<Sn*O_^U9MO}$1R4p5d
zp8D1@GfWt767|0P(D^l3%^r5Y$Q}U~S4tx7xuAHcV*7iClNpE_Mq-oWk%$NGb^zam
zUtdAK35N%o@CywR=*8NoV75z90PThgjT*JG-(VR!(slw5{RAn1%wTuPiEM~Z67tG7
zx?p#^Tc+>HR#<&}vV+V{#&*P<(93@ByTn!2acdtEg@KsvxVy!}kQAoB6M;Wx{%niJ
zP*+);R7WS(We;6Rs|Jfw&4XsPD_)-Mz;|I`z}~yp3xsnnG@xK{3^QhWe!xrG^5_wp
z+NHTjn_^?t297-Zl3SS7HBKliHOcWWfhZlru$&*3zMj__01^GbC#RU1SX-8*4k86B
zcqk}179@#<UIzTTi8Mlcj>g8A?%dG=>R?6^hZgP>cBr+mTkTP{S@n>cH+?srwi@$4
z^spL_J5)5WP8Fn|_z^96*{pL1C7E55eLhUzA~{AQby<H4aoG8!L{KP6AI2?CE5<wf
zJ?~9OIKm|8yCCu;=#+ApWOiNtE8(~sL_Rn=33=qWS}n*R;Ctznt1!QwxIf#{Bx>Hw
zA0(blN^GR{a4`uUxv1B!5uOxlPWq`mdcz(1I5R05IGX_@DtjnH#!)}7Kd?G^Om6~H
zjqN9*&&?0Veb_y+ysO44B_rCr@oqhWL`TQclzmXA@#PF-<!QHQiN5ud`suE8m9eP4
zb?wu;@Aomz;)N-BTo5dz)j*x!(lvb5{F;9)ygs-k`Ee#0_dA#?IAmB%61AP65)FP=
zTRX5uHyd52N<We$iDD6{Z({~wmptrL=bshPX|*oy*wNV!>@sCpFE;I*Yrs+#k2plb
z%aej5V)wWlIWU>Os2$QF-N7A{1$Rt`G93ZvL9hH}YqI4zw<cwBN&PG5z6n6M;SDp<
zh<b&O2;lKml4B>Fsr>y%-ksj`>#w;FCMxjI-V#okSr{8{f`6J(m@S?r8i~|*k6~;`
z<{DeKTzsAwcj9x=A`Q;o2snb5T2WZu`6!LM<1+omvQ4_m13dKaNq53n2rIEOBoo|y
z`nQQoi=;B-ui6btUIi$UsM_78C_}2byjQpu+1bN-Wk9c!Y0si**3_d{7F~}dG+&8p
zb$qMKiTgE?f&yFZziH>BtKMh}ga5mx{ypPH>*J$IHh=%^G|lf8y@O1;v}A9qw&zTP
zmR_T3-c!6^bxWeRKqHkN4c3^^dl;F5*&Vh^={{E&AOJRJUEpIV2)a8tmsF9Hi5_98
zw$$-nUcPPC)+)CiOP-)Mys_gHLbdHpl5685nah#iGCfb&kHq}buUYtS`(<YSe#C)r
z_V+GsMnp0yvs2kp9%c@81x+)?9nv1^>@hg0k2c~&*NeR3$>D~Q@V@ILt7HX_Cy`vW
zbslQU{u$X&6+3%}t@>|x0=^jHmyfZ@=YQWh^bUDPZ&pk<r-cT7V+9gN&Csh|7E_yl
zY)OU5Jx|NdmF~D+@$wG;N^Ae_t#Gr|e&hEw9{yZZCPugopGV0Fo07zNSSK*K_j@0A
z9FZcuury1ty?K%Q$LXq=K?)5bSP=f8$fr`<**)!uj$a>&vm`AftS;7wa(k_VbEQjX
zFN$}|aSa#Yc=nA({dMY_uwv!PvxK52D|>A$YTwbK5T`1R`QONhNwA3@W4e#NW6<<n
z;vqyDN(_{=pSXYq#Zt3|z_#NXANP@9ev)8;BUz}_Is(X%Uo8+l=%*CYc0NO6t0Y`j
z80sZ3gzuL)`R3IC1s{?_yVEou@EeC9!-qRV9GmQ#q-E-74pG?T$d(TeBWbjNhQE<5
zEx;gg_3>b;C#}%}$LaH}%2ewh+_hsElgS}vBc4mrYf`*=#a^u4y0n-*G(5wR@o$t&
z)KMG^`-NeEC0+;YKzdTAct=QMQzr>n;dHrglq#CUoW$3=FBZZb1ZIm-J<<$%hM!FM
z$zhfUQhw&S{GKi(>(a}Qw;@*=Yg2f@gW+(U+s$J8f{_G%SYXs2D$YJYnI2i`zDs$N
zG|vB`>zl$O?V7G*PHat_iEZ1O*tTsuGttDhZ9AD@V%xUW9en-#*YzI$C*22k_sOnZ
zxU1G$weYx!s8|aJvs_^FNz+DEKq4zq8|qS47HY=In<iEv{f3Ly6+%D`|EQ@a7A5!u
zy#hU8sWy}@kw#f3GKM8JlUscMR#6Gr4Q5BhIfX{O=Q_emp+k*bRwbu&m!o|eil=}S
z`*i)-eekX&?b({>+4Ub#w%k=sstkBzGR}if*<CZkTk>}ORQ)|lfzS9BGWSQikds(K
zW0-uu1sud`(N0)p!1s19Fv0D=s1Kr5@FBxWB;u^QXX}C?CcdHUq{R%JVrcz>Nt3Fg
zg_{a&7>E2j-+*$6^HOT7U^hgha!~@-ZLYyrXa9j@7DQH(eO&&B1pos&QE7Znn?Coi
z?PPl{LU#VCft+^YdN(ufZ<E=BbM!4W4{iPi;?H3?1!)k|a=(vnp`3*v&F}5xLjZo=
z6RjH%{k=inl&Gq51XmXve?)63$K;)$!ViqToMq%Ox`En*<)b2A=*?FKldrQfrr(n4
zUG!dGU8`&RKeH6)F_=tj1ke1b2eDECF%4a}=Ud%ka9v$wSzojie?1~e%q`~*PgrO)
z{&djuibV64INLpJD1VqG$98WxFEJ(TSyy=|v;8JnU}iFLQ+#5CFYhWjNSpfZF_o{1
zo$(}+rRyUivkm7!cyq1jTKrn^Tl*L|6k5U-$pOle;qE+^UIf#KXr@&gU6(FuwvkmZ
znAuZzrVkORJVU)ZpoUA4b!WV-ujDRi4CcM4hF~!|pG@yVw?H#)dzBKy=gf)MLgW_$
z3}O6r8@r>52g-nGTkvoLjx@#$MGN&xG-0rzXraR}AIm-cMwBPkOl;I<=m3=L+0WKX
zGA9oCm1sXMLV%T6Zzy9~A>!Hv;@TEjp4N6$9dfN3soNM)<~zeHbEnyzAMyv5UipOB
zbOF9u9TIpVmRe`B=odcV_%wPOBZ8GIW8CGzt+`^j3qd@lLFom-ls=<<e4RF?0n>zj
zL_spJbXV!q0R14Y^pqV0!vQ%%tbbYw2cBsROU{e$r6*kC+clBX&GPUQ5|dN&I>Mk4
zO<IlsuDPY7l1_`cYv!`V*@E+!wuh)-U4%4^PL>RZ%)y1VfL*ZYHiJj%rYXTFeJTpn
zq&2yvT>)r9FWgm?UgQ?RafNWLs7`xTfGvNUjdwYOH*^lWSmFHyZRxf=4Hs+&c6yNm
z0y>R7zJLf|x&J_V)FW<Y*j-@%6gegLoPL2=16C^$7z1lEWI-P^cngO^>UH+Sudhr7
zup7+C!>w1wk$(L(4?7GuqJ3K;$%!btYu`k{fEV=TzNHbgLMS<{gSm;_hs*4{41qto
zg9W+Gi@rm&CK9DF48a)*eIg!Ts9d}AxM`yR?@jgfLQwSDA{a$klP>e^TF_4WH}1h=
z9{--+6fsq}dEa+n5m7=UCp?!RiKfMPR29`lGNR1dMQwld#u!({^{<g^pS?D9b&mLV
z58+-wCZ990fZ!WN4}2BohG@zl?nY}w8gAEj%er?zxstiOUZa<NkUjPh=fz=Q1=-Mu
z?}4Q>4D~t2NQXT8h$6Y<Ag+gnlg%9^NWaDJ3UVZ!sa+H$?gP01OmZpkPpMVSY^92D
zGhF+t{M=88S4qZWbjQ#U&c1MoA0W=6LW$y&YQiltHKv-P?A$*`$5xBhdjvPl#Ck91
zQvk!-_z58g-rCKz@H5{V^GeJy_r1tE*<$wJg*#C)iv@ge8l=lgu7ZQAfJeJ>Rm&Cg
z1g{^s<9O6zVxZ}#NX1swAMhJplHHzDSfMxt=wRD=8;vo~tdbCB9HcO?D9<70Ig~ra
z0HH-1Iz^JM4@C&Hy`QKQj04@oZ#h}JUT<CJjHew;@LuqR-(6^4<yh;_0DB+e|G9>z
zKgw6BLN|tbEnJ5`_ZBh~1+aj>xIl~mjxtU-uP&6e5K_<xRHUEWKLY6W-R8C8c~4ud
zOKhu4u_|RO9$f9}!&r_deuL1qPR{it{kRV;DBZ*9{HSU8Z*iY7n|ZxZF3f24;Gm@4
z+kJX;62cTrXeR^#`njM*%v%WE;;#5LYJa<OJe}01@d83{Eo*`Vs!3{Th2~KDu~cev
zm18j6tALrOPkX{>(e&2eUkW}EWMrsaGM?`JB8>(z7Xb`~l!9pFy7`cQWzX-Y)9!gV
zC~e*v{$&Y$LYmq883gm-5(qcoCy?$PReOr|()GYeW+XTWv@CZF1;qIC6v&TZq4A!O
z+?)OR64`?426Q(;*K5s!Isgh^D%|8UPzjXsvLY5GgvH6_CTy_aG{(neAJ9N;)&sMK
z@f&fKV}%n=%zs<3qG`!drVE7NuV>WdUKOP_pYX$7LbjE<S}l?hSf~T<oMW&0P%hMi
zeo%+tNI4GNZZzYY3r()KQ~JkUnb=w({ZjQ}|EAWHu~Jzq#*d5f*2(&D7nV7KF^hyC
z2S#K-T$D%QpcA+@NVF&%5M{FaRi#r13cX8gESTlajY=EilQ41Gs%;TQG{!DMZNmp6
zOAb=e;nQC(avhc;YwuJkpTa)FkIFBreax}~zh{1bixc6l9waIOQUZv#(?mH02b1P%
zFd;dl+VzJRQ;a+dlj-Z^=HZ7<6Oq*D>$l<-)-sEGXwMYdUii!LydSWdbb_V-14YH5
zG%$?2zqVuuEAjHWBb)C4lyUEqA+omNtdb-sEYe$Jv<3f4{SGn<x?lJ_wX9b#6%hx3
zJ;$*0Q<0kOAeyXjeVgTIqSc7<OuUmFEt?C&<y@9L0rPyrqcksGaNyFMPHukM1<;TO
z`3F^Boqwrl6rJ2}sPBstqzJp9yA&p*7_Lat&?cHg1w;wF{ZarWGrM~#`#F$eTMW@u
zo++=-XrJO^S>Po1f0{s8AcdwuA`z&4i69nirrzXhg5cq6R2Q$-7Y23O6ccllw^pG8
zjDOa}|8V_cdc|?rBVud~bOK!-j;LGOan$&+i?d+!Eh-8`2a`^Q-F?*f=^aeu+US%G
zRIw<cb!7yQ=C`y~d%F_QSPn5MJbk62qMQ>@!!alisWf?FwJa4cvW<1aTj(0z9L~Vi
z&+U}#1Q;<1gH3+60zV9(nkVr(;h*=zNpfl+&}~YiJ@fXD%9oM-Y;MX;2@tNM4V(_s
z)zI1@swQSMH#Saw{&S1El3X_;es6}pT%C$!P?`Bq5**Rx!la14Fj{<q!Ci(Ua)b`v
zkAykR<iXlY+hf+z+|PM6#eW7&r1DDEuM|XotwjlQL1<dTgd?w!Y6d~2o!sn0ds8cq
z4S-1W3{U~VJzlOlzehV5P3aZgXtF@egqdDQ!dKVH#3|uGoqg#{5hxXL5QOa4uIrgR
z$oD70vJ{wE=lGz^dg;>aZ74%Ui+X-q_@%J@?5UFdyU4av6EnH1nkfVUfAg!vo+OXw
zT$ef)02}ir4QKPT#Y6s$YTrHS^xR0!R1>*MBO&HGLPiMe&I!c~Je$wS?t!l=*3khR
z*_HSAxp4QFmUs0k1A8f)uIJmD-?X)8YR`o3F(=0p<!29`0%YoxwGQG38*Y>O#b#;U
z{!Y!^hh^IS)5~3e;e(0qlzZL~Re<(U0xh$RvWY5hXvl>5=+<9u+uX|;K)eM?73`UV
zr2fELb;4AmmQ5>D3=}LpF!7>XPcdhW)p9k?KlZ@Zha^ZPN3<IQBKJzc>V0F)p_uYH
z_SrfzIop5XgpeQ-aqSHW@>|jlDo)5L2P{z^X2V$!n4dH6WBWJ#(HKvNIl0r5iy-wy
zUNGOctV7tJ6G$XCf$6T6LEhOWOb}dy%^I<jeE4_s`F{k>)t$UQp+0#;xO&Q!EKu7a
zQ*+ImT4GqTdgM0Tgo9X0Lvachf<I%B<z&eqv?V|m(GXDTN)ioXNyVJkD?@;Y-XWDf
z?&A70ZELMr*%GBKre1wG@j;?&(Y)(Q@?)iXUAM)*(CZ0)ih-nX3vk-EWIXHj@?6LZ
ztG%8pLbE&#{+j-C%+@5DJ*Pucz&(kzQM6DDh7RYA#87m6r9(OJ<|VDtF~rLAY1es5
z<=ifOnY;Dv=OGdw97VTn2}R8+VM|XVrSQAzTXz$ZTQ`1jX94l_dVYbu!NN0Wu$Z&S
z>A8v}22<|)5C`No3WT^2im?g+`w|SRh{qv(iB^Xx?`xSN@W2|$3-RV-%n)>&{nsiE
z_y~a~28-%LB#2f}g)%Gp6{z<FC!P3#&I5C}2!|?+Vs9_SIC8zayx3g4gw9WaK_cB)
zb?~0vVE3$SK`6Hl|G5mLjIi8G%hmrF7@U(K532UGHCE`u%deHzQ6gFqldONqUx6cX
zuPRJR{?~&jjzA+dk%|t{-xtIv1UW4u1I;w?Z>H>^VN|#K8>dr@8G*JKWKSK;h{S*0
zhD?&64-yo?^JE2E_fzt_Lj9qmH&JRzOBw<+X>@QJHeZV8yeCU8Q~GiHzb%bXpk4xF
z-9nznThcOW@PD;pBFwoSn;fVRX*{&Au~RrgCXKX{as-d~O3A>~e#O<H%Ue;FeE&(?
zQ&`I{=393OsIuTNl7A2q9_A}*Dfa-+J3%!Y>Vi6K!7-97OD?IAf+amlqRP%|{zg})
zudQc<J(zu}MYY*c*-=woI{@4PfeUhsR#qcerckPVbzG+=dPZ2L92p!nM?F(FGv2Z<
ze$_a<ka28YUNDR$+nJIGUBPrN5)&YH^qE9|5hQpXFR$>78ch+2ysyFORjRX;qP232
z^_{+Muc6)q*7WWY3gquj4tD#(a&UjGaJHS%n~ebznFQXyc`W9s|D=|&(;?q2-vGU<
z+e94R^N4XlHa(V!c8UFXt3`?QNHRl&Zox3Q{^9>^PY!gl)y7{Dv{cE}-+r%tH->f!
zxP*Jhq<bYDk~@~ni2`qcRI>#~rF0ktrY+(Zt@-+j<oyu-T-RpnVJ%P$f2Gctc4I;l
zLh%I#{LU#vv`!Vb_|2saw@{0~!WCE1IV@+`8vFP6<o7ikRzC)0s8r!o@Yh+%&na2c
z81ugi&1?)H(F<!*;+f7zOa68hTC_2A5YQZCrS(i0h?oX;<(ccu3eZquvFl5(Hv3&}
ztP$qb)`h9@BDa_UCoz-GkMiZMI1RaL8#TEY+W3kS^)4XH&Pm1RZg*Lc15&&@a#ko|
z(gjl3Ey<vNMc~!TTvSiVL=RWr?8ghGoV2rOYtp4hVg`zC03MvD5^2@u-&X+N?3*pp
z4=!S)!7U`}I$#_zkw(t!rq4{E?hoN@Gt_OJS@Nl%A6o87z9hgZl9$V{G<*?kH3pI+
z84G??7%V&Cw~5-8Bf~QivD6($>l*-0e`wQ*9iqx%M*pE;!fkQ(RcpZI6ML(g4_IdR
ze9A}M$?qSNiG&m<y{PqaC4I{}&s)|C9oYx(&4M>}v%&rpz=RrJh@8Lodz{!umVH|O
zm^*V|!4K@Sqz+gf;ub9f&P<|j1E@icts|4fz-)h>v7!n8=?4E-DBLJe&$2l-|ID8x
zB!@wJHD+$zNh0_u&3MrCR5WO@;{)fP!kqR1bLRj`mdR(Xv6(pg3p^@eUaU0s-_`K`
zE#}b`0pZExo9Om8`AJ(SbQE;VPgb?aqA&6UFhw$mZM1%cR9+}w#qat5<U!^fSz>3W
z1euctoOq$}(Nex&g&u7T6=Y7<L%YmO1dut^jAqUYE4D%Aobsw)VG!8(8$wnj8m|v0
zl>Ez{L>%A0fgO~XfFyfcan(*3LU!uDL5D52<L-e`Dz$y$jLm&G`Y#L#Uh5aM87KI{
zQAyvtq5YUBI#|~x%f!sOC$UWO#?Uj4CVdm&_YGm;f^LFio^hkB(u(9S;qybUg6&+o
zLhL-zr9-)p@HaLc&!%)}{avTKDvc)#&q@+~(U*bss4U=0%h>x#3727RD+-o$rs|MQ
z_r58NtYPWYX8fq+5+mpR=iH}0o}=Lk3u#jhI(4bBz1zCXd;0VquyDP3v=?$<u%i({
zb|HlCg^NAqmhU<>?l3D|hOm1NPHSuw+e@OAh<S>`Kcarwf>+5n8rBET`mM2xgF%%B
ziq`0|t1-x?oRiw^P(!O|u)_s;{Q&8Ph`fmPCK3Z53g`O2(~!*4hjQ#la78Cm3lRiF
ze0nC(3R=c<JvKqT@}4HfJ{vzOJT5pv#~z+lnKqOutWN}x3Vg>nR7z{!NU^5te|i!J
zyNeuMUu?;==F(&H7yJpEc9Qt#1?<s6-@VvCgT(3E^ZJK|*8T$ANIFPFI2-O&Jc#8O
zgLx`)Aup3J>KqLm5)@BOf|AM$=Rol^#v@PWUzty&GAVTXm$0?8vbS41EZ4Xv%PDPG
zx(l}G6Snl9uV~|NHSt=3iVmW~R!b52E_CrWVkYg<=a7;O<I$@~d7UC%zO6Nq!w>L}
zJCkvLq7Sj|6$mnY%kL75;rTzzI$f6e{q(P~RP-~n(p<y!G@;f?u!h^>Ni10aLbG2`
zE?W{LNIBnzP)4wK0=%=<k$As3;%@lSL<PsA;O)>8uS<eROxlkGs7{iiUzDJ^utTPv
z+eBFGvIBaG*}tSoZxYH{82uk$D}1`g?Ed7u3QIS_RQ5-2=%j@|qg_O#Qc%(uc}gmW
z&6^^Z=|*#+<bNY2O8hzOs#NyBj~J$s9=XSOx+RV6&<ErVpwW;y!7SHmYw$~K73u(H
z%b|WM{y#g8hM@|*Ta0$&70+oF&J8lskjT9wVxJkvHZ#rkMd0Lt^IU#=1oubUwH-hM
zE4?szo;nrP;Q-%ptxvl_bZFRS+e7g_7aQ}m<|5Vn;QWuLybPyTli@K+7Vw_%grQEH
zcH(FxLb~gpd^)H{PX{MI{2i#T5py-6IHF}(e#=1yf+qflkXsZ%|ELJXDThR32C2uA
zTL9zNFXF*W<pYWFYK_l5;q(vrM&Euksxr_t(T2VMO=W~Izt4H7wlS<#?MRYl(SB(@
zjte%$=2*$w^m9B|J${Qd#g6SdBz4D?HtI^2oo-!?HiUFFcf1^N48C=RYFvzk$~ZDh
zIHe*v*r+%y+q;OqlHh=$RF?`Cb;BG%7%(!N+(2_}713xT%JY{Z`t~Lyg58VQuuMd<
z(bKp-Y=Jtk??{5b4br5O;ThGZI`VKwVlW1iKJ`qxy?xRc6MO|edk>BDy#6-E3UPqz
z)_eJh`^DT?b%rPk_Yjl4p7S)#AW$Tm^RnDXnx+cGcA5U3_!ReksUz(V$Q@2X#k#mx
zB=6;a%Q+J}8nWO-LMu1x)6Fli`B~{^MLD69%t}K?2r=j-NFNmC3Nbl8iJ6dE8`OY9
zU{#+m7!dc#K8EFsU*4BW3prt$pPo!Es3iyOOZUXpZRQ(ugF*n3lJMED+l+YF-x}6D
z3K;=aF{G50?v<h>&g6GR_Mjq$O<A##foVxYhSq`%LbajIBE8&ek(X_xP%`;Gs{a?r
z!!Fm+9?SGUi#fzekU+z^;$YsDNpz4Y>Am@W>bA6to%;B+uHIGtTM;O8>Da<l32(3t
z3exovW_Z^wO-~Sdvu^^7JE{}R;>;Id4U3trcC~^SkM1J9S@5iiUSzs4x~kG%qP6IW
zSh6w5lFPjr1hs{kf|)Fri=-IX(S{){&=~7Wr`l<uL2XjZ;MrIpk+BF|RwjmYijok3
z-NcDQ6vA{#k_%7SbjoJ=k;33HJh&0GOMTelXVoH4;@YW*(gQa&5|rX-;f|CcL+oD+
zE!BTn2t4|2^o;Q7wL9n}qSpvDr7*LXFC@POv5X9sOW_)v>D(}y;v8UlZosWCCExj=
z594tfkGrWap#xM#G+DQ<aKgL8%*J*Eqy|q~Elr4WQFA{Sn(F(&{qo?zf~#g{mf)h%
zW{=|W&lcpc^m2t*&lYJScVmSLxSsL*aiW5RppK1|a?TxpZ582}dH~awOF$k#?@ugV
z0setUnVBpB)%YLC#}1IA@goxSgr}OVF_9DG8)o?vR1*??{Pr`coDfHtW;rChJTGN6
z2rKb0!AC@Y5r5bEnv3P&MeqF6MJ3cTyHa(B=4kCzoB|k))B}{Ql79t?;~iP5fkxG$
zd$@lOujiNl?%UpuySIq*I#|OdFux?AS5Eq9B35kQz$^W1+*!iOmNfFzyFv4lz=0CB
z@<Hj8e$&p{h_~mQ#@rC@-hk@d4!dr1%YM&w0Dg}hjwNAg5u0tBGyE-X#49TPbs|ib
z6<;fsTJNTO+d*58A0kM!Pz==|GtB3Ge+9eRrP4aL4zp7Ydw{&yFFfw`V)<XG4It0g
zwch_glOi}pCSaVo368sWmH)>F!ocUlO^yyXi2T^#k7u!H^0dxE23=3LTTwUO*}OSp
z85wbsD$uxYyz<1_Qw8)SQFI;P-rOnn%8rqCv0Wtlm$Q^p))~?x$t2katvEffxEww$
z4mFsAs#{x}W{c)3=la1t!fB?HR+(=s<fI(X?P_A0!%K%rfk+ilt`|NZCn{qi2O>*?
zS1)4O41{G8KbjD~gO#Wf6jQJW;7r;kejs1vAGv0Qxeb*vL8w&Tqxml()~u}vzppbk
zV<N!CfZZBmB~fBb>VSv6qf^YCKu%5^VkV?-N9>8-S7fd&ff*gbK1n~OiL|Ci_BMd?
zmKBoKTZ^ZmoEl2z1;vf($Jk&rSl+P99vJ=m7YcV|D6HzR0^yh#qT&$(KVh2JjUaHd
zAgvjlXUZ{OR!Q5=-$&#a0GrdGfkoN-6EfKLb~}1iDx(rg1v1{ik!8e3WDq9`r0ES(
z-Uw%NH-5A{XUqpF@_B)L9QQ^PKc5HG)te$J?(<pSB7LL}edE6M72)xckv6hBBT0b#
zi~}G_vrq*Zr6YUb*YVyaOE{8M2K?GRXAU1;l<2>p&4I67hDx46O6!?m_|WK(NN(c{
z3ogG4K&W0X)4svp%kHaA%|3FCK>7;=db*`3)^H@>sEdIOFltkX80m49ZH87N9bBA|
zgPA1FQpAfm${1#?viHxBw6ddu-8qmfr^w6cLTP;|OulIcd1vH8%nvt#^+%w5me}nm
z%^E@sT(+GWPBokQ;-b*Qs7rg+?H++*K~#<PkT>-6d3AG2l&}A*%;!7a_ZQypM@*00
zaYIo-Bu*_B%-`yUlPqkWG(dHU3Yn(t?D~6`yW`NCtQHhwa1gQ4*Q!B;0KMWb7HoV`
z1QG}iG^3cMu+es|Go=GP$?)hP56~5yo2FD7V+B>BsXXjFuFc(IugQK~f$u8yy$+h9
zpC)qP;4%!9^06kc(kyMI`Cw@=c)=w#CAz}H9oxzGO%RcGGBi2Slm70nJ~|Vd#)k0U
z7DC`}NP%0~{SQ1W_)z~2N9X_A47?ueK>T!gz6kHer#gx>C$4{!%Ku^a3P_-2i^xok
z9qpTgnE?a8fi4&NYlHz%{Xk9VZ@qFv-HFErH)1s3a1`I+$v<RS%_4@*&N{Ou;n;!(
zlhlF;G2`cj_<%=cx|R}B9J5SaJ)ZcsDuDUnC!e@u8s_%nNM6AXMdWObiuSwk$rj5A
z8~Cw=z>y(0PHv12^^taL|5JUf0y!dAIHRvkv66y1tx}yFmChzd<A17u>CtGDUMo!U
zdB{dFZ(zU0qJ_agrvxs%;Dzu}(coH+kH!oIDheXFf7#&w2E9aUt(26sw}NOVtXG@!
z#A*$$-Wk>dm!9Je*fN}_$!sA4NTmxy<BZcwiNZ!T<BrLw8YlVhmtXfVl<CO_`9*ZT
zD>`v5Wehn2@{RRSwhnhXsD0m+-ymkvjo@JNC@nitZ)C>=Pdll>^|}VGV2^hFjzwx>
zlhQmXeMv;Ex*|fFI@0b4lV~9x>N}^7z8InKV%*llT5;=B^V0gHc9?b(SAxAf#riw4
zVW5PYJJ7$RX;iY-8JUk=9zp9RJn#V1ry4>6&_IM!*uovCE<*_+EPwaV99l{jl!4F1
z=tYbl*_{bSI3v~+<{Ob<CXZrTB^#lCI){^fL>}C~fB&{gkb{EmB}(5E3hLdlg6FKD
z2)2Pv<%bcWB9tGfqx=A$emr!hG({x-6cq#xx_B)8GHP>Hpd$s56J(BBdd0NvLNir<
z%FYO?QCZbf#tZZGB>VPs+U?&T;+*`FA(;hD<^r9vxT_M9_#|AfvCM5-J*d^kczkhO
zj^<+q)<dG@MBaH}dpOd;rV*lr;aBs1H!j~SCoZtISyOwQAm`BY=ps@n-MCxESI_WO
z?OycoE9~blqJquA^UJtn0xl|O&~66#gx?$P7)8!PgyU73MC25|a7+|QGWXEHyhU?E
z01{p@>oU0CVk3&ai2Tu_tkd!XA-8_fSBX-K<Cqk@Dm8AxgC8rq@edfgC8^8<jSPED
zo3Xy9M1F-)&`{<tINU#cWHzVl0wl>m-m60#(XJ!LmSa;HI`JUIEF5*<k_yTkxo~4^
z?--YV^3YOuK>;tsbTmV}9}yJbn5Z+@B0kwiH5ZfNPJe-*Gx`EzJ$52NEEd0im^KVW
z@r7ZHd!{LzLt$!$WE&&XQDg5=(l=-SL8zs6|3smai@@akjdn_%%6LWJ86O&BDjza_
z%`Q{xax3KiZ+=a|7TV({@V@KM)}4)dzvU3W4aCr?ZQ*V<>~_gKvGeq!@5ruHzh=F_
zid2SKYW5Sf+fJx&^3~SI7M_BJ<&Sd$@FoLj@EZXuKW?8c?M&Zg56&oK0-x_w!M$i8
zQn}H5&#5mUcasC$&C{LYxzKFW_%|3hYR;k9Rs~wry!tReSzb1MJNT0^3a?M<iv^H2
z8$0d+udgZbg$?*yZ;IB5ia1)3rK96<^g))9_dFDU>0+<3KF9191T(S?zZw2ICJFUU
z=0rd>b`#Ob9{nSlt_YuTCNFsK9(7D8MkV{-NVG6w7;!|8^Uv(xW)hsH^mMtUIo728
zxN?YZUdtsy2LmZ8(ZZ?!HNYqx7na#kjbciIJD+XwT|xX)sNGHy%j8@-%RX`zs*arH
z6#H9AjzGUu!5A52!&nU+^GyQc;9(C=I7LY`zJEuSf8c8pJUOc-I;3DC-1cU|GW?Kb
z_4)=~shEFl{|FGhX6OxP`*3q#D-L)e`bT!7Le1^%jH&AdH4L4jFFwMAGS+1qktPlA
zOb#}`P^4w5ws}!Z5vX46iv?#=Y8fvJ-@85mp-IEUfM?KJC(wA@^}`57P|p===P?#6
zic6(((E`GNi%RVFZ`&M`I8Nix1{Ui!#d{YDV7+(Xw>5-Ce?Ig7umEmrU?0klh_l4Q
ztfEeDkbwBvaAhmiB*YNN29z)Bq@UmI{#?fJHiz?4ix5qUfw9nqz3y0-zDZ9#-W4M=
z&g}H}Z_VC3vImFSN$%R?w(&g=GjI}QG~542)jRRg76V<+w9zxAu6G&RC}Dh%-^)O{
z*Jk|J`p~}j=xfDy2c7PJ2?v(>Zbja6v972HkEHq=tOK=20G!FB`5asc<`$aPa;*bh
z=Xrz=Bu{Ol`Q1*##4$S(Ld?UvbDh{2=HzH3-jT~hu!M6V4pdOX#it$v?pNKXWFWVz
zSecs2M(VDWsmjr#Wirf7TK(VP3+80|&u*A=WoQ(*pm#Uuh&3Gu8Nt`=J#ZN0yI{~n
zGt%f)?34hQ-g-Y<vFe*v_fFOas#(9G-TFXKt^Ep*`7u1yH5(q&hWnv(+B6p!5&#Ck
zK1G@%`KZ7gn=C?+NJDQNEt(PiV(UyM){6<i0GK@z&D~`+q|{`2dG@6&tFs^oZeu&z
z>mOZF7^cz}2FkmL)S454rXd!8%s7z5?v<tp^>PDa{-TI~ncK)Z?KPuOTZ#-Dc+uNS
z*y-i5SQKemCn^3{Pu@#<>7UNr;;KNPjq(213+#oo3fu%e*_T{}dm8~2Lpe{w5;9|j
zz7UNn{st)t=ao`Z{N$TPnTa6Kq^wBq)+9P%=^JByudSk<nqAI@8__?X?^w#>v<rgc
z0com+E-77X$q6XVp)J$P1ZoAwTq#W1<-f3y4VY!J)seuBWo5m0rl&80@9L_MF5Z0n
z2lQbBKJ6OB&vS6PyJP;eqiHVUWOtg3Zy~sTzh#X#otFZmC^rmJUV>7vn+)NCY3)HE
zI4O>AUc(2IBK`IOq0d?sZmoj--pmZa-4+NH76dy#s1n0p_BFR0w+fajbF&mQ1@!vK
zI_v)8dE1hZMgd%C{0Bv<v>QL{Vk@4;8g>7B2>-O|<y7phrF!9IC)<l0(w@hT9}ak(
z`)#$eF}l<2q!anIt+tx5?+1hdTK}gvuH}Io?w59*D>^P0gspU`#Q`X8@D)79|H$Dz
za(?%P??f)Ch#i_!4zCN{Ca;I>49sI*{MNH%5p#A$Y-1@1ip&rGs|yf-1;)U6e6j=>
zkR9fQb8Ic(LBrD2?yU(8@*7ki%U+BwZ2A63`e}(C`9s7xve}%c+Qm1)bUfF^srPq2
zogj|1<5Z6dHs-#_WHO1fHD1E+u;HSw_cW9g-9S9JUX<XVQP!1${!7!wY^D&~h6nGX
zRH|}ArR%m$yEM!;_`KY@SbF<I{TFcC*|e~rG%46UkKg&M+)Nx$io^f<6zre8aB`9M
z)BU_Auu;Kx+h|HZkp$@Pt~JKE5zM4ZLy%4pg%*U1Q5z5A=d_J`xST}ufrJ3$Q`mgs
z--0my5P*yn#tb$~O@MdG%5;BUNCm%Eqfn<=;|8k0#Bf)<(U*ZX#ddHx1zuyk@JfMx
zMJW2>fEQHl@?;1(t#fIH&i2v(G(a>a6&7IdBKVseNkSM7c(C_CF5N9R9U9YcSbr?L
z2I`(!r0x9wg2h`wpy>@NfNCfDYjZz^#E!rA-Ut>xI+Vc&ib5#NtjG1|vFGQjWszYJ
zy1T^g!P*dhPIeQl><s>j*@nk{kqseYS4$X;09`5*F6_Sb*=YIbTj{?&?tN{Hsen_e
z=gw<%BOi3Qr6~hw({o84DI|6$TOSUV6lcbul=-H&?1zk(Qk1ICCN8Y2b}I%b;fO@T
z$2gI;l%O^+s76&A<Ng;Pa<EClN8-Jlz`_aGQRDTVbU*IrOsPb-^b+ni&~~Q6;=?V^
zxs50U&;pd;Hd56n&-h`I4X8ipx>Z*Br=X=Nq4=jFSd&t_v{Ul9-~4;)G8B8429Dk^
z(wmWdZeswwnnz(_XkHi>SCED?vR?X(u%IZq2_sHo0Q$b$&uVr9uvrgxd`GKC0Trgt
zZ^_taAf%`~Q{ZrM?42jv5<D0pm8^Gx>mQWD9=Z>-3fw;qWTc~RDOvt#hvcQ*zcKYb
z!h`#l!x-xE8jbMM^yOK-Ql6$O6qJ29{mydU4)W+RhLfARzrnzJ?QuF~c)=19l|dGd
z$dEiER1CRJ4Anu`--OYRU^9Sp#fMO~kP_}x8VBm}!h}J}eI+mzS5iybB#HVl1~--}
z8lw<pOoPvTg@!TTIdg9!VjvqvrNQKk#e$Pv$x}agJCilc$svA{-jYFGMSV~fCsw!a
zW#aZKgI1nI?7@-b8V196qVc##Hz{xbJ$maxttSR>y9q|2A}Cx@eWBsoLlXl#lV+z8
zhOkUx@UDd`>jXe<dZm9TCjwZ&(Ib=xX-X4=a?u$iX0JFD8R*_&lcocr8~2e5c;6Jk
zm^?NSOjeQf*KQskf;#Zk$5<HWsXEVb#$=x&I$D(<NZ^9}ns{D+R;7HS<W7+hkJEw1
zteXm5-Laj1cMb&mdFjSHB1^IRBsvO2+yah^NKUCZXJ!grv)&|iNgfkgLP{VP8?FL~
zZaNit9*9f=6pZ-mci;*0i6F2ba?N=8RQZkye@feR;S4t_6rx$?VH&YP={I`t$M#x6
zVH=>}iFWIP_TK!0ivokgLNPjjKAnNa9IzJ8{{ew=kd;Fxo+D2ds*-Mq`i-60AeUmU
zMy(vCUO5~U?lkqoL27sdoAh$df|hYc-;KtSQ7ArdMUsUU9Wz)%o*zw6p!j}3TA3#s
z2MyFViwatlia|}8S&|~M8N_Y+4{z-8hOvA***skWAQ*NP4<vqDOgM>B>fir9{h!v$
z@R6>2q;i&@=bBlvj_ZsHsAHpl^fLpVCh>}j`53{-IN3qcd&idij|{0KDVW28g}e7S
zqeb$%K(f0!IG~93$>NXp>^dus*-nLQl<E8=^bc0)clb)XQoo#Jq(01(iM7vT&!OvD
z21A*9{#H1&a#Z|3>@HYFd=#SNm?<O>Br+YR=(<9}H_}dL#i{G?h#weGO>?I$fl~6a
z<Vefl*s-9tzeMA<boBN=luG4)`cZ3A^^11Y-^jDR6)skxwn74?{=k>y)02?|uJ{uH
zX)ZD_rL6YfeRqF@wvdI}tOf@q9J^0UmdbTY>>KOlPe3B8M0hZEHndUx2{Nutkop^W
zdsH{cF<>x-XR7hq3e3(n4(CY48^CRvD0nQx`aI0A4kwu62sw%B=)EZ5nL&%)0wLd5
zdA8M?u8|AAP&7{B1K~9d5|2v8?whtfWtaYlQq!hoG3<wey|9C}+{6-ZYjWf{x{(Hb
z(-J$PlTwMnTNT{<+fhlw`c(IB4e#ts1(2Xcaj9fSzvUnN?J6OdNgd>+NoxSTzvbn=
zHY`m1&DgPaUEO7QvgZt~emD|7voYrnxFc9E)f=NTig*_ZoNA(sCCcO9IoV~=bt5Zh
zcmO#`Has3vQ;ldR0U}tK8yANE6kLD84lp1@z>SsnwcW0h1T1lSboPk(k>>O<mNAY+
z3}uZ8qdqcDe8!DR&TKF7{%F){zm<+-F4RUV1Z*GZpYD=naZDK6PLQ9WSg<&7<c-+*
z{z=&v`AL_|tf+_{Y_28$U1bga)0A_M;?GM5_J8k@fNyDhy-l-ip(uGvQVceYte^{;
zg2n>$1uSTN-A%GDyFb%RyAEsR-4n75yT`DI5iaQ}*n$$qj~#g2lIJRsV=XPJ;oG%^
z?Tw)ey1{PhvLu&{;1e^B!1vz<WiHwJaLIa>3=ME8)UkHR&kd-}!izcrDv*p>iv_Yd
z7}EU@!8RFl;dlDOT~&W79>tRzQ;BtYH~1{s;d$(oy-n|{Ut$fX;L$Ji?-(alQgdqH
zQ}G-_xSvSaKM(+07FL(K6ZR|z;Hb0L!f7!^8P@flxPUiiFSO2NVO=J&gPoA<o_bHl
zU((<I{->RQ#n|~8!1TyPj;-YEK}KSh?cd-SmOoLtH~?1g?y30Co@Tj^#hj?UI|uGm
z@;n(961f4*MlW9u&v88D<?Ct-Hk(L&>+6oK%?<%x{TCIuxJUy@IY~l(Ikg8g*7rRS
zb}~Oc*-TYL`~&eU3oIm&>=rBp`lz8GC`1?n0UHXFR9Y0BmqIvk>UullEika@CBl56
zb(8gojS2bXnt|=4duCFh5xBMUma3B%&_Ex{$U>C#;d^SI+0<d9BNEO4520r&lU{=4
z|6X)`RmKBM#qS%=OQ<-&mm3p*s?VCVL@C(6V-;jOU_p5-%mT|JkLIO(C6rlobN5KK
zrT>|fdVT|H<oUH3HP#)GlyUdD#s5xar%0JQQC+Rv4&VEGol8)6@gV4BdJoOdHC9^~
zW^u#&Q52M_`GGnY5^WEtw$=c1^iZRmhp6&9wgY6>wQDi2zu;8n9An3{5pzCUBSuPs
z)T!ov_!TNm3nKNEI<iimX1?e#{y50|9+R`8AWTZDt8+_kW2i~Dbk+YPF#CshQy-yd
ztK!+vMq`QEJ!?c=4cNY}#NJ+FleFYfy)W#z(2G3F<7$cZGG1##kx!E1pJX1`va@`O
zddW!y;URES_i*%bhO4M9>1?C^JpYxWSLc1Uz*O}3HG4^V1flWfpguX`B|8aFZMi<p
zI<dFeSwwzO{jIw+P#McMz^7B%OI*YQs9&FliYIT<Kf(X~vADqm=`VBjky#Zu+S}&l
zL=Ilt5G#%T0rr3gJUd`xdsY>PeItzi;ORe+zAUqvAUed~XjJ-^J2m`*>Vw_ew3aUP
zsSRz^TPQq<@slKiS^j4F=R;$VJnFmTmG1RT+vD{|H*XFE{B(oPitX|TG{(jjpd|?t
zARy&j;_)}-b@D6#T8-A)hex;8vo*x?YhmS=XNo@1q%{Gzqw9LrFSh>}+U`ub<>Bd<
zXXS_aL!JCP8#zaa?NY9a@D<SJMt#8$E~%^Hi>F0wiE)lPR~eYHezI7}Q_Fefn7t0`
zo~tawAX4@_gm0$2i&zzyxekDG&#7HD=&uB1S9!EgCmpp2>9NM;moU93D+ysHZ5yB^
z1<b}K!=Glh39T@c6PI1V=?D6bRERBI{|;AN6s-MNXX<&cS_fJN_F&gLHGSOA^=78E
z>!b91|K{ivXG`y48T_Hmrf{W@nMJo`^L(|k8p~fow2v>hGR&ISkfkKZX39nBW@QWE
z7iXtXem(QRqvCnL{yo9Ay0zDT)wi@aa`xdiM`qgg^Y<Wg869*}s*PF?cZ&i1_EufO
zq$Xy9cL&bRaS09Pt!SHIWmw8?a#EQ{`O<adoM!Gt*TjfEN$CP6tZ(kDV;bUsplV@d
z5YI<2mZDP)laktBJ|Ln=U#mNlR296Z_zC6C`bC=g3m1XqF#fsH9CHiSd?yN@sv(`0
zdmoJ5L=!E0_IZ9B1DBxWRlLm%b-PFGI?mFw{9ssBURN^EH}=WU{?EGRl1+pBe$V>N
zCok8rmNXl@;N#sA1cLS|YcuwAGi9lLg*7MCcZ>mJUZ&onk$ImwL1M-EH0RfqDV3+8
z&lnT2d<_U^U7zLJt|VKIRqiXz9pSGWfT{ZJw6ZU)qW^@n;pI#ZarsqI2e)Aj2l>JD
zBy-0IzTnbx4LOi)B&0@l@%2q)sI0h?Xcxb#*0Shj#E;VlrZCUoHe>D9Iv?@_ZP&F}
z$Vc6qDUV#;IOayN9rSOmjQ8&$vJFozSu5{spsj_rSnugotPbJj5V;J9<E_@gveH!F
zQpe9H5Vi$+&v5RoQlT()d<T|a<S$c-9@c&G9tPK$I$YOQC!R7M(kplL3(f0x_TS^C
zRVkD5_yFB4eaJdkQ_OnjA-D8gj+<ZV7wg_bTxnfTILMB%(-ZOl4LKJKV1xI?rflZ~
z3Js@7azrF%ePf9wlXCk-WM@vThdlmBOE}AFWA$iC)<S#Q*{6Vw2KelHC~Lzn7o@dC
zVxaFe-y*V#uTn>kOk2z6!HYN1fn5u9*fl=ule$p3s0K<!<*e~~!$<uNtv+%sKxEZ;
z6PjMw_s{x@yI_5`b=%tflX2hT%Tc=gzB+bxtc>BQBri05%t!kAg(-VC(;4r(1-9q_
z;JD+%AGjZ#G-Hsj3k*jE@~up>Wd3IN_}gn7(6a7%*hdiyX(nF>=M>9vY4_R@_wN4o
z)nqKN+wYDBvInB;7V@Cqa%?9s_;vD<ad0IX3uFyr)zK5_q0<XrquK_5Pg;EH87NW<
z`dQjMWHLFM9$)4=jkG<g$AN8IC~hJR@O?-+;N})5$Y-V%ZG3}3ag-JAC{20BAf;nF
zrer?ERF_m$-MPT1OkeTKg7C_lWwE4r^=-C^l%O1D#X_x$;c}b^fNisSJ7;^+)_ZdN
zcjo5Tz=myOX;t$;lhw&P|CVlj%*(TZmG4KBQ)H%w1rA-Cdj8pf5UBmPn#ZP<!XCR-
zfL+?Q)y=kfygxwq%eX~q=@JLkE?N@UbYR_b^3T3y^53|P!2FN`@OyFEb#ZG}rh4s$
zs=Z^2|Gzfhv(|Erx~b2f&Kc_~9J%X}3l|);aTxH_vqpPW9SB_S@@+fnKnnH@G%sOt
z0qv9iJT|udZInmp9&_=V9gQSUJ?*5PMpdYP5ZKp?dC;0?6OO}h=IsCzxyDakN&iY~
z%||3RV0dZA5o#_2T43sWEr)>BvxkGo=*42M#3`e1(hP@28c$oG(E9w8>d{AhC*hya
zVaXs{dQR1!DRIns>c*Svim#KKnW!^Abb@C7bjlOwk-HnmortuLoU=0dp@>ZSBkrud
zSNpy}a9K(Jv<`87N=fS=nOvTp(+u%cqN6q)=n}HKV&KoC38w6I9OyEOTN~641{mHK
z2}}65dQZi7B$fFOV8LV;9BGuDHd#uYY@D>W7K=VhD>g95IcT?Zk!TfhYUa@_V0G&*
z6t%tFOYqG2PP2MyPjEgbR;)0s&`$B%U)k?Xi0q>EUbGmo?&O0lUm-;G==OXyuY217
zf4EY7oIfe|0QHYr*NDa|^p)06GQ*!Pi3hWEOe_fm9E^E^3k!oD&J}_dAF-9eR?`(Q
zWKryn2>M!4kE#d;TCdZCEsoL;UTlJ#RZf;E$d=aIzC@_g>02}`csFEIOGPYah+EQa
zK@5h(Ww$xj8}m&W@H^^?O#YBtpP$?cq}|wCIugguHjZ`tGxm8<8W;Kxi;Sr^zXY#>
zxk^BXT}`EG9XQ%tf^IpH*4MTe#?8ZbgfBO(_f%XqX{nU#^MNnO=BqG5kVp^8vkDgR
zGk-Gcsa(tSOgS>RKnWqd<z}y|su!)DDG;bzYi%VH4e=q&GnTYWJ)sfe$*4z@l!Vm{
z)K^e6_sG-&4`2RFndwMV=b09TkKU*bNn4)QE90LNbH92Y9LJtcFQN7FEQi>BvmuU2
zv=06?SIiQGL%Ey0%6iMJSMA|Y6WU!lQvOTrmnIcEuFlFs0}d>rdoJy&mF305m9bUe
zn&m`P(4ZD}UXREgt1j8Ps8`aG9lTnrCL;TpobJf7jtXa0m_-UgZ-IBMA+7)oFU?IE
zgkYZ<*vw~~kcR!Qbq^Y1m(&Q$yp3nbxh9U8r;7V*BYl0?u5w`BuW{7cC>fzs$$!v~
zYq#~&{#6myavP)Oz+ymi7T{S;k5_Fb;FRF>xhI6KnkLFK%wa|iSe_|6+VrFh(jy5}
zy83mGLgDkuX^;vHs$?oB8$Sw{OKgM^PJXMek@LyKf~{!Tl(OQ(J!q%A9kMmi##~ZV
zfHJX~`SB}Z1%fHB=OBkhiuaK(T$a(L@9VUOM+b!0^oI~vsf4;;w>4uLLAi_8*|z~Z
z2*)H8ZLQM$LVA(gD8#}Ni<`~E3oqsch)VCa$%jEo?-`<5<BkR>Yw@!7UjHlDYv*uS
zVr%J@6OOO(9R35<S}lGF>rxAS*DgN8Jb_k1dwdnslt$NQ?S0^kl^)Io+fkRpr<Yv(
ziW?oYgZ6YKE7f^*HI0nAheMe;rVi4kDrMfSzPd6-YmzLS(pD=;ZupIzb@fce)6I<u
zysNZ~r{OI3ah1Q)Lnl3@sR^z>s&fB8z^stIab$R>fbLXkPt}RasQ)R4<Jzx&GJ(L<
z<LB*~?zl2TwAaGxk-eG5r}NSH3|y#lY9rDu?(myS-sTHuNg^Z@Z)$&x4{Y~K?C@KI
zstt@KMU@S{)Es-ivg-B6_(kl0SJxw+k>4pqKv!O~$xP17u+F1n-M+CYucV%|UIJti
zhI@)@nd2r+)e%dJx^^#T4X9VbvnBZlo_RV(13OU3-@}XY`h8HNy)x|$PXNfRUXWR|
zJHg0UUqVvVc2N^U`dvv^Yh;9w0qJa~rap#tn?rX$2`N|s0VMwPxfLvN6S!=RMu&Jr
zVctaM8mgXG-h*i%xI2mUtZ+HvP&Vxo8q!zEdyunx|7MRtG*}gO?eff{qEp85p|x~v
zK{E_A>Pc`n_?|t{p*u87V3lWMw}gS4Z>_(BHcjBS{EKC2gU(mBF-X*FXz`1wY7GT?
zC;hO&toY`|Dm$&>L%Dzt7|BlnQHQP!=jbV5M9L2YqLFr+<q!v|c=lDyZaF3`U5&hG
zoP6{x{r1P-!SJj(o=MF%18K!U@V*!pK?+o0N8VbSPd-mLJI=TC3mtW4LnG|1dFn}4
z5LJ0JXNKQ5cCRs^Y!+J-bmd*ZBB@!-+^;EzH@L>yhgk{XzV&2&sPrqj$5vR0xN~JV
z)(O;BUK`kUwlPiY{mT4K`j;<$kHaJA_~C|zs_tyoggcLe$PvY3+VXfr+W&KM@hzn|
z5cbhKn;^;j0!>hgGt&|DLFTMyNRajTiUxW!C<mEFk|HZG-)Dy+d*xk>tJAzflsT=_
z?~bU}EYBU_Du|?B&Uv%)Cf__+of^@6L<;#8iLf23dV76V(-V8r#E`#mly(*1l}Q^z
zX@i$MeXg&Qz1U$mVgdu|TBv=zX3{zt)b4Jb0XBJbQf?zWB5p5t@SVR1RlcgTp5M^I
zJ>@Q*c<$*0Tnf7EE_0r^o>S>=U%HRI(^Ijhbz(X#Ha!Nk7F-s>8f{CnyNT%fTU2^J
z<3znqE<B3YqiyokH%PsUWbEU=ivH-EDm<8jV{k%o(&g6=9r)a{L$fl@)-Xr_DO-ZG
z{2`TwMfzzsbL38I9aRflKbU*ikO%k(`my{8pl?L;9U%alUWzOIu|6+9fUS|4-4m5v
zYwq5@pdE~}IkY53U;Dj7nV<!J5e`>3TT&HkJ6#OidErwK9(}67==C~tlfIhi2w`=o
z_7O744+wkAcAyXkVvA0T8z&S<*@Qy_Yh?8@>@B7=WM*<T`;Qw%G$=^j@+1yFaLV`}
z<Nvn!4XT*#ifasBr+JwjH%&axFO{f`nRShuO$)`NQ^sXo!Df2HaiA?i(y%&#aTllQ
z7Xi$3==pYVc0Ywv4zRh7dSHKfzr@9bRWIA^kv^@YX8Uu)ZQ1J*8ujFL+ie=UjWN+c
zz3W5YC@!7M{OsiPynZJ{cd{I;+3s0?zoS*ZruVhp+sbd2E$A}5KzhLJY$E=~ZiYCx
zOXF`Pw4AK@$`~pkZyRioVH0lepQ6{^hdpYPH;zrsBx7s5!G|>rtaR8Zvyht)kY%_?
z;lXF=Ksn8S_Vx>1&-?eV5EbAw8HSK7=4JSk`XCE`FvCXU&TTXd`A5xGD}pD3O`9@l
zrJ<^yY~Qwi50_AZ{u)a68ftl4{}QiJ_Mj(cz=v-7?bfj(lt0E+s$Wcqm(2m@NE6uI
z9~-Ii9z*-n<L#{aQTyy?0rV;-&!%;Ke7>D3`Be(4hAzC$k;@+tU&>wTQ=eB}kt5rw
z!#qVZ<LG0v9I4gOXQqy9?0J3`&v%4-_HcFzpkk>8{*E8w0|WGY<OLPrS!w6xX^-8-
z?`<)Mg-}N0_TnBc>mg%~)lIEX&@ZnzkkQ{K6+9G;K)kI{;%&@@ho%*{cYBAhJ7uRn
zMguQ5vu-UU{kyy+CFB7nx8r`JA-8m{>1EC`As}h132Y)jC$SYZJXj3)Af`)+rd}uF
zCSdTmR&Y!=ayl59jQF0>c}MOap|xAIrwf!AI>AQV&Zq$_`(-vQJcTf7b~hzCNcfHu
zal36IKohQ^u6726cmeXAZd8Cy9Ylq?{s>L#+WoYFt0+c+MbEb3SE(A_Uzdyr5D0rn
z*aLx8{t8!Dcqdkew<{OB*vT11{X{8NKpqU<y0#_8%NzDkKu48Lw}0ocn+u1>upsJb
zY)~y^m4i*y_thuVv>J6H@0{A`CFe6`6+i(=?ng-D#}-h)1~$#{MOOODP)*1l-rd$y
zcL4>yygMafd_tBBBOtbBj(@AjLOrRb^K@U*z_ih9ZLM05y9d{jsE#Ey=jw0w<5P)y
z_Drvbv)s)Ao2wkJZeZ=qgv5DwL%yj>D`+JY4Wyl$&>LaJ_P1Nlx^wMPYbE%;k=O5{
zv5F(-8ogC+E_-3fTRmD><&UA0w|?RBg4hCBTHZ`us#%kUu`vcc8?r%Eb$R}<B`x?1
zl$|+e$4XwcjH4$c73j*3=aE;8@3Jf>SL(mK|48#aA^r+3H`zf@@983Y#$c&?Gk$We
z<TF41i!dIiHhZ;zu<5UC-Plt|l8ZDJ;^kqh>t?@^L+dA~{;VxiyH*43&fs=pTN-MV
z5$9QznOX$rxWc;B02qk!X&-wSV&k`O$U6yho2|_Osq_6r=(fa|H}AxQ1P|}0XRzDZ
zZS&|I^b&Ie8npbhiL4|l#*Ul~?fg?d^*L=}%m*xp-ul#E)*wqk3eJS11~ZncoNOx1
zkI?TbT2iCTzG$P`CAe7(=r9gm=V+Bb98r3ZCWelSpX2c}Cm!wJKs`+h5>#EjaQzrv
zm(i;fUiZ4ZiSY0@n6Dc!znwyu*SdPyEJ&&N9~MA1=!%SdmTN&>VdtvudD+F+_01y^
z25s#{msq6<wSxo5Htq0L^ZDZ}vIc4YpgtB;dY0ok&tYX{=jmzas1hfZ;&2rdq)13t
zR<TF>lj`6o%mlA)DE%y4_Q_CH!3CvEcv;-&I3VCV|1%`fOy_#o4J~9k*Y%CV<7E+6
zuWAXbV<8>pOEiR+jNUH~u~S8}f<h@{r>07E|IsPi&HDs*ekE?TSg2OKu6=m*zAoxK
z#1oy@TH1j+{HG-kUFH9)>^-BJ+_tu1Kw=3hs1%jzR-}Us5Rf8@Qj{KgQIX!17DDI<
z*Z>=#bVOQ04<tb7Rp~8+me8b=gdQN2@Af?7ec%0zbIu<5@*_WzG46ZKHRrt6HOpEn
z@X;hz>sV^p+UiBVtV*oawfeyRMW`P4P53cO48@3nyua)BW2DBZuy?IA`4UR_gZ+46
z!I%%}t>R$5Gq-JjDfg%Wdnro6sir1~KSHX!$N2m;6P|E#5)Bm>7mzhde72tH7f`5_
zmHG?rhSwMTd_IvVh`Q_}Ge1yi6S>-cV*83G*rwMR)U>?bfk2shf~SYar-`|C9P-PN
zp~rGeAri=jhCz`cec2!}Sz7up>s*)C++KA?kTmDg_B)Qj+m@Jzxx4_l5*DObT_Ehf
z8nj9y*YpmFx(=g&kn&ei<X)ab<Zh!)%<&DA38(5ClK6X>{X$EpC$W4wle5-2?pdQ!
zI>ROTgEB7Q8PjdI`xT@Db7#&0l<h33BDoC{YwLpP#V79a<?W*@T#b^wA@O#QCGl%+
zLGhLa=trG3tn2KI0wP7357JKKzXo7%qRE94<0Aps!R3*_5`Sm>aGwV})cMg_m)tWs
zjnZ)!kylRsIKBSM-tMe6^X_XE<v*107@xaZ+A${Y@;_>3olXBJwQw?NAmdnu{VAx`
zftdV&2134UG=eRK7oNeOr6@npXk(}f<;*IUIC+SeAcQX-#z072HF7NxDz(gmr6;+~
zI^eRLYs8;2g2_`RE*+9#jJq-~f3Y5Z|1fa|e5wVZZ=QN}qKU#jR#y*SOh7Xb55OJO
zkot*g??dkdW~8LFN&Vzl1REhsNh0H#m0S*&@Ry}Ad6Ld}4@+tvJbwNl%qhsY85>j?
zjXo^re>A9CusUv)pzs&|cZ0PIM|DiuA{GCs=!%C0L@el)ucQlZpL$B(8N?V|u5F~b
zo2inrA8yMpjcj|`Nv_THcUES8G;OD>Zu))e^+;_y#^>-7h-Bg>7IibF<hsaf%)5vU
zm^90jsqGzf%?XnUGMAH4_~KPi$;d96n^-2zn2driO3S*CyuJMb(X+b<dER%80!1H#
z3y#s^rzkjaFOF=IgC)1on^&h8nb}kr{_V?2yeRj!hAXRFR&yXjUS?d?q5jZ}H-Z^w
zdZO@?ZVsszUITsC`&C;K;bp&b5u$Zs&T*k_X)JVgi`&EHxZ&d``{9ibW)&&M^8IM)
z5h){>A@<g~*^Qf&aA$cY>cU<7g6(^_qkI_NWO<vk0@yyf5|dZ}rR95<y%4fI9Cg$`
zy0pr;Yw>fznWj6hThtZz5w6#*SZKaKm?t5Em`J85FL6F9nmdavv%I}0)*OoU3V2x6
z)%qi3WV8Q=@E879Pz)N&>Z1Hq&AG2dC8+;$+LIKe*6#=&c$|B_S!8(N#y2j45qWg!
zV)bwz2WJwh8{bCiuRMG;0xr|!_#nhyG)=LMN|A`RmSzmUy+OH5JyRBw8=&qwiXh!d
zRw!{&kwuu!lR2573rWv`)0CKw3k3hCFO?+FB7Y6i;k_FygGuZ#Q|eIbX&mN3`>hd=
zQoWweK{=QE__j9+IvSU|cMY5%<D9w5#)v*bq2Yq$4z6a(U&gM=-7Ih`PqnLaVFhwo
zD?8|NK`_}s_g9+C%su=h))Qa~Q=#O-$t5pvUZR4(6r>6(HV4BFefoK7M_rpSfB&V7
z?gg@s^6y=ZdVf3H<1;fZ7`!h=Ocv|TnD#wE;+wR(D{vFf2~v%JoCM4{X83G{r7Thf
zaw649kvtD`-tx7*Ab=Ehu|-)6OBIi9?vFhb@MHo{4NJ@FlQNt*o8XZN2kD;{I+Y%h
zb!qw1aon976?GG5{)0{ZkDa{^SD9W{%<dYyTaRU3oKsIVSR}s?yyJuOh$>`WeJ=vw
zU9zYTe(M6MZ_80bNSXy`jk<Zlb)jTDrxK@Q0bfcbaLf&{z5ys-Zk^W6NUo!|Dk>g>
zC_!cl@<(zYcc$S4>O8pj@aRHojVtdYt7gby?4{|HM@=QU)qLXaLqCF<((xyS{aSOM
zaZh3&gI#y-(rmIke-U5AlA{fAKZ9I%c<;RXmo9<g1Hc^XmM%G=Z{>%tE!QZ<&5}e;
zk+sX3o!$)`AnJGzWwh4c-<0`}F7z*P&tC2M>C)X|m@&6JQ?*jv)y|s>_B|#>zTPpj
zZnT<yGuSxytuf4APzAG^VzsYMok#(ZzAySXp=0WdXJS|Msuz61qXM&S#%E?@FoIn}
zY&pof5xL7~k=e%fw=l}~CU_zo93k_4%0!SNU!=i-)tuZERKDYwSS)6Z5IcIzxxB8j
zqESh|16C^>ZbTBb3bMGxlYNZ$HG-&7kil+6eP-^vCwb0TbgVPtUoxwBGqbn!yPvMW
z<dCwrwmjg8ZmzI}D{fnqV%orgRRyGnyn5yIE2Yc-(cJ&%5kAaQiCO3SOOT%)?q1UO
zO%t80Hqh#;Q4{$=U}qRMvgVR+^i0UngcY>8+LC3i#8sZ`jVtr6_XCk#c7|+6T91H7
z_DyMfiCc$hiQ`q03I^Tk)1pOoT}7^mYeY4((5)sPiM!nMV+HmMQefgjNpa?lvVrB8
zy`E&5`HmU!3LgBqtcd--KGYFN1<5Y_?!&U&mPd-+jTcWNC9!DbPs=)~Ra{QZrc@1p
zuH{M|n-%z%_kQEj74D9EgT6*2I>En;rc{>crj&JAyY(f@yQ7~kpL1%*<@IeN6GDBQ
zm&W){NB$>&|3ANNm<!ZQV#)Uuya#o|$q`GF1dbH$^wBfBe#Xt*K88&0IjX*4-bi^%
z?V07I!Y}HHDJcGlsvNv>_FT#UX&OAX5UE%x;eBU;Q@d^XY(nR`s~nycW4b#o(=hNY
zQD;aoOJk4fYpDgF{1iBBb|cr&`K-DkCf@A9$%`LYyFUk^m~=ql6N_j4OC~IPopOd6
zy3?^Ht%~+Phi3K!N>e`bqih@(hNsu%ppeKy)OER_XSXbR3o;q?f~Ct%>zj34@KrZZ
zLBw1BH|GB(Qr%HT(E9SY=5F{^%)1e7r(MjzgU$n)@_?PkoCBj-{?>=Yw}G3#RK3u{
zwP!?QKSDGt4#|ryTVDwnYof1NClgdh*y16F?cJhF|6n+k%zbAvhp5S2ynENX!$%#W
zx<cnX%nCh8TIpCfGeg#x&We}QLZ>Cz*WA~t#zOA0@uW=<xM$Yn8A&<1-}eRbHJ&PH
z;fGjzN4%UvkaHVD;Ic@MiaqPFx>`JS|FE<pA^pi^b4B1Pc%GO3l5<_g994>WYbN=K
z3GaL#WAK<J@7!3TQDwWb90B~f$kz0UYx_$5j{kP#GbJh?VtjM?5#ToqK|2;h>7mGn
zr|vj67s9u+t^Paw{~vSsvp8s+Re!iGsWIifjAViy0f#q)ybbZ!<UlH=>D#&gn)3|H
z^N(fn)<flcjFvek3l@B_8A$kyHoZ`K?POkPbAVGV4jx$MLmD|IxldMO=D{}LCIXkn
z&cMZjsi#Q0>&;2rJq4n^I3Qmn^2EReN8YOwDO(II7<E6b<h)bsbdBBTn{LP;OJtBX
zV~?{|O}1d|Ir-P}KBEQ55X89wD{#=T8CV&6Z@n#Ao-gIzKd9;d38j+E{913|L}f~(
zW6CvK2PFz`W)C5rJzwEgYBy_9aIz@T_4o*6Fs8H>TPSFHV%l|48u68@+KOYvXlcu?
zdh6}h)|UA!y5pHf^F^H!#00O%!OdH?{JJJ?X%cEnV!sW#bhjK#M+yo%<L^O7bg)?)
z=xZ;ylxZcj&Z0so`)`vMyKVb?4n5jmXFXHeTL=!N{xWL*X%gtOe$(Vc>1@@CZTRyT
z9^cuwSeZkol)L{<bN-$Bgj``^tI=9p_FkfWvq?-$IC^rs>Z*5M=u1k;2MfU$c*Q69
z)ThQwaPX$-@orIhLf+sFn-Negr8^Kt83d&y$$u|ud;<N7!0~2_&qUs8#>(b$euFe1
zOEv2XmWblwwjAW|aqmPuL`vr*y646uz$=#6EF57gL8Cplt87!`=d##fH}3)2f=KwW
zZg&jw@JcY|+s*od#=FT7%B--jtlLeg>8JmF!TFm+>LCo1SoTNXPd#n;AwtoERIY!a
zZ95d8Zdl$baf%>U8hD?Y6#0!u%oXaNcVEoA&>!a$Bw=lA{e&=frVtWM7Lb}d?U_Dm
z?R|>c1}ARG_X(&iC0OK~t2Z!ggK;99H^WxclDT6RdTSjoOe%Q$>^V-Dwi_GO+Am+v
zX97<oBa7xR_;@d))$G;>{Vw(RtL6=IC;3+bpiL9SVkyLVwLAYE3jUvsF)-zx5m5TL
zlFK6-s9LNmoH7Zk5UEJQ7~~qhePGz$V+k#ByHq8(>-PyUv7bj<+OG6rdMEUL<@9+z
z@(;BTYvlLm3VxD2d7$vJ5|^9?AEG>@%ADiX<mc|Zt(5WUJ8`juYv;1NT=XUCEDg`T
zkeZtz=6D2OF8x3$@C!Uf;QxIm-r#ldk5O;GWjRX|orOg+(Lup3*0>7Lxs-fDUW<G8
z((FlogwvZ^2T|Wh)ZQ|3F1y_Wm5&Id%0a4WkN508@X_Z?(xBtx5Cc>f?V|F_KDQnJ
zVl|GO8r^p@wr~X=mdV`R6wu)yQW>QnFJGf*ztyotBuC;e>l%a@*ey@2H6P(9p#^IX
zhI!@5iaB83mAu_?cx)AW=DiHISm$S(>kLai6}g!-x-r5bd6IA79l3|*4mnS`i+QoP
z+a;S#J<Ruv<k$UK!3{BaiT~8ShKl`$?yhA7b$f45f`HqZ6zpet+xy{Xuic=__Fgj|
z9~a!X-*W>+6P-uvl0G~z#E$ZqXM$70SG*1{Zjv^JZ)O*cj4i=<LMo3Zt&ozq?`#lu
zn-m`K!};|b+^pk`Uv;#_hJ*WuT}xfnN4%GeW?=C0z2e->Kn1)N4u3ZnLOn!?!tl;P
zvgNR8z9n>+VL-(}!=#Y9`%{q@&2^kIUE8Twe0EQY%j5OHL4-5Dt*0+w{aq1Pfs?Q4
zF}%8~pc{POhJI))^Bb<X1%;0mta?;nwojSZ`8ca^)}iuE#O24SLHRy?fa|0TkI;Pi
zLJ%zeFu!_f4&@(T#?IT$D*g7@sYjSmH75#cbBi?{y0^|jIt^IDguGi-eb))L(+7H+
z*PEY3(#p{+_+;x2ENWEKY|Nywdy)TY>|3ayvVR?Gqs~bs=a~|dM`x1%E2sYZA0Y`W
z&!wgGJcrD9RqC-AVP9x<oKFBs)fL_3oPQcuxNpSd3u2jw)vWEkQF@rqz{jz&o7t8K
z7rd5b`{S>t=QdMfM7)f3y(<Auh?}Y$W@|EF&=DIF{Y|Zk4$71aW+Cj&w!(2#<|^OE
z?L{Hramzu&j(}pwJ1u<ZE%Hg3na40>%6yzNh}eDlwoS9*OUljtdvqc1;)$l46_D!H
zOedXlLaB<6o?^N0NKxI!rJ7}Yjqi@L)rpyasy<2Fh3mKHU3j}tbV>JK$Y*=<@3)UX
ze|fE6rr>VQCCq6nlIxe*XazY{_#}4aAY(d}VurU`IG`>qKJr6*ds<;!FQsBjOjeXW
zmocO~Mm0ntwz-s$Gtd}*V3|nlzlnO!{BObV-!S$6&a~fOPnNC##{xYW+kSHd*GWMv
zTK*LZePEW`W-RKR!)9`@t(yKqn<;1E*(cBg3=bLHoM_RNnAS6jM#$sk68u0Ed7Ztk
zwA4)0-f6|N<ji+ZL%47Kz6exQs8`l~D71-Uohm~x;g^}mCO#}d{$_OYJ8fu?ZDkEP
z&zDQ0j8+v26*^O;h2OhzksgQi6IIzR$ksm<m>lYS4k#ACN3=HAOj#NuG#Lu3?vw9B
zD6~gmB69v0LD9QGDct=YmF+Wbx+~;l?U3$DBkbsxT+l%tC?tWB>)wjkH`@0<%(6-u
zXg!)*F%^D#Jh^8wQkmQEJ(J^^05e(cQ3j4%16x0U5eoZKk)_eGFX;lnx;T)Dk59W&
zv9D1`8PIl3%Zz);`%J6Ch{?5h-hx%(>AumX!pw)zhhB$AfLp39dmAxpH<;1lFV;#!
z3VLo4U={tbyM3Z*U@Q*RM~H*tcU%Oc;`-$?yYlt<TPuOysNv6;t25Hh0AB0=tdMic
z{=(D^^0rvO@I8nXDGg5NFAoy)g|5}zjF&>R7Rw#|Z$bUv7pLP*2ElF6)ui}S)d|-e
z+jIk7hA=_joFWcC5x?euqp;VFnp3-zJ-RBc$7jReu-*0^WCJpS-7{<U<+`|;sq<A!
zRSa#A6@M`nOju~>IMim=U*b%Q;_~kg#bSe{y9dS`k7#~G&!xmKHy>$%?r=ZU*7If|
z=C+OVj|Na3L!pXyuKQk~XP_dS0{&cwzZ6Z|JNfjj(9#Fh1Wi^~o)PVywTejhnan#;
z!2D~c6i2B-*T2l)soxP4tln5Fhg2;oF)gKnm>Zv@^;w`e>J+MJTA%hdPfw>TpMNp?
zb{(=wzWun>hSLZI)9^Uny=!IoK{rIzx*n^=UZvo)V%mO~{2TV2@?Y{J|7$7*ba@$p
zw%2Hz$6MbKP;9Q|*k5JUr54VA#V3+Z+q8Fcf<f6UgedS-0K#_gWM<Z<T4|lHKOEO0
za!w689L;sjpdIlt7nb5!Uh=7~vC1BF!tDBW0^t0m>Df|QoyOdp<<lNPN$c|&>V|Wp
z(|lD+^6FY%ra{$Xeq7tx6|l}+v(UkaN;mTBfKq1CNyvLz>C9go7X7{%hi8i+Sq@L?
zEA;2%KsB_Mc+T>}>aByBH}lHL_vym65f)*iI!<H8a7;}O0t(N}T(oQ+ZpnDbn_j4#
z=3`*7FN-f+JtxFE;E8oS>E6c!q#l0;cww_^h^8TxyqjaXgc0XFvaxpeZ~+s+C#P)T
zpuIBSE(Na5*lz1L-srclyt#SLZ|~Q){%kXq7*{Q(=K9ZGX9aKi+E2d~oiM%fc<xO+
zwkIlOznsYz<L3BN1Fnsm<g-%rY$^^rR&Fpr6+wi`<~`Okhcv(Q4r$PwFVF~*U#x*(
zX&NFg#(RAEG)8!Otm#1-ww!zw{kLp5qe~HRW5F`g+D;Xu8jgf$YxNuD24=Gnb*!w)
z7KbR7Th&9Xx*=G+$Q9^^*~x%}&qr{R0be?XO+DEmS4yv|bzVjI2N`%8ot{#o<lcg(
zLSzO=EPfrKzCk#W>sp0*?5Z#d$Lq1Ntm9lU>|ExxlqOsk_v0;;(E4n@+w`cs|IeL+
zk8XkM(*)~J5ryV+(L)NUo}VFGWELP)VsB-$nlaQr{PNYii<Mx#IaF$kB<N5NTGobw
z9%N45d3ur_gT3-Nc*XLOz01^ZRE!?J0K$gUmy^g+Bn4o^U1njL<>fER$T9kvm}BtT
z_>tOskOd#T<6WW~0cM!UMIS&Dh0G-Je47m6aU)gV*c3>pPx3VB<h*x4!P0bc;ih3n
zrz%V?eAOjNoBGAd6H{}bHbIl^OuFuEJG1|-npY97b7|k|4fc<Vl!QTJHA>gB)Bbvs
z*{1`sC*8)p(1-C7HagdK-#y@oqmG$GZD)WhPPrHh-U%Q3p09VI4N$Vkc*T_h#F*lb
z)*3t+i;RdiuMrJE)xG{tE8f5TmS)EEih>X{ZQf7X!WCAyVhCIE5QqZWP*jbhuMcgy
zlBX-2GZe4v*iy=3*JSJ8n)>3qtjkc*5!=9|5g}Y*b;r19zbPtza9!`j%<xP3#z4*$
zmOLh6lplE!joyS>-p*D7?ly51dc1B?yx<fs#WSbbmYq3MDI6&a>C~BF4eKAXou18x
z*&S||ogvo4u~d;(d9!<mCf6zGb#F(J4NeISXY>4Q^x1L)wjK_MZ&3z2NB&+SU#)7u
zPVYo<d#c7d&$WNZ-u+GFoM@F@eM{U+$9XHmm#$ysSL{KBR`wx<W|7qwuMbI1VwFXo
z_}&MI$*EJHqg?q?-JLEzfsk8r0&d5*yW8OA7CFjC$9SqlUuO%tK^O}kGp3t!v|=B*
z$+qRYdQu(}rZdcykhiAFRCT}Ib}iF(z@59M8D=W2PA%82q&n>k+iu?R&xpqP^uER{
z4YdmIZe4ghR|9UC3E;R@>g3DWg#3M$b`z(UQpmH2nt5KfmoJtxT%!=Wav_#;KP=kY
z^5I0F^6$JE=Zm)WFaLXT_W#lwHWdLFpxtM;?ae&496;ni#6-MXpPU+}sF>8GQ@cFh
z_eJQT+km0)@^;{+ZBlg554U%S7Ahk1IXAA5+?vn4YIvqs^r%^q`lUPg62Hww?zw=&
zzOE8~!uXfC!iU`>+LNW`5MDCFoLKg^mZgTiC$JgteqVC|Y53+?tU><`xH)fYWyNJQ
z<Qn-2Xj%!;<{3HXG06>1ksVlj-SP~wx-8=~Qw<4)5ujFb(#wNW?-50Fc@4=1&XnUM
zdDGn11NK)$3i~S7yY7M*KdFYb<^erG&B*NcR~m>qG<7xY11=qG0^>w$E*Y7&L8iy7
z?v@<6)m0fuVXuULZt(f+wJbI7lNL@EZQpCTzG1RpP!W@|yT_P(Ig(V=cv{v$+`wKt
zbr(~bBK206H-2%#(sqhTjA0>p;^=afE|jcA@vrfF9@cGk@QJVD*GNLe<)d6o)L9uW
zKHcNhNA?B$6Ce2)-*$(qQ6kvaQ@ZvgUVYlEFx3~qUfakM{jJ3txLx|J<8bhDP=6!U
zSB?@gwa}jW^R2`*o$JvFmrM1!*szkhPL?ETH~*(~!Hlw^4&JZA>!;2$jrvpI)JO4)
zQ0h{0Cn6B)N!jYb7{|D#Tq`mWkN!xyZ$5(2UyyVh<QARe085?>oeLGH`bpLDwC_$j
z@ECvoY`4I`-hIx4$cyl&`bfwnb|Ih~yT*v|fboE>`NHzc)b|TN1`5q}9&>*j5BxA{
z`p`d_$xA`Z5R-T?F=7f5h(w$u3P8$%im~PCB@SaNWH3QAV6`;vbHIac#hJ*-&tcsb
z#ppoAS#^3~THpf*V*~Vh;sUV3QgT#=6v3gSOj~;c-kO`cnhZMAmf2E;`fP4-qU92~
zxKam=@qO<+N2iAg?t*nj$Z4ESEw`$#=4Ho6?>08?gD!C4r-!`dTIS=X%Y5b`U?MEn
z!p-ONYvRp|lysnJFYZ3!2P^Ae^hB5pOi^4vWouYA(vWpO^&+dStW$Gk1RP_Bc5i%^
zdB76mC?@K)?G}!Vz9_v|bT=}ZXLDsr4QiBchU1D>t`AtAPTl?#O+8Y!pFfi9>Ugc-
zeSO2L8)KH%K@S35kMV7!z$rD(FH7)}eEpxGDT(PJ)p|4geU_UA9*k-@3V2jFVfPiS
zox-^}Q#qwb*E|A3m2v&V9kB7F%QAs=NLecbbshrwvhI(Uoy8`L^>d#eIHZ~XpI(5w
zRcCJ8wkAbu7<7HR^|bE`fu>OOCw<F%{aKUR$ecfEsVsKJzn`sY$;oEAxLD*B<}<k)
zx7N&(DD<dgM*cGvR6qKqT;a-Qd#6w8C6<d3WCvNhtu(UEsx&=>7m!Hh4v>auw&APX
zdiD^M4R&OS*nA~-5rx2*9@iNq?)oJ#d1Ay~$v$jvuE~ZqG%+d;>)`RiRkGhr#H|v$
z=X8v(<pamJ`*-$)CeDcZ3UPwNmuy$Eh?UK=n-yaZEtHf8K))m>@M7I--f3@xXd=NF
z>q27tJG$@{K%>R0btNe84DxWu1Kus-5sox@QLR{tm0-q%o}h}|(aPFtCf{RA(yef-
zgRr$>h}Jrq*Z*g_Guf;v$5jgfPOg5Oj^$t6kBmPOkPBobv~19G9o-3_m0Jgj8_j1f
zKa8$~_9jE~#zx>an^h8W+?DGCht)Swzg=vZ^42VCOnTyDfFgjxGifQWqjUwmz^ZUo
zH}^XF_K8PH9$gx8-R2JUB53UpfcJ~s=L&B#tS^9ISQl1lUNl+4ftFRw5<pYO5i}Ao
zR?EU#i<s()k`5P6#ZGNbqf_n`BPVWVS+2A;-A<BsW{qz@)YvEB2A^~eWWhXPwiN$E
zOc#qXS<-p-$Rz_IhA=gH@H^zn@uFpyJ-as_9%JN+>ylkL)y0jAxPP>s*3DVg0uNc{
zWV`i|QayL}EY0jTx3aRbMmP2j7giq~qjco)7?qBmal#`mPE4M$J1ZkaHS+e1&snq_
zM4!^?_M?eH%e4k0x_#+WFEA3ens>wEB6foau<Zr0b=<nfJYN%1TnMS?f?RXME^WCw
zQ3jWMii@mfHWigscdblMOgKI-gs86~fDIRDTmR`=7*WA+r>noJrM6IdAw5dLKYxTz
zdRS3`uDJkIIv)?DfCE=?zdNOb;d7sBM=SHg+bScLIy#u3gUd?wSmTqO-+3PJxG~;=
z)WO>a!@2k0u5{|LmQ>zGho7#t_`JSGyXANFwi2BVSJwiN1{oR0`O9E+#f%9P?)u^g
z?R%oE2b!Qel&H#}omX!@L*J29T1$V&rWrQNvZUGG3b3EVS`f45H;a>n<o~A#`M;yW
z{{W@WO#tHEaTSO%g>ac%;=*d1*sqVZ!Ik|N>clGiYhHYaZ@0XShN)hUYXmpC8g9A@
zaUET>de8{%E$66XY21#uVgp<25uq!dQAtw*gj$>)o6gv-sWod4mCRhTjQQpJR0^~_
zCK@ZB)P=Hn+dQ>xRa31b#oAbp@Wn*gcHh9l^j5To8((C1T)g&zz84AnnZ0K+a-MeG
zF8Dqa)m-H*gH^{>AzMN(%<i(hJrHInpU0-dtUmAFQmID`dFKc6A`JJ|BL*m6c}~#j
z!D-pROZ-G3t#}bHXgnyx#0MQce?h^}*3<@4JNn?B`!^ts(RKauPo%PwsilWeMvPH1
z?oie930+A%U=Xhp0h=rDe7&2|LwFWWNhxIh@oY$~@(UBALTzbBu^2m;ws0_fo%>U4
zm4Rc;N#hz+I@IXkohEw;U0EW)Hkz~m?N`lSUhJ&&UWyYv>5V~rYA%9$iMTRl>i>$k
zWrm{=xl@b7NsC%=!ySpGL@u;la`5Uul&t@5a4*>f2po;36~CugjzDT@a_wC$FFf=I
zGc~=N{gsqWsNK#f*Bn*EBhLHfi!xS7wj;aTa(21=kT%zayqM@z!UW`xru|fb{Frl@
zt<iooo7E#B5kW!;Lkgs}zrv?{q`3He++4o*)0OXomQiZZi+yh#hE1c!*HhenuF471
z>yDg2Nx}7F_Dh|vgzF>`-hH#U6xT7H=PN(uK&vf|JHw=lN?WjLm*HU!y>0PQcC(`x
zhvnY#c-t2nCoj+^%Ij)C+vjyYiV`I@0uCJ!<ITRG^!ucdf!UtG!LDmGNA>Huf${Jm
z*zW5#r|qsTiCXp?risfUa-HYt%dZK15dA~mQo4ZDhNK>KR&QUj<@1-yg7CIUSawwE
zZJ7FWBqx!=RO`8bYk_7RD9&2|J^h)ihX#jXp7-f<Jcf|`6Kpl33A$matf3QFg!)#Y
zg;F8YlM9xCsCv&2v5mF*`;yetASLCIm6ylrl?^vZnGOrXd9FVB<~U_8$=>bMj**oM
zQuL|i1M?q&QZr3&W+?(bQlUvKv%eO~zCNsBPi1dtUr3^@HT|-e-CD12SDaOi@65E9
z@Q+6cLJ0(N$t>C{#qm9uKHaFJRcsoif1#1)6rgAnn00NS!9QJP6I+>UzpfIy2(9GJ
z^mMC@5bfZ`FW!N|?T<^?K=|`VQYptS9!i`_K5{zx?|$(Q46(=*kSH<pP4_uZbGvY$
zUunrK(C0d1)pm!L8T?s0Hy1cO9Xt_`HEDCQ(OTq{QQKG_s`nF$tjDz-<h0GxL!US*
z48T4QKuuS)_V@<YP*OR@8L<sC9i`N4Cab+HVThvsP=Cw%O9@4V^7<p#ht7pWiU*AF
z{Ksx`lmWi{sDDPHa(w}uzHlFS*LmPw?<Rk^6lncnDNoKHwKlRX0S<lTVXW%ByXsrZ
z?6NTIu}zkc#}kQ#$(z*9^#pu*&%UskpUh43(%;MSmJ`Yy9Um^x>8u}ALc|5l&fZq!
zhQeA(b1`D)y}zfx-hzF(X)Eg9z{^aNt;0B);6dJ7L#frwc)8k*FH070%aj$~9>Oya
zP|)Vhs?LfDsa47~MY>`@M&=SRm2JroPi4>DfkgIbc_UJ<YC0Pd?8`Y)(uv6SCM>VE
zd7ik^?Gi6-PwDSN6{d9fId^c^K8mc8H+w71qSYM{s4-pL)S37M<MI#I@xRvZ>l{ED
zy8q3v8K#suA5usAGQ#_(mexBdqfjFe>73XA?MCF6v86!f#W>$}?V7@rPVW;EUdE*s
ziYp>VF~6RgG)gqA=tFAZC7wIOUBUK^G(*y9pnmbz=h9)9cj>qViGWh3*X<X<IbYb#
z^+B9cmFvUzPV>UTc9qpH<sM;oX%~Bs(Zf}k#dHI0rGq6eEZHKEUO{hnudB6IKj<c;
zq1CDUgErj@foXGz1Nab_MB#9mij}Q$8Ci-(iLHCm+3xOLpg4$xLTJrF6^><a>PNMB
zF`h}U=-S1m+^yn^Wy;v|s+b3d3Y`*Pi%Rtf6Xo<yq2jrD@o$4D{2JmsxFg}ZYiy<W
z>?;ieH%NHJI(zWwIFs+@@k!tcEmK<s0)~Wfn#&a(S4_<4JDW9{>wX!iNZ{8S!ZvrQ
zLjmEdK6!@bsG3nbYm~Hh-K_DPK|OVUf8gD?Y=O|s<;Y2@#RUJ%T6mZtNXnA&4${w9
z7l+k%Ofj!+Ye3MiaxMV^`}&E+$J7L&M}AQy`q?74q#uNoPsXyPkTMeP%COiDABbxG
zTwJ1gy{>R|b;WnOek-ey4KO;d^X4-3LD@$q{@!TTP8iYIm4EQCt=JExV`a|ExQ>|#
z^`?a_7<4OF$iqo<RxKTJ7Vzy%MB}O6Umv3xtV+l7-hS8(Dacr9bhBE&xo<c{qIZtH
z*#!KJkNx)JR}DccvOiPMYgN=fw|AB07bMh$(+-s{`?RWnvT%|xlT3-v+Zd__vsk9j
z1>FEVi3@RE8?pkgj$XY>T3WAEG^FvVG8A4csUDB4Fo)cO)L`#X0&8c7DEn4UE783Y
zb2&ES8UTMi#i&XV3_qbfGaE&-In^{INZ(=-ta1v7ad8aNl2{&PfVd(4g1*}IEDd!z
zw&ddrdt<_7GXF6DY~HA0s)U2F<5rcb31^MpqnQ1>6s*$mJvEfwBWr9fb&FbzYKiL3
zT^xaP@Kov3MhFdIgIwrc@Yjl2zc(Y7z~hR>;~DO=4%z5i6-n5U8E`5z@L>sZeAxSI
zyK}NbP?9Lovi#eb^=tHw`XosGX7dYur(QwG7w+^geFr=KWL?{NAWU=8DNFXsO9vaB
zn!o7Mk58|0!+A<AkUgDZgqf*a1WA3Y^`*Qy=iXK_ZQw@bsF=8K;qKbe_I*fP1?fP(
zrXX2mr^?r8UC9YZJM$F~KKfP68Q75)*D6wxOvFo)q77f`VoDq;hC}lU@8HWY(%5#P
zW7UQeGxVCqDR$kpFbNhWaEAo`cK&`}3o_FYs+;CyPas&iDiHYd%oX?zH9PWq@knp1
zCdsrK8s)ZBBjRGeKdKRszGz9<RA6=38i~jmhMi4yt>4Zj%nw_81-__ea-j*jofr}J
zH8xx+*r;_fI8JPy8~83n-@sIK0Is)bC~8}1z;Tmh(DdCpy1KzSEH6x4ZuG08=rR6d
zi}S1C@e8e0vx06LdBDyD%WMYX=;t$asF@TTH8d1j6I8a|SXc=<hnKbUkrSm?lR?ZL
z`>>l7wX_zddu4}A_1KGI?oX+9g?7%BZrJd6X>u-X`Y@MmwAZY1vmob_g<-A~Vvws=
zVlh$JHP>|fFr^{XW-N5JY;{RkQI(z;A7BgfZvfVrBD|Uqaok~eIHWD$Wwgxw!`Lvh
zt%54?mtpXdZ;jpjwN0P{`+-1q&}fqOx2_ov+4YE{cU<;=&BRu>mjRog(Mt{rjR5!-
zFe*-dpl^~Hm>_2bh71MOeGCE^!)xBoAe?dIa`5G1m5Q||1~KD3uerMT58tzB3W)|o
z(VCmpJmD)-x}d_dOr^GV$?&G|dakjmmj(pZtMM1>o37KBNnm6~2m#f5zqsYxT_*IH
zi1|t8vu8q+l+!ycv!0lr4^(x1$zHc^=vr_Fva<Yj@Vk;PZx?I9zzx*HoS;Llu!SEi
zbPM+f^+5N1^tc%%yq$3MU!FX3{t-M|5A3#bc+T(Vz1-eHB+JVyErvb`m9H5y#mPw|
zo5ySV#->?YrPn5fLhr8F^HR@4Df!kO>#fQ}<ja+3^e)9FEW*4E5h`~;?AuNT-QxZa
zK~+b!KZa9E%VdgJs+BhyPDm|0Mvdj7g7QYMJ6U_}Os&j&f%m!uQb22nVh9s7rKH1X
zLGpOs{^Q8qnz)AQL5Z*19@3{9mHt-6`CEPC-z{xQ5THX=>v!ENj|*><J+L<0#9ozv
zzkPg<Id3tUWhS+QVR+9DDFcmGD4U_l$42+6N9%D^?E|eQzryv@wRPg-UrUdtB-wK}
z_{a;9HjQQ^OWXYFoj^1)`w(t~66IF!%fdi+ko&_B2y!)rWCR<{@?Yi|uONRR3eVIb
z5A!0xu_D%k1(!!Hu0Ru&-74gjN0a5}^fP}GGe0CrXwd@W*SC6iixkut<wwOoaD}f{
zo|0}0964+YQK0q37)@DDY91W%+qMfQ2hJIZ!+Q2-;RIqwJiRvJ$S&X?-(vds*H`v(
z^W^rKyr~iNE6T;2xkf{e(_6jQf{L#z=B(+>#gxr>Qr?e<NIcdYt|r1JYb0OLMDAc>
z8labNP4Tj~ap##U@(Yrg6!BSgL^DEA3#=kj6{a4uf6rQZc~-4niEg6)9*EuAhh7Oe
zmV^ECAuCIAn=q44yUAHKW@UFf!z5C7RTEk`qHODLBj>3U59}pBmyPA5DW5QDhj2>6
zcfMb_J5H|Pv3$??DAWocH=VG@z!bg0D|FWd6bhVPF@Zm~<A1<g$v+yHRc2%4svCQ(
zOx}4VujOma3L)#Nn-wbA!MV-Vpm5?ko$kQM{1+o~u_;1D95maJazU73E62M_w5S+o
zoK`YWxXhm{7vN+b5YyF5uW_@z#sHA%+pRMT&u()*EMYruz7G-&c}O@w9z2|TO|SNk
zH<|y*z03)%R|A{61C@`<e`nykR8^V6YUHA;)fM4H#ckH{oTNLTV+N9>T6I@!E8f*m
zl=DswX(AgQfU5jbPkh{2mtRy~3V0s<kA3!k@8nY%16IK1fQTDJWr!u*h?(lVV>*||
z&TVeVEI$9WeMZ8c`ucQvspPSl|LOOqN9HT)fViPo#ok#a--O$xy&QM6!7M^uHqTvi
zFH-}WkX#GL_2kadZ8N_BfQ^3-Yx9$GHvm=1+<USxyqg5(tYTprkEil4dftx?r8DFX
zRw)5^pP+Nijp0%K+>PL)2P&l-;^v(o@rik$X@C;i>Q$tS-wWpXcbxk#CKJL8{$Qs$
z@xwO1T>@p7XCSbQnX%PH$?R3e;2WSj{#|iN`_;fk@ftGkL@+&b_b=UCQ2{29>FOIv
zd6rPZ1noc`1;{*-a)#66i?>D>9>1l&%uBbm{02gDE%KNxVva;2Q61~vnfRg6{Y2AE
zNq5H9AmLY-9P~pQ`dW?t1f^Gufw6haNg61oj^04tJ5pnoUUbdih<n|W{Iz7Xv)v=C
z0OHn9I#berq~!*B$47@=J$xq0##}EITTRP`)LsrV-q*NcfWm!3iFqBi;*^=-bcW|Z
zwM7v~6ZYMV&*lFGv@scpu%nACzDaCOyEZYb?^N+_Edn{Q0*9tmxvO+rpvD=%0>6Cw
zp87Gk0cs2|;>*dv{Y$xVDnLh4uA!eMb<WticKI0HDk=S=lBJF;FAJdIIj`aAI4LiX
zE6eLk)P*?E#WD#XUOc>&b&Q9D?g#$<g9u#~z5OMB28h@tRHN@BATBmbslgW#GAT4I
zufx6rQWTWVZ0>P^52t|S)bQ6i!zg_m#mZ29*}p8h3+$VF(JJHUxu2d12%_R}&gmBx
zbR+YpD*#W>K&e^F9{2L{+Eaa6%&)g!5F`{1sRokU+Of>;`dCB|e40SFlRSSYkeZx+
zqwm&<u>kzkO3%kgLiWl~Hn8Joi}SAxuocCw{N1o;<)Ipc-TyljK7phE$$w1TXHIGL
zvUSybG~`bWIVrw9KtF8Kg53NbI6Vl#lM@Q9A2xH_;;QylkfOJ+q$04+B(9LSV<0fh
zkg2~A`IJrk$<8pbJLB6<&EdH+E%>1uF@$a?LxXZS<48L?d-G*`c?!RKK0+M@E^}NR
zwS<fTn>oZ#P7sQ?uMqNBTYG0sc`Rn-7TxB4-0NK08gKUfDUe;~*R9Z_*B?AB$*i#G
zGA)1a+RtQXAmjI-@U~ieXTjKp7>u1>BV}YpUs0LCN-V5cJY(i0z*<p%CRV3=T`67W
zr>b4$<41=}y}fVWSeSVSZM=8n8Z(TU_Bctmf%ORk1{Q@%=)Eps<uw=dAX?t#TZ1kC
zxw{`3h+;yj&8iTJyjQJhJyz_7U&1vPx}S^q3kW0roOvY4gb1eArDvRm%g@31jZ(qP
zD;A|E3n7e#D_zw6iREwoQeU~_cfRw}ZD&^?0`UXU{qD>%Lf1S;Kr9@$6)cmbb51ib
zfJQa$-!%+Dd2`C6R!ogBnk!xF9=vzilJ=X<wcFd_LSNGD$-0jj3lkJ<tdBQoJOQ?}
zw8ARJGUb0^3|7Pu2XUF5fHC{nPg`Ywf_}CGI&TQ#QK`jr_F)_s(AE0WdYUOobIYj%
znk<Mx^FQ^dBK})M3(3@6h7=HGZD)QhP@CEcG}OcH35A8xJ?alP0Q?b2)QwnoVg#+k
zz2}izG?JPl6<!;8fef}cH$zT9;)W#H!RRq^nA4#mu$xHM!|Lz6=AYe2#T#Hf5d7!r
zX5A;f-xX5*y6YqNR70@IxGmK0<nVz$&N}4#U!p`uU%Yef@HxmT`QW_v2}^n-Z54r4
zU=2E}9DWiw8yYHMRZ0$q)+`w}KYN*}3Oy#8CUZpsvLcEjukD2DRizbnyE>aIJ9aI9
zliFyC!2kb{f&!`{)`mj`KDdMc#qU5Qlkc1}dn)>)$#JP%$cngceEZDzgQWurr#Xjj
z!^%SNh<Qc2L12|DZOw9T?lqs0=@XzK;tq{`gtgKNM~M?I-LfN)T`r-oNT``FAVqgf
zYvax4yQo^90klBpwOK5mrXLbyE&-76IBiAOhxzKGgc1}JaDEMUKG>tte>_Ij7u{TZ
zF=ew;lwfMmTw_1bDdq+L)v;i}-`$mWU7v0bz9<EF@T#W@>ob8gHew36H2HhM9>$GY
z^dS+n>f-EmyzuPN<+GJ=eL|&nIu-^dD6$_>s{CIG_<wR~m05sO+Pbw}Sczk9(Mh`V
zsJ({|IRb6XWhN?kj~o2#M0BXRBaPV#OY-t~fyDTXz{HW=U9-)ZhrpXEGheRo(5;i>
z14h8g<QgyxR|U1`e7(`s4$JrwK+9ut=hr>&CIwpkF6b!n+L)B-h$VM7_;6N=9Xp6y
zs2FYbt*$wk{=<fZzI<_`-wFQ|5pxr?j~cKrLK;UQA?0CZ6jlW9cXUh*5v>pE4)u(+
zYaO?^R!E!PIw+6;nh9ynRTge<tY|`{MNUPuNeEWR>AK|Bn}7DkzyBM+CE$;TDiFWj
z4VgXh`KZ`6Og3Vo`W~a4vpa5|;EjDZvh~-6H1uTUB47EE>R{G>o)O%L5j*3zmkQhv
z5f{IYb&Gd09ge^Gv;70TnIbmz_duA}^oWBu3Rwpf1<;Ujv~dr)4Dp)kM;JFI36xcD
z4n<c&Qo77DM+Kdz2*tG4_{Bldk$j_`=*;J!db-)J$|vRnWv~2u!~4cH=NW*HhMM;M
J0@Wv>{~zw;>P`Rv

literal 0
HcmV?d00001


From 2161a00b81d05fb1f2f8c5f92bb18ba8409db120 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Fri, 3 Sep 2021 13:24:21 +0200
Subject: [PATCH 31/47] Update README

---
 README.md | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index d6a8f59..f343685 100644
--- a/README.md
+++ b/README.md
@@ -39,13 +39,14 @@
       </ul>
     </li>
     <li>
-      <a href="#data">Data</a>
+      <a href="#datasets">Datasets</a>
       <ul>
         <li><a href="#uk-dale">UK-DALE</a></li>
       </ul>
       <ul>
-        <li><a href="#preprocess">Preprocess</a></li>
+        <li><a href="#pecan-street-dataport">Pecan Street Dataport</a></li>
       </ul>
+   <li><a href="#preprocess-the-data">Preprocess the Data</a></li>
     </li>
     <li>
       <a href="#train">Train</a>
@@ -105,12 +106,10 @@ To create the environment using Conda:
        conda activate nilm-thresholding
        ```
  
-## Data
+## Datasets
 
 ### UK-DALE
 
-#### Download UK-DALE
-
 UK-DALE dataset is hosted on the following link:
 [https://data.ukedc.rl.ac.uk/browse/edc/efficiency/residential
 /EnergyConsumption/Domestic/UK-DALE-2017/UK-DALE-FULL-disaggregated](https://data.ukedc.rl.ac.uk/browse/edc/efficiency/residential/EnergyConsumption/Domestic/UK-DALE-2017/UK-DALE-FULL-disaggregated)
@@ -131,7 +130,15 @@ nilm-thresholding
 
 Credit: [Jack Kelly](https://jack-kelly.com/data/)
 
-### Preprocess
+### Pecan Street Dataport
+
+We are aiming to include this dataset in a future release. You can check the issue here: [https://github.com/UCA-Datalab/nilm-thresholding/issues/8](https://github.com/UCA-Datalab/nilm-thresholding/issues/8)
+
+Any help and suggestions are welcome!
+
+Credit: [Pecan Street](https://dataport.pecanstreet.org/)
+
+## Preprocess the Data
 
 Once downloaded the raw data from any of the sources above,
 you must preprocess it.

From 5262887c92f21f8abcf3b82deec7b7fbd5d71e9b Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Wed, 22 Sep 2021 12:59:22 +0200
Subject: [PATCH 32/47] Change url of image

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f343685..b07ee9a 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@
 <!-- PROJECT LOGO -->
 <br />
 <p align="center">
-  <a href="https://github.com/UCA-Datalab/nilm-thresholding">
+  <a href="https://github.com/UCA-Datalab">
     <img src="images/logo.png" alt="Logo" width="400" height="80">
   </a>
 

From e8a01f5ea7a994a3bb42ec7606eb510794fac69c Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 23 Sep 2021 18:44:50 +0200
Subject: [PATCH 33/47] Typo in README

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index fcf4fc8..b07ee9a 100644
--- a/README.md
+++ b/README.md
@@ -181,7 +181,7 @@ python nilmth/train.py  --path_config <path to your config file>
 
 For more information about the script, run:
 
- ```
+```
 python nilmth/train.py  --help
 ```
 

From 6b0149f4022f25e2ddf0804d0625b93d8b8d22d3 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 23 Sep 2021 18:45:47 +0200
Subject: [PATCH 34/47] Change plot_power_distribution argument

---
 nilmth/utils/plot.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nilmth/utils/plot.py b/nilmth/utils/plot.py
index 584b0bf..9a120a4 100644
--- a/nilmth/utils/plot.py
+++ b/nilmth/utils/plot.py
@@ -69,7 +69,7 @@ def plot_real_vs_prediction(
 
 
 def plot_power_distribution(
-    ser: np.array, app: str, bins: int = 20, figsize: tuple = (3, 3)
+    ser: np.array, app: str = "", bins: int = 20, figsize: tuple = (3, 3)
 ):
     """Plot the histogram of power distribution
 
@@ -77,8 +77,8 @@ def plot_power_distribution(
     ----------
     ser : numpy.array
         Contains all the power values
-    app : label
-        Name of the appliance
+    app : str, optional
+        Name of the appliance, by default ""
     bins : int, optional
         Histogram splits, by default 20
     figsize : tuple, optional

From 16c357bd98f6b27fd61e4fdb3f17d998ff95ace9 Mon Sep 17 00:00:00 2001
From: daniprec <daniel.precioso@uca.es>
Date: Tue, 3 Aug 2021 18:01:49 +0200
Subject: [PATCH 35/47] Docstring

---
 nilmth/data/clustering.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/nilmth/data/clustering.py b/nilmth/data/clustering.py
index 026fc84..48dd071 100644
--- a/nilmth/data/clustering.py
+++ b/nilmth/data/clustering.py
@@ -145,3 +145,17 @@ def compute_thresholds_and_centroids(
             [np.min(self.x[clusters == (c + 1)]) for c in range(self.n_cluster)]
         )
         self.thresh = np.divide(np.array(x_min[1:]) + np.array(x_max[:-1]), 2)
+
+    def plot_cluster_distribution(self, label: str = "", bins: int = 100):
+        """Plots the power distribution, and the lines splitting each cluster
+
+        Parameters
+        ----------
+        label : str, optional
+            Label of the distribution, by default ""
+        bins : int, optional
+            Number of bins, by default 100
+        """
+        fig, ax = plot_power_distribution(self.x, label, bins=bins)
+        [ax.axvline(t, color="r", linestyle="--") for t in self.thresh]
+        return fig, ax

From 829b334d888927ef5d391bbbc99310f568a3265f Mon Sep 17 00:00:00 2001
From: daniprec <daniel.precioso@uca.es>
Date: Wed, 4 Aug 2021 12:48:30 +0200
Subject: [PATCH 36/47] Move plot_cluster_distribution to plot

---
 nilmth/data/clustering.py | 14 --------------
 nilmth/utils/plot.py      | 28 ++++++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/nilmth/data/clustering.py b/nilmth/data/clustering.py
index 48dd071..026fc84 100644
--- a/nilmth/data/clustering.py
+++ b/nilmth/data/clustering.py
@@ -145,17 +145,3 @@ def compute_thresholds_and_centroids(
             [np.min(self.x[clusters == (c + 1)]) for c in range(self.n_cluster)]
         )
         self.thresh = np.divide(np.array(x_min[1:]) + np.array(x_max[:-1]), 2)
-
-    def plot_cluster_distribution(self, label: str = "", bins: int = 100):
-        """Plots the power distribution, and the lines splitting each cluster
-
-        Parameters
-        ----------
-        label : str, optional
-            Label of the distribution, by default ""
-        bins : int, optional
-            Number of bins, by default 100
-        """
-        fig, ax = plot_power_distribution(self.x, label, bins=bins)
-        [ax.axvline(t, color="r", linestyle="--") for t in self.thresh]
-        return fig, ax
diff --git a/nilmth/utils/plot.py b/nilmth/utils/plot.py
index 9a120a4..999a690 100644
--- a/nilmth/utils/plot.py
+++ b/nilmth/utils/plot.py
@@ -1,3 +1,4 @@
+from typing import Iterable
 import numpy as np
 from matplotlib import pyplot as plt
 
@@ -97,3 +98,30 @@ def plot_power_distribution(
     ax.set_ylabel("Frequency")
     ax.grid()
     return fig, ax
+
+
+def plot_cluster_distribution(
+    ser: np.array,
+    thresh: Iterable[float],
+    app: str = "",
+    bins: int = 20,
+    figsize: tuple = (3, 3),
+):
+    """Plots the power distribution, and the lines splitting each cluster
+
+    Parameters
+    ----------
+    ser : numpy.array
+        Contains all the power values
+    thresh : Iterable[float]
+        Contains all the threshold values
+    app : str, optional
+        Name of the appliance, by default ""
+    bins : int, optional
+        Histogram splits, by default 20
+    figsize : tuple, optional
+        Figure size, by default (3, 3)
+    """
+    fig, ax = plot_power_distribution(ser, app=app, bins=bins, figsize=figsize)
+    [ax.axvline(t, color="r", linestyle="--") for t in thresh]
+    return fig, ax

From 8b7a4308f89a5d065ae368fb16bd8f7834a65984 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Thu, 23 Sep 2021 19:53:56 +0200
Subject: [PATCH 37/47] Threshold class can change between status and powe

---
 nilmth/data/dataset.py            |  4 ++--
 nilmth/data/threshold.py          | 23 +++++++++++++++++++----
 nilmth/hierarchical_clustering.py | 13 +++++++------
 3 files changed, 28 insertions(+), 12 deletions(-)

diff --git a/nilmth/data/dataset.py b/nilmth/data/dataset.py
index 56ba9bb..e5aceb1 100644
--- a/nilmth/data/dataset.py
+++ b/nilmth/data/dataset.py
@@ -137,7 +137,7 @@ def power_to_status(self, ser: np.array) -> np.array:
             shape [output len, num appliances]
 
         """
-        return self.threshold.get_status(ser)
+        return self.threshold.power_to_status(ser)
 
     def status_to_power(self, ser: np.array) -> np.array:
         """Computes the power assigned to each status
@@ -154,7 +154,7 @@ def status_to_power(self, ser: np.array) -> np.array:
 
         """
         # Get power values from status
-        return np.take_along_axis(self.threshold.centroids, ser.T, axis=1).T
+        return self.threshold.status_to_power(ser)
 
     def __getitem__(self, index: int) -> tuple:
         """Returns an element of the data loader
diff --git a/nilmth/data/threshold.py b/nilmth/data/threshold.py
index 0514b0a..a6f698f 100644
--- a/nilmth/data/threshold.py
+++ b/nilmth/data/threshold.py
@@ -262,7 +262,7 @@ def _compute_status_by_activation_time(self, ser: np.array):
         ser_bin = np.stack(ser_bin).T
         return ser_bin
 
-    def get_status(self, ser: np.array) -> np.array:
+    def power_to_status(self, ser: np.array) -> np.array:
         """
 
         Parameters
@@ -284,6 +284,23 @@ def get_status(self, ser: np.array) -> np.array:
 
         return ser_bin
 
+    def status_to_power(self, ser: np.array) -> np.array:
+        """Computes the power assigned to each status
+
+        Parameters
+        ----------
+        ser : numpy.array
+            shape [output len, num appliances]
+
+        Returns
+        -------
+        numpy.array
+            shape [output len, num appliances]
+
+        """
+        # Get power values from status
+        return np.take_along_axis(self.centroids, ser.T, axis=1).T
+
     @property
     def config_key(self):
         """Key that contains the relevant values of the config file"""
@@ -316,9 +333,7 @@ def write_config(self, path_config: str):
         store_config(path_config, config)
         logging.debug(f"Config stored at {path_config}\n")
 
-    def set_thresholds_and_centroids(
-        self, thresholds: np.array, centroids: np.array
-    ):
+    def set_thresholds_and_centroids(self, thresholds: np.array, centroids: np.array):
         """Change threshold and centroid values to given ones
 
         Parameters
diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index 0a1d294..fb4e4e4 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -9,6 +9,7 @@
 
 from nilmth.data.clustering import HierarchicalClustering
 from nilmth.data.dataloader import DataLoader
+from nilmth.data.threshold import Threshold
 from nilmth.utils.config import load_config
 from nilmth.utils.scores import regression_scores_dict
 
@@ -132,7 +133,7 @@ def plot_error_reduction(intr_error: Iterable[float], ax: Optional[Axes] = None)
     ax.grid()
 
 
-def plot_clustering_results(ser: np.array, dl: DataLoader, method: str = "average"):
+def plot_clustering_results(ser: np.array, th: Threshold, method: str = "average"):
     """Plots the results of applying a certain clustering method
     on the given series
 
@@ -140,7 +141,7 @@ def plot_clustering_results(ser: np.array, dl: DataLoader, method: str = "averag
     ----------
     ser : np.array
         Contains all the power values
-    dl : DataLoader
+    th : Threshold
         Required to apply the thresholds on the series
     method : str, optional
         Clustering method, by default "average"
@@ -158,11 +159,11 @@ def plot_clustering_results(ser: np.array, dl: DataLoader, method: str = "averag
         # Update thresholds and centroids
         thresh = np.insert(np.expand_dims(hie.thresh, axis=0), 0, 0, axis=1)
         centroids = np.expand_dims(hie.centroids, axis=0)
-        dl.threshold.set_thresholds_and_centroids(thresh, centroids)
+        th.set_thresholds_and_centroids(thresh, centroids)
         # Create the dictionary of power series
         power = np.expand_dims(ser, axis=1)
-        sta = dl.dataset.power_to_status(power)
-        recon = dl.dataset.status_to_power(sta)
+        sta = th.power_to_status(power)
+        recon = th.status_to_power(sta)
         dict_app = {"app": {"power": power, "power_pred": recon}}
         # Compute the scores
         dict_scores = regression_scores_dict(dict_app)
@@ -231,7 +232,7 @@ def main(
         appliance = app.capitalize().replace("_", " ")
         # Loop through methods
         for method in LIST_LINKAGE:
-            plot_clustering_results(ser, dl, method=method)
+            plot_clustering_results(ser, dl.threshold, method=method)
             # Place title in figure
             plt.gcf().suptitle(f"{appliance}, Linkage: {method}")
             # Save and close the figure

From 14fe2fff820c44db46ee4def4d1d9391776ecf66 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Fri, 24 Sep 2021 10:40:14 +0200
Subject: [PATCH 38/47] No need to give Threshold

---
 nilmth/data/threshold.py          | 2 +-
 nilmth/hierarchical_clustering.py | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/nilmth/data/threshold.py b/nilmth/data/threshold.py
index a6f698f..4639697 100644
--- a/nilmth/data/threshold.py
+++ b/nilmth/data/threshold.py
@@ -34,7 +34,7 @@ def __init__(
         num_status: int = 2,
     ):
         # Set thresholding method parameters
-        self.appliances = [] if appliances is None else sorted(to_list(appliances))
+        self.appliances = ["App"] if appliances is None else sorted(to_list(appliances))
         self.num_apps = len(self.appliances)
         self.method = method
         self.num_status = num_status
diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index fb4e4e4..bd9048b 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -133,7 +133,7 @@ def plot_error_reduction(intr_error: Iterable[float], ax: Optional[Axes] = None)
     ax.grid()
 
 
-def plot_clustering_results(ser: np.array, th: Threshold, method: str = "average"):
+def plot_clustering_results(ser: np.array, method: str = "average"):
     """Plots the results of applying a certain clustering method
     on the given series
 
@@ -141,8 +141,6 @@ def plot_clustering_results(ser: np.array, th: Threshold, method: str = "average
     ----------
     ser : np.array
         Contains all the power values
-    th : Threshold
-        Required to apply the thresholds on the series
     method : str, optional
         Clustering method, by default "average"
     """
@@ -151,6 +149,8 @@ def plot_clustering_results(ser: np.array, th: Threshold, method: str = "average
     hie.perform_clustering(ser, method=method)
     # Initialize the list of intrinsic error per number of clusters
     intr_error = [0] * len(LIST_CLUSTER)
+    # Initialize threshold class
+    th = Threshold()
     # Initialize the empty list of thresholds (sorted)
     thresh_sorted = []
     # Compute thresholds per number of clusters
@@ -232,7 +232,7 @@ def main(
         appliance = app.capitalize().replace("_", " ")
         # Loop through methods
         for method in LIST_LINKAGE:
-            plot_clustering_results(ser, dl.threshold, method=method)
+            plot_clustering_results(ser, method=method)
             # Place title in figure
             plt.gcf().suptitle(f"{appliance}, Linkage: {method}")
             # Save and close the figure

From c76099681e9daf3ab02db6b40d89ac320ad3341e Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Fri, 24 Sep 2021 11:18:41 +0200
Subject: [PATCH 39/47] Allow to choose centroid computation method

---
 nilmth/hierarchical_clustering.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index bd9048b..734bd2d 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -133,7 +133,9 @@ def plot_error_reduction(intr_error: Iterable[float], ax: Optional[Axes] = None)
     ax.grid()
 
 
-def plot_clustering_results(ser: np.array, method: str = "average"):
+def plot_clustering_results(
+    ser: np.array, method: str = "average", centroid: str = "mean"
+):
     """Plots the results of applying a certain clustering method
     on the given series
 
@@ -143,19 +145,21 @@ def plot_clustering_results(ser: np.array, method: str = "average"):
         Contains all the power values
     method : str, optional
         Clustering method, by default "average"
+    centroid : str, optional
+            Method to compute the centroids (median or mean), by default "mean"
     """
     # Clustering
     hie = HierarchicalClustering()
     hie.perform_clustering(ser, method=method)
     # Initialize the list of intrinsic error per number of clusters
     intr_error = [0] * len(LIST_CLUSTER)
-    # Initialize threshold class
-    th = Threshold()
     # Initialize the empty list of thresholds (sorted)
     thresh_sorted = []
     # Compute thresholds per number of clusters
     for idx, n_cluster in enumerate(LIST_CLUSTER):
-        hie.compute_thresholds_and_centroids(n_cluster=n_cluster)
+        hie.compute_thresholds_and_centroids(n_cluster=n_cluster, centroid=centroid)
+        # Initialize threshold class
+        th = Threshold(method="custom")
         # Update thresholds and centroids
         thresh = np.insert(np.expand_dims(hie.thresh, axis=0), 0, 0, axis=1)
         centroids = np.expand_dims(hie.centroids, axis=0)
@@ -216,7 +220,6 @@ def main(
     # Loop through the list of appliances
     for app in LIST_APPLIANCES:
         config["appliances"] = [app]
-
         # Prepare data loader with train data
         dl = DataLoader(
             path_data=path_data,
@@ -225,7 +228,6 @@ def main(
             path_threshold=path_threshold,
             **config,
         )
-
         # Take an appliance series
         ser = dl.get_appliance_series(app)[:limit]
         # Appliance name

From 45248d746693c7c21ec93726fef5dc9abdbead81 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Fri, 24 Sep 2021 11:40:21 +0200
Subject: [PATCH 40/47] Rename linkage method to distance

---
 nilmth/data/clustering.py         | 14 +++++++-------
 nilmth/hierarchical_clustering.py | 22 +++++++++++-----------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/nilmth/data/clustering.py b/nilmth/data/clustering.py
index 026fc84..72a8070 100644
--- a/nilmth/data/clustering.py
+++ b/nilmth/data/clustering.py
@@ -16,14 +16,14 @@ class HierarchicalClustering:
     dendrogram: dict = None
 
     def __init__(
-        self, method: str = "average", n_cluster: int = 2, criterion: str = "maxclust"
+        self, distance: str = "average", n_cluster: int = 2, criterion: str = "maxclust"
     ):
-        self.method = method
+        self.distance = distance
         self.n_cluster = n_cluster
         self.criterion = criterion
 
     def perform_clustering(
-        self, ser: np.array, method: Optional[str] = None
+        self, ser: np.array, distance: Optional[str] = None
     ) -> np.array:
         """Performs the actual clustering, using the linkage function
 
@@ -31,19 +31,19 @@ def perform_clustering(
         ----------
         ser : np.array
             Series of points to group in clusters
-        method : str, optional
-            Clustering method, by default None (takes the one from the class)
+        distance : str, optional
+            Clustering distance criteria, by default None (takes the one from the class)
 
         Returns
         -------
         np.array
             Z[i] will tell us which clusters were merged in the i-th iteration
         """
-        self.method = method if method is not None else self.method
+        self.distance = distance if distance is not None else self.distance
         # The shape of our X matrix must be (n, m)
         # n = samples, m = features
         self.x = np.expand_dims(ser, axis=1)
-        self.z = linkage(self.x, method=self.method)
+        self.z = linkage(self.x, method=self.distance)
 
     @property
     def cophenet(self):
diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index 734bd2d..b864a94 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -15,7 +15,7 @@
 
 LIST_APPLIANCES = ["dish_washer", "fridge", "washing_machine"]
 LIST_CLUSTER = [2, 3, 4, 5, 6]
-LIST_LINKAGE = [
+LIST_DISTANCE = [
     "average",
     "weighted",
     "centroid",
@@ -134,7 +134,7 @@ def plot_error_reduction(intr_error: Iterable[float], ax: Optional[Axes] = None)
 
 
 def plot_clustering_results(
-    ser: np.array, method: str = "average", centroid: str = "mean"
+    ser: np.array, distance: str = "average", centroid: str = "median"
 ):
     """Plots the results of applying a certain clustering method
     on the given series
@@ -143,14 +143,14 @@ def plot_clustering_results(
     ----------
     ser : np.array
         Contains all the power values
-    method : str, optional
-        Clustering method, by default "average"
+    distance : str, optional
+        Clustering linkage criteria, by default "average"
     centroid : str, optional
             Method to compute the centroids (median or mean), by default "mean"
     """
     # Clustering
     hie = HierarchicalClustering()
-    hie.perform_clustering(ser, method=method)
+    hie.perform_clustering(ser, distance=distance)
     # Initialize the list of intrinsic error per number of clusters
     intr_error = [0] * len(LIST_CLUSTER)
     # Initialize the empty list of thresholds (sorted)
@@ -194,7 +194,7 @@ def main(
     path_output: str = "outputs/hieclust",
 ):
     """Performs the hierarchical clustering on the given list of appliances,
-    testing different linkaged methods and number of splits. For each combination,
+    testing different linkage methods and number of splits. For each combination,
     outputs an image with several informative graphs.
 
     Parameters
@@ -232,13 +232,13 @@ def main(
         ser = dl.get_appliance_series(app)[:limit]
         # Appliance name
         appliance = app.capitalize().replace("_", " ")
-        # Loop through methods
-        for method in LIST_LINKAGE:
-            plot_clustering_results(ser, method=method)
+        # Loop through distances
+        for distance in LIST_DISTANCE:
+            plot_clustering_results(ser, distance=distance)
             # Place title in figure
-            plt.gcf().suptitle(f"{appliance}, Linkage: {method}")
+            plt.gcf().suptitle(f"{appliance}, Linkage: {distance}")
             # Save and close the figure
-            path_fig = os.path.join(path_output, f"{app}_{method}.png")
+            path_fig = os.path.join(path_output, f"{app}_{distance}.png")
             plt.savefig(path_fig)
             plt.close()
 

From 75b16eda98fef20389a53b49643e3593fc153fba Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Fri, 24 Sep 2021 11:41:12 +0200
Subject: [PATCH 41/47] Remove unused import

---
 nilmth/data/clustering.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/nilmth/data/clustering.py b/nilmth/data/clustering.py
index 72a8070..d732305 100644
--- a/nilmth/data/clustering.py
+++ b/nilmth/data/clustering.py
@@ -3,7 +3,6 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
-from nilmth.utils.plot import plot_power_distribution
 from scipy.cluster.hierarchy import cophenet, dendrogram, fcluster, linkage
 from scipy.spatial.distance import pdist
 

From 7e14e34a92d76bf16de1c48348668327920d3612 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Fri, 24 Sep 2021 17:52:30 +0200
Subject: [PATCH 42/47] Include synthetic series

---
 nilmth/hierarchical_clustering.py | 79 ++++++++++++++++++++++++++++++-
 1 file changed, 77 insertions(+), 2 deletions(-)

diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index b864a94..c41d253 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -1,10 +1,10 @@
 import os
+import random
 from typing import Iterable, Optional
 
 import matplotlib.pyplot as plt
 import numpy as np
 import typer
-from matplotlib import pyplot as plt
 from matplotlib.axes import Axes
 
 from nilmth.data.clustering import HierarchicalClustering
@@ -14,7 +14,7 @@
 from nilmth.utils.scores import regression_scores_dict
 
 LIST_APPLIANCES = ["dish_washer", "fridge", "washing_machine"]
-LIST_CLUSTER = [2, 3, 4, 5, 6]
+LIST_CLUSTER = [2, 3, 4, 5]
 LIST_DISTANCE = [
     "average",
     "weighted",
@@ -133,6 +133,25 @@ def plot_error_reduction(intr_error: Iterable[float], ax: Optional[Axes] = None)
     ax.grid()
 
 
+def plot_series_reconstruction(power: np.array, recon: np.array):
+    """Plots the original and reconstructed series
+
+    Parameters
+    ----------
+    power : np.array
+        Original series
+    recon : np.array
+        Reconstructed series
+    """
+    time = np.arange(0, len(power)) * 6
+    plt.plot(time, power, label="Original")
+    plt.plot(time, recon, alpha=0.8, label="Reconstructed")
+    plt.grid()
+    plt.legend()
+    plt.ylabel("Power (watts)")
+    plt.xlabel("Time (s)")
+
+
 def plot_clustering_results(
     ser: np.array, distance: str = "average", centroid: str = "median"
 ):
@@ -175,6 +194,12 @@ def plot_clustering_results(
         # Update the sorted list of thresholds
         thresh = list(set(hie.thresh) - set(thresh_sorted))
         thresh_sorted.append(thresh[0])
+        # Plot
+        plt.figure(figsize=(12, 4))
+        plot_series_reconstruction(power, recon)
+        plt.title(f"Series reconstruction from {n_cluster} statuses")
+        plt.show()
+        plt.close()
     # Initialize plots
     fig, axis = plt.subplots(2, 2, figsize=(12, 8))
     # Plots
@@ -186,6 +211,56 @@ def plot_clustering_results(
     fig.tight_layout(rect=[0, 0.03, 1, 0.95])
 
 
+def build_synthetic_series(
+    size: int = 1500,
+    list_power: Optional[Iterable] = None,
+    period_min: int = 50,
+    period_max: int = 100,
+    noise_mean: float = 0,
+    noise_std: float = 10,
+) -> np.array:
+    """Builds a synthetic series
+
+    Parameters
+    ----------
+    size : int, optional
+        Size of the series, by default 1500
+    list_power : Optional[Iterable], optional
+        List of allowed power (statuses), by default None
+    period_min : int, optional
+        Minimum time period, by default 50
+    period_max : int, optional
+        Maximum time period, by default 100
+    noise_mean : float, optional
+        Mean of the noise, by default 0
+    noise_std : float, optional
+        Standard deviation of the noise, by default 10
+
+    Returns
+    -------
+    np.array
+        synthetic series
+    """
+    list_power = [0, 30, 90] if list_power is None else list_power
+    # Initialize series and indexes
+    ser = np.empty(size)
+    t_start = 0
+    t_end = 0
+    idx = 0
+    while t_end < size:
+        t_start = t_end
+        t_end = min(size, t_end + random.randint(period_min, period_max))
+        ser[t_start:t_end] = list_power[idx]
+        idx += 1
+        if idx >= len(list_power):
+            idx = 0
+            random.shuffle(list_power)
+    # Add noise
+    ser += np.random.normal(noise_mean, noise_std, size)
+    ser[ser < 0] = 0
+    return ser
+
+
 def main(
     limit: int = 20000,
     path_data: str = "data-prep",

From 216a7c8f83b1a6918ee3fa7b08b1656ed3255cfd Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Mon, 27 Sep 2021 16:34:31 +0200
Subject: [PATCH 43/47] Allow to choose error metric

---
 nilmth/data/clustering.py         |  3 +-
 nilmth/hierarchical_clustering.py | 47 ++++++++++++++++++++++---------
 2 files changed, 36 insertions(+), 14 deletions(-)

diff --git a/nilmth/data/clustering.py b/nilmth/data/clustering.py
index d732305..c91db57 100644
--- a/nilmth/data/clustering.py
+++ b/nilmth/data/clustering.py
@@ -143,4 +143,5 @@ def compute_thresholds_and_centroids(
         x_min = sorted(
             [np.min(self.x[clusters == (c + 1)]) for c in range(self.n_cluster)]
         )
-        self.thresh = np.divide(np.array(x_min[1:]) + np.array(x_max[:-1]), 2)
+        thresh = np.divide(np.array(x_min[1:]) + np.array(x_max[:-1]), 2)
+        self.thresh = np.insert(thresh, 0, 0, axis=0)
diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index c41d253..e990cc1 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -13,12 +13,13 @@
 from nilmth.utils.config import load_config
 from nilmth.utils.scores import regression_scores_dict
 
+
 LIST_APPLIANCES = ["dish_washer", "fridge", "washing_machine"]
-LIST_CLUSTER = [2, 3, 4, 5]
+LIST_CLUSTER = [1, 2, 3, 4, 5, 6]
 LIST_DISTANCE = [
     "average",
-    "weighted",
-    "centroid",
+    # "weighted",
+    # "centroid",
     "median",
     "ward",  # Ward variance minimization algorithm
 ]
@@ -71,6 +72,8 @@ def plot_thresholds_on_series(
         Contains all the power values
     thresh : Iterable[float]
         Contains all the threshold values
+    size : int, optional
+        Length of the sample series array, by default 500
     ax : Axes, optional
         Axes where the graph is plotted
     """
@@ -106,6 +109,8 @@ def plot_intrinsic_error(intr_error: Iterable[float], ax: Optional[Axes] = None)
     if ax is None:
         ax = plt.gca()
     ax.plot(LIST_CLUSTER, intr_error, ".--")
+    ymax = min(max(intr_error), 1)
+    ax.set_ylim(0, ymax)
     ax.set_ylabel("Intrinsic Error (NDE)")
     ax.set_xlabel("Number of status")
     ax.set_title("Intrinsic Error depending on splits")
@@ -153,7 +158,11 @@ def plot_series_reconstruction(power: np.array, recon: np.array):
 
 
 def plot_clustering_results(
-    ser: np.array, distance: str = "average", centroid: str = "median"
+    ser: np.array,
+    distance: str = "average",
+    centroid: str = "median",
+    error: str = "nde",
+    plot_recon: bool = False,
 ):
     """Plots the results of applying a certain clustering method
     on the given series
@@ -165,7 +174,11 @@ def plot_clustering_results(
     distance : str, optional
         Clustering linkage criteria, by default "average"
     centroid : str, optional
-            Method to compute the centroids (median or mean), by default "mean"
+        Method to compute the centroids (median or mean), by default "mean"
+    error : str, optional
+        Error metric (mse, mae, rmse, sae, nde), by default "nde"
+    plot_recon : bool, optional
+        If True, plots the reconstructed series, by default False
     """
     # Clustering
     hie = HierarchicalClustering()
@@ -180,8 +193,9 @@ def plot_clustering_results(
         # Initialize threshold class
         th = Threshold(method="custom")
         # Update thresholds and centroids
-        thresh = np.insert(np.expand_dims(hie.thresh, axis=0), 0, 0, axis=1)
+        thresh = np.expand_dims(hie.thresh, axis=0)
         centroids = np.expand_dims(hie.centroids, axis=0)
+        centroids[centroids < 1] += 1e-1
         th.set_thresholds_and_centroids(thresh, centroids)
         # Create the dictionary of power series
         power = np.expand_dims(ser, axis=1)
@@ -190,16 +204,17 @@ def plot_clustering_results(
         dict_app = {"app": {"power": power, "power_pred": recon}}
         # Compute the scores
         dict_scores = regression_scores_dict(dict_app)
-        intr_error[idx] = dict_scores["app"]["nde"]
+        intr_error[idx] = dict_scores["app"][error]
         # Update the sorted list of thresholds
         thresh = list(set(hie.thresh) - set(thresh_sorted))
         thresh_sorted.append(thresh[0])
         # Plot
-        plt.figure(figsize=(12, 4))
-        plot_series_reconstruction(power, recon)
-        plt.title(f"Series reconstruction from {n_cluster} statuses")
-        plt.show()
-        plt.close()
+        if plot_recon:
+            plt.figure(figsize=(12, 4))
+            plot_series_reconstruction(power, recon)
+            plt.title(f"Series reconstruction from {n_cluster} statuses")
+            plt.show()
+            plt.close()
     # Initialize plots
     fig, axis = plt.subplots(2, 2, figsize=(12, 8))
     # Plots
@@ -263,6 +278,7 @@ def build_synthetic_series(
 
 def main(
     limit: int = 20000,
+    error: str = "nde",
     path_data: str = "data-prep",
     path_threshold: str = "threshold.toml",
     path_config: str = "nilmth/config.toml",
@@ -276,6 +292,8 @@ def main(
     ----------
     limit : int, optional
         Number of data points to use, by default 20000
+    error : str, optional
+        Error metric (mse, mae, rmse, sae, nde), by default "nde"
     path_data : str, optional
         Path to the preprocessed data folder, by default "data-prep"
     path_threshold : str, optional
@@ -294,6 +312,7 @@ def main(
 
     # Loop through the list of appliances
     for app in LIST_APPLIANCES:
+        print(f"=====\nAppliance: {app}")
         config["appliances"] = [app]
         # Prepare data loader with train data
         dl = DataLoader(
@@ -305,11 +324,13 @@ def main(
         )
         # Take an appliance series
         ser = dl.get_appliance_series(app)[:limit]
+
         # Appliance name
         appliance = app.capitalize().replace("_", " ")
         # Loop through distances
         for distance in LIST_DISTANCE:
-            plot_clustering_results(ser, distance=distance)
+            print(f"-----\nAppliance: {app} | Distance: {distance}")
+            plot_clustering_results(ser, distance=distance, error=error)
             # Place title in figure
             plt.gcf().suptitle(f"{appliance}, Linkage: {distance}")
             # Save and close the figure

From e6a09d929bfebc13ffa157b4540db034f21bb499 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Tue, 5 Oct 2021 15:45:21 +0200
Subject: [PATCH 44/47] Choose number of states

---
 nilmth/hierarchical_clustering.py | 62 ++++++++++++++++++++-----------
 1 file changed, 40 insertions(+), 22 deletions(-)

diff --git a/nilmth/hierarchical_clustering.py b/nilmth/hierarchical_clustering.py
index e990cc1..de029b4 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/hierarchical_clustering.py
@@ -15,7 +15,6 @@
 
 
 LIST_APPLIANCES = ["dish_washer", "fridge", "washing_machine"]
-LIST_CLUSTER = [1, 2, 3, 4, 5, 6]
 LIST_DISTANCE = [
     "average",
     # "weighted",
@@ -29,6 +28,7 @@ def plot_thresholds_on_distribution(
     ser: np.array,
     thresh: Iterable[float],
     ax: Optional[Axes] = None,
+    power_min: int = 0,
     app: str = "",
     bins: int = 100,
 ):
@@ -49,16 +49,19 @@ def plot_thresholds_on_distribution(
     """
     if ax is None:
         ax = plt.gca()
-    y, x, _ = ax.hist(ser, bins=bins, range=(3, ser.max()))
+    y, x, _ = ax.hist(ser, bins=bins, range=(power_min, ser.max()))
     ax.set_title(app.capitalize().replace("_", " "))
     ax.set_xlabel("Power (watts)")
     ax.set_ylabel("Frequency")
-    ax.set_title("Thresholds on power distribution (>=3 watts)")
+    title = "Thresholds on power distribution"
+    if power_min > 0:
+        title += f" (>={power_min} watts)"
+    ax.set_title(title)
     ax.grid()
     # Plot the thresholds
     for idx, t in enumerate(thresh):
         ax.axvline(t, color="r", linestyle="--")
-        ax.text(t + 0.01 * x.max(), y.max(), idx + 1, rotation=0, color="r")
+        ax.text(t + 0.01 * x.max(), y.max(), idx, rotation=0, color="r")
 
 
 def plot_thresholds_on_series(
@@ -89,18 +92,22 @@ def plot_thresholds_on_series(
     # Plot the thresholds
     for idx, thresh in enumerate(thresh):
         ax.axhline(thresh, color="r", linestyle="--")
-        ax.text(time.max(), thresh + power.max() * 0.01, idx + 1, rotation=0, color="r")
+        ax.text(time.max(), thresh + power.max() * 0.01, idx, rotation=0, color="r")
     ax.set_xlabel("Time (s)")
     ax.set_ylabel("Power (watts)")
     ax.set_title("Thresholds on sample time series")
     ax.grid()
 
 
-def plot_intrinsic_error(intr_error: Iterable[float], ax: Optional[Axes] = None):
+def plot_intrinsic_error(
+    list_states: Iterable[int], intr_error: Iterable[float], ax: Optional[Axes] = None
+):
     """Plots the intrinsic error depending on the number of splits
 
     Parameters
     ----------
+    list_states : Iterable[int]
+        List of states (number of clusters)
     intr_error : Iterable[float]
         List of intrinsic error values
     ax : Axes, optional
@@ -108,20 +115,22 @@ def plot_intrinsic_error(intr_error: Iterable[float], ax: Optional[Axes] = None)
     """
     if ax is None:
         ax = plt.gca()
-    ax.plot(LIST_CLUSTER, intr_error, ".--")
-    ymax = min(max(intr_error), 1)
-    ax.set_ylim(0, ymax)
-    ax.set_ylabel("Intrinsic Error (NDE)")
+    ax.plot(list_states, intr_error, ".--")
+    ax.set_ylabel("Intrinsic Error")
     ax.set_xlabel("Number of status")
     ax.set_title("Intrinsic Error depending on splits")
     ax.grid()
 
 
-def plot_error_reduction(intr_error: Iterable[float], ax: Optional[Axes] = None):
+def plot_error_reduction(
+    list_states: Iterable[int], intr_error: Iterable[float], ax: Optional[Axes] = None
+):
     """Plots the intrinsic error reduction depending on the number of splits
 
     Parameters
     ----------
+    list_states : Iterable[int]
+        List of states (number of clusters)
     intr_error : Iterable[float]
         List of intrinsic error values
     ax : Axes, optional
@@ -130,7 +139,7 @@ def plot_error_reduction(intr_error: Iterable[float], ax: Optional[Axes] = None)
     if ax is None:
         ax = plt.gca()
     rel_error = -100 * np.divide(np.diff(intr_error), intr_error[:-1])
-    ax.plot(LIST_CLUSTER[1:], rel_error, ".--")
+    ax.plot(list_states[1:], rel_error, ".--")
     ax.set_ylim(0, 100)
     ax.set_ylabel("Reduction of Intrinsic Error (%)")
     ax.set_xlabel("Number of status")
@@ -159,9 +168,10 @@ def plot_series_reconstruction(power: np.array, recon: np.array):
 
 def plot_clustering_results(
     ser: np.array,
+    max_clusters: int = 10,
     distance: str = "average",
     centroid: str = "median",
-    error: str = "nde",
+    error: str = "mae",
     plot_recon: bool = False,
 ):
     """Plots the results of applying a certain clustering method
@@ -171,12 +181,14 @@ def plot_clustering_results(
     ----------
     ser : np.array
         Contains all the power values
+    max_clusters : int, optional
+        Maximum number of clusters, by default 10
     distance : str, optional
         Clustering linkage criteria, by default "average"
     centroid : str, optional
         Method to compute the centroids (median or mean), by default "mean"
     error : str, optional
-        Error metric (mse, mae, rmse, sae, nde), by default "nde"
+        Error metric (mse, mae, rmse, sae, nde), by default "mae"
     plot_recon : bool, optional
         If True, plots the reconstructed series, by default False
     """
@@ -184,11 +196,12 @@ def plot_clustering_results(
     hie = HierarchicalClustering()
     hie.perform_clustering(ser, distance=distance)
     # Initialize the list of intrinsic error per number of clusters
-    intr_error = [0] * len(LIST_CLUSTER)
+    intr_error = [0] * max_clusters
+    list_states = [n + 1 for n in range(max_clusters)]
     # Initialize the empty list of thresholds (sorted)
     thresh_sorted = []
     # Compute thresholds per number of clusters
-    for idx, n_cluster in enumerate(LIST_CLUSTER):
+    for idx, n_cluster in enumerate(list_states):
         hie.compute_thresholds_and_centroids(n_cluster=n_cluster, centroid=centroid)
         # Initialize threshold class
         th = Threshold(method="custom")
@@ -216,12 +229,12 @@ def plot_clustering_results(
             plt.show()
             plt.close()
     # Initialize plots
-    fig, axis = plt.subplots(2, 2, figsize=(12, 8))
+    fig, axis = plt.subplots(2, 2, figsize=(12, 8), dpi=150)
     # Plots
     plot_thresholds_on_distribution(power, thresh_sorted, ax=axis[0, 0])
     plot_thresholds_on_series(power, thresh_sorted, ax=axis[0, 1])
-    plot_intrinsic_error(intr_error, ax=axis[1, 0])
-    plot_error_reduction(intr_error, ax=axis[1, 1])
+    plot_intrinsic_error(list_states, intr_error, ax=axis[1, 0])
+    plot_error_reduction(list_states, intr_error, ax=axis[1, 1])
     # Set the space between subplots
     fig.tight_layout(rect=[0, 0.03, 1, 0.95])
 
@@ -278,7 +291,8 @@ def build_synthetic_series(
 
 def main(
     limit: int = 20000,
-    error: str = "nde",
+    max_clusters: int = 10,
+    error: str = "mae",
     path_data: str = "data-prep",
     path_threshold: str = "threshold.toml",
     path_config: str = "nilmth/config.toml",
@@ -292,8 +306,10 @@ def main(
     ----------
     limit : int, optional
         Number of data points to use, by default 20000
+    max_clusters : int, optional
+        Maximum number of clusters, by default 10
     error : str, optional
-        Error metric (mse, mae, rmse, sae, nde), by default "nde"
+        Error metric (mse, mae, rmse, sae, nde), by default "mae"
     path_data : str, optional
         Path to the preprocessed data folder, by default "data-prep"
     path_threshold : str, optional
@@ -330,7 +346,9 @@ def main(
         # Loop through distances
         for distance in LIST_DISTANCE:
             print(f"-----\nAppliance: {app} | Distance: {distance}")
-            plot_clustering_results(ser, distance=distance, error=error)
+            plot_clustering_results(
+                ser, max_clusters=max_clusters, distance=distance, error=error
+            )
             # Place title in figure
             plt.gcf().suptitle(f"{appliance}, Linkage: {distance}")
             # Save and close the figure

From bc65add961015704d878ce778752209b2c604a65 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Tue, 5 Oct 2021 15:54:34 +0200
Subject: [PATCH 45/47] Move functions to plot_clustering

---
 .../plot_clustering.py}                                   | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
 rename nilmth/{hierarchical_clustering.py => plot/plot_clustering.py} (98%)

diff --git a/nilmth/hierarchical_clustering.py b/nilmth/plot/plot_clustering.py
similarity index 98%
rename from nilmth/hierarchical_clustering.py
rename to nilmth/plot/plot_clustering.py
index de029b4..847ad0a 100644
--- a/nilmth/hierarchical_clustering.py
+++ b/nilmth/plot/plot_clustering.py
@@ -293,10 +293,10 @@ def main(
     limit: int = 20000,
     max_clusters: int = 10,
     error: str = "mae",
-    path_data: str = "data-prep",
-    path_threshold: str = "threshold.toml",
-    path_config: str = "nilmth/config.toml",
-    path_output: str = "outputs/hieclust",
+    path_data: str = "../data-prep",
+    path_threshold: str = "../threshold.toml",
+    path_config: str = "../nilmth/config.toml",
+    path_output: str = "../outputs/hieclust",
 ):
     """Performs the hierarchical clustering on the given list of appliances,
     testing different linkage methods and number of splits. For each combination,

From 98357aacecdb40ddf0bd6f25236eb60f0b6f2837 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Tue, 5 Oct 2021 16:08:37 +0200
Subject: [PATCH 46/47] Remove glob attributes from HierarchicalClustering

---
 nilmth/data/clustering.py | 35 ++++++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/nilmth/data/clustering.py b/nilmth/data/clustering.py
index c91db57..780e182 100644
--- a/nilmth/data/clustering.py
+++ b/nilmth/data/clustering.py
@@ -8,19 +8,37 @@
 
 
 class HierarchicalClustering:
-    x: np.array = None
-    z: np.array = None
-    thresh: np.array = None
-    centroids: np.array = None
-    dendrogram: dict = None
-
     def __init__(
         self, distance: str = "average", n_cluster: int = 2, criterion: str = "maxclust"
     ):
+        """This object is able to perform Hierarchical Clustering on a given set of points
+
+        Parameters
+        ----------
+        distance : str, optional
+            Clustering distance criteria, by default "average"
+        n_cluster : int, optional
+            Number of clusters to form, by default 2
+        criterion : str, optional
+            Criterion used to compute the clusters, by default "maxclust"
+        """
         self.distance = distance
         self.n_cluster = n_cluster
         self.criterion = criterion
 
+        # Attributes filled with `perform_clustering`
+        self.x = np.empty(0)  # Set of data points
+        self.z = np.empty(0)  # The hierarchical clustering encoded as a linkage matrix
+        # z[i] will tell us which clusters were merged in the i-th iteration
+
+        # Attributes filled with `plot_dendogram`
+        self.dendrogram = {}
+        # A dictionary of data structures computed to render the dendrogram
+
+        # Attributes filled with `compute_thresholds_and_centroids`
+        self.thresh = np.empty(0)
+        self.centroids = np.empty(0)
+
     def perform_clustering(
         self, ser: np.array, distance: Optional[str] = None
     ) -> np.array:
@@ -32,11 +50,6 @@ def perform_clustering(
             Series of points to group in clusters
         distance : str, optional
             Clustering distance criteria, by default None (takes the one from the class)
-
-        Returns
-        -------
-        np.array
-            Z[i] will tell us which clusters were merged in the i-th iteration
         """
         self.distance = distance if distance is not None else self.distance
         # The shape of our X matrix must be (n, m)

From 0c72a0a049e1cd2b95e5836cb25272ba01165980 Mon Sep 17 00:00:00 2001
From: daniprec <danipg1409@gmail.com>
Date: Tue, 5 Oct 2021 16:31:08 +0200
Subject: [PATCH 47/47] Remove global attributes from objects

---
 nilmth/data/dataloader.py    |  2 --
 nilmth/data/dataset.py       | 12 +++++++-----
 nilmth/data/preprocessing.py |  6 ++++--
 nilmth/data/threshold.py     | 21 ++++++++++++---------
 nilmth/data/ukdale.py        | 16 +++++++++++-----
 5 files changed, 34 insertions(+), 23 deletions(-)

diff --git a/nilmth/data/dataloader.py b/nilmth/data/dataloader.py
index f19631c..4c5595f 100644
--- a/nilmth/data/dataloader.py
+++ b/nilmth/data/dataloader.py
@@ -10,8 +10,6 @@
 
 
 class DataLoader(data.DataLoader):
-    dataset: DataSet = None
-
     def __init__(
         self,
         path_data: str,
diff --git a/nilmth/data/dataset.py b/nilmth/data/dataset.py
index e5aceb1..a6f0910 100644
--- a/nilmth/data/dataset.py
+++ b/nilmth/data/dataset.py
@@ -10,11 +10,6 @@
 
 
 class DataSet(data.Dataset):
-    files: list = list()
-    appliances: list = list()
-    status: list = list()
-    threshold: Threshold = None
-
     def __init__(
         self,
         path_data: str,
@@ -39,6 +34,13 @@ def __init__(
         self.validation_size = valid_size
         self.random_split = random_split
         self.random_seed = random_seed
+
+        # Attributes filled by `_list_files`
+        self.files = list()  # List of files
+
+        # Attributes filled by `_get_parameters_from_file`
+        self.status = list()  # List of status columns
+
         self._list_files(path_data)
         self._get_parameters_from_file()
 
diff --git a/nilmth/data/preprocessing.py b/nilmth/data/preprocessing.py
index 18ef06e..94ffb61 100644
--- a/nilmth/data/preprocessing.py
+++ b/nilmth/data/preprocessing.py
@@ -10,10 +10,9 @@
 
 
 class Preprocessing:
-    dataset: str = "Wrapper"
-
     def __init__(
         self,
+        dataset: str = "Wrapper",
         appliances: list = None,
         buildings: dict = None,
         dates: dict = None,
@@ -28,6 +27,8 @@ def __init__(
 
         Parameters
         ----------
+        dataset : str, optional
+            Name of the dataset, by default "Wrapper"
         appliances : list, optional
             List of appliances, by default empty
         buildings : dict, optional
@@ -49,6 +50,7 @@ def __init__(
         kwargs
             Additional arguments, not taken into account
         """
+        self.dataset = dataset
         # Read parameters from config files
         self.appliances = [] if appliances is None else sorted(to_list(appliances))
         self.buildings = [] if buildings is None else buildings[self.dataset]
diff --git a/nilmth/data/threshold.py b/nilmth/data/threshold.py
index 4639697..ea9a02c 100644
--- a/nilmth/data/threshold.py
+++ b/nilmth/data/threshold.py
@@ -20,13 +20,6 @@
 
 
 class Threshold:
-    num_status: int = 2
-    thresholds: np.array = None  # (appliance, status)
-    centroids: np.array = None  # (appliance, status)
-    use_std: bool = False
-    min_on: list = None
-    min_off: list = None
-
     def __init__(
         self,
         appliances: list = None,
@@ -40,6 +33,18 @@ def __init__(
         self.num_status = num_status
         # Set the default status function
         self._status_fun = self._compute_status
+
+        # Attributes filled by `_initialize_params`
+        self.thresholds = np.zeros(
+            (self.num_apps, self.num_status)
+        )  # (appliance, status)
+        self.centroids = np.zeros(
+            (self.num_apps, self.num_status)
+        )  # (appliance, status)
+        self.use_std = False
+        self.min_on = list()
+        self.min_off = list()
+
         self._initialize_params()
 
     def __repr__(self):
@@ -51,8 +56,6 @@ def _initialize_params(self):
         Given the method name and list of appliances,
         this function defines the necessary parameters to use the method
         """
-        self.thresholds = np.zeros((self.num_apps, self.num_status))
-        self.centroids = np.zeros((self.num_apps, self.num_status))
         if self.method == "vs":
             # Variance-Sensitive threshold
             self.use_std = True
diff --git a/nilmth/data/ukdale.py b/nilmth/data/ukdale.py
index 638ba71..11e649f 100644
--- a/nilmth/data/ukdale.py
+++ b/nilmth/data/ukdale.py
@@ -2,21 +2,27 @@
 
 import pandas as pd
 from pandas import Series
-from pandas.io.pytables import HDFStore
 
 from nilmth.data.preprocessing import Preprocessing
 from nilmth.utils.string import homogenize_label
 
 
 class Ukdale(Preprocessing):
-    dataset: str = "ukdale"
-    datastore: HDFStore = None
-
     def __init__(self, path_h5: str, path_labels: str, **kwargs):
-        super(Ukdale, self).__init__(**kwargs)
+        """UK-DALE preprocessing object
+
+        Parameters
+        ----------
+        path_h5 : str
+            Path to the h5 file
+        path_labels : str
+            Path to the labels folder
+        """
+        super(Ukdale, self).__init__(dataset="ukdale", **kwargs)
         self._path_h5 = path_h5
         self._path_labels = path_labels
         # Load the datastore
+        self.datastore = None  # HDFStore
         self._load_datastore()
 
     def _load_datastore(self):