From 1f1001a7a26ba4cc465c6e517a030003afafdf8b Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Thu, 30 May 2024 16:58:11 -0700
Subject: [PATCH 01/17] Refactored prescriptors to be more user-oriented vs.
 train oriented. Still have to test them

---
 use_cases/eluc/.gitignore                     |   1 +
 .../nsga2/land_use_prescriptor.py             |  84 +++++++++++
 .../prescriptors/nsga2/prescriptor_manager.py |  44 ++++++
 .../prescriptors/nsga2/torch_prescriptor.py   | 132 ------------------
 use_cases/eluc/prescriptors/nsga2/trainer.py  |  27 ++--
 use_cases/eluc/prescriptors/prescriptor.py    |  31 +---
 6 files changed, 150 insertions(+), 169 deletions(-)
 create mode 100644 use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
 create mode 100644 use_cases/eluc/prescriptors/nsga2/prescriptor_manager.py
 delete mode 100644 use_cases/eluc/prescriptors/nsga2/torch_prescriptor.py

diff --git a/use_cases/eluc/.gitignore b/use_cases/eluc/.gitignore
index 83c59ca..494954c 100644
--- a/use_cases/eluc/.gitignore
+++ b/use_cases/eluc/.gitignore
@@ -10,6 +10,7 @@ experiments/figures
 # Ignores trained prescriptors and seeds
 prescriptors/*/trained_prescriptors
 prescriptors/*/seeds
+prescriptors/nsga2/transfer_prescriptors.ipynb
 
 data/*.zip
 data/processed/*.csv
diff --git a/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py b/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
new file mode 100644
index 0000000..bf03a43
--- /dev/null
+++ b/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
@@ -0,0 +1,84 @@
+"""
+Base implementation of the land use prescriptor as used in the paper.
+"""
+import numpy as np
+import pandas as pd
+import torch
+from torch.utils.data import DataLoader
+
+from data import constants
+from data.eluc_data import ELUCEncoder
+from data.torch_data import TorchDataset
+from prescriptors.nsga2.candidate import Candidate
+from prescriptors.prescriptor import Prescriptor
+
+class LandUsePrescriptor(Prescriptor):
+    """
+    Prescriptor object that wraps around a single candidate that was trained via.
+    evolution using NSGA-II.
+    """
+    def __init__(self, candidate: Candidate, encoder: ELUCEncoder, batch_size: int=4096):
+        self.candidate = candidate
+        self.encoder = encoder
+        self.batch_size = batch_size
+
+    def _reco_tensor_to_df(self, reco_tensor: torch.Tensor, context_df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Converts raw Candidate neural network output tensor to scaled dataframe.
+        Sets the indices of the recommendations so that we can subtract from the context to get
+        the land diffs.
+        """
+        reco_df = pd.DataFrame(reco_tensor.cpu().numpy(), index=context_df.index, columns=constants.RECO_COLS)
+        reco_df = reco_df.clip(0, None) # ReLU
+        reco_df[reco_df.sum(axis=1) == 0] = 1 # Rows of all 0s are set to 1s
+        reco_df = reco_df.div(reco_df.sum(axis=1), axis=0) # Normalize to sum to 1
+        reco_df = reco_df.mul(context_df[constants.RECO_COLS].sum(axis=1), axis=0) # Rescale to match original sum
+        return reco_df
+
+    def _reco_to_context_actions(self, reco_df: pd.DataFrame, context_df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Converts recommendation df and original context df to context + actions df.
+        Uses original context to compute diffs based on recommendations - original context.
+        """
+        assert reco_df.index.isin(context_df.index).all(), "Recommendation index must be a subset of context index."
+        presc_actions_df = reco_df - context_df[constants.RECO_COLS]
+        presc_actions_df = presc_actions_df.rename(constants.RECO_MAP, axis=1)
+        presc_actions_df[constants.NO_CHANGE_COLS] = 0
+        context_actions_df = pd.concat([context_df[constants.CAO_MAPPING["context"]],
+                                            presc_actions_df[constants.CAO_MAPPING["actions"]]],
+                                            axis=1)
+        return context_actions_df
+    
+    def prescribe(self, context_df) -> pd.DataFrame:
+        """
+        Prescribes actions from a context.
+        Overall flow of prescription:
+            1. context_df -> context_tensor
+            2. candidate.forward(context_tensor) -> reco_tensor
+            3. reco_tensor -> reco_df
+            4. context_df, reco_df -> context_actions_df
+        """
+        # Either create context_dl or used stored one if it exists
+        encoded_context_df = self.encoder.encode_as_df(context_df[constants.CAO_MAPPING["context"]])
+        encoded_context_ds = TorchDataset(encoded_context_df.to_numpy(),
+                                          np.zeros((len(encoded_context_df), len(constants.RECO_COLS))))
+        encoded_context_dl = torch.utils.data.DataLoader(encoded_context_ds, batch_size=self.batch_size, shuffle=False)
+        return self.torch_prescribe(context_df, encoded_context_dl)
+    
+    def torch_prescribe(self, context_df: pd.DataFrame, encoded_context_dl: DataLoader):
+        """
+        Prescribes straight from a torch DataLoader so that we can avoid the overhead of converting from pandas.
+        """
+        # Aggregate recommendations
+        reco_list = []
+        with torch.no_grad():
+            for X, _ in encoded_context_dl:
+                recos = self.candidate(X)
+                reco_list.append(recos)
+            reco_tensor = torch.concatenate(reco_list, dim=0)
+
+            # Convert recommendations into context + actions
+            reco_df = self._reco_tensor_to_df(reco_tensor, context_df)
+
+        context_actions_df = self._reco_to_context_actions(reco_df, context_df)
+        return context_actions_df
diff --git a/use_cases/eluc/prescriptors/nsga2/prescriptor_manager.py b/use_cases/eluc/prescriptors/nsga2/prescriptor_manager.py
new file mode 100644
index 0000000..ab9355a
--- /dev/null
+++ b/use_cases/eluc/prescriptors/nsga2/prescriptor_manager.py
@@ -0,0 +1,44 @@
+
+import pandas as pd
+
+from data import constants
+from predictors.predictor import Predictor
+from prescriptors.prescriptor import Prescriptor
+
+class PrescriptorManager():
+    """
+    Stores many Prescriptor objects and a predictor.
+    Used to uniformly prescribe and predict various Predictors.
+    """
+    def __init__(self, prescriptors: dict[str, Prescriptor], predictor: Predictor):
+        self.prescriptors = prescriptors
+        self.predictor = predictor
+
+    def prescribe(self, cand_id: str, context_df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Prescribes from a context using a specific candidate.
+        """
+        return self.prescriptors[cand_id].prescribe(context_df)
+
+    def predict_metrics(self, context_actions_df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Computes ELUC and change for each sample in a context_actions_df.
+        """
+        eluc_df = self.predictor.predict(context_actions_df)
+        change_df = self.compute_percent_changed(context_actions_df)
+
+        return eluc_df, change_df
+
+    def compute_percent_changed(self, context_actions_df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Calculates percent of land changed by prescriptor.
+        """
+        # Sum the positive diffs
+        pos_diffs = context_actions_df[context_actions_df[constants.DIFF_LAND_USE_COLS] > 0]
+        percent_changed = pos_diffs[constants.DIFF_LAND_USE_COLS].sum(axis=1)
+        # Divide by sum of used land
+        total_land = context_actions_df[constants.LAND_USE_COLS].sum(axis=1)
+        total_land = total_land.replace(0, 1) # Avoid division by 0
+        percent_changed = percent_changed / total_land
+        change_df = pd.DataFrame(percent_changed, columns=["change"])
+        return change_df
\ No newline at end of file
diff --git a/use_cases/eluc/prescriptors/nsga2/torch_prescriptor.py b/use_cases/eluc/prescriptors/nsga2/torch_prescriptor.py
deleted file mode 100644
index 83b6d24..0000000
--- a/use_cases/eluc/prescriptors/nsga2/torch_prescriptor.py
+++ /dev/null
@@ -1,132 +0,0 @@
-"""
-LandUse Prescriptor using PyTorch NNs
-"""
-
-import numpy as np
-import pandas as pd
-import torch
-
-from data import constants
-from data.eluc_data import ELUCEncoder
-from data.torch_data import TorchDataset
-from predictors.predictor import Predictor
-from prescriptors.prescriptor import Prescriptor
-from prescriptors.nsga2.candidate import Candidate
-
-class TorchPrescriptor(Prescriptor):
-    """
-    Handles prescriptor candidate evolution
-    """
-    def __init__(self,
-                 eval_df: pd.DataFrame,
-                 encoder: ELUCEncoder,
-                 predictor: Predictor,
-                 batch_size: int,
-                 candidate_params: dict):
-
-        self.candidate_params = candidate_params
-
-        # Store eval df if needed
-        if eval_df is not None:
-            self.eval_df = eval_df
-            self.encoded_eval_df = encoder.encode_as_df(eval_df)
-            # We cache the training context here so that we don't have to repeatedly convert to tensor.
-            # We can pass in our own dataframe later for inference.
-            context_ds = TorchDataset(self.encoded_eval_df[constants.CAO_MAPPING["context"]].to_numpy(),
-                                    np.zeros((len(self.encoded_eval_df), len(constants.RECO_COLS))))
-            self.context_dl = torch.utils.data.DataLoader(context_ds, batch_size=batch_size, shuffle=False)
-
-        self.encoder = encoder
-        self.batch_size = batch_size
-        self.predictor = predictor
-
-    def _reco_tensor_to_df(self, reco_tensor: torch.Tensor, context_df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Converts raw Candidate neural network output tensor to scaled dataframe.
-        Sets the indices of the recommendations so that we can subtract from the context to get
-        the land diffs.
-        """
-        reco_df = pd.DataFrame(reco_tensor.cpu().numpy(), index=context_df.index, columns=constants.RECO_COLS)
-        reco_df = reco_df.clip(0, None) # ReLU
-        reco_df[reco_df.sum(axis=1) == 0] = 1 # Rows of all 0s are set to 1s
-        reco_df = reco_df.div(reco_df.sum(axis=1), axis=0) # Normalize to sum to 1
-        reco_df = reco_df.mul(context_df[constants.RECO_COLS].sum(axis=1), axis=0) # Rescale to match original sum
-        return reco_df
-
-    def _reco_to_context_actions(self, reco_df: pd.DataFrame, context_df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Converts recommendation df and original context df to context + actions df.
-        Uses original context to compute diffs based on recommendations - original context.
-        """
-        assert reco_df.index.isin(context_df.index).all(), "Recommendation index must be a subset of context index."
-        presc_actions_df = reco_df - context_df[constants.RECO_COLS]
-        presc_actions_df = presc_actions_df.rename(constants.RECO_MAP, axis=1)
-        presc_actions_df[constants.NO_CHANGE_COLS] = 0
-        context_actions_df = pd.concat([context_df[constants.CAO_MAPPING["context"]],
-                                            presc_actions_df[constants.CAO_MAPPING["actions"]]],
-                                            axis=1)
-        return context_actions_df
-
-    def prescribe(self, candidate: Candidate, context_df=None) -> pd.DataFrame:
-        """
-        Prescribes actions given a candidate and a context.
-        If we don't provide a context_df, we use the stored context_dl to avoid overhead. 
-        Otherwise, we create a new dataloader from the given context_df.
-        Overall flow of prescription:
-            1. context_df -> context_tensor
-            2. candidate.forward(context_tensor) -> reco_tensor
-            3. reco_tensor -> reco_df
-            4. context_df, reco_df -> context_actions_df
-        """
-        # Either create context_dl or used stored one if it exists
-        context_dl = None
-        if context_df is not None:
-            encoded_context_df = self.encoder.encode_as_df(context_df[constants.CAO_MAPPING["context"]])
-            context_ds = TorchDataset(encoded_context_df.to_numpy(),
-                                      np.zeros((len(encoded_context_df), len(constants.RECO_COLS))))
-            context_dl = torch.utils.data.DataLoader(context_ds, batch_size=self.batch_size, shuffle=False)
-        elif self.eval_df is not None:
-            context_df = self.eval_df
-            context_dl = self.context_dl
-        else:
-            raise ValueError("No context provided and no eval df stored.")
-
-        # Aggregate recommendations
-        reco_list = []
-        with torch.no_grad():
-            for X, _ in context_dl:
-                recos = candidate(X)
-                reco_list.append(recos)
-            reco_tensor = torch.concatenate(reco_list, dim=0)
-
-            # Convert recommendations into context + actions
-            reco_df = self._reco_tensor_to_df(reco_tensor, context_df)
-
-        context_actions_df = self._reco_to_context_actions(reco_df, context_df)
-        return context_actions_df
-
-    def predict_metrics(self, context_actions_df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Computes ELUC and change for each sample in a context_actions_df.
-        """
-        eluc_df = self.predictor.predict(context_actions_df)
-        change_df = self.compute_percent_changed(context_actions_df)
-
-        return eluc_df, change_df
-
-    def prescribe_land_use(self, context_df: pd.DataFrame, **kwargs) -> pd.DataFrame:
-        """
-        Wrapper for prescribe method that loads a candidate from disk using an id.
-        Valid kwargs:
-            cand_id: str, the ID of the candidate to load
-            results_dir: Path, the directory where the candidate is stored
-        Then takes in a context dataframe and prescribes actions.
-        """
-        candidate = Candidate(**self.candidate_params)
-        gen = int(kwargs["cand_id"].split("_")[0])
-        state_dict = torch.load(kwargs["results_dir"] / f"{gen + 1}" / f"{kwargs['cand_id']}.pt")
-        candidate.load_state_dict(state_dict)
-
-        context_actions_df = self.prescribe(candidate, context_df)
-        return context_actions_df
-    
\ No newline at end of file
diff --git a/use_cases/eluc/prescriptors/nsga2/trainer.py b/use_cases/eluc/prescriptors/nsga2/trainer.py
index 42fc7b1..c770397 100644
--- a/use_cases/eluc/prescriptors/nsga2/trainer.py
+++ b/use_cases/eluc/prescriptors/nsga2/trainer.py
@@ -10,11 +10,14 @@
 import pandas as pd
 import torch
 
+from data import constants
 from data.eluc_data import ELUCEncoder
+from data.torch_data import TorchDataset
 from predictors.predictor import Predictor
 from prescriptors.nsga2 import nsga2_utils
 from prescriptors.nsga2.candidate import Candidate
-from prescriptors.nsga2.torch_prescriptor import TorchPrescriptor
+from prescriptors.nsga2.land_use_prescriptor import LandUsePrescriptor
+from prescriptors.nsga2.prescriptor_manager import PrescriptorManager
 
 class TorchTrainer():
     """
@@ -38,19 +41,25 @@ def __init__(self,
         self.p_mutation = p_mutation
         self.seed_dir=seed_dir
 
-        # Store eval df if needed
-        if eval_df is not None:
-            self.eval_df = eval_df
-            self.encoded_eval_df = encoder.encode_as_df(eval_df)
-        self.prescriptor = TorchPrescriptor(eval_df, encoder, predictor, batch_size, candidate_params)
+        # Evaluation params
+        self.encoder = encoder
+        self.predictor = predictor
+        self.context_df = eval_df[constants.CAO_MAPPING["context"]]
+        encoded_eval_df = encoder.encode_as_df(eval_df)
+        context_ds = TorchDataset(encoded_eval_df[constants.CAO_MAPPING["context"]].to_numpy(),
+                                  np.zeros((len(encoded_eval_df), len(constants.RECO_COLS))))
+        self.encoded_context_dl = torch.utils.data.DataLoader(context_ds, batch_size=batch_size, shuffle=False)
+        self.batch_size = batch_size
 
     def _evaluate_candidates(self, candidates: list[Candidate]):
         """
         Calls prescribe and predict on candidates and assigns their metrics to the results.
         """
+        prescriptor_manager = PrescriptorManager(None, self.predictor)
         for candidate in candidates:
-            context_actions_df = self.prescriptor.prescribe(candidate)
-            eluc_df, change_df = self.prescriptor.predict_metrics(context_actions_df)
+            prescriptor = LandUsePrescriptor(candidate, self.encoder, self.batch_size)
+            context_actions_df = prescriptor.torch_prescribe(self.context_df, self.encoded_context_dl)
+            eluc_df, change_df = prescriptor_manager.predict_metrics(context_actions_df)
             candidate.metrics = (eluc_df["ELUC"].mean(), change_df["change"].mean())
 
     def _select_parents(self, candidates: list[Candidate], n_parents: int) -> list[Candidate]:
@@ -107,7 +116,7 @@ def neuroevolution(self, save_path: Path):
         if save_path.exists():
             shutil.rmtree(save_path)
         save_path.mkdir(parents=True, exist_ok=False)
-        self.prescriptor.encoder.save_fields(save_path / "fields.json")
+        self.encoder.save_fields(save_path / "fields.json")
         results = []
         parents = [Candidate(**self.candidate_params, cand_id=f"1_{i}") for i in range(self.pop_size)]
         # Seeding the first generation with trained models
diff --git a/use_cases/eluc/prescriptors/prescriptor.py b/use_cases/eluc/prescriptors/prescriptor.py
index 329e70a..fbe99b4 100644
--- a/use_cases/eluc/prescriptors/prescriptor.py
+++ b/use_cases/eluc/prescriptors/prescriptor.py
@@ -1,44 +1,19 @@
 """
 Abstract prescriptor class to be implemented.
 """
-from abc import ABC
+from abc import ABC, abstractmethod
 
 import pandas as pd
 
-from data import constants
-
 class Prescriptor(ABC):
     """
     Abstract class for prescriptors to allow us to experiment with different implementations.
     """
-
-    def prescribe_land_use(self, context_df: pd.DataFrame, **kwargs) -> pd.DataFrame:
+    @abstractmethod
+    def prescribe(self, context_df: pd.DataFrame) -> pd.DataFrame:
         """
         Loads a candidate prescriptor using kwargs.
         Then takes in a context dataframe, and prescribes actions.
         Outputs a concatenation of the context and actions.
         """
         raise NotImplementedError
-
-    def predict_metrics(self, context_actions_df: pd.DataFrame) -> tuple:
-        """
-        Takes in a context actions dataframe and uses the predictor the prescriptor
-        was trained on to predict ELUC. Then computes change.
-        Returns a dataframe of ELUC and change.
-        """
-        raise NotImplementedError
-
-    def compute_percent_changed(self, context_actions_df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Calculates percent of land changed by prescriptor.
-        """
-        # Sum the positive diffs
-        pos_diffs = context_actions_df[context_actions_df[constants.DIFF_LAND_USE_COLS] > 0]
-        percent_changed = pos_diffs[constants.DIFF_LAND_USE_COLS].sum(axis=1)
-        # Divide by sum of used land
-        total_land = context_actions_df[constants.LAND_USE_COLS].sum(axis=1)
-        total_land = total_land.replace(0, 1) # Avoid division by 0
-        percent_changed = percent_changed / total_land
-        change_df = pd.DataFrame(percent_changed, columns=["change"])
-        return change_df
-    
\ No newline at end of file

From 9db5c0478366951ba9572fb470b1f3ed8918b68e Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Fri, 31 May 2024 10:46:34 -0700
Subject: [PATCH 02/17] Added saving loading and frompretrained to prescriptor

---
 .../nsga2/land_use_prescriptor.py             | 30 +++++++++++++
 use_cases/eluc/prescriptors/nsga2/trainer.py  |  3 +-
 use_cases/eluc/prescriptors/prescriptor.py    | 43 ++++++++++++++++++-
 3 files changed, 73 insertions(+), 3 deletions(-)

diff --git a/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py b/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
index bf03a43..13e6ddf 100644
--- a/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
+++ b/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
@@ -1,6 +1,9 @@
 """
 Base implementation of the land use prescriptor as used in the paper.
 """
+import json
+from pathlib import Path
+
 import numpy as np
 import pandas as pd
 import torch
@@ -82,3 +85,30 @@ def torch_prescribe(self, context_df: pd.DataFrame, encoded_context_dl: DataLoad
 
         context_actions_df = self._reco_to_context_actions(reco_df, context_df)
         return context_actions_df
+    
+    def save(self, path: Path):
+        """
+        Saves the prescriptor to disk.
+        """
+        path.mkdir(parents=True, exist_ok=True)
+        cand_params = {
+            "in_size": self.candidate.in_size,
+            "hidden_size": self.candidate.hidden_size,
+            "out_size": self.candidate.out_size
+        }
+        with open(path / "cand_params.json", "w", encoding="utf-8") as file:
+            json.dump(cand_params, file)
+        self.encoder.save_fields(path / "fields.json")
+        torch.save(self.candidate.state_dict(), path / "model.pt")
+
+    @classmethod
+    def load(cls, path: Path) -> "LandUsePrescriptor":
+        """
+        Loads a prescriptor from disk.
+        """
+        with open(path / "cand_params.json", "r", encoding="utf-8") as file:
+            cand_params = json.load(file)
+        candidate = Candidate(**cand_params)
+        candidate.load_state_dict(torch.load(path / "model.pt"))
+        encoder = ELUCEncoder.from_json(path / "fields.json")
+        return cls(candidate, encoder)
diff --git a/use_cases/eluc/prescriptors/nsga2/trainer.py b/use_cases/eluc/prescriptors/nsga2/trainer.py
index c770397..8b31057 100644
--- a/use_cases/eluc/prescriptors/nsga2/trainer.py
+++ b/use_cases/eluc/prescriptors/nsga2/trainer.py
@@ -9,6 +9,7 @@
 import numpy as np
 import pandas as pd
 import torch
+from torch.utils.data import DataLoader
 
 from data import constants
 from data.eluc_data import ELUCEncoder
@@ -48,7 +49,7 @@ def __init__(self,
         encoded_eval_df = encoder.encode_as_df(eval_df)
         context_ds = TorchDataset(encoded_eval_df[constants.CAO_MAPPING["context"]].to_numpy(),
                                   np.zeros((len(encoded_eval_df), len(constants.RECO_COLS))))
-        self.encoded_context_dl = torch.utils.data.DataLoader(context_ds, batch_size=batch_size, shuffle=False)
+        self.encoded_context_dl = DataLoader(context_ds, batch_size=batch_size, shuffle=False)
         self.batch_size = batch_size
 
     def _evaluate_candidates(self, candidates: list[Candidate]):
diff --git a/use_cases/eluc/prescriptors/prescriptor.py b/use_cases/eluc/prescriptors/prescriptor.py
index fbe99b4..0d5b2c5 100644
--- a/use_cases/eluc/prescriptors/prescriptor.py
+++ b/use_cases/eluc/prescriptors/prescriptor.py
@@ -2,18 +2,57 @@
 Abstract prescriptor class to be implemented.
 """
 from abc import ABC, abstractmethod
+from pathlib import Path
 
+from huggingface_hub import snapshot_download
 import pandas as pd
 
 class Prescriptor(ABC):
     """
     Abstract class for prescriptors to allow us to experiment with different implementations.
+    Save and load must be compatible with each other but not necessarily with other models.
     """
     @abstractmethod
     def prescribe(self, context_df: pd.DataFrame) -> pd.DataFrame:
         """
-        Loads a candidate prescriptor using kwargs.
-        Then takes in a context dataframe, and prescribes actions.
+        Takes in a context dataframe and prescribes actions.
         Outputs a concatenation of the context and actions.
         """
         raise NotImplementedError
+        
+    @abstractmethod
+    def save(self, path: Path):
+        """
+        Saves a prescriptor to disk.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    @classmethod
+    def load(cls, path: Path) -> "Prescriptor":
+        """
+        Loads a prescriptor from disk.
+        """
+        raise NotImplementedError
+    
+    @classmethod
+    def from_pretrained(cls, path_or_url: str, **hf_args) -> "Prescriptor":
+        """
+        Loads a model from a path or if it is not found, from a huggingface repo.
+        TODO: This code is copied from predictor. We need to refactor this to avoid code duplication.
+        :param path_or_url: path to the model or url to the huggingface repo.
+        :param hf_args: arguments to pass to the snapshot_download function from huggingface.
+        """
+        path = Path(path_or_url)
+        if path.exists() and path.is_dir():
+            return cls.load(path)
+        else:
+            # TODO: Need a try except block to catch download errors
+            url_path = path_or_url.replace("/", "--")
+            local_dir = hf_args.get("local_dir", f"prescriptors/trained_models/{url_path}")
+
+            if not Path(local_dir).exists() or not Path(local_dir).is_dir():
+                hf_args["local_dir"] = local_dir
+                snapshot_download(repo_id=path_or_url, **hf_args)
+
+            return cls.load(Path(local_dir))

From a18450511a8af7c5db14f978bbf92a9dd2486425 Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Fri, 31 May 2024 10:48:30 -0700
Subject: [PATCH 03/17] Updated heuristics

---
 .../eluc/prescriptors/heuristics/heuristics.py | 18 +++---------------
 1 file changed, 3 insertions(+), 15 deletions(-)

diff --git a/use_cases/eluc/prescriptors/heuristics/heuristics.py b/use_cases/eluc/prescriptors/heuristics/heuristics.py
index 5caa6fe..a4e7ea5 100644
--- a/use_cases/eluc/prescriptors/heuristics/heuristics.py
+++ b/use_cases/eluc/prescriptors/heuristics/heuristics.py
@@ -17,9 +17,6 @@ class HeuristicPrescriptor(Prescriptor, ABC):
     Requires an implementation of reco_heuristic which takes a context dataframe and returns
     recommendations based on the heuristic.
     """
-    def __init__(self, predictor: Predictor):
-        self.predictor = predictor
-
     @abstractmethod
     def _reco_heuristic(self, pct: float, context_df: pd.DataFrame) -> pd.DataFrame:
         """
@@ -28,7 +25,7 @@ def _reco_heuristic(self, pct: float, context_df: pd.DataFrame) -> pd.DataFrame:
         """
         raise NotImplementedError
 
-    def prescribe_land_use(self, context_df: pd.DataFrame, **kwargs) -> pd.DataFrame:
+    def prescribe(self, context_df: pd.DataFrame, **kwargs) -> pd.DataFrame:
         """
         Implementation of prescribe_land_use using a heuristic. Calls the implementation of _reco_heuristic.
         Kwargs must contain a "pct" key that is the percentage of land-use change to prescribe up to.
@@ -44,19 +41,11 @@ def prescribe_land_use(self, context_df: pd.DataFrame, **kwargs) -> pd.DataFrame
         context_actions_df = pd.concat([context_df, prescribed_actions_df[constants.DIFF_LAND_USE_COLS]], axis=1)
         return context_actions_df
 
-    def predict_metrics(self, context_actions_df: pd.DataFrame) -> tuple:
-        column_order = constants.CAO_MAPPING["context"] + constants.CAO_MAPPING["actions"]
-        eluc_df = self.predictor.predict(context_actions_df[column_order])
-        change_df = self.compute_percent_changed(context_actions_df)
-        return eluc_df, change_df
-
-
 class EvenHeuristic(HeuristicPrescriptor):
     """
     Implementation of HeuristicPrescriptor that evenly distributes land use to a "best" column.
     """
-    def __init__(self, best_col: str, predictor: Predictor):
-        super().__init__(predictor)
+    def __init__(self, best_col: str):
         self.best_col = best_col
         self.presc_cols = [col for col in constants.RECO_COLS if col != best_col]
 
@@ -87,12 +76,11 @@ class PerfectHeuristic(HeuristicPrescriptor):
     Implementation of HeuristicPrescriptor that does an informed land use prescription 
     based on linear regression coefficients.
     """
-    def __init__(self, coefs: list[float], predictor: Predictor):
+    def __init__(self, coefs: list[float]):
         """
         We save and sort the columns by highest coefficient i.e. most emissions.
         Separate the best column according to the coefficients to add to.
         """
-        super().__init__(predictor)
         assert len(coefs) == len(constants.RECO_COLS)
         # Sort columns by coefficient
         reco_cols = list(constants.RECO_COLS)

From 33059f24834b3144736c5c3de98deb66df3f0928 Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Fri, 31 May 2024 15:27:24 -0700
Subject: [PATCH 04/17] Removed references to ESP

---
 use_cases/eluc/prescriptors/esp/__init__.py   |   0
 .../eluc/prescriptors/esp/create_seeds.py     | 138 --------
 .../prescriptors/esp/train_prescriptors.py    |  65 ----
 .../config-loctime-crop-nosoft.json           | 145 ---------
 .../prescriptors/esp/unileaf_prescriptor.py   | 297 ------------------
 5 files changed, 645 deletions(-)
 delete mode 100644 use_cases/eluc/prescriptors/esp/__init__.py
 delete mode 100644 use_cases/eluc/prescriptors/esp/create_seeds.py
 delete mode 100644 use_cases/eluc/prescriptors/esp/train_prescriptors.py
 delete mode 100644 use_cases/eluc/prescriptors/esp/unileaf_configs/config-loctime-crop-nosoft.json
 delete mode 100644 use_cases/eluc/prescriptors/esp/unileaf_prescriptor.py

diff --git a/use_cases/eluc/prescriptors/esp/__init__.py b/use_cases/eluc/prescriptors/esp/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/use_cases/eluc/prescriptors/esp/create_seeds.py b/use_cases/eluc/prescriptors/esp/create_seeds.py
deleted file mode 100644
index b866927..0000000
--- a/use_cases/eluc/prescriptors/esp/create_seeds.py
+++ /dev/null
@@ -1,138 +0,0 @@
-import argparse
-from pathlib import Path
-import json
-
-import pandas as pd
-import tensorflow as tf
-from keras.models import load_model
-
-from data import constants
-from data.eluc_data import ELUCData
-from prescriptors.esp.unileaf_prescriptor import UnileafPrescriptor
-from predictors.neural_network.neural_net_predictor import NeuralNetPredictor
-
-def create_template_model():
-    """
-    TODO: The architecture is currently hard-coded. Need to figure out how to do this 
-    like in PyTorch.
-    Creates keras template prescriptor given architecture from paper:
-        Input layer for each context variable
-        Dense layer for each context variable hidden size 16
-        Tanh activation
-        Output as reco_land_use vector
-    """
-    inputs = [tf.keras.Input(shape=(1,), name=f"{col}_input") for col in constants.CAO_MAPPING["context"]]
-    dense = [tf.keras.layers.Dense(16, name=constants.CAO_MAPPING["context"][i])(inputs[i]) for i in range(len(inputs))]
-    add4 = tf.keras.layers.Add()(dense)
-    activation = tf.keras.layers.Activation("tanh", name="first_hidden_activation")(add4)
-    output = tf.keras.layers.Dense(len(constants.RECO_COLS), name="reco_land_use")(activation)
-    model = tf.keras.Model(inputs=inputs, outputs=output)
-    return model
-
-def seed_no_change(seed_dir: Path, df: pd.DataFrame, encoded_df: pd.DataFrame, n_epochs=300):
-    """
-    Creates seed model that attempts to prescribe zero change.
-    This is now feasible because we no longer softmax the output but instead linearly scale them.
-    """
-
-    no_change_preds = df[constants.RECO_COLS].copy()
-    y_train = no_change_preds.to_numpy()
-    X_train = [encoded_df[col].values for col in constants.CAO_MAPPING["context"]]
-
-    no_change_model = create_template_model()
-    opt = tf.keras.optimizers.legacy.Adam(learning_rate=0.001)
-    no_change_model.compile(optimizer=opt, loss='mean_absolute_error', metrics=['mae'])
-    no_change_model.fit(X_train, y_train, epochs=n_epochs, batch_size=4096, verbose=1)
-
-    seed_dir.mkdir(parents=True, exist_ok=True)
-    no_change_model.save(seed_dir / "1_1.h5")
-
-def seed_max_change(seed_dir: Path, df: pd.DataFrame, encoded_df: pd.DataFrame, n_epochs=300, best_col="secdf"):
-    """
-    Creates seed model that attempts to prescribe maximum change.
-    Moves all possible land use to best_col which is secdf by default.
-    """
-    # Move all the land use to secdf
-    land_use = df[constants.RECO_COLS].sum(axis=1)
-    max_change_preds = df[constants.RECO_COLS].copy()
-    max_change_preds[constants.RECO_COLS] = 0
-    max_change_preds[best_col] = land_use
-
-    y_train = max_change_preds.to_numpy()
-    X_train = [encoded_df[col].values for col in constants.CAO_MAPPING["context"]]
-    
-    max_change_model = create_template_model()
-    opt = tf.keras.optimizers.legacy.Adam(learning_rate=0.001)
-    max_change_model.compile(optimizer=opt, loss='mean_absolute_error', metrics=['mae'])
-    max_change_model.fit(X_train, y_train, epochs=n_epochs, batch_size=4096, verbose=1)
-
-    seed_dir.mkdir(parents=True, exist_ok=True)
-    max_change_model.save(seed_dir / "1_2.h5")
-
-def validate_seeds(seed_dir: Path, nn_path: Path, presc_cfg_path:Path, dataset: ELUCData):
-    """
-    TODO: This is pretty yucky right now and exposes some internals in the dummy prescriptor,
-    will have to play around with the SWE side of the prescriptors to make this work better.
-    Validates that the seeds' performances match the intended behavior.
-    Creates a dummy prescriptor and evaluates the seeds, then prints the results.
-    """
-    nnp = NeuralNetPredictor()
-    nnp.load(nn_path)
-    with open(presc_cfg_path, "rb", encoding="utf-8") as f:
-        presc_config = json.load(f)
-    dummy_prescriptor = UnileafPrescriptor(presc_config,
-                                    dataset.train_df.iloc[:1],
-                                    dataset.encoder,
-                                    [nnp])
-    
-    test_df = dataset.test_df.sample(frac=0.01, random_state=100)
-    context_df = test_df[constants.CAO_MAPPING["context"]]
-
-    for seed_path in seed_dir.iterdir():
-        candidate = load_model(seed_path)
-        encoded_context_df = dataset.encoder.encode_as_df(context_df)
-        reco_land_use = dummy_prescriptor.prescribe(candidate, encoded_context_df)
-        reco_df = pd.DataFrame(reco_land_use["reco_land_use"].tolist(), columns=constants.RECO_COLS)
-        context_actions_df = dummy_prescriptor._reco_to_context_actions(reco_df, encoded_context_df)
-        context_actions_df = context_actions_df.set_index(context_df.index)
-
-        eluc_df, change_df = dummy_prescriptor.predict_metrics(context_actions_df)
-        print(f"{seed_path.name} ELUC: {eluc_df['ELUC'].mean()}, change: {change_df['change'].mean()}")
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--seed_dir", type=str, help="Directory to save seeds to", required=True)
-    parser.add_argument("--n_samples", type=float, default=10000,
-                        help="How much of the dataset to use for training. \
-                            If <1 uses a proportion of the dataset, \
-                            otherwise uses a flat number.")
-    parser.add_argument("--n_epochs", type=int, default=300, help="Number of epochs to train for.")
-    parser.add_argument("--validate", default=True, help="Whether to validate the seeds after training.")
-    parser.add_argument("--nn_path", type=str, default="predictors/neural_network/trained_models/no_overlap_nn",
-                        help="Path to saved neural network model.")
-    parser.add_argument("--presc_cfg_path", type=str, default="prescriptors/esp/unileaf_configs/config-loctime-crop-nosoft.json",
-                        help="Path to prescriptor configuration.")
-    args = parser.parse_args()
-
-    dataset = ELUCData()
-
-    # Take small subset for training, we really don't need more and just need the model to converge
-    train_df = dataset.train_df
-    if args.n_samples:
-        if args.n_samples < 1:
-            train_df = train_df.sample(frac=args.n_samples, random_state=100)
-        else:
-            train_df = train_df.sample(n=int(args.n_samples), random_state=100)
-    encoded_train_df = dataset.get_encoded_train().loc[train_df.index]
-
-    seed_dir = Path(args.seed_dir)
-
-    seed_no_change(seed_dir, train_df, encoded_train_df, args.n_epochs)
-    seed_max_change(seed_dir, train_df, encoded_train_df, args.n_epochs)
-
-    if args.validate:
-        nn_path = Path(args.nn_path)
-        presc_cfg_path = Path(args.presc_cfg_path)
-        validate_seeds(seed_dir, nn_path, presc_cfg_path, dataset)
-
-    
\ No newline at end of file
diff --git a/use_cases/eluc/prescriptors/esp/train_prescriptors.py b/use_cases/eluc/prescriptors/esp/train_prescriptors.py
deleted file mode 100644
index 44ece23..0000000
--- a/use_cases/eluc/prescriptors/esp/train_prescriptors.py
+++ /dev/null
@@ -1,65 +0,0 @@
-"""
-Basic script to train prescriptors using ESP.
-Note: This is not open-source and requires the ESP-SDK.
-This is left here because the original paper used this implementation.
-"""
-import argparse
-import os
-import json
-from pathlib import Path
-
-from esp_sdk.esp_service import EspService
-
-from data.eluc_data import ELUCData
-from predictors.neural_network.neural_net_predictor import NeuralNetPredictor
-from prescriptors.esp.unileaf_prescriptor import UnileafPrescriptor
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--experiment_id", type=str, help="Experiment ID to use for training.", required=True)
-    parser.add_argument("--version", type=str, help="Version to use for training.", required=True)
-    parser.add_argument("--config_path", type=str, help="Path to prescriptor configuration.",
-                        default="prescriptors/esp/unileaf_configs/config-loctime-crop-nosoft.json")
-    parser.add_argument("--nn_path", type=str, help="Path to neural net predictor to load.",
-                        default="predictors/neural_network/trained_models/no_overlap_nn")
-    parser.add_argument("--n_samples", type=float, default=0.001,
-                        help="How much of the dataset to use for training. \
-                            If <1 uses a proportion of the dataset, \
-                            otherwise uses a flat number.")
-    args = parser.parse_args()
-
-    print("Loading data...")
-    dataset = ELUCData()
-
-    print("Initializing predictor...")
-    nnp = NeuralNetPredictor()
-    print("Loading predictor...")
-    nn_path = Path(args.nn_path)
-    nnp.load(nn_path)
-
-    # Set up ESP service
-    esp_username = os.getenv('ESP_SERVICE_USER')
-    esp_password = os.getenv('ESP_SERVICE_PASSWORD')
-    if not esp_username or not esp_password:
-        raise ValueError('ESP Service username and password not found.')
-    print('ESP Service username and password found.')
-
-    print("Running prescriptor training...")
-    config_path = Path(args.config_path)
-    with open(config_path, "r", encoding="utf-8") as f:
-        presc_config = json.load(f)
-        presc_config["LEAF"]["experiment_id"] = args.experiment_id
-        presc_config["LEAF"]["version"] = args.version
-
-    eval_df_encoded = dataset.get_encoded_train()
-    if args.n_samples:
-        if args.n_samples < 1:
-            eval_df_encoded = eval_df_encoded.sample(frac=args.n_samples, random_state=42)
-        else:
-            eval_df_encoded = eval_df_encoded.sample(n=int(args.n_samples), random_state=42)
-    esp_service = EspService(presc_config, esp_username, esp_password)
-    esp_evaluator = UnileafPrescriptor(presc_config,
-                                        eval_df_encoded,
-                                        dataset.encoder,
-                                        [nnp])
-    experiment_results_dir = esp_service.train(esp_evaluator)
diff --git a/use_cases/eluc/prescriptors/esp/unileaf_configs/config-loctime-crop-nosoft.json b/use_cases/eluc/prescriptors/esp/unileaf_configs/config-loctime-crop-nosoft.json
deleted file mode 100644
index 668e915..0000000
--- a/use_cases/eluc/prescriptors/esp/unileaf_configs/config-loctime-crop-nosoft.json
+++ /dev/null
@@ -1,145 +0,0 @@
-{
-    "evolution": {
-      "fitness": [
-        {
-          "maximize": false,
-          "metric_name": "ELUC"
-        },
-        {
-          "maximize": false,
-          "metric_name": "change"
-        }
-      ],
-      "nb_elites": 10,
-      "mutation_type": "gaussian_noise_percentage",
-      "nb_generations": 100,
-      "mutation_factor": 0.2,
-      "population_size": 100,
-      "parent_selection": "tournament",
-      "initialization_range": 1,
-      "mutation_probability": 0.2,
-      "remove_population_pct": 0.8,
-      "initialization_distribution": "orthogonal",
-      "seed_weights_dir": "prescriptors/esp/seeds/loctime-crop-nosoft"
-    },
-    "network": {
-      "inputs": [
-        {
-          "name": "crop",
-          "size": 1,
-          "values": [
-            "float"
-          ]
-        },
-        {
-          "name": "pastr",
-          "size": 1,
-          "values": [
-            "float"
-          ]
-        },
-        {
-          "name": "primf",
-          "size": 1,
-          "values": [
-            "float"
-          ]
-        },
-        {
-          "name": "primn",
-          "size": 1,
-          "values": [
-            "float"
-          ]
-        },
-        {
-          "name": "range",
-          "size": 1,
-          "values": [
-            "float"
-          ]
-        },
-        {
-          "name": "secdf",
-          "size": 1,
-          "values": [
-            "float"
-          ]
-        },
-        {
-          "name": "secdn",
-          "size": 1,
-          "values": [
-            "float"
-          ]
-        },
-        {
-          "name": "urban",
-          "size": 1,
-          "values": [
-            "float"
-          ]
-        },
-        {
-          "name": "cell_area",
-          "size": 1,
-          "values": [
-            "float"
-          ]
-        },
-        {
-            "name": "lat",
-            "size": 1,
-            "values": [
-              "float"
-            ]
-          },
-          {
-            "name": "lon",
-            "size": 1,
-            "values": [
-              "float"
-            ]
-          },
-          {
-            "name": "time",
-            "size": 1,
-            "values": [
-              "float"
-            ]
-          }
-      ],
-      "outputs": [
-        {
-          "name": "reco_land_use",
-          "size": 5,
-          "activation": "linear",
-          "use_bias": true,
-          "values": [
-            "float"
-          ]
-        }
-      ],
-      "hidden_layers": [
-        {
-          "layer_name": "hidden_1",
-          "layer_type": "Dense",
-          "layer_params": {
-            "units": 16,
-            "use_bias": true,
-            "activation": "tanh"
-          }
-        }
-      ]
-    },
-    "LEAF": {
-      "representation": "NNWeights",
-      "experiment_id": "test",
-      "version": "1.0",
-      "persistence_dir": "prescriptors/esp/trained_prescriptors/",
-      "candidates_to_persist": "pareto",
-      "esp_host": "localhost",
-      "esp_port": "50051",
-      "secure": false
-    }
-  }
\ No newline at end of file
diff --git a/use_cases/eluc/prescriptors/esp/unileaf_prescriptor.py b/use_cases/eluc/prescriptors/esp/unileaf_prescriptor.py
deleted file mode 100644
index 525ad14..0000000
--- a/use_cases/eluc/prescriptors/esp/unileaf_prescriptor.py
+++ /dev/null
@@ -1,297 +0,0 @@
-"""
-Note: This class cannot be used without the ESP SDK. It is not available to the general public and
-is just a guideline for other evolution methods. A similar open-source implementation is available
-in the "nsga2" directory.
-"""
-from typing import Any
-from typing import Dict
-from typing import List
-
-import pandas as pd
-import numpy as np
-from keras.models import load_model
-
-from esp_sdk.esp_evaluator import EspEvaluator
-
-from data import constants
-from data.eluc_data import ELUCEncoder
-from prescriptors.prescriptor import Prescriptor
-
-class UnileafPrescriptor(EspEvaluator, Prescriptor):
-    """
-    An Unileaf Prescriptor makes prescriptions given an ESP candidate and a context DataFrame.
-    It is also an EspEvaluator implementation that returns metrics for ESP candidates.
-    """
-
-    def __init__(self,
-                 config: Dict[str, Any],
-                 evaluation_df: pd.DataFrame,
-                 data_encoder: ELUCEncoder,
-                 predictors):
-        """
-        Constructs a prescriptor evaluator
-        :param config: the ESP experiment config dictionary
-        :param evaluation_df: the encoded Pandas DataFrame to use to evaluate the candidates
-        :param data_encoder: the DataEncoder used to encode the dataset
-        :param predictors: the predictors this prescriptor relies on
-        """
-        # Instantiate EspEvaluator
-        # Note: sets self.config
-        super().__init__(config)
-
-        # CAO
-        self.cao_mapping = {"context": self.get_context_field_names(config),
-                            "actions": self.get_action_field_names(config),
-                            "outcomes": self.get_fitness_metrics(config)}
-        self.context_df = evaluation_df[self.cao_mapping["context"]]
-        self.row_index = self.context_df.index
-
-        # Convert the context DataFrame to a format a NN can ingest
-        self.context_as_nn_input = self.convert_to_nn_input(self.context_df)
-
-        # Data encoder
-        self.data_encoder = data_encoder
-
-        # Predictors
-        self.predictors = predictors
-
-    @staticmethod
-    def convert_to_nn_input(context_df: pd.DataFrame) -> List[np.ndarray]:
-        """
-        Converts a context DataFrame to a list of numpy arrays a neural network can ingest
-        :param context_df: a DataFrame containing inputs for a neural network. Number of inputs and size must match
-        :return: a list of numpy ndarray, on ndarray per neural network input
-        """
-        # The NN expects a list of i inputs by s samples (e.g. 9 x 299).
-        # So convert the data frame to a numpy array (gives shape 299 x 9), transpose it (gives 9 x 299)
-        # and convert to list(list of 9 arrays of 299)
-        context_as_nn_input = list(context_df.to_numpy().transpose())
-        # Convert each column's list of 1D array to a 2D array
-        context_as_nn_input = [np.stack(context_as_nn_input[i], axis=0) for i in
-                               range(len(context_as_nn_input))]
-        return context_as_nn_input
-
-    def _reco_to_context_actions(self, reco_df: pd.DataFrame, encoded_context_df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Converts a dataframe containing recommended land use proportions to a dataframe containing
-        the context and prescribed actions.
-        """
-        # This is gacky but has to happen sooner or later
-        reco_df = reco_df.reset_index(drop=True)
-        encoded_context_df = encoded_context_df.reset_index(drop=True)
-
-        context_df = self.data_encoder.decode_as_df(encoded_context_df)
-
-        # Linear scaling is implemented here:
-        # Do ReLU here since we no longer softmax
-        reco_df = reco_df.clip(0, None)
-        # If all outputs 0, set to be uniform
-        reco_df[reco_df.sum(axis=1) == 0] = 1 # Could be any positive constant, 1 for simplicity
-        prescribed_total_df = reco_df.sum(axis=1)
-        prescribed_total_df = prescribed_total_df.replace(0, 1)
-        # Since we are no longer using softmax, do a linear scaling
-        reco_df = reco_df.div(prescribed_total_df, axis=0)
-
-        # Scale encoded_reco_df to context_df minus primf/primn
-        # Multiply proportions by sum of non primn/primf cols
-        reco_df = reco_df.mul(context_df[constants.RECO_COLS].sum(axis=1), axis=0)
-
-        # Compute the diff
-        # Note: the index need to match in order to subtract. Otherwise we get NaN
-        prescribed_actions_df = reco_df[constants.RECO_COLS] - context_df[constants.RECO_COLS].reset_index(drop=True)
-
-        # Rename the columns to match what the predictor expects
-        prescribed_actions_df = prescribed_actions_df.rename(constants.RECO_MAP, axis=1)
-        prescribed_actions_df[constants.NO_CHANGE_COLS] = 0
-
-        # Aggregate the context and actions dataframes.
-        context_actions_df = pd.concat([context_df,
-                                                prescribed_actions_df[constants.DIFF_LAND_USE_COLS]],
-                                                axis=1)
-
-        return context_actions_df
-
-    def evaluate_candidate(self, candidate):
-        """
-        Evaluates a single Prescriptor candidate and returns its metrics.
-        Implements the EspEvaluator interface
-        :param candidate: a Keras neural network or rule based Prescriptor candidate
-        :return metrics: A dictionary of {'metric_name': metric_value}
-        """
-        # Prescribe actions
-        # Single action, recommended percentage for each land use type
-        # Note: prescribed action is a softmax, NOT encoded in the same scale as the context
-        prescribed_actions_df = self.prescribe(candidate)
-
-        # Convert the softmax into a DataFrame
-        reco_land_use_df = pd.DataFrame(prescribed_actions_df["reco_land_use"].tolist(),
-                                columns=constants.RECO_COLS)
-
-        context_actions_df = self._reco_to_context_actions(reco_land_use_df, self.context_df)
-
-        # Compute the metrics
-        metrics = self._compute_metrics(context_actions_df)
-        return metrics
-
-    def _compute_metrics(self, context_actions_df):
-        """
-        Computes metrics from the passed context/actions DataFrame using the instance's trained predictors.
-        :param encoded_context_actions_df: a DataFrame of context / prescribed actions
-        :return: A dictionary of {'metric_name': metric_value}
-        """
-        metrics = {}
-
-        # Get the predicted ELUC from the predictors
-        preds = self.predict_eluc(context_actions_df)
-        metrics['ELUC'] = preds['ELUC'].mean()
-
-        # Compute the % of change
-        change_df = self.compute_percent_changed(context_actions_df)
-        metrics['change'] = change_df['change'].mean()
-
-        return metrics
-
-    def predict_eluc(self, context_actions_df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Predicts ELUC using the given predictor
-        """
-        predictor = self.predictors[0]
-        preds = predictor.predict(context_actions_df)
-        preds = preds.astype("float64")
-        return preds
-
-    def prescribe(self, candidate, context_df: pd.DataFrame = None) -> pd.DataFrame:
-        """
-        Generates prescriptions using the passed candidate and context
-        :param candidate: an ESP candidate, either neural network or rules
-        :param context_df: a DataFrame containing the context to prescribe for,
-         or None to use the instance one
-        :return: a DataFrame containing actions prescribed for each context
-        """
-        if context_df is None:
-            # No context is provided, use the instance's one
-            context_as_nn_input = self.context_as_nn_input
-            row_index = self.row_index
-        else:
-            # Convert the context DataFrame to something more suitable for neural networks
-            context_as_nn_input = self.convert_to_nn_input(context_df)
-            # Use the context's row index
-            row_index = context_df.index
-
-        # Temporarily removed, may come back if we do rule-based prescription
-        # is_rule_based = isinstance(candidate, RuleSet)
-        # if is_rule_based:
-        #     actions = self._prescribe_from_rules(candidate, context_as_nn_input)
-        # else:
-        #     actions = self._prescribe_from_nn(candidate, context_as_nn_input)
-        actions = self._prescribe_from_nn(candidate, context_as_nn_input)
-
-        # Convert the prescribed actions to a DataFrame
-        prescribed_actions_df = pd.DataFrame(actions,
-                                             columns=self.cao_mapping["actions"],
-                                             index=row_index)
-        return prescribed_actions_df
-
-    def _prescribe_from_nn(self, candidate, context_as_nn_input: List[np.ndarray]) -> Dict[str, Any]:
-        """
-        Generates prescriptions using the passed neural network candidate and context
-        :param candidate: a Keras neural network candidate
-        :param context_as_nn_input: a numpy array containing the context to prescribe for
-        :return: a dictionary of action name to action value or list of action values
-        """
-        # Get the prescribed actions
-        prescribed_actions = candidate.predict(context_as_nn_input)
-        actions = {}
-
-        if self._is_single_action_prescriptor():
-            # Put the single action in an array to process it like multiple actions
-            prescribed_actions = [prescribed_actions]
-
-        for idx, action_col in enumerate(self.cao_mapping["actions"]):
-            if self._is_scalar(prescribed_actions[idx]):
-                # We have a single row and this action is numerical. Convert it to a scalar.
-                actions[action_col] = prescribed_actions[idx].item()
-            else:
-                actions[action_col] = prescribed_actions[idx].tolist()
-        return actions
-
-    def _is_single_action_prescriptor(self):
-        """
-        Checks how many Actions have been defined in the Context, Actions, Outcomes mapping.
-        :return: True if only 1 action is defined, False otherwise
-        """
-        return len(self.cao_mapping["actions"]) == 1
-
-    @staticmethod
-    def _is_scalar(prescribed_action):
-        """
-        Checks if the prescribed action contains a single value, i.e. a scalar, or an array.
-        A prescribed action contains a single value if it has been prescribed for a single context sample
-        :param prescribed_action: a scalar or an array
-        :return: True if the prescribed action contains a scalar, False otherwise.
-        """
-        return prescribed_action.shape[0] == 1 and prescribed_action.shape[1] == 1
-
-    @staticmethod
-    def get_context_field_names(config: Dict[str, Any]) -> List[str]:
-        """
-        Returns the list of Context column names
-        :param config: the ESP experiment config dictionary
-        :return: the list of Context column names
-        """
-        nn_inputs = config["network"]["inputs"]
-        contexts = [nn_input["name"] for nn_input in nn_inputs]
-        return contexts
-
-    @staticmethod
-    def get_action_field_names(config: Dict[str, Any]) -> List[str]:
-        """
-        Returns the list of Action column names
-        :param config: the ESP experiment config dictionary
-        :return: the list of Action column names
-        """
-        nn_outputs = config["network"]["outputs"]
-        actions = [nn_output["name"] for nn_output in nn_outputs]
-        return actions
-
-    @staticmethod
-    def get_fitness_metrics(config: Dict[str, Any]) -> List[str]:
-        """
-        Returns the list of fitness metric names (Outcomes) to optimize.
-        :param config: the ESP experiment config dictionary
-        :return: the list of fitness metric names
-        """
-        metrics = config["evolution"]["fitness"]
-        fitness_metrics = [metric["metric_name"] for metric in metrics]
-        return fitness_metrics
-
-    def prescribe_land_use(self, context_df: pd.DataFrame, **kwargs) -> pd.DataFrame:
-        """
-        Implementation of prescribe_land_use.
-        Loads a candidate from disk using kwargs:
-            1. cand_id: str, a string in format <gen>_<id> that identifies the candidate to load.
-            2. results_dir: Path, the directory where the candidate is stored.
-        Then prescribes using the loaded candidate.
-        """
-        gen = int(kwargs["cand_id"].split('_')[0])
-        candidate_filename = kwargs["results_dir"] / f"{gen}" / f"{kwargs['cand_id']}.h5"
-        candidate = load_model(candidate_filename, compile=False)
-
-        encoded_context_df = self.data_encoder.encode_as_df(context_df)
-
-        reco_land_use = self.prescribe(candidate, encoded_context_df)
-        reco_df = pd.DataFrame(reco_land_use["reco_land_use"].tolist(), columns=constants.RECO_COLS)
-        context_actions_df = self._reco_to_context_actions(reco_df, encoded_context_df)
-
-        context_actions_df = context_actions_df.set_index(context_df.index)
-
-        return context_actions_df
-
-    def predict_metrics(self, context_actions_df: pd.DataFrame) -> tuple:
-        """
-        Predicts ELUC and computes change from the given context_actions_df.
-        """
-        eluc_df = self.predict_eluc(context_actions_df)
-        change_df = self.compute_percent_changed(context_actions_df)
-
-        return eluc_df, change_df

From 7acd0d2834f96add707a81f08cd87adc3a4f9e6e Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Fri, 31 May 2024 15:27:42 -0700
Subject: [PATCH 05/17] Implemented saving and loading for heuristics

---
 .../prescriptors/heuristics/heuristics.py     | 52 ++++++++++++++++---
 1 file changed, 45 insertions(+), 7 deletions(-)

diff --git a/use_cases/eluc/prescriptors/heuristics/heuristics.py b/use_cases/eluc/prescriptors/heuristics/heuristics.py
index a4e7ea5..3f8414e 100644
--- a/use_cases/eluc/prescriptors/heuristics/heuristics.py
+++ b/use_cases/eluc/prescriptors/heuristics/heuristics.py
@@ -2,21 +2,24 @@
 Heuristic to compare our prescriptors to.
 """
 from abc import ABC, abstractmethod
+import json
+from pathlib import Path
 
 import pandas as pd
 
 from data import constants
-from predictors.predictor import Predictor
 from prescriptors.prescriptor import Prescriptor
 
 class HeuristicPrescriptor(Prescriptor, ABC):
     """
     Abstract heuristic prescriptor class that inherits from prescriptor class.
     Has a percentage threshold that the heuristic is to reach but not exceed.
-    Also takes a predictor so that we can evaluate metrics.
     Requires an implementation of reco_heuristic which takes a context dataframe and returns
     recommendations based on the heuristic.
     """
+    def __init__(self, pct: float):
+        self.pct = pct
+
     @abstractmethod
     def _reco_heuristic(self, pct: float, context_df: pd.DataFrame) -> pd.DataFrame:
         """
@@ -25,12 +28,11 @@ def _reco_heuristic(self, pct: float, context_df: pd.DataFrame) -> pd.DataFrame:
         """
         raise NotImplementedError
 
-    def prescribe(self, context_df: pd.DataFrame, **kwargs) -> pd.DataFrame:
+    def prescribe(self, context_df: pd.DataFrame) -> pd.DataFrame:
         """
         Implementation of prescribe_land_use using a heuristic. Calls the implementation of _reco_heuristic.
-        Kwargs must contain a "pct" key that is the percentage of land-use change to prescribe up to.
         """
-        reco_df = self._reco_heuristic(kwargs["pct"], context_df)
+        reco_df = self._reco_heuristic(self.pct, context_df)
         prescribed_actions_df = reco_df[constants.RECO_COLS] - context_df[constants.RECO_COLS]
 
         # Rename the columns to match what the predictor expects
@@ -45,7 +47,8 @@ class EvenHeuristic(HeuristicPrescriptor):
     """
     Implementation of HeuristicPrescriptor that evenly distributes land use to a "best" column.
     """
-    def __init__(self, best_col: str):
+    def __init__(self, pct: float, best_col: str):
+        super().__init__(pct)
         self.best_col = best_col
         self.presc_cols = [col for col in constants.RECO_COLS if col != best_col]
 
@@ -70,18 +73,37 @@ def _reco_heuristic(self, pct: float, context_df: pd.DataFrame):
         adjusted.loc[to_change, self.best_col] = adjusted.loc[to_change, self.best_col] + max_change
         adjusted = adjusted.drop(["scaled_change", "row_sum", "max_change"], axis=1)
         return adjusted
+    
+    def save(self, path: Path):
+        """
+        Saves best column and percentage.
+        """
+        with open(path / "config.json", "w", encoding="utf-8") as file:
+            json.dump({"pct": self.pct, "best_col": self.best_col}, file)
+
+    @classmethod
+    def load(cls, path: Path) -> "EvenHeuristic":
+        """
+        Loads best column and percentage.
+        """
+        with open(path / "config.json", "r", encoding="utf-8") as file:
+            config = json.load(file)
+        return cls(config["pct"], config["best_col"])
 
 class PerfectHeuristic(HeuristicPrescriptor):
     """
     Implementation of HeuristicPrescriptor that does an informed land use prescription 
     based on linear regression coefficients.
     """
-    def __init__(self, coefs: list[float]):
+    def __init__(self, pct:float, coefs: list[float]):
         """
         We save and sort the columns by highest coefficient i.e. most emissions.
         Separate the best column according to the coefficients to add to.
         """
+        super().__init__(pct)
         assert len(coefs) == len(constants.RECO_COLS)
+        # Keep these so we can save them later
+        self.coefs = coefs
         # Sort columns by coefficient
         reco_cols = list(constants.RECO_COLS)
         zipped = zip(reco_cols, coefs)
@@ -114,3 +136,19 @@ def _reco_heuristic(self, pct: float, context_df: pd.DataFrame) -> pd.DataFrame:
         adjusted[self.best_col] += adjusted[["scaled_change", "presc_sum"]].min(axis=1)
         adjusted = adjusted.drop(["scaled_change", "presc_sum", "amt_change"], axis=1)
         return adjusted
+    
+    def save(self, path: Path):
+        """
+        Saves coefficients and percentage.
+        """
+        with open(path / "config.json", "w", encoding="utf-8") as file:
+            json.dump({"pct": self.pct, "coefs": self.coefs}, file)
+
+    @classmethod
+    def load(cls, path: Path) -> "PerfectHeuristic":
+        """
+        Loads coefficients and percentage.
+        """
+        with open(path / "config.json", "r", encoding="utf-8") as file:
+            config = json.load(file)
+        return cls(config["pct"], config["coefs"])

From 1e5c73b01b7397d6e46e5cefa9091230a6fed5c1 Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Fri, 31 May 2024 15:44:30 -0700
Subject: [PATCH 06/17] ignore esp files

---
 use_cases/eluc/.gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/use_cases/eluc/.gitignore b/use_cases/eluc/.gitignore
index 494954c..ad3557e 100644
--- a/use_cases/eluc/.gitignore
+++ b/use_cases/eluc/.gitignore
@@ -7,6 +7,7 @@ experiments/predictor_significance
 # Ignores figures for paper
 experiments/figures
 
+prescriptors/esp
 # Ignores trained prescriptors and seeds
 prescriptors/*/trained_prescriptors
 prescriptors/*/seeds
@@ -15,3 +16,4 @@ prescriptors/nsga2/transfer_prescriptors.ipynb
 data/*.zip
 data/processed/*.csv
 *.nc
+

From 8bc07d018196e55252c2e24b9967e7a7fa823f61 Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Fri, 31 May 2024 15:45:11 -0700
Subject: [PATCH 07/17] Updated experiments to work with new prescriptor
 architecture

---
 .../experiments/prescriptor_experiments.ipynb | 3685 ++---------------
 .../eluc/prescriptors/nsga2/candidate.py      |    8 +-
 .../nsga2/land_use_prescriptor.py             |    3 +-
 use_cases/eluc/prescriptors/prescriptor.py    |    2 +-
 4 files changed, 315 insertions(+), 3383 deletions(-)

diff --git a/use_cases/eluc/experiments/prescriptor_experiments.ipynb b/use_cases/eluc/experiments/prescriptor_experiments.ipynb
index 8e49cc9..bd4c33b 100644
--- a/use_cases/eluc/experiments/prescriptor_experiments.ipynb
+++ b/use_cases/eluc/experiments/prescriptor_experiments.ipynb
@@ -10,14 +10,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import json\n",
     "import os\n",
     "from pathlib import Path\n",
     "\n",
+    "import torch\n",
     "from tqdm import tqdm\n",
     "import pandas as pd\n",
     "import matplotlib.pyplot as plt\n",
@@ -26,16 +26,16 @@
     "\n",
     "from data import constants\n",
     "from data.eluc_data import ELUCData\n",
-    "from prescriptors.prescriptor import Prescriptor\n",
-    "from prescriptors.nsga2.torch_prescriptor import TorchPrescriptor\n",
-    "from prescriptors.esp.unileaf_prescriptor import UnileafPrescriptor\n",
+    "from prescriptors.nsga2.candidate import Candidate\n",
+    "from prescriptors.nsga2.land_use_prescriptor import LandUsePrescriptor\n",
+    "from prescriptors.nsga2.prescriptor_manager import PrescriptorManager\n",
     "from prescriptors.heuristics.heuristics import EvenHeuristic, PerfectHeuristic\n",
     "from predictors.neural_network.neural_net_predictor import NeuralNetPredictor"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -51,19 +51,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
     "TOTAL_GENS = 100\n",
     "\n",
-    "esp_results_dir = Path(\"prescriptors/esp/trained_prescriptors/no-overlap/seeded\")\n",
-    "torch_results_dir = Path(\"prescriptors/nsga2/trained_prescriptors/full\")"
+    "results_dir = Path(\"prescriptors/nsga2/trained_prescriptors/full\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -78,12 +77,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
-    "esp_pareto_df = create_pareto_df(100, esp_results_dir)\n",
-    "torch_pareto_df = create_pareto_df(100, torch_results_dir)"
+    "pareto_df = create_pareto_df(100, results_dir)"
    ]
   },
   {
@@ -95,11 +93,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
-    "figure_dir = Path(\"experiments/figures/no-overlap\")\n",
+    "figure_dir = Path(\"experiments/figures/test\")\n",
     "figure_dir.mkdir(parents=True, exist_ok=True)"
    ]
   },
@@ -112,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -210,3280 +208,274 @@
     "    plt.grid() \n",
     "    # handles, labels = plt.gca().get_legend_handles_labels()\n",
     "    # order = [0, 1, 2, 4, 3]\n",
-    "    # plt.legend([handles[idx] for idx in order], [curve_names[idx] for idx in order], loc=\"upper right\")\n",
-    "    plt.legend(prop={'size': 9})\n",
-    "    #plt.title(\"Pareto Fronts Across Generations\")\n",
-    "    if save_path:\n",
-    "        plt.savefig(save_path, format=\"png\", dpi=300)\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "gens_to_plot = [1, 3, 10, 25, 100]\n",
-    "plot_gens(esp_results_dir, gens_to_plot, save_path=None)\n",
-    "plot_gens(torch_results_dir, gens_to_plot, save_path=None)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_gen_df(gen: int, results_dir: Path):\n",
-    "    gen_filename = results_dir / f\"{gen}.csv\"\n",
-    "    gen_df = pd.read_csv(gen_filename)\n",
-    "    # Sort by first objective, maximize: lowest to highest, minimize: highest to lowest\n",
-    "    gen_df = gen_df.sort_values(by='change', ascending=True)\n",
-    "    gen_df[\"Name\"] = f\"Gen {gen}\"\n",
-    "    return gen_df\n",
-    "\n",
-    "def get_all_gens_df(gens: list, results_dir: Path):\n",
-    "    dfs = []\n",
-    "    for gen in gens:\n",
-    "        dfs.append(get_gen_df(gen, results_dir))\n",
-    "    merged_df = pd.concat(dfs, ignore_index=True)\n",
-    "    return merged_df"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_all_gens(gens: list, results_dir: Path, save_path=None):\n",
-    "    all_gens_df = get_all_gens_df(gens, results_dir)\n",
-    "    fig, ax = plt.subplots()\n",
-    "\n",
-    "    all_gens_df.plot.scatter(x='change',\n",
-    "                             y='ELUC',\n",
-    "                             ax=ax,\n",
-    "                             label=\"All prescriptors evaluated\")\n",
-    "    # Plot last gen's pareto front in red\n",
-    "    \n",
-    "    #get_pareto_df(dir, gens[-1]).plot.scatter(x='change', y='ELUC', c='red', ax=ax, label=\"Gen 100 Pareto Front\")\n",
-    "    overall_pareto = get_overall_pareto_df(gens[-1], results_dir)\n",
-    "    overall_pareto.plot.scatter(x='change', y='ELUC', c='red', ax=ax, label=\"Final Pareto Front\")\n",
-    "    plt.grid()\n",
-    "    #plt.title(\"All Generations All Prescriptor Performance\")\n",
-    "    plt.legend(loc=\"upper left\")\n",
-    "    if save_path:\n",
-    "        plt.savefig(save_path, format=\"png\", dpi=300) \n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "all_gens = [a + 1 for a in range(100)]\n",
-    "plot_all_gens(all_gens, esp_results_dir, save_path=None)\n",
-    "plot_all_gens(all_gens, torch_results_dir, save_path=None)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "esp_all_pareto_df = get_overall_pareto_df(100, esp_results_dir)\n",
-    "torch_all_pareto_df = get_overall_pareto_df(100, torch_results_dir)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Comparison with Heuristic"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "nnp = NeuralNetPredictor.from_pretrained(\"predictors/neural_network/trained_models/no_overlap_nn\")\n",
-    "presc_config = None\n",
-    "with open(\"prescriptors/esp/unileaf_configs/config-loctime-crop-nosoft.json\") as f:\n",
-    "    presc_config = json.load(f)\n",
-    "unileaf_prescriptor = UnileafPrescriptor(presc_config,\n",
-    "                                   dataset.train_df.iloc[:1],\n",
-    "                                   dataset.encoder,\n",
-    "                                   [nnp])\n",
-    "\n",
-    "candidate_params = {\"in_size\": len(constants.CAO_MAPPING[\"context\"]), \"hidden_size\": 16, \"out_size\": len(constants.RECO_COLS)}\n",
-    "torch_prescriptor = TorchPrescriptor(\n",
-    "                               None, \n",
-    "                               dataset.encoder, \n",
-    "                               nnp, \n",
-    "                               4096, \n",
-    "                               candidate_params)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "even_heuristic = EvenHeuristic(\"secdf\", nnp)\n",
-    "\n",
-    "linreg = LinearRegression()\n",
-    "linreg.fit(dataset.train_df[constants.DIFF_LAND_USE_COLS], dataset.train_df[\"ELUC\"])\n",
-    "coefs = linreg.coef_\n",
-    "coef_dict = dict(zip(constants.LAND_USE_COLS, coefs))\n",
-    "reco_coefs = []\n",
-    "for col in constants.RECO_COLS:\n",
-    "    reco_coefs.append(coef_dict[col])\n",
-    "\n",
-    "perfect_heuristic = PerfectHeuristic(reco_coefs, nnp)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_df = dataset.test_df.sample(frac=0.01, random_state=100)\n",
-    "encoded_test_df = dataset.encoder.encode_as_df(test_df)\n",
-    "\n",
-    "context_df = test_df[constants.CAO_MAPPING[\"context\"]]\n",
-    "encoded_context_df = encoded_test_df[constants.CAO_MAPPING[\"context\"]]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Trained Prescriptors"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def evaluate_prescriptor(context_df: pd.DataFrame, prescriptor: Prescriptor, **kwargs):\n",
-    "    context_actions_df = prescriptor.prescribe_land_use(context_df, **kwargs)\n",
-    "    eluc_df, change_df = prescriptor.predict_metrics(context_actions_df)\n",
-    "    return eluc_df[\"ELUC\"].mean(), change_df[\"change\"].mean()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|          | 0/213 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Metal device set to: Apple M1 Pro\n",
-      "\n",
-      "systemMemory: 16.00 GB\n",
-      "maxCacheSize: 5.33 GB\n",
-      "\n",
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|          | 1/213 [00:04<15:23,  4.36s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  1%|          | 2/213 [00:07<13:34,  3.86s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  1%|▏         | 3/213 [00:11<12:25,  3.55s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  2%|▏         | 4/213 [00:14<12:17,  3.53s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  2%|▏         | 5/213 [00:17<11:49,  3.41s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  3%|▎         | 6/213 [00:20<11:29,  3.33s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  3%|▎         | 7/213 [00:24<11:15,  3.28s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  4%|▍         | 8/213 [00:27<11:27,  3.35s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  4%|▍         | 9/213 [00:30<11:13,  3.30s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  5%|▍         | 10/213 [00:33<11:02,  3.26s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  5%|▌         | 11/213 [00:37<10:53,  3.23s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  6%|▌         | 12/213 [00:40<11:09,  3.33s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  6%|▌         | 13/213 [00:43<10:59,  3.30s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  7%|▋         | 14/213 [00:47<10:47,  3.25s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  7%|▋         | 15/213 [00:50<10:40,  3.23s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  8%|▊         | 16/213 [00:53<10:50,  3.30s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  8%|▊         | 17/213 [00:56<10:42,  3.28s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  8%|▊         | 18/213 [01:00<10:33,  3.25s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  9%|▉         | 19/213 [01:03<10:25,  3.23s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  9%|▉         | 20/213 [01:06<10:41,  3.32s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 10%|▉         | 21/213 [01:10<10:32,  3.29s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 10%|█         | 22/213 [01:13<10:23,  3.27s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 11%|█         | 23/213 [01:16<10:14,  3.23s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 11%|█▏        | 24/213 [01:19<10:28,  3.33s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 12%|█▏        | 25/213 [01:23<10:20,  3.30s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 12%|█▏        | 26/213 [01:26<10:12,  3.28s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 13%|█▎        | 27/213 [01:29<10:04,  3.25s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 13%|█▎        | 28/213 [01:33<10:15,  3.33s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 14%|█▎        | 29/213 [01:36<10:08,  3.30s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 14%|█▍        | 30/213 [01:39<09:58,  3.27s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 15%|█▍        | 31/213 [01:42<09:51,  3.25s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 15%|█▌        | 32/213 [01:46<09:59,  3.31s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 15%|█▌        | 33/213 [01:49<09:52,  3.29s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 16%|█▌        | 34/213 [01:52<09:43,  3.26s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 16%|█▋        | 35/213 [01:55<09:36,  3.24s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 17%|█▋        | 36/213 [01:59<09:48,  3.32s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 17%|█▋        | 37/213 [02:02<09:40,  3.30s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 18%|█▊        | 38/213 [02:05<09:32,  3.27s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 18%|█▊        | 39/213 [02:08<09:24,  3.25s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 19%|█▉        | 40/213 [02:12<09:36,  3.33s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 19%|█▉        | 41/213 [02:15<09:30,  3.32s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 20%|█▉        | 42/213 [02:19<09:21,  3.28s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 20%|██        | 43/213 [02:22<09:14,  3.26s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 21%|██        | 44/213 [02:25<09:22,  3.33s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 21%|██        | 45/213 [02:29<09:26,  3.37s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 22%|██▏       | 46/213 [02:32<09:37,  3.46s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 22%|██▏       | 47/213 [02:36<09:36,  3.47s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 23%|██▎       | 48/213 [02:40<09:47,  3.56s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 23%|██▎       | 49/213 [02:43<09:40,  3.54s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 23%|██▎       | 50/213 [02:47<09:32,  3.51s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 24%|██▍       | 51/213 [02:50<09:27,  3.50s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 24%|██▍       | 52/213 [02:54<09:39,  3.60s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 25%|██▍       | 53/213 [02:57<09:30,  3.56s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 25%|██▌       | 54/213 [03:01<09:25,  3.55s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 26%|██▌       | 55/213 [03:04<09:16,  3.52s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 26%|██▋       | 56/213 [03:08<09:28,  3.62s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 27%|██▋       | 57/213 [03:12<09:20,  3.59s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 27%|██▋       | 58/213 [03:15<09:10,  3.55s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 28%|██▊       | 59/213 [03:19<08:58,  3.50s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 28%|██▊       | 60/213 [03:22<09:10,  3.60s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 29%|██▊       | 61/213 [03:26<09:16,  3.66s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 29%|██▉       | 62/213 [03:30<09:01,  3.59s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 30%|██▉       | 63/213 [03:33<08:42,  3.48s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 30%|███       | 64/213 [03:36<08:44,  3.52s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 31%|███       | 65/213 [03:40<08:36,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 31%|███       | 66/213 [03:43<08:26,  3.45s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 31%|███▏      | 67/213 [03:46<08:16,  3.40s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 32%|███▏      | 68/213 [03:50<08:21,  3.46s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 32%|███▏      | 69/213 [03:53<08:12,  3.42s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 33%|███▎      | 70/213 [03:57<08:07,  3.41s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 33%|███▎      | 71/213 [04:00<08:02,  3.40s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 34%|███▍      | 72/213 [04:04<08:11,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 34%|███▍      | 73/213 [04:08<08:19,  3.57s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 35%|███▍      | 74/213 [04:11<08:15,  3.56s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 35%|███▌      | 75/213 [04:14<08:00,  3.48s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 36%|███▌      | 76/213 [04:18<08:08,  3.56s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 36%|███▌      | 77/213 [04:22<08:13,  3.63s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 37%|███▋      | 78/213 [04:25<08:01,  3.57s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 37%|███▋      | 79/213 [04:29<07:49,  3.50s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 38%|███▊      | 80/213 [04:32<07:45,  3.50s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 38%|███▊      | 81/213 [04:36<07:35,  3.45s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 38%|███▊      | 82/213 [04:39<07:26,  3.40s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 39%|███▉      | 83/213 [04:42<07:16,  3.35s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 39%|███▉      | 84/213 [04:46<07:20,  3.41s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 40%|███▉      | 85/213 [04:49<07:12,  3.38s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 40%|████      | 86/213 [04:52<07:05,  3.35s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 41%|████      | 87/213 [04:56<06:58,  3.32s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 41%|████▏     | 88/213 [04:59<07:06,  3.41s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 42%|████▏     | 89/213 [05:02<06:59,  3.39s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 42%|████▏     | 90/213 [05:06<06:51,  3.35s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 43%|████▎     | 91/213 [05:09<06:46,  3.33s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 43%|████▎     | 92/213 [05:13<06:51,  3.40s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 44%|████▎     | 93/213 [05:16<06:44,  3.37s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 44%|████▍     | 94/213 [05:19<06:37,  3.34s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 45%|████▍     | 95/213 [05:22<06:31,  3.31s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 45%|████▌     | 96/213 [05:26<06:42,  3.44s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 46%|████▌     | 97/213 [05:30<06:38,  3.44s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 46%|████▌     | 98/213 [05:33<06:39,  3.48s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 46%|████▋     | 99/213 [05:36<06:31,  3.43s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 47%|████▋     | 100/213 [05:40<06:45,  3.59s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 47%|████▋     | 101/213 [05:44<06:34,  3.52s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 48%|████▊     | 102/213 [05:47<06:21,  3.43s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 48%|████▊     | 103/213 [05:50<06:12,  3.38s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 49%|████▉     | 104/213 [05:54<06:15,  3.45s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 49%|████▉     | 105/213 [05:57<06:12,  3.45s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 50%|████▉     | 106/213 [06:01<06:14,  3.50s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 50%|█████     | 107/213 [06:05<06:22,  3.61s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 51%|█████     | 108/213 [06:08<06:19,  3.61s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 51%|█████     | 109/213 [06:12<06:07,  3.53s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 52%|█████▏    | 110/213 [06:15<05:55,  3.45s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 52%|█████▏    | 111/213 [06:18<05:46,  3.39s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 53%|█████▎    | 112/213 [06:22<05:49,  3.46s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 53%|█████▎    | 113/213 [06:25<05:41,  3.42s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 54%|█████▎    | 114/213 [06:29<05:34,  3.38s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 54%|█████▍    | 115/213 [06:32<05:27,  3.35s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 54%|█████▍    | 116/213 [06:35<05:30,  3.40s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 55%|█████▍    | 117/213 [06:39<05:25,  3.39s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 55%|█████▌    | 118/213 [06:42<05:18,  3.35s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 56%|█████▌    | 119/213 [06:45<05:14,  3.35s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 56%|█████▋    | 120/213 [06:49<05:22,  3.47s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 57%|█████▋    | 121/213 [06:53<05:21,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 57%|█████▋    | 122/213 [06:56<05:18,  3.50s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 58%|█████▊    | 123/213 [07:00<05:14,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 58%|█████▊    | 124/213 [07:04<05:22,  3.63s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 59%|█████▊    | 125/213 [07:07<05:19,  3.64s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 59%|█████▉    | 126/213 [07:11<05:18,  3.66s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 60%|█████▉    | 127/213 [07:15<05:16,  3.68s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 60%|██████    | 128/213 [07:19<05:20,  3.77s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 61%|██████    | 129/213 [07:22<05:06,  3.65s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 61%|██████    | 130/213 [07:25<04:53,  3.54s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 62%|██████▏   | 131/213 [07:29<05:01,  3.68s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 62%|██████▏   | 132/213 [07:33<05:08,  3.81s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 62%|██████▏   | 133/213 [07:37<04:53,  3.66s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 63%|██████▎   | 134/213 [07:40<04:40,  3.55s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 63%|██████▎   | 135/213 [07:43<04:30,  3.47s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 64%|██████▍   | 136/213 [07:47<04:31,  3.53s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 64%|██████▍   | 137/213 [07:50<04:23,  3.47s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 65%|██████▍   | 138/213 [07:54<04:23,  3.51s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 65%|██████▌   | 139/213 [07:57<04:17,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 66%|██████▌   | 140/213 [08:01<04:20,  3.57s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 66%|██████▌   | 141/213 [08:05<04:17,  3.57s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 67%|██████▋   | 142/213 [08:08<04:13,  3.57s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 67%|██████▋   | 143/213 [08:12<04:08,  3.55s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 68%|██████▊   | 144/213 [08:16<04:16,  3.71s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 68%|██████▊   | 145/213 [08:19<04:11,  3.71s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 69%|██████▊   | 146/213 [08:23<04:09,  3.72s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 69%|██████▉   | 147/213 [08:27<04:02,  3.67s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 69%|██████▉   | 148/213 [08:30<03:59,  3.68s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 70%|██████▉   | 149/213 [08:34<03:54,  3.67s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 70%|███████   | 150/213 [08:38<03:55,  3.73s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 71%|███████   | 151/213 [08:41<03:45,  3.63s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 71%|███████▏  | 152/213 [08:45<03:43,  3.66s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 72%|███████▏  | 153/213 [08:48<03:34,  3.57s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 72%|███████▏  | 154/213 [08:52<03:25,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 73%|███████▎  | 155/213 [08:55<03:18,  3.43s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 73%|███████▎  | 156/213 [08:59<03:18,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 74%|███████▎  | 157/213 [09:02<03:13,  3.45s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 74%|███████▍  | 158/213 [09:05<03:08,  3.44s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 75%|███████▍  | 159/213 [09:09<03:03,  3.39s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 75%|███████▌  | 160/213 [09:12<03:03,  3.47s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 76%|███████▌  | 161/213 [09:16<02:58,  3.44s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 76%|███████▌  | 162/213 [09:19<02:54,  3.41s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 77%|███████▋  | 163/213 [09:22<02:49,  3.38s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 77%|███████▋  | 164/213 [09:26<02:48,  3.44s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 77%|███████▋  | 165/213 [09:29<02:44,  3.42s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 78%|███████▊  | 166/213 [09:33<02:39,  3.39s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 78%|███████▊  | 167/213 [09:36<02:35,  3.38s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 79%|███████▉  | 168/213 [09:40<02:34,  3.44s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 79%|███████▉  | 169/213 [09:43<02:35,  3.54s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 80%|███████▉  | 170/213 [09:47<02:32,  3.55s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 80%|████████  | 171/213 [09:50<02:26,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 81%|████████  | 172/213 [09:54<02:28,  3.61s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 81%|████████  | 173/213 [09:58<02:24,  3.62s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 82%|████████▏ | 174/213 [10:01<02:18,  3.56s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 82%|████████▏ | 175/213 [10:05<02:14,  3.53s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 83%|████████▎ | 176/213 [10:09<02:13,  3.60s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 83%|████████▎ | 177/213 [10:12<02:08,  3.56s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 84%|████████▎ | 178/213 [10:15<02:03,  3.52s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 84%|████████▍ | 179/213 [10:19<01:58,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 85%|████████▍ | 180/213 [10:23<01:58,  3.58s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 85%|████████▍ | 181/213 [10:26<01:53,  3.56s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 85%|████████▌ | 182/213 [10:30<01:48,  3.51s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 86%|████████▌ | 183/213 [10:33<01:43,  3.47s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 86%|████████▋ | 184/213 [10:37<01:42,  3.52s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 87%|████████▋ | 185/213 [10:40<01:37,  3.48s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 87%|████████▋ | 186/213 [10:43<01:33,  3.45s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 88%|████████▊ | 187/213 [10:47<01:28,  3.42s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 88%|████████▊ | 188/213 [10:50<01:27,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 89%|████████▊ | 189/213 [10:54<01:23,  3.47s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 89%|████████▉ | 190/213 [10:57<01:19,  3.46s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 90%|████████▉ | 191/213 [11:01<01:15,  3.43s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 90%|█████████ | 192/213 [11:04<01:14,  3.52s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 91%|█████████ | 193/213 [11:08<01:10,  3.51s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 91%|█████████ | 194/213 [11:11<01:06,  3.48s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 92%|█████████▏| 195/213 [11:14<01:01,  3.44s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 92%|█████████▏| 196/213 [11:18<01:00,  3.53s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 92%|█████████▏| 197/213 [11:22<00:56,  3.51s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 93%|█████████▎| 198/213 [11:25<00:52,  3.48s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 93%|█████████▎| 199/213 [11:28<00:48,  3.45s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 94%|█████████▍| 200/213 [11:32<00:45,  3.51s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 94%|█████████▍| 201/213 [11:36<00:42,  3.51s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 95%|█████████▍| 202/213 [11:39<00:38,  3.47s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 95%|█████████▌| 203/213 [11:42<00:34,  3.45s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 96%|█████████▌| 204/213 [11:46<00:31,  3.52s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 96%|█████████▌| 205/213 [11:50<00:28,  3.50s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 97%|█████████▋| 206/213 [11:53<00:24,  3.47s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 97%|█████████▋| 207/213 [11:56<00:20,  3.44s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 98%|█████████▊| 208/213 [12:00<00:17,  3.53s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 98%|█████████▊| 209/213 [12:04<00:14,  3.51s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 99%|█████████▊| 210/213 [12:07<00:10,  3.49s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 99%|█████████▉| 211/213 [12:10<00:06,  3.45s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 3ms/step\n"
-     ]
-    },
+    "    # plt.legend([handles[idx] for idx in order], [curve_names[idx] for idx in order], loc=\"upper right\")\n",
+    "    plt.legend(prop={'size': 9})\n",
+    "    #plt.title(\"Pareto Fronts Across Generations\")\n",
+    "    if save_path:\n",
+    "        plt.savefig(save_path, format=\"png\", dpi=300)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|█████████▉| 212/213 [12:14<00:03,  3.51s/it]"
-     ]
-    },
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "gens_to_plot = [1, 3, 10, 25, 100]\n",
+    "plot_gens(results_dir, gens_to_plot, save_path=None)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_gen_df(gen: int, results_dir: Path):\n",
+    "    gen_filename = results_dir / f\"{gen}.csv\"\n",
+    "    gen_df = pd.read_csv(gen_filename)\n",
+    "    # Sort by first objective, maximize: lowest to highest, minimize: highest to lowest\n",
+    "    gen_df = gen_df.sort_values(by='change', ascending=True)\n",
+    "    gen_df[\"Name\"] = f\"Gen {gen}\"\n",
+    "    return gen_df\n",
+    "\n",
+    "def get_all_gens_df(gens: list, results_dir: Path):\n",
+    "    dfs = []\n",
+    "    for gen in gens:\n",
+    "        dfs.append(get_gen_df(gen, results_dir))\n",
+    "    merged_df = pd.concat(dfs, ignore_index=True)\n",
+    "    return merged_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_all_gens(gens: list, results_dir: Path, save_path=None):\n",
+    "    all_gens_df = get_all_gens_df(gens, results_dir)\n",
+    "    fig, ax = plt.subplots()\n",
+    "\n",
+    "    all_gens_df.plot.scatter(x='change',\n",
+    "                             y='ELUC',\n",
+    "                             ax=ax,\n",
+    "                             label=\"All prescriptors evaluated\")\n",
+    "    # Plot last gen's pareto front in red\n",
+    "    \n",
+    "    #get_pareto_df(dir, gens[-1]).plot.scatter(x='change', y='ELUC', c='red', ax=ax, label=\"Gen 100 Pareto Front\")\n",
+    "    overall_pareto = get_overall_pareto_df(gens[-1], results_dir)\n",
+    "    overall_pareto.plot.scatter(x='change', y='ELUC', c='red', ax=ax, label=\"Final Pareto Front\")\n",
+    "    plt.grid()\n",
+    "    #plt.title(\"All Generations All Prescriptor Performance\")\n",
+    "    plt.legend(loc=\"upper left\")\n",
+    "    if save_path:\n",
+    "        plt.savefig(save_path, format=\"png\", dpi=300) \n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    },
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEGCAYAAACdJRn3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABsdElEQVR4nO2dd3hUVfr4P2cmkx4CBAhdQHpLpIkiLEEpCgLWtbDo72vBdVFsiG3tawEV666orIroouIuVQQEIkVUAoZiaBGCCSVAgJBAypTz+2Myw5R7p6VNwvk8T57MnNveuZmc9563CiklCoVCoVAEg6G2BVAoFApF3UMpD4VCoVAEjVIeCoVCoQgapTwUCoVCETRKeSgUCoUiaCJqW4CqoEmTJrJdu3YB7XvmzBni4uKqV6BqQMldsyi5axYld83ikHvz5s3HpZRNQzqJlLLO//Tt21cGypo1awLeN5xQctcsSu6aRcldszjkBjJkiPOuMlspFAqFImiU8lAoFApF0CjloVAoFIqgqRcOcy3MZjN5eXmUlpa6jScmJrJz585akip0lNw1S1XLHR0dTevWrTGZTFV2ToWiNqm3yiMvL4+EhATatWuHEMI5XlRUREJCQi1KFhpK7pqlKuWWUlJQUEBeXh7t27evknMqFLVNrZmthBBthBBrhBBZQojfhBBTKsYbCyFWCiH2VvxuFMr5S0tLSUpKclMcCkVtIIQgKSnJaxWsqF0KisvYmnuKguKy2halTlKbKw8L8LCUcosQIgHYLIRYCdwOrJJSviKEeAx4DJgWygWU4lCEC+q7GF4szDzItG+2YTIYMNtsTL+uN2NTW9W2WHWKWlt5SCkPSym3VLwuAnYCrYBxwKcVu30KjK8VARUKRb2koLiMad9so9Rso6jMQqnZxqPfbFMrkCARMgz6eQgh2gFrgZ7AH1LKhhXjAjjpeO9xzN3A3QDJycl9582b57Y9MTGRjh07el3LarViNBqr9gP4YMmSJdxyyy1kZGTQuXNnAA4cOMCNN97Izz//zLp163j77bf5+uuvfZ6nJuU+fPgwjz76KJ999pnuPqdOneLrr7/mrrvu8nmumr7frrz00kvEx8dz//33B33s/v372bRpEzfeeGNQx91zzz2MGjWK8ePHe23Lzs6msLAwaFmCobi4mPj4+Gq9RnVQk3KXmK3sP3YGq8vcZxSC9k3jiDEF912t6/c7LS1ts5SyXyjnqHWHuRAiHvgGeEBKedp1eS+llEIITe0mpfwA+ACgX79+cujQoW7bd+7cqenwrGkH7oIFC7jssstYtGgRzz33HADx8fEYDAYSEhKIjY0lIiLCr0xacjszPQ1Vt4C0WCx07tyZBQsW+NyvoKCAf//73zz00EM+93OV22KxEBFRc1+5qKgooqKiQvp75+Xl8b///Y877rgjqONMJhMxMTGa14yOjuaiiy4KWpZgSE9Px/N/oS5Qk3IXFJfx4KurKTXbnGPRJgMbxl5GUnxUUOc6n+93reZ5CCFM2BXH51LK/1YM5wshWlRsbwEcrSl5qtqBVlxczPr165k9ezaeKyN/fPLJJ4wbN46hQ4fSqVMnXn75ZQBycnLo0qULEydOpGfPnuTm5jJjxgz69+9P7969eeaZZwB77ZrRo0eTkpJCz549+fLLLwHYtGkTl156KSkpKQwYMICioiI++eQTxo4dy7Bhw7j88svJycmhZ8+emnI4FOBjjz3G77//TmpqKlOnTkVKydSpU+nZsye9evVyXm/dunUMHjyYsWPH0r17d125XPn9998ZNWoUffv2ZfDgwezatYvCwkIuuOACbDab8/O1adMGs9nMhx9+SP/+/UlJSeG6667j7NmzXuccOnQoGRkZABw/fhxHLbScnBwGDx5Mnz596NOnDz/++CMAzzzzDOvWrSM1NZWZM2ditVqZOnWq8z7PmjULsCvwyZMn06VLF6644gqOHq2xr6siRJLio5h+XW+iTQYSoiKINhmYfl3voBXH+U6trTwqTFKzgZ1SyjdcNi0CbgNeqfi9sCbkqQ4H2sKFCxk1ahSdO3cmKSmJzZs307dv34CP/+WXX9ixYwexsbH07duXa6+9liZNmrB3714+/fRTBg4cyIoVK9i7dy+//PILUkrGjh3L2rVrOXbsGC1btmTp0qUAFBYWUl5ezp///Ge+/PJL+vfvz+nTp4mJiQFgy5YtbNu2jcaNG5OTk6MrR//+/Rk9ejSvvPIKO3bsIDMzE4BvvvmGzMxMtm7dyvHjx+nfvz9DhgxxnnvHjh20b9+eb775xksuT+6++27ef/99OnXqxM8//8y9997L6tWrSU1N5YcffiAtLY0lS5YwcuRITCYT1157rdN89tRTTzF79mzuu+++gO5xs2bNWLlyJdHR0ezdu5ebb76ZjIwMnnvuOf75z3+yZMkSAD744AMSExPZtGkTZWVlDBo0iBEjRvDrr7+ye/dusrKyyM/Pp3v37vzf//1fwH9jRe0wNrUVgzo2Ie9kCa0bxSjFEQK1ufIYBPwFGCaEyKz4uQq70hguhNgLXFHxvlqpLgfaf/7zH2666SYAbrrpJv7zn/8Edfzw4cNJSkoiJiaGq6++mvXr1wNwwQUXMHDgQABWrFjBihUruOiii+jTpw+7du1i79699OrVi5UrVzJt2jTWrVtHYmIiu3fvpkWLFvTv3x+ABg0aOM1Iw4cPp3Hjxn7luPbaa51yuLJ+/XpuvvlmjEYjycnJ/OlPf2LTpk0ADBgwwJnfoCWXK8XFxfz444/ccMMNpKamMmnSJA4fPgzgVHwA8+bN489//jMAO3bsYPDgwfTq1YvPP/+c3377LeB7bDabueuuu+jVqxc33HADWVlZmvutWLGCOXPmkJqaysUXX0xBQQF79+5l7dq1zs/dsmVLhg0bFvC1FbVLUnwUKW0aKsURIrW28pBSrgf04hcvr0lZ8k6WYDIYKOWcDdRkMJB3siTkL9aJEydYvXo127dvRwiB1WpFCMGMGTMCPodneKfjvWsJaCkljz/+OJMmTfI6fsuWLXz77bc89dRTXH755VxzzTW61/JVVlpPjkBxPXfnzp295Hr66aed2202Gw0bNnSuaFwZO3YsTzzxBCdOnGDz5s3Oifr2229nwYIFpKSk8Mknn5Cenu51bEREhNPk5ZpvMXPmTJKTk9m6dSs2m43o6GjNzyCl5J133mHkyJFu499++23A90GhqE+o2lZA60YxmG02tzGzzUbrRjEhn3P+/Pn85S9/4cCBA+Tk5JCbm0v79u1Zt25dwOdYuXIlJ06coKSkhKVLlzJo0CCvfUaOHMm///1viouLATh48CBHjx7l0KFDxMbGMmHCBKZOncqWLVvo0qULhw8fdq4IioqKsFgsQcmxYMECBg0aREJCAkVFRc59Bg8ezJdffonVauXYsWOsXbuWAQMGeJ1LSy5XGjRoQPv27Z3RZ1JKtm7dCtgDDfr378+UKVMYM2aMM4qrqKiIFi1aYDab+fzzzzU/Q7t27di8eTNg/9s4KCwspEWLFhgMBj777DOsVqvzWq6fb+TIkfzrX//CbDYDsGfPHs6cOcOQIUOcn/vw4cOsWbPG7/1UKOoDtR5tFQ44HGiPevg8KrOc/c9//sO0ae65jdddd53muB4DBgzguuuuIy8vjxtuuIF+/fp5+SNGjBjBzp07ueSSSwD7pDd37lyys7OZOnUqBoMBk8nEv/71LyIjI/nyyy+57777KCkpISYmhu+//z4oOSZMmEC/fvbIvkGDBtGzZ0+uvPJKpk+fzsaNG0lJSUEIwfTp02nevLnXubZv3+4llyeff/45f/3rX3nxxRcxm83cdNNNpKSkAHbT1Q033OC2unjhhRe4+OKLadq0KRdffLHbpO/gkUce4cYbb+SDDz5g9OjRzvF7772X6667jjlz5jBq1CjnKqlnz54YjUZSUlK4/fbbmTJlCjk5OfTp0wcpJU2bNmXBggVcc801rF69mu7du9O2bVvn30ERXhQUlyn/RlUTaiOQcPrRagaVlZWl2QTl9OnTmuNSSnm8qFRm/nFSHi8q1d2npvj444/l3/72N+d7X3LXpBzBUltyV5bqkFvvO1mV1PXmRNXBgl/zZJenvpU9n/5OdnnqW7nw17wqO3ddv99UohmUWnm4kBQfpZ5KFIp6hGswjMOn+eg32xjUsYn6X68kSnmEKbfffju33357bYsRNnIoFKFQHcEwCjvKYa5QKOot1REMo7CjlIdCoai3JMVH8fcx3YmMMBAXZdTNJlfl2YNHma0UCkW9ZWHmQV5YkoXJIDBbbDxzdQ+vyhGqPHtoqJWHQqGol7g6y8+UWym3Sl5YmuW2ulDl2UNHKY9qxGg0kpqa6vzJycnh0ksvDfl8t99+u1uCm+t4+/btSU1NpU+fPmzcuLEyYgP2kuv//Oc/gz7O8zMfOHCg0rK8+eabmsUOFQpfOJzlrjic5cHso9BGma2qkZiYGK8yG46qrVXNjBkzuP7661mxYgWTJk1i27Ztfo9xxGtrlXR3KI977703KDk8P7Nrwp6v6/nizTffZMKECcTGxgZ1nOL8JhBnuXKoh45aebhy7Bhs2mT/XU04Gsc46ulff/31dO3alVtvvRVZ0Zzm+eefp3///vTs2ZO7777bOR4IQ4YMITs7m+LiYi6//HL69OlDr169WLjQXpw40JLugZZc98eBAwe8rqd1Hr378fbbb3Po0CHS0tJIS0sL+D4oFIGUXlfl2StBqNmF4fRTJRnmX3whZUyMlImJ9t9ffKG9XxAYDAaZkpIiU1JS5Pjx46WUUsbFxUkp7RmeDRo0kLm5udJqtcqBAwfKdevWSSmlLCgocJ5jwoQJctGiRfL06dPytttuk19//bXXdVzHv/rqKzlgwABpNptlYWGhlFLKY8eOyQsvvFDabDa5f/9+KYSQGzdulFJKuXz5cnnXXXdJm80mrVarHD16tPzhhx/k/v37ZY8ePZzXmD9/vrziiiukxWKRR44ckW3atJGHDh3y+5m3b9/udj298/i6HxdccIE8duxY5f4YQaIyzGuW6pQ7kMoRoVaXqOv3G5VhXkmOHYM77oCSEvsP2N9fcQU0bRryabXMVq4MGDCA1q1bAzh9Ipdddhlr1qxh+vTpnD17lhMnTtCjRw+/Xb+mTp3Kiy++SNOmTZk9ezZSSp544gnWrl2LwWDg4MGD5OfnA/ol3cFeEn3v3r20bdvW7fx6JdfHjh3r8zPv2LHD7Xp652nQoIHu/VAoKkMglSNUdYngUcoDICcHIiPPKQ4Ak8k+Xgnl4Y+oqHNfVqPRiMViobS0lHvvvZeMjAzatGnDs88+61ZCXA+Hz8PBJ598wrFjx9i8eTMmk4l27do5zxNISXfPAoyVwVe5d1e07odCoQhPlM8DoF07KC93HzOb7eM1jGOCb9KkCcXFxZrRVYFQWFhIs2bNMJlMrFmzRjfqSa+ke6gl1/0Rynk8ZVEoFLWPWnmAfXUxe7bdVGUy2RXH7NnVuurQo2HDhtx111307NmT5s2bO7v+Bcutt97K1VdfTa9evejXrx9du3bV3E+vpPuFF14YUsl1f1xzzTWa59m1a5fuMXfffTejRo2iZcuWql+GQhEuhOosqYof4N/AUWCHy9izwEEgs+LnKn/nqaqS7PLoUSl/+cX+O8xQpc1rFuUwr1mU3DVLfXCYfwK8C8zxGJ8ppXytxqVp2rRWVhsKhUJR16hVn4eUci1wojZlUCgUCkXwCBlEAlq1CCBEO2CJlLJnxftngduB00AG8LCU8qTGcXcDdwMkJyf3nTdvntv2xMRELrzwQoQQbuNWq9XZ+7ouoeSuWapabiklv//+O4WFhVV2Ti2Ki4udiah1CV9yW22ScquNSKMBo0Fo7lNb1PX7nZaWtllK2S+Uc4Sj8kgGjgMSeAFoIaX8P1/n6Nevn8zIyHAb279/PwkJCSQlJbkpkKKiIhISEqr2Q9QASu6apSrlllJSUFBAUVER7du3r5Jz6uHI1K9r6Mkd7hVv6/r9FkKErDxq2+fhhZQy3/FaCPEhsCSU87Ru3Zq8vDyOeZQaKS0tJTo6unJC1gJK7pqlquWOjo52JkAqAkO1kA1vwk55CCFaSCkPV7y9BtgRynlMJpPmU156erozm7ouoeSuWeqq3PUJ1UI2vKlV5SGE+A8wFGgihMgDngGGCiFSsZutcoBJescrFIr6i6p4G97UqvKQUt6sMTy7xgVRKBRhh6Pi7aMePg+16ggPws5spVAoFA7GprZiUMcm5J0soXWjGKU4wgilPBQKRVijKt6GJ6owokKhUCiCRikPhUKhUASNUh4KhUKhCBqlPBQKhUIRNEp5KBQKn2TnFzE/I5fsfNWQS3EOFW2lUCh0eXrBdub89Ifz/cRL2vL8uF61KJEiXFArD4VCoUl2fpGb4gCYs/EPtQJRAEp5KBQKHTJzTwU1rgieguIytuaeoqC4rLZFCRpltlIoFJqktmmoOd4o1sT8jFxS2zSkY3LdK7cfLoR7uXl/KOWhUCg06ZicwMRL2jJn4znTVZfkOO6Ys9n5XvlAQqM+lJtXykOhUOjy/LheTBzYjszcUzSKNbkpDrD7QCYObKdWIEFSH8rNK5+HQqHwScfkBK7v14aTZ82a25UPJHjqQ7l5pTwUCkVA6PlA9MYV+jjKzUebDCRERRBtMtS5cvPKbKVQKAJCywcy8ZK2biarguIyVT49QOp6uXmlPBQKRcC4+kA8o608o4f+Pro7PVsl1smJsaaoy+XmlfJQKBRB0TE5wctBrhU99OSCHcRHGbHYZJ0LQ1X4p1Z9HkKIfwshjgohdriMNRZCrBRC7K343ag2ZVQoFP5xRA95UlxmpdRs49FvttXJRDiFPrXtMP8EGOUx9hiwSkrZCVhV8V6hUIQxWtFDrjjCUBX1h1pVHlLKtcAJj+FxwKcVrz8FxtekTAqFInhco4fiIo1e2+taGKrCP0JKWbsCCNEOWCKl7Fnx/pSUsmHFawGcdLz3OO5u4G6A5OTkvvPmzQvoesXFxcTHx1eJ7DWJkrtmUXKHhtUmKbfaKCm3criwFAFI7CuTxBiT7nGhyG21SUrMVgBiTEaMBlEJyUOjtu93qDjkTktL2yyl7BfKOcLaYS6llEIITe0mpfwA+ACgX79+cujQoQGdMz09nUD3DSeU3DWLkrvyBBO2G6zcCzMP8vBXmVgqLGUmo+D1G1Jq3CkfTvc7GKpC7tr2eWiRL4RoAVDx+2gty6NQKPygVR02KT6KlDYNSYqPqtLqsQXFZTw6f6tTcQCYrZKp85VTviYJx5XHIuA24JWK3wtrVxyFQuELf9Vhq7p6bN7JEozCAFjdxo0GUadqQ9V1ajtU9z/ARqCLECJPCHEHdqUxXAixF7ii4r1CoQhDXPM7isosXmG5/raHQutGMVild2SX1SaVU74Gqe1oq5ullC2klCYpZWsp5WwpZYGU8nIpZScp5RVSSs9oLIVCESZo5Xe4huX62x4KSfFRzLg+hQiX05qMghnX163aUHWdcDRbKRSKOoK/6rDVVT3WURfqt0OnAUmPlolKcdQw4egwVygU1cSCLbnc+ekmFmzJrZLz+asOW53VY5PioxjSuSlDOjdTiqMWUCsPheI8YeBLKzlyuhyA73ce5dXvdrHxieGVPq+/6rB1vXqsQhulPBSK84AFW3KdisPB4dPlLNiSy/g+bXweG0i+hr/qsHW5eqxCG6U8FIrzgCXbj+iO+1IeVR1mW9dQ/Un0UcpDoTgPGNOrOd/v9M63HdOrue4xWmXWH/1mG4M6NjkvJtLzXXH6QznMFYrzgPF92tCiQaTbWIsGkT5XHdURZltXqI78lPqGWnkoFOcJG58YzoItuSzZfoQxvZr79XXohdmaLVbmZ+R6dRKsTzgUp2PFBecU5/mw6goEpTwUivOI8X3a+FUaDhxhto+6mG76XdCI62f95Nxn4iVteX5cr+oSt9aorvyU+oQyWykUYUzG/gLeWLGbjP0FVXK+VVlHmDZ/K6uytB3onoxNbcWGacOYe+fFzP2/AazPdpdjzsY/yM4vqhLZwonqzE+pL6iVh0IRpkz46CfnZP326mwGd0ziszsHhny+ETPT2ZN/BoAvM/LokhzH8geH+j3OEWY7P0M7sTAz91S9NF+p/BTfqJWHQhGGZOwv8HrKX5ddEPIKZFXWEaficLA7/0zAKxCA1DYNgxoPV4IpD+9aVl7hjlIeCkUYsnbv8aDG/bEiKz+ocS06Jicw8ZK2bmMTL2lbp1YdCzMPMujV1Uz46GcGvbqaRZkHa1ukOosyWykUYciQTk14e3W25ngojOiezJcZeZrjWmTnF5GZe8orour5cb2YOLCd5rZwpz7krYRT0qJSHgpFGNKvfRKDOyaxzsV0NbhjEv3aJ4V0vsu7N6dLchy7XUxXXZLjuLy7d5Lg0wu2M+enP5zvPSOqOiYnVEpp1NYEWNfDb8MtaVEpD4UiTPnszoFk7C9g7d7jDOnUJGTF4WD5g0NZlXWEFVn5jOierKk4svOL3BQH2COqJg5sVyWrjNqcAOty+G04rpqU8lAowph+7UNfbWhxeffmmkrDQWbuKd3xyioPXxNgTaCVt1JXwm/DcdUUtspDCJEDFGFvVGyRUvarXYkUirqFv1WGFu2SYjXHqyKiSmsCNApRo+VO6mr4bTiumsJWeVSQJqUMLbxEoajH+CszEkpOh9OkZBSYrdI5XlURVVoT4JlyKzsOFVKTlvu6WB4+HFdN4a48FAqFB/6aOvnK6dBbgbialByYjIL/3HlxlZnNkuKj+Pvo7jy5YIfb+AtLsnjrT1FszT2luxoIpyij2iLcVk1CSul/r1pACLEfOAlIYJaU8gOP7XcDdwMkJyf3nTdvXkDnLS4uJj4+voqlrX6U3DVLuMp96qyZ3JNnvcbbNIqlYayJ4uJiCs1GTpwt99qncWwkrXTMHMVlFg4UnMXmMh8YhaB90zhiTMYqk7/EbGX/sTNYXa5jEIJm0ZJjpQKJfYWSGGNybi8sMZN3sgQBmttrk3D9nvjDIXdaWtrmUF0C4aw8WkkpDwohmgErgfuklGu19u3Xr5/MyMgI6Lzp6ekMHTq06gStIZTcNUu4yn3np5s0+3Jc0a0ZH93Wn/T0dKzNunLHnM1e+8ye2Fdz5bEw8yCPzt9KmcV9Log2GdgwbViVPuEWFJcx6NXVbiscgId7WXh9e4TXdbPzi7jqnfWUW87tHxUh+HBiP3q0TKz1p+9w/Z74wyG3ECJk5RG2GeZSyoMVv48C/wMG1K5ECkXto9e8yXXckdPhil5Oh8Nc5ak4oiKqpxCgZ8HBSKMg2qTdM2Rh5kGuenudm+IAKLNI7pm7RWWI1zJh6fMQQsQBBillUcXrEcDztSyWQlHrjO/Thle/28Vhl37kWk2dtHI6tKKvtCKgYk1G3v9LX4Z0blotn8Fhu//t0GlOl5Tz8Nfb3LabbTbiIo1M+2Yb5VZty8jZcivgO9dB+Umql7BUHkAy8D8hBNhl/EJK+V3tiqRQhAeBNnVyzenQi75q3SiGcqv7k70NSY+WDYDqm4DXZx93JgtabTaEECRERTijiM6UW72UmhaOUF9P2cItG7s+EpbKQ0q5D0ipbTkUinAlmKZOvqKvfthzjDIXs5BBwN9HdycpPqraJmCtZEEBvHfrRU4/RkFxmVdYr8kABoPBTV5HqG+KSx5KOGZj10fC1uehUCi0CaakOOhXzv16c55XKRKbhOeXZPH5Twe8enhPnV81Pby1eqMLIDEm0jm5azVjev3GVJ4e093rfC8syXKT63zuvV6ThOXKQ6FQaBPKakCvom7LxGjN/cssNp5b/BuREQav8b8v3M4/b61csQetZEFHCK4rY1Nb0b1FA7cKvltzTxEfZaS4zOrcz7NMRzhmY9dH1MpDoagjuJpjHKuBR785txrI2F9A/ukyr4ZRetFXt1x8ge61bFK6mYccfLs939l2Nju/iPkZuUG3odVaVWj5VBZmHmTMu+t5bnEWY95dz6LMg7RuFIPF5u5E91QMruePizQSaRROU5yi6lArD4WijuCrON6Ueb+yPruAh3tZmDbrJ6+WtXoVdSde0pY5G//wvBQWGwzv1oSVO495bcvMPcWcjTk+y7b7wzNbenvGRrften6LDdOGBVSmY2xqK4pKLTy3JIvICAMvLM0iITpCOc2rEKU8FIo6gp455nhRqW7LWtfSIloVdZ8f14vkhGhmrNjjdb3OyQmayiPCQJWUbfdVY8qXogykTEdBcRkvLM2i3GKj3GIfU07zqsWn2UoIMUMIMUljfJIQ4pXqE0uhUHiiZe6Zfl1vtuYVau6v17I2Y38Bb6zY7TRvjeyhnXjYrUUiJqNwGzMZBfuOe5dHAf1y7qHgz2/hr7d4XXeaBxsUURv4W3kMAx7VGP8Q2AY8VuUSKRQKXbSeujP2FwTcsnbCRz85Vylvr852mrc8zVcTL2nLJRcmYTS4V9g1GgQdmlRf2XYHla0iW5ed5nUlR8Wf8oiSGsWvpJQ2UZHBp1AoapbMP066+S4OFpY6iwY60GpZm7G/QNe8pdWbPDu/iGsvasU3Ww4SabRPZP0vaMQDX7lnhEPVlW13pTJVZMOxhHkg1KUcFX/Ko0QI0UlKudd1UAjRCagb6z+Foh7hmSl+YdNYDp4qdVMckUbBmzdd5HWsnhlr7d7j9Guf5Nab3LOP+eXdmvJ/l7bn+lk/eR2vV3DRlVAz1SvTeyPcSpgHQjh2DNTDn/J4GlgmhHgRcJTp7Ac8DjxQjXIpFHWGWWv2smDbYcb3bsGktE7Vdh2tTPHfj50lxiMfIyrCqDnZDOnUJCDzllYf82+359OjRaKmXCfPmn3KXZtmmLrW+Kkumdt8OsyllMuA8UAa8EnFTxpwnZTy22qWTaEIe7o99S0vL9/DzsNFvLx8D92eqr5/C71Mcc/aVHqTTb/2SQzu6G7K0jJvBev49uXr8JebEih1wYFcFegFRYSjAvQbqiul3AHcVgOyKOooGfsLWLv3OEM6NamyrnN1gVlr9lLiUcq8xCKZtWZvtaxA9DLF77isPXN+OoBRCISw+kyI++zOgX7/XnrKYGSP5uQXlXo51n35OqrCDFMdK5dwrrhbV8xtPpWHEGIx7n44CRwH1kgp51anYIq6gV70zvnAgm2HdcerQ3k4MsV3u5iuuiTH8cTo7lyQFMdzS7IwgN+EuH7tvVcbrnRMTtCMvuqYnKDpWPdFZc0w1eFArgvRTHXB3OZv5fGaxlhjYIIQoqeUUoXqhjkzl+9k4bYjjOvdnAdHdqvSc/uK3jkfViDje7dg52Hv0hzje7eotmtqZYq7JsRZpXSahiozwfpSEq6OdX9UJuqpoLiMNbuOEmHwyDWphAO5LkUzhTs+lYeU8getcSHEIuwOdKU8wphOjy/FXLFufGvNPv6Zvo+9L4+usvP7i96pabLziwJ+Iq4KJqV14s1V7qarmAhRrU5z8M4Ur64InWCUhC+CNcMUFJfx+c9/8N6abAwCSsxV50CuS9FM4U5I5UmklFaV5hHezFy+06k4HJilfTyUFYjWCibQ6J2awDO0NNhaS6Gy88WraizaSo+6EKETqBlGr586QFyUEatN8vfR3Z2Z4sFO+HXhXtUV/JUnaazxc6EQ4jngtxqSUVHBgi253PnpJhZsyfW778JtR4Ia90Wnx5fy1pp95BSc5a01++j0+FIg8Oid6kYrtHTOxj+CrvYaKpPSOrFsypBaURzgHqFjFCKsI3R8oddP3cHUEZ35++juvLA0iwkf/RxSD/O6FM0U7vhbeWzG7iR3LDMcDvN04J7qEwuEEKOAtwAj8JGUslpqafW5/wtaF+aTl5jMlrdvqY5LVAm7jhTxynf2zN7vdx7l1e92sfGJ4br7j+vdnLfW7NMcDwZ/K5hAoneqG73Q0szcUzVivgoHHKahXzauZ8PYy2p1Mgw1kknLpORKk/hoHpm/tdL+iroSzRTu+PN5tNfbJoT4EvhzlUtkP7cReA8YDuQBm4QQi6SUWVV5nfvGTmXDsrcxGyIw2SxMzsnk3UXTq/ISVcKCLbmYrTZcF4qHT5ezYEuubivSB0d245/p+9wmfpMgaJOVrxWM41z+oneqG73Q0qqstVQXSIqPIsZk9DkZBtL73JVgFUFlIpm0TEoOIgzQICaiyvwVtRnNFM5hwsFQmWZQl1SZFN4MALKllPuklOXAPGBcVV6gz/1fMH3Z28RYymlQfpYYSzkzlr1Fn/u/qMrLVAlLtmtP4K9+t4uUZ7/jkS+3AHDDP9dx4eNLueGf6wDY+/JopqR1oF1SLFPSOoTkLNdbqQS7gqlOHKGlrlRHraW6zsCXVvLAV9v4fudRHvhqG5e8tNLn/gszDzLo1dUBm4gqmxDoalKKqqjmG2kUREUI3rgxlR4tE2vNX1FVSYrB3tNwRmjUPQzsQCH+kFK29b9nSOe+Hhglpbyz4v1fgIullJNd9rkbuBsgOTm577x58wI6d3FxMfHx8WTnHKXDiYMY5Lkvo00Y2Ne4FR3bNavCT1N5Tp01U156lvwgq4n1aqVdTiJYdhwsdEv2EUDPAM/tuN81QZnFxtlyK7GRRqIiKtcksyblrkr05D511kzuSe9S6m0axdIw1uQ1brVJdh0pwuYyPxiEoGvzBIwG7WCZErOV/cfOYHU5xigE7ZvGEWMyBiy31SYpt9owCIFNSiKNBuc1C0vM5J0scRaCbN0ohsQYb/mrEl/XDOZ7Eso9rS4ccqelpW2WUobUV9hfkmAfvU1A9f7F/CCl/AD4AKBfv35y6NChAR2Xnp7O0KFDeej+L9jwr8eIsZQ7t5VERPLIXz9my+2BnasmeX/eYl7fHtyE2L/QyNf3Dq70tYdyLtpqeNemjEltHfCS23G/6xr1Te47P93E9zvLvcav6NaQj27r7zW+NfcU7//wM0VlFudYbKSB/wy+iBQXc6BreHSjuEgefHU1pS6htZFGwbf3D6BRXKRPU00w97u6zT6u5wcY9OpqSs3nlF+0ycKGaUNIio8KSm6te5oQFcFcj3taE1TF99ufw/x1H9t2VerKvjkIuBpkW1eMVRlb3r6FyTmZzFj2ltPnMfXKKWHrNO/aPIE3b7yQJduPsH7PUUqt/o/Zknu6yq7/4MhudEhuwLRvtjEv42DYZuaeL2i1lPXFmF7N+X7nUc1xLbT8D2fLbXz+8wHnRKcVHu1ICJQ2SZlVYjAIrnx7HVJKYkwRlFutTE7rxC0Xtw154q9Of4Wnz+ZvQztWmZ+lvoUJ+yuMmObrpxrl2gR0EkK0F0JEAjcBi6r6Iu8ums6gv37MhJteZNBfPw5LZ7kr4/u04aPb+jMmwAzmPm0auL2/b+4mejy9jPvmbgr62lVV4E5ReUbMTOeOOZv5MiOPO+ZsZuTMdL/HjO/ThhYNIt3GWjSI1HWaJ8VH8dDwzl7jX2XkkZ1fpBse3b1FA5ZMvgxZkQdWarZhtkosNigqs1Bmkby+cg+XvhJ+9n6t7/i7a/YGXHjSH/UtTNif2epRKeX0itc3SCm/dtn2kpTyieoQSkppEUJMBpZjD9X9t5SyWvJKwnWl4YvX/tyH+b8u9bufq8mq3WPn9l+84yiLH1tKziuBO9BVZm54oFWWfXf+GVZlHfG7Atn4xHBntFXDaCMHTpYy98f9TLhUO6iycWyk5rivqruZuafolJxAlNFAuUU7cgrs/qlwKwui9R2PNBq5e0gH3kvPrpKmUvUpTNifEf0ml9ePe2wbVcWyuCGl/FZK2VlKeaGU8h/Vea26SM4ro2nbUPuL1zjG4KYY9FYawaxA6tuSu66iV5Zdb9yT8X3asGl/AfN/PcymnJM8tSiLlGe/09zXVwi0r21mi5VSi3+7arj1FNf7jt9ycVs2TBvG3DsvZsO0YZU21frrv15X8Kc8hM5rrfeKGqaw1KI5bpXuf5rFO7xt3QCr92jXptKivi256yojuicHNe7J3B/3U+jhMCsstTL3x/1e+/oKgdbbNmdjDtfP+snZ99xkFJiMAqPGbBFuDx++vuP1ZcKvSvw5zD3LsettU9QCw7s1Y/6v3mXBh3c7F2rsyPnQYlhnew2qQBPHKrPk1itaWNPFDOs6emXZA3GaAyzUKSO/cNthTfOVr+q6ntsArpi51u14s1Uyf9JA2jeN5+8LdvDtjnM5Szf2ax12k3F9MitVN/6UR4oQ4jT2VUZMxWsq3kdXq2QKv+j5Pl7787kIa18RV+9M6M/Al1Zy5LQ9hDOQsiehRLroFS30HB/VsxmdmzU475pKBYtWWXZXfIWyjuvdgk05J73OOc5HEIav6rqu2+ZnaNdcyyk4S/um8aze7b4C/iojjymXd3aTMZgw3OoK2a0LvTTCAX/lSXxn9ihqnZxXRvPIl1tYufMow7s1c1McYI+42vSHtgLp8vhSyjzWj4dPl9P1qW8Z06u517m0mPvjfhZuO8y43i00n1zLLDbNqJw/dWrqNf7djqN8x9EqaypVX8pAaOFZlt1BYYmZQa+u1i0PMuHS9sxYsdvNdJUYbdR1mgeDLz9IIAEXwZQ2qQsNnWqC2vyOh1SSXVFzOAo3XnnFBQzV2cfXJP/1vYPdIq1c8VQcDkotkvm/Hmb+r74jslKe/c45CW3KOcmMFbvZ+qx7HMXZcm3HqT8Hb2WbSoX75FId//SOc5aajT4LB259dpRfpa+Hq5kRcDNn+epAWFBc5jPgwmqTATdpqmxDp/ryUFHb33GlPMIY18KNm1NeYPLYR525KJc99AWNC/I5kZTM+jd8hxt3bRbLrqPepSkC4ZEvt2gqJ1+OV9fJKDZSe/Gq14/blVCbSoV7t7jq+qd3lNBwRS+cesKl7YNebXiaGV2ZeElbJg5sR+9WDZk9sSknz5rdfCT+OgqWW20Bh4JXJmy8tifcqiIcvuNKeYQpfe7/gg0VhRtjKEdIWVG4MZVBOb+y0rUacLbvasDfPZSmu/rwx0qNrGQI3PEaFWHQfBq9vHtzr3FPQm0qpTW5SAkbfz/OmJTanSiq85++daMYryiWqopo0koKdGXOxj+8/sbX93MPvvDljI40GgIOBQ81bDwcJtyqIhzyripXPU5RbbQuzMdscNftZkME3fN/16wGfNlDvqsB57wymq7NYoOWwzVyyxU9B+sVXZq6VR89caacnYeLmJLWgdeu7833Dw5xdvh7flwvvn9wCK9d35s+bd0LLVamqZTW5FJmsTH5P5k8vXB7SOesKhz/9K5UVb5DUnwUrRvFVEs4ta/EQC30mnHphbwaDSLgUPBQw8ar897XNOGQd6VWHmFKXmIyJpt7HofjvdkQQQznityZDRE0LjjnQ5j02hKO7thLs56dmPXIGOf4dw+lMeSV7/njVOAlRfT8KVqO15gIwczV2ZjS92G22RBScm83M5tyzGzKOUlitNHLJ+KwlV/fr02VNZVyTC6PfL2Vcqv7s7jDWe8wq6zKOlKjLWSr8p9ey3afGGNiw7QhVW7TD6U3SrDNuHytTDw/ayghteEw4VYV/syANYFSHmGKZ+FGKQRTr5xCTqsLNZXKiSR7kth9Y6fypqtJa+0UN5OWL8XhL3LLE1fH6xVdmjJzdbabScATLZ+IK1XZVGpsaitOnCnn2cXe/cPumLPZa2zn4SLeXLWXnS9eVSXX16Oq/ul92e6rItTUM/9Gyxnuj3ZJsZrn8oWW7HqfNdjP6bj3U+dvw2gQWG2yTie61nZOilIeYcy7i6bT5/5Ue7RV0wt4d9FDAEzO9q4GvP6NW5j02hLedPGTAMxY9hbD7upAfHkJeYnJtG3ZTFOBOEqdBBKe64rD8bo19xSm9H26isOBp0+kOiNfLusYnM+kxCKZtWZvta9AKvtP78t2XxXo5eW4JgUWnCnnjZV7EIBVSqw2ic21a6VRYIow6p4rUKraTyEBKSVWm/13Xac2c1KU8ghzHIUb09PTnWPvLprOZQ+lekVbHd2x1+t4o83Gtx/fR7kx0qlo/uj+J6/91j52RaXk9NVC1BVXX8nCzIM88tVWJBKB4PUbU6o08iWUp+UF2w7XiPmqMv/0vpyllUWvWu6fOjXl8u7N6ZicQKO4SAa9upoyH4UPjQaB2WLVPNfEge0CNmdVpWO4oLiMR77eWlE6xa44Hv56a510mIcDymFeR1n/xi0s+vRBtzDdQlMM0Rb3hj8mm4Voq8XpXH/t25l0KPDOBB7kpyWpP+Zv+oPGsSYM4HRixkS4B466JqMVFJcxZV4mZpu9XLfZJrl/XmaVl3h3OOX/3K91QPuPD7DcfW1SnbZ7Pcf4HXM2O4MNtBzP0SYDkUbh5sDOKdAODw/G+V6Vn/W3Q4XOmlvOc1klvx0qDPpcCqU86hXx5SWUGH03eIyyWlj28f2MyfrBbfzg6fKQI5G6PfUtLy/fw6HCMmxAmcXChmnD2PniVSRERRBphKEdG7s5y/+3RTvHQ2+8MnRMTuCuwR387hcTIWpk1VFZqrJIZcb+At5YsZuM/QUArNt7THdfRwSV3irz2/sHu1We9ZVxHihVW5BTr5arqvEaCspsVY/IS0xGCN//CAKIspqZsewtfmyXyonYcyGywZoUAGat2UuJxf1prtxqX4m8tmIP9/e0UG6NID37BJ0eX8rel+0Z69sPapdM0Rt3JZRiilomrLEpLejRPCGkaKuqigwLlapwlk746CfWZ9uVxturs+nTNpEtf/h+Cs/MPcX1/dpoOv09/xa+Ms5dKSguo8RspaC4TPNzVJVjuGViNEYBrouPCAP0aNlA/yCFLkp51CO0WuvO6z2Cm7d+R5TV4vZ8ZTZE0Low3015QPDhlQt0kgU/WL8fs4c/0iztvdAfHNmNsSktWLj1kNdxY1N8m40q44DVqxAb7GrDc9KtijpcrngqJj1lWRm/Scb+AudncOBPccC5VYO/Cd0h88SB7XSr8gLM+uF3Xluxmwd6WHjw1dW6Gd+unzWU4ok7DhbywtIsIgwCq1USaRQIATOuT1H+jhBRyqOe4RqhlZeYzJa3b2HYXe+z7OP7ibKanfuZbBaKI2PofXgPeYnJTiUSbDz/+N4t2HnYOxnMquM8X7jtCA+O7EZRqZk4k4Ez5nP7+SstrufMDWS15DoBe2Y+B4PWpFvZOlyueCqmFg0iOXz6nB/LU1kG28vcwYfrvPt3+ENr1aBFoAr+0a8z+WqzvRWtTUpna2OHA1tLaYZSPNEoBGc0aqwtvW+wagNQCZTyqId4ttZd/eE9TM7f57EiGc7ST6a4hfs2vuMvQf8zTUrrxJur3E1XMRGCG/q05sMNB7z2H961qVsZeACjgA5N4vjLxRf4vJaeo9Xfaqmy4aKurN2r3UAr0DpcWhPiPxbvYMmOI/Rrk+ilmFwVB7gryxEz050tab/MyKNLchyPX+T/MxQUl7Fmt7ZvY1TPZnyn0TysXVKM2z3Tm8QDVfDZ+UVOxeGKQQjyTpbw1vd7vP5mUy7vHFLxRC2iIoyaCiUY/Jnb6jthpzyEEM8CdwGOb/cTUspva0+i+sG7i6Yz8aVBnN69j9ORMSz9ZIpXPsigdqlu9mnXirqj3ljjLK7YtVks3z2U5ty288WrmLVmr5vvYGvuKU3lkRBjclMcYLdB7z12hqcWZTkr83qeD3yX/NajMqsVraf6IZ2a8PbqbK99A6nDpaXE5m78wxmEurhQu46YJ5m5pzhQcEazl3lRqf9JLO9kCVERBsqt7hNrautE3p/Qn7k/7uepRe7JlTkFJc4+6Qu25PLw19uxSuk1iQeq4PX2M1ttuiG+A9o1rlTxRLfrVDI6zaE87+9m9mluq8+EnfKoYKaU8rXaFqK+MeeJcQCMvW2mZokTTx9Iu8eW8v2DQ7y6w+06epZ2j7mXa5+U1snNd+CoseRKtMlAxoFTPmUsLLVy4eNLnU5N18zvQB2wroS6Wtl7tJh/fGfPRHc81S9/cCj92icxuGMS61xWCIHU4dJTYqGQ2qYhH67bp7ntdIlZc9zBgi25/PfXgxSVebcwnn17f7Lzi3SLXq7IyufV5bu8lBacm8T1FHn+6VKy84toFBdJ3skSGsVqRwVOHdGFHYe0gyYWZh6qVPFEgLgoY6Uzy11XNVYNc9v5QrgqD0U1olc3S8sH4qk4XBn1xhq3FYgrjhDL3KzNJERFOE0bNptN1/TjwCMUnxKL5L65myixwphezX06YD0JZbWyKusIpWYrrv8eu/PPOJ+8P7tzoNOpndI6kSYJ0X5NF8EWFnSg5fP4ZMM+vt2uPcE3iNEP1fY0F3oy9etMVu/W/9s0T4jUVBxwbhLff6xYc/uMFXuYsWIPRoMgQkCZVWIQuGWl39ivFcmJ0TwwL1PzHCt3HmVg+0Zk5hX6Le2iVQbm76O707NVot+6Wf4Ih4q24YAItxT9CrPV7cBpIAN4WErp1TdTCHE3cDdAcnJy33nz5gV0/uLiYuLj46tK3BqjquXOzT5I69P5FbndkhMxDWhcctr5Pq9BMqdi/F+vV6tEn9uLioqIiI4l0mjAaLDHe+06UoTZ6j8bXQ+T0UDX5oH7Zg4VllBQfG7STIqPpGWivsni4MkSTLKcfI+E7caxkbRyecotLDE7e2hI7E+7iTqTd5nFxh6NKrNaNIwxERlhJCE6gthII2UWG2fLrcRGGn2eI9pkpEUsmt+TU2fN5J4MraeL49yxJiMnznorH4GgTWP7Z88/XcbRotKgzi2EoG28IC4+np1HivyWDbmwaTxC4Pad0sNqk5Rbbbr7njhTzqHCUgz4/xu6nnPXkSJsUpIcA/kldl9N1+YJfuUJFxzzSVpa2mYpZb9QzlErykMI8T2gFRryJPATcBz73/IFoIWU8v98na9fv34yIyMjoGunp6czdOjQoOQNB6pDbkeXwmIXH4iDkohIBv31Y69QXlc8fR9aaMnd6fGlXmG8DiINUB6AXnnzxt6M7xN41JSv3BDPJ89VWUfI+vVnXt/uvjCfPbGv0/dRUFzGoFdXuzlko00GNkwbpvv0+fTC7X5NVQZgn073xqf+u5W5v3gnUcZHGnjrpou4vHtz3e/JnZ9u4nud3iy+6JocT6dm8dx2aTsKS8yaRSVd/xYZ+wu4ftZPQV0jISqC6ZdF0LJrX26ctdFn2ROA167vXamIOQcf/PA7Ly3b5Tbm72/oYFHmQR6t8Hm8vdNU53weju+JECJk5VErZispZUCFlIQQHwJLqlmc8xZHVNb42/V9IIAz7NdTkfhTHFrMXL5TU3EI4IWx3ZlwaXu6PfWtV+KhJ0u2HwlKeTgqwzpwmJ0EMGvdPq+ooX073DsgeoYRh2K6aNUgWnO8f9sG5BWWMaZnc568uqfuZ1j2m3br3uJyGxckxekeB3ZzXyjKY1d+Mbvyi1m8/Qh92yaSnBBFftG5EjJdkuPo2aoh8zNySW3TkH7tk+jVKoHtBwNbZYHd5BVpNNibWQXwMBtKeXhPPv/pgJfiAHtNrkDMT448l182rmfD2MvOK3OVg7DzeQghWkgpHQbda4AdtSnP+UBSt46aPpAeR7L58ovH7OG8VjPvXPpn5qVeSbN2LfjuobSQMr0XbjuiOS6BFg3tJiHX6K2OSTEs1ggd7d+2YcCfz1NO11wKBw4l8MjXW9l+sJCLGsYwe2IP3RyKUGou6SVUFpslGx/3/zx1ZY9kzZUHwPrs4z7/BuP7tOHV73a5+U8c5rZA2eySRNixaRyPX9mVH/Ycc/OLTbykLYvvG8LYd9eyLU9bgZgMYLbhDKiYfl1vjKf2cvJMOTf0bcMXv/yhK5cjQCKU756DguIynlv8m+Y2s1UGHIWVFB9FjMl4XioOCEPlAUwXQqRi/17nAJNqVZrzgNnTrmbyhilueSDPXX4Xz6z60C2cd+q6uUz58Uu+6nUFw3buZl/SuSf/QHMnxvVuzltrtCOFVmTlOydp1+itjJdWeuU7vLx8D7M37Of+YZ189uL2DI+9skeyl+Jwpdwq+XDdfh7uZeGXP3J0M8dD6cuhl1CpVYxRa3J88doUXeXx8rJdNI6LxFehjY1PDGfBllyWbD/CmF7NKS61eIXkAlyT2oL806X8uM/L1XhOvmNneHtVNlsPumelO8KgF00ewvTvdvLPdO+/9V+HdmRsSkvOlFudpsIvFmzjdhclNKRTEsO6JjvL6rvei8rm7eSdLMFkNFBu9c7zeObq7uetMgiWsCuMKKX8i5Syl5Syt5RyrMsqRFGNvLtoOpNfnM/Em19k8ovzyUq+0KsNrqMu1oTMZaz66K88s/J95zbPtqNp01fR7rGlXg7eB0d20y1DN6J7sub4Y1d1J0LDEXm02MxTi7JIefY7zeO0wmP1TD9aODLH9Th9tpxuzRO49eI2zmKAvpiU1smr0rBWMcanF2zniplreWT+Nq6YudatYGXOK6PprNFOuMxiDxe12nyvJcb3acNHt/VnfJ82TLi0PYnR7ua5xGgjM2/qQ7kfsyHgpTgcOCLL9ErEj01pScfkBGc72uz8IgrOuD8crN1bwGUdm7h1mnSsOLRCnrVa3oJ9leHaFhnsq0arhnnsiau6cqufRFXFOcJOeShqj9nTrmbBJw8ye9rVFDVr7mXKciAqfm7fssStvLtj0mj32FL2n7BH3JRZbLR7bKnb8ftfGU3jGN8+BQeOmHqLj0nR0aHQk1DDY13RCytOefY7nlqUxa+5hby/dj/DXlsT0Pl2vngVj4/sTLcWCTw+srNX58JAJscVD6Xx7s0XER3h3Y/bM/FPD0c13dm39efFsd3p364RL47t7qx8PGFg24DOo0Vqm4Zk5xexaKv3c9+41BZeZiZfuTiBjOmNL8w8yKBXVzPho58Z9OpqFmXaM9pdK/XGRAiMAqYM68jdQy70+bkU7oSj2UoRBqyZcTOTd//KjG/fJNpq1l0tpB46Z75KbdOQtOmrNPdLm76KNY9e7jTHfHXPIA4UnPFbl8lfprADzw6FDnm0CKR6rAOtzPG5P+53690O/lvsuuKZUAnnzFT5p7XDXD2TGi+5MMmrkrjD8eyLWWv28tbqvZytiFpwFHb8+p5L3fbT8pEEg94kP7hjU6+x1DYNObzbe1+tv1+geTv+OhCOTW3F+uzjfJVhNwO+tTqbkyXlIZetOR9RKw+FLu8ums5VD37Ka4MnUGY0aToxM1t2AaDx2UIeevQjCvO0zUL7T5R6mWN+2HuMV69P8VnQL5QOhQ5++l171XBtaivmTxpI/3aNfJ7z4vaNMEUYvRpU6WVg6437w/W+zFixR3Mfz8lRr8+FrzwDR9+Vsx7hbnrmuY1PDGdKWgdaJQbnA3D4JwL5HGCPhEuKj3Qb06sc4KgyoLWvq4lKq2GVa7fF7Pwip+Jw4Mv8pfBGrTwUPlkz42bgZk7sf5kVV97MmN3rnds+6TOGeyeN5ofn32b6srfPOduH3UVW8wvJS0wGzoWQ+qoxdd/cTazec5xhnZvwzoT+zn08HdPlVhs2q80t3Ne1Q6Ervib5CZe2Z9rILpo5Cdf1aUVydD5bdxUy4aOfvaq3juvdgk053s5kLQXmDy0zlRZ/+2Izyx8c6jamVRY9Pd27FTFo911xxVHY0dWh/p9Nufy8X99prkdqm4bc+4V3PshVvZJpFBepcQS0TIzh+wf7BhRBpVVa37NQ499Hd/cZDae3MvIVtRZsJnp9RykPRUA0bt+aq3etY9hd75N6aDeZLbuw+sN76HP/F2xY9rZbVNbLK96jODKGCJuV+b3/DTTUPW9m7im3UM/FO46y2KNultYkOffH/SzcdphxvVvomor8TfJ6daqeuKob8xb9QanZqGnymHBpe2as2O1lumoQ6z4xBhJOGqhfxrU8iitaPT1cFYAjF0YvTNjB3vwit/IloeSEOJj02WZ+P+5dxmTNrmMM2qVfRNAzF8cXrvtqmaheWJrF38d054UlWZrRcHorI0fUmqd8wZSCP19QykMRFKs/vMftfevCfK8EQwEklNvNA61P59P4rNDNVF+SqR16et/cTV4rENdJcsKl7f36F7Qmec9VimudKkfzpa0aE7pnAuDqR9IY+NIqzC6OfFcFE2g4aTAJb66hzHrsOlLEK99tA+wK4NXvdrHxieG6YcIOgolC84eW4gAoMfsuox4qegmbPVsmsmTyZZoKXKvIJpyLWnOVz5f/5HxG+TwUlUKryKIrEuHMVPdk4iVt2fTHKc1tq/foF+jTCr/UY+uzozSjiVzp1z6Jh0Z0cVbG3XGwEJtHKKdnAmDeyRKiTe4RYyaDgd8OnWbJ1oMBh5N2TE7QDL3VQi+U2cGCLbleNcMOny5nwZZcJqV1IjJM/ttdfQ+uBPN3dUUvYXPHwULGvLue5xZnMebd9c5oKwfPj+vFU1d1xeThJ/KUz5//5HxFrTwUlcK19a1FGIk3l7gFAQkkeYnuT8uvXd/b+SR4sqhUM4N8WGftp7pQzAeBrFIcFBSX8cLSLP7W1X3876Pdk8e0JqwSs4W75ujXWNMrA19wxncZdfDfZRHsJVtSNP6jHaVcXrq2N4/M3+b3WtWNViZ+YYmZQa+uDtos5PBDeJqo/j66Oy8szfLZOMpzdagnn69qAsF7hOoPSnkoKo1r69vu+b/zzKoPnc7zvAbuNbFyPIr+vTOhP4s98kAc4574Mh8s23aIhdsO06VZHGYbQbdldaD1lBkXZaSnR/Vgb0e+FZvEZ1E/R/6DpxnFV9mRAe0aMWlIh4A+y5hezcnd6d0Xfkyv5s7r63Fxu4b8nHPK5/kjIwz0apngVqbEHwKYcHEbvt5yUDcT36EA9HxMemg5yR0l1/3VHtMLVIiKMHjJF0o1gfMBpTwUVYJr69vxT6dhO/AH5S1bMTrm3D+Yp+JwsPmpK3jgi838knOSto1jefm63pr76U0IQ6av4ky53czkcJC7NnAKBq2nzDKzds0qV0d+YUk5f/v8V8xWbROe3b6eo+kH0Ss70qJBJF955F/4YnyfNry/J9PrHOP7tHEqrbEpLdyS9zo2iePxq7ry/lrtkjECiHVpoDQ2tZVbL5NJczfjqwiuBK7v15YHhnfRjVRylLV3xV+RST0nuWtF3FCirR6/sqvmikcraON8RykPRZWz4PnrnK/T09PJuXUofe7/grG3zSQvMdlN0SzMPMjUrzNxtJPee/ws18/6icEdk7zqSumZivQmL70IJV84njIP/HbO/GSxSS57ZZUzG9wzZDMpPoqC4jLNWkkG4I0be9OzVUOvxlquoco5r4zmqf9u5X+ZB0mMieTRkV38Vg3Wijjr2jyBN2+8kLk//0Hj2EjuHtLByzwzLrUFx06X8eO+E2QfP8MdczZzcbuGmtd4bGRnBnZs6vysrpFcl3dvzvDuzVimYXZ05aMf9vLOhP66E27rRjFeOUR6RSYdiqtFYrTPlYW/1YLeKuwyH05wrci28xmlPBTVzn1jp7LBkQdiNTM9cxknb/oLj0z8Ew/My9RMPnQkrrm2d3WdEBx9NKSf/EF/EUpasfuHNZomlVgks9bspXmjWE2fS1J8FJPTOvH6SvckPxvwwFfbGNRBu02tqx/kxWtTePHaFL/ygb08iiOKbFPOSWfvd4D5Ww462/2u0Ai5XZjpHbarZbJKjDa6ZcJ7hvI+8FVg/pPFO47SaOF23eztpPioirbFFp9mIc9qyJ6rFU+F42u1EEpLY4U7SnkoqpWduSeY7pEHMnXdXMo2fsUj301Bdv+T7rFP/Hc7L13by02BjE1txf0ubUq9n/Xd6ZCkH8mk53xfsO0wV2k8gM7bnMfBU6WUW7SdsLdc3JZ312Rr+j027NMusOjLD+GQz1jRtvXRkV24e8iFPsujxJ4pZ322dqhssLxxYypgz1eZvX6fzxa2/piz8Q/+1KmpWzMt10k9McbE3P/r4xYy7UrG/gKvasgSiDQKoiKMugrH12pBK9lQEThKeSiqFZPVopkHEm0pZ8ayt/ixXapuDsieY2e4ftZPRBsFk4a058GR3RjzZnpQ1395+R7W/17gZQLz5Xwf37sF5Ye842j+KDjr1V/dgOC3Q6cZ0rkpSfFRzLi+t5tyc9vXo2e30SB0M65d5XPw0re7yD5azH6dPIpXl+/i7s7lVNW/9YqsfH7YcyygDPhAuGPOZm7s15pyi5XFWw8TGWFAYu/nUXyqhCe+s2f7v7062ysv5sN12j6Z2y5tx5jeLb1WFoH2+9BLTKxMv5BQqY1rVgalPBTVitkYoZsHEki3QoBSq+StNfv4Z/o+fFUK79+uEY2ijazY5Z4jomUC8xWN07xRLH94By15KQ6As2Yrd83JYMb19lVL9xb6HTWiIwycdVEGsSajplO4oLiMNbuOYtAw6H2VkceUtA6amfNFZYH3hY8yQpmfZVuvlg00+334Is4kaNMoll1HtRWcaz0pR9Lg1PnbmNzNXem5+oMKistYs/uY5vlGdk8mxWP1Vtl+H5U9PhRq45qVJUzShhT1lW5tGjP1yimUaBRWdHQr3PCv/8fceU+x4V//jzFZP+ieyyyhQZT2V7Zn8zi+vudSurZsqLnds7S6Xux+XKSRB3RWDno4spIList0o3g6JMW6KQ7H9TydwgszD3LJy6t47L/bvQoYOmiTFO/VhyPKqLmrvswViiPaCO/efBEXNnU373VJjiM6MvhnyzNmycgeyfRuqb2a1MIzIdOBa1+QqAjvD5japoGXeSvYfh8OHAmKGfsLQjq+MoQqc22jlIei2nl30XQG3fsJrw2eQGlEJKcjYymJiOS5y+/i6dUfEWMpp0H5WWIqTFmNz+rnERTqPF0/OMKe1adVQl1rXK8q7a4jp4NqzerAsWrR82EcLPQute6ZeDj3x/1MmZdJuVX67F+S2qahV+b85zodD/1RaoUp835l37GzDOrQiD/3a83siX1Z/uBQ3c/S0k+V3bfW7GPbocBzQcxaSzrO+YO0FH2kUTD7tgFex+gp77t9JG+69v246aOfNfepit4wegTToyScqBWzlRDiBuBZoBswQEqZ4bLtceAO7L7Q+6WUy2tDRkXVYg/PvYXH//kX9m3ZSYc+3cj6+Tcvf4hFGAMyZXn2375jzmZnXodWsUPPJ1TQjsb5ZIN3U6lAcKwikuKjvKJ4ruqVzLo9BW6OdM/EQ9dIJl+4RgR1bdGAo8XldG3RwFnkEYKvUeWYuzfsO0nCwUJevd4e8aVX/+lQYXDlQ0JhbMq5plF6Ybcnz5SzZtdR2iXFYoow0rpRjK7C21dwljdX7uaB4V3cxrV8X1oEU4MsWIIpXx9O1JbPYwdwLTDLdVAI0R24CegBtAS+F0J0llL6C6pR1BFevncEMAKAP+077uUPiTeXcPOvyxi/8wcsBiORVgvPXHE3Kzpf6qZMtJ5Vd+ef4e5Pfib7WDFX92xG+2YNNCN3XPGMxvEV59+9eRxZR7xt+UaBW6SPZxRPo7hIBr262u0Yq03SulFMQJFMw7o05apeLdwcqa5hq46GTp/dOZBvV6zi/mGtaRYfydHicuJMBvYVnOXY6TJW79H2G7hSVGZza2r1/LhejO3dkgWZh5j7c9U4zgNhSCf3plGeiv6t7/e4BSaYjAKjQTD9ut50T04gS8Pk886a3/nLJe3c/t5avq8IA265Q9UdwltXw4ZrRXlIKXcCCOHVuGYcME9KWQbsF0JkAwOAjTUroaIm+OG1W3hs+4+8vOI9Z8y+AG7avtIthv/l5e/x/MpZlEZEYrJZmHrlFJbohPg6nOWLC49i4CgPjeiiuZ8ezmZDxd7RPVlHzmDEPTzYKOCXJ6/wcnp7RvFoPTm/9f2egCKZbr24rVuuilbY6rrsAub+uJ/WkUYeGqr9mbPzi7j6nXU++3qAe1dGR7iwjlui2nA8dXtWPNYrLWK2SsxWyaPfbOOR4Z3J+naX1zkjDMIrQEHLJBZhNDDvrgHkFJytscinuhg2LGRNfytcLy5EOvCIw2wlhHgX+ElKObfi/WxgmZRyvsaxdwN3AyQnJ/edN29eQNcsLi4mPj6+aj5ADVJf5f495yjtTxzE4C/bzwUpBLuatsNi8O8lbhofRaO4SM6WW4mNNBJV0ff7SGEpp0rMNIwx0Twx2uu4k4WnySv2/t9olhDFmTIr5VYbjWNNNGsQzdlyK0WlFhKiI4iN1JapzGKjuMxChEEQHxWBxSbZE4BDNNpkpFMz9/uXf7qMo0Xa7WpbxkJSI3czX1GphdMlZhrEmEiIjuDEmXJOnTUjkZwt917Ut2oYQ+O4SKw2ya4jRboObS1iI42a5/RHcgzkVxSpbRBtIsIgKDFbKTGfO1d8VATtm8Rx8qyZPI1ETgCjELRNitUMZzYIQdfmCV7dFgtLzM4SKRK7QkmMMQUkd13/v0xLS9sspewXyjmqbeUhhPge0ErtfVJKubCy55dSfgB8ANCvXz85dOjQgI5LT08n0H3Difoq979fWsgtzzxGjOWc2UbinT3sSlFkDIuvmET6hf11c0QcxJhslJjPlc6eeElb5m78o8JIYQCsGDjDPo+6W8u/X83rG7VKbjsmMwODOzbkSHYJe486JnKLZlkV7zDM5vRu1ZDXv9fP0I42wnu39tXMjs/YX8A0jQ6IAA/3snBB6rnEyhEz09mT7/BRlNElOYLlD45w7t/lyaVuIbsxEYKdL9q3b809xT/Tf+KMjjJonxTD/gL3e/v8uF5k7C/g74t+0+wf0ioxWjN44OFeFr7MjSfCIMg5UcK5b4H7FDV/Ui/igQd1Pn+0ycCGaYOxZR/nwS8znf4ck1Hw+g0pXK5TqTfULoH19f8yEKpNeUgprwjhsIOAa0Gf1hVjinrKnCfGMfmnKcxY9pazEu//uv+Jm7et1FUg8eUlPLdyFhEr/unThAVQ4hHu6un8BXsJkX8s3sGTV/d0jkVFGDSdxa6s8zAdOcZcc0r0wjBnT2zqdSzAwPaNuKl/G591rbQ6ILriaCm7KusIe/Ldn8Bd630VFJchDAZw6QFikTjl33GwUFdxAPwtrROpbRpqmloubBKnqTwKzuj7dvJOaa+mXPlw3X5+2HsMk1G4RWm5+jyS4qOcPpLfDp0GJD1aJvpUCqpuVfCEW5LgIuALIcQb2B3mnYBfalckRXXz7qLpTHxpEKd376NBlw7MeWIcj42czLOrZmE2mIiylIMQlEWYiC+3mxcSKlYTM75902eWeqAs2XHETXmAux06M/dUwA5jx+QN+uGWJ8+avZST0SC45eILAupj8dmdA5n7437NJD5HWPIT/9Ne2TjqfeWdLMHsUUrFbJVcP+snbuzXmkVbNTIlXXAoDFelMejllRws1FcQpS7X84yYC4Q1u49R7qLsTEbB+7f2oUlCtL2/xply5mfkOmUb0tmupFdlHWFFVn7IpfoV3tRWqO41wDtAU2CpECJTSjlSSvmbEOIrIAuwAH9TkVbnB3OeGOf2/pXl73LZQ5fSuCCfE0nJLLpvCC9Ofp3nVs5yKg6AaKuZmzOX8d6lNwHQ+GyhMyrruuG9+XDDgYCuP6an9oTSKC6STskJZP5xIuDP4ppT4isMM61rM77clOcM4bXaZFAtWidc2p7lWfluK5CoCAN/X/Qbfdskkl+k3WTK0ZHweFGpZtY82DPB43y0HtSKBmqn0ZcFoN8FDdmaV+i2UoiLMnJJh6Sge6Ub7JZGJ9ERRpokRJPSpqFulrbddGdfgYVaql/hTW1FW/0P+J/Otn8A/6hZiRThyPo3bnF7n35hfyKWv+c2JoD7Nn7Ff1KvZFDOr0x3VO+1WZiaMwV8mLQcGIAnr+7p9nRqxL1wYnG5fqtdVzo1i6V903i25p6idaMYzTDMvm0TaRQXSd7JEiKNBrf8D399LDxx9GB/d3U26XuPU2axsfNwkW6/8qTYCOeT99Y834l8pRbvxLwnrurGZR2beCmOfyzeoXue3w4WeiUCWm2Sm/u3CVp5lOpk6euZBzs3jfdpulOEjsowV9QZtrx9C+9c+mcvU0e5IYLu+b87q/c6stVf+3YmHQpy/Z73vrQOjJiZzh1zNvNlRh53zNnMnvwiZ/JYUZkl4FDV2y/t4MxWHvTqahZlHuT5cb1ol3SuDMnmPwrp9+L37DhU6LNhUaDc8ekm0vfq93x3ZcLFbZ2v5/7kOyHyLwMvcMvAf+2GFG4f1F4zjHTJjiO659EKDe7dMoH31+6jQ5PA+rc7MBnAaIDYSIOzKkBSfJSueXDhNu/y82A33Skqh1IeijpF7jU3UxbhXonWkWhoNrgvpKOsFpZ9fB9/+3Gez5InX/yS6/V0WmaxYbMGHj4M9ifz55ZkORVOqdle82rBllxyCtwjtyTw3KLf+Pvo7s4JGiDaaOD9NXsBu+P6jRW7ydiv7RgHNMuz++KtNfu45KWVLNiSy4mz+scZDYL7hnViw7RhzL3zYjZMG+bTF6Nn9tPjlwOFbMo5yb7j2iG3ephtdv/+2XIbY1NaOmXSMw+O691Cc3y7n1WXwj9KeSjqFO88eBWPXDmFEpcaWVOvnEJW8oVe2eoCuwJ5ZN1cNrx3G/fqKBFH7ocn5R66I9pk4PGRnUlto+2cL7dKyj1MPSaDgSXbtZ/KbTZJVISBJZMvo7jMLvupUgsfbjhAu8eWcv2sn3h7dTbXz/qJv3ykHZqq92TtoGG092c7fLqcD9dqrzoE9vsx88YUZwRSSpuGTjOao4BgQbF7iZInr+5ZrZOJVuTdVxl5zuKBzuROFyZe0pauOlWOs44U+VTKCv+EW7SVQuGXdxdN576ZQzm0bTcte3fh3Qft7WEn52Ty2rczibJa3CYbAcTYLExdN5f7N37FIy7hvSYB7ZvEkeenXlNUhHA2i3pl+R6f+7pittkY06u5pm3fIuHZxb9RUm71G3XkGgI8a81eFmw7zPjeLRjXu4VmeXYHp0p1Vk9C+4oPXN6RCRUlPFxbzo7v00a3eZaDfa+M5h+Ld/DfzEMUnNF21ofK8G5NWbHTu7zKTR9s5K7L2jMprZNmlvYbK3brntM1Kk4RPEp5KOok7zx4FXCV29i7i6Yz7K4OLPv4fqKs3pOXownVa8ve4lRMAlnJF7Ll7VtYlXWE37bv1y3EGGMyMG1UVwZ1bMI/Fu/wO9EL7NnQrhPsv374nd353lnPxf6aariwdu9x/jL7Z6cPYefhIky+sil9cHP/tsxctYeCM+dWa3GRBgZ1bMLJM+UMeXU1Zyqc09/vPMrLy3ZyqsRCmUU660A99GUmq3flc3Xvlk7n85NX9+SetE5c/NL3ur3lQyFGpzz88TNmXl6+hzdX7WXni1d5hQ4P6dSEt1dnax6rV4FZERhKeSjqFas/vIeXSg/y0LzpRFnKNc0dUZZy3v/vPzAimZyTiUCe67FeUTsrosdAeh/e51Qmzy7O4tnFWT4z3x3cn9aBYd1buGUrL39wKKuyjrBo6yGS4iL5anNeUIoD4ERxqZfzWaflh08iBLy4bBcmgwGTUWAywFmz5Ey5jet1Mre1wn4tEhZkHmZB5mG38Nek+ChuGdBWs25XTIQgMsIQlJ8GYOHWw4xNac6irdomQEePedee62BPqGzeINKr8KRepWVF4Cifh6Le8cRnL/DLms3MGDyBEkOE10pBAPGWMnv/kG/fZIZHlNYbS2fS9WiOW4OqxmcL6X14D418ON4dfLXlIEsy87zCbS/v3py3bu7D34Z1oiRIxZHaOpHNuVXj5LVInE59s1XqNp0KBkf4K9j9Il9tzvPa565BF7DzxavY+uworr2oZdDXGNKpGVNHdNbd/s6abKcMDrLzizQrFj9zdY+gr+9Jdn4RJ8+aw75pU3WhVh6KesmQy3oyZO1n9Ln/Sm7OXMZ9G7/CKgzEmkvdVg9WYfCq7myyWRBIGpTbI4HeWPIGNqOR8oqVyXPD7iKr+YVuJi6jONcX43BhGR9uOMCHGw6Q41EzC2DYa2sINvN19u39mb/pD938jXDAEf76n025miu0T3/OpWliDI1jIxndqwX//dV3BrsnjoiqGSu0fU7F5Ta3vi7gu9FSZSrXOhISH+5l4cGZa93qerlWAa7PKOWhqNc4mlBdMW00zXP28uE3LxDj4g8xShvCjzHKJK0Ii5XoiqZVL694j+LIGCJsVmdtLb1M7XaPLXVTIMGG1joY+I/veebq7t6yCTBGGCgz20LqgFiVrNtzjC8zvFccDsotNl5yKZXeJTlO0w+kRazJwJe/HODJq3syNqUFi7bqR5m5JgFWR6MlvYTEHQcL2fKHfXXo2mOlvqKUh+K84PtX7eVLJo8tcivCOPXKKQDOsUibBYPV9+QugITyEudxWckdaHnaHgmUlXwh4N4Fsd1jS5kwoDUvXpuiG1rrr86TWeJVx+rxkZ2ZlNbJWRF25spdhNJJMBgSKgIBGsVEcNjDHHTodHAdBnfnn2H2xL7cP+9Xv/ueNdv4cMMBZm84wL5XRiPEFhZm6iuQF5buBOymwqpstJSdX8SH67x7vQBOxeHAs0hmfUMpD8V5xbuLptPn/lTn5G5fmcDF96eSXJhPfmIy/XMyuU4ITkfGYrKaMUpJpE2/PMnyj/5GREUEklUYsCEoNUW5mbh+XJbL2IWryUtMBo0ijpVZNTjyMSandWLjj9WrPKZc3pFr+rTm4XlbOHw68Hpfeny/M58zngk1PrABd3/yM43ioxnZvSnLs7S7I+YUnHUzYVVFoyXP2lmBUJ/DgZXyUJx3OBSGKz+7jd3Cvz77LzNvepG8xGQuzclkxrK3sAgj8eYSNyNXtEdEV0RFU6vICn/Jyyveo9QYSbS1nBKjCSGEps8kFF5ZsYcWjWKduRb92ieRucl/g6z+FySy6YBv53tygkkzwmrv0WL6vvh9aAJrkFMQXIY5nOsWGQiuJqxTZ8tZtPVQ0P6I7Pwilv92xKfiGNWzGd/t8M7lqc/hwEp5KBQadGvTmL9+em3Fu1sY9GAqSSfy6Z7/O8+s+hCzIYIoqxlpsxHto/CzAGKsdvNObIWv5eUV71ESEYUB6ZawGCxS4laF9x+Ld9DQYgO0FUha5yQ27j9J1uFiv+fWq8j77bbQ2+vERRrcVhkTL2lLnzYN2biv8isYX6zIyufjH3M0e77r4XB87z5ymuVZ+sUbG8dG8v2Dl9ExOYG/fPSTW4Xj+h4OrJSHQhEAG2aeW5mMfzoN24E/KI6MYenH94MfH4knAoi12P0Dbyyd6exH4ignXxwZQ3x5SUArk1KzjVe+3ck3Ww5iAx7upW8AW7MnuHIcrhFkAG0aRZN7Ur9hU2K0EbPVphv6mxBppKTcRpvG0cy+bYDTfPTUwu1ByRUsVqtVs+d7xv4Cdh0+zcJthxnXu4Wzb/uEj37y2l+PJglRzs/hqHCsoq0UCoUmC56/zvl6cv4+3ljyBqaK1YfD51EWEell4tLCZLPQPf93GpWcZvqyt5FSEmM1U1pR/NHVxAXQPf93wO6YdyiWr7eEthqIjTRyQVKsbvivZwTZNRe11s3WBvxGkR0ptq9mDpwo5YqZa7miWzPW7zlKCMFnmrRpGE2uRjfCH3/XXtnc8uFPzvplm3JOMmPFbmbf1j9gxTHxkrZERdj3dVUaD43oEtoHqGMo5aFQVIJ3F03nT4+k0ibXPqkfadeJknKbm4kL7L6RMmEkSlq9FEpC6RlnOXkHjteOsOAoczkGJMYKn4pZGPlgwDX81vxCiqLi3JRJoJwttzJpcHse+Eq/l7orv+aEVkjQCJp5LcH28vCHluIAiInUNuN5+ukLS62860M5Opg6ojMjezSnY3IC6enpbiuV8yFE14FSHgpFJfnhNW8HvINRjw8h8tBBiiNjaHn6GP/++lki5blZyyyMFEXHYTZEEIN3JrRrWLArkdLK336e73IeA7MGXEt852vpUFDoFjrsS6kEqjgA1u87iUGALcjQsNpuBXrfsI58s+Wgmz+iQZSR0xpZ/vlF/vuo5xeVOk1VZ8v1TWLKbFUNCCFuAJ4FugEDpJQZFePtgJ2AoxTmT1LKe2pDRoWiKvju5Rvd3k8uKWLGt29iFQaM0sbUqx7geIcuXuXkA8F1BRMpbUz+eT4/3DCQVR894hw3C8HTw+9l3kVXhvoRnEgIuClWuNCiQSTj+7RhfJ82bqalXYdPa/Z/79gkFquUXv1dXJmz8Q8mDmxHx+QEikq1/271OUTXQW2tPHYA1wKzNLb9LqVMrVlxFIqaQS/PZPJvGcxY9tY5n4fRRLTVHFAhRgfC4zdApJS8vOI94swl7G7aDrCvRhqWnCb10G4yW3ZhX1KbqvhoYUPDGAMxkSbG9GzOk1f3dI7vOnyajfsKaBYfyYRL2zNjxW4vP81ijXBbLRzlTRKiIwBvBVKfQ3Qd1FYP852AV00hheJ8QCvP5N1F0xn1eD+niSu+vMQtLDjaXObm8whWqTy15t/O9zbcK6Iu7jKINwdPoMuxHJoUn2RD+4vqtEI5VWLjVIm9vtja7OMsf3AoKc9+51QUDuf41mdHcd/cTQErDFcc5U1iI40M7ph0XoXoOhCyFtehQoh04BEPs9VvwB7gNPCUlHKdzrF3A3cDJCcn9503b15A1ywuLiY+Pr7Sstc0Su6aJVzkzjt6mvKSUiwRJqw2SbS5jLjyEpqeOampQIpbtyY+T7++VKCciGnAidhEbEJgkBKz0f6cabJaMBsjsBj8JyMGQ3IM5Hu7dqqEWJORs2Zv/0ZyQhSnSsyUBdl4pEG0iQuS7L3XHd+Ts+VWikotJERHEKvjoA8nHHKnpaVtllL2C+Uc1bbyEEJ8D2g1Nn5SSrlQ57DDQFspZYEQoi+wQAjRQ0p52nNHKeUHwAcA/fr1k0OHDg1IrvT0dALdN5xQctcs4S736Ce/plH2LhLKztDjyO/c/cv/MEkrP7z2Gn96xO7zqMy6XgKlBhPRNjMlRhMRNhsIQZnRRKTNzGcpV7K5dXeKouM41KBpwHkpejzcy8Lr2yOINHhHQVUNWlOdFfsaLLjOFH/u14rbhqYA4f890aMq5K425SGlvCKEY8qAsorXm4UQvwOdgYwqFk+hqNMs/ccNbu+vmDaP5jl7ubxRS56/819cu2MVd/2yALMxgjiPMvSBYG/da8/LcGTGI3HW+Lpjy2Lu2LLYuX+ZMCKFYHb/8fyWfCFF0aGFD5fboFeLOHYcPlPrVYL1GNE9ubZFCAvCKlRXCNEUOCGltAohOgCdAO0SlgqFwomjanB6ejqr/+9m4B5GP/k1xrw8uuf/zvMrZzkjulx9HqGuTjyPi5ZWkHiEDxt5evg9ZDW/EKPVQvuThwJy0G8/HFiZdi2iBJRVo9bpkhxHdn4Rr63cw/jeLehyHrttaytU9xrgHaApsFQIkSmlHAkMAZ4XQpixf8fvkVJWb+EbhaKe4ro62ffbwzz9/FzgXLTV/8tYyA3bV2EDtx4nUDVKJVJaeXnFe5gNRky2cz6HJV0u45kRfwVwlmOJMTem8dkzlSoUCVDuQ3EkREFRcFXjadMoigkDLmBfwVlGdE9m8hdbeHm5vRnVzsNFTO1tZajOsQu25LJk+xHG9GrO+D51NwBBj9qKtvof8D+N8W+Ab2peIoWiftOhR3vmfvl3j9F76H//F7QozOdsZAydj+WQVHySSJuFR9bZFU20xV4NOMJqxYQtJPNXpM3dWT1m93pG7d2IlGAxGIixmknv9job/vU4z11+l7MUyxlTNBf/sQMErOh8SUARYL4WHcEqDpMB1k07Z32ftWavVw95m9TunT7wpZXO9rff7zzKq9/tYuMTw4MTIMwJK7OVQqGoWTZphA0DjHhsBNGHD7kVaRyx50deWPk+ER7KIBSF4liJRFYUlRRSEmMp5+Xl72keM23tHJZ3HMDcPmOcDnpH1j74z6QPBbMNN8WwQKeR12sr97gpjwVbcr36ph8+Xc6CLbn1agWilIdCofBixSt/1hi9hRP7H2PaUx8TUWz3S/TI/507MxaClERpZMmHolj0GJn9CyOzfwFwdoJ0YAVWdryY1R0HcMGJQ6Qc3s3GC1KYd9FVlVIqC7YddiqG8b1baBaRNNtw9gwBWLL9iOa5lmw/opSHQqE4P2ncvjUffu5u/ho45QuancqnLDKGqxqa2bXnIEXRcbQuzOeZVR9itNmcE31l/Mtu/hQPRRUBjMr+mVHZPzvHLsvdwSPrP+d4VJy92rHBSG5ic/516Y380HFAQNfsmBTjfL3j4Cnd/VZk5TuVx5hezTWLPo7ppZW5UHdRykOhUFSKn97SLwzZ5/5LaV2Yj9Fq4drf1nDD9u8pN5qItpSDlE6fhxQCSdUpF9expmXnordanj3Fxd88TwlG/ttzGK2LjtKsqIBVHQfw8cXXea1SFu84StFHG0nP9h234xq+O75PG179bpdbj3dHja36hFIeCoWi2nAvxTKVtet3sHX9VlIuS+GBr7Y5o61uadyY5SP+xvMr33f2RnGlqpVKDFZu3bHS+b7bL3lM/uW/OGLOrAh+aN+XJ8Y8SLqfKu1dkuOcqw4HG58YrqKtFAqFoqoYcllPhlxmL1a45bJzRQvT09O5c/m7XHz/pXSqaHhljI+l295tdDu2jyt3/YgJl1L2FeG/VZWn4sDk/C0ZuT+Dke/cig0oAXpOW+K2r1FAu6Q4lt86VPNcjmq+9RWlPBQKRdjws07019r1O/jwnf8hwRlt1T93B4+v+RijToBuKIpF6xgDEAfse3UMHVwUyFU9mpEQHXpCY11HKQ+FQhH2uK5YXDmx/zmefOBduh7dD0Bew2QuOHGI//vlf8TgXSSrsgplx6tjnCuQdyb0Jz09PYQz1g+U8lAoFHWWxu1b86+Fr2hum3z1I9zx839JOluIyWomqbTIaZZyJRiFEg1c3bMZ70zoH4q49YrgykkqFApFHeHdxa9x0dF9tC0uoEXJaSKl5JGxD7O1WQd2JF3A5z2HU449ysvzR49SUIqjArXyUCgU5w2vL3wNeA2AXhVjj424l4d+mENiub2Sb6TOsRKIr2t9eKsRtfJQKBTnNa+s+CfNyoqJkpJoKTFIye9xTbCC8+cMYFCKww218lAoFAoPOhYfc3tf+z0lww+18lAoFApF0CjloVAoFIqgUcpDoVAoFEGjlIdCoVAogkYpD4VCoVAEjZD1IPxMCHEMOBDg7k2A49UoTnWh5K5ZlNw1i5K7ZnHIfYGUsmkoJ6gXyiMYhBAZUsp+tS1HsCi5axYld82i5K5ZqkJuZbZSKBQKRdAo5aFQKBSKoDkflccHtS1AiCi5axYld82i5K5ZKi33eefzUCgUCkXlOR9XHgqFQqGoJEp5KBQKhSJo6o3yEEKMEkLsFkJkCyEe09geJYT4smL7z0KIdi7bHq8Y3y2EGFkX5BZCtBNClAghMit+3g8zuYcIIbYIISxCiOs9tt0mhNhb8XNbzUldabmtLvd7Uc1JHZDcDwkhsoQQ24QQq4QQF7hsC+f77UvucL7f9wghtlfItl4I0d1lWzjPJ5pyhzSfSCnr/A9gBH4HOmDv5bIV6O6xz73A+xWvbwK+rHjdvWL/KKB9xXmMdUDudsCOML7f7YDewBzgepfxxsC+it+NKl43Cne5K7YVh/H9TgNiK17/1eV7Eu73W1PuOnC/G7i8Hgt8V/E63OcTPbmDnk/qy8pjAJAtpdwnpSwH5gHjPPYZB3xa8Xo+cLkQQlSMz5NSlkkp9wPZFecLd7lrE79ySylzpJTbAJvHsSOBlVLKE1LKk8BKYFRNCE3l5K5NApF7jZTybMXbn4DWFa/D/X7ryV2bBCL3aZe3cZzrXhvW84kPuYOmviiPVkCuy/u8ijHNfaSUFqAQSArw2OqiMnIDtBdC/CqE+EEIMbi6hdWSqYJg7lm4329fRAshMoQQPwkhxlepZL4JVu47gGUhHluVVEZuCPP7LYT4mxDid2A6cH8wx1YTlZEbgpxPVCfBusthoK2UskAI0RdYIITo4fFkoahaLpBSHhRCdABWCyG2Syl/r22hXBFCTAD6AX+qbVmCQUfusL7fUsr3gPeEELcATwE16k8KFR25g55P6svK4yDQxuV964oxzX2EEBFAIlAQ4LHVRchyVyyLCwCklJux2zo7V7vEHjJVEMw9C/f7rYuU8mDF731AOnBRVQrng4DkFkJcATwJjJVSlgVzbDVRGbnD/n67MA8YH+KxVUnIcoc0n9SEI6cGHEUR2B2B7TnnKOrhsc/fcHc8f1XxugfuDq591JyDqzJyN3XIid1BdhBoHC5yu+z7Cd4O8/3YnbeNKl7XBbkbAVEVr5sAe/FwRtby9+Siin/4Th7jYX2/fcgd7ve7k8vrq4GMitfhPp/oyR30fFLtH6imfoCrgD0VX8QnK8aex/40AxANfI3dgfUL0MHl2CcrjtsNXFkX5AauA34DMoEtwNVhJnd/7DbXM9hXeL+5HPt/FZ8nG/h/dUFu4FJge8U/5HbgjjCT+3sgv+L7kAksqiP3W1PuOnC/33L5/1uDyyQd5vOJptyhzCeqPIlCoVAogqa++DwUCoVCUYMo5aFQKBSKoFHKQ6FQKBRBo5SHQqFQKIJGKQ+FQqFQBI1SHgpFEAghPvGstqtQnI8o5aFQKBSKoFHKQ6HwgRBiYkWvia1CiM8qhocIIX4UQuxzrEKEEPEV/Si2VPRLGFcx3k4IsVMI8aEQ4jchxAohREzFtv4V584UQswQQuyoGDdWvN9UsX1SrXx4hcIHSnkoFDoIIXpgLxw3TEqZAkyp2NQCuAwYA7xSMVYKXCOl7IO9R8XrLqXzOwHvSSl7AKewZ/MCfAxMklKmAlaXS98BFEop+2PPeL9LCNG+6j+hQhE6qqquQqHPMOBrKeVxACnliQp9sEBKaQOyhBDJFfsK4CUhxBDsvUBaAY5t+6WUmRWvNwPthBANgQQp5caK8S+wKyOAEUBvF99KInYFtL/qP6JCERpKeSgUwVPm8tqxurgVe3G5vlJKsxAiB3tdMs/9rUCMn/ML4D4p5fIqkFWhqBaU2Uqh0Gc1cIMQIglACNHYx76JwNEKxZEGXODrxFLKU0CREOLiiqGbXDYvB/4qhDBVXLezECIuxM+gUFQLauWhUOggpfxNCPEP4AchhBX41cfunwOLhRDbgQxgVwCXuAP4UAhhA37A3iUS4CPsPaW3VPhNjnGuX4RCERaoqroKRS0hhIiXUhZXvH4MaCGlnOLnMIUiLFArD4Wi9hgthHgc+//hAeD22hVHoQgctfJQKBQKRdAoh7lCoVAogkYpD4VCoVAEjVIeCoVCoQgapTwUCoVCETRKeSgUCoUiaP4/owIrkOLVL78AAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "all_gens = [a + 1 for a in range(100)]\n",
+    "plot_all_gens(all_gens, results_dir, save_path=None)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all_pareto_df = get_overall_pareto_df(100, results_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Comparison with Heuristic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_candidate(results_dir: Path, cand_id: str, cand_params: dict[str, int]) -> Candidate:\n",
+    "    cand_path = results_dir / str(int(cand_id.split('_')[0])+1) / f\"{cand_id}.pt\"\n",
+    "    cand = Candidate(**cand_params, device=\"mps\", cand_id=cand_id)\n",
+    "    cand.load_state_dict(torch.load(cand_path))\n",
+    "    return cand"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nnp = NeuralNetPredictor.from_pretrained(\"predictors/neural_network/trained_models/no_overlap_nn\")\n",
+    "\n",
+    "candidate_params = {\"in_size\": len(constants.CAO_MAPPING[\"context\"]), \"hidden_size\": 16, \"out_size\": len(constants.RECO_COLS)}\n",
+    "# Set up new PrescriptorManager\n",
+    "cands = [load_candidate(results_dir, cand_id, candidate_params) for cand_id in all_pareto_df[\"id\"]]\n",
+    "prescs = {cand.cand_id: LandUsePrescriptor(cand, dataset.encoder) for cand in cands}\n",
+    "torch_manager = PrescriptorManager(prescs, nnp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_df = dataset.test_df.sample(frac=0.01, random_state=100)\n",
+    "encoded_test_df = dataset.encoder.encode_as_df(test_df)\n",
+    "\n",
+    "context_df = test_df[constants.CAO_MAPPING[\"context\"]]\n",
+    "encoded_context_df = encoded_test_df[constants.CAO_MAPPING[\"context\"]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Trained Prescriptors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluate_prescriptor(prescriptor_manager: PrescriptorManager, cand_id: str, context_df: pd.DataFrame):\n",
+    "    context_actions_df = prescriptor_manager.prescribe(cand_id, context_df)\n",
+    "    eluc_df, change_df = prescriptor_manager.predict_metrics(context_actions_df)\n",
+    "    return eluc_df[\"ELUC\"].mean(), change_df[\"change\"].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 213/213 [12:17<00:00,  3.46s/it]\n",
-      "100%|██████████| 397/397 [02:15<00:00,  2.93it/s]\n"
+      "100%|██████████| 397/397 [01:49<00:00,  3.63it/s]\n"
      ]
     }
    ],
    "source": [
-    "assert len(esp_all_pareto_df[\"id\"].unique()) == len(esp_all_pareto_df)\n",
-    "assert len(torch_all_pareto_df[\"id\"].unique()) == len(torch_all_pareto_df)\n",
+    "assert len(all_pareto_df[\"id\"].unique()) == len(all_pareto_df)\n",
+    "\n",
+    "ids = all_pareto_df[\"id\"].tolist()\n",
+    "elucs = []\n",
+    "changes = []\n",
+    "for cand_id in tqdm(ids):\n",
+    "    eluc, change = evaluate_prescriptor(torch_manager, cand_id, context_df)\n",
+    "    elucs.append(eluc)\n",
+    "    changes.append(change)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Heuristics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pcts = [i/len(ids) for i in range(1, len(ids) + 1)]\n",
     "\n",
-    "esp_ids = esp_all_pareto_df[\"id\"].tolist()\n",
-    "esp_elucs = []\n",
-    "esp_changes = []\n",
-    "for id in tqdm(esp_ids):\n",
-    "    eluc, change = evaluate_prescriptor(context_df, unileaf_prescriptor, cand_id=id, results_dir=esp_results_dir)\n",
-    "    esp_elucs.append(eluc)\n",
-    "    esp_changes.append(change)\n",
+    "linreg = LinearRegression()\n",
+    "linreg.fit(dataset.train_df[constants.DIFF_LAND_USE_COLS], dataset.train_df[\"ELUC\"])\n",
+    "coefs = linreg.coef_\n",
+    "coef_dict = dict(zip(constants.LAND_USE_COLS, coefs))\n",
+    "reco_coefs = []\n",
+    "for col in constants.RECO_COLS:\n",
+    "    reco_coefs.append(coef_dict[col])\n",
     "\n",
-    "torch_ids = torch_all_pareto_df[\"id\"].tolist()\n",
-    "torch_elucs = []\n",
-    "torch_changes = []\n",
-    "for id in tqdm(torch_ids):\n",
-    "    eluc, change = evaluate_prescriptor(context_df, torch_prescriptor, cand_id=id, results_dir=torch_results_dir)\n",
-    "    torch_elucs.append(eluc)\n",
-    "    torch_changes.append(change)"
+    "even_manager = PrescriptorManager({str(pct): EvenHeuristic(pct, \"secdf\") for pct in pcts}, nnp)\n",
+    "perfect_manager = PrescriptorManager({str(pct): PerfectHeuristic(pct, reco_coefs) for pct in pcts}, nnp)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 213/213 [01:43<00:00,  2.06it/s]\n"
+      "100%|██████████| 397/397 [02:47<00:00,  2.36it/s]\n"
      ]
     }
    ],
    "source": [
-    "pcts = [i/len(esp_ids) for i in range(1, len(esp_ids) + 1)]\n",
     "even_elucs = []\n",
     "even_changes = []\n",
     "perfect_elucs = []\n",
     "perfect_changes = []\n",
     "for pct in tqdm(pcts):\n",
-    "    even_eluc, even_change = evaluate_prescriptor(context_df, even_heuristic, pct=pct)\n",
+    "    even_eluc, even_change = evaluate_prescriptor(even_manager, str(pct), context_df)\n",
     "    even_elucs.append(even_eluc)\n",
     "    even_changes.append(even_change)\n",
-    "    perfect_eluc, perfect_change = evaluate_prescriptor(context_df, perfect_heuristic, pct=pct)\n",
+    "    perfect_eluc, perfect_change = evaluate_prescriptor(perfect_manager, str(pct), context_df)\n",
     "    perfect_elucs.append(perfect_eluc)\n",
     "    perfect_changes.append(perfect_change)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Comparison"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -3495,17 +487,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
-    "esp_changes_sorted, esp_elucs_sorted = order_pareto_points(esp_changes, esp_elucs)\n",
-    "torch_changes_sorted, torch_elucs_sorted = order_pareto_points(torch_changes, torch_elucs)"
+    "changes_sorted, elucs_sorted = order_pareto_points(changes, elucs)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -3523,12 +514,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -3543,15 +534,14 @@
     "all_results = {\n",
     "    \"Even Heuristic\": (even_changes, even_elucs, \"green\"),\n",
     "    \"Perfect Heuristic\": (perfect_changes, perfect_elucs, \"lightgreen\"),\n",
-    "    \"ESP Prescriptors\": (esp_changes, esp_elucs, \"red\"),\n",
-    "    \"Torch Prescriptors\": (torch_changes, torch_elucs, \"orange\")\n",
+    "    \"Trained Prescriptors\": (changes, elucs, \"orange\")\n",
     "}\n",
     "plot_result_pareto(all_results)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -3617,29 +607,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Even hypervolume: 19.883448199417447\n",
-      "Perfect hypervolume: 20.450602282335318\n",
-      "ESP hypervolume: 20.704040842702252\n",
-      "Torch hypervolume: 20.37706786923874\n"
+      "Even hypervolume: 19.896059487032417\n",
+      "Perfect hypervolume: 20.46381337096913\n",
+      "Trained hypervolume: 20.377067863712263\n"
      ]
     }
    ],
    "source": [
     "# Filter out points that are dominated by others\n",
-    "esp_changes_filtered, esp_elucs_filtered = filter_dominating(esp_changes_sorted, esp_elucs_sorted)\n",
-    "torch_changes_filtered, torch_elucs_filtered = filter_dominating(torch_changes_sorted, torch_elucs_sorted)\n",
+    "changes_filtered, elucs_filtered = filter_dominating(changes_sorted, elucs_sorted)\n",
     "\n",
     "print(f\"Even hypervolume: {two_dim_decreasing_neg_hypervolume(even_changes, even_elucs)}\")\n",
     "print(f\"Perfect hypervolume: {two_dim_decreasing_neg_hypervolume(perfect_changes, perfect_elucs)}\")\n",
-    "print(f\"ESP hypervolume: {two_dim_decreasing_neg_hypervolume(esp_changes_filtered, esp_elucs_filtered)}\")\n",
-    "print(f\"Torch hypervolume: {two_dim_decreasing_neg_hypervolume(torch_changes_filtered, torch_elucs_filtered)}\")"
+    "print(f\"Trained hypervolume: {two_dim_decreasing_neg_hypervolume(changes_filtered, elucs_filtered)}\")"
    ]
   },
   {
@@ -3651,7 +638,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -3676,12 +663,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -3696,14 +683,12 @@
     "pct = 0.2\n",
     "even_idx = get_idx_close(pct, even_changes)\n",
     "perfect_idx = get_idx_close(pct, perfect_changes)\n",
-    "esp_idx = get_idx_close(pct, esp_changes_sorted) - 1\n",
-    "torch_idx = get_idx_close(pct, torch_changes_sorted) - 1\n",
+    "idx = get_idx_close(pct, changes_sorted) - 1\n",
     "\n",
     "selected_points = {\n",
     "    \"Even Heuristic\": (even_changes[even_idx], even_elucs[even_idx], \"green\"),\n",
     "    \"Perfect Heuristic\": (perfect_changes[perfect_idx], perfect_elucs[perfect_idx], \"lightgreen\"),\n",
-    "    \"ESP Prescriptors\": (esp_changes_sorted[esp_idx], esp_elucs_sorted[esp_idx], \"red\"),\n",
-    "    \"Torch Prescriptors\": (torch_changes_sorted[torch_idx], torch_elucs_sorted[torch_idx], \"orange\")\n",
+    "    \"Trained Prescriptors\": (changes_sorted[idx], elucs_sorted[idx], \"red\"),\n",
     "}\n",
     "\n",
     "plot_selected_points(selected_points)"
@@ -3711,13 +696,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def trained_prescribe_and_predict(context_df: pd.DataFrame, prescriptor: Prescriptor, **kwargs):\n",
-    "    context_actions_df = prescriptor.prescribe_land_use(context_df, **kwargs)\n",
-    "    eluc_df, change_df = prescriptor.predict_metrics(context_actions_df)\n",
+    "def trained_prescribe_and_predict(prescriptor_manager: PrescriptorManager, cand_id: str, context_df: pd.DataFrame):\n",
+    "    context_actions_df = prescriptor_manager.prescribe(cand_id, context_df)\n",
+    "    eluc_df, change_df = prescriptor_manager.predict_metrics(context_actions_df)\n",
     "    context_actions_df[\"ELUC\"] = eluc_df[\"ELUC\"]\n",
     "    context_actions_df[\"change\"] = change_df[\"change\"]\n",
     "    return context_actions_df"
@@ -3725,33 +710,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": 30,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "757/757 [==============================] - 3s 4ms/step\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "esp_unsorted_idx = esp_changes.index(esp_changes_sorted[esp_idx])\n",
-    "esp_id = esp_all_pareto_df[\"id\"].iloc[esp_unsorted_idx]\n",
-    "esp_result = trained_prescribe_and_predict(context_df, unileaf_prescriptor, cand_id=esp_id, results_dir=esp_results_dir)\n",
-    "\n",
-    "torch_unsorted_idx = torch_changes.index(torch_changes_sorted[torch_idx])\n",
-    "torch_id = torch_all_pareto_df[\"id\"].iloc[torch_unsorted_idx]\n",
-    "torch_result = trained_prescribe_and_predict(context_df, torch_prescriptor, cand_id=torch_id, results_dir=torch_results_dir)\n",
+    "unsorted_idx = changes.index(changes_sorted[idx])\n",
+    "trained_id = all_pareto_df[\"id\"].iloc[unsorted_idx]\n",
+    "trained_result = trained_prescribe_and_predict(torch_manager, trained_id, context_df)\n",
     "\n",
-    "even_result = trained_prescribe_and_predict(context_df, even_heuristic, pct=pcts[even_idx])\n",
-    "perfect_result = trained_prescribe_and_predict(context_df, perfect_heuristic, pct=pcts[perfect_idx])"
+    "even_result = trained_prescribe_and_predict(even_manager, str(pcts[even_idx]), context_df)\n",
+    "perfect_result = trained_prescribe_and_predict(perfect_manager, str(pcts[perfect_idx]), context_df)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -3775,12 +748,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 60,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEGCAYAAACZ0MnKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAA2gklEQVR4nO3deXhU5dn48e9NCHsIBLAKEoIVVJYAYROooiBKhVcraIuNvqBRqrhhKyrygguk1WorqLUYG8VqWnF7K+LWYt1eUCxgVFDUiGzGn0LCEpAlJM/vjzMzzEzOmTmTzJrcn+vKlcmZM2eeDGTueZb7fsQYg1JKKeVGs0Q3QCmlVOrQoKGUUso1DRpKKaVc06ChlFLKNQ0aSimlXGue6AbEUufOnU1OTk6im6GUUill7dq1O40xXezua9RBIycnhzVr1iS6GUoplVJEZIvTfTo8pZRSyjUNGkoppVzToKGUUsq1Rj2noZQKrbq6mu3bt3Pw4MFEN0UlQKtWrTj++ONJT093/RgNGko1Ydu3bycjI4OcnBxEJNHNUXFkjKGiooLt27fTs2dP14/T4SknM2ZA8+YgYn2fMSPRLVIq6g4ePEinTp00YDRBIkKnTp0i7mWmXNAQkfEi8rmIlInIrbF4jvsr7mfhgt4s/P4+Flbcz8Lv7+OO0d/VDRwlJZCTA82aWd9LStzdlwjJ1h6VNDRgNF31+bdPqaAhImnAn4CfAn2Ai0WkTzSf4/6K+xGROl8dxp3GPfN6UPzyLdaJJSUwfTps2QLGWN+nT7eOh7ovEm7e6N30iGbMgEsvDWzPJZdoL0opFbGUChrAMKDMGLPJGHMYeBo4P5pP4A0SdsdbtWxF1YjjWFi5kPkjv6B4+smBJ/3wA8yZY3398IP9feAuGLgJPGedBX/+M9TUWD/X1Fg/t2t39LySEli82LqGHe9jRI5+ZWQEPl57KCpGKioqGDhwIAMHDuTYY4+lW7duvp8PHz4c8rFr1qzh+uuvj0o7lixZwrXXXmt7vEuXLgwcOJA+ffrw6KOPRuX53Jg3bx4rVqwIec4//vEPPv300zi1yCKptAmTiFwIjDfGXOH5+VJguDHmWr9zpgPTAbKzswdv2eKY2GhrYeVC1102Yww/HNjPj+57gYKF67wN8N5p9wvAk09ab/7+QaVNGygqgvz8o8dycqxAEaxHD9i82XrzvuQS58Z5rzlnjv11wmneHK68Ep54IrCt6enQvj1UVkJ2NhQWBrZbpZTPPvuMU045JdHNAOCOO+6gXbt23HTTTb5jR44coXnz2K/XWbJkCWvWrOGhhx5yPP7999/Tt29f1q9fz49+9KOYtrGmpoa0tLSw502bNo2JEydy4YUXur52cHvt/g+IyFpjzBC7x6daTyMsY0yRMWaIMWZIly62pVOiRkRo26YdlbOnUDwzzzqYnW192cnODt8L8dq61f4a3uPB5wfzXtPpOuEcOWIFneC2VldDRUXDht1U6opDz3PatGlcddVVDB8+nJtvvpkPPviAESNGMGjQIEaOHMnnn38OwFtvvcXEiRMBK+BcfvnlnHHGGZxwwgk88MADvus99dRTDBs2jIEDB/KrX/2KGk/P/PHHH6d3794MGzaMlStXhm3XMcccw49//GO2bNlSp41fffUV48ePZ/DgwZx22mls3LgRgGeffZZ+/foxYMAATj/9dMAKCDfddBP9+vUjNzeXBx98ELDKHt1yyy3k5eXx7LPPMm3aNJ577jnffTfffDP9+/dn2LBhlJWVsWrVKpYtW8asWbMYOHAgX331FaWlpZx66qnk5uZywQUXsGvXLgDOOOMMZs6cyZAhQ1i0aFGD/n1SbcntN0B3v5+P9xyLGm/PK5IJohbpLSi/fiIUbbQ+ea9cWXdIqE0b675LL7W/SPCbe3a2fQ/BG5DcBIOtW52v44Z32CsUb3DS3kbj5x0y9X6Q8H5ogKj/+2/fvp1Vq1aRlpbG3r17effdd2nevDkrVqzgtttu4/nnn6/zmI0bN/Lmm29SVVXFSSedxNVXX01ZWRlLly5l5cqVpKenM2PGDEpKShg3bhy33347a9euJTMzkzPPPJNBgwaFbNOmTZvYtGkTJ554Yp02jh07lsWLF9OrVy9Wr17NjBkz+Pe//81dd93F66+/Trdu3di9ezcARUVFbN68mdLSUpo3b05lZaXvOTp16sS6ddaoxWuvvRbw/JmZmXzyySf89a9/ZebMmSxfvpzzzjsvoKfhDUKjR49m3rx53HnnnSxcuBCAw4cPR6UWX6oFjf8AvUSkJ1awmAL8MppPcGOnG7m/4n4gssCRkdkRiooo7vAx383pRpsFfwQ4Onx1aLj1h+UZLiqemUf59RPJyOxI1Z5ddH38LQr8L1hYaD+MVVho3XYTDLzDR8HXibb69mZUagnVS45y0Ljooot8wzN79uxh6tSpfPnll4gI1dXVto+ZMGECLVu2pGXLlhxzzDF89913vPHGG6xdu5ahQ4cCcODAAY455hhWr17NGWecgXc04he/+AVffPGF7XWXLl3K//3f/9GyZUseeeQRsrKyAtq4b98+Vq1axUUXXeR7zKFDhwAYNWoU06ZN4+c//zmTJk0CYMWKFVx11VW+ISLv9bztcHLxxRf7vt9444117t+zZw+7d+9m9OjRAEydOjWgTaGuHYmUGp4yxhwBrgVeBz4DnjHGbIj289zY6UYy3vuW/T/sw+2cT62p5baTP6BqxHG0bdPON6Hetk07dt/2S4ozP7JOLCyk+KZhVM6eQvsOWYgI7TtkUXntRIrLio9eMD/fGh7q0cOaC+nRI3Deo7DQCiJOWrQ4Ot8QfJ2xY63hhWhxGo5TjUu4IdMoatu2re/23LlzOfPMM1m/fj0vvfSSY15By5YtfbfT0tI4cuQIxhimTp1KaWkppaWlfP7559xxxx0RteUXv/gFpaWlrF69mgsuuKBOG2tra+nQoYPvOUpLS/nss88AWLx4MQsWLGDbtm0MHjyYiooK1793MP8PsfVZKhvq2pFIqaABYIx5xRjT2xjzY2NMYayep2DCPdzWbQ4/HNjv6vy0Zmkc07On7T9m8+bNKZ9+ltW9z8+n/NpzaZHeIuCcFuktKG9ZHvjA/Hxr0ru21vru/2kuPx+mTj068R7MP9gFX2fFCmvo6amnrCDSEP69H9W4hZqri6E9e/bQrVs3wJqYjsTYsWN57rnn+P777wGorKxky5YtDB8+nLfffpuKigqqq6t59tln692+9u3b07NnT981jDF89JH1IfGrr75i+PDh3HXXXXTp0oVt27Yxbtw4HnnkEY4cOeJrkxtLly71fR8xYgQAGRkZVFVVAdbwVceOHXn33XcBePLJJ329jmhKuaARbz8q3ev7xw0nVPTPyOzomzTOyMi0P6dtRvgn8Z+ILCpyXkpbXR1+stwbTIwBFys1bAWv+koB8zbNY2HlQt/XvE3zEt2k1GDXu43Dh4abb76Z2bNnM2jQINd/i159+vRhwYIFnH322eTm5jJu3Di+/fZbjjvuOO644w5GjBjBqFGjGryCrKSkhOLiYgYMGEDfvn158cUXAZg1axb9+/enX79+jBw5kgEDBnDFFVeQnZ1Nbm4uAwYM4G9/+5ur59i1axe5ubksWrSI+++3htCnTJnCvffey6BBg/jqq6944oknmDVrFrm5uZSWljJvXvT/b6fUkttIDRkyxERj4qf45VvYOTiLli1a1jt7tqa2hl93/g306MH8dwto3659nXP27q5k7qrezm/CJSVw2WVWQHBDxOpduDFjhpWvEQnv8t8UMm/TPLI8w4Jexhgqd1dy1wl3JbBliRHxktuSkqOr8nTJddx4N5Tr3Llz1K8d6ZLbVJsIT4iCCfcAVvAo79uKjPYdqTW1pDVz/+m8mXg6dVu30vVQVypbVgYMURljyMjsyPyRX9B19igK7nmv7h/lDTe4DxgQ2bDBqFHw17/CfnfDcfX5hFlcVkx5y3Iy2mZQtb+Kroe6UnBiQfgHRlFwwACrh5jVIcvhESpAfr4GiSZOh6ciUDDhHubm3MnMrJlkvv8dh6sDM1ZD9dqq9ljrpcnOpuDEArIeWs7e3ZUYYzDG+CbO23fIovLGn1F8w6C6eRBhJtHq2LLlaHa30/r6khLo3NlKFAwXMIIn5cH1mv3ismIq21fSvl176/ds157K9pWBk/9KKVubN2+OSS+jPjRo1FPBhHvI+s9O9u6x3vj37qlk99oNtiuuDlcfpusDywM+nRcseJeuDyyn1tTW+eTry/uAgMS/4pl5zN80j4UV9zN/07yjCYWh7Ntn5YZcckndkiQzZljf3QSjHj2stmdnW0MTN9wAl19et55V5862waO8Zbm7yX+lVFLT4akG8A5bAZAF5Fg3/YexqvbsousDyyn434qASePiW0ZQeePPaOEwxJWR2fHoD1u3UvzyLdYyXc8bb/sOWVYmOhwtYeLErgf0ww/u5zDatIFzzw3M93AKNBUVtglfTpP8rib/lVJJQ4NGDNQJJvffCfcHnlM+/SxfALDjG84CyM6mvG+rOuf7eiThgoafOkmFDywPHXS8PQy7xC4nNglfVfurbCf/q/ZXWa+RUiol6PBUggT0JIL4hrPAN6SV0d7+/FDXCVY8M69uUqF/3Sx/bdpYeRze/JBIE7iCzu96qGudOaDD1YfpeqhrZNdVSiWUBo04K375Fn77jfOqo5raGrIeWk7Bog8DssCr9u6yPd+/RxJuzqP8+on28wre+ROvTp3q5l9EmsDlLY3gmYAv6H2lNfm/d7c1B7RvL1l7s+K+ekoln7S0NF859IEDB3L33XfH7Ln8ixx6+RcGbKjy8vKQFWd3797Nww8/7Pr8ZKTDU3FU/PItVA7tTFuHYSljDJnvf0fBXW9DUMpA1ze+pvK/2gW86fv3SHy9iBBzHk69kjrHd+6se5JdDav0dKsartOqsaACdwXz34E/rPEEpJn2j1FNTuvWrSktLU10MxrsyJEjdO3aNWQA8gaNGZ6Nz8Kdn4y0pxFH5X1b1fmkH6xqxHHM33z70R0CAUpKKLj+ebJ+97Rvme7e3ZVk/e5pX0Bw04sImCfxf07/42lpzktnW7c+elvEyhlxChiVle7LwKuUUfJJCTkLc2h2ZzNyFuZQ8klsyuK/9tprAcX2/HsI//znPxkxYgR5eXlcdNFF7Nu3D7AS4G6//Xby8vLo37+/rzx5JNauXcvo0aMZPHgw55xzDt9++y1glRb3Jgrv3LmTnJwcwCprct555zFmzBjGjh3L5s2b6devHwAbNmzwlWTPzc3lyy+/5NZbb+Wrr75i4MCBzJo1K+B8p5LpyUZ7GnHkNC/h5V162z4zi8qhhyl++RZrUt3z5luwcJ3jpLebXkTXB5ZTOXuKY28FsGpSBa9+Ci6JDc7Bwsu7NNeOw/FkSP5Tzko+KWH6S9P5odr6f7Blzxamv2T9X8nvX/+EvwMHDjBw4EDfz7Nnz2by5MlMnz6d/fv307ZtW5YuXcqUKVPYuXMnCxYsYMWKFbRt25Z77rmHP/7xj75yGZ07d2bdunU8/PDD3HffffzlL3+p83zvvvtuwPNt3bqViRMnUl1dzXXXXceLL75Ily5dWLp0KXPmzOGxxx4L2f5169bx8ccfk5WVxWa/CgmLFy/mhhtuID8/n8OHD1NTU8Pdd9/N+vXrfT0r//NDlUxPJho04qhq7y7aZ7pbKtQivQXlfVtZP7iYhK7as4v2NlnN3l6Eb9VU83RqamtoJs2cV08Fr37y6zG4Wn3lzUdx2jXQZn7El/yXbq2wat+uPZUtreQ/DRzJYc4bc3wBw+uH6h+Y88acBgUNp+Gp8ePH89JLL3HhhRfy8ssv8/vf/563336bTz/9lFGjRgHWHhHe4n2Ar/z44MGDeeGFF2yf77TTTmP58qMflKZNmwbA559/zvr16xk3bhxgffI/7rjjwrZ/3LhxAeXNvUaMGEFhYSHbt29n0qRJ9OrVK+R1QpVMTyYaNOKo64aDVA49XKd8CNgXO/T1TMLtndGmDV3/7TznETzfkSZpvvscl9v6ByrPbTfzJohY1Xe9ASfUniB+yluW+wKGlyb/JZete+w/vDgdb6gpU6bw0EMPkZWVxZAhQ8jIyMAYw7hx4/j73/9u+xhveXRvafRIGGPo27cv7733Xp37mjdvTq2njltwaXankuO//OUvGT58OC+//DLnnnsujzzyCCeccEJEbUpGOqcRR3ZZ5Bnvfeu8Msp7vLDQuQR6WhoUFVFQ8Nc618566RMK/rfC/aopf/69Ac9tV9cxBl55xbpts5dH8TPXMv/0TSysXMj8bfN9ZURSMvkvDlufJpPsTPsVdE7HG2r06NGsW7eORx99lClTpgBw6qmnsnLlSsrKygDYv3+/4+ZJkTrppJPYsWOHL2hUV1ezYYO1XU9OTg5r164FcD1xvWnTJk444QSuv/56zj//fD7++OOAUubB6lsyPd60pxFndlnk1qqqw3V7CRsOWlnm+flWiQ47tbW+T/V1rl1gfWVULrR9qG++Q8R+a1ovz8op16uv/HspfgXujg5BeXoqfkNQVS1TLPkvjlufJovCsYUBcxoAbdLbUDi2YaXRg+c0xo8fz913301aWhoTJ05kyZIlPPHEEwB06dKFJUuWcPHFF/t2x1uwYAG9e/duUBsAWrRowXPPPcf111/Pnj17OHLkCDNnzqRv377cdNNN/PznP6eoqIgJEya4ut4zzzzDk08+SXp6Osceeyy33XYbWVlZjBo1in79+vHTn/6Ua665xnf+FVdcwRdffEFubi7p6elceeWVXHvttQ3+vaJNS6MniYDSI3t30XXDwcAgkJNjP0Tlojz5/G3z7Uux79vL3O5z3ZW7njGD+bO62M6b7N1dyVz/suIObQrVjq6HulLZvrJO4Ix2LsfCyoW2Q4HGGGZmzXR/oQb8eySTSEujl3xSwpw35rB1z1ayM7MpHFvYoPkMlXhaGj1FOdWx8vHLk6gzGe1dZeXArhR7QDa2m3LXr7xC15adwq++ClEyPdQQVEH3gtRaPRXHrU+TSX7/fA0STZwGjVThHeJZ/zCVN/4scDLaf3mujYITI39DrnP+BZ0oWLiOYqi7eup/K6whrjCb8oSrPxXQnmQckvLntDhB90tXjZwGjVSSn0/55i/sCxd6l+c6iOQN2Xb5q/8qKf8VVxEMx4Tt8YSRVD0Ruwx53S9dNQG6eirFOBYuDJM4WPzyLczffLu1aik44zyI494XwautvG+SLlcRFZxYQNbeLPbu2xtYf2p1q7CPT7pNnGxWhqXifulKRUp7GinGKUGwau8uxx6Et+aVb0grOOM8iOPcQ2ZH683Rf8IcIlpFVKfH43IVUlLmcejWp6oJ0p5Gium64aB9ifENBx0eYV/zKtSQVtV++3XkVfurrKGo2tqjJdPd1JcK1RNxWZ8qJfM4lGqENGikGLsEwaz/7Ay5eirSIa2I9r7wWy0UUJr9zanWEJi3JxG81aw3cLhchRQykKmU5i2N3q9fPy666CJ+cLvZl8esWbPo27cvs2bNivi5f/vb3zrel5OTw06/is92ZdUb4oorruDTTz91vH/JkiWUl5e7Pj9eNGikoIIJ9zA3505mZs1kbs6dIQMGED7jPPj6TnMPdpPOntVCths8De1M8fqHQ/cknFYbBR2P1iZOhw4fiui4ij1v7an169fTokULFi9e7Opx3szpoqIiPv74Y+69996InztU0Iilmpoa/vKXv9CnTx/Hc4KDRrjz40WDRhNQnyGtghMLmNt9rhWYus91XqVUWAht2jiXGJl+lv3jvD0Jz+MD2KxCiiiQhfDhFx8SnNBqjOHDLz6M6DpN1cZDG3lsz2Ms2rWIx/Y8xsZDkZcfD+W0006jrKyM/fv3c/nllzNs2DAGDRrEiy++CNQtRX7eeeexb98+Bg8ezNKlS9mxYweTJ09m6NChDB06lJUrVwKwb98+LrvsMvr3709ubi7PP/88t956qy8bPT/CualQ7fPP4p44cSJvvfUWAO3ateM3v/kNAwYM4L333vOVW6+pqWHatGn069eP/v37c//99/Pcc8+xZs0a8vPzGThwIAcOHAgoz/7aa6+Rl5fHgAEDGDt2bENf9ojoRHgTUDDhnvAZ5/Xl+WPLyNxhe7fjdrTenoR/Jd1QGelEJ4/jlJxT6mSEiwin5LjPim6qNh7ayBs/vMERrE/4VbVVvPHDGwCc3PLkBl//yJEjvPrqq4wfP57CwkLGjBnDY489xu7duxk2bBhnnWV9APEvRQ7Wm7G3Su4vf/lLbrzxRn7yk5+wdetWzjnnHD777DPmz59PZmYmn3zyCQC7du1i8uTJPPTQQyE3gDrzzDNJS0sDrMBz8snW7xmqfU7279/P8OHD+cMf/hBwvLS0lG+++Yb169cD1kZNHTp04KGHHuK+++5jyJDAxOwdO3Zw5ZVX8s4779CzZ8+416jSoNFEhM04b4j8fKo2326/qmvPLqvnECqfIY6rkDLbZUZ0XB216uAqX8DwOsIRVh1c1aCg4V976rTTTqOgoICRI0eybNky7rvvPsCqLLvV0zt1KkUOVnlx/3H/vXv3sm/fPlasWMHTTz/tO96xY+gl6l5vvvkmnTt3Bqw5DW97/vnPfzq2z0laWhqTJ0+uc/yEE05g06ZNXHfddUyYMIGzzz475HXef/99Tj/9dHr27AnEv4R60gUNEbkX+C/gMPAVcJkxZrfnvtlYZfhqgOuNMa8nqp0qkF3Z98PVh+n66UErf8FFTyIe9uzbQ4eMDrbHkz4LPcGqah0WIzgcd8tuPw1jDM8//zwnnXRSwPHVq1c7liIHqK2t5f3336dVq9DJrg3l1L61a9f6SqhDYBn1Vq1a+Xot/jp27MhHH33E66+/zuLFi3nmmWfCbvyUSMk4p/EvoJ8xJhf4ApgNICJ9gClAX2A88LCI1P0XUAkRclVXfn7dpboJ8up7r9rO77z63qsJalHqyGjmsOzZ4XhDnHPOOTz44IO++acPP3Q353T22WcHbJPqDUbjxo3jT3/6k+/4rl3WIpD09HSqq6uj1r6cnBxKS0upra1l27ZtfPDBB2GvtXPnTmpra5k8eTILFixg3Tqr4oJTGfVTTz2Vd955h6+//hqIfwn1pOtpGGP+6ffj+8CFntvnA08bYw4BX4tIGTAMqLtjigorFnMcUR0Cc1N5tx5Wb1xNdW01E0dOpGNGR3ZV7WL5quWs+8JhMyrlM7LVyIA5DYDmNGdkq5FRf665c+cyc+ZMcnNzqa2tpWfPngG77Tl54IEHuOaaa8jNzeXIkSOcfvrpLF68mP/5n//hmmuuoV+/fqSlpXH77bczadIkpk+fTm5uLnl5eZREsB+KU/tGjRpFz5496dOnD6eccgp5eXlhr/XNN99w2WWX+Xoov/vd7wBrR8GrrrqK1q1bB2wM1aVLF4qKipg0aRK1tbUcc8wx/Otf/3Ld9oZK6tLoIvISsNQY85SIPAS8b4x5ynNfMfCqMea5oMdMB6YDZGdnD94Sase7JsqbIV6nDHmYfI+4sduTvE2bqJTpkDsdNrMCzO3J+7cQK5GWRt94aCOrDq6iqraKjGYZjGw1MiqT4CpxUqI0uoisAI61uWuOMeZFzzlzgCNARNuhGWOKgCKw9tNoYFMbpfK+repV9DBuQmWJR6G3MWn0JEb1H0UzaUatqWXlJyt54W37/aRVoJNbnqxBoolLSNAwxoRcmyYi04CJwFhztCv0DdDd77TjPcdUhOpb9DBuQmWJN3DYavLoyfwk9ye+ZbdpksZpuachOPdAlFJHJd1EuIiMB24GzjPG+H/cXAZMEZGWItIT6AWEn2VSdUSaIR53TlniWVmhS5K4MLL/SNs8jZH9oz8unyqSeYhaxVZ9/u2TLmgADwEZwL9EpFREFgMYYzYAzwCfAq8B1xhjahLXzNTllCFe82W56/LpMeWUJQ72w1aXXFK3EKJDkcRmYv9f3ul4Y9eqVSsqKio0cDRBxhgqKioiXp6c1BPhDZVKe4THW/DqqZovy2k7oHfyTI77D0O1aQMHDlhLdkPxTpaD40T6H8d/R1qzuiu1a2pr+HWnX0fxF0gN1dXVbN++PSCfQDUdrVq14vjjjyc9PT3geKiJcA0aCoD5Dhnde/dUMjfnzgS0yGPGDPjzn92f36OH9d1u1VyPHkxeMtiaw/AbojLG8O7H7/L8Gc83sLFKNQ6hgkbT7JOrOpJ2ctzbc3Br69aQE+kvvP0CG7duxBjj+9q4daOunlLKJQ0aCkjiyfGaCKetsrNDllvP651Hr269EBHfV69uvcjrlRfRhLpSTZUGDQXUr3x6XNjU6gGsfbntnHtuyHLrk06fRPPmgSvNmzdvzqTRk+rsFqiUqkuDhgLqtyNgXHj3Cw/mNBf3yitW3kZRkTW/IWJ992STt21tX+yubeu2zsNaSimfpKs9pRIn6uXTo1E/6uGHre9FRdZQVbNmViBwGrbyvvHXp9y607CWUspHexoqNkLtDe6QQ+Ho4YfhyBHrOt27h57naMgbf9BugUqpurSnoWLDqX7UDTdYORfe+7zBBCA/P3z13VBDSDbbxEYkgSXblUoV2tNQseH05l5R4ViM0Ft9t31mFiJC+8wsKod2DsxMd+pJpKW5qoJbU2vfS3E6rpQKpD0NFRvZ2b4Eu+KZeZRfP5GMzI5U7dlF1weWU7AwaP+KrVsdq+9+N7D90QOFhQ0qm26XDR7quFIqkPY0VGx4lr0Wz8yjcvYU2nfw9B46ZFE5ewrFM4M2p8nOdkwkbNO67dHeRoiVUUqp2NOehooNz5t4+cgv7PfuuH4ieHsbnrmIqr1f2JYyEZHAvT7qszJKKRUV2tNQsZOfT0amQ3mSzI51egpdNxx0rLaa8HImSilAg4aKsZDlSWprYfNmX6+hYMI9/HBgv/35e5Jkrw+lmjgNGiqmIi1P8qP7XrA//4HlMWtjRCLNMVGqkdGgoWIq0vIkBQ9+RNbvnmbvbs/5uyvJ+t3TFDz4UVTaU2vs9+RwOh4gVMKiUk2E7qehkotTIUJwrjcVgatKr+Lk7JPr7KexcetGFg9cHPrBOTmO+3SweXNkDYlGiRWlYiTUfhq6ekollx49nN+YG6C4rJjyluV1AgZYq7O6d+ke/iIh9umIiLfH4pAVr1Qy0+EplVxClDWvr+KyYirbV9K+Xfs6AcPLqfptgBD7dETEqcSKlmZXKUCDhkoukSbvuZiYLm9ZHrD3uSt2141WQItWj0WpBNCgoZJPfr41RxC0JLcOlxPTGW0zwj7l/oN+S32drgvRyUaPVo9FqQTQoKFSl8thnqr9VSEvY4xh2/fb3F3XbUALJQZDcErFiwYNlbpcDvN0PdS1Tu6HPxHhpO4nRXzdetP6WSqFadBQqcvlME/BiQVk7c1i7769jmVKAibI4zF8FI0ei1IJoEFDpa4IhnkKTixgbve5Ub+uK5pFrhoRDRoqdcVqmCfcdSMJAppFrhoZzQhXjZLTtrELKxfa5moYY5iZNTP8hYMT8yD0JlDRzCJXKk5CZYRrT0M1Oq62ja2vSBPzNCdDNTIaNFSjU963VZ1kvhbpLQI3cnISbujJrtcQ6rjmZKhGJmmDhoj8RkSMiHT2/Cwi8oCIlInIxyKSF+4aqmly2rAp7EZObuYf0hz2Enc6rjkZqpFJyqAhIt2BswH/PvxPgV6er+nAnxPQNJUCQm78FIqboaeaGvvHBh/39lguvRRat4ZOnTQnQzUKSRk0gPuBmwH/Wfrzgb8ay/tABxE5LiGtU0kt0o2ffNzMPzhV2/U/HtxjqaiAAwfgySc1J0OlvKQLGiJyPvCNMSZ4151ugF+tB7Z7jgU/frqIrBGRNTt27IhhS1WyinTjJx838w9uhpviUcVWcz9UgiRkPw0RWQEca3PXHOA2rKGpejHGFAFFYC25re91VGoLCBBZQI6LBxUW2i+n9Q8I3l5CqA2U6rNiKpJNmez247j0Uli5Eh5+OPzvqVQDJKSnYYw5yxjTL/gL2AT0BD4Skc3A8cA6ETkW+Abw3ynneM8xpaLDbbJguBIgka6YijQB0K4nYwwsXhz4GO2NqBhIquEpY8wnxphjjDE5xpgcrCGoPGPM/wOWAf/tWUV1KrDHGPNtIturGqFEVLGNVu6HMUcfo5noKkaSKmiE8QpWT6QMeBSYkdjmqFRksB+xdDpeL/n5MHXq0WW4aWnWz04BKNLhrFA5Ht7H6O6AKkaSOmh4ehw7PbeNMeYaY8yPjTH9jTFaH0RFzik2RHP2q6QEnnji6DLcmhrrZ6dP+eGGs4KHmc491xo+C/UYzURXMZLUQUOpaHPaI9zpeL3mBSL9lB9qOMtumOmJJ2DMmLqBw38ITDPRVYxo0FDKSX3nBSL9lB9qAt4pAJWVWXkfTpP2momuYkSr3KomJaIqt5FUqPVfMtusmX3meH0q2zZrZgWsYCLWZH0okSzjVcpPqCq3CcnTUColuO0xBOdN2AWM+n7Kz862D1xuhpny8zVIqKjT4SmlnLidF7AbQgJr1VRD603pMJNKMho0lHLi9g3bqUdSW9vwPcBjtTuhUvWkQUMpJ27fsGO9UikaCYdKRYkGDaVCcfOGrUNIqgkJGTRE5F4R+ZXN8V+JyN2xa5ZSKUSHkFQTEm711BisfS2CPQp8DNwa9RYpFUMRJ/e5pSuVVBMRbniqpbFJ5DDG1AIN/CtTSjVIcLb6jBla1VbFXLiexgER6WWM+dL/oIj0Ag7ErllKqZDs9tT4s98OyN7sddAekIqqcD2NecCrIjJNRPp7vi4DXvbcp1RK6Z/eP6LjScspN8SfVrVVMRAyaBhjXgV+BpwJLPF8nQlMNsa8EuO2KRV1Y9qNoX96f8QzuioI/dP7M6bdmAS3zEaoYoluq9VqVVsVZWHLiBhj1gNT49AWpeJiTLsxjCEJg4Q/u+En/+Emp/IiwbSqrYqycEtuXxKRZX5fL4pIsYhcEq8GKtUkhSuvbpcbEkxzRVQMhOtp3GdzLAu4RET6GWN0ya1SsRCuWKJ3ctu/iu2558Irr2hVWxVT9SqNLiJpwFpjzMCotyiKtDS6SlmRlGVXKspClUavVxkRY4xN7WelVNRoaRKVpEIOT4lIls3hjsB/Axti0iKllP3wkw43qSQQbk5jLWA4mv1tgJ3AW8BVsWuWUkpLk6hkFC5Po6cx5gTPd+/tYcaYm4G/xKmNSqlIhcrxUKoBGlIafUTUWqGUih5vjseWLdb+4t4cD2/g0ICiGkD3CFeqsXHK8bjhBut2qKRBpcIIueRWRPKc7gKWG2OOi0mrokSX3KomqVkzq4dhp1MnqKioe1yX8io/oZbchutp/CHEfRvr3ySlVMyEKjFiFzBAa1Qp10IGDWPMmfFqiFIqSgoL4ZIIK/1ojSrlUrjaUzf73b4o6L7fxqpRSqkGyM+3hqHsdOqkSYOqQcKtnprid3t20H3jo9wWHxG5TkQ2isgGEfm93/HZIlImIp+LyDmxen6lUt6iRfbBYdEi3c9cNUi4OQ1xuG33c1SIyJnA+cAAY8whETnGc7wPVhDrC3QFVohIby1popq8khLnzHGn4xokVD2F62kYh9t2P0fL1cDdxphDAMaY7z3HzweeNsYcMsZ8DZQBw2LUBqVSg11OxuWXQ+fOcOml1jlPPmmtjNJAoTkqURAuaAwQkb0iUgXkem57f47V/pi9gdNEZLWIvC0iQz3HuwHb/M7b7jkWQESmi8gaEVmzY8eOGDVRqSRhl5Nx+LC1Ssousa8pC5f0qFwJV0YkzRjT3hiTYYxp7rnt/Tm9vk8qIitEZL3N1/lYQ2ZZwKnALOAZEXE9FGaMKTLGDDHGDOnSpUt9m6hUanCzVFb3CreE29hKuZKQjHBjzFlO94nI1cALxso6/EBEaoHOwDdAd79Tj/ccU6rpcrvtq+ZhhN/YSrnSkNpTsfIP4EwAEekNtMCqrLsMmCIiLUWkJ9AL+CBRjVQqKbjZ9hU0DwOcXwN9bSKSjEHjMeAEEVkPPA1MNZYNwDPAp8BrwDW6cko1efn5gUtoO3WC9KCRY83DsOjGVlGRdEHDGHPYGHOJMaafMSbPGPNvv/sKjTE/NsacZIx5NZHtVCpp5Odbq6Nqa2HnTnj88dTMw4j1yqbgAJtKr00Sqdce4alCCxYqlSK8K5v8J6rbtNE39QSJ+h7hSikVVbqyKWVo0FBKJZ6ubEoZGjSUUomnK5tShgYNpVTiFRZCixaBx1q00JVNSUiDhlIqOQQvymnEi3RSmQYNpVTizZkD1dWBx6qrdSI8CWnQUErFlpv8C50ITxkaNJRSseO2sqxOhKcMDRpKqdhxyr+YOjUwcGiJj5ShQUMpFTtOw0s1NdZmUd7AoSU+UoaWEVFKxU5OTujS7Z06WfWyVFLRMiJKqcQIV7q9oiJ+bVFRkZBNmJRSTYR3eOmSSxLbDhU12tNQSsVWfr41DGXH6bhKWho0lFKxt2hR3c2h0tOt4yqlaNBQSsVefn7dzaEef1xXR6UgndNQSsVHfr4GiUZAexpKqdBivQ2rSina01BKOQvehtVbBgS019BEaU9DKeVMt2FVQTRoKKWcafVZFUSDhlLKmVafVUE0aCilnGn1WRVEg4ZSyplWn1VBdPWUUio0za9QfrSnoZRSyjUNGkqp5BWLxEJNVmyQpAsaIjJQRN4XkVIRWSMiwzzHRUQeEJEyEflYRPIS3ValVAy53V880ddsYpIuaAC/B+40xgwE5nl+Bvgp0MvzNR34c0Jap5SKLqdP/rFILEzlZMUk6SEl40S4Adp7bmcC5Z7b5wN/Ndb+tO+LSAcROc4Y820iGqmUioJQZUpikViYqsmKSVTOJRl7GjOBe0VkG3AfMNtzvBuwze+87Z5jSqlUFeqTfywSC1M1WTGJekgJCRoiskJE1tt8nQ9cDdxojOkO3AgUR3jt6Z65kDU7duyIRfOVUtES6pN/LBILUzVZMYl6SAkJGsaYs4wx/Wy+XgSmAi94Tn0WGOa5/Q3Q3e8yx3uOBV+7yBgzxBgzpEuXLrH8NZRSDRXqk38sEgu91/TfZrZ16/pfL16SqIeUjMNT5cBoz+0xwJee28uA//asojoV2KPzGUqluHCf/PPzYfNmqK21vkdr/P7AgaO3KyqSfwVVEvWQkjFoXAn8QUQ+An6LtVIK4BVgE1AGPArMSEzzlFJRk4gyJUk0P+BaEpVzEWsxUuM0ZMgQs2bNmkQ3QymVTJo1s3I0golYPRqFiKw1xgyxuy8ZexpKKRU7STQ/kIo0aCilmpYkmh/wCZe4lySJfaBBQymVzGLxZplE8wNA+NImyVb6xBjTaL8GDx5slFIp6qmnjGnTxhjrrdL6atPGOt6Qa/boYYyI9b0h14rW8/boEfg7er969HB3fwwAa4zD+6pOhCulklNOjvWpOliPHtby20gFl+IAa1gq1r2McM8bbmI+ARP3OhGulEo90c6CTtRS23DPG25iPskm7jVoKKWSU7TfLBNViiPc84abmE+yiXsNGkqp5BTtN8tEfGIvKbGGl0I9b7iJ+WSbuHea7GgMXzoRrlSKi+bEdSwm1iN9vng8bxSgE+FKKYX1yX/OHGtoKDvb6rXE6hO700R+Who88UTiegouhJoI16ChlFKxkMLlSnT1lFJKxVuSrXqKFg0aSikVC0m26ilaNGgopVQs+K96Amsuw5ufkcx7d4TRPNENUEqpRss72e2fEe6tHeV/fwrRnoZSSsVSNDPRk6DarfY0lFIqlqKViR5cwypBPRbtaSillJNofLJ3Wi2VlRXZtZNkm1oNGkopZSda+1jYraJq0QL27o3s2omqnRVEg4ZSStmJ1id7u9pRGRlQXR3ZtZMk70ODhlJK2YnmJ/v8fGsPkNpa63tlZeTXdpv3EePJcg0aSillJ5af7OtzbTfVbuOwNawGDaWUshPLjO76Xju4xxK8aioOk+UaNJRSyk4s97GI1bXjMFmuVW6VUqqxiNK+6lrlVimlGiv/ie99+yA9PfD+KBdJ1KChlFKpKnjiu6LCGu7q1ClmW8Nq0FBKqVhxs/y1IUtk7Sa+Dx+Gdu2cJ8sbSGtPKaVULLipFdXQelIJyBJPSE9DRC4SkQ0iUisiQ4Lumy0iZSLyuYic43d8vOdYmYjcGv9WK6VUCME9hhtuCL/8taFLZBOQJZ6o4an1wCTgHf+DItIHmAL0BcYDD4tImoikAX8Cfgr0AS72nKuUUolnl1RXUWF/rn8voKE9hQTsDpiQoGGM+cwY87nNXecDTxtjDhljvgbKgGGerzJjzCZjzGHgac+5SimVeHY9Bif+vYCG9hRimUviINkmwrsB2/x+3u455nS8DhGZLiJrRGTNjh07YtZQpZTycdszCO4FuOkphJsoD5clHmUxCxoiskJE1tt8xbSHYIwpMsYMMcYM6dKlSyyfSimlLE49g06dQvcCwvUU4lBLKlIxWz1ljDmrHg/7Buju9/PxnmOEOK6UUolVWBi4CgqsHsOiReE/+efn1z2npMQa8rLL7vZOlCdof/FkG55aBkwRkZYi0hPoBXwA/AfoJSI9RaQF1mT5sgS2Uymljorm3IJ/78JJnDde8peQPA0RuQB4EOgCvCwipcaYc4wxG0TkGeBT4AhwjTGmxvOYa4HXgTTgMWPMhkS0XSmlbNn1GOrDzaR6nDde8qcFC5VSKpk0a2bNXzhp0ybmK6S0YKFSSqWKUL2IOCypDUeDhlJKxVO4JbROy3CfeiouS2rD0aChlFLx4mYJbQIS9iKhcxpKKRUvUdokKdZ0TkMppZJBAqrSRpsGDaWUipcEVKWNNg0aSikVLwmoShttGjSUUipeknyS2w3duU8ppeIpWpnjCaI9DaWUUq5p0FBKKeWaBg2llFKuadBQSinlmgYNpZRSrjXqMiIisgMIsZNJWJ2BnVFqTirT1+EofS0s+jpYGuvr0MMYY7tfdqMOGg0lImuc6q80Jfo6HKWvhUVfB0tTfB10eEoppZRrGjSUUkq5pkEjtKJENyBJ6OtwlL4WFn0dLE3uddA5DaWUUq5pT0MppZRrGjSUUkq51uSDhoiMF5HPRaRMRG61ub+liCz13L9aRHIS0My4cPFa/FpEPhWRj0XkDRHpkYh2xlq418HvvMkiYkSk0S65dPNaiMjPPf8vNojI3+Ldxnhw8beRLSJvisiHnr+PcxPRzrgwxjTZLyAN+Ao4AWgBfAT0CTpnBrDYc3sKsDTR7U7ga3Em0MZz++rG+Fq4eR0852UA7wDvA0MS3e4E/p/oBXwIdPT8fEyi252g16EIuNpzuw+wOdHtjtVXU+9pDAPKjDGbjDGHgaeB84POOR94wnP7OWCsiEgc2xgvYV8LY8ybxpgfPD++Dxwf5zbGg5v/EwDzgXuAg/FsXJy5eS2uBP5kjNkFYIz5Ps5tjAc3r4MB2ntuZwLlcWxfXDX1oNEN2Ob383bPMdtzjDFHgD1Ap7i0Lr7cvBb+CoBXY9qixAj7OohIHtDdGPNyPBuWAG7+T/QGeovIShF5X0TGx6118ePmdbgDuEREtgOvANfFp2nxpzv3qYiJyCXAEGB0otsSbyLSDPgjMC3BTUkWzbGGqM7A6nm+IyL9jTG7E9moBLgYWGKM+YOIjACeFJF+xpjaRDcs2pp6T+MboLvfz8d7jtmeIyLNsbqeFXFpXXy5eS0QkbOAOcB5xphDcWpbPIV7HTKAfsBbIrIZOBVY1kgnw938n9gOLDPGVBtjvga+wAoijYmb16EAeAbAGPMe0AqrmGGj09SDxn+AXiLSU0RaYE10Lws6Zxkw1XP7QuDfxjPb1ciEfS1EZBDwCFbAaIxj1xDmdTDG7DHGdDbG5BhjcrDmds4zxqxJTHNjys3fxz+wehmISGes4apNcWxjPLh5HbYCYwFE5BSsoLEjrq2MkyYdNDxzFNcCrwOfAc8YYzaIyF0icp7ntGKgk4iUAb8GHJdgpjKXr8W9QDvgWREpFZHgP5yU5/J1aBJcvhavAxUi8inwJjDLGNOoeuIuX4ffAFeKyEfA34FpjfTDpZYRUUop5V6T7mkopZSKjAYNpZRSrmnQUEop5ZoGDaWUUq5p0FBKKeWaBg2lokBElojIhYluh1KxpkFDKaWUaxo0lKoHEflvz74JH4nIk57Dp4vIKhHZ5O11iEg7z94j60TkExE533M8R0Q+E5FHPftQ/FNEWnvuG+q5dqmI3Csi6z3H0zw//8dz/68S8surJk2DhlIREpG+wP8AY4wxA4AbPHcdB/wEmAjc7Tl2ELjAGJOHtR/JH/xK6/fCKiveF9gNTPYcfxz4lTFmIFDj99QFwB5jzFBgKFYGcs/o/4ZKOdMqt0pFbgzwrDFmJ4AxptITB/7hqWr6qYj8yHOuAL8VkdOBWqyS2t77vjbGlHpurwVyRKQDkOEpegfwN6wgBHA2kOs3d5KJFXi+jv6vqJQ9DRpKRY9/1V9vbyIf6AIMNsZUeyrjtrI5vwZoHeb6AlxnjHk9Cm1Vql50eEqpyP0buEhEOgGISFaIczOB7z0B40wg5L7qnn0oqkRkuOfQFL+7XweuFpF0z/P2FpG29fwdlKoX7WkoFSFPhdNC4G0RqcHaI9tJCfCSiHwCrAE2uniKAuBREakF3sbaLRLgL0AOsM4zL7ID+Fm9fgml6kmr3CqVZESknTFmn+f2rcBxxpgbwjxMqbjQnoZSyWeCiMzG+vvcgm4tq5KI9jSUUkq5phPhSimlXNOgoZRSyjUNGkoppVzToKGUUso1DRpKKaVc+/+GNifYJNnGSQAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -3792,14 +765,12 @@
     }
    ],
    "source": [
-    "esp_sample =  esp_result.sample(frac=0.01, random_state=42)\n",
-    "torch_sample = torch_result.loc[esp_sample.index]\n",
-    "even_sample = even_result.loc[esp_sample.index]\n",
-    "perfect_sample = perfect_result.loc[esp_sample.index]\n",
+    "sample =  trained_result.sample(frac=0.01, random_state=42)\n",
+    "even_sample = even_result.loc[sample.index]\n",
+    "perfect_sample = perfect_result.loc[sample.index]\n",
     "\n",
     "expanded_results = {\n",
-    "    \"ESP Prescriptor\": (esp_sample[\"change\"], esp_sample[\"ELUC\"], \"red\"),\n",
-    "    \"Torch Prescriptor\": (torch_sample[\"change\"], torch_sample[\"ELUC\"], \"orange\"),\n",
+    "    \"Trained Prescriptor\": (sample[\"change\"], sample[\"ELUC\"], \"red\"),\n",
     "    \"Even Heuristic\": (even_sample[\"change\"], even_sample[\"ELUC\"], \"green\"),\n",
     "    \"Perfect Heuristic\": (perfect_sample[\"change\"], perfect_sample[\"ELUC\"], \"lightgreen\"),\n",
     "}\n",
@@ -3809,7 +780,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 61,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -3823,17 +794,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 62,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [],
    "source": [
-    "esp_diff = create_diff_df(esp_sample, perfect_sample)\n",
-    "torch_diff = create_diff_df(torch_sample, perfect_sample)"
+    "trained_diff = create_diff_df(sample, perfect_sample)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -3858,24 +828,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 64,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -3887,13 +845,12 @@
     }
    ],
    "source": [
-    "plot_diffs(esp_diff)\n",
-    "plot_diffs(torch_diff)"
+    "plot_diffs(trained_diff)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 65,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -3915,18 +872,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Number less change better ELUC: 0\n",
-      "Number of points where trained prescriptor prescribes less change than perfect heuristic AND produces better ELUC by more than predictor model MAE: 0\n",
-      "Average difference in change for these points: nan\n",
-      "Average difference in ELUC for these points: nan\n",
-      "\n",
       "Number less change better ELUC: 0\n",
       "Number of points where trained prescriptor prescribes less change than perfect heuristic AND produces better ELUC by more than predictor model MAE: 0\n",
       "Average difference in change for these points: nan\n",
@@ -3936,13 +888,12 @@
     }
    ],
    "source": [
-    "display_dominating(esp_diff)\n",
-    "display_dominating(torch_diff)"
+    "display_dominating(trained_diff)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -3967,12 +918,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -3985,8 +936,7 @@
    ],
    "source": [
     "plot_avg_presc({\n",
-    "    \"ESP Prescriptor\": (esp_sample, \"red\"),\n",
-    "    \"Torch Prescriptor\": (torch_sample, \"orange\"),\n",
+    "    \"Trained Prescriptor\": (sample, \"red\"),\n",
     "    \"Even Heuristic\": (even_sample, \"green\"),\n",
     "    \"Perfect Heuristic\": (perfect_sample, \"lightgreen\"),\n",
     "})"
@@ -4001,7 +951,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 69,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -4030,33 +980,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[0.9230349380998744, 0.43807104207699554, -0.29004901879260875, -0.2351340289893659, -0.05092533293805986, -0.09623288169068946, 0.13216382229535967, 0.15509841768596153, 0.32893283987412425, -0.2783848147588405, -0.21376403628922513, 0.014942717949453916]\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0.9059005993480254, 0.5011587606004066, -0.31973205797930904, -0.3059206272223369, 0.07049172159692892, -0.10795210782289759, 0.1576329101792274, 0.14580177100167327, 0.3985471113103744, -0.34303557055794415, -0.2238433660617915, 0.014087250251697304]\n"
+      "[0.9059005967298545, 0.5011587614679881, -0.31973206003781973, -0.3059206297856045, 0.07049173357560067, -0.10795210825363703, 0.15763290451952458, 0.1458017703887272, 0.3985471133990941, -0.34303557228139303, -0.22384336501109753, 0.014087249570502978]\n"
      ]
     },
     {
@@ -4073,13 +1004,12 @@
     }
    ],
    "source": [
-    "plot_corrs(esp_result)\n",
-    "plot_corrs(torch_result)"
+    "plot_corrs(trained_result)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -4099,7 +1029,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 72,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
@@ -4249,7 +1179,7 @@
    ],
    "source": [
     "for feature in constants.LAND_USE_COLS + constants.NONLAND_FEATURES:\n",
-    "    plot_context_change(torch_sample, feature, False)"
+    "    plot_context_change(sample, feature, False)"
    ]
   },
   {
@@ -4261,14 +1191,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 73,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 6/6 [00:10<00:00,  1.67s/it]\n"
+      "100%|██████████| 6/6 [00:09<00:00,  1.52s/it]\n"
      ]
     }
    ],
@@ -4276,9 +1206,10 @@
     "pcts = [0.01, 0.05, 0.1, 0.2, 0.5, 1]\n",
     "total_emissions = []\n",
     "total_changes = []\n",
+    "warming_manager = PrescriptorManager({str(pct): PerfectHeuristic(pct, reco_coefs) for pct in pcts}, nnp)\n",
     "for pct in tqdm(pcts):\n",
-    "    result_df = perfect_heuristic.prescribe_land_use(dataset.test_df.loc[2021][constants.CAO_MAPPING[\"context\"]], pct=pct)\n",
-    "    eluc_df, change_df = perfect_heuristic.predict_metrics(result_df)\n",
+    "    result_df = warming_manager.prescribe(str(pct), dataset.test_df.loc[2021][constants.CAO_MAPPING[\"context\"]])\n",
+    "    eluc_df, change_df = perfect_manager.predict_metrics(result_df)\n",
     "    result_df[\"ELUC\"] = eluc_df[\"ELUC\"]\n",
     "    result_df[\"change\"] = change_df[\"change\"]\n",
     "    result_df[\"total_emissions\"] = result_df[\"ELUC\"] * result_df[\"cell_area\"]\n",
@@ -4289,7 +1220,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 74,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -4304,7 +1235,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 75,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [
     {
@@ -4332,7 +1263,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 76,
+   "execution_count": 50,
    "metadata": {},
    "outputs": [
     {
diff --git a/use_cases/eluc/prescriptors/nsga2/candidate.py b/use_cases/eluc/prescriptors/nsga2/candidate.py
index 1e13050..e7fd06a 100644
--- a/use_cases/eluc/prescriptors/nsga2/candidate.py
+++ b/use_cases/eluc/prescriptors/nsga2/candidate.py
@@ -22,16 +22,16 @@ def __init__(self, in_size: int, hidden_size: int, out_size: int,
             torch.nn.Tanh(),
             torch.nn.Linear(hidden_size, out_size))
 
-        self.device = device
-        self.model.to(device)
-        self.model.eval()
-
         # Orthogonal initialization
         for layer in self.model:
             if isinstance(layer, torch.nn.Linear):
                 torch.nn.init.orthogonal_(layer.weight)
                 layer.bias.data.fill_(0.01)
 
+        self.device = device
+        self.model.to(device)
+        self.model.eval()
+
         # To keep track of metrics
         self.metrics = None
         self.rank = None
diff --git a/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py b/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
index 13e6ddf..0d67880 100644
--- a/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
+++ b/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
@@ -65,7 +65,7 @@ def prescribe(self, context_df) -> pd.DataFrame:
         encoded_context_df = self.encoder.encode_as_df(context_df[constants.CAO_MAPPING["context"]])
         encoded_context_ds = TorchDataset(encoded_context_df.to_numpy(),
                                           np.zeros((len(encoded_context_df), len(constants.RECO_COLS))))
-        encoded_context_dl = torch.utils.data.DataLoader(encoded_context_ds, batch_size=self.batch_size, shuffle=False)
+        encoded_context_dl = DataLoader(encoded_context_ds, batch_size=self.batch_size, shuffle=False)
         return self.torch_prescribe(context_df, encoded_context_dl)
     
     def torch_prescribe(self, context_df: pd.DataFrame, encoded_context_dl: DataLoader):
@@ -76,6 +76,7 @@ def torch_prescribe(self, context_df: pd.DataFrame, encoded_context_dl: DataLoad
         reco_list = []
         with torch.no_grad():
             for X, _ in encoded_context_dl:
+                X = X.to(self.candidate.device)
                 recos = self.candidate(X)
                 reco_list.append(recos)
             reco_tensor = torch.concatenate(reco_list, dim=0)
diff --git a/use_cases/eluc/prescriptors/prescriptor.py b/use_cases/eluc/prescriptors/prescriptor.py
index 0d5b2c5..d3991ce 100644
--- a/use_cases/eluc/prescriptors/prescriptor.py
+++ b/use_cases/eluc/prescriptors/prescriptor.py
@@ -27,8 +27,8 @@ def save(self, path: Path):
         """
         raise NotImplementedError
 
-    @abstractmethod
     @classmethod
+    @abstractmethod
     def load(cls, path: Path) -> "Prescriptor":
         """
         Loads a prescriptor from disk.

From b917f17db827782c062e7cb772be4b3d4bc02248 Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Mon, 3 Jun 2024 08:57:47 -0700
Subject: [PATCH 08/17] reran training with fixed distance calculation then
 reran experiments

---
 .../experiments/prescriptor_experiments.ipynb | 150 +++++++++---------
 ...pdated-format.json => fixed-distance.json} |   8 +-
 .../configs/{test.json => no-overlap.json}    |   0
 use_cases/eluc/prescriptors/nsga2/trainer.py  |   3 +-
 4 files changed, 81 insertions(+), 80 deletions(-)
 rename use_cases/eluc/prescriptors/nsga2/configs/{updated-format.json => fixed-distance.json} (54%)
 rename use_cases/eluc/prescriptors/nsga2/configs/{test.json => no-overlap.json} (100%)

diff --git a/use_cases/eluc/experiments/prescriptor_experiments.ipynb b/use_cases/eluc/experiments/prescriptor_experiments.ipynb
index bd4c33b..dbe2beb 100644
--- a/use_cases/eluc/experiments/prescriptor_experiments.ipynb
+++ b/use_cases/eluc/experiments/prescriptor_experiments.ipynb
@@ -10,7 +10,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 56,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -35,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 57,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -51,18 +51,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 58,
    "metadata": {},
    "outputs": [],
    "source": [
     "TOTAL_GENS = 100\n",
     "\n",
-    "results_dir = Path(\"prescriptors/nsga2/trained_prescriptors/full\")"
+    "results_dir = Path(\"prescriptors/nsga2/trained_prescriptors/fixed-distance\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 59,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 60,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -93,7 +93,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 61,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -110,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 62,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -218,12 +218,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 63,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEGCAYAAABCa2PoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAB2k0lEQVR4nO2dd3hURdfAf7ObZBNSIR0ChEDoPQGkJ9KkCDYQRVEU8X1BRbF/KsXy2kEUUBEbgmJB6R0STOi99x4IJQHSSM98f+xu2CS7ySbZVOb3PPvk7ty5c+fsbvbsmXPmHCGlRKFQKBSK0qKp6AkoFAqFonqgFIpCoVAobIJSKAqFQqGwCUqhKBQKhcImKIWiUCgUCptgV9ETKE+8vLxkYGCgVX1TUlJwdnYu2wmVM9VNpuomDyiZqgrVTaai5Nm1a1eclNK7qHHuKIUSGBjIzp07reobGRlJWFhY2U6onKluMlU3eUDJVFWobjIVJY8Q4pw146glL4VCoVDYBKVQFAqFQmETlEJRKBQKhU24o3woCoWifMjMzCQmJoa0tDTc3d05cuRIRU/JplQ3mYzyODo6EhAQgL29fYnGUQpFoVDYnJiYGFxdXQkMDCQ5ORlXV9eKnpJNSUpKqlYyJSUl4eLiQnx8PDExMTRo0KBE41TaJS8hxD1CiGNCiJNCiDfMnNcJIX43nN8mhAgsi3msfOAhEl19kEJDoqsPKx94qCxuo1BUK9LS0vD09EQIUdFTUViJEAJPT0/S0tJKPEalVChCCC0wE+gPNAceEUI0z9ftaeCGlLIRMA342NbzWPnAQ/Reugy35GsIJG7J1+i9dJlSKgqFFShlUvUo7XtWKRUK0BE4KaU8LaXMABYAQ/L1GQL8bDj+C+glbPwJ7rr2X+yz0vO02Wel03Xtv7a8jUJxR7Noz0W6frSBBm8sp+tHG1i052KJx9q3bx/9+/enZ8+edOvWjWeeeYbMzMxSze+dd96hfv369O7du1Tj3AlUVh9KHeCCyfMYoJOlPlLKLCFEAuAJxJl2EkKMAcYA+Pr6EhkZadUEkpOTcU2OM3vONfkaR95sh6efJ2kudbhVI4BbNQJIdapDpoObVeNXBMnJyVbLXxWobvJA9ZHJ3d2dpKQkALKzs3OP87P84BUmLz9BWlYOABdvpvLGwv2kpaUysKVvse6ZkJDAiBEjmD9/PkFBQQBs2bKFmzdv4ujoWGJZRo4cydChQxk/frxVMlVFTOVJS0sr8WewsioUmyGlnA3MBggNDZXW7m6NjIwkycULt+RrBc4JIOCrCxxu6EFs8/M08dtEM5cbOGmzwKkWeAXrH57B4NVYf1wzELQli5ywFXfa7t6qSHWR6ciRI7lO67cX7uVEXKrZfnvO3yQjOydPW1pWDhOXneCf/QX/95rXdmPSvS3MjrV06VLuu+8+2rRpk9vWt2/f3OM333yTzZs3k5GRwVtvvcWgQYOYPHkyJ06cICkpifPnz7NgwQKaNm2aZ1xXV1fOnj2LVqvNlak6OuWN8jg6OtKuXbsSjVNZFcpFoK7J8wBDm7k+MUIIO8AdiLflJDb16UHvpcvyLHtlanXsbBGK180EOu7fiNgvueDflMigu7jZ1p1GAXYE3Yqj1rE1iFvzbg+msYNaQQYlY3w0Bs9GUKOWLaetUFQZ8iuTotoL48KFC9Stq//auHbtGkOHDiUuLo6ffvqJuLg4bty4wcaNG7l16xadO3dm4MCBAHh7ezN//nx+/fVX5syZw2effVZyge5wKqtC2QEECyEaoFccw4FH8/VZAjwBbAEeAjZIG9cz7v/3X6x84CG6rv0X1+Q4kly82NSnB/cs/JONx6/x2fzV9I78iz77ttJ/01HSdzhzrEEbVtX34lbjnjRq25aGQT7UcUtHe+MUxJ3QP06sgRyTdd0aXuatGo/6oK2sb5FCYR2v921o8dd81482cPFmQeuljocTvz/buVj3qVu3LocPHwb0SiIyMpInn3yStLQ0Dhw4wMaNG3Otv/T0dOLj9b8/Q0JCAKhXrx5r164t1j0VeamU31YGn8hzwGpAC/wgpTwkhHgX2CmlXAJ8D/wihDgJXEevdGxO/7//yj12Qx92BhDWxIeeUx5jw9G+PL76CA23r+HxfZG0ObaT1scyuLarHge3X2BpbQdy3J0IbBtCw/ZP02BgKE41asDNcwYFcxziDYrm6HK4ZWJkaezBs6HeijEqGaNV4+RRFuIqFOXKq/2a8ObfB0jNzM5tc7LX8mq/JsUea8CAAXz00Uc89dRTuT6UrKwsAFq0aEHfvn2ZPn06ABkZGTg4OAB5I5ts/Jv0jqNSKhQAKeUKYEW+tokmx2nA0PKelylCCHo18+Xupj6sPdyUt9f159qpCzx/eg19d0UTvn0NPTT2nAhqzZHLmazaFAVaDf6Nm9IwpCNB7Tvg2aVf3lC9W9f1yiXeoGziTsK1Y3B8FeRk3e7n7GNQMgZlY1xK86gHGm35vxgKRQm4r10dAD5dfYxLN1Op7eHEq/2a5LYXBw8PD+bOncvYsWNJTU3FycmJevXq0aJFC2rWrMnmzZsJCwtDCEFAQAC//PKLVePOmDGDBQsWcOTIEXr37s23336Lj49Psed3JyDuJI0cGhoqyzJ9fU6OZPWhy0xbd5zjV5IZcusMj+1ZScsdUTilJ5Ho4sXB1u041difqwZLxN3Hl6D2HQkK6UhAs5bYWUp5kJ0JN84WtGrijkPqjdv9tLp8Vo1B6XgGE7l1d7Vw+BqpLg5sU6qLTEeOHKFZs2ZA9XNgQ/WTyVQe0/fOiBBil5QytKhxKq2FUhXRaAT9W/nTr4UfKw7G8sU6F4bWaEDrQS/y/OXNBC9bROfN6+iyWXK6XlOOdmnPzZo1ObB+NXtWLcXe0YnANu30CqZdKDXcPW4PrrW/7WdhQN4bp8SbKBmDVXPlkH4JTd5eSujsUBPOtjRZOjOM514XNJV1S5JCoagqKIVSBmg0gkGta9O/pT/L9l9i+roTPKMLpflzd/NiPYH//O+pt3YFAxb8SprOmb1t23G5fxfsvH24uH8fJ7ZtBiHwb9SYhiGdCGrfAa96gZZ3sTp7gnNnqJ/PiZmVATfOGJTMCW4cjMIvKwkOLoS0hNv97BwNFo1pUIDeqkHnUnYvlEKhqFYohVKGaDWCIW3rMLCVP0v2XWL6+hOM2XaLVj2f5sUpH9BwcySZ33xH6M7N2G2L5rJ3PbThoWgefQCXDB1ndu8kesFcohfMxdXLm6D2HWkY0pG6zVthZ3AoFoqdA3g30T+Ao9nt8QsLAykhJS7f0tkJuLQXDi8GaRKy6Vr7tkVjGonmVkdZNQqFIg9KoZQDdloND7QPYHCb2vy95yJfrj/B07/soU3d+rz06+8EOEtOfDiNWn8vpP8ff5P911IONm2J09Ae3PPBJLLPXSdxxu+0njspN3z5QO9BuL0wnKB2HXD2qFm8CQkBLt76R2DXvOey0uH66VyrJjdAYP/vkJ54u599Db2vxnTpzBiB5lCj9C+aQqGociiFUo7YaTUMC63L/e3qsHBXDF9tOMmTP+6gfT0PJrz4Ck1nfEjcqmjiP59G403raDNlDwlT53Oxdl3uOnkIu+wMANySr9Fx2a+svXqZNQEa/Bo1Jqh9BxqGdMK7foPSJXiz04FPM/3DFCkh+apB0RyH+JP6vzE74eDfgElwh3vdfKHORqumtl6ZKRSKaolSKBWAvVbD8I71eKB9AH/svMDMiJM89v02OgbW4qU+zem87m+yk1M5Pe077Of+RLNje8j/NWyflU6Pg7up9fJ0Tu/azuY/f2XzH/Nx8fSiYfsOBLXvSN2WrbF30Nlm0kKAq6/+0aB73nOZqSZWzcnbSmfvfMhIvt3PweW2VWO0Zrwa69vsnWwzT4VCUWEohVKBONhpeOyu+jwUEsDvO/SK5ZHvtnJXUC0m9GlCx3degHdeQFr4Ve+ceBWfXh2464GHSbl5gzN7dnJ69w4OR0Wyb+1K7Bx01GvVRr/npV2HshPE3gl8W+gfpkgJSbEmoc4GZXN+Gxz406SjAI+6eQMCjErHxVdZNdWd/X/A+nchIQbcA6DXRGg9rERD7du3jzfeeINbt26RnZ1Ns2bNmDVrVokrEAI8/vjjXLhwgeTkZEaMGMFLL71U4rGqO0qhVAIc7bU80SWQhzvU5ddt55kVeYph326hWyMvXuoTTBM3X1wSrxS4Lk3nwn0Lh9DKrzVDGg7hnq730DK8D1mZmcQcPsCpXds5vXs7p3dtB6CGty8O1y7SMKQTPoFBiLJ2qguhX+Zyqw1BPfOey7gF10/l9dXEHYfzWyDz1u1+Dq4muc9MotBqBZXt3BXlw/4/YOkLeisXIOGC/jkUW6kkJCTw+OOP888//9CwYUMAoqOjyc7OLpVC+f7773FwcCArK4tmzZoxevToEo9V3VEbGy1QkRvMUjOymbf1HN9sPEV8Sgbvnd3O8IUf50lSmYNAg+RSvRZ88d/GrPQ/gU6r4+56d3Nfw/vo5N8JrUaLlJL4C+c4tXsHeyLWknIlFqTEuWYtggxLY/VbtcFeV/L03jYlJweSLuUNCDAqnUST/KBCQ6rOB6e6rQsm3HT2rrJWTXXc2JixZAIO8cfMd4zZAdnpBdu1OggwY1X7tYL+H5kd6tdff+Xw4cO8//77Zs+XNNuwkeTkZIYMGcKaNWu4deuW2thoBmWhVEKcHLQ80yOIEXfVY+6Wc0zdaM/FhBcYu+lnXJOukeLmQ+JLbyMy0qk17V0+fOsYoweN4J/ng1hycTUrz6zEp4YPgxsOZkjDIQTWC8SrXiCpHt50bN9OvzS2azvHNv/LgfWrsbN3oG7L1jQM6UiDdh1w8/KuOOE1Gv2yh3sANAzPey49Wb9sZlg6Szq8CafEWDgTBVkmCQZ17patGjsrwq0V5Yc5ZVJYeyGUZbbhoUOHsnHjRv773/+i1arURpZQCqUSU8PBjv/0bMhjd9Xn581BdP+3NwmpmfRp7suLvYNpUdudtGce4erjY2m85GfG/lubEe9/yqGBniw+uZgfDv7AnANzaOvdliGNhuCc40wNN3da9OxFi569yM7KJObwIU7v3s6p3ds5s0dvvXkHBukd+yEd8QsKLvulMWvRuUDttvoHcFhE4hMWprdqEmPyLp3Fn4DTkbDvt9vXCy3UrJ83IMBo1dTwrLJWTWUnPXwKDpZ+zU9rqV/myo97XRi1vFj3Kctsw3/++Se3bt2iR48ePPzww7mKS5EXpVCqAC46O8aFN+LxzvX5adNZvos6zcAvr9C/pR/jewfTNHoR8fOWYv/icwQ8NwLND33p+ss33OoymeWnl7Po5CKmbJmCvbAn8t9I7mt0Hx39OqK1s6d+67bUb92WsCee4frFGE7t2sbp3TvY9s+fbP37d2q4e+iXxkI6Ur9VWxwcK2E0lkajT4rpUQ8a9cp7Lj3JsHR2Mq+/5lRE3l/Bjh55c58Z99fUalDhhdGqNb0m5vWhgD7Io9dEy9dYoCyyDUspyczMxMHBAUdHR5ycnHByqoT/A5UEpVCqEG6O9rzQK5gnugTyffQZfog+w8qDlxnY2p8X+4QRdP4ol/7zFj6/ziC7XSvSx7zOyM/f4MkWT3Iw7iCz/p1F1MUoVpxZgZ+zH/cG3cuQRkOo71YfIQSeAXXxDKhLxyEPkZqUyNm9uzi1azsntm3mYMRatHZ21G3RmqCQjjRs3xE377wZV49ERRC1YC5J8XG4enrRffhImnUPtyBNOaFzhTrt9Q9TcrL1v4xNw5zjT8LJtbA3X2G0moEWrBpVGK3UGB3vNojyKotsw1lZWblVHzMyMhg2bBgNGjSoVuV/bYlyylugKjhHb97KYE7UGX7cdIZbmdkMblObF3oF43v6DGlPPIPXsW3E12mB/OZrvAZ1JzIyks7dOxNxIYJFJxex5dIWcmQO7X3aM6TREPrW74uLQ8HcXdlZWVw8elgfMbZ7OzdiLwHgVS8wNw3/jcuxrPtuJlkZt3/12zno6DvmuTJTKmX2HqUl6BWNaUBA3Al9VJphcymgXyYrUIHTWO65ZL/VqsLnzhpUtuGqha2c8kqhWKAq/WNfT8lg9r+n+XnzWdKzsrmvbR2eD2+I85x5uH7wFrrUBC7eM5JTzw4lbMjtTMVXUq6w7PQyFp1cxNnEszhqHeldvzdDGg2ho19HNMK87+T6pYucNiyNxRw9hMzJQQhhtjiRq5c3Y2b+WCZyl/t7lJNtUhgt396aFJP65xp7/VKZ0Zox3V/jVHianKr0uSsMpVCqFirKS5FLLWcH3ujflNHdG/DtxlP8svUci/dd4oF2XRi3Yy+68a9Rd+VPeESt4Hy3/tTavArnxKs4u/kwYMJEnpq4hP1x+1l8cjGrzqxi2ell+Dv750aJ1XXL64CsVbsOtWo/QOi9D5CWnMzZfbtY/uWnZueWFB9XHi9B+aDR6iPFagVB4355z6XeuL18Zppw8/jqvOWenb0LWjXGcs+qMJqiiqMsFAtU5V+KV5PS+CbyNPO2nSMnR/JQSABjUi/g858ncUnJ+wVvfPdT3HxJmjCRmm89lWdJTCJp79Oe+xrdR9/AvjjbO5u95+xxo0iKu1agvVpZKCUhO8tg1RwvaNWYlnvWOkCthlyTHng365LXqnF0r7j5lxBloVQtlIWisIiPqyMT723Osz2DmBVxkt+2X2Ahgl1mlrCM8S0uiVfQvT+BOKD/pLH0b9CfyymXWXZ6GYtPLmbi5ol8uP1D+tTvw5CGQwj1C82zJNZ9+EjWzJ5RwIfSffjIMpa2kqO1M1TQbAhN+uc9Zyz3bGLVOJ/fB9Hb8xRGw8U3b0Zno3XjXldZNYpKRaVTKEKIT4F7gQzgFDBKSnnTTL+zQBKQDWRZoz3vNHzdHJkypCXP9mzIrMiTuCYXtCBMsc9Kx2/yOJKnvkvShIn4TxrL6Fajebrl0+y7to/Fp/RLYktOLaGOSx0GNxzMvQ3vpa5r3VzH+8qZU5FS4urlXTmivCozNWpBvU76h4HtkZGEde9qKPd8PG/CzUP/QNrN29drdYbIM5MwZ6Oy0Zn8erZhriyFojAqnUIB1gJvSimzhBAfA28Cr1voGy6lrEaL9GVDbQ8n3r+vFUmu3rgmXS20r0BvrThPHkdMdBQBa39DCEFbn7a09WnLax1eY8P5DSw+uZhv9n3D1/u+JtQ3VB8ldldfvJYG4urlzf2vFX8fgcJAnnLPA2+3S6lfJstn1XD5IBxZmq8wmr/hegHnNt/245QiV1ZZsfz0cqbvns7llMv4Ofsxvv14BgYNLPpCM5RFcsh33nmHuXPnEhwczLp163Lbf/rpJ2bPno0Qgq+++or27dsXMsqdQaVTKFLKNSZPtwIPVdRcqhtHH3matj9MzZMTzBICqLNuAbFTuuM/aWxuu5OdEwODBjIwaCCXUy6z5NQSFp9czDub3mHews+5K8aDa+fOMHvcKGWh2BohwNlL/yhQ7jkdrp8xCXU2WDUXd5GnVg3oNxGuf7dSKJTlp5czefNk0rLTAIhNiWXy5skAxVYqZZUccuzYsYwaNYoxY8bktt24cYMvv/ySrVu3cvHiRR5//HGio6NLfI/qQqV2ygshlgK/SynnmTl3BriB/r/lWynlbAtjjAHGAPj6+oYsWLDAqnsnJyfj4lK96qknJyfju3QzTX/7HheDpVJUspEkVx92Lfm90D5SSo4e3kjypl1osm9/nnK0Au/u3Qhs1qmQq0tOdX2PbClTz8j7EPkVCiARbAxbZLP75Mfd3Z1GjRoBMG3vNE4mnjTb7+D1g2SaRsEZsNfY07JWywLtwe7BvNjmRbNj/fHHHxw9epSJE81bx5MnT2bbtm1kZGTwyiuv0L9/f/73v/9x6tQpkpOTiYmJ4ccff6Rx48YFrj137hzPP/88S5YsAWDNmjWsW7eOTz75BIAuXboQERGBTmej+kPlTHZ2dm6OspMnT5KQkJDnfHh4eOV1ygsh1gF+Zk69JaVcbOjzFpAFzLcwTDcp5UUhhA+wVghxVEr5b/5OBkUzG/RRXtZGBVWJCKJiEhkZSYdv/wff/g+A2CmzcJ36Ls6JVywqFpeka1a9Dif+mptHmQBosiXntkYQFXScIY2G0Lteb2rY2648cHV9j2wq054As7myhHtAmb52R44cyY0aEkJYTKhoTpkY281d4+DgYDG6Ki4ujkaNGuHq6mo2OWRKSgrR0dG5ySGHDh2KTqejdu3afPHFF/z666/89ttvZpNDuri4oNVqc+998+ZNfH19c5/XqlWLzMxMvLy8in5xKiGmUV6Ojo60a9euRONUiEKRUvYu7LwQ4klgENBLWjChpJQXDX+vCiH+AToCBRSKwjL+k8bCpLHETpmF3+RxZpVKipsP1vxetrTfxCXNjtiUWN6KfosP7D6gb2BfhjQcQohvSOlKFSusw4a5skrKi21etKgE+v7Vl9iU2ALt/s7+/HhP8cLNyzI5ZH5q1qzJgQMHcp8nJCRQq5ZKxVNJ0sjeRghxD/AaMFhKectCH2chhKvxGOgLHCy/WVYv/CeN5WLv4QUWRjLtdMzu/iTT150gMc38L0kjrp7mf5m5enmz/P7l/HTPT/QL7Meas2sYtXoUA/4ewDf7vuFS8iUbSaEwS+thcO+X+hBj0O93uffLSuE/ARjffjyO2ry1eBy1joxvP77YYw0YMIAlS5Zw+vTp3Lb8ySEjIyOJjIxk//79udZEYckhLREaGkp0dDSZmZmcP38eFxeXKrvcZUsqnVMemAHo0C9jAWyVUv5HCFEbmCOlHAD4Av8YztsBv0opV1XUhKsDAWt/I6aP3hEPIIWG810Hc2TYQ6xdd5wfNp3hme4NeLJrA1x0BT825vahaLRaug8fiRCCEN8QQnxDeKPjG6w/v57FJxczc+9MZu6dSSe/Tvolsfq9cbJTmVxtTuth+seGDyDqM2hU6AJBuWJ0vNsiyqsskkMCzJgxgwULFnDkyBF69+7Nt99+i4+PD2PHjqVnz54IIXKzGN/pVGqnvK25U3bKW6IwmWKnzMLr/Ql5IsAy7XTEvT2VuKdH8MW646w/epWaNewZ06MhIzvXxzmfYjHNNmzn4EB2Ziajv/reYsGui8kXc6PELiZfxNnemX6B/RjScAjtfNoVuSR2p71HpebCDvi+Nzz4PbQq2+BJtVO+amGrnfKVbslLUTG4Tn23QDixfVY6rlPfpVWAO98/2YFF47rSOsCDj1cdpccnEcz+9xSpGbd3dDfrHs6YmT/y8oKljJr6NRqtls1/WIqpgDoudfhvm/+y4oEV/NjvR3rX683KMyt5YtUTDPpnELP3zyY2ueD6uqKE1GkPTrXg5Lqi+yoUJUApFAUAzonmNzyatret68HPT3Vk4X+70Ly2G/9bcZTun0TwffQZ0jKz81zn5uVD236DOPTveq6dP1vovTVCQ6hfKO93e5/IYZG83/V9fJ19+WrPV/Rb2I9n1jzDstPLSDUt86soPhqtvgDZibX6KpcKhY2pjD4URQWQ4uaDS+IV8+352kLq1+SXpzux/cx1pq09znvLDvPtxlOMDWvI8I71cLTXh3t2un8Ye9csZ/7/TSA7K9Oqols17GswpNEQhjQawoWkCyw9tZQlp5bwZtSbuNi70C+wH/c1uo823m1sKf6dQ3BfOPAnxO6BOiEVPRtFNUNZKAoAkiZMJNMub5RKpp2OpAmWw0s7NqjFb2Pu4rdn7iLQ05nJSw8T9mkkv2w9R3pWNmf37ERmZ5OdmQFSkhR3jTWzZ3AkKsKqOdV1rcvYtmNZ8cAKfuj3A3fXu5sVZ1bw+MrHuXfRvaxOWM3llMulkvuOo2EvQOitFIXCxiiFogD0ocNxb08l2c0XiT79wNVx7+RJu2KJzg09+f3Zu5g/uhN1ajrxzqKD3P3ZRlb//CM52XmXwrIy0lkx43NmjxtltWLRCA0d/DrwQbcPiBgWwbtd3sXLyYtlN5fR96++PLv2WVacXkFaVloJJL/DcPbUWyZKoSjKAKVQFLn4TxqLS8Jlbq7ZggCEg/X5j4QQdG3kxV//6czPT3XE21VHVtJ1i/2La60YcbZ35v7g+/npnp+YWHsiz7Z5lrMJZ3k96nXu/uNu3t3yLvuu7bN6P8EdSXBffY6vFJVXVWFblEJRFMCjV0duOXngM/UdpNCQ7O5H7JRZVl0rhKBnY2/+GdsFB3fPQvtmZaQTtWBuiefpbe/NuLbjWPngSub0nUNY3TCWnlrKYyseY/Ciwcw5MIcrKVdYfno5ff/qS+ufW9P3r74sP728xPesFgT3ASScXF/RMwH04eazx43i8+H3FstyNce+ffvo378/PXv2pFu3bjzzzDNkZha+KbcwUlNT6dOnD926deOuu+5i5cqVgD63V82aNQkLCyMsLIzly+/wz5QB5ZRXFODye9/gm5aExlDkyVh8KxasWgIDvWLp8/iTBTY75scWJYI1QkMn/0508u/E/3X6P9aeW8uik4uYvns603dPRyM05BhSu5cmm221wb+tvhTxybXQ5uEKncqRqIg8nxGj5QoUO1N1WWQbtrOz47vvviMwMJC4uDi6du1K//76QmkhISF50tkrlEJRmMF16ru5ysSIcU8KVioUuP2FELVgrtnywGA5ZUtJcXFw4f7g+7k/+H7OJ57n4WUPk5yZnKdPWnYa03dPv3MVikaj3y1/fBXkZJd51cfNC37m5qUYs+dijx8jOyuvBZGVkc7qb75k/4bVBfr71A8i/MkxBdoBli9fzuDBg3OVCUC3bt1yj9988002b95MRkYGb731FoMGDWLy5MmcOHGCpKQkzp8/z4IFC2jatGnuNfb29gQGBgLg5OSERnN7UWffvn10796dBg0aMG3aNDw9C7fI7wTUkpeiANbsSbEW42bHAc+9jJ1D3iiyHASb3Tqw8kAsOTm293nUc6tHSmaK2XN3fHRYcB9IvWGol1Jx5FcmRbUXxoULF6hbV5+z7No1fZbsli1bsnPnTlatWsWNGzfYuHEj69ev56233sr1s3l7e7NkyRJee+015syZY3H8l156iddeew0APz8/Tp8+TVRUFN26dcttv9NRFoqiAMXZk2IteayV+DgcnV1IS07CPekC/523i2a13XmxdzB9m/vaNAuxn7Of2Wy2fs7mqifcQTS8G4QGTqyBuh3L9FZdhj9hMU3J7HGjzFqvrl7ePDzpo2LdpyyzDb/33nu4ubkxatQoAHQ6Xa5Mjz32GDNnzizWXKsrykJRFMDcnhQJJIy0frnLHKapWcZ9/xt3PfAw9a4dYGL9y6RmZPHsL7u4d0Y0649csVmUli2z2VYrnGpCQMcKDx/uPnxkAcvVzkFH9+Ejiz1WWWUbnjFjBidOnODTTz/NbTMtQLVhwwaaNGlS7PlWR5RCURQg754UwS3nWmRr7PH48UtS3HyQQpCj0SKFKFYEWH66DHuMpl17cmPjImZ11vDZ0DYkpmbx9M87uW/mJiKOXS21YhkYNJDJXSbnWiSu9q5M7jL5zvWfmBLcB2L3QlJBa7S8aNY9nL5jnsPVyxuEwNXLm75jnitR6WjTbMM9e/bknnvuoUaNGrRo0YIBAwbg6upKWFgY4eHhPP3001aNefXqVcaPH8/p06cJDw8nLCyM7OxsoqKiaN++PT179uSrr74yW5TrjkRKecc8QkJCpLVERERY3beqUBqZLjz0X5kDUpp5ZNjp5KXJM0s0bmZGhvxt4qty2oj7ZMyRQzIjK1su2H5Odvlwvaz/+jJ538xo+e/xqzInJ6fU8tw1/y750baPSjTP8qJcP3eX9kk5yU3K3fNsPvThw4dzjxMTE20+fkVT3WQylcf0vTMC7JRWfMcqC0VhFR5r/rZYJjg3AqwE2NnbM+SVt3Hz8mbRZ++TfO0yD3eoR8QrYXxwf0uuJKTx+PfbGfbtFjafKl2IsYfOg+tpljdb3nH4tQIXP334sEJhA5RTXmEVRUV4OZtx4luLk6sb978xmV/ffoUFE19Do7Uj+UY8rp5efDPscfY5tGBGxEke/W4bnRrUYkKfxnQKKn6IZi3HWtxMv1nieVY7hIDg3nB4KWRngVZ9HShKh7JQFFaR4uZTZJ+S+lIAavrVpm2fAdxKuEny9bjcZJIRc2YSmnWGja+GM+ne5pyOS+Hh2VsZMWcrJ25kFz2wCR6OHtxIu1HiOVZLgvtCegLEbK/omSiqAUqhKKzCXOSXKQLwen9CqZTKoX8LpgIxpmdxtNcyqmsDol4L5+2BzTh2OYkPtqXx+Pfb2H3eOiXhofPgRrpSKHkICgONnT58WKEoJUqhKKzCGPmVIyx/ZErjSwHLaVhM2x3ttYzuHsS/r4UzrIk9hy4l8sCszYz6cTv7Y24WOn4tx1rcTCu8zx2HozvUvQtOqBQiitJT6RSKEGKyEOKiEGKv4THAQr97hBDHhBAnhRBvlPc870T8J43lyqSvCrVUSrKb3oilNCzm2ms42DGggQNRr4Xz2j1N2HPhJoNnbGL0zzs4eDHBzCh6CyUtO41bmbdKPMdqSXAfuHIAEi9VyO2Pb7vMz/+3iZn/2cDP/7eJ49tKnsXA1skhAd555x3q169P796987T/9NNPdOnSha5du7J7925AHzX7/PPP0717dwYNGsT163dWEEilUygGpkkp2xoeK/KfFEJogZlAf6A58IgQonl5T/JOpChLxRpfiyVKssnNWWfH2LBGRL0Wzst9GrP9zHUGfRXNs7/s5EhsYp6+tRxrASjHfH6C++r/VsAmx+PbLhMx/yjJ1/XJIZOvpxMx/2iJlIoxOeSMGTPYuHEj0dHRPPHEE2RnF8/Xlp+xY8cSEZE3A/KNGzf48ssviYyMZN68ebzwwgsArF69mlu3bhEVFcWwYcP45JNPSnXvqkZVDevoCJyUUp4GEEIsAIYAhyt0VncI/pPGEoveZ2KfdTuTsLHCY2nSs1w8doR9a/W/IYRGQ4uevaza5ObqaM/zvYIZ2SWQHzed4fuoM6w+FMXAVv6M7x1MY19XPHQeANxIu0Ftl9olnGU1xKcZuAXow4dDnrD58DsWnyfhivmM01fOJJCdlXfzalZGDht+OcKh6IIWk1ddF7oPa2x2rLJIDgng7+/P2bNn87Tt2rWL7t274+DgQIMGDUhKSiI9PZ2NGzcyaNAgAO69916+/vpryy9MNaSyKpTnhBAjgZ3Ay1LK/J7UOsAFk+cxQCdzAwkhxgBjAHx9fYmMjLRqAsnJyVb3rSrYVKaezYm5NIGmv32PS9JVpNCwd+R4Uno251gJ7xF//DDnNt52DsucHPZHrCEhBzwbFzRALcnT1g4+6ubAqrOCtYdjWXEglo5+WkLqXwRg446NXHMyn/24oqmoz11j5xb4HF/Hpg1rkZqSpXo3xd3dnaSkJAByZI5FKyG/MjFtN3dNZkZm7rj5OXnyJN7e3iQlJREXF8fIkSOJj4/n66+/Jj4+nqtXr7Js2TJu3bpF79696dGjB+np6bi7u/PNN9/wxx9/MGvWLD744IMCYycnJ5OdnZ1777i4OGrUqJH73NXVlfPnz3P58mV0Oh1JSUlotVri4+MtzrcyYSpbWlpaiT+DFaJQhBDrAHPZ+d4CvgbeQ58+6j3gc+Cpkt5LSjkbmA0QGhoqjcnhiiIyMhJr+1YVbC5TWBh8+z8uDBlN3SXfE/rDJ6T89TNJEyZaXTfFlNl//ow05F4yIrOyiN+3gwfHFByvKHkGAjdSMvgu6jQ/bT7Lzut21GgIjv4+hLW1fF1FUmGfO78UWLCang100KBHqYc7cuRIbvLETvcFWkwO+fP/bcpd7jLFpZaOh17rUKx7NmrUiMOHD+Pq6oqrqytRUVE8+eSTaLVaTp06xebNm7n33nsByMzMJCMjA51OR+fOnXF1daVJkyZER0ebnauLiwtarTb3nKenJ4cOHcp9npycTL169fD19SUjIwNXV1du3ryJp6enRdkrE0lJSbnzdHR0pF27diUap0J8KFLK3lLKlmYei6WUV6SU2VLKHOA79Mtb+bkI1DV5HmBoU5QzsVNm4bdiHqAPHXZJvFLi8GFroryKS01nB167pylRr4UzsqPeyvlozU5e/mMf5+LNp7a/I2nQEzT25R4+3HlIQ+wc8n4N2Tlo6DykoYUrLFNWySHNERoaSnR0NJmZmZw/fx4XFxd0Oh09e/ZkxQr9ku2KFSvo2bNnseWoylQ6p7wQwt/k6f3AQTPddgDBQogGQggHYDiwpDzmp8iL69R38/hRoOThw8WJ8iouni463hkYgkZoaRvowLL9l7j78428/td+LlxXUV/oXCCwa7mHDzfu5Ef4iKa41NIHY7jU0hE+oimNOxW/vEBZJIcEfbbhxx57jD179tC7d29OnTpFzZo1c+/zyCOP8MUXXwDQr18/7O3t6d69O/Pnz+fVV18tthxVGWGtRi4vhBC/AG3RL3mdBZ6VUsYKIWoDc6SUAwz9BgBfAFrgByllwYXPfISGhsqdO3daNQ+15GUdUmgQFPwMSQTCUHbXWvKXgwV9lJel7LMlkSfs9zDC6obx35Zv8HXkKX7ddp4cKRkaWpfn7m5EHQ+nYo1nayr0c7d5Bqx5C148AB71SjXUkSNHaNasGZB3OaW6UN1kMpXH9L0zIoTYJaUMLWqcSmehSCkfl1K2klK2llIOllLGGtovGZWJ4fkKKWVjKWVDa5SJomywFCZckvDhPKnM0Ud59SlhKnNL1HSsyc30m/i6OTJ5cAs2vhbGIx3r8deuC4R9GsE7iw4Sm5Bqs/tVKSowfFhRPah0CkVRtTCXksUYPlwSjEW4WvXqh8zJYeWMz5k9bhRHoiKKvtgKajrWzJPPy9/diffua0nkq+E8FFKX37afp+enkUxecoiriWk2uWeVwSsYPOorhaIoMUqhKEpF3mJcei4PH1uiKC8jR6Ii8iiQpLhrrJk9o9RKZfnp5Ry4doDdV3fT96++LD+9PPdcHQ8nPnygFRGvhHF/2zr8svUc3T+J4L1lh7mWZH4PRbVDCP2u+TMbIesOkVlhU5RCUZQa/0ljcUm4zKXx7wMQMG9aqSo5Ri2YS1ZGRp42Y5LIkrL89HImb55MWrbe6ohNiWXy5sl5lApA3Vo1+Pih1mx4uSeDWtfmx01n6P7JBj5ccYT45DvgSza4L2TegnObKnomiiqIUigKmxA7ZRY+M98DyjB8OO4aKTdLli14+u7pucrESFp2GtN3Tzfbv76nM58Pa8O6CT3p39Kf2VGn6f5JBB+vOsqNlAyz11QLAruDVqeWvRQlorLulFdUMSyFD7t9NgmKufzl6ulFUpz5nexzXhhN+3vuJXTwg8Ua83KK+dxQsSmx3L/4fhq4NyDQLZBA98Dcv24ObgR5uzDt4baMC2/I9PUn+WbjKeZuPkvP9hc4nvknV29dxs/Zj/Htx1ePOvUONaBBd71CuefDip6NooqhFIrCJljKMuycHEeiZz2S2nVF06cXHg8PwCkwbx6t2CmzcJ36Ls6JV0lx86HrI0+xziGxQPhw12EjuHLmFNuXLGTvmhV4tmzL/ux0tv69gKT4OFw9veg+fKTZqDA/Zz9iU2ILzs/OmToudThx4wQbzm8gW95O91HLsRaBboG5yubBboE82CmQr6LX8e+NnxEafRZb4/IZUD2USqM+sOp1uH4aagWV/f3mz4e33oLz56FePfjgAxgxotjDnD17lnbt2tGmTRsABg4cSHZ2NgMHDqRVq1bFGissLIx58+YREBCQ2xYZGckjjzxCkyZNSEpK4uOPPy6Qgbg4LFq0iPbt21OvnnUh2k8++ST79u3D3d0dgD///BNvb+8S3Xvv3r0kJibSo0fpsyKYohSKwiakuPngYqYMcJrOldTaDfCOWoLD+gXwBtzwb8ytkK7Y9e9D1vlL+Hz+Vq5145J4hcbfT4WnJ7DJLdasouh431A2/zGPkzs2E7tjc+69kuKusWLG51w8doTeo/NaRePbj8/jQwFw1DryTud3cpVAZk4mMUkxnE04y9lEwyPhLBEXIgrUos+fbDktO41pu6ZXD4USbFAoJ9ZBpzFle6/582HMGLhl2Fx67pz+OZRIqYSEhLBuXdltzhw4cCBz5szh8OHDPPzwwxw4cKDIa3JyctBoCnoXFi1ahJeXl9UKBeCrr77Kk/DSSHZ2Nlqt1upx9u7dS0xMjFIoispJ0oSJ6MxkH77x5kf4TxpLTnoG8cv+JW3xKhy2bMR35Tzslv2IRO9zMcU+K536v/1AiwTzy1Te9QIZ8srbTH9yGFmpBXe571u7gjpNmuWxVIxf9NN3T+dyivllKnuNPQ3cG9DAvUGBMRPSE3IVzNub3jY7ryspscyKPMkTnQNx1lXhfy3PhlCroT4Niw0Uiu711+GwhUTgW7dCer5gh1u34Omn4bvvCvZv2xYMu9Kt4cknn2T06NF069aNevXq0b9/f/bt20e3bt347LPPOHz4MM899xzZ2dnY2dmxYMECq371161bl+TkZIvXh4WFERISwsGDB/nyyy/59NNPOXXqFJmZmUydOhUXFxdWrVrFvn37aNSoEX/++SdTpkxh1apV5OTkMHHiRAYOLPzHydmzZxk6dChNmzbF3t6eMWPGMGHCBDQaDa1atWLWrFmcO3eOBx98kGbNmnH48GFGjhzJiy++yNSpU0lKSmLdunXMnz8fNzc3q1/TwlBOeYVNyBs+LEh28yXu7am54cManQOeD/amztzP8D6xA+Kvc/WHvy2O55x4pchIMXPKxIi5iLCBQQNZ89Aa9j+xnzUPrSmWNeGuc6eNdxuGNBqCv7O/2T4OePLJqmN0/ySCbzee4lZGltl+VYLgvnA2CjLLeJNnfmVSVHsR7Nq1i7CwMMLCwti4cWOec1evXmXKlCls2bKFZcuWkZiYSIMGDVi3bh0bN27koYcesjrd/P79+/H29i70+tDQUFavXk1ERASNGjUiIiKChQsX8tJLL9G8eXPuuecevvrqK/7880/27t1LVFQUmzdvZvXq1bz00kvk5BTMNPH8888TFhbGqFGjAL1SmTlzJj/88APPPfcc8+bNIzo6mvT0dJYuXQpAbGwss2fPZvPmzUyfrg9CmTBhAk8//TSRkZHUqVOnRK+1OarwzyhFZcN/0thcB7yL4WEJO3cXfEbdT/KLvmaXyoyRYrr3JxBrHDsfDi5uZCQnFmiH0iWULApzy2cOGgfe7foq/nd3Ydra43y48ijfRZ3mPz0b8thd9XG0t345olIQ3Bu2fQ1no/VLYKUg/eOPcbCUpiQwUL/MlZ/69aEEKdTzL3n9+OOPucd16tTBz0+fIywgIIAbN26QkZHBhAkTSExMJCEhgQ4dCs9wvHz5csLDw9FqtcyePZuYmBiL13fp0gWAAwcOsHnzZlatWgXoC4Hl59ixY9x1110IIfDw8MDHx4e4uDh8fPJmnDBd8jp79iwtW7bMtS4SEhIICgrKvffRo0dp3bo1zZo1o0aNGgDFWhYrCcpCUVQo5nbam1JYosnanQquJRuxRUJJSwwMGsjkLpPxd/ZHINAKLTXsahBeN5z29Wryy9Od+Os/nWni58r7y4/Q/ZMIftx0hrTM0lUOLFfqdwM7p7LPPvzBB2D4ssulRg19u40xzSoM+szCM2bM4NFHH2Xjxo2MGTOmyGzDAwcOJCIign/++Ye2bdsWer3xy7tFixaMHDkyN9OxsVywg4NDbjbkxo0bs3XrVqSU3Lx5k6tXr+ZmQy4MUwXh7u6em2l58+bNNGnSxKzc+e9tS5RCUVQo5nba58dSBJln4+a06TOgQHtRZYNtgeny2Q/9fuBmxk1m7p2Zez40sBbzR9/FgjF30cDLmSlLDxP2aSS/bDlLelYVUCz2jhDUU69QyjKB7IgRMHu23iIRQv939uwSOeRLwn333cf777/P4MGDrXKwl+T6Z555hmPHjhEeHk54eDhvvfUWAIMGDWLixIk8++yztGvXji5dutC5c2f69u3L559/btaRXxhffvklI0aMoFu3btjb2zN48GCLfbt27cqaNWt46KGHuHy5+OWWLVHpsg2XJSrbcOWWKdndz+zyV7KbLy5mHPRGeY5ERRC1YC5Jcdewd3Skz+hxNk0oaQ3vbnmXhScW8uuAX2nh1SLPOSklW07FM3XtcXaeu0Ftd0fG3d2IoSF1cbDL+6VRqd6j7d/BilfguV3g1ahYl6psw1WLapttWHHnUtJEk8aEkn6NGuMf3LTclQnAiyEv4mznzGMrH6P1z63z5AoTQtClkRd//qczvzzdEV93R9765yDhn0Xy+47zZGYXL81/uWH0nZRz0S1F1UUpFEWlIf/yV5bWPk+kWFHU9KvNjdiKKdwZFRNFWnYaWTlZSKTZXGFCCLoHe/P3f7vw46gOeLk48PrCA/T6fCN/7Yohq7IplpqB4NVEKRSF1SiFoqhU5CaavOdxpNDi87r1lfU8/GqTFB9XILFkeTB993QyczLztFnKFSaEILyJD4vGdeX7J0JxdbTjlT/30Wfav2y+lEV2TiVahg7uo08UmVH8csl30nJ6daG075lSKIpKiZQ52GeloXFytDpzcc3adUBKbl4pmGKlrLGUK8xSO+gVS69mvix7vhvfPh6Czk7D7P3p9J22kSX7LlUOxRLcB7Iz4My/xbrM0dGR+Ph4pVSqEFJK4uPjcXR0LPEYah+KotIRO2UWfuv+BG7vR3GePI6Y6CgC1v5m8bqafvocYTdiL+JVt355TDUXS7nC/JyLro0uhKBfCz/6NPPl8z/WszZW8MJve/hq/Qle7N2Y/i390GgKhn6WC/U6g4OLftmrSX+rLwsICCAmJoZr166RlpZWqi+pykh1k8koj6OjY578ZcVFKRRFpcN16rvYZeddthJAnXULiJ3S3aJPpaa/UaFcKuspFsDcZkc7Ycf49uOtHkOjEXTws+PlYT1YfiCWL9YdZ9yvu2nq58qLvRvTr4Wv2T0FZYqdDoLC9Hm9pNSH9lqBvb09DRroU9hERkbSrl27Mpxk+VPdZLKVPJVuyUsI8bsQYq/hcVYIsddCv7NCiAOGftbFAiuqBJb2nQiwuMkRQFfDmRruHhWiUPJvdtRpdei0OnrV61XssTQawb1tarPmpZ5MH96WjKwc/jNvF4O+imbt4Svlv4wU3AcSzsO1Y+V7X0WVo9IpFCnlw1LKtlLKtsBCwHLCJwg39C0yPlpRdUhx87F4zpKyMeLhV5ubl8tfoUDezY5f9/6alKwUlpxaUuLxtBrBkLZ1WPNSDz4f2obk9CyembuTITM3EXH0avkplkYqfFhhHZVOoRgRett+GGB50VxRLUmaMNHirvnClA3ol71uVJBCMSXUN5RWXq346dBPZOeUbme8nVbDgyEBrJvQk08eas31lAxG/bSD+2dtZuPxa2WvWNzrgE8LpVAURVJpd8oLIXoAUy1ZH0KIM8ANQALfSilnW+g3BhgD4OvrG7JgwQKr7p+cnIyLS2HpDaseVUkmvzen0WTrkjyp7TPtdOx9agIpj/QFzMsTu3sbl7ZF0fbpF9A6OJTjjAuy99Zevr/2PU95PUU7Z+vWp615j7JyJNEXs1h6KpP4NEkjDw0PBDvQrJamzHwsQad+JiBmCZu6/kK2XY2iLzChKn3urKW6yVSUPOHh4VbtlEdKWe4PYB1w0MxjiEmfr4GXCxmjjuGvD7AP6FHUfUNCQqS1REREWN23qlDVZLo0eaZMcvOVOSAzNfby0uSZec6bk+fYlij52bCB8vLpk+U0S8tkZWfJgX8PlMOWDpM5OTlWXVOc9ygtM0vO3XJWdvpgnaz/+jI59JvNcsupuBLOtgjOREk5yU3Kw0uKfWlV+9xZQ3WTqSh5gJ3Siu/2ClnyklL2llK2NPNYDCCEsAMeAH4vZIyLhr9XgX+AjuUxd0X5kbvJ8b5nEEi8xj9e5DU1/fW1HSrKj2KKVqPliRZPcDj+MNsvb7f5+Do7LY/fVZ/IV8OYMrgFZ+NSGD57K4/M3sqOs9eLHqA41O0EOje17KUolMrqQ+kNHJVSxpg7KYRwFkK4Go+BvugtHEU1xK5PONqcLG4ujiiyr4efvvjVjUsVk4IlP4MbDsbT0ZMfD/5YdOcS4miv5Ykugfz7WjjvDGrOiavJDP1mC49/v41d527Y5iZae2gYfjt8WKEwQ2VVKMPJ54wXQtQWQqwwPPUFooUQ+4DtwHIp5apynqOinPB4oC85QkPGqvVF9rXXOeJSy7NSOOYBdFodob6hbLq0qUDSSFvjaK/l6W4NiHotnLcGNOPQpUQe/HozT/ywnb0Xbpb+BsF9IekSXDlU+rEU1ZJKubFRSvmkmbZLwADD8WmgTTlPS1FB6Pw8ue7fGIedm63qX9O/ToUliczP8tPLiYyJBMiTNBIoVgni4uDkoOWZHkE82qkec7ec49t/T3HfzE30aurDS30a07KOe8kGbtRb//fEGvBrabsJK6oNhVooQohPhRDPmml/VgjxUdlNS6HIS6ZbLbxO7kQKTZG5vWr61ebG5fLP52WO6bunk56dtz56WnYan+38jKycsq0576yz479hDYl6LZxX+jZmx9nrDPoqmmfm7uTQpYJlaIvE1Q/8WsOJtbafrKJaUNSS192AuXDc74BBtp+OQlGQ2Cmz8Dy+AwEIJC6JV/B6fwLOv63J0yfZ3Q8pNNz1yns0OHKT1OSkipu0AUvJIeNS4+j6W1fGrBnDN/u+YcflHaRlpZntW1pcHe157u5got+4m5d6N2br6XgGfhnNf+ft4tjlYr5GwX3hwjZIvVkmc1VUbYpa8tIZQsbyIKXMEeWeVEhxp+I69V3s8qWGt89Kp+33U7kYewVuXMd3y3LssvV9XJOu0mf7Bs5N+pJGn79VEVPOxVLSSA+dB/0C+7H76m5m7Z2FRGKnsaOufV1279pNiE8IbX3a4q4r4fKUGdwc7RnfO5gnuwTyffRpfth0llWHLjOwlT8v9g6mkY8VFQiD+0LUZ3A6Alrcb7O5KaoHRSmUVCFEsJTyhGmjECIYSC27aSkUt7GUbsUuOx3fFfMKJJIEvcLx/e5LqGCFYi5ppKPWkTc6vpHrQ0lIT2Dv1b3surqLyBOR/HL4F348+CMCQaOajWjv054Q3xDa+7TH19m31HNyr2HPhL5NGNW1AXOiT/PjprMsPxDL4Da1eaFXMA29C9mwFxAKjh76ZS+lUBT5KEqhTARWCiHeB3YZ2kKBN4EXy3BeCkUuKW4+5mvNu/rgcv0S0t4eYSZZi0vSNWaPG0X34SMrpCww3Ha8T989ncspl/Fz9mN8+/F5HPLuOnd61u1Jz7o9aZ/Unk7dOnEw7iC7ruxi95XdLDm1hN+P6bdk1XGpk6tc2vu2J9AtMM/u+OWnlxd6L1NqOjvwar+mPNW1AbOjTjN38zmW7rvEfe3q8MLdwQR6ORe8SKOFRr30CiUnBzSVNVBUUREUqlCklCuFEPcBrwLPG5oPAQ9KKQ+U8dwUCkCf20v3/gTss247tzPtdBx95Gk62GlJtqBwkly8SIq7xprZMwAqVKkUJ6LLyc6JDn4d6ODXAYCsnCyOXT+mVzBXdxMVE5WbdLKWY61c5XIr8xZzDszJtYasjSjzdNHxZv9mjO4WxLcbT/HL1nMs3nuJB9vX4fm7g6lbK1+qleC+cHAhXN4Ptdta/0Ioqj1Fhg1LKQ8CT5TDXBQKs/hPGkssel+Kc+JVUtx8SJowkZSezQG42TEc53UL8uT9ksDpOo0AyMpIJ2rB3ApTKKXFTmNHC68WtPBqwcgWI5FScibhDLuu6i2Y3Vd2s+78OrPXGssQW6PQvF11vD2oOWN6BPH1xlPM33aev3dfZGhoAOPCGxFQ06BYGhpS8p9YqxSKIg+FKhQhxFLIs5YggTggQko5rywnplCY4j9pLBgKa7kYHsciIwHw2B5B/ggRAQRdPMn6NvqMPElx18prqmWOEIIgjyCCPIIY2ngooI8m6/NXH7P9CytDbA4fN0cm3duCZ3s0ZFbkSRZsv8Bfu2J4uENdxoU3wt/dG2q31+9H6flqqeVRVB+KslA+M9NWC3hMCNFSSvlGGcxJoSgWlpz2rslxeZ5vnPcDnR96BAdHp/KYVrni5+yHv7N/icsQmx3T3ZF3h7TkPz0bMjPiJL/vuMAfO2J4pGNdXq13Ny7bpsKt61CjVmmnr6gmFOpRk1JuNPP4B32dknvKZ4oKReFYqpGS5OIFgJ2DAwHNWrJz6d/8OOG/HN8aXf5VD8uB8e3H46gtWOc8NSu1VOleans48cH9rdjwchgPtK/DvG3neTLaA2QOCQdVxiPFbUoUoiGlLF3FIIXChiRNmEimnS5PmwT2NWqNq5c3fcc8z8OTP+KR9z6jhqs7S6d9xML/TeR6JUkgaSuMZYjdHfLuXbmZfpPJmyeXOodY3Vo1+OjB1kS8HEZQ627ES1cil83ng+WHiUtOL3oARbWnqNQrtcw8GgohpqCP9lIoKhz/SWOJe3sqyW6+SAQprt5k2Neg3cn9PDpvBU179CLZ3Q/x2wZGfDiVu0c9y+WTx5n76jiiF/xCZnrZ7FCvCAYGDaSGfcECWEbnvC2o51mDT4a1Q9e0L73sD/BD9Cm6fxzBRyuPcj2l4J4gxZ1DURbKLmCn4a/x+DfACfhP2U5NobAeY+0UIXNwTrzK1YGP4pJ8DZfEq3nStVx571va3XMvo6Z9Q5PO3dn2z+/89PI4Tu7cVtEi2AxLTvjiOueLwqXlAFyyE9g4woO+LXz59t9TdP94A5+tPsbNW0qx3IkU5UNpIKUMMvw1HneUUr4GzCmnOSoUxabmhqUF2uyz0nGd+i4Azh416f/cyzw86SPsdToWf/oe/3w8hZtXbPulWxFYcsKX1DlvkYZ3g9AQcC2a6cPbsebFHoQ19WFGxEm6fxzB1LXHSUjNLHocRbWhNOnrO9tsFgqFjbEU+ZW/PaB5Sx7/+Ev2rFzC5r9+4+eXx9LxvqG4enqz+a/5JMVdQ2g0yJwcXL28K3TXvbVYSvcyvv14296oRi2oE6oPHw5/k2BfV2Y+2p7n705k+roTfLn+BD9uOkPvAEHIXZm4Otrb9v6KSkelrIeiUJSWNJ0rTumJ5tvztWnt7Ai99wGadO1B5Nzv2fzn/DznZU4OQKXYdW8Nxk2MX+z6gsu3LuNq78pbd71VNvVXgvtCxPuQfA1cvAFo6ufG14+FcOhSAl+sO8E/h6+w4eMIxvQI4okugbjo1NdOdaUop3x7C48QQP3cUFReLCXDLiRJtmstL+598XVquFnO8GvcdV/ZGRg0kLVD1+KodeSB4AfKrJgXwYbNlKcKVtNsUdud70aGMrmzIyH1a/Lp6mN0/3gD32w8xa2MLBbtuUjXjzbQ4I3ldP1oA4v2VK+ouzuRon4qfF7IuaO2nIhCYUsc0wpaJ4W1m3IrqfA+SXH6pJNJ8XG4enpV6mUwd507N9Nvlt0N/FqDs49+2avNcLNdAt21PDmkA3sv3GTa2uN8tPIoX60/QXpWDlk5+v1AF2+m8ubf+vSA97WrU3bzVZQpRSWHrJz/JQpFEVjKUJzi5kMhydkBcPX0KjJVi/F8ZV8G89B5kJBRguqM1qLR6K2Uo8shOwu0lr9S2tb14OenOrLr3HUe/W5brjIxkpqZzaerjymFUoUpasnrNZPjofnO/a80NxZCDBVCHBJC5AghQvOde1MIcVIIcUwI0c/C9Q2EENsM/X4XQjiUZj6K6oWlzY43n3yuyGu7Dx+JnYOuyH5GKvMymLvOnYT0MlQooFcoaTfh4q4iuwKE1K9FRlaO2XOXbqoyS1WZovahmNqwb+Y7V9rUKweBB4B/TRuFEM0N921huMcsIYTWzPUfA9OklI2AG8DTpZyPohpRYLOjsxcS8J31fp669Kalg41tzbqH03fMc7h66Z3MwlDzw/jcHElx1zgSFVEeohWLMl/yAggKB6HVL3tZSW0P8/nULLUrqgZF+VCEhWNzz4uFlPIIkKc4kIEhwAIpZTpwRghxEugIbMm9sf6iu4FHDU0/A5OBr0szJ0X1wjRDceKUWTi++0JuTRWXxCs4TnkBIQTanKzcNt37E4gFmk0aa3YJa/a4URaXwyrj0le5WChOHlC3k16h9HrHqkte7deEN/8+QGrm7SxOAhjfK7hs5qgoF4qyUPKnrrd0zpbUAS6YPI8xtJniCdyUUmYV0kehyMV16rtoc/KmoLOT2bnKxIjp5kdzFLYcVhmXvjx0HiSmJ5Z9MszgPvqCW0nWbQy9r10dPnygFXU8nBCAp7MDEth0Kq5aJu68UyjKQmkjhEhE/+PByXCM4XnBtKb5EEKsA8xtz31LSrm4WDMtIUKIMcAYAF9fXyINNTSKIjk52eq+VYXqJlNx5OlpYaOjOZwTrxYyriCgey/Orl9h9mxS3LVSvca2fo/iEuPIklmsiliFk6bslpOck2vRATi6bAaX/XvnOWdJJg/gg7s0gL7U8JJTkr/3XsIpNY57GlTuXQl38v9SYRQV5WXOd2E1UsreRfcqwEWgrsnzAEObKfGAhxDCzmClmOtjnMNsYDZAaGioDAsLs2oSkZGRWNu3qlDdZCqOPJbKBJsjxc2n8HHDwpi9b4fZpS9XL+9Svca2fo9unLjBos2LaNWhFQGuATYbtwBSwrGPaao9T9N887dWph49JCnzd/HH4Svc270dXRt5lc1cbcCd/L9UGCVKX1/GLAGGCyF0QogGQDCw3bSD1NvEEcBDhqYngHKxeBRVE3NRX1lCS7Ym728qCdRIvMqNB58sdDxzS192Djq6Dx9pi+naDA+dB0DZ+1GEgODecCoCskuWv0ujEXw+rC0NvV147tfdXLh+y8aTVJQ1FaZQhBD3CyFi0OcEWy6EWA0gpTwE/AEcBlYB44z1V4QQK4QQtQ1DvA5MMDjtPYHvy1sGRdUhf9RXspsv1yZ9ydWJ08nQOuY6BAWgQeLx989kONQgdsoss+PljwRDCO5+ckylcsiD3ikP5aBQQJ+GJT0RLmwvuq8FXHR2zB4ZSlaO5NlfdpGaoUovVSUqTKFIKf+RUgZIKXVSSl8pZT+Tcx9IKRtKKZtIKVeatA+QUl4yHJ82ZD5uJKUcaogKUygsYpri3iXhMv6TxuI/aSx2ORlmQxgdMlPxen9CoUplzMwfGfHBVJCS9NTK94vaaKGUeegwQIOeoLEvVviw2WG8nPlyeDuOXE7k9YX7lZO+ClEZl7wUinJFSPOb7KDoqC8Av0aNqdu8FbtWLCY7K6vQvuWN0UIpF4Xi6Ab17oITa0s9VHhTH17p24Ql+y7x4oK9KudXFUEpFMUdjxSF/xtYSoVvSofBD5IcH8exzf8W2bc8cdO5AZRt+hVTXHzh6iGY7AHTWsL+P0o81NiwhrQOcGPxvktcvJmK5HbOL6VUKidKoSjueBLuf7zQTVUpbj5FjhHYNgSvuvXZsWRhpVqisdfY42LvUj4+lP1/wNFlhicSEi7A0hfwubKxRMMJIbiWVLDyozHnl6LyoRSK4o6n5sKfuPnAE+RgfveuNiPNoh/FiBCCDoMfJO7COc7utS6nVXlRLrvlAda/C1lpedsyUwk6/UuJh7yckGa2XeX8qpwohaJQoFcqVybPJCdfGLEAnNISCnXOG2nSpQeunt7sWLKwDGdafMolnxdAQozZZl16XImHtJTbSwKPzdnGP3tiuJVRufxWdzJKoSgUBvTpWcx/OVnjnNfa2REycAgXDh8g9mTlWZLx0HmUj4Xibn7jZLpDrRIP+Wq/JjjZ591frbPT0K+5L+eup/DS7/vo8P46Xv1zH1tPx5OTU3mWG+9ElEJRKAwU5Xy3xjnf6u6+6Go4s3PJ37aaVqlxdyinJa9eE8G+oEWhzU6DywdKNGT+nF91PJz4+MHWfDsylI2vhPP7mLsY2NqflQcvM3z2Vnp8GsHUtcc5F59SSmEUJUEVd1YoDFgqypXnfBFjODjVoE6zFhzftonPHx6Eq5d3hVd0LLclr9bD9H/Xv6tf/nIPgNCnyImaAT/0h2E/Q6NexR72vnZ1zBbd0mgEnYI86RTkyZTBLVl96DILd8fw1YYTfLn+BB0Ca/Jg+wAGtPbHzbFy5warLiiFolAYSJowEd37E3JT3JuSaacjacLEIhXKkagIzh/Ye3vMSlDR0V3nTlJGEtk52Wg1pUrPVzSth91WLAZ2p9Sj85lp8OswGPQFtH/c5rd1ctDmKp5LN1P5Z89FFu6O4Y2/DzBpySH6tfDjwZAAujXyQqspVeUNRSEohaJQGPCfNJZY9L4UZ4OlIoAcoeFK2P0EGGqrFEbUgrlkZeQNdTWmta8oheKh80AiScpIwsPRo9zvn+7oBaNWwp9PwJLn4OZ5CP8/ff6vMqC2hxPjwhsxNqwhey/cZOHuGJbui2XJvkv4uum4r10dHmofQLCva5nc/05G+VAUChP8J40lacJEsux0uelYNDIH38h/iOnzSIHqjvlJijcf0ZQUV/JIp9JSrrvlLeHoBo/+Ae0eg38/gX/+A1kF95jYEiEE7erV5P37WrH9rV7MGtGelrXdmRN1hj7T/mXIjGjmbjnLjZSyncedhLJQFIp8uE59t8Cyl31WOnXWLchVMqbVHf1NLBdXTy+zae2FRhB74hj+wU3KcObmyU0QWV675S2htYfBM8AjECLeh8SL8PA8fcXHMkZnp2VAK38GtPLnWlI6i/deZOHui0xcfIj3lh2mV1NfHgwJIKyJN/Za9Tu7pKhXTqHIh6VorvwLNPZZ6fhOeT6PxWIurb3W3h6dszMLJr3GtkV/InMs5w4rC8othb01CAE9X4X7v4XzW+GHe+DmhaKvsyHerjpGdw9i5fjurHihOyM7B7Lz3HWembuTu/63nilLD3HwYkKlynhQVVAKRaHIhzWpVoxoZA4CiUviFfwmjyP43gd5qEFTfVp7IXD18qbfsy/w9PTvCO7YhejffuavD94m+Xp8GUqQl0qx5JWfNsPhsYWQeAnm9IJLeytkGs1ru/HOoOZsebMX3z8RSqegWszfep5BX0XTf3oU3/17mqtJ5nfrKwqilrwUinyYi/aSFLRQ8iMAu4Qb+H/4KWN++hFGjMhzfuD416jfph0bfvyWn197nhY9e3F8azRJ8XG4enoZinPdvsuRqAiiFszNc74kjv3tsfr6JG9Fv8WMPTMY3348A4MGFnscmxPUE55eDfOHwo8DYOhP0LhvhUzFXquhVzNfejXz5eatDJbuj2Xhrhg+WHGEj1YdpUewFw+GBNC7mS+O9mUcKVeFURaKQpEPc8W4LvYeXqDioyU0WZlkjX2+QLsQglbhfXn8o+nY63TsWvaP3t8iZW54cfzxw4BemayZPaPA+SNREcWSZfnp5Xyy45Pc57EpsUzePJnlp5cXa5wyw6cZjF4Hng3ht+Gw88eKnhEeNRx4/K76LBrXlXUTevJsjyCOXk7iuV/30PGDdfzfPwc4eSNbLYmZQVkoCoUZ/CeNBYOz3cXwiJ0yyxBSfBUpBJpC6qhoE29YPFerdkDBLJTow4vPRqxiwcVzXDl9kqyM9ALnixt+PH33dNKy8y7ZpGWnMX339MphpQC4+unDiv8aBctehJvn4O6JoKn437uNfFx47Z6mvNy3CVtOxbNwdwx/744hLTOHX09t5MGQAO5vV4ftZ67z6epjXLqZSm0PJ17t18TsZszqjlIoCoWVmCqZy1Nm4WVhE6Q1JF23EEack4PQiALKJPc6MxFkhXE55bLZ9tiUWEasGIG/sz9+Nfzwc877qOVYC00RdWJsis4Fhv8GK16B6Gn6vSr3fQ1WWoVljVYj6BbsRbdgL94d0oJpf0VyMEXHp6uP8enqY2gEGNOIGWu2AHecUlEKRaEoAcZNkL6Tn0NjxtzItHPEoZDrLYUXO7i48fCkj5g9bpRF5XEkKsJqK8XP2Y/YlNgC7U52TjhpnTh6/SiRFyJJz84XJq2xx6eGz20lU8NPr3xMlI6bgxvCwubE5aeXM333dC6nXMZD68Hrp18v2iLS2sGgaVCzPqybDEmX9WHFNUqeXLIscHW0p0eAPRPDOnPh+i0GfBlFUlrepKLGmi1KoZQDQoihwGSgGdBRSrnT0N4H+AhwADKAV6WUG8xcPxl4BjD+x/2flHJF2c9cobhNYUpFm5NF7JRZefaomNJ9+EjWzJ6RxxKxc9BRu1O33PMrZnxu9triLHuNbz+eyZsn51n2ctQ6MqnzpNwveCklN9Nvcjnlsv5x6zKxKbFcTrnMlZQr7Lmyh6u3rpIl835pOtk54VvDN691U8OPc4nn+PXor7lK6kb2DSZvngxQtFIRArq9BO51YdF/4fu+8NhfUDPQKnnLm7q1apCcZj5D9Z1Ys6WiLJSDwAPAt/na44B7pZSXhBAtgdWAJRU/TUr5WRnOUaEoEv9JY0n96P9wSsu7x0Obk4X7J2+TOf5x7D0Kpvjw2HCEpxZH45J0jSQXL7Z16k7ApOe4kq3/xd+se7hFhZIUd42Umzdw9qhZ5PyMX+BGa8HP2a9AlJcQgpqONanpWJNmns3MjpOdk018WvxtpWNQPEals/niZq6lXkNaqH2Zlp3Gh9s+LHQeeWj1ELj6w4JHYU5vePR3qBNSpLwVQW0PJy6aUR6WarlUZypEoUgpjwAFzGUp5R6Tp4cAJyGETkpZsoVqhaIccExLNNte49YNcmp5cN2/Makt2qPp0hmXAWEkrYzE+/1Xcv0vbsnX6L3+b9I2rSd55FgICwPA1cvb4rLX7LGjaNK5G+3uuRf/4CaFhhgPDBpYpGVQVIiyVqPFp4YPPjV8aO3d2uwYmTmZXLt1jX4L+5k9n5CRkLtb3xhtZpyfWQK7wtNrYf6D8NMgePB7aDqgUDkqglf7NeHNvw+Qmpmd2+Zkr+HVfuWfFaGiqcw+lAeB3YUok+eEECOBncDLUkrLYTUKRRliKe19qpMH1wc8gsP+nXhH/oPD2l9hCjgjCiyRGStDhs7+kPhNEXge3GJxWazL0BEkXb/Goch1HImOxM3Hl+Tr8eRk6Zdeipvh2BiibLxPSTMk22vsqe1SG39nf7N+m/xYFW3m3RhGr9dnKv59BPT/BBzd86bI7zWxQIbj8sToJ/l09bFcS+Wxu+rfcf4TAFFWsdRCiHWAn5lTb0kpFxv6RAKvGH0oJte2AJYAfaWUp8yM7Yt+eUwC7wH+UsqnLMxjDDAGwNfXN2TBggVWzT85ORkXl6KSlVctqptMlUUe59/W0PaHqXkivjLtdOx9agIpj+g36snMLOwPncV512HazptW6CZJCZwOH8yFiS8Rf/wwl7ZFk5GciIOLG7U7dcOzcXMAsjMyiD9+iAvREWAmhFljZ0fNRk3RaLUIrR1Cq0Wj0SLs7Axt+ucx2/4lO63gbnAHFzdaPT6m2K/HjuQd/Hb9NzJlplX9v6r/VZF9NNlpND/8GV7xO8gRWjTytjWQrdFxrMk4rvr2LPZcS4qlz15WjuTljakEuml4KcSx3OZTWor6XwoPD98lpQwtapwyUyjWYE6hCCECgA3AKCnlJivGCASWSSlbFtU3NDRU7ty5s6huAERGRhJmWHqoLlQ3mSqTPKZ7VFLcfEiaMNGiQz7Z3a/QQl6gVyppju44piUWOd7nD9+L2Y0tgIunF9kZGWRnZZKdmUl2VjHqrwvBywuWWt/fhPxRXtJOmk394u/sz5qH1lg3aE42fFQPMpILnnOvCy8dLNFcS0Jhn73PVh9jVuRJol6/mzpVxI9S1P+SEMIqhVKplryEEB7AcuCNwpSJEMJfSmm0qe9H7+RXKCoMcxshLVFYIS8jxiUw0Gc2dp48jpjoKALW/lagr6uX+RBkVy9vxszMu/Nc5uSQnZVFdlYmWQZF8+vbr5By43rB6z29CpGicEz9NpGRkaTUSykQbQZQ37U+UkqL4cd50Gghw0Jp34SYEs/V1gzvWJeZkSf5fft5JvS9s/woFbIVVQhxvxAiBugMLBdCrDaceg5oBEwUQuw1PHwM18wRQhg15CdCiANCiP1AOPBSecugUJQUY2qXVJ2bBbuiIAKos26B2Ros5jIc2znoDLnB8o2j0WDn4ICuhjPOHjVx8/Kh54hRVl9fUgYGDWRyl8n4O/sjEPg7+9MzoCdbL29l1r6CMlnEPcDyucXj4OwmKOdszvkJqFmDsMbeLNhxgczsip1LeVNRUV7/AP+YaX8feN/CNaNNjm1fQ1ShKEeMFk18y87UOrS1yMSToFcqHh++mWsJGTE6zkuaSNLYb/1Ps0lPTgLATlfYtsySkT/aTErJ5C2T+WbfN1xMusjOKzuLDinuNRGWvgCZJmG6Wp0+pPjQItgzDzzqQ5tHoM3DUCvI5nJYw6Od6vPM3J2sP3KVe1qacyVXTyrVkpdCcafheXALNx58Eo+/f7ZKqTimJ5Lq5MHNN/6Xx6fSrHt4qUsMZ5uULk5LSipRpFdxEELwzl3vcDT+KEtP3/bVFBpSbIzmMhfllZECR5bBvl9h48ew8SOo11mvXFrcp48OKyfCm3jj5+bIr9vP31EKpeKzrykUdzg1F/7E5ckzrcpmbPSteE95gVQnj0LLEReHqAVzLSajLEvsNHZcTy/ovzGGFJul9TC9A37yTf1fo5JxcNZbJSMX69t7TYJb8XqL5rPG8NdTcGKd3rlfxthpNQzvWJd/j1/jfPytMr9fZUEpFIWiEmD0qyS5+iARZGh1hfpX7GQ2TmkJucW9vN6fUCqlkhRvPlllUtw1Ph9+L7PHjSp26nxruZJiPuLNUmJLq3APgO4TYNx2GL1BX8v+5Hr9JsmpzWHNO3DlMOz/A6a1hMke+r/7/yj5PfPxcIe6aAT8tuO8zcas7CiFolBUEvwnjWXXkt8RMgeHrDTSirFEY5+VjuvUd0t870IjukpRj8Ua/JzNLwlZai8WQkBACAz8HF45DsN+gTrtYess+Loz/D0GEi4AUv936Qs2Uyr+7k70aubLnzsvkJF1ZzjnlUJRKCopN9/4n9VFvQCcE6+UePnLXKRYfspqCWx8+/E4agtuAuwR0MO2N7LTQfPB8Mhv8PIxcPSgwP6dzFRYP8Vmt3y0Uz3ikjNYc7gU1lYVQikUhaKSUtzwYgG5y18xfR4h2d0PKTSkOroX6W9p1j2cvmOew9XLW/+r3gKWlsZKw8CggQxpNKRA++KTi8uusqSzF+RL6JlLQgxs+hJS4kt9mx7B3gTUdOLXbXfGspdSKApFJcZ/0lic0hK4PHlmbkniVJ0b2RrLAZr2WenUWbcAl8QrCCRO6YlW+VuadQ9nzMwfeXnBUr1iMYPOuWxS3fwb82+BtkId87bA0p4WrQOsfQemNoW/noaz0VDCjCJajeCRjvXYfCqe09fM7PCvZiiFolBUAfwnjcUl4TJC5uCUlsDVidMNCsY8hYUg22el6/ezFEL34SMRWm2B9vSU5DLxo1hywJfKMV8UvSaCfb7UKPZOMGQmjN0KoU/BibXw00CY2RG2zIRbBSPSimJoaAB2GsFv26u/laIUikJRBTEqmBQ33xJd75ieSEyfRyyeb9Y9HK2dGStIStb/NLtE9ywMSw54TydPm98rl9bD4N4v9XnAEPq/936pb/dpBv0/hpePwpBZ+j0sq/8PPm8Kfz+LW8IRq60WH1dH+rbw5c9dMaRlln3IckWiFIpCUYVJmjCxgOPeWn9LnXULTHwtghyNFilErp8lK918rjHjbnpbYskxfyP1BguPL6TMktha2tNixKEGtBsBo9fBf6Kh/eNwdDnt97wBszrDtm8h9WaRt3m0Y31u3spk1cHq7ZxXCkWhqMIYHfdG/0qymy8Xew+3epPkbV8LaGROrmPfb/I4eu2zbnnnSFQEs8eNKtV+FXO5vt6+6206+ndk8pbJvLPpHVKzKrikrl8rQ/jxMY42eQ7sHWHla3qrZdFYuLDDotXSpaEngZ41mL/tXDlPunxRqVcUiiqOuUzHpun0JRQo6GXEkq9FAG2ObQE6s75NrQLn961diVe9QOJjzhPx0+xSF+cC85UlHwp+iG/3f8s3+77hyPUjTA2bSn23+sUa1+Y4OHPZvw9NH/kALu2FXT/C/j9h73zwbQkhT0Lrh8HRLfcSjcE5/+HKoxy/kkRj34JloasDykJRKKohpk78K5NnWJ3V2BSjUnnpjxVM+GM5z6zYTrMY/Qa9dXNmsmDiq6yd/VWZpmzRarSMbTuWWb1nceXWFR5e9jDrzq2zydg2oXZbuHc6vHIMBk0DoYEVr8DnTWDxc3Bxd27Xh0ICcNBqqnUIsbJQFIpqjv+kscRER1Fn3YI8Fomk8GgwDOeFQR25JV+j/+aVhDs6Iad9TmyHEBZ9Yn53flLcNc4f3Eedps1z245EReTJaOzo6srdT4yxypLpVqcbfw76k5c3vsxLkS8xsvlIXgx5EXuNfZHXlgs6V31UWMgovRLZ9QMcXAh7fgH/NhAyCs9WD/HfWrsYuvM5cnbFcVV4c6H9q3QY/GxFz95mKAtFobgDCFj7W569LMXxtZiiT06ZiuPz42l49ITF/SoAf773FrNGP8qp1UtYM3sGK7/+Io9DPy0piRUzPmfm6Ees8rv4u/jz8z0/80jTR5h7eC6jV4/m6q2rxZp/mWNM9TJkpj5CbMBnkJ0Fy14k66MGPJ/4OQGaODQC/LhGy11vs2PJtxU9a5uhLBSF4g6hcF+LPkGjNSn0ATRZmWSNfJLRMgchc5BCw/7GnVjfphZ2DjruHvUsTq5unN6zg6NbN3Hg9HGLYxUnVb691p7/6/R/tPNpx6TNkxi6dCgPNHqA5WeWF11LpbxxdIeOz0CH0XBhO5k/3IuTyMzTxUlkUHf3p1BNrBRloSgUdzC3fS2Si72HF8vXos3Jyo0M08gc2hzbwtDoMzy1OJqWve7B5+4h2C+6St0eY4ocq7h+l/4N+rNg4AK0Qsucg3OITYlFInNrqZRZypaSIATU64ROmg/D9pXXbJrluCJRCkWhUAC3l8XSHK3PHZb/ed1Lh3FNuopA4pZ8lbCV79Pw0+nUqNWhyPGKmycsyCMIrSi4mz8tO42Pt39MQrqFXF0VxFVhfnlQCGya5bgiUQpFoVDk4j9pLI6pCYh586B+fSTWbZQ0Yk7JtDq8hGe/mUKvPTGFXltoCn0LXLllvpbKjfQbdF/QnQeWPMD7W99n5ZmVBequLD+9nL5/9aX1z63p+1ffMrdqLrR/lVRpobRyZqq+CmUVR/lQFApFQUaMgBEjEOj9LD7vjkebk5V72poIMSPGSLE2J/bR/Mwx1nUM50hAwd+ymelpHImKsHr/ypGoCIZF1sXxFqQ4ZrOryQ3O1NFXR/R09GR40+HsvrKbpaeW8vux3wGo41KHEN8Q7IQdy88sJz1bvwxVaNlhG9Fh8LPsAEJ3v2b+tUsoXOFWBSpEoQghhgKTgWZARynlTkN7IHAEOGboulVK+R8z19cCfgcCgbPAMCnljbKet0JxJ+I/aSyxkLtRMsXNhxTf+vic2F6sMGQBOGSl0X/zSvoDSS7eRLcOzVUueuf8V2RmpNO0a0+ERoNGo0FoNAihQZik1T8SFcGa2TNwytC3uaTZ0WOfF97Xk9jfNpVXO7yaqxiycrI4dv0Yu67sYvfV3URfjOZ6muWyw2Xp0O8w+Fk49ZWhqFdectzqVPklo4qyUA4CDwDm4uVOSSnbFnH9G8B6KeVHQog3DM9ft+0UFQqFEXMRYjF9HqH2+j9yo7yk1g5tVkaRYxnVgnFfS38gTedKREg3jgRksHb2DNYaor7yXihyFUx2ZmbB0wiaXXClV+f78ygFO40dLbxa0MKrBSNbjERKSZu5bZBmFvNiU2KRUrLizAqm755eNpFjvSbqfSaZt1PJ3JIOLHAaySgp8yjOqkaFKBQp5RGgNC/cECDMcPwzEIlSKApFuRKw9jfgN8CgJObPJ+fxkWik9eVujd8ATulJ9Nu6ltrBHQi6eBLX5DiSXLzZ2vFpTgT3AsBel41fgwQ8vJPZsWShhfEEyRv2w4N6KyZqwVyS4uNw9fSi+/CRNOsejhACP2c/YlNizY4x8J+BXE65TGaOXmnZfDnMmIBy3WRIvAg6d7Y2fI13dzcgZcNJnu8VXPp7VBCizLJ4WnNzISKBV/IteR0CjgOJwNtSyigz192UUnoYjgVww/jcTN8xwBgAX1/fkAULFlg1t+TkZFxcyqaYUEVR3WSqbvJA1ZfJZ906Gn7xJQ4p+g2Mxf3JmH/ZzPjtlKZzI6rrOE427U3tDnAhag4ZyYmW59E6hGuH9yGzsvK0ezVvQ/2efdiRvIPfrv9Gprxt6dgLe0JqhLA9ZTs5FFSKNbU1eTdA7zi31fvUZdMTxHuGcrTJc8w+kM6WS9m80E5He9/y/a1flDzh4eG7pJShRY1TZgpFCLEOMFfk4C0p5WJDn0jyKhQd4CKljBdChACLgBZSyjyfHFOFYnh+Q0pZs6g5hYaGyp07d1o1/8jISMLCwqzqW1WobjJVN3mgesl048Encf/7Z4NTvvTov6kEh1sPRjNjPCtmfG6+oxCF1ipp02cAvUePZfnp5WaXtVr/3NrscphAsP+J/YCN3qf9f8DicZCdAe51yQh7m4c2BXDqajL/jOtargkki5JHCGGVQikzNSil7F2Ca9KBdMPxLiHEKaAxkF8LXBFC+EspY4UQ/kAly7+gUChqLvwJ+Ikdz/4fzRb8UOzd+PnRXydpvn8x9FhMUyDTzp61IS04Wr8OAHYOOnqPHsuqWdMsjrNv7QrqNGnGwO4FsxsDFpfDLBUBKxH7/9D7UbINPqeECziseJG5vT6nz3pfnpm7k8XjuuJRw0KYcSWlUgUVCCG8hdDvVBJCBAHBwGkzXZcATxiOnwAWl88MFQpFcUl5pG/ubvzCNk5au1YiTB4OWZkM2LaX5/9ez4Q/lvP8/EU0D+vNMyt20OJqMBr7JmbHKGxXvrliX45aR8a3H2/lDK1g/bt5nPIAZKbiseVDvnkshNibaTz36x6ysq33R1UGKkShCCHuF0LEAJ2B5UKI1YZTPYD9Qoi9wF/Af6SU1w3XzBFCGE2uj4A+QogTQG/Dc4VCUckx3TiZ5VYzd+NkmpN7iZJVwu1wZNMiYW7JV+kX+QXjfv86N+W+KUlx1yyOZ1rsy8joVqNtG05sac9JwgVCvCXv39+S6JNxfLjyqO3uWQ5UiEKRUv4jpQyQUuqklL5Syn6G9oVSyhZSyrZSyvZSyqUm14w2+lqklPFSyl5SymApZW+j0lEoFFWEESOwS7iOkBIhJY63bhKw9jfi3p5qdeqXotArmlT6b17J3Xvy7vsQmsK/+gYGDWTNQ2vY8sgWdBodcw7Mse2OevcAy+emNmNYzEe82TaN76PP8NeuqrPhUe2UVygUlYbc/S7z58OzzyJTUkrt0BdA2xP7aXH6ONl29jimJ5Pk4sWh//wfm7SxBcKKwSTkOO4a9zp5savxDc7UuZ18cpjHMMJydy6UADN7UbB3gh6vQ8J52Pc7z2bO427Xpny7qBeNar1A2wY29OGUEUqhKBSKyocx9cv8+WSPHoMm7VbuqZIoGAE4ZKdBdhqg31TZ/NsPMZb/Oudbl8WJt4NJ18yekVuJ0iXVjm77POl8wBP7HP3dM+wjOOIeWuwyx7kY96Ksf1e//OUeoFcyxvbek2HvbwRtm81nmTO5/vMvpHR8EucuY8CjbsnuWQ4ohaJQKCovI0agHTEi96ktQ5FNr69/5QIvzLtA0qIoNrXtSFbtvH21aNCauGJ0mYJV30wHiq7hYpHWw24rkPw4usNd/0HbcQznd63gxLJphG2fgdwxA9FkgL7GSlCYIVVx5UEpFIVCUWUwhiLfLgx2lTSdK9rsTOyzUksZkqy3XO6JXs495N1kmapzJKJt09zwZICcrCyW/vwlOc19aOHZoqQiFY5GQ70OgzjsFEqPeat4t8527j6/CnF0GXg11iuWNo+Ao1vZ3L+YVKqwYYVCobCG24XBcnBKS8Ah81aByLGSYrR+NCbHNdLTGLBtLw9u3J+nryYpgze/fYoRy0ew9NRSMrKLzmVWEu5p6cfQ3l14+uJAfuq4HO77Rl/HfuVr8HlTWDYBrh7Rd97/B0xrCZM99H/Lsc6KslAUCkX1YMQI7AzLY7FTZuHx4Zs4pifaZJc+6BVL/SsXmPDHBSSCC7VbUzMxlpf/uEZSjSOsbX+AJwd/wV29hjCsyTDbboQEXrg7mCOxiby3+jSNnupN92cegYu7YPsc2DMPdn4Pno3h5tk8GyZZ+oL+2NLymg1RFopCoah2+E8ai1NaApcnzyTZzReJIFXnRqqje6ksmNvWi6TepX24JRuqU95K4oHoA7zy7Un2/7aQfgv78WLEi2yL3YaU0ibFvDQawdRhbQn2ceW5X/dwNi4F6oTA/V/DhCN6R/71U7eViZFyLN6lLBSFQlFtMU2772TSntyhB847b+edLWnkWP7n7U6dZ9YXF1l7fw921zhOVOq7rHGSnPe+Rderjjin1SXFMZsfTn4Ew4qfvdhZZ8d3I0MZPDOaZ+bu5O+xXXB1tAdnT+j2EqybYv7CcirepSwUhUJxx+Gy49/cTZWXJ88kVWfLzZTZ9P8zglcWRPPyHysZv3An92+ugUuaHQKBS5odHfe58uvf07iVeavIMfNbNwcSIpj1aHtOx6Xw0u/7yMkxmbmlDZOFbaS0IcpCUSgUdzRGKyZ2yixqfvQmujT9fhRjlFdJrBcN+hovcLuQWG87J+yz0khy8SK6dSiaHB3DPw0ntbEbQe5BNHBvkPu3gXsDPB09WXFmBZM3TybNsH/GuLFycpfJvDOwOZOXHmbauuO83NeQs8zShsleE0v8+hQHpVAUCoWCvMtjoFckttr3YkwDA3krVb7yB0ihIar7dV4ds4fUrNuKwNXBlbSstNxCX0aMpYpXP7iaI7FJfLXhJE393BjY2v+2492oVNzr5t0wWcYohaJQKBQWMN334vney9gbLIXSWC/ku07IHHr8u5vN0VrWd+/AQV9PNO41SOvsz6+aDWavv5xyGSEE797XghNXk3jlz3008HKmeW03vfK4uBv2/AIvHSzhDEuG8qEoFApFEfhPGotDVmqu3+XfiAhuPvCETfwuoFcwdjnZ9N64labnLpKTcIsaG2JoccXLbH83B/1GRp2dlm8eD8HdyZ5n5u4kPlmfLgZXX8hIhvRkG83QOpSFolAoFCWg5sKfiJ3SMddyyV+6uCTWixYYsG0vA7btBeAF43hCw75GLVnfLgAJnKyfCo/oz/m4OjJ7ZAhDv9nC2Pm7mTe6E/Yuhj0wyVdAV34lpZWFolAoFCXEaLmY7ndJdvPlanDHUu91MX1oZA5tT+znoY0H0CAIPufEnKmv5V7TOsCDjx9sza749XSd34vW+/5H34DaLD9ZvrUHlYWiUCgUpcTUoe9ieOTPN2afcQutzCqV38W4Ux+AP1aQ8+pn/Pu/0Vy7vw8n0k/gXGchqTILgFh7O944+iN75C3evuvt0opoFcpCUSgUijIgf74xu5xMYu4eTI7QlHi3fgHLJUfS843veKjJMN7s/BYfzLpY4Jrfjy7ghV8fKZUs1qIUikKhUJQTddcvRpOTjZDSZk59UwUzcPs19j95kC+mxZl0EERkHODLPyfY4G6FoxSKQqFQVAA1F/5k4nspXYZkI0bFcve+y+x/8iA7Rx/jieW3QAi+T1ljm/LFhVAhCkUIMVQIcUgIkSOECDVpHyGE2GvyyBFCtDVz/WQhxEWTfgPKVQCFQqGwAbeXxSRi3jyoXz9XudgiBb8uK5OX/zzN/icPsuepI1yZMK1MlUpFWSgHgQeAf00bpZTzpZRtpZRtgceBM1LKvRbGmGbsK6VcUaazVSgUirJmxAg4ezZ3r4uYN49sxxqltlxMI8VGLV5Pt5YjirqkxFSIQpFSHpFSHiui2yPAgvKYj0KhUFQ6RoxAm5qSJyQ5h9JbLm6pCST4BtpmjvnHl9JWez1LcHMhIoFXpJQ7zZw7BQyRUhbIHSCEmAw8CSQCO4GXpZQ3LNxjDDAGwNfXN2TBAut0VHJyMi4u5bchqDyobjJVN3lAyVRVqEiZmv73P/gevf17vCRhyBLYGBGR+7woecLDw3dJKUMtdsgdWMoyeQDr0C9t5X8MMekTCYSaubYTcKCQsX3RbyrVAB8AP1gzp5CQEGktERERVvetKlQ3maqbPFIqmaoKlUWmpJD2MgdkDkhZjEcO5BmnKHmAndKK79gy29gopexdisuHA78VMvYV47EQ4jtgWSnupVAoFFUSl527ANsUDLMFlS5sWAihAYZRiP9ECOFv8vR+9JaPQqFQ3JGYFgxLCWlfaKSYBBJ96pfJPCoqbPh+IUQM0BlYLoRYbXK6B3BBSnk63zVzTEKMPxFCHBBC7AfCgZfKZeIKhUJRyXHZuStXuWTZ2+VRLkZl4n7lbJncu0JyeUkp/wH+sXAuErjLTPtok+PHy2xyCoVCUU2wz8gs0OZehverdEteCoVCoaiaKIWiUCgUCpugFIpCoVAobIJSKAqFQqGwCUqhKBQKhcImVGjqlfJGCHENOGdldy8grsheVYvqJlN1kweUTFWF6iZTUfLUl1J6FzXIHaVQioMQYqe0JndNFaK6yVTd5AElU1WhuslkK3nUkpdCoVAobIJSKAqFQqGwCUqhWGZ2RU+gDKhuMlU3eUDJVFWobjLZRB7lQ1EoFAqFTVAWikKhUChsglIoCoVCobAJd6RCEULcI4Q4JoQ4KYR4w8x5nRDid8P5bUKIQJNzbxrajwkh+pXrxC1QUnmEEIFCiFQhxF7D45tyn7wFrJCphxBitxAiSwjxUL5zTwghThgeT5TfrAunlDJlm7xPS8pv1paxQp4JQojDQoj9Qoj1Qoj6Jueq6ntUmEyV7j0Cq2T6j6EcyF4hRLQQornJueJ931lT1rE6PdCXDj4FBAEOwD6geb4+Y4FvDMfDgd8Nx80N/XVAA8M42iosTyBwsKLfkxLKFAi0BuYCD5m01wJOG/7WNBzXrMoyGc4lV7QMJZAnHKhhOP6vyeeuKr9HZmWqjO9RMWRyMzkeDKwyHBf7++5OtFA6AiellKellBnoK0MOyddnCPCz4fgvoJcQQhjaF0gp06WUZ4CThvEqktLIU1kpUiYp5Vkp5X4gJ9+1/YC1UsrrUsobwFrgnvKYdBGURqbKiDXyREgpbxmebgUCDMdV+T2yJFNlxRqZEk2eOnO70GOxv+/uRIVSB7hg8jzG0Ga2j5QyC0gAPK28trwpjTwADYQQe4QQG4UQ3ct6slZSmte5Mr5HUPp5OQohdgohtgoh7rPpzEpGceV5GlhZwmvLi9LIBJXvPQIrZRJCjBNCnAI+AV4ozrWmVEjFRkWlIRaoJ6WMF0KEAIuEEC3y/WJRVA7qSykvCiGCgA1CiANSylMVPSlrEEI8BoQCPSt6LrbCgkxV9j2SUs4EZgohHgXeBkrk17oTLZSLQF2T5wGGNrN9hBB26Ktmxlt5bXlTYnkMpmw8gJRyF/o10sZlPuOiKc3rXBnfIyjlvKSUFw1/TwORQDtbTq4EWCWPEKI38BYwWEqZXpxrK4DSyFQZ3yMo/mu9ALivhNfekU55O/ROwAbcdlK1yNdnHHmd2H8YjluQ10l1mop3ypdGHm/j/NE77S4CtarCe2TS9ycKOuXPoHf21jQcV3WZagI6w7EXcIJ8jtXKKA/6L9RTQHC+9ir7HhUiU6V7j4ohU7DJ8b3ATsNxsb/vKlTYCnyRBwDHDR+Mtwxt76L/xQHgCPyJ3gm1HQgyufYtw3XHgP4VLUtp5AEeBA4Be4HdwL0VLUsxZOqAfk03Bb31eMjk2qcMsp4ERlW0LKWVCegCHDD8cx8Anq5oWayUZx1wxfD52gssqQbvkVmZKut7ZKVM002+ByIwUTjF/b5TqVcUCoVCYRPuRB+KQqFQKMoApVAUCoVCYROUQlEoFAqFTVAKRaFQKBQ2QSkUhUKhUNgEpVAUChsjhPgpf7ZgheJOQCkUhUKhUNgEpVAUilIihBhpqI+xTwjxi6G5hxBisxDitNFaEUK4GGpo7DbUnxhiaA8UQhwRQnwnhDgkhFgjhHAynOtgGHuvEOJTIcRBQ7vW8HyH4fyzFSK8QmGCUigKRSkQQrRAn0zvbillG2C84ZQ/0A0YBHxkaEsD7pdStkdfV+NzkzICwcBMKWUL4Cb6LAYAPwLPSinbAtkmt34aSJBSdkC/w/4ZIUQD20uoUFiPyjasUJSOu4E/pZRxAFLK6wYdsUhKmQMcFkL4GvoK4H9CiB7oa57UAYznzkgp9xqOdwGBQggPwFVKucXQ/it6BQXQF2ht4qtxR6+UztheRIXCOpRCUSjKhnSTY6MVMgJ9Qs4QKWWmEOIs+jxr+ftnA05FjC+A56WUq20wV4XCJqglL4WidGwAhgohPAGEELUK6esOXDUok3CgfiF9kVLeBJKEEJ0MTcNNTq8G/iuEsDfct7EQwrmEMigUNkFZKApFKZBSHhJCfABsFEJkA3sK6T4fWCqEOADsBI5acYunge+EEDnARvTVNgHmoK9Bv9vgh7nG7ToWCkWFoLINKxSVGCGEi5Qy2XD8BuAvpRxfxGUKRYWgLBSFonIzUAjxJvr/1XPAkxU7HYXCMspCUSgUCoVNUE55hUKhUNgEpVAUCoVCYROUQlEoFAqFTVAKRaFQKBQ2QSkUhUKhUNiE/weMMhlK4utFOAAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -241,7 +241,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 64,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -263,7 +263,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 65,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -290,12 +290,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 66,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -313,7 +313,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 67,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -329,7 +329,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 68,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -342,7 +342,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 69,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -357,7 +357,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 70,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -377,7 +377,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 71,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -389,14 +389,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 72,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 397/397 [01:49<00:00,  3.63it/s]\n"
+      "100%|██████████| 179/179 [00:51<00:00,  3.45it/s]\n"
      ]
     }
    ],
@@ -421,7 +421,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 73,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -441,14 +441,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 74,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 397/397 [02:47<00:00,  2.36it/s]\n"
+      "100%|██████████| 179/179 [01:15<00:00,  2.39it/s]\n"
      ]
     }
    ],
@@ -475,7 +475,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 75,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -487,7 +487,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 76,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -496,7 +496,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 77,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -514,12 +514,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 78,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEGCAYAAACO8lkDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAA1S0lEQVR4nO3de3xU1bnw8d+TCwkhiBDQIgiJFuVASAJEIHIU5CKcwquVyxENClKLwPHSnorVcrTWSutbe8NSblrrLSgKlKIcxQaUWhBooOGmEYEABn1bQEBCBHJZ7x8zE2aSmcneeyaZyeT5fj75JLP3nj2LMc6TtZ61niXGGJRSSilvcZFugFJKqeijwUEppVQ9GhyUUkrVo8FBKaVUPRoclFJK1ZMQ6QaEQ8eOHU16enqkm6GUUs3Ktm3bjhljOvk7FxPBIT09naKiokg3QymlmhURORTonA4rKaWUqkeDg1JKqXo0OCillKonJnIOSimXyspKysrKOHv2bKSboqJIcnIyXbt2JTEx0fJzNDgoFUPKyspo27Yt6enpiEikm6OigDGG48ePU1ZWRkZGhuXnRe2wkoiMFpFPRGSfiDzcJC9aWgCr0mFpnOt7aUGTvKxS4XL27FnS0tI0MKhaIkJaWprt3mRU9hxEJB74PTASKAP+LiKrjTEfhfN1CnYVMGfdHA6fOsy9l3Tg1xefJsGcd52sOARbp7t+zsgP58sq1ag0MKi6nPxORGvPYQCwzxhzwBhzHngNuDmcL1Cwq4Dff/x7ptwyhV/f92ueuKTqQmDwqK6AHXPC+bJKKdUsRGtw6AJ85vW4zH0sbF468BK3DL2FDhd1QERod+6U/wsrDofzZZWKefHx8eTk5NR+PfXUU432Wu+//z5jx471OTZ16lSWL18elvt//vnnTJgwIeD5kydPsmDBAsvXNydROaxkhYhMB6YDdOvWzfbzB+UMolViq9rHp5Pbc9HZE/UvTLF/b6VastatW1NcXBzpZoSsqqqKyy67LGig8QSHWbNmATR4fXMSrT2HI8DlXo+7uo/VMsYsMcbkGmNyO3XyWxokqPZt2/s83njVGCrjfKd5VdTA3zp8y/a9lWouCnYVkP7bdOJ+Ekf6b9Mp2NU4kzDeeecdJk6cWPvY+y/+d999l7y8PPr168fEiRMpLy8HXGVxfvzjH9OvXz/69OlDSUmJ7dfdtm0bQ4YMoX///owaNYovvvgCgKFDh9aW3Dl27Bie2mwvvPACN910E8OGDWP48OEcPHiQzMxMAPbs2cOAAQPIyckhKyuLTz/9lIcffpj9+/eTk5PD7Nmzfa6vrq7mwQcfJDMzk6ysLH73u985e/MiJFqDw9+BHiKSISKtgEnA6nC+QHx1vM/jvV1yKcy8la+S22OAr5LbMzeuO9e/t4hZa2aF86WVigoFuwqY/uZ0Dp06hMFw6NQhpr85PeQA8fXXX/sMKy1btowRI0awZcsWzpw5A8CyZcuYNGkSx44d48knn6SwsJDt27eTm5vLr3/969p7dezYke3btzNz5kx++ctf+n29Dz74wOf1Vq92fVRUVlZy3333sXz5crZt28a0adOYM6fhHOL27dtZvnw5GzZs8Dm+aNEiHnjgAYqLiykqKqJr16489dRTXHnllRQXF/P000/7XL9kyRIOHjxIcXExO3fuJD+/eU1sicphJWNMlYjcC6wF4oHnjTF7wvkaIy8ayTtn3vHJ4u/tksveLrm1j9NqqukrBSwsWgjAgjEL6t1HqeZqzro5VFRW+ByrqKxgzro55Pdx/kEWaFhp9OjRvPnmm0yYMIE1a9bwi1/8gg0bNvDRRx8xePBgAM6fP09eXl7tc8aNGwdA//79Wblypd/Xu+6663jrrbdqH0+dOhWATz75hN27dzNy5EjA9Zd8586dG2z/yJEj6dChQ73jeXl5zJ07l7KyMsaNG0ePHj2C3qewsJAZM2aQkOD6mPV3z2gWlcEBwBjzv8D/Ntb9eyb15PPKz9l5fmfAaV7xcfHcMeoO0juns3CDBggVWw6f8j/ZItDxUE2aNIn58+fToUMHcnNzadu2LcYYRo4cyauvvur3OUlJSYAryV1VVWXr9Ywx9O7dmw8//LDeuYSEBGpqagDqzf9v06aN3/vdfvvtDBw4kDVr1vCtb32LxYsXc8UVV9hqU3MSrcNKTWJY6jCyWmVhjAl4jYhwXdZ1jBsyjoVFC3WIScWMbu38T7YIdDxUQ4YMYfv27Tz77LNMmjQJgEGDBrFx40b27dsHwJkzZ9i7d29YXu/qq6/m6NGjtcGhsrKSPXtcAxDp6els27YNwHIC+cCBA1xxxRXcf//93HzzzezcuZO2bdty+vRpv9ePHDmSxYsX1wa1L7/8MtR/UpNq0cEBLgQIAscHDRAqJs0dPpeUxBSfYymJKcwdPjek+9bNOTz8sKvAQXx8PGPHjuXtt9+uTUZ36tSJF154gdtuu42srCzy8vIcJZ79adWqFcuXL+eHP/wh2dnZ5OTksGnTJgAefPBBFi5cSN++fTl27Jil+73++utkZmaSk5PD7t27ufPOO0lLS2Pw4MFkZmYye/Zsn+vvvvtuunXrRlZWFtnZ2SxdujQs/66mIsH+am4ucnNzTaib/ZScK+HdincxQaKEMYYPdn7Ayg0rSWudxrz/mBfS2KxS4fbxxx/zb//2b5av964S0K1dN+YOn6u/0zHK3++GiGwzxuT6uz5qcw5NrWdSTwDWVqwNeI2nBwGwcsNK7lh5BxsPb9Q8hGq28vvkazBQfrX4YSVvPZN60iexT9BrPAHiye8+Sd+r+rKwaCFtf9620eaHK6VUJGhwqGNY6jBLASK1dSp3jLqDcUPGUX6+nMkrJ2suQikVMzQ4+GElQIBvohrQZLVSKmZocAgglADR8RcddZhJKdWsaXAIwmmAOP71ce5YeYf2IpRSzZYGhwYMSx3GqJRRJJEU9Lq6AcJgdJhJtUiekt2ZmZlMnDiRioqKhp/kZfbs2fTu3bveugErfvaznwU8l56e7rOmwV+571DcfffdfPRR4P3IXnjhBT7//HPL10eaBgcLeib1ZEb7GbZmMvW7qh+geQjV8nhqK+3evZtWrVqxaNEiS8/zrCResmQJO3furFfIzopgwaExVVdX89xzz9GrV6+A19QNDg1dH2kaHGxwMpMJ0OmuKmqVnCvh+VPPM+/EPJ4/9Twl58KzOtnjuuuuY9++fZw5c4Zp06YxYMAA+vbty5///Gegfonsm266ifLycvr378+yZcs4evQo48eP55prruGaa65h48aNAJSXl3PXXXfRp08fsrKyWLFiBQ8//HDt6my7FVCDte/ee++tvW7s2LG8//77AKSmpvKDH/yA7OxsPvzww9oy4NXV1UydOpXMzEz69OnDb37zG5YvX05RURH5+fnk5OTw9ddf+5QNf+edd+jXrx/Z2dkMHz481Lc9LHQRnE3DUodBOeyq3BX0uroL5jzTXXXRnIoWJedKWFexjipcf7GfrjnNuop1wIVFoaGoqqri7bffZvTo0cydO5dhw4bx/PPPc/LkSQYMGMCIESMAV4nsnTt31lYtTU1Nra3qevvtt/P973+ff//3f+fw4cOMGjWKjz/+mJ/+9Ke0a9eOXbtc/x+eOHGC8ePHM3/+/KAbDd1www3Ex7vK9ZeXl9Ozp+vfGax9gZw5c4aBAwfyq1/9yud4cXExR44cYffu3YBrQ6CLL76Y+fPn88tf/pLcXN8FyUePHuW73/0uf/3rX8nIyIiaGkwaHBxwGiAALf+tosams5tqA4NHFVVsOrsppODg+esdXD2H73znO1x77bWsXr26dk+Gs2fPcviwq/proBLZ4Cp77T0u/9VXX1FeXk5hYSGvvfZa7fH27dv7e3o97733Hh07dgRcOQdPe959992A7QskPj6e8ePH1zt+xRVXcODAAe677z7GjBnDjTfeGPQ+mzdv5vrrrycjIwOIntLeGhwc0gChmrvTNf6riQY6bpW//RyMMaxYsYKrr77a5/iWLVsClsgGqKmpYfPmzSQnJ4fUpoYEat+2bdtqS3uDb3nv5OTk2l6It/bt27Njxw7Wrl3LokWLeP3113n++ecbr/GNRHMOIXA6kwl0PYSKvLZxbW0dD8WoUaP43e9+V1se/x//+Iel5914440+22t6gs7IkSP5/e9/X3v8xAnX/u+JiYlUVlaGrX3p6ekUFxdTU1PDZ599xtatWxu817Fjx6ipqWH8+PE8+eSTbN++HSBgee9Bgwbx17/+ldLSUiB6SntrcAiR3ZlM3gHi+NfHmbxyctMmq0sLYFU6LI1zfS/V4NRSXZt8LQl1Bg8SSODa5GvD/lqPPvoolZWVZGVl0bt3bx599FFLz3vmmWcoKioiKyuLXr161c58+p//+R9OnDhBZmYm2dnZvPfeewBMnz6drKws2wnpQO0bPHgwGRkZ9OrVi/vvv59+/fo1eK8jR44wdOhQcnJymDx5Mj//+c8B1w51M2bMqE1Ie3Tq1IklS5Ywbtw4srOzufXWW221vbFoye4wWl++vsFhJu+y33XNzJ3ZuENNpQWwdTpUe807j0+BAUsgQytzxgK7JbtLzpWw6ewmTtecpm1cW65NvjYsyWgVfbRkdwRZyUP4y0F4NHouYscc38AArsc75lw4X3EYUrpB9lwNGC1Az6SeGgyUXzqsFGZW10Jcl3Vd7UI5b426aK4iwOyLikOuHkXFIcBceKxDTkq1WBocGoHVAJF/Y37TBoiUAHsDS3zwHoVSqsXR4NBIrASI+Lh4n5XU3hplVXX2XFeOwYeAqfZ/faCehlIq5mlwaER2hpj8BYiwbyKUkQ8ZUwDxOmjqPPbSKjoW4yilmp4Gh0ZmJ0A8NeOpxh9m+vx/cQUEbwFmrFV+pXkHpVooDQ5NwLNYTgL9hY4rQCS3Sg46zCQ/kdAXztkZKjKVmndQthw/fpycnBxycnL4xje+QZcuXWofnz9/Puhzi4qKuP/++8PSjroF87yPd+rUiZycHHr16sWzzz4bltez4rHHHqOwsDDoNatWrYqaMt46lbWJeKYLrq1YG/S6YFNd4cLCOccF/FK6uWclWaR5B2VDWlpa7Srmxx9/nNTUVB588MHa81VVVSQk+P/Yyc3NrVeUrjHceuutzJ8/n3/961/07t2bm266iUsvvdRSG52qrq7miSeeaPC6VatWMXbsWFulvBujvaA9hybVM6mno53l/LE11OS9KrqqHCTR93x8CiSm+X9uoBlOKjY0wYp5z8rggQMH8tBDD7F161by8vLo27cv1157LZ988gngu/nO448/zrRp0xg6dChXXHEFzzzzTO39XnnlFQYMGEBOTg733HMP1dWuCRV//OMfueqqqxgwYEBtae9gLrnkEq688koOHTpUr4379+9n9OjR9O/fn+uuu46SElcp8zfeeKN2Vfb1118PuD74H3zwQTIzM8nKyqot95Gens4Pf/hD+vXrxxtvvMHUqVNZvnx57bmHHnqIPn36MGDAAPbt28emTZtYvXo1s2fPJicnh/3791NcXMygQYPIysrilltuqS0TMnToUL73ve+Rm5vLvHnz/LYrVNpzaGKhFOyra2HRQl7e+TKLxi4iv4+fBWulBVD0AFQev3Ds/HGIawUJaVD5JSR2cOWjzx/H9YNX/iE+xTXDScWmuivmPetbIOwLIMvKyti0aRPx8fF89dVXfPDBByQkJFBYWMiPfvQjVqxYUe85JSUlvPfee5w+fZqrr76amTNnsm/fPpYtW8bGjRtJTExk1qxZFBQUMHLkSH784x+zbds22rVrxw033EDfvn2DtunAgQMcOHCAb37zm/XaOHz4cBYtWkSPHj3YsmULs2bNYv369TzxxBOsXbuWLl26cPLkScC1OdHBgwcpLi4mISHBpzZSWlpabW2ld955x+f1PSXHX3rpJb73ve/x1ltvcdNNNzF27FgmTJgAUBtshgwZwmOPPcZPfvITfvvb3wJw/vz52v0g+vTpU69dodLgEAHhDBAB94nwVyrDo+Y8JKdC7rw613hmLhlI6a6rpGNdsBXzYf7vPnHixNoKpqdOnWLKlCl8+umniEjAQnljxowhKSmJpKQkLrnkEv75z3+ybt06tm3bxjXXXAO4yoNfcsklbNmyhaFDh9KpUyfANXS0d+9ev/ddtmwZf/vb30hKSmLx4sW1JbI9bSwvL2fTpk1MnDix9jnnzp0DXLWWpk6dyn/+538ybpyrZ19YWMiMGTNqh3a8S24Hq5N022231X7//ve/X+/8qVOnOHnyJEOGDAFgypQpPm3yvre/doVKg0OEDEsdxmXnLqOwopBqAqwzwFqAAD+lN/z9j++t4nCAa9yB4dsHrfwzVHMWcMV8+PNM3mW5H330UW644Qb+9Kc/cfDgQYYOHer3OUlJF6odx8fHU1VVhTGGKVOm1Baz81i1apXltnhyDoHaWFNTw8UXX+x306BFixaxZcsW1qxZQ//+/dm2bVvQ1wpWjlxE/P5slfe9/bUrLS3AULFFmnOIoJ5JPbm3/b2O9qb2x2fhXEP/g6d0a9IPBxWFAuWTGjnPdOrUKbp06QK4Zg/ZMXz4cJYvX86//vUvwFXe+tChQwwcOJANGzZw/PhxKisreeONNxy376KLLiIjI6P2HsYYduzYAcD+/fsZOHAgTzzxBJ06deKzzz5j5MiRLF68uHYPbKslt5ctW1b7PS8vD/At692uXTvat2/PBx98AMDLL79c24uoy1+7QhV1wUFEHheRIyJS7P76VqTb1Nic7k3tj2eY6bgE/oulNpcQoQ8HFSX8rZhvgjzTQw89xCOPPELfvn1rP1Ct6tWrF08++SQ33ngjWVlZjBw5ki+++ILOnTvz+OOPk5eXx+DBg21VpvWnoKCAP/zhD2RnZ9O7d+/aPaVnz55Nnz59yMzM5NprryU7O5u7776bbt26kZWVRXZ2NkuXLrX0GidOnCArK4t58+bxm9/8BoBJkybx9NNP07dvX/bv38+LL77I7NmzycrKori4mMcee8zvvfy1K1RRV7JbRB4Hyo0xv7T6nGgp2R0qKyW/IXjZb4/bUuG5SyGlbvhvlQb957nGlLWEd8yxW7Kb0gKtxhsB6enpFBUV1W5Z2hS0ZHczFs5E9avlru8/6wjdE0H8JZg9P+uHQ8uVka//vZVf0Roc7hWRO4Ei4AfGmBN1LxCR6cB0gG7dYmcYJNwBwhMkUlsdZ9GVUO9jQD8clGpyBw8ejHQTGhSRnIOIFIrIbj9fNwMLgSuBHOAL4Ff+7mGMWWKMyTXG5Hqmr8WKUPamDiTsRfxU1Iq2oWIVeU5+J6Iu5+BNRNKBt4wxmcGui5Wcgz9Wtx49V3mO19e/zva92y3dN611GvP+Y57/xXOq2SotLaVt27akpaU5mh6pYo8xhuPHj3P69GkyMjJ8zjWrnIOIdDbGfOF+eAuwO5LtiTSrW496ivald04Pmqj2CLlGk4pKXbt2paysjKNHj0a6KSqKJCcn07VrV1vPibqeg4i8jGtIyQAHgXu8goVfsdxz8AjnTKa6UlulBi7BoZSKWc2q52CMuSPSbYhG4UxU1xWwBIdSqsWKukVwKjAri+XAFSCuz7qeW28IXNfFn0bZmlQp1SxpcGhmrAYIBPL65LHwroWktbZeY0VnNSmlIApzDk60hJxDXSXnShos2ueRSCJJx5N44PUHOFN5xvJraC5CqdgWLOegPYdmymrRPoBKKilPK2f1/auZmTvT8mtoL0KplkuDQzNneZgJVzJ7wpAJvDLuFdokBinMV4dPLqIJdg5TSkWeBocYYDdAlF9eTtEPimz3Ita8O5mKjZPde1CbCzuH1Q0QGkCUavY0OMQIOwHirDnL2oq1tnsRP+vop8qrZ+cwD0+l14YCiFIqqmlwiCF2AgS4ehGnup6y3IvoFmhVjPfmQMG2nlRKNRsaHGKMp2hfPPGWrq+k0nIv4nCAfVl8NhbS3eWUigkaHGKQnZlMHrsqd9E5ozPlPyoP2Iv40TE4U+N77EwN3Pd5+YWEte4up1RM0OAQw6yW/vbYVbmL9eXrWTBmgd9exKvl8N1/wsFKqDGu79/9p+u4Z9rrtEP/jypp5XvjJth6UikVXroIroWwWrgPXIvmhqUMo2dSTwp2FXDPm/fYWjx3Wyr87rJU0swZ3V1OqSimi+CUrWS1Jw+xvnw9+X3ygw41+fNqOXTcW07bQ20ouFIDg1LNkQaHFsRustozzAQEHGoKRldYK9V8aXBoYewmq3dV7mLBiQWUnCsJ2ou4LRVK06H6m67vt6VeOKfVXpVqfjQ4tFBOh5mgfi/itlR49lJIT4Q4cX1/9lLfAOHpRWiQUKp50ODQgjlZNOcJEJ5exCvjXuGpTkKbOr9JbeJcK6rr0qEmpZoHDQ4tXCh5CHAFiUArpwOuqEaHmpSKdhocVEh5CCDgArdAK6o9tBehVPTS4KBqOc5DZM91LXTzcqbGtaLaCu1FKBV9NDgoH46GmTp1hgFLIKU7IJDSnX90m8nqc/anvWqQUCo66AppFZDTVdXenKywBpiZO5MFYxbYeo5Syh5dIa0cCWW6q4eTFdbgGmrSXIRSkaPBQQUVynRXb05WWGsuQqnI0eCgGuQkD+Ezm8nNSS9CZzQpFRkaHJQldqe7BhpmAu1FKNUcaEJa2WYnUQ2Bk9XgSljfsfIODNZ/D1NbpbJo7CLy+2i1V6VCoQlpFVZOtyL114vI75PPy+NeJl6s3Qt0qEmppqDBQTnidCvSQAHixVtetDXMBDrUpFRj0mElFbJwDzM5WRehQ01K2afDSqpRhXuYycm6CB1qUiq8IhIcRGSiiOwRkRoRya1z7hER2Scin4jIqEi0T9nndJjJ35RXcDajCXSoSalwiVTPYTcwDvir90ER6QVMAnoDo4EFIjYylSriGqMX4XR7Ug0SSjkXkeBgjPnYGPOJn1M3A68ZY84ZY0qBfcCApm2dClU4k9UQ2lDTlD9N0QChlAPRlnPoAnzm9bjMfaweEZkuIkUiUnT06NEmaZyyx0npjQUnFnDk06dhVTosjXN9L3V9uDsZaqo21dyx8g4NEErZ1GizlUSkEPiGn1NzjDF/dl/zPvCgMabI/Xg+sNkY84r78R+At40xy4O9ls5Wim4l50oorCikmmqf41cdKWLw3jW0PXuC08nt2XjVGDqfKCX7s42I94XxKa6S4BkXZiI5mdWkM5qU8hVstlJEp7L6CQ6PABhjfu5+vBZ43BjzYbD7aHBoHrynvF51pIgRu5eRWFNZe75K4ok31b6BwSOlO3z7YL3Ds9bMYmHRQlvt0CChlEtzmsq6GpgkIkkikgH0ALZGuE0qTLyT1YP3rvEJDAAJgQIDQMVhv4edDDXptFelGhapqay3iEgZkAescfcQMMbsAV4HPgLeAf7LGFMd+E6qufEkq9uePWnreZWtOwc8F8qeETqjSSn/IjVb6U/GmK7GmCRjzKXGmFFe5+YaY640xlxtjHk7Eu1TjU9Sulm+1gCFPYYFnM3ksWDMAseL5zRIKOUr2oaVVEuRPdeVaPZSJfFU1fmVNMCOywezt0tu0EVzHk4Xz+lQk1K+NDioyMjId81ASumOQfgquT1/6XMbf8m6na+S22OAr5Lb807WZDZkTqx9WrBFcx5OF8+Bbk+qlIcW3lNRIdB012B8CviVFsCOOa7EdUo3V8/EPfVVp70q5V/UTmUNFw0OscNuhVeAEf/8J713zIPqigsH/ayN0GmvSvlyPJVVRJ4WkXv8HL9HRJ4KVwOV8rBbmwng8o8W+QYGcD3eMcfnkE57Vcq6hnIOw4Alfo4/C4wNf3OUsl+bqe3ZE/5P+Fkb4Z2PkMCrKurRaa+qpWkoOCQZP+NOxpgasPF/llIOWO1FnE5u7/9EkOmyoWxPOuKlEZafo1Rz1VBw+FpEetQ96D72deM0SakLrPQiNl41hsq4RJ9jBjAVh3wK99XldHvSdaXraP1ka+1FqJjWUHB4DHhbRKaKSB/3113AGvc5pZpEsF7E3i65FGbeWjsF1uDq1gpAxSHYOj1ogHAy7fVs9VnNRaiY1uBsJRHJBGYDme5De4CnjTH2ppQ0Ip2t1LIEm9F013s/4SJ/OYgAhfvq0mmvqiUJqfCeMWa3MWaKMaa/++vOaAoMquUJ1osIlJw2FYeCrqz2cFKnSUtwqFjU0FTWN0VktdfXn0XkDyIyuakaqJQ/gXIRgZLTp5PbN7iy2ptn2muruFaW26QJaxVLgg4ricgQP4c7AJOBT40xDzdWw+zQYaWWzXt1tb99IirjEinMvJW9XVy9Z5+V1RaMeGkE60rX2WpTcnwyz938nA41qagW9hXSIhIPbDPG5ITYtrDQ4KAAVpxaQVlNmd8d5jyBwZudIOEkFwEwM3cmC8YssPUcpZpKo5TPEJFiDQ4q2ngChB19EvswLHWYpWu1BIeKJY6Dg4h08HO4PXAn8E1jTFT8tmtwUN6c1Gdqil6EBgkVbUIJDqVcmDaO++djwPvAT40xp8PbVGc0OCjApzJrZevOrO8xgpIu/WzdomtcV8a3G2/p2oJdBUxbNY3zNedtvYYONalo0VjDSsuMMbeG1LIw0eDQgtUGhEO4/obx+n2OT2FP9gMUXnqprVvaCRDgLGGtvQgVDUJa5xBEXgjPVSp0pQWu1c8Vh9wH6vyhU11B75Kltqu8ltWUNbjjnLfCOwsdV3vVtREqWoXSczhsjLG+EXAj0p5DC7Uq3SswBCJwew2UFlBZ/BAJX38edAZTXXaS1eAsYQ061KQiI1jPIaGBJwYasBUgMcA5pZqGn5Lc9aR0q+1hJLr3fLjo7AlG7F4G0GCA2FW5i5ITJZaT1QvGLGBwt8G2E9aegKIBQkWLhhLS7wV7sjHmhrC3yAHtObRQDfUcPLvB1eYkfH2V3J4/3vBjyy9nd/GcTntV0c5xzsEYc0Owr8ZprlIWZc8l4LYiEn9hm9AAPYyLzp6ka1xXyy9XSaWjEhyai1DNUUO1lR7y+nlinXM/a6xGKWVJRj58cwb1AkR8Cgx68cL+0YE2/Unpxvh24y3vOOexq3KX5QDhtCS41mlSkdbQbKVJXj8/Uufc6DC3RSn7BiyAvJddJbkR13dPj8Eje64rYNRVVQ6lBY72rd5VucvWjCan25PqxkIqUhrKOfzDGNO37s/+HkeS5hxUg0oLoOgBqDxe54R7bURKd8iey/pOnRt1dTW4Fs9N+dMUqk21rdfRfIQKt1DWOZgAP/t7rFT0ysiHxFQ/J9y/xhWHYMs0hh39wnYvwm4uwun2pJ6hJt19TjWFhnoO1cAZXH9etQYqPKeAZGNMVExn1Z6DsmRpHA3+TdMqDSYcA1ylwNdWrLX1Ek56EVrtVUVKKLOV4o0xFxlj2hpjEtw/ex5HRWBQyrJAiWlv5y8MO/VM6smolFG2XsJJL8KTi7CzsdDCooU6o0k1qlDKZyjVvARKTAfhCRB2hpnAWcL63KPnGJ4x3PJr6LRX1ZgiEhxEZKKI7BGRGhHJ9TqeLiJfi0ix+2tRJNqnYlRGvmsmU0r3wNckptU75NmStLFzERBanSbNRahwclxbKaQXFfk3oAZYDDxojClyH08H3jLGZNq5n+YclG2lBbD5LjAXthNFEmHQH32nwfrhvS2pVXZzEeDKR9yx8g6MjbkfOqNJ2dFYVVkdM8Z8bIz5JBKvrRTgCgCD/ui7PsJCYIALPQk7i+c8vYgVp1ZYfk5+n3xeHvcy8WK9t6KL51S4RGPOIUNE/iEiG0TkukAXich0ESkSkaKjR482ZftUrMjId+UhUrq5SmzsmOPqUVg0LHWY7dXVZTVlzD8x31Yuwsm0V108p0LVaMNKIlIIfMPPqTnGmD+7r3kf32GlJCDVGHNcRPoDq4Dexpivgr2WDispRzz7QVRXXDjmKdZnoQfh4WSYCZpu2qsONalAGmUnuHCoGxzsnvfQ4KAcCVTVNaU7fPug7ds5DRJNtWfE8IzhFN5ZaPt5KnZFXc4hEBHpJOIaYBWRK4AewIHItkrFrED7QVjZJ8IPJ7kIcE17tZOLcFLtFXSoSdkTqamst4hIGa6tRteIiGcZ6vXAThEpBpYDM4wxX0aijaoFCFKtNRSeQn52Cuw5yUU4WTx3tvqsro1QlkR0WClcdFhJORKmnEMwK06toKymzNZznEx7HfHSCNaVrrPbPC3D0cI1m2ElpZqUz6K4AOW+QzS+3XjHi+fsrLB2sngOtAyHCkx7Dko1kaZKWBfsKmDaqmmcrzlv63U0Yd3yRO1spXDR4KCak2geakqOT+a5m5/Taa8thA4rKRVFxrcbb2vvami6oSZNWCsPDQ5KRYCTXAQ4Lwk+M3emrdfRYn5Kg4NSdpQWuBbPLY1zffcutxHsnB9Oq72C/ZLgTtdGaMK65dKcg1JWBZv6CiFPi11fvt72/tXgrAyHk4S1TnuNPZqQViocgpXbgLCU4nA6ownsz2pykrDWOk2xRRPSSoVDwHIbh/wHhmDPCaAph5p0YyEVjAYHpaxyUlbDYSkOp3Wa7O4b4TRhrbmI2KfBQSmr7O5BHdfK9ZwQeOo02e1F2K3V5CRhrRsLxTYNDkpZ5Sm3YVVNZcPXWOB0qKmaaltrI5z2IrTaa2zShLRSdgVKTPsT5kJ+4HxWU9e4roxvN97StU43FtIV1s2LJqSVCic7w0vVFa7tR8OoKYaanPYidIV17NCeg1JOlBa4PvQrDkOrDlD5FZhAw0gCt9c0SjNKzpXwbsW7GOz9f2xnbYTTXgTo2ohop+sclGpspQWweQoYP+sTHG47aoeTYn5gb22EVnuNPTqspFRjy8iHQS/WH26KTwl5xpIVTms12Vkbkd8nn3OPnmN4xnBbr6EJ6+ZJg4NS4dIEmwcF4z2ryc4WpXbXRngWzznZnlSnvTYfOqykVIxyOtSULMkMaT3EUj5i1ppZLCxaaO/+OqMpamjOQakWKpRaTXamvmqQaJ4056BUc2WzDHhdTstwgL2pr54V1jrUFDs0OCgVrTwlwisOAcb1/cM7YKv9ondO10Z4VllbyUdowjq26LCSUtGktACKHoDK40EuEsh72XGi2+naCLCej9Bpr82DDisp1RyUFsDmuxoIDAAmpFXXPZN6cn/7+23vYw1w1py1tE1pKL0I+YloSfAooMFBqWixY06QVdZ1WK3tFIRnbUQSSbafa3V9hJNpr+AqCa5DTZGlw0pKRYulcWB5qCf8JTmcTn2NJ54RKSMaHGpyMqMJdKipMemwklLNga2NgcL/R52nJ2FnAR1YLw2+YMwCzI+NDjU1ExoclIoW2XNBEq1f73B6azCh5CM8K60bykfoUFPzoMFBqWiRkQ+D/giJaRaf4J7eunW6b4AIcW0EOK/VBK58xLwT84IGCacJa8/aCO1FND7NOSgVzUoLYMs0aGhKqKfyq2dtRHXFhXMhbjgUyiprK/kIp9NedYV16LR8hlLNmffeEQFzDe4EdaBd6lK6u4atPPdJ6eZ6XDdgeL9WnWtCWR9hZf8IXRvR9KIuOIjI08D/Ac4D+4G7jDEn3eceAb4DVAP3G2PWNnQ/DQ6qxQj24f/tgw3MeJI65wS+OQMGuDfjsdjrcLpNKVir1zTipRGsK11n677ai3AmGmcr/QXINMZkAXuBRwBEpBcwCegNjAYWiIj9QU+lYpW/LUq994wIOuOpbtAwsG/RhZxE0QO+gQH8bnM6LHUYD7R/wHG9pnkn5rH45OKAM5tCKQmu25OGT0SCgzHmXWNMlfvhZsAzNeJm4DVjzDljTCmwDxgQiTYqFZUa2jPC7/7Wwaamuldbb50VeGV2xWG/h53Wa4ILK60DTX/1JKzt7mFdfr5cE9ZhEvGcg4i8CSwzxrwiIvOBzcaYV9zn/gC8bYxZ7ud504HpAN26det/6FDoK0aVigl18waWVlPXHXLyPhUPpiZwnoLQ8hEQfLtSTVg3nojkHESkEPiGn1NzjDF/dl8zB8gFxhljjJ3g4E1zDkoFEShP4SHx/ve+9ieuFcS3hcov/QaLUPIREDxI6Arr8Iu6hDSAiEwF7gGGG2Mq3MceATDG/Nz9eC3wuDHmw2D30uCgVBD+Es0e8Sn+j1vlJ2Fdcq6E9yve5xznHN82WJBwkrAGmJk7kwVjFjhuUyyKuuAgIqOBXwNDjDFHvY73BpbiyjNcBqwDehgT/M8aDQ5KNaB2qOnQhZ6Cz/TWEIZlPTOl/HBarwmCr5Fw2ovo1bEXe/5rj6P2xKJoDA77gCTAkwHbbIyZ4T43B5gGVAHfM8a83dD9NDgoFYJgPQurbg/8ORLKIjoIHCQKdhVwz5v3cKbyjO17ai/CJeqCQ7hpcFAqRKUFsHmK9dxDQxLTIHdeveGmxgoSmrB2RoODUqph/noQkmh9j4m6JNFVKyoj32cGVWXrzqzvMYKSLv0c3TZQkHA61JTaKpVFYxe1yCChwUEpZY2/8hmh5iTi20B1naGf+BSO9HucFR2THE9/DRQknCasW+KsJg0OSinnwpGTCCSlO0d6/1fYg0TBrgKmrJxiewirpQ01aXBQSoXGe7ZTuLmnw5Zc1j+khXT+goT2IoLT4KCUCp+ts1w1mcK9G507ib2+U+eQFtLVDRJOE9YQ+7OaNDgopcLLpycRpPSGbXGQ9xJk5Ie82rpukNC1EfVpcFBKNZ2w5CgEEtpA1Rm+bt2J93vcCMDQj/9Esntdw9cJKWzoNY69Xfx+tvlIlmSGtB7Ctr3bdG2EFw0OSqmm5T3rKaENVJWHfEtD/fqyVcTxl6zbLQUIuLCfhNOhpoS4BF749gsxk7DW4KCUiqyts2Cf/SEdK2qAtVmTARi8dw1tz57gdHJ7Nl41JmDQ8OxM90zhMy16bYQGB6VU5DVWItt9R4PvBjVWehXxxNP6eGtmvTrLUcK6uc9qisad4JRSLc2ABZD3snujovAS6n+YJVDDkI9WBn1eNdWUp5Xzi3t/wcK7FtreuGhd6ToSf5oYk7vPac9BKRU5jbl+ggt9lIaGmbwdOHCAZ956xvZrNcdehA4rKaWi39ZZsH+Ju/ifhC2R7VEZl8ieLgO44uhHtD17grOJbTDG0Lqqon7wMFB+tpyVG1ayfe92y6/R3BLWGhyUUs3X1lmwbzGu1HNo/M148qiMS6Qw81af3oUxhsrqSl4rfM1WkGguCWsNDkqp2FBaANsegPPHG77WgRriWOsnie35nPxg5wes3BA8j+Et2ms1aXBQSsWeRspXeHoQnU+UkvXZhwg1GOLYeXke7/eeAMCZs2dsDTlFaz5Cg4NSKnYFXJEdh+9QlPUyH56rxM+xHZcPZkPmRNtDTtGYj9DgoJSKbf72oQDfY5d9C0pfDLn0eN0ZUJ9c1h+D4W87/2ZpyCmaehEaHJRSCsK+Haqp/S7uYaeJlvIS0dKL0OCglFIejbR5kW+P4luUXNa/wd5EpBPWGhyUUsqb9zBUYgdXcuH8lyBxYelVeD5VD3XowaoBsxrsTURqqEmDg1JKWeGnVxFsbURD6n66ll58JRNPtQuYwG7qsuBaW0kppazIyIcBS9z1nwRSuiOXDAeJry3uZ4fU+co4uZ8is53SgT0YN2RcvesXFi1EfiLMWjMr1H9JyLTnoJRSVpUWULXtXuLPn3TcmwDfILP9skFM/+J8vd5EvMTz4i0vNmo+QnsOSikVDhn5JEw4geS9AvFtansTofQo+n2+2W9votpUM3nlZFo/2ToiVV+156CUUiH68sPbaF/6Wth6E9XA7y7O5b//fuFzrTGS1tpzUEqpRtQh71VXb0ISHG9l5N2bSAC+d7KImh5Q0wPWZGWwrnQdCU8kNFkvQoODUkqFQ0Y+3FbpChKt0nyGnJwEDO9g8R9fl1LTA/55VSsmr5zcJBsM6bCSUko1opJzJbR+72a6fbkXcD4tFnyDzKG4VAYfuYgjPzji+H46rKSUUhHSM6kn3Ud/gtxu+DKtX0g7aHv3JrrXlFPW+XPMUuHwq+3C01gvEQkOIvK0iJSIyE4R+ZOIXOw+ni4iX4tIsftrUSTap5RSjSFt1DYk7xVqJDGkISfwDRSXm6+oWRpKn6S+SPUc/gJkGmOygL3AI17n9htjctxfMyLTPKWUaiQZ+cTddh653SC3G8rbdA8pSMCFIBHOABGR4GCMedcYU+V+uBnoGol2KKVUpLW9+SByu+Hza35BtcSFnMAOl2jIOUwD3vZ6nCEi/xCRDSJyXaAnich0ESkSkaKjR482fiuVUqoRdekxm/jbqmsDRQ2hDTuFqtFmK4lIIfANP6fmGGP+7L5mDpALjDPGGBFJAlKNMcdFpD+wCuhtjPkq2GvpbCWlVKw6s7wDKedPAA33DAwgt1v/TA82WynB8l1sMsaMCHZeRKYCY4Hhxh2hjDHngHPun7eJyH7gKkA/+ZVSLVKbCV8CUP5uHm2Oba49XjdQeHoZ4RpaarTgEIyIjAYeAoYYYyq8jncCvjTGVIvIFUAP4EAk2qiUUtEk9cYPa3/2l3g2QJyNXkNDIhIcgPlAEvAXEQHY7J6ZdD3whIhU4toZfIYx5ssItVEppaKSvyAQ3omsEQoOxphvBji+AljRxM1RSilVRzTMVlJKKRVlNDgopZSqR4ODUkqpejQ4KKWUqicmSnaLyFHgkIOndgSOhbk5sUjfp4bpe9QwfY+sacr3qbsxppO/EzERHJwSkaJAqwPVBfo+NUzfo4bpe2RNtLxPOqyklFKqHg0OSiml6mnpwWFJpBvQTOj71DB9jxqm75E1UfE+teicg1JKKf9aes9BKaWUHxoclFJK1dMigoOIjBaRT0Rkn4g87Od8kogsc5/fIiLpEWhmRFl4j64Xke0iUiUiEyLRxmhg4X36bxH5SER2isg6EekeiXZGkoX3aIaI7BKRYhH5m4j0ikQ7I6mh98jruvEiYkSk6ae2GmNi+guIB/YDVwCtgB1ArzrXzAIWuX+eBCyLdLuj8D1KB7KAl4AJkW5zFL9PNwAp7p9n6u+S3/foIq+fbwLeiXS7o+09cl/XFvgrsBnIbep2toSewwBgnzHmgDHmPPAacHOda24GXnT/vBwYLu6NJlqIBt8jY8xBY8xOXPtstFRW3qf3zIUNrDYDXZu4jZFm5T3y3va3DZHbJjlSrHwmAfwU+L/A2aZsnEdLCA5dgM+8Hpe5j/m9xhhTBZwC0pqkddHBynuk7L9P3wHebtQWRR9L75GI/Jd7G+BfAPc3UduiRYPvkYj0Ay43xqxpyoZ5awnBQakmJyKTgVzg6Ui3JRoZY35vjLkS+CHwP5FuTzQRkTjg18APItmOlhAcjgCXez3u6j7m9xoRSQDaAcebpHXRwcp7pCy+TyIyApgD3GSMOddEbYsWdn+XXgO+3ZgNikINvUdtgUzgfRE5CAwCVjd1UrolBIe/Az1EJENEWuFKOK+uc81qYIr75wnAeuPOCLUQVt4jZeF9EpG+wGJcgeFfEWhjpFl5j3p4PRwDfNqE7YsGQd8jY8wpY0xHY0y6MSYdV+7qJmNMUVM2MuaDgzuHcC+wFvgYeN0Ys0dEnhCRm9yX/QFIE5F9wH8DAaeWxSIr75GIXCMiZcBEYLGI7IlciyPD4u/S00Aq8IZ7qmaLCrIW36N7RWSPiBTj+v9tiv+7xSaL71HEafkMpZRS9cR8z0EppZR9GhyUUkrVo8FBKaVUPRoclFJK1aPBQSmlVD0aHJSyQUReaMlVaVXLocFBKaVUPRoclApCRO50782wQ0Redh++XkQ2icgBTy9CRFLd+zdsd+9VcLP7eLqIfCwiz7oXfr0rIq3d565x37tYRJ4Wkd3u4/Hux393n78nIv941aJpcFAqABHpjaso3DBjTDbwgPtUZ+DfgbHAU+5jZ4FbjDH9cO3p8Cuvsu89gN8bY3oDJ4Hx7uN/BO4xxuQA1V4v/R3glDHmGuAa4LsikhH+f6FSgSVEugFKRbFhwBvGmGMAxpgv3Z/3q4wxNcBHInKp+1oBfiYi1+Pa86IL4DlXaowpdv+8DUgXkYuBtsaYD93Hl+IKNgA3AlleuY12uAJMafj/iUr5p8FBKfu8K616egf5QCegvzGm0l1NM9nP9dVA6wbuL8B9xpi1YWirUo7osJJSga0HJopIGoCIdAhybTvgX+7AcAMQdO9oY8xJ4LSIDHQfmuR1ei0wU0QS3a97lYi0cfhvUMoR7TkoFYC7UuZcYIOIVAP/CHJ5AfCmiOwCioASCy/xHeBZEakBNuDagRDgOVx7dm935y2O0vL2PFARplVZlYoQEUk1xpS7f34Y6GyMeaCBpynVJLTnoFTkjBGRR3D9f3gImBrZ5ih1gfYclFJK1aMJaaWUUvVocFBKKVWPBgellFL1aHBQSilVjwYHpZRS9fx/kWmrhxNjdMIAAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -541,7 +541,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 79,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -607,16 +607,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 80,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Even hypervolume: 19.896059487032417\n",
-      "Perfect hypervolume: 20.46381337096913\n",
-      "Trained hypervolume: 20.377067863712263\n"
+      "Even hypervolume: 19.87827885124927\n",
+      "Perfect hypervolume: 20.445184246654176\n",
+      "Trained hypervolume: 20.612026679495887\n"
      ]
     }
    ],
@@ -638,7 +638,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 81,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -663,12 +663,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 82,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -696,7 +696,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 83,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -710,7 +710,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 84,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -724,7 +724,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 85,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -748,12 +748,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 86,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -780,7 +780,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 87,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -794,7 +794,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 88,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -803,7 +803,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 89,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -828,12 +828,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 90,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -850,7 +850,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 91,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -872,7 +872,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 92,
    "metadata": {},
    "outputs": [
     {
@@ -893,7 +893,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 93,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -918,12 +918,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 94,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -951,7 +951,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 95,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -980,19 +980,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 96,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[0.9059005967298545, 0.5011587614679881, -0.31973206003781973, -0.3059206297856045, 0.07049173357560067, -0.10795210825363703, 0.15763290451952458, 0.1458017703887272, 0.3985471133990941, -0.34303557228139303, -0.22384336501109753, 0.014087249570502978]\n"
+      "[0.833829812009902, 0.6505255840955172, -0.25363241947260634, -0.2565692273582894, -0.04820242793010668, -0.07578107423921765, 0.0306483354548232, 0.14394597756353772, 0.31080526300406486, -0.2708375110699364, -0.1873337078723743, 0.009221983705203095]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1009,7 +1009,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 97,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1029,12 +1029,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 98,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABNq0lEQVR4nO2deZyNZfvAv9csGCUjtBj7voekRRLKvJKSVkmvsrwqUkqRQiqJRIrslRZL68ubX3pLWpSkLDF4kyV7CNFYZrl/f9zncIyzzczZz/X9fOYz51nOc1/Pc855rue+VjHGoCiKosQvCeEWQFEURQkvqggURVHiHFUEiqIocY4qAkVRlDhHFYGiKEqco4pAURQlzlFFoCgRjFheF5EDIrIs3PL4g4g8ISLTHK8ri4gRkaQAHXuLiFxTwPdeLSLbAyFHrKGKwA9E5E4RWS4iR0Rkl4j8n4hcGYDjviEizwZIxoAdK5oQkcWOm2TRcMviDhHpJiLfFuIQVwLXAuWNMc08HD/H8d38S0RWisj1hRiv0BhjRhhjeoRjbBFpJiILROSgiPwpIstE5J5wyBJNqCLwgYj0B8YBI4DzgYrARODGMIoVVAL19BZsRKQy0AIwwA3hlSZoVAK2GGP+9rLP98aYs4FUYDowV0RK5d0pFJ9rOL87InI5sAj4CqgOlAbuA9qFS6aowRijfx7+gJLAEeBWL/sUxSqKnY6/cUBRx7arge3AI8AfwC7gHse2XkAWcMIxxnzH+nLAB8BeYDPwoGP9uY5jdXAsnw1sBO72dCw3stYD/gv8CewBnnCsHwa8D7wN/AX0cMgxz7HvRqCny3Gc+88BDgM/Axd5GPM14MU86/4N9He8fhzY4TjOBqBNPj6fIcAS4CXgP3m2vYFV2P/nuCZLgAscn88BYD3Q2GX/OsBi4CCwFrjBZdtioIfLcjfgW5dlA/QGfnW8fwIgjmMeA3IcMhz0cB5urzXQPc/7n3bz3ryynOWQp6mHz7UkVlnsclz3Z4FEx3urY2+ih4B9wJwCfneGAW87tld2yNML+/vYBTzqctwEYCDwG7AfmAuc67K9K7DVsW0wsAW4xsN1/BaY4OX7cjUefo+O7e2BFY7z2AYMc9nmPI9/Ar87rs9gl+0pwJvY79Y64DFge57P+IzfdaT8hV2ASP4D/gFkA0le9hkOLAXOA8oC3wHPuHzxsh37JAPXAZlAKcf2N4BnXY6VAPyEvcEVAaoCm4B0x/a2wG7HWFOB913ee9qx3MhZwvHFfwQo5li+1LFtGFaRdHTIkAJ8jb2RFgMaOb7ArfPsf4vjvB51fLmT3Yx7leNHJY7lUsBRxw+jlmNbOce2ykC1fHw+G4H7gYsd8pyf53rsc2wrhn1S3IxVnInYG+CXjn2THcd6wnHdW2MVUy3H9sX4VgT/wT6RV3Rcq3+429fDeXi71l7f77odSAL6OWQv6eFz/QiYjFUY5wHLgH853j8Le7NNcMhyZQG/O8M4UxHMcozZwHF+1zi298P+fspjH6omA7Mc2+piFeBVjm0vYX9PZygCoDhWYbbycq2uxvvv8WqHfAlAQ6zC65jnPKY6zvEi4DhQx7F9JFaJlnKcy2ocigAfv+tI+Au7AJH8B3QBdvvY5zfgOpfldOxU3vnFOoqLIsE+iVzmeP0GpyuCS4Hf8xx/EPC6y/IrwC/Yp7nSLutPO5YbOTsDKzxsGwZ87bJcwfGjKuGy7nngDZf9l7psS8DeKFq4ObZgn6Cuciz3BBY5Xld3XI9rcKNEfFz3K7E3oDKO5fXAw3mux1SX5b7AOpflBjie0LHmpd1Agsv2WTieCPFPEVzpsjwXGOhuXzfn4eta+3p/N+zN7SBW8S3l1E027+d6PvbmlZLne/Gl4/VMYArWH1Gg747LuryKoLbL9lHAdMfrdbjMAoELHZ9rEvbGOdtl21nYWa87RZCWdxw3+1yNl9+jm/3HAWPznEd5l+3LgDscr0+7sWNnRk5F4PN3He4/9RF4Zz9Qxofdsxx26upkq2PdyWMYY7JdljOxZh13VALKORxdB0XkIPYp9XyXfaYA9bE3iv3+nQZgbzi/edm+zeV1OeBPY8xhl3VbsT+2M/Y3xuRip9yu5+3cZoDZ2JsJwJ3AO45tG4GHsDeOP0RktoiccQwP/BP4zBizz7H8rmOdK3tcXh91s+z8HMoB2xzn4STv+fpit8trb59xXvy51r5YaoxJNcaUMcZcZoz53GWb6+daCfskvMvl+zUZOzMAa84QYJmIrBWRex3r8/Pd8Wcf199IJeAjF3nWYRXj+Y59XL9nf2N/k+44AORiFYk3PP4eReRSEflSRPaKyCGsua9Mnvd7+pxPk5Uzr7uv33VYUUXgne+xT1AdveyzE/tBO6noWOcPJs/yNmCz40ft/CthjLkOQEQSsYpgJnC/iFT3cqy8bMNOSf2RZSdwroiUcFlXETsLcVLB+UJEErDTYU/nPQu4RUQqYZ+OPjg5qDHvGmOuxF5DA7zg4zwQkRTgNqCliOwWkd3Aw8BFInKRr/e7YSdQwXEeTlzP92+s6cHJBfk4tq/PxZ9rXRhcx9+G/T6Xcfl+nWOMqQdgjNltjOlpjCkH/AuY6PiO5ee744kKLq9dfyPbgHZ5vvPFjDE7sLNM1+9ZcawD+EwBjMnE/l5v9kMWT7yL9dVUMMaUBCZhFaM/7ML+Bpy4nq/X33UkoIrAC8aYQ9jp6QQR6SgixUUkWUTaicgox26zgCdFpKyIlHHs/7afQ+zh9B/YMuCwiDwuIikikigi9UXkEsf2J7A/unuB0cBMh3Jwd6y8/Ae4UEQeEpGiIlJCRC71cN7bsL6O50WkmIg0xDouXc/rYhHp5JgtPYS9wSz1cLwVWLPFNGChMeYggIjUEpHWjtDPY9in9Fx3x8hDR+xTY12sTb0R1jH7DdYHkF9+wD7dPeb4fK8GOmBnMgArgU6Oz7869lr4yx6gvIgUcbfRz2sdEIwxu4DPgDEico6IJIhINRFpCSAit4qI82Z2APtdyyUf3x0vPOW4fvWAe7CBBmBvts85HhJw/I5udGx7H7heRK50XL/heL9nPQZ0E5EBIlLacbyLRGS2l/e4UgI7OzsmIs2ws1d/mQsMEpFSIpIG9HHZ5ut3HXZUEfjAGDMG6A88iXVybcN+yB87dnkWWI51Dv2CjaDxN55/OlDXMV382BiTA1yPvbFt5tTNs6SIXOyQ427Hfi9gf6gD3R3LzXkcxsajd8BOb38FWnmRrTPWLroT62Acmsfk8G/gduwNoyvQyRiT5eV472J9Ae+6rCuKdbLt45QTfBCAiHQRkbUejvVPrH31d8dT7G5jzG7gVaBLfkMYjTEnsNelnUOWidjrvN6xy1isbXoPNjLknXwcfhE2Cmm3iOzzsI+vax1I7sY6LDOwn937nDKnXAL8ICJHsE/G/Ywxmwrw3XHHV1iH/BfYKLLPHOtfdoz1mYgcxj5MXApgjFkLPID9zuxyyOsxIcwY8x3W0d8a2CQif2Jn0Av8lPF+YLhDjiHYm7u/DHfIthn4HHtdjzvk8vi7zsfxg4ozkkNR/EZEhgHVjTF3hVsWRYlEROQ+rCO5Zbhl8QedESiKohQSEblQRJo7zG21sKG2H4VbLn+JigxSRVGUCKcINgKrCjaUdzbWxBgVqGlIURQlzlHTkKIoSpwTdaahMmXKmMqVK4dbDEVRlKjip59+2meMKetuW9QpgsqVK7N8+fJwi6EoihJViMhWT9vUNKQoihLnqCJQFEWJc1QRKIqixDmqCBRFUeIcVQSKoihxTtAUgYjMEJE/RGSNh+0iIuNFZKOIrBaRJsGSRVEURfFMMGcEb2BbPXqiHVDD8dcL29tWURRFCTFBUwTGmK+xja49cSMw01iWAqki4qu7UOH47Tc4diyoQyiKogSav//+my1btgTt+OH0EaRxeju37XhozycivURkuYgs37t3b8FGy86G9u2hUSNYsqRgx1AURQkxixYtomHDhnTq1IncXH/6NuWfqHAWG2OmGGOaGmOali3rNkPaN0lJ8PLLdkbQogU8+CAcORJYQRVFUQLEwYMH6dmzJ23atCEhIYGxY8eSkBCcW3Y4FcEOTu/rWZ7A9Wl1T3o6rFkDffrAq69C/fqweXNQh1QURckvOTk5XHHFFcyYMYPHHnuM1atX07Jl8HrchLPW0Dygj6Of6KXAIUdP1eBy9tkwfjzcfjtMmgQVK9r1xoD426daURQl8Ozfv59zzz2XxMREnnvuOSpUqEDTpk2DPm4ww0dnAd8DtURku4h0F5HeItLbscsCYBO2j+lUbL/Q0NG8Obz1FiQmwt69cNFF8OGHIRVBURQFwBjD22+/Tc2aNZk2bRoAN910U0iUAARxRmCM6exju8E2pg4/Bw9aH8LNN9u/V1+FCy4It1SKosQB27Zto3fv3ixYsIDLLruM5s2bh1yGqHAWB50aNeCHH+D55+E//4G6deGNN6y5SFEUJUjMmjWLevXqsXjxYsaNG8e3335L3bp1Qy6HKgInyckwcCCsWgX16sH8+eozUBQlqJQqVYpLL72UNWvW0K9fPxITE8MiR9T1LG7atKkJemOa3Fz4+28oUQL+9z9YuBAeeACCFLqlKEp8kJ2dzdixYzlx4gSDBw8GrH9AQvDQKSI/GWPcOh30zuaOhASrBMCaiB580OYerFsXVrEURYleVq1axWWXXXYyHNT5EB4KJeALVQS+eO45mDkT1q+3WckjRkBWVrilUhQlSjh+/DhPPfUUTZs2Zdu2bbz33nvMnj07IhSAE1UEvhCBrl0hIwM6doTBg+Gll8ItlaIoUcKvv/7KCy+8wJ133klGRga33HJLRCkBiMLm9WHj/PNhzhyrFFq1sus2boS0NEhJCa9siqJEFEeOHOHf//43Xbp0oX79+qxfv56qVauGWyyP6Iwgv1x/PZx11ulF7L79NtxSKYoSIfz3v/+lQYMGdO3alXUOv2IkKwFQRVBwkpJgwgQ4ccI6kvv0gcOHwy2VEoF8vGIHzUcuosrAT2g+chEfrwhuSS0lPBw4cIDu3bvTtm1bihQpwldffUWdOnXCLZZfqCIoDNdcA7/8Av36wcSJNv9g06ZwS6VEEB+v2MGgD39hx8GjGGDHwaMM+vAXVQYxRk5ODs2bN+fNN99k0KBBrFq1ihYtWoRbLL9RH0FhOftsGDfOFrF77TWoVMmuz83VvAOF0Qs3cDQr57R1R7NyGL1wAx0bu22/EXY+XrGD0Qs3sPPgUcqlpjAgvVbEyhpu9u3bd7JI3IgRI6hYsSJNmkRf1129UwWKyy+3YabOInYNGsDcuVqmIs7ZefBovtaHG53B+IcxhpkzZ55WJK5jx45RqQRAFUFwOHTIRhLdfjt06gQ7d4ZbIiVMlEt1H1HmaX248TaDUSxbt26lXbt2/POf/6ROnTpcddVV4Rap0KgiCAbVq8PSpTBqFHz6qS1iN326zg7ikAHptUhJPr1+TEpyIgPSa4VJojNxdWbviLIZTKh5++23qV+/Pt9++y2vvPIK33zzDbVr1w63WIVGfQTBIikJBgywSWg9eliF0L17uKVSQozTth4sm7sve74/2wd9+MsZs4C8ROoMJtSULVuW5s2bM3nyZCo5/YExgBadCwW5uZCZaR3LGzZYpdCnj/UnKEoBcXcTT0lO5PlODejYOM3ndoDmIxd5nAV4ek9eGWLZsZyVlcWYMWPIysriqaeeAkJXJC7QaNG5cJOQYJUA2K5oDz0EV15py1YoSgHxZc/3x97vzeQjQFpqilclEMuO5RUrVnDppZcyaNAgMjIyIqpIXKBRRRBqnnkG3n4bfv0VGje2yydOhFsqJQrxFZHkT8SSJ5NPWmoKm0e2Z8nA1h6f8IPtWA5XIt6xY8d44oknuOSSS9i5cycffPABs2bNikkF4EQVQagRgS5d7GygUycYMgTGjg23VEoU4isiyZ+IpcI4s4MZGhvO2cbGjRt58cUXufvuu1m3bh2dOnUK+pjhRhVBuDjvPJg1Cz75xPoLwDbBycwMr1xK2PH3SdjXTdyfm3zHxmk836kBaakpPk1BeQlmaGyow1iPHDnCW2+9BUD9+vXZsGEDM2bMoFSpUkEZL9LQqKFwc9119n92NnToYB3L06ZBy5bhlUsJC3kdvM4nYeCMm7OviCR/I5Y6Nk7z28Hr6hwumZJMcqKQlXMq4CRQobGhTMRbuHAhvXr1Ytu2bTRt2pQ6depQpUqVgI8TyagiiBSSkmyJip494eqroXdveOEFOOeccEumBAl3ETf5LUnh6yaen5u8P/K6KqmDR7NIThBKFU/mYGZWQKOGyqWmuI1mCmQY6/79++nfvz8zZ86kdu3afPPNN1FTJC7QaPhopJGZecpvUK4cfPUVRHgJWyX/eArt9BTPL8Dmke1DJJ17PIWapqWmsGRg64CO5e76JCcIZxdLCojSycnJoV69emzcuJGBAwfy5JNPUqxYsUCJH5F4Cx/VGUGkUbw4vPgi3HYbTJqkRexiFE9P/oki5Lh5OIuEhK5QmmvymrVKpiTz94lsDmTaNrHeTGbe2Lt3L6VLlyYxMZEXXniBSpUq0ahRo4DLH23onSVSadYMZsywSWd//AH168Ps2VqmIkrJ6wD2lMSVY0yhSlIEM+Qy1HWTOjZOY8nA1mwe2Z6ziiad5ouA/DmPjTG8/vrr1KxZk6lTpwJw4403qhJwoIogGjh82Cakde5sS1bsiI2EnXjBXSikp4h0Z9SOaxTPzRenMXrhBp8392CHXPoThRQsRVSY2ciWLVtIT0/n3nvvpUGDBrRytppVTqKKIBqoVg2+/x7GjIH//tcWsZs6VWcHUYI7M5CBM5SB86bq+iQ8IL0WH/y0w6+be7BDLn2FmgZTERV0NvLWW29Rv359vv/+eyZOnMjixYupWbNmoeWJNVQRRAuJidC/v+2IdvHF8NlnNjlNiXg8PbUa8Bm/n5+beyhs+K5KKm/WcTAVUUET384//3yuuuoq1q5dy3333UeC+tncos7iaKNaNfjiC/j7b7u8fr1NSnvoIS1iF6F4CoX0J9omPzf3UIRcesObrIUtTudvTkRWVhajRo0iJyeHIUOG0LZtW9q2bVvwk4oTVD1GIyKniti98w48+qjtkLZmTXjlUtxSmDIO+TGJhLv3gSdZU4snB8Rk5G02AvDzzz9zySWX8OSTT7JhwwaiLTQ+nKgiiHaGD7elKjZvhiZNYNgwLWIXYRSmjEN+bu6FGScQeJLVGILquzh69CgDBw6kWbNm7Nmzh48++oh33nknpovEBZqgJpSJyD+Al4FEYJoxZmSe7RWBN4FUxz4DjTELvB0z5hPKCsq+fdY89M478PzzMHBguCVSAkQ01fx3J+vDc1bi7i4TqCS5tWvX0rhxY+6++25Gjx4dN/WB8ou3hLKgKQIRSQT+B1wLbAd+BDobYzJc9pkCrDDGvCYidYEFxpjK3o6risAHCxdCixY2MW3DBqhQwb5WlDARjIzkv/76iw8//JBu3boBto9wLHUMCwbhakzTDNhojNlkjDkBzAZuzLOPAZzFdEoC2uW9sKSn2xt/djbccAM0aABffhluqZQ4JtC+iwULFlC/fn26d+/OunXrAFQJFJJgKoI0YJvL8nbHOleGAXeJyHZgAdDX3YFEpJeILBeR5Xv37g2GrLFHUhJMmWLLUrRuDb16waFD4ZZKiWE8JZMFynexb98+unbtSvv27SlRogRLliyJ2yJxgSaYpqFbgH8YY3o4lrsClxpj+rjs098hwxgRuRyYDtQ3xuR6Oq6ahvJJZqZ1II8ZAxdcAF9/bUNQFSWA+NMfuTDk5ORQt25dNm3axBNPPMETTzxB0aJFC33ceCJcpqEdQAWX5fKOda50B+YCGGO+B4oBZYIoU/xRvDiMGgU//ADt2kHlynZ9rkddqyj5JljJZHv27CE3N5fExERefPFFfvrpJ55++mlVAgEmmIrgR6CGiFQRkSLAHcC8PPv8DrQBEJE6WEWgtp9g0LSpbXjjLGJXty68+66WqVACQqCzmo0xTJ8+nVq1ajFlyhQAOnToQMOGDQsso+KZoCkCY0w20AdYCKwD5hpj1orIcBG5wbHbI0BPEVkFzAK6Gc0CCT5HjkCpUrZ3cocOsG2b7/coihcCWZl006ZNXHPNNfTo0YNGjRpxzTXXFFY8xQdBTSgzxiwwxtQ0xlQzxjznWDfEGDPP8TrDGNPcGHORMaaRMeazYMqjOKhaFb79FsaNsxFF9erZ3geqg5UCEqjIoDfffJMGDRrw448/MmnSJBYtWkT16tUDKariBs0sjlcSE6FfP1vErlkzqxA0EzNqCGbfgYIQqMigcuXK0bp1azIyMvjXv/6lReJChLaqVOxM4OhR61hevx7mz4eHH7YhqCEkmjJow4Hz+jj7Gbj+cgMZoRNKTpw4wciRI8nNzWXYsGHhFiemCVfUkBItiJzKPn73XXjsMVvEbvXqkIkQ7KYq0Y7r9QHOKNmQ3widSJhR/Pjjj1x88cUMHTqUTZs2aZG4MKKKQDmdp5+GuXPh999t34MhQ+D48aAPG+ymKtGOu+uTF38jdMKtdDMzM3n00Ue57LLLOHDgAPPmzWPmzJlaJC6MqCJQTkcEbr0VMjJsa8xnnoGxY4M+bCgbo0cj/lwHfyN0wq10N2/ezCuvvELPnj1Zu3YtHTp0CMm4imdUESjuKV0aZs60ndAefNCuW7/+VEOcABPqxujRhq/rkJ8InXAo3UOHDvH6668DUK9ePTZu3MikSZMoWbJk0MZU/EcVgeKda689s4jd558HfJhwN1WJdNxdH6chJb8ROqFWup988gn16tWjR48erF+/HoAKFSr4eJcSSlQRKP6RlGQzk5OSrHLo3h0OHAjY4cPdVCXScXd9xt7eiC0eunV5I1RKd+/evXTp0oXrr7+eUqVK8f3331O7du2AjqEEBg0fVfLH0aO2K9ro0VC2LHzzDWjCT9QR7FBdZ5G4zZs38+STTzJw4ECKFCkSsOMr+ScsjWmChSqCCOHnn2028muv2eS0nBz7X4lrdu/ezXnnnUdCQgL/+c9/qFy5MvXr1w+3WAqaR6AEgyZNbL+DxETYswfq1IG33tIyFXFKbm4ukydPpmbNmkyePBmA66+/XpVAlKCKQCk8mZnWTHT33XDddTYHQYkbNm7cSJs2bejduzeXXHIJ6enp4RZJySeqCJTCU6WK9RWMH2//16sHEybo7CAOeP3112nQoAE///wzU6dO5fPPP6dq1arhFkvJJ6oIlMCQkAB9+8KaNXDFFbYTmmaKxjwVK1YkPT2djIwMevToodnBUYo6i5XA41rEbt06mDcPHnkk5EXsYpVQF+dzHe+CsxOptO0zap5/NsOHDw/amErgUWexElpci9jNmQMDB8Kll8LKlWEVKxYIdZ0g1/GO7dzATy//izlTxvLtyvVaJC6GUEWgBJdhw+D992HHDtsuc/BgOHYs3FKFhGBU+Ax1naDRCzfw999/8+cXU9n91qPkHs+k7C1DOX5FbzUDxRA6V1eCz803Q6tW8OijMGIElChhZwkxgjtTDcCgD385edN2PrkDhTLjhLpO0M6DR8n+6w8Or1jA2Y3bUaplNxKKFtdigDGGKgIlNJx7LsyYAXfdBZddZtetWwcVKsDZZ4dXtkLgNJ3kveEXTUrw+OReGEVQLjXlZE+CvOsLgid/w8GDB3n//fcpl1qVHVQkrddUks4pU+jxlMhETUNKaGnd+lQRuxtvhPr1bYXTKMWTqebg0Sy3+xf2STqQdYI8+RsGjZ1B3bp16d27N51rJpKSnHiaEtBigLGHKgIlPCQlweuvQ0oKpKfDPffAn3+GW6p8k98be2GfpANZnC+vEsv5+yC/vz+Ckf27U7ZsWZYuXUqfTi21GGAcoOGjSng5dgyefRZGjoQyZeDbbyO+iJ2rOSVBhBwPv6FI7ytcZeAnJ+UzuTnsnNab7L/2knpFZ/74YjrJyclhlU8JLN7CR9VHoISXYsWsIrjlFlvEzpmVGqFF7PL6BDwpAbBKwKkM0kIQ759fyqWmsHXbdhLPLoUkJHJum14kljyfKtVrqRKIM9Q0pEQGjRpZRZCQYIvY1aoFb7wRMWUqnKGgD81Z6bZ3cKKHUEqnEshvz4Bgk5ubS4O/fmDXtN4cWfF/AKRUu4SSF1ZR+38coopAiTyOHoULL7R+g/R02LIlrOK4OlU9kWsMnqLqIy3U8n//+x+tWrVi8vNP0KBxUyo3aq72/zhHTUNK5FG5Mnz1lZ0hPP64jSwaMcLWMgpDEpO7yKC8OJ3AgQztDAbTp0+nT58+FCtWjBkzZtCtWzdNDFN0RqBEKAkJcP/9tohdixbw/fdhK2Ln64neGU4ZDX2XK1euTLt27cjIyOCee+5RJaAAOiNQIp1KlWDBglNlKTIy4KOP4LHHIEQOTU9JXODeCRzKgnC+OH78OM888wwAzz77LG3atKFNmzZhk0eJTFQRKJGPiM03AHjvPVu/6L33bKZykyZBH35Aeq3TIoXAcyhox8ZpEWNj/+677+jevTvr16/n3nvvxRijMwDFLWoaUqKLoUPtjGDPHmjWzNYsOhpcZ2wgk7hCwZEjR+jXrx9XXnklmZmZfPrpp0yfPl2VgOKRoCaUicg/gJeBRGCaMWakm31uA4ZhI+1WGWPu9HZMTShTADhwAAYMgOnT4fnnY6qIXWHJyMigSZMm9OzZkxEjRlCiRIlwi6REAN4SyoKmCEQkEfgfcC2wHfgR6GyMyXDZpwYwF2htjDkgIucZY/7wdlxVBMppLF5sex2kpMDatVCxoq1uGmccOHCA9957j169egGwc+dOypUrF2aplEgiXI1pmgEbjTGbjDEngNnAjXn26QlMMMYcAPClBBTlDK6+2iqB7Gzo2NH2S/6//wu3VH4TiJ4FH330EXXr1uX+++9nwwbbl0CVgJIfgqkI0oBtLsvbHetcqQnUFJElIrLUYUo6AxHpJSLLRWT53r17gySuEtUkJcHMmbak9XXXwd13w/794ZbKK4XtNrZ7925uvfVWOnXqxAUXXMCyZcuoVStyQlWV6CHczuIkoAZwNdAZmCoiqXl3MsZMMcY0NcY0LVu2bGglVKKHyy+HFSvgqadg1iyoUwd+/TXcUnmkMN3GcnJyaNGiBfPnz2fEiBEsW7aMJiGIoFJik2CGj+4AKrgsl3esc2U78IMxJgvYLCL/wyqGH4MolxLLFC0Kw4efKmJXrZpdn51tZw0RREG6jW3fvp1y5cqRmJjI+PHjqVKlCrVr1w6WiEqcEMwZwY9ADRGpIiJFgDuAeXn2+Rg7G0BEymBNRZuCKJMSLzRsCBMn2gzl3buhZk0bYRQhRezAc+kJd+tzc3N55ZVXqF27Nq+99hoA7dq1UyWgBAS/HpFEpDjwCFDRGNPTEe1TyxjzH0/vMcZki0gfYCE2fHSGMWatiAwHlhtj5jm2tRWRDCAHGGCMiWzDrhJ9HD9uo4l69LAmoylTTpW7DiOeEtXylqRYv349PXr0YMmSJaSnp3P99deHWtSoISsri+3bt3PMmYkehxQrVozy5cvnq5S4X+GjIjIH+Am42xhT36EYvjPGNCqosAVFw0eVApGbC1On2tyDnBx47jno1y9s9YuceOoZ7GTatGn06dOH4sWLM27cOLp27aqJYV7YvHkzJUqUoHTp0nF5nYwx7N+/n8OHD1OlSpXTtgWiMU01Y8ztItLZMVimxONVVqKKM2+y19Mxoz307g0//BB2JQC+S1JUq1aNDh068Oqrr3L++eeHULLo5NixY1SuXDkulQCAiFC6dGnyG13pryI4ISIpODrviUg14Hj+RFSU0JG3k5gzNJNODeg4f741F4EtYvfBB7bcdZEiYZTYcuzYMYYPHw7AiBEjaNWqFa1atQqzVNFFvCoBJwU5f3+dxUOBT4EKIvIO8AXwWL5HU5QQ4TU0U8S2yASrBIYMgaZN4cfwBqstWbKERo0a8fzzz7N3716irZ+4Er34pQiMMf8FOgHdgFlAU2PM4uCJpSiFw+/QzKeegn//2yafXXaZLW+dmRkCCU9x+PBh+vbtS4sWLTh+/DgLFy5k6tSpcf9kq4QOvxSBiDQBKgG7gJ1ARRGpJiKRFZitRCyBKKWQnzESPNxEU4u7iaS44QZrIureHUaPhpdfDrhs3ti+fTvTpk2jb9++/PLLL7Rt2zak4yuBY8iQIYwbN+7k8uDBg3nZx/fp0KFD1KpV62R5kM6dOzN16tRginkG/t7IJwJNgNWAAPWBtUBJEbnPGPNZkORTYgCP9noIWCnnvGPkeDCrHDmWzccrdpw5bsmSNqz0rrvgkkvsujVroEIFuy3PWIVtPrN//37mzp3LfffdR506ddi0aRMXXnhhvo6h+Obqq68+Y91tt93G/fffT2ZmJtddd90Z27t160a3bt3Yt28ft9xyy2nbFi9e7HW8e++9l06dOvHQQw+Rm5vL7NmzWbRoEY0aNXK7/7vvvkvdunV59dVX6datG/369ePAgQP07NnT31MMCP4qgp1Ad2PMWgARqQsMx/oJPgRUEUQRgbiR5Qdv9vpAjetPX2GArFzjfdyrrrL/c3Lgpptsr4PJk6F9e6DwSs0YwwcffMADDzzAn3/+SevWralVq5YqgRihcuXKlC5dmhUrVrBnzx4aN25MpUqVWLlypdf3XXvttbz33ns88MADrFq1KjTCuuCvIqjpVAIAxpgMEaltjNmkdszoIhRP53kpSCmFQI1R4H0TE+Gdd6y56Prr4c47Ydy4Qim1Xbt28cADD/DRRx9x8cUX89lnn2mRuCDj7Qm+ePHiXreXKVPG5wzAHT169OCNN95g9+7d3HvvvRw+fJgWLVq43dc5I8jNzWXdunUUL16cAwcOUL58+XyPWxj8VQRrReQ1bClpgNuBDBEpCmQFRTIlKITi6Twvnnr+eiqx4A95ZzUlU5I5eNS/r2LecT3OkJo1g59+so1vnnsOPvuMIjc9B+eeeZ18KRdnkbgdO3YwatQoHn74YZIirPaREhhuuukmhgwZQlZWFu+++y6JiYk+ZwRjx46lTp06jBgxgnvuuYfvv/8+X5nBhcXfb2I34H7gIcfyEuBRrBLQIGc/CbVJxh2heDrPi6dSCq1ql6X5yEX5vh7uZjXJiUJygpCVe8o3kJwoYDhtXd4SDj5nSEWK2PaYN98MkyeTdWFV+Os4STnZZCee+vl4Umrbtm0jLS2NxMREJkyYQJUqVahZs6Y/l02JUooUKUKrVq1ITU0lMTHR5/4bNmxg2rRpLFu2jBIlSnDVVVfx7LPP8vTTT4dAWou/4aNHjTFjjDE3Of5eNMZkGmNyjTFHgi1kLFDY2vOBIj+FzgKFu56/N1+cxgc/7SjQ9XA3q8nKMZxdLOm0MUbfchGjb73Ia69hv0tB168Pr7zCo+3qUOH4Ib6c+i/uWPkpGOO2PlBOTg7jx48/rUhcenq6KoE4IDc3l6VLl9K9e3e/9q9Vqxbr1q072VL0pZdeCqkSAP+LzjXH9hWu5PoeY0z4K3dFCeEwybjD30JngSZvKYXmIxcV+Hp4mr0czMxixZAzQy+9HS+/M6SOjdNI2VWdP+ZdyMiFr3Lrr9+yf+yrtHUZY926dXTv3p3vv/+edu3a0aFDB2+no8QQGRkZXH/99dx0003UqFEj3OL4jb+moenAw9jCc75DM5QzCIdJxh3Om2Ikm6h8mdAC6XMoyLHSr2sG7X6GadO4+NFH4Y5r4dln4eGHmTJ1Kn379qVEiRK89dZbdOnSRRPD4oi6deuyaVP0VdL3VxEcMsZETyPYCCQYDtOC4qvQWSjwdD1KpiT7jGryNavJjy+mwDMkEejZ07bFvO8+61QWoUaNGtx0002MHz+e8847z/8LoihhxN9aQ1+KyGgRuVxEmjj/gipZjDEgvRYpyac7jkJhkolUPF0PEXza7N35HJy2//z6Yrwdyx+Onnsuj9euzZOOPIBWZcsyu3ZtzktN9fdSKErY8XdGcKnjv2stawO0Dqw4sUukmGQiBU/X4+E5K93un9eU5GlWUxBfTEFnSF9//TU9evTg119/pXfv3hhjkH//G55+Gt5/H2bMsCGoihLh+KUIjDEaIhoACmuSiYTw00Di7nqMXrihUCa0UPhi/vrrLwYOHMhrr71G1apV+eKLL2jd2vFMNHgwNGpkex5cfjk89JDtoXzWWQEbX1ECjd89i0WkvYg8JiJDnH/BFEw5nUgJPw02hTWhhSI8dufOnbzxxhv079+f1atXn1ICTtq3h7Vr4V//gpdegvHjAza2Epu8+uqrVK9eHRFh3759IR/f3+qjk7DZxH2xReduxYaSKiHC73j3KKewNvtg+WL27dvHxIkTAahduzabN29mzJgxnOXpSf+cc2DiRPj2WzsrAPjlFzh0qFByKLFJ8+bN+fzzz6lUKTy3VX99BFcYYxqKyGpjzNMiMgbQKKIQ4sm0sePg0QJl50YyhTGhBdoXY4xh7ty59O3bl4MHD3LNNddQs2ZN/9tGNm9u/+fkQKdOttfBpEmguQUxyZAhQzj33HN5yKH8Bw8ezHnnnUe/fv28vq9x48Y+j33o0CGaNWvGvHnzqFWrFp07d6Z169YBqVTqryJw3oUyRaQcsB/QcokhxFO4pcDJ9aEoIBcNBCo8dufOndx3333MmzePpk2b8sUXXxQ8MzgxEWbNgnvvtf0P7rjD9j3QENPg4qYMNbfdBvffb5WymzLUdOtm//btgzxlqAlSGWp/KFmyZNDKVfurCP4jIqnAaOBnbMTQtIBIEOf46wB2F+8uOJpIuxCObOVYJCcnh6uuuoodO3bw4osv0q9fv8IXiWvaFJYvh1Gj4Jln4L//he++Ay07ETMUtAy1vwSrXLW/UUPPOF5+ICL/AYoZY9TYWUjyUxLancnD3QwBQp+tHEts3bqV8uXLk5iYyMSJE6latSrVq1cP3ABFisCTT1oz0eTJ4Dx2VhaEsNpk3ODtCb54ce/by5TxOQNwR0HKUHsiPT2dPXv20LRpU6ZNmxa0ctXib4NsEbkCqMzptYZmBkSKfNC0aVOzfPnyUA8bFJqPXOT2Zp6WmsKSgb5TNAr7/nATSeGwOTk5vPzyyzz55JOMGjWKPn36hG7wnTttv+RBg2ykUYLfwXxKHtatW0edOnXCKsOJEydo0KABWVlZ/Prrr35VIHVSuXJlli9fTpkyZdxuHzNmDBs2bKBr1648/PDDHstVu7sOIvKTMabpGTvjf9TQW8CLwJXAJY4/twdU/KcgMe+ufXkzT2STnHB6HZtoyVaOpHDYNWvWcMUVV/DII4/Qpk0bOnbsGFoBcnKgVi1rt27VCn79NbTjKwHFWYb6tttu81sJjB8/nvLly7N9+3YaNmxIjx49ztjHWa56zJgxtGjR4mS56kDg14xARNYBdY2/04cgEs8zgrymJLA1988qksSho1lhf6rOD5Eym5k0aRIPPvggJUuWZPz48dxxxx3hKRJnDLzxBvTvD8eO2ezkAQNsTSPFbyJhRpCbm0uTJk147733wlaBNCgzAmANcEEhZVPykN+Yd091+M8qmsTmke1ZMrB1VCgB8B4OG4pZgfOZpk6dOtx6661kZGTQuXPn8FUKFYF77oGMDGjXDlavViUQhWRkZFC9enXatGkTO2WoRWQ+NjClBLY15TLguHO7MeaG4IoX2+Q35j1SSlkHAm/O7mCGwGZmZjJkyBASExN54YUXaNmyJS1btgz4OAXmwgvhgw/gxAm7vGYNzJ1rS1cULRpe2RSfxGoZ6nnA+cA3eda3AHYFRaIopDBOz/zEvEdSKevC4i4c1kmwQmAXL15Mjx49+O2337j//vttkbhIfOoWOXXTnzfPhpq+/z5Mn27rFylKgPGlCG4EBhljfnFdKSJ/AiOwDWvimvyEgHp6f9Br5xcSp4w7Dh4lUYQcY0grpD/C+b6H/Kw2WhgOHTrEY489xpQpU6hWrRqLFi2iVasoqaP4xBPQuLGNJmreHB58EJ57TovYeSFiFXyIKIgr15eP4Py8SsAx0C/YUNK4pzA1gEJdO78guMoIkOP4kgUiyqdj4zTSQlAkbteuXbz99ts8+uijrF69OnqUgJN27WwRu/vvt9nIr7wSbokilmLFirF///4C3QxjAWMM+/fvp1ixYvl6n68ZQaqXbT5/qSLyD+BlIBGYZowZ6WG/m4H3gUuMMVEVElQYu30oa+cXFHcyOgmECSdYs5y9e/cye/Zs+vbtS+3atdmyZQtly5Yt1DHDSokS8Oqr0KWLnSEArFoFFStCqVLhlS2CcIZg7t27N9yihI1ixYrlO9HMlyJYLiI9jTFTXVeKSA9s/2KPiEgiMAG4FtgO/Cgi84wxGXn2KwH0A37Il+QRQmHs9tHg/PUlS2FlzeswTy2ejDHw8JyVjF64Id/mJ2MMs2bN4sEHH+Svv/4iPT2dmjVrRrcScMXpI8jJsXVwjhyxVU5vuim8ckUIycnJVKlSJdxiRB2+TEMPAfeIyGIRGeP4+wrojr15e6MZsNEYs8kYcwKYjfU55OUZ4AXgWP5EjwzchYAmJwiZJ7KpMvATmo9c5NF8Eora+YXFlyyBkLVj4zSWDGzN2NsbcSwrl4NHswqUZLZt2zY6dOhAly5dqF69OitWrCh4kbhIJzER5syBCy6w5SpuvRV27w63VEqU4lURGGP2GGOuAJ4Gtjj+njbGXG6M8fWtSwO2uSxvd6w7iaPvcQVjzCfeDiQivURkuYgsj7QpX167fWpKMggcyPR9M3OnRJzVRL0pkFDiTkYngXZUF8bfkp2dzdVXX82XX37J2LFjWbJkCfXq1QuYbBFJkyawbBmMGAHz50PduvC//4VbKiUK8bfo3JfAl4EcWEQSgJeAbn6MPwWYAjazOJByBAJXu33zkYs4eDTrtO2ebOmuZpEdB4+eVk00UkpK55UxUFFD7iiIqWzLli1UqFCBpKQkJk+eTNWqValatWrAZIp4kpNtjaKbboIpU04VsTtxwha4UxQ/KGRdXa/sACq4LJd3rHNSAqgPLHaEel0AzBORG6LNYexKfm9mTiXiruRCpJSUDpWDOj/+luzsbMaNG8dTTz3FqFGj6Nu3L9dcc03QZYxYate2bTHBFrG79FIYOBDuu0+L2Ck+CeY35EeghohUEZEiwB3YBDUAjDGHjDFljDGVjTGVgaVAVCsB8GwzN+DV3BMNjuNg42/JjdWrV3P55ZczYMAA0tPTufnmm0MpZuSTm2vNRH36QMuWsCG22pkqgSdoisAYkw30ARYC64C5xpi1IjJcRGK2NIU3m7o3f0E0OI6DjT95EhMnTuTiiy9m69atzJkzh48++ohy5cqFT+hIpHx5+PRTW8Ru7Vq46CIYOdIWtlMUN/jdjyBSiIbqo66ZuO5wV2HTXWXRlOTEoCeMRQvObNGvv/6aqVOnMnbsWI812xUXdu+2M4OUFHjrrXBLo4QRb9VHVREEkSoDPzmjlSTYyKDNI9ufsT6SGrVECn///TdPPvkkSUlJjB49OtziRC9O5/Hq1TB7NgwZAvnMPlWiG2+KIJjO4rgnv8lmoc4ajnS++OILevbsyebNm+nbt2/c15ApFM4IogUL4Pnn4cMPbRG75s3DK5cSEWg4QRDJb7+BwuLavczfPISCvCfYHDx4kB49enDNNdeQlJTE119/zfjx41UJBIKBA2HhQtv8pkUL6NsXDh8Ot1RKmFFFEERCWSSuIK0fI6ldpCt79uxh9uzZPP7446xatcpj42+lgLRta/sc9O0LEybYGkZKXKM+ghihIK0fI6VdJJy6+ffrZyuX7Nu3T53BoeCHH2xUUbFisHKlLWJ37rnhlkoJAoFoValEOAXJQ4iE3AVjDG+//TZ169blscce41dH43ZVAiHi0kutEsjJsfWK6ta1HdKUuEIVgQ8i0YbujoLkIeTnPcG4Dr///jvt27ena9eu1KpVi5UrV0ZVn9eYIjER3nsP0tJsVdObb4Zd2oQwXoh7ReDtBhepNnR3FMQx7e97gnEdnEXinI7gb775hjp16hT4eEoAaNTImopGjoRPPrGzA81KjgviOnzUV5vJgjSOCTbucg3gVOXO/BSFy9sLwFPuQiCvw6ZNm6hUqRJJSUlMnTqVatWqUbly5XwdQwkiSUnw+OO2iN3kyeCcoR0/fqqPshJzxLWz2JezNL8JYcHGXfZxcoKAQFbOKUkDnZEciOuQnZ3NmDFjGDp0KKNGjeLBBx8MiGxKCNixA5o1swrigQesGUmJOuLeWezJ/OPLWRpp9X/cPZln5ZrTlAC4r+FfGBt/Ya/DypUrufTSSxk4cCDXXXcdt956q99jKxGAiI0s6tfP5h6sWxduiZQAE/OKwJt929cNLtQJYb7ITzSP676FtfEX5jq8+uqrXHLJJezYsYP333+fDz/8kAsvvNDv81AigHLlrM/grbesz6BRI3j2WS1iF0PEvCLwZt/2dYPLT0JYKKKL8jMTcd23MJ2/oGCJcU6TY8OGDenSpQsZGRlaLjqaEYG77rKzgY4dbSc0zfSOGWLeR1B5oOcumFtGtg9IoTd/KocGYpwnP/6Ft5f+fsb6BIFcl48x79iB9HX4Oo8jR44wePBgkpOTefHFF/N1bCWKyMqy3dFWr4Z334WhQ22FUyViieuic84oGnfrITCF3nxF1fiKTvKXL9e779dcMiWZ4kWSPN6c81v8zhO+zuOzzz6jV69e/P7771okLtZJTrb/P/0UXnjBFrGbNg2uuiq8cikFIuZNQ+6UgHN9oMw4vpzOhTXN+BrnYGYWSwa2ZvPI9iwZ2PoM5RIoX4en83j+4+Xcc889pKenU6xYMb7++mtefvllVQLxwGOPweefQ3a27Yb2wANaxC4KiXlFkOblqTdQyVG+nM6BKuVQ0OidQBW/8yTvjp27ef/99xk0aBArV67kyiuvzNdxlSinTRv45Rd46CF47TVbyE6JKmLeR+DOfu+OwhRaczeGYBVNWmoKmSeyOZCZVegxw93FzDXvIufIAf5e9xXnXNKRtNQU5vW8iNKlSwddBiXC+fFHaNjQJp+tWAEVKoDWjYoI4jqPIO/TsCcKU2jNdQw4pQTAzjiOHMsmOfH00QtimgllWWt3DEivRbGkBI788gU7p9/Hga/eJPHwbgak11IloFguucQqgZwcuO02W6Zi7lwNNY1wYn5GkJdgl172dPzUlGTOKurZoRsNbNmyhZs6d2Pl0q8omlaXOrcNYGjXa6PuPJQQ8csvcO+9sHw53HgjTJxocxKUsBDXUUNOvDWUT06UgCWJeZpZHDqaxcqhbQMyhjuC3e84OzubVq1asW/fPiZMmEDv3r1JSIj5CaVSGBo0gO+/h5dfhieftLODH36AWuFJyFQ8Exe/ZNfMWrcEcFIUjrIU7jKHH5qzksbDPyt0RNTGjRvJyckhKSmJGTNmsGbNGu6//35VAop/JCXBI4/Y2UGvXlCzpl1/7Fh45VJOIy5+ze7CHl3JyjX5DuX0RDjKUng6vwOZWQWOiMrKymLEiBHUq1ePCY4okFatWlGpUqVCy6vEIdWrw6hRNht5xw6oWhXGjbO+BCXsxIUi8McRHKiuXB0bp3HzxWknE9YSRbj54sInrXnDm+wFyVf4+eefadasGYMHD+bGG2/k9ttvL6yIinIKEWjSBB5+GJo3h7Vrwy1R3BMXisAfs0x+TDe+mtl88NOOk4lsOcbwwU87gtrMxpfs+VFy48ePp1mzZuzevZsPP/yQuXPncv755xdWREU5RblyMH8+vPMObNwIjRvD8OEaWRRG4kIRDEivZev2e8CX6cZ546888BOqDvqEh+as9FjJM1BZxPnBnTnKFX+UnDN6rHHjxtx9991kZGRw0003BUxGRTkNEbjzTlvE7pZb4LfftIhdGIkLRbB8659k5bp/2vAVi5/X0ezuMK43+nA0hHfmF6SmJJ+xzZeSO3z4MH369OHRRx8FoEWLFsyYMYNSpUoFTV5FOUnZsrZo3bRpdnnVKhgwADIzwytXnBHziuDjFTt4x03FTjiVO+DNfu/L0ewk3M1sOjZOY+XQtoy7vZHfCWeffvop9evXZ+LEiRhjiLacEiWGcBax++wzePFFm528eHFYRYonYj6PYPTCDR6jQ3ccPErzkYu8xt57DDnNg/NG36p2Wd5Z+vtpY4aymY0/1VT3799P//79mTlzJnXq1GHJkiVcfvnlIZFPUbwyYAA0bQo9e0KrVjbkdNQoKFky3JLFNDE/I/B1I/fWtctfB6/zRu90FLsqAYGgRw3ll/379/PRRx/x1FNPsWLFClUCSmTRqpXtc/Doo9ZkNHFiuCWKeYKqCETkHyKyQUQ2ishAN9v7i0iGiKwWkS9EJOBB6on5cEC52vqdvgFfpKYknzS/uDMjGTz3EQglu3bt4sUXX8QYQ82aNdm6dSvDhw+naNGi4RZNUc6keHEYPdoWsevf36776SfYG/7fUiwSNEUgIonABKAdUBfoLCJ18+y2AmhqjGkIvA+MCrQcnvoReMJbD4G8lCqezMqhbU8+7YfDUewLYwwzZsygTp06PPXUU2zcuBFAncFKdNCkyakidnfcYctUzJqloaYBJpgzgmbARmPMJmPMCWA2cKPrDsaYL40xzvCApUD5QAuR34A0Xz0EnCQnCkM71HP7Xk/HDDWbN2+mbdu2dO/enYsuuohVq1ZRo0aNsMiiKIUiMRE++shmJN95J9xwA2zfHm6pYoZgKoI0YJvL8nbHOk90B/7P3QYR6SUiy0Vk+d58Tg3z89zg6tRNLX5mKKaTUsWTGX3LRUHrBJYfPCW3ZWdn07p1a3744Qdee+01vvzyS2o667woSjRSvz589x289BJ88QXUqwfr14dbqpggIqKGROQuoCnQ0t12Y8wUYArYMtSBHNvZ0zgtT9SQp5lnakoyK4a4ryLqfG8wq4C64q6H8CPTPiXnnmu5uWlFXn/9dapVq0aFChWCMr6ihJzERFua4oYbYOrUU5VMjx6FlPDMvGOBYCqCHYDrHai8Y91piMg1wGCgpTHmeBDlcUuOMSef2l1v2IeOntlRzN16d+WfA9HXwB9c/RgmJ5tDP7zPoe9m8+jvvbh5/gSuvvrqkMihKCGnWjUYOdK+3r7dNsR55BHbLjMpIp5vo4pgXrEfgRoiUgWrAO4A7nTdQUQaA5OBfxhj/giiLF45mpXD0/PXnnZDTy2e7La9pKu9390TuTPSqCCzgPz2FHD6MY7v+pX9//cyWXu3ULzOVeRUviLfYytK1JKUBJdeanMQ5syB6dNtQpriN0HzERhjsoE+wEJgHTDXGLNWRIaLyA2O3UYDZwPvichKEZkXLHl8cSAz67ScAn/aSwayrpC7ngK+SkiXS03hr+X/Zvdbj5B79C/KdnqKsjc8RoW0C/M9vqJELRdcYB3Js2fD1q1w8cUwdKhGFuWDoM6hjDELgAV51g1xeX1NMMcvDM7aRJ58CBDYcFFvSsXdrMAYw4D0WvRbX4ushtdS6up7SCh2dkizmBUlYhCB22+HNm2sD2HrVi1ilw/UmOYDTz4EsE/k7jKXCxIu6q9S+euvv3j88ccpVqwYY8eOhX53MHph46juhawoAaNMGXjrLcjOtsurVsHMmbbM9VlnhVe2CCbmS0wEAk/mnkCGi/qTg7BgwQLq1avHlClTSEpKwhhDx8ZpLBnYms0j2/ssoKcocYPTYfz55zbctGFDWLQovDJFMKoI/MTdE7uz/LO/1T694U2p7Nu3j7vuuov27dtTsmRJvvvuO0aPHo3o1FdRvPPII/DVVzbstE0bW8zu4MFwSxVxqGnITzw9sftT7dMfvOUg/Prrr8yfP5+hQ4fyxBNPUKRIkUKPpyhxw1VXWRPRsGG2xHW1ajDwjNJncY0qAj8IlQPWVans2LGDd955B9NoADVq1GDr1q2kpqYGXQZFiUlSUuCFF07VKwJYvhwqVABtxaqmIV+UKp5cYHNPQTDGMHXqVOrWrcuwYcP47bffAFQJKEogaNz4VBG7zp2tUnj77bgPNVVF4IPiRZJCpgR+++032rRpQ69evWjSpAmrV6+mevXqIRlbUeKKxESYN8+WqOjaFdq3h9/ddzKMB9Q05ANvjW3ymwnsjezsbNq0acOff/7J5MmT6dGjBwkJqqcVJWjUqQPffAMTJsCgQbaI3Y8/Qu3a4ZYs5Kgi8IFgb/gdG6edduNPLZ7MkWPZJxPPClpeYsOGDVSrVo2kpCTefPNNqlWrRvnyAa/GrSiKOxIT4cEHoUMH2w0tTovY6SOnDwwwbN7aM0pAHMjMOqkEnOSnvMSJEyd4+umnadCgARMmTACgZcuWqgQUJRxUqQLPPWezkbdtg8qVba9kZ2JajKOKwEHeukKuHDyaxdPz1/rsWAb+lZdYtmwZF198McOGDePWW2+lS5cu+ZJVUZQgUqQING8Ojz9ui9mtWhVuiYJOXCuCUsWTTyaCjb7lItK8lIZwV4nUHb7KS4wbN47LL7+cAwcOMH/+fN555x3KlCmTH7EVRQkm558PH3wA771nS1w3bQpPPRXTkUUx7yNIToCsXPfr3TWYeWjOygKP5S3fwBiDiNCsWTN69uzJCy+8QMmSJQs8lqIoQUQEbrkFWrWC/v2tQojhTP6YnxEkJ7o/RXfrOzZOo5SHFpWpKclnlIBIThRSU5K9lpc4dOgQ//rXv3j44YcBuOKKK5g0aZIqAUWJBkqXhjfftI5kgBUrbPObI0fCKlagiXlFkOluOuBl/dAO9UhOOF3zJycIw26od0ZdodG3XMTKoW09FnybP38+devWZdq0aRQtWhQTw1NLRYlpEh0PgV9+CS+/DA0awH//G16ZAkjMm4b8wTUstGRKMmeoCIde8Leu0N69e+nXrx+zZs2iQYMGfPzxx1xyySUBl1tRlBDTv79ti9mjB7RtC/fcA2PGQKlS4ZasUMT8jOCsIoket328YscZYaEHj2aRkycsNCvH5Kvr2KFDh1iwYAFPP/00y5cvVyWgKLFEixY2kmjQINvrYNKkcEtUaGJ+RmB9Ae7DPp0394KGhbrOJEpzmDp/r2Lm+BFUr16drVu3qh9AUWKVYsVgxAhbxM6ZhPbjj7aI3QUXhFe2AhDziuDgUc9hn/lpKZk3LNQ5k8g8kcWRlZ+ydfHr/GxyueKa9tx345WqBBQlHmjY0P7PyYE774T9+2HsWLj77qiKMop501Cilw+jXGqKX20l3YWFjl64gb/2/M6eWU/w52cTKXphTS68dwJvrztRaJkVRYkyEhNh/nxbzbRbN2jXzvZNjhJiXhHkeInUGZBey21nMFcSRdyGhe748wh75jzFiT82U7rdg5x3+7Mkp15QoMb1iqLEALVrw9dfwyuvwLff2iJ269aFWyq/iHnTUKniyR6zgh+as5K01BRuvjiN/6zadYYZKSU58QwlsG7dOmrUqEHauWdz7Pr+JKVeSFKJ0ie3F6RxvaIoMUJCAvTpc6qInbOSaWYmFC8eXtm8EPMzgmM+HME7Dh5lzrJtDLuhHuNub+Sx//Dx48cZOnQoDRs25NVXX2VAei1KVb3oNCUQqk5miqJEOJUqwTPPnF7EbuRIyPKvVE2oifkZwVEPiWOuZOUahs1by8qhbd3mCSxdupTu3buTkZFB165d6dq1K6VLWwUQqH4EiqLEKEWLQsuWNtx07lyYPt12SosgYl4R+Iun6KIxY8YwYMAAypcvz4IFC2jXrt3JbYFqXK8oSgxz3nm2gN2HH8IDD9iEtMceO1X2OgKIedOQp9pBvsjNtTOJyy+/nN69e7NmzZrTlICiKEq+6NQJMjJsaOkff0SMEoA4UARDO9QjMcH3BXcqjIMHD9K9e3f69esH2CJxEydO5JxzzgmqnIqixAGlSsGMGTB5sl1esQL69oXDh8MqVswrgo6N0yjipemMK4Nemk7dunV58803KVGihBaJUxQlODiL2H39te2ZXL8+LFwYNnFiXhF8vGKHT4dxzt8H+d+7zzDykR4UO+dcli1bxogRI5AImropihKD9Otncw6KF4d//AP++U/488+QixHziuDp+Wt97pN7IpNjW1aQetXdnN/1JZo0aRICyRRFUYArrrAmosGD4d13YcqUkIsQ81FDnpLJsv/6g7/XfMk5l99GcqlypN33OglFi7P7cGTG+SqKEsMUKwbPPgu3336qiN2yZbaI3YUXBn34oM4IROQfIrJBRDaKyEA324uKyBzH9h9EpHIw5QEwJpfDP3/CzukPcGjpXLIP7gIgoajN+tPMYEVRwkaDBlCkiC1i16WLrV30+utB75ccNEUgIonABKAdUBfoLCJ18+zWHThgjKkOjAVeCJY8AFn7t7Pn3UH8+d/XKFquNuW6TyS5VLlTMoNmBiuKEn4SE+GTT6xiuPdeSE+HzZuDNlwwZwTNgI3GmE3GmBPAbODGPPvcCLzpeP0+0EaC5KE1uTnsmTuErL1bKH3dQ5x323CSSp5/crsAXS6rqAliiqJEBjVrwuLFMHEifP89tG8Pub4rJRSEYPoI0oBtLsvbgUs97WOMyRaRQ0BpYJ/rTiLSC+gFULFixQIJIwmJlOnwiC0Sd/a5p21LTUlm2A31VAkoihJZJCTAffdZJbBrl10OAlHhLDbGTAGmADRt2rTAxrJi5eudtizA2NsbqQJQFCWyqVjR/gWJYJqGdgAVXJbLO9a53UdEkoCSwP4gynQaqgQURVGCqwh+BGqISBURKQLcAczLs8884J+O17cAi0yA03m3jGzvdv04VQKKoihAEE1DDpt/H2AhkAjMMMasFZHhwHJjzDxgOvCWiGwE/sQqi4DjSRkoiqIoQfYRGGMWAAvyrBvi8voYcGswZVAURVG8E/MlJhRFURTvqCJQFEWJc1QRKIqixDmqCBRFUeIcibbmKyKyF9hawLeXIU/Wchyg5xwf6DnHB4U550rGmLLuNkSdIigMIrLcGNM03HKEEj3n+EDPOT4I1jmraUhRFCXOUUWgKIoS58SbIgh9D7jwo+ccH+g5xwdBOee48hEoiqIoZxJvMwJFURQlD6oIFEVR4pyYVAQi8g8R2SAiG0VkoJvtRUVkjmP7DyJSOQxiBhQ/zrm/iGSIyGoR+UJEKoVDzkDi65xd9rtZRIyIRH2ooT/nLCK3OT7rtSLybqhlDDR+fLcrisiXIrLC8f2+LhxyBgoRmSEif4jIGg/bRUTGO67HahFpUuhBjTEx9Yctef0bUBUoAqwC6ubZ535gkuP1HcCccMsdgnNuBRR3vL4vHs7ZsV8J4GtgKdA03HKH4HOuAawASjmWzwu33CE45ynAfY7XdYEt4Za7kOd8FdAEWONh+3XA/2GbLF4G/FDYMWNxRtAM2GiM2WSMOQHMBm7Ms8+NwJuO1+8DbUREQihjoPF5zsaYL40xmY7FpdiOcdGMP58zwDPAC8CxUAoXJPw5557ABGPMAQBjzB8hljHQ+HPOBjjH8boksDOE8gUcY8zX2P4snrgRmGksS4FUEbmwMGPGoiJIA7a5LG93rHO7jzEmGzgElA6JdMHBn3N2pTv2iSKa8XnOjilzBWPMJ6EULIj48znXBGqKyBIRWSoi/wiZdMHBn3MeBtwlItux/U/6hka0sJHf37tPoqJ5vRI4ROQuoCnQMtyyBBMRSQBeArqFWZRQk4Q1D12NnfV9LSINjDEHwylUkOkMvGGMGSMil2O7HtY3xuSGW7BoIRZnBDuACi7L5R3r3O4jIknY6eT+kEgXHPw5Z0TkGmAwcIMx5niIZAsWvs65BFAfWCwiW7C21HlR7jD253PeDswzxmQZYzYD/8MqhmjFn3PuDswFMMZ8DxTDFmeLVfz6veeHWFQEPwI1RKSKiBTBOoPn5dlnHvBPx+tbgEXG4YWJUnyes4g0BiZjlUC0243BxzkbYw4ZY8oYYyobYypj/SI3GGOWh0fcgODPd/tj7GwAESmDNRVtCqGMgcafc/4daAMgInWwimBvSKUMLfOAux3RQ5cBh4wxuwpzwJgzDRljskWkD7AQG3EwwxizVkSGA8uNMfOA6djp40asU+aO8ElcePw859HA2cB7Dr/478aYG8ImdCHx85xjCj/PeSHQVkQygBxggDEmame7fp7zI8BUEXkY6zjuFs0PdiIyC6vMyzj8HkOBZABjzCSsH+Q6YCOQCdxT6DGj+HopiqIoASAWTUOKoihKPlBFoCiKEueoIlAURYlzVBEoiqLEOaoIFEVR4hxVBIqiKHGOKgJFKSSO7HRFiVo0j0BR/EBE7gYexSYsrcYmax0DGgNLgJnAJKA4tmzyvcaYAyKyGFs6uSU2gfNeY8yykJ+AonhBZwSK4gMRqQc8CbQ2xlwE9HNsKg9cYYzpj1UEjxtjGgK/YLNBnRQ3xjTC9sGYETLBFcVPVBEoim9aA+8ZY/YBGGOcteLfM8bkiEhJINUY85Vj/ZvY5iJOZjne9zVwjoikhkZsRfEPVQSKUnD+9nO/vPZXtccqEYUqAkXxzSLgVhEpDSAi57puNMYcAg6ISAvHqq7AVy673O5435XYSpGHgi+yoviPRjsoig8c1S6fA74SkRxsT+C8/BOYJCLFsWWfXStCHhORFdgKkvcGXWBFyScaNaQoQcQRNfRolPdBUGIcNQ0piqLEOTojUBRFiXN0RqAoihLnqCJQFEWJc1QRKIqixDmqCBRFUeIcVQSKoihxzv8DEkNRcoGmtMgAAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1046,7 +1046,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1058,7 +1058,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1070,7 +1070,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1082,7 +1082,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABR90lEQVR4nO2dZ3hU1daA35VJaIp0VHovAZQmiJHOFRFRQFGwopQLiIIgCIIIiFSRoqJUFUWaIoLyiQp6uXIpoqFIU6SHIiAgSEvZ3499gpMwk8wkM3Om7Pd58mRmn7bOmXP2OnuttdcSpRQGg8FgiFyi7BbAYDAYDPZiFIHBYDBEOEYRGAwGQ4RjFIHBYDBEOEYRGAwGQ4RjFIHBYDBEOEYRGAwhhGjeE5HTIrLRbnk8QUReEpFZ1ucyIqJEJNpH+94vIi2yuG0TETnsCzlCHaMI0iEij4jIJhE5LyJHReT/ROROH+z3fREZ5SMZfbavcENEvrc6yZx2y+IKEeksIj9kYxd3Av8CSiil6rnZf7J1//4lIptF5N5sHC/bKKVGK6W62nFsEaknIitE5IyI/CkiG0XkKTtkCWaMInBCRPoBk4HRwI1AKWAacL+NYmUbX719BTsiUgZoCCjgPnul8Rulgf1Kqb8zWGedUup6ID8wG1gkIgXSrxSI+8LOe09EGgCrgf8AFYBCQE+glV0yBS1KKfOnZ1fnA84DHTJYJydaURyx/iYDOa1lTYDDQH/gD+Ao8JS1rDuQCFyxjrHcai8GfAqcAPYBz1ntBa19tbG+Xw/sAZ5wty8XsirgGeA3YJ/VNgU4BPwF/AQ0dFp/OLAImAucA7YDdZ2W1wbirWWLgYXAKKfl9wKbgTPA/4Bb3Mj1DvB6urbPgX7W5xeBBOs4u4HmXvyGw4C1wBvAF+mWvY9W6v9nXbe1wE3Wb3ga2AXUclq/KvC9dT7bgfucln0PdHX63hn4Id2172Fd+zPA24BY+7wEJFsynHFzHsWAZcCf1u/ezWrvkm77ES62TS/LdZY8da3f+BPgI+se6Iq+72ej79cEYBTgsLatgO5EzwIngYVO+60GfGPJeBx4yek+Sn+M4cBH1vIyljzd0c/QUeAFp/1GAYOA34FT6HuyoNPyx4ED1rIhwH6ghZvr+APwdgb3SxPcPLPW8tboe/4v9HMz3GlZ6nk8CRy0rs8Qp+W5gQ/Q99ZOYCBwON1vfM2zb1v/Z+fBg+kPuBtIAqIzWGcksB4oChRBd3ivOt1USdY6McA9wAWggLX8fdJ2nFHozngYkAMoB+wFWlrL7wKOWceaCXzitG2afbmRVVkPakEgt9X2GPqtKNq6+Y8Buaxlw9GdzD2AAxgDrLeW5bAevj7WubVHK6JR1vJa1oNU39r2SesBzelCrkbWQyXW9wLARevBqGwtK2YtKwOU9+I33AP0AuqgleWN6a7ZSWtZLvSb4j60cnWgO8DvrHVjrH29ZJ17M7Riqmwt/57MFcEX6DfyUuiH/W5X67o5jzVopZULqGlt38yT7Z2XW79zH0v2fNZvnAi0Rd9/uYHPgOlohVEU2Aj829p+PrqzjbJkudNqz4vuNPtb7XmB+k73UfpjDOdaRTDfOmYN6/xaWMv7oJ+xEugXr+nAfGtZLFoBNrKWvYF+5q5RBEAetMJsmsG1akLGz2wTS74o4Ba0wmub7jxmWud4K3AZqGotH4tWogWsc9mKpQjI5Nm3pf+z68DB9gc8ChzLZJ3fgXucvrdED9NTb5qLOCkSdOd4u/X5fdIqgvrAwXT7Hwy85/T9TWAb+k2tkFN7mn25kVVhdR4ZrHMauNX6PBz41mlZLHDR+tzIkkGclv/AP4rgHSyF6LR8N9DYxTEF/QbVyPreDVhtfa5gXbMWQIyXv9+d6A6osPV9F/B8ums20+n7s8BOp+81sN7Q0ealY0CU0/L5WG+EeKYI7nT6vggY5GpdF+dREt2B5XVqGwO87+H2ndGd2xm04lvPP53scGCN07o3ojuv3E5tnfhHIc4FZqD9EaRbJ97N8dMcw6ktvSKo4rR8PDDb+rwTp1EgcLP1u0ajO84FTsuuQ7+QuFIExdMfx8U6TcjgmXWx/mRgUrrzKOG0fCPQ0fqcpmNHj4xSFUGmz36g/4yP4B9OAYUzsWkWQ78Zp3LAaru6D6VUktP3C2izjitKA8UsJ9YZETmDfgO90WmdGUB1dCdwyrPTSMMh5y8i8oKI7BSRs9bx8gGFnVY5lk72XNb1KAYkKOuOdbHv0kD/dOdSkrTXBgBrHwvQnQnAI8A8a9keoC+64/hDRBaIyDX7cMOTwNdKqZPW94+tNmeOO32+6OJ76m9VDDiklEpxWn4A3bl4Svpr6e4+SE8x4E+l1LlsHHu9Uiq/UqqwUup2pdS3TsvS/24xwFGn3206emQA2pwhwEYR2S4iT1vtJdEvRe44lMEyV+s4P0elgc+c5NmJVow3Wutc3U5pP4m75+I0kIJWJBnh9pkVkfoi8p2InBCRs2hzX+F027v7ndPIyrXXPbNnP6AYRfAP69BvR20zWOcI+kdMpZTV5gkq3fdDaNt9fqe/vEqpewBExIFWBHOBXiJSIYN9ZXpMEWmIfrAfQg9986Ntv+LBfo4CxUXEed2S6c7ltXTnkkcpNd/N/uYDD4pIafTb0adXBVbqY6XUnejrrIBxmQknIrmt82osIsdE5BjwPHCriNzqwfml5whQUkScn49S6FERwN9o00MqN3mx78x+uyNAQRHJ6+bY2SW9Mr+MHkWl/m43KKWqASiljimluimligH/BqZZ9+EhtDnDk2O4w/n+cX6ODgGt0t1LuZRSCej78Op2IpIHbeq8VgClLqCf6Qc8kMUdH6N9NSWVUvmAd/HsecGStYTT9/TPi9tn3w6MIrBQSp1FDz3fFpG2IpJHRGJEpJWIjLdWmw8MFZEiIlLYWv8jDw9xnLQPz0bgnIi8KCK5RcQhItVF5DZr+UvoB+ppYAIw11IOrvblCXnRJoMTQLSIDANu8HDbdei3st4iEi0i9wPOoYszgR7WG5SIyHUi0jpdZ3YVpVQ82mwxC1iplDoDICKVRaSZFfp5Cf2WnuJqH+loa8kXi7ap10Q7Zv+L9gF4ywb0291A6x5oArRBj2RAO8XbW/dIBbQT11OOAyVEJIerhUqpQ2jf0xgRySUit1j79/Q+8xil1FHga2CiiNwgIlEiUl5EGgOISAcRSe3MTqPvxxS0/+NmEekrIjlFJK+I1Pfy8C9b168a8BQ6+AB0Z/ua9ZKA9azdby37BLhXRO60rt9IMu7DBgKdRWSAiBSy9neriCzIYBtn8qJHZ5dEpB569Oopi4DBIlJARIoDvZ2WZfbsBxyjCJxQSk0E+gFD0R3mIfQPuNRaZRSwCe342Qb8bLV5wmwg1hoKLlVKJaMjbWqinZapHWM+EaljyfGEtd449EM4yNW+PDz+SuAr4Ff0UPwSng3hUUpdQTuIu6Btz4+hO4PL1vJNaFv/W+gOYw/aVp0RH6N9AR87teVEO9lO8o+jfDCAiDwqItvd7OtJtH31oPUWe0wpdcyS51FvQxit822DDjM8iXbcPqGU2mWtMgltmz6OjgyZ58XuV6OjkI6JyEk363RC26CPoJ25r6Qz7/iSJ9AOyx3o3+4T/jGn3AZsEJHz6DfjPkqpvZbZ6l/oa3QMHR3V1Mvj/gd9n6xCR5F9bbVPsY71tYicQ/s46gMopbajI+E+Rr9xn0ZH/bhEKfU/tKO/GbBXRP5Ej7JXeChjL2CkJccwdOfuKSMt2fYB36Kva+rz4vbZ92L/PiU1csNg8AoR2QC8q5R6z25ZDIZgR0R6oh3Jje2WxRVmRGDwCBFpLCI3WaahJ9HhdF/ZLZfBEIyIyM0iEmeZ2yqjQ20/s1sud0TEjFODT6iMHhpfhw6Ne9CyMRsMhmvJgY7AKos2py5AmxiDEmMaMhgMhgjHmIYMBoMhwgk501DhwoVVmTJl7BbDYDAYQoqffvrppFKqiKtlIacIypQpw6ZNm+wWw2AwGEIKETngbpkxDRkMBkOEYxSBwWAwRDhGERgMBkOEYxSBwWAwRDhGERgMBkOE4zdFICJzROQPEfnFzXIRkakiskdEtopIbX/JYjAYDAb3+HNE8D66/KM7WgEVrb/u6CpXBoPBYAgwflMESqk16MLW7rgfmKs064H8IpJZNaHs8fvvcOmSXw9hMBgMvubvv/9m//79ftu/nT6C4qTNh38YN+X4RKS7iGwSkU0nTpzI2tGSkqB1a6hZE9auzdo+DAaDIcCsXr2aW265hfbt25OS4kmdJu8JCWexUmqGUqquUqpukSIuZ0hnTnQ0TJmiRwQNG8Jzz8H5874V1GAwGHzEmTNn6NatG82bNycqKopJkyYRFeWfLttORZBA2jqeJfBdXVbXtGwJv/wCvXvDW29B9eqwb59fD2kwGAzekpyczB133MGcOXMYOHAgW7dupXFj/9W0sTPX0DJ0DdwF6FJ0ZwOS3/7662HqVHj4YXj3XShVSrcrBeJpXWqDwWDwPadOnaJgwYI4HA5ee+01SpYsSd26df1+XH+Gj85HFz2vLCKHRaSLiPQQkR7WKivQBU72oIuf9/KXLC6Ji4MPPwSHA06cgFtvhSVLAiqCwWAwACil+Oijj6hUqRKzZs0CoF27dgFRAuDHEYFSqlMmyxW6ELX9nDmjfQgPPKD/3noLbrrJbqkMBkMEcOjQIXr06MGKFSu4/fbbiYuLC7gMIeEs9jsVK8KGDTBmDHzxBcTGwvvva3ORwWAw+In58+dTrVo1vv/+eyZPnswPP/xAbGxswOUwiiCVmBgYNAi2bIFq1WD5cuMzMBgMfqVAgQLUr1+fX375hT59+uBwOGyRI+RqFtetW1f5vTBNSgr8/TfkzQu//gorV8Izz4CfQrcMBkNkkJSUxKRJk7hy5QpDhgwBtH9AAvDSKSI/KaVcOh1Mz+aKqCitBECbiJ57Ts892LnTVrEMBkPosmXLFm6//far4aCpL+GBUAKZYRRBZrz2GsydC7t26VnJo0dDYqLdUhkMhhDh8uXLvPzyy9StW5dDhw6xePFiFixYEBQKIBWjCDJDBB5/HHbsgLZtYcgQeOMNu6UyGAwhwm+//ca4ceN45JFH2LFjBw8++GBQKQEIweL1tnHjjbBwoVYKTZvqtj17oHhxyJ3bXtkMBkNQcf78eT7//HMeffRRqlevzq5duyhXrpzdYrnFjAi85d574brr0iax++EHu6UyGAxBwjfffEONGjV4/PHH2Wn5FYNZCUCEKIKl8QnEjV1N2UFfEjd2NUvjfZDSKDoa3n4brlzRjuTeveHcuezv12AwhCSnT5+mS5cu3HXXXeTIkYP//Oc/VK1a1W6xPCLsFcHS+AQGL9lGwpmLKCDhzEUGL9nmG2XQogVs2wZ9+sC0aXr+wd692d+vwWAIKZKTk4mLi+ODDz5g8ODBbNmyhYYNG9otlseEvY9gwsrdXExMTtN2MTGZCSt307aWy/IH3nH99TB5sk5i9847ULq0bk9J8dm8g6XxCUxYuZsjZy5SLH9uBrSs7BvZDQZDtjh58uTVJHGjR4+mVKlS1K4delV3w35EcOTMRa/as0yDBjrMNDWJXY0asGhRttNU+HVEYzAYsoRSirlz56ZJEte2bduQVAIQAYqgWH7XET3u2n3C2bM6kujhh6F9ezhyJMu7ymhEYzAYAs+BAwdo1aoVTz75JFWrVqVRo0Z2i5Rtwl4RDGhZmdwxafN35I5xMKBlZf8dtEIFWL8exo+Hr77SSexmz87S6CC7Ixq/OMoNhgjlo48+onr16vzwww+8+eab/Pe//6VKlSp2i5Vtwt5HkGpLD7iNPToaBgzQk9C6dtUKoUsXr3dTLH9uElx0+pmNaJbGJzB82XbOXPxnFnSqWQnw6PyNb8JgSEuRIkWIi4tj+vTplE71B4YBEZ10LmAdXUoKXLigHcu7d2ul0Lu39id4IOPgJdvSmIdyxzgY076GW1ldbeNM8fy5WTuomc+PazCEG4mJiUycOJHExERefvllIHBJ4nyNSTrngoA6YaOitBIAXRWtb1+4806dtiIT2tYqzpj2NSiePzeC7sQz64xd+RWc8cSsZHwThkgnPj6e+vXrM3jwYHbs2BFUSeJ8TdibhtyRWUfnt5HCq69C1ap67kGtWjB0KLz4IuTI4XaTtrWKe3X8zDp6TxzlAYu2MhiCjEuXLjFy5EjGjx9P4cKF+fTTT2nfvr3dYvmViB0RuOvQUkcGfhspiMCjj+rRQPv2MGwYTJrkm31bZNTRe+ootyXaymAIAvbs2cPrr7/OE088wc6dO8NeCUAEKwJ3HZpDJDAmkaJFYf58+PJL7S8AXQTnwoVs79pVpBRAgTwxLs1KriKLbIm2Mhhs4vz583z44YcAVK9end27dzNnzhwKFChgs2SBISKcxa6cwoBLZ6g727oA+8a2zrLcmZKUpFNUpKTArFnQuHG2duepIzwjpzDYEG1lMASYlStX0r17dw4dOsT27dtDJj+Qt2TkLA57RbA0PoEBi7eQmPLPecZECRM63Apc29FNWLnbZbimJ5E22Wb1aujWTecr6tEDxo2DG27w6yHjxq6273wNBhs5deoU/fr1Y+7cuVSpUoVZs2YRFxdnt1h+IyNFEPbO4uHLtqdRAgCJKYrhy7az+ZW7XL7hunpDDohJpFkzncQu1W/wxRfwn/+AH1PYGqewIRJJTRK3Z88ehgwZwtChQ8mVK5fdYtlG2CsC5wlVnrTbNgEtlTx54PXX4aGH4N13/ZLEzpmsTlgzGEKREydOUKhQIRwOB+PGjaN06dLUrFnTbrFsJ2KdxRnRtlZx1g5qxr6xrVk7qJk9dvF69WDOHD3p7I8/oHp1WLAgS2kqMkozYZzChkhAKcV7771HpUqVmDlzJgD333+/UQIWRhFkg4Dl8Tl3Tk9I69RJp6xI8Pw4mU2cy8qENYMhlNi/fz8tW7bk6aefpkaNGjRNLTVruErYm4YEcPUOnd25gemjbbzN4+MV5cvDunUwZYqegBYbq81HXbvqeQkZ4Ek9Bm8nrBkMocKHH35Iz549ERGmTZvGv//9b6L8YGINdcL+irgzpGQ3VirgKRgcDujXTzuT69SBr7/OVAmAcQYbIpsbb7yRRo0asX37dnr27GmUgBvCfkTgL2zrYMuXh1Wr4O+/9fddu/SktL59XSaxM85gQySRmJjI+PHjSU5OZtiwYdx1113cdddddosV9IS9eswT4/oU3bV7iq0pGET+SWI3bx688IKukPbLL9esapzBhkjh559/5rbbbmPo0KHs3r2bUJsjZSdhrwhyRLtO9eyu3VOCpoMdOVKnqti3D2rXhuHD4cqVq4uNM9gQ7ly8eJFBgwZRr149jh8/zmeffca8efPCMkuov/CraUhE7gamAA5gllJqbLrlpYAPgPzWOoOUUit8KcNZN/MF3LV7iu3zDVIRgY4doUULbR4aMQJy5YJBg9LIajp+Q7iyd+9e3njjDTp37syECRMiJj+QL/GbIhARB/A28C/gMPCjiCxTSjkn4R8KLFJKvSMiscAKoIwv5fCnjTyoOtjCheGjj+Dxx6FhQ922ezeULKknqRkMYcRff/3FkiVL6Ny5M9WqVeO3334Lq4phgcafpqF6wB6l1F6l1BVgAXB/unUUkJpMJx+Q9SrvbggaE06gaNlSd/xJSXDffVCjBnz3nd1SGQw+Y8WKFVSvXp0uXbqwc+dOAKMEsok/FUFx4JDT98NWmzPDgcdE5DB6NPCsqx2JSHcR2SQim06cOOGVEP6wkYdEQfjoaJgxQ6elaNYMuneHs2ftlspgyDInT57k8ccfp3Xr1uTNm5e1a9eGbabQQOO37KMi8iBwt1Kqq/X9caC+Uqq30zr9LBkmikgDYDZQXSmV4m6/vqxZnBVCrpbvhQvagTxxItx0E6xZo0NQDYYQIjk5mdjYWPbu3ctLL73ESy+9RM6cOe0WK6Swq2ZxAlDS6XsJq82ZLsAiAKXUOiAXUNiPMmWbkKvlmycPjB8PGzZAq1ZQpoxuT3Graw2GoOH48eOkpKTgcDh4/fXX+emnnxgxYoRRAj7Gn4rgR6CiiJQVkRxAR2BZunUOAs0BRKQqWhF4Z/sJMCE7U7duXV3wJjWJXWwsfPxxlpLYGQz+RinF7NmzqVy5MjNmzACgTZs23HLLLTZLFp74TREopZKA3sBKYCc6Omi7iIwUkfus1foD3URkCzAf6KyCfBZIWNTyPX8eChTQtZPbtIFDhzLfxmAIEHv37qVFixZ07dqVmjVr0qJFC7tFCnv8OqFMKbVCKVVJKVVeKfWa1TZMKbXM+rxDKRWnlLpVKVVTKfW1P+XxBWERhVSuHPzwA0yerCOKqlXTtQ+CWwcbIoAPPviAGjVq8OOPP/Luu++yevVqKlSoYLdYYU/YzywG30b5hM1MXYcD+vTRSezq1dMKwczENNhMsWLFaNasGTt27DCZQgNIRNQs9iTKx9Ni72GJUnDxonYs79oFy5fD88/rEFQi/NoY/MqVK1cYO3YsKSkpDB8+3G5xwhq7ooaCAk+ifDIr3hL2iPwz+/jjj2HgQJ3EbutWc20MfuPHH3+kTp06vPLKK+zdu9ckibORsFcErtJLpG8PuZBQfzJiBCxaBAcPQp06nH5hEMkXL6VZJWKvjcEnXLhwgRdeeIHbb7+d06dPs2zZMubOnWuSxNlI2CsCh5uby7k9ZENC/YEIdOgAO3ZAp048tfojumxaes1qEXltDD5h3759vPnmm3Tr1o3t27fTpk0bu0WKeMK+ME2ym+Gmc7sp3uKCQoVg7lz6xlTnq/x6JnL5U4c4krcIF3PkiuxrY/Cas2fPsmTJEp566imqVavGnj17KFmyZOYbGgJC2I8IirvpsJzbwyIk1E806f0okuc6HCnJzPz0VVbOeYZmh7aaa2PwmC+//JJq1arRtWtXdu3aBWCUQJAR9orAk04+bEJC/UDqtbmp4PUMbvUcREcz5+OXaPvWMDh92m7xDEHMiRMnePTRR7n33nspUKAA69ato0qVKnaLZXBB2IePggl/9CkXL+qqaBMmQJEi8N//gpnwY0hHapK4ffv2MXToUAYNGkSOHDnsFiuiySh8NCIUgcEP/Pyzno38zjt6clpysv5viGiOHTtG0aJFiYqK4osvvqBMmTJUr17dbrEMRPg8AoOfqF1b1ztwOOD4cahaFT780KSpiFBSUlKYPn06lSpVYvr06QDce++9RgmECEYRGLLPhQvaTPTEE3DPPXoOgiFi2LNnD82bN6dHjx7cdttttGzZ0m6RDF5iFIEh+5Qtq30FU6fq/9Wqwdtvm9FBBPDee+9Ro0YNfv75Z2bOnMm3335LuXLl7BbL4CVGERh8Q1QUPPss/PIL3HGHroRmZoqGPaVKlaJly5bs2LGDrl27mtnBIUpEOIszixoyUUU+xjmJ3c6dsGwZ9O9/NYmdIXS5fPkyY8aMISUlhZEjR9otjsELItpZnFnSNJNUzQ84J7FbuBAGDYL69WHzZlvFMmSPDRs2UKdOHUaMGMHBgwdNkrgwIuwVQWYJ5UzCuX/wZd2GqwwfDp98AgkJulzmkCFw6VKmmxmCh7///pt+/frRoEEDzp49yxdffMH7779vzEBhRNiP1TNLKGcSzmnS121IHRkB2TeTPfAANG0KL7wAo0dD3rx6lJCJPMZcFxwcOHCAadOm0aNHD8aOHcsNN9xgt0gGHxP2IwJ3ydEUEDd2Nflyx3i1Xbji95FRwYIwZw6sWgXPPafbdu7U9ZPTYcx19nPmzBlmzZoFQGxsLHv27GHatGlGCYQpYa8IXOUaSiXhzEX+vpJETFTaIW4kJpwL2MioWTPtP0hKgvvvh+rV4eu0paqNuc5ePv/8c2JjY+nRo8fVJHElSpSwWSqDPwl7ReCcUM4VicmK63NFR3zCOXcjIL+NjKKj4b33IHduaNkSnnoK/vwTMOY6u/jjjz/o2LEjbdu2pUiRIqxfv94kiYsQwt5HALDpwJ8cO+veQXnmQiLxw+4KoETBx4CWlV3WdvbryCguDuLjYdQoGDsW/u//4IcfTH0IG0hOTiYuLo6DBw8yatQoBg4cSEyMa7OpIfwI+xHB0KXb+Gj9QbcFasB0MGBjKu5cubQi2LQJ2raFcuUY0LIy16Wz5kWiuS4QHDlyhJSUFBwOB1OmTCE+Pp4hQ4YYJRBhhP2EsvKDV2SoBHLHOILKFGSiZYDjxzlftz5Tbn+IWeUaUaxAnsi8Dn4kNUnciy++yNixY+nVq5fdIhn8TEYTysLeNJSREigeZB2tX0M4Q4mLF7m+TEmGfDKBIf/arLOclomg8/czv/76K926dWPNmjW0aNGCVq1a2S2SwWbC3jSUUfH6tYOaBVUHa6JlLMqUgf/8RyeuW7dORxZNnWqS2PmA2bNnc+utt7J161bmzJnD119/TdmyZe0Wy2AzYa8IOtV3XRvVXbudmGgZJ6KioFcvncSuYUOtEMxM1mxTpkwZWrVqxY4dO3jqqafM7GADEAGmoVFtawAwf8MhkpXCIUKn+iWvtgcTJlrGBaVLw4oV/6Sl2LEDPvsMBg4E49DMlMuXL/Pqq68CMGrUKJo3b07z5s1tlsoQbIS9IgCtDIKx40+PLSGcoYCInm8AsHixzl+0eLGeqVy7tq2iBTP/+9//6NKlC7t27eLpp59GKWVGAAaXhL1pKJSwLYQzlHjlFT0iOH4c6tXTOYsuRqDpLAPOnz9Pnz59uPPOO7lw4QJfffUVs2fPNkrA4Ba/ho+KyN3AFMABzFJKjXWxzkPAcHT6ny1KqUcy2qcpXm8A4PRpGDAAZs+GMWMyTWIXSezYsYPatWvTrVs3Ro8eTd68ee0WyRAEZBQ+6jdFICIO4FfgX8Bh4Eegk1Jqh9M6FYFFQDOl1GkRKaqU+iOj/RpFYEjD99/rWge5c8P27VCqlM5uGmGcPn2axYsX0717d0BPFCtWrJjNUhmCCbsK09QD9iil9iqlrgALgPvTrdMNeFspdRogMyWQVfySZ98QHDRpopVAUpKemVytmk5VEUF89tlnxMbG0qtXL3bv1qHGRgkYvMGfiqA4cMjp+2GrzZlKQCURWSsi6y1T0jWISHcR2SQim06cOOGVECalcYQQHQ1z58L118M998ATT8CpU3ZL5VeOHTtGhw4daN++PTfddBMbN26kcuUIDywwZAm7ncXRQEWgCdAJmCki+dOvpJSaoZSqq5SqW6RIEa8OYCZpRRANGugkdi+/DPPnQ9Wq8NtvdkvlF5KTk2nYsCHLly9n9OjRbNy4kdomgsqQRfwZPpoAOM/aKmG1OXMY2KCUSgT2icivaMXwo6+EMJO0IoycOWHkSHjwQXj3XShfXrcnJelRQ4hz+PBhihUrhsPhYOrUqZQtW9akijZkG3+OCH4EKopIWRHJAXQElqVbZyl6NICIFEabivb6UoiA59k3BAe33ALTpukZyseOQaVKOsIoRNNUpKSk8Oabb1KlShXeeecdAFq1amWUgMEnePSKJCJ5gP5AKaVUNyvap7JS6gt32yilkkSkN7ASHT46Rym1XURGApuUUsusZXeJyA4gGRiglPKpYddM0jJw+bKOJuraVZuMZsyAcuXslspjdu3aRdeuXVm7di0tW7bk3nvvtVukoCUxMZHDhw9z6ZL7+iPhTq5cuShRooRXqcQ9Ch8VkYXAT8ATSqnqlmL4n1KqZlaFzSpZCR81qZ0NpKTAzJl67kFyMrz2GvTpE/T5i2bNmkXv3r3JkycPkydP5vHHHzcTwzJg37595M2bl0KFCkXkdVJKcerUKc6dO3dNMkFfpKEur5R6WEQ6WQe7ICF0ldvWKm46/jDGI0UfFQX//je0bg09esCGDUGvBADKly9PmzZteOutt7jxxhvtFifouXTpEmXKlIlIJQAgIhQqVAhvoys9VQRXRCQ3evYvIlIeuOydiAaD7/G6hkOJErB8uTYXgU5i9+mn8OKLkCNHoMR2y6VLlxg5ciQAo0ePpmnTpjRt2tRmqUKLSFUCqWTl/D11Fr8CfAWUFJF5wCpgoNdHMxh8TJbCg0V0iUzQSmDYMKhbF370WbBalli7di01a9ZkzJgxnDhxglCrHmgIXTxSBEqpb4D2QGdgPlBXKfW9/8QyGDwj2+HBL78Mn3+uJ5/dfrtOb33hgg8lzJxz587x7LPP0rBhQy5fvszKlSuZOXNmxL/ZGgKHR4pARGoDpYGjwBGglIiUF5GQCMweunQb5QevoMygLyk/eAVDl26zWyTbCLd0Gz4JD77vPm0i6tIFJkyAKVN8JJ1nHD58mFmzZvHss8+ybds27rrrroAe3+A7hg0bxuTJk69+HzJkCFMyuZ/Onj1L5cqVr6YH6dSpEzNnzvSnmNfgaUc+DagNbAUEqA5sB/KJSE+l1Nd+ki/bDF26jY/WH7z6PVmpq99DoUaBLwnHmsg+Cw/Ol0+HlT72GNx2m2775RcoWVIv8zGnTp1i0aJF9OzZk6pVq7J3715uvvlmnx8n0mnSpMk1bQ899BC9evXiwoUL3HPPPdcs79y5M507d+bkyZM8+OCDaZZ9//33GR7v6aefpn379vTt25eUlBQWLFjA6tWrqVmzpsv1P/74Y2JjY3nrrbfo3Lkzffr04fTp03Tr1s3TU/QJniqCI0AXpdR2ABGJBUai/QRLgKBVBPM2HHTb7mtFEOxhqhnZ04NJTm9Ildtn171RI/0/ORnatdO1DqZP19FGPkApxaeffsozzzzDn3/+SbNmzahcubJRAmFCmTJlKFSoEPHx8Rw/fpxatWpRunRpNm/enOF2//rXv1i8eDHPPPMMW7ZsCYywTniqCCqlKgEApdQOEamilNob7HZMd/42X/vhQuFtO1zTbfglPNjhgHnztLno3nvhkUdg8mTwMteVM0ePHuWZZ57hs88+o06dOnz99dcmSZyfyegNPk+ePBkuL1y4cKYjAFd07dqV999/n2PHjvH0009z7tw5GjZs6HLd1BFBSkoKO3fuJE+ePJw+fZoSJUp4fdzs4Kki2C4i76BTSQM8DOwQkZxAol8kCyI8edPPztt2oEYSpiayl9SrBz/9pAvfvPYafP01/O9/ULGi17tKTRKXkJDA+PHjef7554kOg9xHhmtp164dw4YNIzExkY8//hiHw5HpiGDSpElUrVqV0aNH89RTT7Fu3TqvZgZnF0/vxM5AL6Cv9X0t8AJaCQR1kHOemCguJKa4bPcET9/0s/q2nd2RhDdKxKTbyAI5cujymA88oE1EqUnsEhPBgwf10KFDFC9eHIfDwdtvv03ZsmWpVKmSn4U22EmOHDlo2rQp+fPnx+FwZLr+7t27mTVrFhs3biRv3rw0atSIUaNGMWLEiABIq/E0fPSiUmqiUqqd9fe6UuqCUipFKXXe30Jmh/Z1XA+x3LWnx9M49axGr2QnTba3tRZMTeRsUL06vPlm2iR2M2e6tTEmJyczderUNEniWrZsaZRABJCSksL69evp0qWLR+tXrlyZnTt3Xi0p+sYbbwRUCYDn4aNxIvKNiPwqIntT//wtnC/4bpfrqdbu2tPj6Zv+gJaVyR2TVvt78radHbt9VpRI21rFWTuoGfvGtmbtoGZGCWSFK1egbFno3h2aN4fff0+zeOfOnTRs2JA+ffrQuHFj2rRpY5OghkCzY8cOKlSoQPPmzamYBROiXXg6s3g28AZwJ3Cb01/Qk10Hqadv+ll923a3/yiRTGP9w9X5G/SUKgWrVulw059+gho14I03QClmzJhBzZo1+fXXX/nwww/58ssvKVWqlN0SGwJEbGwse/fuZeLEiXaL4hWe+gjOKqVCshBsdh2k3tjVsxK94mr/oOc7QMY+A+P8tTFkVwS6ddNlMXv21ApBhIoVK9KuXTumTp1K0aJF/S+HweADPB0RfCciE0SkgYjUTv3zq2Q+Iqsmm1T8bVdPv3+Hi3Bcd+ae7J5bqBMM9agvFizIi1WqMNSaB9C0SBEWVKlC0fz5AyaDwZBdPB0R1Lf+O+eyVkAz34rje3wx4cjfaayd91920Jcu13Fl7vH5ZKoQw+4JcmvWrKFr16789ttv9OjRA6UU8vnnMGIEfPIJzJmjQ1ANhiDHI0WglArqENFwwltzTyTXWrDLR/LXX38xaNAg3nnnHcqVK8eqVato1sx6JxoyBGrW1DUPGjSAvn11DeXrrvOrTAZDdvC4ZrGItBaRgSIyLPXPn4L5imAwH3hDpJt7vMGuetRHjhzh/fffp1+/fmzduvUfJZBK69awfbsuhPPGGzB1ql/lMYQ+b731FhUqVEBEOHnyZMCP72n46Lvo2cTPopPOdUBnIw16shOnbwcm1t9zAqk0T548ybRp0wCoUqUK+/btY+LEiVzn7k3/hhtg2jT44Qc9KgDYtg3OnvW5bIbQJy4ujm+//ZbSpe3pVj31EdyhlLpFRLYqpUaIyEQgJKKIvDUfBEPiuEg293hDIHwkSikWLVrEs88+y5kzZ2jRogWVKlXyvGxkXJz+n5wM7dvrWgfvvgtmbkFYMmzYMAoWLEhfS/kPGTKEokWL0qdPnwy3q1WrVqb7Pnv2LPXq1WPZsmVUrlyZTp060axZM59kKvVUEaT2mhdEpBhwCgiJdIne2NxDIXGcIS3+VJpHjhyhZ8+eLFu2jLp167Jq1aqszwx2OGD+fHj6aV3/oGNHXffAhJj6FxdpqHnoIejVSytlF2mo6dxZ/508CenSUOOnNNSekC9fPr+lq/ZUEXwhIvmBCcDP6IihWT6RwM94Mw/A7iiU9ATD6CRSSU5OplGjRiQkJPD666/Tp0+f7CeJq1sXNm2C8ePh1Vfhm290EjuTdiJsyGoaak/xV7pqT6OGXrU+fioiXwC5lFIhYez0xnwQTDN1zejEHg4cOECJEiVwOBxMmzaNcuXKUaFCBd8dIEcOGDpUm4mmT4fUfXuYxM7gJRm9wefJk/HywoUzHQG4IitpqN3RsmVLjh8/Tt26dZk1a5bf0lWLpwWyReQOoAxOykMpNdcnUnhB3bp11aZNm/yy77ixq12akYrnz83aQYGdMhFMskQCycnJTJkyhaFDhzJ+/Hh69+4duIMfOQK3387mx3rS+/rbSPjrshkBZpGdO3dStWpVW2W4cuUKNWrUIDExkd9++82jDKSplClThk2bNlG4cGGXyydOnMju3bt5/PHHef75592mq3Z1HUTkJ6VU3WtWxvOooQ+B10mba8jlDoMRT+v0BlPoZjCNTsKdX375hTvuuIP+/fvTvHlz2rZtG1gBkpP5o1gZao55iYnvPk/pPxOCPszZ4J7UNNQPPfSQx0pg6tSplChRgsOHD3PLLbfQtWvXa9ZJTVc9ceJEGjZseDVdtS/waEQgIjuBWOXp8MGPeDsiSG9iAd25uwvJDBa7vBkRBIZ3332X5557jnz58jF16lQ6duyIHVX34sas4o7/Lmfo6lnkTE5k0p2PML3eAxQvkMf83l4QDCOClJQUateuzeLFi23LQOrtiMBT79cvwE3A0eyJF3i8dQAHS+imKSLjX5RSiAhVq1alQ4cOTJ48mSLZKEOZXY6cvcTiW/7F9+Xq8Oo371Dlj/0gYkaAIcaOHTu49957adeuXUiloc5QEYjIcnSEUF50acqNwOXU5Uqp+/wrXvZx9VadUXuwEOl5hPzFhQsXGDZsGA6Hg3HjxtG4cWMaN25st1hXw5xPXF+QHm1fIkdyEgBxl47BsGE6dUXOnDZLaciM1DTUoUZmI4JlwI3Af9O1NyRERgcOkaspndO3uyJYTEMQPKOTcOH777+na9eu/P777/Tq1evqqCAYSDMCFOFKdAy5Yxy8dP43eHWcTmI3e7bOX2Qw+JjMFMH9wGCl1DbnRhH5ExiNLlgT1LhSAu7aMwvZDCYl4WvC+dzOnj3LwIEDmTFjBuXLl2f16tU0beo6j6Jd18HdCDC21t3QurHOWxQXB889B6+9ZpLYZUAwKXg7yIorNzNFcGN6JWAdaJuIlPH6aDZQ3M3M4uIuZhZnlpcoXOP6w33OwtGjR/noo4944YUXGDFiBHny5HG5nt3Xwe0IsFUrncRu8GA9G/mmm2DQIL/LE4rkypWLU6dOUahQoYhUBkopTp06Ra5cubzaLsOoIRH5TSnl0uMhInuUUhnOtBGRu4EpgAOYpZQa62a9B4BPgNuUUhmGBPkzaqjsoC9xdTUE96kqwiGKJxwjlE6cOMGCBQt49tlnr37PzBkcEtdh3TqoVQty5YItW3TZzAIF7JYqaEhMTOTw4cNcunTJblFsI1euXJQoUeKa+QXZiRraJCLdlFIz0+2wK/BTRhuKiAN4G/gXcBj4UUSWKaV2pFsvL9AH2JCJLFmiba3ibDrwJ/M3HCJZKRwiPFDH9ZtXRnmJwjmuP5zOTSnF/Pnzee655/jrr79o2bIllSpV8igiKCSuQ6qPIDlZ58E5f15nOW3Xzl65goSYmBjKli1rtxghR2YTyvoCT4nI9yIy0fr7D9AF3XlnRD1gj1Jqr1LqCrAA7XNIz6vAOMAvKnxpfAILNx666hNIVoqFGw+5nKiT0YQyu3LfB4JwObdDhw7Rpk0bHn30USpUqEB8fLxXSeJC6jo4HLBwoTYTtW8PHTrAsWN2S2UIUTJUBEqp40qpO4ARwH7rb4RSqoFSKrO7rjhwyOn7YavtKlbd45JKKdf1Gf9Zr7uIbBKRTSdOnMjksGkZvmw7iSlpDT6JKYrhy7Zfs25GtQCCadaxrwmHc0tKSqJJkyZ89913TJo0ibVr11KtWjWv9hFy16F2bdi4EUaPhuXLITYWfv3VbqkMIYinSee+A77z5YFFJAp4A+jswfFnADNA+wi8Oc6Zi4letbtz2IVzXH8on9v+/fspWbIk0dHRTJ8+nXLlylGuXLks7Sskr0NMjHYit2sHM2b8k8TuyhWd4M5g8ACPk855vWORBsBwpVRL6/tgAKXUGOt7PuB34Ly1yU3An8B9GTmMvXUWl3FTDB5g/9jWHu/HEFwkJSUxefJkXn75ZcaPH3/VKWxAJ7GrX19HFvXsCVEeV6Q1hDHZTjqXRX4EKopIWRHJAXRET1ADQCl1VilVWClVRilVBlhPJkrAYADYunUrDRo0YMCAAbRs2ZIHHnjAbpGCi5QUbSbq3RsaN4bdwVmW1RA8+E0RKKWSgN7ASmAnsEgptV1ERopIwFJT5IlxfYru2g3BzbRp06hTpw4HDhxg4cKFfPbZZxQrVsxusYKLEiXgq6/g/ff1/INbb4WxY8H+nJGGICWbJZcyRim1AliRrm2Ym3Wb+EOGHNEOLiSmuGw3hA6ps0WrV69Ox44dmTRpktuc7QZABJ58Elq21COD7dt1m8HgAr8qgmDgrBunsLt2Q3Dx999/M3ToUKKjo5kwYQKNGjWiUaNGdosVOtx0k85TdOWK/r51KyxYoBPZeTn71BC+hL19JKRiww1pWLVqFTVq1GDy5Mlcvnw5SzlUDBapEUQrVsCYMVCzJqxda6tIhuAh7BWBq9hwgAtXkkz1pyDlzJkzdO3alRYtWhAdHc2aNWuYOnVq2OeO8bSSXrYYNAhWroRLl6BhQ3j2WTh3zvfHMYQUYa8IUieJ5c+dNu/G6QuJphRgkHL8+HEWLFjAiy++yJYtW9wW/g4nUnNiJZy5iAL/lqq86y745RetBN5+G956y/fHMIQUYa8IQCuD63Je6w5xzixqsJfjx48zZcoUACpXrsz+/fsZO3YsuXNHhgkvs8y3Puf663Um03Xr4PnnddvmzfDnn/45niGoiQhFACGSUCwCUUrx0UcfERsby8CBA/ntt98AIi4iyLb7s3597TROTtb5imJj4dNP/XtMQ9ARMYrAnXM4f54Yl+0G/3Pw4EFat27N448/TuXKldm8efPVOq8BsZcHEbYHNTgcsHgxFC+us5o+8AAcDYkihAYfEDGKYEDLysQ4rnU2nr+UudM40jqlQJCaJC7VEfzf//6XqlWrAgG2lwcJQZHwrmZN2LBBTz778ks9OjCzkiMCv+Ua8hfe5hpypuaIr10mm8uo8Ig3hW0M/+Cu5OPevXspXbo0DoeDVatWUb58ecqUKZNmW7sKxNhdrtPu46fh119h+nSYMEHnKrp8GXLmtEcWg0/IKNdQRCmCjCqQ7XOTgC4kqlYFGa6UZy4H1Du/lkXT32D8+PE899xzbrfPyu+UXYzCz4CEBKhXD158EZ55RpuRDCFHdiqUhRUZVSBzRzA6mYPqzdEF6SNgrhzfy9H/m8Lu47/Trl07OnTokOH2WfmdsktGUTvBdG1TCeg9IKLzFfXpo2clz54NlhnPEB5EjI8AsmaHtd2Jl45QsJ87K8m/flrO0bnPk3T+FEXaDmbJkiXcfPPNGW5vh708GBW+OwJ+DxQrpn0GH36ofQY1a8KoUSaJXRgREYpg6NJtlB+8gr4LN3MpKZk8MVHXVCBzR1A48ZwIeLx5FiiWP/fVdBA5ipblutgmFOvyDhXrt8h029Q33YuJyTismcSe/E6+kNmbdjux5R4Qgcceg507oW1b7UMI85nekUTYm4aGLt3GR+sPXv2uFFxITOGx20sxqm0NIONhdrBVrQr2N9fz589TYOs8du07Q97GT5OrZHVylazukfJMb6dPVurqdv6+3gNaVnbpIwjGMpW+uAeybFoqWlTXSk60gi62boWPP4ZXXoEImfwXjoT9iGD+hkMZtnsyzG5bqzhrBzVj39jWrB3UzFabcTC/uX799ddUr16dFQveo0HZ/BTLl8vjkRfYO9rJqF51sJHde8AnpqUYa/7NV1/BuHHah7BmjefbG4KKsB8RJLuxY6a2h5qTMBjfXE+fPk2/fv14//33qVy5MmvWrOHOO+/0ej92j3bc1avOLr527Gb3HvDpPT9wINSpA9266WpovXrpeQh583q3H4OthP2IwOHGjpnabnfn4y3B+Ob6xx9/8MknnzB48GA2b96cJSUAwT3aySr+cOxm9x7w+T3fvDls2wZ9+8I77+hEdoaQIuznEaT3EThTPH9uLlxJ4vQF7yaZGeDYsWPMnz+f562EZadOnaJQoULZ2mc4xvIH4zwUv8r0449wyy168ll8PJQsCRGWNypYsat4fVAwqm0NHru9lMuRQcKZi5y/lHRN6gm7TS3BjFKKDz74gNjYWAYPHnw1SVx2lQAE52gnuwTjiNOvkXC33aaVQHIyPPSQTlOxaJEJNQ1ywl4RgFYGv4+5h+IuTAyJKYrrckSHVefjL/bv38/dd99N586diY2NTZMkzlcEk2PeFwSjuSsgCtfhgCVLoHRpePhhaNcOjhzx3f4NPiXsncWpLI1PcDkcBl2/ePMrdwVYItcE66zhpKQkmjZtysmTJ3n77bfp0aMHUVHB8R4RrNcMgtO5D/5zjKehRg1d72DKFBg6VI8ONmyAyma0HWxEhCIYunQb89z4CSB4nJHpbeSpjkXAto5tz549lC1blujoaObMmUO5cuUoXbq0LbK4IhivmTPBNg8l4ERHQ//+cP/9MGMGVKqk2y9d0nUQDEFBcLzS+ZGl8QnMW3/QZRIzCI63s1SCadZwYmIio0ePplq1arxtRYE0bdo0qJQABNc1c0e4mbuyRIUKMH68no2ckADlysHkydqXYLCdsFcEE1budqsEgKDyB7hzICacuRjQXEI///wz9erVY8iQIdx///08/PDDATu2twSjM9aQCSJQu7YukRkXB9u32y1RxBP2iiCjDqF4/txBowQgYxNVoBLLTZ06lXr16nHs2DGWLFnCokWLuPHGG/1+3KzirsJcsJj7DC4oVgyWL4d582DPHqhVC0aONJFFNhL2isBdhyAQNCahVFyF9aXib3NH6nySWrVq8cQTT7Bjxw7atWvnt+P5gqXxCZy/lHRNe4xDgu63TSUSq925PGcReOQRncTuwQfh9999msQuEq9zdgh7Z7GrqA0BHr29VMBHA5lFt6R+7rtws8vt/WHuOHfuHIMHDyZnzpxMnDiRhg0b0rBhQ58fxx9MWLmbxJRr3yKvyxEdVCO9VILdse0PMj3nIkV00rrUJHZbtsBHH8GIEZAnj3+OabiGsB8RuIqZnvRwzauZRwOFp6kG2tYq7nK+A/je3PHVV19RvXp1pk2bhlKKUJtl7k4xnnVRjjQYCGbHtr/eoD0+59Qkdl9/Da+/rmcnf/99luQM5uscrIT9iAACFDOdCd4k+vJ37PmpU6fo168fc+fOpWrVqqxdu5YGDRr4ZN+BxI5KZtkhK47tQMyR8NUbtCtZPTnntNvVYdz0hdw5/iVo2hS6d9fRRvnyuZVz04E/+W7XiavHdTdfyAQQuCfsRwTBgjedgL9nfp46dYrPPvuMl19+mfj4+JBUAhB8RYMyw52CypfbtcM7UJXIfPEG7U7WzJz5rrbrdugGls/9Cl54AWbNgmnTMpRz3vqDabZ352kI1heEYMCvIwIRuRuYAjiAWUqpsemW9wO6AknACeBppdQBf8pkF96+vfp6FHP06FHmzZtH//79qVSpEgcOHKBAgQI+278dhNpkrQEtKzNg8ZZr/Bp/X0liaXzCNXIHKkW6L0Jw3cmaMzqK3DEOt6Nbd9uNXXOQNhMmQKdOUK0aAAV3bePiDUX4M0++NOunN2gqtB/Qud35mME8E90u/DYiEBEH8DbQCogFOolIbLrV4oG6SqlbgE+A8f6Sx27sentVSjFnzhyqVq3Kyy+/zJ49ewBCXgmkEkqTtdrWKs71ua5990pMVi7fvr3poLNj4/dFPqSM/DUZjW4zPcfata8msZv2xQS+mdWT+3b8J9NQU2UdK/0xQ6Hmtx34c0RQD9ijlNoLICILgPuBHakrKKW+c1p/PfCYH+WxFTveXvft20f37t359ttvadSoETNnzvR5kjiDd5xxkfIcXHeIno4is2vj94VPKiNZMxrdejxSdjj49Z0PKNz3GaYun8B9O75n6F3PcPyGwi4njLpLqZ2VUZYvRxDBOhrxpyIoDjjXiTwM1M9g/S7A/7laICLdge4ApUqVypIwwfADBNJpnZSURLNmzTh16hTvvPMO3bt3D5okcZGMNyZCTzvo7JqQfPGSklVl4ul2S+MTmPC7cPTR8Tz903L6r/mQb+c8w6zXP2b68RweH9dbM5grJdt34WZGLN/OK22qeaU8gKANaw2KqCEReQyoCzR2tVwpNQOYAbowjbf7j6S44t9++41y5coRHR3Ne++9R/ny5SlZsqTLdYNBOUYa3nSYnnbQvrDxe/KSktH9klVl4sl2aZ7fKAezbmvLmioNeOvCT/R9pg1lNh9hyhdb2f93SqbH9dZX50rJApy+kOi2D3HX3+SMjsqywn505jrW/v7n1e9x5Qsyr5vvgjz8VqFMRBoAw5VSLa3vgwGUUmPSrdcCeBNorJT6I7P9eluhDIKzSpSvSUxMZNy4cbz66quMHz+ePn36ZLh+OFYDCxV8rYD9eX+nypoajZPeARuI+yXT8zt8WBfE6d9fl8uMdv9+6+19X3bQlxnmKnN1jd3J6w4B9o1t7Xb5v974nt/++Puadm+VQUYVyvw5IvgRqCgiZYEEoCPwSDrBagHTgbs9UQJZJdzjijdt2kSXLl3YunUrHTt2pFOnTpluE6iIlEAQaiMbX5sI/TXvJH2nmb5DDNT9kumIJzoa6teHAQNg4UKYPVtPSHNBRiMQV/dRRvMS3Mnmbb+SkVN+aXyCSyUApBkhZBe/KQKlVJKI9AZWosNH5yiltovISGCTUmoZMAG4HlgsOs/IQaXUfb6U49GZ69wucxfjHEpMmTKFfv36cdNNN/H5559z332eXb5wydoZSWY/d/grEMGdWcSZQNwvmZpzbroJPvtMl8R89lmoUwdeegmGD3eZv8iVInZ3Hz1Qpzif/pTg9jq46kPcyVsgTwyXElO8UtiBmg3tVx+BUmoFsCJd2zCnzy38eXzIWGueuZDoMn47FFBKISLUrVuXLl26MH78ePLnz+/x9qE2K9cd4TSyyQ7+CETwpJMPxP3i0YhHRJfEbN5cp7c+cMCrJHbu7qP5Gw6RnIH53NUid/K+0qba1WN5qrAD9WIWFM5iu1DoBG99F26meAiYFAD++usvXnzxRXLlysWkSZOIi4sjLi7O6/0EawlFbwmXkU0wkplZJFD3i1cjnsKF4cMPIcnKSrtlC8ydq9NcX3ddmlWdTUHuuvqMlAC4zmuVmbze9DEZ/QZx5Qt6vJ/MiGhF4EwomBRWrFjBv//9b44cOUK/fv2ujgqyQqjNynVHuIxsghF3mXtTJ2sF8n7xesST6jD+9lt44w1YuhRmzoRm2rHrymmcFfydGcDVbwBQseh1Po0aCntFEFe+oMdOlWA1KZw8eZK+ffsyb948qlWrxieffEL9+hlNyfCMYEjGl13CZWQTjITFy0L//jqiqGtXbTbq2hUmTPDI/5EZgbjPAvUbhL0i6FC3lFfe9WA0KZw+fZrly5fzyiuv8NJLL5EjRw67RQo47iKDwqKzCmLC4WWBRo20iWj4cJ3iunx5jpxxn4ZegCgRl2YhhwgpSgX0PgvEbxD2imDIZ9u8Wj+QJoWMwh4TEhKYN28eAwYMoGLFihw4cMArZ3A4kVlkUFh0Vn4g1MJq0+NT+XPnhnHjoGNHiI2l2KS1FNy5laM3FObkdf/k3UqdF+DKdBTjEK7LER209S6yQ9grgr+veD78C6RJwV3nppTi5E//xwsvvEBiYiLt27enQoUK5M+fP+Qf7KwyfNl2ExnkJaEeVus3+WvVAmBAiwrUGv84N1w8x4gW3Vka24TcOaKvPv/pR5r588Rw+kIiZywlkHDmIv0Wbc6+PEFCRCefeez2Un7L+Z8ZrmyUf/1xmM4d2tC9e3dq167N1q1bqVChAhC43PTBxtL4hKsPX3qC0YwXLIR6lS5/y9+2bil+mzmPw0VLMvmLicxf+iqTGxS8pnRsambbyy78CSkKXlqy1Sfy2E1EK4JRbWuwdlAzJj1cE4DnF24OWKHr9J2YSknm+IIhnDu8m+nTp7Nq1aqrSgCy9mCEQwHvjM7PRAa5J9TDagMhf4sHmlBj71aYMoUGh3+h5cPNYdcul+teSEzxqj3UCHvTUGYsjU9IUywk4cxFBizeAvh3yJca9ph46jDRBW5GohwUbv08JUqXpXv3h69Z3xdZE0PJNJBKRg++iQxyT6iH1QZMfocDnnsO2rTR1dAqW/fUxYvarxAhRPSIYGl8AsOXbb+mYlRiimL4su0e7yMrb919m5Xl73ULODKnN+d+/gKAAuVrMvShO12u723xkFA3DaTi7vwK5IkJKYUWaEKtjGd6Ai5/2bLw2mt6NvKhQ1CmjK6VnDoxLcyJaEUwYeVut/Znd+3OZNVuv3HjRkZ2uY+Taz6icI3GXB/bJFMfhbcPRqibBlJxd96p0/UNrvF33Wt/Y6v8OXJAXBy8+KJOZrdlC7ljXHeV7tpDjYg2DWW3U8xKnpvJkyfTv39/br75ZpYvX869997r0bG8jZcPddNAKuE+T8CfkWChHlZrm/w33giffqr/nnkG6tZlaednaFWwBSlOM/mjgDHtXWc5DTXCXhE8dnspPlp/0OWyYvlzc+FKEqddlA8s4EFmUm/eulPTQdSrV49u3boxbtw48uXL52Jr93jzYGR1xm0whqiGeofmjnDx44QlIvDgg9C0KfTrR+Wks7zRsVbQPRu+IuwVwai2Ndh34vw1s4udO8UBn2whMfkfP0GMQzwyPXjy1n327FkGDhxI7ty5mTx5MnfccQd33HFHVk/HY7LyJm06psBiMqeGAIUKwQcfQHIybR0O2vIHfLAMeo+C66+3WzqfER4GrkyY160Bkx+u6dbeeF2Of/RhgTwxTHjwVo+Lfmdkt1++fDmxsbHMmjWLnDlz4q9qcO5wjoNeO6hZpucULg7mUCFc/DgRgcN6zr/7DqZMgRo14Jtv7JXJh4T9iCAVT4pRAFxyExeckckkfXtciRw88sgjzJ8/nxo1arB06VJuu+02/52cj/BFx+RP01Iwmq2yQ7j4cSKKfv3+SWJ3113w1FMwcSIUKJD5tkFMRCgCdx2Ip0NzT3LdOLNnzx5WrFjBiBEjGDRoUMgkictux+RP01I4mq1M5tQQpWFDncRu5EgdYlqxIgwebLdU2SLsTUNL4xMY8MmWNCGeAz7ZwtL4BI/fgD0xmRw6dIgxY8aglKJChQocOHCAYcOGhYwSgOzHbvvTtJTVfQfz7OpQD/GMaHLlgtGj4eef9SgB4Mcf4dgxe+XKImE/IhixfHsaRzBAYrJixPLtHr8BZ6QwUlJSmDFjBgMHDiQ5OZkOHTpQoUIFryOCgoHshmr60+adlX2HwigiXCOiIoZbrPDR5GR45BE4dQomTYInnvCqVKbdhP2IwFVoaGq7p2/Abme3Jp2iWbNm9OzZk3r16rFt27Y0+YFCEW8dzM54O/vZG7Kyb+P8NgQMhwOWL4fYWOjcGVq10nWTQ4SwVwQZ4enQ3JXCUCnJ/DJrID/+FM/s2bP55ptvKFeuXAClDz78mRYgK/s2UTmGgFKlCqxZA2++CT/8ANWqwc6ddkvlEWFvGsqfO8Zluoj8ufWEMXfRRMOXbb+6XYE8MTxQpzif/ZzAmSP7iS5YDIlyULD181xfpAQFazXJcu3gQOPvmazgn1nAWdm3icoxBJyoKOjd+58kdlWq6PYLFyBPHntlywAJdGx7dqlbt67atGmTx+unzy4KEBMlTOhw7VyBpfEJjFi+3aU5KSoliT/XLuTs+kUUaPI0N9x2/9VlqVWNgh1X4bK5Yxxh66CMtPM1BCmHDkGdOtqp3L8/xGSetcAfiMhPSqm6rpaFvWmoba3iTOhwaxrzjzslMHjJNpdK4HLCLg7PeY6z/5vPdVUbcV31pmmWh4qpIdJs5iYqxxAU5MwJjRvrENP69SE+3m6JriHsTUPgWWSGq04S4K+NSzj93Xs48ham6IPDyV3+WoUaKqaGSLSZm6gcg+0ULQqLF8OSJTqJ3W23wcCB/6S9DgIiQhFkZhdfGp9wjS1ZqRREoshRrCrX12pFgcadicp5rY1PCJ0CKcZmbjDYSPv2Oold//7wxx9BowQgAkxDmdUMSF2eSsql85xcMYXT384AIFeJqhS6qxcxua8jJirtDyfAo7eXCpk3zlAvVmIwhDwFCsCcOTB9uv4eHw/PPgvnztkqVtgrAnd28dQKZM7LL/y6jiOze/H3L6uQHLmvJokrkCeGiR1uvcbXMOnhmoxqWyOg55MdjM3cYAgSUpPYrVkDb78N1avDypW2iRP2UUNlBn3pdllqaGny32f485t3ubD7B2KKlqNQq+fIeVMFJj9c03SSBoPBv/zvf9ClC+zapWckT5oEBQv6/DARHTUUlYEZLnWeQMqVC1zaH0/+Rk9w8xNvkPOmCqYmrsFgCAx33KFNREOGwMcfw4wZARch7J3FKW4GPEl//cHfv3zHDQ0eIqZAMYr3fC+NMzjEBkoGgyGUyZULRo2Chx+GypbPbuNGKFkSbr7Z74f364hARO4Wkd0iskdEBrlYnlNEFlrLN4hIGX/KAzoa6NzPX3Jk9jOcXb+IpDNHAa6JCDrrQfF6g8Fg8Ck1akCOHDqJ3aOP6txF773n9zdTvykCEXEAbwOtgFigk4jEplutC3BaKVUBmASM85c8AImnDnP848H8+c075CxWhWJdphFToJjLdU1IpcFgsA2HA778UiuGp5+Gli1h3z6/Hc6fI4J6wB6l1F6l1BVgAXB/unXuBz6wPn8CNBc/Je1RKckcXzSMxBP7KXRPX4o+NJLofDe6XNeEVBoMBtupVAm+/x6mTYN166B1a0hxXUExu/jTR1AcOOT0/TBQ3906SqkkETkLFAJOOq8kIt2B7gClSpXKkjAS5aBwm/5E57+Z6Ov/8cjHRAkP1yvJd7tOhE0JRIPBECZERUHPnloJHD2qv/uBkHAWK6VmADNAh49mdT+5SlS7ps1V3iGDwWAIKkqV0n9+wp+moQSgpNP3Elaby3VEJBrIB5zyo0xpiCtf0CgBg8EQ8fhTEfwIVBSRsiKSA+gILEu3zjLgSevzg8Bq5eMZbvvHtnbZHle+IPO6NfDloQwGgyEk8ZtpyLL59wZWAg5gjlJqu4iMBDYppZYBs4EPRWQP8CdaWfgcd8rAYDAYDH72ESilVgAr0rUNc/p8CejgTxkMBoPBkDFhn2LCYDAYDBljFIHBYDBEOEYRGAwGQ4RjFIHBYDBEOCFXj0BETgAHsrh5YdLNWo4AzDlHBuacI4PsnHNppVQRVwtCThFkBxHZ5K4wQ7hizjkyMOccGfjrnI1pyGAwGCIcowgMBoMhwok0RRD4GnD2Y845MjDnHBn45ZwjykdgMBgMhmuJtBGBwWAwGNJhFIHBYDBEOGGpCETkbhHZLSJ7RGSQi+U5RWShtXyDiJSxQUyf4sE59xORHSKyVURWiUhpO+T0JZmds9N6D4iIEpGQDzX05JxF5CHrt94uIh8HWkZf48G9XUpEvhOReOv+vscOOX2FiMwRkT9E5Bc3y0VEplrXY6uI1M72QZVSYfWHTnn9O1AOyAFsAWLTrdMLeNf63BFYaLfcATjnpkAe63PPSDhna728wBpgPVDXbrkD8DtXBOKBAtb3onbLHYBzngH0tD7HAvvtljub59wIqA384mb5PcD/AQLcDmzI7jHDcURQD9ijlNqrlLoCLADuT7fO/cAH1udPgOYiIgGU0ddkes5Kqe+UUhesr+vRFeNCGU9+Z4BXgXHApUAK5yc8OeduwNtKqdMASqk/Aiyjr/HknBVwg/U5H3AkgPL5HKXUGnR9FnfcD8xVmvVAfhG5OTvHDEdFUBw45PT9sNXmch2lVBJwFigUEOn8gyfn7EwX9BtFKJPpOVtD5pJKqS8DKZgf8eR3rgRUEpG1IrJeRO4OmHT+wZNzHg48JiKH0fVPng2MaLbh7fOeKSFRvN7gO0TkMaAu0NhuWfyJiEQBbwCdbRYl0ESjzUNN0KO+NSJSQyl1xk6h/Ewn4H2l1EQRaYCuelhdKZVit2ChQjiOCBKAkk7fS1htLtcRkWj0cPJUQKTzD56cMyLSAhgC3KeUuhwg2fxFZuecF6gOfC8i+9G21GUh7jD25Hc+DCxTSiUqpfYBv6IVQ6jiyTl3ARYBKKXWAbnQydnCFY+ed28IR0XwI1BRRMqKSA60M3hZunWWAU9anx8EVivLCxOiZHrOIlILmI5WAqFuN4ZMzlkpdVYpVVgpVUYpVQbtF7lPKbXJHnF9gif39lL0aAARKYw2Fe0NoIy+xpNzPgg0BxCRqmhFcCKgUgaWZcATVvTQ7cBZpdTR7Oww7ExDSqkkEekNrERHHMxRSm0XkZHAJqXUMmA2evi4B+2U6WifxNnHw3OeAFwPLLb84geVUvfZJnQ28fCcwwoPz3klcJeI7ACSgQFKqZAd7Xp4zv2BmSLyPNpx3DmUX+xEZD5amRe2/B6vADEASql30X6Qe4A9wAXgqWwfM4Svl8FgMBh8QDiahgwGg8HgBUYRGAwGQ4RjFIHBYDBEOEYRGAwGQ4RjFIHBYDBEOEYRGAwGQ4RjFIHBkAnWxB3zrBjCFnNzGwwuEJEyVg78ucAvwGwR2WTl+B/htN5+ERkhIj+LyDYRqWK1FxGRb6z1Z4nIAWumLyLymIhsFJHNIjJdRBz2nKXBoDGKwGBwT0VgmlKqGtBfKVUXuAVoLCK3OK13UilVG3gHeMFqewWduqQaOtV5KbiaAuFhIE4pVRM9+/fRQJyMweCOsEsxYTD4kANWvneAh0SkO/qZuRldAGWrtWyJ9f8noL31+U6gHYBS6isROW21NwfqAD9aqT5yA+GQ+8kQwhhFYDC4528AESmLftO/TSl1WkTeRyc2SyU1k2symT9TAnyglBrsY1kNhixjTEMGQ+bcgFYKZ0XkRqCVB9usBR4CEJG7gAJW+yrgQREpai0rKGFQP9oQ2pgRgcGQCUqpLSISD+xCV4Za68FmI4D5IvI4sA44BpxTSp0UkaHA11YkUiLwDHDAP9IbDJljso8aDH5ARHICyVYa5QbAO5Zz2GAIOsyIwGDwD6WARdZb/xV0UXmDISgxIwKDwWCIcIyz2GAwGCIcowgMBoMhwjGKwGAwGCIcowgMBoMhwjGKwGAwGCKc/wdla38TYKfcJAAAAABJRU5ErkJggg==",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1094,7 +1094,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABNOUlEQVR4nO2deZzN1f/Hn++5M7YSQot9XwbZJpLsakIilUiKLEVESfFTQkLWCMkWUUQhlVLftIpKjXUQWWIsIZRss5zfH+czXOPemTsz997PXc7z8biPufd8zv2c92fu53PeZ3mf1xGlFAaDwWAIXyLsNsBgMBgM9mIcgcFgMIQ5xhEYDAZDmGMcgcFgMIQ5xhEYDAZDmGMcgcFgMIQ5xhEYsoWIDBORhU6f7xORAyJyRkRq2mlbqCGat0XkpIj8bLc9niAi/ycis633pUREiUikl869T0SaZ/G7jUXkoDfsCAWMI3CDiDwsIhusCu2wiHwmInd44bzzRGSkl2z02rm8yHigj1LqWqVUnD8LFpFvrEoypz/L9RQR6SIiP2TjFHcAdwLFlFJ13Jw/2bpn/xGRjSJyTzbKyzZKqVFKqe52lC0idURklYicEpG/ReRnEelqhy2BjnEELhCRZ4HXgVHAjUAJYDrQxkazgoWSwDZ/FyoipYAGgALu9Xf5fqIksE8p9V86edYppa4F8gNzgCUiUiBtJm+1ytPDH2WkU3Y9YA3wLVAOKAj0AlrYZVNAo5QyL6cXkA84AzyYTp6caEdxyHq9DuS0jjUGDgIDgL+Aw0BX61hPIBG4aJXxsZVeBPgQOAbsBZ620q+3ztXa+nwtsBt41N250tgpwCTLjn+ALUBVp2sYD/wJHAVmALmdvtsG2Gh97w/gbiu9NPrh+hf4EpgKLLTOdwZdEf8H/OHCnjeB8WnSPgKetd6/ACRY594JNMvE7zYUWAtMBD5Jc2we2pF/Ztm4FrjJ+t1OAjuAmk75KwPfAKfQTu1ep2PfAN2dPncBfnD6rIAngV3W96dZv0Nl4DyQbNlwys11FAFWAn9bv3UPK71bmu8Pd/HdtLZcY9kTAwwDPrB+q3+A7uh7fQ76Hk0ARgIO67vlrN/5NHAceN/pvFWs3/5v6975PyvdVRnDgIXW8VKWPT3Rz81h4Dmn80YAg9D32wlgCXC90/HOwH7r2BBgH9Dczf/xB2BaOvdLY9w8p9bxVkCcdR0HgGFOx1Kv4zH083McGOJ0PDcwH31vbQeeBw6m+Y2vet5trffsNiDQXsDdQBIQmU6eEcB64AagMPAj8IrTDZZk5YkCWgJngQLW8XnASKdzRQC/oiuyHEAZYA8Qax2/CzhilTUL+MDpu1ecy4Wdsda583O5MrrZOjYJXeFcD+QFPgZGW8fqoCuAOy37igKVrGPr0JVtTqAhutJe6FSmAsq5saeh9VCJ9bkAcM56MCpax4pYx0oBZTPxu+0GegO10Q7yxjT/p+PWsVzoluJetEN1oCvAr628Uda5/s/6PZpa11jROv4NGTuCT6z/eQn0w363q7xuruM7tNPKBdSwvt/Uk+87HwcigX6W7fnQFXIi0Nb6TXMDy4G30A7jBuBn4Anr+4vQlW2EZcsdVnpedKU5wErPC9S1jrkqYxhXO4JFVpnVrOtrbh3vh36uiqHvr7eARdaxaLQDbGgdm4h+zq5yBEAetMNsks7/qjHpP6eNLfsigFvQDq9tmuuYZV1jdeACUNk6PgbtRAtY17IZyxGQwfNuW71nZ+GB+AI6AUcyyPMH0NLpcyy6y556A53DyZGgWxy3We/ncaUjqAv8meb8g4G3nT6/gW7NJwAFndKvOJcLO5sCvwO3ARFO6YJutZd1SqsH7LXevwVMcnG+EtbDc41T2nt47ggE3YJqaH3uAayx3pez/k/NgahM/mZ3oCugQtbnHcAzaf5Ps5w+9wW2O32uhtVCRw8vHUnz/1qE1SLEM0dwh9PnJcAgV3ldXEdxdAWW1yltNDDPw+93sX6fU2jHt57Lleww4DunvDeiKy/nXmBHLjvEd4CZ6PkI0uSJc1P+FWU4paV1BJWcjo8F5ljvt+PUCwRutn7XSHTFudjp2DXo3rArR1A0bTku8jQmnefURf7XsZ4Jp+so5nT8Z6CD9f6Kih3dM0p1BBk+73a8zBzB1ZwACmUwvlkE3UVNZb+VdukcSqkkp89n0cM6rigJFLEmtE6JyCl0a/RGpzwzgaroCuGEZ5cBSqk16KGbacBfIjJTRK5D92LyAL86lfm5lQ66QvrDxSmLACfVlWPU+13kc2ePAhajKxOAh4F3rWO7gf7oiuMvEVksIkVcnMYVjwFfKKWOW5/fs9KcOer0/pyLz6m/TxHggFIqxen4fnTl4ilHnN6n99unpQjwt1Lq32yUvV4plV8pVUgpdZtS6n9Oxw44vS+JbgkfdroH3kL3DEAPZwjws4hsE5HHrXR394arMjzJ4/zslASWO9mzHe0Yb7TyXPqedQ+6exZOAiloR5Iebp9TEakrIl+LyDEROY0e7iuU5vvufucrbOXq/3tGz7vfMY7gatahW0pt08lzCP2DplLCSvMElebzAXRLPL/TK69SqiWAiDjQjuAdoLeIlEvnXFcXptQUpVRtdNe6AjAQ3Vo8B1RxKjOf0pOMqTaVdXG6w0ABEbnGKa1Ehld8JYuAB0SkJLp19KGTre8ppe5A/28V8FpGJxOR3EB7oJGIHBGRI8AzQHURqZ5J20D/jsVFxPnZKIHujYHuSeVxOnZTJs6d0e91CLheRPK6KTu7OJd/AH2fF3K6B65TSlUBUEodUUr1UEoVAZ4Aplv33gH0cIYnZbijuNN752fnANAizbOQSymVgL73Ln1PRPKgJ4CvNkCps+jn+H4PbHHHe+ih0+JKqXzoOTTx8LuH0UNCqThfb7rPu10YR5AGpdRpdDd0moi0FZE8IhIlIi1EZKyVbRHwoogUFpFCVv6F7s6ZhqNc+SD9DPwrIi+ISG4RcYhIVRG51Tr+f+iH63FgHPCO5RxcnesKRORWq2UTha7AzgMpVmt3FjBJRG6w8hYVkVjrq3OAriLSTEQirGOVlFL7gQ3AcBHJYYXTtvbwugFQOqT0ODAbWK2UOmWVX1FEmlqhn+fRjirF7Yku0xbdaoxGj6nXQM+FfI+eA8gsP6Fbd89bv3tj9DUuto5vBNpZ90U59CSupxwFiolIDlcHlVIH0PNNo0Ukl4jcYp3f03vLY5RSh4EvgAkicp31O5cVkUYAIvKgiKRWZifR92AKev7jZhHpLyI5RSSviNTNZPEvWf+/KkBX4H0rfQbwqtVIwHq+2ljHPgDuEZE7rP/fCNKvv54HuojIQBEpaJ2vuogsTuc7zuRF987Oi0gddO/VU5YAg0WkgIgUBfo4HcvoebcF4whcoJSaADwLvIiezDqA/jFXWFlGoivEzeix+9+sNE+YA0Rb3cIVSqlk4B50BbaXy5VkPhGpbdnxqJXvNfQDOcjVuVyUdR26wj/J5WiLcdaxF9CToutF5B/gf+gJW5RSP6Mf0EnoSeNvudwDehjdkv8beBndU8ks76HnAt5zSsuJnmQ7zuXJ8cEAItJJRNyFpD6GHl/902rFHlFKHUEPiXXKbAijUuoiuuJvYdkyHf3/32FlmYQemz6Kjgx5NxOnX4OOQjoiIsfd5OmIHoM+hJ7MfTnN8I43eRQ9YRmPvkc+4PJwyq3ATyJyBt0y7qeU2mMNW92J/h8dQUdHNclkud+i772v0FFkX1jpk62yvhCRf9FzHHUBlFLbgKfQ98xhy163C8KUUj+i58iaAntE5G90z3qVhzb2BkZYdgxFV+6eMsKybS/6ufoA3fsivec9E+f3OqnRGwaDwWDwASLSCz2R3MhuW9xhegQGg8HgRUTkZhGpbw23VUSH2i632670sG3ln8FgMIQoOdARWKXRobyL0UOMAYsZGjIYDIYwxwwNGQwGQ5gTdENDhQoVUqVKlbLbDIPBYAgqfv311+NKqcKujgWdIyhVqhQbNmyw2wyDwWAIKkTErQqAGRoyGAyGMMc4AoPBYAhzjCMwGAyGMMc4AoPBYAhzjCMwGAyGMMdnjkBE5orIXyKy1c1xEZEpIrJbRDaLSC1f2WIwGAwG9/iyRzAPve2jO1oA5a1XT/R+tgaDwWDwMz5zBEqp79BSxe5oA7yjNOuB/CKS0Y5C2eOPP+D8eZ8WYTAYDN7mv//+Y9++fT47v51zBEW5cgu3g7jZkk9EeorIBhHZcOzYsayVlpQErVpBjRqwdm3WzmEwGAx+Zs2aNdxyyy20a9eOlBRP9mrKPEExWayUmqmUilFKxRQu7HKFdMZERsLkybpH0KABPP00nDnjXUMNBoPBS5w6dYoePXrQrFkzIiIimDRpEhERvqmy7XQECVy5l2cxvLc3q2tiY2HrVujTB6ZOhapVYe9enxZpMBgMmSU5OZnbb7+duXPn8vzzz7N582YaNfLdvjZ2ag2tBPpYe4jWBU5b+6j6lmuvhSlT4KGHYMYMKGHtva4UiKd7UxsMBoP3OXHiBNdffz0Oh4NXX32V4sWLExMT4/NyfRk+ughYB1QUkYMi0k1EnhSRJ60sq4A96L1LZ6H3CPUf9evDggXgcMCxY1C9Oixb5lcTDAaDAUApxcKFC6lQoQKzZ88G4L777vOLEwAf9giUUh0zOK7Qm1Hbz6lTeg7h/vv1a+pUuOkmu60yGAxhwIEDB3jyySdZtWoVt912G/Xr1/e7DUExWexzypeHn36C0aPhk08gOhrmzdPDRQaDweAjFi1aRJUqVfjmm294/fXX+eGHH4iOjva7HcYRpBIVBYMGwaZNUKUKfPyxmTMwGAw+pUCBAtStW5etW7fSr18/HA6HLXYE3Z7FMTExyucb06SkwH//Qd688PvvsHo1PPUU+Ch0y2AwhAdJSUlMmjSJixcvMmTIEEDPD4gfGp0i8qtSyuWkg6nZXBERoZ0A6CGip5/Waw+2b7fVLIPBELxs2rSJ22677VI4aGoj3B9OICOMI8iIV1+Fd96BHTv0quRRoyAx0W6rDAZDkHDhwgVeeuklYmJiOHDgAEuXLmXx4sUB4QBSMY4gI0Sgc2eIj4e2bWHIEJg40W6rDAZDkLBr1y5ee+01Hn74YeLj43nggQcCyglAEG5ebxs33gjvv6+dQpMmOm33bihaFHLnttc2g8EQUJw5c4aPPvqITp06UbVqVXbs2EGZMmXsNsstpkeQWe65B6655koRux9+sNsqg8EQIHz55ZdUq1aNzp07s92aVwxkJwBh4ghWxCVQf8waSg/6lPpj1rAizguSRpGRMG0aXLyoJ5L79IF//83+eQ0GQ1By8uRJunXrxl133UWOHDn49ttvqVy5st1meUTIO4IVcQkMXraFhFPnUEDCqXMMXrbFO86geXPYsgX69YPp0/X6gz17sn9eg8EQVCQnJ1O/fn3mz5/P4MGD2bRpEw0aNLDbLI8J+TmCcat3ci4x+Yq0c4nJjFu9k7Y1XW5/kDmuvRZef12L2L35Jiv+jmTckjUcPvkfNxe4hoGxFb1TjsFgCDiOHz9+SSRu1KhRlChRglq1gm/X3ZDvERw6dS5T6VmmXj1WPDOawR/Fc+7QET6f04ca675g8IebvdP7MBgMAYNSinfeeecKkbi2bdsGpROAMHAERfK7juhxl54dUnsfeS/8x/moHExb+RqvLxnB20vNjmgGQ6iwf/9+WrRowWOPPUblypVp2LCh3SZlm5B3BANjKxIVcWXMblSEMDC2otfLSu1l7C9QhPs6T2BU46402vsbCyY+DnPmGBE7gyHIWbhwIVWrVuWHH37gjTfe4Pvvv6dSpUp2m5VtQt4RACSnqYDTfvYWzr2M5AgHM+vez91d3+CPImXh88+NiJ3BEOQULlyY+vXrs23bNvr06eOzrSP9TWhcRToMWb6FlDT1forS6d5mYGxFckddqR549MYS7F/6Cbz9tk7YuVPvnZyc7OIMBoMhkEhMTGTMmDG88sorAMTGxvLZZ59RsmRJmy3zLiHvCP676LrCdZeeHdrWLMrodtUomj83AhTNn5vR7arRtnZxHV0Eele0/v3hjju0bIXBYAhI4uLiqFu3LoMHDyY+Pj6gROK8TciHj/qbtjWLph8u+sorULmyXntQsya8+CK88ALkyOE/Iw0Gg1vOnz/PiBEjGDt2LIUKFeLDDz+kXbt2dpvlU0K+RxBwiECnTro30K4dDB0KkybZbZXBYLDYvXs348eP59FHH2X79u0h7wQgDByBu06c7Z27G26ARYvg00+1PAXoTXDOnrXXLoMhDDlz5gwLFiwAoGrVquzcuZO5c+dSoEABmy3zDyHvCNzFBwVMIGfLlpdF7Fq3hurV4dtv7bbKYAgbVq9eTZUqVXjssccuicSVLl3aZqv8S8g7ggg3TX936XaxYstR+jbsyf7jZ6BxY/Y++Cj884/dZhkMIcuJEyd47LHHuPvuu8mTJw/ff/990IjEeZuQdwRpQ0czSreDVGG8jwtWIvbxqcy89T5KfPguZytUMiJ2BoMPSBWJe/fddxkyZAhxcXHUr1/fbrNsw0QNBQDOwnjno3Ixqmk3Pq10Bz3iv+Se1HjllBS9l7LBYMgyx44do2DBgjgcDl577TVKlixJjRo17DbLdkK+ZnEX8htIocCuBPA2FalI3+Z9wOGAv/7in3KVGNrxRUq/8In39lQwGMIEpRRvv/02FSpUYNasWQC0adPGOAGLkO8RuFOT8FRlYkVcAuNW7+TQqXMUyZ/bJ7LSRfLnJsGFM0iVrPhi/S5uuiCMWPwqDcrV5cW7ejF42UUAI3FtMGTAvn376NmzJ19++SUNGjSgSepWs4ZLmB5BOvh0UxsnXElT5I5yXBLGGx5/gbadxvFKk27csW8jX87uTZtfPmXc5zu8aofBEGosWLCAqlWrsm7dOqZPn84333xDhQoV7DYr4Ah5R5CdHkF6m9p4E7fSFFZr/9Cpc6REOJhT5z5iH5/K1pvK0WBfHIdOn/eqHQZDqHHjjTfSsGFDtm3bRq9evUJGJM7bhPzQUHbw26Y2pC9N4Tx09GeBm3m4w6vkSTyvh4527NCL0vr31/MJBkMYk5iYyNixY0lOTmbo0KHcdddd3HXXXXabFfCEvHu8JofrytFdujP+3NQmPa4aOhJBXXOtHjp691147jmoVw+2bvWrXQZDIPHbb79x66238uKLL7Jz585LInGGjAl5RxDlcH2J7tKdyWjs3l+kO3Q0YoSWqti7F2rVgmHD4OJFv9pnMNjJuXPnGDRoEHXq1OHo0aMsX76cd999NyRVQn2FT4eGRORuYDLgAGYrpcakOV4CmA/kt/IMUkqt8qYNp88lZirdmdShGl9HDXmC26EjEejQAZo318NDw4dDrlwwaJDfbTQY7GDPnj1MnDiRLl26MG7cuLDRB/ImPnMEIuIApgF3AgeBX0RkpVLKWYT/RWCJUupNEYkGVgGlvGlHRqGZGZGhrHSgUKgQLFwInTtDgwY6bedOKF4c8uSx1zaDwcv8888/LFu2jC5dulClShV27doVcpvF+BNfDg3VAXYrpfYopS4Ci4E2afIo4DrrfT7gkLeNCJThHb8RG6sr/qQkuPdeqFYNvv7abqsMBq+xatUqqlatSrdu3S6JxBknkD186QiKAgecPh+00pwZBjwiIgfRvYG+rk4kIj1FZIOIbDh27FimjGhbsyj31y6KwxovdIhwf+0gaeVnh8hImDlTy1I0bQo9e8Lp03ZbZTBkmePHj9O5c2datWpF3rx5Wbt2bdiKxHkbuyeLOwLzlFLFgJbAAhG5yial1EylVIxSKqZw4cKZKmBFXAIf/ppwacP6ZKX48NeE8JBoaNQINm2CgQNhzhyIjoY//rDbKoMh06SKxC1evJihQ4fy22+/cdttt9ltVsjgS0eQABR3+lzMSnOmG7AEQCm1DsgFFPKmEf5aFBaw5MkDY8fCTz9BixZQqpROT0mx1SyDwROOHj1KSkoKDoeD8ePH8+uvvzJ8+HBy5sxpt2khhS8dwS9AeREpLSI5gA7AyjR5/gSaAYhIZbQjyNzYTwb4c1FYQBMTA7NnXxKxIzoa3nvPc9Elg8GPKKWYM2cOFStWZObMmQC0bt2aW265xWbLQhOfOQKlVBLQB1gNbEdHB20TkREicq+VbQDQQ0Q2AYuALsrLq0ACZVFYQHHmDBQooPdObt0aDhzI+DsGg5/Ys2cPzZs3p3v37tSoUYPmzZvbbVLI49M5AqXUKqVUBaVUWaXUq1baUKXUSut9vFKqvlKqulKqhlLqC2/bEHZRQ55Qpgz88AO8/rqOKKpSBWbMML0Dg+3Mnz+fatWq8csvvzBjxgzWrFlDuXLl7DYr5LF7stjnhG3UUEY4HNCvH2zZAnXqaIdgVmIabKZIkSI0bdqU+Ph4nnjiCSMS5yck2PQ4YmJi1IYNGzzOvyIugQFLN5HstDelI0KY8GB14wxSUQrOndMTyzt2wMcfwzPP6BBUg8GHXLx4kTFjxpCSksKwYcPsNiekEZFflVIxro6FvLsdsnzLFU4AIDlFMWT5FpssCkBELq8+fu89eP55LWK3ebO9dhlCml9++YXatWvz8ssvs2fPHiMSZyMh7wj+u5icqfSwZ/hwWLIE/vwTateGoUPhwgW7rTKEEGfPnuW5557jtttu4+TJk6xcuZJ33nnHiMTZSMg7AkMmEYEHH4T4eOjYEV55BSZNstsqQwixd+9e3njjDXr06MG2bdto3bq13SaFPWYQ2OCaggXhnXe0iF39+jptxw4tYnfNNfbaZgg6Tp8+zbJly+jatStVqlRh9+7dFC9ePOMvGvxCyPcI8kS5vkR36YY03Hnn1SJ2//uf3VYZgohPP/2UKlWq0L17d3bs0PtsGycQWIR8bTiq3S1EpBl6jBCdbsgEkZF6ZXJkpHYO3brByZN2W2UIYI4dO0anTp245557KFCgAOvWraNSpUp2m2VwQcg7grY1izKxfY0rdvea2L6GCR3NCg0bahG7QYNg/nwtU7F7t91WGQKQ5ORk7rjjDpYuXcrw4cP59ddfqVOnjt1mGdwQ8usIDD7it9/0auQ339SL05KT9V9DWHPkyBFuuOEGIiIi+OSTTyhVqhRVq1a12ywDYb6OwOAjatXS+x04HHD0KFSuDAsWGJmKMCUlJYW33nqLChUq8NZbbwFwzz33GCcQJBhHYMg+Z89C4cLw6KPQsqVeg2AIG3bv3k2zZs148sknufXWW4mNjbXbJEMmMY7AkH1Kl4bvv4cpU/TfKlVg2jTTOwgD3n77bapVq8Zvv/3GrFmz+N///keZMmXsNsuQSYwjMHiHiAjo2xe2boXbb4fvvjMidmFAiRIliI2NJT4+nu7du5vVwUFKWEwWv7hiC4t+OkCyUjhE6Fi3OCPbVvORhYYrROy2b4eVK2HAACNiFwJcuHCB0aNHk5KSwogRI+w2x5AJwnqy+MUVW1i4/s8r9ixeuP5PXlxhROd8hrOI3fvv63DTunVh40ZbzTJkj59++onatWszfPhw/vzzTyMSF0KEvCNY9JPr3bfcpRu8zLBh8MEHkJCgt8scMgTOn7fbKkMm+O+//3j22WepV68ep0+f5pNPPmHevHlmGCiECHlHkOym1eIu3eAD7r9fi9g9+iiMGqV3RjMEDfv372f69Ok8+eSTbNu2jVatWtltksHLmEFbg3+4/nqYOxceeQRuu02nbd+uReyuvdZe2wxXcerUKT744AO6d+9OdHQ0u3fvplixYnabZfARId8jMAQYTZteFrFr0waqVoUvvL5VtSEbfPTRR0RHR/Pkk09eEokzTiC0MY7AYA+RkfD225A7N8TGQteu8PffdlsV1vz111906NCBtm3bUrhwYdavX29E4sIE4wgM9lG/PsTF6QnkBQuMiJ2NJCcnU79+fZYvX87IkSPZsGEDMTEuIw0NIUjIzxHkjIzgQlKKy3RDAJArF4wcCQ88oEXsUlelGhE7v3Do0CFuuukmHA4HkydPplSpUkRHR9ttlsHPhHxteNGFE0gv3ZA1VsQlUH/MGkoP+pT6Y9awIi4hcyeoUUM7gogILWJXsSLMm2dkKnxESkoKb775JpUqVWLGjBkAtGzZ0jiBMCXkHYG7asRUL95jRVwCg5dtIeHUORSQcOocg5dtybwzSOXcObj5Zj1vEBsL+/Z509yw5/fff6dJkyb07t2bunXr0qJFC7tNMthMyDsCh5tFL+7SDZln3OqdnEtMviLtXGIy41bvzNoJS5WCb7/VwnXr1unIoilTTO/AC8yZM4fq1auzefNm5s6dyxdffEHp0qXtNstgMyHvCDrWdb03qrt0Q+Y5dOpcptI9IiICevfWInYNGmiHYJx3tilVqhQtWrQgPj6erl27mtXBBiAMJotTxeWM6JzvKJI/NwkuKv0i+XNn/+QlS8KqVZdlKeLjYflyeP55iIrK/vlDnAsXLvDKK68AMHLkSJo1a0azZs1stsoQaIS8IwDtDEzF7zsGxlZk8LItVwwP5Y5yMDC2oncKENHrDQCWLtX6RUuX6pXKtWp5p4wQ5Mcff6Rbt27s2LGDxx9/HKWU6QEYXBLyQ0MG39O2ZlFGt6tG0fy5EaBo/tyMbleNtjWLer+wl1/WPYKjR6FOHa1sei4bQ1AhyJkzZ+jXrx933HEHZ8+e5fPPP2fOnDnGCRjc4tP9CETkbmAy4ABmK6XGuMjTHhiGDuTZpJR6OL1zms3rDQCcPAkDB8KcOTB6tHYIBgDi4+OpVasWPXr0YNSoUeTNm9dukwwBQHr7EfjMEYiIA/gduBM4CPwCdFRKxTvlKQ8sAZoqpU6KyA1Kqb/SO69xBIYr+OYbvddB7tywbRuUKAFhWPGdPHmSpUuX0rNnT0AvFCtSpIjNVhkCCbs2pqkD7FZK7VFKXQQWA23S5OkBTFNKnQTIyAkYwhuXi9YaN9ZOICkJ2rbV+yV/9pndpvqV5cuXEx0dTe/evdm5U4fsGidgyAy+dARFAefdXw5aac5UACqIyFoRWW8NJV2FiPQUkQ0isuHYsWM+MtcQyGS4aC0yEt55R0tat2yp9z44ccJWm33NkSNHePDBB2nXrh033XQTP//8MxUremmC3hBW2D1ZHAmUBxoDHYFZIpI/bSal1EylVIxSKqZw4cL+tdAQEHi0aK1ePS1i99JLsGgRVK4Mu3b52VL/kJycTIMGDfj4448ZNWoUP//8M7VMBJUhi/gyfDQBcF61VcxKc+Yg8JNSKhHYKyK/ox3DLz60yxCEeLxoLWdOGDHisohd2bI6PSlJ9xqCnIMHD1KkSBEcDgdTpkyhdOnSRirakG182SP4BSgvIqVFJAfQAViZJs8KdG8AESmEHira40ObDEGKu8Vpbhet3XILTJ+uVygfOQIVKugIoyCVqUhJSeGNN96gUqVKvPnmmwC0aNHCOAGDV/CoiSQieYABQAmlVA8r2qeiUuoTd99RSiWJSB9gNTp8dK5SapuIjAA2KKVWWsfuEpF4IBkYqJQK7YFdQ5bI1qK1Cxd0NFH37nrIaObMy3LXQcCOHTvo3r07a9euJTY2lnvuucdukwKWxMREDh48yPnUlehhSK5cuShWrBhRmVh571H4qIi8D/wKPKqUqmo5hh+VUjWyamxWMeGj4cuKuATGrd7JoVPnKJI/NwNjK3q+aC0lBWbN0msPkpPh1VehX7+A1y+aPXs2ffr0IU+ePLz++ut07tzZLAxLh71795I3b14KFiwYlv8npRQnTpzg33//vUpMML3wUU8HTcsqpR4SkY5WYWcliP7L2apADAFD25pFs/67RUTAE09Aq1bw5JPw008B7wQAypYtS+vWrZk6dSo33nij3eYEPOfPn6dUqVJh6QQARISCBQuS2ehKTx3BRRHJjSXjLyJlgQuZM9EeUsMOU4cUUsMOAeMMwpFixeDjj/VwEWgRuw8/hBdegBw57LUNXZGNGDECgFGjRtGkSROaNGlis1XBRbg6gVSycv2eTha/DHwOFBeRd4GvgOczXZoNeF0r3xD8iOgtMkE7gaFDISYGfrE3WG3t2rXUqFGD0aNHc+zYMXwp/2IwOOORI1BKfQm0A7oAi4AYpdQ3vjPLe/hEK98QOrz0Enz0kV58dtttWt767Fm/mvDvv//St29fGjRowIULF1i9ejWzZs0K+5atwX945AhEpBZQEjgMHAJKiEhZEQn4wOxMhx0awo9779VDRN26wbhxMHmyX4s/ePAgs2fPpm/fvmzZsoW77rrLr+UbvMfQoUN5/fXXL30eMmQIkzO4n06fPk3FihUvyYN07NiRWbNm+dLMq/C0Ip8O1AI2AwJUBbYB+USkl1LqCx/Zl23y5HDt69ylG8KUfPl0WOkjj8Ctt+q0rVuheHF9zMucOHGCJUuW0KtXLypXrsyePXu4+eabvV5OuNO4ceOr0tq3b0/v3r05e/YsLVu2vOp4ly5d6NKlC8ePH+eBBx644tg333yTbnmPP/447dq1o3///qSkpLB48WLWrFlDjRo1XOZ/7733iI6OZurUqXTp0oV+/fpx8uRJevTo4eklegVPHcEhoJtSahuAiEQDI9DzBMuAgHUEu/76L1PphjCnYUP9NzkZ7rsPzp1j3fOjeO5sMa9EnSml+PDDD3nqqaf4+++/adq0KRUrVjROIEQoVaoUBQsWJC4ujqNHj1KzZk1KlizJxo0b0/3enXfeydKlS3nqqafYtGmTf4x1wlNHUCHVCQAopeJFpJJSao8ZxzSEJA4HvPsupzs9Sr1+jzEwuhEjmvUkAbIcdXb48GGeeuopli9fTu3atfniiy+MSJyPSa8FnydPnnSPFypUKMMegCu6d+/OvHnzOHLkCI8//jj//vsvDRo0cJk3tUeQkpLC9u3byZMnDydPnqRYsWKZLjc7eOoItonIm2gpaYCHgHgRyQkk+sQyg8Fu6tTh3scm0/bzd3hq3RIa7I3j/kfGse/6ooxbvTNTjiBVJC4hIYGxY8fyzDPPEBkC2keGq7nvvvsYOnQoiYmJvPfeezgcjgx7BJMmTaJy5cqMGjWKrl27sm7dukytDM4unt6JXYDeQH/r81rgObQTMEHOhpDlzzNJTL7jYT6reDsPb/yc/QX0EM5fJ/716PsHDhygaNGiOBwOpk2bRunSpalQoYIvTTbYTI4cOWjSpAn58+fH4XBkmH/nzp3Mnj2bn3/+mbx589KwYUNGjhzJ8OHD/WCtxiNHoJQ6B0ywXmk541WLDIYAokj+3CScOsfvhUsx7M4nASh85iQfvTcQKvyl9YtcDI8mJyczbdo0Bg8ezNixY3nqqaeIjY31t/kGG0hJSWH9+vUsXbrUo/wVK1Zk+/btlz5PnDjRV6a5xdPw0foi8qWI/C4ie1JfvjbOYLCbgbEVyR11Zasub0QKUWXLQM+e0KwZ/PHHFce3b99OgwYN6NevH40aNaJ169b+NNlgI/Hx8ZQrV45mzZpRvnx5u83xGE+HhuYAz6CF55IzyGswhAyp8wDOWlVPP9SMwpM7w+zZ8NxzUK0ajBwJzzzDzFmz6Nu3L3nz5mXBggV06tTJLAwLI6Kjo9mzJ/jayJ46gtNKqfDaCNZgsHArdtejh94Ws1cv+PVXEKF8+fLcd999TJkyhRtuuMH/xhoMWcBTR/C1iIxDrxm4JDanlPrNJ1Z5kagISExxnW4wZJdz11/PsEqViEpJYSTQpHBhmlSqBPnz222aweAxnlaHdYEYYBSXJ43H+8oob+LKCaSXbjB4ynfffUf16tUZO24cJ/77T4vEffQRDB8OtWrBzz/bbaLB4BGeis41cfFq6mvjDIZA5J9//qF37940atSI5ORkvvrqK9588009FzBkCHzyCZw+DfXqwYAB8J9ZxW4IbDweIBGRViLyvIgMTX350jBvkcfNGJC7dIMhIw4dOsS8efN49tln2bx5M02bpmkTtWoF27bpjXAmToQpU+wx1BA0TJ06lXLlyiEiHD9+3O/lexo+OgO9mrgvWnTuQbQaacCTM8r1gg536QaDK44fP8706dMBqFSpEnv37mXChAlcc801rr9w3XUwfTr88AP076/TtmzRPQWDIQ3169fnf//7HyVL2lOtetosvl0p9ShwUik1HKgHBMXyyFNnXStguEs3+IYVcQnUH7OG0oM+pf6YNayIS7DbJI9QSvH+++8THR1N//79+f333wE83zayfn3InVuL2LVrB9HReoc0Q0iSFRlqgJo1a1KqVKl08/hSrtrTqKHUXVzOikgR4AQQFHKJqStDXaUb/EOwbhd66NAhevXqxcqVK4mJieGrr77KujyEwwGLFsHjj+v9Dzp00PsemBBT3+JChpr27aF3b70BkQsZarp00a/jxyGNDDU+kqH2hHz58vlMrtpTR/CJiOQHxgG/ofcunu0VC3zMwNiKV1RCALmjHAyMNaqP/iK97UID1REkJyfTsGFDEhISGD9+PP369UtXJG5FXMIVi85cSlXHxMCGDTB2LLzyCnz5Jfz4IxjtoZAhqzLUnuIruWpPtYZesd5+KCKfALmUUkEx2OlqZWh29OQNmSeYtgvdv38/xYoVw+FwMH36dMqUKUO5cuXS/U6mejw5csCLL+phorfegtRzJyaCH9Umw4b0WvB58qR/vFChDHsArsiKDLU7YmNjOXr0KDExMcyePdtnctUe6+CKyO1AqdTviAhKqXe8YoUhpAmG4bnk5GQmT57Miy++yNixY+nTp4/HW0ZmqccTHX15S8xDh/R+yYMH60ijCBPRFsxkRYbaHatXr77is6/kqj2NGlqAXkB2B3Cr9YrJdul+ILW1lnDqHIrLrbVgmay0A29P7LoSbguk4bmtW7dy++23M2DAAJo1a0bbtm0z9f1s93iSk6FiRT1u3aQJ7NqVqfINgUWqDHX79u09kqEGmDJlCsWKFePgwYPccsstdO/e/ao8qXLVEyZMoEGDBpfkqr2BKKUyziSyHYhWnmT2MTExMWrDhg0e568/Zo3L1mjR/LlZO8isiUtL2mEO0JX26HbVsjWc5tEYug3MmDGDp59+mnz58jFlyhQ6dOiQaZE4r9xjSsG8efDss3D+vF6dPHCgS4lrg3u2b99O5cqVbbUhJSWFWrVqsXTpUtsUSF39H0TkV6WUywa8p33QrcBN2bTNFoJpfDoQSG+YIzu0rVmUtYOasndMK9YOamq7E0ht01SuXJkHH3yQ+Ph4OnbsmCWlUK/0eESga1eIj4cWLWDzZuMEgpCQlKEWkY/REUJ50VtT/syVonP3+ta87JMvdxSnzl29ZiBfbjMx54pQd5xnz55l6NChOBwOXnvtNRo1akSjRo2ydU6vBiTcfDN8+CFcvKg/b90KS5Zo6YqcObNlp8H3hKoM9UrgRuD7NOkNgMM+scjLuGtUmcaWa4JhYjerfPPNN3Tv3p0//viD3r17o5Ty2l4BbqWqs4LI5Up/5UodavrBBzBnjtYvMhi8TEZDQ22Aj5RS3zq/gI+Atj63zgucdLOC2F16oGDXStxAn9jNCqdPn+aJJ56gSRO9vfaaNWuYNm1acGwY83//B6tWwZkzepVy//5GxC4DAmAq01aycv0ZOYIblVJbXBS0BR1KGvC4e9QDuQqwM9Kpbc2ijG5XjaL5cyPoCc/sThTbzeHDh1m4cCHPPfccmzdvvuQQgoYWLbSIXe/eOuT0jTfstihgyZUrFydOnAhbZ6CU4sSJE+TKlStT38toaCh/OscyHCsQkbuByYADmK2UGuMm3/3AB8CtSinPQ4I8wN3tEMi3id0rcb06zGETx44dY/HixfTt25dKlSqxb98+ChcubLdZWSdvXpg6FTp1gpo1ddqmTVCiBBQoYK9tAURqCOaxY8fsNsU2cuXKlemFZhk5gg0i0kMpdYWykYh0R+9f7BYRcQDTgDuBg8AvIrJSKRWfJl9eoB/wU6YsD2FCfcLWlyilWLRoEU8//TT//PMPsbGxVKhQIbidgDOpcwTJyVoH58wZrXJ633322hUgREVFUbp0abvNCDoyGhrqD3QVkW9EZIL1+hbohq6806MOsFsptUcpdRFYjJ5zSMsrwGvA+cyZ7hnBODTkbmLW2xO2waoI6o4DBw7QunVrOnXqRLly5YiLi8u6SFyg43DA++/DTTdpuYoHH4QjR+y2yhCkpOsIlFJHlVK3A8OBfdZruFKqnlIqo7uuKHDA6fNBK+0SIlILKK6U+jS9E4lITxHZICIbMtvly+1mAxp36YGAPyZsA2nFtTccUlJSEo0bN+brr79m0qRJrF27lipVqvjA2gAidTvMUaO0tHV0NFgy2QZDZvBUdO5r4GtvFiwiEcBEoIsH5c8EZoJeWZyZcs652ZzYXXog4A+hPLvnIVLJrkT1vn37KF68OJGRkbz11luUKVOGMmXK+NTmgCIqSmsU3XcfzJx5WcTu4kUtcGcweIAvm8UJQHGnz8WstFTyAlWBb0RkH3AbsFJEvKph5K9hFm/j65W4gTIPkdWVzElJSYwfP57KlStf2jmsefPm4eUEnKlUSW+LGRGhRezKloVp0yAlcBs8hsDBl47gF6C8iJQWkRxAB/QCNQCUUqeVUoWUUqWUUqWA9cC93o4aGhhbkSjHlTMCUQ4J6rh4bxAoDjIrDmnz5s3Uq1ePgQMHEhsby/333+8r84KTlBQ9TNSnDzRqBDuzJw9iCH185giUUklAH2A1sB1YopTaJiIjRMS/0hRpB5MCOXbUTwTKwrHMOqTp06dTu3Zt9u/fz/vvv8/y5cspUqSIL00MPooVg88/1yJ227ZB9eowZowWtjMYXODTGVOl1CqlVAWlVFml1KtW2lCl1EoXeRt7uzcAeughMeXKByAxRWVbRC3YCZSFY546pNQFQlWrVqVDhw7Ex8fTvn374FgdbAci8NhjWsTunnu0QzD/K4MbPJKhDiQyK0NdetCnLjsAAuwd08prdhmyTnoS1f/99x8vvvgikZGRjBs3zmZLg5jUyePNm2HxYhg6FDK5+tQQ3KQnQ+3xDmXBSiiLqIUK7lYyf/XVV/To0YO9e/fSt29fr4rEhR2pEUSrVsHo0bBsmRaxq1/fXrsMAUHgBtN7iYGxFYmKSDNZHGEmiwOVFXEJ1H15JXmrx9K8eXPOJ8N3333HlClTjBPwBoMGwerVevObBg2gb1/491+7rTLYTMg7AuDqZcSmPglIUtcUHDx0mP+2f8d1dR8gb8dJnLg2TENCfcVdd+l9Dvr21SGmU6fabZHBZkJ+jsBsVRkcHD16lNu6j0BVaQlA8tnTOPLkA8xv5VN++klHFeXKBRs3ahG766+32yqDD/DGVpVBS6AsnDK4RinFwoULiY6OZt9nM0n8W685THUCYH4rn1K3rnYCyclaryg6Wu+QZggrQt4ReGvhVKgJtAUCf/75J61ataJz585UrFiRGk/PJOr6qyeNzcS+H3A4YOlSKFpUq5refz8cDopNCA1eIOQdQZNKruWH3aW7IpAE2kKFVJG41Ing77//npc73xUQi9zClho19FDRmDHw6ae6d2BWJYcFIe8IPt3sulXjKt1dqz+rejiGq9mzZw/JyclERkYya9Ystm7dSt++fXE4HAGzyC2siYyEF17Q6w0efxzKl9fpFy7Ya5fBp4T8OgJP9yxOTwXTzDNkn6SkJCZMmMDLL7/M2LFjefrpp2nWrNlV+UJhd7SQoEIFmDBBv09IgDp1tIN46ik9jGQIKUK+R+Ap6bX6A0WgzS6yOz+yceNG6taty6BBg2jZsiUPPvigjyw1+AQRHVnUr59ee7B9u90WGbyMcQQW6bX6A0WgzQ6yOz8ydepUbr31VhISEvjggw9YtmwZN998s2+NNniXIkX0nMGCBXrOoEYNGDnSiNiFECE/NCS4FhtNu6YsPSkKf2wUk1XS0+nxBlndwCZVDuKWW26hU6dOTJw4ketNfHrwIgKPPKIXo/Xtq3dCs1Z6+/oeNPiekHcE7tosadMHxla8Yo4Armz1B+LYdXZ39/KEzM6PnDlzhiFDhhAVFcX48eNp2LAhDRs29IotBu+R5cr7hhv0XsmJeo5tzftfcmzKLI7f1gEVldMn96DB94T80JA7eZq06cEYseKPaKbMzI988cUXVK1alTfeeIPExESCbdV6uOCVcOioKAC2z1tKjx+X8tnbfalzYCtgIuqCkZB3BO7qIlfpvt4e0tv4I5rJk/mRkydP0rVrV2JjY8mVKxffffcdkydPNiJxAYo3GxDjq7fh4YdGEpmSzJL3BjHiize55sJZE1EXZIS8Iwhl/BHN5ElP6a+//uKDDz5g8ODBbNy4kTvuuMNr5Ru8jzcbEEXy5+bHUjWIfXwac2La8EjcKh6N+zRsIupChZCfI/B0sjgYyWhew1u4mh85cuQIixYt4plnnqFixYrs27ePggULerVcg2/w5h4dl+5BcvFKsx58FN2IfUXKMiK2IsTFQfHiUKiQN8w2+JCQ7xF4OlkcjNgxr6GUYv78+URHRzN48GB27doFYJxAEOEN2ZVU0t6DJypXZ0T72rS95SZo317LVCxZYkJNA5yQ7xEUddP6KRoiXVd/RjPt27ePJ554gi+++IL69esze/ZsyqdKEBiChq93HMtUeka4vQeXLdMyFQ89BO+9B9On6zUJhoAj5HsEZocy75CUlESTJk348ccfmTZtGt999x2VKlWy26ywwZvqt74KMrjKxqTrYd06GD9e74pmROwClpDvEQAkp+mWpv1scM/u3bspXbo0kZGRzJ07lzJlylCyZEm7zQorvL1exBf7eKdr44AB0KYNzJypNYxAb5WZK1eWyzN4l5DvEQxbuY2UNPV+itLpBvckJiYyatQoqlSpwrRp0wBo0qSJcQI24O31Ir6QTMnQxnLlYOxYvYAnIQHKlIHXX9cb4hhsJ+QdwalzrtVH3aUb4LfffqNOnToMGTKENm3a8NBDD9ltUljj7aEcXwQZZMpGEY6UjYZnniGueBUeeWau2dvDZsJiaMjgOVOmTOHZZ5+lcOHCLFu2jPvuu89uk8IeXwzleDvIIDM2rjiqGNxoAHcWqMmw/81k7pQneOu3DqyYNJq2tYp5zSaD54R8j+CaHK6109Omh/tWlKlyEDVr1uTRRx8lPj7eOIEAIRjUbzNj47jVOzmXlMLK6MY07/4mn1WsT5G/DzHui9/9Za4hDSHfI7iY5HoM0jndH+Jtgcq///7L4MGDyZkzJxMmTKBBgwY0aNDAbrMMTgSy+m0qmbHRebjo7zz56HfvQCKTk0g+dQ42bYKFC2H4cMiTx2/2hzsh7wgSUzJOdzfRNWDJJp55f6MtD54/pH0///xznnjiCQ4cOED//v0vSUcbAo9AVL9Ni6c2uhpGSnJE6rU9X3yhw02XL4fZs6FxYx9Za3Am5IeGPMHdRFeyUrZsVu8Vdch0OHHiBI899hgtWrTgmmuuYe3atUycONE4AYNfSHcYaeBAWLNGJzZpAk88AadP22BleGEcAZ5NuvlTWtfX8tInTpxg+fLlvPTSS8TFxVGvXj2vnNdg8IQMo5aaNIHNm+G553SvYPp0W+0NB3w6NCQidwOTAQcwWyk1Js3xZ4HuQBJwDHhcKbXflza5wpV4myv8Ja3ri5Wfhw8f5t1332XAgAFUqFCB/fv3U6BAgSyfz2DIDhkOI+XJA+PGQceOUKWKTvv1VyhRAgpnXhPJkD4+6xGIiAOYBrQAooGOIhKdJlscEKOUugX4ABjrK3vSI20LxeFmiMRf0rrelJdWSjF37lwqV67MSy+9xO7duwGMEzAEB7VqQc6ceuFZhw5apmLRIiNi52V8OTRUB9itlNqjlLoILAbaOGdQSn2tlDprfVwP2BZE7LwpzYT21W0N1/NWuODevXu566676NatG9WrV2fTpk1GJM4QnDgcegK5TBl4+GG49144eNBuq0IGXw4NFQUOOH0+CNRNJ3834DNXB0SkJ9AToESJEt6yzy12h+t5o/ykpCSaNm3KiRMnePPNN+nZsycREd71+2bTcoNfqVoVfvwRpkyBIUP0kNFPP4ERP8w2ARE+KiKPADFAI1fHlVIzgZkAMTExPusTBlLFltVwwV27dlGmTBkiIyN5++23KVu2LMWLF/e6feG89sJgIw4HPPOM7hHMmgUVrV7yuXOQOzSk5e3Al0NDCYBzDVTMSrsCEWkODAHuVUpd8KE96eLrkE1fk5iYyMiRI6latSpTp04FoHHjxj5xAuD7yCaDIV3KloUxY7SI3cGDesho/HhISrLbsqDEl47gF6C8iJQWkRxAB2ClcwYRqQm8hXYCf/nQlgwJ5optw4YNxMTE8NJLL9GuXTs6duzo8zJ9pWlvCB+8JusSGQl16+o1CPXq6dBTQ6bwmSNQSiUBfYDVwHZgiVJqm4iMEJF7rWzjgGuBpSKyUURWujmdzwnWim3y5MnUrVuX48eP89FHH7Fo0SJuuOEGn5frzcgmQ/jh1R74TTfpieTFi2H/fqhdG15+2UQWZQKfLihTSq1SSlVQSpVVSr1qpQ1VSq203jdXSt2olKphve5N/4y+I9gqtlSRuJiYGLp168a2bdu4996M/33eaoUFgxCaIXDxeg9cRG+JGR+vw0z379dpBo8wK4stgqVi++eff+jVqxfPPvssAPXr12fmzJnkz58/w+96sxXmC017Q/jgsx54oUKwYIFekQxaxG7AAPjvv+ydN8QxjsAiGCq2VatWUaVKFWbOnElkZOSlXoGneLsV5rz2Yu2gpgH1vzIENj7vgUdaAZH/+x9MnAi33HJZw8hwFcYROBGoFdvx48d55JFHaNWqFfny5ePHH39k3LhxmRaJC9Z5EEPo4bce+IAB8O23Ouy0WTPo0QNOnfJuGSGAcQRBwMmTJ/n44495+eWX+e2336hbN711ee4JtnkQQ+ji1x54w4Z6iOj552HuXJgxw/tlBDkBsaDMcDUJCQm8++67DBw4kPLly7N//36P5gHSw5W4XnqtsEBaYGcIPfy6x0Lu3PDaa5f1igA2bIDixeHGG/1jQwBjegROBMJ2lUopZs2aRXR0NMOGDeOPP/4AyLYTgMy1woJ9gZ3B4JKaNS+L2HXsqJ3CwoVhH2pqegQWgSCZ8Mcff9CjRw++/vprGjduzKxZsyhXrpxXy/C0FZbexLLpFRiCHocDVq6Ebt2gc2d47z09ZOQHLbNAxPQILLwVUZPVXkVSUhLNmjVjw4YNvPXWW3z11VdedwKZwUwsG0KeypXh++9h8mQ9oVylCuzYYbdVtmB6BBbeqPiy0qvYuXMnZcuWJTIykvnz51O2bFmKFbNNjfsSrvaVTU03+AYzJ2MDDgc8/TS0bq3XHoSpiJ3pEVh4I6ImM72KixcvMnz4cKpVq8a0adMAaNSoUUA4AQieBXahgpmTsZnSpeHVV/Vq5AMHoFQpGDs2bETsjCOw8EbF52mv4ueff6Z27doMGzaMBx98kE6dOmXeYB8TDAvsQolgFj0MOXLkgPr14YUXtJjdpk12W+RzzNCQhTc2g/FkOOX1119nwIAB3HzzzXz88cfcc8892TfeR/g1vC/MMXMyAcSNN8KHH+rXU09BTAwMGgQjRoSsfpFxBE5kt+JLL05fKYWIUKdOHXr06MFrr71Gvnz5vGG2IQQwczIBhgg88AA0aQLPPqv3PAhRJwBmaMiruBpOefHOknw2YwTPPPMMALfffjszZswwTsBwBWZOJkApWBDmz78sYhcXB/37w5kztprlbUyPwMs49yo+/vhjnuzYnCNHjvDcc89d6hWEMibyJWvYvU+2IQMclpP++msdbvrRRzBzJtx5p712eQnjCHzAsWPH6NevH4sWLaJatWqsWLGCW2+91W6zfE4gLMoLZsycTBDw7LNw663QvTvcdRd07cqnjw1g1LqjQe3AQ35oKGek60t0l+4NTp8+zapVqxg+fDgbNmzwuRMIBGkMMJEvhjChQQMdSTR4MCnvvMPO4eODPuw35HsEF5NSMpWeVQ4cOMDChQsZNGgQ5cqVY//+/X6ZBwikVri7CJeEU+eoP2ZNULeYDIYryJULRo2iy3+lWR9VGIBbDv/O4byFOXZtgaCTYgn5HoE7KSlvSUylpKQwY8YMqlSpwsiRIy+JxPlrMjiQWuHuIlwEgr7FZDC44vvcRbgYGUVESjKTPx7Hl3N6cf+Wrzh08qzdpmWKkHcEvmTXrl00bdqUXr16UadOHbZs2eJ3faBAij93FfkiXO10zXCRIVRIbfykRDjofv9QdhUswYRVk1i0fITeNzlIMI4giyQlJXHnnXeyceNG5syZw5dffkmZMmX8bkcgbTbjKnzWXc/LLJQyhALOjZ8/ChanfacxvBLbi5iD27SI3fbtNlvoGSE/R1AgTxQnzya6TM8K27dvp3z58kRGRrJgwQLKli1LkSJFsmtmlsnsZjO+Jm3kS/0xa8xCKcMlQi28+Kqw3wLXUG30ECKvf0GvPahUiRVxCUz5eBN7z6qAvWbJ7AbodhMTE6M2bNjgcf7y//cpiS7mhaMiYNeoVh6f58KFC4waNYpRo0Yxbtw4+vfv7/F3fU0gP1xpJ7NBOyqjWxR+hOO9sCIugclvr2HpnL7MubUts269D4mK4tpckZw6m+jX51VEflVKxbg6FvI9AldOIL10V6xfv55u3boRHx9P586d6dy5s3eM8xKBHH9uFkoZUgnHzY7Grd7JeRXBT8Wr8sK382m14wdeaPE0224sCwTOWpuQdwTZZcKECQwcOJBixYqxatUqWrRoYbdJQUcgOyqD/wikwAZ/cejUOdQ1+Xmq7WBW7vyRV758k4/mP8Nbde9nXMNHQSQgnGHIOwIR19uRZqT0kJKSQkREBPXq1ePJJ59kzJgxXHfddZkuP5CHbQwGfxKOwnrO17y64u2sK3kLL66ZTcGzp6+ohOx2hiEfNXR7meszlX7q1Cm6detGv379dL7bb2f69OlZdgJmsxGDQROOwnppr/mfXNfyfMv+/F/sUwBUOfoHw76cQbnc9s7Vhrwj2HfCtad1lb5ixQqio6OZP38+efPmJbsT6YG02MtTAkWuwhB6hONmR2mvOX/uKKIcQkqEdg51Dmzl0d8+5aMZT8Lq1bbZGfJRQ6UGfer22OsP1WDc6p0cSDjM2W9ncWLLt9SoUYM5c+ZQq1atTNnlPASUL3cUIrgMWwW9yGrvGM8jlvxFOEZ1GAz+Ju1w8eib/qXha4Ngxw549FGYNAmudz1ikR3COmrIIUKyC2cnwqVKL/niWU7+voFCjR9jyGvDqFWrVKbKSFuBnjrn2gGkEqhjooEQ1WHmVAyhjqvgiZWVqvL3/71Mp4XvMvtoDm4ePcyv933IOwJXTgAg8fRfnNr6NdfVa09UgSIU7fU2ETnzMPKz33mgTqlMleGqAnVHII+JejOqIysVeiAJ6BkM/mJFXAKDP93FuTodWVS6HnuuL0rksi0c/vJbPjsVxeaUPJcatEV91DjyqSMQkbuByYADmK2UGpPmeE7gHaA2cAJ4SCm1z5s2pF1ZrFQKZ+I+4+S380ClkKdyA6IKFCEiZx5At+ZTx8U9rcg8rSh99SN6qxWdmaiO9MrMTIWeeh5X5ULox5kbDM4NyZ2FSwGQfOEid097jofP/sPIpt1ZWq05iJBw6hz939/Ihv1/M7JtNa/Z4LPJYhFxANOAFkA00FFEotNk6wacVEqVAyYBr3nbDmcnkHjiIEffG8zfX75JziKVKNJtOlEFrpaHGP7xtkxF+3gy1FM0f27WDmrqEyfgrcgkT6M6MirT00ly5/Okh92hdQaDL3F1f6dEOHj8gWHsKFyKcZ9N5p0lQyl26sil4wvX/+nVQA5fRg3VAXYrpfYopS4Ci4E2afK0AeZb7z8AmomP9nJUKckcXTKUxGP7KNiyPze0H0Fkvhtd5j15NjFT0T6uKlBnfDkc5M3IJE+jOjIq09MhJk+H1AJ1TsVg8Abu7u+91xelw8OjefGu3tQ6tIO3PxiOqMuSCN6MPvTl0FBR4IDT54NAXXd5lFJJInIaKAgcd84kIj2BngAlSpTIkjES4aBQ6wFE5r+ZyGuzNiPvroJLK6OQGjXkDy0Rb6/W9GQVcEZlejrE5ImNgTynYjB4A1fCkany7UoiWFizJWvKxnDDmZMoudx292ZPOSgmi5VSM4GZoMNHs3qeXMWqZJgnQuC6XFEuI3/Sa5naJaNgx2rNjMr0VBHV3XlScYiY0FVDyONKj6tJpcJ8+GvCpWfo0HU3cOi6G674njefcV8ODSUAxZ0+F7PSXOYRkUggH3rS2BZyOISJ7Wsw7N4qQbMC0o7VmhmV6ekQU3pDarmjHExoX904AUNY0LZmUdYOasreMa1YO6gpI9tWY3S7am7l8qMc4tVn3GcLyqyK/XegGbrC/wV4WCm1zSnPU0A1pdSTItIBaKeUap/eeTO7oAxcLyqLioBrc0W5Hb4Jpnh2O2z1VpnOUUO+DpEzGIKRFXEJDFu57dIoRYE8Ubzcukqmn4/0FpT5dGWxiLQEXkeHj85VSr0qIiOADUqplSKSC1gA1AT+Bjoopfakd86sOAKDwWAId2xbWayUWgWsSpM21On9eeBBX9pgMBgMhvQJedE5g8FgMKSPcQQGg8EQ5hhHYDAYDGGOcQQGg8EQ5gTdfgQicgzYn8WvFyLNquUwwFxzeGCuOTzIzjWXVEoVdnUg6BxBdhCRDe7Cp0IVc83hgbnm8MBX12yGhgwGgyHMMY7AYDAYwpxwcwQz7TbABsw1hwfmmsMDn1xzWM0RGAwGg+Fqwq1HYDAYDIY0GEdgMBgMYU5IOgIRuVtEdorIbhEZ5OJ4ThF53zr+k4iUssFMr+LBNT8rIvEisllEvhKRknbY6U0yumanfPeLiBKRoA819OSaRaS99VtvE5H3/G2jt/Hg3i4hIl+LSJx1f7e0w05vISJzReQvEdnq5riIyBTr/7FZRGplu1ClVEi90JLXfwBlgBzAJiA6TZ7ewAzrfQfgfbvt9sM1NwHyWO97hcM1W/nyAt8B64EYu+32w+9cHogDClifb7Dbbj9c80ygl/U+Gthnt93ZvOaGQC1gq5vjLYHP0Dta3gb8lN0yQ7FHUAfYrZTao5S6CCwG2qTJ0waYb73/AGgmIuJHG71NhteslPpaKXXW+rgevWNcMOPJ7wzwCvAacN6fxvkIT665BzBNKXUSQCn1l59t9DaeXLMCrrPe5wMO+dE+r6OU+g69P4s72gDvKM16IL+I3JydMkPRERQFDjh9PmilucyjlEoCTgMF/WKdb/Dkmp3phm5RBDMZXrPVZS6ulLp6i7rgxJPfuQJQQUTWish6Ebnbb9b5Bk+ueRjwiIgcRO9/0tc/ptlGZp/3DAmKzesN3kNEHgFigEZ22+JLRCQCmAh0sdkUfxOJHh5qjO71fSci1ZRSp+w0ysd0BOYppSaISD1ggYhUVUql2G1YsBCKPYIEoLjT52JWmss81t7K+YATfrHON3hyzYhIc2AIcK9S6oKfbPMVGV1zXqAq8I2I7EOPpa4M8gljT37ng8BKpVSiUmovet/w8n6yzxd4cs3dgCUASql1QC60OFuo4tHznhlC0RH8ApQXkdIikgM9GbwyTZ6VwGPW+weANcqahQlSMrxmEakJvIV2AsE+bgwZXLNS6rRSqpBSqpRSqhR6XuRepVQwb3jtyb29At0bQEQKoYeK0t0HPMDx5Jr/BJoBiEhltCM45lcr/ctK4FEreug24LRS6nB2ThhyQ0NKqSQR6QOsRkcczFVKbROREcAGpdRKYA66+7gbPSnTwT6Ls4+H1zwOuBZYas2L/6mUutc2o7OJh9ccUnh4zauBu0QkHkgGBiqlgra36+E1DwBmicgz6InjLsHcsBORRWhnXsia93gZiAJQSs1Az4O0BHYDZ4Gu2S4ziP9fBoPBYPACoTg0ZDAYDIZMYByBwWAwhDnGERgMBkOYYxyBwWAwhDnGERgMBkOYYxyBweAnRGSeiDxgvW9gqYNuFJHcdttmCG+MIzAY7KETMFopVUMpdc5uYwzhjVlHYDC4QUSuQUsXFEMvZnoFvYhnInpx3nH04qXDIlIOmAEURi/kehC9ovcN4E60SNhFYC6QHxiLFjv8USnVyX9XZTBcTcitLDYYvMjdwCGlVCsAEcmHVm1to5Q6JiIPAa8CjwPvAmOUUstFJBe6t30fUBGtkX8jEI9eGTtbRO4APlFKfeD3qzIY0mAcgcHgni3ABBF5DfgEOIkWsvvSkulwAIdFJC9QVCm1HEApdR5ARBoCi5RSycAhEVljwzUYDBliHIHB4Aal1O/WngYtgZHAGmCbUqqecz7LERgMQYuZLDYY3CAiRYCzSqmFaNG+ukBhS/MeEYkSkSpKqX+BgyLS1krPKSJ50FtkPiQiDmsHqSa2XIjBkAGmR2AwuKcaME5EUoBE9F7PScAUa74gEngd2AZ0Bt6yVDET0ZPFy4Gm6LmBP4F1/r4Ag8ETTNSQwWAwhDlmaMhgMBjCHOMIDAaDIcwxjsBgMBjCHOMIDAaDIcwxjsBgMBjCHOMIDAaDIcwxjsBgMBjCnP8HAsARTHvmtv0AAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1106,7 +1106,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABQc0lEQVR4nO2deZzN1fvA38/cGc2QEFrsW5ZBIVGJsjVJRdqTIksUKVJEim9JhCiyV1S2kohv+pV8lTY01kHJEmMJIYxllvP743yurnHvnXvv3P2e9+s1r7n3s53nc+/nnuec53nO84hSCoPBYDDELnGhFsBgMBgMocUoAoPBYIhxjCIwGAyGGMcoAoPBYIhxjCIwGAyGGMcoAoPBYIhxjCIw+ISIvCIiH4ZajlhERO4Wkd0ickJE6oZanrwQkXKWrDbr/XIR6eKna+frORSRnSLSwh+yRDJGEeRCRB4WkdXWg7tPRP4rIjf54brvi8irfpLRb9eKNkSko4goEXkg1LK4wpKvSj4u8SbQUyl1sVIq1cX1T1rPcLqIjLZ3wqFAKfWnJWt2sNsWkUtE5C0R+dP6PP6w3pcItizhjFEEDohIH+AtYBhwOVAOmAC0CaFYBu94DPgbeDTUggSQ8sCmPI65Ril1MdAceBjomvsAEYkPgGxBb8NN2wWAb4CawG3AJcANwGGgQajkCkuUUuZPr64uApwA7nNzzEVoRbHX+nsLuMjadwuwB+gL/AXsAzpZ+7oBmcBZq41F1vZSwKfAQWAH8LS1/VLrWnda7y8GtqE7N6fXyiWnAGMsOf4BNgC1HO7hTeBP4AAwEUhyOLcNsNY67w/gNmt7ReB/wHHg/4B3gA+tfRUAhe6E/wQOAQNdfIYNgf2AzWHb3cB663UDYLXV/gFgtBffYXkgB7gHyAKucNhn/36ed/h+2gK3A7+hlceLHn7XHYHvc7WtgCrW6/eB8cBi6/P6Gahs7VthHXvS+v4ecHIfccAgYJcl6wz083mRdY79/D9cfA7nZLHez7O+L/v31Nn6nlZY+x8HNgNHgKVAeQ+eoyRglCXjMeB7a9sFbThsi7fOXQ68DvxiXfdz4FIHea8HfgCOAuuAWxz2uXwOnXwOXdDP0MVunpmdwHPAeus+5gCJ1r5iwBfo3+cR63UZh3OXA/8BVlryfAWUcNj/qPX5HAZestpq4fAd90f/xg4Dcx0/g6D3f6FqONz+0COGLPvD6uKYocBPwGVASeth/Y+17xbr/KFAArqDyQCKWfvfB151uFYcsAYYDBQAKgHbgRRr/63oDvMyYArwicO5513LiZwp1rWLon/MNYArrX1jgIVoZVMYWAS8bu1rYP0YWlrylQaqW/t+BEajO6Mm1oOfWxFMQXcG1wBngBou5PsDaOnwfh7Q36GdDtbri4HrvfgOXwJ+sV5vAPo67LN/P4Ot76cr+gf+sfU51AROARU9+K47krcisI8644GPgNnOjnVxH4+jFX8l6zOYD8z04nxHWZKt56izw/c0AyhkfVdtrLZqWLIOAn7w4Dkaj+4ISwM24Ebr2XDWhn2boyJIB2pZx3zq8CyVtj6729HPYEvrfcm8nkMnn8Ns4IM8npmdaIVUCv2b2Ax0t/YVRw8qClrPyDxggcO5y9HPclXrPpcDwx0+9xPATejf95voAZxdEfRGP19lrHuZBMwKWf8XqobD7Q9oD+zP45g/gNsd3qcAO63Xt6A7kniH/X9hdWRcqAgaAn/muv4A4D2H92+jO7R0oLjD9vOu5UTOZuhR7vVAnMN2QY8kKztsuwHYYb2eBIxxcr1y6E60kMO2j7lQETiOln4BHnQh36vAdOt1YUum8tb7FcAQHEZWXnyHvwPPOHyW6xz22b8fm0O7CmjocMwaoK0H33VH8lYEUx323Q5scXasi/v4BnjS4X01dCcS7+H5Cj3SPmLdx6voTtX+PVVyOPa/QGeH93HoAUx5N89RnPVZXuOkbWdt2Lc5KoLhDvuT0TNcG/ACDkrP2r8UPdt0+xw6keX/HNtxccxO4BGH9yOAiS6OrQMccXi/HBjk8P5J4Evr9WAcOna0MjnLv4pgM9DcYf+Vjt9xsP+Mj+BfDgMl8rBplkJP9ezssradu4ZSKsvhfQZ6ROeM8kApETlq/wNeRPsm7ExGj5reV0od9uw2QCm1DD1lHg/8JSKTReQS9Mi2ILDGoc0vre0AZdEdR25KoX8AJx227XJy3H6H1+7u/WOgnYhcBLQDflVK2a/XGT3C2iIiq0TkDvd3qxGRRmizwWyHNmqLSB2Hww6rfx2Wp6z/Bxz2n3KQOa/vOi88/Syc4azteM5/NvKinlKqmFKqslJqkFIqx2HfbofX5YGxDs/D3+gBQ2k3z1EJIBHnz4qzNvLavws9SythyXNfrt/FTeiO0tPn0M5h67y8cPpdiUhBEZkkIrtE5B/0IKVoLse7q++5lOM9KqUyLHnslAc+c7jHzUA23n3HfsMogn/5EW3OaOvmmL3oL9BOOWubJ6hc73ejR+JFHf4KK6VuB7AetsnoKfaTuaJMcl/rwsaUGqeUuhY92qoK9EPb7k8BNR3aLKK0U9EuU2Unl9sHFBORQg7byuV5x65lS0P/gFuhHZkfO+z7XSn1ENok8wbwSa52XfEYugNbKyL70XZ5+3ZfcPddn0QrVABE5Aof2/Cm7SzOV1r5wfH52Q08kes5TFJK/QBun6PTOH9WnLXhjLIOr8uhR8OHLHlm5pKnkFJqON4/h18DKR4+P87oi56NNVRKXYI2RYF+zvJiH9rso08QSUKbmuzsBlrlus9EpVS6j7LmC6MILJRSx9DTufEi0tYaDSSISCsRGWEdNgsYJCIlrfCzwYCnMcwH0DZfO78Ax0XkBRFJEhGbiNQSkeus/S+if0yPAyOBGQ4jkdzXOg8RuU5EGopIArrTOg3kWKPCKcAYEbnMOra0iKRYp04DOolIcxGJs/ZVt0brq4EhIlLACqe908P7dsXHaDtpE7Tt1S77IyJS0pL1qLU558LTz7vfROB+tCO9jsNfL+BhHyNX3H3X64CaIlLHavsVL6/t9vuz2n5WRCqKyMXoKLY5uWab/mIiMEBEagKISBERuc967e45mg6MFpFS1rN7gzXD85RHRCRZRAqi/TGfWLO1D4E7RSTFum6iiNwiImV8eA5nojvcT0WkuvVMFxeRF0Xkdg9kLIweOB0VkUuBl724v0+s+7jRil56hfMVyETgNREpD2A9Z228uL5fMYrAAaXUKKAP2mF2EP0Q9QQWWIe8in4Q16Nt979a2zxhGpBsTQUXWA/9HegOawd6NDQVKCIi11pyPGod9wZaKfR3di0nbV2C7vCP8G/Uwkhr3wto5+BP1nT3a/SoB6XUL0AntEP5GDo6wz4yfRjt1/gb/YOY4eF9u2IWcDOwTCl1yGH7bcAmETkBjEX7GU4BWHHgjZ1cqy36BztDKbXf/ofurOKta3qLy+9aKfUbuvP6Gu2X+N7La78CfGB9f/c72T8d3YmtQD8bp9FKze8opT5DP1+zredhI3qmBu6fo+fQn8sq9DPxBt71JzPRvpT9aDPT05Y8u9EO7Bf59zfYz+HaHj+HSqkzQAtgC9pf8A96AFaCf2eM7ngL7QQ+hHbsfunpzSmlNqG/s9no2cEJtM/wjHXIWHTQxlcicty6fkNPr+9vxHJUGAwGgyFAWDO7o8BVSqkdIRbnAsyMwGAwGAKAiNxpmZgLocNHN6CjlMIOowgMBoMhMLTh3wWJV6HNnGFpgjGmIYPBYIhxzIzAYDAYYpyQJYTylRIlSqgKFSqEWgyDwWCIKNasWXNIKVXS2b6IUwQVKlRg9erVoRbDYDAYIgoRcbkK25iGDAaDIcYxisBgMBhiHKMIDAaDIcYxisBgMBhiHKMIDAaDIcYJmCIQkeki8peIbHSxX0RknIhsE5H1IlIvULIYDAaDwTWBnBG8j/usj63Qy66vQqcPfjeAshgMBoPBBQFTBEqpFehUsa5og04brJRSP6Er/3hSTch3/vgDTp8OaBMGg8Hgb06ePMnOnTsDdv1Q+ghKc365uj3WtgsQkW4islpEVh88eNC31rKyoHVrqFMHVq707RoGg8EQZJYtW8bVV19Nu3btyMlxW6PJZyLCWayUmqyUqq+Uql+ypNMV0nkTHw9jx+oZQePG8PTTcOKEfwU1GAwGP3H06FG6du1K8+bNiYuLY8yYMcTFBabLDqUiSOf8uqVlrG2BIyUFNm6Enj3hnXegVi3YEXY1IgwGQ4yTnZ3NjTfeyPTp03n++edZv349N998c8DaC2WuoYVATxGZjS7RdkwptS/grV58MYwbBw88ABMnQjmr9rVSIJ7UpDYYDIbAcPjwYS699FJsNhuvvfYaZcuWpX79+gFvN5Dho7OAH4FqIrJHRDqLSHcR6W4dsgTYjq6fOwV4MlCyOKVRI5g5E2w2OHgQrrkG5s8PqggGg8EAoJTiww8/pGrVqkydOhWAu+++OyhKAAI4I1BKPZTHfgU8Faj2veLoUe1DuOce/ffOO3DFFaGWymAwxAC7d++me/fuLFmyhOuvv55GjRoFXYaIcBYHnKuugp9/htdfhy++gORkeP99bS4yGAyGADFr1ixq1qzJ8uXLeeutt/j+++9JTk4OuhxGEdhJSID+/WHdOqhZExYtMj4Dg8EQUIoVK0bDhg3ZuHEjvXv3xmazhUSOiKtZXL9+fRXwwjQ5OXDyJBQuDL/9BkuXwlNPQYBCtwwGQ2yQlZXFmDFjOHv2LAMHDgS0f0CCMOgUkTVKKadOB9OzOSMuTisB0Caip5/Waw82bw6pWAaDIXJZt24d119//blwUPsgPBhKIC+MIsiL116DGTNgyxa9KnnYMMjMDLVUBoMhQjhz5gwvvfQS9evXZ/fu3cybN4/Zs2eHhQKwYxRBXohAhw6QlgZt28LAgTB6dKilMhgMEcLvv//OG2+8wcMPP0xaWhr33ntvWCkBiMDi9SHj8sthzhytFJo21du2bYPSpSEpKbSyGQyGsOLEiRN8/vnntG/fnlq1arFlyxYqVaoUarFcYmYE3nLHHVCo0PlJ7L7/PtRSGQyGMOH//u//qF27Nh06dGCz5VcMZyUARhHkyYLUdBoNX0bF/otpNHwZC1KtdEjx8TB+PJw9qx3JPXvC8eOhFdZgMISMI0eO0LlzZ2699VYKFCjA//73P2rUqBFqsTzCKAI3LEhNZ8D8DaQfPYUC0o+eYsD8Df8qgxYtYMMG6N0bJkzQ6w+2bw+pzAaDIfhkZ2fTqFEjPvjgAwYMGMC6deto3LhxqMXymJjwESxITWfk0q3sPXqKUkWT6JdSjbZ1nZY+OI+RS7dyKjP7vG2nMrMZuXTrv+dffDG89ZZOYvfuu1C+vN6ek2PWHRgMUc6hQ4fOJYkbNmwY5cqVo169yKu6G/U9VZ6jejfsPXrK8+033KDDTO1J7GrXhrlzTZoKgyEKUUoxY8aM85LEtW3bNiKVAMSAInA3qs+LUkWdRwO52n6OY8d0JNEDD0C7drB3r8fyGgyG8GbXrl20atWKxx57jBo1atCkSZNQi5Rvol4ReDWqz0W/lGokJZyf+yMpwUa/lGruT6xSBX76CUaMgC+/hORkUl9+k0avf3Oh09lgMEQMH374IbVq1eL777/n7bff5rvvvqN69eqhFivfRL0i8HlUD7StW5rX29WmdNEkBChdNInX29X2yL+wYMMBGmVfS9MOY1ldtBz75i4g/djpc+apfp+sM8rAYIgwSpYsSaNGjdi0aRM9e/YMWOnIYBP1SefsPgJH81BSgs3jDt0XcrcpKoekzDNkFEii0uE93LxjDR/UuwNsNpTCKwe2wWAIHpmZmYwaNYrMzExeeuklIHhJ4vxNTCedy8+o3ldy+yWUxJFRQM9A7t70LS9/M4VPPnqeSgf/9NqBbTAYgkNqaioNGzZkwIABpKWlhVWSOH8T9TOCQJBXOGrF/otx+akqRZu05bz8zRQKnc3gnRseYOL195JpS6B00SRW9m8WlHswGAzOOX36NEOHDmXEiBGUKFGCCRMm0K5du1CLlW9iekbgbzwJR3XrfxDh85pNadl5Akur3kjf7z+i86rPAc8c2AaDIbBs27aNN998k0cffZTNmzdHhRLIC6MIvGBBajp9567LMxzVWbRRbg4XKsrTdz1Px3tf1v4CoGHmIcjI8L/gBoPBLSdOnGDmzJkA1KpVi61btzJ9+nSKFSsWYsmCg1EEHmKfCWS7MKU5juad+SUeub7cufdFkxJIsGk74/LK13GqQCK2nGyGfzCIE9Vrwv/+F4Q7MhgMAEuXLqVmzZo89thj55LEVaxYMcRSBReTYsJDnC1McyS3Oaht3dJu21iQms6QRZs4kqGL3GTH2RjQsgdvfPk2F99yC3TvDm+8AZdc4pWcBoPBMw4fPkyfPn2YMWMG1atX57vvvouYJHH+JuoVQe5QTrtN346nCsKd/d6jRWa5aFu3NCOXbj2nCAB+LH8Ntz7+DoNXzeHhyZPhiy/07CDMU9gaDJGGPUnctm3bGDhwIIMGDSIxMTHUYoWMqFcErlJMvLJwE2eycpwqCGfKoFTRJNKdKAObiM/hqM6Uy+mERAbe+BgPv/kcTJxoktgZDH7k4MGDFC9eHJvNxhtvvEH58uWpU6dOqMUKOVHfs7gayR89lelVDiJX6SZG3X+Nz2sS3K56btAApk/XSez++gtq1YLZs00SO4PBB5RSvPfee1StWpUpU6YA0KZNG6MELKJeERRJSvDqeFeKIxAL0zzOZXT8uE53/dBD0LYtXy5d7bxYjsFguICdO3eSkpLC448/Tu3atWlqLzVrOEfUm4Yys3O8Ot7dGoC8HMDeYr9Wnn6KypXhxx9h7FiyBg6k0dKvaXzL48y+JiVPk5bBEMvMnDmTHj16ICJMmDCBJ554ImryA/mTqFcEJ8+6jvTJjS9O3/zisXKx2aBPHx7edxnPzB1J452pzK5zG+CkWI7BYADg8ssvp0mTJkycOJFy5cqFWpywJepTTFTov9ij4+IELklM4NipzLBOAlex/2KUUhTMPE1GgSQqH95N0z9W8V79Nvwx4q5Qi2cwhJTMzExGjBhBdnY2gwcPDrU4YUVMp5go6oGPIMEm2EQ4eioz7JPAlSqaBCLnkti12bScQd9OZ9Gs52HjxhBLZzCEjl9//ZXrrruOQYMGsXXrViJtkBtKol4RvHJXTRLizs8WGCdaQdidvoUKxJOZc/5D42kVs2CT28E8uvEj9L37BSqfOAj16sErr8DZs6ET0GAIMqdOnaJ///40aNCAAwcO8Nlnn/HRRx9FZZbQQBFQRSAit4nIVhHZJiL9newvJyLfikiqiKwXkdv9LUPbuqUZed8150X7jL6/DmtfvpUdw1uzsn8zjp3KdHpuOCaBuyB6qVhBGr/Ui4t+3wr33w9DhsDo0aEW02AIGtu3b2f06NF07NiRtLQ02rZtG2qRIo6A+QhExAb8BrQE9gCrgIeUUmkOx0wGUpVS74pIMrBEKVXB3XUDkYa60fBlTheLRWRa6KVLoXFjKFgQtm6FsmX1a4Mhivjnn3+YP38+HTt2BHQd4fL2xZcGp4TKR9AA2KaU2q6UOgvMBtrkOkYB9mQ6RYCQVHn3uTZxOJKSojv+rCy46y6oXRu+/TbUUhkMfmPJkiXUqlWLzp07n0sSZ5RA/gikIigN7HZ4v8fa5sgrwCMisgdYAvRydiER6SYiq0Vk9cGDB/0uqK+LxRakpofvwq74eJg8WaelaNYMunWDY8dCLZXB4DOHDh2iQ4cOtG7dmsKFC7Ny5cqYTRLnbwJpGroXuE0p1cV63wFoqJTq6XBMH0uGUSJyAzANqKWUcrkKLBwqlEFoaiH7REaGdiCPGgVXXAErVugFagZDBJGdnU1ycjLbt2/nxRdf5MUXX+Siiy4KtVgRRahMQ+lAWYf3ZaxtjnQG5gIopX4EEoESAZTJb7hKZhd2kUYFC8KIEfDzz9CqFVSooLfneLfi2mAIBQcOHCAnJwebzcabb77JmjVrGDJkiFECfiaQimAVcJWIVBSRAsCDwMJcx/wJNAcQkRpoReB/208AcBVRFI6RRgDUrw9Tp/6bxC45GT7+2CSxM4QlSimmTZtGtWrVmDx5MgB33nknV199dYgli04CpgiUUllAT2ApsBmYq5TaJCJDRcS+BLYv0FVE1gGzgI4qQlaBuM0cGu6cOAHFikH79nDnnbB7d97nGAxBYvv27bRo0YIuXbpQp04dWrRoEWqRop6AriNQSi1RSlVVSlVWSr1mbRuslFpovU5TSjVSSl2jlKqjlPoqkPL4k4iONKpUCb7/Ht56S0cU1aypax9Ehg42RDEffPABtWvXZtWqVUycOJFly5ZRpUqVUIsV9UR90rlA4XHm0HDFZoPevfWMoFs39sxfwgNHq0bmvRiihlKlStGsWTPeffddypQpE2pxYgajCHzEH3WQ/XGNfFOpEgtGvM+Quas5cvQUlQ/vpvnPvzDo+D2ASW1tCCxnz55l+PDh5OTk8Morr9CyZUtatmwZarFiDqMIfMBdHWRPO05/XCM/OCqhOBGy0cn57kr7H71/mE3rLd8z6kQ/2tbtGnBZDLHJqlWrePzxx9m4cSMdOnRAKWXyA4WIqE86Fwj8EToayvBTuxJKP3oKBWQ7+AbG3NSeJ9v0p9Q/B5n2Tg8YPBjOnAm4TIbYISMjg+eee47rr7+eI0eOsHDhQmbMmGGUQAgxisAH/BE6GsrwU2dK6BwiLKl+Ey27TODra5rBf/4DY8YEXCZD7LBjxw7efvttunbtyqZNm7jzzjtDLVLMY0xDPlCqaJLTJHXehI764xq+4omyOXNJMc5Mew8OpUGjRnrjli06iV2hQgGW0BBtHDt2jPnz59OpUydq1qzJtm3bKFu2bN4nGoKCmRH4gD9CR0MZfupK2dhELsy11LLlhUnsvv464DIaoofFixdTs2ZNunTpwpYtWwCMEggzjCLwAV+T1Pn7Gr7iSgmNuv+aczUaLpAjPl6vTI6P18qhc2c4ciTgshoil4MHD9K+fXvuuOMOihUrxo8//kj16tVDLZbBCVFfs9jgHJ9DV0+dgqFDYeRIKFkSvvsOzIIfQy7sSeJ27NjBoEGD6N+/PwUKFAi1WDGNu6RzRhEYfOPXX/Vq5Hff1YvTsrP1f0NMs3//fi677DLi4uL44osvqFChArVq1Qq1WAZivHi9IUDUq6frHdhscOAA1KgBM2eaNBUxSk5ODpMmTaJq1apMmjQJgDvuuMMogQjBKAJD/snI0GaiRx+F22+HP/8MtUSGILJt2zaaN29O9+7due6660hJSQm1SAYvMYrAkH8qVtS+gnHj9P+aNWH8eDM7iAHee+89ateuza+//sqUKVP4+uuvqVSpUqjFMniJUQQG/xAXB716wcaNcOONuhKaWSka9ZQrV46UlBTS0tLo0qWLWR0coRhncS6ClQguLBLOBQqldHRRwYKweTMsXAh9++rQU0NEc+bMGV5//XVycnIYOnRoqMUxeIFxFntI7hw89kRw/i5KH6x2QoaIVgIAc+ZA//7QsCGsXRtSsQz54+eff+baa69lyJAh/Pnnn0TaINLgGqMIHPA1EdyC1HQaDV9Gxf6LaTR8WZ4desTUO/YHr7wCn3wC6em6XObAgXD6dKilMnjByZMn6dOnDzfccAPHjh3jiy++4P333zdmoCjCKAIHfEkE58vo3tX10o+e8liZRBT33ANpaTqqaNgwXRnNEDHs2rWLCRMm0L17dzZt2kTr1q1DLZLBzxhF4IAvdYh9Gd27u56nysTbWUjIufRSmD4dvvkGnn5ab9u8WddPNoQdR48eZerUqQAkJyezbds2JkyYwCWXXBJiyQyBwCgCB3xJBOfLLMJZO7lxp0wi2sfQrNm/SezatIFateCriClVHRN8/vnnJCcn071793NJ4kzZyOjGKAIHfEkE58ssInc7rnClTKLCxxAfD++9B0lJkJICnTrB33+HWqqY5q+//uLBBx+kbdu2lCxZkp9++skkiYsRTDxfLtrWLe1VGGe/lGrnlZwEz9JJO7bTaPgyr2oThLKojT9wDJ2t8PAYXl4/n5tmTOPIvAU81X0cD7d3kv3UEFCys7Np1KgRf/75J6+++irPP/88CQkJoRbLECSMIsgn9g4rP2sCvFUmoSxqk19y12recTKbjpXbkPxobdqvXcIqW1E2zN8A2dm0rV8uxNJGP3v37uWKK67AZrMxduxYKlSoQHJycqjFMgSZmFhQFgmLt7yRMXdnClpxBKueQX5wNftxpMTJIyz4+AXKjHoNHnvMrFAOAPYkcS+88ALDhw/nySefDLVIhgDjbkFZ1M8IcneadscqEFadpjcmKX/MQkKFJ+arxKyz7CtYlDKdOsHHH+sspxUqBF64GOG3336ja9eurFixghYtWtCqVatQi2QIMVE/I3A1Ai1dNImV/Zv5UzSDB3gyIwAoc8lFfF/0N3jhBZ2yYtgwncvIzA7yxbRp0+jZsyeJiYmMHj2ajh07moVhMUJMp5iIdMdqtOFJ6GxSgo3nWtWAJ5/USewaN4YffzRKwA9UqFCBVq1akZaWRqdOnYwSMAAxYBqKZMdqNOLMrNW0ekm+3XLQuZmrfHlYsuTftBRpafDZZ/D882CiWvLkzJkz/Oc//wHg1VdfpXnz5jRv3jzEUhnCjahXBL6GdxoCh7chuojo9QYA8+bp/EXz5umVyvXqBUTGaOCHH36gc+fObNmyhccffxyllJkBGJwS9aYhXxaJGcKYl1/WM4IDB6BBA53Z9JQx8zly4sQJevfuzU033URGRgZffvkl06ZNM0rA4JKAOotF5DZgLGADpiqlhjs55n7gFXSanXVKqYfdXdMUrzcAcOQI9OsH06bB669rhWAAIC0tjXr16tG1a1eGDRtG4cKFQy2SIQxw5ywOmCIQERvwG9AS2AOsAh5SSqU5HHMVMBdoppQ6IiKXKaX+cnddowgM57F8ua51kJQEmzZBuXIQgx3fkSNHmDdvHt26dQP0QrFSpUqFWCpDOBGqqKEGwDal1Hal1FlgNtAm1zFdgfFKqSMAeSkBX4m4TJ0Gz7nlFq0EsrKgbVtdL/m//w21VEHls88+Izk5mSeffJKtW3W+KaMEDN4QSEVQGtjt8H6Ptc2RqkBVEVkpIj9ZpqQLEJFuIrJaRFYfPHjQKyEiOlOnwXPi42HGDLj4Yrj9dl374PDhUEsVUPbv3899991Hu3btuOKKK/jll1+oVs0EQRi8J9TO4njgKuAW4CFgiogUzX2QUmqyUqq+Uqp+yZIlvWogKjJ1GjzjhhsgNRVeeglmzYIaNeD330MtVUDIzs6mcePGLFq0iGHDhvHLL79Qz0RQGXwkkOGj6UBZh/dlrG2O7AF+VkplAjtE5De0YljlLyHMgrIY46KLYOhQuPdemDgRKlfW27Oy9KwhwtmzZw+lSpXCZrMxbtw4KlasaFJFG/JNIGcEq4CrRKSiiBQAHgQW5jpmAXo2gIiUQJuKtvtTCF/qBRiigKuvhgkTIC4O9u+HqlV1hFGEpVSxk5OTw9tvv0316tV59913AWjVqpVRAga/4NEQSUQKAn2Bckqprla0TzWl1BeuzlFKZYlIT2ApOnx0ulJqk4gMBVYrpRZa+24VkTQgG+inlPKrYdcsKDNw5oyOJurSRZuMJk+GSpVCLZXHbNmyhS5durBy5UpSUlK44447Qi1S2JKZmcmePXs4bV+JHoMkJiZSpkwZr+pJeBQ+KiJzgDXAo0qpWpZi+EEpVcdXYX0lWtNQGwJMTg5MmaLXHmRnw2uvQe/eYZ+/aOrUqfTs2ZOCBQvy1ltv0aFDB7MwzA07duygcOHCFC9ePCY/J6UUhw8f5vjx41SsWPG8ff5IQ11ZKfWAiDxkNZYhEfQpe53SIJ8YxROGxMXBE09A69bQvTv8/HPYKwGAypUrc+edd/LOO+9w+eWXh1qcsOf06dNUqFAhJpUAgIhQvHhxvI2u9FQRnBWRJPTqX0SkMnDGOxFjg0ipfxCzlCkDixZpcxHoJHaffqrTXRcoEFrZ0B3Z0KFDARg2bBhNmzaladOmIZYqsohVJWDHl/v31Fn8MvAlUFZEPgK+AZ73urUYwISrRgAikJioX3/6KQweDPXrwyq/Bav5xMqVK6lTpw6vv/46Bw8eJNJqhRgiF48UgVLq/4B2QEdgFlBfKbU8cGJFLiZcNcJ46SX4/HO9+Oz663V664yMoIpw/PhxevXqRePGjTlz5gxLly5lypQpMT+yNQQPjxSBiNQDygP7gL1AORGpLCKRH5jtZ2I5XDWSUnk4ylp3bSI3PfoOs2q3hJEj2fTCf4Iqy549e5g6dSq9evViw4YN3HrrrUFt3+A/Bg8ezFtvvXXu/cCBAxk7dqzbc44dO0a1atXOpQd56KGHmDJlSiDFvABPO/IJQD1gPSBALWATUEREeiilvgqQfBFHrIarRpJvZNCCDXz005/YDS9HMjI5QgEG3NaLz2o25bdC1XklNZ22CUegbFkoUsTvMhw+fJi5c+fSo0cPatSowfbt27nyyiv93k6sc8stt1yw7f777+fJJ58kIyOD22+//YL9HTt2pGPHjhw6dIh77733vH3Lly93297jjz9Ou3bteOaZZ8jJyWH27NksW7aMOnXqOD3+448/Jjk5mXfeeYeOHTvSu3dvjhw5QteuXT29Rb/gqSLYC3RWSm0CEJFkYCjaTzAfCGtFEMwonkguLJ8f3PlGwuneF6Smn6cEcvNL2VoAjPpvGm3fe1LXOpg0SUcb+QGlFJ9++ilPPfUUf//9N82aNaNatWpGCUQJFSpUoHjx4qSmpnLgwAHq1q1L+fLlWbt2rdvzWrZsybx583jqqadYt25dcIR1wFNFUNWuBACUUmkiUl0ptT3c7ZihGKkGO1w1HIgU38jIpVtdKgFH9vxzFj76CDp3hjvugIcfhrfeAi9zXTmyb98+nnrqKT777DOuvfZavvrqK5MkLsC4G8EXLFjQ7f4SJUrkOQNwRpcuXXj//ffZv38/jz/+OMePH6dx48ZOj7XPCHJycti8eTMFCxbkyJEjlClTxut284OnimCTiLyLTiUN8ACQJiIXAZkBkcxP+HOkap9ZpB89hU2EbKUoHSMj/ryIlNrQniqmUkWTdAW0NWt04ZvXXoOvvoIffoCrrvK6XXuSuPT0dEaMGMGzzz5LfBTkPjJcyN13383gwYPJzMzk448/xmaz5TkjGDNmDDVq1GDYsGF06tSJH3/80auVwfnF0yexI/Ak8Iz1fiXwHFoJhHWQs79GqrlnFtlWaF8428L9jTsTW6T4RlwpLEcSbPKv3AUK6PKY99yjTUT2JHaZmeDBD3X37t2ULl0am83G+PHjqVixIlWrVs3vbRjCmAIFCtC0aVOKFi2KzWbL8/itW7cydepUfvnlFwoXLkyTJk149dVXGTJkSBCk1XgaPnpKKTVKKXW39femUipDKZWjlDoRaCHzg7+ieJzNLOzEwjqBvOo6REpt6H4p1UhKyOPH6cx2VKsWvP32+UnspkxxmcQuOzubcePGnZckLiUlxSiBGCAnJ4effvqJzp07e3R8tWrV2Lx587mSoqNHjw6qEgDPw0cbicj/ichvIrLd/hdo4fyBsx++LyPVvGYQ4WYL9zeeLJRrW7c0K/s3Y8fw1qzs3yzslABcqLBsTnxcmTnKvWI/exYqVoRu3aB5c/jjj/N2b968mcaNG9O7d29uvvlm7rzzTj/fhSFcSUtLo0qVKjRv3pyrfDAhhgpPTUPTgGfRieecD4vDFH9F8eRlUgg3W7i/8dTEFgl5lhyd+RX7L3Z6jFvFXq4cfPMNTJ0Kzz0HtWvDq6/Cs88yecoUevXqReHChZk5cybt27c3C8NiiOTkZLZvj4gx8nl4qgiOKaUithCsP6J4nNnA7dhnGJHQCfqKJ87gSFpLYMdnJ7cIdO2qy2L26KGdyiJcddVV3H333YwbN47LLrssQFIbDP7F01xD34rISBG5QUTq2f8CKlmY4WhSgH9NCnZbOBDVtZE9MbFFYp6l/JoOT116KS9Ur84gax1A05IlmV29OpcVLepvUQ2GgOHpjKCh9d8xl7UCmvlXnPDG3cyi0fBlEbGgylc8MbFFyloCR/JjOlyxYgVdunTh999/p3v37iilkM8/hyFD4JNPYPp0HYJqMIQ5HikCpVRYh4iGA646u/Sjp1iQmh41ysDdfUTKWoLceGs6/Oeff+jfvz/vvvsulSpV4ptvvqFZM2tMNHAg1Kmjax7ccAM884yuoVyoUEBkNxj8gcc1i0WktYg8LyKD7X+BFCzScNfZRZOJyB3+itAKd/bu3cv7779Pnz59WL9+/b9KwE7r1rBpky6EM3o0jBsXGkENEcM777xDlSpVEBEOHToU9PY9DR+diF5N3AuddO4+dDZSg4W7+PRwt5P7i0hZS+ALhw4dYsKECQBUr16dHTt2MGrUKAq5GulfcglMmADff69nBQAbNsCxY8ER2BBRNGrUiK+//pry5UPTrXrqI7hRKXW1iKxXSg0RkVFAxEQRBSOax369Z+asdbo/nO3k/iTa8iwppZg7dy69evXi6NGjtGjRgqpVq3peNrJRI/0/OxvatdO1DiZOBLO2ICoZPHgwl156Kc9Yyn/gwIFcdtll9O7d2+15devWzfPax44do0GDBixcuJBq1arx0EMP0axZM79kKvVUEdh7sQwRKQUcBiIiXWIwQxrb1i19LhdRbsLdTm64kL1799KjRw8WLlxI/fr1+eabb3xfGWyzwaxZ8PjjcNdd8OCDMHYsmBDTwOIkDTX33w9PPqmVspM01HTsqP8OHYJcaagJUBpqTyhSpEjA0lV7qgi+EJGiwEjgV3TE0FS/SBBggp0eOVJy7hjck52dTZMmTUhPT+fNN9+kd+/e+U8SV78+rF4NI0bAf/4D//d/OomdSTsRNfiahtpTApWu2tOoIXvJpk9F5AsgUSkVEcZOV6uB80o85iuxWo8gWti1axdlypTBZrMxYcIEKlWqRJUqVfzXQIECMGiQNhNNmgT2a3uYxM7gJe5G8AULut9fokSeMwBn+JKG2hUpKSkcOHCA+vXrM3Xq1IClqxZPC2SLyI1ABRyUh1Jqhl+k8IL69eur1atXe3x85QFLzmUKdcQmwh+vO5kWBoBoXnEcLWRnZzN27FgGDRrEiBEj6NmzZ/Aa37tX10seMEBHGsV5HMxnyMXmzZupUaNGSGU4e/YstWvXJjMzk99//92jDKR2KlSowOrVqylRooTT/aNGjWLr1q106NCBZ5991mW6amefg4isUUrVv+BgPI8amgm8CdwEXGf9Ob1guOFMCbjb7m/yytppCD0bN27kxhtvpG/fvjRv3py2bdsGV4DsbKhWTdutmzaF338PbvsGv2JPQ33//fd7rATGjRtHmTJl2LNnD1dffTVdunS54Bh7uupRo0bRuHHjc+mq/YFHMwIR2QwkK0+nDwHE2xlBnSFfcfTUhbVziiYlsPblwBcJbzR8mVMzVOmiSazsH1MLs8OSiRMn8vTTT1OkSBHGjRvHgw8+GJokcUrB++9Dnz5w+rRendyvn85pZPCYcJgR5OTkUK9ePebNmxeyDKQBmREAG4Er8ilbSHD1OwrW7ysS0y7EAvYxTY0aNbjvvvtIS0vjoYce8qsSWJCaTqPhy6jYfzGNhi9zPwsUgU6dIC0NWrWC9euNEohAojINtYgsQkcIFUaXpvwFOGPfr5S6K7Di5Z+jGc4rabra7m8iNe1CtJKRkcHgwYOx2Wy88cYb3Hzzzdx8881+b8fnsOUrr4RPP9U1DwA2boS5c3Xqiosu8rucBv8SqWmo85oRLAR+AV4B2gLDgFHWts8DKZi/8FeFMl8Jh7QLXo1Mo5jly5dz9dVXM2rUKE6cOEEgLZ35ysQq8m+nv3ChDjWtWxd+/DEAkhoMeSuCNsDnSqn/Of6hlUDbgEvnB/qlVCMh7vwpdkKcBK0jblu3NPdcW/pc2mqbCPdcm7/Vt9507MZZrVdkPvHEEzRtqnMnLlu2jPHjxwfUF+A3k+CLL8KSJXDihF6l/MwzcPJk/gWMYsLAlRlSfLn/vBTB5UqpDU4a2oAOJY0Mcv/eg2h6XZCazqdr0s9FKWUrxadr0n3uiL3t2COxRoC/2bdvHx9++CHPPfcc69evP6cQAolfZ6KtWukkdk8+qVcjv/12PqWLXhITEzl8+HDMKgOlFIcPHyYxMdGr8/JaUFbUzb48n2gRuQ0YC9iAqUqp4S6Ouwf4BLhOKeV5SJAHjFy6lczs8x+KzGwVtDoB/l7Z7O31YtVZffDgQWbPnk2vXr2oXr06O3fupGTJkkFr3+8rzAsXhnfegfbttZkIYN06XTazWDE/SBwd2EMwDx48GGpRQkZiYqLXC83yUgSrRaSrUmqK40YR6YKuX+wSEbEB44GWwB5glYgsVEql5TquMNAb+NkryT0k1B2hv9v39nqx5qxWSjFr1iyefvpp/vnnH1JSUqhatWpQlQAEZoX5gtR0Rv7vFHs//4YylxTgvxO7cXHmaZ3l9O67/SV6RJOQkEDFihVDLUbEkZdp6Bmgk4gsF5FR1t//gM7oztsdDYBtSqntSqmzwGy0zyE3/wHeAE57J7pnhNpZ7O/2vb1eODirg8Xu3bu58847ad++PVWqVCE1NdX3JHF+oG3d0qzs34wdw1uzsn+zfCsBR5Pg7n/O8titfTlapLhOV3HffbB/v/+EN8QUbhWBUuqAUupGYAiw0/obopS6QSmV11NXGtjt8H6Pte0cVt3jskqpxe4uJCLdRGS1iKz2dsrXtLrzkaCr7f7G3x2xt9eL5hoBjmRlZXHLLbfw7bffMmbMGFauXEnNmjVDLZbfcGYSXFOiInd1GA3DhsGiRZCcDL/9FiIJDZGMp0nnvgW+9WfDIhIHjAY6etD+ZGAy6JXF3rSzeP0+l9tfbVvbm0v5hL9NBL5cL9pqBDiyc+dOypYtS3x8PJMmTaJSpUpUqlQp1GL5HVemv93HM2H4AG0amjz53yR2Z8/qBHcGgwfkM6+uW9KBsg7vy1jb7BQGagHLrTC+K4CFInKXPx3GR1wsHHO1PRD4uyOO5o7dU7Kysnjrrbd46aWXGDFiBL169aJFixahFitg5OnrqV5dl8UEncSuYUPo3x969DBJ7Ax5EsgnZBVwlYhUFJECwIPoBWoAKKWOKaVKKKUqKKUqAD8BflUCBvdE6kKz9evXc8MNN9CvXz9SUlK45557Qi1SwPHKJJiTo81EPXvCzTfD1tgJFTb4RsAUgVIqC+gJLAU2A3OVUptEZKiIBC01RdEk5zneXW2PFSJ1odmECRO49tpr2bVrF3PmzOGzzz6jVKlSoRYr4Hjl6ylTBr78Uiex27QJrrkGhg/Xie0MBid4XI8gXPA2++iC1HT6zVtHZs6/95kQJ4y875qYNq9EWlZUpRQiwooVK5gyZQpjxoxxmbPd4MD+/XpmkJQEM2eGWhpDCHGXfTSQPoKwwFQMc06o11d4ysmTJxk0aBDx8fGMHDmSJk2a0KRJk1CLFTlccQV88sm/SezWr4fZs2HwYPBy9akheol6RQDGueqMSFho9s0339C1a1d27NhBr169zs0KDD5gjyBasgRefx3mz4dp03T+IkPMExPhBJHqFPUFT+81nBeaHT16lC5dutCiRQvi4+NZsWIF48aNM0rAH/TvD0uX6uI3jRtDr15w/HiopTKEmKhXBJHqFPUFb+41nBeaHThwgNmzZ/PCCy+wbt06l4W/DT5y6626zkGvXjB+vM5hZIhpot5ZHGlO0fwQyfdq7/x799aZSw4dOmScwcHg5591VFFiIqxdq5PYXXppqKUyBAB/lKqMWCLFKeoPIvFelVJ8+OGHJCcn8/zzz/O7VbjdKIEg0bChVgLZ2TpfUXKyrpBmiCmiXhGEOumcnWD4KcLlXj3lzz//pHXr1nTo0IFq1aqxdu3aiKrzGlXYbDBvHpQuDffeC/fcA/ucp2cxRB9Rrwh8TTrnz447WH6KcHYA58aeJM7uCP7uu++oUaNGqMWKberU0aai4cNh8WI9OzCrkmOCqA8f/XaL82ylrrZDPgqPu8DfxWlcEQlrJrZv30758uWJj49nypQpVK5cmQoVKoRarHMsSE0P688v4MTHwwsv6CR2kyaBfYZ25sy/dZQNUUfUzwicOU/dbQf/l3cMpu3enznw/UlWVhZvvPEGycnJjB8/HoDmzZuHnRKIlQizPKlaFUaN0gnr0tOhUiUYN077EgxRR9QrApuL2HNX28H/HXcwbffhuGZi7dq1NGzYkP79+3P77bdz3333hVokp5j6zi4Q0ZFFvXvrtQebN4daIoOfiXpFkO0iPNbVdvB/xx0s2304jmjfeecdrrvuOtLT0/nkk0+YP38+V155ZcjkcUckRl0FhVKltM9g5kztM6hTB1591SSxiyKiXhH4MiPwd8cdrMVb4TSita9Pufrqq2nfvj1paWlhny460qKuAoHLGaUIPPKIng20basroZmV3lFD1DuLfZkROHO6Nq1ekpFLt/LsnLU+ORGDke8oHEa0J06cYODAgSQkJPDmm29GVJK4finVzgsSgPCNugoEHgVJXHYZzJkDmVZhp/Xr4eOP4eWXdYZTQ0QS9TMCX3F0uvZLqcana9LDyuTijFCPaL/66itq1arF22+/TWZmJpG2aj2c024EA69mlAlWPY8vv4Q33tA+hBUrgiClIRAYReABrn4gryzcFCKJnBOqdQRHjhyhU6dOpKSkkJiYyIoVKxg7dmxEJokL16irYODTjPL55+HrryErS1dDe+opk8QuAjGKwANc/RCOnsoMq1lBqEa0f/31F5988gkDBgxg7dq13HTTTQFtzxAYfJ5RNm8OGzbAM8/Au+/qRHaGiCLqfQSFCtg4efbC2OdCBWxOjnaOq9z9gN8XheWXYNVe2L9/P7NmzeLZZ5+lWrVq7Ny5k+LFiwe8XUPgyJePpFAhGDMGHn4Yrr5ab0tNhbJlweSNCnuifkZwdz3nnaKr7c5w90OItdBCpRQffPABycnJDBgw4FySOKMEIh+/zCivu06vQM7Ohvvv12kq5s41oaZhTtQrAl9STOSmbd3SFCvovNh9LIUW7ty5k9tuu42OHTuSnJxsksRFIX7zkdhsugpa+fLwwAM6ZcXevf4V1uA3ol4R+CuksvXVV5Lb9RlLoYVZWVk0bdqUH374gfHjx7NixQqqV68earEM4Uzt2vDjj/Dmm7oqmkliF7ZEvY+goAsfQUEvfAQLUtP5dE06jpNbAe65NvprIW/bto2KFSsSHx/P9OnTqVSpEuXLlw+1WAY3hFXivPh46NsX2rSByZN1DiPQpTITE0Mjk+ECon5GkOFECbjb7gxn4aMK78xLkUZmZibDhg2jZs2a55LENW3a1CiBMCcc04wAUKUKjBihVyPbk9i99ZZJYhcmRL0icOWi8sZ1FQ4rdoPJr7/+SoMGDRg4cCBt2rThgQceCLVIBg8JpzQjLhGBevXg2WehUSPYFF7rcWKRqFcErpY0ebPUKdQrdnMTyAyj48aNo0GDBuzfv5/58+czd+5cLr/8cr9d3xBYImLQUqoULFoEH30E27ZB3bowdKiJLAohxkfgAf7KQZPbdtu0ekm+3XLQK1uuv4vm2FFKISLUrVuXRx99lFGjRlGsWDGfr2cIDa7WvIRddJuIXnPQsqVOb/3HHyaJXQiJ+hmBMyXgbrsz/BFf7cx2++FPf3pty/X31P/48eP07NmT5557DoDGjRszffp0owQilEgqVwpAyZI6ad3Uqfr9unXQrx9kZIRWLotwrO8RCKJ+RmATcZpp1F0aamfkd8Wusw48N56Ur/Tn1P/LL7/kiSeeYPfu3TzzzDPnZgWGyCUSypU6xZ7E7quvdLjpZ59p5XDLLSETKVCz73Ak6hWBL2mo/c2C1HS3pTEdST96ior9F7v8Aftj6n/48GH69OnDjBkzqFGjBitXruSGG27w+Hw7/ghTDKtQxyghWGlGAkK/flC/PnTtCk2bQrduOtqoSJGgixKsWuPhQNSbhkKNfVThDe5MRfmZ+tunudcM+JSP5nzCfV17k5qa6rMSyG+YYtiGOhpCS9Omus7Bc8/pWcGECSERIyIc734ioIpARG4Tka0isk1E+jvZ30dE0kRkvYh8IyJRF6TuiUnIFacys3lmztrzbJO++iumf/Ur3fq9zJ4jGcRfWporu09nw+W38d+0Qz7J5g9fRUSEOhpCQ8GCMHIkrFoFffrobWvWwMHgrd0Jt2jBQBIw05CI2IDxQEtgD7BKRBYqpdIcDksF6iulMkSkBzAC8GvQur98BL7ibvTwyPXlzkUNuTNU5bZNejP1V0rx3nvv0e2pp8nJyuTKSg1IuLQ0tsSLPZrmujLd+GO0FEsjLoOP1Kun/2dnw4MPwtGjMG6cfh3g33AsVawL5IygAbBNKbVdKXUWmA20cTxAKfWtUsoeHvATUMbfQjzUsKxX2/2Nq9FDsYIJvNq29rkEX6XzGGX4MlLesWMHt956K507dya+ZEWu7PQ2CZee3+m763TdmW78MVqKpRGXIZ/YbNqBXKmSDju96y7YsyegTcZSxbpAKoLSwG6H93usba7oDPzX2Q4R6SYiq0Vk9UEvp4b1y1+a53ZfQsQ8PadfSjUSbBeOXE6czjrvHGe2/9y46rSdyZKVlUWzZs34+eefeffdd6nXfcwFSgDcd7ruTDf+CFOMuFBHQ2ipVQt++AFGj4ZvvoGaNWHLloA2GSsV68LCWSwijwD1gZHO9iulJiul6iul6pcsWdKra7sqJ2nf7ovD0ptz2tYtTaECF1rgMnPUebI5jj5c4azTzi3Lzu3b6P/JWr7YcID33nuPTZs20b17d55vVcPrTted6cYfo6VYGnEZ/ITNplNTbNgAPXpANev5PWXMifkhkOGj6YCj/aWMte08RKQFMBC4WSl1xt9CHD2V6Xa7LyFi3p5zzI0MC1LTz51j/z9k0SaOZJx/jqtO2y6Lys7i2M+fcOyH2RS7pRMjCyexsn+zc8f5El+eV6iqP8IUIzrU0RA6KleG4cP16z17dEGcvn11ucz4qI+K9zuB/MRWAVeJSEW0AngQeNjxABGpC0wCblNK/RVAWVzii8PS03MWpKbzysJNbh3Bjsoj9wIWO0WTEnjlrppOO8y9R09xZt/vHP7vWDIP7qRgjSYUqnGzUxm97XRjyVlmiGDi46FhQ70GYc4cmDbt33KZISAQa2MGLdjArJ93k60UNhEealiWV9vW9pPEATQNKaWygJ7AUmAzMFcptUlEhorIXdZhI4GLgXkislZEFgZKHlcUdVF5zNV28MzJuSA1nX7z1rmckdhx7LBdhZoWuije9YO0aQn7Z/Yl59Q/lGz3EiXveh5boaJ+cbga040hIrjiCu1Inj0bdu2Ca6+Fl18OSRK7QKyNGbRgAx/+9Oe56Mdspfjwpz8ZtMC79UnuCOgcSim1BFiSa9tgh9ctAtm+J7h6Vtw9Q56MlEcu3UpmTt4PoqPC8WZ2Yk8H0a1dS95I384lTToSl3ixU1nygzHdGCICEV0Ss3lz7UPYtSskSexcmY2HLNrk8yxh1s+7XW7316wgLJzFocSV/d7VdvBspOxpLLxj9JAnM41//vmHHj160MdaZDOgU1venzaVsleUNKN2Q8CImORrJUrAzJnnJ7Hr2xdOngxK865+90cyMn2eJQQjTU7Ue1VEnI/u7YMFVw7ROJHzHLm5yWuk7Oq6ucnMUef8BE2rl+TDn/684Jim1XWk1JIlS3jiiSfYu3cvffr0OTcrMKN2QyCJyORrdofx11/rcNMFC2DKFGjWzO1p+cXT3703OYuCsSg26mcEeZl+XMXvZyuVL9tev5RqJMR59kXZRxGuSl9+tWYbjzzyCK1bt6ZIkSL88MMPjBw50mQKNXiNLyP7iE4F0rcv/O9/Ouy0eXOdzO7o0YA158l6IDueWg2CsSg26mcEpV1o6NIOIZAAfeeuu0Dr5ifToP2cVxZuOucwjhNw5jawm35c+ggOHGTrokW8/PLLvPjiixQoUCDP9k1WTwOc/xwUSUrg5NksMrP1Q+jpyN4T31VYP29NmmgT0Suv6BTXlStD/wtSn/kFZ2HaJ89kOQ0a8TSgw+4HCGTUkKgIKw9Xv359tXr1ao+PX5CaTr9P1p17+O08cn258z7Iiv0XuwzzFHD6cHv78DsLD01KsJ2z6Tcavuyc0so6foiTacu5pME9lClWkMXd61G0aFGP79ldO4bYwFU4cm5KFz1/zUluHJ9LZ+dF1POWmgrJyXDRRbB6NZQtCwEuxRoun4+IrFFK1Xe2L+pNQ8AFSgBgzqrdLEhNZ9CCDVQesMRtrL8zB48vYWJ5OZn7pVQjMT6O42u/ZO/UJzn2/SziT/xFv5RqHisByN9UPmKcgoY88TTzbV4mirxSgUSU6ahuXa0EsrPhoYe0Uvjww4CGmkZCGHbUm4ZcpZjIzFa8OH89GZk5Hl/L0VTka9EKd47d2pecJmHpq/y9+gcSy9Wmxn39GNze+/wmvmb1jEinYJjirD714vX7zq0Yd7dI0F94aoPOy0SR16r0iMwia7PBwoXQuTN06KDLZU6cCOXKBaS5cA/oiHpF4G5BlzdKwI794XYVGeDrw5+VlUXz5s35+++/mTRpEl26dCEuzrcJm69VzCKtIlO42qWdKdTc0WBHT2XSb946IHBK1pMIFk/XnLjryPxRNS8k1KgB330H48fDgAE6id2qVVC9eqglCzoxYRryBVfJ30oVTWJBajqu4nXyevhzm17Gf7aCrKws4uPj+eCDD0hLS6Nbt24+KwHwPatnJI3swrm6macmGXvocKBw9hwkxAnFCib41UQR0VlkbTZ4+mnYuFH/j9EkdlGvCHwNsHT3cI9cutWpT0Gs81zh2HnlZGey6Ytp9Ly3OU8MeA2Am2++mTJl8l+SwVebZCTVBwhnu7Q/ivP4A2fPwcj7riF18K1+TascCTbwPKlYEV57TS8w2r0bKlTQtZKzskItWVCIetOQOxdQQhw4sw4lxLm3iz47Z63Lttw9/PbO68zerRz+7zgyD+2iYPLNbEj0f4IsX2ySkZRkLpxnL54uKrIfG0iCZZsOdxu4VxQoAI0awQsv6CR206fDNdeEWqqAEvUzAndcnOg8sZx9u70oxZgH6gDwrFU/uEiS8/PyqjK29+gp/ln1Ofs/7EfO6ROUvGcwJe/sx8HMvNcFBINIGtmF8+zF00VFCXESlko25rn8cvj0U5g3T6e4rl8fXnopJEnsgkXUzwiKJiU4dRgXTUrgaIZzR/KRjEwq9l98Ltrj0zXp5zn+EmxCQpycl1Qur5GzUopSRZM4dWVVLr7mVord0om4iwoB4dF52YmUkV04z16cLSbMTTCihgz5QATuvReaNoU+fbRCiOKV/LGxoGzeuvM67YQ4YeR91zBy6dY8p/CCc/NSsYIJFCwQn2fEyrFjx3j++edJSkrilsf6hcXCkmghXKOGHIkEGQ0ekJ2tHcupqfDBB/Dqq3DxxaGWyivcLSiL+hlB27qlWb3r7/OWZz/QoOy5H2NeKy9dqcmjGZmkDr7VbduLFi2ie/fu7N+/n+eee442dUoB3lUJM7gmEmYvkSCjwQNslqnv229h7Fj4/HOYPBlatgytXH4iNmYEuVJMJNiEkfdeQ9u6pc8bsXn7SdizApbO1aEfPHiQ3r17M2vWLGrXrs20adO47rrrvLy6wWAIS777Drp0gd9+g06dYNQoKFYs1FLlSUynmBiyaNMFKSYysxVDFukVx3aH8I7hrV06e11ZBu1J6nLHsB87dowlS5YwZMgQVq9ebZSAwRBNNG6sk9gNGAAzZugVyRFO1CuC3EXg3W13tXag/fXl8owIOn54P70HvIxSiipVqrBr1y4GDx7sUaZQg8EQYSQmwrBh8Ouv2pkMelXy/v2hlctHot5H4A155VRxlqFUqRxOrP2SI8vfA5XDH3/0p0qVKhQpUiTI0hsMhqBztbUGKDsbHn4YDh+GMWPg0UcjKsrIKIJceJNTJfPvdA5/+TZndm8ksfw1JN//HFWqVAmWqAaDIVyw2WDRIu076NgRZs2CSZOgfPlQS+YRUW8aygtv0i47mo5UTjYH5rzE2b92ULzV05R/5HVeeqhpsMQ2GAzhRvXqsGIFvP02fP+9TmK3eXOopfKIqI8aqjhgsdsFgbnXCSQl2Ljn2tJ8u+WgU/PQ258uZ9aWTPYeP8vZPZuIK3IF5cuWMWGgBoPhX3btgqlTYehQbSLKyICCBUMqkruooahXBC1HL+f3v0561YYz5TD0jqpsXPIBw4YNY+TIkTzzzDNeXdNgMMQou3fDtddqp3LfvpDgPEVNoInpBWXbDnqnBODCRWRHd27isbu6c+qvXXTo0IEOHTr4RziDwRD9XHQR3HyzDjedOxemTdOV0sKIqPcR5HfC888v89n/YT/OnspgyZIlzJgxg+LFi/tHOIPBEP1cdplOYPfpp7BvH1x3Hbz4YlglsYt6ReAt9oAvpXR+6gKlanBx3VaU7TKBM1f4P120wWCIEdq1g7Q0HVr6119hFV4a9YogwYM7tH8dpYsmcU/tohz9chxHvp4MQGKZGhS/9UlUgaSwqYBlMBgilGLFdH2DSZP0+9RU6NULjh8PqVhRrwhc1RyIs3p/mwgKrQSaFNjBx/3u4/jGb7BdVJDcjvRwqYBlMBgiHHsSuxUrdM3kWrVg6dKQiRP1isBViokcpaOBspUi++RR1r7/MsP7diHxkktZ9csvFG3yKOJk6hYOFbAMBkOU0Lu3XnNQsCDcdhs89hj8/XfQxYh6ReAOe/rpnLMZnN6ZStEmj3J5h9HUq1cvrCtgGQyGKOLGG7WJaOBA+Phjnd46yMSsIsj65y+O/TAHpRQJxUpRusd7FLnhfvYf1zMId8XrDQaDwa8kJupiN45J7H75RUcZBYGAKgIRuU1EtorINhHp72T/RSIyx9r/s4hUCKQ8oKOBjv+6mL3TnuLYT3PJOqo/6LiL9Ko/+4g/kur3GgyGKKF2bShQQCexa98ekpPhvfcCHmoasAVlImIDxgMtgT3AKhFZqJRKczisM3BEKVVFRB4E3gAeCJRMmYf36CRxezaRWKEuxW/rSXyRy8/tzz3iN9WlDAZDSLDZYPFincTu8cf/TWJXsWJAmgvkjKABsE0ptV0pdRaYDbTJdUwb4APr9SdAc3HmofUDKiebA3MHk3lwJ8Vvf4bL7h96TgmYEb/BYAg7qlaF5cthwgT48Udo3RpycgLSVCBTTJQGdju83wM0dHWMUipLRI4BxYFDjgeJSDegG0C5cuV8EkbibJS4sy/xRa8k/uJL/xWgaBIr+zfz6ZoGg8EQUOLioEcPrQT27dPvA9FMQK7qZ5RSk5VS9ZVS9UuWLOnzdRLL1DxPCRjnr8FgiAjKlYOGucfR/iOQiiAdKOvwvoy1zekxIhIPFAEOB1Cm8zCmIIPBYAisIlgFXCUiFUWkAPAgsDDXMQuBx6zX9wLLlJ/zYu8c3trldqMEDAaDIYA+Asvm3xNYCtiA6UqpTSIyFFitlFoITANmisg24G+0svA7rpSBwWAwGAJcj0AptQRYkmvbYIfXp4H7AimDwWAwGNwTEc5ig8FgMAQOowgMBoMhxjGKwGAwGGIcowgMBoMhxhE/R2sGHBE5COzy8fQS5Fq1HAOYe44NzD3HBvm55/JKKacrciNOEeQHEVmtlKofajmCibnn2MDcc2wQqHs2piGDwWCIcYwiMBgMhhgn1hRB8GvAhR5zz7GBuefYICD3HFM+AoPBYDBcSKzNCAwGg8GQC6MIDAaDIcaJSkUgIreJyFYR2SYi/Z3sv0hE5lj7fxaRCiEQ0694cM99RCRNRNaLyDciUj4UcvqTvO7Z4bh7RESJSMSHGnpyzyJyv/VdbxKRj4Mto7/x4NkuJyLfikiq9XzfHgo5/YWITBeRv0Rko4v9IiLjrM9jvYjUy3ejSqmo+kOnvP4DqAQUANYBybmOeRKYaL1+EJgTarmDcM9NgYLW6x6xcM/WcYWBFcBPQP1Qyx2E7/kqIBUoZr2/LNRyB+GeJwM9rNfJwM5Qy53Pe24C1AM2uth/O/BfdLn164Gf89tmNM4IGgDblFLblVJngdlAm1zHtAE+sF5/AjQXEQmijP4mz3tWSn2rlMqw3v6ErhgXyXjyPQP8B3gDOB1M4QKEJ/fcFRivlDoCoJT6K8gy+htP7lkBl1iviwB7gyif31FKrUDXZ3FFG2CG0vwEFBWRK/PTZjQqgtLAbof3e6xtTo9RSmUBx4DiQZEuMHhyz450Ro8oIpk879maMpdVSi0OpmABxJPvuSpQVURWishPInJb0KQLDJ7c8yvAIyKyB13/pFdwRAsZ3v7e8ySghWkM4YeIPALUB24OtSyBRETigNFAxxCLEmzi0eahW9CzvhUiUlspdTSUQgWYh4D3lVKjROQGdNXDWkqpnFALFilE44wgHSjr8L6Mtc3pMSISj55OHg6KdIHBk3tGRFoAA4G7lFJngiRboMjrngsDtYDlIrITbUtdGOEOY0++5z3AQqVUplJqB/AbWjFEKp7cc2dgLoBS6kcgEZ2cLVrx6PfuDdGoCFYBV4lIRREpgHYGL8x1zELgMev1vcAyZXlhIpQ871lE6gKT0Eog0u3GkMc9K6WOKaVKKKUqKKUqoP0idymlVodGXL/gybO9AD0bQERKoE1F24Moo7/x5J7/BJoDiEgNtCI4GFQpg8tC4FEreuh64JhSal9+Lhh1piGlVJaI9ASWoiMOpiulNonIUGC1UmohMA09fdyGdso8GDqJ84+H9zwSuBiYZ/nF/1RK3RUyofOJh/ccVXh4z0uBW0UkDcgG+imlIna26+E99wWmiMizaMdxx0ge2InILLQyL2H5PV4GEgCUUhPRfpDbgW1ABtAp321G8OdlMBgMBj8QjaYhg8FgMHiBUQQGg8EQ4xhFYDAYDDGOUQQGg8EQ4xhFYDAYDDGOUQQGQ4ARkfdF5N5Qy2EwuMIoAoPBYIhxjCIwGHIhIoVEZLGIrBORjSLygIhcKyL/E5E1IrLUnu1RRKqIyNfWsb+KSGVrxec7Vg79r4HLHK69U0SGWMduEJHqIbtRg8HCKAKD4UJuA/Yqpa5RStUCvgTeBu5VSl0LTAdes479CJ32+RrgRmAfcDdQDZ0b/1FruyOHlFL1gHeB5wJ9MwZDXkRdigmDwQ9sAEaJyBvAF8ARdAK7/7PSc9iAfSJSGCitlPoMQCl1GkBEmgCzlFLZwF4RWZbr+vOt/2uAdoG+GYMhL4wiMBhyoZT6zaplcDvwKrAM2KSUusHxOEsR+II982s25jdoCAOMachgyIWIlAIylFIfopP1NQRKWrnuEZEEEamplDoO7BGRttb2i0SkILo05gMiYrN8CU1DciMGg4eY0YjBcCG1gZEikgNkoms8ZwHjRKQI+nfzFrAJ6ABMsrJhZgL3AZ8BzYA0dIrkH4N9AwaDN5jsowaDwRDjGNOQwWAwxDhGERgMBkOMYxSBwWAwxDhGERgMBkOMYxSBwWAwxDhGERgMBkOMYxSBwWAwxDj/D4Pn9mw45840AAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1118,7 +1118,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1130,7 +1130,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEXCAYAAABVr8jJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAA0w0lEQVR4nO2de5wdRZX4v2cmNzABNsMjIpkQgohhQYSQWR5GV0QxPAQijwXEn+CLn28RzBrU1YCoWbOuoqIILLIg8tZseGh8BH+rKMjEJEIQJIZHMoCExyCSAJPJ+f1RdZOem/voe2/37ep7z/fzmc/07equPt1dXafqnFNVoqoYhmEYRj10ZS2AYRiGkT9MeRiGYRh1Y8rDMAzDqBtTHoZhGEbdmPIwDMMw6saUh2EYhlE3pjw6BBGZIiIqImP871+JyPuzlstIBxGZKiLLROR5Efl41vLEQURWiMihfnuuiPwgoXwPFZE1TZx/hYhckIQs7URHKQ8ReaeIDIjI30XkcRH5iYi8IYF8EytcVlDTR0R2F5GNIvLdrGWpRALK/V+B21V1O1X9ZoX8X/TfwlMi8iMR2aWJ6zWNqu6jqr9q9XXF8XERuVdEXhCRNSJyg4js22pZ8kTHKA8RORv4BvBlYGdgMvAd4LgMxWobij2anPBu4FngZBHZKmthUmI3YEWNYz6qqtsCrwF6ga+XHtCK9xpA2bkQ+ATwcWAH3PNYABydoUzho6pt/weMB/4OnFTlmK1wyuUx//cNYCufdiiwBjgHeBJ4HHiPTzsTGAZe9te42e+fCNwErAUeAj7u9+/g8zrG/94WWImr0MrmVUbWfYCfA88AfwU+4/d3AXOAvwBPA9cDO/i0KYACY/zvXwHvr/Hc9gAW+7yeAq4GeiPpDwOfBv4IvASMAQ4GfgsMAcuBQyPHvwf4E/A8sAr4v1XexRDw2si+CcB64BXATsAt/phngF8DXTHLgvjn8yH/7E4sSVfgw8CDXs4v+ufwW+Bv/pmOjRz/Af/+ngEWAhPLPe/SZw6cAfwG+A+cInsIONKnfQkYAV705eDbFe7lWJyCGPJ5/6Pfv7jk/NeUOXfU+wc+Atzb4Hs9w7/P5/19nFbyfIrv/D7ggCrXeBh4q0+fC9wIXOfP/QOwXyTfst+XT+sBrvDP9T5gNrCmwjPc0z+rA6uUmSuAi4BbvSx3AXtE0i8EVvvysQR4YyRtLq7MXOnPXQH0R9IPAJb6tBv8/V4QSX87sMw/998Cr8uiDi37XLIWoCU3CUcAG4h8yGWOOR+4E1c5TfAv6os+7VB//vlAATgKWAdsHylc0Rfe5QvR54GxwKv8xzXTp78NeMJf61LgxpKCekEVObfDKa9zgK3974N82if8PUzCVcDfA67xaVOoX3m8Gjjc5zUB+F/gG5H0h33B3tV/sH04RXOUfwaH+98T/PFH4ypiAd7kn+EBFa59OfClyO+PAD/1218BLvbvogC8EZCYZeGNuMpqe+BblCho/4z+B/gHnJJ+Cfilf4fjcZXR6f7Yw3BK9QD/jL4F/G+55136zHEV7jCucu3GKbPHivdR6/3gWscv+GdcwJmpVuIVW4zzo7LshFM4V9X7XoFtcJXmVH/uLsA+fvskYBD4J//OXw3sVu4akX1R5TEMnOjv71M4JVGg9vc1D9eg2MHnfy+VlccHgUdqlJkr/P0eiFNyVwPXRtLfBezo087BfdtbR+7jRf/sunFl906fNhZ4BPfdFoDjcQ3HC3z6NFxj9SB/7un+GW2VVV066rlkLUBLbhJOA56occxfgKMiv2cCD/vtQ3Gt3mhF8CRwcKRwRZXHQcCjJfmfC3w/8vtbwD3+49qxpKBWUx6nAksrpP0JeEvk9y7+AxxDA8qjTP6zotf2Bfm9kd+fxldAkX2L8JVtmfwWAJ+okPZW4C+R33cA7/bb5+Mq+Fc3UBYuAxb47UP883lFJF2BGZHfS4BPR35/Da9Agf8CvhpJ29bnN6X0eZc+c5zyWBlJG+ePf2Wc9wP8G3B95HeXL0uHxjz/VzjlPeTPu5rNSj72e8UpjyHgBLwSKDmm0vsddY3IvqjyuLPk/h7HKf+q3xdOkRwRSTuTysrjs9HrVDjmCuCyyO+jgPurHP8svpfk7+MXkbS9gfV++5/9s5dI+m/YrDy+i2/ARtIfAN5Ub7lP469TfB5PAzvVsK1OxLUCijzi923KQ1U3RH6vw1UW5dgNmCgiQ8U/4DM4X0uRS4DXAleo6tPxbgNwLam/VLnujyPX/BOuS75zheOrIiI7i8i1IjIoIn8DfoBrpUZZXXL9k0ru+w04JYaIHCkid4rIMz7tqDL5FbkdGCciB4nIFGB/4Mc+bT6ulf0zEVklInNi3k8PrjV8NYCq/g54FHhnyaF/jWyvL/O7+N5HlRlV/TuurPXFkQfXQi2eu85vVipTpZReeyPuXcS9NjhTT6+q9qnqaaq6NpIW672q6gvAybgW/OMicquI7OXPq1ZWS69RNd3f3xrcfdf6viaW5B39rkt5Gl8+a/BEZHvUty8inxKRP4nIc16W8Ywu16Xnbu3roonAoHqt4Cl97ueU3OeujK6XMqNTlMfvcOaHWVWOeQz3sopM9vvioCW/VwMP+Q+z+Ledqh4FICLdOOVxJfBhEXl1lbxKWY3rpldKO7Lkulur6mDM+yjly16efVX1H3Ddcyk5prTgX1Vy/W1UdZ53TN+Es/HvrKq9wG1l8nOZqo7gbMWn+r9bVPV5n/a8qp6jqq/C2f3PFpG3xLifd+DMUd8RkSdE5AlcZXt6jHPLMarMiMg2OPPFIM6kBK5HUeSVdeRdqxyUXltwFUuj77ra9Su+VwBVXaSqh+Mq4ftxptjieXvEvEY5di1uiEgXzhz7GDW+L1wPZddIPpOrXOOXwCQR6a8hS1lE5I04k+G/4MzYvcBzVCjXJTwO9Pl3VyQq92qc6TZ6n+NU9ZpGZE2ajlAeqvoczj56kYjMEpFxIlLwLeGv+sOuAT4nIhNEZCd/fNw4878yukL/PfC8iHxaRHpEpFtEXisi/+TTP4P7cN6La0Vf6RVKubxKuQXYRUTOEpGtRGQ7ETnIp10MfElEdgPw93JczHsox3Y4h+tzItKHczxW4wfAMSIy09/z1j7GfhLOvrsVzsG5QUSOxPl+qvFDXKv2NL8NgIi8XURe7T+653C9q40x7ud0nC9lX1xPZn9gBrBfg2GZ1wDvEZH9vXL8MnCXqj7sW/GDwLv8s3gv1SvSUmqVg+uBo0XkLSJSwNnaX8L56pKm4nv1vdPjvOJ8CVdeiu/iMuBTIjLdh8O+ulg2YzJdRI73rfSzfP53Uvv7uh44V0S292XvY5UuoKoP4qIur/H3NNbf3ykxe7Tb4fyha4ExIvJ5XAMlDr/Dld2PisgY/60eGEm/FPig732LiGwjIkeLyHYx80+VjlAeAKr6NeBs4HO4F70a+CjO7g5wATCAi/64BxfdEXe8xX8Be/uu5QLfan47rnJ6COdUvQwYLyLTvRzv9sf9O06RzCmXV5n7eB7nsDwG1x1+EHizT74QF/HzMxF5HvehHVSaRx2ch3MGP4eLNPlRtYNVdTUu9PkzbH7Gs3GRUM/jQiGvx9mE3+llrZbfXbgW/ETgJ5GkPYFf4Cqq3wHfUdXbAcSN3flMaV5e+b0F5694IvK3BPgpDfQ+VPUXON/DTbhW5B7AKZFDPoC7/6dxzvd6KvYLgRNF5FkR2WKchqo+gOsJfgtXvo7BRfC9XO991KLae/V/Z+N6BM/gAiE+5M+7ARc59kNcNNECnBM7Lv+Dazw8C/wf4HhVHa72ffnzzsOZqh4CfgZcVeM6Hwe+jYuoGsKZ2t4B3BxDxkW48vNnf80XqW2OA8C/q+OB9/nrvgvXOHzJpw/gytC3cc9gJc5XFgTFyA7DMAwjY0TkLuBiVf1+1rLUomN6HoZhGKEhIm8SkVd6s9XpwOtwPZngMeXR4YjIxeKmqCj9uzhr2QyjA5iKG3Q5hPNbnaiqj2cqUUzMbGUYhmHUjfU8DMMwjLrJekKyutlpp510ypQpWYthGIaRK5YsWfKUqk5IKr/cKY8pU6YwMDCQtRiGYRi5QkSqjbSvGzNbGYZhGHVjysMwDMOoG1MehmEYRt2Y8jAMwzDqxpSHYRiGUTepKQ8RuVxEnhSReyuki4h8U0RWisgfReSAtGQxjNBYsHSQGfMWs/ucW5kxbzELliY1k7phtIY0Q3WvwM0GeWWF9CNxs6PuiZv59bs0NwOsYeSCBUsHOfdH97B+eASAwaH1nPujewCYNa2etZzCZsHSQeYveoDHhtYzsbeH2TOnNn1/aeRpNEZqykNV/1fcCnCVOA640q+idaeI9IrILnmZ18UwGmX+ogc2KY4i64dHmL/ogbapCJtVkAuWDnLezSt4dt0wAL09Bd6+3y7ctGSw7ZVukdAVZZY+jz5Gz3u/hgpLaIrImSIyICIDa9euLXeIYeSGx4bW17U/j1RTkLVYsHSQ2Tcu36Q4AIbWD/ODOx9tOM+8UVS+g0PrUTYrypDMm7lwmKvqJarar6r9EyYkNrreMFrOgqWDdEn5FUon9va0WJr0aEZBzl/0AMMj8SdsbSelW6QZ5dsqslQeg4xer3cSya2/bBjBUWxNjpSZybqn0M3smVMzkCodKinCOAqyXmXQTkq3SB56p1kqj4XAu33U1cHAc+bvMNqZcq1JgG4RvnL8vkHZs5tl9syp9BS6R+2LqyCrKYPSPlu7Kd0izSjfVpFmqO41uPWlp4rIGhF5n4h8UEQ+6A+5DViFW5f3UuDDacliGCFQqdW4UbWtFAc4B/ZXjt+Xvt4eBOjr7YmtIGfPnEqhe0vTXqFLOO3gyQ3lmTeaUb6tIs1oq1NrpCvwkbSubxihMbG3h8EyCiSk1mSSzJrW11DFXjynNNpq7rH7tKWiKEfxPkOOtsrdSoL9/f1qU7IbeaQ0fBVca7JdW89GWIjIElXtTyq/3K3nYRh5JQ+tyUYJfUyCkTymPAwjYapVpI2acpKUIY1rdcKIeWM0pjwMI0FCqEhbLUMoI+at99NacjFI0DDyQgiDu1otQwhjEvIwIrvdMOVhGAkSQkXaahlCGJMQgtLuNEx5GEaChFCRtlqGEMYkhKC0Ow1THoaRICFUpK2WoZkBgbWIu+5JCEq70zCHuWEkSAjhuFnIkEYUWT2O/9kzp5YdQxPSiOx2wwYJGoYRJDPmLS47Ir+vt4c75hy2xX6LtqqODRI0DKMjqNeP0aoxNIbDlIdhtAFptrqzatF32lxgecMc5oaRc9Ic45Dl+IkQgg/iENep326Y8jCMJsm68khzjEOW4yfSjOJKik4enGhmK8NoghCmI0lzjEPW4ydC92OEMjVLFljPwzCaIISRzWmOcbDxE9XJWrlmiSkPw2iCECqPNH0DefE7ZEUnK1dTHobRBCFUHmn6BvLgd8iSTlauNkjQMJrAVgc08jI40QYJGkZAhDAdiZEtoTv108KUh2E0SadWHkZnY8rDMDqEvJhXjHxgysMwOoAQxqMY7YVFWxlGBxDCeBSjvTDlYRgdQKVxJ4ND6ztiKg0jeUx5GEYHUG3cSafMxWQkiykPw+gAyg1mK2LmK6MRzGFuGB1A0Sl+1nXLyqZ3wlxMRrJYz8MwOoRZ0/roC2A6FaM9MOVhGB1EJ8/FZCSLma0Mo4Ow6VTCJy+DOVNVHiJyBHAh0A1cpqrzStInA/8N9Ppj5qjqbWnKZBidjk2nEo8sKvE8DeZMzWwlIt3ARcCRwN7AqSKyd8lhnwOuV9VpwCnAd9KSxzAMIy5ZLS+bp8Gcafo8DgRWquoqVX0ZuBY4ruQYBf7Bb48HHktRHsMwjFhkVYmHsLhYXNI0W/UBqyO/1wAHlRwzF/iZiHwM2AZ4a7mMRORM4EyAyZMnJy6oYRhGlFZV4qWmsd5xBZ5dN7zFcSFGw2UdbXUqcIWqTgKOAq4SkS1kUtVLVLVfVfsnTJjQciENw2g/FiwdZMa8xew+51ZmzFs8yiTVihUiy5nG/v7iBgrdMuq4UKPh0lQeg8Cukd+T/L4o7wOuB1DV3wFbAzulKJNhGEZNn0YrQprLmcaGNyrDI0q3OAUS8rK/aSqPu4E9RWR3ERmLc4gvLDnmUeAtACLyjzjlsTZFmQzDMGr6NNJeu33B0kEGq5jARlQ3KasQFQek6PNQ1Q0i8lFgES4M93JVXSEi5wMDqroQOAe4VEQ+iXOen6F5W1TdMIzcEcenkVZIc7HXU4uiMus45QHgx2zcVrLv85Ht+4AZacpgGIZRysTenrIt/1Y4psv1eioRYpRVkawd5oZhGC0ny2la6lEIIUZZFTHlYRhGx5G2T6MalRSClPwONcqqiM1tZRgZkpd5jNqRrKZpefNeE7j6zkeJOnd7Ct2cML2P2+9fm5uyYMrDMDIiT/MYGcmwYOkgNy0ZHKU4BDhheh8XzNo3K7EawsxWhpEReZrHyEiGcu9cgdvvz98IBet5GEZG5Gkeo04iTVNiO71zUx6GkRFZhovmjVb5htI2JbbTOzezlWFkhK3qF49WTo+etimxnd65KQ/DyIgsw0XzRCt9Q2mbldrpnZvZyjAyxFb1q02tCr0Zk1YWU6K3yzs35WEYRtBU8xM046Mod26hSyh0C8Mjm4Np82pWShszWxmGETTV/ATNmLQqTYm+zdgxbWFWShvreRiGsQUhjXwvXrecPJ+8blnZc+L4KCod89z6YZZ94W0Ny9spmPIwDGMUIY58r+QnaCb0tZ3CZrPAzFaGkTOqLZ+aBHka+d5M6GtSYbNpv49QsZ6HYeSIVvQK8jQKuppJK865A488wzV3rWZE3dKvJ0yvLxIqxF5aqzDlYRg5olqvIKnKKm/mnEZDX4uTFI74xUtHVLlpySD9u+0QO79WvI9QMbOVYeSIVvQK2mkUdDWSMM/lqZeWNKY8DCNHVGr9Jz2IrV1GQVcjiYq/Fe8jVMxsZRg5YvbMqaNs7JBOr6BdRkFXIwnzXCPvI6Qw6GYw5WEYOaIZB3GoZFWZJqGI630f7eRgF1WtfVRA9Pf368DAQNZiGIaRAKWVKbgKvFVmslYrrhnzFpft7fT19nDHnMNSuy6AiCxR1f6k8rOeh2EYmZF1tFKrzXPt5GA35WEYRmaUa4VD6yvTVvVA8hYGXQ2LtjIMIxMWLB1EKqS1sjJt5WJT7RQGbcrDMIxMmL/oAcp5XAVaWpm2cjqWdgqDNrOVYRiZUMk0pbQ28qjVfoh2CYO2nodhGJlQyTTV12L7fycP9GsGUx6GYWRCKPb/UOTIG2a2MgwjE0IZ8BiKHHkj1UGCInIEcCHQDVymqvPKHPMvwFycqXO5qr6zWp42SNAwOps8Tu8Rgsy5GSQoIt3ARcDhwBrgbhFZqKr3RY7ZEzgXmKGqz4rIK9KSxzCM/JPH6T3yKHMc0vR5HAisVNVVqvoycC1wXMkxHwAuUtVnAVT1yRTlMQwj52SxymGzKwXmaWXGekhTefQBqyO/1/h9UV4DvEZE7hCRO72ZawtE5EwRGRCRgbVr16YkrmEYodPqsNokBhC205QkUbKOthoD7AkcCpwKXCoivaUHqeolqtqvqv0TJkxorYSG0SSdusZ1GrQ6rDaJXkO7hgKnqTwGgV0jvyf5fVHWAAtVdVhVHwL+jFMmhtEWtHLqi06g1WG1SfQa2jUUOM1Q3buBPUVkd5zSOAUojaRagOtxfF9EdsKZsValKJNhtJSsZ43NE3EikpIKq40b/ZTERIbtGgocS3mIyDjgHGCyqn7AR0lNVdVbKp2jqhtE5KPAIlyo7uWqukJEzgcGVHWhT3ubiNwHjACzVfXpJu/JMIKhXe3dSVNPRFKz03vUc62kVm5slylJosTteXwfWAIc4n8PAjcAFZUHgKreBtxWsu/zkW0FzvZ/htF25G0K7qzGI7Syh1bPtdq115AEcZXHHqp6soicCqCq60Sk0mzKhmF4WrXmeBJkOR6hlT20eq/Vjr2GJIjrMH9ZRHpwo8ARkT2Al1KTyjDahDxNwZ3leIRWRiS1a/RTq4nb8/gC8FNgVxG5GpgBnJGWUIbRTuSl5Zqlf6aVPbQ37zWBq+98dNRaIiH0BkOYwqQeYikPVf25iPwBOBi3VssnVPWpVCUzDKOlVPLPKDBj3uJUK7NW+RYWLB3kpiWDoxSHACdMz1bB1zIZhqhY4kZbHeA3H/f/J4vIeOARVd2QimSG0QGEVCmUa/0XaYX/oxU9tHKmOQVuvz/bmStqmQxDnBsrrtnqO8ABwB9xivq1wApgvIh8SFV/lpJ8htG2hDZhXrT1X64H0g7jU1plmqu3UVBNrlDHCsV1mD8GTPNThEwHpuEG8x0OfDUt4QyjnalUKZx384qMJHIK5I45h1EplDLv41Na4SxvZFaBanKFOlYorvJ4japuKtF+WvW9VNVGgxtGg1T6+J9dN5z59CXtGpHUiqlCGolaqyZXqO8irvJYISLfFZE3+b/vAPeJyFbAcIryGUbbUu3jz3q67nadj6kVodON9BSqyRXqu4jr8zgD+DBwlv99B/ApnOJ4c+JSGUYHMHvmVM66blnZtKxNElmNrG5FAEHajvlGZxWoJFeoo9zjhuquB77m/0r5e6ISGUaHMGtaH3MXrmBo/Zad96xNEtD68SmhBRA0StJjVkKKyIsSy2wlIjNE5Oci8mcRWVX8S1s4w2h35h67T5AmiSxolxX3kjSNhTylf1yz1X8Bn8RNjrhlELhhGA0RqkkiC0KNKmqEenpt1XoWoYbpQnzl8Zyq/iRVSQyjQ8nL9CVpk7cZiJOglqkuZIUaN9rqdhGZLyKHiMgBxb9UJTMMo6MINaooTWqZ6kIN04X4PY+D/P/+yD4FDktWHMMwOpVONOFV61ksWDrIupe3nP0pFIUaN9rKwnENw0idTjPhVTLVje8plJ1nrLenwNxj9wniGcVew1xEjgb2AbYu7lPV89MQyjAMoxOoFNYrQtkJKrfZakwQigPih+peDJwMfAw3MeJJwG4pymUYhtH2VArrHVpXfuKOEBzlReL2PF6vqq8TkT+q6nki8jXAoq8MI0eEOtis0ylnqqs0s3EIjvIicaOtinexTkQm4qYl2SUdkQzDSJqQB5sZW5KHyLO4PY9bRKQXmA/8ARdpdVlaQhmGkSwhDzYzNvcKB4fW0y3CiCq9PQW2LnQxtG44yJ5i3GirL/rNm0TkFmBrVX0uPbEMw0iSkAebdTqlAwVH1C2SO7R+mJ5CN18/ef+glEaReqKtXg9MKZ4jIqjqlSnJZRhGgnTi6O28UK5XWCTk3mHcaKurgP8A3gD8k//rr3qSYRjBkAcbeqdSq/cXau8wbs+jH9hb1fenDMPIFSGO3rboL0elXmE0PUTiKo97gVcCj6coi2EYEZKuXEMavd0ua3ckQbmBgkVC7h1WVR4icjMusmo73LKzvwdeKqar6rHpimcYnUm7V64W/bWZaK8wGm3VF3hvrFbPYyGwM/Drkv1vxHohhpEa7V65dkL0Vz09x5B6hXGppTyOA85V1XuiO0XkGeDLuEWiDMNImHavXNs9+qvde45QO9pq51LFAeD3TUlFIsMwglvHYcHSQWbMW8zuc25lxrzFTY9Mb/for3ZZUrcatZRHb5W0mqVYRI4QkQdEZKWIzKly3AkioiJi4b+GQViVaxpTmyS5zneItHvPEWqbrQZE5AOqeml0p4i8H7eeeUVEpBu4CDgcWAPcLSILVfW+kuO2Az4B3FWv8IbRrtQTWpt2yGta/pc82vnj0u5mOaitPM4Cfiwip7FZWfQDY4F31Dj3QGClqq4CEJFrcT6U+0qO+yLw78Ds+GIbRvsTp3JthW29E1rRSVNpnY52MctBDbOVqv5VVV8PnAc87P/OU9VDVPWJGnn3Aasjv9f4fZvw66Dvqqq3VstIRM4UkQERGVi7dm2NyxpG59AK23po/pc80O5mOYg/MeLtwO1JXlhEuoD/BM6Icf1LgEsA+vv7bZS7YXha0SvohFZ0GrSzWQ7ir+fRCIPArpHfk/y+ItsBrwV+JSIPAwcDC81pbhjxaUWvoBNa0Ub9xJ5VtwHuBvYUkd1xSuMU4J3FRD+l+07F3yLyK+BTqjqQokyG0Va0qlfQ7q1oo35SUx6qukFEPgosArqBy1V1hYicDwyo6sK0rm0YnUKIEx4anYHkbaLc/v5+HRiwzolhGEY9iMgSVU3MLZCm2cowDCNR8jKNe17kbAZTHoZh5IK8zBeVFzmbJc1oK8MwjMTIy3xRScuZ9LxiSWE9D8MwckFeRronKWfIvRjreRiGkQvyMtI9STlD7m2Z8jAMIxeENNNwNZKUM+TelpmtDMPYRMhRQnkZ05KknCHPzmvjPAzDALa0r4NrMdtUJOkQR1En+U6SHudhZivDMICw7evtRtwFtkKeV8zMVoZhAGHb19uNehbYCnVeMet5GIYB5CeaqR1oB0VtysMwDCA/0UztQDsoalMehpERoY0cnjWtjxOm99EtAkC3CCdMD9NkknfaQVGbz8MwMiDEkcMLlg5y05JBRnwE5ogqNy0ZpH+3HUyBlKGZsOa8hB1Xw0J1DSMDZsxbXDZ+v6+3hzvmHJaBRGHKFCp5DGu2UF3DaANCdJiGKFOoWFizKQ/DyIQQHaYhyhQqpmhNeRhGJoToMA1RplAxRWsOc8PIhLQdpo04c9vBidsqZs+cWtbnEUfRxn03Ic8zBuYwN4y2I4/O3DxST+VePHZwaD0CRGvdcu8mjXdoa5gbRkaE3hIsUs/UF0bjxJ02pFQRlDbXo472YvnqEtkUMh097pzrl2+6dtaY8jCMGKQxLiMtZWTO3LAop8xLKZan4nGliqPIiGrm44GKmMPcMGKQxrrUcWZVbQRz5oZFHKXdLVJTwRQJJSTYlIdhxCCp1nxxSpKzrluW2jgBi5oKi1pKu6fQXbGnUYkQepGmPAwjBkm05qO9jUokUSmEvAZEJ1JOmYv/X3w3fXX2CkPoRZrPwzBi0ExoZpE4tu+kKoVQ14DoROKGQJcrXydM7+OmJYNNlbu0MOVhGDFIYgxErV5FKJWCkTy1lHm18tW/2w5BRvnZOA/DaBGVJh4EZ74IpVIw2hMb52EYOaWS6Sskf0TIY1lClq0TMeVhGC0i9Ok/QlxjpEjIsnUqqSoPETkCuBDoBi5T1Xkl6WcD7wc2AGuB96rqI2nKZBhZErIjO+SR6SHL1qmkpjxEpBu4CDgcWAPcLSILVfW+yGFLgX5VXSciHwK+CpyclkyG0Y4kZc4JeWR6yLJ1KmmO8zgQWKmqq1T1ZeBa4LjoAap6u6qu8z/vBCalKI9htB1JjlQPeWR6yLJ1Kmkqjz5gdeT3Gr+vEu8DflIuQUTOFJEBERlYu3ZtgiIaRr5JctqUkEemhyxbMxRnHNh9zq3MmLc4kelpWkUQDnMReRfQD7ypXLqqXgJcAi5Ut4WiGUbQJGnOCdmhH7JsjZL3IIA0lccgsGvk9yS/bxQi8lbgs8CbVPWlFOUxjLZjYm9P2bEjjZpzQnbohyxbI+Q9CCBNs9XdwJ4isruIjAVOARZGDxCRacD3gGNV9ckUZTGMtiQLc06eTS0hkfcggNR6Hqq6QUQ+CizCheperqorROR8YEBVFwLzgW2BG0QE4FFVPTYtmQyj3Wi1OScPppa8DCaM22sM9X5sehLDMGJTaYqVvt4e7phzWAYSjSZPS/BWkvWE6X3cfv9aHhtaz9gxXby0YeOo8xq9n6SnJ7Ep2Q3DiE3oppakF+1Kk3JT5xdn0S2GXpcqDgjnfoKItjIMIx8k7aAH1wI/7+YVPLtuGIDengJzj92n7QY6lqM0CGDGvMWxVhQM4X6s52EYRmySdtAvWDrI7BuXb1IcAEPrh5l9w/K2G+gYh7hKIYT7MeVhGEZskl6lcP6iBxge2dLvOrxR226gYy0WLB2kS6T2gRDE/ZjZyjCMukhyvEW1lna7DXSsRtF5Hmct80IgTX5THoZhZEYlH0oxrRHyOJiw0hLFApSqk+GNBBEeHYgOMwyjE5k9cyqF7i1NNYUuCcI00yqq9bL6yijRECKuTHkYhpEZs6b1Mf/E/dh+XGHTvt6eAvNP2i93vYdmqOboDzWCzMxWRm4JdeStUR95NDMlTaUlimfPnDoqjDlKb0ThZoH1PIxckuQ6FoZRiVbN41Utiq2SDz3ryUGs52HkkrzPSBoS1oMrT6vn8arUA3tu/Za9jmr7W4UpDyOXhGoHTptaFX29iiCEiQ6THGGeJKE0UNIY1Z8EZrYyckneRxI3Qi1TXSOmvKzngkp6hHmShNJACXXgoykPI5eE+kGlSa2KvhFFkHUFmfQI8yQJpYGS9Kj+pDCzlZFL8jqSOA6VTE+1KvpGFEGrTSKl91ZpgCBkb4KsFgHVakKMSDPlYeSWED+oasTxR1TzQdSq6BtRBK2sIMvdW7kR1EWaVWDNBgK0cwMlCUx5GEYLiOuYrmZ6qlXRN6IIWllBlru3Soqj2RHmSQUCZNVAKVV8b95rwqYFokJRYqY8DKMFxI3cqWZ6qlXRN6oIWlVBVjNDbT+ukGi0VSiRUpBMBNwP7nx0U3ooS/+a8jCMFhDXH1HL9FSrog/ZlFfp3tJYwjbrQIAijfSAKk2SGCWEMU0WbWUYLSBu5E47R5G18t5CiZRKMgKu0ePSwpSHYbSAuBVnqGGZSdDKe0tSUTUzRUmjEXBxyHpMk5mtDCMBatm16/FHhGx6KqVee361e0tympS4zzvOiP1mHO9JRcCVImS/mqBo1rNr1Ul/f78ODAxkLYZhbKK0ggHXym1ljyGL+amSvO9WPsPTLv0dd/zlmbJppdecMW9xbD9NuXcANHRfxbzKhTMLcNrBk7lg1r7xbrh4nsgSVe2v66QqmNnKMJokhCk+sphhuNp912vqadUzrKY4yl0zrtmp0jsAGjLVzZrWxx1zDuPheUfz9ZP3H3X+10/ev27FkQZmtjJSoZNmas06siersNRK91esOOsx9bTqGVZTHOWuWcnsNL6nwIx5izeV7xde2lDxHdwx57Cy9x33GwnVjGk9DyNxOm2tjawje7JSXpXur0uouxeR5jOM9oLiEL1mOcd7F27yxmj5HqowPfrg0PqyPa8430ir1hJpFFMeRuLUa4II/SOpRdbhtVkpr0rrj2+s4EatpszSeoallXQcotcsjRDr7SmwsU4ZooqhWNbPum5Z1W8kDw0wM1sZiVNPSziE9SSaJes5kOJOS1LOTDLwyDNcc9dqRlTpFuHUg3aNbU+fNa2PuQtXVGx1l1JNmaX1DOMMuIvSU+hi/qIH+OR1y0bJEHWgx73fKOuHRzjv5hW8OLyxqjzFb6RSA+ys65Ztmqom6+/DlIeROPWEJ4Y0jUQzZGmXjlPxllPSZ1+3bFQrekR10zQYcRVI3NXs4vQiGn2G1XwH9ZjuugQ2bNRNZbdcQ6YZU2C5dchLKX4j1a4zOLSe2TcuHyVXFpjZykicekwQWTubsyQpc10cx2s5JV3J/HLNXatjX7tSb6K3p9CSwYC1zDuV5Nt+XIHensKo3+N7ClusLVJqbm2FKTDOdYZHlPNuXpGqLLUw5WEkTj0jibN0Nmfpa0nKpr1g6SCzb1g+Kp9yq/DVo4xH6hj7Vamh8Pb9domdRzNU6rl+8vpl7tlUkO8Lx+zDsi+8jYfnHc3D845m6effxlCFnkH02c2eOZUtvTyjKXTJFr6gnkL3KGVVDpHNPYlycpcSpyeTJqmarUTkCOBCoBu4TFXnlaRvBVwJTAeeBk5W1YeTlqPS4J2ovXb7cQW+cMzmmTwrteaqtfKaWV+60qCgUrkAPrfgHq6+89FNxxSP76sydXM0/24RRlTp8+k3DDw6KoRxbLcwPKKM7ykgAkPrhukdV0DVmSkm9vYwZcce7lz17BYVzZguYYP3mFZaq+FzC+4ZNUtoKT2Fbqbs2MMe5962Rf69PQUmbDeWB598YYvzxhW6GDumm+fWDzO+p8ALLw0zHGle9xS6+Mrxr2PWtL4tnmE1X0u5Z1f6DOttVVeq9OYuXFHxPZW7xtyFKxgu8VAPb1TmLlyx6TqPDa2ny+cVh26pVT2OLsu94wpsNaZrU9l4814TuGnJ4CgT2SevW8bAI8/Qv9sOifo1KilFVTjrumX09hQ4YXoftyx/fNO3vnWhfJt5fE+hrD9DgSkxI7WKMwLD5me/daGL9cMjNX0vqu65zprWx8Ajz/BiHb6aLEhthLmIdAN/Bg4H1gB3A6eq6n2RYz4MvE5VPygipwDvUNWTq+Vb7wjzciNXC93CyIhu0W0vdAvzT9wPKD8q9ITpfaM+iuL+rxy/b8Vzii3uaiNoy51bTq5ipVet4i2lktytpnivA488U1X+LuCQPXaIFY/fCF3AOw+ePEpxRCkdOVzuvZXSyEjouJVRrWtUy6en0N3QO39XjdHLtUaDVxqVDa4sR01DzY4ir3atTdfsEhCqXre4lnq5JXHroTTfRr7XAyaPj1X+C13w4JePjp13nkaYHwisVNVVqvoycC1wXMkxxwH/7bdvBN4iEqPZUwflWnjDZRRHcf/8RQ9UbBVec9fqis7dZtaXrhURUpQL6rNHV5O71RTvtZb8G4E7Vz2bmhwbcc+wUhVR2pKtZ3rseojTum/2GnHe+bhC1yZZukVqKg6oHYpdzURWy6dQL3FCeYc3as3rVlpLvV5K823ke43bcNqQ8cxSaZqt+oDok1sDHFTpGFXdICLPATsCT0UPEpEzgTMBJk+eXJcQ9Tpeqx1fqdtf7Zxm1pcud1w99ugijZyTBo/FjLVPW95q+Zf6WtKaHruReyx3jegiSo2wfngjD82L33qtJEd0f621yePmF4d6w4UrXTfJAI1oXmmW5aw/61w4zFX1ElXtV9X+CRMm1HVuvY7Xib09Fc+p1Fqsdk50fel6zy2XT70t1kbPSYOJvT2xZElb3kr5l5upNK3psfsaCAgod40vHLPPFs7ZQrfUdM5Wy7PRc4r74ziVm5Uhytxjt3wG9V43yQCNaF5pluWsv+s0lccgsGvk9yS/r+wxIjIGGI9znCdGuaiFQreUvfFCt1s3uVKExqkH7VoxBLVWeGq19FqRFUW5AE49aNeKx5WjktytpnivteTf8xXb1H2P9dAFZZ9HcabSUtt7nKiXRkZCly2XZaJ0al1j1rQ+5p+436jItvkn7sfcY/dJRe5KskfzmjWtj9MOnryFAqkUhdTsKPLiM9h+XHmFGee6cd5zHErzbeR7nbHHDrGOTfM7iUOaZqu7gT1FZHeckjgFeGfJMQuB04HfAScCizVhD36lAVRQPdqq3DmzpvXVjBZpZn3pONFWRXt0vdFWRbmziLaKRgsV76OcE3HPV2zDz88+dNPv4sjnKElFW8WN+om+tySjraqVy3qirYp5VVvStJh/pbJRL3HK8gWz9i37jGud1yjRZ1ApurLe9VbevNcEbv3j41XNgoUu2HbrAkPrhis+B2CLAI3id11Jrs8tuIcf3vXopqleugDETf1S70wAaZHqeh4ichTwDVyo7uWq+iUROR8YUNWFIrI1cBUwDXgGOEVVV1XL09bzMAzDqJ+ko61SHeehqrcBt5Xs+3xk+0XgpDRlMAzDMJInFw5zwzAMIyxMeRiGYRh1Y8rDMAzDqBtTHoZhGEbdpBptlQYishZ4JMahO1EyUj0nmNytxeRuLSZ3a4nKvZuq1jfKugq5Ux5xEZGBJMPSWoXJ3VpM7tZicreWNOU2s5VhGIZRN6Y8DMMwjLppZ+VxSdYCNIjJ3VpM7tZicreW1ORuW5+HYRiGkR7t3PMwDMMwUsKUh2EYhlE3QSsPEblcRJ4UkXsj+3YQkZ+LyIP+//Z+v4jIN0VkpYj8UUQOiJxzuj/+QRE5PbJ/uojc48/5ZlJL4IrIriJyu4jcJyIrROQTeZBdRLYWkd+LyHIv93l+/+4icpe/1nUiMtbv38r/XunTp0TyOtfvf0BEZkb2H+H3rRSROc3KXCJ/t4gsFZFb8iK3iDzs3+MyERnw+4IuJz7fXhG5UUTuF5E/icghocstIlP9cy7+/U1Ezgpdbp/vJ8V9k/eKyDXivtVsy7eqBvsH/DNwAHBvZN9XgTl+ew7w7377KOAnuGUkDgbu8vt3AFb5/9v77e192u/9seLPPTIhuXcBDvDb2wF/BvYOXXaf17Z+uwDc5a9xPW66fICLgQ/57Q8DF/vtU4Dr/PbewHJgK2B34C+4afm7/fargLH+mL0TLC9nAz8EbvG/g5cbeBjYqWRf0OXE5/vfwPv99ligNw9yR+TvBp4Adgtdbtxy3Q8BPZFyfUbW5Tuxl5HWHzCF0crjAWAXv70L8IDf/h5waulxwKnA9yL7v+f37QLcH9k/6riE7+F/gMPzJDswDvgDbt35p4Axfv8hwCK/vQg4xG+P8ccJcC5wbiSvRf68Tef6/aOOa1LeScAvgcOAW7wceZD7YbZUHkGXE9yKnw/hA27yIneJrG8D7siD3DjlsRqnrMb48j0z6/IdtNmqAjur6uN++wlgZ79dfMBF1vh91favKbM/UXyXcRquFR+87OJMP8uAJ4Gf41okQ6q6ocy1Nsnn058DdmzgfpLgG8C/AsW1A3fMidwK/ExElojImX5f6OVkd2At8H1xZsLLRGSbHMgd5RTgGr8dtNyqOgj8B/Ao8DiuvC4h4/KdR+WxCXVqMthYYxHZFrgJOEtV/xZNC1V2VR1R1f1xLfkDgb2ylag2IvJ24ElVXZK1LA3wBlU9ADgS+IiI/HM0MdByMgZnTv6uqk4DXsCZezYRqNwAeN/AscANpWkhyu19MMfhlPZEYBvgiEyFIp/K468isguA//+k3z8IRFeEn+T3Vds/qcz+RBCRAk5xXK2qP8qT7ACqOgTcjuvS9opIcdXJ6LU2yefTxwNP15C73P5mmQEcKyIPA9fiTFcX5kDuYqsSVX0S+DFOYYdeTtYAa1T1Lv/7RpwyCV3uIkcCf1DVv/rfocv9VuAhVV2rqsPAj3BlPtvynaQdMY0/tvR5zGe0c+urfvtoRju3fu/374Czz27v/x4CdvBppc6toxKSWYArgW+U7A9admAC0Ou3e4BfA2/HtdCijrkP++2PMNoxd73f3ofRjrlVOKfcGL+9O5sdc/skXF4OZbPDPGi5cS3I7SLbv8W1KIMuJz7fXwNT/fZcL3Pwcvu8rwXek6Pv8iBgBc4PKbhghY9lXb4T+2jT+MPZJB8HhnGtnffhbHe/BB4EfhF5aQJchLPR3wP0R/J5L7DS/0ULTT9wrz/n25Q4AJuQ+w24ru8fgWX+76jQZQdeByz1ct8LfN7vf5X/KFb6AruV37+1/73Sp78qktdnvWwPEIk48c/hzz7tsymUmUPZrDyCltvLt9z/rSjmG3o58fnuDwz4srIAV4nmQe5tcK3w8ZF9eZD7POB+n/dVOAWQafm26UkMwzCMusmjz8MwDMPIGFMehmEYRt2Y8jAMwzDqxpSHYRiGUTemPAzDMIy6MeVhGIZh1I0pD8OogYicISLf9ttzReRTWctkGFljysMwWkxkSgnDyC2mPIyORUTe7Rf5WS4iV4nIBBG5SUTu9n8zGsjzA/7c5T6vcX7/FSJysYjcBXxVRPYQkZ/62XR/LSJ7+eOO8Qv4LBWRX4jIzlUvaBgZYS0goyMRkX2AzwGvV9WnRGQH3HQSX1fV34jIZNx6B/9YZ9Y/UtVL/TUuwE2p8y2fNslfb0REfgl8UFUfFJGDgO/gJnT8DXCwqqqIvB83zfw5zd2tYSSPKQ+jUzkMuEFVnwJQ1WdE5K3A3pGVQ//BT6tfD6/1SqMX2BangIrc4BXHtsDrgRsi19rK/58EXOdndx2Lm3TPMILDlIdhbKYL1+p/MbqzzmWorwBmqepyETkDN1FjkRci1xlSt25KKd8C/lNVF4rIobgZaw0jOMznYXQqi4GTRGRHAG+2+hluqmv8vv0byHc74HG/nstp5Q5QtzDYQyJykr+OiMh+Pnk8m9dSOL2B6xtGSzDlYXQkqroC+BLw/0RkOfCfwMeBfu9Evw/4YANZ/xtuyeE7cFNoV+I04H3+2itwK8WB62ncICJLcGtPG0aQ2JTshmEYRt1Yz8MwDMOoG3OYG0YDiMhFuHWko1yoqt/PQh7DaDVmtjIMwzDqxsxWhmEYRt2Y8jAMwzDqxpSHYRiGUTemPAzDMIy6+f+VAKbPWKNKBgAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1142,7 +1142,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAx90lEQVR4nO2de5xdVXX4v2smk2QC/DIiiDIkJGqE8lIwEiz+FBAFQUNqpYD4RKTWatXS2KBUA6JG01b5tahFfKHIW6dBsPEBWksNkjjEGDA2BSQZQcIjCGSASbJ+f+x9J2funHPvufee5z3r+/nMZ+45Z99z1tl37732XmvtvUVVMQzDMKpLT94CGIZhGPliisAwDKPimCIwDMOoOKYIDMMwKo4pAsMwjIpjisAwDKPimCKoOCKiIvLCvOUwQESOFpH/EZEnRGRR3vLEwcv6fP/56yJyUUL3fYeI/FcH3/+JiJydhCxVwBRBm4jIm0Vkta8I94vI90XkFQncN8nKlOS95nilMSWJ+7Xx/GP88/8+j+fHQUTuFZHjO7jFhcC/quruqjoUcf9RX+b+4H/f3Tt4Xsd4We/O+rkiMlVElnrF+aTPm6+KyJysZekGTBG0gYj8LfB54FPAPsBs4AvAKTmK1e28HXgEeFvegqTI/sD6JmneoKq7A0cA84Hz6xNkoazz6hAEuA5YCLwZmAm8GFgDvDpPoUqLqtpfC3+4QvcEcGqDNNNwiuL3/u/zwDR/7RhgM3Au8CBwP/BOf+0cYAx4xj/jBn9+X+B6YAtwD/A3/vye/l5v8Me7AxtxjWXovUJkVeCF/vPJwDDwR2ATsDSQ7j6f9gn/9/K6++wLjAJ7Bs4dDjwE9AEvBH4KPObPXd1Cnu8GPA6c7t9nfuDaHC/XO73MjwLvAV4G/ArYiutl19L34BrP3/n8vxyYGfxt6p59L3C8/7wUuMZ/53Fcoz3fX/smsNPnwRPAhyPe5d3+N3oEWAHs68//b933p4V8d1wWf7wc+F7gd/xr4H+Ae/y51wN3+Dz4b+CwwHf/Hhjx77EBeLU/3wt8xMvzOK5xndXgGcHy83XgS8AP/Xd/CuwfeOaB/toj/pl/Ebj2bJ8ffwR+AXwC+K+IPDze59OsBmXmJ/4et3pZfgDsFbh+LfAArjz+J3Bw4NrXgUuAG/13bwNeELj+Wi//Y7gO4E+BswPXzwLuwpXFlcE8KOpf7gKU7Q84EdgOTGmQ5kJgFfAcYG9fCT/hrx3jv38hroE8CdgGPEt3FcKLAvfq8ZXxY8BU4PnA3cAJ/vprfYF+DvBl4LrAdyfcK0LWYEU+BjjUP/Mw4A/AIn9tjk/b6L1vBt4dOF4OfMl/vhL4qL/3dOAVLeT5W3EKsxe4AfiXwLWaXF/y930t8BQw5PNkENfgv8qnPwvXED8fpzi/A3wz8P7NFMFT/jfrBT4NrApLG/Eex+GU4BG4zsK/AP/ZwveDsszCKaJauVJcI7sn0I9Twg8CC7ysb/ffnwYcgFOa+wby8AX+82JgnU8juJ72s8OeEVJ+vo5rOF/pn3MxvjHHKfNNOIU9hV2dhIP89atwSnY34BCckopSBMuAnzYpMz/BKbMX+fz4CbAscP0sYA92ddruqKs3DwNHelmvAK7y1/bCKas3+msfwHW4zvbXT8GVrz/x188H/jvvdqtpHctbgLL9AWcCDzRJ87/ASYHjE4B7/edjcL2ZKYHrDwJH+c9fZ6IiWADcV3f/84CvBY7/xVfekVqlDbtXhKzjFTnk2ueBz/nPc2iuCM4GbvafxVf8V/rjy4FLgf3ayPMfAZ/3n8/AjYz66uQaDKR/GDgtcHw98EH/+cfAewPXDvAVeQrxFMGPAtcOAkbD0ka8x1eAzwaOd/fPnhPz+/fiRgtbcSOaLzCxQT4ukPaLeCUROLcBeBVudPYgrmfdF5LmlAZl5biQc0FFcFXd++3AKa3TgJ/VffffgI/jFNUYcGDg2qeIVgRfDj4nIs1PgPMDx+8F/iMi7YB/j5mB97gscP0k4Df+89uAnweu1cp5TRF8H3hX4HoPrqO3f6vlPss/8xG0zsPAXk1spPviKmqN3/lz4/dQ1e2B4224ShPG/sC+IrK19ocbuu8TSHMprhf1dVV9ON5rTEZEFojILSKyRUQew5lY9mrhFtcDLxeR5+F6hTuBn/lrH8ZVml+IyHoROSumTLOAY3G9MoB/x/X8T65L+ofA59GQ41r+hv02U5iYn414IPB5GzC9BXv5hGer6hO48jQY8/vgRmgDqrq/qr5XVUcD1zYFPu8PnFtXbmbhRgEbgQ/iFNuDInKViNTK5yxcRyaKTQ2uTbju3+8R3HvvDyyok+dM4Lm4UfOUunsHf6N6Hgae10QOmPxb7Q4gIr0iskxE/ldE/ohTsDCxrId+179L8B0VZ56tsT9wceAdH8GV+1Z+48wxRdA6PweeBhY1SPN7XIGoMdufi4PWHW/C2WMHAn97qOpJ4Ao1ThFcDry3LhS0/l7N+DbOTjtLVWfizC0S916q+ijOFnsazol3lda6jaoPqOq7VXVf4C+BL8QMW30rrpzeICIP4Mxi03GmjnYI+2224xTHk8CM2gWft3u3cO9meTTh2SKyG842PtLCM+I+fxPwybpyM0NVrwRQ1W+r6iu8PAp8JvC9F8R8Rhizah98RNOeuPfehDPnBOXZXVX/CjfC2x78Lu53ieJHwJEisl8TWaJ4M86EczzO5zenJnKM794PjD9XRCR4jHvPv6x7z35V/e82Zc0EUwQtoqqP4ez1l4jIIhGZISJ9IvI6EfmsT3YlcL6I7C0ie/n034r5iD/g7Nc1fgE8LiJ/LyL9vjdziIi8zF//CK5ynoWzyV/uG7CwezVjD+ARVX1KRI7EVZgaW3A9/Gb3+zZu+Pwm/xkAETk1UHEf9TLvjCHT24ELgJcE/v4cOElEnh3j+/VcCXxIROb6hupTOMf1duC3uB7+ySLSh7PvTmvh3s3y+0rgnSLyEhGZ5p99m6re28Z7NOPLwHv8KE9EZDf/XnuIyAEicpyX4SnciKn2W1wGfEJE5vnvHdZiPp8kIq8Qkak4Z+0qVd0EfA94kYi81deXPhF5mYj8iaruwPlqlvr6dBANFL2q/gjnq/iuiLxURKb493pPzJHmHrjO3MM4xf+pFt7vRuBQX/en4Jznzw1c/xJwnogcDCAiM0Xk1BbunwumCNpAVf8J+FtcQ7EF1wt4H85BCXARsBoXtbIO+KU/F4evAAf5oeWQrySvxzWA9+AcbJcBM0XkpV6Ot/l0n8E1sEvC7hXj2e8FLhSRx3HK65rAO28DPgnc6u93VMQ9VgDzcH6UtYHzLwNuE5EnfJoPqI8/96aiM+tv5J+xP3CJH1HU/lbgHHJnxHiner6Ki/D5T1x+PgW837/jYz4PLsP10p9k4rC/GZ/GdQC2isjf1V/0Ddg/4Exo9+N63qe38Q5NUdXVuAilf8Up3o3AO/zlaTiH60PsCjQ4z1/7Z9zv/gOcU/QrOGdrXL6Ns/s/ArwUeIuX53GcI/903AjhAVx5rSna9+HMLw/gbPRfa/KcNwE3AVfjond+jQun/VEMGS/HmZ5GgDtxgR2xUNWHgFOBz+IUyUG4uv60v/5d3Htd5c1OvwZeF/f+eSF+5G4YhmG0iIj04DoLZ6rqLXnL0y42IjAMw2gBETlBRAa8ae0jON9C7FFFETFFYBiG0Rovx0VWPQS8ARfJNdr4K8XGTEOGYRgVx0YEhmEYFSfvhaNaZq+99tI5c+bkLYZhGEapWLNmzUOqGjovpnSKYM6cOaxevTpvMQzDMEqFiETO1jbTkGEYRsUxRWAYhlFxTBEYhmFUHFMEhmEYFccUgWEYRsUpXdSQYbTL0PAIy1du4PdbR9l3oJ/FJxzAosMLvUy8YWSCKQKjEgwNj3Ded9YxOrYDgJGto5z3nXUApgyMymOmIaMSLF+5YVwJ1Bgd28HylRtyksgwioONCIxK8Put4WuCRZ034mHmtu7ARgRGJdh3IHxvlajzRnNq5raRraMou8xtQ8NJ7bxpZIUpAqMSLD7hAPr7eiec6+/rZfEJB+QkUfkxc1v3YKYhoxLUzBVmxmiNRqYfM7d1D6YIjMqw6PBBa/g9Q8MjLF2xnq2jYwA8a0YfH3/DwRPyp1mk1b4D/YyENPpmbisfZhoyjIoxNDzC4mvXjisBgEe3jbH4urUT7PvNTD9pmtuGhkc4etnNzF1yI0cvu9n8DiljisAwKsbylRsY2zl5Z8KxHTrBvt/M9LPo8EE+/cZDGRzoR4DBgX4+/cZDOx51mRM6e8w0ZBgFJo3wzEY2/OC1OKafNMxtjUYiZtpLBxsRGEZBSatn3MiGH7yWV6SVOaGzxxSBYRSUtMIzF59wAH09Mul8X69MaOTTMv00w+Z8ZI+ZhhLEZlkaSZJWz7hWJptFDdXSZl2GF59wAIuvW8vYjl1+jHolZSSLKYKEsEXNjKRJMzyz8KG09b7syb5tI0HMNJQQNsvSSJqyz4ZuNwQ0LKppbKdaXUoRGxEkhDm4jKQJmw197IF7s3zlBj509R2FNj92MkK2upQ9pggSwmZZGmkQNOGUyfzYSQio1aXsMdNQQmQxjLfZltWmTObHsIYc4vXqy24SKyM2IkiItBY1q0UijWwdRdjlMytyb9BIh05MJllGtA0Nj0woq0Hi9OptgcDsMUWQIElHYtSbAuorls22rBbtmkyyNiktX7khVAkIxO7VFz6qqcsw01CBCTMF1GMOtOrQrskka5NSVJlUbPRaVEwRFJg4jbw50KpDuzN9s47CiSqTg1ZWC4spggLTrJE3B5oRh6yXbDBnb/kwRVBgwipUbYWYrNZ9MYpDu4vQZd0w57VGkdE+qTqLReRE4GKgF7hMVZfVXZ8NfAMY8GmWqOpNacpUJix6wgjSbmx+HuXInL3lIjVFICK9wCXAa4DNwO0iskJV7wwkOx+4RlW/KCIHATcBc9KSqYxYhTJqdGLrt3JkNCJN09CRwEZVvVtVnwGuAk6pS6PA//GfZwK/T1Eewyg1tjyzkRZpKoJBYFPgeLM/F2Qp8BYR2YwbDbw/7EYico6IrBaR1Vu2bElDVsMoPOaENdIi7wllZwBfV9V/EpGXA98UkUNUdWcwkapeClwKMH/+fFuQ1uh6Gs0ENp+RkTRpKoIRYFbgeD9/Lsi7gBMBVPXnIjId2At4MEW5DKPQNJsJbA2/kTRpmoZuB+aJyFwRmQqcDqyoS3Mf8GoAEfkTYDpgth+j0pRpcTmjO0hNEajqduB9wErgLlx00HoRuVBEFvpk5wLvFpG1wJXAO1TVTD9GpbH1+I2sSdVH4OcE3FR37mOBz3cCR6cpg2GUDVuP38gam1lsGAXDooOMrMk7asgwjDosOsjIGlMEhlFA0owOynKTmqQoo8xlwhSBYWRMno1aXvsed/LOZdqruayYj8AwMqTdFUSTIo/Q1E7f2cJp08cUgWFkSN6NWh6hqZ2+s4XTpo8pAsPIkLwbtTwWruv0nW2xvfQxRWAYGZJ3o5ZHaGqn72zhtOljisAwMiTvRi2P3cM6fWfb8Sx9pGwrOsyfP19Xr16dtxiG0TZVDIWs4jsXDRFZo6rzQ6+ZIjAMw+h+GikCMw0ZhmFUHFMEhmEYFccUgWEYRsUxRWAYhlFxTBEYhmFUHFt0zjBKhoViGkljisAwSkS3rMRpyqxYmGnIMEpE3ovWJUHeK7Aak7ERgWGUiLwXrUuCRsqs2ajARhLpYIrAMEpE3I3ti9xgtqvMusUsVkTMNGQYbTI0PMLRy25m7pIbOXrZzZmYNuIs4FZ000u7q5F2g1msqJgiMIw2yKuxjbMSZ9EbzHZXI+0Gs1hRMdOQYbRBJ3buTmm2sX3RG8ya7K2aruKaxYzWMUVgGG1Q5Ma2DA1mM2UWxuITDpjgIwDboCYpTBEYRh1xHK1FbmzL3mBG5X+7IwmjOaYIDCNA3MiUIje27TaYRYg0apb/7YwkjObYxjSGEeDoZTeH9vQHB/q5dclxE84VoeFMivoGGJxiy3pLyFby32iNRhvT2IjAMAK0Yvvvpt5pns7vIEX2vXQzFj5qGAHajXEvO0VpgKua/3ljisAwArQb4152itIAVzX/88YUgWEEiDNhqxspSgNc1fzPG3MWG4YBdJfz25iMOYsNw2hKNzm/jdZI1TQkIieKyAYR2SgiSyLS/IWI3Cki60Xk22nKYxiGYUwmtRGBiPQClwCvATYDt4vIClW9M5BmHnAecLSqPioiz0lLHsMwDCOcNE1DRwIbVfVuABG5CjgFuDOQ5t3AJar6KICqPpiiPIZReMxOb+RBmqahQWBT4HizPxfkRcCLRORWEVklIiemKI9hFJqi7yNgdC95h49OAeYBxwBnAF8WkYH6RCJyjoisFpHVW7ZsyVZCw8iIou8jYHQvaSqCEWBW4Hg/fy7IZmCFqo6p6j3Ab3GKYQKqeqmqzlfV+XvvvXdqAhtGnhRldq9RPdJUBLcD80RkrohMBU4HVtSlGcKNBhCRvXCmortTlMkwCktRZvca1SM1RaCq24H3ASuBu4BrVHW9iFwoIgt9spXAwyJyJ3ALsFhVH05LJsMoMkWZ3WtUD5tZbBgFwqKGjLSwmcWGURJsdq+RB6YIDMOIhY1WuhdTBIZhNCXuFp5GOcl7HoFhGCXA5jh0N6YIDMNois1x6G7MNFRRzN5rtMK+A/2hm8rX5jhYeSo3NiKoILamjdEqjeY4JF2ehoZHOHrZzcxdciNHL7vZymUGmCKoIGbvNVql0RaSS1esT6w8WSclH8w0VEHM3mu0Q9gch6HhEbaOjoWmb6c8XXBDtFIxU1N6xBoRiMgMEfkHEfmyP54nIq9PVzQjLWxNGyMpGvX6Wy1PQ8MjPLotXKmMbB01M1GKxDUNfQ14Gni5Px4BLkpFIiN1bE0bo0an9vhGvf5Wy1MzU5KZidIjriJ4gap+FhgDUNVtgKQmlZEqjey9VaLqTsmh4REWX7d2gj1+8XVrW8qHqF7/s2b0tVye4piSzJeVDnF9BM+ISD+gACLyAtwIwSgpVV/TxmbKOnv82I6Ji06O7VAuuGF97DxYfMIBE/IR3Ojy4284uGV5okJU6zFfVvLEHRF8HPgPYJaIXAH8GPhwalIZRspY5BSR9vio82EkOboMM1mGYb6s5Ik1IlDVH4rIL4GjcCahD6jqQ6lK1oXYpJviYJFTyZHU6LJ2j1odmdnfx5PPbJ8wajFfVjrEUgQicoT/eL//P1tEZgK/8xvQGE0wU0SxaDZTtgoM9PeFhn4O9Pel9sxmnaF6pWKdp2yI6yP4AnAE8CvciOAQYD0wU0T+SlV/kJJ8XUMjU4QV7OyJsm1Xqbe5dOHBLL52LWM7d/W4+3qEpQtbt+/HoZ3OUNV9WVkR10fwe+Bwv4H8S4HDcXsLvwb4bFrCdRNmiigWFjnl8mD5qS+ekAfLT31xanlgfpniEndE8CJVXV87UNU7ReRAVb1bxKJI49ANpohuG6ZbbzPbPLDOUHGJOyJYLyJfFJFX+b8vAHeKyDT83AKjMWWfxGVrwBidYjPai0tcRfAOYCPwQf93tz83BhybvFjdR9lNETasNzql7J2hbkZUtXmqAjF//nxdvXp13mJUjrlLbiSspAhwz7KTsxbHKAFhpkSgq8yLZUJE1qjq/LBrccNHjwaWAvsHv6Oqz09CQKP4dIOPw8iOqAihT7/xUG5dclzO0hn1xDUNfQX4Z+AVwMsCf0ZFsGG90QpmSiwXcaOGHlPV76cqiVFoasP3C25YP74EwbQptq+REY5FCJWLuIrgFhFZDnyHwGJzqvrLVKQyCstTYzvHP28dHbPZ0UYoZkosF3EVwQL/P+hoUMCMfRWiSrOju23ORNbYzO1yEXfROQsRNSoz3D9/aB1XrLpvPErK1oVqnfoF5EyZFpvYexaLyMnAwcD02jlVvTANoYxiUoXh/tDwyAQlUKNbRz5pYjO3y0PcPYu/BJwGvB8XOn4qLpTUqBBViBxavnJD6HwJ6L6RT1Go+k5xRSDuiOBPVfUwEfmVql4gIv8EWBRRxajCcL9RY99NI5+iYMuzF4O4iqBWO7aJyL7Aw8Dz0hGpe+kGB2S3D/ejzF9C65uxG82pUgBCkYmrCL4nIgPAcuCXuIihy9ISqhuxnk84RVOOYdEuApx51Oyu+J2Klt9VCUAoOnGjhj7hP14vIt8DpqvqY+mJ1X1Yz2cyeSjHODtkQXeav4rYGalCAEIZaCVq6E+BObXviAiqenmT75wIXAz0Apep6rKIdH8OXAe8TFW7ckU56/lMJmvlGLch7FbzVxE7IzbfoBjEjRr6JvCPTFxrKHQVu8B3eoFLgNcBBwFniMhBIen2AD4A3NaS5CXD1mKfTNbKserr3xShM1IfIQSUenn2biHuiGA+cJC2tmb1kcBGVb0bQESuAk4B7qxL9wngM8DiFu5dOqznM5mszQJFaAjzJG8zjK1IWlzirhr2a+C5Ld57ENgUON7sz40jIkcAs1T1xhbvXTrKujFNmjHeWc9LqPqoLO95IFUfkRWZhiMCEbkBFyG0B25ryl8wcdG5he0+WER6cEtbvyNG2nOAcwBmz57d7iNzp2y257Sdi3Eds0lFulR9VJa3I7zqI7Ii08w0tALYB/hZ3fn/C9zf5LsjwKzA8X7+XI09gEOAn4gIuBHHChFZWO8wVtVLgUvB7VDW5LlGQmThXGymHJNURnk3hEUgz85I3qYpI5pmiuAU4DxVXRc8KSKPAJ/CbVgTxe3APBGZi1MApwNvrl304ad7Be75E+DvujVqqIwUoQeXtDIq26ism6j6iKzINPMR7FOvBAD8uTmNvqiq24H3ASuBu4BrVHW9iFwoIm2blIzsKIJNvQjKyEiGsvrJqkCzEcFAg2tNWwNVvQm4qe7cxyLSHtPsfka2FKEH143mhKLN7s0SG5EVk2YjgtUi8u76kyJyNrAmHZGMolCEHlzekS5JU/N5jGwdRdnl87AVN408kUZTA0RkH+C7wDPsavjnA1OBP1PVB1KXsI758+fr6tXmRqgS3dSDPnrZzaEjnMGBfoulN1JFRNaoauhE4IamIVX9A/CnInIsLsIH4EZVvTlhGQ0jkm4yJ5jPwygicReduwW4JWVZDKPr6Uafh1F+Yi86ZxhFJWnTUZqmqCI44A2jHlMERqlJevZzUWZTG0aWmCIwSk3SE86KMJvaMLIm7qJzhlFIkna+mjPXqCI2IjBKTdLO1yo7c7spTNdoDVMEBhDeCEDxbdlJO1+r6swt4jaWRnaYIqgwtcZ/ZOsogltvHFwjsPjatSAwtkPHzxWxYUja+VpVZ24Rt7E0ssMUQQHIY0he3wOsn18+tnPyjPOiNgxJO1+r6Mw130i1MUWQM3kNycN6gHGwhqE4JNmBqLJvxLCoodzJa/u+dht0axiKQdKL16W9uF+aW54anWOKIGfyGpI3a9D7eoS+XplwrgpO07KQdAcizZVmbcXV4mOmoZzJa0geFh1TcxgPlihqqKrE6UC0ajrqxDdy/tA6rrxtEztU6RXhjAWzuGjRoUDrjmgLY80eUwQ5k1e4YtzoGKuA6dFJg9esA5Gl7+n8oXV8a9V948c7VMePL1p0aEujXgtjzQczDeVMnpu/LDp8kFuXHMc9y07m1iXHWUXLkE7NJc1s+ln6nq68bVPD861seZqXz6zq2IigABQ1XNGG6OnRadx+sxFdlr6nHRGbW9XOtzLqtTDWfDBFYIRiQ/R0SaLBa9SByNL31CsSqgx6xQUbtDJJz8JY88FMQxUkTiifDdHTpRVzSTtkudfzGQtmNT0f1wzZbXtUlwVTBBUjrm3ahujpknaDl6Xv6aJFh/KWo2aPjwB6RXjLUbPHo4ZaIU+fWZVpuHl9EbHN6zsj7ubptsl6+pgPxsiStjevN7qPuD39VsNarVFrnaIGCZQFK3PJYYqgYsR1xrXi4DPHcjXJsyG2MpcspggqRis9/bg9VlvCuHqk2RDHUTBW5pLFnMUVIw1nnDmWq0daUWUWzJAPNiKoIEnbpi32u3qk1RBHKZilK9ZPKLNW5pLFRgRdQN5L/Frsd/WIanB7RDoqf1GKZOvo2IT7WplLFhsRlJzzh9Zxxar7JmwzmbTTrJnNtqrbO5aNJJ27Yb4mcMtKdFL+onr6wAT7v5W5ZLF5BCVmaHiED119x6RtJiG5eP96pyC4npdN8ikXafyOQ8MjnHvN2tDlJdotf0PDI3zw6jtCrwlwz7KTW76n4Wg0j8BMQyVm+coNoUoAknOaFX2pibzNYmUhjd9x0eGD7IzoSLZb/hYdPsizZvSFXjP7f3qYaahD8oylblTZFDc7uFHsf73cMHmoXeToDIslj09av2MaTtuPv+HgXPboqDKmCDog74aokT21kTxhci++bi0ojO3UCd+d2d/H1tGx0GfnTR6x5EWezdpItrSibNLYWMns/9ljiqADsmiIGlXuKIddM3nC5B7bMXmIPzq2g+l9PfT39Rayd5b1aCVvxd+IZrKltRNeWo22Lb+RLakqAhE5EbgY6AUuU9Vlddf/Fjgb2A5sAc5S1d+lKVOSpN0QNavc9ZUwrr+gFfm2bhvjc6e9pJC9s6xjyYs8m7WZbGn2sq3RLj+pKQIR6QUuAV4DbAZuF5EVqnpnINkwMF9Vt4nIXwGfBU5LS6akSbohqu/9P/n09qYNT7ASRq0YWi9PM5NSfdqiVvSs93uOUqBx8jJtk1KcTklRf0cjf9KMGjoS2Kiqd6vqM8BVwCnBBKp6i6pu84ergP1SlCdxkpzUEja1Psw2D9GVPq48Yen6eoW+Hpn03WMP3LuwUTlZr10fpeAF9/tFRTB1uj9xJ7IVwZdjFJ80TUODQHBX683Aggbp3wV8P+yCiJwDnAMwe/bspOTrmCSH22FD+yiiKndceaLS1Z879sC9uX7NSCFt4jWy6uUODY/w5NPbQ68pcMEN63lqbGdoXmVhUupkdFRkB7iRDalNKBORNwEnqurZ/vitwAJVfV9I2rcA7wNepapPN7pvt04om7vkxkgbf5C+HmH5qS+OVVE7reDdtjlNu/kRNhkrLoMD/ZH+m6QnSLXzfjZhsDrktTHNCBDczHQ/f24CInI88FFiKIFuJq7dfuqUnrYar3Z680WeQ9AqneRHK6O1emqNcthv2yPC3CU35hppk7UD3EYfxSRNRXA7ME9E5uIUwOnAm4MJRORw4N9wI4cHU5Sl8MQJBQV48pl4DVISFTyuM7wMlbuT/Gim+Pr7epk2pSfUpzMwo6/hujzg53Fcu5YLbljP1m1jDMzoQxUeGx1LPT/bVfZJjD6KaGqsKqk5i1V1O87csxK4C7hGVdeLyIUistAnWw7sDlwrIneIyIq05Ck6QcdnEiTRm4/jfM7CEZoEneRHI4drzUG9dOHB9PXKpOtPPOX8CkGndm2T9yBjO5VHt42hwKPbxtg6OpZJfvb3hTcBUeeh/d+86MuVVJlU5xGo6k3ATXXnPhb4fHyazy8btaF9lG0eYKA/fB2WepIIbY3jfC5ybH2NoeERekRCF0eLkx9Rjth6O/rSFesnjQrGdirLV27g1iXHjaedu+TGluRvJz/j9thHt+8Mf2bEeWjeoEc9t5tMjd2GzSwuIItPOIDF162dNNu3B1i68ODY90gixr6Z3bnolbvWew1TAnHzI2401mMxw30HZvTx6LbwtFG0kp+tmGCiYkUaxZA0mk/R6LlR720hrvljiqCA1CrrBTesH684A/19LF14cOxeYVbrtRR9p6goR2+vSEuRMXEcsXHyYmh4ZNxc1Aqt5Gcro7TeiJFSmPkqKEvUiLXRSCHsvft6pRDLlVQdUwQFJYn4+Cxi7LOe3dsqUb3XnaqJ502cvFi+csP4wn5xaTU/WxmlnbFgFt9adV/o+SjiBjYEnxv13rtNnVIYE2KVMUXQpWQVyVP0lSKzGLEMDY9MGL0JbpLZYEheNDLx1OYcDMzo46mxHYyOOTv99AaO2zBaeeeLFh0KwJW3bWKHKr0inLFg1vj5MOp/8yj/S/C5Ue8dZU4zssV2KOtCunmSUKsKLu28GBoeCfXnRE38izNJr1OZs/79G02GrD13+coNoe/dK8JO1cJ1ILoR26GsoKS1u1a3hum1E7aY9npEy1duCF3CuxYtVE+ckNxOf78k3zlOGY0aXQX9MGHvDW4uRZHDjquCmYZyIs1N54seyROklR5+u6GqafpKGuVp2LU4prQkfr8k3jlu9FGjCXMfvPoOPnj1HQwO9PPnLx3klt9siTQnFS3suEqYIsiBoeGRCUqgRlIVoeiRPDXiNjQ1ZREVqZKngmsUQdNoccDg+50/tG58E/joWJ3sf7+4ijeo3KLyYmTrKNevGRkfIUTNpShiZ6UKmGkoB9LedD7J5bHTJI4JJGgOiiJPBXfsgXuHnu/riRcWef7QOr616r7x3rH6v3qifr8kzItR92hlZLLo8EFuXXJcw7DT4G9ry2YXCxsR5ECjxj6JipB3JE9cc0+chqbZgm95Krih4RGuXzO54Z3R18On3nhYrPy+8rZNTdNEzXlIYu2eRvdoZ2TZKHoIdv22eYQdl2FNrLwwRZADURVMILGKkNduVHEap1qFjGoygg1Ns3DLPCtzlJJ61m7TYsvUrOGE6DkPSSzv0ege7TTWURPUatR+26w7K7bgXWNMEeRAWAUT4MyjZpe+UDZrnJqt7V/f0EQpzSLsiZCEU7dZwwnRPfAknt/oHu001lET1GDyb5tlZ6UMa2LliSmCHMjbdJMmzRqnRqaesB5+kWcuJ+GUb9RwQuN3TeL5ze5R31jX/AlR5bZ+glqNvEdvZYqkywNTBDmRl+kmbZo1LFEVTyC0h19kpZmEkqpvOAWYMbWXbc/saPquSTy/lXvENa9ctOjQhjOT86AskXR5YYqgS8nLMdasYWmnQhZVaSalpNptOJN4fiv3KLN5pcgjyyJgS0x0IXkvMdFICeUtm9E+UUtJJLH3chYdl6pHDeW1Z3FhqFoByLvn1qgHX2RTj9GYtMwrWUX0FHVkWQS6XhEkVcjKpEyK7hizCllO0jKvRHVcLrhhfWnqXNnpekWQRO+4bDHI3eQYK5MC7nZq+R7ckrPVJbLDiOqgPLptbHxp76LXubLT9Yogid5x3qaWVimzYyzY8M/s7+PJZ7aPr+5pjUExeDqwn/Gj28Y6/k0ardcUpMh1rux0/VpDSaxpUnRTSz1pL72cFvXLTG8dHZu0xHM3LKddZtJY4jxqieowilrnyk7XjwiS6B2X0dRSRjt8s3WFalhjkB9pdIrCAgiefHr7uPkpSJHrXJnpekWQRJRKmU0tZSJuY2KNQXK06oNJq1MUNoPZ6lx2dL0igM57xxbymA1xbMVVbwySdJ63skBg7XnHHrg3168ZSb2BDqtzxx64N8tXbuBDV99hdTBhbEKZURjCeoF9PcLu06ewddtYYpW/rJFISU/Ga7Z/ctTzgjuNZZV/NhGxcyo/ocwoB1mMvMoWChwkylF77jVrgdblb2eBwNGxHdzymy2Zr/xatsi9smGKwCgUaTu5y9ygRDXcO1TbUmbtLhCYh7O+SLJ0I10fPmoYNYaGRwq573FcGjlk2wnhbLalaZG2k8xSliS2/ywbpgiMSlAzCUVRhkikZvH2rSqzZvNNirT3dVay1M9lqZkOu10ZmGnIqASN5iiUJRKp1kCfe83a0F3N2lFmZVkgMCtZymw67ARTBEbhCUb5DMzoQxUeG20tiqhRb7nokSf1UU5nLJiVSQgnFGtiYhayVNUXYYrAKDT1UT61Rchg17B99e8eaRrO2Gjv46I0dGGERTldv2YklxDObiWoaHsi9pAug+mwE0wRGIWm2bITo2M7uGLVfeMbpkSFg5Z1dniRQjiTIM4cjiznedQr2jAlUIZy0immCIxIijDxKs6QvL7qhtl0i2TvboVuMlUMDY+w+Nq1jO3ctZrs4msnzoFoZZ5HWPmEXb/xzP4+xnbs5Mln3L36+3qY3tc7YXJiVEejV4SdqqUpJ52S6sxiETkRuBjoBS5T1WV116cBlwMvBR4GTlPVexvdsxtnFrfS4DbbBrKdhi6qQnU6y3doeIQLblg/bs4Z6O9j6cKDY1eq84fW8a1V98VKW0/99olFUGrt0Gz2bxok4ZMJ3mdk6yi9ESYX2FUugvsc1BN836HhkdC0vT2C7lR2ht0gAwSYMbV3XPFEMbVXmDF1Co+Njk3I39rnraNj4/nVI+D1JiKg6vKinfLbaGZxaopARHqB3wKvATYDtwNnqOqdgTTvBQ5T1feIyOnAn6nqaY3u222KoJWp843SwuSGO84U/Kh7TpvSE1kp49x/aHiExdetnbSMdF+PsPzUFzctxHGVgDB5RACTG46yLk+QtexhzwsS99nN7lNPX4+MjxSiuHfZyS3ft1tppww0UgRpziM4Etioqner6jPAVcApdWlOAb7hP18HvFpEJEWZCkcr67s3StvuOvFR32umBJrdf/nKDZOUAMDYTo018enK2zZFXhvo7xuPez/zqNlN48vTWEM/K7LeWyKOTyZOvsVdUrxGMyXQ65uFVu/brSRdftP0EQwCwdq8GVgQlUZVt4vIY8CzgYeCiUTkHOAcgNmzZ6clby60YgNux17czJbcqa05DZkg3GlX446Pv3bC8fz992xo9im7nT3LEM44eZJUmlaolYey/GZZkGRelMJZrKqXApeCMw3lLE6itLK+e7O07awTH3XPZ83o46mxnU17X42m/kct5xAnFC/KptwbMmBs1lCWcWOhvIizFHicfIu7/WRfr7Db1ClNR6CD/plx71sFkiy/aZqGRoBZgeP9/LnQNCIyBZiJcxpXhlamzjdK2+4U/KjvffwNB08wSQz099HXK5PSRd1/8QkHTEoPzhYcJxTvjAWzWjrfiCItlVB0mi1jETffGt2nVioGB/pZ/qYXs3ThwfT1RFuEg89sdN8ecX9VIOnym+aI4HZgnojMxTX4pwNvrkuzAng78HPgTcDNWrYNEjqklbDGOGlbjYxpds/6XaPi3r92vt2ooYsWOQf4lbdtYocqvSKcsWDW+PlWKGvoaB7U51W7UUPB+wSjhhpFvAQjgWrRMvXpm903KHt/Xw+j23eSVYtS9KihhrKnHD56EvB5XPjoV1X1kyJyIbBaVVeIyHTgm8DhwCPA6ap6d6N7dlvUkGEYRhbktjGNqt4E3FR37mOBz08Bp6Ypg2EYhtEYW4baMAyj4pgiMAzDqDimCAzDMCqOKQLDMIyKk2rUUBqIyBbgd3nL4dmLulnQJcJkz56yyg0me14kKfv+qrp32IXSKYIiISKro8Kxio7Jnj1llRtM9rzISnYzDRmGYVQcUwSGYRgVxxRBZ1yatwAdYLJnT1nlBpM9LzKR3XwEhmEYFcdGBIZhGBXHFIFhGEbFMUXQASJyroioiOzlj0VE/p+IbBSRX4nIEXnLGERElovIb7xs3xWRgcC187zcG0TkhBzFjERETvTybRSRJXnL0wgRmSUit4jInSKyXkQ+4M/vKSI/FJH/8f+flbesYYhIr4gMi8j3/PFcEbnN5/3VIjI1bxnDEJEBEbnOl/O7ROTlJcrzD/my8msRuVJEpmeV76YI2kREZgGvBYI7rL8OmOf/zgG+mINojfghcIiqHgb8FjgPQEQOwu0XcTBwIvAFEYnenSQHvDyX4PL4IOAML3dR2Q6cq6oHAUcBf+3lXQL8WFXnAT/2x0XkA8BdgePPAJ9T1RcCjwLvykWq5lwM/IeqHgi8GPcOhc9zERkE/gaYr6qH4JbuP52M8t0UQft8DvgwEPS2nwJcro5VwICIPC8X6UJQ1R+o6nZ/uAq3axw4ua9S1adV9R5gI3BkHjI24Ehgo6rerarPAFfh5C4kqnq/qv7Sf34c1yAN4mT+hk/2DWBRLgI2QET2A04GLvPHAhwHXOeTFFXumcArga8AqOozqrqVEuS5ZwrQ73drnAHcT0b5boqgDUTkFGBEVdfWXRoENgWON/tzReQs4Pv+cxnkLoOMoYjIHNzmS7cB+6jq/f7SA8A+ecnVgM/jOjk7/fGzga2BTkRR834usAX4mjdrXSYiu1GCPFfVEeAfcRaG+4HHgDVklO+l2Lw+D0TkR8BzQy59FPgIzixUOBrJrar/7tN8FGe6uCJL2aqIiOwOXA98UFX/6DrXDlVVESlU/LaIvB54UFXXiMgxOYvTKlOAI4D3q+ptInIxdWagIuY5gPdbnIJTZluBa3Fm2kwwRRCBqh4fdl5EDsX9WGt9pd4P+KWIHInbmzm4u/p+/lxmRMldQ0TeAbweeHVgf+jc5Y5BGWScgIj04ZTAFar6HX/6DyLyPFW935sNH8xPwlCOBhb6bWanA/8HZ3cfEJEpvnda1LzfDGxW1dv88XU4RVD0PAc4HrhHVbcAiMh3cL9FJvlupqEWUdV1qvocVZ2jqnNwhe8IVX0AWAG8zUcPHQU8FhiS5o6InIgb8i9U1W2BSyuA00VkmojMxTm7f5GHjA24HZjnoyim4hxpK3KWKRJvV/8KcJeq/nPg0grg7f7z24F/z1q2Rqjqeaq6ny/bpwM3q+qZwC3Am3yywskN4OvgJhE5wJ96NXAnBc9zz33AUSIyw5edmuyZ5LvNLO4QEbkX5+l/yP+A/4ob0m0D3qmqq/OUL4iIbASmAQ/7U6tU9T3+2kdxfoPtODPG98Pvkh++l/p5XETFV1X1k/lKFI2IvAL4GbCOXbb2j+D8BNcAs3HLqf+Fqj6Si5BN8Kahv1PV14vI83EO+j2BYeAtqvp0juKFIiIvwTm5pwJ3A+/EdXgLn+cicgFwGq4ODgNn43wCqee7KQLDMIyKY6YhwzCMimOKwDAMo+KYIjAMw6g4pggMwzAqjikCwzCMimOKwDDaQESeaHJ9QETem5U8htEJpggMIx0GAFMERikwRWAYHSAiu4vIj0XklyKyzi9ICLAMeIGI3CEiy/OU0TCaYRPKDKMNROQJVd29tmSwX1BuL9zy3vOA/YHv+bXlDaPQ2KJzhtEZAnxKRF6JW0pikAIuc2wYjTBFYBidcSawN/BSVR3za09Nz1ckw2gN8xEYRmfMxK3fPyYix+JMQgCPA3vkJ5ZhxMcUgWF0xhXAfBFZB7wN+A2Aqj4M3Oo3IjdnsVFozFlsGIZRcWxEYBiGUXFMERiGYVQcUwSGYRgVxxSBYRhGxTFFYBiGUXFMERiGYVQcUwSGYRgV5/8DwEjgQtgUGXAAAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1154,7 +1154,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1166,7 +1166,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1191,14 +1191,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 99,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 6/6 [00:09<00:00,  1.52s/it]\n"
+      "100%|██████████| 6/6 [00:08<00:00,  1.45s/it]\n"
      ]
     }
    ],
@@ -1220,7 +1220,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 100,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1235,7 +1235,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 101,
    "metadata": {},
    "outputs": [
     {
@@ -1263,7 +1263,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 102,
    "metadata": {},
    "outputs": [
     {
diff --git a/use_cases/eluc/prescriptors/nsga2/configs/updated-format.json b/use_cases/eluc/prescriptors/nsga2/configs/fixed-distance.json
similarity index 54%
rename from use_cases/eluc/prescriptors/nsga2/configs/updated-format.json
rename to use_cases/eluc/prescriptors/nsga2/configs/fixed-distance.json
index 6e36b0c..94425f6 100644
--- a/use_cases/eluc/prescriptors/nsga2/configs/updated-format.json
+++ b/use_cases/eluc/prescriptors/nsga2/configs/fixed-distance.json
@@ -1,8 +1,8 @@
 {
-    "predictor_path": "predictors/trained_models/danyoung--eluc-global-nn",
+    "predictor_path": "predictors/neural_network/trained_models/no_overlap_nn",
     "evolution_params": {
-        "pop_size": 10,
-        "n_generations": 3,
+        "pop_size": 100,
+        "n_generations": 100,
         "p_mutation": 0.2,
         "candidate_params": {
             "in_size": 12,
@@ -11,5 +11,5 @@
         },
         "seed_dir": "prescriptors/nsga2/seeds/small_sample"
     },
-    "save_path": "prescriptors/nsga2/trained_prescriptors/reformat-test"
+    "save_path": "prescriptors/nsga2/trained_prescriptors/no-overlap"
 }
\ No newline at end of file
diff --git a/use_cases/eluc/prescriptors/nsga2/configs/test.json b/use_cases/eluc/prescriptors/nsga2/configs/no-overlap.json
similarity index 100%
rename from use_cases/eluc/prescriptors/nsga2/configs/test.json
rename to use_cases/eluc/prescriptors/nsga2/configs/no-overlap.json
diff --git a/use_cases/eluc/prescriptors/nsga2/trainer.py b/use_cases/eluc/prescriptors/nsga2/trainer.py
index 8b31057..c4cc63e 100644
--- a/use_cases/eluc/prescriptors/nsga2/trainer.py
+++ b/use_cases/eluc/prescriptors/nsga2/trainer.py
@@ -115,8 +115,9 @@ def neuroevolution(self, save_path: Path):
         3. Make new population from parents
         """
         if save_path.exists():
-            shutil.rmtree(save_path)
+            raise ValueError(f"Path {save_path} already exists. Please choose a new path.")
         save_path.mkdir(parents=True, exist_ok=False)
+        print(f"Saving to {save_path}")
         self.encoder.save_fields(save_path / "fields.json")
         results = []
         parents = [Candidate(**self.candidate_params, cand_id=f"1_{i}") for i in range(self.pop_size)]

From 1cb76207aab397c61c62b15ffc13a8a814ac2d50 Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Mon, 3 Jun 2024 15:06:45 -0700
Subject: [PATCH 09/17] Modified app to use new prescriptors and performed
 minor refactoring of prescriptors

---
 use_cases/eluc/.gitignore                     |  5 ++--
 use_cases/eluc/Dockerfile                     |  3 +++
 use_cases/eluc/app/app.py                     | 22 +++++----------
 use_cases/eluc/app/constants.py               |  9 +++----
 use_cases/eluc/app/data/pareto.csv            | 11 ++++++++
 use_cases/eluc/app/process_data.py            |  2 +-
 use_cases/eluc/app/utils.py                   | 27 +++++++++++++++++--
 .../experiments/prescriptor_experiments.ipynb |  4 +--
 use_cases/eluc/predictors/upload_model.py     |  8 +++++-
 .../nsga2/configs/fixed-distance.json         |  2 +-
 .../nsga2/configs/no-overlap.json             |  2 +-
 use_cases/eluc/prescriptors/nsga2/trainer.py  |  3 +--
 .../{nsga2 => }/prescriptor_manager.py        |  0
 13 files changed, 64 insertions(+), 34 deletions(-)
 create mode 100644 use_cases/eluc/app/data/pareto.csv
 rename use_cases/eluc/prescriptors/{nsga2 => }/prescriptor_manager.py (100%)

diff --git a/use_cases/eluc/.gitignore b/use_cases/eluc/.gitignore
index ad3557e..20cec0a 100644
--- a/use_cases/eluc/.gitignore
+++ b/use_cases/eluc/.gitignore
@@ -9,11 +9,12 @@ experiments/figures
 
 prescriptors/esp
 # Ignores trained prescriptors and seeds
-prescriptors/*/trained_prescriptors
+prescriptors/*/training_runs
 prescriptors/*/seeds
+prescriptors/trained_models
 prescriptors/nsga2/transfer_prescriptors.ipynb
 
+app/data/app_data.csv
 data/*.zip
-data/processed/*.csv
 *.nc
 
diff --git a/use_cases/eluc/Dockerfile b/use_cases/eluc/Dockerfile
index 53197e4..70092e6 100644
--- a/use_cases/eluc/Dockerfile
+++ b/use_cases/eluc/Dockerfile
@@ -22,6 +22,9 @@ RUN pip install --no-cache-dir --upgrade pip && \
 # Copy source files over
 COPY . .
 
+# Python setup script - downloads data and processes it
+RUN python -m app.process_data
+
 # Expose Flask (Dash) port
 EXPOSE 4057
 
diff --git a/use_cases/eluc/app/app.py b/use_cases/eluc/app/app.py
index 17bbe4f..4858ff3 100644
--- a/use_cases/eluc/app/app.py
+++ b/use_cases/eluc/app/app.py
@@ -18,10 +18,8 @@
 import dash_bootstrap_components as dbc
 
 from data import constants
-from data.eluc_data import ELUCEncoder
 import app.constants as app_constants
 from app import utils
-from prescriptors.nsga2.torch_prescriptor import TorchPrescriptor
 
 app = Dash(__name__,
            external_stylesheets=[dbc.themes.BOOTSTRAP, dbc.icons.BOOTSTRAP],
@@ -32,19 +30,13 @@
 df.rename(columns={col + ".1": col for col in app_constants.INDEX_COLS}, inplace=True)
 COUNTRIES_DF = regionmask.defined_regions.natural_earth_v5_0_0.countries_110.to_dataframe()
 
-# Prescriptor list should be in order of least to most change
+# Load pareto df
 pareto_df = pd.read_csv(app_constants.PARETO_CSV_PATH)
-pareto_df = pareto_df.sort_values(by="change", ascending=True)
+pareto_df.sort_values(by="change", inplace=True)
 prescriptor_list = list(pareto_df["id"])
 
-encoder = ELUCEncoder.from_json(app_constants.PRESCRIPTOR_PATH / "fields.json")
-# TODO: Stop hard-coding candidate params -> make cand config file?
-candidate_params = {
-    "in_size": len(constants.CAO_MAPPING["context"]),
-    "hidden_size": 16,
-    "out_size": len(constants.RECO_COLS)
-}
-prescriptor = TorchPrescriptor(None, encoder, None, 1, candidate_params)
+# Load prescriptors
+prescriptor_manager = utils.load_prescriptors()
 
 # Load predictors
 predictors = utils.load_predictors()
@@ -478,9 +470,7 @@ def select_prescriptor(_, presc_idx, year, lat, lon):
     presc_id = prescriptor_list[presc_idx]
     context = df.loc[year, lat, lon][constants.CAO_MAPPING["context"]]
     context_df = pd.DataFrame([context])
-    prescribed = prescriptor.prescribe_land_use(context_df,
-                                                cand_id=presc_id,
-                                                results_dir=app_constants.PRESCRIPTOR_PATH)
+    prescribed = prescriptor_manager.prescribe(presc_id, context_df)
     # Prescribed gives it to us in diff format, we need to recompute recommendations
     for col in constants.RECO_COLS:
         prescribed[col] = context[col] + prescribed[f"{col}_diff"]
@@ -544,7 +534,7 @@ def compute_land_change(sliders, year, lat, lon, locked):
         warnings.append(html.P("WARNING: Negative values detected. Please lower the value of a locked slider."))
 
     # Compute total change
-    change = prescriptor.compute_percent_changed(context_actions_df)
+    change = prescriptor_manager.compute_percent_changed(context_actions_df)
 
     return warnings, f"{change['change'].iloc[0] * 100:.2f}"
 
diff --git a/use_cases/eluc/app/constants.py b/use_cases/eluc/app/constants.py
index 6bcbc82..61116ce 100644
--- a/use_cases/eluc/app/constants.py
+++ b/use_cases/eluc/app/constants.py
@@ -5,7 +5,7 @@
 
 from data.constants import LAND_USE_COLS
 
-DATA_FILE_PATH = Path("data/processed/app_data.csv")
+DATA_FILE_PATH = Path("app/data/app_data.csv")
 
 APP_START_YEAR = 2012
 
@@ -31,12 +31,9 @@
 CHART_TYPES = ["Treemap", "Pie Chart"]
 
 PREDICTOR_PATH = Path("predictors/trained_models")
-PRESCRIPTOR_PATH = Path("prescriptors/nsga2/trained_prescriptors/demo")
+PRESCRIPTOR_PATH = Path("prescriptors/trained_models")
 
 # Pareto front
-PARETO_CSV_PATH = PRESCRIPTOR_PATH / "pareto.csv"
-PARETO_FRONT_PATH = PRESCRIPTOR_PATH / "pareto_front.png"
-
-FIELDS_PATH = PRESCRIPTOR_PATH / "fields.json"
+PARETO_CSV_PATH = Path("app/data/pareto.csv")
 
 DEFAULT_PRESCRIPTOR_IDX = 1  # By default we select the second prescriptor that minimizes change
diff --git a/use_cases/eluc/app/data/pareto.csv b/use_cases/eluc/app/data/pareto.csv
new file mode 100644
index 0000000..d5e4fd5
--- /dev/null
+++ b/use_cases/eluc/app/data/pareto.csv
@@ -0,0 +1,11 @@
+id,parents,NSGA-II_rank,distance,ELUC,change
+1_1,"(None, None)",1,inf,-0.011886149,0.0040596884414631
+49_0,"('45_27', '21_80')",1,0.20109607207578,-2.1743317,0.0533331221986483
+61_92,"('26_38', '60_66')",1,0.0427627827542644,-4.3928847,0.0690307965236667
+85_51,"('82_16', '53_65')",1,0.0506403998177242,-8.327706,0.1045782392704721
+82_16,"('51_17', '76_44')",1,0.0606549652913774,-11.905426,0.1340041432727491
+70_30,"('59_5', '51_15')",1,0.0230698188448444,-13.6480255,0.1685300249153988
+67_70,"('39_79', '59_5')",1,0.032665984351135,-14.625315,0.1968721749125319
+36_3,"('30_85', '34_74')",1,0.0577219544984151,-15.683007,0.2284119445886663
+62_84,"('58_38', '56_3')",1,0.0310138542659899,-16.641254,0.2609490730066026
+54_67,"('43_94', '43_94')",1,inf,-17.59739,0.2924915519940842
diff --git a/use_cases/eluc/app/process_data.py b/use_cases/eluc/app/process_data.py
index 191957a..8a952ea 100644
--- a/use_cases/eluc/app/process_data.py
+++ b/use_cases/eluc/app/process_data.py
@@ -13,7 +13,7 @@ def main():
     """
     dataset = ELUCData(APP_START_YEAR-1, APP_START_YEAR, 2022)
     test_df = dataset.test_df
-    save_dir = Path("data/processed")
+    save_dir = Path("app/data")
     save_dir.mkdir(exist_ok=True)
     test_df.to_csv(save_dir / "app_data.csv")
 
diff --git a/use_cases/eluc/app/utils.py b/use_cases/eluc/app/utils.py
index 09f0a09..d5887b1 100644
--- a/use_cases/eluc/app/utils.py
+++ b/use_cases/eluc/app/utils.py
@@ -8,6 +8,11 @@
 
 import app.constants as app_constants
 from data import constants
+
+from prescriptors.prescriptor_manager import PrescriptorManager
+from prescriptors.nsga2.land_use_prescriptor import LandUsePrescriptor
+
+from predictors.predictor import Predictor
 from predictors.neural_network.neural_net_predictor import NeuralNetPredictor
 from predictors.sklearn.sklearn_predictor import LinearRegressionPredictor, RandomForestPredictor
 
@@ -258,9 +263,27 @@ def create_pareto(pareto_df: pd.DataFrame, presc_id: int) -> go.Figure:
                                     " Average ELUC: %{y} tC/ha<extra></extra>")
     return fig
 
-def load_predictors() -> dict:
+def load_prescriptors() -> tuple[list[str], PrescriptorManager]:
+    """
+    Loads in prescriptors from disk, downloads from HuggingFace first if needed.
+    TODO: Currently hard-coded to load specific prescriptors from pareto path.
+    :return: dict of prescriptor name -> prescriptor object.
+    """
+    prescriptors = {}
+    pareto_df = pd.read_csv(app_constants.PARETO_CSV_PATH)
+    pareto_df = pareto_df.sort_values(by="change")
+    for cand_id in pareto_df["id"]:
+        cand_path = f"danyoung/eluc-{cand_id}"
+        cand_local_dir = app_constants.PRESCRIPTOR_PATH / cand_path.replace("/", "--")
+        prescriptors[cand_id] = LandUsePrescriptor.from_pretrained(cand_path, local_dir=cand_local_dir)
+
+    prescriptor_manager = PrescriptorManager(prescriptors, None)
+
+    return prescriptor_manager
+
+def load_predictors() -> dict[str, Predictor]:
     """
-    Loads in predictors from disk.
+    Loads in predictors from disk, downloads from HuggingFace first if needed.
     TODO: Currently hard-coded to load specific predictors. We need to make this able to handle any amount!
     :return: dict of predictor name -> predictor object.
     """
diff --git a/use_cases/eluc/experiments/prescriptor_experiments.ipynb b/use_cases/eluc/experiments/prescriptor_experiments.ipynb
index dbe2beb..5c2290e 100644
--- a/use_cases/eluc/experiments/prescriptor_experiments.ipynb
+++ b/use_cases/eluc/experiments/prescriptor_experiments.ipynb
@@ -28,7 +28,7 @@
     "from data.eluc_data import ELUCData\n",
     "from prescriptors.nsga2.candidate import Candidate\n",
     "from prescriptors.nsga2.land_use_prescriptor import LandUsePrescriptor\n",
-    "from prescriptors.nsga2.prescriptor_manager import PrescriptorManager\n",
+    "from prescriptors.prescriptor_manager import PrescriptorManager\n",
     "from prescriptors.heuristics.heuristics import EvenHeuristic, PerfectHeuristic\n",
     "from predictors.neural_network.neural_net_predictor import NeuralNetPredictor"
    ]
@@ -57,7 +57,7 @@
    "source": [
     "TOTAL_GENS = 100\n",
     "\n",
-    "results_dir = Path(\"prescriptors/nsga2/trained_prescriptors/fixed-distance\")"
+    "results_dir = Path(\"prescriptors/nsga2/training_runs/fixed-distance\")"
    ]
   },
   {
diff --git a/use_cases/eluc/predictors/upload_model.py b/use_cases/eluc/predictors/upload_model.py
index 6d6dd13..9fa7c0b 100644
--- a/use_cases/eluc/predictors/upload_model.py
+++ b/use_cases/eluc/predictors/upload_model.py
@@ -35,7 +35,10 @@ def upload_to_repo(model_path: str, repo_id: str, token: str=None):
         token=token
     )
 
-if __name__ == "__main__":
+def main():
+    """
+    Main logic for uploading a model.
+    """
     parser = ArgumentParser()
     parser.add_argument("--model_path", type=str, required=True)
     parser.add_argument("--repo_id", type=str, required=True)
@@ -47,3 +50,6 @@ def upload_to_repo(model_path: str, repo_id: str, token: str=None):
     if args.token:
         upload_args["token"] = args.token
     upload_to_repo(**upload_args)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/use_cases/eluc/prescriptors/nsga2/configs/fixed-distance.json b/use_cases/eluc/prescriptors/nsga2/configs/fixed-distance.json
index 94425f6..d1db5e9 100644
--- a/use_cases/eluc/prescriptors/nsga2/configs/fixed-distance.json
+++ b/use_cases/eluc/prescriptors/nsga2/configs/fixed-distance.json
@@ -11,5 +11,5 @@
         },
         "seed_dir": "prescriptors/nsga2/seeds/small_sample"
     },
-    "save_path": "prescriptors/nsga2/trained_prescriptors/no-overlap"
+    "save_path": "prescriptors/nsga2/training_runs/no-overlap"
 }
\ No newline at end of file
diff --git a/use_cases/eluc/prescriptors/nsga2/configs/no-overlap.json b/use_cases/eluc/prescriptors/nsga2/configs/no-overlap.json
index 454e89b..8214d16 100644
--- a/use_cases/eluc/prescriptors/nsga2/configs/no-overlap.json
+++ b/use_cases/eluc/prescriptors/nsga2/configs/no-overlap.json
@@ -11,5 +11,5 @@
         },
         "seed_dir": "prescriptors/nsga2/seeds/small_sample"
     },
-    "save_path": "prescriptors/nsga2/trained_prescriptors/test"
+    "save_path": "prescriptors/nsga2/training_runs/test"
 }
\ No newline at end of file
diff --git a/use_cases/eluc/prescriptors/nsga2/trainer.py b/use_cases/eluc/prescriptors/nsga2/trainer.py
index c4cc63e..a7af8b7 100644
--- a/use_cases/eluc/prescriptors/nsga2/trainer.py
+++ b/use_cases/eluc/prescriptors/nsga2/trainer.py
@@ -2,7 +2,6 @@
 PyTorch implementation of NSGA-II.
 """
 import random
-import shutil
 from pathlib import Path
 
 from tqdm import tqdm
@@ -18,7 +17,7 @@
 from prescriptors.nsga2 import nsga2_utils
 from prescriptors.nsga2.candidate import Candidate
 from prescriptors.nsga2.land_use_prescriptor import LandUsePrescriptor
-from prescriptors.nsga2.prescriptor_manager import PrescriptorManager
+from prescriptors.prescriptor_manager import PrescriptorManager
 
 class TorchTrainer():
     """
diff --git a/use_cases/eluc/prescriptors/nsga2/prescriptor_manager.py b/use_cases/eluc/prescriptors/prescriptor_manager.py
similarity index 100%
rename from use_cases/eluc/prescriptors/nsga2/prescriptor_manager.py
rename to use_cases/eluc/prescriptors/prescriptor_manager.py

From f5ae44869a2c919e1c91530f362825c5c1297569 Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Mon, 3 Jun 2024 17:01:43 -0700
Subject: [PATCH 10/17] renamed indices so that we don't have duplicate columns

---
 use_cases/eluc/app/app.py        | 13 ++++++-------
 use_cases/eluc/app/constants.py  |  2 +-
 use_cases/eluc/data/eluc_data.py |  6 ++++--
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/use_cases/eluc/app/app.py b/use_cases/eluc/app/app.py
index 4858ff3..694f978 100644
--- a/use_cases/eluc/app/app.py
+++ b/use_cases/eluc/app/app.py
@@ -27,7 +27,6 @@
 server = app.server
 
 df = pd.read_csv(app_constants.DATA_FILE_PATH, index_col=app_constants.INDEX_COLS)
-df.rename(columns={col + ".1": col for col in app_constants.INDEX_COLS}, inplace=True)
 COUNTRIES_DF = regionmask.defined_regions.natural_earth_v5_0_0.countries_110.to_dataframe()
 
 # Load pareto df
@@ -42,12 +41,12 @@
 predictors = utils.load_predictors()
 
 # Cells
-min_lat = df.index.get_level_values("lat").min()
-max_lat = df.index.get_level_values("lat").max()
-min_lon = df.index.get_level_values("lon").min()
-max_lon = df.index.get_level_values("lon").max()
-min_time = df.index.get_level_values("time").min()
-max_time = df.index.get_level_values("time").max()
+min_lat = df["lat"].min()
+max_lat = df["lat"].max()
+min_lon = df["lon"].min()
+max_lon = df["lon"].max()
+min_time = df["time"].min()
+max_time = df["time"].max()
 
 lat_list = list(np.arange(min_lat, max_lat + app_constants.GRID_STEP, app_constants.GRID_STEP))
 lon_list = list(np.arange(min_lon, max_lon + app_constants.GRID_STEP, app_constants.GRID_STEP))
diff --git a/use_cases/eluc/app/constants.py b/use_cases/eluc/app/constants.py
index 61116ce..449a78b 100644
--- a/use_cases/eluc/app/constants.py
+++ b/use_cases/eluc/app/constants.py
@@ -11,7 +11,7 @@
 
 GRID_STEP = 0.25
 
-INDEX_COLS = ["time", "lat", "lon"]
+INDEX_COLS = ["time_idx", "lat_idx", "lon_idx"]
 
 NO_CHANGE_COLS = ["primf", "primn", "urban"]
 CHART_COLS = LAND_USE_COLS + ["nonland"]
diff --git a/use_cases/eluc/data/eluc_data.py b/use_cases/eluc/data/eluc_data.py
index cf8596e..68f50e0 100644
--- a/use_cases/eluc/data/eluc_data.py
+++ b/use_cases/eluc/data/eluc_data.py
@@ -172,7 +172,6 @@ class ELUCData(AbstractData):
     """
     Loads ELUC data from HuggingFace repo and processes it.
     """
-
     def __init__(self, start_year=1851, test_year=2012, end_year=2022, countries=None):
         """
         If update_path is given, load raw data the old way using 2 files that are merged.
@@ -200,7 +199,10 @@ def hf_to_df(self, hf_repo):
         """
         ds = load_dataset(hf_repo)["train"]
         df = ds.to_pandas()
-        df = df.set_index(["time", "lat", "lon"], drop=False)
+        df["time_idx"] = df["time"]
+        df["lat_idx"] = df["lat"]
+        df["lon_idx"] = df["lon"]
+        df = df.set_index(["time_idx", "lat_idx", "lon_idx"], drop=True)
         return df
 
 

From babf912592a163a171dfdc0585bc4648b84d2d3c Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Tue, 4 Jun 2024 10:04:38 -0700
Subject: [PATCH 11/17] Fixed test to download data and use it

---
 use_cases/eluc/tests/test_nsga2.py       | 128 +++++------------------
 use_cases/eluc/tests/test_prescriptor.py |  31 +++---
 2 files changed, 43 insertions(+), 116 deletions(-)

diff --git a/use_cases/eluc/tests/test_nsga2.py b/use_cases/eluc/tests/test_nsga2.py
index c48e3f9..09675cf 100644
--- a/use_cases/eluc/tests/test_nsga2.py
+++ b/use_cases/eluc/tests/test_nsga2.py
@@ -8,52 +8,12 @@
 import torch
 
 from data import constants
+from data.eluc_data import ELUCData
 from data.eluc_data import ELUCEncoder
-from predictors.sklearn.sklearn_predictor import LinearRegressionPredictor
 from prescriptors.nsga2.candidate import Candidate
-from prescriptors.nsga2.torch_prescriptor import TorchPrescriptor
+from prescriptors.nsga2.land_use_prescriptor import LandUsePrescriptor
 from prescriptors.nsga2 import nsga2_utils
 
-def get_fields(df):
-    """
-    TODO: This is temporary before the dataset becomes public, enabling us to test without
-    having to download the dataset from HuggingFace.
-    Dummy fields method to create the encoder for dummy data.
-    """
-    fields_df = df[constants.CAO_MAPPING["context"] + constants.CAO_MAPPING["actions"] + ["ELUC"]].astype("float64")
-    fields = {}
-    for col in constants.CAO_MAPPING["context"] + constants.CAO_MAPPING["actions"] + ["ELUC"]:
-        # Set range of land and diff land uses manually to their true ranges because they
-        # do not need to be scaled
-        if col in constants.LAND_USE_COLS:
-            ran = [0, 1]
-        elif col in constants.DIFF_LAND_USE_COLS:
-            ran = [-1, 1]
-        else:
-            ran = [fields_df[col].min(), fields_df[col].max()]
-        fields[col] = {
-            "data_type": "FLOAT",
-            "has_nan": False,
-            "mean": fields_df[col].mean(),
-            "range": ran,
-            "std_dev": fields_df[col].std(),
-            "sum": fields_df[col].sum(),
-            "valued": "CONTINUOUS"
-        }
-
-    # These are just dummy values so that the prescriptor knows we have a change outcome
-    fields["change"] = {
-        "data_type": "FLOAT",
-        "has_nan": False,
-        "mean": 0.5,
-        "range": [0, 1],
-        "std_dev": 0.1,
-        "sum": len(fields_df) // 2,
-        "valued": "CONTINUOUS"
-    }
-
-    return fields
-
 class TestNSGA2Utils(unittest.TestCase):
     """
     Tests the NGSA-II utility functions.
@@ -88,55 +48,29 @@ def test_distance_calculation(self):
         for candidate, tgt in zip(shuffled_front, shuffled_tgts):
             self.assertAlmostEqual(candidate.distance, tgt)
 
-class TestTorchPrescriptor(unittest.TestCase):
+class TestLandUsePrescriptor(unittest.TestCase):
     """
     Tests PyTorch prescriptor class
     """
     @classmethod
     def setUpClass(cls):
-        cls.dummy_data = pd.DataFrame()
-        np.random.seed(42)
-        for col in constants.CAO_MAPPING["context"] + constants.CAO_MAPPING["actions"] + ["ELUC"]:
-            cls.dummy_data[col] = np.random.random(size=(1000,))
-
-        fields = get_fields(cls.dummy_data)
-        encoder = ELUCEncoder(fields)
-
-        predictor = LinearRegressionPredictor({"features": constants.DIFF_LAND_USE_COLS, "n_jobs": -1})
-        predictor.fit(cls.dummy_data[constants.DIFF_LAND_USE_COLS], cls.dummy_data["ELUC"])
-        cls.prescriptor = TorchPrescriptor(
-            eval_df=cls.dummy_data,
-            encoder=encoder,
-            predictor=predictor,
-            batch_size=1,
-            candidate_params={"in_size": len(constants.CAO_MAPPING["context"]), 
-                              "hidden_size": 16, 
-                              "out_size": len(constants.RECO_COLS)}
-        )
-
-    def test_reco_tensor_to_df(self):
-        """
-        Takes a tensor of recommendations and converts it to a scaled DataFrame.
-        Makes sure the scaled dataframe's rows sum to the original sum of land use and
-        that the index is the same.
-        """
-        reco_tensor = torch.rand(100, len(constants.RECO_COLS))
-        context_df = self.prescriptor.eval_df.iloc[:100]
-        reco_df = self.prescriptor._reco_tensor_to_df(reco_tensor, context_df)
-        self.assertIsInstance(reco_df, pd.DataFrame)
-        self.assertEqual(reco_df.shape, (100, len(constants.RECO_COLS)))
-        self.assertEqual(reco_df.sum(axis=1).all(), context_df[constants.RECO_COLS].sum(axis=1).all())
-        self.assertTrue(reco_df.index.equals(context_df.index))
+        data = ELUCData()
+        cls.df = data.train_df
+
+        candidate = Candidate(len(constants.CAO_MAPPING["context"]), 16, len(constants.RECO_COLS))
+        cls.prescriptor = LandUsePrescriptor(candidate, data.encoder)
+
+        cls.n = 10
 
     def test_reco_tensor_to_df_all_zero_tensor(self):
         """
         Tests the case where the tensor is all zeros.
         """
-        reco_tensor = torch.zeros(100, len(constants.RECO_COLS))
-        context_df = self.prescriptor.eval_df.iloc[:100]
+        reco_tensor = torch.zeros(self.n, len(constants.RECO_COLS))
+        context_df = self.df[constants.CAO_MAPPING["context"]].iloc[:self.n]
         reco_df = self.prescriptor._reco_tensor_to_df(reco_tensor, context_df)
         self.assertIsInstance(reco_df, pd.DataFrame)
-        self.assertEqual(reco_df.shape, (100, len(constants.RECO_COLS)))
+        self.assertEqual(reco_df.shape, (self.n, len(constants.RECO_COLS)))
         self.assertEqual(reco_df.sum(axis=1).all(), context_df[constants.RECO_COLS].sum(axis=1).all())
         self.assertTrue(reco_df.index.equals(context_df.index))
 
@@ -144,13 +78,14 @@ def test_reco_tensor_to_df_all_zero_context(self):
         """
         Tests the case where the context dataframe is all zeros.
         """
-        reco_tensor = torch.rand(100, len(constants.RECO_COLS))
-        context_df = pd.DataFrame(0, index=range(0, 200, 2), columns=constants.RECO_COLS)
-        reco_df = self.prescriptor._reco_tensor_to_df(reco_tensor, context_df)
+        reco_tensor = torch.rand(10, len(constants.RECO_COLS))
+        zero_df = self.df.iloc[:self.n].copy()
+        zero_df[constants.LAND_USE_COLS] = 0
+        reco_df = self.prescriptor._reco_tensor_to_df(reco_tensor, zero_df)
         self.assertIsInstance(reco_df, pd.DataFrame)
-        self.assertEqual(reco_df.shape, (100, len(constants.RECO_COLS)))
-        self.assertEqual(reco_df.sum(axis=1).all(), context_df[constants.RECO_COLS].sum(axis=1).all())
-        self.assertTrue(reco_df.index.equals(context_df.index))
+        self.assertEqual(reco_df.shape, (10, len(constants.RECO_COLS)))
+        self.assertEqual(reco_df.sum(axis=1).all(), zero_df[constants.RECO_COLS].sum(axis=1).all())
+        self.assertTrue(reco_df.index.equals(zero_df.index))
 
     def test_reco_to_context_actions(self):
         """
@@ -159,15 +94,13 @@ def test_reco_to_context_actions(self):
         Also makes sure diff for all the NO_CHANGE_COLS is 0.
         TODO: This isn't a great test - should I redo it with synthetic data?
         """
-        reco_df = self.prescriptor.eval_df.iloc[:100][constants.RECO_COLS]
+        reco_df = self.df.iloc[:self.n][constants.RECO_COLS]
         self.assertTrue(reco_df.sum(axis=1).all() > 0)
         self.assertTrue(reco_df.sum(axis=1).all() <= 1)
 
-        context_df = self.prescriptor.eval_df.iloc[100:200][constants.CAO_MAPPING["context"]].copy()
+        context_df = self.df.iloc[:self.n][constants.CAO_MAPPING["context"]].copy()
         self.assertTrue(context_df.sum(axis=1).all() > 0)
         self.assertTrue(context_df.sum(axis=1).all() <= 1)
-        # This has to be true - fudge it
-        context_df = context_df.set_index(reco_df.index)
 
         context_actions_df = self.prescriptor._reco_to_context_actions(reco_df, context_df)
 
@@ -178,25 +111,12 @@ def test_reco_to_context_actions(self):
 
         self.assertTrue((diff_df == context_actions_df[constants.DIFF_LAND_USE_COLS]).all().all())
 
-    def test_compute_percent_changed_indices_same(self):
-        """
-        Makes sure the indices in change_df are the same as in the context_actions_df.
-        """
-        context_actions_df = self.prescriptor.eval_df.iloc[:100]
-        context_actions_df = context_actions_df[constants.CAO_MAPPING["context"] + constants.CAO_MAPPING["actions"]]
-        change_df = self.prescriptor.compute_percent_changed(context_actions_df)
-
-        self.assertTrue(change_df.index.equals(context_actions_df.index))
-
     def test_prescribe_indices_same(self):
         """
         Tests prescribe method to see if context_actions_df has the same indices as the input context_df.
         """
-        candidate = Candidate(in_size=len(constants.CAO_MAPPING["context"]),
-                              hidden_size=16,
-                              out_size=len(constants.RECO_COLS))
-        context_df = self.dummy_data.iloc[:100][constants.CAO_MAPPING["context"]]
-        context_actions_df = self.prescriptor.prescribe(candidate, context_df)
+        context_df = self.df.iloc[:self.n][constants.CAO_MAPPING["context"]]
+        context_actions_df = self.prescriptor.prescribe(context_df)
 
         self.assertTrue(context_actions_df.index.equals(context_df.index))
         self.assertTrue(context_df.equals(context_actions_df[constants.CAO_MAPPING["context"]]))
diff --git a/use_cases/eluc/tests/test_prescriptor.py b/use_cases/eluc/tests/test_prescriptor.py
index d703d83..e878b33 100644
--- a/use_cases/eluc/tests/test_prescriptor.py
+++ b/use_cases/eluc/tests/test_prescriptor.py
@@ -7,7 +7,7 @@
 import pandas as pd
 
 from data import constants
-from prescriptors.nsga2.torch_prescriptor import TorchPrescriptor
+from prescriptors.prescriptor_manager import PrescriptorManager
 
 class TestComputeChange(unittest.TestCase):
     """
@@ -18,13 +18,7 @@ def setUp(self):
         Sets up a dummy prescriptor. This doesn't even really have to be instantiated properly it just needs to
         be able to call compute_percent_changed.
         """
-        self.prescriptor = TorchPrescriptor(
-            eval_df=None,
-            encoder=None,
-            predictor=None,
-            batch_size=1,
-            candidate_params=None
-        )
+        self.prescriptor_manager = PrescriptorManager(None, None)
 
     def _list_data_to_df(self, context_data: list, presc_data: list) -> pd.DataFrame:
         """
@@ -55,7 +49,7 @@ def test_compute_percent_change(self):
 
         context_actions_df = self._list_data_to_df(context_data, presc_data)
 
-        percent_change = self.prescriptor.compute_percent_changed(context_actions_df)["change"].iloc[0]
+        percent_change = self.prescriptor_manager.compute_percent_changed(context_actions_df)["change"].iloc[0]
         self.assertAlmostEqual(percent_change, even_amt * 2)
 
     def test_compute_percent_change_no_change(self):
@@ -67,7 +61,7 @@ def test_compute_percent_change_no_change(self):
 
         context_actions_df = self._list_data_to_df(context_data, presc_data)
 
-        percent_change = self.prescriptor.compute_percent_changed(context_actions_df)["change"].iloc[0]
+        percent_change = self.prescriptor_manager.compute_percent_changed(context_actions_df)["change"].iloc[0]
         self.assertAlmostEqual(percent_change, 0)
 
     def test_compute_percent_change_all_nonreco(self):
@@ -79,7 +73,7 @@ def test_compute_percent_change_all_nonreco(self):
 
         context_actions_df = self._list_data_to_df(context_data, presc_data)
 
-        percent_change = self.prescriptor.compute_percent_changed(context_actions_df)["change"].iloc[0]
+        percent_change = self.prescriptor_manager.compute_percent_changed(context_actions_df)["change"].iloc[0]
         self.assertEqual(percent_change, 0)
 
     def test_compute_percent_change_not_sum_to_one(self):
@@ -91,6 +85,19 @@ def test_compute_percent_change_not_sum_to_one(self):
 
         context_actions_df = self._list_data_to_df(context_data, presc_data)
 
-        percent_change = self.prescriptor.compute_percent_changed(context_actions_df)["change"].iloc[0]
+        percent_change = self.prescriptor_manager.compute_percent_changed(context_actions_df)["change"].iloc[0]
 
         self.assertAlmostEqual(percent_change, 0.02 / (0.01 * len(constants.LAND_USE_COLS)))
+
+    def test_compute_percent_changed_indices_same(self):
+        """
+        Makes sure the indices in change_df are the same as in the context_actions_df.
+        """
+        # TODO: Fix this test it's a good one
+        context_data = [0.01 for _ in range(len(constants.LAND_USE_COLS))]
+        presc_data = [0.02, 0.00, 0.02, 0.00, 0.01]
+    
+        context_actions_df = self._list_data_to_df(context_data, presc_data)
+        change_df = self.prescriptor_manager.compute_percent_changed(context_actions_df)
+
+        self.assertTrue(change_df.index.equals(context_actions_df.index))
\ No newline at end of file

From 926ffe00da5f83526782d6e3941e94dbc0442555 Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Tue, 4 Jun 2024 10:19:09 -0700
Subject: [PATCH 12/17] Linted to reach threshold

---
 use_cases/eluc/predictors/predictor.py          | 17 ++++++++---------
 use_cases/eluc/predictors/upload_model.py       |  2 +-
 .../eluc/prescriptors/heuristics/heuristics.py  |  4 ++--
 .../eluc/prescriptors/nsga2/create_seeds.py     |  2 +-
 .../prescriptors/nsga2/land_use_prescriptor.py  |  9 +++++----
 .../eluc/prescriptors/prescriptor_manager.py    |  9 +++++++--
 use_cases/eluc/tests/test_nsga2.py              |  4 +++-
 use_cases/eluc/tests/test_prescriptor.py        |  5 ++---
 8 files changed, 29 insertions(+), 23 deletions(-)

diff --git a/use_cases/eluc/predictors/predictor.py b/use_cases/eluc/predictors/predictor.py
index eaef851..f8c19bd 100644
--- a/use_cases/eluc/predictors/predictor.py
+++ b/use_cases/eluc/predictors/predictor.py
@@ -58,16 +58,15 @@ def from_pretrained(cls, path_or_url: str, **hf_args) -> "Predictor":
         path = Path(path_or_url)
         if path.exists() and path.is_dir():
             return cls.load(path)
-        else:
-            # TODO: Need a try except block to catch download errors
-            url_path = path_or_url.replace("/", "--")
-            local_dir = hf_args.get("local_dir", f"predictors/trained_models/{url_path}")
+        # TODO: Need a try except block to catch download errors
+        url_path = path_or_url.replace("/", "--")
+        local_dir = hf_args.get("local_dir", f"predictors/trained_models/{url_path}")
 
-            if not Path(local_dir).exists() or not Path(local_dir).is_dir():
-                hf_args["local_dir"] = local_dir
-                snapshot_download(repo_id=path_or_url, **hf_args)
+        if not Path(local_dir).exists() or not Path(local_dir).is_dir():
+            hf_args["local_dir"] = local_dir
+            snapshot_download(repo_id=path_or_url, **hf_args)
 
-            return cls.load(Path(local_dir))
+        return cls.load(Path(local_dir))
 
     @classmethod
     def load(cls, path: Path) -> "Predictor":
@@ -75,4 +74,4 @@ def load(cls, path: Path) -> "Predictor":
         Loads a model from the path on disk.
         :param path: path to the model
         """
-        raise NotImplementedError
\ No newline at end of file
+        raise NotImplementedError
diff --git a/use_cases/eluc/predictors/upload_model.py b/use_cases/eluc/predictors/upload_model.py
index 9fa7c0b..a666929 100644
--- a/use_cases/eluc/predictors/upload_model.py
+++ b/use_cases/eluc/predictors/upload_model.py
@@ -52,4 +52,4 @@ def main():
     upload_to_repo(**upload_args)
 
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    main()
diff --git a/use_cases/eluc/prescriptors/heuristics/heuristics.py b/use_cases/eluc/prescriptors/heuristics/heuristics.py
index 3f8414e..d8eb05b 100644
--- a/use_cases/eluc/prescriptors/heuristics/heuristics.py
+++ b/use_cases/eluc/prescriptors/heuristics/heuristics.py
@@ -73,7 +73,7 @@ def _reco_heuristic(self, pct: float, context_df: pd.DataFrame):
         adjusted.loc[to_change, self.best_col] = adjusted.loc[to_change, self.best_col] + max_change
         adjusted = adjusted.drop(["scaled_change", "row_sum", "max_change"], axis=1)
         return adjusted
-    
+
     def save(self, path: Path):
         """
         Saves best column and percentage.
@@ -136,7 +136,7 @@ def _reco_heuristic(self, pct: float, context_df: pd.DataFrame) -> pd.DataFrame:
         adjusted[self.best_col] += adjusted[["scaled_change", "presc_sum"]].min(axis=1)
         adjusted = adjusted.drop(["scaled_change", "presc_sum", "amt_change"], axis=1)
         return adjusted
-    
+
     def save(self, path: Path):
         """
         Saves coefficients and percentage.
diff --git a/use_cases/eluc/prescriptors/nsga2/create_seeds.py b/use_cases/eluc/prescriptors/nsga2/create_seeds.py
index 9b064f1..027570a 100644
--- a/use_cases/eluc/prescriptors/nsga2/create_seeds.py
+++ b/use_cases/eluc/prescriptors/nsga2/create_seeds.py
@@ -11,7 +11,7 @@
 from data import constants
 from data.eluc_data import ELUCData
 from data.torch_data import TorchDataset
-from prescriptors.nsga2.torch_prescriptor import Candidate
+from prescriptors.nsga2.candidate import Candidate
 
 def supervised_backprop(save_path: Path, ds: TorchDataset):
     """
diff --git a/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py b/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
index 0d67880..40a1674 100644
--- a/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
+++ b/use_cases/eluc/prescriptors/nsga2/land_use_prescriptor.py
@@ -51,7 +51,7 @@ def _reco_to_context_actions(self, reco_df: pd.DataFrame, context_df: pd.DataFra
                                             presc_actions_df[constants.CAO_MAPPING["actions"]]],
                                             axis=1)
         return context_actions_df
-    
+
     def prescribe(self, context_df) -> pd.DataFrame:
         """
         Prescribes actions from a context.
@@ -67,10 +67,11 @@ def prescribe(self, context_df) -> pd.DataFrame:
                                           np.zeros((len(encoded_context_df), len(constants.RECO_COLS))))
         encoded_context_dl = DataLoader(encoded_context_ds, batch_size=self.batch_size, shuffle=False)
         return self.torch_prescribe(context_df, encoded_context_dl)
-    
+
     def torch_prescribe(self, context_df: pd.DataFrame, encoded_context_dl: DataLoader):
         """
-        Prescribes straight from a torch DataLoader so that we can avoid the overhead of converting from pandas.
+        Prescribes straight from a torch DataLoader so that we can avoid the overhead of converting from pandas
+        during evolution.
         """
         # Aggregate recommendations
         reco_list = []
@@ -86,7 +87,7 @@ def torch_prescribe(self, context_df: pd.DataFrame, encoded_context_dl: DataLoad
 
         context_actions_df = self._reco_to_context_actions(reco_df, context_df)
         return context_actions_df
-    
+
     def save(self, path: Path):
         """
         Saves the prescriptor to disk.
diff --git a/use_cases/eluc/prescriptors/prescriptor_manager.py b/use_cases/eluc/prescriptors/prescriptor_manager.py
index ab9355a..96f71a5 100644
--- a/use_cases/eluc/prescriptors/prescriptor_manager.py
+++ b/use_cases/eluc/prescriptors/prescriptor_manager.py
@@ -1,4 +1,8 @@
-
+"""
+Manages multiple Prescriptors and a Predictor. Allows the user to easily prescribe based on different Prescriptors and
+then predict on a uniform Predictor in order to compare them.
+Additionally handles the percent changed computation.
+"""
 import pandas as pd
 
 from data import constants
@@ -29,6 +33,7 @@ def predict_metrics(self, context_actions_df: pd.DataFrame) -> pd.DataFrame:
 
         return eluc_df, change_df
 
+    # TODO: Move this to its own predictor
     def compute_percent_changed(self, context_actions_df: pd.DataFrame) -> pd.DataFrame:
         """
         Calculates percent of land changed by prescriptor.
@@ -41,4 +46,4 @@ def compute_percent_changed(self, context_actions_df: pd.DataFrame) -> pd.DataFr
         total_land = total_land.replace(0, 1) # Avoid division by 0
         percent_changed = percent_changed / total_land
         change_df = pd.DataFrame(percent_changed, columns=["change"])
-        return change_df
\ No newline at end of file
+        return change_df
diff --git a/use_cases/eluc/tests/test_nsga2.py b/use_cases/eluc/tests/test_nsga2.py
index 09675cf..7e87efc 100644
--- a/use_cases/eluc/tests/test_nsga2.py
+++ b/use_cases/eluc/tests/test_nsga2.py
@@ -9,7 +9,6 @@
 
 from data import constants
 from data.eluc_data import ELUCData
-from data.eluc_data import ELUCEncoder
 from prescriptors.nsga2.candidate import Candidate
 from prescriptors.nsga2.land_use_prescriptor import LandUsePrescriptor
 from prescriptors.nsga2 import nsga2_utils
@@ -62,6 +61,8 @@ def setUpClass(cls):
 
         cls.n = 10
 
+    # Disable protected access warning so we can test the private methods
+    # pylint: disable=protected-access
     def test_reco_tensor_to_df_all_zero_tensor(self):
         """
         Tests the case where the tensor is all zeros.
@@ -110,6 +111,7 @@ def test_reco_to_context_actions(self):
         diff_df = diff_df[constants.DIFF_LAND_USE_COLS]
 
         self.assertTrue((diff_df == context_actions_df[constants.DIFF_LAND_USE_COLS]).all().all())
+    # pylint: enable=protected-access
 
     def test_prescribe_indices_same(self):
         """
diff --git a/use_cases/eluc/tests/test_prescriptor.py b/use_cases/eluc/tests/test_prescriptor.py
index e878b33..f65c9c2 100644
--- a/use_cases/eluc/tests/test_prescriptor.py
+++ b/use_cases/eluc/tests/test_prescriptor.py
@@ -93,11 +93,10 @@ def test_compute_percent_changed_indices_same(self):
         """
         Makes sure the indices in change_df are the same as in the context_actions_df.
         """
-        # TODO: Fix this test it's a good one
         context_data = [0.01 for _ in range(len(constants.LAND_USE_COLS))]
         presc_data = [0.02, 0.00, 0.02, 0.00, 0.01]
-    
+
         context_actions_df = self._list_data_to_df(context_data, presc_data)
         change_df = self.prescriptor_manager.compute_percent_changed(context_actions_df)
 
-        self.assertTrue(change_df.index.equals(context_actions_df.index))
\ No newline at end of file
+        self.assertTrue(change_df.index.equals(context_actions_df.index))

From 3bdde8c4f91ba36cd868a70410b900a74eb38c63 Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Thu, 6 Jun 2024 15:54:44 -0700
Subject: [PATCH 13/17] Added some documentation to show where prescriptor
 logic is used in training

---
 use_cases/eluc/prescriptors/nsga2/trainer.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/use_cases/eluc/prescriptors/nsga2/trainer.py b/use_cases/eluc/prescriptors/nsga2/trainer.py
index a7af8b7..38c9ad9 100644
--- a/use_cases/eluc/prescriptors/nsga2/trainer.py
+++ b/use_cases/eluc/prescriptors/nsga2/trainer.py
@@ -54,6 +54,10 @@ def __init__(self,
     def _evaluate_candidates(self, candidates: list[Candidate]):
         """
         Calls prescribe and predict on candidates and assigns their metrics to the results.
+        This is where the Project Resilience Prescriptor logic is used in evolution, although it doesn't have to be.
+        We wrap a LandUsePrescriptor around the Candidate we are evaluating and call torch_prescribe which is a
+        special prescription method that goes straight from tensor to tensor instead of converting to DataFrame.
+        We use a dummy PrescriptorManager to compute the metrics using predict_metrics.
         """
         prescriptor_manager = PrescriptorManager(None, self.predictor)
         for candidate in candidates:

From 0f58c24edd78e6f82e51c596dcbd3608f2d1ca3f Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Fri, 7 Jun 2024 14:26:09 -0700
Subject: [PATCH 14/17] Modified ELUCData by consolidating yucky classes into
 single clean class

---
 use_cases/eluc/data/eluc_data.py    | 267 +++++++---------------------
 use_cases/eluc/data/eluc_encoder.py | 102 +++++++++++
 2 files changed, 171 insertions(+), 198 deletions(-)
 create mode 100644 use_cases/eluc/data/eluc_encoder.py

diff --git a/use_cases/eluc/data/eluc_data.py b/use_cases/eluc/data/eluc_data.py
index 68f50e0..6934195 100644
--- a/use_cases/eluc/data/eluc_data.py
+++ b/use_cases/eluc/data/eluc_data.py
@@ -10,9 +10,7 @@
 data from the HuggingFace repo.
 """
 from abc import ABC
-import json
 import os
-from pathlib import Path
 import warnings
 
 from datasets import load_dataset, Dataset
@@ -22,206 +20,60 @@
 
 from data import constants
 from data.conversion import construct_countries_df
+from data.eluc_encoder import ELUCEncoder
 
-class ELUCEncoder():
+class ELUCData():
     """
-    Encodes our ELUC dataset by using minmax scaling.
+    Wrapper for pandas dataframe that separates the data into train and test sets based on the time column.
+    Contains an encoder for prescriptors to use.
+    Can be either loaded from raw files provided by BLUE and LUH or from the processed HuggingFace dataset.
     """
-    def __init__(self, fields):
-        self.fields = fields
-
-    def encode_as_df(self, df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Encodes a dataframe using the fields given in the constructor.
-        Uses minmax scaling.
-        """
-        new_df = df.copy()
-        for col in new_df.columns:
-            if col in self.fields:
-                min_val = self.fields[col]["range"][0]
-                max_val = self.fields[col]["range"][1]
-                # If min and max are the same, just set value to 0
-                if min_val == max_val:
-                    new_df[col] = 0
-                else:
-                    new_df[col] = (new_df[col] - min_val) / (max_val - min_val)
-        return new_df
-
-    def decode_as_df(self, df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Decodes a dataframe using the fields given in the constructor.
-        Uses minmax scaling.
-        """
-        new_df = df.copy()
-        for col in new_df.columns:
-            if col in self.fields:
-                min_val = self.fields[col]["range"][0]
-                max_val = self.fields[col]["range"][1]
-                new_df[col] = new_df[col] * (max_val - min_val) + min_val
-        return new_df
-
-    def save_fields(self, path: Path):
-        """
-        Saves the fields to a JSON file.
-        """
-        with open(path, "w", encoding="utf-8") as file:
-            json.dump(self.fields, file, indent=4)
-
-    @classmethod
-    def from_json(cls, path: Path):
-        """
-        Loads the fields from a JSON file.
-        """
-        with open(path, "r", encoding="utf-8") as file:
-            fields = json.load(file)
-        return cls(fields)
+    def __init__(self, df: pd.DataFrame, start_year=1851, test_year=2012, end_year=2022, countries=None):
+        if countries:
+            df = self.subset_countries(df, countries)
+        self.train_df = df.loc[start_year:test_year-1].copy()
+        self.test_df = df.loc[test_year:end_year-1].copy()
+        assert self.train_df['time'].max() == self.test_df["time"].min() - 1
 
-class AbstractData(ABC):
-    """
-    Abstract class for handling data.
-    ELUCData and RawELUCData instantiate this based on different sources and create dataframes.
-        ELUCData: HuggingFace repo
-        RawELUCData: Raw zarr files
-    Allows user to subset by countries, encode data, and potentially push to HuggingFace.
-    """
-    def __init__(self):
-        self.countries_df = construct_countries_df()
-        self.train_df = None
-        self.test_df = None
+        self.encoder = ELUCEncoder(self.train_df)
+        # Set encoded values to None so that we don't encode them until we need to
         self.encoded_train_df = None
         self.encoded_test_df = None
-        self.encoder = None
 
     def subset_countries(self, df, countries):
         """
-        Subsets dataframe by country list
+        Subsets dataframe by country list.
+        TODO: This currently doesn't work.
         """
-        idx = self.countries_df[self.countries_df["abbrevs"].isin(countries)].index.values
+        countries_df = construct_countries_df()
+        idx = countries_df[countries_df["abbrevs"].isin(countries)].index.values
         return df[df["country"].isin(idx)].copy()
 
-    def get_encoded_train(self):
-        """
-        Reduces cost of encoding data by caching the encoded version.
-        """
-        if self.encoded_train_df is None:
-            self.encoded_train_df = self.encoder.encode_as_df(self.train_df)
-        return self.encoded_train_df
-
-    def get_encoded_test(self):
-        """
-        Same as above but for test data.
-        """
-        if self.encoded_test_df is None:
-            self.encoded_test_df = self.encoder.encode_as_df(self.test_df)
-        return self.encoded_test_df
-
-    def get_fields(self) -> dict:
-        """
-        Creates fields json object for the data encoder/prescriptor.
-        """
-        cao_cols = constants.CAO_MAPPING["context"] + constants.CAO_MAPPING["actions"] + ["ELUC"]
-        fields_df = self.train_df[cao_cols].astype("float64")
-        fields = {}
-        for col in cao_cols:
-            # Set range of land and diff land uses manually to their true ranges because they
-            # do not need to be scaled
-            if col in constants.LAND_USE_COLS:
-                ran = [0, 1]
-            elif col in constants.DIFF_LAND_USE_COLS:
-                ran = [-1, 1]
-            else:
-                ran = [fields_df[col].min(), fields_df[col].max()]
-            fields[col] = {
-                "data_type": "FLOAT",
-                "has_nan": False,
-                "mean": fields_df[col].mean(),
-                "range": ran,
-                "std_dev": fields_df[col].std(),
-                "sum": fields_df[col].sum(),
-                "valued": "CONTINUOUS"
-            }
-
-        # These are just dummy values so that the prescriptor knows we have a change outcome
-        fields["change"] = {
-            "data_type": "FLOAT",
-            "has_nan": False,
-            "mean": 0.5,
-            "range": [0, 1],
-            "std_dev": 0.1,
-            "sum": len(fields_df) // 2,
-            "valued": "CONTINUOUS"
-        }
-
-        return fields
-
-    def push_to_hf(self, repo_path, commit_message, token=None):
-        """
-        Pushes data to huggingface repo. Don't use this unless you're sure you want to update it!
-        :param repo_path: Path to huggingface repo.
-        """
-        whole_df = pd.concat([self.train_df, self.test_df])
-        # We get the indices as columns anyways so we can drop them
-        whole_df = whole_df.drop(["lat", "lon", "time"], axis=1)
-        ds = Dataset.from_pandas(whole_df)
-        if not token:
-            token = os.getenv("HF_TOKEN")
-        ds.push_to_hub(repo_path, commit_message=commit_message, token=token)
-
-
-class ELUCData(AbstractData):
-    """
-    Loads ELUC data from HuggingFace repo and processes it.
-    """
-    def __init__(self, start_year=1851, test_year=2012, end_year=2022, countries=None):
-        """
-        If update_path is given, load raw data the old way using 2 files that are merged.
-        Otherwise, path is taken to be a huggingface repo and we load the data from there.
-        """
-        assert start_year < test_year < end_year
-
-        super().__init__()
-
-        df = self.hf_to_df(constants.HF_PATH)
-        if countries:
-            df = self.subset_countries(df, countries)
-
-        self.train_df = df.loc[start_year:test_year-1]
-        self.test_df = df.loc[test_year:end_year-1]
-        assert self.train_df['time'].max() == self.test_df["time"].min() - 1
-
-        self.encoder = ELUCEncoder(self.get_fields())
-
-    def hf_to_df(self, hf_repo):
+    @classmethod
+    def from_hf(cls, start_year, test_year, end_year, countries=None):
         """
-        Loads dataset from huggingface, converts to pandas, then sets indices
-        appropriately to time/lat/lon.
-        Keep old time/lat/lon columns so we can use them as features later.
+        Loads dataframe from HuggingFace dataset to be processed by ELUCData constructor.
         """
-        ds = load_dataset(hf_repo)["train"]
+        ds = load_dataset(constants.HF_PATH)["train"]
         df = ds.to_pandas()
         df["time_idx"] = df["time"]
         df["lat_idx"] = df["lat"]
         df["lon_idx"] = df["lon"]
         df = df.set_index(["time_idx", "lat_idx", "lon_idx"], drop=True)
-        return df
-
-
-class RawELUCData(AbstractData):
-    """
-    Takes in the raw ELUC data files and processes it.
-    """
-    def __init__(self, path, update_path, start_year=1851, test_year=2012, end_year=2022, countries=None):
-        super().__init__()
-        raw = self.import_data(path, update_path)
-        df = self.da_to_df(raw, start_year, end_year, countries)
-
-        self.train_df = df.loc[start_year:test_year-1]
-        self.test_df = df.loc[test_year:end_year-1]
-        assert self.train_df['time'].max() == self.test_df["time"].min() - 1
-
-        self.encoder = ELUCEncoder(self.get_fields())
-
-    def import_data(self, path, update_path):
+        return cls(df, start_year, test_year, end_year, countries)
+    
+    @classmethod
+    def from_file(cls, path, update_path, start_year, test_year, end_year, countries=None):
+        """
+        Loads xarray from raw files which is then converted to dataframe.
+        This dataframe is then processed by the ELUCDataset constructor.
+        """
+        raw = cls.import_data(path, update_path)
+        df = cls.da_to_df(raw)
+        return cls(df, start_year, test_year, end_year, countries)
+    
+    @staticmethod
+    def import_data(path, update_path):
         """
         Reads in raw data and update data and processes them into an xarray.
         Replace ELUC and cell_area columns with updated ones.
@@ -251,18 +103,14 @@ def import_data(self, path, update_path):
             country_mask = regionmask.defined_regions.natural_earth_v5_0_0.countries_110.mask(raw)
             raw["country"] = country_mask
         return raw
-
-    def da_to_df(self, da: xr.DataArray, start_year=None, end_year=None, countries=None) -> pd.DataFrame:
+    
+    @staticmethod
+    def da_to_df(da: xr.DataArray) -> pd.DataFrame:
         """
         Converts an xarray DataArray to a pandas DataFrame.
         Duplicates indices into columns so we can use them as features.
         Adds country name column for easier access.
         :param da: xarray DataArray to convert.
-        :param start_year: Year to start at (inclusive)
-        :param end_year: Year to end at (uninclusive)
-        :param countries: List of country abbreviations to subset by
-        :param merge_crop: Whether to merge crop columns into one column.
-            (Note: Still leaves crop types untouched, just adds merged crop column)
         :return: pandas DataFrame
         """
         df = da.to_dataframe()
@@ -270,13 +118,6 @@ def da_to_df(self, da: xr.DataArray, start_year=None, end_year=None, countries=N
 
         df = df.reorder_levels(["time", "lat", "lon"]).sort_index()
 
-        if start_year:
-            df = df.loc[start_year:]
-        if end_year:
-            df = df.loc[:end_year]
-        if countries:
-            df = self.subset_countries(df, countries)
-
         # Keep time/lat/lon in columns so we can use them as features
         df["time"] = df.index.get_level_values("time")
         df["lat"] = df.index.get_level_values("lat")
@@ -286,9 +127,39 @@ def da_to_df(self, da: xr.DataArray, start_year=None, end_year=None, countries=N
         df["crop"] = df[constants.CROP_COLS].sum(axis=1)
         df["crop_diff"] = df[[f"{c}_diff" for c in constants.CROP_COLS]].sum(axis=1)
 
-        df['country_name'] = self.countries_df.loc[df['country'], 'names'].values
+        countries_df = construct_countries_df()
+        df['country_name'] = countries_df.loc[df['country'], 'names'].values
 
         # Drop this column we used for preprocessing (?)
         df = df.drop("mask", axis=1)
 
         return df
+    
+    def get_encoded_train(self):
+        """
+        Reduces cost of encoding data by caching the encoded version.
+        """
+        if self.encoded_train_df is None:
+            self.encoded_train_df = self.encoder.encode_as_df(self.train_df)
+        return self.encoded_train_df
+
+    def get_encoded_test(self):
+        """
+        Same as above but for test data.
+        """
+        if self.encoded_test_df is None:
+            self.encoded_test_df = self.encoder.encode_as_df(self.test_df)
+        return self.encoded_test_df
+
+    def push_to_hf(self, repo_path, commit_message, token=None):
+        """
+        Pushes data to huggingface repo. Don't use this unless you're sure you want to update it!
+        :param repo_path: Path to huggingface repo.
+        """
+        whole_df = pd.concat([self.train_df, self.test_df])
+        # We get the indices as columns anyways so we can drop them
+        whole_df = whole_df.drop(["lat", "lon", "time"], axis=1)
+        ds = Dataset.from_pandas(whole_df)
+        if not token:
+            token = os.getenv("HF_TOKEN")
+        ds.push_to_hub(repo_path, commit_message=commit_message, token=token)
diff --git a/use_cases/eluc/data/eluc_encoder.py b/use_cases/eluc/data/eluc_encoder.py
new file mode 100644
index 0000000..6428312
--- /dev/null
+++ b/use_cases/eluc/data/eluc_encoder.py
@@ -0,0 +1,102 @@
+"""
+Encoder class for the ELUC dataset.
+"""
+import json
+from pathlib import Path
+
+import pandas as pd
+
+from data import constants
+
+class ELUCEncoder():
+    """
+    Creates an encoder for a pandas dataset by collecting fields used for minmax scaling.
+    Special case for "change" column which doesn't have to be encoded
+    Special case for "diff" colums which we want to force between [-1, 1] which stretches them out.
+    """
+    def __init__(self, df: pd.DataFrame):
+        self.fields = self.get_fields(df)
+
+    def get_fields(self, df: pd.DataFrame) -> dict:
+        """
+        Creates fields json object for the data encoder/prescriptor.
+        """
+        cao_cols = constants.CAO_MAPPING["context"] + constants.CAO_MAPPING["actions"] + ["ELUC"]
+        fields_df = df[cao_cols].astype("float64")
+        fields = {}
+        for col in cao_cols:
+            # Set range of land and diff land uses manually to their true ranges because they
+            # do not need to be scaled
+            if col in constants.LAND_USE_COLS:
+                ran = [0, 1]
+            elif col in constants.DIFF_LAND_USE_COLS:
+                ran = [-1, 1]
+            else:
+                ran = [fields_df[col].min(), fields_df[col].max()]
+            fields[col] = {
+                "data_type": "FLOAT",
+                "has_nan": False,
+                "mean": fields_df[col].mean(),
+                "range": ran,
+                "std_dev": fields_df[col].std(),
+                "sum": fields_df[col].sum(),
+                "valued": "CONTINUOUS"
+            }
+
+        # These are just dummy values so that the prescriptor knows we have a change outcome
+        fields["change"] = {
+            "data_type": "FLOAT",
+            "has_nan": False,
+            "mean": 0.5,
+            "range": [0, 1],
+            "std_dev": 0.1,
+            "sum": len(fields_df) // 2,
+            "valued": "CONTINUOUS"
+        }
+        return fields
+
+    def encode_as_df(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Encodes a dataframe using the fields given in the constructor.
+        Uses minmax scaling.
+        """
+        new_df = df.copy()
+        for col in new_df.columns:
+            if col in self.fields:
+                min_val = self.fields[col]["range"][0]
+                max_val = self.fields[col]["range"][1]
+                # If min and max are the same, just set value to 0
+                if min_val == max_val:
+                    new_df[col] = 0
+                else:
+                    new_df[col] = (new_df[col] - min_val) / (max_val - min_val)
+        return new_df
+
+    def decode_as_df(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Decodes a dataframe using the fields given in the constructor.
+        Uses minmax scaling.
+        """
+        new_df = df.copy()
+        for col in new_df.columns:
+            if col in self.fields:
+                min_val = self.fields[col]["range"][0]
+                max_val = self.fields[col]["range"][1]
+                new_df[col] = new_df[col] * (max_val - min_val) + min_val
+        return new_df
+
+    def save_fields(self, path: Path):
+        """
+        Saves the fields to a JSON file.
+        """
+        with open(path, "w", encoding="utf-8") as file:
+            json.dump(self.fields, file, indent=4)
+
+    @classmethod
+    def from_json(cls, path: Path):
+        """
+        Loads the fields from a JSON file.
+        """
+        with open(path, "r", encoding="utf-8") as file:
+            fields = json.load(file)
+        return cls(fields)
\ No newline at end of file

From 04c26e619f021af922551133bf4133b1d2e8ef5b Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Fri, 7 Jun 2024 14:27:14 -0700
Subject: [PATCH 15/17] Updated documentation for new data file

---
 use_cases/eluc/data/eluc_data.py | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/use_cases/eluc/data/eluc_data.py b/use_cases/eluc/data/eluc_data.py
index 6934195..926b26a 100644
--- a/use_cases/eluc/data/eluc_data.py
+++ b/use_cases/eluc/data/eluc_data.py
@@ -1,15 +1,7 @@
 """
-Objects used to handle preprocessing the ELUC dataset.
-
-ELUCEncoder performs simple min/max scaling on numerical columns.
-
-AbstractData contains the member variables and methods usable by the user.
-RawELUCData is an implementation of AbstractData that loads the ELUC data via.
-the raw files and processes it.
-ELUCData is the standard implementation of AbstractData that loads the ELUC
-data from the HuggingFace repo.
+File handling the processing of data for the ELUC use case.
+Dataset wraps around a pandas dataframe and provides an encoder for prescriptors to use.
 """
-from abc import ABC
 import os
 import warnings
 

From 2f34f9d7d4077b240fbfec78f6f329ff081d5a1a Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Fri, 7 Jun 2024 15:11:10 -0700
Subject: [PATCH 16/17] Refactored data and encoder, updated all things to work
 with new data

---
 use_cases/eluc/app/process_data.py            |   2 +-
 use_cases/eluc/data/eluc_data.py              |  10 +-
 use_cases/eluc/data/eluc_encoder.py           |  14 ++-
 .../experiments/prescriptor_experiments.ipynb | 108 +++++++++---------
 .../prescriptors/nsga2/train_prescriptors.py  |   6 +-
 use_cases/eluc/tests/test_data.csv            |  11 ++
 use_cases/eluc/tests/test_nsga2.py            |  34 +++---
 7 files changed, 109 insertions(+), 76 deletions(-)
 create mode 100644 use_cases/eluc/tests/test_data.csv

diff --git a/use_cases/eluc/app/process_data.py b/use_cases/eluc/app/process_data.py
index 725b642..d5bf273 100644
--- a/use_cases/eluc/app/process_data.py
+++ b/use_cases/eluc/app/process_data.py
@@ -13,7 +13,7 @@ def main():
     """
     # Subsets the dataset so train_df is from start_year-1 to test year which we discard.
     # Then we take the app data as the test def which is from the app start year to the end of the dataset.
-    dataset = ELUCData(start_year=APP_START_YEAR-1, test_year=APP_START_YEAR)
+    dataset = ELUCData.from_hf(start_year=APP_START_YEAR-1, test_year=APP_START_YEAR)
     test_df = dataset.test_df
     save_dir = Path("app/data")
     save_dir.mkdir(exist_ok=True)
diff --git a/use_cases/eluc/data/eluc_data.py b/use_cases/eluc/data/eluc_data.py
index 926b26a..89b363c 100644
--- a/use_cases/eluc/data/eluc_data.py
+++ b/use_cases/eluc/data/eluc_data.py
@@ -24,10 +24,11 @@ def __init__(self, df: pd.DataFrame, start_year=1851, test_year=2012, end_year=2
         if countries:
             df = self.subset_countries(df, countries)
         self.train_df = df.loc[start_year:test_year-1].copy()
-        self.test_df = df.loc[test_year:end_year-1].copy()
-        assert self.train_df['time'].max() == self.test_df["time"].min() - 1
+        if test_year:
+            self.test_df = df.loc[test_year:end_year-1].copy()
+            assert self.train_df['time'].max() == self.test_df["time"].min() - 1
 
-        self.encoder = ELUCEncoder(self.train_df)
+        self.encoder = ELUCEncoder.from_pandas(self.train_df)
         # Set encoded values to None so that we don't encode them until we need to
         self.encoded_train_df = None
         self.encoded_test_df = None
@@ -42,7 +43,7 @@ def subset_countries(self, df, countries):
         return df[df["country"].isin(idx)].copy()
 
     @classmethod
-    def from_hf(cls, start_year, test_year, end_year, countries=None):
+    def from_hf(cls, start_year=1851, test_year=2012, end_year=2022, countries=None):
         """
         Loads dataframe from HuggingFace dataset to be processed by ELUCData constructor.
         """
@@ -139,6 +140,7 @@ def get_encoded_test(self):
         """
         Same as above but for test data.
         """
+        assert self.test_df is not None, "No test data provided."
         if self.encoded_test_df is None:
             self.encoded_test_df = self.encoder.encode_as_df(self.test_df)
         return self.encoded_test_df
diff --git a/use_cases/eluc/data/eluc_encoder.py b/use_cases/eluc/data/eluc_encoder.py
index 6428312..5752201 100644
--- a/use_cases/eluc/data/eluc_encoder.py
+++ b/use_cases/eluc/data/eluc_encoder.py
@@ -14,10 +14,18 @@ class ELUCEncoder():
     Special case for "change" column which doesn't have to be encoded
     Special case for "diff" colums which we want to force between [-1, 1] which stretches them out.
     """
-    def __init__(self, df: pd.DataFrame):
-        self.fields = self.get_fields(df)
+    def __init__(self, fields: dict):
+        self.fields = fields
 
-    def get_fields(self, df: pd.DataFrame) -> dict:
+    @classmethod
+    def from_pandas(cls, df: pd.DataFrame):
+        """
+        Records fields from a pandas dataframe.
+        """
+        return cls(cls.get_fields(df))
+
+    @staticmethod
+    def get_fields(df: pd.DataFrame) -> dict:
         """
         Creates fields json object for the data encoder/prescriptor.
         """
diff --git a/use_cases/eluc/experiments/prescriptor_experiments.ipynb b/use_cases/eluc/experiments/prescriptor_experiments.ipynb
index 5c2290e..6fb9059 100644
--- a/use_cases/eluc/experiments/prescriptor_experiments.ipynb
+++ b/use_cases/eluc/experiments/prescriptor_experiments.ipynb
@@ -10,7 +10,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -26,6 +26,7 @@
     "\n",
     "from data import constants\n",
     "from data.eluc_data import ELUCData\n",
+    "from data.eluc_encoder import ELUCEncoder\n",
     "from prescriptors.nsga2.candidate import Candidate\n",
     "from prescriptors.nsga2.land_use_prescriptor import LandUsePrescriptor\n",
     "from prescriptors.prescriptor_manager import PrescriptorManager\n",
@@ -35,11 +36,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
-    "dataset = ELUCData()"
+    "dataset = ELUCData.from_hf()\n",
+    "encoder = ELUCEncoder.from_pandas(dataset.train_df)"
    ]
   },
   {
@@ -51,7 +53,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -62,7 +64,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -77,7 +79,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 60,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -93,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 61,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -110,7 +112,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 62,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -218,7 +220,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -241,7 +243,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 64,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -263,7 +265,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 65,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -290,7 +292,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -313,7 +315,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -329,7 +331,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -342,7 +344,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 69,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -351,18 +353,18 @@
     "candidate_params = {\"in_size\": len(constants.CAO_MAPPING[\"context\"]), \"hidden_size\": 16, \"out_size\": len(constants.RECO_COLS)}\n",
     "# Set up new PrescriptorManager\n",
     "cands = [load_candidate(results_dir, cand_id, candidate_params) for cand_id in all_pareto_df[\"id\"]]\n",
-    "prescs = {cand.cand_id: LandUsePrescriptor(cand, dataset.encoder) for cand in cands}\n",
+    "prescs = {cand.cand_id: LandUsePrescriptor(cand, encoder) for cand in cands}\n",
     "torch_manager = PrescriptorManager(prescs, nnp)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
     "test_df = dataset.test_df.sample(frac=0.01, random_state=100)\n",
-    "encoded_test_df = dataset.encoder.encode_as_df(test_df)\n",
+    "encoded_test_df = encoder.encode_as_df(test_df)\n",
     "\n",
     "context_df = test_df[constants.CAO_MAPPING[\"context\"]]\n",
     "encoded_context_df = encoded_test_df[constants.CAO_MAPPING[\"context\"]]"
@@ -377,7 +379,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -389,14 +391,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 72,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 179/179 [00:51<00:00,  3.45it/s]\n"
+      "100%|██████████| 179/179 [00:50<00:00,  3.57it/s]\n"
      ]
     }
    ],
@@ -421,7 +423,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 73,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -441,14 +443,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 74,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 179/179 [01:15<00:00,  2.39it/s]\n"
+      "100%|██████████| 179/179 [01:14<00:00,  2.41it/s]\n"
      ]
     }
    ],
@@ -475,7 +477,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 75,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -487,7 +489,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 76,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -496,7 +498,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 77,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -514,7 +516,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 78,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
@@ -541,7 +543,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 79,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -607,7 +609,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 80,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
@@ -638,7 +640,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 81,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -663,7 +665,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 82,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
@@ -696,7 +698,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 83,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -710,7 +712,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 84,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -724,7 +726,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 85,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -748,7 +750,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 86,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
@@ -780,7 +782,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 87,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -794,7 +796,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 88,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -803,7 +805,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 89,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -828,7 +830,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 90,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
@@ -850,7 +852,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 91,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -872,7 +874,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 92,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [
     {
@@ -893,7 +895,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 93,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -918,7 +920,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 94,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [
     {
@@ -951,7 +953,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 95,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -980,7 +982,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 96,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [
     {
@@ -1009,7 +1011,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 97,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1029,7 +1031,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 98,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [
     {
@@ -1191,14 +1193,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 99,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 6/6 [00:08<00:00,  1.45s/it]\n"
+      "100%|██████████| 6/6 [00:08<00:00,  1.42s/it]\n"
      ]
     }
    ],
@@ -1220,7 +1222,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 100,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1235,7 +1237,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 101,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
@@ -1263,7 +1265,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 102,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [
     {
diff --git a/use_cases/eluc/prescriptors/nsga2/train_prescriptors.py b/use_cases/eluc/prescriptors/nsga2/train_prescriptors.py
index 166d13d..c8e4679 100644
--- a/use_cases/eluc/prescriptors/nsga2/train_prescriptors.py
+++ b/use_cases/eluc/prescriptors/nsga2/train_prescriptors.py
@@ -8,6 +8,7 @@
 from pathlib import Path
 
 from data.eluc_data import ELUCData
+from data.eluc_encoder import ELUCEncoder
 from prescriptors.nsga2.trainer import TorchTrainer
 from predictors.neural_network.neural_net_predictor import NeuralNetPredictor
 
@@ -21,7 +22,8 @@
         config = json.load(f)
 
     print("Loading dataset...")
-    dataset = ELUCData()
+    dataset = ELUCData.from_hf()
+    encoder = ELUCEncoder.from_pandas(dataset.train_df)
 
     print("Loading predictor...")
     # TODO: We need to make it so you can load any predictor here
@@ -32,7 +34,7 @@
         config["evolution_params"]["seed_dir"] = Path(config["evolution_params"]["seed_dir"])
     tp = TorchTrainer(
         eval_df=dataset.train_df.sample(frac=0.001, random_state=42),
-        encoder=dataset.encoder,
+        encoder=encoder,
         predictor=nnp,
         batch_size=4096,
         **config["evolution_params"]
diff --git a/use_cases/eluc/tests/test_data.csv b/use_cases/eluc/tests/test_data.csv
new file mode 100644
index 0000000..5e736e9
--- /dev/null
+++ b/use_cases/eluc/tests/test_data.csv
@@ -0,0 +1,11 @@
+time_idx,lat_idx,lon_idx,ELUC_diff,c3ann,c3ann_diff,c3nfx,c3nfx_diff,c3per,c3per_diff,c4ann,c4ann_diff,c4per,c4per_diff,cell_area_diff,pastr,pastr_diff,primf,primf_diff,primn,primn_diff,range,range_diff,secdf,secdf_diff,secdn,secdn_diff,urban,urban_diff,ELUC,cell_area,country,crop,crop_diff,country_name,time,lat,lon
+2012,50.125,-5.625,0.6143503,0.11180475,0.00015483052,0.006066836,8.401461e-06,0.0,0.0,0.0026001413,3.600726e-06,0.0,0.0,49543.36,0.1565842,0.062717825,0.0,0.0,0.0,0.0,0.06143657,-0.06143657,0.0,0.0,0.07702281,-0.0013826042,0.009482789,-6.5470114e-05,4.28316,49543.36,143.0,0.12047173,0.0001668327,United Kingdom,2012,50.125,-5.625
+2012,50.125,-5.375,-0.010087967,0.21377629,0.00061927736,0.011195366,3.2430515e-05,0.00084496377,2.4476903e-06,0.0048587145,1.4075078e-05,0.0,0.0,49543.36,0.20467533,0.0020473301,0.0,0.0,0.0,0.0,4.9112125e-10,5.2850835e-09,0.111086704,-0.0025047734,0.0,0.0,0.037052073,-0.00021079183,0.2954502,49543.36,143.0,0.23067534,0.00066823064,United Kingdom,2012,50.125,-5.375
+2012,50.125,-5.125,-0.051891327,0.25353593,0.00022375584,0.013354132,1.1785887e-05,0.00039282485,3.4665572e-07,0.005891553,5.1991083e-06,0.0,0.0,49543.36,0.3292197,0.0011976361,0.0,0.0,0.0,0.0,4.9883813e-09,3.073569e-09,0.14206162,-0.001235053,0.0,0.0,0.028397104,-0.00020365231,0.14264679,49543.36,143.0,0.27317443,0.00024108749,United Kingdom,2012,50.125,-5.125
+2012,50.375,-5.125,-0.009803772,0.21232493,0.0002645254,0.011630909,1.4490448e-05,0.0006841576,8.523348e-07,0.0047891033,5.966518e-06,0.0,0.0,49284.117,0.22515206,0.004094735,0.0,0.0,0.0,0.0,0.0024033189,-0.0024033189,0.11356922,-0.0017561838,0.0,0.0,0.028949084,-0.00022106804,0.20087814,49284.117,143.0,0.2294291,0.0002858347,United Kingdom,2012,50.375,-5.125
+2012,50.375,-4.875,-0.0062828064,0.31292868,0.0013995469,0.016478479,7.369742e-05,0.00084040104,3.758585e-06,0.0073985006,3.308896e-05,0.0,0.0,49284.117,0.446775,0.0032997727,0.0,0.0,0.0,0.0,5.288069e-09,6.0071907e-09,0.1818322,-0.004669711,0.0,0.0,0.02137504,-0.00014016218,0.55989075,49284.117,143.0,0.33764604,0.0015100918,United Kingdom,2012,50.375,-4.875
+2012,50.375,-4.625,0.0009765625,0.1530304,0.0008800775,0.00770235,4.429603e-05,0.0,0.0,0.0036331436,2.0894222e-05,0.0,0.0,49284.117,0.30028272,0.05127409,0.0,0.0,0.0,0.0,0.05023551,-0.050235502,0.1258082,-0.0018767789,0.0,0.0,0.01254346,-0.00010706391,0.23663712,49284.117,143.0,0.16436589,0.00094526773,United Kingdom,2012,50.375,-4.625
+2012,50.375,-4.375,-0.0026988983,0.17357937,0.0010203421,0.0087594,5.149003e-05,0.00029217277,1.7174752e-06,0.0039417204,2.317084e-05,0.0,0.0,49284.117,0.28131965,0.0010857284,0.0,0.0,0.0,0.0,1.45617705e-08,-1.45617705e-08,0.0,0.0,0.09888996,-0.002130881,0.005915402,-5.1575247e-05,0.27333927,49284.117,143.0,0.18657264,0.0010967205,United Kingdom,2012,50.375,-4.375
+2012,50.375,-4.125,-0.012577057,0.15427873,0.0012707263,0.008473902,6.979611e-05,0.0,0.0,0.0037385595,3.0793017e-05,0.0,0.0,49284.117,0.25169906,2.95043e-05,0.0,0.0,0.0,0.0,6.9650525e-09,-6.9650525e-09,0.0,0.0,0.11867979,-0.0009937137,0.15042886,-0.00040709972,0.15741348,49284.117,143.0,0.16649118,0.0013713154,United Kingdom,2012,50.375,-4.125
+2012,50.375,-3.875,-0.0062179565,0.25444505,0.0019072294,0.0128248725,9.6131116e-05,0.00037239672,2.7913484e-06,0.005576115,4.179636e-05,0.0,0.0,49284.117,0.46091825,0.0004426837,0.0,0.0,0.0,0.0,1.1587524e-09,6.333768e-09,0.1589224,-0.0024436414,0.0,0.0,0.0051572393,-4.7012698e-05,0.3351097,49284.117,143.0,0.27321842,0.0020479483,United Kingdom,2012,50.375,-3.875
+2012,50.375,-3.625,0.14909363,0.2423857,0.00096043944,0.012525458,4.963111e-05,0.0004390001,1.7395068e-06,0.005493631,2.1768268e-05,0.0,0.0,49284.117,0.25724518,0.045945466,4.809759e-09,0.0,0.0,0.0,0.043528896,-0.043528896,0.12863077,-0.013060391,0.0,0.0,0.07014576,0.009610251,1.4518242,49284.117,143.0,0.26084378,0.0010335783,United Kingdom,2012,50.375,-3.625
diff --git a/use_cases/eluc/tests/test_nsga2.py b/use_cases/eluc/tests/test_nsga2.py
index 7e87efc..7f17262 100644
--- a/use_cases/eluc/tests/test_nsga2.py
+++ b/use_cases/eluc/tests/test_nsga2.py
@@ -1,6 +1,7 @@
 """
 Unit tests for the NSGA-II Torch implementation.
 """
+from pathlib import Path
 import unittest
 
 import numpy as np
@@ -8,7 +9,7 @@
 import torch
 
 from data import constants
-from data.eluc_data import ELUCData
+from data.eluc_encoder import ELUCEncoder
 from prescriptors.nsga2.candidate import Candidate
 from prescriptors.nsga2.land_use_prescriptor import LandUsePrescriptor
 from prescriptors.nsga2 import nsga2_utils
@@ -53,13 +54,20 @@ class TestLandUsePrescriptor(unittest.TestCase):
     """
     @classmethod
     def setUpClass(cls):
-        data = ELUCData()
-        cls.df = data.train_df
+        """
+        Set up tests by reading dummy data from csv in repo.
+        """
+        test_df = pd.read_csv(Path("tests/test_data.csv"))
+        test_df["time_idx"] = test_df["time"]
+        test_df["lat_idx"] = test_df["lat"]
+        test_df["lon_idx"] = test_df["lon"]
+        test_df = test_df.set_index(["time_idx", "lat_idx", "lon_idx"], drop=True)
+        cls.df = test_df
 
-        candidate = Candidate(len(constants.CAO_MAPPING["context"]), 16, len(constants.RECO_COLS))
-        cls.prescriptor = LandUsePrescriptor(candidate, data.encoder)
+        encoder = ELUCEncoder.from_pandas(test_df)
 
-        cls.n = 10
+        candidate = Candidate(len(constants.CAO_MAPPING["context"]), 16, len(constants.RECO_COLS))
+        cls.prescriptor = LandUsePrescriptor(candidate, encoder)
 
     # Disable protected access warning so we can test the private methods
     # pylint: disable=protected-access
@@ -67,11 +75,11 @@ def test_reco_tensor_to_df_all_zero_tensor(self):
         """
         Tests the case where the tensor is all zeros.
         """
-        reco_tensor = torch.zeros(self.n, len(constants.RECO_COLS))
-        context_df = self.df[constants.CAO_MAPPING["context"]].iloc[:self.n]
+        reco_tensor = torch.zeros(len(self.df), len(constants.RECO_COLS))
+        context_df = self.df[constants.CAO_MAPPING["context"]]
         reco_df = self.prescriptor._reco_tensor_to_df(reco_tensor, context_df)
         self.assertIsInstance(reco_df, pd.DataFrame)
-        self.assertEqual(reco_df.shape, (self.n, len(constants.RECO_COLS)))
+        self.assertEqual(reco_df.shape, (len(self.df), len(constants.RECO_COLS)))
         self.assertEqual(reco_df.sum(axis=1).all(), context_df[constants.RECO_COLS].sum(axis=1).all())
         self.assertTrue(reco_df.index.equals(context_df.index))
 
@@ -80,7 +88,7 @@ def test_reco_tensor_to_df_all_zero_context(self):
         Tests the case where the context dataframe is all zeros.
         """
         reco_tensor = torch.rand(10, len(constants.RECO_COLS))
-        zero_df = self.df.iloc[:self.n].copy()
+        zero_df = self.df.copy()
         zero_df[constants.LAND_USE_COLS] = 0
         reco_df = self.prescriptor._reco_tensor_to_df(reco_tensor, zero_df)
         self.assertIsInstance(reco_df, pd.DataFrame)
@@ -95,11 +103,11 @@ def test_reco_to_context_actions(self):
         Also makes sure diff for all the NO_CHANGE_COLS is 0.
         TODO: This isn't a great test - should I redo it with synthetic data?
         """
-        reco_df = self.df.iloc[:self.n][constants.RECO_COLS]
+        reco_df = self.df[constants.RECO_COLS]
         self.assertTrue(reco_df.sum(axis=1).all() > 0)
         self.assertTrue(reco_df.sum(axis=1).all() <= 1)
 
-        context_df = self.df.iloc[:self.n][constants.CAO_MAPPING["context"]].copy()
+        context_df = self.df[constants.CAO_MAPPING["context"]].copy()
         self.assertTrue(context_df.sum(axis=1).all() > 0)
         self.assertTrue(context_df.sum(axis=1).all() <= 1)
 
@@ -117,7 +125,7 @@ def test_prescribe_indices_same(self):
         """
         Tests prescribe method to see if context_actions_df has the same indices as the input context_df.
         """
-        context_df = self.df.iloc[:self.n][constants.CAO_MAPPING["context"]]
+        context_df = self.df[constants.CAO_MAPPING["context"]]
         context_actions_df = self.prescriptor.prescribe(context_df)
 
         self.assertTrue(context_actions_df.index.equals(context_df.index))

From 8a96046d836bc341f75de08c105e47f6496946b6 Mon Sep 17 00:00:00 2001
From: Daniel Young <danyoung@utexas.edu>
Date: Fri, 7 Jun 2024 15:59:10 -0700
Subject: [PATCH 17/17] Linted files to reach 9.7

---
 use_cases/eluc/.pylintrc                      |  2 +-
 use_cases/eluc/data/eluc_data.py              |  8 ++++----
 use_cases/eluc/data/eluc_encoder.py           |  2 +-
 .../experiments/predictor_significance.py     |  8 ++++----
 .../eluc/predictors/predictor_evaluator.py    |  8 ++++----
 .../eluc/prescriptors/nsga2/create_seeds.py   |  2 +-
 use_cases/eluc/prescriptors/prescriptor.py    | 19 +++++++++----------
 7 files changed, 24 insertions(+), 25 deletions(-)

diff --git a/use_cases/eluc/.pylintrc b/use_cases/eluc/.pylintrc
index d68504a..951551a 100644
--- a/use_cases/eluc/.pylintrc
+++ b/use_cases/eluc/.pylintrc
@@ -3,7 +3,7 @@ ignore=prescriptors/esp
 
 recursive=y
 
-fail-under=9.65
+fail-under=9.7
 
 jobs=0
 
diff --git a/use_cases/eluc/data/eluc_data.py b/use_cases/eluc/data/eluc_data.py
index 89b363c..4f55b0a 100644
--- a/use_cases/eluc/data/eluc_data.py
+++ b/use_cases/eluc/data/eluc_data.py
@@ -54,7 +54,7 @@ def from_hf(cls, start_year=1851, test_year=2012, end_year=2022, countries=None)
         df["lon_idx"] = df["lon"]
         df = df.set_index(["time_idx", "lat_idx", "lon_idx"], drop=True)
         return cls(df, start_year, test_year, end_year, countries)
-    
+
     @classmethod
     def from_file(cls, path, update_path, start_year, test_year, end_year, countries=None):
         """
@@ -64,7 +64,7 @@ def from_file(cls, path, update_path, start_year, test_year, end_year, countries
         raw = cls.import_data(path, update_path)
         df = cls.da_to_df(raw)
         return cls(df, start_year, test_year, end_year, countries)
-    
+
     @staticmethod
     def import_data(path, update_path):
         """
@@ -96,7 +96,7 @@ def import_data(path, update_path):
             country_mask = regionmask.defined_regions.natural_earth_v5_0_0.countries_110.mask(raw)
             raw["country"] = country_mask
         return raw
-    
+
     @staticmethod
     def da_to_df(da: xr.DataArray) -> pd.DataFrame:
         """
@@ -127,7 +127,7 @@ def da_to_df(da: xr.DataArray) -> pd.DataFrame:
         df = df.drop("mask", axis=1)
 
         return df
-    
+
     def get_encoded_train(self):
         """
         Reduces cost of encoding data by caching the encoded version.
diff --git a/use_cases/eluc/data/eluc_encoder.py b/use_cases/eluc/data/eluc_encoder.py
index 5752201..7b4419b 100644
--- a/use_cases/eluc/data/eluc_encoder.py
+++ b/use_cases/eluc/data/eluc_encoder.py
@@ -107,4 +107,4 @@ def from_json(cls, path: Path):
         """
         with open(path, "r", encoding="utf-8") as file:
             fields = json.load(file)
-        return cls(fields)
\ No newline at end of file
+        return cls(fields)
diff --git a/use_cases/eluc/experiments/predictor_significance.py b/use_cases/eluc/experiments/predictor_significance.py
index 350d561..5733091 100644
--- a/use_cases/eluc/experiments/predictor_significance.py
+++ b/use_cases/eluc/experiments/predictor_significance.py
@@ -58,10 +58,10 @@ def train_and_test(n: int,
         for _ in tqdm(range(n)):
             result_row = {"train": train_region}
             model = model_constructor(**config)
-            s = time.time()
+            start = time.time()
             _ = model.fit(train_region_df, train_region_df["ELUC"])
-            e = time.time()
-            result_row["time"] = e - s
+            end = time.time()
+            result_row["time"] = end - start
             # Evaluate on each region
             for test_region, countries in constants.COUNTRY_DICT.items():
                 if test_region != "ALL":
@@ -85,7 +85,7 @@ def main():
     train_and_test to train and test the models n times.
     """
     print("Loading data...")
-    dataset = ELUCData()
+    dataset = ELUCData.from_hf()
 
     nn_config = {
         "features": constants.NN_FEATS,
diff --git a/use_cases/eluc/predictors/predictor_evaluator.py b/use_cases/eluc/predictors/predictor_evaluator.py
index a172d97..8817c14 100644
--- a/use_cases/eluc/predictors/predictor_evaluator.py
+++ b/use_cases/eluc/predictors/predictor_evaluator.py
@@ -14,10 +14,10 @@ def __init__(self, test_start_year=2012, test_end_year=2022, test_countries=None
         """
         Initializes the evalutor with a test set to consistently test on.
         """
-        dataset = ELUCData(start_year=test_start_year-1,
-                           test_year=test_start_year,
-                           end_year=test_end_year,
-                           countries=test_countries)
+        dataset = ELUCData.from_hf(start_year=test_start_year-1,
+                                   test_year=test_start_year,
+                                   end_year=test_end_year,
+                                   countries=test_countries)
         self.X_test = dataset.test_df.drop("ELUC", axis=1)
         self.y_test = dataset.test_df["ELUC"]
 
diff --git a/use_cases/eluc/prescriptors/nsga2/create_seeds.py b/use_cases/eluc/prescriptors/nsga2/create_seeds.py
index 027570a..099107a 100644
--- a/use_cases/eluc/prescriptors/nsga2/create_seeds.py
+++ b/use_cases/eluc/prescriptors/nsga2/create_seeds.py
@@ -78,7 +78,7 @@ def seed_max_change(seed_dir: Path, df: pd.DataFrame, encoded_df: pd.DataFrame):
     supervised_backprop(seed_dir / "max_change.pt", ds)
 
 if __name__ == "__main__":
-    dataset = ELUCData()
+    dataset = ELUCData.from_hf()
     train_df = dataset.train_df.sample(10000)
     encoded_train_df = dataset.get_encoded_train().loc[train_df.index]
     seed_no_change(Path("prescriptors/nsga2/seeds/test"), train_df, encoded_train_df)
diff --git a/use_cases/eluc/prescriptors/prescriptor.py b/use_cases/eluc/prescriptors/prescriptor.py
index d3991ce..acf718c 100644
--- a/use_cases/eluc/prescriptors/prescriptor.py
+++ b/use_cases/eluc/prescriptors/prescriptor.py
@@ -19,7 +19,7 @@ def prescribe(self, context_df: pd.DataFrame) -> pd.DataFrame:
         Outputs a concatenation of the context and actions.
         """
         raise NotImplementedError
-        
+
     @abstractmethod
     def save(self, path: Path):
         """
@@ -34,7 +34,7 @@ def load(cls, path: Path) -> "Prescriptor":
         Loads a prescriptor from disk.
         """
         raise NotImplementedError
-    
+
     @classmethod
     def from_pretrained(cls, path_or_url: str, **hf_args) -> "Prescriptor":
         """
@@ -46,13 +46,12 @@ def from_pretrained(cls, path_or_url: str, **hf_args) -> "Prescriptor":
         path = Path(path_or_url)
         if path.exists() and path.is_dir():
             return cls.load(path)
-        else:
-            # TODO: Need a try except block to catch download errors
-            url_path = path_or_url.replace("/", "--")
-            local_dir = hf_args.get("local_dir", f"prescriptors/trained_models/{url_path}")
+        # TODO: Need a try except block to catch download errors
+        url_path = path_or_url.replace("/", "--")
+        local_dir = hf_args.get("local_dir", f"prescriptors/trained_models/{url_path}")
 
-            if not Path(local_dir).exists() or not Path(local_dir).is_dir():
-                hf_args["local_dir"] = local_dir
-                snapshot_download(repo_id=path_or_url, **hf_args)
+        if not Path(local_dir).exists() or not Path(local_dir).is_dir():
+            hf_args["local_dir"] = local_dir
+            snapshot_download(repo_id=path_or_url, **hf_args)
 
-            return cls.load(Path(local_dir))
+        return cls.load(Path(local_dir))