Repository: zincware/MDSuite (language: python)

Issue:
check_existence is prone to errors
**Describe the bug**
check_existence method in database is prone to errors if properties share a part of their name.
For example in the case of the integrated heat current we have: 
For normal EH:  Integrated_Heat_Current
For normal Kinaci formulation:  Kinaci_Integrated_Heat_Current

**To Reproduce**
If you run the example of conductivity_thermal with conductivity_kinaci.py, and then with conductivity_eh.py, the code will think that the Integrated_Heat_Current has been computed because in line 380 in database it performs the check based on part of the name.  ​

**Temporary fix**
I have changed  the name of the current, and simple called it Kinaci_Heat_Current to avoid this problem, but I guess a better solution could be better as in the future it could lead to bugs which are somewhat tricky to find. 

Maybe a better fix would be that the current name should be between "/" like: /Kinaci_Heat_Current/ since in the h5 file it will be like this always...



Discussion / hints:

Fix patch:
diff --git a/.gitignore b/.gitignore
index 82aa91d4..182fb02b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -163,3 +163,4 @@ log.lammps
 *.yaml
 *.hdf5
 *.pdf
+./tutorials/data/trajectory_files
diff --git a/mdsuite/database/database.py b/mdsuite/database/database.py
index 6974ff8e..f6a83cec 100644
--- a/mdsuite/database/database.py
+++ b/mdsuite/database/database.py
@@ -22,7 +22,9 @@ class Database:
     Attributes
     ----------
     architecture : str
-                The type of the database_path implemented, either a simulation database_path, or an analysis database_path.
+                The type of the database_path implemented, either a simulation database_path, or an
+                analysis database_path.
+
     name : str
             The name of the database_path in question.
     """
@@ -34,7 +36,8 @@ def __init__(self, architecture: str = 'simulation', name: str = 'database'):
         Parameters
         ----------
         architecture : str
-                The type of the database_path implemented, either a simulation database_path, or an analysis database_path.
+                The type of the database_path implemented, either a simulation
+        database_path, or an analysis database_path. name : str The name of the database_path in question.
         name : str
                 The name of the database_path in question.
         """
@@ -93,8 +96,7 @@ def add_data(self, data: np.array, structure: dict, start_index: int, batch_size
                 Number of configurations in each batch
         start_index : int
                 Point in database_path from which to start filling.
-        database : hf.File
-                Database in which to store the tensor_values
+
         structure : dict
                 Structure of the tensor_values to be loaded into the database_path e.g.
                 {'Na/Velocities': {'indices': [1, 3, 7, 8, ... ], 'columns' = [3, 4, 5], 'length': 500}}
@@ -155,20 +157,22 @@ def _update_indices(data: np.array, indices: np.array, batch_size: int, n_atoms:
 
         """
         atom_ids = np.tile(indices, batch_size)
-        simulation_ids = np.split(np.array(data[:, 0]).astype(int), int(batch_size/n_atoms))
-        indices = np.zeros(int(batch_size*len(atom_ids)))
+        simulation_ids = np.split(np.array(data[:, 0]).astype(int), int(batch_size / n_atoms))
+        indices = np.zeros(int(batch_size * len(atom_ids)))
+
 
         counter = 0
         for i, item in enumerate(simulation_ids):
             stop = counter + len(atom_ids)
-            correction = i*n_atoms
+            correction = i * n_atoms
+
             sorter = np.argsort(item)
             simulation_ids[counter:stop] = sorter[np.searchsorted(item, atom_ids, sorter=sorter)] + correction
             counter += len(atom_ids)
 
         return indices
 
-    def _resize_dataset(self, structure: dict):
+    def resize_dataset(self, structure: dict):
         """
         Resize a dataset so more tensor_values can be added
 
@@ -190,17 +194,34 @@ def _resize_dataset(self, structure: dict):
 
         # construct the architecture dict
         architecture = self._build_path_input(structure=structure)
+        # Check for a type error in the dataset information
 
         for identifier in architecture:
-            for data in database[identifier]:
-                data.resize(architecture[identifier], 1)
+            dataset_information = architecture[identifier]
+            try:
+                if type(dataset_information) is not tuple:
+                    print("Invalid input for dataset generation")
+                    raise TypeError
+            except TypeError:
+                raise TypeError
+
+            # get the correct maximum shape for the dataset -- changes if a experiment property or an atomic property
+            if len(dataset_information[:-1]) == 1:
+                axis = 0
+                expansion = dataset_information[0] + database[identifier].shape[0]
+            else:
+                axis = 1
+                expansion = dataset_information[1] + database[identifier].shape[1]
+            database[identifier].resize(expansion, axis)
+
 
     def initialize_database(self, structure: dict):
         """
         Build a database_path with a general structure.
 
-        Note, this method WILL overwrite a pre-existing database_path. This is because it is only to be called on the initial
-        construction of an experiment class and the first addition of tensor_values to it.
+        Note, this method WILL overwrite a pre-existing database_path. This is because it is only to be called on the
+        initial construction of an experiment class and the first addition of tensor_values to it.
+
 
         Parameters
         ----------
@@ -221,31 +242,27 @@ def _build_path_input(structure: dict) -> dict:
         """
         Build an input to a hdf5 database_path from a dictionary
 
-        In many cases, whilst a dict can be passed on to a method, it is not ideal for use in the hdf5 database_path. This
-        method takes a dictionary and return a new dictionary with the relevant file path.
+        In many cases, whilst a dict can be passed on to a method, it is not ideal for use in the hdf5 database_path.
+        This method takes a dictionary and return a new dictionary with the relevant file path.
+
 
         Parameters
         ----------
         structure : dict
-                General structure of the dictionary with relevant dataset sizes.
-                e.g. {'Na': {'Forces': (200, 5000, 3)}, 'Pressure': (5000, 6), 'Temperature': (5000, 1)}
-                In this case, the last value in the tuple corresponds to the number of components that wil be parsed
-                to the database_path. The value in the dict can also be an integer corresponding to a resize operation such
-                as {'Na': {'velocities' 100}}. In any case, the deepest portion of the dict must be a non-dict object
-                and will be returned as the value of the path to it in the new dictionary.
+                General structure of the dictionary with relevant dataset sizes. e.g.
+        {'Na': {'Forces': (200, 5000, 3)}, 'Pressure': (5000, 6), 'Temperature': (5000, 1)} In this case,
+        the last value in the tuple corresponds to the number of components that wil be parsed to the database_path.
+        The value in the dict can also be an integer corresponding to a resize operation such as {'Na': {'velocities'
+        100}}. In any case, the deepest portion of the dict must be a non-dict object and will be returned as the
+        value of the path to it in the new dictionary.
+
 
         Returns
         -------
         architecture : dict
-                Corrected path in the hdf5 database_path. e.g. {'/Na/Velocities': 100}, or {'/Na/Forces': (200, 5000, 3)}
+                Corrected path in the hdf5 database_path. e.g. {'/Na/Velocities': 100}, or
+                {'/Na/Forces': (200, 5000, 3)}
 
-        Examples
-        --------
-        >>> database_path = Database
-        >>> database_path._build_path_input(structure = {'Na' : {'Forces': (200, 5000, 3)}})
-        {'Na/Forces': (200, 5000, 3)}
-        >>> database_path._build_path_input(structure={'Na': {'velocities' 100}})
-        {'Na/Velocities': 100}
         """
 
         # Build file paths for the addition.
@@ -264,19 +281,17 @@ def add_dataset(self, structure: dict):
         """
         Add a dataset of the necessary size to the database_path
 
-        Just as a separate method exists for building the group structure of the hdf5 database_path, so too do we include
-        a separate method for adding a dataset. This is so datasets can be added not just upon the initial construction
-        of the database_path, but also if tensor_values is added in the future that should also be stored. This method will assume
-        that a group has already been built, although this is not necessary for HDF5, the separation of the actions is
-        good practice.
+        Just as a separate method exists for building the group structure of the hdf5 database_path, so too do we
+        include a separate method for adding a dataset. This is so datasets can be added not just upon the initial
+        construction of the database_path, but also if tensor_values is added in the future that should also be
+        stored. This method will assume that a group has already been built, although this is not necessary for HDF5,
+        the separation of the actions is good practice.
 
         Parameters
         ----------
         structure : dict
                 Structure of a single property to be added to the database_path.
                 e.g. {'Na': {'Forces': (200, 5000, 3)}}
-        database_path: hf.File
-                Open hdf5 database_path object to be added to.
 
         Returns
         -------
@@ -306,23 +321,21 @@ def add_dataset(self, structure: dict):
                 max_shape[1] = None
                 max_shape = tuple(max_shape)
 
-            database.create_dataset(dataset_path, dataset_information, maxshape=max_shape, scaleoffset=5)
+            database.create_dataset(dataset_path, dataset_information, maxshape=max_shape, scaleoffset=5, chunks=True)
         database.close()
 
     def _add_group_structure(self, structure: dict):
         """
         Add a simple group structure to a database_path.
+        This method will take an input structure and build the required group structure in the hdf5 database_path.
+        This will NOT however instantiate the dataset for the structure, only the group hierarchy.
 
-        This method will take an input structure and build the required group structure in the hdf5 database_path. This will
-        NOT however instantiate the dataset for the structure, only the group hierarchy.
 
         Parameters
         ----------
         structure : dict
                 Structure of a single property to be added to the database_path.
                 e.g. {'Na': {'Forces': (200, 5000, 3)}}
-        database: hf.File
-                Open hdf5 database_path object to be added to.
 
         Returns
         -------
@@ -376,8 +389,8 @@ def check_existence(self, path: str) -> bool:
         keys = []
         database_object.visit(lambda item: keys.append(database_object[item].name) if type(database_object[item]) is
                                                                                       hf.Dataset else None)
+        path = f'/{path}'  # add the / to avoid name overlapping
 
-        path = f'/{path}' # add the / to avoid name overlapping
         response = any(list(item.endswith(path) for item in keys))
         database_object.close()
         return response
@@ -422,7 +435,8 @@ def load_data(self, path_list: list = None, select_slice: np.s_ = None, dictiona
         if not dictionary:
             data = []
             for i, item in enumerate(path_list):
-                data.append(tf.convert_to_tensor(database[item][select_slice], dtype=tf.float64)*scaling[i])
+                data.append(tf.convert_to_tensor(database[item][select_slice], dtype=tf.float64) * scaling[i])
+
         if dictionary:
             data = {}
             for item in path_list:
@@ -476,7 +490,8 @@ def get_data_size(self, data_path: str, database_path: str = None, system: bool
         database_path: (optional) str
                 path to a specific database_path, if None, the class instance database_path will be used
         system : bool
-                If true, the row number is the relavent property
+                If true, the row number is the relevant property
+
         Returns
         -------
         dataset_properties : tuple
diff --git a/mdsuite/experiment/experiment.py b/mdsuite/experiment/experiment.py
index 145e13c3..2a9aa52a 100644
--- a/mdsuite/experiment/experiment.py
+++ b/mdsuite/experiment/experiment.py
@@ -452,7 +452,8 @@ def add_data(self, trajectory_file: str = None, file_format: str = 'lammps_traj'
             flux = False
 
         if database_path.exists():
-            pass  # self._update_database(trajectory_reader)
+            self._update_database(trajectory_reader, trajectory_file, database, rename_cols)
+
         else:
             self._build_new_database(trajectory_reader, trajectory_file, database, rename_cols=rename_cols, flux=flux)
 
@@ -506,6 +507,42 @@ def _build_new_database(self, trajectory_reader: FileProcessor, trajectory_file:
 
         self.save_class()  # Update the class state
 
+    def _update_database(self, trajectory_reader: FileProcessor, trajectory_file: str, database: Database,
+                         rename_cols: dict, flux: bool = False):
+        """
+        Update the database rather than build a new database.
+
+        Returns
+        -------
+        Updates the current database.
+        """
+        counter = self.number_of_configurations
+        architecture, line_length = trajectory_reader.process_trajectory_file(rename_cols=rename_cols)
+        number_of_new_configurations = self.number_of_configurations - counter
+        database.resize_dataset(architecture)  # initialize the database_path
+        batch_range = int(number_of_new_configurations / self.batch_size)  # calculate the batch range
+        remainder = number_of_new_configurations - (batch_range * self.batch_size)
+        structure = trajectory_reader.build_file_structure()  # build the file structure
+        f_object = open(trajectory_file, 'r')  # open the trajectory file
+        for _ in tqdm(range(batch_range), ncols=70):
+            database.add_data(data=trajectory_reader.read_configurations(self.batch_size, f_object, line_length),
+                              structure=structure,
+                              start_index=counter,
+                              batch_size=self.batch_size,
+                              flux=flux,
+                              n_atoms=self.number_of_atoms)
+            counter += self.batch_size
+
+        if remainder > 0:
+            structure = trajectory_reader.build_file_structure(batch_size=remainder)  # build the file structure
+            database.add_data(data=trajectory_reader.read_configurations(remainder, f_object, line_length),
+                              structure=structure,
+                              start_index=counter,
+                              batch_size=remainder,
+                              flux=flux)
+
+        f_object.close()
+
     def _load_trajectory_reader(self, file_format, trajectory_file, sort: bool = False):
         try:
             class_file_io, file_type = dict_file_io[file_format]  # file type is per atoms or flux.
@@ -712,4 +749,6 @@ def write_xyz(self, dump_property: str = "Positions", species: list = None, atom
                 f.write("Generated by the mdsuite xyz writer\n")
                 for j, atom_species in enumerate(species):
                     for atom in data_matrix[j].numpy():
-                        f.write(f"{atom_species:<2}    {atom[i][0]:>9.4f}    {atom[i][1]:>9.4f}    {atom[i][2]:>9.4f}\n")
+                        f.write(
+                            f"{atom_species:<2}    {atom[i][0]:>9.4f}    {atom[i][1]:>9.4f}    {atom[i][2]:>9.4f}\n")
+
diff --git a/mdsuite/file_io/extxyz_trajectory_reader.py b/mdsuite/file_io/extxyz_trajectory_reader.py
index 415983e7..dc639f11 100644
--- a/mdsuite/file_io/extxyz_trajectory_reader.py
+++ b/mdsuite/file_io/extxyz_trajectory_reader.py
@@ -305,17 +305,18 @@ def process_trajectory_file(self, update_class: bool = True, rename_cols: dict =
         species_summary, box, property_groups, line_length = self._get_species_information(number_of_atoms)
 
         if update_class:
-            self.project.batch_size = batch_size
-            self.project.dimensions = get_dimensionality(box)
-            self.project.box_array = box
-            self.project.volume = box[0] * box[1] * box[2]
-            self.project.species = species_summary
-            self.project.number_of_atoms = number_of_atoms
-            self.project.number_of_configurations += number_of_configurations
-            self.project.sample_rate = sample_rate
-            self.project.property_groups = property_groups
+            self.experiment.batch_size = batch_size
+            self.experiment.dimensions = get_dimensionality(box)
+            self.experiment.box_array = box
+            self.experiment.volume = box[0] * box[1] * box[2]
+            self.experiment.species = species_summary
+            self.experiment.number_of_atoms = number_of_atoms
+            self.experiment.number_of_configurations += number_of_configurations
+            self.experiment.sample_rate = sample_rate
+            self.experiment.property_groups = property_groups
 
         else:
-            self.project.batch_size = batch_size
+            self.experiment.batch_size = batch_size
+
 
         return self._build_architecture(species_summary, property_groups, number_of_configurations), line_length
diff --git a/mdsuite/file_io/file_read.py b/mdsuite/file_io/file_read.py
index bc6d7444..9cbed006 100644
--- a/mdsuite/file_io/file_read.py
+++ b/mdsuite/file_io/file_read.py
@@ -15,7 +15,8 @@ class FileProcessor(metaclass=abc.ABCMeta):
 
     Attributes
     ----------
-    obj, project : object
+    obj, experiment : object
+
             File object to be opened and read in.
     header_lines : int
             Number of header lines in the file format being read.
@@ -34,7 +35,8 @@ def __init__(self, obj, header_lines, file_path):
                 Number of header lines in the given file format.
         """
 
-        self.project = obj  # Experiment class instance to add to.
+        self.experiment = obj  # Experiment class instance to add to.
+
         self.header_lines = header_lines  # Number of header lines in the given file format.
         self.file_path = file_path   # path to the file being read
 
diff --git a/mdsuite/file_io/flux_files.py b/mdsuite/file_io/flux_files.py
index 7ed916bd..4762aef7 100644
--- a/mdsuite/file_io/flux_files.py
+++ b/mdsuite/file_io/flux_files.py
@@ -49,22 +49,22 @@ def build_database_skeleton(self):
         #                    libver='latest')
         axis_names = ('x', 'y', 'z', 'xy', 'xz', 'yz', 'yx', 'zx', 'zy')
 
-        with hf.File(os.path.join(self.project.database_path, 'database_path.hdf5'), 'w', libver='latest') as database:
+        with hf.File(os.path.join(self.experiment.database_path, 'database_path.hdf5'), 'w', libver='latest') as database:
             # Build the database_path structure
             database.create_group('1')
-            for property_in, columns in self.project.property_groups.items():
+            for property_in, columns in self.experiment.property_groups.items():
                 if len(columns) == 1:
-                    database['1'].create_dataset(property_in, (self.project.number_of_configurations -
-                                                               self.project.number_of_configurations %
-                                                               self.project.batch_size,),
+                    database['1'].create_dataset(property_in, (self.experiment.number_of_configurations -
+                                                               self.experiment.number_of_configurations %
+                                                               self.experiment.batch_size,),
                                                  compression="gzip", compression_opts=9)
                 else:
                     n_cols = len(columns)
                     database['1'].create_group(property_in)
                     for axis in axis_names[0:n_cols]:
-                        database['1'][property_in].create_dataset(axis, (self.project.number_of_configurations -
-                                                                         self.project.number_of_configurations %
-                                                                         self.project.batch_size,),
+                        database['1'][property_in].create_dataset(axis, (self.experiment.number_of_configurations -
+                                                                         self.experiment.number_of_configurations %
+                                                                         self.experiment.batch_size,),
                                                                   compression="gzip", compression_opts=9)
 
     def fill_database(self, counter=0):
@@ -75,16 +75,17 @@ def fill_database(self, counter=0):
         counter
         """
         # loop range for the tensor_values.
-        loop_range = int((self.project.number_of_configurations - counter) / self.project.batch_size)
+        loop_range = int((self.experiment.number_of_configurations - counter) / self.experiment.batch_size)
         skip_header = 0
-        with hf.File(os.path.join(self.project.database_path, 'database_path.hdf5'), "r+") as database:
-            with open(self.project.trajectory_file) as f:
+        with hf.File(os.path.join(self.experiment.database_path, 'database_path.hdf5'), "r+") as database:
+            with open(self.experiment.trajectory_file) as f:
                 for _ in tqdm(range(loop_range), ncols=70):
                     if skip_header == 0:
-                        batch_data = self.read_configurations(self.project.batch_size, f,
+                        batch_data = self.read_configurations(self.experiment.batch_size, f,
                                                               skip=True)  # load the batch tensor_values
                     else:
-                        batch_data = self.read_configurations(self.project.batch_size,
+                        batch_data = self.read_configurations(self.experiment.batch_size,
+
                                                               f)  # load the batch tensor_values
                     self.process_configurations(batch_data, database, counter)  # process the trajectory
                     skip_header = 1  # turn off the header skip
@@ -143,7 +144,8 @@ def process_configurations(self, data, database, counter):
         """
         axis_names = ('x', 'y', 'z', 'xy', 'xz', 'yz')
         # Fill the database_path
-        for property_group, columns in self.project.property_groups.items():
+        for property_group, columns in self.experiment.property_groups.items():
+
             num_columns = len(columns)
             if num_columns == 1:
                 database['1'][property_group][counter:counter + len(data)] = data[:, columns[0]].astype(float)
diff --git a/mdsuite/file_io/lammps_flux_files.py b/mdsuite/file_io/lammps_flux_files.py
index 890a685e..e17fab40 100644
--- a/mdsuite/file_io/lammps_flux_files.py
+++ b/mdsuite/file_io/lammps_flux_files.py
@@ -41,7 +41,8 @@ def __init__(self, obj, header_lines=9, file_path=None, sort: bool = False):
         """
 
         super().__init__(obj, header_lines, file_path, sort=sort)  # fill the experiment class
-        self.project.flux = True
+        self.experiment.flux = True
+
 
     @staticmethod
     def _build_architecture(property_groups: dict, number_of_atoms: int,
@@ -122,7 +123,8 @@ def process_trajectory_file(self, update_class=True, rename_cols=None):
 
         # Find properties available for analysis
         column_dict_properties = self._get_column_properties(header_line)
-        self.project.property_groups = self._extract_properties(var_names, column_dict_properties)
+        self.experiment.property_groups = self._extract_properties(var_names, column_dict_properties)
+
 
         batch_size = optimize_batch_size(self.file_path, number_of_configurations)
 
@@ -136,36 +138,36 @@ def process_trajectory_file(self, update_class=True, rename_cols=None):
             time_1_line = f.readline().split()
             time_1 = float(time_1_line[column_dict_properties['time']])
 
-        sample_rate = (time_1 - time_0) / self.project.time_step
+        sample_rate = (time_1 - time_0) / self.experiment.time_step
 
         # Update class attributes with calculated tensor_values
-        self.project.batch_size = batch_size
+        self.experiment.batch_size = batch_size
         # self.properties = properties_summary
-        self.project.number_of_configurations = number_of_configurations
-        self.project.sample_rate = sample_rate
+        self.experiment.number_of_configurations = number_of_configurations
+        self.experiment.sample_rate = sample_rate
         self.time_0 = time_0
 
         # Get the number of atoms if not set in initialization
-        if self.project.number_of_atoms is None:
-            self.project.number_of_atoms = int(header[2][1])  # hopefully always in the same position
+        if self.experiment.number_of_atoms is None:
+            self.experiment.number_of_atoms = int(header[2][1])  # hopefully always in the same position
 
         # Get the volume, if not set in initialization
-        if self.project.volume is None:
+        if self.experiment.volume is None:
             print(float(header[4][7]))
-            self.project.volume = float(header[4][7])  # hopefully always in the same position
+            self.experiment.volume = float(header[4][7])  # hopefully always in the same position
 
-        self.project.species = {'1': []}
+        self.experiment.species = {'1': []}
 
         if update_class:
-            self.project.batch_size = batch_size
-            self.project.volume = self.project.volume
+            self.experiment.batch_size = batch_size
+            self.experiment.volume = self.experiment.volume
 
         else:
-            self.project.batch_size = batch_size
+            self.experiment.batch_size = batch_size
 
         line_length = self._get_line_length()
-        return self._build_architecture(self.project.property_groups,
-                                        self.project.number_of_atoms,
+        return self._build_architecture(self.experiment.property_groups,
+                                        self.experiment.number_of_atoms,
                                         number_of_configurations), line_length
 
     def build_file_structure(self):
@@ -175,9 +177,10 @@ def build_file_structure(self):
 
         structure = {}  # define initial dictionary
 
-        for observable in self.project.property_groups:
+        for observable in self.experiment.property_groups:
             path = join_path(observable, observable)
-            columns = self.project.property_groups[observable]
+            columns = self.experiment.property_groups[observable]
+
             structure[path] = {'indices': np.s_[:], 'columns': columns, 'length': 1}
 
         return structure
diff --git a/mdsuite/file_io/lammps_trajectory_files.py b/mdsuite/file_io/lammps_trajectory_files.py
index 2914ebd2..eb756ad8 100644
--- a/mdsuite/file_io/lammps_trajectory_files.py
+++ b/mdsuite/file_io/lammps_trajectory_files.py
@@ -226,17 +226,18 @@ def process_trajectory_file(self, update_class: bool = True, rename_cols: dict =
         species_summary, box, property_groups, line_length = self._get_species_information(number_of_atoms)
 
         if update_class:
-            self.project.batch_size = batch_size
-            self.project.dimensions = get_dimensionality(box)
-            self.project.box_array = box
-            self.project.volume = box[0] * box[1] * box[2]
-            self.project.species = species_summary
-            self.project.number_of_atoms = number_of_atoms
-            self.project.number_of_configurations += number_of_configurations
-            self.project.sample_rate = sample_rate
-            self.project.property_groups = property_groups
+            self.experiment.batch_size = batch_size
+            self.experiment.dimensions = get_dimensionality(box)
+            self.experiment.box_array = box
+            self.experiment.volume = box[0] * box[1] * box[2]
+            self.experiment.species = species_summary
+            self.experiment.number_of_atoms = number_of_atoms
+            self.experiment.number_of_configurations += number_of_configurations
+            self.experiment.sample_rate = sample_rate
+            self.experiment.property_groups = property_groups
 
         else:
-            self.project.batch_size = batch_size
+            self.experiment.batch_size = batch_size
+
 
         return self._build_architecture(species_summary, property_groups, number_of_configurations), line_length
diff --git a/mdsuite/file_io/trajectory_files.py b/mdsuite/file_io/trajectory_files.py
index 54e85766..9dab46a7 100644
--- a/mdsuite/file_io/trajectory_files.py
+++ b/mdsuite/file_io/trajectory_files.py
@@ -85,7 +85,8 @@ def read_configurations(self, number_of_configurations: int, file_object: TextIO
         """
 
         # Define the empty tensor_values array
-        configurations_data = np.empty((number_of_configurations*self.project.number_of_atoms, line_length),
+        configurations_data = np.empty((number_of_configurations * self.experiment.number_of_atoms, line_length),
+
                                        dtype='<U15')
 
         counter = 0
@@ -95,7 +96,8 @@ def read_configurations(self, number_of_configurations: int, file_object: TextIO
                 file_object.readline()
 
             # Read the tensor_values into the arrays.
-            for k in range(self.project.number_of_atoms):
+            for k in range(self.experiment.number_of_atoms):
+
                 configurations_data[counter] = np.array(list(file_object.readline().split()))
                 counter += 1  # update the counter
         return configurations_data
@@ -107,15 +109,16 @@ def build_file_structure(self, batch_size: int = None):
 
         structure = {}  # define initial dictionary
         if batch_size is None:
-            batch_size = self.project.batch_size
+            batch_size = self.experiment.batch_size
 
-        for item in self.project.species:
-            positions = np.array([np.array(self.project.species[item]['indices']) + i * self.project.number_of_atoms -
+        for item in self.experiment.species:
+            positions = np.array([np.array(self.experiment.species[item]['indices']) + i * self.experiment.number_of_atoms -
                                   self.header_lines for i in range(batch_size)]).flatten()
-            length = len(self.project.species[item]['indices'])
-            for observable in self.project.property_groups:
+            length = len(self.experiment.species[item]['indices'])
+            for observable in self.experiment.property_groups:
                 path = join_path(item, observable)
-                columns = self.project.property_groups[observable]
+                columns = self.experiment.property_groups[observable]
+
                 structure[path] = {'indices': positions, 'columns': columns, 'length': length}
 
         return structure
diff --git a/mdsuite/memory_management/memory_manager.py b/mdsuite/memory_management/memory_manager.py
index 5c1a750a..5a803815 100644
--- a/mdsuite/memory_management/memory_manager.py
+++ b/mdsuite/memory_management/memory_manager.py
@@ -40,8 +40,9 @@ def get_batch_size(self, system: bool = False) -> tuple:
         """
         Calculate the batch size of an operation.
 
-        This method takes the tensor_values requirements of an operation and returns how big each batch of tensor_values should be for
-        such an operation.
+        This method takes the tensor_values requirements of an operation and returns how big each batch of tensor_values
+        should be for such an operation.
+
 
         Parameters
         ----------
@@ -58,6 +59,7 @@ def get_batch_size(self, system: bool = False) -> tuple:
         if self.data_path is []:
             print("No tensor_values has been requested.")
             sys.exit(1)
+
         per_configuration_memory: float = 0
         for item in self.data_path:
             n_rows, n_columns, n_bytes = self.database.get_data_size(item, system=system)
@@ -65,7 +67,6 @@ def get_batch_size(self, system: bool = False) -> tuple:
         maximum_loaded_configurations = int(np.clip((self.memory_fraction*self.machine_properties['memory']) /
                                                     per_configuration_memory, 1, n_columns))
         batch_size = self._get_optimal_batch_size(maximum_loaded_configurations)
-        batch_size = 100
         number_of_batches = int(n_columns / batch_size)
         remainder = int(n_columns % batch_size)
 
@@ -107,7 +108,6 @@ def _get_optimal_batch_size(self, naive_size):
         """
         db_io_time = self.database.get_load_time()
 
-
         return naive_size
 
     def get_ensemble_loop(self, data_range: int, correlation_time: int = 1) -> int:
diff --git a/requirements.txt b/requirements.txt
index 945c9b46..e69de29b 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,1 +0,0 @@
-.
\ No newline at end of file
diff --git a/tutorials/scripts/emim/databases/py_vista_trial.ipynb b/tutorials/scripts/emim/databases/py_vista_trial.ipynb
new file mode 100644
index 00000000..f4bbcc6c
--- /dev/null
+++ b/tutorials/scripts/emim/databases/py_vista_trial.ipynb
@@ -0,0 +1,154 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import h5py as hf\n",
+    "import numpy as np\n",
+    "#import tensorflow as tf\n",
+    "import pyvista as pv\n",
+    "import pyvistaqt as pvqt\n",
+    "import time\n",
+    "from threading import Thread"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db = hf.File('database.hdf5', 'r')\n",
+    "data_C = np.array(db['C']['Positions'])\n",
+    "data_H = np.array(db['H']['Positions'])\n",
+    "data_N = np.array(db['N']['Positions'])\n",
+    "data_F = np.array(db['F']['Positions'])\n",
+    "db.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class TrajectoryVisualizer:\n",
+    "    \"\"\"\n",
+    "    Class for visualizing trajectories of atoms.\n",
+    "    \"\"\"\n",
+    "    def __init__(self):\n",
+    "        self.data_dictionary = {}\n",
+    "        \n",
+    "        self.plotter: pvqt.BackgroundPlotter\n",
+    "        \n",
+    "    def _prepare_canvas(self):\n",
+    "        \"\"\"\n",
+    "        Prepare the pyqt canvas.\n",
+    "        \"\"\"\n",
+    "        self.plotter = pvqt.BackgroundPlotter(notebook=True)\n",
+    "        #self.plotter = pv.Plotter()\n",
+    "        \n",
+    "    def _update_positions(self, start: int, stop: int):\n",
+    "        \"\"\"\n",
+    "        Update positions\n",
+    "        \"\"\"\n",
+    "        for item in self.data_dictionary:\n",
+    "            position_tensor = self.data_dictionary[item]['tensor'][:, stop]\n",
+    "            for i, sphere in enumerate(self.data_dictionary[item]['spheres']):\n",
+    "                self.plotter.update_coordinates(position_tensor[i], sphere)\n",
+    "        #self.plotter.update()\n",
+    "    \n",
+    "    def _construct_spheres(self):\n",
+    "        \"\"\"\n",
+    "        Construct the sphere objects\n",
+    "        \"\"\"\n",
+    "        for item in self.data_dictionary:\n",
+    "            self.data_dictionary[item]['spheres'] = []\n",
+    "            radius = self.data_dictionary[item]['mass']\n",
+    "            for atom in self.data_dictionary[item]['tensor']:\n",
+    "                self.data_dictionary[item]['spheres'].append(pv.Sphere(radius=radius, center=atom[0]))\n",
+    "    \n",
+    "    def _draw_spheres(self):\n",
+    "        \"\"\"\n",
+    "        draw the spheres on the canvas.\n",
+    "        \"\"\"\n",
+    "        for item in self.data_dictionary:\n",
+    "            colour = self.data_dictionary[item]['colour']\n",
+    "            for sphere in self.data_dictionary[item]['spheres']:\n",
+    "                self.plotter.add_mesh(sphere, lighting=False, show_edges=False, color=colour)\n",
+    "    \n",
+    "    def _loop_configurations(self, start=1):\n",
+    "        \"\"\"\n",
+    "        Loop over configurations until end or interrupted.\n",
+    "        \"\"\"\n",
+    "        if start == 0:\n",
+    "            start = 1\n",
+    "        species = list(self.data_dictionary)\n",
+    "        loop_range = int(len(self.data_dictionary[species[0]]['tensor'][start:]) - 1)\n",
+    "        for i in range(start, loop_range):\n",
+    "            self._update_positions(start=i-1, stop=i)\n",
+    "            \n",
+    "        \n",
+    "                \n",
+    "    def run_visualization(self):\n",
+    "        \"\"\"\n",
+    "        Run a visualization and hold open for inputs.\n",
+    "        \"\"\"\n",
+    "        self._prepare_canvas()\n",
+    "        self._construct_spheres()\n",
+    "        self._draw_spheres()\n",
+    "        thread = Thread(target=self._loop_configurations())\n",
+    "        thread.start()\n",
+    "        \n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vis = TrajectoryVisualizer()\n",
+    "vis.data_dictionary = {'C': {'tensor': data_C, 'mass': 1.0, 'colour': 'black'},\n",
+    "                       'N': {'tensor': data_N, 'mass': 0.7, 'colour': 'red'},\n",
+    "                       'H': {'tensor': data_H, 'mass': 0.2, 'colour': 'white'},\n",
+    "                       'F': {'tensor': data_F, 'mass': 0.5, 'colour': 'green'}\n",
+    "                      }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vis.run_visualization()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/tutorials/walkthrough_notebooks/MDSuite_Binary_Salt_Walkthrough.ipynb b/tutorials/walkthrough_notebooks/MDSuite_Binary_Salt_Walkthrough.ipynb
index 284438c8..7ffdb432 100644
--- a/tutorials/walkthrough_notebooks/MDSuite_Binary_Salt_Walkthrough.ipynb
+++ b/tutorials/walkthrough_notebooks/MDSuite_Binary_Salt_Walkthrough.ipynb
@@ -168,7 +168,8 @@
     {
      "data": {
       "text/plain": [
-       "{'NaCl_1400K': <mdsuite.experiment.experiment.Experiment at 0x148432567af0>}"
+       "{'NaCl_1400K': <mdsuite.experiment.experiment.Experiment at 0x14ae017bcac0>}"
+
       ]
      },
      "execution_count": 6,
@@ -193,11 +194,15 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0.) NaCl_1400K\n"
-     ]
+     "data": {
+      "text/plain": [
+       "'0.) NaCl_1400K'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+
     }
    ],
    "source": [
@@ -301,29 +306,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 17,
+
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "\r",
-      "  0%|                                           | 0/1 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'id': 0, 'type': 1, 'element': 2, 'x': 3, 'y': 4, 'z': 5, 'vx': 6, 'vy': 7, 'vz': 8}\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████| 1/1 [00:00<00:00,  6.66it/s]\n"
+      "100%|███████████████████████████████████| 1/1 [00:00<00:00, 11.97it/s]\n"
+
      ]
     }
    ],
@@ -333,22 +325,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 18,
+
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[13.1, 13.1, 13.1]"
+       "380"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 18,
+
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "NaCl_1400K.box_array"
+    "NaCl_1400K.number_of_configurations"
+
    ]
   },
   {
@@ -381,7 +376,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 20,
+
    "metadata": {
     "scrolled": false
    },
@@ -390,74 +386,14 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Batch Loop: 100%|█████████████████████████████████████████████████████| 1/1 [00:00<00:00,  2.60it/s]\n",
-      "Batch Loop: 100%|█████████████████████████████████████████████████████| 1/1 [00:00<00:00,  2.51it/s]\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiQAAAHCCAYAAADfBtJyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAMTQAADE0B0s6tTgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzde3zO9f/H8Yet5hva0MEpJL7kzOaQb0eFSSqFnHIaM2NzVqIDkXLKIRPRUal8Uw5zmEOTMTKnGaY11OSQYXbZzI6f3x+f39e3voaN67o+17bn/XZzu22Xz/X5vHa7pKfX+1QsPDzcQERERMRCblYXICIiIqJAIiIiIpZTIBERERHLKZCIiIiI5RRIRERExHIKJCIiImI5BRIRERGxnAKJiIiIWO42qwv4qy1btrB8+XLi4uJITU1l48aNuLu7O+RZLVu2zPX1efPmUbt2bYc8U0RERHLnUoEkPT0db29vfHx8WLRokUOftWzZsr99v3TpUsLDw6lVq5ZDnysiIiJXc6lA0rp1awD27duX6+/HxcUxb948YmNjKVOmDL6+vvTq1eumuihly5b92/eRkZG0bt0aNzeNYomIiDhbgfm/b3JyMqNHj6Z58+Z88sknjBkzhk2bNrF06dJbvndMTAzHjx/H19fXDpWKiIhIfhWYQLJ8+XIaNWpEt27dqFSpEo0aNaJPnz6Ehobe8r3DwsKoW7culStXtkOlIiIikl8uNWRzPceOHSMyMpKnn376yms5OTlkZWWRk5ODm5sbvXr14vjx49e8R+/evenTp8/fXktPT2fz5s0EBAQ4qnQRERG5gQITSNLS0mjZsiW9e/e+6vf+M+9j1qxZZGdnX/MeJUqUuOq1iIgIsrKyrrnqRkRERBwvT4HkZpbjbtq0iSVLlnD8+HE8PT3p1KkTXbt2velCq1evzu7du6lUqdI1r/nfiap5ERYWxsMPP0ypUqVuujYRERG5NXkKJPldjrt+/XpCQkIIDAykfv36pKamkpqaesP32Ww2zpw5w4kTJwCIj4/H3d2dSpUq0aFDB1atWsX06dPp0KEDHh4eHDlyhD/++IOePXvm5ce4SmJiInv27OHdd9+9qfeLiIiIfeQpkNxoOe5fZWVlMX/+fAIDA2nbtm2+iomMjGTKlClXvh84cCAAM2fOpFGjRsyePZv58+cTHByMm5sbVapUoUOHDvl6xl9t2LCBsmXL0qRJk5u+h4iIiNw6u88hiYuLIykpiezsbPr27UtqaiqNGzdm0KBBeHl5Xfe9bdu2vW6IeeCBB5g6dardau3evTvdu3e32/1ERETk5th92e/p06cBWLJkCQEBAbz55pskJCQwadIkez9KRERECgm7d0hycnIA6NmzJw899BAAI0eOxN/fnzNnznDvvffm+p5z585xxx13UKxYMXuXJCIiIg5gGAZpaWncddddt7zTud0DSZkyZQCoUqXKldf+8/W1Asm5c+d46aWX7F2KiIiIOMHSpUu55557bukedg8ktWrV4rbbbuPEiRPUqVMH4MqqmXLlyuX6njvuuAPgyhJhsdbYsWOZPHmy1WUI+ixciT4L16HPwnXYbDYqV6585f/jtyJPgeR6y3FTUlIYOXIkr732GrVr16ZUqVL4+vry6aefUq5cOUqWLMmcOXNo3rz5NdPTf4ZpPD09FUhcgIeHhz4HF6HPwnXos3Ad+ixcjz2mW+QpkFxvOW758uU5fvw46enpV34/ODiYkJAQxo0bh7u7O82aNSMoKOiWixUREZHCKU+B5EbLccPDw//2ffHixRkxYgQjRoy4terEEjr12HXos3Ad+ixchz6LwqnAnPYrzqP/2F2HPgvXoc/CdeizKJwUSERERMRyCiQiIiJiOQUSERERsZwCiYiIiFhOgUREREQsp0AiIiIillMgEREREcspkIiIiIjlFEhERETEcgokIiIiYjkFEhEREbGcAomIiIhYToFERERELKdAIiIiIpZTIBERERHLKZCIiIiI5RRIRERExHIKJCIiImI5BRIRERGxnAKJiIiIWE6BRERERCynQCIiIiKWUyARERERyymQiIiIiOUUSERERMRyCiQiIiKSb4YBS5bY73632e9WIiIiUhRcvgyBgbB6tf3uqQ6JiIiI5FlCAjz6KBw+DFu22O++CiQiIiKSJ5s3g48PeHubX1esaL97K5CIiIjIdRkGzJ4NzzwD77wDCxZA8eL2fYbmkIiIiMg1XboEAQGwaRNs3AgtWjjmOQokIiIikqvffoMXX4QSJWD3bqhQwXHP0pCNiIiIXGXTJmjSxOyI/PijY8MIKJCIiIjIXxgGzJgBzz0HU6dCSAh4eDj+uRqyEREREQBsNujXD3bsgPBwaNbMec9Wh0REREQ4cACaNoXkZNizx7lhBPIYSLZs2cKIESNo3749LVu2JDs7O083T01NpWvXrvl6j4iIiDjXV1+Zc0W6doW1a+Gee5xfQ54CSXp6Ot7e3nTr1i1fN58zZw5VqlS5qcJERETEsdLTYfBgCA6Gb7+FCRPA3d2aWvI0h6R169YA7Nu3L883joiIICEhgf79+xMVFXVz1YmIiIhDJCRA586QnW0O0dx/v7X1OGQOyfnz55k7dy5jxozB3aqoJSIiIrkKCzO3f2/cGLZutT6MgIMCyYwZM3jxxRepWrWqI24vIiIiNyEnB95+Gzp2hPffh/nz4R//sLoqk92X/a5du5bk5GQ6d+5s71uLiIjITTp7Fnr2hPh4iIyEBg2srujv7B5IoqOjiY2NvTLv5D/atGnDsGHDePbZZ6/53rFjx+Lx/7uv+Pr64uvra+/yREREipxt28wVNM2awa5d4OV18/cKCwsjLCwMgIyMDDtVCMXCw8ONvF68b98+hg8fzsaNG685NyQxMZGUlJQr3x8+fJipU6eycOFCypUrx5133nnVe1JTU2nfvj3Jycl4enrexI8hIiIi/ysnB6ZNM4dp3nsPgoKgWDH73d9ms+Hl5UVoaCglS5a8pXvlqUNis9k4c+YMJ06cACA+Ph53d3cqVapESkoKI0eO5LXXXqN27drcc8893POXBczJyckAVKtWTRNcRUREnOTsWejVCw4fhp9+Ms+lcWV5CiSRkZFMmTLlyvcDBw4EYObMmZQvX57jx4+Tnp7umApFREQkX7ZuNYdoHnrIXNJburTVFd1YvoZsHEVDNiIiIrcuJ8c8EG/iRJgyxdz0zJ5DNP/L6UM2IiIi4toSE80hmrg42LIFfHysrih/dLieiIhIARcRYW5yVrKkOURT0MIIKJCIiIgUWNnZMHkytG0Lr70G//73rS3ptZKGbERERAqg06fNjc5++83skHh7W13RrVGHREREpIDZsAEaNoR774Xduwt+GAEFEhERkQIjKwvGjoUXXoB334Uvv4TCsjhVQzYiIiIFQEICdOsGNhvs3Al16lhdkX2pQyIiIuLiVqyARo2gXj34+efCF0ZAHRIRERGXlZ4Oo0fD55/DRx9Bly5WV+Q4CiQiIiIuKD7eDCBububeItWrW12RY2nIRkRExMUsX24ehvfoo7BtW+EPI6AOiYiIiMvIzDRX0Xz0EXz8MXTqZHVFzqNAIiIi4gJOnjRP6E1KgqgoqFnT6oqcS0M2IiIiFtu82dzcrFo1cxVNUQsjoEAiIiJimZwceO89eOYZmDgRPvsMSpSwuipraMhGRETEAklJ0Ls3xMTAli0F84Ree1KHRERExMn27DEDiGH89+uiToFERETESQwDFi40l/P6+5s7sJYpY3VVrkFDNiIiIk6QlgaDBsGaNbBqFTz5pNUVuRYFEhEREQc7cgQ6doSSJc0hmkqVrK7I9WjIRkRExIFWrTJ3XX3iCXN5r8JI7tQhERERcYDsbHjzTfjgA3PeSGE7GM8wDFb9sspu91MgERERsbMzZ6B7dzhxAnbsgDp1rK7Ivo4mHWXwmsFEHY2y2z01ZCMiImJHO3aYu66WLQs7dxauMJKRncHkiMnU/7A+Vb2qsnvAbrvdWx0SEREROzAMCAmBV1+Fd96BoUOhWDGrq7Kfn377icDVgdzufjsbe26kReUW2Gw2u91fgUREROQWpaWZ+4r8+COEhcEjj1hdkf0kpiYyesNolsUuY/zj4xn60FBuc7N/fFAgERERuQUJCfDCC3DHHeaS3vLlra7IPnKMHD7d+ymvbHyFx6o+xsFBB6niVcVhz1MgERERuUlbtkCnTmYg+eAD8PCwuiL7OHDmAIGrA/n9wu98+vynPFfrOYc/U5NaRURE8skwYN48ePpp85TeBQsKRxhJy0xj7KaxNFvYjBb3teDQ4ENOCSOgDomIiEi+pKdDUBCsXFm45otsPLqRgaEDuavEXWzvt52G5Rs69fkKJCIiInl06pS5BXxGBuzaBZUrW13RrUtMTWTE+hGsOLyCyU9NJrBJIO5u7k6vQ0M2IiIiebBzp7kFfI0aEBFR8MOIYRh8uvdTHgx5kNSMVA4NPkRQsyBLwgioQyIiInJDn39untQ7aRIMG1bw9xeJOxdHQGgAv577lY+f+5gOD3awuiQFEhERkWvJzIRRo+DLL2HFCmjVyuqKbk16VjpTtk3hva3v0d+7Pyu6rsCzuKfVZQEKJCIiIrk6dQpeegkuXoSoKHjgAasrujVbE7YyYNUAPNw92NxnM80qNbO6pL/RHBIREZH/ERkJPj5w//3m1wU5jCSlJTFg1QDaftmWPo36EOUf5XJhBBRIRERErjAMmDsXWreGsWPhiy+gRAmrq7o5hmHwzYFvqB1Sm+O248QExvDKw69wu/vtVpeWqzwN2WzZsoXly5cTFxdHamoqGzduxN0991m4NpuNTz75hKioKM6ePcvdd9+Nr68vPXr0uOZ7RERErHbpEgQEwKZNsH49PPyw1RXdvGNJxxi0ZhB7Tu1hdtvZdKnbhWIuPhM3T4EkPT0db29vfHx8WLRo0XWvPXfuHBcuXCA4OJjKlSvz+++/M23aNAzDoHfv3nYpWkRExJ6OHoUXX4Q774Tdu6FCBasrujmZ2ZnM2jGLCT9NoHv97ix5cQll7ihjdVl5kqdA0rp1awD27dt3w2urVavG+PHjr3xfqVIlOnXqxE8//aRAIiIiLmftWujRA3r2hOnT4XbXHNG4oZ0ndjJg1QAysjNY9/I6HqlSsLaQdcockuTkZO68805nPEpERCRPcnLMc2g6d4Y5c2D27IIZRmzpNoasHcITnz1Bx9od2Ruwt8CFEXDCst+TJ0+yZs0aRowY4ehHiYiI5ElSEvTuDQcPwrZt0NC5x7bYhWEYLItdxtB1Q6l1Vy32DdxHzbtqWl3WTXNoIElKSmLMmDE8+eSTPPnkk458lIiISJ7s22eeR1O7tnkeTZmCMcXib44lHSNobRBRJ6J43/d9etTv4fKTVm/EYYEkOTmZUaNGUatWLYYNG5an94wdOxaP/z+/2dfXF19fX0eVJyIiRdBnn5kn9Y4ZYy7rdStgm19kZmcyY/sMJm2ZRPf63VkctJiyd5R1ag1hYWGEhYUBkJGRYbf7OiSQXLx4kdGjR1OhQgXGjBmDWx4/8cmTJ+Pp6Rpb2IqISOFx+TIMGQLff2/+atPG6oryb2vCVgaGDqRYsWKs77mef1X+lyV1/LVhYLPZCAkJsct985QUbDYb8fHxnDhxAoD4+Hji4+NJS0sjMTGRXr16ERsbC0BqaiqvvPIK7u7uBAcHk5yczPnz57lw4YJdChYREcmP336DRx4xh2r27Cl4YeTcpXP0X9mftl+2pVfDXuwZsMeyMOJIeeqQREZGMmXKlCvfDxw4EICZM2dSvnx5jh8/Tnp6OgC//vorhw8fBqBr165X3lOuXDm++eYbuxUuIiJyI+vWmUt6u3SBmTOheHGrK8o7wzBYvH8xI9eP5KH7HuLAoAPcX/p+q8tymGLh4eGG1UWkpqbSvn17kpOTNWQjIiK37D9LeqdNgw8/NPcYKUjizsUxMHQgcefimPP0HF548AWXnLRqs9nw8vIiNDSUkiVL3tK9dNqviIgUKufOwcsvQ3y8eTBegwZWV5R36VnpTNk2hfe2voe/tz/Luy7Hs3jR+Ie6AomIiBQaO3fCSy9B48bmkl4vL6sryruI3yMICA3Aw92Dn/r8RNNKTa0uyakK2IInERGRqxkGzJoFLVvC4MHmSpqCEkaS0pLwX+nP0189jV9jP3YN2FXkwgioQyIiIgVcUhL4+ZkdkQ0b4F8FZAGKYRh8c+AbhoUNw6eCT6GftHojCiQiIlJgRUWZQzR16pjLeu+6y+qK8uZY0jECVwey7/Q+5rSdw0t1X3LJSavOpCEbEREpcAwDPvgAnngCAgNh1aqCEUYyszOZum0q9T6sR1WvqsQOjqVLvS5FPoyAOiQiIlLAJCdDv36wYweEhZmbnhUEUSei8F/lT0Z2But6rOPRqo9aXZJLUYdEREQKjN27wdsbUlPNIZqCEEYupl9k6NqhPP7Z43Ss3ZG9AXsVRnKhQCIiIi7PMCAkBB57DPz9YfVquPtuq6u6sZW/rKTOvDpE/xnN3oC9vPH4GxS/rQBtF+tEGrIRERGXdvYs9O9vTmBdtw4eLQDNhZMXTxK8NpjwY+FMbzOdvo36ap7IDahDIiIiLmvjRnOnVTc32L/f9cNIjpHDh1EfUjukNv+47R8cDjqMX2M/hZE8UIdERERcTkYGjBtnnkPz/vvmMI2r/z/94JmD+K/y53TKaZZ2WopvDV+rSypQFEhERMSlHD4M3bubX+/aBQ8+aG09N5Kelc67W99l6rapBDULYvwT4ylxewmryypwFEhERMQlGAYsWgTDh5t7i0yaBMVdfP7njj920G9lPzzcPdjqtxXvCt5Wl1RgKZCIiIjlzp0zh2V27IAffoDWra2u6PpSMlJ4/cfXWbhnIa8/+jqj/jWK291vt7qsAk2BRERELPXjj9CrF/j4mBNXXX057/oj6wkIDaCyZ2X2DNhDrbtrWV1SoaBAIiIilsjMhDffNLeAnz4dAgJce+Lq+bTzjAgbwfex3zO19VQG+AzArZgWq9qLAomIiDjdkSPQrRukp8POnebheK7KMAy+O/QdQWuDaFqxKQcHHaSyV2Wryyp0FO1ERMSpFi+Gxo2hRQv4+WfXDiOnU07TcWlHBq0ZxCzfWazqtkphxEHUIREREaew2WDQIPNAvK+/hmeesbqiazMMg69ivmLouqH4VvcldnAsd5dw8cktBZwCiYiIONyOHebeIjVqmBNXK1SwuqJrO3nxJAGhAUSdiOLj5z6mw4MdrC6pSNCQjYiIOEx2NkyeDE89ZXZH1q1z3TBiGAaf7/ucuvPqUvofpTk0+JDCiBOpQyIiIg7xxx/QsyecOAFbtpjLel3VH7Y/GLBqANF/RrP4hcW0r9ne6pKKHHVIRETE7n74ARo2hGrVYM8e1w0jhmHw8Z6PqTuvLuVKleNA4AGFEYuoQyIiInaTkgLDhsGyZTB/PnTpYnVF15aQnID/Kn8OnjnINx2/4el/Pm11SUWaOiQiImIXO3eay3mPHDEnrrpqGMkxcpi/az715tWjsmdlDg46qDDiAtQhERGRW5KVBe++a/4aPx5GjgR3d6uryt2R80fov6o/x5KOseylZbSu7uKH5hQhCiQiInLTjh0zJ66ePQtbt4K3ix52m52TzZyf5/BG+Bv0bdSXVd1WUcqjlNVlyV8okIiISL4ZBnz5JQQFQY8e5lk0JUpYXVXuYhNj8Vvpx9lLZ1nTYw2PVX3M6pIkF5pDIiIi+ZKUZJ5DM3IkfPUVzJvnmmEkMzuTdyPepcnCJjxS+RGiB0YrjLgwdUhERCTPfvrJHKKpXx9iYqBcOasryl306Wj8VvpxOesyP/b6keb3Nbe6JLkBdUhEROSGMjNh3Dho1w5efRVCQ10zjGRkZ/BW+Fu0+LgF7Wq0Y8+APQojBYQ6JCIicl3x8eY8kbQ0c2lv3bpWV5S7qBNR+K30w72YO9v8ttG4QmOrS5J8UIdERERyZRjw+efmypkWLVw3jKRlpjFm4xge/+xxutTtQpR/lMJIAaQOiYiIXOXCBRg4EMLD4dtv4WkX3Tcs8ngkfiv88CzuSZR/FHXvdcHEJHmiDomIiPxNRIR5Do3NZu646ophJDUjlWHrhtF6cWv6e/cnsl+kwkgBpw6JiIgA5o6rb78NM2bAe++Ze4wUK2Z1VVcLPxZO/1X9qXhnRfYG7KXmXTWtLknsIE+BZMuWLSxfvpy4uDhSU1PZuHEj7tfZFzgtLY05c+awZcsWbrvtNtq0acPAgQOv+x4REbHO0aPmxFWbDbZvhwYNrK7oarZ0G69ueJUvY75k8pOTGdxsMG7F1OgvLPL0Saanp+Pt7U23bt3ydNNZs2Zx6NAhpk2bxltvvUV4eDiff/75LRUqIiL2ZxiwcKE5ROPjA7t2uWYYWR23mnrz6hF3Po7ogdEENw9WGClk8tQhad3aPHxo3759N7z24sWLbNy4kSlTplCnTh0A/Pz8WLBgAb1791aXRETERZw6Bf37w7598N134OtrdUVXO3XxFEPXDWXD0Q1MbTWV/t79KeaK40hyy+weL+Pi4gBo1KjRlde8vb2x2WycOHHC3o8TEZGbsHQp1KsHZcrAgQOuF0ZyjBwW7FpA7ZDauLu5Ezs4Fn8ff4WRQszuk1qTkpIoVaoUt93231uXLl0agAsXLlClShV7P1JERPLo/Hlzsur69TB/PnTubHVFVzt45iABoQGcuHiCbzp9Q9saba0uSZzA7h0SwzCuek2JVkTEemFh5hk0Fy+aXRFXCyOXsy7zxo9v0HRhU1rc14IDgQcURooQu3dIypYtS0pKCllZWVe6JElJScB/OyXXMnbsWDw8PADw9fXF19V6iCIiBVBKCowebZ7MO3Mm+Pm53nLe8GPhBIQG4PUPLyL7RdKofKMbv0ksERYWRlhYGAAZGRl2u6/dA8k///lPAKKjo/Hx8QFg7969eHp6UqlSpeu+d/LkyXh6etq7JBGRImvbNujdGypVguhoqFbN6or+7uyls4zeMJrvDn3HpJaTCGoWhLubFj+4sr82DGw2GyEhIXa5b56GbGw2G/Hx8VcmpcbHxxMfH09aWhqJiYn06tWL2NhYADw9PXnqqaf44IMPiI2NZe/evXzyySc8//zzWmEjIuIkaWkwciS0aQOBgeYW8K4URgzD4LN9n/Hg3Ac5n3aeQ4MOMfShoQojRVieOiSRkZFMmTLlyvcDBw4EYObMmZQvX57jx4+Tnp5+5feHDx/O7NmzGTVqFO7u7rRp04bevXvbuXQREclNZCT07Qtly8Lu3fDgg1ZX9HexibEMXD2Qo0lHWfTcIjo82MHqksQFFAsPD796FqqTpaam0r59e5KTkzVkIyJyk9LS4PXXzdUz48fDiBHgSo3ptMw03ol4h/e3v8/AJgOZ8MQE7ix+p9VlyS2w2Wx4eXkRGhpKyZIlb+leOstGRKQQ2L4d+vQx9xVxxa7I+iPrGbR6EHeVuIttfttoXKGx1SWJi9G+uyIiBVhamrmCplUr6NfPnMTqSmHkdMppui3rRud/d2ZEixFE+kUqjEiu1CERESmgtm8354p4eZln0NSubXVF/5Wdk82C3QsYu2ksbWu05fDgw1S4s4LVZYkLUyARESlgLl+GN9+EkBB46y1zrshtLvS3+f4/9zNg1QASLyXybadv8a2hPaXkxlzoj7CIiNxIVJS5r0ipUubX/3+GqUu4lHmJCZsn8MHODxjafChvPP4GJW4vYXVZUkAokIiIFAAZGTBxIsyYYa6keeUV1+qKhMWHEbg6kPKlyvNz/5+pX66+1SVJAeNCf5xFRCQ3+/dDr17m19u3Q8OG1tbzV3+m/MnwsOGs/nU17z31HgFNAnArpvUSkn/6UyMi4qKysuCdd+Chh+DZZ2HnTtcJIzlGDgt3L+TBkAfJysni8ODDBDYNVBiRm6YOiYiIC4qNNeeKpKTATz9B06ZWV/RfhxIPERAaQEJyAotfWEz7mu2tLkkKAUVZEREXkp1tzhNp0gQefxz27HGdMHI56zJvhr9Jk4+a0LxScw4OOqgwInajDomIiIs4etTsipw6BWFh8MgjVlf0XxG/R+C/yp+SHiXZ6rcV7wreVpckhYw6JCIiFjMM+PhjaNQI6teH6GjXCSMXLl8gYFUAT3/1NP7e/vzc/2eFEXEIdUhERCx05gz4+5sTVpcuhbZtra7ov76P/Z6gNUHUu7ce+wP380CZB6wuSQoxBRIREYusXAn9+5tzRQ4cgLvusroi0wnbCYLWBhHxewQzfWfycoOXKVasmNVlSSGnIRsRESe7eNEMIr16wfvvm50RVwgjOUYOH0Z9SJ15dSjlUYrYwbH0bNhTYUScQh0SEREn2rrVDCL3329ueFalitUVmWITY/Ff5c+JiydY2mmpzp8Rp1OHRETECTIy4LXXwNcXgoNh40bXCCPpWemM3zwen498aF6pOQcCDyiMiCXUIRERcbCDB+Hll83VND//DPXqWV2RKeL3CAaEDuCO2+4gom8EPhV9rC5JijB1SEREHCQnB+bMgWbNzM7Izp2uEUb+upS3X+N+7PTfqTAillOHRETEAU6ehL594ZdfYO1aeOwxqysCwzBYFruM4LXBNCjXgJjAGKqVqWZ1WSKAOiQiIna3bJm5wVm5cuYmZ64QRo4nH6fDtx0IXB3I9NbTWddjncKIuBQFEhERO7HZzK5I//4wbx588QV4eVlbU3ZONnN3zqXuvLqU+UcZYgfH0qNBDy3lFZejIRsRETvYtg169oQHHoCYGLjvPqsrgujT0QSEBpB4KZHvu3xPqwdaWV2SyDWpQyIicgsyM+GNN6BNG3M57/r11oeRlIwURoaNpMXHLXiq2lPEBMYojIjLU4dEROQm/fKLuZw3PR127DDnjVjJMAxW/LKC4LXBPFDmAXYN2EWde+pYW5RIHqlDIiKST4YBH34IPj7mhNWdO60PI79f+J3nv3me/iv7M7HlRDb33qwwIgWKOiQiIvnw55/Qr5+5emblSnjySWvryczOZNaOWUz4aQJd6nbhl6BfuKuECxyMI5JPCiQiInn0n9N5n3rKPIemTBlr64k8HsnA0IFkG9ms7YYey7cAACAASURBVLGWR6s+am1BIrdAQzYiIjeQkgIDBpiH4s2aBV9/bW0YOZ92ngGrBtB6cWu61+/O3oC9CiNS4KlDIiJyHTt2mMt5K1Wy/nRewzD4IvoLRm0YRbNKzTgQeECbm0mhoUAiIpKLrCyYNAmmTYPx42HECHB3t66eg2cOMmjNII4mHWVB+wW88OAL2txMChUFEhGR/xEXZw7PXLxobnjWqJF1taRmpDJxy0Rm/zybwU0Hs7r7akp5lLKuIBEH0RwSEZH/l5MDs2eDtze0aAG7dlkbRlb+spK68+qy5fct/Nz/Z6a3ma4wIoWWOiQiIsDRo+Y5NMePw5o11h6Il5CcwJC1Q4hIiGBKqyn4NfbDrZj+/SiFm/6Ei0iRlpNjHoTXsCHUq2dOXLUqjGRmZzJ121TqhNSh7B1lOTz4MP29+yuMSJGgDomIFFm//25ucvbrr/DDD9DKwuNefvrtJwatGUQximlPESmSFLtFpMgxDFi0yNzuvVo183Req8LI6ZTT9PyhJ+2/bo9fIz/tKSJFVr46JEuWLOH7778nJSUFHx8fRo4cSdmyZXO99tixY8ybN4/Y2Fjc3d1p2LAhgwcPply5cnYpXETkZvzxh7nb6oEDsHQptG1rTR1ZOVl8GPUhb4S/QZvqbYgdHMt9nhYfEyxioTx3SNauXcvixYsZMmQIc+fOJTU1lQkTJlzz+tdff51SpUoxb948ZsyYQUpKCpMmTbJL0SIi+WUYsHixOU+kfHkzkFgVRnb8sYOmC5vywc4PWNp5KUs7L1UYkSIvz4Hkhx9+oGPHjjz22GPUqFGDV155hf379xMfH3/VtRcuXODkyZP06NGDKlWqUKNGDTp16kRcXJxdixcRyYvz56FLFxg5Er74Aj77DEqXdn4dZy+dpf/K/jz1xVN0qt2JmMAY2lRv4/xCRFxQngJJRkYGR44coXHjxldeq1ixIuXLl+fQoUNXXe/p6cl9993H+vXrycjIIC0tjU2bNtGkSRP7VS4ikgcbN5pzRdLSzLkizz3n/BpyjBwW7VlErbm1OJN6hgOBBxj32DiK31bc+cWIuKg8zSGx2Wzk5ORQ5n9OkypdujQXLly46no3NzemTZvG2LFjWbZsGYZhUKtWLaZNm2afqkVEbuDyZXjtNVi4EN5/H/z9wYqd1mMTYxkQOoDjycf57PnPeLbWs84vQqQAyFOHxDCMfN00JyeHWbNmUbVqVUJCQpg9ezYlSpTQHBIRcYroaGjSBCIjYc8e86ReZ4eR9Kx0xm8ej89HPjSv1JyDgw4qjIhcR546JF5eXri5uZGUlPS31y9cuEDpXAZi9+7dy969e1m1ahUeHh4AvPbaa3Tu3JmjR4/ywAMP5PqcsWPHXrne19cXX1/ffP0wIlK0ZWeb3ZC33oJXXoFx4+D2251fx5bftzBg1QBKepRkq99WvCt4O78IEQcJCwsjLCwMMKd02EueAomHhwfVq1dn3759+Pj4AHDq1ClOnz5NnTp1rrr+8uXLFCtWDDe3/zZg/vN1Tk7ONZ8zefJkPD098/UDiIiAuclZ797mst4ff4SHHnJ+DUlpSby68VWWxCzh7ZZvM6T5EG5z0/6TUrj8tWFgs9kICQmxy33zvMqmQ4cOLFu2jIiICOLj45k2bRoNGjSgRo0aJCYm0qtXL2JjYwGoW7cut99+OzNmzCAhIYEjR44wffp0KlasSNWqVe1SuIgImMt5v/zS3Pq9Zk3Yt8/5YcQwDJYeXErtkNoctx0nJjCGES1GKIyI5EOe/2tp164dSUlJzJo168rGaKNGjQIgOzub48ePk56eDpiTXd977z0++ugjBg0ahLu7O3Xq1OHdd9/ldiv6pyJSKJ07B4GBsHkzfP45PP+882tISE5g0OpB7Dyxk9ltZ9O1XleKWTF7VqSAKxYeHp6/GasOkJqaSvv27UlOTtaQjYjkybp14OcHTZuaK2nuvde5z8/OyeaDnR/wRvgbvFTnJaa1mUbZO3LfuVqksLLZbHh5eREaGkrJkiVv6V7qJ4pIgZKaak5YXbwYZs2Cvn2dv4Jmz6k9DFg1gIsZF1nVbRVP3P+EcwsQKYR0uJ6IFBg//wyNG8P+/eZcET8/54aRlIwURoSN4JFPHuGZfz5D9MBohRERO1EgERGXl5kJ48dDy5bQr585Z+Qauwc4TGhcKHXn1WXXyV3sHrCbCS0n8I/b/uHcIkQKMQ3ZiIhLO3wYevY0d16NjIRGjZz7/JMXTzJ03VA2Ht3ItNbT8Gvsh1sx/VtOxN70X5WIuKScHJg719xx9fHHISrKuWEkx8jhw6gPqR1Sm9vdbufw4MP09+6vMCLiIOqQiIjL+f13c37IkSMQGgpPPOHc5+//cz8DQwdyOuU033b6lrY12jq3AJEiSFFfRFyGYcAnn0CDBlC9ujl51ZlhJPlyMsPWDaP5ouY8WuVRDgw6oDAi4iTqkIiISzh50jyRd98++OYbePpp5z3bMAy+ivmKUetHUffeuuwZsIfa99R2XgEiokAiItYyDPj6awgKgmeegQMHoEwZ5z3/wJkDDF4zmPjz8cxuO5uX6r6knVZFLKBAIiKWSUw0t37fsgU+/hheeMF5z7al25iweQLzds0jqGkQod1CubP4nc4rQET+RoFERCyxfDkMGACPPgoHD8I99zjnuYZh8M2Bbxi5fiS17q7FLv9d1L23rnMeLiLXpEAiIk514QIMGWKunpk7F7p1c95uq4cSDxG0JojDZw8zo80MHYQn4kK0ykZEnGbjRqhf3xyqiYmB7t2dE0aSLyczfN1wfD7yoVH5RhwOOky3+t0URkRciDokIuJwly7BmDHw6acwfbo5VOOMLJBj5PD5vs8Zs2kM9e+tz+4Bu6lzTx3HP1hE8k2BREQcKirK3Pq9bFnYuxdq1HDSc09EEbw2mFMpp5jXbh4v1n5RHRERF6YhGxFxiMxMeOstc9v33r0hIsI5YeRM6hn6r+zP4589jm91X2IHx9KxTkeFEREXpw6JiNhdbKzZFUlPd96BeFk5WcyLmseb4W/SslpLDg46SLUy1Rz/YBGxCwUSEbGbnByYMwfGjTM3Onv7bShe3PHPDT8WzpB1Q8jIzuDbTt/iW8PX8Q8VEbtSIBERu/j9d+jbF377DdatM/cXcbRjSccYvWE064+s543H3mDoQ0PxcPdw/INFxO40h0REbolhmLus1q9vHogXHe34MJKakcrrP75O3Xl18SruRVxwHKMfHq0wIlKAqUMiIjft1ClzCe/u3eaBeO3aOfZ5hmGwJGYJr258laqlq7Kl7xaaVGzi2IeKiFMokIjITVm61DyHxtfXPBCvbFnHPm/XyV0MWTuEhOQEpraeSrd62thMpDBRIBGRfDl3zpywumEDzJ8PnTs79nmnU04zdtNY8/yZFiMZ88gYSnqUdOxDRcTpNIdERPJszRqoVw9SU82uiCPDSHpWOlO3TaXmBzW5mHGRQ4MPMfHJiQojIoWUOiQickM2G4wcaQ7TzJ5tbnTmqNESwzD4PvZ7Rm8YjWdxT1Z0XUHLai0d8zARcRkKJCJyXT/+CH5+5gqamBioUsVxz9pzag/Dw4bzy9lfeOfJd+jTqA/ubu6Oe6CIuAwN2YhIri5eNCetPv88jB5tzhlxVBg5efEkfVf05ZFPHuHhyg/za/Cv9PPupzAiUoSoQyIiV9m4Efr1M7si+/dDNQftwJ6WmcaM7TOYsm0K7f7ZjkODD3F/6fsd8zARcWkKJCJyhc0Go0aZe4pMnWruMeLmgD6qYRh8e/BbXt34KveWvJe1PdbySJVH7P8gESkwFEhEBICwMPD3h1q1zLkiVas65jlRJ6IYum4ovyf/zrtPvcvLDV7GrZhGj0WKOv0tIFLEJSdD//7w0kvwxhuwfr1jwsipi6fou6Ivj3/2OK0eaEVcUBy9GvZSGBERQB0SkSJtzRpzWKZuXcetoLmcdZlZO2bxTsQ7tPtnO2IHx1K1tIPaLyJSYCmQiBRBKSkwYgR8+y3MnGme0mvvfUUMw2D54eWM2jAKz+KerO6+mseqPmbfh4hIoaFAIlLEbN8OL79sdkMc1RWJ+TOGYWHDiPkzhneefAe/xn5awisi16XBW5EiIjPTnCPSqhUMGgSbNtk/jJy9dJZBqwfRbFEzGpdvzK/Bv+Lv468wIiI3pA6JSBFw+LDZFcnIgB07oH59+94/IzuDkJ0hvL3lbR6p8gjRA6OpeVdN+z5ERAo1BRKRQswwICQExowxd12dNAmKF7fn/Q1Wxa1i1PpR3O5+O990/AbfGr72e4CIFBn5CiRLlizh+++/JyUlBR8fH0aOHEnZsmWvef2mTZtYsmQJx48fx9PTk06dOtG1a9dbLlpEbuzkSXOy6uHDEBoKTzxh3/vv/3M/w8OGs//P/bz9xNv4+/hzm5v+jSMiNyfPc0jWrl3L4sWLGTJkCHPnziU1NZUJEyZc8/r169czZ84cOnfuzKeffsrkyZOpVauWXYoWkev77jtzWKZcOXPrd3uGkT9T/mTAqgE0X9Qc7/Le/Br8K4FNAxVGROSW5PlvkB9++IGOHTvy2GPmsr1XXnmFHj16EB8fT40aNf52bVZWFvPnzycwMJC2bdvat2IRuaYLFyA4GFavhgULoHNn+937ctZlZu+YzTsR79DqgVbEBMZQo2yNG79RRCQP8hRIMjIyOHLkCAEBAVdeq1ixIuXLl+fQoUNXBZK4uDiSkpLIzs6mb9++pKam0rhxYwYNGoSXl5d9fwIRAcwD8fr2NTsjBw5AxYr2ua9hGHx36Dte2fgKZf5RhpXdVvLE/U/Y5+YiIv8vT0M2NpuNnJwcypQp87fXS5cuzYULF666/vTp04A55yQgIIA333yThIQEJk2aZIeSReSvLl2CIUPghRfg9dfN7oi9wsj249t5+JOHGbJuCG8+9iZR/lEKIyLiEHnqkBiGka+b5uTkANCzZ08eeughAEaOHIm/vz9nzpzh3nvvzWeZIpKbnTuhZ0+4+27Yuxdq2GkE5cj5I7y26TXW/LqG0f8azch/jaSURyn73FxEJBd5CiReXl64ubmRlJT0t9cvXLhA6dKlr7r+P52UKn/Zdek/X18vkIwdOxYPDw8AfH198fXV8kGR3GRmwsSJMH06vPkmjB4N7nbYe+x82nkmbZnEh7s+pEf9HsQFx1HxTju1W0SkUAgLCyMsLAwwp3TYS54CiYeHB9WrV2ffvn34+PgAcOrUKU6fPk2dOnWuur5WrVrcdtttnDhx4srvnzhxAoBy5cpd8zmTJ0/G09Mz3z+ESFFy6JDZFcnMNLeBb9jw1u+ZnpXOvKh5TNwykWaVmvFz/59pUK7Brd9YRAqdvzYMbDYbISEhdrlvnpf9dujQgWXLlhEREUF8fDzTpk2jQYMG1KhRg8TERHr16kVsbCwApUqVwtfXl08//ZT9+/dz5MgRZs2aRfPmzbnnnnvsUrhIUZOTYx6E17Spuf17VNSthxHDMPj3wX9TZ14dPt33KV93/Jp1L69TGBERp8vzst927dqRlJTErFmzrmyMNmrUKACys7M5fvw46enpV64PDg4mJCSEcePG4e7uTrNmzQgKCrL/TyBSBPz2G/TpAwkJEBYGjzxy6/f8+Y+fGR42nN8u/MakJyfRu2FvnTkjIpYpFh4enr8Zqw6QmppK+/btSU5O1pCNyF8YBnzyCQwfDt27m3NGSt3i3NKTF0/y2qbX+O7Qd4xqMYrRD4/WhFURuSk2mw0vLy9CQ0MpWbLkLd1LWyuKuKhTp8Df31w9s3Qp3Ooeg5ezLjNz+0wmb53MM/98htjBsVTxsvNxvyIiN0mBRMQFLV1qHobn6wsxMXCdI6NuyDAMVvyygpHrR+JV3Is13dfwaNVH7VesiIgdKJCIuJDz52HwYNiwAebPv/Wt3w+cOcCwdcPY/+d+Jj81mb6N+mqeiIi4pDyvshERx1q7FurVg5QUc+v3Wwkj59POE7QmiKYLm9KofCN+Df6V/t79FUZExGWpQyJisZQUGDkSvvnGXNbbty8UK3Zz98rKyWL+rvm8tfktWtzXgn0B+6h1t07ZFhHXp0AiYqGtW6F3b6hSBaKj4f77b/5e64+sZ3jYcLJzsvnyhS95+p9P261OERFH05CNiAXS0+HVV81Jq8HBsGnTzYeRuHNxPPv1s3T5rgsDvAcQExijMCIiBY46JCJOFh1tbv3u4WHutprL6Qt5cuHyBSb+NJF5u+bRt1Fffg3+lbtL3G3fYkVEnEQdEhEnyc6G996Df/0LXnzRPIfmZsJIdk42C3YtoOYHNYn+M5qd/Xcy75l5CiMiUqCpQyLiBPHx5lyRc+dg82bzPJqbsfm3zQxbN4yUjBQWPruQ52o9R7GbnQErIuJC1CERcSDDMPcTadwYmjSBPXtuLowcTTpKx6Udee7r5+hevzsHBx3k+QefVxgRkUJDHRIRBzl5Evr1M/cUWb4cnnoq//e4mH6RyRGTmf3zbLrV60ZccBzlS5W3f7EiIhZTIBGxM8OAL7+EIUPg2WfNrd9Ll87fPXKMHL6I/oLXNr1GjbI12Oq3Fe8K3o4pWETEBSiQiNjRqVMQEAA7d8Jnn8Hzz+f/HtsStjEsbBhnUs8wu+1sOtfprKEZESn0NIdExA4MA776CurWhTvvhIMH8x9GEpIT6LasG75f+vJ8rec5PPgwL9V9SWFERIoEdUhEbtGff8LAgRAZCR9/DC+8kL/3X8q8xNRtU5kWOY2OtTvyS9AvVPKs5JhiRURclAKJyE0yDPj2WwgKglatzK7I3fnYCsQwDJbFLmNE2Agq3lmRH3v9SPP7mjuuYBERF6ZAInITzpyBwEDYssVc1tupU/7eH5sYS/DaYGLOxDC11VR6NuyJWzGNoIpI0aW/AUXywTBg6VJzroi7Oxw6lL8wYku3MWr9KLw/8qb+vfWJC4qjd6PeCiMiUuSpQyKSR3/8AYMHm3NF5s6FLl3y/l7DMFgSs4TRG0ZT866aRPlHUe/eeo4rVkSkgFEgEbmBnBxYsADGjIEOHSA2Nn9zRaJPRxO0NohjSceY6TtTK2dERHKhQCJyHYcPQ//+cOIE/Pvf0KZN3t+blJbEm+FvsmjvIoY2H8raHmsp5VHKccWKiBRgGrgWyUVGBkycCN7e0Ly5uf17XsNIdk42C3cvpObcmsSdj2NfwD7ea/WewoiIyHWoQyLyP3bsMLsi7u7w00/5Owxv+/HtBK8N5nzaeRY9u0in8YqI5JE6JCL/LyUFhg0zD8Hr0QN27cp7GDmdcprey3vTanErnq/1vE7jFRHJJ3VIRICNG82uSNWqsHcv1KyZt/dlZGfwwc8fMOGnCbSt0ZbYwbFU8ari2GJFRAohBRIp0mw2GD0avv4apkwxD8Zzy2PfcP2R9QxdNxT3Yu4s77qcJ6s96dhiRUQKMQUSKbI2bDC7IjVqwP79cP/9eXvfsaRjjFg/gvBj4bzd8m0CmwRyu/vtDq1VRKSw0xwSKXJsNhgwADp2hLFjzeGavISRtMw0xm8eT70P63HXHXcRFxzHkOZDFEZEROxAHRIpUtavN7siNWvmvStiGAar4lYxbN0w7ipxF+G9w2lWqZnDaxURKUoUSKRISE6GUaPM03mnTTM7JHlZAPPruV8Zum4oO0/s5N2n3sWvsR/ubu6OL1hEpIjRkI0UemFhUK8e/PYbxMSYE1dvFEZSM1IZt2kcDec35P7S9xMXHIe/j7/CiIiIg6hDIoXWhQswcqS55fv06eDvf+MgYhgG38d+z/Cw4VTyrMRWv614V/B2TsEiIkWYAokUSqtXm52QunXNbd+r5GFrkMNnDxO8Npjo09FMbT2VXg174VZMTUQREWfQ37ZSqCQlQe/e5k6rb78N69bdOIykZqQyZuMYGi9oTO27axMXHEefRn0URkREnEgdEik0Vq40uyLe3mZX5L77rn/9X4dnKntVZke/HTQs39A5xYqIyN8okEiBd+4cDBkCa9bA7NnQs+eN54r8eu5XgtcGs+fUHg3PiIi4gHz9DbxkyRI6depE27ZtGTduHOfPn7/he1JTU+natSstW7YkOzv7pgsVyc3330OdOubBeAcPQq9e1w8jlzIv8caPb9BwfkOql6nOL0G/aHhGRMQF5Plv4bVr17J48WKGDBnC3LlzSU1NZcKECTd835w5c6iSlxmFIvmQmAhdu5orZ2bOhOXLoWLF679n1S+rqDuvLuuPrieibwQhz4RQ5o4yzilYRESuK8+B5IcffqBjx4489thj1KhRg1deeYX9+/cTHx9/zfdERESQkJBAly5d7FKsCJjLeOvWhYwMsyvSvfv1uyLHko7x7NfP0mdFH8Y+Mpbt/bbjU9HHeQWLiMgN5SmQZGRkcOTIERo3bnzltYoVK1K+fHkOHTqU63vOnz/P3LlzGTNmDO7u2kxKbt2ZM9C5MwQGwgcfwLJlUL78ta/PyM5gcsRk6n1YjwqlKvBL0C/4+/hreEZExAXlaVKrzWYjJyeHMmX+3t4uXbo0Fy5cyPU9M2bM4MUXX6Rq1aokJSXdeqVSZBkGLF0KgwdDy5Zw6BDce+/137Pl9y0MDB3IbW63sbHnRlpUbuGcYkVE5KbkKZAYhpGvm65du5bk5GQ6d+58U0WJ/Meff8KgQbBlC3z4odkhuZ6zl87yyoZXWHpwKeOfGM/Q5kN1Gq+ISAGQp0Di5eWFm5vbVZ2OCxcuULp06auuj46OJjY2ltatW//t9TZt2jBs2DCeffbZXJ8zduxYPDw8APD19cXX1zdPP4QUPoYB33wDQUHQqpXZFbnnnutdb/DZvs8YvWE0D1d5mEODD1HFS5OpRUTsLSwsjLCwMMCc0mEveQokHh4eVK9enX379uHjY04GPHXqFKdPn6ZOnTpXXd+vX7+/TWQ9fPgwU6dOZcGCBZQrV+6az5k8eTKenp75/RmkkDl92pwnsm0bLFgAnTpd//rYxFgGrh7I0aSjLHpuER0e7OCcQkVEiqC/NgxsNhshISF2uW+eZ/d16NCBZcuWERERQXx8PNOmTaNBgwbUqFGDxMREevXqRWxsLAD33HMP1apVu/KrQoUKAFSrVo0777zTLoVL4fTtt+a+Iv/4h9kVuV4YSctM4/UfX8fnIx+aVGhC7OBYhRERkQIqzzu1tmvXjqSkJGbNmkVKSgo+Pj6MGjUKgOzsbI4fP056errDCpXCLSnJHJ4JC4OFC6Fjx+tfv+noJgaEDuDuEncT2S+SRuUbOadQERFxiGLh4eH5m7HqAKmpqbRv357k5GQN2RRBmzZBnz5Qvz58/DH8f0MtV0lpSYxcP5LvDn3H5KcmE9gkEHc3LSsXEbGCzWbDy8uL0NBQSpYseUv30oYMYpm0NBg+HJ5/HsaNg9Wrrx1GDMPgu0PfUTukNn+m/smBQQcIahakMCIiUkjocD2xxN698PLLUKoU7NkDNWte+9qTF08yeM1gtiZsZXbb2XSr141iNzo9T0REChR1SMSpsrPh3Xfh4YehSxdzJc21wohhGCzcvZA6IXUoeXtJDg06RPf63RVGREQKIXVIxGmOHjVP401MhJ9+gqZNr31t/Pl4/Ff5c+T8EZZ0XEK7f7ZzXqEiIuJ06pCIwxkGfP45NGpk/tq799phJCsni2nbptFwfkPq3lOXg4MOKoyIiBQB6pCIQ9ls5iZnGzaYe4w8/fS1rz1w5gB9V/QlJSOF9S+v5+EqDzuvUBERsZQ6JOIwO3dC48bmEM3+/dcOI5nZmUz8aSLNFjajVbVW7A3YqzAiIlLEqEMidpeTA9Onw/jx5q9Ro8DtGtF376m9+K30Izsnmy19t9CkYhNnlioiIi5CgUTs6vRpc+JqfDyEh0Pz5rlfl56VzqQtk5ixfQaj/zWacY+Nw8Pdw7nFioiIy1AgEbtZtw5694annoJ//xu8vHK/LupEFH1X9MXD3UPbvouICKA5JGIHGRnmsEznzjBlCnz1Ve5h5HLWZV7d8CqPf/Y43ep14+f+PyuMiIgIoA6J3KL4eOja1dzwbNcuqFUr9+u2H99O3xV98SzuSZR/FHXvrevcQkVExKWpQyI35T97izRuDI88Ajt25B5G0jLTGLV+FK0Wt8KvsR+R/SIVRkRE5CrqkEi+Xbhg7i2yaZO5t0i7a+xbti1hG34r/Sh7R1l2D9jNg3c/6NxCRUSkwFCHRPIlMtLcbTUpydxbJLcwcinzEiPCRtDmyzYM8B7A1r5bFUZEROS61CGRPMnKgsmTzUmr77wDQ4bkvrfI1oSt+K3w4+4Sd7NnwB5q3X2NSSUiIiJ/oUAiN5SQAD16wNmzsHWrOW/kf13KvMS4TeP4aM9HTGw5kaHNh+Lu5u78YkVEpEDSkI1c19Kl0LAh1KljrqLJLYxE/B5Bgw8bsPPkTvYG7GVEixEKIyIiki/qkEiuUlJg6FD44QdYtAg6drz6mrTMNMZuGstHez5iUstJDGk+REFERERuigKJXGXnTnj5ZahYEaKjoXLlXK45sZNeP/SizB1l2Buwl5p31XR+oSIiUmhoyEauyMqCt9+GJ56Afv3MZb3/G0YysjN448c3eOKzJ+jTqA9b+25VGBERkVumDokA5o6rPXuCzQbbtuU+VyTmzxh6Le9FjpHDjv47aFCugfMLFRGRQkkdkiLOMMw5Io0bQ7NmuU9czc7JZsrWKTRf1Jx2NdoR5R+lMCIiInalDkkRlpgI/ftDVBQsWwZt2lx9Tfz5eHov783ZS2f5sfePPHTfQ84vVERECj11SIqoNWugfn24/XaIibk6jOQYOYTsDKHR/Eb4VPBhb8BehREREXEYdUiKmEuXYNQo+PJL+OAD6NULihX7+zUJyQn0W9mPX87+woquK3jqgaesKVZERIoMdUiKkJ07zfkh+/eby3l79/57GDEMg4/3fEz9D+tT1asqMYExCiMiIuIU6pAUAZmZMHEiTJ8OsEYM3wAAFxtJREFUb74Jo0eD+//sX3bCdgL/Vf5E/xnNNx2/4el/Pm1NsSIiUiQpkBRyhw6Zy3kzM2H7dnMb+L8yDIMv93/JkHVDeK7WcxwIPECZO8pYU6yIiBRZGrIppHJyYNYsaNoUWrUyV9L8bxg5nXKaF759gdEbRvPZ85/xeYfPFUZERMQS6pAUQgkJ0KcP/PYbrFsHjz769983DINvD37L4DWDaVO9DQcHHeSuEndZUaqIiAigQFKoGAZ88QUMGQJdusCKFXDnnX+/JjE1kUFrBrH5t80saL+ATnU6WVOsiIjIXyiQFBKJiRAQAJGR8NVX0L791dd8H/s9A0P/r717j6qqTv84/gYU84ZKXlAmzKTIS4rQWDllaSneKtaIKZGKlxJFGi+oqK2s+TWmY06o4M/MofxZZnbR1ES8DJOWl9DBW8ogZkmKosjhCCEInN8fJ1Dydg63A4fPay3Xwr03ez/HZ8F+fPZ3f78hPNH2CX6Y8AMtG7as+kBFRERuQgWJHfj6axg92vxo5uhRaN689P5LuZcIiw0j9kQs0QOiGdZ5GA6/n3xERETEhjSotQb79VeYMAECA+Hvf4fPPruxGNmUvIlOSzthzDPyw4QfCHwoUMWIiIhUO+qQ1FD/+Q8EBYGrq3mSs3btSu/PupLFpLhJrDu+jkX9FjGi6wgVIiIiUm2pQ1LDFBbCvHnw+OPw0kvwzTc3FiNbT26l8/925uzlsxydcJSR3iNVjIiISLVmVYdk9erVfPnll2RnZ+Pr68vUqVNxdXW94Tij0UhMTAwJCQlcvHiR5s2b4+fnR1BQEE6/nyJULPbzz+a1Z9LSzIXIH/9Yev/lvMuEbw3nk6OfsLDvQsb6jFUhIiIiNYLFHZLY2FhWrVrFq6++SlRUFDk5Obz55ps3PTYjIwODwUBYWBgxMTGEhoaybt06PvroowoLvLb5+GPzxGYPPgiJiTcWI/Gn4umyrAsnLp3g8PjDvOz7sooRERGpMSzukKxbt47BgwfTs2dPAKZPn05QUBApKSl4enqWOrZdu3a88cYbJX93d3cnICCAb775hpEjR1ZM5LWEwWAeuLptm3mOkeeeK73fmGdkxrYZrDq8innPzGPCHyfg6KAncSIiUrNYdOfKz8/n5MmTdOvWrWRbmzZtcHNz49ixYxZdKCsri8a/n6VLbis+Hrp0MRclR47cWIxsPrGZTks7lXRFJnafqGJERERqJIvuXkajkaKiIpo1K73OSdOmTTEYDHf8/rNnz7J582YGDhxYtihrmStXYOpUePZZiIgwzzPi5nZtf8avGYxYN4IXv3iROU/OYdvwbdzX7D7bBSwiIlJOFj2yMZlMZb5AZmYmERER9O7dm969e5f5PLXFwYPmt2caNIADB8DL69o+k8nE58c+Z2LsRB5xf4QfJvyAu4u77YIVERGpIBYVJE2aNMHR0ZHMzMxS2w0GA02bNr3l92VlZREeHo6XlxeTJk2643VmzZqFs7MzAH5+fvj5+VkSnl0oLIR33oG//hWmT4dZs6Bu3Wv70y6nEbo5lF2nd7Gk/xKGdhqqQasiIlLl4uLiiIuLA8xDOiqKRQWJs7Mz7du35+DBg/j6+gKQlpbGuXPn6Nix402/5/Lly0ybNo3WrVsTERGBo+Odnw7NnTsXFxcXK8K3D6dOmV/nPX/ePG6ke/dr+0wmEysPrWRK3BT6efbj2IRjtGjYwnbBiohIrXZ9w8BoNBIdHV0h57V4BKS/vz9ffPEFu3btIiUlhQULFtClSxc8PT25cOECI0aM4Pjx4wDk5OQwffp0nJycCAsLIysri0uXLlk03qQ2MZnggw/Mr/N26WJ+nff6YuRnw8/0/7g/s/81m5X+K1k9eLWKERERsUsWv/Y7YMAAMjMziYyMLJkYLTw8HIDCwkJSU1PJy8sD4MSJEyQlJQEwbNiwknO0atWKNWvWVGT8NdaFC/DKK7B3L3z6KfTvf21fYVEhUd9H8Vr8awzrNIw1AWtoetetH42JiIjUdA7x8fFlH7FaQXJychg0aBBZWVm14pHN11/DmDHm6d+XLSu9IN7R9KOM3TCWjNwMlg9aTq92vWwXqIiIyG0YjUaaNGnCpk2baNiwYbnOpUkrqlB2NowbBy++eOPqvHkFecyJn0P397vz1L1PcTjksIoRERGpNbTabxXZvds8cPWee+DwYWjb9rp9qbsZu2Es9evW57vR39Gtdbdbn0hERMQOqUNSyfLzYfZs6NPHPAX8jh3XipHLeZcJ2xxGn1V9CPYOZt/YfSpGRESkVlKHpBIdO2ae5KyoCPbtg86dr+3bfGIzIZtC8HT15FDIITxdPW99IhERETunDkklKCqCyEjzirx+fqWLkbTLaQz7fBhBXwYx58k57BixQ8WIiIjUeuqQVLDUVAgONk92FhdnfpMGoMhUxPIDy4nYHkH/+/tzPPQ4bo3cbnsuERGR2kIFSQUxmeDjjyEsDAYPhvXroXhx46PpR3ll4yukZafxyeBP6H9//9ufTEREpJbRI5sKcOECBASYV+j98ENYscJcjORezWXWjll0f787T3g8wdHxR1WMiIiI3IQ6JOW0YQO8/LL50czRo9Dit5ndt53cRsjXITRv0Jw9Y/bQ1a2rbQMVERGpxlSQlFFWFkyaZH40s2QJBAWBgwOk56QzOW4ym5I3Mbf3XEIeDsHJ0cnW4YqIiFRremRTBv/6l3kxvDNn4MgR86u9Jop4/8D7PBj1IHkFeRybcIzQ7qEqRkRERCygDokVfv0VZs6Ef/4TFiyAkBBzV+Tw+cOEbArh7OWzrPRfybNez9o6VBERkRpFHRIL7dsH3bpBQgIkJsL48ZBzNZvwreE8suIRerbtyQ8TflAxIiIiUgYqSO4gL8889XuvXjBqFOzaBZ6eJtYnradDdAf2ndlHwssJzHtmHg2dy7fSoYiISG2lRza3kZBgnuTsrrtg717zuJGfDD8RFhvGntQ9LOizgJHeI3F0UF0nIiJSHrqT3sSVK+axIk8+aX57Zu9e6NDpKvO/nU/npZ1p2aAlSROTGNVtlIoRERGRCqAOye/s22d+NNOwIXz/vXkNmm9Pf0vIphAAtry0hcc9HrdxlCIiIvZF/73/zZUrMGMG9O4NI0bAnj3g3j6TVza+Qr+P+jG8y3ASxyWqGBEREakE6pBgLj5GjzZP956QAB06mFhzdA2T4ibh09qHI+OP0K5ZO1uHKSIiYrdqdYckNxfCw+GZZ8yPaXbvhnpuJ+n3cT+mbJ3Ckv5L2PziZhUjIiIilazWdkgOHDDPsNqkCezfD+0fyGfB7oW8testRnYdyacBn9L0rqa2DlNERKRWqHUFSUEBzJ8Pf/ubeX6RGTPg+7Td+C4fB8D24dt57J7HbByliIhI7VKrCpKTJ80DVjMyYOdO8OxsYOKWCFYdXsXrPV9nymNTqOtU19ZhioiI1Dq1YgyJyQQrVoC3N/j6woEDJpKcP8IryoufDD9xZPwRZjw+Q8WIiIiIjdh9hyQ9HV5+2fz2zOefg4fPcQZ9PoHkjGSiB0QzuMNgHBwcbB2miIhIrWbXHZKNG+Ghh6BePdj3n1/5ps4sfJf70s2tG0mhSQR0DFAxIiIiUg3YZYckOxumTIG1ayEqClwe3sgTa8Jo07gNe8bsoatbV1uHKCIiItexu4Lk0CF44QVo0wZid59m/uFX2bVhF/Ofmc/obqO19oyIiEg1ZDd3Z5MJ3nsPevSAYUH59P3rfPqs74hrfVeSQpMY6zNWxYiIiEg1ZRcdEqMRxo2Df/8b/vHJAaLPjMJ01KSF8ERERGqIGt8yOHgQHn4Y0jPyGPrebCYfeYKAjgEceOWAihEREZEaosZ2SEwmWL7cPHh1eEQC3949CsO5euwdu5curbrYOjwRERGxQo3skBiNEBgIc/7nCv5LZvJ/jk8S2DmQvWNUjIiIiNRENa5DkphofovG9aF9uEwfxX8LGvD9y9/TuWVnW4cmIiIiZVRjOiTFb9H86alc3IZP54hvL0Z1G87esXtVjIiIiNRwNaJDkpcHYWHw+d49NJ89irxmLiQ8n0Cnlp1sHZqIiIhUgGrfIUlLg6eezmfjr7PIfeFpQnuMYveY3SpGRERE7IhVHZLVq1fz5Zdfkp2dja+vL1OnTsXV1fWmx+bm5rJ48WJ27txJnTp16Nu3LyEhITg5OVl8vX374NkxRyh4bjj33OPAtsEaKyIiImKPLO6QxMbGsmrVKl599VWioqLIycnhzTffvOXxkZGRHDt2jAULFjBnzhzi4+NZuXKlxYHFfFDIExELMAx5hJCnB5Lwyj4VIyIiInbK4oJk3bp1DB48mJ49e+Lp6cn06dM5fPgwKSkpNxx7+fJltm/fTlhYGB07dsTHx4fRo0fz1VdfUVhYeNvrXL0KwZNPMW5PL1r0W843o3cw9+m/4ezkbP2nkzKJi4uzdQjyG+Wi+lAuqg/lwj5ZVJDk5+dz8uRJunXrVrKtTZs2uLm5cezYsRuOT05OBsDb27tkm4+PD0ajkTNnztzyOhcvmnho5ApWNezK0F6dSZ58kMfuecziDyMVQz/s1YdyUX0oF9WHcmGfLBpDYjQaKSoqolmzZqW2N23aFIPBcMPxmZmZNGrUiDp16pQ6FsBgMODh4XHT63SaMxTuO8IXwz7Dv7OfxR9CREREajaLChKTyWTVSW92vIODwx2Pb9uyHlsmfodrA1eMRqNV15SKk5+fr3//akK5qD6Ui+pDuag+ivNgbZ1wMxYVJE2aNMHR0ZHMzMxS2w0GQ0nn43qurq5kZ2dTUFBQ0iUp/t6bHZ+bmwvAf/+xgXb/2GDdJ5BKER0dbesQ5DfKRfWhXFQfykX1kpubS6NGjcp1DosKEmdnZ9q3b8/Bgwfx9fUFIC0tjXPnztGxY8cbjr///vsBOHToUMnxiYmJuLi44O7ufsPxd999N2vXrqV+/fq37aSIiIhI9WEymcjNzeXuu+8u97ksnofE39+fqKgoHnjgAVq3bs3SpUvp0qULnp6eXLhwgalTpzJz5kw6dOiAi4sLTz/9NEuWLGHGjBlcuXKFmJgYnn/++ZvOQ+Lo6EiLFi3K/WFERESkapW3M1LM4oJkwIABZGZmEhkZWTIxWnh4OACFhYWkpqaSl5dXcvzkyZNZtGgR4eHhODk50bdvX0aOHFkhQYuIiIh9cYiPjy//SBQRERGRcqj2a9mIiIiI/auy1X6reh0cuTVLc2E0GomJiSEhIYGLFy/SvHlz/Pz8CAoKUi4qiDU/F8VycnIYM2YM58+fZ/v27cpFBbI2Hzt27GD16tWkpqbi4uJCQEAAw4YNq8KI7Zc1uTh16hRLly7l+PHjODk50bVrV0JDQ2nVqlUVR21/du7cyfr160lOTiYnJ+eOv3PKc/+ukg5JVa+DI7dmTS4yMjIwGAyEhYURExNDaGgo69at46OPPqriqO2TtT8XxRYvXnzLyQWl7KzNx9atW1m8eDFDhgzhgw8+YO7cuXh5eVVhxPbL2ly89tprNGrUiKVLl7Jw4UKys7N56623qjBi+5WXl4ePjw+BgYEWHV+e+3eVFCRVtQ6O3Jk1uWjXrh1vvPEGjz76KO7u7vTo0YOAgAC+++47G0Ruf6zJRbFdu3Zx+vRphg4dWoWR1g7W5KOgoIBly5Yxfvx4+vXrh7u7Ow888ECp5TWk7KzJhcFg4OzZswQFBeHh4YGnpycBAQElS5hI+fTp04eXXnqJTp063fHY8t6/K70gqap1cOTOrM3FzWRlZdG4cePKCrHWKEsuLl26RFRUFBEREXpMU8HK8nsqMzOTwsJCRo0axQsvvMDbb79NVlZWVYZtl6zNhYuLC3/4wx/YunUr+fn55ObmsmPHDh5++OGqDFso//270guSil4HR8rO2lz83tmzZ9m8eTMDBw6srBBrjbLkYuHChfz5z3+mbdu2VRFirWJtPs6dOweYxzmMGzeO119/ndOnT+sxQQWwNheOjo4sWLCA/fv3079/fwYOHMjZs2eZOXNmVYUsvynv/bvSC5LKXgdHLFeetQYyMzOJiIigd+/e9O7duwKjqp2szUVsbCxZWVkMGTKkkiKq3azNR1FREQDDhw/n0UcfpXPnzkydOpX9+/eTnp5eGSHWGmXJRWRkJG3btiU6OppFixbRoEEDFYc2UN77d6W/ZVPZ6+CI5azNRbGsrCzCw8Px8vJi0qRJlR1mrWBtLg4dOsTx48fp06dPqe19+/Zl0qRJPPvss5Uar72zNh/F/3u/fnBx8dfp6em0bNmyEqO1b9bmIjExkcTERDZu3IizszMAM2fOZMiQIfz444/cd999VRK3lP/+XekdkuvXwSlm6To4xW63Do5YztpcgHmQ0rRp02jdujURERE4OmrqmopgbS7GjBnDihUrSv4Uz5L83nvv8dRTT1VV2HbL2nx4eXlRp06dUs/Fi7/Wq6blY20urly5goODQ6nfTcVfF3eypGqU9/7tFBwc/EYlxXbtIk5OrFy5Eg8PD65evcqiRYto2bIlQUFBXLhwgfHjx/Pggw/SokUL6tWrx5kzZ4iNjcXLy4tffvmFxYsXM2jQoJKF+qTsrMlFTk4O06ZNw9HRkRkzZnD16lVyc3PJy8vjrrvusvVHqfGsyUXDhg1p1qxZyZ+cnBzi4uL4y1/+olxUEGvy4ezsTHp6OrGxsdx///1kZ2ezaNEi7r33Xp5//nlbf5Qaz5pcuLi48NVXX3HmzBk8PDy4ePEi0dHRFBUVERwcrAHg5WQ0GklNTeXUqVPs3r2bHj16YDAYqF+/PgaDoULv31UyMZrWwak+rMnFiRMnSEpKAig12VOrVq1Ys2ZN1QdvZ6z9uZDKZW0+wsLCiI6OZvbs2Tg5OdG9e3cmTpxoq/DtijW5aNq0KfPmzWP58uVMmDABJycnOnbsyNtvv03dunVt+THswu7du5k/f37J30NCQgB49913cXNzq9D7t9ayEREREZvTgAARERGxORUkIiIiYnMqSERERMTmVJCIiIiIzakgEREREZtTQSIiIiI2VyXzkIiIiIhldu7cyfr160lOTiYnJ4ft27dX2gRvGzZsYNu2bZw4cYLGjRvz2WefldqfkZFBVFQUSUlJnDt3jvDw8EpbYFUdEhERkWokLy8PHx8fAgMDK/1a+fn5/OlPf+K555676f6rV6/SvHlzxowZg6ura6XGog6JiIhINVK8iOb16/lcLzk5maVLl3L8+HGaNWuGn58fI0aMKFMXJSAgAIAtW7YQHx9/w343NzdCQ0MBWLFihdXnt4Y6JCIiIjVEVlYW06ZN45FHHiEmJoaIiAh27NjB2rVrbR1auakgERERqSHWr1+Pt7c3gYGBuLu74+3tTXBwMJs2bbJ1aOWmRzYiIiI1RPGqu/379y/ZVlRUREFBAUVFRTg6OjJixAhSU1NveY6RI0cSHBxcBdFaRwWJiIhIDZGbm0uvXr1uuoKuo6P5oUdkZCSFhYW3PEeDBg0qLb7yUEEiIiJSQ7Rv354DBw7g7u5+y2Mq+22YyqKCREREpBoxGo2kp6dz5swZAFJSUnBycsLd3R1/f382btzIO++8g7+/P87Ozpw8eZJffvmF4cOHW32tS5cucenSJc6fP09hYSEpKSkAtG3blrp165ZcH6CgoID09HRSUlJo3LgxrVq1qqBPbOYQHx9vqtAzioiISJlt2bKF+fPn37D93Xffxdvbmx9//JFly5Zx5MgRHB0d8fDwwN/fHz8/P6uv9eGHH7Jy5cobtn/yySe4ubkB0KtXrxv2+/n5ERERYfX1bkcFiYiIiNicXvsVERERm1NBIiIiIjangkRERERsTgWJiIiI2JwKEhEREbE5FSQiIiJicypIRERExOZUkIiIiIjNqSARERERm1NBIiIiIjb3//CXyZKSFCG+AAAAAElFTkSuQmCC\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "NaCl_1400K.run_computation.EinsteinDiffusionCoefficients(plot=True, data_range=50)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Batch Loop: 0it [00:00, ?it/s]\n",
-      "Ensemble Loop: 0it [00:00, ?it/s]\u001b[A\n",
-      "Ensemble Loop: 43it [00:00, 422.01it/s]\u001b[A\n",
-      "Ensemble Loop: 99it [00:00, 455.45it/s]\u001b[A\n",
-      "Ensemble Loop: 177it [00:00, 540.53it/s]\u001b[A\n",
-      "Batch Loop: 1it [00:00,  2.64it/s]\n",
-      "No handles with labels found to put in legend.\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "NaCl_1400K.run_computation.EinsteinHelfandIonicConductivity(plot=True, data_range=13)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Batch Loop: 100%|█████████████████████████████████████████████████████| 1/1 [00:05<00:00,  5.58s/it]\n",
-      "Batch Loop: 100%|█████████████████████████████████████████████████████| 1/1 [00:05<00:00,  5.25s/it]\n"
+      "Batch Loop: 100%|█████████████████████████████████████████████████████| 1/1 [00:00<00:00,  3.74it/s]\n",
+      "Batch Loop: 100%|█████████████████████████████████████████████████████| 1/1 [00:00<00:00,  4.73it/s]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlEAAAG4CAYAAABl37IJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAxOAAAMTgF/d4wjAABl2ElEQVR4nO3deVhV1f7H8bcCjiiVmqRZiShO2SxqKg4ZmrOWaZoS1C0yf9KkZTaHplmGaVEKOEQmaUlCihMaDpBWNmgqB61sgFuJzMoBzu+PnVwHygMCmwOf1/Pc58bZa6/9PTvNj2uvvVat+Ph4GyIiIiJSKrXNLkBERETEESlEiYiIiJSBQpSIiIhIGShEiYiIiJSBQpSIiIhIGShEiYiIiJSBQpSIiIhIGShEiYiIiJSBs70NbTYbS5cuJTY2lpycHNq1a0dQUBCtW7cusX1WVhYhISEkJiYC0K1bN4KCgnB1dS1us337dsLCwkhLS8Pd3Z2AgAB69+5dqX1YLBYWL15McnIy6enpzJs3j5tuuums73Lw4EHeffddLBYLtWvXpkuXLkyePBl3d3d7b5+IiIhUM3aPRK1atYr169czd+5c1q5dS+fOnZk2bRp5eXkltg8ODiY9PZ3IyEgiIyNJT09n9uzZxccPHDhAcHAwAQEBxMbG4u/vT3BwMIcOHarUPlxcXOjVq9dZn52pqKiIp59+Gg8PD9asWcPKlStxcnLilVdesffWiYiISDVkd4iKjo5mzJgxeHh4ULduXfz9/bFarSQkJJzXNjU1laSkJAIDA3Fzc8PNzY3AwEB27dpFWloaAOvWrcPb2xsfHx+cnZ3x8fGha9euREdHV2ofV199NUOGDMHLy6vE752Tk8OJEycYNGgQderUoUGDBvj6+pKcnFyK2ywiIiLVjV0hKjs7m9TUVDp06FD8mZOTE23bti0xTFgsFlxcXPD09Cz+zNPTExcXFywWS3Gb9u3bn3Wel5fXWccro48LadSoESNGjCA2NpaTJ0+SnZ3Nhg0b6NWrl13ni4iISPVk15yo3NxcgLPmIp3++fSxc9uf2/bc9iW1adSoETk5OZXahz18fHyYP38+gwcPxmaz4enpyauvvlpi26KiIv766y/q169PrVq17L6GiIiImMdms5GXl0eTJk2oXdu+B3V2hagGDRoAxojUmbKzs2natGmJ7c9te7r96b5KapOVlUXDhg0rtY8L+eWXX3jyySeZPHkyd9xxB4WFhaxcuZIpU6awZMkS6tevf1b7v/76izFjxtjVt4iIiFQtUVFRNGvWzK62doUoV1dX3N3dOXjwIJ06dQKgsLAQi8XCgAEDzmvv6emJ1WolJSWFNm3aAJCSkoLVai1+tObp6XnWBHCAw4cPn3W8Mvq4kJSUFOrWrcuIESOKP7v77rtZsWIFR48epWPHjme1Px2qjh07RuPGje26hpRsxowZzJo1y+wyqgXdy/Kje1k+dB/Lj+5l+cjMzKRVq1bnDY78G7uXOBg+fDhRUVHceOONtGjRghUrVuDs7Fzi3CB3d3e8vb0JDQ1l5syZAISGhtKjRw+aN28OwNChQwkKCiIhIYHu3buze/dukpKSCAkJqdQ+bDYbVqu1uPaCggLy8/NxcnLCyckJLy8vrFYr69atKx6JWr16NfXr16dVq1bnfffTj/AaN26sEHWR6tSpo3tYTnQvy4/uZfnQfSw/upflqzRTcewOUXfffTe5ubk8/vjj5Obm4uXlxZw5c6hfvz5paWn4+fkxZ84cunTpAhjJOCQkhPHjxwP/W5/ptI4dOzJjxgwWL17Myy+/jLu7OzNmzDhronhl9JGWlsa4ceOKf37qqacAmDRpEn5+fri7u/PKK6+wdOlS3nvvPQA8PDyYNWsWjRo1svf2iYiISDVTKz4+3mZ2EdVJTk4OQ4YMISMjQ38zuEhxcXH4+vqaXUa1oHtZfnQvy4fuY/nRvSwfmZmZuLm5ERMTUzy3+kIUosqZQpSIiIjjKUuI0t55IiIiImWgECUiIiJSBgpRIiIiImWgECUiIiJSBgpRIiIiImWgECUiIiJSBgpRIiIiImWgECUiIiJSBgpRIiIiImWgECUiIiJSBgpRIiIiImWgECUiIiJSBgpRIiIiImWgECUiIiJSBgpRIiIiImWgECUiIiJSBgpRIiIiImWgECUiIiJSBgpRIiIiImWgECUiIiI13okTpT9HIUpERERqtLw8uOOO0p+nECUiIiI12hNPQL16pT9PIUpERERqrDVrIDISwsNLf65z+ZcjIiIiUvUdPgz+/hARAddcU/rzNRIlIiIiNU5ODoweDf/5D4waVbY+FKJERESkRrHZ4KGH4NJLYfbssvejx3kiIiJSo7z7LmzaBF9/Dc4XkYQUokRERKTG+OILePxxWL8errji4vrS4zwRERGpEf76C+66C158EXr3vvj+FKJERESk2isqgokT4cYbjZGo8qDHeSIiIlLtvf46HDhgzIOqVat8+lSIEhERkWpt1y544QWIj4dLLim/fu0OUTabjaVLlxIbG0tOTg7t2rUjKCiI1q1bl9g+KyuLkJAQEhMTAejWrRtBQUG4uroWt9m+fTthYWGkpaXh7u5OQEAAvc94SFkZfVgsFhYvXkxycjLp6enMmzePm2666bzvs2HDBqKiovj999+pV68effv25f/+7//svX0iIiJigr/+grFjITgYunYt377tnhO1atUq1q9fz9y5c1m7di2dO3dm2rRp5OXlldg+ODiY9PR0IiMjiYyMJD09ndlnLMZw4MABgoODCQgIIDY2Fn9/f4KDgzl06FCl9uHi4kKvXr3O+uxcUVFRLFu2jKCgIGJiYvjggw8YOHCgvbdORERETGCzgZ+fMQ9q6tTy79/uEBUdHc2YMWPw8PCgbt26+Pv7Y7VaSUhIOK9tamoqSUlJBAYG4ubmhpubG4GBgezatYu0tDQA1q1bh7e3Nz4+Pjg7O+Pj40PXrl2Jjo6u1D6uvvpqhgwZgpeXV4nfOycnh4iICKZMmUKXLl1wcnKifv36tGvXrhS3WURERCrbG2/Ad98Z27qU1zyoM9kVorKzs0lNTaVDhw7Fnzk5OdG2bVuSk5PPa2+xWHBxccHT07P4M09PT1xcXLBYLMVt2rdvf9Z5Xl5eZx2vjD4uZP/+/Zw8eZJffvmFCRMmMHLkSJ588km7zxcREZHKl5gIzz4Lq1YZK5NXBLtCVG5uLsBZc5FO/3z62Lntz217bvuS2jRq1IicnJxK7eNCMjIyANixYwfz58/nww8/xNPTk+nTp5OdnW1XHyIiIlJ5jh+Hu++GV14Bb++Ku45dE8sbNGgAcF5oyM7OpmnTpiW2LylgZGdnF/dVUpusrCwaNmxYqX1cyOl248ePp1mzZgDcf//9fPLJJ+zfvx/vf/i3M2PGDOrUqQOAr68vvr6+dl1PREREys5mg/vug+uug0cf/fe2cXFxxMXFAZCfn1/qa9kVolxdXXF3d+fgwYN06tQJgMLCQiwWCwMGDDivvaenJ1arlZSUFNq0aQNASkoKVqu1+NGap6fnWRPAAQ4fPnzW8cro40Latm0LQK1SPkydNWsWjRs3LtU5IiIicnHefBP27bNvPagzBzkyMzNZtGhRqa5l98Ty4cOHExUVxdGjRzl16hQRERE4OzvTq1ev89q6u7vj7e1NaGgoGRkZZGRkEBoaSo8ePWjevDkAQ4cOJTExkYSEBAoKCkhISCApKYlhw4ZVah82m438/PziBFpQUEB+fj6FhYUAXH755fTs2ZPIyEiOHz9Ofn4+4eHhNGrUiM6dO5fqZouIiEjF+eILmDkTPvwQLrus4q9XKz4+3mZPQ5vNRkREBDExMeTm5uLl5cXUqVPx8PAgLS0NPz8/5syZQ5cuXQAj0YWEhJCUlASUvMbTtm3bCA8PJzU1tXiNJx8fn+LjldFHamoq48aNO+/7Tpo0CT8/P8B4Q2/hwoXs2LGD2rVr4+XlRWBgYIlrZOXk5DBkyBAyMjI0EiUiIlJJ0tPhhhtg8mR48snSn5+ZmYmbmxsxMTHF04IuxO4QJfZRiBIREalcNhuMGgVWK3z6KdQuw87AZQlR2vZFREREHNr8+bB3rzEXqiwBqqwUokRERMRhxccb60HFx0OTJpV77UrMayIiIiLl5+efYcwYCAkp/33x7KEQJSIiIg7n5EkYPdqYC3X//ebUoBAlIiIiDsVmg4cfBmdnWLDAvDo0J0pEREQcSmgofPYZfPkl1K1rXh0KUSIiIuIwduyAJ56ADRugZUtza9HjPBEREXEIKSkwYgS8/jqUsGFKpVOIEhERkSrvxAkYMgQmToSHHjK7GoNClIiIiFRpVivceSe0bQuvvWZ2Nf+jOVEiIiJSZdlsxn54f/5pzIdycjK7ov9RiBIREZEq6403ICYGkpLA1dXsas6mECUiIiJVUnQ0PP88bNsGrVqZXc35NCdKREREqpyvv4YJE2D5crj5ZrOrKZlClIiIiFQpv/4KQ4fCM88Y27pUVQpRIiIiUmXk5BgB6vbbYfp0s6v5dwpRIiIiUiUUFRmP8NzcjK1datUyu6J/p4nlIiIiUiU89RTs3w+JiVCnjtnVXJhClIiIiJhuyRIICzMC1GWXmV2NfRSiRERExFRbt8LUqRAba6xK7ig0J0pERERMc/AgjB4NCxdCnz5mV1M6ClEiIiJiij//NDYVfughuO8+s6spPYUoERERqXSnThlrQF1/PQQHm11N2ShEiYiISKWy2eA//4G8PGNF8toOmkY0sVxEREQq1fPPG5PJv/gCGjQwu5qyU4gSERGRSrNwISxaBAkJcMUVZldzcRSiREREpFJERcHTT8PGjdCxo9nVXDyFKBEREalwmzcbb+B99BF07252NeXDQadyiYiIiKPYu9d4Ey80FO64w+xqyo9ClIiIiFSY5GQjOD3/PNx7r9nVlC+FKBEREakQv/0Gt98Ofn7w+ONmV1P+FKJERESk3J04AQMHgo8PzJljdjUVw+6J5TabjaVLlxIbG0tOTg7t2rUjKCiI1q1bl9g+KyuLkJAQEhMTAejWrRtBQUG4uroWt9m+fTthYWGkpaXh7u5OQEAAvXv3rtQ+LBYLixcvJjk5mfT0dObNm8dNN91U4nfKyckhICCAtLQ0Nm/ejJOTk723T0REpMbIy4Nhw+Cqq2DxYqhVy+yKKobdI1GrVq1i/fr1zJ07l7Vr19K5c2emTZtGXl5eie2Dg4NJT08nMjKSyMhI0tPTmT17dvHxAwcOEBwcTEBAALGxsfj7+xMcHMyhQ4cqtQ8XFxd69ep11mf/ZOHChbRq1creWyYiIlLjFBbCPfcY/x8VBS4uZldUcewOUdHR0YwZMwYPDw/q1q2Lv78/VquVhISE89qmpqaSlJREYGAgbm5uuLm5ERgYyK5du0hLSwNg3bp1eHt74+Pjg7OzMz4+PnTt2pXo6OhK7ePqq69myJAheHl5/ev337VrF0ePHmXs2LH23jIREZEaxWaDRx6BQ4dg3TrHXo3cHnaFqOzsbFJTU+nQoUPxZ05OTrRt25bk5OTz2lssFlxcXPD09Cz+zNPTExcXFywWS3Gb9u3bn3Wel5fXWccrow97ZGRksGDBAqZPn65HeCIiIv8gOBg+/RQ2bIDLLjO7mopnV4jKzc0FOGsu0umfTx87t/25bc9tX1KbRo0akZOTU6l92GP+/PkMHjz4H+d/iYiI1HTh4TBvnhGgrrrK7Goqh10hqsHf43HZ2dlnfZ6dnV187Nz257Y9t31JbbKysmjYsGGl9nEhW7du5bfffuOee+6xq72IiEhNExMDU6ZAdDRce63Z1VQeu97Oc3V1xd3dnYMHD9KpUycACgsLsVgsDBgw4Lz2np6eWK1WUlJSaNOmDQApKSlYrdbiR2uenp5nTQAHOHz48FnHK6OPC/niiy84duwYo0aNKv7eAKNGjSIwMJCBAweWeN6MGTOoU6cOAL6+vvj6+tp1PREREUeSmAjjxsGyZcZyBo4kLi6OuLg4APLz80t9vt1LHAwfPpyoqChuvPFGWrRowYoVK3B2dqZXr17ntXV3d8fb25vQ0FBmzpwJQGhoKD169KB58+YADB06lKCgIBISEujevTu7d+8mKSmJkJCQSu3DZrNhtVqLay8oKCA/Px8nJyecnJyYPHkyAQEBxcf379/Piy++yLvvvoubm9s/3q9Zs2bRuHFje2+viIiIwzl4EIYMgdmz4c47za6m9M4c5MjMzGTRokWlOr9WfHy8zZ6GNpuNiIgIYmJiyM3NxcvLi6lTp+Lh4UFaWhp+fn7MmTOHLl26FBcTEhJCUlISUPIaT9u2bSM8PJzU1NTiNZ58zoixldFHamoq48aNO+/7Tpo0CT8/v/M+37dvH48++ug/rhOVk5PDkCFDyMjIUIgSEZFq67ffoEcPGD/emFDu6DIzM3FzcyMmJqZ4WtCF2B2ixD4KUSIiUt1lZEDv3nDjjcaE8uqwmGZZQpS2fRERERG7nToFI0ZAy5bw3nvVI0CVld1zokRERKRmKyqCe++FnBzjjbzqvBq5PRSiRERExC5PPAH79sHOnWDnE69qTSFKRERELujdd2H5ckhKgmbNzK6malCIEhERkX+1ZQs89hisXw9/L7soaGK5iIiI/ItDh4w1oBYtMt7Ik/9RiBIREZES/fWXsZjmQw9BCUsn1ngKUSIiInKe/HwYPdrYC686LKb5b4psRTwU81Cpz9OcKBERETmLzQaBgZCVBbGxULsaD7nYbDamrp9K0i9JpT63Gt8WERERKYt582DDBvj00+q/lMFL21/i44Mfs3bs2lKfq5EoERERKbZ2Lbz0EmzfbqxKXp0t/GIhIUkhJNyXQKt6rUp9vkaiREREBICvvzZWJF++3NgXrzpb+d1Knt7yNLH3xNLp8k5l6kMjUSIiIsJvv8HQofDMMzBypNnVVKwNlg3cv+5+1oxZQ/dW3cvcj0aiREREaricHCNA3X47TJ9udjUVa/ex3dz10V0sGbqEgZ4DL6ovhSgREZEarKgIJkyARo0gNBRq1TK7oorzXdp3DP5gMHNum8O4a8dddH96nCciIlKDPf007N8Pu3dDnTpmV1Nxvv/v9/Rf3p/Huj/Gw7c8XC59KkSJiIjUUGFhsHgxJCZCkyZmV1Nx9v93P/2W9eORro8ws/fMcutXIUpERKQGio+H//s/iImBdu3MrqbiHPjjAP2W92PyLZN5zue5cu1bc6JERERqmMOHjS1d3noL+vY1u5qKsy91H32W9iHw5kCe7/N8ufevECUiIlKD/PUXDB4MDzwA/v5mV1Nxkn5Jou+yvjzW/TFe6PNChVxDj/NERERqiDM3FZ492+xqKs72H7czdOVQgvsFM8V7SoVdRyFKRESkBrDZ4MEHq/+mwnGWOEZHjWbBoAX431CxQ20KUSIiIjXAnDmwcSN88UX13VR47cG1TPh4AkuGLWFs57EVfj2FKBERkWpuzRoIDq7emwqv/G4lD6x7gMhRkQxvP7xSrqkQJSIiUo3t3QuTJkFkZPXdVDh0byhPbHyCj+/+mNvb3F5p11WIEhERqaaOHTP2xHvhBRheOYMzlcpms/Fs/LO8s/cd4ibEcetVt1bq9RWiREREqqHsbCNADRkCjz9udjXlz1po5T8x/2Hr0a3suG8HHZp1qPQaFKJERESqmcJCuOceYyuXt9+ufpsKZ+dnc2fUnaRmp7I7YDctGrUwpQ6FKBERkWrEZoOHHgKLBXbuBBcXsysqX2nZaQz+YDBu9dzY7rcdt3puptVSTVeJEBERqZlmzDCWMti4ES691OxqylfyX8n0CO+BV1Mv1o9fb2qAAoUoERGRauONN2DJEiNAXXml2dWUry9+/YIe4T0Y3WE0K0auoI5THbNL0uM8ERGR6mDZMuMtvK1bwcvL7GrKV+zhWMauGcsrfV9harepZpdTTCFKRETEwa1bBw8/bPz/zTebXU35WvLVEqZumMrS4Uu5q9NdZpdzFrtDlM1mY+nSpcTGxpKTk0O7du0ICgqidevWJbbPysoiJCSExMREALp160ZQUBCurq7FbbZv305YWBhpaWm4u7sTEBBA7969K7UPi8XC4sWLSU5OJj09nXnz5nHTTTcVn5+enk5oaCjffvstJ06cwM3Njf79+zNp0iTq1DF/KFFERGq2zz+HceNgxQro18/sasqPzWbj5c9fZn7ifD675zN8rvExu6Tz2D0natWqVaxfv565c+eydu1aOnfuzLRp08jLyyuxfXBwMOnp6URGRhIZGUl6ejqzz9gy+sCBAwQHBxMQEEBsbCz+/v4EBwdz6NChSu3DxcWFXr16nfXZmfLy8mjVqhXz5s0jNjaW119/ncTERN577z17b52IiEiF2LcPhg2D+fNh1Cizqyk/BUUFPBjzIIu/WkzCfQlVMkBBKUJUdHQ0Y8aMwcPDg7p16+Lv74/VaiUhIeG8tqmpqSQlJREYGIibmxtubm4EBgaya9cu0tLSAFi3bh3e3t74+Pjg7OyMj48PXbt2JTo6ulL7uPrqqxkyZAhe//AAuUWLFkyYMIGWLVtSu3ZtWrZsyaBBg/j6669LcZtFRETKV0oKDBwI06fDAw+YXU35ycnPYeSqkew6totd/rvofHlns0v6R3aFqOzsbFJTU+nQ4X+rgTo5OdG2bVuSk5PPa2+xWHBxccHT07P4M09PT1xcXLBYLMVt2rdvf9Z5Xl5eZx2vjD7KYu/evbRt27bM54uIiFyM33+HAQNg/Hh46imzqyk/f+T8Qf/l/ck6lcUO/x20cmtldkn/yq4QlZubC3DWXKTTP58+dm77c9ue276kNo0aNSInJ6dS+yit5cuXk5ycTEBAQJnOFxERuRjp6eDrC716wWuvVZ/VyI+mH+XW8Fu5yu0qNkzYwCX1LjG7pAuya2J5gwYNAGNE6kzZ2dk0bdq0xPbntj3d/nRfJbXJysqiYcOGldpHaYSHh7Nhwwbmz59Ps2bN/rXtjBkziiee+/r64uvrW+rriYiInCk319gP75prjPWgaleT1R4P/HGAASsGMKr9KEIGhVC7VuV8sbi4OOLi4gDIz88v9fl2hShXV1fc3d05ePAgnTp1AqCwsBCLxcKAAQPOa+/p6YnVaiUlJYU2bdoAkJKSgtVqLX605unpedYEcIDDhw+fdbwy+rCHzWYjJCSEPXv2sGDBAtzd3S94zqxZs2jcuLHd1xAREfk3ViuMGWMEp1Wrqs92Lnt/28vA9wcy+ZbJvNDnBWpV4tDamYMcmZmZLFq0qFTn2x31hg8fTlRUFEePHuXUqVNERETg7OxMr169zmvr7u6Ot7c3oaGhZGRkkJGRQWhoKD169KB58+YADB06lMTERBISEigoKCAhIYGkpCSGDRtWqX3YbDby8/OLE2hBQQH5+fkUFhYCRlgMDg5m3759dgcoERGR8lRUBP7+8Msv8OmnUL++2RWVj20/bqP/8v480+sZXuz7YqUGqPJQKz4+3mZPQ5vNRkREBDExMeTm5uLl5cXUqVPx8PAgLS0NPz8/5syZQ5cuXQAj0YWEhJCUlASUvMbTtm3bCA8PJzU1tXiNJx+f/73GWBl9pKamMm7cuPO+76RJk/Dz82Pfvn08+uijuLi44OTkdFab9evXn3deTk4OQ4YMISMjQyNRIiJy0Ww2eOwxYyHNHTuguvxdfu3BtUz4eAILBi3A/wZ/s8shMzMTNzc3YmJiiqcFXYjdIUrsoxAlIiLladYseOst2LkTPDzMrqZ8RHwdwZT1U3h/1PuMaD/C7HKAsoUobfsiIiJSRb33nvEG3vbt1SdAvbbzNV5JeIWYe2Loc00fs8u5KApRIiIiVdDq1cZjvA0b4O+ZMg7NZrMxffN0lu5bSvykeG684kazS7poClEiIiJVzJYtMGkSREVBz55mV3PxCooKeHDdg2w5uoUd/jto16Sd2SWVC4UoERGRKmTPHhg5EkJDYfBgs6u5eCcLTjJuzTiS/0pmp/9OWjZuaXZJ5UYhSkREpIo4dAgGDYKXXoJ77zW7mouXnpfO8A+HU1BUwOf3fc5l9S8zu6RyVU3WOhUREXFsaWlGgHrgAQgKMruai/dzxs/0jOjJpfUvZfPEzdUuQIFClIiIiOlycoztXLp1g+Bgs6u5eN+lfUePsB70uqoXa8asoYFL6bdacwQKUSIiIiYqLIR77oEGDSAiwvH3w9v24zZ6RfTioZsf4p3B7+Bcu/rOHKq+30xERKSKs9mMR3fJycZimnXrml3RxVn1/Sr8P/Vn4aCF3HfDfWaXU+EUokREREwyfz589BEkJsKll5pdzcUJSQxhZvxMVt+1mkFtB5ldTqVQiBIRETHB6tXw/PMQHw/XXGN2NRdnzo45zN01l60Tt3JLy1vMLqfSKESJiIhUsl27wM8PPvwQbr7Z7Gouzqs7XuW1Xa+xZeIWrne/3uxyKpVClIiISCU6fBiGDTP2xBsyxOxqLs7shNm8vvv1GhmgQCFKRESk0vzxh7EWVEAABAaaXc3FmZUwizd2v8GWiVu4zv06s8sxhUKUiIhIJTh5EoYPNx7fzZ5tdjUXJ/jzYOYnzq/RAQoUokRERCqczWaMPhUVwdKljr0W1MvbX2bBFwvYOmkrXZp3MbscUylEiYiIVLDgYNixA5KSoH59s6spu5e2v8RbX7zF1olbubb5tWaXYzqFKBERkQr00Ucwd64Rotzdza6m7F7c9iKL9iwiflI8nS/vbHY5VYJClIiISAXZswfuu89YyqCLAz/5emHbC7y95222TtqqAHUGhSgREZEKcOyYsZTBSy859lIGL2x7gXf2vkP8pHg6Xd7J7HKqFIUoERGRcpaZaQSnIUPg0UfNrqZsbDYbL2x7gdAvQ4mfFE/HZh3NLqnKUYgSEREpR1Yr3HknXHEFvP021KpldkWlZ7PZeH7b87z35XsKUP9CIUpERKSc2Gzw4IPGopqffw4uLmZXVHo2m41n459lyVdLiJ8UT4dmHcwuqcpSiBIRESknL78MmzdDYiI0amR2NaVns9mYuXUmYV+HKUDZQSFKRESkHCxbBm+8YSxl0KKF2dWUns1m45mtzxCxL4Jtftto37S92SVVeQpRIiIiF2nzZnj4YVi3Djo74AoANpuNaZumEfldJPGT4hWg7KQQJSIichG+/RZGj4bQUOjXz+xqSs9ms/Fo3KOs+WEN2/2207ZJW7NLchgKUSIiImV07BgMHgxPPgn33mt2NaVXZCtiymdTiEmOYbvfdjwu9TC7JIeiECUiIlIGaWlw221GiHrmGbOrKb0iWxEPxTzE5iOb+dzvc66+5GqzS3I4ClEiIiKldPw4DBgAt9zimGtBFRYVcv+6+9n5804+v+9zrmx8pdklOSSFKBERkVLIzISBA6FNG1i6FGrXNrui0ikoKsBvrR9f/v4l2/y20aKRA75KWEUoRImIiNgpNxeGDoVLLzU2FXZ2sD9FrYVW7v3kXr7/7/dsm7SN5q7NzS7JoTnYv34RERFznDplvIVns8Enn0DdumZXVDr5hfmMWzMOy3EL8ZPiadawmdklOTy7Q5TNZmPp0qXExsaSk5NDu3btCAoKonXr1iW2z8rKIiQkhMTERAC6detGUFAQrq6uxW22b99OWFgYaWlpuLu7ExAQQO/evSu1D4vFwuLFi0lOTiY9PZ158+Zx0003lfq7iIhI9VVQAPfcA3/+CVu2QIMGZldUOqcKTjFm9RiOZRxj68StNGnQxOySqgW7n+SuWrWK9evXM3fuXNauXUvnzp2ZNm0aeXl5JbYPDg4mPT2dyMhIIiMjSU9PZ/bs2cXHDxw4QHBwMAEBAcTGxuLv709wcDCHDh2q1D5cXFzo1avXWZ+V9ruIiEj1VVQEAQFw+DBs2ACNG5tdUenkWfMYuWokv2f9zpaJWxSgypHdISo6OpoxY8bg4eFB3bp18ff3x2q1kpCQcF7b1NRUkpKSCAwMxM3NDTc3NwIDA9m1axdpaWkArFu3Dm9vb3x8fHB2dsbHx4euXbsSHR1dqX1cffXVDBkyBC8vrxK/tz19iIhI9fXUU5CQABs3QhMHyx+ZpzIZFDmIrPwsNt27iUvrX2p2SdWKXSEqOzub1NRUOnT430aETk5OtG3bluTk5PPaWywWXFxc8PT0LP7M09MTFxcXLBZLcZv27c9eVt7Ly+us45XRx4WURx8iIuKYQkIgIgLi4uCKK8yupnT+yv2L25bfRl3nusRNiMOtnpvZJVU7doWo3NxcgPPmALm6uhYfO7d9SfOFzmxfUptGjRqRk5NTqX1cSHn0ISIijmfVKpg5E2Jjoa2D7YTye9bv9FnWh1Zurfh07Kc0cHGwSVwOwq6J5Q3+nkGXnZ191ufZ2dk0bdq0xPbntj3d/nRfJbXJysqiYcOGldrHhZS1jxkzZlCnTh0AfH198fX1tet6IiJivvh48PeH1auha1ezqymdn078xG0rbqNHqx6EDQvDubZexP8ncXFxxMXFAZCfn1/q8+26s66urri7u3Pw4EE6deoEQGFhIRaLhQEDBpzX3tPTE6vVSkpKCm3atAEgJSUFq9Va/FjM09PzrAngAIcPHz7reGX0cSFl7WPWrFk0drTZhyIiwjffwMiRsGgRDBpkdjWlc/ivw/Rf3p9h7Ybx1h1vUbuWg60EWsnOHOTIzMxk0aJFpTrf7rs7fPhwoqKiOHr0KKdOnSIiIgJnZ2d69ep1Xlt3d3e8vb0JDQ0lIyODjIwMQkND6dGjB82bGwt7DR06lMTERBISEigoKCAhIYGkpCSGDRtWqX3YbDby8/OLE2hBQQH5+fkUFhba3YeIiFQPR44YwWnaNPDzM7ua0vkm9Rt6RfRiwrUTWHjHQgWoSlArPj7eZk9Dm81GREQEMTEx5Obm4uXlxdSpU/Hw8CAtLQ0/Pz/mzJlDly5dACPRhYSEkJSUBJS8ttK2bdsIDw8nNTW1eI0nHx+f4uOV0Udqairjxo077/tOmjQJv79/B9lTx2k5OTkMGTKEjIwMjUSJiDiQ1FTo2dNYkfyNNxxrP7zEXxK5I/IOnuzxJE/3etrschxSZmYmbm5uxMTEFE8LuhC7Q5TYRyFKRMTxnDgBPj5w3XWOtx/e1qNbGfHhCGb3n83krpPNLsdhlSVEabaZiIjUaLm5MGQIXH01hIU5VoCKORzD2NVjWXTHIiZdP8nscmochSgREamxrFa46y5wcjKWNHBxMbsi+636fhX+n/qzfMRyRnccbXY5NZJClIiI1EhFRcbk8d9/N5Y0qF/f7Irst/jLxTwa9yhrxqxhoOdAs8upsRSiRESkxrHZYOpU2LMHduwANwdZzNtms/HqjleZs3MO68evp9fV578hL5VHIUpERGqcF1+ETz4xAtTll5tdjX2KbEU8sfEJPvjuA7b7bec69+vMLqnGU4gSEZEa5a23jP8lJMA115hdjX2shVbuX3c/CT8lsNN/J20ua2N2SYJClIiI1CCRkfDMM7BpE3TsaHY19smz5nH36rv58cSP7PTfyRWNHGwn5GpMIUpERGqE2Fj4z39g7Vrw9ja7GvtknMxg2IfDKCwqZLvfdi6tf6nZJckZHGg1DBERkbJJSIC774Zly6CELV+rpP/m/Je+y/rS0KUhG+/dqABVBSlEiYhItfbNNzBsGMyfD3feaXY19vk542d6RfSiXZN2rB27lgYuDcwuSUqgECUiItWWxQK+vjB9OjzwgNnV2Ofgnwe5NfxW+l3Tj8hRkdRxqmN2SfIPFKJERKRa+u0349HdvfcaIcoRfPnbl/SK6MXELhN5e/DbONV2Mrsk+RcKUSIiUu0cPw633w79+sHcuVCrltkVXdi2H7fRb3k/nrr1KYL7B1PLEYqu4fR2noiIVCs5OTB4MLRtC+++6xgB6tNDn3LPmntYMGgB/jf4m12O2EkhSkREqo38fBg1ytgHb+VKcHaAP+Uiv43kPzH/YcXIFYzqMMrscqQUHOCXl4iIyIUVFhrzn/76C7ZuhXr1zK7owj747gMejHmQT+7+hNvb3G52OVJKClEiIuLwbDaYPNlYziAhARo3NruiC4vaH8UD6x7g4zEfK0A5KIUoERFxeM8+C599Bjt3QrNmZldzYR//8DH3Rd/HR3d9hK+nr9nlSBkpRImIiEN7801jAnlCArRqZXY1FxZ9MJp7P7mXD0d/yB1t7zC7HLkIClEiIuKw1qwxRqG2boX27c2u5sJiD8dyz8f38P7I9xnqNdTscuQiKUSJiIhDSkyESZOMt/BuucXsai4szhLHmNVjWDp8KSM7jDS7HCkHWmxTREQczpEjxn54s2fDUAcY0Nl8ZDOjo0azZOgS7up0l9nlSDlRiBIREYdy/DjccQfccw9MmWJ2NRcWfzSeER+OIHRIKOOuHWd2OVKOFKJERMRhnDplLKbZvj28/rrZ1VzY5z99zrAPh7HwjoVM6DLB7HKknGlOlIiIOASbDR54wNjWJTYWnKr43rw7f97JkA+GMN93Pn7X+5ldjlQAhSgREXEIL74In39uTChv2NDsav5d4i+J3PHBHcwdMJf7b7zf7HKkgihEiYhIlbdsGYSEwI4d4O5udjX/bs+vexj4/kCC+wXz0M0PmV2OVCCFKBERqdLi4+Hhh+HTT6FTJ7Or+Xdf/f4Vt79/O8/7PM8jXR8xuxypYJpYLiIiVdaBA8ZE8kWLoH9/s6v5d9+lfceAFQOY0XMGj3Z/1OxypBIoRImISJWUlgaDBxvLGPj5mV3Nv/vhjx/ov7w/j3V7jCdvfdLscqSSKESJiEiVk5trLKJ5663GhPKqzHLcQv/l/Xnwpgd5pvczZpcjlUghSkREqpTCQpgwAerXh7AwqFXL7Ir+2U8nfqL/8v6Mv3Y8L/V9yexypJLZPbHcZrOxdOlSYmNjycnJoV27dgQFBdG6desS22dlZRESEkJiYiIA3bp1IygoCFdX1+I227dvJywsjLS0NNzd3QkICKB3795Vro+DBw/y7rvvYrFYqF27Nl26dGHy5Mm4V/VXREREHNCTTxpzoXbtgrp1za7mn/2S+Qv9lvdjWLthzB0wl1pVOe1JhbB7JGrVqlWsX7+euXPnsnbtWjp37sy0adPIy8srsX1wcDDp6elERkYSGRlJeno6s2fPLj5+4MABgoODCQgIIDY2Fn9/f4KDgzl06FCV6qOoqIinn34aDw8P1qxZw8qVK3FycuKVV16x99aJiIidFi2CFSuMxTQvu8zsav7Zb1m/0X95f/q37k/IoBAFqBrK7hAVHR3NmDFj8PDwoG7duvj7+2O1WklISDivbWpqKklJSQQGBuLm5oabmxuBgYHs2rWLtLQ0ANatW4e3tzc+Pj44Ozvj4+ND165diY6OrlJ95OTkcOLECQYNGkSdOnVo0KABvr6+JCcnX8RtFxGRc8XEwPTpxlIGbdqYXc0/+zXzV/os7cOtrW4ldEgotWtpZkxNZde/+ezsbFJTU+nQoUPxZ05OTrRt27bEMGGxWHBxccHT07P4M09PT1xcXLBYLMVt2rdvf9Z5Xl5eZx2vCn00atSIESNGEBsby8mTJ8nOzmbDhg306tXLnlsnIiJ2+OorGDcOli6F7t3Nruaf/Zr5K32X9aXXVb1YMmyJAlQNZ9e//dzcXICz5hGd/vn0sXPbn9v23PYltWnUqBE5OTlVqg8AHx8fvvrqKwYPHsywYcP4/fffefjhh8/rV0RESu/XX4038Z59Fu680+xq/tkvmb/QZ1kfel3Vi8XDFitAiX0hqkGDBoAxInWm7Ozs4mPntj+37bntS2qTlZVFw783RKoqffzyyy88+eSTjBw5kvXr1xMbG0u3bt2YMmXKP84HExER++TmwvDhMHCgMaG8qjqSfoReEb3oe01fBSgpZtfbea6urri7u3Pw4EE6/b3mfmFhIRaLhQEDBpzX3tPTE6vVSkpKCm3+frCdkpKC1WotfrTm6el51gRwgMOHD591vCr0kZKSQt26dRkxYkTx8bvvvpsVK1Zw9OhROnbsWOI9mzFjBnXq1AHA19cXX1/fkm+uiEgNVVQEkyYZmwm/807VXcrg4J8H6b+8P3d1vIv5vvM1ibwaiYuLIy4uDoD8/PxSn293lB4+fDhRUVEcPXqUU6dOERERgbOzc4lzg9zd3fH29iY0NJSMjAwyMjIIDQ2lR48eNG/eHIChQ4eSmJhIQkICBQUFJCQkkJSUxLBhw6pUH15eXlitVtatW0dhYSH5+fmsXr2a+vXr06pVq3+8X7NmzeKNN97gjTfeUIASESnB888bc6HWrIG//85Z5Xyb9i29I3rjd52fAlQ15OvrW/xn9axZs0p9fq34+HibPQ1tNhsRERHExMSQm5uLl5cXU6dOxcPDg7S0NPz8/JgzZw5dunQBIDMzk5CQEJKSkoCS12fatm0b4eHhpKamFq/P5OPjU3y8qvSxZ88eli5dys8//wyAh4cH9913H9dff/159yknJ4chQ4aQkZFB48aN7bm1IiI1zgcfGJsK79oF/zCgb7o9v+7B931fHu/+uFYirwEyMzNxc3MjJiameErPhdgdosQ+ClEiIv8uMRFuuw1WrzbmQlVFO37eweAPBvNinxcJ6hZkdjlSCcoSouxesVxERORipaTAsGEwe3bVDVCbj2xm5KqRvH776/znpv+YXY5UYQpRIiJSKf78EwYNMvbFmzLF7GpKFns4lrtX303okFAmdJlgdjlSxSlEiYhIhcvLM5Yy6NIF5s0zu5qSfbT/I/yi/Vg2Yhl3dqzCC1ZJlaEQJSIiFer0UgY2m7EvXu0quMTS8m+W83Dsw0TdGcXgdoPNLkcchEKUiIhUqOnT4euvjTfx6tc3u5rzhSSGMDN+JtFjo+nv0d/scsSBKESJiEiFWbjQ2A9v925o1szsas5WZCviqc1PEbEvgi0Tt9C1ZVezSxIHoxAlIiIV4pNP4KmnYNMmOGMf+CohvzAf/2h/dh3bxS7/XbRt0tbsksQBKUSJiEi527UL7r0XIiOhe3ezqzlb1qksRkeN5q+8v9gdsJvmrs3NLkkcVBWc3iciIo7s0CEYOhRee814I68qSc1Opc+yPgBsm7RNAUouikKUiIiUm9RUYxHN//wHAgPNruZsh/48RPew7nRs1pGYe2JoVLeR2SWJg1OIEhGRcpGVBYMHQ8+eUIa9XCvUrmO76BHeg3Gdx7F8xHLqOFXRHY/FoWhOlIiIXDSrFe66Cy67DMLCoFYtsyv6n09++IR7P7mX1wa8RuAtVWx4TByaQpSIiFwUm814fJeaCp9/DnWq0CDPoi8WMX3zdCJHRTK8fRWboCUOTyFKREQuyquvwpYtkJgIjRubXY2hyFbEjC0zWPLVEjZP3Ey3K7uZXZJUQwpRIiJSZjExEBwMCQnQooXZ1RjOWgMqYBftmrQzuySpphSiRESkTH74AcaPN+ZA3XCD2dUYMk5mMCpqFJmnMrUGlFQ4vZ0nIiKlduKEsQbU5Mlw991mV2P4NfNXei/tTT3nesRPileAkgqnECUiInaz2YxHeN7e4OUFL79sdkWG/f/dT7ewbtzS4haix0bjWsfV7JKkBlCIEhERuxw+DHfcAX5+8H//Z+yN5+RkdlWw/cft9Izoyf033M/ioYtxrq2ZKlI5FKJERORf5eTA00/DddeBh4cRpiZPBucqkFVWfb+KwR8M5vXbX+f5Ps9TqyotUCXVXhX4LSAiIlWRzQZr18LUqdCqlbGpcFWZQA7wxu43eGHbC3x010cMajvI7HKkBlKIEhGR8xw5AlOmwBdfGBsJT5wItavIs4vCokIe3/g4K79fydZJW7m5xc1mlyQ1VBX5LSEiIlXBqVPwyitw7bVw5ZVw8KAxB6qqBKiTBSe5e/XdfJb8GbsDditAiak0EiUiIhQWwvvvw/PPw6WXGiuQd6tii3wfzzvO8A+HU1hUyK6AXTRt0NTskqSGU4gSEanBbDbjLbuZM+HkSWPJgnvuqRpv3Z3ppxM/MShyEF5NvYgcFUkDlwZmlySix3kiIjXV5s3Gek+TJ8MjjxiP7u69t+oFqH2p++gW1o2+1/Rl9V2rFaCkylCIEhGpYRIToX9/GDMGRo8GiwUefhjq1DG7svNtStmEz1IfgryDWHjHQpxqV7GEJzWaQpSISA3x/fcwYgTcdpsx3+nIEZg+HRo2NLuyki3/ZjkjVo1g0R2LmN5zutaAkipHc6JERKq5I0eMCeOrV8MDD0BKCjSvwtvK2Ww2Zu+YzZydc4geG81tHreZXZJIiRSiRESqqexsY7mCkBBjk+AffoBrrjG7qn9XUFTAlM+mEH0omu1+27ne/XqzSxL5RwpRIiLVjM0Ga9bAo4/C1Vcbc6Cuu87sqi4s15rL2NVjsRy3kHh/Ile5XWV2SSL/SiFKRKQaOXYMHnoI9u41Vhq/915whKlEf+T8wdCVQ6njVIed/ju5tP6lZpckckGaWC4iUg3YbPDee9C5MzRrZjy6mzjRMQJUyvEUeoT34Cq3q9h470YFKHEYdo9E2Ww2li5dSmxsLDk5ObRr146goCBat25dYvusrCxCQkJITEwEoFu3bgQFBeHq6lrcZvv27YSFhZGWloa7uzsBAQH07t27yvUBsGHDBqKiovj999+pV68effv25f/+7//svX0iIhXmyBFjwnhyMqxaBQMHml2R/fb8uofBHwxm/LXjed33dWrX0t/txXHY/at11apVrF+/nrlz57J27Vo6d+7MtGnTyMvLK7F9cHAw6enpREZGEhkZSXp6OrNnzy4+fuDAAYKDgwkICCA2NhZ/f3+Cg4M5dOhQlesjKiqKZcuWERQURExMDB988AEDHem/UiJSLRUWGpPGu3SBdu2MJQwc6T9NsYdj6be8H0/3fJr5A+crQInDsftXbHR0NGPGjMHDw4O6devi7++P1WolISHhvLapqakkJSURGBiIm5sbbm5uBAYGsmvXLtLS0gBYt24d3t7e+Pj44OzsjI+PD127diU6OrpK9ZGTk0NERARTpkyhS5cuODk5Ub9+fdq1a3cRt11E5OJYLNC7NyxYADEx8M470Lix2VXZb8lXSxizegxhw8J4tPujZpcjUiZ2hajs7GxSU1Pp0KFD8WdOTk60bduW5OTk89pbLBZcXFzw9PQs/szT0xMXFxcsFktxm/bt2591npeX11nHq0If+/fv5+TJk/zyyy9MmDCBkSNH8uSTTxYfFxGpTDYbLFkCN9wAN94I334LffqYXZX9bDYbz8U/x5ObnuSzez5jTKcxZpckUmZ2zYnKzc0FOGse0emfTx87t/25bc9tX1KbRo0akZOTU6X6yMjIAGDHjh3Mnz+fxo0bs3TpUqZPn86yZctK7F9EpCL897/G3Kc9e4wlDG6/3eyKSie/MJ/7P72f7T9tZ8d9O+h0eSezSxK5KHaFqAYNjM0es7Ozz/o8Ozubpk2bltj+3Lan25/uq6Q2WVlZNPx7/4Gq1AfA+PHjadasGQD3338/n3zyCfv378fb2/u8/gFmzJhBnb83ovL19cXX17fEdiIi9oiNBX9/4xHed99BkyZmV1Q6J06eYHTUaE6cPEFiQCJXNLrC7JJEiIuLIy4uDoD8/PxSn29XiHJ1dcXd3Z2DBw/SqZPxN4fCwkIsFgsDBgw4r72npydWq5WUlBTatGkDQEpKClartfjRmqen51mTtwEOHz581vGq0Efbtm0BSr1n06xZs2jsSBMURKRKOnXK2N8uIgLeestx1n06008nfmLwB4O5+pKr2e63Hdc6GsGXquHMQY7MzEwWLVpUqvPtnlg+fPhwoqKiOHr0KKdOnSIiIgJnZ2d69ep1Xlt3d3e8vb0JDQ0lIyODjIwMQkND6dGjB83/3rBp6NChJCYmkpCQQEFBAQkJCSQlJTFs2LAq1cfll19Oz549iYyM5Pjx4+Tn5xMeHk6jRo3o3LlzqW62iEhpWCzQowfs2AFffuk46z6d6avfv6JbWDd6XdWL6LHRClBSrdSKj4+32dPQZrMRERFBTEwMubm5eHl5MXXqVDw8PEhLS8PPz485c+bQpUsXwEh0ISEhJCUlASWvz7Rt2zbCw8NJTU0tXp/Jx8en+HhV6SMnJ4eFCxeyY8cOateujZeXF4GBgSWukZWTk8OQIUPIyMjQSJSIlFlUlDH/6b77YM4cqFvX7IpK77Pkzxi7eiwze8/kyR5PlnpEX6QyZWZm4ubmRkxMTPGUnguxO0SJfRSiRORinDxp7Hm3apXxCG/4cLMrKpvQvaE8vvFxwoeFc3fnu80uR+SCyhKitHeeiEgVcfgwjBkD9erB118bmwc7miJbETO2zGDxV4uJmxBHz6t6ml2SSIXR8rAiIlXAypVw881w223w+eeOGaBOFpxk/Mfj+ejAR+zy36UAJdWeRqJEREyUlwdBQbB6NURGwtChZldUNul56YxYNYJTBafYHbCbyxtebnZJIhVOIUpExCTffGMsWeDqajy+u+oqsysqm58zfmZQ5CA8L/Nk5eiVNHBpYHZJIpVCj/NERCqZ1QovvQTdu8OIEbB9u+MGqG/TvqV7WHd6XdWLNWPWKEBJjaKRKBGRSrRvn7HyeEGBsf7TjTeaXVHZbT26lVGrRjHt1mk83fNpLWEgNY5GokREKkF2NjzxhLF45pAhsHevYwYom83Gd2nf8eK2Fxm6cihvDnyTGb1mKEBJjaSRKBGRCrZuHUyeDNdcY6w83qGD2RWVzsmCk2z7cRsxh2OIORzDH7l/cHub24kZF0Pf1n3NLk/ENApRIiIV5Mcf4bHHjDlPr70Gfn5Q20HG/zNOZrDu8Do+/uFjNqZs5LL6lzG03VBCh4TS55o+1HOuZ3aJIqZTiBIRKWd//gmzZsE778DYsXDwIDRrZnZVF3Y87zifHvqU1QdWs+nIJjo168SoDqN4oc8LXHv5tXpkJ3IOhSgRkXKSkwMhIcZedz17QlIS/L2daJWVX5hPzOEYln2zjPXJ67nO/Tru7HAnIQNDaHNZG7PLE6nSFKJERC5SQQGEh8MLL0CrVhAdDX36mF3VP7PZbOz9bS/LvlnGyu9Xckm9S5jYZSLzfefjcamH2eWJOAyFKBGRMrLZ4JNPYMYM45/fegtGjYKq+tQrPS+dsK/DCP86nF8yf2FMpzGsvXstPa/qqUd1ImWgECUiUgbbtsFTT8FPPxkjUP7+4OJidlUlO/TnIRYkLWDpN0u56YqbeKbXM4zsMFILY4pcJIUoEZFS+PprePpp2L0bpk+HqVOhYUOzqzqfzWZj85HNvJn0JluObGFMpzF87vc5N7W4yezSRKoNhSgRETtYLPDss8Z8p8mTjc2CmzQxu6rznSw4SeS3kcxPnE9aThqBNweyZOgSrmh0hdmliVQ7ClEiIv/it9/g5Zdh6VKYMAEOH4YrrzS7qvP9lfsXoXtDeeuLt7is/mU83v1xxncZr/WcRCqQQpSISAlOnDCWKliwAAYNMh7jtW9vdlXnO5J+hPm75xO+Lxzvlt6EDw9noOdAatdykFU9RRyYQpSIyBlyc2HhQnj1VbjhBmMC+S23mF3V2YpsRWz7cRvv7H2HTw99yugOozXfScQEClEiIvxvracXXwR3d1i1CgYMMLuqs6VmpxLxdQRhX4eRcSoDv+v8OPzIYa6+5GqzSxOpkRSiRKRGs9kgJgaefBKKiuDNN2H06Kqzx53NZiP+x3gWfrGQmMMx9LmmD7P7z2Z4++HUcapjdnkiNZpClIjUWN98A48/Dvv2wUsvwQMPVJ21nnKtuUR+G8mCLxbwe9bvPHDjA7z+yOu0vrS12aWJyN8UokSkxklLg5kz4f334ZFHYPVquOQSs6sy/JzxM2/veZvFXy3mysZXEuQdxD3X3kN9l/pmlyYi51CIEpEaIz0d5s0zNgn29YXvv4c2VWCPXZvNxo6fd7DgiwV8euhTBrcdzJoxa/C52kfbsYhUYQpRIlLtZWUZwWnePLj5Zti0Cbp3N7sqyM7P5qP9H/HWF29x9MRR7r/hfg49cohrLrnG7NJExA4KUSJSbeXmwttvG+s9tW1rbBbct6+5NRUWFRL/YzzLv1nOxz98jMelHjx8y8Pc2+VeGtapgvvHiMg/UogSkWonNxdCQ43wdOWVsGyZsWCmmU/G9v93Pyu+XcH7375PQVEB468dzw7/HVzX/Do9shNxUApRIlJt5OXBu+8a4emKK2DJEhgyxLzw9N+c/7Lyu5Us/3Y5B/44wIj2I1g8dDED2gzAubb+8yvi6PS7WEQc3smT8N57xirjzZsbo1DDhpkTnvKseaw7vI7l3yxnY8pGerTqweRbJjO6w2jc6rlVfkEiUmEUokTEYZ08aYw2zZ4NTZvCokUwfHjlL5RZZCti5887Wf7NcqIOROHu6s7ELhNZeMdCTRIXqcYUokTE4Zw6BWFhMGsWXHYZvPUWjBhR+eEp+a9kVny7ghXfriDzVCZjO41l44SNdG3ZVfOcRGoAhSgRcRinTkFEhBGe3NyMLVpGjarc8HQ87zirvl/F8m+X89XvXzG47WDm+87njrZ3aBsWkRpGIUpEqrz8fCM8BQdDo0bGek933ll54amwqJDPkj9j6TdLiTkcw41X3MjELhOJGRdDkwZNKqcIEaly7A5RNpuNpUuXEhsbS05ODu3atSMoKIjWrUvexykrK4uQkBASExMB6NatG0FBQbi6uha32b59O2FhYaSlpeHu7k5AQAC9e/eucn2clpOTQ0BAAGlpaWzevBknJyd7b5+IlIHVCkuXGuGpQQN47TUjPFXWb73fsn4j7KswFn+1mCJbEX7X+zG7/2zaNWlXOQWISJVm99/jVq1axfr165k7dy5r166lc+fOTJs2jby8vBLbBwcHk56eTmRkJJGRkaSnpzN79uzi4wcOHCA4OJiAgABiY2Px9/cnODiYQ4cOVbk+Tlu4cCGtWrWy95aJSBlZrcacp3bt4I03jInj330Hd99d8QGqyFbExpSNjI4azTVvXsOuX3bx1qC3+DHoR17p94oClIgUsztERUdHM2bMGDw8PKhbty7+/v5YrVYSEhLOa5uamkpSUhKBgYG4ubnh5uZGYGAgu3btIi0tDYB169bh7e2Nj48Pzs7O+Pj40LVrV6Kjo6tUH6ft2rWLo0ePMnbs2DLcZhGxR0GBMfLUvj3MnQuvvGLsbzduXMWHp6xTWYQkhtDurXbc+8m9eDXx4tAjh1g/fj3D2w/Xuk4ich67QlR2djapqal06NCh+DMnJyfatm1LcnLyee0tFgsuLi54enoWf+bp6YmLiwsWi6W4Tfv27c86z8vL66zjVaEPgIyMDBYsWMD06dP1CE+kAhQWwvvvQ4cOxqO7F16A/fth/PiKD08/Z/zMExuf4Mr5V/LB9x/wSr9XOPboMWb1n0XrS0ueriAiAnbOicrNzQU4ax7R6Z9PHzu3/bltz21fUptGjRqRk5NTpfoAmD9/PoMHD6Z169bs27fvvP5EpGyKiiAqCl580Xjz7rnnYMIEcK6EQZ+vfv+KuTvn8snBTxjmNYz149fT/cruWppAROxm13+qGjRoABgjUmfKzs6madOmJbY/t+3p9qf7KqlNVlYWDRs2rFJ9bN26ld9++41nn332vH7+zYwZM6hTx3jd2dfXF19f31KdL1Ldbd0Kjz0Gx4/Ds8+Cnx+4uFT8dRN+SmDWjll8/tPn3H/D/RycfFAjTiI1VFxcHHFxcQDk5+eX+ny7QpSrqyvu7u4cPHiQTp06AVBYWIjFYmHAgAHntff09MRqtZKSkkKbNm0ASElJwWq1Fj9a8/T0PG/y9uHDh886XhX6+OKLLzh27BijRo0q/t4Ao0aNIjAwkIEDB5Z4z2bNmkXjxo3/5a6K1EzJyfDkkxAfb4SnKVOgbt2KvabNZmODZQOzdsziu7TveKTrIywfsZxmDZtV7IVFpEo7c5AjMzOTRYsWlep8uyeWDx8+nKioKI4ePcqpU6eIiIjA2dmZXr16ndfW3d0db29vQkNDycjIICMjg9DQUHr06EHz5s0BGDp0KImJiSQkJFBQUEBCQgJJSUkMGzasSvUxefJkli9fzpIlS1iyZAlPPPEEAO+++y4+Pj6lutkiNdmJE/DEE9ClC7i7G2HqiScqNkAVFhWy+sBqbnrvJiatncTgtoP5KegnXun3igKUiFy0WvHx8TZ7GtpsNiIiIoiJiSE3NxcvLy+mTp2Kh4cHaWlp+Pn5MWfOHLp06QIYiS4kJISkpCSg5PWZtm3bRnh4OKmpqcXrM50ZTKpKH2fat28fjz766D+uE5WTk8OQIUPIyMjQSJQIxht3YWEwc6YRoObPN/6/IlkLrUR+F8mrO14l15rLkz2eJODGABq4NKjYC4uIw8rMzMTNzY2YmJjiKT0XYneIEvsoRIn8z5Yt8OijkJcHr78OQ4dCRc7bzrXmEvZVGPN2z6Oecz2euvUpxncZr+1YROSCyhKitPCJiJS7w4eNeU/btxtv3D3yCNSpwByTnpfO23veJiQphCsbX8lrA15jdIfRONXWkiQiUnEUokSk3Pz5J7z0EixebLxtl5wMzSpw6tHvWb8zP3E+oXtDufGKG1kxcgW3t7ldyxSISKVQiBKRi3byJLz1lrFQZs+e8OWX0LFjxV3vSPoR5u6cy7JvljHAYwBxE+Lo3qp7xV1QRKQEClEiUmY2G6xaBU89BZdcAmvWQP/+FXe979K+49Wdr7LmwBru7Hgnex7YQ+fLO1fcBUVE/oVClIiUyd69EBQER47ArFlw770Vt0XL7mO7mb1jNpuObOK+6+/jwOQDeFzqUTEXExGxk93rRImIAKSmgr8/9O4NffoYk8j9/Mo/QNlsNrYc2ULfZX3xfd+XDk07cHTqUd4e/LYClIhUCRqJEhG75Ocb855eegkGDIADB+CaayrmWtt/3M5z257ju7TveLTbo3w85mMurX9pxVxMRKSMFKJE5F9ZrcYmwS+/bGwM/Mkn0K9fxVxr5887eW7bc3z525c81v0xPh37KW713CrmYiIiF0khSkRKdPw4vPceLFwI9evD44/D/fcbQaq8Hf7rME9sfIJtP24jqFsQq+9arZEnEanyFKJE5CyHD8Obb8KyZXDLLbBoEQwZUjGTxk+cPMHL21/m7b1vc9/193Fk6hGaNmha/hcSEakAClEigs0G8fHGvnabNsGYMbBjB9xwQ8Vcr7CokMVfLebZ+Ge53v16LVUgIg5JIUqkBjt1ClauNMLTr7/CQw/Bu+9CixYVd82tR7cStCGIvII8woaFMbTdUK0wLiIOSSFKpAb64w945x14+2249FJjvad774UGDSrumpbjFp7c9CRbj27lud7PMcV7ijYGFhGHpnWiRGqQ5GR48EG46irjcV1EBOzfb3xWUQEq42QG0zZN49p3ruXyBpeTPCWZx3s8rgAlIg5PI1EiNcDevTBnDqxbZ8x3+uILuPbair1mYVEh4V+HMzN+Jp2adSIxIJHr3K+r2IuKiFQihSiRaspmMyaJz5kDSUnG8gSHDxujUBVt+4/bCYoLIvNUJqGDQxnRfoTmPYlItaMQJVLN5Ocbi2O+8QYcOwZTphg/N2lS8dc+kn6EJzc9yaaUTczsPZOp3lOp61y34i8sImIChSiRauKPP4w36xYtgsaN4f/+D+67r2Ini5+WdSqLWQmzCEkK4Z5r7+HwlMO4u7pX/IVFREykECXi4L79FkJC4IMPoFcvCAuDgQOhdiW8NlJkK2LpvqXM2DIDr6Ze7PTfyQ1XVNDiUiIiVYxClIgDKiiATz81tmRJTIQJE2DPHuhcietVJvyUQFBcEMfzjrPwjoWM7jBa855EpEZRiBJxIGlpsGQJhIYaI02BgcZ8p6aVuFPKjyd+ZNqmaay3rGdGzxk82v1R6jnXq7wCRESqCIUokSrOZjNGmxYtgtWrwcfH+OfBgytmP7t/kp2fzas7XuWN3W9wd+e7OfzIYa5odEXlFSAiUsUoRIlUUbm58OGHxiO7lBRjkvi330K7dpVbx/G844R/Hc4bu9/A41IPPr/vc25ucXPlFiEiUgUpRIlUMSkpxpYs4eFw5ZUweTKMHw+urpVXQ5GtiG0/biPs6zA+/uFjurbsysI7FjKy/UjNexIR+ZtClEgVUFQEGzYYj+k2b4YRIyA6Gnr2hMrMLMcyjrF031Ii9kWQnZ/NvV3uZe8De+l0eafKK0JExEEoRImY6PhxY8TpnXcgL8/Yw27xYmjRovJqyDyVSezhWJZ/u5wtR7YwoM0A5t0+jyHthmh/OxGRf6EQJWKCr74yRp1WroRbboHZs2HkSHBxqZzrp+el8+mhT1n9w2o2pWyibZO2jO00lsVDF3Nl4ysrpwgREQenECVSSU6eNN6uW7QIvvvOWNspKaniNwI+7b85/2XtwbWs+WEN8Ufj6dK8C6M7jOb121+nXZNKnq0uIlINKESJVLAffoD33oNly6B5c3joIWP+k5tbxV/7t6zf+PiHj1nzwxp2/LyDW1rcwugOowkdHErrS1tXfAEiItWYQpRIBcjOhk8+MeY3ffEF3Hln5UwULygqYO9ve9mUson1lvXs+W0PPa/qyegOo3l/5Pu0bNyy4i4uIlLDKESJlJPCQtiyBVasMAJU69bG2k6ffAJNmlTMNW02G5bjFjYd2cSmI5uIPxqPU20n+rfuj/8N/qwdu5bLG15eMRcXEanhFKJELtIPP0BEBLz/vrG6+D33wI4dcN11FTPq9Gfun2w5soVNRzax+chmfs/+nZ5X9WSAxwBm9prJ9e7X41S7EpcyFxGpoewOUTabjaVLlxIbG0tOTg7t2rUjKCiI1q1LnleRlZVFSEgIiYmJAHTr1o2goCBcz1gxcPv27YSFhZGWloa7uzsBAQH07t27SvWRnp5OaGgo3377LSdOnMDNzY3+/fszadIk6tTR6981VWamsWddeLjxpt2oUUaQuu228t+K5WTBSXb8vINNKcZo0zdp33Dt5dcywGMA7w55l15X96KBS4PyvaiIiFyQ3SFq1apVrF+/nrlz59KyZUuWL1/OtGnTWL58OfXr1z+vfXBwMFarlcjISABeeuklZs+eTXBwMAAHDhwgODiYZ555hltvvZWdO3cSHBxM8+bN8fLyqjJ95OXl0apVKyZOnMgVV1zB77//znPPPcepU6d45JFHynTTxTHZbJCQYASnjz6CDh3A3x9iY+HSS8vvOkW2Ir5J/YbNRzaz6cgmEn5OoEn9JgxoM4AnejxB/9b9ae7avPwuKCIiZVLb3obR0dGMGTMGDw8P6tati7+/P1arlYSEhPPapqamkpSURGBgIG5ubri5uREYGMiuXbtIS0sDYN26dXh7e+Pj44OzszM+Pj507dqV6OjoKtVHixYtmDBhAi1btqR27dq0bNmSQYMG8fXXX1/EbRdH8uOP8NJL4OlpjDhdcgns2gV798LDD198gLLZbHz/3+95K+ktRq0aRbPXmtF7aW8+//lzhrQbwlf/+Ypjjx4jYngE91x7jwKUiEgVYddIVHZ2NqmpqXTo0KH4MycnJ9q2bUtycjK33377We0tFgsuLi54enoWf+bp6YmLiwsWi4XmzZtjsVjo06fPWed5eXnx+eefV6k+SrJ3717atm37zzdMHF52trGm07JlsHMnDBoEr70GgwdD3boX13eRrYgDfxzg858+Z/tP24k/Gk+ONYdbW91K32v6Mu3Wadx0xU24OFXSypsiIlImdoWo3NxcgLPmEZ3++fSxc9uf2/bc9iW1adSoETk5OVWqj3MtX76c5ORkQkNDSzwujquoCLZvN4LT6tXQpg34+cGHHxrrO5WVzWbj27Rv2XxkMwk/J5DwcwInC07So1UPel/Vmyldp9C1ZVdtsSIi4mDsClENGhiTVrOzs8/6PDs7m6ZNm5bY/ty2p9uf7qukNllZWTRs2LBK9XGm8PBwNmzYwPz582nWrNl5x8UxpaTA8uVGeMrJgfHjjbfrrr++7H0ezzvOppRNbEjZwAbLBrLzs+lzTR98rvZhRq8Z3OB+g0aaREQcnF0hytXVFXd3dw4ePEinTsZu7oWFhVgsFgYMGHBee09PT6xWKykpKbRp0waAlJQUrFZr8aM1T09PDh06dNZ5hw8fPut4VegDjJGEkJAQ9uzZw4IFC3B3d7/gPZsxY0bx23u+vr74+vpe8BypPFlZxuTwpUuNrVfuuANCQozHdmV56bKwqJC9v+1lg2UDG1I2sOfXPXS+vDMDPQeycvRKerTqoZEmEZEqJi4ujri4OADy8/NLfb7db+cNHz6cqKgobrzxRlq0aMGKFStwdnamV69e57V1d3fH29ub0NBQZs6cCUBoaCg9evSg+d/PRYYOHUpQUBAJCQl0796d3bt3k5SUREhISJXqo7CwkNmzZ2OxWFiwYAFN7Fw1cdasWTRu3Nje2yuVoKgI4uON4LRmDbRvbzyuW7MGyjKwmJqdSpwljg0pG9iYshGbzcaANgN48KYHWTNmDS0atSjvryAiIuXozEGOzMxMFi1aVKrza8XHx9vsaWiz2YiIiCAmJobc3Fy8vLyYOnUqHh4epKWl4efnx5w5c+jSpUtxMSEhISQlJQElr8+0bds2wsPDSU1NLV6fycfHp/h4Vehj3759PProo7i4uOB0zgJA69evP+8+5eTkMGTIEDIyMhSiqojDh43HdcuXw6lTxsa/kybB379U7WYttLLr2K7i0aZv077l5hY3M7DNQAZ6DuSWlrfgXFvr14qIOKLMzEzc3NyIiYkpcUpPSewOUWIfhaiqIS3NmBAeGQnffANDhxqjTr6+4FKKqUg/nfiJuJQ4Nlg2sPnIZuq71Geg50AGthnIgDYDaNrg/DmBIiLieMoSovTXZqk2Tm/6Gxlp7GHXsyf85z8werT9azmdKjjF9p+2G6NNlg0kH0+mR6seDGwzkGd7P8t17tdRu5bdy6uJiEg1phAlDq2wEDZv/t+mv56extt1ixdDq1b29fFHzh98lvwZ6w6vIy4ljkvqXcIdnncQ3C+Yfq374VbPrWK/hIiIOCSFKHFI335rzHH64APj5wkTIDERrr32wufabDYO/XWITw99yqeHPiXxl0RuuOIGhrYbyszeM7mu+XXUqoidg0VEpFpRiBKH8ddfxlpOy5aBxWJswbJ0KfTvf+FNfwuKCth1bFdxcDqWeYzbPG5j4nUTiborSm/SiYhIqSlESZVmsxn71IWGGus6de0Kjz1mBKhGjf793IyTGWxM2ci6w+uITY7FqZYTQ9sN5bUBr3Gbx200rGPfxEEREZGSKERJlZSRAe+/b4SnY8eMJQm++go6dvznc2w2Gwf/PEhsciyxybHs+HkHbS9ry3Cv4cSMi6Fry6441b7AkJWIiIidFKKkSvnySyM4ffCBMb/pscfg7rvh7116znOy4CTbftxG7GEjOP2W9Rv9Wvfjzg53Ej4snNaXtq7cLyAiIjWGQpSYLifHWNMpNBR++MGYJL5jB9xwQ8ntj2Uc47Pkz4hNjmXL0S00qd+EwW0Hs2DQAvq17kcDl39IXCIiIuVIIUpMY7HAwoXG5PBrroGHHoJ77oFz1ygtKCog8ZfE4tGmA38coEerHgxuO5hZ/WfRqVknvU0nIiKVTiFKKlVREWzaBAsWGOs73XknrF8P3brBmTnor9y/2GDZQGxyLBssG6hdqzaD2g5iRq8Z+Lbx5dL6dq6eKSIiUkEUoqRSZGUZSxO89RacOAGBgbBkCVxxxf/a/Jn7J2sOrOHD/R+S8FMCXZp3YXDbwXw2/jNuaXGLJoWLiEiVohAlFSo5GRYtgvBw8PKCZ5+Fu+6CunWN4xknM1h7cC0f7v+QLUe2cEvLW7i70928P/J9WjZuaW7xIiIi/0IhSspdbi6sXg1hYcYq4qNGwcaN4O1tPLLLyc9h7fcxfLj/Q9Ynr6djs46M7TyW0MGhXH3J1WaXLyIiYheFKCkXNpuxPMGSJbByJVx5JQQEGGGqWTNjY99PD23gw/0f8umhT7nK7SrGdR7Hq/1fxaupl9nli4iIlJpClFyU9HRjUcwlS+DIERg7FuLijFGnQlsBW49u5cNdH/LxDx9zWf3LGNt5LLsDdnPt5dfqjToREXFoClFSajabsY7Te+8ZI0033ABBQcZcpwYNi9jx8w4mf/YhHx34iDpOdbi7091svHcjt7S4RcFJRESqDYUosdsff8Dy5caoU1oaTJwIe/ZAp0429vy2h+d2fkjU/ihOFZ7iro53sWbMGnpe1ZPatWqbXbqIiEi5U4iSf1VUBFu3wuLFsHYtdO9uvGE3cqSNH058zQcHVvPhlg85nnecUR1GET48nH6t++FcW7+0RESketOfdFKi3383VhJfssRY48nPD7791saJhl+w5oc1zHxvNX/m/smQdkN4c+Cb+Lbxpa5zXbPLFhERqTQKUVKsoMCYFL5kCcTGQt++MPvVIprduIvo5NUM+OxjsvKzGOY1jJCBIQxoM4B6zvXMLltERMQUClHC/v3GqNP774OzM9w7qYC7piWw8/hqgg5+Qv7RfEa2H8l7Q9+jX+t+1HGqY3bJIiIiplOIqqGOH4cPPzTC03ffwYhRVv5vQTxH6q5myaG11N5Zm1EdRrFi5Ap8rvHRHCcREZFz6E/GGiQ/Hz77zBhxiomB6286hfeEzbR1X836o9EkHGvA6A6jWT1mNbe2ulV71YmIiPwLhahqzmaD3bthxQqIigLXS/PwvieO24esZnvqOlKLLmW022hi74nF+0pvLUcgIiJiJ4Woauqnn4zgtGwZ/JGRzS3j1nP9K6tJSo/l60ZXMPrK0Tx3+xZuuuImLYApIiJSBgpR1UhODqxZYwSnz5My6TwqhssCV/NL3np+ueQa7mp/F290mEGX5l0UnERERC6SQpSDKyqChARjgvhHMce5xPtTGvddQ+0+Gylq1p7BHUYT0fEVOjbraHapIiIi1YpClIM6csTYgiUsKpX0y9dy2a0fc3JKPM3du3BnhzsZ3fF12jVpZ3aZIiIi1ZZClAPJyoKPPoJ3V/3E3uxPuKTHGk7cvZtuV3bjzo6jGdnhPa655BqzyxQREakRFKKquNN71739/i+s+3ElLjes4lSPb7j1Sh/GdbmHEe2juKLRFWaXKSIiUuMoRFVRycnw3rJMwnavIdvjfQqv+Zyu3n35T7fJDPMaRpMGTcwuUUREpEZTiKpCTpyAlausLPgsjsP13of20Vzj24Gne0xg/HUraNGohdklioiIyN8UokxWWAgbN9qYH/UFW/9aQa3Oq2h0cwP+74bx3N91L50u72R2iSIiIlICu0OUzWZj6dKlxMbGkpOTQ7t27QgKCqJ169Ylts/KyiIkJITExEQAunXrRlBQEK6ursVttm/fTlhYGGlpabi7uxMQEEDv3r0dso/SOnAA5i3/no9++JC8Nh/ifPWfjOw7hik+a+h5VU+tHC4iIlLF2f0n9apVq1i/fj1z585l7dq1dO7cmWnTppGXl1di++DgYNLT04mMjCQyMpL09HRmz55dfPzAgQMEBwcTEBBAbGws/v7+BAcHc+jQIYfrw17Hj8OLb6Vw5T3BdF50LcvrduXG25JZFTCPEzNT+Wjie/S+urcC1N/i4uLMLqHa0L0sP7qX5UP3sfzoXprH7j+to6OjGTNmDB4eHtStWxd/f3+sVisJCQnntU1NTSUpKYnAwEDc3Nxwc3MjMDCQXbt2kZaWBsC6devw9vbGx8cHZ2dnfHx86Nq1K9HR0Q7Xx78pKIBlH//KdQ/Np+lT3rz4Zwcu65LIu/c+zYln/sv2KasY3WkE9Zzr2fuvosbQfxjKj+5l+dG9LB+6j+VH99I8doWo7OxsUlNT6dChQ/FnTk5OtG3bluTk5PPaWywWXFxc8PT0LP7M09MTFxcXLBZLcZv27dufdZ6Xl9dZxx2lj5L8kJLJHTPDaPBwH/y+uYaM5jG8NOIB/nwqlW+fWscD3e7BtU7ZHweKiIiIueyaE5Wbmwtw3hwgV1fX4mPnti9pvtCZ7Utq06hRI3JychyujzPZbDYAukV40rh2eybeOI7H73iPlpe4Gw2skGnNPO88OV9+fj6ZmbpX5UH3svzoXpYP3cfyo3tZPk7fw9N/jtvDrhDVoEEDwBiROlN2djZNmzYtsf25bU+3P91XSW2ysrJo2LChw/VxpuI5Ym+dIpNvCOMbwnjqvHZin0WLFpldQrWhe1l+dC/Lh+5j+dG9LD95eXl2vzhmV4hydXXF3d2dgwcP0qmT8cp9YWEhFouFAQMGnNfe09MTq9VKSkoKbdq0ASAlJQWr1Vr8WMzT0/OsydsAhw8fPuu4o/RxpiZNmhAVFUX9+vWpVavWhW+uiIiImM5ms5GXl0eTJvYvZm33EgfDhw8nKiqKG2+8kRYtWrBixQqcnZ3p1avXeW3d3d3x9vYmNDSUmTNnAhAaGkqPHj1o3rw5AEOHDiUoKIiEhAS6d+/O7t27SUpKIiQkxOH6OFPt2rVp1qyZvbdVREREqojSLl1UKz4+3q6HfzabjYiICGJiYsjNzcXLy4upU6fi4eFBWloafn5+zJkzhy5dugDGs8WQkBCSkpKAktdW2rZtG+Hh4aSmphavz+Tj41N83JH6EBERkZrF7hAlIiIiIv+jVR1FREREykB755WT0m6LI/9s69atrF27lpSUFHJzc9m8eTNOTk5ml+Vw3nvvPRITE0lLS6NevXpcf/31PPjgg1x++eVml+Zwli1bxsaNG8nIyMDJyYl27drx4IMPlvhyidjv2WefZceOHcybN4+bbrrJ7HIcytKlS1mxYgV16tQp/qxHjx48++yzJlbluPbv309YWBgHDx6kdu3aXHPNNSxYsIDatf99rEkhqpycuS1Oy5YtWb58OdOmTWP58uXUr1/f7PIciqurK8OHD+fUqVO89tprZpfjsGrVqsX06dPx8PDg1KlTzJ8/nxkzZrBkyRKzS3M4ffv2ZdSoUTRq1Air1conn3zCtGnT+OijjxTwyyguLo6TJ0+aXYZD69ixI2+99ZbZZTi8/fv3M336dKZMmcKsWbNwcXHh0KFDdr1hr8d55aQ02+LIv+vatSv9+/enRYsWZpfi0B544AG8vLxwcXHB1dWVcePGkZKSQlZWltmlOZyrrrqKRo0aAcaoc+3atUlPT9e9LKM//viD8PBwnnjiCbNLEeHdd9/ljjvuwNfXl3r16uHk5ETHjh3tClEaiSoHF9oW5/bbbzexOhHDnj17aN68eXEYkNLZvXs3wcHB5OTkUKtWLe68804uueQSs8tyODabjblz5zJhwoQSl4kR+1ksFkaMGEG9evXo1KkT999/P1dccYXZZTmUkydPsn//fjp27EhgYCC//fYbzZs3Z/z48We9pf9PFKLKQWm3xRGpbF9++SXLly/nxRdfNLsUh9W9e3diYmLIzMwkLi5O68GVUXR0NDabjaFDh5pdikPz8fFh4MCBNG/enD///JN3332XJ554giVLlmgKSSlkZWVRVFTExo0bmTVrFm3btmXnzp28/PLLNG3atHiB8X+ix3nl4N+2xSlpaxiRyrR7926ef/55ZsyYQdeuXc0ux+E1btyY0aNHM2/evH/dhFzO9+uvv7JixQo9xisHrVu3xt3dnVq1atGsWTOmTZvGH3/8wffff292aQ7ldOD09fWlffv2ODk50bt3b66//np27NhxwfM1ElUOSrstjkhl2bRpEyEhITz33HMKUOXIZrNRUFDAr7/+qjf0SuG7774jMzOTBx988KzPn3/+efr06aNwdRFq1apFrVq1SrV5rhh/frdo0aLM27QpRJWT0myLI/+usLCQwsJCrFYrYOxQ7uTkhLOz8wVfN5X/+eSTTwgPD2fWrFnFOwlI2axevZp+/fpx2WWXceLECZYsWYKzszOdO3c2uzSH0qdPn/OWMhgzZgyPPfYYN998s0lVOab4+HhuvPFG3NzcOH78OKGhoVx66aX6NVkGI0eO5IMPPqBfv354eHiwe/duvvnmG+67774LnqsVy8vJv22LI6WzYcMG5syZc97n8+fP5/rrr6/8ghxU3759cXJywsXF5azPz9yeSezz9NNPc+jQIfLy8mjQoAHt27dn4sSJeHl5mV2aw+vbt6/WiSqDZ555hv3793Py5EkaNWpEly5d8Pf3p2XLlmaX5pAiIyOJjo4mOzubK6+8kokTJ9KzZ88LnqcQJSIiIlIGejYiIiIiUgYKUSIiIiJloBAlIiIiUgYKUSIiIiJloBAlIiIiUgYKUSIiIiJloMU2RUREpEJs3bqVtWvXkpKSQm5uLps3b8bJycmUa506dYrZs2djsVj47bffGD9+PAEBARd1TY1EiYiISIVwdXVl+PDhTJ482fRr1apVi06dOvH444/Tvn37crmmRqJERESkQpzes3Pfvn0lHj9w4ADvvfceR48epX79+tx+++1MmjSpTKNVF7pWnTp1uOuuu4r/uTxoJEpEREQq3c8//8zjjz/OsGHD+Pjjj3nzzTfZuXMnK1euNLs0u2kkSkRERCrd2rVr6dGjB/369QPA3d2dsWPHsnTpUiZMmADA2LFjSUtL+8c+Jk2ahJ+fX2WUWyKFKBEREal0v/76K19//TVDhgwp/sxms1FUVFT88+LFi8/6+Vx169at0BovRCFKREREKt1ll11G//79mT59+j+2adSoUSVWVHqaEyUiIiIVorCwkPz8fKxWKwD5+fnk5+dTVFTE8OHD+fzzz9m2bRtWq5XCwkJ+/fVXvvjii3K/1mmnPzs94nVm+7KoFR8fbyvz2SIiIiL/YMOGDcyZM+e8z+fPn8/111/PgQMHiIiIIDk5mYKCAtzd3Rk2bBjDhg0r92tByXOsrrvuOt58881SXw8UokRERETKRI/zRERERMpAIUpERESkDBSiRERERMpAIUpERESkDBSiRERERMpAIUpERESkDBSiRERERMpAIUpERESkDBSiRERERMpAIUpERESkDP4f+JKMvlBbyN0AAAAASUVORK5CYII=\n",
+
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -467,53 +403,38 @@
     }
    ],
    "source": [
-    "NaCl_1400K.run_computation.GreenKuboSelfDiffusionCoefficients(plot=True, data_range=50)"
+    "NaCl_1400K.run_computation.EinsteinDiffusionCoefficients(plot=True, data_range=300)"
+
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "#NaCl_1400K.run_computation.GreenKuboIonicConductivity(plot=True, data_range=150)"
+    "#NaCl_1400K.run_computation.EinsteinHelfandIonicConductivity(plot=True, data_range=13)"
+
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "#NaCl_1400K.run_visualization()"
+    "#NaCl_1400K.run_computation.GreenKuboSelfDiffusionCoefficients(plot=True, data_range=13)"
+
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████| 1/1 [00:00<00:00, 32.01it/s]\n",
-      "No handles with labels found to put in legend.\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "NaCl_1400K.run_computation.RadialDistributionFunction(start=1, stop=150, number_of_configurations=100)"
+    "#NaCl_1400K.run_computation.RadialDistributionFunction(start=1, stop=150, number_of_configurations=100)"
+
    ]
   },
   {
@@ -521,8 +442,10 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": []
-  }
+   "source": [
+    "#NaCl_1400K.run_computation.GreenKuboIonicConductivity(plot=True, data_range=150)"
+   ]
+
  ],
  "metadata": {
   "kernelspec": {


Test patch:
diff --git a/mdsuite/tests/__init__.py b/mdsuite/tests/__init__.py
new file mode 100644
index 00000000..b545ad2c
--- /dev/null
+++ b/mdsuite/tests/__init__.py
@@ -0,0 +1,3 @@
+"""
+Python module for all MDSuite tests, including performance tests.
+"""
diff --git a/mdsuite/tests/correlation_usage.npy b/mdsuite/tests/correlation_usage.npy
new file mode 100644
index 00000000..6357fb0c
Binary files /dev/null and b/mdsuite/tests/correlation_usage.npy differ
diff --git a/mdsuite/tests/speed_memory_test.py b/mdsuite/tests/speed_memory_test.py
new file mode 100644
index 00000000..4f09040f
--- /dev/null
+++ b/mdsuite/tests/speed_memory_test.py
@@ -0,0 +1,60 @@
+"""
+Module for the speed and memory tests of different methods.
+"""
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+from memory_profiler import memory_usage
+import tensorflow as tf
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from scipy.signal import correlate
+from tqdm import tqdm
+
+
+def correlation():
+    """
+    Test the speed of the autocorrelation methods.
+
+    Data stored as [n_atoms, data_range, time]
+    """
+    test_range = [10, 100, 200, 300, 500, 700, 1000, 2000, 4000, 6000, 10000, 12000, 15000, 20000, 50000]
+    scaling = []
+
+    def correlation_function(data):
+        """
+        Perform correlation
+        """
+        acf = np.zeros(2 * len(data[0]) - 1)
+        for item in data:
+            acf += sum([correlate(item[:, idx], item[:, idx], mode="full", method='fft') for idx in range(3)])
+        return acf
+
+    for traj_length in tqdm(test_range):
+        for atom_number in test_range:
+            data = tf.random.uniform((atom_number, traj_length, 3))
+            start = time.time()
+            correlation_function(data)
+            time_taken = time.time() - start
+            scaling.append([atom_number, traj_length, time_taken])
+
+    scaling_data = np.array(scaling)
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.scatter(scaling_data[:, 0], scaling_data[:, 1], scaling_data[:, 2])
+    ax.set_xlabel('Number of atoms')
+    ax.set_ylabel('Data range')
+    ax.set_zlabel('Time (s)')
+    plt.show()
+    np.save('correlation_usage.npy', scaling_data)
+
+
+def main():
+    """
+    Run all methods.
+    """
+    correlation()
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file