diff --git a/README.md b/README.md
index 0f0fab15..c61b318d 100644
--- a/README.md
+++ b/README.md
@@ -51,6 +51,8 @@ Get in touch with us on [Slack](https://aif360.slack.com) (invitation
 * Grid Search Reduction ([Agarwal et al., 2018](https://arxiv.org/abs/1803.02453), [Agarwal et al., 2019](https://arxiv.org/abs/1905.12843))
 * Fair Data Adaptation ([Plečko and Meinshausen, 2020](https://www.jmlr.org/papers/v21/19-966.html), [Plečko et al., 2021](https://arxiv.org/abs/2110.10200))
 * Sensitive Set Invariance/Sensitive Subspace Robustness ([Yurochkin and Sun, 2020](https://arxiv.org/abs/2006.14168), [Yurochkin et al., 2019](https://arxiv.org/abs/1907.00020))
+* Subgroup and Instantaneous Fairness Optimisation ([Quan Zhou, Jakub Marecek, and Robert N. Shorten](http://arxiv.org/abs/2209.05274))
+* Distributional Repair ([Abigail Langbridge, Anthony Quinn, and Robert Shorten](http://arxiv.org/abs/2403.13864))
 
 ## Supported fairness metrics
 
diff --git a/aif360/algorithms/postprocessing/lds_fairness.py b/aif360/algorithms/postprocessing/lds_fairness.py
new file mode 100644
index 00000000..d6ec7150
--- /dev/null
+++ b/aif360/algorithms/postprocessing/lds_fairness.py
@@ -0,0 +1,315 @@
+from aif360.algorithms import Transformer
+import numpy as np
+import cvxpy as cp
+from picos import Problem, RealVariable, trace
+import warnings
+import os
+from ncpol2sdpa import SdpRelaxation, generate_operators, flatten
+
+warnings.simplefilter(action='ignore', category=FutureWarning)
+
+class _BaseLDS(Transformer):
+    """
+    Base class for Linear Dynamical System transformers.
+
+    These algorithms have been adapted from [1]_.
+
+    References:
+        .. [1] Quan Zhou, Jakub Marecek, and Robert N. Shorten. “Fairness in Forecasting of Observations of Linear
+            Dynamical Systems”. en. In: Journal of Artificial Intelligence Research 76 (Apr. 2023). arXiv:2209.05274 [cs,
+            eess, math, stat], pp. 1247–1280. ISSN: 1076-9757. DOI: 10.1613/jair.1.14050. URL: http://arxiv.org/a
+            bs/2209.05274 
+    """
+    def __init__(self, S, X, Y_hat, solver_path=None):
+        """
+        Base class for Linear Dynamical System transformers.
+
+        The SDPA solver can be downloaded from https://sdpa.sourceforge.net/.
+        This will provide a faster solution than using CVXPY, but requires the user to have the SDPA executable.
+
+        Args:
+            S (str): The name of the sensitive attribute.
+            X (list): The names of the features.
+            Y_hat (str): The name of the predicted label.
+            solver_path (str): The path to the SDPA executable. If None, CVXPY will be used.
+        """
+        super().__init__()
+        self.S = S
+        self.X = X
+        self.Y_hat = Y_hat
+        self.solver_path = solver_path
+        self.fitted = False
+
+    def fit(self, dataset):
+        """
+        Fit the Linear Dynamical System transformer to the dataset.
+
+        Args:
+            dataset (BinaryLabelDataset): The dataset to fit the transformer to.
+        Returns:
+            LinearDynamicalSystem: Returns self.
+        """
+        D = dataset.convert_to_dataframe()[0]
+        self._store_base_rate_info(D)
+        D_privileged, D_unprivileged = self._split_data(D)
+        constraints, obj_D, x_vars, e, z = self._create_optimisation(D_privileged, D_unprivileged)
+        self.solved_x_vars, self.solved_e, self.solved_z = self._solve_optimisation(constraints, obj_D, x_vars, e, z)
+        self.fitted = True
+        return self
+
+    def transform(self, dataset):
+        """
+        Transform the dataset using the fitted Linear Dynamical System transformer.
+
+        Args:
+            dataset (BinaryLabelDataset): The dataset to transform.
+        Returns:
+            BinaryLabelDataset: The transformed dataset.
+        """
+        if self.fitted:
+            D = dataset.convert_to_dataframe()[0]
+            D_reweighted = self._reweigh_data(D)
+            D_normalised = self._normalise(D_reweighted)
+            base_rate = self._calculate_base_rate(D)
+            D_classified = self._apply_threshold(D_normalised, base_rate)
+            dataset.df = D_classified
+            return dataset.df
+        else:
+            raise Exception("Model has not been fitted yet")
+
+    def fit_transform(self, dataset_train, dataset_test):
+        """
+        Fit the Linear Dynamical System transformer to the training dataset and transform the test dataset.
+
+        Args:
+            dataset_train (BinaryLabelDataset): The dataset to fit the transformer to.
+            dataset_test (BinaryLabelDataset): The dataset to transform.
+        Returns:
+            BinaryLabelDataset: The transformed dataset.
+        """
+        self.fit(dataset_train)
+        return self.transform(dataset_test)
+
+
+    def _split_data(self, dataset):
+        # Split the dataset into privileged and unprivileged groups based on the S attribute
+        D_privileged = dataset[dataset[self.S] == 1]
+        D_unprivileged = dataset[dataset[self.S] == 0]
+        return D_privileged, D_unprivileged
+
+    def _create_optimisation(self, D_privileged, D_unprivileged):
+        x_vars, e, z = self._create_decision_variables()
+        constraints, obj_D = self._get_constraints(D_privileged, D_unprivileged, x_vars, e, z)
+        return constraints, obj_D, x_vars, e, z
+
+    def _solve_optimisation(self, constraints, obj_D, x_vars, e, z):
+        if self.solver_path != None:
+            return self._solve_optimisation_sdpa(constraints, obj_D, x_vars, e, z)
+        else:
+            return self._solve_optimisation_cvx(constraints, obj_D, x_vars, e, z)
+
+    def _solve_optimisation_sdpa(self, constraints, obj_D, x_vars, e, z):
+        var_list = []
+        for x in x_vars:
+            var_list.extend(x)
+        var_list.extend(e)
+        var_list.extend(z)
+        sdp_D = SdpRelaxation(variables = flatten(var_list), verbose = 0)
+        sdp_D.get_relaxation(1, objective=obj_D, inequalities=constraints)
+        sdp_D.solve(solver='sdpa', solverparameters={"executable":"sdpa_gmp","executable":self.solver_path})
+        
+        solved_e = [sdp_D[e[0]], sdp_D[e[1]]]
+        solved_z = [sdp_D[z[0]], sdp_D[z[1]]]
+        solved_x_vars = flatten([[sdp_D[i[0]], sdp_D[i[1]]] for i in x_vars])
+        return solved_x_vars, solved_e, solved_z
+
+    def _solve_optimisation_cvx(self, constraints, obj_D, x_vars, e, z):
+        prob = Problem()
+        prob.add_list_of_constraints(constraints)
+        prob.set_objective('min', obj_D)
+
+        try:
+            prob.solve(solver='cvxopt', verbose=0)
+        except Exception as exception:
+            raise Exception(f"Optimisation failed to find a feasible solution. Error: {str(exception)}")
+
+        solved_x_vars = flatten([[x[0].value, x[1].value] for x in x_vars])
+        solved_e = [e[0].value, e[1].value]
+        #iterate through z to get the values, as it is not a constant length
+        solved_z = [z[i].value for i in range(len(z))]
+        return solved_x_vars, solved_e, solved_z
+
+    def _reweigh_data(self, D):
+        D_reweighted = D.copy()
+        
+        for index, row in D_reweighted.iterrows():
+            if row[self.S] == 0:
+                score = sum(self.solved_x_vars[i] * row[x_name] for i, x_name in zip(range(0, len(self.solved_x_vars), 2), self.X)) + self.solved_e[0]
+            else:
+                score = sum(self.solved_x_vars[i] * row[x_name] for i, x_name in zip(range(1, len(self.solved_x_vars), 2), self.X)) + self.solved_e[1]
+            D_reweighted.at[index, self.Y_hat] = score
+        return D_reweighted
+            
+    def _normalise(self, D):
+        D_normalised = D.copy()
+        Y_hat_col = D_normalised[self.Y_hat]
+        Y_hat_min = np.min(Y_hat_col)
+        Y_hat_max = np.max(Y_hat_col)
+        Y_hat_normalised = np.array([round(float(x - Y_hat_min) / (Y_hat_max - Y_hat_min), 1) for x in Y_hat_col])
+        Y_hat_normalised[Y_hat_normalised > 1] = 1
+        Y_hat_normalised[Y_hat_normalised < 0] = 0
+        D_normalised[self.Y_hat] = Y_hat_normalised
+        return D_normalised
+
+    def _store_base_rate_info(self, dataset):
+        D_privileged, D_unprivileged = self._split_data(dataset)
+        self.priv_count = D_privileged.shape[0]
+        self.priv_pos_count = D_privileged[D_privileged[self.Y_hat] == 1].shape[0]
+        self.unpriv_count = D_unprivileged.shape[0]
+        self.unpriv_pos_count = D_unprivileged[D_unprivileged[self.Y_hat] == 1].shape[0]
+
+    def _calculate_base_rate(self, dataset):
+        D_privileged, D_unprivileged = self._split_data(dataset)
+        priv_count = D_privileged.shape[0] + self.priv_count
+        priv_pos_count = D_privileged[D_privileged[self.Y_hat] == 1].shape[0] + self.priv_pos_count
+        unpriv_count = D_unprivileged.shape[0] + self.unpriv_count
+        unpriv_pos_count = D_unprivileged[D_unprivileged[self.Y_hat] == 1].shape[0] + self.unpriv_pos_count
+        base_rate_privileged = 1- priv_pos_count / priv_count
+        base_rate_unprivileged = 1- unpriv_pos_count / unpriv_count
+        return base_rate_privileged, base_rate_unprivileged
+
+    def _apply_threshold(self, dataset, base_rate):
+        # Apply threshold based on base rate
+        D_classified = dataset.copy()
+        th_privileged = np.percentile(dataset[dataset[self.S] == 1][self.Y_hat], [base_rate[0]*100])[0]
+        th_unprivileged = np.percentile(dataset[dataset[self.S] == 0][self.Y_hat], [base_rate[1]*100])[0]
+        D_classified.loc[dataset[self.S] == 1, self.Y_hat] = (dataset[dataset[self.S] == 1][self.Y_hat] >= th_privileged).astype(int)
+        D_classified.loc[dataset[self.S] == 0, self.Y_hat] = (dataset[dataset[self.S] == 0][self.Y_hat] >= th_unprivileged).astype(int)
+        return D_classified
+    
+class SubgroupFairOptimiser(_BaseLDS):
+    """
+    The subgroup fair optimiser uses a min-max strategy minimise the loss 
+    between a protected and unprotected subgroup, over the entire time period.
+    """
+    def _create_decision_variables(self):
+        if self.solver_path != None:
+            return self._create_decision_variables_sdpa()
+        else:
+            return self._create_decision_variables_cvx()
+
+    def _create_decision_variables_sdpa(self):
+        #for x in self.X, there is a 0 and 1 decision variable
+        x_vars = [generate_operators(f"x{i}", n_vars=2, hermitian=True, commutative=False) for i in range(len(self.X))]
+        e = generate_operators("e", n_vars=2, hermitian=True, commutative=False)
+        z = generate_operators("z", n_vars=3, hermitian=True, commutative=True)
+        return x_vars, e, z
+
+    def _create_decision_variables_cvx(self):
+        #for x in self.X, there is a 0 and 1 decision variable
+        x_vars = [RealVariable(f"x{i}", (2,)) for i in range(len(self.X))]
+        e = RealVariable("e", (2,))
+        z = RealVariable("z", (3,))
+        return x_vars, e, z
+
+    def _get_constraints(self, D_privileged, D_unprivileged, x_vars, e, z):
+        if self.solver_path != None:
+            return self._get_constraints_sdpa(D_privileged, D_unprivileged, x_vars, e, z)
+        else:
+            return self._get_constraints_cvx(D_privileged, D_unprivileged, x_vars, e, z)
+
+    def _get_constraints_sdpa(self, D_privileged, D_unprivileged, x_vars, e, z):
+        ine1 = [z[0] + row[self.Y_hat] - sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0] for _, row in D_unprivileged.iterrows()]
+        ine2 = [z[0] - row[self.Y_hat] + sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0] for _, row in D_unprivileged.iterrows()]
+        ine3 = [z[0] + row[self.Y_hat] - sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1] for _, row in D_privileged.iterrows()]
+        ine4 = [z[0] - row[self.Y_hat] + sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1] for _, row in D_privileged.iterrows()]
+        max1 = [z[1] - sum((row[self.Y_hat] - sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0])**2 for _, row in D_unprivileged.iterrows()) / len(D_unprivileged)]
+        max2 = [z[2] - sum((row[self.Y_hat] - sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1])**2 for _, row in D_privileged.iterrows()) / len(D_privileged)]
+
+        obj_D = z[0] + z[1] + z[2] + 0.5 * (z[2] - z[1])
+        constraints = ine1 + ine2 + ine3 + ine4 + max1 + max2
+        return constraints, obj_D
+
+    def _get_constraints_cvx(self, D_privileged, D_unprivileged, x_vars, e, z):
+        constraints = []
+
+        ine1 = [z[0] + row[self.Y_hat] - sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0] for _, row in D_unprivileged.iterrows()]
+        ine2 = [z[0] - row[self.Y_hat] + sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0] for _, row in D_unprivileged.iterrows()]
+        ine3 = [z[0] + row[self.Y_hat] - sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1] for _, row in D_privileged.iterrows()]
+        ine4 = [z[0] - row[self.Y_hat] + sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1] for _, row in D_privileged.iterrows()]
+
+        constraints.extend([ine >= 0 for ine in ine1 + ine2 + ine3 + ine4])
+
+        max1 = z[1] - sum((row[self.Y_hat] - sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0])**2 for _, row in D_unprivileged.iterrows()) / len(D_unprivileged)
+        max2 = z[2] - sum((row[self.Y_hat] - sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1])**2 for _, row in D_privileged.iterrows()) / len(D_privileged)
+
+        constraints.append(max1 >= 0)
+        constraints.append(max2 >= 0)
+
+        obj_D = z[0] + z[1] + z[2] + 0.5 * (z[2] - z[1]) + 0.05*(e[0]**2 + e[1]**2)
+
+        return constraints, obj_D
+
+class InstantaneousFairOptimiser(_BaseLDS):
+    """
+    The instantaneous fair optimiser uses a min-max strategy minimise the loss 
+    between a protected and unprotected subgroup, at each point in time.
+    """
+    def _create_decision_variables(self):
+        if self.solver_path != None:
+            return self._create_decision_variables_sdpa()
+        else:
+            return self._create_decision_variables_cvx()
+
+    def _create_decision_variables_sdpa(self):
+        #for x in self.X, there is an 0 and 1 decision variable
+        x_vars = [generate_operators(f"x{i}", n_vars=2, hermitian=True, commutative=False) for i in range(len(self.X))]
+        e = generate_operators("e", n_vars=2, hermitian=True, commutative=False)
+        z = generate_operators("z", n_vars=2, hermitian=True, commutative=True)
+        return x_vars, e, z
+
+    def _create_decision_variables_cvx(self):
+        #for x in self.X, there is an 0 and 1 decision variable
+        x_vars = [RealVariable(f"x{i}", (2,)) for i in range(len(self.X))]
+        e = RealVariable("e", (2,))
+        z = RealVariable("z", (2,))
+        return x_vars, e, z
+        
+    def _get_constraints(self, D_privileged, D_unprivileged, x_vars, e, z):
+        if self.solver_path != None:
+            return self._get_constraints_sdpa(D_privileged, D_unprivileged, x_vars, e, z)
+        else:
+            return self._get_constraints_cvx(D_privileged, D_unprivileged, x_vars, e, z)
+
+    def _get_constraints_sdpa(self, D_privileged, D_unprivileged, x_vars, e, z):
+        ine1 = [(z[0] + row[self.Y_hat] - sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0])/len(D_unprivileged) for _, row in D_unprivileged.iterrows()]
+        ine2 = [(z[0] - row[self.Y_hat] + sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0])/len(D_unprivileged) for _, row in D_unprivileged.iterrows()]
+        ine3 = [(z[0] + row[self.Y_hat] - sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1])/len(D_privileged) for _, row in D_privileged.iterrows()]
+        ine4 = [(z[0] - row[self.Y_hat] + sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1])/len(D_privileged) for _, row in D_privileged.iterrows()]
+        max1 = [(z[1] + row[self.Y_hat] - sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0])/len(D_unprivileged) for _, row in D_unprivileged.iterrows()]
+        max2 = [(z[1] - row[self.Y_hat] - sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1])/len(D_privileged) for _, row in D_privileged.iterrows()]
+
+        obj_D = z[0] + z[1]
+        constraints = ine1 + ine2 + ine3 + ine4 + max1 + max2
+        
+        return constraints, obj_D
+
+    def _get_constraints_cvx(self, D_privileged, D_unprivileged, x_vars, e, z):
+        constraints = []
+
+        ine1 = [(z[0] + row[self.Y_hat] - sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0]) / len(D_unprivileged) for _, row in D_unprivileged.iterrows()]
+        ine2 = [(z[0] - row[self.Y_hat] + sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0]) / len(D_unprivileged) for _, row in D_unprivileged.iterrows()]
+        ine3 = [(z[0] + row[self.Y_hat] - sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1]) / len(D_privileged) for _, row in D_privileged.iterrows()]
+        ine4 = [(z[0] - row[self.Y_hat] + sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1]) / len(D_privileged) for _, row in D_privileged.iterrows()]
+
+        constraints.extend([ine >= 0 for ine in ine1 + ine2 + ine3 + ine4])
+
+        max1 = [(z[1] + row[self.Y_hat] - sum(x[0] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[0]) / len(D_unprivileged) for _, row in D_unprivileged.iterrows()]
+        max2 = [(z[1] - row[self.Y_hat] - sum(x[1] * row[x_name] for x, x_name in zip(x_vars, self.X)) + e[1]) / len(D_privileged) for _, row in D_privileged.iterrows()]
+
+        constraints.extend([max1_ine >= 0 for max1_ine in max1])
+        constraints.extend([max2_ine >= 0 for max2_ine in max2])
+
+        obj_D = z[0] + z[1] + 0.01*(e[0]**2 + e[1]**2)
+
+        return constraints, obj_D
\ No newline at end of file
diff --git a/aif360/algorithms/preprocessing/distributional_repair.py b/aif360/algorithms/preprocessing/distributional_repair.py
new file mode 100644
index 00000000..d9cc9257
--- /dev/null
+++ b/aif360/algorithms/preprocessing/distributional_repair.py
@@ -0,0 +1,236 @@
+import numpy as np
+import pandas as pd
+
+from aif360.algorithms import Transformer
+from aif360.datasets import StandardDataset
+
+from sklearn.neighbors import KernelDensity
+import ot
+
+
+class DistributionalRepair(Transformer):
+    """Distributional Repair class for mitigating bias in datasets.
+
+    Adapted from the work of Abigail Longbridge et al.
+    https://arxiv.org/pdf/2403.13864
+
+    This class implements the Distributional Repair algorithm to mitigate bias
+    in datasets by aligning the distributions of protected and unprotected groups
+    for each feature conditioned on the outcome variable.
+
+    """
+
+    def __init__(self, s, u, x, y, continuous_features, n_q=250):
+        """
+        Initialize the Distributional Repair transformer.
+
+        Args:
+        s (str): Name of the protected attribute.
+        u (str): Name of the unprotected variable.
+        x (list): List of feature names to be repaired (remaining observations).
+        y (str): Name of the outcome variable.
+        continuous_features (list): List of continuous feature names.
+        n_q (int, optional): Number of probability function supports. Defaults to 250.
+        """
+        super(DistributionalRepair, self).__init__()
+        self.s = s
+        self.u = u
+        self.x = x
+        self.y = y
+        self.n_q = n_q
+        self.continuous_features = continuous_features
+
+    def fit(self, dataset_R):
+        """Fit the Distributional Repair transformer to create an optimal transport plan from the reference dataset.
+
+        Args:
+            dataset_R (StandardDataset): Dataset to fit the transformer.
+
+        Returns:
+            self: Fitted transformer.
+        """
+        dataframe_R = dataset_R.convert_to_dataframe()[0]
+        self.supports = {}
+        self.pmf_0s = {}
+        self.pmf_1s = {}
+        self.T_0s = {}
+        self.T_1s = {}
+        self.s_R, self.u_R, self.x_R, self.y_R = self._split_dataframe(dataframe_R)
+        for feat in self.x:
+            continuous = feat in self.continuous_features
+            for u_val in self.u_R.unique():
+                if continuous:
+                    self._continuous_fit(feat, u_val)
+                else:
+                    self._discrete_fit(feat, u_val)
+        return self
+
+    def _continuous_fit(self, feat, u_val):
+        support = self._get_support(feat, u_val)
+        self.supports[(feat, u_val)] = support
+        pmf_0, pmf_1 = self._get_pmfs(feat, u_val)
+        barycenter = self._get_barycenter(pmf_0, pmf_1, feat, u_val)
+        T_0, T_1 = self._get_transport_plans(pmf_0, pmf_1, barycenter, feat, u_val)
+        self.pmf_0s[(feat, u_val)] = pmf_0
+        self.pmf_1s[(feat, u_val)] = pmf_1
+        self.T_0s[(feat, u_val)] = T_0
+        self.T_1s[(feat, u_val)] = T_1
+
+    def _discrete_fit(self, feat, u_val):
+        if self._is_valid_data(u_val):
+            pmf_0, pmf_1 = self._get_discrete_pmfs(feat, u_val)
+            T = self._get_discrete_transport_plan(pmf_0, pmf_1)
+            self.pmf_0s[(feat, u_val)] = pmf_0
+            self.pmf_1s[(feat, u_val)] = pmf_1
+            self.T_0s[(feat, u_val)] = T
+        else:
+            self.pmf_0s[(feat, u_val)] = None
+            self.pmf_1s[(feat, u_val)] = None
+
+    def transform(self, dataset_D):
+        """Transform the dataset to apply the OT plan.
+
+        Args:
+            dataset_D (StandardDataset): Dataset to be transformed.
+
+        Returns:
+            StandardDataset: Transformed dataset with bias mitigated.
+        """
+        dataframe_D = dataset_D.convert_to_dataframe()[0]
+        s_D, u_D, x_D, y_D = self._split_dataframe(dataframe_D)
+        tilde_x_D = x_D.copy()
+        for feat in self.x:
+            continuous = feat in self.continuous_features
+            for u_val in u_D.unique():
+                if continuous:
+                    support = self.supports[(feat, u_val)]
+                    T_0 = self.T_0s[(feat, u_val)]
+                    T_1 = self.T_1s[(feat, u_val)]
+                    tilde_x_D = self._continuous_transform(s_D, u_D, x_D, feat, tilde_x_D, u_val, support, T_0, T_1)
+                else:
+                    tilde_x_D = self._discrete_transform(s_D, u_D, x_D, feat, tilde_x_D, u_val)
+        
+        tilde_dataframe_D = pd.concat([tilde_x_D, dataframe_D.drop(columns=self.x)], axis=1)
+        tilde_dataset_D = StandardDataset(df=tilde_dataframe_D, 
+                                          label_name=self.y,
+                                          favorable_classes=[1],
+                                          protected_attribute_names=[self.s],
+                                          privileged_classes=[[1]])
+        return tilde_dataset_D
+
+    def fit_transform(self, dataframe_R, dataframe_A):
+        """Fit and transform the datasets.
+
+        Args:
+            dataframe_R (DataFrame): Reference dataset.
+            dataframe_A (DataFrame): Dataset to be transformed.
+
+        Returns:
+            tuple: Transformed reference dataset and transformed dataset.
+        """
+        self.fit(dataframe_R)
+        tilde_dataframe_A = self.transform(dataframe_A)
+        tilde_dataframe_R = self.transform(dataframe_R)
+        return tilde_dataframe_R, tilde_dataframe_A
+
+    def _split_dataframe(self, dataframe):
+        s_D = dataframe[self.s]
+        u_D = dataframe[self.u]
+        x_D = dataframe[self.x]
+        y_D = dataframe[self.y]
+        return s_D, u_D, x_D, y_D
+
+    def _get_support(self, feat, u_val):
+        min_val = np.min(self.x_R[(self.u_R == u_val)][feat]) - np.ptp(self.x_R[(self.u_R == u_val)][feat])*0.1
+        max_val = np.max(self.x_R[(self.u_R == u_val)][feat]) + np.ptp(self.x_R[(self.u_R == u_val)][feat])*0.1
+        return np.linspace(min_val, max_val, self.n_q).reshape(-1, 1)
+
+    def _get_pmfs(self, feat, u_val):
+        kde_0 = KernelDensity(kernel='gaussian', bandwidth='silverman').fit(self.x_R[(self.u_R == u_val) & (self.s_R == 0.0)][feat].values.reshape(-1, 1))
+        pmf_0 = np.exp(kde_0.score_samples(self.supports[(feat, u_val)]))
+        kde_1 = KernelDensity(kernel='gaussian', bandwidth='silverman').fit(self.x_R[(self.u_R == u_val) & (self.s_R == 1.0)][feat].values.reshape(-1, 1))
+        pmf_1 = np.exp(kde_1.score_samples(self.supports[(feat, u_val)]))
+        pmf_0 /= np.sum(pmf_0)
+        pmf_1 /= np.sum(pmf_1)
+        if np.any(np.isnan(pmf_0)) or np.any(np.isnan(pmf_1)):
+            raise ZeroDivisionError("One or more PMFs have sum zero")
+        return pmf_0, pmf_1
+
+    def _get_barycenter(self, pmf_0, pmf_1, feat, u_val):
+        M = ot.utils.dist(self.supports[(feat, u_val)], self.supports[(feat, u_val)])
+        A = np.vstack([pmf_0, pmf_1]).T
+        barycenter = ot.bregman.barycenter(A, M, 10)
+        if np.any(np.isnan(pmf_0)) or np.any(np.isnan(pmf_1)):
+            raise RuntimeError("No valid barycenter was found, try to increase reg")
+        return barycenter
+
+    def _get_transport_plans(self, pmf_0, pmf_1, barycenter, feat, u_val):
+        M = ot.utils.dist(self.supports[(feat, u_val)], self.supports[(feat, u_val)])
+        T_0 = ot.emd(pmf_0, barycenter, M)
+        T_1 = ot.emd(pmf_1, barycenter, M)
+        return T_0, T_1
+
+    def _is_valid_data(self, u_val):
+        return (len(self.x_R[(self.u_R == u_val) & (self.s_R == 0)]) > 1) and (len(self.x_R[(self.u_R == u_val) & (self.s_R == 1)]) > 1)
+
+    def _get_discrete_pmfs(self, feat, u_val):
+        pmf_0 = self.x_R[(self.u_R == u_val) & (self.s_R == 0)][feat].value_counts()
+        pmf_1 = self.x_R[(self.u_R == u_val) & (self.s_R == 1)][feat].value_counts()
+        return pmf_0, pmf_1
+
+    def _get_discrete_transport_plan(self, pmf_0, pmf_1):
+        M = ot.dist(pmf_0.index.values.reshape(-1, 1), pmf_1.index.values.reshape(-1, 1))
+        weights = [pmf_0.values / pmf_0.values.sum(), pmf_1.values / pmf_1.values.sum()]
+        return ot.emd(weights[0], weights[1], M)
+
+    def _continuous_transform(self, s_D, u_D, x_D, feat, tilde_x_D, u_val, support, T_0, T_1):
+        for i, row in x_D[(u_D == u_val)].iterrows():
+            if s_D[i] == 1:
+                tilde_x_D.loc[i, feat] = self._repair_data(row[feat], support[:, 0], support[:, 0], T_1)
+            else:
+                tilde_x_D.loc[i, feat] = self._repair_data(row[feat], support[:, 0], support[:, 0], T_0)
+        return tilde_x_D
+
+    def _discrete_transform(self, s_D, u_D, x_D, feat, tilde_x_D, u_val):
+        pmf_0 = self.pmf_0s[(feat, u_val)]
+        pmf_1 = self.pmf_1s[(feat, u_val)]
+        T = self.T_0s[(feat, u_val)]
+        
+        if pmf_0 is None or pmf_1 is None:
+            return tilde_x_D
+        
+        for i, row in x_D[(u_D == u_val)].iterrows():
+            if s_D[i] == 1:
+                tilde_x_D.loc[i, feat] = self._repair_data(row[feat], pmf_1.index.values, pmf_0.index.values, T.T, i_split=False, j_split=False)
+            else:
+                tilde_x_D.loc[i, feat] = self._repair_data(row[feat], pmf_0.index.values, pmf_1.index.values, T, i_split=False, j_split=False)
+        return tilde_x_D
+
+    def _repair_data(self, x, support_i, support_j, T, i_split=True, j_split=False):
+        if i_split:
+            idx = np.searchsorted(support_i, x, side='left')
+            if idx == 0 or idx == len(support_i):
+                i = min(idx, len(support_i)-1)
+            else:
+                interp = float(x - support_i[idx-1]) / np.diff(support_i)[0]
+                if np.round(interp, 4) == 1.0:
+                    i = idx
+                else:
+                    i = np.random.choice([idx-1, idx], p=[1-interp, interp])
+        else:
+            i_indices = np.argwhere(support_i == x)
+            if len(i_indices) > 0:
+                i = i_indices[0,0]
+            else:
+                i = np.argmin(np.abs(support_i - x))
+
+        if not j_split:
+            if np.sum(T[i]) > 0.0:
+                j = np.random.choice(T.shape[1], p=(T[i] / np.sum(T[i]))) # stochastic choice of which marginal entry to transport to
+            else:
+                j = i
+            x_repaired = support_j[j]
+        else:
+            row = T[i] / np.sum(T[i])
+            x_repaired = 0.5*x + 0.5*row@support_j
+        return x_repaired
\ No newline at end of file
diff --git a/examples/demo_distributional_repair.ipynb b/examples/demo_distributional_repair.ipynb
new file mode 100644
index 00000000..dd495cc6
--- /dev/null
+++ b/examples/demo_distributional_repair.ipynb
@@ -0,0 +1,370 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Distributional Repair Algorithm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The distributional repair algorithm is adapted from the work of Abigail Longbridge et al.\n",
+    "https://arxiv.org/pdf/2403.13864\n",
+    "\n",
+    "This algorithm learns an optimal transport plan from the privileged and unprivileged groups to the barycentre between them. This plan can then be applied to either the training data or the test data to repair the dataset under the notion of conditional independence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load all necessary packages\n",
+    "import sys\n",
+    "sys.path.append(\"../\")\n",
+    "from aif360.algorithms.preprocessing.distributional_repair import DistributionalRepair\n",
+    "# from aif360.algorithms.preprocessing.pointwise_repair import PointwiseRepair\n",
+    "\n",
+    "from aif360.datasets import AdultDataset\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import ot\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.neighbors import KernelDensity\n",
+    "\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This demo file uses the adult dataset to demonstrate the distributional repair algorithm."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_adult_dataset(s,u,x,y):\n",
+    "    def custom_preprocessing(df):\n",
+    "        pd.set_option('future.no_silent_downcasting', True)\n",
+    "        def group_race(x):\n",
+    "            if x == \"White\":\n",
+    "                return 1.0\n",
+    "            else:\n",
+    "                return 0.0\n",
+    "\n",
+    "        df['race'] = df['race'].apply(lambda x: group_race(x))\n",
+    "\n",
+    "        # Encode 'sex' column as numerical values\n",
+    "        df['sex'] = df['sex'].map({'Female': 0.0, 'Male': 1.0})\n",
+    "\n",
+    "        df['Income Binary'] = df['income-per-year']\n",
+    "        df['Income Binary'] = df['Income Binary'].replace(to_replace='>50K.', value=1, regex=True)\n",
+    "        df['Income Binary'] = df['Income Binary'].replace(to_replace='>50K', value=1, regex=True)\n",
+    "        df['Income Binary'] = df['Income Binary'].replace(to_replace='<=50K.', value=0, regex=True)\n",
+    "        df['Income Binary'] = df['Income Binary'].replace(to_replace='<=50K', value=0, regex=True)\n",
+    "        # 1 if education-num is greater than 9, 0 otherwise\n",
+    "        df['college_educated'] = (df['education-num'] > 9).astype(int)\n",
+    "\n",
+    "        #drop nan columns\n",
+    "        df = df.dropna()\n",
+    "\n",
+    "        return df\n",
+    "\n",
+    "    adult = AdultDataset(\n",
+    "        label_name=y,\n",
+    "        favorable_classes=[1,1],\n",
+    "        protected_attribute_names=[s],\n",
+    "        privileged_classes=[[1.0]],\n",
+    "        instance_weights_name=None,\n",
+    "        categorical_features=[],\n",
+    "        features_to_keep=[s]+[u]+x,\n",
+    "        na_values=[],\n",
+    "        custom_preprocessing=custom_preprocessing,\n",
+    "        features_to_drop=[],\n",
+    "        metadata={}\n",
+    "    )\n",
+    "    return adult"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "KL divergence is used as the distance metric between the original and repaired data distributions. Is calculated for each feature, with the the average KL divergence across all features used as the final distance metric, U-Mean KLD."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _eval_kld(x_0, x_1):\n",
+    "    support = np.linspace(np.min([np.min(x_0), np.min(x_1)]), np.max([np.max(x_0), np.max(x_1)]), 500).reshape(-1,1)\n",
+    "    kde_0 = KernelDensity(kernel='gaussian',bandwidth='silverman').fit(x_0.reshape(-1,1))\n",
+    "    pmf_0 = np.exp(kde_0.score_samples(support)) \n",
+    "    #add a small value to avoid division by zero\n",
+    "    pmf_0 += 1e-10\n",
+    "    kde_1 = KernelDensity(kernel='gaussian',bandwidth='silverman').fit(x_1.reshape(-1,1))\n",
+    "    pmf_1 = np.exp(kde_1.score_samples(support))\n",
+    "    pmf_1 += 1e-10\n",
+    "    return - np.sum(pmf_0 * np.log(pmf_1 / pmf_0))\n",
+    "\n",
+    "def eval_kld(x, s, u, order=[0,1]):\n",
+    "    tot_kld = 0.0\n",
+    "    for u_val, u_count in u.value_counts().items():\n",
+    "        mask_0 = np.asarray((u == u_val) & (s == 0))\n",
+    "        mask_1 = np.asarray((u == u_val) & (s == 1))\n",
+    "        if (np.sum(mask_0) == 0) or (np.sum(mask_1) == 0):\n",
+    "            continue\n",
+    "        tmp = _eval_kld(x[mask_0].values, x[mask_1].values)\n",
+    "        if np.isnan(tmp):\n",
+    "            continue\n",
+    "        tot_kld += tmp * u_count / len(u)\n",
+    "    return tot_kld"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parameters for Distributional Repair Algorithm\n",
+    "\n",
+    "- `n_q` is the number of support points for the probability distribution function. This defaults to 250, however this can be increased to improve the accuracy of the repair algorithm.\n",
+    "  \n",
+    "- `S` is the protected or sensitive attribute for which the repair is against\n",
+    "\n",
+    "- `U` the name of the unprotected attribute. This should not be a sensitive attribute, or be used later by a model to predict the outcome.\n",
+    "\n",
+    "- `X` is a list of features used by the model to make its predictions. This should not include the sensitive attribute.\n",
+    "\n",
+    "- `X_continuous` is a list of continuous features in `X`\n",
+    "\n",
+    "- `Y` is the outcome of a model, which is predicted using the features in `X`. This should be a binary outcome."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_R = 10000 # number of points in the research dataset\n",
+    "n_q = 250 # number of supports under the estimated pdfs\n",
+    "\n",
+    "S = 'sex'\n",
+    "U = 'college_educated'\n",
+    "X = ['age','hours-per-week']\n",
+    "X_continuous= ['age','hours-per-week']\n",
+    "Y = 'Income Binary'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 1: Split the data into a research and archive set\n",
+    "\n",
+    "The research dataset will be used by the repair algorithm to generate an optimal transport plan that can be used to drive data towards the barycentre of the distributions of the protected and unprotected groups. The archive dataset will be used to evaluate the performance of the repair algorithm."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = load_adult_dataset(S,U,X,Y)\n",
+    "dataset_R, dataset_A = data.split([n_R], shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 2: Initialise the repair algorithm\n",
+    "\n",
+    "The Distributional Repair Algorithm is initialised with the research dataset, and the parameters:\n",
+    "- `S`\n",
+    "  \n",
+    "- `U`\n",
+    "  \n",
+    "- `X`\n",
+    "  \n",
+    "- `Y`\n",
+    "  \n",
+    "- `X_continuous`\n",
+    "  \n",
+    "- `n_q` *(optional)*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "dist_repair = DistributionalRepair(S,U,X,Y,X_continuous,n_q)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 3: Fit the repair algorithm\n",
+    "Using the research dataset as the input, the fit method derives an optimal transport plan used to repair the data under the notion of conditional independence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dist_repair.fit(dataset_R)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step  4: Transform the data\n",
+    "\n",
+    "The transform method is used to repair the data in the archive dataset by applying the optimal transport plan. The method returns the repaired data, and can be used to repair either the research or archive dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "dataset_A_repaired = dist_repair.transform(dataset_A)\n",
+    "dataset_R_repaired = dist_repair.transform(dataset_R)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Evaluating the repair algorithm\n",
+    "The U-Mean KLD value can be calculated for both the repaired and the original data. The U-Mean KLD value is the average KL divergence across all features, and is used to evaluate the performance of the repair algorithm. The lower the U-Mean KLD value, the better the repair algorithm has performed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tilde_x_R = dataset_R_repaired.convert_to_dataframe()[0][X]\n",
+    "tilde_x_A = dataset_A_repaired.convert_to_dataframe()[0][X]\n",
+    "kld_x_R = np.zeros(shape=(len(X), 2))\n",
+    "kld_x_tilde_R = np.zeros(shape=(len(X), 2))\n",
+    "kld_x_A = np.zeros(shape=(len(X), 2))\n",
+    "kld_x_tilde_A = np.zeros(shape=(len(X), 2))\n",
+    "pos = np.arange(len(X))\n",
+    "for i, feat in enumerate(X):\n",
+    "    kld_x_R[i, 0] = eval_kld(dist_repair.x_R[feat], dist_repair.s_R, dist_repair.u_R, order=[0, 1])\n",
+    "    kld_x_R[i, 1] = eval_kld(dist_repair.x_R[feat], dist_repair.s_R, dist_repair.u_R, order=[1, 0])\n",
+    "    kld_x_tilde_R[i, 0] = eval_kld(tilde_x_R[feat], dist_repair.s_R, dist_repair.u_R, order=[0, 1])\n",
+    "    kld_x_tilde_R[i, 1] = eval_kld(tilde_x_R[feat], dist_repair.s_R, dist_repair.u_R, order=[1, 0])\n",
+    "    kld_x_A[i, 0] = eval_kld(data_A.convert_to_dataframe()[0][X][feat], data_A.convert_to_dataframe()[0][S], data_A.convert_to_dataframe()[0][U], order=[0, 1])\n",
+    "    kld_x_A[i, 1] = eval_kld(data_A.convert_to_dataframe()[0][X][feat], data_A.convert_to_dataframe()[0][S], data_A.convert_to_dataframe()[0][U], order=[1, 0])\n",
+    "    kld_x_tilde_A[i, 0] = eval_kld(tilde_x_A[feat], data_A.convert_to_dataframe()[0][S], data_A.convert_to_dataframe()[0][U], order=[0, 1])\n",
+    "    kld_x_tilde_A[i, 1] = eval_kld(tilde_x_A[feat], data_A.convert_to_dataframe()[0][S], data_A.convert_to_dataframe()[0][U], order=[1, 0])\n",
+    "kld_x_A_mean = np.mean(kld_x_A, axis=1)\n",
+    "kld_x_tilde_A_mean = np.mean(kld_x_tilde_A, axis=1)\n",
+    "kld_x_R_mean = np.mean(kld_x_R, axis=1)\n",
+    "kld_x_tilde_R_mean = np.mean(kld_x_tilde_R, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plotting the results\n",
+    "\n",
+    "The plot below demonstrates how the repair algorithm has performed. Successful repair is indicated by the repaired scores (green) being lower than the original scores (red)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "\n",
+    "bar_width = 0.3\n",
+    "original_color = 'red'\n",
+    "repaired_color = 'green'\n",
+    "\n",
+    "original_bars = ax.bar(x=pos - bar_width/2, height=kld_x_A_mean, width=bar_width, alpha=0.4, color=original_color)\n",
+    "repaired_bars = ax.bar(x=pos + bar_width/2, height=kld_x_tilde_A_mean, width=bar_width, alpha=0.4, color=repaired_color)\n",
+    "original_scatter = ax.scatter(x=pos - bar_width/2, y=kld_x_R_mean, color=original_color, marker='o', s=50)\n",
+    "repaired_scatter = ax.scatter(x=pos + bar_width/2, y=kld_x_tilde_R_mean, color=repaired_color, marker='o', s=50)\n",
+    "\n",
+    "x_labels = [x.replace('-', ' ').capitalize() for x in X]\n",
+    "ax.set_xticks(pos)\n",
+    "ax.set_xticklabels(x_labels)\n",
+    "\n",
+    "handles = [original_bars, repaired_bars, original_scatter, repaired_scatter]\n",
+    "labels = ['Original Archived Data', 'Repaired Archived Data', 'Original Research Data', 'Repaired Research Data']\n",
+    "\n",
+    "ax.legend(handles, labels, loc='upper left')\n",
+    "ax.set_ylabel(\"KLD\")\n",
+    "ax.set_xlabel(\"Features\")\n",
+    "\n",
+    "fig.suptitle(\"U-Mean KLD between P(X|S=1,U) and P(X|S=0,U)\", fontsize=16)\n",
+    "plt.tight_layout(rect=[0, 0, 1, 0.95])\n",
+    "plt.show()\n"
+   ]
+  }
+ ],
+ "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.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/demo_lds_fairness.ipynb b/examples/demo_lds_fairness.ipynb
new file mode 100644
index 00000000..a2d47e77
--- /dev/null
+++ b/examples/demo_lds_fairness.ipynb
@@ -0,0 +1,406 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Subgroup and Instantaneous Fairness\n",
+    "\n",
+    "This notebook demonstrates the usage of the subgroup fairness and instantaneous fairness post processing methods.\n",
+    "\n",
+    "These methods are derived from the 'Fairness in Forecasting of Observations of Linear Dynamical Systems' paper by Quan Zhou, et al. The paper can be found at https://www.jair.org/index.php/jair/article/view/14050. \n",
+    "\n",
+    "Subgroup fairness and instantaneous fairness are two notions of fairness introduced to address under-representation bias when learning forecasting models from imbalanced time series data. \n",
+    "\n",
+    "**Subgroup fairness** seeks to equalize the total loss for each subgroup over the entire time period. The optimisation problem for subgroup fairness is as follows:\n",
+    "\n",
+    "**Instantaneous fairness**, on the other hand, seeks to equalize the maximum instantaneous loss across all subgroups at each time step. The optimisation problem for instantaneous fairness is as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load all necessary packages\n",
+    "import sys\n",
+    "sys.path.append(\"../\")\n",
+    "\n",
+    "import numpy as np\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "from aif360.algorithms.preprocessing.optim_preproc_helpers.data_preproc_functions\\\n",
+    "import load_preproc_data_compas, load_preproc_data_german, load_preproc_data_adult\n",
+    "\n",
+    "from aif360.datasets import CompasDataset\n",
+    "\n",
+    "import pandas as pd\n",
+    "\n",
+    "from aif360.algorithms.postprocessing.lds_fairness import SubgroupFairOptimiser, InstantaneousFairOptimiser\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.text as mtext"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The COMPAS dataset is used to demonstrate the usage of subgroup and instantaneous fairness."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_compas_dataset(s,u,u_cat,x,y):\n",
+    "    def custom_preprocessing(df):\n",
+    "        df=df[(df[\"race\"]=='African-American')|(df[\"race\"]=='Caucasian')]\n",
+    "        mask = (df.days_b_screening_arrest <= 30) & \\\n",
+    "               (df.days_b_screening_arrest >= -30) & \\\n",
+    "               (df.is_recid != -1) & \\\n",
+    "               (df.c_charge_degree != 'O') & \\\n",
+    "               (df.score_text != 'N/A')\n",
+    "        df = df.loc[mask].copy()\n",
+    "        charge_degree_map = {'M': 0, 'F': 1} \n",
+    "        df['c_charge_degree'] = df['c_charge_degree'].map(charge_degree_map)\n",
+    "        df['race'] = df['race'].apply(lambda x: 1 if x == 'Caucasian' else 0)\n",
+    "        df['sex'] = df['sex'].apply(lambda x:1 if x == \"Female\" else 0)       \n",
+    "        df['priors_total_count'] = (df['juv_fel_count'] + df['juv_misd_count'] + df['priors_count']) / 3\n",
+    "        df['age_under_25'] = df['age'].apply(lambda x:1 if x < 25 else 0)\n",
+    "        return df\n",
+    "\n",
+    "    compas = CompasDataset(\n",
+    "        label_name=y,\n",
+    "        favorable_classes=[1],\n",
+    "        protected_attribute_names=[s],\n",
+    "        privileged_classes=[[1]],\n",
+    "        instance_weights_name=None,\n",
+    "        categorical_features=u_cat,\n",
+    "        features_to_keep=[s]+u+x,\n",
+    "        na_values=[],\n",
+    "        custom_preprocessing=custom_preprocessing,\n",
+    "        metadata={}\n",
+    "    )\n",
+    "    return compas"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This class can be used to calculate various performance metrics based on the original dataset, and the repaired dataset. The performance metrics include:\n",
+    "- **IND:** absolute difference in negative prediction rates\n",
+    "- **SP:** sum of absolute differences in false positive and false negative rates\n",
+    "- **SF:** sum of absolute differences in positive and negative predictive values\n",
+    "- **INA:** inaccuracy of the model's predictions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LDS_Fairness_Evaluator:\n",
+    "    def __init__ (self,S, Y_hat):\n",
+    "        self.S = S\n",
+    "        self.Y_hat = Y_hat\n",
+    "\n",
+    "    def evaluate(self, dataset_orig, dataset_repaired):\n",
+    "        D_orig = dataset_orig.convert_to_dataframe()[0]\n",
+    "        D_repaired = dataset_repaired#.convert_to_dataframe()[0]\n",
+    "        \n",
+    "        D_privileged_orig, D_unprivileged_orig = self._split_data(D_orig)\n",
+    "        D_privileged_repaired, D_unprivileged_repaired = self._split_data(D_repaired)\n",
+    "        \n",
+    "        Y_hat_orig_privileged = D_privileged_orig[self.Y_hat]\n",
+    "        Y_hat_orig_unprivileged = D_unprivileged_orig[self.Y_hat]\n",
+    "        Y_hat_repaired_privileged = D_privileged_repaired[self.Y_hat]\n",
+    "        Y_hat_repaired_unprivileged = D_unprivileged_repaired[self.Y_hat]\n",
+    "\n",
+    "        perf_privileged = self.calculate_performance_metrics(Y_hat_orig_privileged, Y_hat_repaired_privileged)\n",
+    "        perf_unprivileged = self.calculate_performance_metrics(Y_hat_orig_unprivileged, Y_hat_repaired_unprivileged)\n",
+    "        \n",
+    "        metrics = {\n",
+    "            \"IND\": abs(perf_unprivileged[0] - perf_privileged[0]), # Independent difference\n",
+    "            \"SP\": abs(perf_unprivileged[1] - perf_privileged[1] + abs(perf_privileged[2] - perf_unprivileged[2])), # Separation\n",
+    "            \"SF\": abs(perf_unprivileged[3] - perf_privileged[3] + abs(perf_unprivileged[4] - perf_privileged[4])), # Sufficiency\n",
+    "            \"INA\": (perf_unprivileged[5] + perf_privileged[5]) / (len(D_orig)) # Inaccuracy\n",
+    "        }\n",
+    "\n",
+    "        return metrics\n",
+    "\n",
+    "    def calculate_performance_metrics(self, Y_hat_orig, Y_hat_repaired):\n",
+    "        TP = np.sum((Y_hat_orig == 1) & (Y_hat_repaired == 1))\n",
+    "        TN = np.sum((Y_hat_orig == 0) & (Y_hat_repaired == 0))\n",
+    "        FP = np.sum((Y_hat_orig == 0) & (Y_hat_repaired == 1))\n",
+    "        FN = np.sum((Y_hat_orig == 1) & (Y_hat_repaired == 0))\n",
+    "        \n",
+    "        NR = (TN+FN)/(len(Y_hat_orig))\n",
+    "        FPR = FP/(FP+TN+1e-10)\n",
+    "        FNR = FN/(FN+TP+1e-10)\n",
+    "        PPV = TP/(TP+FP+1e-10)\n",
+    "        NPV = TN/(TN+FN+1e-10)\n",
+    "        inACC = FP+FN\n",
+    "        return [NR, FPR, FNR, PPV, NPV, inACC]\n",
+    "\n",
+    "    def _split_data(self, dataset):\n",
+    "        D_privileged = dataset[dataset[self.S] == 1]\n",
+    "        D_unprivileged = dataset[dataset[self.S] == 0]\n",
+    "        return D_privileged, D_unprivileged"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parameters for Distributional Repair Algorithm\n",
+    " \n",
+    "- `S` is the protected or sensitive attribute for which the repair is against\n",
+    "\n",
+    "- `U` are any other attributes that are not used in the repair, but are to still be loaded in the dataset\n",
+    "\n",
+    "- `U_categorical` is a list of categorical features, in addition to `U`\n",
+    "\n",
+    "- `X` is a list of features used by the algorithm to repair the model. These cannot be sensitive attributes.\n",
+    "\n",
+    "- `Y_hat` is the predicted label\n",
+    "\n",
+    "- `solver_path` *(optional)*. For the best results, the SPDA solver can be used. Download it from https://sdpa.sourceforge.net/ and provide the path to the solver. If not provided, the default CVXOPT solver will be used, although it may not be as accurate and will take considerably longer to run."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "S = 'race'\n",
+    "U = ['sex', 'age']\n",
+    "U_categorical = ['age_cat','c_charge_degree']\n",
+    "X = ['age_under_25','priors_total_count','decile_score']\n",
+    "Y_hat = 'is_recid'\n",
+    "# solver_path=\"../sdpa.exe\"\n",
+    "solver_path=None"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 1: Split the data into training and testing sets\n",
+    "The dataset is split into a training and testing set. The training set is used to construct the min-max optimisation in order to minimise loss, and generate variables by which to reweigh the data. The testing set is used to evaluate the performance of the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "split = 0.2\n",
+    "compas = load_compas_dataset(S, U, U_categorical, X, Y_hat)\n",
+    "data_train, data_test = compas.split([split], shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 2: Initialise the model\n",
+    "The implementation of the subgroup and instantaneous fairness methods is identiacal, with both classes inheriting from the baseLDS class. The model is initialised with the following parameters:\n",
+    "- `S`\n",
+    "- `X`\n",
+    "- `Y_hat`\n",
+    "- `solver_path` *(optional)*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "subgroup_fair_optimiser = SubgroupFairOptimiser(S, X, Y_hat,solver_path=solver_path)\n",
+    "instantaneous_fair_optimiser = InstantaneousFairOptimiser(S, X, Y_hat,solver_path=solver_path)"
+   ]
+  },
+  {
+   "attachments": {
+    "image-2.png": {
+     "image/png": "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"
+    },
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 3: Fit the model\n",
+    "\n",
+    "Using the training data, the model is fit to the data. The will apply the following optimisation problem to the data:\n",
+    "\n",
+    "### Subgroup Fairness\n",
+    "![image.png](attachment:image.png)\n",
+    "\n",
+    "### Instantaneous Fairness\n",
+    "![image-2.png](attachment:image-2.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Subgroup Fair Optimiser trained\n",
+      "Instantaneous Fair Optimiser trained\n"
+     ]
+    }
+   ],
+   "source": [
+    "subgroup_fair_optimiser = subgroup_fair_optimiser.fit(data_train.copy())\n",
+    "print(\"Subgroup Fair Optimiser trained\")\n",
+    "instantaneous_fair_optimiser = instantaneous_fair_optimiser.fit(data_train.copy())\n",
+    "print(\"Instantaneous Fair Optimiser trained\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 4: Transform the data\n",
+    "\n",
+    "The training data can now be reweighed using the solved decision variables from the optimisation problem. A base rate from the original data is applied in order to keep the number of favourable and unfavourable outcomes similar. The data is transformed using the following equation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Subgroup Fair Optimiser repaired\n",
+      "Instantaneous Fair Optimiser repaired\n"
+     ]
+    }
+   ],
+   "source": [
+    "subgroup_repaired = subgroup_fair_optimiser.transform(data_test.copy())\n",
+    "print(\"Subgroup Fair Optimiser repaired\")\n",
+    "instantaneous_repaired = instantaneous_fair_optimiser.transform(data_test.copy())\n",
+    "print(\"Instantaneous Fair Optimiser repaired\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Evaluating the repair algorithms\n",
+    "\n",
+    "Using the previously defined evaluator, we can now evaluate the performance of the repair algorithms. Lower scores are better for all metrics."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Subgroup Fair Optimiser evaluated\n",
+      "{'IND': 0.08595698093038928, 'SP': 0.09581577572572064, 'SF': 0.2113697894180282, 'INA': 0.3516457494672034}\n",
+      "Instantaneous Fair Optimiser evaluated\n",
+      "{'IND': 0.036757413398222305, 'SP': 0.14469668558161286, 'SF': 0.25127977354498343, 'INA': 0.62206961875444}\n"
+     ]
+    }
+   ],
+   "source": [
+    "evaluator = LDS_Fairness_Evaluator(S, Y_hat)\n",
+    "subgroup_repaired_metrics = evaluator.evaluate(data_test.copy(), subgroup_repaired.copy())\n",
+    "print(\"Subgroup Fair Optimiser evaluated\")\n",
+    "print(subgroup_repaired_metrics)\n",
+    "instantaneous_repaired_metrics = evaluator.evaluate(data_test.copy(), instantaneous_repaired.copy())\n",
+    "print(\"Instantaneous Fair Optimiser evaluated\")\n",
+    "print(instantaneous_repaired_metrics)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plotting the results\n",
+    "\n",
+    "The plot below demonstrates how the metrics from the evaluator can be visualised, and shows the performance of the case used in this demo file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABgMklEQVR4nO3deVxN+f8H8Ndtu+2FNktKhYqI7L7KEBlr9nVSRoxlMI11jEqM7IxlJgzDWMbOGAZDNGPfs0u2spW1IhT1+f3h1xlXxb1Ul+P1fDzug875nHPe53TuPa/O+ZxzFUIIASIiIiKZ0NF2AUREREQFieGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4aYIxMTEQKFQICYmRtulfDLCw8OhUCiKdJlTpkyBk5MTdHV14enpWaTLLggNGzZE5cqVtV2G7PHzgAqTQqFAeHi4tsvQOoabN1i8eDEUCkWer5EjR2q7vA9CTojQ0dHB9evXc41PS0uDkZERFAoFBg4c+E7LmDBhAjZu3PielRauv//+G8OHD0f9+vXx66+/YsKECYW+zD///BM+Pj6wsbGBsbExnJyc0KlTJ2zbtq3Ql02FL+fz5+jRo4Uy/3PnziE8PBzXrl0rlPm/6tatWwgPD0dsbGyhL+tjdO3atXyPNXXq1NF2eR8lPW0X8DGIiIhAuXLlVIZp8heut7c3nj59CgMDg4Iu7YOhVCrx+++/Y/jw4SrD169f/97znjBhAjp06AB/f3+1p/n++++LNIDu2rULOjo6WLhwYZH8nqdOnYphw4bBx8cHo0aNgrGxMS5duoSdO3di5cqVaNasWaHXQB+3c+fOYezYsWjYsCEcHR0LdVm3bt3C2LFj4ejo+FGe1SwqXbt2RfPmzVWGWVtbazSPp0+fQk+Ph3ZuATV8/vnnqFGjxjtPr6OjA0NDw7e2e/LkCYyNjd95OdrUvHnzPMPNihUr0KJFC6xbt65I6khPT4eJiQn09PSK9A1+584dGBkZFViwEULg2bNnMDIyyjXuxYsXGDduHJo0aYK///47z1o+ZB/zfk5UmKpXr44ePXq81zzUOdbkfE7KGS9LvYeEhAT0798fFStWhJGREUqUKIGOHTvmOs2b1zX2nP4Nx44dg7e3N4yNjfHdd99JpyenTp2K+fPnw9nZGUqlEjVr1sSRI0dy1XDhwgV06NABxYsXh6GhIWrUqIFNmzaptHn+/DnGjh2L8uXLw9DQECVKlMD//vc/7NixQ2qTlJSEoKAglClTBkqlEiVLlkSbNm3UPmXdrVs3xMbG4sKFCyrz3LVrF7p165bnNBkZGQgLC4OLiwuUSiXs7e0xfPhwZGRkSG0UCgXS09OxZMkS6TRtYGAggP8uiZ07dw7dunVDsWLF8L///U9l3OuWLVuGWrVqwdjYGMWKFYO3t7dKQDh69Cj8/PxgZWUFIyMjlCtXDr169XrjuisUCvz6669IT0+Xaly8eDGA/4JIzu/R0dER3333nco6AoCjoyNatmyJ7du3o0aNGjAyMsK8efPyXN69e/eQlpaG+vXr5znexsZG+n/OpQ119skcx44dQ7169aT1j4qKytUmISEBrVu3homJCWxsbPDNN99g+/btau/nwMsQ9uWXX8LW1haGhoaoWrUqlixZoladOe+TnO0MAIGBgTA1NcWVK1fg5+cHExMTlCpVChERERBC5LmtXvXHH3+gRYsWKFWqFJRKJZydnTFu3DhkZWWptMtZp3PnzuGzzz6DsbExSpcujcmTJ+ea540bN+Dv76+ynV7/3WsiZx1v3rwJf39/mJqawtraGkOHDs1V58qVK+Hl5QUzMzOYm5vDw8MDP/74I4CX+0XHjh0BAJ999pm03+Zs54LcFjExMahZsyYAICgoKNd7ZM+ePejYsSPKli0rfQ588803ePr06Tuve3Z2NmbOnIlKlSrB0NAQtra26Nu3Lx4+fJhrm/7000+oVKkSlEolSpUqhQEDBiAlJUWljaOjo/S58/r6N2zYUGXY7NmzUalSJekzpkaNGlixYkWuaTWRmZmJ0NBQeHl5wcLCAiYmJmjQoAF2796dq+3rfW7e9DmZ87mzd+9e1KpVC4aGhnBycsJvv/2Wa74pKSkYMmQI7O3toVQq4eLigkmTJiE7O1ul3Zv2O0C941FB4JkbNaSmpuLevXsqw6ysrHDkyBHs378fXbp0QZkyZXDt2jX8/PPPaNiwIc6dO/fWv07v37+Pzz//HF26dEGPHj1ga2srjVuxYgUePXqEvn37QqFQYPLkyWjXrh2uXLkCfX19AMDZs2dRv359lC5dGiNHjoSJiQlWr14Nf39/rFu3Dm3btgXwcueOjIxE7969UatWLaSlpeHo0aM4fvw4mjRpAgBo3749zp49i6+//hqOjo64c+cOduzYgcTERLVOWXt7e6NMmTJYsWIFIiIiAACrVq2CqakpWrRokat9dnY2Wrdujb1796JPnz5wc3PD6dOnMWPGDFy8eFHqY7N06VKp7j59+gAAnJ2dVebVsWNHlC9fHhMmTHjjQWzs2LEIDw9HvXr1EBERAQMDAxw6dAi7du1C06ZNcefOHTRt2hTW1tYYOXIkLC0tce3atbdeWlu6dCnmz5+Pw4cP45dffgEA1KtXDwDQu3dvLFmyBB06dMC3336LQ4cOITIyEufPn8eGDRtU5hMXF4euXbuib9++CA4ORsWKFfNcno2NDYyMjPDnn3/i66+/RvHixd9YnyYePnyI5s2bo1OnTujatStWr16Nfv36wcDAQAp56enpaNSoEW7fvo3BgwfDzs4OK1asyPODFsh7P3/69CkaNmyIS5cuYeDAgShXrhzWrFmDwMBApKSkYPDgwe9Uf1ZWFpo1a4Y6depg8uTJ2LZtG8LCwvDixQtpv8zP4sWLYWpqipCQEJiammLXrl0IDQ1FWloapkyZkms7NWvWDO3atUOnTp2wdu1ajBgxAh4eHvj8888BvLw80LhxYyQmJmLQoEEoVaoUli5dil27dr3Tur26jn5+fqhduzamTp2KnTt3Ytq0aXB2dka/fv0AADt27EDXrl3RuHFjTJo0CQBw/vx57Nu3D4MHD4a3tzcGDRqEWbNm4bvvvoObmxsASP8W5LZwc3NDREQEQkND0adPHzRo0ADAf++RNWvW4MmTJ+jXrx9KlCiBw4cPY/bs2bhx4wbWrFmj8boDQN++fbF48WIEBQVh0KBBuHr1KubMmYMTJ05g37590mdoeHg4xo4dC19fX/Tr1w9xcXH4+eefceTIEZV26lqwYAEGDRqEDh06YPDgwXj27BlOnTqFQ4cO5ftH3quePHmS61hjYWGBtLQ0/PLLL+jatSuCg4Px6NEjLFy4EH5+fjh8+LBal/ry+5y8dOkSOnTogC+//BI9e/bEokWLEBgYCC8vL1SqVEmqy8fHBzdv3kTfvn1RtmxZ7N+/H6NGjcLt27cxc+ZMAG/f7wD1jkcFQlC+fv31VwEgz5cQQjx58iTXNAcOHBAAxG+//SYN2717twAgdu/eLQ3z8fERAERUVJTK9FevXhUARIkSJcSDBw+k4X/88YcAIP78809pWOPGjYWHh4d49uyZNCw7O1vUq1dPlC9fXhpWtWpV0aJFi3zX8+HDhwKAmDJlihpbRVVYWJgAIO7evSuGDh0qXFxcpHE1a9YUQUFBQgghAIgBAwZI45YuXSp0dHTEnj17VOYXFRUlAIh9+/ZJw0xMTETPnj3zXXbXrl3zHZcjPj5e6OjoiLZt24qsrCyVttnZ2UIIITZs2CAAiCNHjmiwBV7q2bOnMDExURkWGxsrAIjevXurDB86dKgAIHbt2iUNc3BwEADEtm3b1FpeaGioACBMTEzE559/Ln744Qdx7NixXO1y9uGrV6+qDH/TPjlt2jRpWEZGhvD09BQ2NjYiMzNTCCHEtGnTBACxceNGqd3Tp0+Fq6ur2vv5zJkzBQCxbNkyaVhmZqaoW7euMDU1FWlpafnWKcR/75Nff/1VGtazZ08BQHz99dfSsOzsbNGiRQthYGAg7t69m/fG/H95vZ/79u0rjI2NVd5jOev06ns8IyND2NnZifbt2+dax9WrV0vD0tPThYuLS57r9Lqc392r+2POOkZERKi0rVatmvDy8pJ+Hjx4sDA3NxcvXrzId/5r1qzJt46C3hZHjhzJ9ft607IiIyOFQqEQCQkJ0jB1133Pnj0CgFi+fLlKu23btqkMv3PnjjAwMBBNmzZV+UyYM2eOACAWLVokDXNwcMjzM8jHx0f4+PhIP7dp00ZUqlQpV7u3ydmf83rt3r1bvHjxQmRkZKhM8/DhQ2Frayt69eqlMhyACAsLk35+0+dkzufOv//+Kw27c+eOUCqV4ttvv5WGjRs3TpiYmIiLFy+qTD9y5Eihq6srEhMThRDq7XdvOx4VFF6WUsPcuXOxY8cOlRcAlf4Qz58/x/379+Hi4gJLS0scP378rfNVKpUICgrKc1znzp1RrFgx6eecv3auXLkCAHjw4AF27dqFTp064dGjR7h37x7u3buH+/fvw8/PD/Hx8bh58yYAwNLSEmfPnkV8fHyey8rpKxITE5PnaVt1devWDZcuXcKRI0ekf/P7a2XNmjVwc3ODq6urVPu9e/fQqFEjAMj3LEBevvrqq7e22bhxI7KzsxEaGgodHdXdPufylaWlJQBg8+bNeP78udrLz89ff/0FAAgJCVEZ/u233wIAtmzZojK8XLly8PPzU2veY8eOxYoVK1CtWjVs374do0ePhpeXF6pXr47z58+/c816enro27ev9LOBgQH69u2LO3fu4NixYwCAbdu2oXTp0mjdurXUztDQEMHBwXnOM6/9/K+//oKdnR26du0qDdPX18egQYPw+PFj/PPPP++8Dq/elZdzl15mZiZ27tz5xulefT/nvKcaNGiAJ0+eqFxuBQBTU1OVvhEGBgaoVauW9P7MWceSJUuiQ4cO0jBjY2PpDOT7eH2fb9CggcqyLS0tkZ6e/s6n+gt6W6i7rPT0dNy7dw/16tWDEAInTpzI1f5t675mzRpYWFigSZMmKp8tXl5eMDU1lT5bdu7ciczMTAwZMkTlMyE4OBjm5ua53p/qsLS0xI0bN/LsQqCOPn365DrWVK1aFbq6ulJ/vuzsbDx48AAvXrxAjRo11DrWAPl/Trq7u0vHF+BlB+aKFSvm2qYNGjRAsWLFVLapr68vsrKy8O+//0rr/7b97m3Ho4LCcKOGWrVqwdfXV+UFvDztHBoaKl2DtLKygrW1NVJSUpCamvrW+ZYuXTrfDqhly5ZV+Tkn6OSEj0uXLkEIgTFjxsDa2lrlFRYWBuC/jqURERFISUlBhQoV4OHhgWHDhuHUqVPSvJVKJSZNmoStW7fC1tYW3t7emDx5MpKSkjTaTtWqVYOrqytWrFiB5cuXw87OTgorr4uPj8fZs2dz1V6hQgWV2tXx+p1sebl8+TJ0dHTg7u6ebxsfHx+0b98eY8eOhZWVFdq0aYNff/31nftIJCQkQEdHBy4uLirD7ezsYGlpiYSEBI3X41Vdu3bFnj178PDhQ/z999/o1q0bTpw4gVatWuHZs2fvVHOpUqVydTTM+Z3k9NtJSEiAs7Nzrj5Nr69njrz284SEBJQvXz5X0My5LPL6tlGXjo4OnJyc3lh/fs6ePYu2bdvCwsIC5ubmsLa2lg7ar7+fy5Qpk2v9ixUrpvLHQUJCAlxcXHK1y+9yo7oMDQ1z3UHz+rL79++PChUq4PPPP0eZMmXQq1cvjR4RUNDb4k0SExMRGBiI4sWLS/1ofHx88lyWOuseHx+P1NRU2NjY5Pp8efz4sfTZkrOPvf77MDAwgJOT0zvtgyNGjICpqSlq1aqF8uXLY8CAAdi3b5/a05cvXz7XsSbns3/JkiWoUqWK1E/F2toaW7ZsUetYA+T/+fL6sQbIe5tu27Yt1/bMORbmbFN19ru3HY8KCvvcvIevv/4av/76K4YMGYK6devCwsICCoUCXbp0ydXJKi953QmTQ1dXN8/h4v+vlebMf+jQofn+tZ9zsPH29sbly5fxxx9/4O+//8Yvv/yCGTNmICoqCr179wYADBkyBK1atcLGjRuxfft2jBkzBpGRkdi1axeqVav21nXJ0a1bN/z8888wMzND586dcx28cmRnZ8PDwwPTp0/Pc7y9vb3ay3zTdtSEQqHA2rVrcfDgQfz555/Yvn07evXqhWnTpuHgwYMwNTV95/mq413Xw9zcHE2aNEGTJk2gr6+PJUuW4NChQ/Dx8cl32a93wCxM7/P7Kar6U1JS4OPjA3Nzc0RERMDZ2RmGhoY4fvw4RowYkev9/Lb3Z2HKb9mvsrGxQWxsLLZv346tW7di69at+PXXXxEQEJCr0/brinJbZGVloUmTJnjw4AFGjBgBV1dXmJiY4ObNmwgMDFR7Wa/Kzs6GjY0Nli9fnud4TW+tBt68H75ak5ubG+Li4rB582Zs27YN69atw08//YTQ0FCMHTtW4+XmWLZsGQIDA+Hv749hw4bBxsYGurq6iIyMxOXLl9WaR37vQ3V+f9nZ2WjSpEmuu2Fz5PwBoc5+p87xqCAw3LyHtWvXomfPnpg2bZo07NmzZ7l62heGnL9O9fX1pfT8JsWLF0dQUBCCgoLw+PFjeHt7Izw8XGVncnZ2xrfffotvv/0W8fHx8PT0xLRp07Bs2TK16+rWrRtCQ0Nx+/ZtLF26NN92zs7OOHnyJBo3bvzWg39BPGnY2dkZ2dnZOHfu3Fs739WpUwd16tTBDz/8gBUrVqB79+5YuXKlxm88BwcHZGdnIz4+XjojAQDJyclISUmBg4PDu6zKG9WoUQNLlizB7du3Afx3xu/1fTK/v0pv3bqV6zbRixcvAoDUsdzBwQHnzp2DEELld3Pp0iW163RwcMCpU6eQnZ2tEoBzLnnkbBtN68/OzsaVK1ekD9u86s9LTEwM7t+/j/Xr18Pb21safvXqVbXX6XUODg44c+ZMru0UFxf3zvPUhIGBAVq1aoVWrVohOzsb/fv3x7x58zBmzJg8zyjlKIxtkd+yTp8+jYsXL2LJkiUICAiQhr/PnTPOzs7YuXMn6tev/8ZgnbOPxcXFqZzty8zMxNWrV1U+V4sVK5bn53pCQkKuM4UmJibo3LkzOnfujMzMTLRr1w4//PADRo0apdZt2nlZu3YtnJycsH79epVtmXOWvrA5Ozvj8ePHah1r3rbfAeodj94XL0u9B11d3Vx/ncyePbtI/iq2sbFBw4YNMW/ePOlA9qq7d+9K/79//77KOFNTU7i4uEiXW548eZLrMoazszPMzMw0viTj7OyMmTNnIjIyErVq1cq3XadOnXDz5k0sWLAg17inT58iPT1d+tnExOS9A6O/vz90dHQQERGR66/BnN/hw4cPc/0+c4LQu1yaynkYV86dBDlyzlbldReZOp48eYIDBw7kOW7r1q0A/jvVnnNnWc41ceDlX5vz58/Pc/oXL16o3IKemZmJefPmwdraGl5eXgAAPz8/3Lx5U+WRA8+ePcvzd5mf5s2bIykpCatWrVJZ9uzZs2FqaipdlnBwcICurq5K/cDL23fzM2fOHOn/QgjMmTMH+vr6aNy4cb7T5Pz1+urvPzMz843LeZvmzZvj1q1bWLt2rTTsyZMn+W77gvT6e15HRwdVqlQB8N++nBNgX39vFca20GRZQgiVW4c11alTJ2RlZWHcuHG5xr148UKqwdfXFwYGBpg1a5bK8hcuXIjU1FSV96ezszMOHjyIzMxMadjmzZtzPZX99e1uYGAAd3d3CCHeqx9fXtvp0KFD+X4OFLROnTrhwIED2L59e65xKSkpePHiBQD19ru3HY8KCs/cvIeWLVti6dKlsLCwgLu7Ow4cOICdO3eiRIkSRbL8uXPn4n//+x88PDwQHBwMJycnJCcn48CBA7hx4wZOnjwJ4GWHsYYNG8LLywvFixfH0aNHsXbtWqnj5cWLF9G4cWN06tQJ7u7u0NPTw4YNG5CcnIwuXbpoXJc6t/F+8cUXWL16Nb766ivs3r0b9evXR1ZWFi5cuIDVq1dLz3sBAC8vL+zcuRPTp09HqVKlUK5cOdSuXVujmlxcXDB69GiMGzcODRo0QLt27aBUKnHkyBGUKlUKkZGRWLJkCX766Se0bdsWzs7OePToERYsWABzc/NcTw1VR9WqVdGzZ0/Mnz9fOtV/+PBhLFmyBP7+/vjss880nifw8gBZr1491KlTB82aNYO9vT1SUlKwceNG7NmzB/7+/tKlxEqVKqFOnToYNWoUHjx4gOLFi2PlypXSh9HrSpUqhUmTJuHatWuoUKECVq1ahdjYWMyfP1+6LbZv376YM2cOunbtisGDB6NkyZJYvny59FepOmfa+vTpg3nz5iEwMBDHjh2Do6Mj1q5di3379mHmzJkwMzMD8PI22I4dO2L27NlQKBRwdnbG5s2b8+2TZWhoiG3btqFnz56oXbs2tm7dii1btuC777574+WIevXqoVixYujZsycGDRoEhUKBpUuXvtdlpuDgYMyZMwcBAQE4duwYSpYsiaVLlxbJAwx79+6NBw8eoFGjRihTpgwSEhIwe/ZseHp6SmcRPT09oauri0mTJiE1NRVKpRKNGjUqlG3h7OwMS0tLREVFwczMDCYmJqhduzZcXV3h7OyMoUOH4ubNmzA3N8e6deve68YGHx8f9O3bF5GRkYiNjUXTpk2hr6+P+Ph4rFmzBj/++CM6dOgAa2trjBo1CmPHjkWzZs3QunVrxMXF4aeffkLNmjVVOkn37t0ba9euRbNmzdCpUydcvnwZy5Yty/VYiqZNm8LOzg7169eHra0tzp8/jzlz5qBFixbSPv0uWrZsifXr16Nt27Zo0aIFrl69iqioKLi7u+Px48fvPF91DRs2DJs2bULLli2l28TT09Nx+vRprF27FteuXYOVlZVa+93bjkcFptDvx/qI5XUr5qsePnwogoKChJWVlTA1NRV+fn7iwoULuW4bzO+227xuGcy5JTCv27Lx2i1+Qghx+fJlERAQIOzs7IS+vr4oXbq0aNmypVi7dq3UZvz48aJWrVrC0tJSGBkZCVdXV/HDDz9It/beu3dPDBgwQLi6ugoTExNhYWEhateurXILa35evRX8TfDareBCvLz1d9KkSaJSpUpCqVSKYsWKCS8vLzF27FiRmpoqtbtw4YLw9vYWRkZGAoC0bd+07NdvBc+xaNEiUa1aNWl5Pj4+YseOHUIIIY4fPy66du0qypYtK5RKpbCxsREtW7YUR48efet2yOtWcCGEeP78uRg7dqwoV66c0NfXF/b29mLUqFEqt9MK8fKWTHVvj3z+/LlYsGCB8Pf3Fw4ODkKpVApjY2NRrVo1MWXKlFy3jF6+fFn4+voKpVIpbG1txXfffSd27NiR7z559OhRUbduXWFoaCgcHBzEnDlzctVw5coV0aJFC2FkZCSsra3Ft99+K9atWycAiIMHD+aaZ16Sk5Ol94+BgYHw8PDI81bhu3fvivbt2wtjY2NRrFgx0bdvX3HmzJk8bwU3MTERly9fFk2bNhXGxsbC1tZWhIWF5br9Py/79u0TderUEUZGRqJUqVJi+PDhYvv27Wq/d3v27CkcHBxUhiUkJIjWrVsLY2NjYWVlJQYPHizdkvyut4LntZ+9vr+vXbtWNG3aVNjY2AgDAwNRtmxZ0bdvX3H79m2V6RYsWCCcnJyErq6uSk2FsS3++OMP4e7uLvT09FR+d+fOnRO+vr7C1NRUWFlZieDgYHHy5Ml8f79vW/cc8+fPF15eXsLIyEiYmZkJDw8PMXz4cHHr1i2VdnPmzBGurq5CX19f2Nrain79+omHDx/mmt+0adNE6dKlhVKpFPXr1xdHjx7NdSv4vHnzhLe3tyhRooRQKpXC2dlZDBs2TOXzLC9v+twX4uUjDSZMmCC936tVqyY2b96c53Z+/Tjxps/J/D53Xl8vIYR49OiRGDVqlHBxcREGBgbCyspK1KtXT0ydOlU6lqiz373teFRQFEIUQQ84IpK9mTNn4ptvvsGNGzdQunTpIl9+YGAg1q5dWyR/yRLRh419bohIY68/Gv/Zs2eYN28eypcvr5VgQ0T0Kva5ISKNtWvXDmXLloWnpydSU1OxbNkyXLhwId/bb4mIihLDDRFpzM/PD7/88guWL1+OrKwsuLu7Y+XKlejcubO2SyMiAvvcEBERkaywzw0RERHJCsMNERERycon1+cmOzsbt27dgpmZWYE81p+IiIgKnxACjx49QqlSpfL93sIcn1y4uXXrlkZfykhEREQfjuvXr6NMmTJvbPPJhZucR2Bfv34d5ubmWq6GiIiI1JGWlgZ7e3u1vsrikws3OZeizM3NGW6IiIg+Mup0KWGHYiIiIpIVhhsiIiKSFYYbIiIikpVPrs+NurKysvD8+XNtl0H0UTEwMHjrLZpERIWN4eY1QggkJSUhJSVF26UQfXR0dHRQrlw5GBgYaLsUIvqEMdy8JifY2NjYwNjYmA/6I1JTzgMyb9++jbJly/K9Q0Raw3DziqysLCnYlChRQtvlEH10rK2tcevWLbx48QL6+vraLoeIPlG8OP6KnD42xsbGWq6E6OOUczkqKytLy5UQ0aeM4SYPPJ1O9G743iGiDwHDDREREckKww1JYmJioFAoeKfYK65duwaFQoHY2Fhtl0JERGpih2I1OY7cUqTLuzaxhUbt7969i9DQUGzZsgXJyckoVqwYqlatitDQUNSvX7+Qqvw4LF68GEFBQbmGL1iwAL17937jtPb29rh9+zasrKwKqzwiIipgDDcy0b59e2RmZmLJkiVwcnJCcnIyoqOjcf/+fW2XhszMTK0/98Tc3BxxcXEqwywsLN46na6uLuzs7PIdL4RAVlYW9PT4ViIi+lDwspQMpKSkYM+ePZg0aRI+++wzODg4oFatWhg1ahRat24NIO/LKykpKVAoFIiJiVGZ3759+1ClShUYGhqiTp06OHPmjMr4BQsWwN7eHsbGxmjbti2mT58OS0tLaXx4eDg8PT3xyy+/oFy5cjA0NAQAJCYmok2bNjA1NYW5uTk6deqE5ORkabrAwED4+/urLGvIkCFo2LCh9HPDhg0xcOBADBw4EBYWFrCyssKYMWMghHjjNlIoFLCzs1N5GRkZYdu2bfjf//4HS0tLlChRAi1btsTly5el6V7fbjmX7rZu3QovLy8olUrs3bsXDRs2xKBBgzB8+HAUL14cdnZ2CA8Pz/V76t27N6ytrWFubo5GjRrh5MmT0viTJ0/is88+g5mZGczNzeHl5YWjR48CABISEtCqVSsUK1YMJiYmqFSpEv766683rjMR0aeK4UYGTE1NYWpqio0bNyIjI+O95zds2DBMmzYNR44cgbW1NVq1aiXdJr9v3z589dVXGDx4MGJjY9GkSRP88MMPueZx6dIlrFu3DuvXr0dsbCyys7PRpk0bPHjwAP/88w927NiBK1euoHPnzhrXt2TJEujp6eHw4cP48ccfMX36dPzyyy/vtK7p6ekICQnB0aNHER0dDR0dHbRt2xbZ2dlvnG7kyJGYOHEizp8/jypVqkh1mZiY4NChQ5g8eTIiIiKwY8cOaZqOHTvizp072Lp1K44dO4bq1aujcePGePDgAQCge/fuKFOmDI4cOYJjx45h5MiR0rNiBgwYgIyMDPz77784ffo0Jk2aBFNT03daZyIiueO5dBnQ09PD4sWLERwcjKioKFSvXh0+Pj7o0qWLdODVRFhYGJo0aQLg5QG7TJky2LBhAzp16oTZs2fj888/x9ChQwEAFSpUwP79+7F582aVeWRmZuK3336DtbU1AGDHjh04ffo0rl69Cnt7ewDAb7/9hkqVKuHIkSOoWbOm2vXZ29tjxowZUCgUqFixIk6fPo0ZM2YgODg432lSU1NVwoCpqSmSkpLQvn17lXaLFi2CtbU1zp07h8qVK+c7v4iICGkb5ahSpQrCwsIAAOXLl8ecOXMQHR2NJk2aYO/evTh8+DDu3LkDpVIJAJg6dSo2btyItWvXok+fPkhMTMSwYcPg6uoqzSNHYmIi2rdvDw8PDwCAk5OTOpuKiD5V4W+/7F64y0/V6uJ55kYm2rdvj1u3bmHTpk1o1qwZYmJiUL16dSxevFjjedWtW1f6f/HixVGxYkWcP38eABAXF4datWqptH/9ZwBwcHCQgg0AnD9/Hvb29lKwAQB3d3dYWlpK81ZXnTp1VJ6nUrduXcTHx7/xwXFmZmaIjY2VXvv37wcAxMfHo2vXrnBycoK5uTkcHR0BvAwTb1KjRo1cw14PkiVLlsSdO3cAvLzk9PjxY5QoUUI602ZqaoqrV69Kl8FCQkLQu3dv+Pr6YuLEiSqXxwYNGoTx48ejfv36CAsLw6lTp95YHxHRp4zhRkYMDQ3RpEkTjBkzBvv370dgYKB0JiHnm5pf7ZtSmN96bmJiovE0Ojo6ufrOFFSNOjo6cHFxkV45Zz5atWqFBw8eYMGCBTh06BAOHToE4OWZpzfJa/1e/7oBhUIhXd56/PgxSpYsqRKwYmNjERcXh2HDhgF42Vfp7NmzaNGiBXbt2gV3d3ds2LABANC7d29cuXIFX3zxBU6fPo0aNWpg9uzZ77dRiIhkiuFGxtzd3ZGeng4A0lmU27dvS+Pze3bLwYMHpf8/fPgQFy9ehJubGwCgYsWKOHLkiEr713/Oi5ubG65fv47r169Lw86dO4eUlBS4u7tLNb5aX3415gSQV+stX748dHV131rHq+7fv4+4uDh8//33aNy4Mdzc3PDw4UON5qGu6tWrIykpCXp6eiohy8XFReU28woVKuCbb77B33//jXbt2uHXX3+Vxtnb2+Orr77C+vXr8e2332LBggWFUisR0ceO4UYG7t+/j0aNGmHZsmU4deoUrl69ijVr1mDy5Mlo06YNAMDIyAh16tSROsH+888/+P777/OcX0REBKKjo3HmzBkEBgbCyspKuovp66+/xl9//YXp06cjPj4e8+bNw9atW9/62H1fX194eHige/fuOH78OA4fPoyAgAD4+PhIl3gaNWqEo0eP4rfffkN8fDzCwsJy3akFvLxkFBISgri4OPz++++YPXs2Bg8erPF2K1asGEqUKIH58+fj0qVL2LVrF0JCQjSejzp8fX1Rt25d+Pv74++//8a1a9ewf/9+jB49GkePHsXTp08xcOBAxMTEICEhAfv27cORI0ekUDlkyBBs374dV69exfHjx7F7925pHBERqWK4kQFTU1PUrl0bM2bMgLe3NypXrowxY8YgODgYc+bMkdotWrQIL168gJeXF4YMGYLx48fnOb+JEydi8ODB8PLyQlJSEv7880/pOTX169dHVFQUpk+fjqpVq2Lbtm345ptvpNu986NQKPDHH3+gWLFi8Pb2hq+vL5ycnLBq1SqpjZ+fH8aMGYPhw4ejZs2aePToEQICAnLNKyAgAE+fPkWtWrUwYMAADB48GH369NF4u+no6GDlypU4duwYKleujG+++QZTpkzReD7qUCgU+Ouvv+Dt7Y2goCBUqFABXbp0QUJCAmxtbaGrq4v79+8jICAAFSpUQKdOnfD5559j7NixAF5+EeWAAQPg5uaGZs2aoUKFCvjpp58KpVYioo+dQrztASEyk5aWBgsLC6SmpsLc3Fxl3LNnz3D16lWVZ7PQ2wUHB+PChQvYs2dPoS+rYcOG8PT0xMyZMwt9WaQ5voeIPhAyvFvqTcfv1/FWcNLY1KlT0aRJE5iYmGDr1q1YsmQJzyIQEdEHQ+uXpebOnQtHR0cYGhqidu3aOHz48Bvbp6SkYMCAAShZsiSUSiUqVKjAJ7UWscOHD6NJkybw8PBAVFQUZs2a9dbvaCIiIioqWj1zs2rVKoSEhCAqKgq1a9fGzJkz4efnh7i4ONjY2ORqn5mZiSZNmsDGxgZr165F6dKlkZCQoPLofyp8q1ev1tqyX/+qCCIiotdpNdxMnz4dwcHB0jc2R0VFYcuWLVi0aBFGjhyZq/2iRYvw4MED7N+/X3qmSM5D14iIiIgALV6WyszMxLFjx+Dr6/tfMTo68PX1xYEDB/KcZtOmTahbty4GDBgAW1tbVK5cGRMmTHjjk2kzMjKQlpam8iIiIiL50lq4uXfvHrKysmBra6sy3NbWFklJSXlOc+XKFaxduxZZWVn466+/MGbMGEybNi3fW5oBIDIyEhYWFtLr1cf/ExERkfxovUOxJrKzs2FjY4P58+fDy8sLnTt3xujRoxEVFZXvNKNGjUJqaqr0evUJuURERCQ/WutzY2VlBV1dXSQnJ6sMT05Ohp2dXZ7TlCxZEvr6+iqP2Xdzc0NSUhIyMzOlB829SqlUSt/CTERERPKntTM3BgYG8PLyQnR0tDQsOzsb0dHRKt9K/ar69evj0qVL0pcRAsDFixdRsmTJPIMNERERfXq0elkqJCQECxYswJIlS3D+/Hn069cP6enp0t1TAQEBGDVqlNS+X79+ePDgAQYPHoyLFy9iy5YtmDBhAgYMGKCtVSAqVOHh4fD09NR2GUREHxWt3greuXNn3L17F6GhoUhKSoKnpye2bdsmdTJOTEyEjs5/+cve3h7bt2/HN998gypVqqB06dIYPHgwRowYUfjFFvWjrDV8dHVgYCBSUlKwcePGAlm8o6MjhgwZgiFDhhTI/F6lUCiwYcMG6cs45a5hw4b4559/cg1//vw59PTe/BYcOnQovv7668IqjYhIlrT+9QsDBw7EwIED8xyX1wPb6tati4MHDxZyVUQFKzg4GBERESrD3hZsgJdfimpqaprv+Pz6mhERfco+qrulSH0NGzbEoEGDMHz4cBQvXhx2dnYIDw+XxgshEB4ejrJly0KpVKJUqVIYNGiQNG1CQgK++eYbKBQKKBQKAMD9+/fRtWtXlC5dGsbGxvDw8MDvv/+u0XJzHrrYtm1bKBQK6efLly+jTZs2sLW1hampKWrWrImdO3eqzNvR0RETJkxAr169YGZmhrJly2L+/Pkqba5fv45OnTrB0tISxYsXR5s2bXDt2jVpfHZ2NiIiIlCmTBkolUrpbGGOmJgYKBQKpKSkSMNiY2OhUCik+SQkJKBVq1YoVqwYTExMUKlSpbd+BYixsTHs7OxUXgAwYsQIVKhQAcbGxnBycsKYMWPw/PlzabrXL0sFBgbC398fP/zwA0qVKoWKFSvi2rVrUCgUWL9+PT777DMYGxujatWquZ4XtXfvXjRo0ABGRkawt7fHoEGDkJ6eLo3/6aefUL58eRgaGsLW1hYdOnSQxq1duxYeHh4wMjJCiRIl4OvrqzItEdGHhOFGxpYsWQITExMcOnQIkydPRkREBHbs2AEAWLduHWbMmIF58+YhPj4eGzduhIeHBwBg/fr1KFOmDCIiInD79m3cvn0bwMtvfPby8sKWLVtw5swZ9OnTB1988UWu7wN703KPHDkCAPj1119x+/Zt6efHjx+jefPmiI6OxokTJ9CsWTO0atUKiYmJKvOeNm0aatSogRMnTqB///7o168f4uLiALy8zOPn5wczMzPs2bMH+/btg6mpKZo1a4bMzEwAwI8//ohp06Zh6tSpOHXqFPz8/NC6dWvEx8ervV0HDBiAjIwM/Pvvvzh9+jQmTZr0xrMrb2JmZobFixfj3Llz+PHHH7FgwQLMmDHjjdNER0cjLi4OO3bswObNm6Xho0ePxtChQxEbG4sKFSqga9euePHiBYCX4bFZs2Zo3749Tp06hVWrVmHv3r3SWdOjR49i0KBBiIiIQFxcHLZt2wZvb28AwO3bt9G1a1f06tUL58+fR0xMDNq1awchxDutMxFRYdP6ZSkqPFWqVEFYWBgAoHz58pgzZw6io6PRpEkTJCYmws7ODr6+vtDX10fZsmVRq1YtAEDx4sWhq6sLMzMzldvyS5cujaFDh0o/f/3119i+fTtWr14tTfu25VpbWwMALC0tVeZdtWpVVK1aVfp53Lhx2LBhAzZt2qRy2bJ58+bo378/gJdnPWbMmIHdu3ejYsWKWLVqFbKzs/HLL79IZ5t+/fVXWFpaIiYmBk2bNsXUqVMxYsQIdOnSBQAwadIk7N69GzNnzsTcuXPV2q6JiYlo3769FAadnJzeOs1PP/2EX375Rfq5b9++mDZtGr7//ntpmKOjI4YOHYqVK1di+PDh+c7LxMQEv/zyi3Q5KueM0tChQ9GiRQsAwNixY1GpUiVcunQJrq6uiIyMRPfu3aU+VOXLl8esWbPg4+ODn3/+GYmJiTAxMUHLli1hZmYGBwcHVKtWDcDLcPPixQu0a9cODg4OACCtOxHRh4jhRsaqVKmi8nPJkiVx584dAEDHjh0xc+ZMODk5oVmzZmjevDlatWr1xn4gWVlZmDBhAlavXo2bN28iMzMTGRkZMDY2Vnu5+Xn8+DHCw8OxZcsW6WD69OnTXGduXp23QqGAnZ2dNO+TJ0/i0qVLMDMzU5nm2bNnuHz5MtLS0nDr1i3Ur19fZXz9+vVx8uTJN9b3qkGDBqFfv374+++/4evri/bt2+da59d1794do0ePln7O+bLXVatWYdasWbh8+TIeP36MFy9ewNzc/I3z8vDwyLOfzas1lCxZEgBw584duLq64uTJkzh16hSWL18utRFCIDs7G1evXkWTJk3g4OAg7Q/NmjVD27ZtpUtcjRs3hoeHB/z8/NC0aVN06NABxYoVe+u2IiLSBl6WkrGcLxfNoVAopGcE2dvbIy4uDj/99BOMjIzQv39/eHt7q/T3eN2UKVPw448/YsSIEdi9ezdiY2Ph5+cnXfJRZ7n5GTp0KDZs2IAJEyZgz549iI2NhYeHh0bzfvz4Mby8vBAbG6vyunjxIrp16/bG5efIuTvv1Usur2+T3r1748qVK/jiiy9w+vRp1KhRA7Nnz37jfC0sLODi4iK9rKyscODAAXTv3h3NmzfH5s2bceLECYwePTrXOr/OxMQkz+GvbpucM1evbpu+ffuqbJeTJ08iPj4ezs7OMDMzw/Hjx/H777+jZMmSCA0NRdWqVZGSkgJdXV3s2LEDW7duhbu7O2bPno2KFSvi6tWrb6yTiEhbGG4+YUZGRmjVqhVmzZqFmJgYHDhwAKdPnwbw8iGLr38h6b59+9CmTRv06NEDVatWhZOTEy5evKjxcvX19fOcd2BgINq2bQsPDw/Y2dmpdARWR/Xq1REfHw8bGxuVIOHi4gILCwuYm5ujVKlS2LdvX65lu7u7A4B02SynnxHwskPx6+zt7fHVV19h/fr1+Pbbb7FgwQKNagWA/fv3w8HBAaNHj0aNGjVQvnx5JCQkaDwfdVSvXh3nzp3LtV1cXFyks0B6enrw9fXF5MmTcerUKVy7dg27du0C8DIs1a9fH2PHjsWJEydgYGCADRs2FEqtRETvi+HmE7V48WIsXLgQZ86cwZUrV7Bs2TIYGRlJfSocHR3x77//4ubNm7h37x6Al/00duzYgf379+P8+fPo27dvrq/PUIejoyOio6ORlJSEhw8fSvNev369dEahW7dubz3b87ru3bvDysoKbdq0wZ49e3D16lXExMRg0KBBuHHjBgBg2LBhmDRpElatWoW4uDiMHDkSsbGxGDx4MADAxcUF9vb2CA8PR3x8PLZs2YJp06apLGfIkCHYvn07rl69iuPHj2P37t1wc3PTeDuUL18eiYmJWLlyJS5fvoxZs2YVWmAYMWIE9u/fj4EDByI2Nhbx8fH4448/pP5MmzdvxqxZsxAbG4uEhAT89ttvyM7ORsWKFXHo0CFMmDABR48eRWJiItavX4+7d+++0zoTERUFhptPlKWlJRYsWID69eujSpUq2LlzJ/7880+UKFECABAREYFr167B2dlZOpvx/fffo3r16vDz80PDhg1hZ2f3Tg/imzZtGnbs2AF7e3up0+r06dNRrFgx1KtXD61atYKfnx+qV6+u0XyNjY3x77//omzZsmjXrh3c3Nzw5Zdf4tmzZ1I/lkGDBiEkJATffvstPDw8sG3bNmzatAnly5cH8PKs0u+//44LFy6gSpUqmDRpUq5vnc/KysKAAQPg5uaGZs2aoUKFCvjpp5803g6tW7fGN998g4EDB8LT0xP79+/HmDFjNJ6POqpUqYJ//vkHFy9eRIMGDVCtWjWEhoaiVKlSAF7uD+vXr0ejRo3g5uaGqKgo/P7776hUqRLMzc3x77//onnz5qhQoQK+//57TJs2DZ9//nmh1EpE9L4U4hO7nzMtLQ0WFhZITU3N1XHz2bNnuHr1KsqVKwdDQ0MtVUj08eJ7iOgDUdRP1c+1fM2esq+ONx2/X8czN0RERCQrDDdEREQkKww3REREJCsMN0RERCQrDDd5+MT6WBMVGL53iOhDwHDzipwnvD558kTLlRB9nHKerqyrq6vlSojoU8bvlnqFrq4uLC0tpe8qMjY2lh5jT0Rvlp2djbt378LY2PiN31FGRFTY+An0mpxvqn7bFz0SUW46OjooW7Ys/yggIq1iuHmNQqFAyZIlYWNj88YvkSSi3AwMDKQvHyUi0haGm3zo6uqy3wAREdFHiH9iERERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrHwQ4Wbu3LlwdHSEoaEhateujcOHD+fbdvHixVAoFCovQ0PDIqyWiIiIPmRaDzerVq1CSEgIwsLCcPz4cVStWhV+fn64c+dOvtOYm5vj9u3b0ishIaEIKyYiIqIPmdbDzfTp0xEcHIygoCC4u7sjKioKxsbGWLRoUb7TKBQK2NnZSS9bW9sirJiIiIg+ZFoNN5mZmTh27Bh8fX2lYTo6OvD19cWBAwfyne7x48dwcHCAvb092rRpg7Nnz+bbNiMjA2lpaSovIiIiki+thpt79+4hKysr15kXW1tbJCUl5TlNxYoVsWjRIvzxxx9YtmwZsrOzUa9ePdy4cSPP9pGRkbCwsJBe9vb2Bb4eRERE9OHQ+mUpTdWtWxcBAQHw9PSEj48P1q9fD2tra8ybNy/P9qNGjUJqaqr0un79ehFXTEREREVJT5sLt7Kygq6uLpKTk1WGJycnw87OTq156Ovro1q1arh06VKe45VKJZRK5XvXSkRERB8HrZ65MTAwgJeXF6Kjo6Vh2dnZiI6ORt26ddWaR1ZWFk6fPo2SJUsWVplERET0EdHqmRsACAkJQc+ePVGjRg3UqlULM2fORHp6OoKCggAAAQEBKF26NCIjIwEAERERqFOnDlxcXJCSkoIpU6YgISEBvXv31uZqEBER0QdC6+Gmc+fOuHv3LkJDQ5GUlARPT09s27ZN6mScmJgIHZ3/TjA9fPgQwcHBSEpKQrFixeDl5YX9+/fD3d1dW6tAREREHxCFEEJou4iilJaWBgsLC6SmpsLc3Fzb5RARERW8cAstLz+1wGepyfH7o7tbioiIiOhNGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFY+iHAzd+5cODo6wtDQELVr18bhw4fVmm7lypVQKBTw9/cv3AKJiIjoo6H1cLNq1SqEhIQgLCwMx48fR9WqVeHn54c7d+68cbpr165h6NChaNCgQRFVSkRERB8DrYeb6dOnIzg4GEFBQXB3d0dUVBSMjY2xaNGifKfJyspC9+7dMXbsWDg5ORVhtURERPSh02q4yczMxLFjx+Dr6ysN09HRga+vLw4cOJDvdBEREbCxscGXX3751mVkZGQgLS1N5UVERETy9U7hZs+ePejRowfq1q2LmzdvAgCWLl2KvXv3ajSfe/fuISsrC7a2tirDbW1tkZSUlOc0e/fuxcKFC7FgwQK1lhEZGQkLCwvpZW9vr1GNRERE9HHRONysW7cOfn5+MDIywokTJ5CRkQEASE1NxYQJEwq8wFc9evQIX3zxBRYsWAArKyu1phk1ahRSU1Ol1/Xr1wu1RiIiItIuPU0nGD9+PKKiohAQEICVK1dKw+vXr4/x48drNC8rKyvo6uoiOTlZZXhycjLs7Oxytb98+TKuXbuGVq1aScOys7MBAHp6eoiLi4Ozs7PKNEqlEkqlUqO6iIiI6OOl8ZmbuLg4eHt75xpuYWGBlJQUjeZlYGAALy8vREdHS8Oys7MRHR2NunXr5mrv6uqK06dPIzY2Vnq1bt0an332GWJjY3nJiYiIiDQ/c2NnZ4dLly7B0dFRZfjevXvf6c6lkJAQ9OzZEzVq1ECtWrUwc+ZMpKenIygoCAAQEBCA0qVLIzIyEoaGhqhcubLK9JaWlgCQazgRERF9mjQON8HBwRg8eDAWLVoEhUKBW7du4cCBAxg6dCjGjBmjcQGdO3fG3bt3ERoaiqSkJHh6emLbtm1SJ+PExETo6Gj9jnUiIiL6SCiEEEKTCYQQmDBhAiIjI/HkyRMAL/u1DB06FOPGjSuUIgtSWloaLCwskJqaCnNzc22XQ0REVPDCLbS8/NQCn6Umx2+NztxkZWVh3759GDBgAIYNG4ZLly7h8ePHcHd3h6mp6XsVTURERFQQNAo3urq6aNq0Kc6fPw9LS0u4u7sXVl1ERERE70TjziyVK1fGlStXCqMWIiIiovemcbgZP348hg4dis2bN+P27dv8agMiIiL6oGh8t1Tz5s0BAK1bt4ZCoZCGCyGgUCiQlZVVcNURERERaUjjcLN79+7CqIOIiIioQGgcbnx8fAqjDiIiIqICoXG4AYCUlBQsXLgQ58+fBwBUqlQJvXr1goWFlu+rJyIiok+exh2Kjx49CmdnZ8yYMQMPHjzAgwcPMH36dDg7O+P48eOFUSMRERGR2jQ+c/PNN9+gdevWWLBgAfT0Xk7+4sUL9O7dG0OGDMG///5b4EUSERERqUvjcHP06FGVYAMAenp6GD58OGrUqFGgxRERERFpSuPLUubm5khMTMw1/Pr16zAzMyuQooiIiIjelcbhpnPnzvjyyy+xatUqXL9+HdevX8fKlSvRu3dvdO3atTBqJCIiIlKbxpelpk6dCoVCgYCAALx48QIAoK+vj379+mHixIkFXiARERGRJhRCCPEuEz558gSXL18GADg7O8PY2LhACyssmnxlOhER0UcpXMuPZglPLfBZanL81vjMTWpqKrKyslC8eHF4eHhIwx88eAA9PT0GBiIiItIqjfvcdOnSBStXrsw1fPXq1ejSpUuBFEVERET0rjQON4cOHcJnn32Wa3jDhg1x6NChAimKiIiI6F1pHG4yMjKkjsSvev78OZ4+fVogRRERERG9K43DTa1atTB//vxcw6OiouDl5VUgRRERERG9K407FI8fPx6+vr44efIkGjduDACIjo7GkSNH8Pfffxd4gURERESa0Djc1K9fHwcOHMCUKVOwevVqGBkZoUqVKli4cCHKly9fGDUSERF9NBxHbtF2CbhmqO0KtEvjcAMAnp6eWL58eUHXQkRERPTe1A43L168QFZWFpRKpTQsOTkZUVFRSE9PR+vWrfG///2vUIokIiIiUpfa4SY4OBgGBgaYN28eAODRo0eoWbMmnj17hpIlS2LGjBn4448/0Lx580IrloiIiOht1L5bat++fWjfvr3082+//YasrCzEx8fj5MmTCAkJwZQpUwqlSCIiIiJ1qR1ubt68qdJhODo6Gu3bt4eFxcvvr+jZsyfOnj1b8BUSERERaUDtcGNoaKjykL6DBw+idu3aKuMfP35csNURERERaUjtcOPp6YmlS5cCAPbs2YPk5GQ0atRIGn/58mWUKlWq4CskIiIi0oDaHYpDQ0Px+eefY/Xq1bh9+zYCAwNRsmRJafyGDRtQv379QimSiIiISF1qhxsfHx8cO3YMf//9N+zs7NCxY0eV8Z6enqhVq1aBF0hERESkCY0e4ufm5gY3N7c8x/Xp06dACiIiIiJ6Hxp/cSYRERHRh4zhhoiIiGSF4YaIiIhkheGGiIiIZEXjcHPkyBEcOnQo1/BDhw7h6NGjBVIUERER0bvSONwMGDAA169fzzX85s2bGDBgQIEURURERPSuNA43586dQ/Xq1XMNr1atGs6dO1cgRRERERG9K43DjVKpRHJycq7ht2/fhp6eRo/NISIiIipwGoebpk2bYtSoUUhNTZWGpaSk4LvvvkOTJk0KtDgiIiIiTWl8qmXq1Knw9vaGg4MDqlWrBgCIjY2Fra2t9MWaRERERNqicbgpXbo0Tp06heXLl+PkyZMwMjJCUFAQunbtCn19/cKokYiIiEht79RJxsTEhN8lRURERB8ktcLNpk2b8Pnnn0NfXx+bNm16Y9vWrVsXSGFERERE70KtcOPv74+kpCTY2NjA398/33YKhQJZWVkFVRsRERGRxtS6Wyo7Oxs2NjbS//N7vWuwmTt3LhwdHWFoaIjatWvj8OHD+bZdv349atSoAUtLS5iYmMDT05MdmYmIiEii0a3gz58/R+PGjREfH19gBaxatQohISEICwvD8ePHUbVqVfj5+eHOnTt5ti9evDhGjx6NAwcO4NSpUwgKCkJQUBC2b99eYDURERHRx0ujcKOvr49Tp04VaAHTp09HcHAwgoKC4O7ujqioKBgbG2PRokV5tm/YsCHatm0LNzc3ODs7Y/DgwahSpQr27t1boHURERHRx0njh/j16NEDCxcuLJCFZ2Zm4tixY/D19f2vIB0d+Pr64sCBA2+dXgiB6OhoxMXFwdvbO882GRkZSEtLU3kRERGRfGl8K/iLFy+waNEi7Ny5E15eXjAxMVEZP336dLXnde/ePWRlZcHW1lZluK2tLS5cuJDvdKmpqShdujQyMjKgq6uLn376Kd+nI0dGRmLs2LFq10REREQfN43DzZkzZ6Qvzrx48WKBF6QOMzMzxMbG4vHjx4iOjkZISAicnJzQsGHDXG1HjRqFkJAQ6ee0tDTY29sXYbVERERUlDQON7t37y6whVtZWUFXVzfXF3EmJyfDzs4u3+l0dHTg4uICAPD09MT58+cRGRmZZ7hRKpVQKpUFVjMRERF92DTuc9OrVy88evQo1/D09HT06tVLo3kZGBjAy8sL0dHR0rDs7GxER0ejbt26as8nOzsbGRkZGi2biIiI5EnjcLNkyRI8ffo01/CnT5/it99+07iAkJAQLFiwAEuWLMH58+fRr18/pKenIygoCAAQEBCAUaNGSe0jIyOxY8cOXLlyBefPn8e0adOwdOlS9OjRQ+NlExERkfyofVkqLS0NQggIIfDo0SMYGhpK47KysvDXX39JD/rTROfOnXH37l2EhoYiKSkJnp6e2LZtm9TJODExETo6/2Ww9PR09O/fHzdu3ICRkRFcXV2xbNkydO7cWeNlExERkfwohBBCnYY6OjpQKBT5z0ihwNixYzF69OgCK64wpKWlwcLCAqmpqTA3N9d2OUREJDOOI7douwRcM+ym3QLCUwt8lpocv9U+c7N7924IIdCoUSOsW7cOxYsXl8YZGBjAwcEBpUqVeveqiYiIiAqA2uHGx8cHAHD16lWULVv2jWdxiIiIiLRF4w7FDg4O2Lt3L3r06IF69erh5s2bAIClS5fyKxCIiIhI6zQON+vWrYOfnx+MjIxw/Phx6Rbs1NRUTJgwocALJCIiItKExuFm/PjxiIqKwoIFC6Cvry8Nr1+/Po4fP16gxRERERFpSuNwk9+XVFpYWCAlJaUgaiIiIiJ6ZxqHGzs7O1y6dCnX8L1798LJyalAiiIiIiJ6VxqHm+DgYAwePBiHDh2CQqHArVu3sHz5cgwdOhT9+vUrjBqJiIiI1KbxF2eOHDkS2dnZaNy4MZ48eQJvb28olUoMHToUX3/9dWHUSERERKQ2jcONQqHA6NGjMWzYMFy6dAmPHz+Gu7s7TE1NC6M+IiIiIo1oHG5yGBgYwN3dvSBrISIiInpvaoebXr16qdVu0aJF71wMERER0ftSO9wsXrwYDg4OqFatGtT8rk0iIiKiIqd2uOnXrx9+//13XL16FUFBQejRo4fKl2cSERERfQjUvhV87ty5uH37NoYPH44///wT9vb26NSpE7Zv384zOURERPTB0Og5N0qlEl27dsWOHTtw7tw5VKpUCf3794ejoyMeP35cWDUSERERqU3jh/hJE+roQKFQQAiBrKysgqyJiIiI6J1pFG4yMjLw+++/o0mTJqhQoQJOnz6NOXPmIDExkc+5ISIiog+C2h2K+/fvj5UrV8Le3h69evXC77//Disrq8KsjYiIiEhjaoebqKgolC1bFk5OTvjnn3/wzz//5Nlu/fr1BVYcERERkabUDjcBAQFQKBSFWQsRERHRe9PoIX5ERPQRCLfQ8vJTtbt8+uS9891SRERERB8ihhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhU9bRdARCQnjiO3aLsEXDPUdgVE2sUzN0RERCQrH0S4mTt3LhwdHWFoaIjatWvj8OHD+bZdsGABGjRogGLFiqFYsWLw9fV9Y3siIiL6tGg93KxatQohISEICwvD8ePHUbVqVfj5+eHOnTt5to+JiUHXrl2xe/duHDhwAPb29mjatClu3rxZxJUTERHRh0jr4Wb69OkIDg5GUFAQ3N3dERUVBWNjYyxatCjP9suXL0f//v3h6ekJV1dX/PLLL8jOzkZ0dHQRV05EREQfIq2Gm8zMTBw7dgy+vr7SMB0dHfj6+uLAgQNqzePJkyd4/vw5ihcvXlhlEhER0UdEq3dL3bt3D1lZWbC1tVUZbmtriwsXLqg1jxEjRqBUqVIqAelVGRkZyMjIkH5OS0t794KJiIjog6f1y1LvY+LEiVi5ciU2bNgAQ8O8732MjIyEhYWF9LK3ty/iKomIiKgoaTXcWFlZQVdXF8nJySrDk5OTYWdn98Zpp06diokTJ+Lvv/9GlSpV8m03atQopKamSq/r168XSO1ERET0YdJquDEwMICXl5dKZ+CczsF169bNd7rJkydj3Lhx2LZtG2rUqPHGZSiVSpibm6u8iIiISL60/oTikJAQ9OzZEzVq1ECtWrUwc+ZMpKenIygoCAAQEBCA0qVLIzIyEgAwadIkhIaGYsWKFXB0dERSUhIAwNTUFKamplpbDyIiIvowaD3cdO7cGXfv3kVoaCiSkpLg6emJbdu2SZ2MExMToaPz3wmmn3/+GZmZmejQoYPKfMLCwhAeHl6UpRMREdEHSOvhBgAGDhyIgQMH5jkuJiZG5edr164VfkFERET00fqo75YiIiIieh3DDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERyYqetgsgogIWbqHl5adqd/lE9MnjmRsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWth5u5c+fC0dERhoaGqF27Ng4fPpxv27Nnz6J9+/ZwdHSEQqHAzJkzi65QIiIi+ihoNdysWrUKISEhCAsLw/Hjx1G1alX4+fnhzp07ebZ/8uQJnJycMHHiRNjZ2RVxtURERPQx0Gq4mT59OoKDgxEUFAR3d3dERUXB2NgYixYtyrN9zZo1MWXKFHTp0gVKpbKIqyUiIqKPgdbCTWZmJo4dOwZfX9//itHRga+vLw4cOFBgy8nIyEBaWprKi4iIiORLa+Hm3r17yMrKgq2trcpwW1tbJCUlFdhyIiMjYWFhIb3s7e0LbN5ERET04dF6h+LCNmrUKKSmpkqv69eva7skIiIiKkR62lqwlZUVdHV1kZycrDI8OTm5QDsLK5VK9s8hIiL6hGgt3BgYGMDLywvR0dHw9/cHAGRnZyM6OhoDBw7UVllE781x5BatLv+aoVYXT0SkdVoLNwAQEhKCnj17okaNGqhVqxZmzpyJ9PR0BAUFAQACAgJQunRpREZGAnjZCfncuXPS/2/evInY2FiYmprCxcVFa+tBREREHw6thpvOnTvj7t27CA0NRVJSEjw9PbFt2zapk3FiYiJ0dP7rFnTr1i1Uq1ZN+nnq1KmYOnUqfHx8EBMTU9TlExER0QdIq+EGAAYOHJjvZajXA4ujoyOEEEVQFREREX2sZH+3FBEREX1atH7mRm603pl0YgutLp+IiEjbeOaGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkRU/bBVABC7fQ8vJTtbt8IiL65PHMDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJCsMNERERycoHEW7mzp0LR0dHGBoaonbt2jh8+PAb269Zswaurq4wNDSEh4cH/vrrryKqlIiIiD50Wg83q1atQkhICMLCwnD8+HFUrVoVfn5+uHPnTp7t9+/fj65du+LLL7/EiRMn4O/vD39/f5w5c6aIKyciIqIPkdbDzfTp0xEcHIygoCC4u7sjKioKxsbGWLRoUZ7tf/zxRzRr1gzDhg2Dm5sbxo0bh+rVq2POnDlFXDkRERF9iLQabjIzM3Hs2DH4+vpKw3R0dODr64sDBw7kOc2BAwdU2gOAn59fvu2JiIjo06KnzYXfu3cPWVlZsLW1VRlua2uLCxcu5DlNUlJSnu2TkpLybJ+RkYGMjAzp59TUVABAWlra+5Ser+yMJ4UyX3WlKYRWl49C2q4fE+4Dn/Y+oO3fP8B9QNu4D6BQ9oGc47YQb183rYabohAZGYmxY8fmGm5vb6+FagqfhbYLmKj1Cj55Wv8NcB/QOq3/BrgPaJ3WfwOFuA88evQIFhZvnr9Ww42VlRV0dXWRnJysMjw5ORl2dnZ5TmNnZ6dR+1GjRiEkJET6OTs7Gw8ePECJEiWgUCjecw3kJS0tDfb29rh+/TrMzc21XQ5pAfcB4j5AH+o+IITAo0ePUKpUqbe21Wq4MTAwgJeXF6Kjo+Hv7w/gZfiIjo7GwIED85ymbt26iI6OxpAhQ6RhO3bsQN26dfNsr1QqoVQqVYZZWloWRPmyZW5u/kHt0FT0uA8Q9wH6EPeBt52xyaH1y1IhISHo2bMnatSogVq1amHmzJlIT09HUFAQACAgIAClS5dGZGQkAGDw4MHw8fHBtGnT0KJFC6xcuRJHjx7F/PnztbkaRERE9IHQerjp3Lkz7t69i9DQUCQlJcHT0xPbtm2TOg0nJiZCR+e/m7rq1auHFStW4Pvvv8d3332H8uXLY+PGjahcubK2VoGIiIg+IFoPNwAwcODAfC9DxcTE5BrWsWNHdOzYsZCr+vQolUqEhYXluoxHnw7uA8R9gOSwDyiEOvdUEREREX0ktP6EYiIiIqKCxHBDREREssJwQ0RERLLCcENERESywnDzCQgMDJQekhgYGAiFQoGJEyeqtNm4caPKE5tjYmKgUCigUCigo6MDCwsLVKtWDcOHD8ft27eLsnwqBHfv3kW/fv1QtmxZKJVK2NnZwc/PD/v27QMAODo6Sr9/ExMTVK9eHWvWrNFy1VSQNNkHcl5lypTRctX0Pt7lWPAqV1dXKJXKfL/L8UPCcPMJMjQ0xKRJk/Dw4cO3to2Li8OtW7dw5MgRjBgxAjt37kTlypVx+vTpIqiUCkv79u1x4sQJLFmyBBcvXsSmTZvQsGFD3L9/X2oTERGB27dv48SJE6hZsyY6d+6M/fv3a7FqKkia7AM5rxMnTmixYipomhwL9u7di6dPn6JDhw5YsmRJEVT3fj6I59xQ0fL19cWlS5cQGRmJyZMnv7GtjY0NLC0tYWdnhwoVKqBNmzaoVq0a+vXrh7179xZRxVSQUlJSsGfPHsTExMDHxwcA4ODggFq1aqm0MzMzg52dHezs7DB37lwsW7YMf/75J+rVq6eNsqkAaboPkDxpcixYuHAhunXrBh8fHwwePBgjRowooirfDc/cfIJ0dXUxYcIEzJ49Gzdu3NBoWiMjI3z11VfYt28f7ty5U0gVUmEyNTWFqakpNm7ciIyMDLWm0dPTg76+PjIzMwu5OioK77IPkPyoeyx49OgR1qxZgx49eqBJkyZITU3Fnj17irBSzTHcfKLatm0LT09PhIWFaTytq6srAODatWsFXBUVBT09PSxevBhLliyBpaUl6tevj++++w6nTp3Ks31mZiYiIyORmpqKRo0aFXG1VBjU3QdGjBghBSFTU1PMmjVLSxVTYVHnWLBy5UqUL18elSpVgq6uLrp06YKFCxcWYZWaY7j5hE2aNAlLlizB+fPnNZou56HW+XU6ow9f+/btcevWLWzatAnNmjVDTEwMqlevjsWLF0ttcg5sxsbGmDRpEiZOnIgWLVpor2gqUOrsA8OGDUNsbKz0CggI0F7BVGjedixYtGgRevToIf3co0cPrFmzBo8ePSqqEjXGcPMJ8/b2hp+fH0aNGqXRdDlvAEdHx0KoioqKoaEhmjRpgjFjxmD//v0IDAxU+est58B248YNPHz48IO/xk6ae9s+YGVlBRcXF+llaWmpvWKp0LzpWHDu3DkcPHgQw4cPh56eHvT09FCnTh08efIEK1eu1EK16mG4+cRNnDgRf/75Jw4cOKBW+6dPn2L+/Pnw9vaGtbV1IVdHRcnd3R3p6enSzzkHNjs7O56l+0S8vg/QpyO/Y8HChQvh7e2NkydPqpzFCwkJ+aAvTfFuqU+ch4cHunfvnu+19Dt37uDZs2d49OgRjh07hsmTJ+PevXtYv359EVdKBeX+/fvo2LEjevXqhSpVqsDMzAxHjx7F5MmT0aZNG22XR0WA+wC9Lq9jwfPnz7F06VJERESgcuXKKu179+6N6dOn4+zZs6hUqVJRl/tWDDeEiIgIrFq1Ks9xFStWhEKhgKmpKZycnNC0aVOEhITw9tCPmKmpKWrXro0ZM2bg8uXLeP78Oezt7REcHIzvvvtO2+VREeA+QHl5/ViwadMm3L9/H23bts3V1s3NDW5ubli4cCGmT59elGWqRSFyeocSERERyQD73BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQkdoCAwOhUCjQsGFDbZciW9zGRO+P4YboE9CwYUMoFIo8Xxs3blR7Ps7Ozqhduzbc3d0Lr9giFBMTo7ItXv9akeHDh6uMf/bsmUbzd3R0hEKhQHh4uNrTyG0bE2kDv36B6BNiYGCAatWqqQwrXry42tOPGTMGY8aMeWu7zMxMGBgYaFyfts2ZMwft2rUD8PJLYovyiwGzsrIAqL+NiSh/PHND9AkpWbIkDh48qPLy9vYGAPTs2RPly5eHmZkZDAwM4ODggEGDBiEtLU2aPq9LJjlnNSZPnox27drB1NQUffr0wbVr16RxixcvRsuWLWFsbIxy5crlCg23bt1Cr169UKpUKRgYGMDJyQnjxo3DixcvpDYHDx5E48aNUaJECRgaGsLR0RH+/v64fPkyACApKQndu3dHyZIloVQqYWdnh0aNGuGvv/5Sa9vo6+tj9+7dOHPmDABg+fLlePDgAfT19fNsv3XrVvj4+MDMzAxGRkZo0KABdu/eDQDSuickJAAAxo4dK20LAAgPD4dCoYCjoyN+++03ODs7w8DAANevX89zG2dmZuKHH36Am5sbDA0NYWlpCR8fH9y4cUOtdSP65Agikj0fHx8BQDg4OOTbxsLCQpQoUUJUrVpVODk5CQACgOjQoYPUpmfPngKA8PHxkYbltDMwMBDm5uaicuXKIjg4WFy9elUap6+vLxwdHYW5ubkAIHR0dMT58+eFEELcu3dP2NvbCwDCzMxMVKlSRejp6QkAIigoSAghRFZWlihRooQAIGxtbYWnp6ewtrYWAMTu3buFEEK0bdtWABCmpqaievXqwt7eXigUChEWFpbvOu/evVuqsUuXLgKA6Nu3rxBCiCpVqgiFQiENByCePn0qhBBi5cqVQqFQSNu0XLlyAoDQ1dUVu3btErdu3RK1a9cWBgYGAoAoXbq0qF27tqhdu7YQQoiwsDBpuygUClGhQgVRsmRJcfXq1Ty3ccuWLaUaSpYsKVxdXYWurq44ceKEmnsA0aeF4YboE5ATbvJ65YiNjVWZZvTo0QKA0NPTkw7qbwo3rq6u4sGDB0IIIV68eKESbjp06CCys7PFyZMnpWE///yzEEKI8PBwKbTcuXNHCCHExo0bBQChUChEfHy8uHfvnjTdjRs3pGWfOXNGJCcnCyGEqFy5sgAgli1bJo2/deuWFKLy8mq42bhxo7C2thYmJibijz/+EABE06ZNpSDyarhxdHQUAESvXr1Edna2yM7OlsLV//73P2n+Dg4OAkCugPXqPHO2Q3Z2tsjKysq1jf/55x+p7cCBA0VWVpYQQohr166J+/fv57tuRJ8yXpYi+oQYGBigdu3aKq8cO3fuROXKlWFkZASFQoEffvgBAPDixQvcvXv3rfPu2bMnihUrBgDQ1dVVGde9e3coFAqVTrLJyckAgMOHD0s/29jYQKFQwN/fHwAghMChQ4dQokQJ1K1bFwDg4uICDw8PdO3aFSdOnICVlRUAoFWrVlIdLi4uaNmyJZYtW4ZSpUqptW2USiWCg4ORnp6OL774AgDw9ddf52p39+5dXLt2DQCwaNEi6OjoQEdHBxs2bAAAHDp0SK3lAYCRkRH69OkD4OXlPR2d3B/Jr85v5MiRUhsHBweN+ksRfUrYoZjoE5LT5+Z1y5cvx9ChQ6U29vb2uHfvHq5cuQLgv86ub2Jra5vvOEtLSwCAnt5/HzlCCJU2ZmZmed4hZGxsDACIjo7GihUrsG/fPpw7dw5r167FypUrcfv2bQwbNgw//PAD6tevj+3bt+PMmTP4999/sWXLFsTExGDLli1vrR8A+vXrh8mTJyMtLQ1OTk5o3rw5jh49mm97JycnWFtb5xqubodqa2vrPAMNEb0fvquISAo8ZmZmuHr1Kg4dOoSmTZtqNI+czrKaqlmzJoCXwWflypVSR+cdO3agf//+aNu2LYQQ2L9/PwIDA7Fo0SIcPHgQX375JQDg33//BQDs27cPPj4+mDVrFnbt2oX58+erjFdHmTJlpLNGAwYMyDN4WFtbw8HBAQBQvXp17N27V6r5t99+w7hx46RgkxPM0tPT81yeOtvs1bNrU6ZMkULh9evX8eDBA7XXjehTwnBDRKhSpQoA4NGjR3BycoKTkxNWr15dJMseMGAASpcujYcPH6JixYrw9PSEs7MzSpQogZ49ewJ4eebI19cXxYoVQ6VKleDh4YEFCxao1D5y5EiUKFECLi4u8PLyQq9evVTGq2vp0qW4e/cuBg0alG+bCRMmAADWrl2LUqVKoVq1arCzs0PFihWxfPlyqZ2rqysAYNasWahZsyaCgoI0qgUAvL290bJlSwDAjz/+iNKlS8Pd3R1OTk5ITEzUeH5EnwKGGyLCl19+iZCQEFhZWeHRo0do2LAhIiIiimTZ1tbWOHjwIIKCglCiRAmcPXsWT58+RYMGDTBjxgwAL/vwfPXVVyhXrhxu3ryJS5cuwdHREUOHDkVoaCgAoHPnzqhRowbS0tJw+vRpWFpaokuXLvj99981qsfQ0BBWVlYql9Be161bN2zevBk+Pj54+vQp4uLiYGZmhoCAAPTu3VtqN378eNSpUwc6Ojo4evQoTp8+/Q5bCFi3bh3Gjx8PV1dX3L9/Hzdv3kTdunWl/kZEpEohXr/wTURERPQR45kbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSlf8DeG4960TKXhgAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plot the results\n",
+    "fig, ax = plt.subplots()\n",
+    "barWidth = 0.25\n",
+    "bars1 = [subgroup_repaired_metrics[\"IND\"], subgroup_repaired_metrics[\"SP\"], subgroup_repaired_metrics[\"SF\"], subgroup_repaired_metrics[\"INA\"]]\n",
+    "bars2 = [instantaneous_repaired_metrics[\"IND\"], instantaneous_repaired_metrics[\"SP\"], instantaneous_repaired_metrics[\"SF\"], instantaneous_repaired_metrics[\"INA\"]]\n",
+    "r1 = np.arange(len(bars1))\n",
+    "r2 = [x + barWidth for x in r1]\n",
+    "plt.bar(r1, bars1, color='tab:blue', width=barWidth, label='Subgroup Fairness')\n",
+    "plt.bar(r2, bars2, color='tab:orange', width=barWidth, label='Instantaneous Fairness')\n",
+    "plt.xlabel('Fairness Metric', fontweight='bold')\n",
+    "plt.xticks([r + barWidth for r in range(len(bars1))], ['IND', 'SP', 'SF', 'INA'])\n",
+    "plt.legend()\n",
+    "plt.ylabel('Metric Score')\n",
+    "plt.title('Fairness Metrics for Subgroup and Instantaneous Fairness')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "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.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tests/test_distributional_repair.py b/tests/test_distributional_repair.py
new file mode 100644
index 00000000..fe6f5428
--- /dev/null
+++ b/tests/test_distributional_repair.py
@@ -0,0 +1,14 @@
+from .notebook_runner import notebook_run
+import os
+
+
+def test_distributional_repair():
+    nb, errors = notebook_run(os.path.join(
+            os.path.dirname(os.path.abspath(__file__)),
+            '..', 'examples', 'demo_distributional_repair.ipynb'))
+
+    if len(errors) > 0:
+        for err in errors:
+            for tbi in err['traceback']:
+                print(tbi)
+        raise AssertionError("errors in notebook testcases")
diff --git a/tests/test_lds_fairness.py b/tests/test_lds_fairness.py
new file mode 100644
index 00000000..36825ed1
--- /dev/null
+++ b/tests/test_lds_fairness.py
@@ -0,0 +1,14 @@
+from .notebook_runner import notebook_run
+import os
+
+
+def test_lds_fairness_optimiser():
+    nb, errors = notebook_run(os.path.join(
+            os.path.dirname(os.path.abspath(__file__)),
+            '..', 'examples', 'demo_lds_fairness.ipynb'))
+
+    if len(errors) > 0:
+        for err in errors:
+            for tbi in err['traceback']:
+                print(tbi)
+        raise AssertionError("errors in notebook testcases")