Repository: ochsenfeld-lab/adaptive_sampling (language: python)

Issue:
Merge development with main



Discussion / hints:

Fix patch:
diff --git a/adaptive_sampling/colvars/__init__.py b/adaptive_sampling/colvars/__init__.py
index d1dd66d..61147db 100644
--- a/adaptive_sampling/colvars/__init__.py
+++ b/adaptive_sampling/colvars/__init__.py
@@ -1,7 +1,9 @@
 from .colvars import * 
 from .utils import *
+from .path_cv import *
 
 __all__ = [
     "colvars",
     "utils",
+    "path_cv"
 ]
diff --git a/adaptive_sampling/colvars/colvars.py b/adaptive_sampling/colvars/colvars.py
index f4dcf99..f4b1678 100644
--- a/adaptive_sampling/colvars/colvars.py
+++ b/adaptive_sampling/colvars/colvars.py
@@ -25,6 +25,9 @@ def __init__(self, the_mol: MDInterface, requires_grad: bool = False):
         self.the_mol = the_mol
         self.requires_grad = requires_grad
 
+        if self.requires_grad:
+            torch.autograd.set_detect_anomaly(True)
+
         md_state = self.the_mol.get_sampling_data()
 
         self.mass = torch.from_numpy(md_state.mass).float()
@@ -305,6 +308,78 @@ def distorted_distance(self, cv_def: list, r_0: float = 3.0) -> float:
 
         return float(self.cv)
 
+    def distance_min(self, cv_def: list) -> float:
+        """distorted distance between two mass centers in range(0, inf) mapped to range(1,0)
+
+        Args:
+            cv_def (list):
+                list of distances beteen atoms: [[ind0, ind1], [], ...]
+
+        Returns:
+            distorted distance (float): computed distance
+        """
+        self.update_coords()
+        
+        p1 = self._get_com(cv_def[0])
+        p2 = self._get_com(cv_def[1])
+
+        # get distances
+        dists = []
+        for atoms in cv_def:
+            p1 = self._get_com(atoms[0])
+            p2 = self._get_com(atoms[1])
+            dists.append(torch.linalg.norm(p2 - p1, dtype=torch.float))
+
+        self.cv = min(dists)
+
+        # get forces
+        if self.requires_grad:
+            self.gradient = torch.autograd.grad(
+                self.cv, self.coords, allow_unused=True
+            )[0]
+            self.gradient = self.gradient.detach().numpy()
+
+        return float(self.cv)
+    
+    def electrostatic_potential(
+        self, 
+        cv_def: list,
+    ):
+        """Electrostatic potential on spezific Atom. Environmental CV to treat reorganization of polar solvent or protein sites  
+        needs a file called `charges.npy` that contains the charges of all atoms in cv_def
+ 
+        Args:
+            cv_def: list with involved atoms, the first element defines the atom where the potential is calculated
+
+        Returns:
+            cv: electroststic potential in a.u.
+        """
+        try:
+            charges = np.load("charges.npy")
+        except:
+            raise ValueError("CV ERROR: Could not find charges for electrostatic potential in charges.npy")
+
+        if len(cv_def) != len(charges)+1:
+            raise ValueError(
+                "CV ERROR: Number of charges for electrostatic potential has to match number of Atoms!"
+            )
+        self.update_coords()
+
+        A = self._get_com(cv_def[0])
+        self.cv = 0
+        for i, atom in enumerate(cv_def[1:]):
+            if atom != cv_def[0]:
+                B = self._get_com(atom)
+                self.cv += charges[i] / torch.linalg.norm(B-A, dtype=torch.float)
+
+        if self.requires_grad:
+            self.gradient = torch.autograd.grad(
+                self.cv, self.coords, allow_unused=True
+            )[0]
+            self.gradient = self.gradient.detach().numpy()
+        
+        return float(self.cv)
+
     def rmsd(
         self,
         cv_def: Union[str, list],
@@ -346,6 +421,44 @@ def rmsd(
 
         return float(self.cv)
 
+    def path(self, cv_dev: list, method: str="gpath") -> float:
+        """Adaptive path collective variable
+
+        Args:
+            cv_def: dictionary of parameters for PathCV
+        """
+        if not hasattr(self, 'pathcv'):
+            from .path_cv import PathCV
+            self.pathcv = PathCV(**cv_dev)
+        
+        self.update_coords()
+
+        if method == 'gpath':
+            self.cv = self.pathcv.calculate_gpath(self.coords)
+        else:
+            self.cv = self.pathcv.calculate_path(self.coords, distance=False)
+
+        if self.requires_grad:
+            self.gradient = torch.autograd.grad(
+                self.cv, self.coords, allow_unused=True
+            )[0]
+            self.gradient = self.gradient.detach().numpy()
+        return float(self.cv)
+
+    def path_z(self, pathcv: object) -> float:
+        """Get z component of path cv (distance to path)
+        only available if `self.path` was called first to calculate PathCV
+
+        Args:
+            pathcv: PathCV object that contains path_z 
+        """
+        if not hasattr(pathcv, "path_z"):
+            raise ValueError(" >>> ERROR: `pathcv` has to `require_z`!")
+        
+        self.cv = pathcv.path_z
+        self.gradient = pathcv.grad_z
+        return float(self.cv)
+
     def get_cv(self, cv: str, atoms: list, **kwargs) -> Tuple[float, np.ndarray]:
         """get state of collective variable from cv definition of sampling_tools
 
@@ -372,9 +485,20 @@ def get_cv(self, cv: str, atoms: list, **kwargs) -> Tuple[float, np.ndarray]:
         elif cv.lower() == "torsion":
             xi = self.torsion(atoms)
             self.type = "angle"
+        elif cv.lower() == "minimum_distance":
+            xi = self.distance_min(atoms)
+            self.type = "distance"
         elif cv.lower() == "lin_comb_dists":
             xi = self.linear_combination(atoms)
             self.type = "distance"
+        elif cv.lower() == "lin_comb_dists_min":
+            xi0 = atoms[0] * self.distance(atoms[1])
+            forces0 = atoms[0] * np.copy(self.gradient)
+            xi = xi0 + atoms[2] * self.distance_min(atoms[3])
+            self.cv = float(xi)
+            forces1 = atoms[2] * np.copy(self.gradient)
+            self.gradient = forces0 + forces1
+            self.type = "distance"
         elif cv.lower() == "lin_comb_angles":
             xi = self.linear_combination(atoms)
             self.type = "angle"
@@ -387,8 +511,17 @@ def get_cv(self, cv: str, atoms: list, **kwargs) -> Tuple[float, np.ndarray]:
         elif cv.lower() == "rmsd":
             xi = self.rmsd(atoms)
             self.type = "distance"
+        elif cv.lower() == "path":
+            xi = self.path(atoms, method="path")
+            self.type = None
+        elif cv.lower() == "gpath":
+            xi = self.path(atoms, method="gpath")
+            self.type = None
+        elif cv.lower() == "path_z":
+            xi = self.path_z(atoms)
+            self.type = None
         else:
-            print(" >>> Error in CV: Unknown coordinate")
+            print(" >>> Error in CV: Unknown Collective Variable")
             sys.exit(1)
 
         if self.requires_grad:
diff --git a/adaptive_sampling/colvars/path_cv.py b/adaptive_sampling/colvars/path_cv.py
new file mode 100644
index 0000000..22a8f72
--- /dev/null
+++ b/adaptive_sampling/colvars/path_cv.py
@@ -0,0 +1,557 @@
+import math
+import torch
+
+from .utils import *
+
+class PathCV:
+    """Adaptive Path Collective Variables
+
+    Args:
+        guess_path: filename of `.xyz` or `.npy` with initial path 
+        active: list of atom indices included in PathCV
+            if `coordinate_system=cv_space`, has to contain list of list of indices for distances, angles and torsions that define CV space 
+        n_interpolate: Number of nodes that are added between original nodes by linear interpolation,
+            if negative, slice path nodes according to `self.path[::abs(n_interpolate)]`
+        smooth_damping: Controls smoothing of path (0: no smoothing, 1: linear interpolation between neighbours)
+        reparam_steps: Maximum number of cycles for reparamerization of path to ensure equidistant nodes
+        reparam_tol: Tolerance for reparametrization of path to ensure equidistant nodes
+        coordinate_system: coordinate system for calculation of Path CV
+            available: `cartesian`, `zmatrix` or `cv_space`
+        metric: Metric for calculation of distance of points
+            `RMSD`: Root mean square deviation
+            `MSD`: Mean square deviation
+            `Kabsch`: Root mean square deviation of optimally fitted coords
+            `KMSD`: Mean square deviation of optimally fitted coords
+            `distance`: Absolute distance 
+        adaptive: if adaptive, path converges to average CV density perpendicular to path
+        update_interval: number of steps between updates of adaptive path
+        half_life: number of steps til weight of original path is half due to updates
+        requires_z: if distance to path should be calculated and stored for confinement to path
+        ndim: number of dimensions (2 for 2D test potentials, 3 else)
+        verbose: if verbose information should be printed
+    """
+    def __init__(
+        self, 
+        guess_path: str=None, 
+        active: list=None, 
+        n_interpolate: int=0,
+        smooth_damping: float=0.0,
+        reparam_steps: int=1,
+        reparam_tol: float=0.01,
+        coordinate_system: str="Cartesian",
+        metric: str="RMSD",
+        adaptive: bool=False,
+        update_interval: int=100,
+        half_life: float=-1, 
+        requires_z: bool=False,
+        ndim: int=3,
+        verbose: bool=False,
+    ):  
+        if guess_path == None:
+            raise ValueError(" >>> ERROR: You have to provide a guess path to the PathCV")
+        self.guess_path = guess_path
+        self.active = active 
+        self.smooth_damping = smooth_damping
+        self.reparam_steps = reparam_steps
+        self.reparam_tol = reparam_tol
+        self.coordinates = coordinate_system
+        self.metric = metric
+        self.adaptive = adaptive
+        self.update_interval = update_interval
+        self.half_life = half_life
+        self.requires_z = requires_z
+        self.ndim = ndim
+        self.verbose = verbose
+       
+        # initialize path
+        self.path, self.nnodes = read_path(
+            self.guess_path, 
+            ndim=self.ndim,
+        )
+
+        # if `.xyz` is given convert coordinate system 
+        if self.guess_path[-3:] == 'xyz':
+            self._reduce_path()
+
+        self._interpolate(n_interpolate)
+        self._reparametrize_path(tol=self.reparam_tol, max_step=self.reparam_steps)
+        self.boundary_nodes = self._get_boundary(self.path)
+
+        # accumulators for path update
+        if self.adaptive:
+            self.n_updates = 0 
+            self.weights = torch.zeros(self.nnodes)    
+            self.avg_dists = [torch.zeros_like(self.path[0]) for _ in range(self.nnodes)]
+            if half_life < 0:
+                self.fade_factor = 1.0
+            else:
+                self.fade_factor = math.exp(-math.log(2.) / float(self.half_life))
+
+        if self.verbose:
+            print(f" >>> INFO: Initialization of PathCV with {self.nnodes} nodes finished.")
+
+    def calculate_path(self, coords: torch.tensor) -> torch.tensor:
+        """calculate PathCV according to
+        Branduardi, et al., J. Chem. Phys. (2007): https://doi.org/10.1063/1.2432340
+
+        Args:
+            coords: cartesian coordinates 
+
+        Returns:
+            path_cv: progress anlong path in range [0,1]
+        """
+        z = convert_coordinate_system(
+            coords, self.active, coord_system=self.coordinates, ndim=self.ndim
+        )
+        rmsds = self._get_distance_to_path(z)
+        
+        la = (
+            1. / torch.square(
+                self.get_distance(self.path[1], self.path[0], metric=self.metric)
+            )
+        ).type(torch.float64)
+        
+        term1 = 0.0
+        term2 = 0.0
+        for i, rmsd in enumerate(rmsds):
+            exp = torch.exp(-la * torch.square(rmsd))
+            term1 += float(i) * exp
+            term2 += exp
+
+        # avoids numerical inconsistency by never reaching absolute zero
+        if abs(term2) < 1.e-15:
+            term2 += 1.e-15
+
+        # position on path in range [0,1]
+        self.path_cv = (1. / (self.nnodes-1)) * (term1 / term2)
+        
+        # distance from path
+        if self.requires_z:
+            self.path_z = -1. / la * torch.log(term2)
+            self.grad_z = torch.autograd.grad(
+                self.path_z, coords, allow_unused=True, retain_graph=True,
+            )[0]
+            self.grad_z = self.grad_z.detach().numpy()
+
+        if self.adaptive:
+            _, coords_nearest = self._get_closest_nodes(z, rmsds)
+            self.update_path(z, coords_nearest)
+
+        return self.path_cv
+
+    def calculate_gpath(self, coords: torch.tensor) -> torch.tensor:
+        """Calculate geometric PathCV according to
+        Leines et al., Phys. Ref. Lett. (2012): https://doi.org/10.1103/PhysRevLett.109.020601
+        
+        Args:
+            coords: cartesian coordinates
+
+        Returns:
+            path_cv: progress anlong path in range [0,1]
+        """
+        z = convert_coordinate_system(
+            coords, self.active, coord_system=self.coordinates, ndim=self.ndim
+        )
+        dists = self._get_distance_to_path(z)
+        idx_nodemin, coords_nodemin = self._get_closest_nodes(z, dists)
+
+        # add boundary nodes to `self.path`
+        self.path.insert(0, self.boundary_nodes[0])
+        self.path.append(self.boundary_nodes[1])
+        idx_nodemin = [i+1 for i in idx_nodemin]
+
+        isign = 1 if idx_nodemin[0] - idx_nodemin[1] > 0 else -1
+
+        idx_nodemin[1] = idx_nodemin[0] - isign
+        idx_nodemin.append(idx_nodemin[0] + isign)
+        
+        # compute some vectors
+        v1 = self.path[idx_nodemin[0]] - z
+        v3 = z - self.path[idx_nodemin[1]] 
+        if idx_nodemin[2] < 0 or idx_nodemin[2] >= self.nnodes+1:
+            v2 = self.path[idx_nodemin[0]] - self.path[idx_nodemin[1]]
+        else:
+            v2 = self.path[idx_nodemin[2]] - self.path[idx_nodemin[0]]
+
+        # get `s` component of PathCV (progress along path)
+        v1 = v1.view(torch.numel(v1))
+        v2 = v2.view(torch.numel(v2))
+        v3 = v3.view(torch.numel(v3))
+
+        v1v1 = torch.matmul(v1, v1)
+        v1v2 = torch.matmul(v1, v2)
+        v2v2 = torch.matmul(v2, v2) 
+        v3v3 = torch.matmul(v3, v3)
+
+        root = torch.sqrt(torch.square(v1v2) - v2v2 * (v1v1 - v3v3))
+        dx = 0.5 * ((root - v1v2) / v2v2 - 1.)
+        self.path_cv = ((idx_nodemin[0]-1) + isign * dx) / (self.nnodes-1)
+
+        if self.requires_z or self.adaptive:
+            v = z - self.path[idx_nodemin[0]] - dx * (self.path[idx_nodemin[0]] - idx_nodemin[1])
+
+        # remove boundary nodes from `self.path`
+        del self.path[0]
+        del self.path[-1]
+
+        # get perpendicular `z` component (distance to path)
+        if self.requires_z: 
+            self.path_z = torch.linalg.norm(v)
+            self.grad_z = torch.autograd.grad(
+                self.path_z, coords, allow_unused=True, retain_graph=True,
+            )[0]
+            self.grad_z = self.grad_z.detach().numpy()
+
+        # accumulate average distance from path for path update
+        if self.adaptive:
+
+            w2 = -1. * dx
+            w1 = 1. + dx
+            if w1 > 1:
+                w1, w2 = 1.0, 0.0 
+            elif w2 > 1:
+                w1, w2 = 0.0, 1.0
+            
+            if idx_nodemin[0] > 0 and idx_nodemin[0] <= self.nnodes:
+                self.avg_dists[idx_nodemin[0]-1] = w1 * v
+                self.weights[idx_nodemin[0]-1] *= self.fade_factor
+                self.weights[idx_nodemin[0]-1] += w1
+            
+            if idx_nodemin[1] > 0 and idx_nodemin[1] <= self.nnodes:
+                self.avg_dists[idx_nodemin[1]-1] = w2 * v
+                self.weights[idx_nodemin[1]-1] *= self.fade_factor
+                self.weights[idx_nodemin[1]-1] += w2
+            
+            self.update_path(z, coords_nodemin, gpath=True)
+        
+        return self.path_cv
+
+    def update_path(self, z: torch.tensor, q: list, gpath=False):
+        """Update path nodes to ensure smooth convergence to the MFEP
+        
+        see: Ortiz et al., J. Chem. Phys. (2018): https://doi.org/10.1063/1.5027392
+
+        Args:
+            z: reduced coords 
+            q: coords of two neighbour nodes of z
+        """
+        if not gpath:
+            s = self._project_coords_on_line(z, q)
+            dist_ij = self.get_distance(self.path[0], self.path[1], metric=self.metric)
+            for j, _ in enumerate(self.path[1:-1], start=1):
+                w = max([0, 1 - self.get_distance(self.path[j], s, metric=self.metric) / dist_ij])
+                self.weights[j] += self.fade_factor * w
+                self.avg_dists[j] += w * (z-s)
+                
+        # update path all `self.update_interval` steps
+        self.n_updates += 1
+        if self.n_updates == self.update_interval:
+            new_path = self.path.copy()
+            for j in range(self.nnodes-2):
+                if self.weights[j+1] > 0:
+                    new_path[j+1] += (self.avg_dists[j+1] / self.weights[j+1])
+                    new_path[j+1] = new_path[j+1].detach()
+
+            self.path = new_path.copy()
+            self._reparametrize_path(tol=self.reparam_tol, max_step=self.reparam_steps)
+
+            # reset accumulators
+            self.n_updates = 0 
+            self.weights = torch.zeros_like(self.weights)
+            self.avg_dists = [torch.zeros_like(self.avg_dists[0]) for _ in range(self.nnodes)]
+
+    def _reparametrize_path(
+        self, 
+        tol: float=0.01, 
+        max_step: int=10,
+        smooth: bool=True,
+    ):
+        """Reparametrization of path to ensure equidistant nodes
+        see: Maragliano et al., J. Chem. Phys. (2006): https://doi.org/10.1063/1.2212942
+        
+        Args:
+            tol: tolerance for convergence, difference of absolute path length to previous cycle
+            max_step: maximum number of iterations
+            smooth: if path should be smoothed to remove kinks
+        """ 
+        # TODO: When smoothing only once there might be too many kinks in the path in some cases?
+        if smooth:
+            self.path = self._smooth_string(self.path, s=self.smooth_damping)
+
+        # get length of path
+        L, sumlen = [0], [0]
+        for i, coords in enumerate(self.path[1:], start=1):
+            L.append(torch.linalg.norm(coords - self.path[i-1]))
+            sumlen.append(sumlen[-1] + L[-1])
+
+        prevsum, iter = 0, 0
+        while abs(sumlen[-1]-prevsum) > tol and iter <= max_step:
+            prevsum = sumlen[-1]
+
+            # cumulative target distance between nodes
+            sfrac = []
+            for i in range(self.nnodes):
+                sfrac.append(i * sumlen[-1] / float(self.nnodes-1))
+
+            # TODO: Smoothing in every cycle might introduce too much corner cutting?
+            #if smooth:
+            #    self.path = self._smooth_string(self.path, s=self.smooth_damping)
+
+            # update node positions
+            path_new = [self.path[0]]
+            for i, _ in enumerate(self.path[1:-1], start=1):
+                k = 0
+                while not ((sumlen[k] < sfrac[i]) and (sumlen[k+1] >= sfrac[i])):
+                    k += 1
+                    if i >= self.nnodes:
+                        raise ValueError(" >>> ERROR: Reparametrization of path failed!")
+                dr = sfrac[i] - sumlen[k] 
+                vec = self.path[k+1] - self.path[k]
+                vec /= torch.linalg.norm(vec)
+                path_new.append(self.path[k] + dr * vec)
+            path_new.append(self.path[-1])
+            self.path = path_new.copy()
+
+            # get new length of path
+            L, sumlen = [0], [0]
+            for i, coords in enumerate(self.path[1:], start=1):
+                L.append(torch.linalg.norm(coords - self.path[i-1]))
+                sumlen.append(sumlen[-1] + L[-1])
+            iter += 1
+
+        self.boundary_nodes = self._get_boundary(self.path)
+        
+        if self.verbose:
+            crit = abs(sumlen[-1]-prevsum)
+            if crit < tol:
+                print(f" >>> INFO: Reparametrization of Path converged in {iter} steps. Final convergence: {crit:.6f}.")
+            else:
+                print(f" >>> WARNING: Reparametrization of Path not converged in {max_step} steps. Final convergence: {crit:.6f}.")        
+
+    @staticmethod
+    def _smooth_string(path: list, s: float=0.0) -> list:
+        """Smooth string of nodes 
+
+        Args:
+            path: path of nodes to be smoothed
+            s: damping factor in range(0,1)
+        
+        Returns:
+            path_new: smoothed path
+        """
+        path_new = [path[0]]
+        for i, coords in enumerate(path[1:-1], start=1):
+            path_new.append((1-s) * coords)
+            path_new[-1] += s / 2. * (path[i-1] + path[i+1])
+        path_new.append(path[-1])
+        return path_new
+
+    @staticmethod
+    def _get_boundary(path: list) -> list:
+        """compute one final lower and upper node by linear interpolation of path
+        
+        Args:
+            path: list of path nodes
+        
+        Returns:
+            boundaries: list with lower and upper boundary node
+        """
+        delta_lower = path[1] - path[0]
+        lower_bound = path[0] - delta_lower
+        delta_upper = path[-2] - path[-1]
+        upper_bound = path[-1] - delta_upper
+        return [lower_bound, upper_bound]
+
+    def _get_distance_to_path(self, z: torch.tensor) -> list:
+        """Calculates distance according to chosen metric
+
+        Args:
+            z: reduced coords 
+
+        Return:
+            rmsds: list of distances of z to every node of path
+        """
+        d = []
+        for i in range(self.nnodes):
+            d.append(self.get_distance(z, self.path[i], metric=self.metric))
+            self.path[i] = self.path[i].detach()  # for performance reasons
+        return d
+
+    @staticmethod
+    def get_distance(
+        coords: torch.tensor, 
+        reference: torch.tensor,
+        metric: str="RMSD"    
+    ) -> torch.tensor:
+        """Get distance between coordinates and reference calculated by `metric`
+        
+        Available metrics are: 
+            `RMSD`: Root mean square deviation
+            `MSD`: Mean square deviation
+            `kabsch`: Root mean square deviation of optimally fitted coords
+            `KMSD`: Mean square deviation of optimally fitted coords
+            `distance`: Absolute distance 
+
+        Args:
+            coords: coordinates 
+            reference: coordinates of reference
+            metric: distance metric
+
+        Returns:
+            d: distance between coords and reference in `self.metric`
+        """
+        if metric.lower() == "rmsd":
+            d = get_rmsd(coords, reference)
+        
+        elif metric.lower() == "msd":
+            d = get_msd(coords, reference)
+
+        elif metric.lower() == "kmsd":
+            coords_fitted, reference_fitted = kabsch_rmsd(
+                coords, 
+                reference, 
+                return_coords=True
+            )
+            d = get_msd(coords_fitted, reference_fitted)
+        
+        elif metric.lower() == "kabsch":
+            d = kabsch_rmsd(coords, reference)
+        
+        elif metric.lower() == "distance":
+            d = torch.linalg.norm(coords - reference)
+        
+        else:
+            raise NotImplementedError(
+                " >>> INFO: Available distance metrics in PathCV: `RMSD`, `MSD`, `kabsch`, `KMSD`, `distance`"
+            )
+
+        return d.type(torch.float64)
+
+    def _project_coords_on_line(self, z: torch.tensor, q: list) -> torch.tensor:
+        """Projection of coords on line
+
+        Args:
+            z: reduced coords 
+            q: coords of two nodes that span line on which to project
+
+        Returns:
+            s: projection of coords on path 
+        """    
+        shape_z = z.shape        # for reshaping results
+        ncoords = torch.numel(z) # to flatten inputs
+
+        z = z.view(ncoords)
+        q0 = q[0].view(ncoords)
+        q1 = q[1].view(ncoords)
+        ap = z - q0
+        ab = q1 - q0
+
+        return (q0 + torch.matmul(ap,ab) / torch.matmul(ab,ab) * ab).view(shape_z)
+
+    def _get_closest_nodes(self, z: torch.tensor, dists: list) -> tuple:
+        """get two closest nodes of path
+
+        Args:
+            z: reduced coordinates
+            rmsds: list of rmsds of z to path nodes
+
+        Returns:
+            closest_index: list with indices of two closest nodes to z  
+            closest_coords: list with coordinates of two closest nodes to z
+        """
+        dists.insert(0, self.get_distance(z, self.boundary_nodes[0], metric=self.metric))
+        dists.append(self.get_distance(z, self.boundary_nodes[1], metric=self.metric))
+        
+        distmin1, idxmin1 = 99999, 0
+        distmin2, idxmin2 = 99999, 1
+        for i, dist in enumerate(dists):
+            if dist < distmin1:
+                distmin2 = distmin1
+                idxmin2 = idxmin1
+                distmin1 = dist
+                idxmin1 = i
+            elif (dist < distmin2):
+                distmin2 = dist
+                idxmin2 = i
+
+        self.path.insert(0, self.boundary_nodes[0])
+        self.path.append(self.boundary_nodes[1])
+        closest_coords = [self.path[idxmin1], self.path[idxmin2]]
+        del self.path[0]
+        del self.path[-1]
+
+        if self.verbose:
+            # if path gets highly irregualar this can fail, so print warning
+            if abs(idxmin1 - idxmin2) != 1:
+                print(
+                    f" >>> WARNING: Two closest nodes of PathCV ({idxmin1-1,idxmin2-1}) are not neighbours!"
+                ) 
+        
+        return [idxmin1-1, idxmin2-1], closest_coords
+
+    def _interpolate(self, n_interpolate):
+        """Add nodes by linear interpolation or remove nodes by slicing
+        
+        Args:
+            n_interpolate: Number of interpolated nodes between two original nodes
+        """
+        if n_interpolate > 0:
+            # fill path with n_interplate nodes per pair
+            path_new = []
+            for i in range(self.nnodes - 1):
+                a = self.path[i]
+                b = self.path[i + 1]
+                r = b - a
+                d = torch.linalg.norm(r)
+                unit_vec = r / d
+                step = d / (n_interpolate+1)
+
+                path_new.append(a)
+                for j in range(1, n_interpolate+1):
+                    # linear interpolation
+                    p = a + unit_vec * j * step
+                    path_new.append(p)
+
+            path_new.append(b)
+            self.path = path_new.copy() 
+
+        elif n_interpolate < 0:
+            # slice path to keep only every n_interpolate node 
+            self.path = self.path[::abs(n_interpolate)]
+        
+        self.nnodes = len(self.path)
+
+    def _reduce_path(self):
+        """reduce path nodes to only active coordinates
+        """
+        path_reduced = []
+        for c in self.path:
+            path_reduced.append(
+                convert_coordinate_system(c, self.active, coord_system=self.coordinates, ndim=self.ndim)
+            )
+        self.path = path_reduced.copy()
+        if self.verbose:
+            print(f" >>> INFO: Reduced coordinate system to {torch.numel(self.path[0])} {self.coordinates} coordinates.")
+
+    def write_path(self, filename: str="path_cv.npy"):
+        """write nodes of PathCV to dcd trajectory file
+
+        Args:
+            filename
+        """
+        if filename[-3:] == "npy":
+            import numpy as np
+            path_tmp = []
+            for coords in self.path:
+                path_tmp.append(coords.detach().numpy())
+            np.save(filename, path_tmp, allow_pickle=True)
+        else:
+            import mdtraj
+            from ..units import BOHR_to_ANGSTROM
+
+            dcd = mdtraj.formats.DCDTrajectoryFile(filename, 'w', force_overwrite=True)
+            for coords in self.path:
+                dcd.write(BOHR_to_ANGSTROM * coords.view(int(torch.numel(coords)/3),3).detach().numpy())
+            dcd.close()
+
+
diff --git a/adaptive_sampling/colvars/utils.py b/adaptive_sampling/colvars/utils.py
index 297b599..41cf057 100644
--- a/adaptive_sampling/colvars/utils.py
+++ b/adaptive_sampling/colvars/utils.py
@@ -1,12 +1,12 @@
 import os
 import itertools
 import torch
-from scipy.spatial import KDTree
-
 from adaptive_sampling.units import BOHR_to_ANGSTROM
 
 
-def read_xyz(xyz_name: str) -> torch.tensor:
+def read_xyz(
+    xyz_name: str
+) -> torch.tensor:
     """Read cartesian coordinates from file (*.xyz)
 
     Args:
@@ -30,17 +30,84 @@ def read_xyz(xyz_name: str) -> torch.tensor:
     mol = torch.FloatTensor(list(mol)) / BOHR_to_ANGSTROM
     return mol
 
+def read_path(
+    filename: str, 
+    ndim: int,
+) -> tuple:
+    """Read coordinates of path nodes from file (*.xyz, *.npy)
+        
+    Args:
+        filename 
+        
+    Returns:
+        traj: list of torch arrays containing coordinates of nodes
+        nnodes: number of nodes in path
+    """
+    if filename[-3:] == "dcd":
+        # TODO: Read path from dcd file
+        raise NotImplementedError(" >>> ERROR: Reading path from dcd not yet implemented. Use instead: `.xzy` or `.npy`")
+
+    elif filename[-3:] == "npy":
+        import numpy
+        traj = numpy.load(filename)
+        traj = traj.tolist()
+        traj = [torch.from_numpy(t) for t in traj]
+
+    elif filename[-3:] == "xyz":
+        with open(filename, "r") as xyzf:
+            traj = []
+            mol = []
+            n = 0
+            for i, line in enumerate(xyzf):
+                words = line.strip().split()
+                if i == 0:
+                    n_atoms = int(words[0])
+                elif n == n_atoms:
+                    n = 0
+                    mol = itertools.chain(*mol)
+                    mol = torch.FloatTensor(list(mol))
+                    traj.append(mol)
+                    mol = []
+                elif len(words) >= 4:
+                    if ndim == 2:
+                        mol.append([float(words[1]), float(words[2])])
+                    else:
+                        mol.append([
+                            float(words[1]) / BOHR_to_ANGSTROM, 
+                            float(words[2]) / BOHR_to_ANGSTROM, 
+                            float(words[3]) / BOHR_to_ANGSTROM,
+                        ])
+                    n += 1
+
+        if mol:
+            mol = itertools.chain(*mol)
+            mol = torch.FloatTensor(list(mol))
+            traj.append(mol)
+    
+    else:
+        raise ValueError(" >>> ERROR: Unnown format of path. Available: `.xzy`, `.npy`, `.dcd`.")
 
-def rmsd(V, W):
+    return traj, len(traj)
+
+
+def get_rmsd(V: torch.tensor, W: torch.tensor):
     """root-mean-square deviation"""
     diff = V - W
     return torch.sqrt(torch.sum(diff * diff) / len(V))
 
 
+def get_msd(V: torch.tensor, W: torch.tensor):
+    """mean-square deviation"""
+    diff = V - W
+    return torch.sum(diff * diff) / len(V)
+
+
 def kabsch_rmsd(
     coords1: torch.tensor,
     coords2: torch.tensor,
     indices: bool = None,
+    return_coords: bool=False,
+    ndim: int=3,
 ) -> torch.tensor:
     """minimize rmsd between cartesian coordinates by kabsch algorithm
 
@@ -48,13 +115,12 @@ def kabsch_rmsd(
         coords1: (3*n_atoms,) tensor of cartesian coordinates
         coords2: (3*n_atoms,) tensor of cartesian coordinates
         indices: indices of atoms that are included
-
+        return_coords: if only transformed coords should be returned
     Returns:
-        coords1: (3*n_atoms,) coordinates fitted to coords2
+        rmsd: root-mean-squared deviation after fit
     """
-    n = len(coords1)
-    coords1 = torch.reshape(coords1, (int(n / 3), 3)).float()
-    coords2 = torch.reshape(coords2, (int(n / 3), 3)).float()
+    coords1 = coords1.view(int(torch.numel(coords1) / ndim), ndim).float()
+    coords2 = coords2.view(int(torch.numel(coords2) / ndim), ndim).float()
 
     if indices != None:
         coords1 = coords1[indices]
@@ -66,10 +132,15 @@ def kabsch_rmsd(
 
     # optimal rotation of coords1 to fit coords2
     coords1_new = kabsch_rot(coords1_new, coords2_new)
-    return rmsd(coords1_new, coords2_new)
+
+    if return_coords:
+        return coords1_new, coords2_new
+    return get_rmsd(coords1_new, coords2_new)
 
 
-def centroid(X: torch.tensor) -> torch.tensor:
+def centroid(
+    X: torch.tensor,
+) -> torch.tensor:
     """Centroid is the mean position of all the points in all of the coordinate
     directions, from a vectorset X.
 
@@ -83,7 +154,10 @@ def centroid(X: torch.tensor) -> torch.tensor:
     return C
 
 
-def kabsch_rot(coords1: torch.tensor, coords2: torch.tensor) -> torch.tensor:
+def kabsch_rot(
+    coords1: torch.tensor, 
+    coords2: torch.tensor,
+) -> torch.tensor:
     """Rotate coords1 on coords2
 
     Args:
@@ -151,11 +225,13 @@ def quaternion_rmsd(
     coords1_new = torch.matmul(coords1_new, rot)
 
     if return_coords:
-        return rmsd(coords1_new, coords2_new), coords1_new
-    return rmsd(coords1_new, coords2_new)
+        return get_rmsd(coords1_new, coords2_new), coords1_new
+    return get_rmsd(coords1_new, coords2_new)
 
 
-def _quaternion_transform(r: torch.tensor) -> torch.tensor:
+def _quaternion_transform(
+    r: torch.tensor,
+) -> torch.tensor:
     """Get optimal rotation"""
     Wt_r = _makeW(*r).T
     Q_r = _makeQ(*r)
@@ -189,7 +265,10 @@ def _makeQ(r1, r2, r3, r4=0):
     return Q
 
 
-def quaternion_rotate(X: torch.tensor, Y: torch.tensor) -> torch.tensor:
+def quaternion_rotate(
+    X: torch.tensor, 
+    Y: torch.tensor,
+) -> torch.tensor:
     """
     Calculate the rotation
 
@@ -209,3 +288,165 @@ def quaternion_rotate(X: torch.tensor, Y: torch.tensor) -> torch.tensor:
     r = eigen[1][:, eigen[0].argmax()]
     rot = _quaternion_transform(r)
     return rot
+
+
+def get_amber_charges(prmtop: str) -> list:
+    """Parse charges from AMBER parameter file 
+
+    Args:
+        prmtop (string): filename
+
+    Returns:
+        charges (list): atom charges in a.u.
+    """
+    with open(prmtop, "r") as f:
+        prm = f.readlines()
+        for i, line in enumerate(prm):
+            if line.find("CHARGE") != -1:
+                q_str = prm[i+2]
+                j = 3
+                while len(prm) > j:
+                    if prm[i+j].find("FLAG") != -1:
+                        break
+                    else:
+                        q_str += prm[i+j]
+                        j += 1
+                break
+
+    charge = []
+    for q in q_str.split(" "):
+        if q:
+            charge.append(float(q) / 18.2223)  # converted to a.u. with factor sqrt(electrostatic constant)
+
+    return charge
+
+
+def get_internal_coordinate(
+    cv: list, 
+    coords: torch.tensor, 
+    ndim: int=3,
+) -> torch.tensor:
+    """Get internal coordinate (distance, angle or torsion)
+
+    Args:
+        cv: inidices of atoms that are included in cv
+        coords: cartesian coords
+        ndim: umber of dimensions of coords
+    
+    Returns:
+        cv: internal coordinate
+    """
+    z = coords.view(int(torch.numel(coords)/ndim), ndim)
+
+    # dist
+    if len(cv) == 2:
+        xi = torch.linalg.norm(z[cv[0]] - z[cv[1]])
+
+    # angle
+    elif len(cv) == 3:
+        q12 = z[cv[0]] - z[cv[1]]
+        q23 = z[cv[1]] - z[cv[2]]
+
+        q12_n = torch.linalg.norm(q12)
+        q23_n = torch.linalg.norm(q23)
+                
+        q12_u = q12 / q12_n
+        q23_u = q23 / q23_n
+
+        xi = torch.arccos(torch.dot(-q12_u, q23_u))  
+                
+    # torsion
+    elif len(cv) == 4:
+        q12 = z[cv[1]] - z[cv[0]]
+        q23 = z[cv[2]] - z[cv[1]]
+        q34 = z[cv[3]] - z[cv[2]]
+
+        q23_u = q23 / torch.linalg.norm(q23)
+
+        n1 = -q12 - torch.dot(-q12, q23_u) * q23_u
+        n2 = q34 - torch.dot(q34, q23_u) * q23_u
+
+        xi = torch.atan2(
+            torch.dot(torch.cross(q23_u, n1), n2), torch.dot(n1, n2)
+        ) 
+    else:
+        raise ValueError(" >>> ERROR: wrong definition of internal coordinate!")
+        
+    return xi
+
+
+def cartesians_to_internals(
+    coords: torch.tensor, 
+    ndim: int=3,
+) -> torch.tensor:
+    """Converts reduced cartesian coordinates to Z-Matrix
+
+    Args:  
+        coords: reduced cartesian coordinates
+        ndim: Number of dimensions of input coordinates
+        
+    Returns:
+        zmatrix: Z-Matrix with angles given in radians
+    """
+        
+    z = coords.view(int(torch.numel(coords)/ndim), ndim)
+    zmatrix = torch.zeros_like(z)
+            
+    for i, _ in enumerate(z[1:], start=1):
+        # distance
+        zmatrix[i, 0] = get_internal_coordinate(
+            [i-1, i], coords, ndim=ndim
+        )  
+
+        # angle
+        if i > 1:
+            zmatrix[i, 1] = get_internal_coordinate(
+                [i-2, i-1, i], coords, ndim=ndim
+            ) 
+                
+        # torsion
+        if i > 2:
+            zmatrix[i, 2] = get_internal_coordinate(
+                [i-3, i-2, i-1, i], coords, ndim=ndim
+            )
+    
+    return zmatrix
+
+
+def convert_coordinate_system(
+    coords: torch.tensor,
+    active: list=None,
+    coord_system: str="Cartesian", 
+    ndim: int=3,
+) -> torch.tensor:
+    """Convert XYZ tensor to selected coordinate system
+
+    Args:
+        coords: xyz coordinates 
+        active: list of active atoms or list of internal coordinates
+        coord_system: Selected new coordinate system:
+            `Cartesian`: xyz coordinates reduced to `active` atoms
+            `ZMatric`: Z-Matrix of `active` atoms
+            `CV_space`: Selected internal coordinates (distances, angles and torsions)
+        ndim: Number of dimensions of input coordinates
+
+    Returns:
+        new_coords: Converted coords 
+    """
+    if coord_system.lower() == "cartesian":
+        z = coords.view(int(torch.numel(coords)/ndim), ndim)
+        if active != None:
+            z = z[active]
+        return z
+
+    elif coord_system.lower() == "zmatrix":
+        z = coords.view(int(torch.numel(coords)/ndim), ndim)
+        if active != None:
+            z = z[active]
+        return cartesians_to_internals(z, ndim=ndim)
+
+    elif coord_system.lower() == "cv_space":
+        cvs = torch.zeros(len(active))
+        for i, cv in enumerate(active):
+            cvs[i] = get_internal_coordinate(cv, coords, ndim=ndim)
+        return cvs
diff --git a/adaptive_sampling/processing_tools/mbar.py b/adaptive_sampling/processing_tools/mbar.py
index fd904bb..d644252 100644
--- a/adaptive_sampling/processing_tools/mbar.py
+++ b/adaptive_sampling/processing_tools/mbar.py
@@ -122,6 +122,7 @@ def build_boltzmann(
         traj_list: list of trajectories
         meta_f: definition of simulation with force constants and cv grid
         dU_list: optional, additional potential that enters boltzmann factor (GaMD, confinement, reweighting, ...)
+        equil_temp: equilibrium temperature of the simulation
     
     Returns:
         exp_U: num_trajs**num_frames array of Boltzmann factors
@@ -202,18 +203,19 @@ def get_windows(
 
 
 def pmf_from_weights(
-    grid: np.array, cv: np.array, weights: np.array, equil_temp: float = 300.0
-) -> Tuple[np.array, np.array]:
-    """make free energy surface from statistical weigths obtained by MBAR
+    grid: np.ndarray, cv: np.ndarray, weights: np.ndarray, equil_temp: float = 300.0
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Get 1D Potential of Mean Force (PMF) from statistical weigths obtained by MBAR
 
     Args:
-        grid: grid along cv
+        grid: centroids of grid along cv
         cv: trajectory of cv
         weights: boltzmann weights of frames in trajectory
         equil_temp: Temperature of simulation
 
     Returns:
-        Potential of mean force (PMF), probability density
+        pmf: Potential of mean force (PMF) in kJ/mol 
+        rho: probability density
     """
     RT = R_in_SI * equil_temp / 1000.0
 
@@ -226,11 +228,59 @@ def pmf_from_weights(
         rho[ii] = W_x.sum()
 
     rho /= rho.sum() * dx
-    pmf = -RT * np.log(rho, out=np.zeros_like(rho), where=(rho != 0))
+    pmf = -RT * np.log(rho, out=np.full_like(rho, np.NaN), where=(rho != 0))
 
     return pmf, rho
 
 
+def fes_from_weights(
+    x: np.ndarray, 
+    y: np.ndarray, 
+    xi_x: np.ndarray, 
+    xi_y: np.ndarray, 
+    weights: np.ndarray, 
+    equil_temp: float=300.0
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Get 2D Free Energy Surface (FES) from statistical weigths obtained by MBAR
+
+    Args:
+        x: grid centroids along cv0
+        y: grid centroids along cv1
+        xi_x: trajectory of cv0
+        xi_y: trajectory of cv1
+        weights: boltzmann weights of frames in trajectory
+        equil_temp: equilibrium temperature of simulation
+
+    Returns:
+        xx: grid of shape (len(x), len(y)) for x
+        yy: grid of shape (len(x), len(y)) for y
+        fes: free energy surface in kJ/mol
+    """
+    RT = R_in_SI * equil_temp / 1000.0
+
+    dx = x[1] - x[0]
+    dx2 = dx / 2.0
+    
+    dy = y[1] - y[0]
+    dy2 = dy / 2.0
+    
+    yy, xx = np.meshgrid(y, x)
+    
+    rho = np.zeros_like(xx, dtype=float).flatten()
+    for i, xy in enumerate(zip(xx.flatten(), yy.flatten())):
+        ind_x  = np.where(np.logical_and(
+            xi_x >= xy[0] - dx2, xi_x < xy[0] + dx2
+        ))
+        ind_xy = np.where(np.logical_and(
+            xi_y[ind_x] >= xy[1] - dy2, xi_y[ind_x] < xy[1] + dy2
+        ))
+        rho[i] = weights[ind_xy].sum()
+
+    rho /= rho.sum() * dx
+    fes = -RT * np.log(rho, out=np.full_like(rho, np.NaN), where=(rho != 0))
+    return xx, yy, fes.reshape(xx.shape)
+
+
 def deltaf_from_weights(
     TS: float, cv: np.array, weights: np.array, equil_temp: float = 300.0
 ) -> Tuple[np.array, np.array]:
diff --git a/adaptive_sampling/processing_tools/thermodynamic_integration.py b/adaptive_sampling/processing_tools/thermodynamic_integration.py
index 41cb7c1..a78c6ca 100644
--- a/adaptive_sampling/processing_tools/thermodynamic_integration.py
+++ b/adaptive_sampling/processing_tools/thermodynamic_integration.py
@@ -80,7 +80,6 @@ def czar(
     f_corr = np.zeros(len(grid), dtype=float)
     for i, x in enumerate(grid_local):
         la_x = la[np.where(np.logical_and(xi >= x - dx2, xi < x + dx2))]
-
         hist[i] = len(la_x)
         if hist[i] > 0:
             la_avg = np.average(la_x)
@@ -88,7 +87,7 @@ def czar(
 
     log_hist = np.log(hist, out=np.zeros_like(hist), where=(hist != 0))
 
-    return -RT * np.gradient(log_hist, grid_local) + f_corr
+    return -RT * np.gradient(log_hist, grid_local) + f_corr 
 
 def force_error(
     grid: np.ndarray,
@@ -157,5 +156,3 @@ def force_error(
         return err_pmf
 
 
-
-
diff --git a/adaptive_sampling/sampling_tools/eabf.py b/adaptive_sampling/sampling_tools/eabf.py
index 8395f32..b782ab4 100644
--- a/adaptive_sampling/sampling_tools/eabf.py
+++ b/adaptive_sampling/sampling_tools/eabf.py
@@ -471,7 +471,7 @@ def write_restart(self, filename: str = "restart_abf"):
             ext_hist=self.ext_hist,
             czar_corr=self.correction_czar,
             ext_momenta=self.ext_momenta,
-            ext_coors=self.ext_coords,
+            ext_coords=self.ext_coords,
         )
 
     def restart(self, filename: str = "restart_abf", restart_ext_sys=True):
diff --git a/adaptive_sampling/sampling_tools/gawtmeabf.py b/adaptive_sampling/sampling_tools/gawtmeabf.py
index 41c029d..161adea 100644
--- a/adaptive_sampling/sampling_tools/gawtmeabf.py
+++ b/adaptive_sampling/sampling_tools/gawtmeabf.py
@@ -297,7 +297,8 @@ def restart(self, filename: str="restart_gaabf", restart_ext_sys: bool=True):
         if self.verbose:
             print(f" >>> Info: Adaptive sampling restartet from {filename}!")
 
-    def write_traj(self, filename='CV_traj.dat'):
+
+    def write_traj(self, filename: str = 'CV_traj.dat'):
         """save trajectory for post-processing"""
 
         data = self._write_ext_traj()
diff --git a/adaptive_sampling/sampling_tools/metaeabf.py b/adaptive_sampling/sampling_tools/metaeabf.py
index 6752d17..ef8967d 100644
--- a/adaptive_sampling/sampling_tools/metaeabf.py
+++ b/adaptive_sampling/sampling_tools/metaeabf.py
@@ -60,9 +60,7 @@ def step_bias(
         bias_force = self._extended_dynamics(xi, delta_xi)  # , self.hill_std)
         force_sample = [0 for _ in range(2 * self.ncoords)]
 
-        if (self.ext_coords <= self.maxx).all() and (
-            self.ext_coords >= self.minx
-        ).all():
+        if self._check_boundaries(self.ext_coords):
 
             bin_la = self.get_index(self.ext_coords)
             self.ext_hist[bin_la[1], bin_la[0]] += 1
diff --git a/adaptive_sampling/sampling_tools/reference.py b/adaptive_sampling/sampling_tools/reference.py
index 51121f0..8d8f9b4 100644
--- a/adaptive_sampling/sampling_tools/reference.py
+++ b/adaptive_sampling/sampling_tools/reference.py
@@ -24,7 +24,7 @@ class Reference(EnhancedSampling):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-    def step_bias(self, write_output: bool = True, write_traj: bool = True, **kwargs):
+    def step_bias(self, write_output: bool = True, write_traj: bool = True, traj_file="ref_traj.dat", **kwargs):
 
         md_state = self.the_md.get_sampling_data()
         (xi, delta_xi) = self.get_cv(**kwargs)
@@ -57,7 +57,7 @@ def step_bias(self, write_output: bool = True, write_traj: bool = True, **kwargs
             # write output
 
             if write_traj:
-                self.write_traj()
+                self.write_traj(filename=traj_file)
 
             if write_output:
                 self.get_pmf()
@@ -155,13 +155,13 @@ def restart(self, filename: str = "restart_ref"):
         if self.verbose:
             print(f" >>> Info: Sampling restartet from {filename}!")
 
-    def write_traj(self):
+    def write_traj(self, filename: str="CV_traj.dat"):
         """save trajectory for post-processing"""
         data = {
             "Epot [H]": self.epot,
             "T [K]": self.temp,
         }
-        self._write_traj(data)
+        self._write_traj(data, filename=filename)
 
         # reset trajectories to save memory
         self.traj = np.array([self.traj[-1]])
diff --git a/examples/2D_potentials/gawtmeabf/Untitled.ipynb b/examples/2D_potentials/gawtmeabf/Untitled.ipynb
new file mode 100644
index 0000000..b21ab93
--- /dev/null
+++ b/examples/2D_potentials/gawtmeabf/Untitled.ipynb
@@ -0,0 +1,515 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "67cb8ffc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from adaptive_sampling.processing_tools import mbar\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "eacf5769",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "traj1 = np.loadtxt(\"lower_bound/CV_traj.dat\", skiprows=1)\n",
+    "traj2 = np.loadtxt(\"upper_bound/CV_traj.dat\", skiprows=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "b5d197de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ext_sigma = 2.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b1653ff5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "54"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "minimum   = traj1[:,1].min()     \n",
+    "maximum   = traj1[:,1].max()\n",
+    "bin_width = 2.0\n",
+    "\n",
+    "grid = np.arange(minimum, maximum, bin_width)\n",
+    "len(grid)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6b22276d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cv1 = traj1[:,1]  # trajectory of collective variable\n",
+    "la1 = traj1[:,2]  # trajectory of extended system (for US: center of window)\n",
+    "u1  = traj1[:,3]\n",
+    "\n",
+    "cv2 = traj2[:,1]  # trajectory of collective variable\n",
+    "la2 = traj2[:,2]  # trajectory of extended system\n",
+    "u2  = traj2[:,3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "bf28073d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f7487574400>]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(cv1)\n",
+    "plt.plot(cv2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "ede50ed3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "traj1_list, indices1, meta_f1 = mbar.get_windows(grid, cv1, la1, ext_sigma, equil_temp=300.0)\n",
+    "dU1_list, _, _ = mbar.get_windows(grid, u1, la1, ext_sigma, equil_temp=300.0)\n",
+    "exp_U1, frames_per_traj1 = mbar.build_boltzmann(\n",
+    "    traj1_list, \n",
+    "    meta_f1, \n",
+    "    dU_list=dU1_list,\n",
+    "    equil_temp=300.0,\n",
+    ")\n",
+    "exp_U1_no, frames_per_traj1 = mbar.build_boltzmann(\n",
+    "    traj1_list, \n",
+    "    meta_f1, \n",
+    "    equil_temp=300.0,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "1f43bda5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All ready!\n",
+      "\n",
+      "Start of the self-consistent iteration.\n",
+      "========================================================================\n",
+      "Iter    1:\tConv=  1.3250071466\tConv_errvec=    676.321472\n",
+      "Iter  100:\tConv=  0.0230709608\tConv_errvec=     57.375435\n",
+      "Iter  200:\tConv=  0.0054027245\tConv_errvec=     14.658823\n",
+      "Iter  300:\tConv=  0.0015287956\tConv_errvec=      4.859921\n",
+      "Iter  400:\tConv=  0.0006541249\tConv_errvec=      2.248085\n",
+      "Iter  500:\tConv=  0.0004512870\tConv_errvec=      1.326531\n",
+      "Iter  600:\tConv=  0.0003187535\tConv_errvec=      0.875642\n",
+      "Iter  700:\tConv=  0.0002237516\tConv_errvec=      0.601631\n",
+      "Iter  800:\tConv=  0.0001567688\tConv_errvec=      0.418735\n",
+      "Iter  900:\tConv=  0.0001097750\tConv_errvec=      0.292613\n",
+      "Iter 1000:\tConv=  0.0000768547\tConv_errvec=      0.204733\n",
+      "Iter 1100:\tConv=  0.0000538040\tConv_errvec=      0.143300\n",
+      "Iter 1200:\tConv=  0.0000376661\tConv_errvec=      0.100312\n",
+      "Iter 1300:\tConv=  0.0000263685\tConv_errvec=      0.070223\n",
+      "Iter 1400:\tConv=  0.0000184595\tConv_errvec=      0.049160\n",
+      "Iter 1500:\tConv=  0.0000129227\tConv_errvec=      0.034415\n",
+      "Iter 1600:\tConv=  0.0000090466\tConv_errvec=      0.024092\n",
+      "Iter 1700:\tConv=  0.0000063331\tConv_errvec=      0.016866\n",
+      "Iter 1800:\tConv=  0.0000044336\tConv_errvec=      0.011807\n",
+      "Iter 1900:\tConv=  0.0000031037\tConv_errvec=      0.008266\n",
+      "Iter 2000:\tConv=  0.0000021728\tConv_errvec=      0.005786\n",
+      "Iter 2100:\tConv=  0.0000015211\tConv_errvec=      0.004051\n",
+      "Iter 2200:\tConv=  0.0000010648\tConv_errvec=      0.002836\n",
+      "Iter 2300:\tConv=  0.0000007455\tConv_errvec=      0.001985\n",
+      "Iter 2400:\tConv=  0.0000005219\tConv_errvec=      0.001390\n",
+      "Iter 2500:\tConv=  0.0000003653\tConv_errvec=      0.000973\n",
+      "Iter 2600:\tConv=  0.0000002558\tConv_errvec=      0.000681\n",
+      "Iter 2700:\tConv=  0.0000001790\tConv_errvec=      0.000477\n",
+      "Iter 2800:\tConv=  0.0000001253\tConv_errvec=      0.000334\n",
+      "========================================================================\n",
+      "Converged after 2864 iterations!\n",
+      "Max error vector:       0.000266\n",
+      "========================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "weights1 = mbar.run_mbar(\n",
+    "    exp_U1,\n",
+    "    frames_per_traj1, \n",
+    "    max_iter=10000,\n",
+    "    conv=1.0e-7,\n",
+    "    conv_errvec=1.0,\n",
+    "    outfreq=100,\n",
+    "    device='cpu',\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "018ff90a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All ready!\n",
+      "\n",
+      "Start of the self-consistent iteration.\n",
+      "========================================================================\n",
+      "Iter    1:\tConv=  1.3250071466\tConv_errvec=    676.321472\n",
+      "Iter  100:\tConv=  0.0230709608\tConv_errvec=     57.375435\n",
+      "Iter  200:\tConv=  0.0054027245\tConv_errvec=     14.658823\n",
+      "Iter  300:\tConv=  0.0015287956\tConv_errvec=      4.859921\n",
+      "Iter  400:\tConv=  0.0006541249\tConv_errvec=      2.248085\n",
+      "Iter  500:\tConv=  0.0004512870\tConv_errvec=      1.326531\n",
+      "Iter  600:\tConv=  0.0003187535\tConv_errvec=      0.875642\n",
+      "Iter  700:\tConv=  0.0002237516\tConv_errvec=      0.601631\n",
+      "Iter  800:\tConv=  0.0001567688\tConv_errvec=      0.418735\n",
+      "Iter  900:\tConv=  0.0001097750\tConv_errvec=      0.292613\n",
+      "Iter 1000:\tConv=  0.0000768547\tConv_errvec=      0.204733\n",
+      "Iter 1100:\tConv=  0.0000538040\tConv_errvec=      0.143300\n",
+      "Iter 1200:\tConv=  0.0000376661\tConv_errvec=      0.100312\n",
+      "Iter 1300:\tConv=  0.0000263685\tConv_errvec=      0.070223\n",
+      "Iter 1400:\tConv=  0.0000184595\tConv_errvec=      0.049160\n",
+      "Iter 1500:\tConv=  0.0000129227\tConv_errvec=      0.034415\n",
+      "Iter 1600:\tConv=  0.0000090466\tConv_errvec=      0.024092\n",
+      "Iter 1700:\tConv=  0.0000063331\tConv_errvec=      0.016866\n",
+      "Iter 1800:\tConv=  0.0000044336\tConv_errvec=      0.011807\n",
+      "Iter 1900:\tConv=  0.0000031037\tConv_errvec=      0.008266\n",
+      "Iter 2000:\tConv=  0.0000021728\tConv_errvec=      0.005786\n",
+      "Iter 2100:\tConv=  0.0000015211\tConv_errvec=      0.004051\n",
+      "Iter 2200:\tConv=  0.0000010648\tConv_errvec=      0.002836\n",
+      "Iter 2300:\tConv=  0.0000007455\tConv_errvec=      0.001985\n",
+      "Iter 2400:\tConv=  0.0000005219\tConv_errvec=      0.001390\n",
+      "Iter 2500:\tConv=  0.0000003653\tConv_errvec=      0.000973\n",
+      "Iter 2600:\tConv=  0.0000002558\tConv_errvec=      0.000681\n",
+      "Iter 2700:\tConv=  0.0000001790\tConv_errvec=      0.000477\n",
+      "Iter 2800:\tConv=  0.0000001253\tConv_errvec=      0.000334\n",
+      "========================================================================\n",
+      "Converged after 2864 iterations!\n",
+      "Max error vector:       0.000266\n",
+      "========================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "weights1_no = mbar.run_mbar(\n",
+    "    exp_U1_no,\n",
+    "    frames_per_traj1, \n",
+    "    max_iter=10000,\n",
+    "    conv=1.0e-7,\n",
+    "    conv_errvec=1.0,\n",
+    "    outfreq=100,\n",
+    "    device='cpu',\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7e1a0ecb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "traj2_list, indices2, meta_f2 = mbar.get_windows(grid, cv2, la2, ext_sigma, equil_temp=300.0)\n",
+    "dU2_list, _, _ = mbar.get_windows(grid, u2, la2, ext_sigma, equil_temp=300.0)\n",
+    "exp_U2, frames_per_traj2 = mbar.build_boltzmann(\n",
+    "    traj2_list, \n",
+    "    meta_f2, \n",
+    "    dU_list=dU2_list,\n",
+    "    equil_temp=300.0,\n",
+    ")\n",
+    "exp_U2_no, frames_per_traj2 = mbar.build_boltzmann(\n",
+    "    traj2_list, \n",
+    "    meta_f2, \n",
+    "    equil_temp=300.0,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "a45a29aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All ready!\n",
+      "\n",
+      "Start of the self-consistent iteration.\n",
+      "========================================================================\n",
+      "Iter    1:\tConv=  0.5179874888\tConv_errvec=    393.379913\n",
+      "Iter  100:\tConv=  0.0138414679\tConv_errvec=     32.385334\n",
+      "Iter  200:\tConv=  0.0030642982\tConv_errvec=      7.783641\n",
+      "Iter  300:\tConv=  0.0008145609\tConv_errvec=      2.466259\n",
+      "Iter  400:\tConv=  0.0003385535\tConv_errvec=      1.113036\n",
+      "Iter  500:\tConv=  0.0002317209\tConv_errvec=      0.650333\n",
+      "Iter  600:\tConv=  0.0001616087\tConv_errvec=      0.426421\n",
+      "Iter  700:\tConv=  0.0001123219\tConv_errvec=      0.290860\n",
+      "Iter  800:\tConv=  0.0000779875\tConv_errvec=      0.200826\n",
+      "Iter  900:\tConv=  0.0000541323\tConv_errvec=      0.139167\n",
+      "Iter 1000:\tConv=  0.0000375708\tConv_errvec=      0.096542\n",
+      "Iter 1100:\tConv=  0.0000260755\tConv_errvec=      0.066994\n",
+      "Iter 1200:\tConv=  0.0000180972\tConv_errvec=      0.046494\n",
+      "Iter 1300:\tConv=  0.0000125600\tConv_errvec=      0.032268\n",
+      "Iter 1400:\tConv=  0.0000087170\tConv_errvec=      0.022395\n",
+      "Iter 1500:\tConv=  0.0000060499\tConv_errvec=      0.015542\n",
+      "Iter 1600:\tConv=  0.0000041988\tConv_errvec=      0.010787\n",
+      "Iter 1700:\tConv=  0.0000029141\tConv_errvec=      0.007486\n",
+      "Iter 1800:\tConv=  0.0000020224\tConv_errvec=      0.005196\n",
+      "Iter 1900:\tConv=  0.0000014036\tConv_errvec=      0.003606\n",
+      "Iter 2000:\tConv=  0.0000009742\tConv_errvec=      0.002503\n",
+      "Iter 2100:\tConv=  0.0000006761\tConv_errvec=      0.001737\n",
+      "Iter 2200:\tConv=  0.0000004692\tConv_errvec=      0.001205\n",
+      "Iter 2300:\tConv=  0.0000003257\tConv_errvec=      0.000837\n",
+      "Iter 2400:\tConv=  0.0000002260\tConv_errvec=      0.000581\n",
+      "Iter 2500:\tConv=  0.0000001569\tConv_errvec=      0.000403\n",
+      "Iter 2600:\tConv=  0.0000001089\tConv_errvec=      0.000280\n",
+      "========================================================================\n",
+      "Converged after 2624 iterations!\n",
+      "Max error vector:       0.000256\n",
+      "========================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "weights2 = mbar.run_mbar(\n",
+    "    exp_U2,\n",
+    "    frames_per_traj2, \n",
+    "    max_iter=10000,\n",
+    "    conv=1.0e-7,\n",
+    "    conv_errvec=1.0,\n",
+    "    outfreq=100,\n",
+    "    device='cpu',\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "3b85ca2c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All ready!\n",
+      "\n",
+      "Start of the self-consistent iteration.\n",
+      "========================================================================\n",
+      "Iter    1:\tConv=  0.5179874888\tConv_errvec=    393.379913\n",
+      "Iter  100:\tConv=  0.0138414679\tConv_errvec=     32.385334\n",
+      "Iter  200:\tConv=  0.0030642982\tConv_errvec=      7.783641\n",
+      "Iter  300:\tConv=  0.0008145609\tConv_errvec=      2.466259\n",
+      "Iter  400:\tConv=  0.0003385535\tConv_errvec=      1.113036\n",
+      "Iter  500:\tConv=  0.0002317209\tConv_errvec=      0.650333\n",
+      "Iter  600:\tConv=  0.0001616087\tConv_errvec=      0.426421\n",
+      "Iter  700:\tConv=  0.0001123219\tConv_errvec=      0.290860\n",
+      "Iter  800:\tConv=  0.0000779875\tConv_errvec=      0.200826\n",
+      "Iter  900:\tConv=  0.0000541323\tConv_errvec=      0.139167\n",
+      "Iter 1000:\tConv=  0.0000375708\tConv_errvec=      0.096542\n",
+      "Iter 1100:\tConv=  0.0000260755\tConv_errvec=      0.066994\n",
+      "Iter 1200:\tConv=  0.0000180972\tConv_errvec=      0.046494\n",
+      "Iter 1300:\tConv=  0.0000125600\tConv_errvec=      0.032268\n",
+      "Iter 1400:\tConv=  0.0000087170\tConv_errvec=      0.022395\n",
+      "Iter 1500:\tConv=  0.0000060499\tConv_errvec=      0.015542\n",
+      "Iter 1600:\tConv=  0.0000041988\tConv_errvec=      0.010787\n",
+      "Iter 1700:\tConv=  0.0000029141\tConv_errvec=      0.007486\n",
+      "Iter 1800:\tConv=  0.0000020224\tConv_errvec=      0.005196\n",
+      "Iter 1900:\tConv=  0.0000014036\tConv_errvec=      0.003606\n",
+      "Iter 2000:\tConv=  0.0000009742\tConv_errvec=      0.002503\n",
+      "Iter 2100:\tConv=  0.0000006761\tConv_errvec=      0.001737\n",
+      "Iter 2200:\tConv=  0.0000004692\tConv_errvec=      0.001205\n",
+      "Iter 2300:\tConv=  0.0000003257\tConv_errvec=      0.000837\n",
+      "Iter 2400:\tConv=  0.0000002260\tConv_errvec=      0.000581\n",
+      "Iter 2500:\tConv=  0.0000001569\tConv_errvec=      0.000403\n",
+      "Iter 2600:\tConv=  0.0000001089\tConv_errvec=      0.000280\n",
+      "========================================================================\n",
+      "Converged after 2624 iterations!\n",
+      "Max error vector:       0.000256\n",
+      "========================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "weights2_no = mbar.run_mbar(\n",
+    "    exp_U2_no,\n",
+    "    frames_per_traj2, \n",
+    "    max_iter=10000,\n",
+    "    conv=1.0e-7,\n",
+    "    conv_errvec=1.0,\n",
+    "    outfreq=100,\n",
+    "    device='cpu',\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "ae1a9edd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pmf1,_ = mbar.pmf_from_weights(grid, cv1[indices1], weights1)\n",
+    "pmf2,_ = mbar.pmf_from_weights(grid, cv1[indices1], weights1_no)\n",
+    "pmf3,_ = mbar.pmf_from_weights(grid, cv2[indices2], weights2)\n",
+    "pmf4,_ = mbar.pmf_from_weights(grid, cv2[indices2], weights2_no)\n",
+    "pmf1 -= pmf1.min()\n",
+    "pmf2 -= pmf2.min()\n",
+    "pmf3 -= pmf3.min()\n",
+    "pmf4 -= pmf4.min()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "f793cf8a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f748839cb50>]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(grid,pmf1,label=\"lower\") \n",
+    "plt.plot(grid,pmf2,label=\"lower\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "3c47d7fe",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f74883fd340>]"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(grid,pmf3,label=\"upper\")\n",
+    "plt.plot(grid,pmf4,label=\"upper\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5fbb8d7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.9.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/2D_potentials/gawtmeabf/lower_bound/md_2d_metaeabf.py b/examples/2D_potentials/gawtmeabf/lower_bound/md_2d_metaeabf.py
new file mode 100644
index 0000000..f4714b5
--- /dev/null
+++ b/examples/2D_potentials/gawtmeabf/lower_bound/md_2d_metaeabf.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+from adaptive_sampling.sampling_tools.gawtmeabf import GaWTMeABF
+from adaptive_sampling.interface.interfaceMD_2D import *
+
+bohr2angs = 0.52917721092e0
+
+################# Imput Section ####################
+
+# MD
+seed = 42
+nsteps = 210000  # number of MD steps
+dt = 5.0e0  # stepsize in fs
+target_temp = 300.0  # Kelvin
+mass = 10.0  # a.u.
+potential = "1"
+
+# eABF
+ats = [["x", [], 70.0, 170.0, 2.0]]
+N_full = 100
+
+step_count = 0
+coords = [80.0, 0]
+the_md = MD(
+    mass_in=mass,
+    coords_in=coords,
+    potential=potential,
+    dt_in=dt,
+    target_temp_in=target_temp,
+    seed_in=seed,
+)
+the_abm = GaWTMeABF(
+    2.0,
+    20.0,
+    2.0,
+    4.0,
+    0.0005,
+    1000,
+    10000,
+    the_md,
+    ats,
+    hill_drop_freq=100,
+    do_wtm=True,
+    gamd_bound="lower",
+    output_freq=1000,
+    f_conf=100,
+    equil_temp=300.0,
+)
+# the_abm.restart()
+
+the_md.calc_init()
+the_abm.step_bias()
+the_md.calc_etvp()
+
+
+################# the MD loop ####################
+print(
+    "%11s\t%14s\t%14s\t%14s\t%14s\t%14s\t%14s"
+    % ("time [fs]", "x", "y", "E_pot", "E_kin", "E_tot", "T")
+)
+print(
+    "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+    % (
+        the_md.step * the_md.dt * atomic_to_fs,
+        the_md.coords[0],
+        the_md.coords[1],
+        the_md.epot,
+        the_md.ekin,
+        the_md.epot + the_md.ekin,
+        the_md.temp,
+    )
+)
+
+while step_count < nsteps:
+    the_md.step += 1
+    step_count += 1
+
+    the_md.propagate(langevin=True)
+    the_md.calc()
+
+    the_md.forces += the_abm.step_bias()
+    print(the_abm.k0)
+    the_md.up_momenta(langevin=True)
+    the_md.calc_etvp()
+
+    print(
+        "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+        % (
+            the_md.step * the_md.dt * atomic_to_fs,
+            the_md.coords[0],
+            the_md.coords[1],
+            the_md.epot,
+            the_md.ekin,
+            the_md.epot + the_md.ekin,
+            the_md.temp,
+        )
+    )
diff --git a/examples/2D_potentials/gawtmeabf/md_2d_metaeabf.py b/examples/2D_potentials/gawtmeabf/md_2d_metaeabf.py
index 6005833..dfed257 100644
--- a/examples/2D_potentials/gawtmeabf/md_2d_metaeabf.py
+++ b/examples/2D_potentials/gawtmeabf/md_2d_metaeabf.py
@@ -33,14 +33,14 @@
     20.0,
     2.0,
     4.0,
-    3.5,
+    12,
+    1000,
     1000,
-    10000,
     the_md,
     ats,
     hill_drop_freq=100,
     do_wtm=True,
-    gamd_bound="lower",
+    gamd_bound="aMD",
     output_freq=1000,
     f_conf=100,
     equil_temp=300.0,
diff --git a/examples/2D_potentials/gawtmeabf/upper_bound/md_2d_metaeabf.py b/examples/2D_potentials/gawtmeabf/upper_bound/md_2d_metaeabf.py
new file mode 100644
index 0000000..20eb0d5
--- /dev/null
+++ b/examples/2D_potentials/gawtmeabf/upper_bound/md_2d_metaeabf.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+from adaptive_sampling.sampling_tools.gawtmeabf import GaWTMeABF
+from adaptive_sampling.interface.interfaceMD_2D import *
+
+bohr2angs = 0.52917721092e0
+
+################# Imput Section ####################
+
+# MD
+seed = 42
+nsteps = 210000  # number of MD steps
+dt = 5.0e0  # stepsize in fs
+target_temp = 300.0  # Kelvin
+mass = 10.0  # a.u.
+potential = "1"
+
+# eABF
+ats = [["x", [], 70.0, 170.0, 2.0]]
+N_full = 100
+
+step_count = 0
+coords = [80.0, 0]
+the_md = MD(
+    mass_in=mass,
+    coords_in=coords,
+    potential=potential,
+    dt_in=dt,
+    target_temp_in=target_temp,
+    seed_in=seed,
+)
+the_abm = GaWTMeABF(
+    2.0,
+    20.0,
+    2.0,
+    4.0,
+    0.0001,
+    1000,
+    10000,
+    the_md,
+    ats,
+    hill_drop_freq=100,
+    do_wtm=True,
+    gamd_bound="upper",
+    output_freq=1000,
+    f_conf=100,
+    equil_temp=300.0,
+)
+# the_abm.restart()
+
+the_md.calc_init()
+the_abm.step_bias()
+the_md.calc_etvp()
+
+
+################# the MD loop ####################
+print(
+    "%11s\t%14s\t%14s\t%14s\t%14s\t%14s\t%14s"
+    % ("time [fs]", "x", "y", "E_pot", "E_kin", "E_tot", "T")
+)
+print(
+    "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+    % (
+        the_md.step * the_md.dt * atomic_to_fs,
+        the_md.coords[0],
+        the_md.coords[1],
+        the_md.epot,
+        the_md.ekin,
+        the_md.epot + the_md.ekin,
+        the_md.temp,
+    )
+)
+
+while step_count < nsteps:
+    the_md.step += 1
+    step_count += 1
+
+    the_md.propagate(langevin=True)
+    the_md.calc()
+
+    the_md.forces += the_abm.step_bias()
+
+    the_md.up_momenta(langevin=True)
+    the_md.calc_etvp()
+
+    print(
+        "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+        % (
+            the_md.step * the_md.dt * atomic_to_fs,
+            the_md.coords[0],
+            the_md.coords[1],
+            the_md.epot,
+            the_md.ekin,
+            the_md.epot + the_md.ekin,
+            the_md.temp,
+        )
+    )
diff --git a/examples/2D_potentials/meta-eabf/MW/Untitled.ipynb b/examples/2D_potentials/meta-eabf/MW/Untitled.ipynb
new file mode 100644
index 0000000..ec185b9
--- /dev/null
+++ b/examples/2D_potentials/meta-eabf/MW/Untitled.ipynb
@@ -0,0 +1,2276 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "67cb8ffc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from adaptive_sampling.processing_tools import mbar\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "eacf5769",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "traj1 = np.loadtxt(\"W1/CV_traj1.dat\", skiprows=1)\n",
+    "traj2 = np.loadtxt(\"W2/CV_traj1.dat\", skiprows=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "b5d197de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ext_sigma = 2.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b1653ff5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "40"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "minimum   = traj1[:,1].min()     \n",
+    "maximum   = traj1[:,1].max()\n",
+    "bin_width = (maximum-minimum)/40\n",
+    "\n",
+    "grid = np.arange(minimum, maximum, bin_width)\n",
+    "len(grid)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6b22276d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cv1 = traj1[:50000,1]  # trajectory of collective variable\n",
+    "la1 = traj1[:50000,2]  # trajectory of extended system (for US: center of window)\n",
+    "\n",
+    "cv2 = traj2[:,1]  # trajectory of collective variable\n",
+    "la2 = traj2[:,2]  # trajectory of extended system"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "bf28073d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7faef53fb430>]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(cv1)\n",
+    "plt.plot(cv2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "ede50ed3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "traj1_list, indices1, meta_f1 = mbar.get_windows(grid, cv1, la1, ext_sigma, equil_temp=300.0)\n",
+    "exp_U1, frames_per_traj1 = mbar.build_boltzmann(\n",
+    "    traj1_list, \n",
+    "    meta_f1, \n",
+    "    equil_temp=300.0,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "1f43bda5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All ready!\n",
+      "\n",
+      "Start of the self-consistent iteration.\n",
+      "========================================================================\n",
+      "Iter    1:\tConv=  1.7675200511\tConv_errvec=    267.073135\n",
+      "Iter  100:\tConv=  0.0269842402\tConv_errvec=     20.507113\n",
+      "Iter  200:\tConv=  0.0056850731\tConv_errvec=      4.562759\n",
+      "Iter  300:\tConv=  0.0010883686\tConv_errvec=      1.045899\n",
+      "Iter  400:\tConv=  0.0002442996\tConv_errvec=      0.368655\n",
+      "Iter  500:\tConv=  0.0001794171\tConv_errvec=      0.176308\n",
+      "Iter  600:\tConv=  0.0001240836\tConv_errvec=      0.103332\n",
+      "Iter  700:\tConv=  0.0000843008\tConv_errvec=      0.066312\n",
+      "Iter  800:\tConv=  0.0000569560\tConv_errvec=      0.043973\n",
+      "Iter  900:\tConv=  0.0000384136\tConv_errvec=      0.029480\n",
+      "Iter 1000:\tConv=  0.0000258934\tConv_errvec=      0.019834\n",
+      "Iter 1100:\tConv=  0.0000174508\tConv_errvec=      0.013359\n",
+      "Iter 1200:\tConv=  0.0000117603\tConv_errvec=      0.009001\n",
+      "Iter 1300:\tConv=  0.0000079252\tConv_errvec=      0.006065\n",
+      "Iter 1400:\tConv=  0.0000053408\tConv_errvec=      0.004087\n",
+      "Iter 1500:\tConv=  0.0000035991\tConv_errvec=      0.002754\n",
+      "Iter 1600:\tConv=  0.0000024254\tConv_errvec=      0.001856\n",
+      "Iter 1700:\tConv=  0.0000016345\tConv_errvec=      0.001251\n",
+      "Iter 1800:\tConv=  0.0000011015\tConv_errvec=      0.000843\n",
+      "Iter 1900:\tConv=  0.0000007423\tConv_errvec=      0.000568\n",
+      "Iter 2000:\tConv=  0.0000005002\tConv_errvec=      0.000383\n",
+      "Iter 2100:\tConv=  0.0000003371\tConv_errvec=      0.000258\n",
+      "Iter 2200:\tConv=  0.0000002272\tConv_errvec=      0.000174\n",
+      "Iter 2300:\tConv=  0.0000001531\tConv_errvec=      0.000117\n",
+      "Iter 2400:\tConv=  0.0000001032\tConv_errvec=      0.000079\n",
+      "========================================================================\n",
+      "Converged after 2408 iterations!\n",
+      "Max error vector:       0.000076\n",
+      "========================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "weights1 = mbar.run_mbar(\n",
+    "    exp_U1,\n",
+    "    frames_per_traj1, \n",
+    "    max_iter=10000,\n",
+    "    conv=1.0e-7,\n",
+    "    conv_errvec=1.0,\n",
+    "    outfreq=100,\n",
+    "    device='cpu',\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "7e1a0ecb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "traj2_list, indices2, meta_f2 = mbar.get_windows(grid, cv2, la2, ext_sigma, equil_temp=300.0)\n",
+    "exp_U2, frames_per_traj2 = mbar.build_boltzmann(\n",
+    "    traj2_list, \n",
+    "    meta_f2, \n",
+    "    equil_temp=300.0,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "a45a29aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All ready!\n",
+      "\n",
+      "Start of the self-consistent iteration.\n",
+      "========================================================================\n",
+      "Iter    1:\tConv=  1.6011112041\tConv_errvec=    950.639731\n",
+      "Iter  100:\tConv=  0.0247825784\tConv_errvec=     68.897390\n",
+      "Iter  200:\tConv=  0.0049497273\tConv_errvec=     15.323238\n",
+      "Iter  300:\tConv=  0.0013236164\tConv_errvec=      4.802003\n",
+      "Iter  400:\tConv=  0.0006777219\tConv_errvec=      2.267798\n",
+      "Iter  500:\tConv=  0.0004658258\tConv_errvec=      1.366479\n",
+      "Iter  600:\tConv=  0.0003181882\tConv_errvec=      0.899387\n",
+      "Iter  700:\tConv=  0.0002169901\tConv_errvec=      0.607285\n",
+      "Iter  800:\tConv=  0.0001479148\tConv_errvec=      0.412883\n",
+      "Iter  900:\tConv=  0.0001008173\tConv_errvec=      0.281222\n",
+      "Iter 1000:\tConv=  0.0000687141\tConv_errvec=      0.191637\n",
+      "Iter 1100:\tConv=  0.0000468332\tConv_errvec=      0.130606\n",
+      "Iter 1200:\tConv=  0.0000319198\tConv_errvec=      0.089015\n",
+      "Iter 1300:\tConv=  0.0000217554\tConv_errvec=      0.060669\n",
+      "Iter 1400:\tConv=  0.0000148277\tConv_errvec=      0.041350\n",
+      "Iter 1500:\tConv=  0.0000101060\tConv_errvec=      0.028183\n",
+      "Iter 1600:\tConv=  0.0000068879\tConv_errvec=      0.019208\n",
+      "Iter 1700:\tConv=  0.0000046945\tConv_errvec=      0.013092\n",
+      "Iter 1800:\tConv=  0.0000031996\tConv_errvec=      0.008923\n",
+      "Iter 1900:\tConv=  0.0000021807\tConv_errvec=      0.006081\n",
+      "Iter 2000:\tConv=  0.0000014863\tConv_errvec=      0.004145\n",
+      "Iter 2100:\tConv=  0.0000010130\tConv_errvec=      0.002825\n",
+      "Iter 2200:\tConv=  0.0000006904\tConv_errvec=      0.001925\n",
+      "Iter 2300:\tConv=  0.0000004706\tConv_errvec=      0.001312\n",
+      "Iter 2400:\tConv=  0.0000003207\tConv_errvec=      0.000894\n",
+      "Iter 2500:\tConv=  0.0000002186\tConv_errvec=      0.000610\n",
+      "Iter 2600:\tConv=  0.0000001490\tConv_errvec=      0.000415\n",
+      "Iter 2700:\tConv=  0.0000001015\tConv_errvec=      0.000283\n",
+      "========================================================================\n",
+      "Converged after 2704 iterations!\n",
+      "Max error vector:       0.000279\n",
+      "========================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "weights2 = mbar.run_mbar(\n",
+    "    exp_U2,\n",
+    "    frames_per_traj2, \n",
+    "    max_iter=10000,\n",
+    "    conv=1.0e-7,\n",
+    "    conv_errvec=1.0,\n",
+    "    outfreq=100,\n",
+    "    device='cpu',\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "7b744cf8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "traj3_list, indices3, meta_f3 = mbar.get_windows(grid, np.append(cv1,cv2), np.append(la1,la2), ext_sigma, equil_temp=300.0)\n",
+    "exp_U3, frames_per_traj3 = mbar.build_boltzmann(\n",
+    "    traj3_list, \n",
+    "    meta_f3, \n",
+    "    equil_temp=300.0,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7e2c83fe",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All ready!\n",
+      "\n",
+      "Start of the self-consistent iteration.\n",
+      "========================================================================\n",
+      "Iter    1:\tConv=  1.6341380394\tConv_errvec=   1084.250845\n",
+      "Iter  100:\tConv=  0.0251704285\tConv_errvec=     86.058311\n",
+      "Iter  200:\tConv=  0.0050149238\tConv_errvec=     18.417146\n",
+      "Iter  300:\tConv=  0.0012157271\tConv_errvec=      5.283457\n",
+      "Iter  400:\tConv=  0.0004981859\tConv_errvec=      2.263521\n",
+      "Iter  500:\tConv=  0.0003360481\tConv_errvec=      1.296700\n",
+      "Iter  600:\tConv=  0.0002292389\tConv_errvec=      0.838519\n",
+      "Iter  700:\tConv=  0.0001562783\tConv_errvec=      0.563174\n",
+      "Iter  800:\tConv=  0.0001065208\tConv_errvec=      0.382305\n",
+      "Iter  900:\tConv=  0.0000726022\tConv_errvec=      0.260282\n",
+      "Iter 1000:\tConv=  0.0000494834\tConv_errvec=      0.177347\n",
+      "Iter 1100:\tConv=  0.0000337262\tConv_errvec=      0.120864\n",
+      "Iter 1200:\tConv=  0.0000229867\tConv_errvec=      0.082374\n",
+      "Iter 1300:\tConv=  0.0000156669\tConv_errvec=      0.056143\n",
+      "Iter 1400:\tConv=  0.0000106780\tConv_errvec=      0.038265\n",
+      "Iter 1500:\tConv=  0.0000072778\tConv_errvec=      0.026080\n",
+      "Iter 1600:\tConv=  0.0000049603\tConv_errvec=      0.017775\n",
+      "Iter 1700:\tConv=  0.0000033808\tConv_errvec=      0.012115\n",
+      "Iter 1800:\tConv=  0.0000023042\tConv_errvec=      0.008257\n",
+      "Iter 1900:\tConv=  0.0000015705\tConv_errvec=      0.005628\n",
+      "Iter 2000:\tConv=  0.0000010704\tConv_errvec=      0.003836\n",
+      "Iter 2100:\tConv=  0.0000007295\tConv_errvec=      0.002614\n",
+      "Iter 2200:\tConv=  0.0000004972\tConv_errvec=      0.001782\n",
+      "Iter 2300:\tConv=  0.0000003389\tConv_errvec=      0.001214\n",
+      "Iter 2400:\tConv=  0.0000002310\tConv_errvec=      0.000828\n",
+      "Iter 2500:\tConv=  0.0000001574\tConv_errvec=      0.000564\n",
+      "Iter 2600:\tConv=  0.0000001073\tConv_errvec=      0.000384\n",
+      "========================================================================\n",
+      "Converged after 2619 iterations!\n",
+      "Max error vector:       0.000357\n",
+      "========================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "weights3 = mbar.run_mbar(\n",
+    "    exp_U3,\n",
+    "    frames_per_traj3, \n",
+    "    max_iter=10000,\n",
+    "    conv=1.0e-7,\n",
+    "    conv_errvec=1.0,\n",
+    "    outfreq=100,\n",
+    "    device='cpu',\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "d9be99aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "74.71992956584087"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sum(weights1)\n",
+    "sum(weights2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "16de255a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "weights4 = np.append(weights1, weights2)\n",
+    "weights4 /= weights4.sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "fcf13ad6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# normalize weights of individual simulations to 1\n",
+    "weights1_n = weights1 / weights1.sum()\n",
+    "weights2_n = weights2 / weights2.sum()\n",
+    "\n",
+    "# scale the contribution of the simulation by the number of frames it adds\n",
+    "weights1_n *= len(weights1_n)\n",
+    "weights2_n *= len(weights2_n)\n",
+    "\n",
+    "# combine simulations\n",
+    "weights5 = np.append(weights1_n, weights2_n)\n",
+    "weights5 /= weights4.sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "ae1a9edd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pmf1,_ = mbar.pmf_from_weights(grid, cv1[indices1], weights1)\n",
+    "pmf2,_ = mbar.pmf_from_weights(grid, cv2[indices2], weights2)\n",
+    "pmf3,_ = mbar.pmf_from_weights(grid, np.append(cv1,cv2)[indices3], weights3)\n",
+    "pmf4,_ = mbar.pmf_from_weights(grid, np.append(cv1[indices1],cv2[indices2]), weights4)\n",
+    "pmf5,_ = mbar.pmf_from_weights(grid, np.append(cv1[indices1],cv2[indices2]), weights5)\n",
+    "#pmf1 -= pmf1.min()\n",
+    "#pmf2 -= pmf2.min()\n",
+    "#pmf3 -= pmf3.min()\n",
+    "#pmf4 -= pmf4.min()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "a0bfdd91",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9999999999999996"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sum(weights4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "f793cf8a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(80.0, 160.0)"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plt.plot(grid,pmf1)\n",
+    "#plt.plot(grid,pmf2)\n",
+    "plt.plot(grid,pmf3)\n",
+    "plt.plot(grid,pmf4)\n",
+    "plt.plot(grid,pmf5)\n",
+    "plt.xlim([80,160])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "af2f7d51",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[array([], dtype=float64),\n",
+       " array([70.94445 , 70.889374, 70.835632, 70.784134, 70.734932, 70.687508,\n",
+       "        70.640564, 70.593796, 70.549789, 70.505562, 70.457123, 70.405212,\n",
+       "        70.351822, 70.301765, 70.256798, 70.213287, 70.169113, 70.123405,\n",
+       "        70.077972, 70.035187, 69.996117, 69.961571, 69.930664, 69.90136 ,\n",
+       "        69.874535, 69.853386, 69.831314, 69.807533, 69.787018, 69.770874,\n",
+       "        69.76059 , 69.75396 , 69.752586, 69.753845, 69.75589 , 69.763023,\n",
+       "        69.771812, 69.778069, 69.782219, 69.783829, 69.786034, 69.792397,\n",
+       "        69.800529, 69.805794, 69.812111, 69.822197, 69.831985, 69.84346 ,\n",
+       "        69.857666, 69.873749, 69.892281, 69.916031, 69.946739, 69.986771,\n",
+       "        70.033318, 70.082489, 70.129906, 70.17292 , 70.213242, 70.24881 ,\n",
+       "        70.280228, 70.309631, 70.337105, 70.369347, 70.40728 , 70.445518,\n",
+       "        70.485588, 70.527657, 70.565903, 70.604301, 70.655251, 70.71328 ,\n",
+       "        70.773911, 70.837364, 70.895973, 70.955742, 71.018349, 71.079926,\n",
+       "        71.140656, 71.200859, 71.264275, 71.331711, 71.400452, 71.469269,\n",
+       "        71.541168, 71.620415, 71.704521, 71.784798, 71.862   , 71.937462,\n",
+       "        72.012093, 72.089539, 72.168648, 72.246124, 72.322861, 72.40107 ,\n",
+       "        72.47892 , 72.552521, 72.627396, 72.704803, 72.78109 , 72.862602,\n",
+       "        72.949844, 73.039131, 73.126366, 73.214897, 73.309204, 73.405319,\n",
+       "        73.502892, 69.491821, 69.535522, 69.579575, 69.624641, 69.673965,\n",
+       "        69.724426, 69.771828, 69.817932, 69.860657, 69.899353, 69.942635,\n",
+       "        69.989571, 70.036087, 70.078629, 70.118858, 70.162979, 70.209038,\n",
+       "        70.256401, 70.303062, 70.347618, 70.389526, 70.427971, 70.466484,\n",
+       "        70.506081, 70.54335 , 70.577209, 70.610413, 70.641823, 70.66851 ,\n",
+       "        70.689537, 70.710297, 70.736084, 70.765785, 70.796722, 70.828056,\n",
+       "        70.861275, 70.894539, 70.925575, 70.956276, 70.987312, 71.020607,\n",
+       "        71.058044, 71.090958, 71.120872, 71.156746, 71.194603, 71.231102,\n",
+       "        71.265823, 71.297981, 71.330238, 71.382591, 71.347565, 71.305916,\n",
+       "        71.263008, 71.223831, 71.185333, 71.145821, 71.11087 , 71.082191,\n",
+       "        71.053627, 71.021942, 70.991051, 70.962204, 70.936089, 70.914673,\n",
+       "        70.894882, 70.875839, 70.856651, 70.842232, 70.833237, 70.81945 ,\n",
+       "        70.798325, 70.774796, 70.750092, 70.723106, 70.696251, 70.670273,\n",
+       "        70.641899, 70.611473, 70.587067, 70.572899, 70.564285, 70.56118 ,\n",
+       "        70.559021, 70.553726, 70.548096, 70.542343, 70.535118, 70.528175,\n",
+       "        70.521698, 70.515198, 70.510605, 70.509872, 70.514427, 70.519875,\n",
+       "        70.524422, 70.532936, 70.551033, 70.573822, 70.596756, 70.618835,\n",
+       "        70.636086, 70.654442, 70.678558, 70.706146, 70.738274, 70.773338,\n",
+       "        70.807755, 70.847412, 70.894035, 70.942322, 70.98983 , 71.035133,\n",
+       "        71.079201, 71.12236 , 71.166   , 71.214096, 71.265587, 71.317383,\n",
+       "        71.370575, 71.426628, 71.487122, 71.555695, 71.628281, 71.699318,\n",
+       "        71.76889 , 71.836639, 71.902519, 71.962509, 72.01722 , 72.073494,\n",
+       "        72.131905, 72.186478, 72.239143, 72.292099, 72.345665, 72.39817 ,\n",
+       "        72.447113, 72.494362, 72.536186, 72.571228, 72.603249, 72.635292,\n",
+       "        72.671143, 72.705605, 72.733154, 72.755051, 72.772789, 72.788803,\n",
+       "        72.799141, 72.804283, 72.806625, 72.808907, 72.817009, 72.827957,\n",
+       "        72.83902 , 72.84906 , 72.855469, 72.860924, 72.866852, 72.874466,\n",
+       "        72.883675, 72.892204, 72.904526, 72.920731, 72.936539, 72.95163 ,\n",
+       "        72.967094, 72.985405, 73.00106 , 73.011246, 73.021942, 73.030716,\n",
+       "        73.035118, 73.031677, 73.022026, 73.016418, 71.011253, 71.038124,\n",
+       "        71.068283, 71.102036, 71.136581, 71.171944, 71.208397, 71.241318,\n",
+       "        71.26606 , 71.289185, 71.316795, 71.344604, 71.370338, 71.403122,\n",
+       "        71.444283, 71.485245, 71.528244, 71.571526, 71.613914, 71.661949,\n",
+       "        71.719124, 71.780815, 71.838966, 71.892532, 71.943802, 71.995644,\n",
+       "        72.050133, 72.109688, 72.175583, 72.244026, 72.307343, 72.363762,\n",
+       "        72.418808, 72.471657, 72.518173, 72.566376, 72.61763 , 72.663727,\n",
+       "        72.709076, 72.755257, 72.800056, 72.845276, 72.891571, 72.940613,\n",
+       "        72.989136, 73.03756 , 73.085976, 73.133919, 73.184357, 73.239563,\n",
+       "        73.298462, 73.351791, 73.40036 , 73.443741, 73.479309, 73.512535,\n",
+       "        73.542122, 73.563461, 73.578041, 73.588104, 73.59668 , 73.599716,\n",
+       "        73.591644, 73.579109, 73.567596, 73.556549, 73.547234, 73.535278,\n",
+       "        73.518623, 73.498734, 73.474823, 73.448517, 73.42231 , 73.400818,\n",
+       "        73.384865, 73.370827, 73.352066, 73.332474, 73.310844, 73.28376 ,\n",
+       "        73.254303, 73.226074, 73.203384, 73.179405, 73.155052, 73.134239,\n",
+       "        73.113853, 73.095963, 73.0802  , 73.069725, 73.064598, 73.060051,\n",
+       "        73.057564, 73.050385, 73.041206, 73.035812, 73.033134, 73.033218,\n",
+       "        73.038948, 73.05265 , 73.068436, 73.066216, 73.066376, 73.069817,\n",
+       "        73.078148, 73.090546, 73.104881, 73.12085 , 73.135757, 73.145302,\n",
+       "        73.150314, 73.15274 , 73.155785, 73.161964, 73.171371, 73.177795,\n",
+       "        73.179329, 73.18132 , 73.180275, 73.175278, 73.170174, 73.16745 ,\n",
+       "        73.169502, 73.172989, 73.175705, 73.179657, 73.182671, 73.190361,\n",
+       "        73.205826, 73.223282, 73.240524, 73.256233, 73.265732, 73.270065,\n",
+       "        73.275337, 73.281715, 73.283623, 73.276489, 73.26519 , 73.259506,\n",
+       "        73.255852, 73.247559, 73.234192, 73.218391, 73.202339, 73.183411,\n",
+       "        73.16436 , 73.145042, 73.128204, 73.115356, 73.102119, 73.087372,\n",
+       "        73.072617, 73.058693, 73.039726, 73.014366, 72.987938, 72.959625,\n",
+       "        72.932343, 72.91037 , 72.888687, 72.86348 , 72.834442, 72.802788,\n",
+       "        72.764336, 72.720009, 72.678314, 72.639435, 72.605957, 72.574989,\n",
+       "        72.543961, 72.516548, 72.490837, 72.468719, 72.450096, 72.42868 ,\n",
+       "        72.404549, 72.379013, 72.35273 , 72.325958, 72.298309, 72.271217,\n",
+       "        72.242546, 72.210075, 72.174759, 72.140167, 72.108452, 72.082115,\n",
+       "        72.062042, 72.04805 , 72.036232, 72.024086, 72.014038, 72.002159,\n",
+       "        71.986832, 71.971741, 71.958321, 71.943214, 71.927391, 71.910332,\n",
+       "        71.890114, 71.872551, 71.859871, 71.848396, 71.83654 , 71.827103,\n",
+       "        71.821228, 71.818398, 71.814537, 71.806572, 71.797684, 71.789268,\n",
+       "        71.782417, 71.776337, 71.769119, 71.759521, 71.749817, 71.742264,\n",
+       "        71.73333 , 71.721939, 71.710365, 71.696716, 71.679932, 71.66082 ,\n",
+       "        71.641258, 71.627014, 71.616791, 71.608589, 71.60006 , 71.593697,\n",
+       "        71.592972, 71.592796, 71.595276, 71.600937, 71.607063, 71.615837,\n",
+       "        71.624222, 71.631325, 71.638329, 71.644951, 71.651894, 71.661591,\n",
+       "        71.672127, 71.679031, 71.682396, 71.68631 , 71.689125, 71.688377,\n",
+       "        71.690132, 71.693573, 71.698212, 71.704414, 71.711975, 71.722801,\n",
+       "        71.733154, 71.740601, 71.744339, 71.744354, 71.740303, 71.730446,\n",
+       "        71.714615, 71.694984, 71.677048, 71.660164, 71.643257, 71.629486,\n",
+       "        71.620926, 71.614616, 71.606644, 71.600403, 71.597626, 71.595161,\n",
+       "        71.591988, 71.587189, 71.5774  , 71.565315, 71.552856, 71.533707,\n",
+       "        71.509979, 71.484985, 71.459068, 71.437492, 71.41832 , 71.398094,\n",
+       "        71.374481, 71.344093, 71.308945, 71.271645, 71.236137, 71.207085,\n",
+       "        71.185143, 71.165718, 71.146133, 71.128304, 71.113739, 71.10289 ,\n",
+       "        71.09433 , 71.082275, 71.066574, 71.052643, 71.041283, 71.032463,\n",
+       "        71.021011, 71.004578, 70.987511, 70.970116, 70.954445, 70.938995,\n",
+       "        70.922318, 70.906227, 70.890121, 70.877159, 70.869698, 70.867012,\n",
+       "        70.864899, 70.861404, 70.85688 , 70.851761, 70.845085, 70.836967,\n",
+       "        70.82708 , 70.817177, 70.805283, 70.788826, 70.772095, 70.759979,\n",
+       "        70.750229, 70.737724, 70.726898, 70.722206, 70.725525, 70.72924 ,\n",
+       "        70.724472, 70.71701 , 70.713737, 70.717628, 70.726006, 70.731476,\n",
+       "        70.734344, 70.742424, 70.757538, 70.776566, 70.795975, 70.81913 ,\n",
+       "        70.848457, 70.881866, 70.923088, 70.969322, 71.016487, 71.065842,\n",
+       "        71.116776, 71.16835 , 71.222618, 71.284721, 71.349457, 71.415474,\n",
+       "        71.488968, 71.567924, 71.652771, 71.740814, 71.830055, 71.915405,\n",
+       "        71.994713, 72.075661, 72.16423 , 72.256096, 72.346878, 72.440857,\n",
+       "        72.541153, 72.639793, 72.735703, 72.837151, 72.939575, 73.039963,\n",
+       "        73.137039, 73.229469, 73.315346, 73.39389 , 73.469292, 73.543419,\n",
+       "        76.776794, 76.848724, 76.916023, 76.979904, 77.035301, 77.085472,\n",
+       "        77.13913 , 77.196121, 77.251335, 77.302696, 77.349091, 77.388412,\n",
+       "        77.420036, 77.442818, 77.459656, 77.469917, 77.474205, 77.477249,\n",
+       "        77.481628, 77.484955, 77.482918, 77.474342, 77.459785, 77.441574,\n",
+       "        77.424164, 77.404755, 77.383392, 77.360069, 77.333237, 77.308929,\n",
+       "        77.282181, 77.253319, 77.224754, 77.190048, 77.150581, 77.106888,\n",
+       "        77.056549, 77.00351 , 76.951683, 76.895348, 76.834892, 76.774315,\n",
+       "        76.7136  , 76.652603, 76.588516, 76.516876, 71.288681, 71.276436,\n",
+       "        71.262131, 71.246063, 71.232086, 71.217392, 71.203018, 71.188972,\n",
+       "        71.179482, 71.178574, 71.179054, 71.177841, 71.180183, 71.187065,\n",
+       "        71.191338, 71.19455 , 71.201279, 71.208931, 71.219704, 71.230759,\n",
+       "        71.237526, 71.241974, 71.246872, 71.252243, 71.26162 , 71.27433 ,\n",
+       "        71.289032, 71.307602, 71.325981, 71.34301 , 71.362686, 71.388359,\n",
+       "        71.418282, 71.450172, 71.481674, 71.509483, 71.533768, 71.55159 ,\n",
+       "        71.566628, 71.586792, 71.609589, 71.63176 , 71.652046, 71.672714,\n",
+       "        71.699196, 71.729164, 71.757668, 71.786667, 71.81501 , 71.838326,\n",
+       "        71.858406, 71.875549, 71.889839, 71.903847, 71.916512, 71.927635,\n",
+       "        71.941376, 71.956787, 71.970009, 71.981438, 71.989929, 71.996948,\n",
+       "        72.002991, 72.006401, 72.006851, 72.008476, 72.012741, 72.02182 ,\n",
+       "        72.03302 , 72.037529, 72.037872, 72.035599, 72.032646, 72.031708,\n",
+       "        72.035141, 72.04557 , 72.060486, 72.081398, 72.106506, 72.130859,\n",
+       "        72.154442, 72.179398]),\n",
+       " array([73.599541, 73.696945, 73.801033, 73.908966, 74.016632, 74.125359,\n",
+       "        74.233025, 74.338791, 74.444206, 74.550095, 74.654648, 74.753563,\n",
+       "        74.852554, 74.950241, 75.039406, 75.122612, 75.207581, 75.294472,\n",
+       "        75.380173, 75.468842, 75.557426, 75.644547, 75.733383, 75.820427,\n",
+       "        75.905205, 75.991653, 76.077324, 76.158966, 76.238647, 76.317673,\n",
+       "        76.397224, 76.474998, 76.549072, 76.623146, 76.702721, 76.78582 ,\n",
+       "        76.868271, 76.945259, 77.013618, 77.079575, 77.14283 , 77.202019,\n",
+       "        77.256645, 77.308395, 77.362175, 77.416687, 70.17836 , 70.098335,\n",
+       "        70.025894, 69.959679, 69.895844, 69.834335, 69.778572, 69.72316 ,\n",
+       "        69.666435, 69.609177, 69.555153, 69.503212, 69.451965, 69.406456,\n",
+       "        69.364723, 69.331833, 69.305901, 69.279831, 69.254623, 69.231941,\n",
+       "        69.215347, 69.206955, 69.204849, 69.203575, 69.204803, 69.211891,\n",
+       "        69.222664, 69.239891, 69.257271, 69.27243 , 69.287453, 69.304176,\n",
+       "        69.330177, 69.364388, 69.405563, 69.449646, 71.364372, 71.400452,\n",
+       "        71.436218, 71.472816, 71.512398, 71.552307, 71.589493, 71.624123,\n",
+       "        71.65937 , 71.697594, 71.739609, 71.785355, 71.834419, 71.886116,\n",
+       "        71.935165, 71.977722, 72.018074, 72.062141, 72.111526, 72.162971,\n",
+       "        72.216057, 72.272575, 72.332062, 72.396233, 72.464226, 72.532249,\n",
+       "        72.599892, 72.663322, 72.717987, 72.770859, 72.822403, 72.86998 ,\n",
+       "        72.922554, 72.979317, 75.288261, 75.21244 , 75.136528, 75.062157,\n",
+       "        74.985497, 74.907585, 74.834969, 74.7705  , 74.710526, 74.645348,\n",
+       "        74.575974, 74.507767, 74.442429, 74.37719 , 74.312584, 74.250153,\n",
+       "        74.184006, 74.118195, 74.054398, 73.988289, 73.919777, 73.853958,\n",
+       "        73.787727, 73.713043, 73.635437, 73.560471, 73.48481 , 73.412735,\n",
+       "        73.342865, 73.272247, 73.203568, 73.133064, 73.063553, 73.000053,\n",
+       "        72.936417, 72.869614, 72.7995  , 72.729065, 72.663757, 72.600166,\n",
+       "        72.534828, 72.47084 , 72.409187, 72.3489  , 72.29335 , 72.237389,\n",
+       "        72.180893, 72.126892, 72.071754, 72.020576, 71.9711  , 71.91684 ,\n",
+       "        71.860023, 71.80394 , 71.7509  , 71.69825 , 71.647667, 71.600586,\n",
+       "        71.555191, 71.507698, 71.461998, 71.420143, 73.013504, 73.011337,\n",
+       "        73.008652, 73.008621, 73.011528, 73.010696, 73.008415, 73.007751,\n",
+       "        73.008507, 73.008209, 73.004829, 73.001007, 72.9944  , 72.982773,\n",
+       "        72.972221, 72.963844, 72.956963, 72.949593, 72.938087, 72.924797,\n",
+       "        72.911095, 72.895683, 72.878616, 72.858177, 72.836319, 72.811348,\n",
+       "        72.787148, 72.767334, 72.74913 , 72.734772, 72.723427, 72.713379,\n",
+       "        72.707222, 72.707924, 72.71299 , 72.716026, 72.720833, 72.730972,\n",
+       "        72.744682, 72.76136 , 72.775993, 72.792183, 72.811745, 72.833504,\n",
+       "        72.857689, 72.882751, 72.913193, 72.947304, 72.977524, 73.006241,\n",
+       "        76.277771, 76.197906, 76.120033, 76.042694, 75.966248, 75.890434,\n",
+       "        75.816536, 75.745827, 75.677361, 75.609077, 75.538368, 75.464867,\n",
+       "        75.386627, 75.303024, 75.217674, 75.131821, 75.049149, 74.970779,\n",
+       "        74.890144, 74.80545 , 74.71608 , 74.62632 , 74.53933 , 74.452477,\n",
+       "        74.365189, 74.275658, 74.188812, 74.10363 , 74.01828 , 73.935158,\n",
+       "        73.850159, 73.759995, 73.659721, 73.553207, 73.445084, 73.335915,\n",
+       "        73.228828, 73.12059 , 73.010422, 72.905411, 72.805092, 72.708748,\n",
+       "        72.612801, 72.517517, 72.425262, 72.334015, 72.245041, 72.153259,\n",
+       "        72.060936, 71.975166, 71.889748, 71.803391, 71.722382, 71.650002,\n",
+       "        71.585579, 71.526474, 71.471115, 71.414551, 71.359215, 71.31012 ,\n",
+       "        71.263374, 71.218002, 71.170418, 71.122864, 71.07943 , 71.036949,\n",
+       "        70.997307, 70.958916, 70.922409, 70.886414, 70.85154 , 70.82225 ,\n",
+       "        70.797462, 70.772888, 70.746796, 70.724388, 70.70768 , 70.691582,\n",
+       "        70.673454, 70.658279, 70.644882, 70.62648 , 70.606819, 70.594284,\n",
+       "        70.586845, 70.581154, 70.576141, 70.573425, 70.575401, 70.577911,\n",
+       "        70.582344, 70.59301 , 70.609428, 70.623848, 70.633728, 70.642998,\n",
+       "        70.654144, 70.661682, 70.663826, 70.664757, 70.665268, 70.670067,\n",
+       "        70.67585 , 70.681412, 70.689171, 70.702171, 70.72419 , 70.751556,\n",
+       "        70.780838, 70.81189 , 70.847069, 70.885658, 70.921913, 70.954071,\n",
+       "        70.983795, 73.084282, 73.100487, 73.116257, 73.132553, 73.151604,\n",
+       "        73.176018, 73.200058, 73.220955, 73.242645, 73.260872, 73.274948,\n",
+       "        73.293488, 73.314163, 73.328674, 73.340424, 73.355637, 73.374115,\n",
+       "        73.394928, 73.41861 , 73.441139, 73.463387, 73.48658 , 73.509857,\n",
+       "        73.53289 , 73.552155, 73.564713, 73.56929 , 73.574257, 73.580994,\n",
+       "        73.585732, 73.589073, 73.591621, 73.597504, 73.603943, 73.61441 ,\n",
+       "        73.62973 , 73.644653, 73.661301, 73.683609, 73.710213, 73.737068,\n",
+       "        73.760376, 73.781296, 73.803398, 73.82476 , 73.844063, 73.860512,\n",
+       "        73.87571 , 73.887482, 73.896538, 73.905983, 73.915016, 73.923302,\n",
+       "        73.929291, 73.933647, 73.940323, 73.949265, 73.961586, 73.97657 ,\n",
+       "        73.990379, 74.003265, 74.016014, 74.028008, 74.03862 , 74.043518,\n",
+       "        74.043983, 74.044647, 74.044693, 74.048195, 74.055656, 74.066475,\n",
+       "        74.080765, 74.096893, 74.471657, 74.398674, 74.329987, 74.26947 ,\n",
+       "        74.212921, 74.156631, 74.097481, 74.036781, 73.976738, 73.92437 ,\n",
+       "        73.880203, 73.84008 , 73.802269, 73.768425, 73.73378 , 73.699783,\n",
+       "        73.667191, 73.630623, 73.59523 , 73.565468, 73.537689, 73.505302,\n",
+       "        73.469818, 73.433098, 73.398598, 73.36953 , 73.343925, 73.31665 ,\n",
+       "        73.289902, 73.267517, 73.244942, 73.22184 , 73.200867, 73.185783,\n",
+       "        73.177879, 73.174683, 73.173317, 73.169777, 73.165047, 73.159302,\n",
+       "        73.150978, 73.137901, 73.122383, 73.112411, 73.108353, 73.10524 ,\n",
+       "        73.097176, 73.085632, 73.07811 , 73.075699, 73.07708 , 73.076645,\n",
+       "        73.072136, 73.068214, 73.617493, 73.692513, 73.769096, 73.844315,\n",
+       "        73.91835 , 73.991982, 74.064606, 74.136726, 74.208344, 74.280136,\n",
+       "        74.353172, 74.419975, 74.475197, 74.5289  , 74.584702, 74.642769,\n",
+       "        74.702385, 74.763008, 74.821877, 74.87606 , 74.923744, 74.967865,\n",
+       "        75.012856, 75.059822, 75.111626, 75.166756, 75.222885, 75.281738,\n",
+       "        75.339233, 75.392578, 75.444099, 75.490974, 75.534836, 75.573402,\n",
+       "        75.60701 , 75.640091, 75.670357, 75.697182, 75.723152, 75.74968 ,\n",
+       "        75.780731, 75.817535, 75.853882, 75.886993, 75.92131 , 75.954201,\n",
+       "        75.98436 , 76.015129, 76.04303 , 76.069435, 76.096405, 76.121841,\n",
+       "        75.261024, 75.206276, 75.147705, 75.086983, 75.027336, 74.969513,\n",
+       "        74.909622, 74.846519, 74.779984, 74.710655, 74.64109 , 74.571365,\n",
+       "        74.499092, 74.425667, 74.35067 , 74.273674, 74.197014, 74.123161,\n",
+       "        74.055908, 73.991821, 73.930519, 73.867958, 73.802238, 73.736641,\n",
+       "        73.665001, 73.58828 , 73.51223 , 73.437927, 73.365753, 73.295204,\n",
+       "        73.223969, 73.153214, 73.081245, 73.006989, 72.932869, 72.85672 ,\n",
+       "        72.783081, 72.713257, 72.645638, 72.579567, 72.513618, 72.448395,\n",
+       "        72.376808, 72.300781, 72.226181, 72.154358, 72.08522 , 72.014626,\n",
+       "        71.944832, 71.874901, 71.806076, 71.744629, 71.685341, 71.628464,\n",
+       "        71.580299, 71.534393, 71.49231 , 71.461823, 71.435493, 71.40509 ,\n",
+       "        71.378777, 71.357315, 71.333275, 71.310295, 71.294052, 71.281784,\n",
+       "        71.269463, 71.254829, 71.240166, 71.225937, 71.209236, 71.192932,\n",
+       "        71.179047, 71.164825, 71.148148, 71.130493, 71.112267, 71.093887,\n",
+       "        71.073364, 71.057976, 71.048645, 71.038895, 71.037735, 71.043762,\n",
+       "        71.052147, 71.065277, 71.078392, 71.087967, 71.098907, 71.112106,\n",
+       "        71.128616, 71.150467, 71.176598, 71.207237, 71.242355, 71.279327,\n",
+       "        71.313805, 71.346588, 71.379959, 71.416466, 71.451195, 71.484291,\n",
+       "        71.523094, 71.566963, 71.612564, 71.656319, 71.697586, 71.737053,\n",
+       "        71.777023, 71.817642, 71.857887, 71.903343, 71.955467, 72.010277,\n",
+       "        72.06945 , 72.131592, 72.192772, 72.253479, 72.317108, 72.381203,\n",
+       "        72.442055, 72.504311, 72.563103, 72.619011, 72.674721, 72.729622,\n",
+       "        72.788551, 72.847031, 72.905777, 72.970055, 73.036163, 73.100807,\n",
+       "        73.163673, 73.225075, 73.288994, 73.354073, 73.413979, 73.472694,\n",
+       "        73.531487, 73.583931, 73.629906, 73.675018, 73.726784, 73.782967,\n",
+       "        73.839607, 73.898941, 73.95932 , 74.021774, 74.085617, 74.144707,\n",
+       "        72.495522, 72.548607, 72.603477, 72.662788, 72.723373, 72.786362,\n",
+       "        72.852226, 72.914177, 72.969299, 73.023926, 73.078972, 73.132111,\n",
+       "        73.186127, 73.243561, 73.307495, 73.383392, 73.463776, 73.542885,\n",
+       "        73.624588, 73.706245, 73.788582, 73.875313, 73.962936, 74.049469,\n",
+       "        74.139549, 74.228638, 74.313255, 74.400444, 74.489845, 74.574287,\n",
+       "        74.657295, 74.742638, 74.829689, 74.917099, 75.000275, 75.079704,\n",
+       "        75.159218, 75.23909 , 75.319481, 75.400688, 75.483009, 75.569626,\n",
+       "        75.656181, 75.742134, 75.827263, 75.909286, 75.992851, 76.076904,\n",
+       "        76.160004, 76.243301, 76.322762, 76.3993  , 76.477066, 76.553268,\n",
+       "        76.628487, 76.702934, 76.441978, 76.367729, 76.289284, 76.211037,\n",
+       "        76.133934, 76.054604, 75.973839, 75.891327, 75.809418, 75.724586,\n",
+       "        75.635246, 75.548157, 75.461388, 75.37104 , 75.27903 , 75.187363,\n",
+       "        75.093575, 74.997681, 74.905556, 74.814873, 74.721855, 74.625259,\n",
+       "        74.52816 , 74.436256, 74.346191, 74.253265, 74.157745, 74.06559 ,\n",
+       "        73.97538 , 73.88649 , 73.801277, 73.721878, 73.64975 , 73.5793  ,\n",
+       "        73.507599, 73.4394  , 73.379486, 73.324837, 73.270073, 73.215973,\n",
+       "        73.169586, 73.130524, 73.091805, 74.834999, 74.752373, 74.670959,\n",
+       "        74.587494, 74.50309 , 74.421936, 74.340668, 74.252495, 74.162796,\n",
+       "        74.077942, 73.99514 , 73.911911, 73.829399, 73.750557, 73.676216,\n",
+       "        73.608429, 73.544289, 73.47998 , 73.422318, 73.370705, 73.323433,\n",
+       "        73.276939, 73.228149, 73.184578, 73.14341 , 73.098465, 73.051453,\n",
+       "        73.000511, 72.946411, 72.891373, 72.836777, 72.783592, 72.729134,\n",
+       "        72.672699, 72.61602 , 72.559151, 72.502739, 72.444633, 72.38028 ,\n",
+       "        72.313873, 72.251694, 72.193031, 72.135536, 72.078346, 72.019783,\n",
+       "        71.962479, 71.910187, 71.861664, 71.813965, 71.766228, 71.72113 ,\n",
+       "        71.680771, 71.641968, 71.604507, 71.569275, 71.536598, 71.507187,\n",
+       "        71.480621, 71.45533 , 71.430206, 71.408142, 71.386795, 71.362778,\n",
+       "        71.343178, 71.327522, 71.313225, 71.301582, 72.207161, 72.234856,\n",
+       "        72.263008, 72.29113 , 72.316551, 72.34108 , 72.364265, 72.387573,\n",
+       "        72.409439, 72.432365, 72.462196, 72.490593, 72.516815, 72.543732,\n",
+       "        72.571342, 72.604256, 72.642334, 72.684441, 72.726776, 72.770607,\n",
+       "        72.818161, 72.868492, 72.921722, 72.97657 , 73.03331 , 73.088646,\n",
+       "        73.140579, 73.190712, 73.242821, 73.298012, 73.356102, 73.417702,\n",
+       "        73.479843, 73.540863, 73.603195, 73.666504, 73.729347, 73.790665,\n",
+       "        73.849449, 73.911263, 73.98185 , 74.0541  , 74.123772, 74.193436,\n",
+       "        74.264107, 74.329109, 74.385818, 74.441887, 74.496826, 74.55394 ,\n",
+       "        74.61364 , 74.670074, 74.728584, 74.79071 , 74.853325, 74.916168,\n",
+       "        74.973236, 75.025543]),\n",
+       " array([77.469078, 77.517532, 77.565384, ..., 76.015663, 76.103523,\n",
+       "        76.194305]),\n",
+       " array([78.646698, 78.656952, 78.673691, ..., 78.868179, 78.826614,\n",
+       "        78.7826  ]),\n",
+       " array([78.622513, 78.624512, 78.625862, ..., 76.567497, 76.533806,\n",
+       "        76.499001]),\n",
+       " array([78.877754, 78.902565, 78.927483, ..., 83.651459, 83.651726,\n",
+       "        83.6539  ]),\n",
+       " array([81.663078, 81.738831, 81.815887, 81.891159, 81.966461, 82.042953,\n",
+       "        82.115326, 82.183731, 82.244629, 82.303497, 82.369186, 82.439987,\n",
+       "        82.513466, 82.589561, 82.667709, 82.748413, 82.82991 , 82.911407,\n",
+       "        82.996391, 83.081917, 83.168419, 83.262718, 83.362419, 83.462517,\n",
+       "        83.564384, 83.670288, 83.77877 , 83.889366, 83.999245, 84.106049,\n",
+       "        84.212051, 84.313713, 84.406364, 84.497696, 84.590607, 84.677574,\n",
+       "        84.757179, 84.831192, 84.903023, 84.977982, 85.050049, 85.114449,\n",
+       "        85.17849 , 85.239471, 85.297432, 85.355034, 85.415146, 85.481812,\n",
+       "        85.547417, 85.606064, 85.66246 , 85.720108, 85.777786, 85.830086,\n",
+       "        85.880486, 85.936157, 85.995132, 86.051361, 86.103073, 86.154213,\n",
+       "        86.205414, 86.257942, 86.314095, 86.370186, 86.423721, 86.474358,\n",
+       "        86.52124 , 86.564766, 86.608971, 86.657127, 86.708588, 86.76181 ,\n",
+       "        86.813736, 86.8638  , 86.912155, 86.959953, 87.006935, 87.049622,\n",
+       "        87.088768, 87.122528, 87.151077, 87.17939 , 87.207413, 87.236404,\n",
+       "        87.263588, 87.294197, 87.32933 , 87.357803, 87.380188, 87.401413,\n",
+       "        87.420883, 87.439636, 87.459373, 87.477631, 87.494781, 87.510178,\n",
+       "        87.520592, 87.522881, 87.517441, 87.508301, 87.500801, 87.498657,\n",
+       "        87.501907, 87.504639, 87.507263, 87.514206, 87.521339, 87.524948,\n",
+       "        87.524826, 87.521576, 87.513046, 87.497917, 87.480621, 87.462532,\n",
+       "        87.440117, 87.413956, 87.384659, 87.352814, 87.32164 , 87.293037,\n",
+       "        87.268929, 87.250153, 87.234932, 87.223297, 87.217224, 87.213272,\n",
+       "        87.207687, 87.205688, 87.207787, 87.208763, 87.206131, 86.05619 ,\n",
+       "        85.989944, 85.925598, 85.864113, 85.80645 , 85.750191, 85.691048,\n",
+       "        85.627968, 85.567299, 85.50856 , 85.451897, 85.399292, 85.344971,\n",
+       "        85.289871, 85.235809, 85.183769, 85.133522, 85.087067, 85.044548,\n",
+       "        85.006134, 84.968575, 84.933464, 84.907928, 84.889839, 84.875191,\n",
+       "        84.861397, 84.849274, 84.840851, 84.838287, 84.841812, 84.84758 ,\n",
+       "        84.85347 , 84.853745, 84.846863, 84.835747, 84.822281, 84.807266,\n",
+       "        84.789368, 84.771194, 84.754898, 86.424057, 86.488548, 86.555969,\n",
+       "        86.623787, 86.690109, 86.755157, 86.816582, 86.875244, 86.933975,\n",
+       "        86.994347, 87.056122, 87.119293, 87.182259, 87.244705, 87.308357,\n",
+       "        87.370834, 87.428535, 87.485886, 87.547569, 87.612907, 87.681641,\n",
+       "        87.748756, 87.811234, 87.867714, 87.920509, 87.974518, 88.033829,\n",
+       "        88.099648, 88.166901, 88.234383, 88.299973, 88.363403, 88.42308 ,\n",
+       "        88.475739, 88.524521, 88.573608, 88.62558 , 88.677834, 88.726761,\n",
+       "        88.774178, 88.821312, 88.867462, 88.910233, 88.950203, 88.989616,\n",
+       "        89.030258, 84.701187, 84.714409, 84.726173, 84.742233, 84.760635,\n",
+       "        84.781784, 84.806038, 84.833397, 84.862404, 84.889191, 84.917274,\n",
+       "        84.949524, 84.982513, 85.014763, 85.048615, 85.083992, 85.119164,\n",
+       "        85.152794, 85.189888, 85.23568 , 85.290047, 85.348312, 85.403358,\n",
+       "        85.456566, 85.50663 , 85.553215, 85.603607, 85.657692, 85.713867,\n",
+       "        85.771896, 85.830574, 85.889023, 85.952759, 86.019104, 86.082962,\n",
+       "        86.144737, 86.204773, 86.265274, 86.325462, 86.384247, 86.442055,\n",
+       "        86.499146, 86.550728, 86.596085, 86.640762, 86.687874, 86.73143 ,\n",
+       "        86.768394, 86.804878, 86.840286, 86.867851, 86.895164, 86.9235  ,\n",
+       "        86.949875, 81.519173, 81.559799, 81.6007  , 81.648804, 81.700951,\n",
+       "        81.744522, 81.785904, 81.827553, 81.865486, 81.899818, 81.932304,\n",
+       "        81.969215, 82.009155, 82.053001, 82.099846, 82.150604, 82.204819,\n",
+       "        82.253792, 82.296272, 82.332703, 82.369156, 82.40947 , 82.455658,\n",
+       "        82.50795 , 82.563461, 82.625839, 82.692276, 82.761902, 82.835686,\n",
+       "        82.908401, 82.978516, 83.0438  , 83.108307, 83.17775 , 83.253387,\n",
+       "        83.335289, 83.417725, 83.499687, 83.58551 , 83.672653, 83.759277,\n",
+       "        83.848236, 83.940628, 84.033485, 84.123146, 84.21183 , 84.299309,\n",
+       "        84.383812, 84.466003, 84.544518, 84.621185, 84.696404, 84.771378,\n",
+       "        84.847244, 84.922768, 84.998154, 85.078018, 85.164223, 85.251671,\n",
+       "        85.337875, 85.422729, 85.506752, 85.587456, 85.665894, 85.741074,\n",
+       "        85.814079, 85.889198, 85.966225, 86.041992, 86.112885, 86.185005,\n",
+       "        86.256653, 86.323807, 86.389992, 86.454765, 86.515472, 86.57193 ,\n",
+       "        86.628334, 86.685349, 86.747307, 86.816353, 86.883934, 86.948395,\n",
+       "        87.016335, 87.086876, 87.154243, 87.215263, 87.273384, 87.328781,\n",
+       "        87.380562, 87.428032, 87.46888 , 87.50576 , 87.536194, 87.563156,\n",
+       "        87.591736, 87.621498, 87.647018, 87.669113, 87.691849, 87.714622,\n",
+       "        87.73938 , 87.763832, 87.781853, 87.795517, 87.808472, 87.817261,\n",
+       "        87.821922, 87.825798, 87.827843, 87.827072, 87.82605 , 87.817017,\n",
+       "        87.797897, 87.778267, 87.75602 , 87.733894, 87.713814, 87.692978,\n",
+       "        87.669022, 87.641144, 87.615273, 87.591759, 87.571754, 87.553246,\n",
+       "        87.534012, 87.513496, 87.489525, 87.464088, 87.434288, 87.402702,\n",
+       "        87.375076, 87.346458, 87.315758, 87.287506, 87.261124, 87.237427,\n",
+       "        87.215515, 87.192253, 87.170654, 87.150795, 87.129341, 87.108368,\n",
+       "        87.089294, 87.069145, 87.046143, 87.022835, 87.001053, 86.979561,\n",
+       "        87.353111, 87.294731, 87.237457, 87.180634, 87.122559, 87.062897,\n",
+       "        87.001396, 86.940208, 86.879135, 86.814545, 86.747757, 86.674873,\n",
+       "        86.593468, 86.506363, 86.413628, 86.319603, 86.228111, 86.139847,\n",
+       "        86.049782, 85.956886, 85.864105, 85.771477, 85.678696, 85.585999,\n",
+       "        85.492836, 85.399055, 85.307991, 85.217804, 85.129921, 85.051163,\n",
+       "        84.980133, 84.914917, 84.854401, 84.787544, 84.715942, 84.648247,\n",
+       "        84.580246, 84.508347, 84.434875, 84.361443, 84.28614 , 84.213142,\n",
+       "        84.144348, 84.076637, 84.011032, 83.949959, 83.89389 , 83.838493,\n",
+       "        83.780167, 83.721336, 83.664047, 83.609123, 83.553925, 83.497612,\n",
+       "        83.441811, 83.390388, 83.345909, 83.304672, 83.265182, 83.225311,\n",
+       "        83.188408, 83.156219, 83.12471 , 83.09774 , 83.076279, 83.056396,\n",
+       "        83.040581, 83.025856, 83.009865, 82.992752, 82.975586, 82.955246,\n",
+       "        82.935707, 82.924774, 82.916405, 82.906769, 82.897713, 82.889648,\n",
+       "        82.875633, 82.858765, 82.844879, 82.826569, 82.803696, 82.779099,\n",
+       "        82.753418, 82.724342, 82.688408, 82.645416, 82.600708, 82.555161,\n",
+       "        82.505768, 82.457832, 82.41201 , 82.36882 , 82.327805, 82.290398,\n",
+       "        82.256729, 82.224358, 82.190903, 82.157906, 82.128036, 82.098709,\n",
+       "        82.070091, 82.043015, 82.018402, 81.991386, 81.960861, 81.93248 ,\n",
+       "        81.906189, 86.450951, 86.501251, 86.554489, 86.608002, 86.659035,\n",
+       "        86.705559, 86.746223, 86.778038, 86.803062, 86.827042, 86.850761,\n",
+       "        86.872597, 86.892509, 86.912086, 86.930473, 86.944115, 86.957321,\n",
+       "        86.973297, 86.99099 , 87.010201, 87.028168, 87.043587, 87.053505,\n",
+       "        87.057999, 87.060608, 87.061325, 87.062408, 87.063675, 87.066772,\n",
+       "        87.073936, 87.086365, 87.104424, 87.120384, 87.128181, 87.133408,\n",
+       "        87.1418  , 85.614189, 85.591728, 85.572525, 85.560242, 85.551567,\n",
+       "        85.544212, 85.535355, 85.526566, 85.520706, 85.513557, 85.50515 ,\n",
+       "        85.495987, 85.482178, 85.472527, 85.470444, 85.466217, 85.460495,\n",
+       "        85.454285, 85.440811, 85.42157 , 85.406013, 85.392357, 85.375626,\n",
+       "        85.358643, 85.347343, 85.345726, 85.350906, 85.355576, 85.355331,\n",
+       "        85.354149, 85.355614, 85.357597, 85.357681, 85.353699, 85.344391,\n",
+       "        85.330872, 85.313751, 85.293671, 85.27272 , 85.256508, 85.24836 ,\n",
+       "        85.241325, 85.230324, 85.217018, 85.198044, 85.175606, 85.157509,\n",
+       "        85.141487, 85.125198, 85.111107, 85.099197, 85.090721, 85.086578,\n",
+       "        85.080643, 85.074364, 85.067863, 85.062225, 85.059975, 85.0597  ,\n",
+       "        86.050308, 86.088867, 86.132545, 86.175072, 86.212402, 86.246277,\n",
+       "        86.277115, 86.304428, 86.332947, 86.361412, 86.383743, 86.399139,\n",
+       "        86.406708, 86.409821, 86.409782, 86.407341, 86.401352, 86.393433,\n",
+       "        86.390053, 86.39061 , 86.391121, 86.38681 , 86.377083, 86.367477,\n",
+       "        86.359314, 86.354599, 86.353554, 86.352798, 86.348877, 86.339645,\n",
+       "        86.325417, 86.308975, 86.296059, 84.300575, 84.242531, 84.191803,\n",
+       "        84.149765, 84.116318, 84.082306, 84.042953, 83.999229, 83.955681,\n",
+       "        83.916504, 83.88269 , 83.851631, 83.820396, 83.793549, 83.772736,\n",
+       "        83.757782, 83.744186, 83.726906, 83.70813 , 83.690132, 83.674683,\n",
+       "        83.664223, 83.655006, 83.645119, 83.633423, 83.617851, 83.600784,\n",
+       "        83.583801, 83.565796, 83.543396, 83.519348, 83.497665, 83.479141,\n",
+       "        83.461044, 83.443138, 83.429062, 83.417572, 83.402985, 83.384033,\n",
+       "        83.364975, 83.344749, 83.324631, 83.30777 , 83.292999, 83.275864,\n",
+       "        83.255302, 83.230858, 83.203789, 83.17453 , 83.141586, 83.112358,\n",
+       "        83.088905, 83.067993, 83.048874]),\n",
+       " array([87.203186, 87.203674, 87.20459 , ..., 84.486061, 84.422035,\n",
+       "        84.361588]),\n",
+       " array([85.881142, 85.88459 , 85.892921, 85.90712 , 85.924515, 85.94294 ,\n",
+       "        85.959503, 85.974861, 85.98745 , 85.997955, 86.010406, 86.020599,\n",
+       "        86.024788, 86.030472, 86.038902, 86.048012, 86.062248, 86.081474,\n",
+       "        86.102448, 86.122208, 86.143944, 86.170792, 86.203171, 86.239029,\n",
+       "        86.272346, 86.30265 , 86.332199, 86.363617, 86.395691, 86.427322,\n",
+       "        86.463646, 86.503372, 86.54187 , 86.574623, 86.604568, 86.638664,\n",
+       "        86.673889, 86.703392, 86.727577, 93.861031, 93.789017, 93.714066,\n",
+       "        93.643623, 93.577873, 93.507645, 93.435791, 93.363297, 93.287796,\n",
+       "        93.209633, 93.132469, 93.051521, 92.96022 , 92.862175, 92.760056,\n",
+       "        92.654366, 92.541946, 92.4217  , 92.299774, 92.180473, 92.06144 ,\n",
+       "        91.938377, 91.814827, 91.695869, 91.579506, 91.465897, 91.356827,\n",
+       "        91.250534, 91.141541, 91.027679, 90.908997, 91.144394, 91.123451,\n",
+       "        91.096489, 91.062485, 91.028   , 90.99543 , 90.96492 , 90.935242,\n",
+       "        90.900017, 90.860741, 90.82225 , 90.785835, 90.750214, 90.711113,\n",
+       "        90.665901, 90.615028, 90.560852, 90.504242, 90.44278 , 90.377892,\n",
+       "        90.311081, 90.249199, 90.194077, 90.139343, 90.079712, 90.014008,\n",
+       "        89.947197, 89.878601, 89.810463, 89.745628, 89.684258, 89.62484 ,\n",
+       "        89.566383, 92.318947, 92.286552, 92.25219 , 92.220497, 92.192696,\n",
+       "        92.165817, 92.138741, 92.111443, 92.082878, 92.054367, 92.027222,\n",
+       "        91.996933, 91.964706, 91.934944, 91.905228, 91.873352, 91.844307,\n",
+       "        91.816811, 91.789742, 91.765343, 91.74189 , 91.716171, 91.688622,\n",
+       "        91.662621, 91.636269, 91.604248, 91.568275, 91.534744, 91.500755,\n",
+       "        91.462486, 91.420898, 91.37513 , 91.326813, 91.277298, 91.220337,\n",
+       "        91.160301, 91.102501, 91.043625, 90.982437, 90.918037, 90.8498  ,\n",
+       "        90.778618, 90.705948, 90.630585, 90.551682, 90.469971, 90.389549,\n",
+       "        90.314949, 90.247597, 90.183578, 90.115959, 90.042236, 89.966606,\n",
+       "        89.891434, 89.816238, 89.744629, 89.680077, 89.615784, 89.549942,\n",
+       "        89.488441, 89.428223, 89.367424, 89.30864 , 89.251701, 89.197746,\n",
+       "        89.146683, 89.098869, 89.052605, 89.002853, 88.955391, 88.912964,\n",
+       "        88.874161, 88.838234, 88.803665, 88.771614, 88.741692, 88.712395,\n",
+       "        88.68248 , 88.651039, 88.619934, 88.59304 , 88.565498, 88.536629,\n",
+       "        88.508797, 88.481918, 88.45343 , 90.313591, 90.354065, 90.39418 ,\n",
+       "        90.434227, 90.480522, 90.531906, 90.586533, 90.646118, 90.707748,\n",
+       "        90.767632, 90.824471, 90.877266, 90.930916, 90.98349 , 91.02951 ,\n",
+       "        91.068855, 91.104485, 91.138519, 91.171791, 91.206955, 91.238541,\n",
+       "        91.265327, 91.291908, 91.320496, 91.348198, 91.372833, 91.402901,\n",
+       "        91.438728, 91.475143, 90.088593, 90.069389, 90.050148, 90.033234,\n",
+       "        90.016548, 90.001572, 89.987198, 89.969589, 89.952042, 89.937103,\n",
+       "        89.92395 , 89.915047, 89.912193, 89.912766, 89.914742, 89.919319,\n",
+       "        89.929016, 89.939667, 89.956566, 89.983582, 90.012825, 90.040863,\n",
+       "        90.067085, 90.094864, 90.12355 , 90.148849, 90.170609, 90.190048,\n",
+       "        90.209877, 90.22702 , 90.239899, 90.254692, 90.273743, 90.291512,\n",
+       "        90.303444, 90.313583, 90.325874, 90.34156 , 90.360641, 90.383598,\n",
+       "        90.407661, 90.426254, 88.158813, 88.189148, 88.221748, 88.257126,\n",
+       "        88.297218, 88.337814, 88.376862, 88.41288 , 88.447342, 88.48053 ,\n",
+       "        88.51059 , 88.540932, 88.571297, 88.599159, 88.62571 , 88.655869,\n",
+       "        88.691429, 88.730423, 88.768234, 88.801712, 88.833008, 88.863983,\n",
+       "        88.896667, 88.933197, 88.975372, 89.022659, 89.070137, 89.112717,\n",
+       "        89.154228, 89.197159, 89.23922 , 89.277489, 89.312965, 89.349869,\n",
+       "        90.662064, 90.628532, 90.598267, 90.570496, 90.54528 , 90.521049,\n",
+       "        90.495819, 90.471382, 90.442802, 90.420662, 90.410378, 90.40712 ,\n",
+       "        90.404022, 90.399025, 90.392036, 90.380455, 90.367691, 90.353081,\n",
+       "        90.340179, 90.332375, 90.324234, 90.312431, 90.303963, 90.300323,\n",
+       "        90.294113, 90.28611 , 90.286804, 90.297958, 90.312462, 90.32753 ,\n",
+       "        90.34481 , 90.366165, 88.909698, 88.915672, 88.923904, 88.934082,\n",
+       "        88.944397, 88.953468, 88.965439, 88.977539, 88.987801, 89.001854,\n",
+       "        89.022224, 89.041771, 89.062309, 89.088943, 89.120117, 89.151001,\n",
+       "        89.178658, 89.204582, 89.22821 , 89.248787, 89.265038, 89.275032,\n",
+       "        89.281746, 89.291763, 89.304161, 89.32103 , 89.343376, 89.368576,\n",
+       "        89.393501, 89.411835, 89.428772, 89.449387, 89.471115, 89.496666,\n",
+       "        89.52771 , 89.560852, 89.595345, 89.630692, 89.66716 , 89.700638,\n",
+       "        89.728737, 89.75441 , 89.782051, 89.814369, 89.850555, 89.888329,\n",
+       "        89.924515, 89.956261, 89.986954, 90.018585, 90.050766, 90.084923,\n",
+       "        90.119408, 90.155258, 90.192207, 90.227928, 90.259285, 90.284317,\n",
+       "        90.301849, 90.315681, 90.331169, 90.347946, 90.365425, 90.386024,\n",
+       "        90.409607, 90.432449, 90.449844, 90.46611 , 90.488228, 90.513145,\n",
+       "        90.54052 , 90.572372, 90.608841, 90.644234, 90.677139, 90.705566,\n",
+       "        90.729004, 90.754105, 90.779205, 90.802666, 90.824257, 90.843613,\n",
+       "        90.859482, 90.876007, 90.900131, 90.929436, 90.960922, 90.992775,\n",
+       "        91.019165, 91.038399, 91.057243, 91.081589, 91.107521, 91.130188,\n",
+       "        91.152832, 91.174057, 91.193367, 91.213951, 91.231392, 91.246811,\n",
+       "        91.265846, 91.286827, 91.309265, 91.332405, 91.348717, 91.362755,\n",
+       "        91.379921, 91.395943, 91.414352, 91.435028, 91.457489, 91.483177,\n",
+       "        91.509766, 91.538872, 91.567963, 91.593567, 91.616005, 91.638466,\n",
+       "        91.659554, 91.676331, 91.693893, 91.715858, 91.739944, 91.768044,\n",
+       "        91.797554, 91.820045, 91.834572, 91.84684 , 91.86055 , 91.874672,\n",
+       "        91.893036, 91.917801, 91.944405, 91.968346, 91.990143, 92.005737,\n",
+       "        92.012482, 92.017296, 92.02018 , 92.02272 , 92.028671, 92.03569 ,\n",
+       "        92.037437, 92.033897, 92.027321, 92.01593 , 91.999367, 91.976288,\n",
+       "        91.949684, 91.918945, 91.884995, 91.854202, 91.827934, 91.804611,\n",
+       "        91.785057, 91.767677, 91.752708, 91.735588, 91.713844, 91.69342 ,\n",
+       "        91.678345, 91.670631, 91.663124, 91.651756, 91.636879, 91.619278,\n",
+       "        91.602272, 91.588242, 91.573235, 91.557602, 91.547798, 91.543839,\n",
+       "        91.543785, 91.543419, 91.541016, 91.534706, 91.525238, 91.513031,\n",
+       "        91.496239, 94.202469, 94.156708, 94.107773, 94.052567, 93.993523,\n",
+       "        93.936028, 93.880547, 93.818535, 93.75399 , 93.692139, 93.626869,\n",
+       "        93.555412, 93.47773 , 93.400146, 93.323814, 93.248337, 93.169022,\n",
+       "        93.082527, 92.992386, 92.90049 , 92.808205, 92.718277, 92.631439,\n",
+       "        92.545509, 92.460297, 92.376823, 92.299019, 92.226463, 92.155777,\n",
+       "        92.083618, 92.008888, 91.929825, 91.847771, 91.76619 , 91.682343,\n",
+       "        91.599915, 91.521461, 91.447044, 91.378891, 91.311798, 91.243973,\n",
+       "        91.177025, 91.114151, 91.052292, 90.984657, 90.915787, 90.845665,\n",
+       "        90.770134, 90.687752, 90.597885, 86.991005, 87.00666 , 87.030304,\n",
+       "        87.061462, 87.094315, 87.125992, 87.157654, 87.190659, 87.224266,\n",
+       "        87.259216, 87.288956, 87.312439, 87.337784, 87.365051, 87.391518,\n",
+       "        87.419487, 87.448402, 87.478996, 87.510574, 87.5439  , 87.581734,\n",
+       "        87.623718, 87.670776, 87.720558, 87.77533 , 87.835854, 87.90062 ,\n",
+       "        87.967911, 88.034821, 88.100266, 88.167183, 88.240608, 88.321533,\n",
+       "        88.410187, 88.504448, 88.604988, 88.71405 , 88.832062, 88.955048,\n",
+       "        89.076385, 89.1978  , 89.317421, 89.435074, 90.346153, 90.381325,\n",
+       "        90.417297, 90.453201, 90.48848 , 90.525887, 90.562607, 90.597   ,\n",
+       "        90.637001, 90.679962, 90.723312, 90.765968, 90.805481, 90.842438,\n",
+       "        90.874054, 90.901588, 90.929893, 90.960442, 90.992737, 91.026604,\n",
+       "        91.059586, 91.087242, 91.110367, 91.131798, 91.154251, 91.179428,\n",
+       "        91.206268, 91.232895, 91.258003, 91.281395, 91.300606, 91.317757,\n",
+       "        91.336327, 91.349808, 91.356461, 86.703003, 86.727493, 86.751617,\n",
+       "        86.778351, 86.811012, 86.844864, 86.878067, 86.916939, 86.965843,\n",
+       "        87.021881, 87.083046, 87.150719, 87.225334, 87.304253, 87.382317,\n",
+       "        87.452698, 87.518059, 87.58699 , 87.662582, 87.73922 , 87.814407,\n",
+       "        87.891144, 87.968849, 88.046242, 88.126236, 88.206131, 88.281746,\n",
+       "        88.357239, 88.435883, 88.519272, 88.607719, 88.697296, 88.783363,\n",
+       "        88.864471, 88.942345, 89.021141, 89.104111, 91.605553, 91.528648,\n",
+       "        91.451569, 91.372681, 91.290489, 91.205452, 91.125526, 91.050552,\n",
+       "        90.973991, 90.899002, 90.829201, 90.762329, 90.695534, 90.628136,\n",
+       "        90.559296, 90.49218 , 90.423889, 90.355537, 90.291733, 90.230431,\n",
+       "        90.16507 , 90.095581, 90.027512, 89.959862, 89.896675, 89.839745,\n",
+       "        89.784668, 89.727425, 89.669853, 89.612045, 89.550789, 89.485031,\n",
+       "        89.418297, 89.353386, 89.287903, 89.221954, 89.156021, 89.087692,\n",
+       "        89.014076, 88.934738, 88.854691, 88.776955]),\n",
+       " array([86.753708, 86.784157, 86.81884 , 86.850571, 86.882538, 86.923744,\n",
+       "        86.967537, 87.013527, 87.063934, 87.119804, 87.178925, 87.240219,\n",
+       "        87.308342, 87.379227, 87.448647, 87.523239, 87.603348, 87.688515,\n",
+       "        87.780434, 87.876366, 87.980743, 88.093994, 88.211632, 88.329277,\n",
+       "        88.442963, 88.554688, 88.669991, 88.791245, 88.912491, 89.028358,\n",
+       "        89.142143, 89.255524, 89.370018, 89.486473, 89.603615, 89.723579,\n",
+       "        89.84687 , 89.97123 , 90.090958, 90.205376, 90.321526, 95.128555,\n",
+       "        95.098412, 95.062546, 95.020729, 94.974884, 94.925758, 94.87706 ,\n",
+       "        94.831825, 94.789551, 94.747223, 94.702866, 94.660484, 94.621803,\n",
+       "        94.583084, 94.546036, 94.509636, 94.469994, 94.426743, 94.380272,\n",
+       "        94.333466, 94.286049, 94.240891, 94.198822, 94.155365, 94.107315,\n",
+       "        94.052948, 93.992294, 93.928421, 89.510536, 89.457512, 89.407722,\n",
+       "        89.358009, 89.304794, 89.251373, 89.200546, 89.14843 , 89.093811,\n",
+       "        89.034004, 88.973557, 88.915047, 88.86161 , 88.812424, 88.765877,\n",
+       "        88.726723, 88.688965, 88.650398, 88.616394, 88.590675, 88.568764,\n",
+       "        88.5494  , 88.533897, 88.521835, 88.512016, 88.505669, 88.505554,\n",
+       "        88.510757, 88.516251, 93.470299, 93.440521, 93.408089, 93.377846,\n",
+       "        93.353241, 93.331657, 93.312065, 93.293739, 93.280159, 93.27327 ,\n",
+       "        93.268845, 93.262062, 93.255501, 93.248734, 93.234703, 93.214867,\n",
+       "        93.193741, 93.171394, 93.148537, 93.122269, 93.093948, 93.067139,\n",
+       "        93.038849, 93.007912, 92.979164, 92.955368, 92.932381, 92.910736,\n",
+       "        92.891609, 92.870705, 92.847527, 92.830421, 92.821327, 92.809288,\n",
+       "        92.792648, 92.777084, 92.765465, 92.755516, 92.742058, 92.726158,\n",
+       "        92.709862, 92.691574, 92.668266, 92.641174, 92.610939, 92.581009,\n",
+       "        92.55748 , 92.537468, 92.518745, 92.50119 , 92.479485, 92.453743,\n",
+       "        92.430061, 92.406868, 92.378281, 92.348465, 91.515388, 91.557938,\n",
+       "        91.598801, 91.635918, 91.673798, 91.714859, 91.754707, 91.795189,\n",
+       "        91.83712 , 91.878357, 91.918945, 91.960869, 92.004753, 92.045853,\n",
+       "        92.084137, 92.122894, 92.161537, 92.202141, 92.246429, 92.288467,\n",
+       "        92.328873, 92.373787, 92.422035, 92.472054, 92.522568, 92.57103 ,\n",
+       "        91.64727 , 91.66478 , 91.686584, 91.708359, 91.732834, 91.761452,\n",
+       "        91.78933 , 91.817215, 91.84845 , 91.883118, 91.920967, 91.959   ,\n",
+       "        91.995453, 92.029457, 92.062279, 92.100037, 92.142296, 92.187408,\n",
+       "        92.231934, 92.274834, 92.3246  , 92.376625, 92.421669, 92.462784,\n",
+       "        92.506126, 92.55175 , 92.595894, 92.639046, 92.684685, 92.735474,\n",
+       "        92.787651, 92.8414  , 92.900986, 92.965202, 93.031731, 93.099602,\n",
+       "        93.166733, 93.2304  , 93.292198, 93.355263, 93.420319, 93.488884,\n",
+       "        93.557449, 93.626282, 93.701103, 93.77816 , 93.853508, 93.927185,\n",
+       "        94.001251, 94.079796, 94.16143 , 94.242142, 94.321167, 94.398567,\n",
+       "        94.474991, 94.549004, 94.621613, 94.693771, 94.766357, 94.841179,\n",
+       "        94.913727, 94.9823  , 95.049492, 95.120575, 95.19593 , 95.274025,\n",
+       "        95.356712, 95.440628, 95.523026, 95.60524 , 95.685509, 95.761772,\n",
+       "        95.8349  , 95.905731, 95.973717, 96.036987, 96.095978, 96.153297,\n",
+       "        96.209633, 96.263046, 96.311104, 96.353065, 96.394577, 96.435829,\n",
+       "        96.471115, 96.50296 , 96.533211, 96.559822, 96.578278, 96.58699 ,\n",
+       "        96.590576, 96.587692, 96.577171, 96.560272, 96.538528, 96.514656,\n",
+       "        96.492668, 96.471077, 96.443214, 96.411034, 96.37812 , 96.339455,\n",
+       "        96.296013, 96.249023, 96.19754 , 96.143311, 96.086174, 96.026138,\n",
+       "        95.962212, 95.898872, 95.838753, 95.779396, 95.718079, 95.659576,\n",
+       "        95.601845, 95.539291, 95.476517, 95.41394 , 95.348297, 95.279816,\n",
+       "        95.207741, 95.134178, 95.064171, 95.00061 , 94.937195, 94.86985 ,\n",
+       "        94.80468 , 94.743362, 94.681732, 94.616028, 94.550293, 94.488884,\n",
+       "        95.436897, 95.459679, 95.479279, 95.495056, 95.508713, 95.524765,\n",
+       "        95.543472, 95.560455, 95.57119 , 95.576584, 95.580467, 95.581367,\n",
+       "        95.57933 , 95.571434, 95.5625  , 95.558922, 95.553291, 95.537605,\n",
+       "        95.514694, 95.488319, 95.460754, 95.431374, 95.396576, 95.355873,\n",
+       "        95.310089, 95.264702, 95.223076, 95.182175, 95.140106, 95.093956,\n",
+       "        95.043365, 94.990623, 94.9375  , 94.884155, 94.82885 , 94.771965,\n",
+       "        94.709991, 94.643539, 94.576767, 94.508987, 94.437767, 94.36174 ,\n",
+       "        94.280548, 94.194977, 94.109238, 94.024834, 93.943665, 93.863152,\n",
+       "        93.773804, 93.679283, 93.586021, 93.486748, 93.384575, 93.283493,\n",
+       "        93.180664, 93.078918, 92.976273, 92.869217, 92.764778, 92.665413,\n",
+       "        92.560234, 92.448349, 92.336372, 92.227997, 92.125366, 92.027382,\n",
+       "        91.93161 , 91.838524, 91.749756, 91.670067, 91.598221, 91.526016,\n",
+       "        91.451324, 91.376305, 91.305115, 91.240211, 91.179611, 91.119392,\n",
+       "        91.061905, 91.011681, 90.963043, 90.90947 , 90.853973, 90.80056 ,\n",
+       "        90.750076, 90.699219, 90.647179, 90.596931, 90.550079, 90.504662,\n",
+       "        90.45829 , 90.413536, 90.373375, 90.341499, 90.314865, 90.28656 ,\n",
+       "        90.257584, 90.23333 , 90.213066, 90.192833, 90.17395 , 90.159485,\n",
+       "        90.148544, 90.141678, 90.134987, 90.122429, 90.10627 , 89.38929 ,\n",
+       "        89.429741, 89.472931, 89.519379, 89.568222, 89.620422, 89.67778 ,\n",
+       "        89.74086 , 89.807106, 89.873299, 89.937614, 90.002609, 90.066963,\n",
+       "        90.129082, 90.192627, 90.258881, 90.325653, 90.391731, 90.459419,\n",
+       "        90.527962, 90.591202, 90.650909, 90.713409, 90.784515, 90.862099,\n",
+       "        90.940483, 91.021988, 91.106506, 91.189392, 91.271576, 91.356232,\n",
+       "        91.439545, 91.52037 , 91.601013, 91.68222 , 91.765648, 91.848495,\n",
+       "        91.931458, 92.017883, 92.107338, 92.29789 , 92.254288, 92.216019,\n",
+       "        92.185837, 92.162018, 92.139656, 92.114525, 92.087883, 92.060654,\n",
+       "        92.031128, 91.997162, 91.960831, 91.927582, 91.891533, 91.847542,\n",
+       "        91.802216, 91.755493, 91.707733, 91.665649, 91.625526, 91.586571,\n",
+       "        91.549324, 91.511383, 91.473297, 91.434464, 91.396317, 91.356567,\n",
+       "        91.314217, 91.272224, 91.232376, 91.187935, 91.139694, 91.096581,\n",
+       "        91.056465, 91.019447, 90.987297, 90.959404, 90.934654, 90.914108,\n",
+       "        90.894806, 90.877007, 90.861343, 90.842598, 90.82106 , 90.799934,\n",
+       "        90.776253, 90.750343, 90.722755, 90.692795, 91.478546, 91.460762,\n",
+       "        91.444466, 91.42981 , 91.411499, 91.386093, 91.355057, 91.321938,\n",
+       "        91.290436, 91.257133, 91.222336, 91.191635, 91.162651, 91.13414 ,\n",
+       "        91.103554, 91.071198, 91.039421, 91.006882, 90.978035, 90.952553,\n",
+       "        90.925858, 90.902634, 90.884407, 90.866158, 90.846161, 90.827034,\n",
+       "        90.812859, 90.806328, 90.80513 , 90.803528, 90.802109, 90.801392,\n",
+       "        90.796783, 90.78846 , 90.777122, 90.76545 , 90.757339, 90.754593,\n",
+       "        90.756302, 90.763153, 90.776726, 90.791748, 90.806   , 90.820892,\n",
+       "        90.840256, 90.864319, 90.889275, 90.914215, 90.939468, 90.96463 ,\n",
+       "        90.990372, 91.015976, 91.038322, 91.059532, 91.084389, 91.116852,\n",
+       "        91.152298, 91.188782, 91.229202, 91.270622, 91.314857, 91.360985,\n",
+       "        91.402954, 91.446709, 91.496521, 91.542747, 91.583656, 91.623703,\n",
+       "        91.663872, 91.705414, 91.748169, 91.789482, 91.826736, 91.864464,\n",
+       "        91.906868, 91.951134, 91.994705, 92.034012, 92.067719, 92.097725,\n",
+       "        92.127472, 92.161575, 92.198318, 92.234657, 92.270706, 92.306915,\n",
+       "        92.342522, 92.379204, 92.416237, 92.447823, 92.475372, 92.502266,\n",
+       "        92.530441, 92.561073, 92.592896, 92.623932, 92.653206, 92.681496,\n",
+       "        92.704636, 92.724426, 92.743484, 92.762199, 92.782616, 92.803337,\n",
+       "        92.826859, 92.85891 , 92.89994 , 92.946365, 92.994736, 93.041512,\n",
+       "        93.086266, 93.130302, 93.174545, 93.220329, 93.26963 , 93.322037,\n",
+       "        93.377884, 93.437981, 93.50029 , 95.118324, 95.104553, 95.088882,\n",
+       "        95.072319, 95.053528, 95.034027, 95.016495, 94.999962, 94.986893,\n",
+       "        94.98082 , 94.980164, 94.981056, 94.979828, 94.975891, 94.968262,\n",
+       "        94.958244, 94.945702, 94.930328, 94.916069, 94.89978 , 94.87735 ,\n",
+       "        94.849083, 94.814438, 94.777855, 94.741699, 94.701813, 94.658661,\n",
+       "        94.614029, 94.564713, 94.507881, 94.449783, 94.394669, 94.34169 ,\n",
+       "        94.293381, 94.247955, 89.556427, 89.676582, 89.794144, 89.911446,\n",
+       "        90.025902, 90.137268, 90.249992, 90.369064, 90.492287, 90.615585,\n",
+       "        90.73851 , 90.860695, 90.98056 , 91.098511, 91.221291, 91.348595,\n",
+       "        91.476067, 91.606438, 91.740303, 91.874863, 92.009888, 92.149231,\n",
+       "        92.291161, 92.433182, 92.574898, 92.7192  , 92.86451 , 93.007378,\n",
+       "        93.150078, 93.293503, 93.434448, 93.572731, 93.707565, 93.839447,\n",
+       "        93.97068 , 94.100258, 94.231094, 94.368263, 94.508598, 94.644798,\n",
+       "        94.782028, 94.921875, 95.061768, 95.202248, 95.342621, 95.481743,\n",
+       "        95.614128, 95.738274, 95.855736, 95.969833, 96.085236, 89.575676,\n",
+       "        89.537666, 89.50222 , 89.465996, 89.431099, 89.402756, 89.385246,\n",
+       "        89.373688, 89.365456, 89.363533, 89.366089, 89.370956, 89.381111,\n",
+       "        89.394684, 89.40873 , 89.427467, 89.448006, 89.473061, 89.508217,\n",
+       "        89.549095, 89.59346 , 89.643204, 89.696548, 89.747566, 89.794731,\n",
+       "        89.840866, 89.886688, 89.932678, 89.9786  , 90.024529, 90.06559 ,\n",
+       "        90.101616, 90.133804, 90.165016, 90.197998, 90.23185 , 90.270714,\n",
+       "        90.310432, 89.189804, 89.277199, 89.369499, 89.462524, 89.554031,\n",
+       "        89.647461, 89.741699, 89.83744 , 89.9347  , 90.031006, 90.128044,\n",
+       "        90.228302, 90.333328, 90.442307, 90.554489, 90.670929, 90.789696,\n",
+       "        90.908829, 91.027046, 91.14119 , 91.251991, 91.367691, 91.490082,\n",
+       "        91.614998, 91.741287, 91.868637, 91.993652, 92.114258, 92.231781,\n",
+       "        92.348244, 92.46759 , 92.588638, 92.707405, 92.822586, 92.933563,\n",
+       "        93.04287 , 93.155846, 93.269501, 93.380066, 93.489967, 93.599533,\n",
+       "        94.606369, 94.514717, 94.423134, 94.33255 , 94.23864 , 94.14489 ,\n",
+       "        94.056297, 93.967804, 93.877495, 93.788322, 93.704956, 93.621429,\n",
+       "        93.527145, 93.42601 , 93.324242, 93.225632, 93.131165, 93.035774,\n",
+       "        92.940636, 92.846764, 92.751244, 92.655701, 92.56498 , 92.47998 ,\n",
+       "        92.399223, 92.320503, 92.239883, 92.160141, 92.082138, 92.005295,\n",
+       "        91.928452, 91.84816 , 91.765816, 91.684288]),\n",
+       " array([90.443024, 90.569557, 90.700577, 90.832901, 90.96257 , 91.090973,\n",
+       "        91.222427, 91.356979, 91.491455, 91.624146, 91.755928, 91.889572,\n",
+       "        92.024696, 92.159348, 92.293831, 92.427818, 92.56543 , 92.709602,\n",
+       "        92.857964, 93.008194, 93.157288, 93.310905, 93.468185, 93.622154,\n",
+       "        93.772659, 93.920006, 94.066315, 94.212891, 94.356552, 94.495537,\n",
+       "        94.633842, 94.771591, 94.910011, 95.052505, 95.201157, 95.352089,\n",
+       "        95.499443, 95.643684, 95.785133, 95.920341, 96.049301, 96.178719,\n",
+       "        96.309158, 96.441086, 96.578865, 96.720055, 96.865059, 97.011421,\n",
+       "        97.154274, 97.295433, 97.430023, 97.55619 , 97.679398, 97.800186,\n",
+       "        97.918137, 98.03363 , 98.142281, 98.24247 , 98.337334, 98.428177,\n",
+       "        98.515549, 98.599236, 98.687233, 98.781937, 98.880524, 98.981476,\n",
+       "        99.078934, 99.171974, 99.260635, 96.441231, 96.382118, 96.327049,\n",
+       "        96.272865, 96.212585, 96.147636, 96.083969, 96.023605, 95.963593,\n",
+       "        95.905602, 95.850014, 95.796875, 95.748138, 95.705658, 95.665985,\n",
+       "        95.623444, 95.580811, 95.540344, 95.49765 , 95.452614, 95.405724,\n",
+       "        95.358688, 95.312691, 95.269188, 95.231537, 95.194862, 95.159241,\n",
+       "        88.523827, 88.540169, 88.564537, 88.592064, 88.620346, 88.650177,\n",
+       "        88.683548, 88.722244, 88.766304, 88.817436, 88.873665, 88.934807,\n",
+       "        88.999886, 89.067711, 89.137749, 89.209953, 89.284027, 89.359467,\n",
+       "        89.437111, 89.516068, 89.59597 , 89.675461, 89.756149, 89.838837,\n",
+       "        89.921562, 90.006119, 90.09169 , 90.177917, 90.270065, 90.366478,\n",
+       "        90.463844, 90.564728, 90.670029, 90.778   , 90.883583, 90.989029,\n",
+       "        91.099823, 91.215492, 91.331322, 91.445297, 91.565735, 91.693031,\n",
+       "        91.819771, 91.948334, 92.082062, 92.21917 , 92.355103, 92.486824,\n",
+       "        92.621765, 92.76207 , 95.02668 , 94.983353, 94.94278 , 94.895798,\n",
+       "        94.847893, 94.805237, 94.766998, 94.726479, 94.68174 , 94.641502,\n",
+       "        94.600647, 94.55928 , 94.523499, 94.488556, 94.45237 , 94.416023,\n",
+       "        94.376068, 94.331337, 94.285095, 94.241592, 94.20031 , 94.155945,\n",
+       "        94.107811, 94.061424, 94.018951, 93.979805, 93.946129, 93.917244,\n",
+       "        93.887871, 93.855049, 93.824417, 93.793854, 93.761436, 93.728111,\n",
+       "        93.692497, 93.656357, 93.62159 , 93.588623, 93.555   , 93.523468,\n",
+       "        93.49675 , 92.618294, 92.663902, 92.704475, 92.741486, 92.780075,\n",
+       "        92.825775, 92.87899 , 92.933403, 92.982971, 93.030533, 93.080963,\n",
+       "        93.133354, 93.183273, 93.23217 , 93.281975, 93.334961, 93.391808,\n",
+       "        93.448212, 93.504303, 93.558327, 93.607613, 93.659042, 93.716209,\n",
+       "        93.77861 , 96.319809, 96.271301, 96.224892, 96.185234, 96.149529,\n",
+       "        96.117096, 96.085297, 96.051758, 96.015198, 95.973953, 95.930565,\n",
+       "        95.890472, 95.854126, 95.818199, 95.779366, 95.743622, 95.715279,\n",
+       "        95.690132, 95.665611, 95.640465, 95.614845, 95.589928, 95.566299,\n",
+       "        95.543777, 95.518913, 95.485519, 95.447601, 95.408096, 95.365013,\n",
+       "        95.320282, 95.275772, 95.231651, 95.182877, 95.12664 , 95.064606,\n",
+       "        94.998253, 94.93309 , 94.870338, 94.805702, 94.743767, 94.688843,\n",
+       "        94.638527, 94.586067, 94.533524, 94.48172 , 94.425522, 94.370232,\n",
+       "        94.317856, 94.263733, 94.204338, 94.143295, 94.080589, 94.010918,\n",
+       "        93.93705 , 93.863029, 93.786415, 93.704407, 93.621986, 93.544693,\n",
+       "        93.47187 , 93.397125, 93.318329, 93.236458, 93.152428, 93.073044,\n",
+       "        92.998146, 92.92952 , 92.86615 , 92.798973, 92.728714, 92.659355,\n",
+       "        92.591896, 92.528648, 92.470016, 92.413368, 92.357826, 92.302589,\n",
+       "        92.250458, 92.196877, 92.141228, 92.090179, 92.04184 , 91.998138,\n",
+       "        91.954826, 91.90947 , 91.867294, 91.829666, 91.79776 , 91.769379,\n",
+       "        91.738716, 91.705246, 91.672737, 91.642265, 91.616402, 91.59668 ,\n",
+       "        91.582199, 91.571594, 91.565742, 91.563156, 91.559669, 91.55381 ,\n",
+       "        91.546791, 91.541092, 91.53521 , 91.529343, 91.526138, 91.531387,\n",
+       "        91.544571, 91.553825, 91.562576, 91.573532, 91.583946, 91.597397,\n",
+       "        91.609566, 91.619614, 91.629639, 91.635269, 91.637268, 91.639351,\n",
+       "        94.429939, 94.370216, 94.312729, 94.259521, 94.20829 , 94.15519 ,\n",
+       "        94.100723, 94.051361, 94.006607, 93.961517, 93.91526 , 93.869362,\n",
+       "        93.822426, 93.77565 , 93.729729, 93.678734, 93.62561 , 93.574722,\n",
+       "        93.523079, 93.470558, 93.416168, 93.360703, 93.30542 , 93.247444,\n",
+       "        93.190987, 93.137428, 93.081253, 93.023018, 92.966156, 92.910507,\n",
+       "        92.858841, 92.811996, 92.769516, 92.732605, 92.700478, 92.670288,\n",
+       "        92.638222, 92.604759, 92.570534, 92.537933, 92.510956, 92.488022,\n",
+       "        92.467079, 92.450996, 92.442177, 92.440575, 92.443817, 92.449158,\n",
+       "        92.460197, 92.477646, 92.496246, 92.515343, 92.538139, 92.565201,\n",
+       "        92.592178, 92.619705, 92.643593, 92.661758, 92.680794, 92.700325,\n",
+       "        92.72113 , 92.746147, 92.776596, 92.812798, 92.854469, 92.90416 ,\n",
+       "        92.960152, 93.017624, 93.076912, 93.131187, 93.181129, 93.23336 ,\n",
+       "        93.284554, 93.333855, 93.384354, 93.437141, 93.490868, 93.544922,\n",
+       "        93.601784, 93.658264, 93.713608, 93.771004, 93.827888, 93.883957,\n",
+       "        93.93943 , 93.997902, 94.061218, 94.126923, 94.193626, 94.260384,\n",
+       "        94.324402, 94.382538, 94.436295, 94.486389, 94.532806, 94.580696,\n",
+       "        94.629173, 94.67601 , 94.717339, 94.754089, 94.796089, 94.841949,\n",
+       "        94.885483, 94.924759, 94.962677, 95.001892, 95.042465, 95.083214,\n",
+       "        95.120346, 95.154167, 95.185249, 95.211555, 95.241753, 95.275909,\n",
+       "        95.311081, 95.346992, 95.378952, 95.409851, 92.200523, 92.292404,\n",
+       "        92.383217, 92.477837, 92.575348, 92.675247, 92.776054, 92.873055,\n",
+       "        92.968224, 93.063789, 93.158424, 93.255745, 93.35569 , 93.46035 ,\n",
+       "        93.569511, 93.681366, 93.797554, 93.913399, 94.02623 , 94.138596,\n",
+       "        94.250359, 94.357956, 94.459137, 94.559937, 94.660217, 94.753883,\n",
+       "        94.842735, 94.929047, 95.014214, 95.099022, 95.177841, 95.250427,\n",
+       "        95.319763, 95.386856, 95.454048, 95.522224, 95.587425, 95.650017,\n",
+       "        95.714073, 95.77314 , 95.824982, 95.878372, 95.934219, 95.989647,\n",
+       "        96.045341, 96.10363 , 96.162506, 97.737762, 97.772049, 97.800812,\n",
+       "        97.827179, 97.851128, 97.873787, 97.891853, 97.902847, 97.911232,\n",
+       "        97.919838, 97.929802, 97.939438, 97.94474 , 97.94709 , 97.95565 ,\n",
+       "        97.967194, 97.977608, 97.986305, 97.991821, 97.99411 , 97.993248,\n",
+       "        97.990768, 97.986702, 97.979408, 97.969162, 97.958252, 97.945465,\n",
+       "        97.92868 , 97.90976 , 97.888557, 97.863853, 97.832611, 97.796059,\n",
+       "        97.758888, 97.724571, 97.691612, 97.650551, 97.60157 , 97.54966 ,\n",
+       "        97.498016, 97.446106, 97.392235, 97.334991, 97.271454, 97.20417 ,\n",
+       "        97.137245, 97.06868 , 96.994576, 96.919136, 96.845665, 96.769852,\n",
+       "        96.693932, 96.623123, 96.55619 , 96.487854, 96.415756, 96.342972,\n",
+       "        96.269257, 96.193985, 96.12011 , 96.048561, 95.976501, 95.899422,\n",
+       "        95.817184, 95.731804, 95.64447 , 95.559006, 95.478188, 95.401108,\n",
+       "        95.327454, 95.257393, 95.189308, 95.120354, 95.053406, 94.990868,\n",
+       "        94.93013 , 94.867958, 94.800545, 94.733688, 94.673096, 94.614845,\n",
+       "        94.555603, 94.495064, 94.440033, 94.390419, 94.339592, 94.287361,\n",
+       "        94.233109, 94.178421, 94.124886, 94.069084, 94.015945, 93.968506,\n",
+       "        93.924767, 93.888153, 93.8554  , 93.82476 , 93.796036, 93.769447,\n",
+       "        93.746536, 93.726501, 93.707481, 93.689117, 93.669456, 93.653976,\n",
+       "        93.64122 , 93.624413, 93.607185, 93.590424, 93.572121, 93.552002,\n",
+       "        93.530502, 93.506737, 93.481834, 93.452415, 93.417625, 93.380569,\n",
+       "        93.342674, 93.306099, 93.272408, 93.243256, 93.220444, 93.201477,\n",
+       "        93.179344, 93.150169, 93.114052, 93.072029, 93.028725, 92.984947,\n",
+       "        92.940567, 92.895264, 92.850868, 92.808029, 92.764793, 92.722878,\n",
+       "        92.682281, 92.642342, 92.600945, 92.553574, 92.502937, 92.451004,\n",
+       "        92.397957, 92.346382, 93.559036, 93.612617, 93.661331, 93.709076,\n",
+       "        93.763786, 93.823128, 93.882896, 93.944801, 94.011436, 94.082199,\n",
+       "        94.152351, 94.219429, 94.284615, 94.347748, 94.415665, 94.489349,\n",
+       "        94.562202, 94.633934, 94.705276, 94.773315, 94.840729, 94.912132,\n",
+       "        94.987816, 95.06929 , 95.158836, 95.251114, 95.341309, 95.434196,\n",
+       "        95.530495, 95.627762, 95.727333, 95.83036 , 95.933548, 96.035423,\n",
+       "        96.137131, 96.241982, 96.348091, 96.452576, 96.556412, 96.663078,\n",
+       "        96.771774, 96.878311, 96.987343, 97.097267, 97.203575, 97.304344,\n",
+       "        97.402458, 97.49865 , 97.587898, 97.670914, 97.749634, 97.826874,\n",
+       "        97.902496, 97.972221, 98.035446, 98.095459, 95.643417, 95.629951,\n",
+       "        95.61483 , 95.593536, 95.568604, 95.543488, 95.516983, 95.495255,\n",
+       "        95.479614, 95.468636, 95.45842 , 95.446854, 95.432747, 95.418846,\n",
+       "        95.405304, 95.388634, 95.374222, 95.358353, 95.341187, 95.325768,\n",
+       "        95.307945, 95.287491, 95.26506 , 95.243607, 95.225197, 95.212219,\n",
+       "        95.202538, 95.193459, 95.186371, 95.175789, 95.164078, 95.153252,\n",
+       "        95.143944, 95.138245, 95.12989 , 96.204216, 96.325676, 96.443771,\n",
+       "        96.55648 , 96.667862, 96.778908, 96.885063, 96.986351, 97.081261,\n",
+       "        97.173973, 97.270485, 97.36985 , 97.470139, 97.572159, 97.678947,\n",
+       "        97.789154, 97.898422, 97.999435, 98.095253, 98.189034, 98.279831,\n",
+       "        98.367546, 98.451363, 98.530334, 98.603287, 98.671089, 98.733681,\n",
+       "        98.795341, 98.860321, 98.926453, 98.993927, 99.068596, 99.150528,\n",
+       "        99.233536, 99.315582, 99.3937  , 99.46595 , 98.467545, 98.473389,\n",
+       "        98.483925, 98.498535, 98.513634, 98.532845, 98.554359, 98.574615,\n",
+       "        98.597549, 98.620232, 98.641426, 98.656982, 98.669403, 98.680832,\n",
+       "        98.689819, 98.701805, 98.718704, 98.729942, 98.731255, 98.728539,\n",
+       "        98.718994, 98.707855, 98.698555, 98.687698, 98.676086, 98.663391,\n",
+       "        98.651062, 98.637383, 98.619492, 98.597961, 98.572319, 98.543266,\n",
+       "        98.512779, 98.482468, 98.451042, 98.416092, 98.378967, 98.341148,\n",
+       "        98.301727, 98.262108, 98.225395, 98.193199, 98.158127, 98.119278,\n",
+       "        98.080292, 98.039474, 97.998871, 97.956726, 97.91568 , 97.875191,\n",
+       "        97.829849, 97.783943, 97.738617, 97.688705, 97.633942, 97.574348,\n",
+       "        97.512039, 97.450569, 97.391159, 97.330376, 97.268364, 97.207336,\n",
+       "        97.142761, 97.074707, 97.005959, 96.934509, 96.861031, 96.786789,\n",
+       "        96.707771, 96.624939, 96.541664, 96.457016, 96.372612, 96.289268,\n",
+       "        96.205566, 96.122162, 96.037285, 95.94899 , 95.857239, 95.76545 ,\n",
+       "        95.675964, 95.5868  , 95.497879, 95.410881, 95.320976, 95.229172,\n",
+       "        95.139458, 95.050453, 94.965042, 94.881561, 94.79763 , 94.716461,\n",
+       "        94.636955, 94.551727, 94.459969, 94.366974, 94.273911, 94.18129 ,\n",
+       "        94.090805, 93.999054, 93.905663, 93.813217, 93.724922, 93.64032 ,\n",
+       "        93.553391, 93.467789, 93.389687, 93.31469 , 93.237892, 93.157623,\n",
+       "        93.073128, 92.989159, 92.907715, 92.823708, 92.73391 , 92.64312 ,\n",
+       "        92.552399, 92.462814, 92.37542 , 92.292931, 92.219276, 92.146034,\n",
+       "        92.071159, 91.997482, 91.922661, 91.843124, 91.75737 , 91.673065,\n",
+       "        91.591431, 91.50666 , 91.424004, 91.346931, 91.269844, 91.196907,\n",
+       "        91.130974, 91.066963, 91.003998, 90.943901, 90.884758, 90.823952,\n",
+       "        90.76384 , 90.703133, 90.638443, 90.572563, 90.5065  , 90.435745,\n",
+       "        90.364685, 90.294258, 90.225342, 90.159897, 90.097862, 90.042816,\n",
+       "        89.987816, 89.932625, 89.880867, 89.833298, 89.790016, 89.749107,\n",
+       "        89.715729, 89.686485, 89.651276, 89.61364 , 93.709557, 93.818314,\n",
+       "        93.926109, 94.034752, 94.142021, 94.245781, 94.344826, 94.443146,\n",
+       "        94.544296, 94.648224, 94.752022, 94.852249, 94.9533  , 95.057083,\n",
+       "        95.16214 , 95.265915, 95.365555, 95.460632, 95.550003, 95.636414,\n",
+       "        95.720818, 95.803787, 95.880829, 95.947731, 96.007874, 96.065453,\n",
+       "        96.121834, 96.178123, 96.240364, 96.305511, 96.367523, 96.429352,\n",
+       "        96.4907  , 96.548286, 96.603111, 96.659126, 96.718552, 96.776016,\n",
+       "        96.981796, 96.92601 , 96.869164, 96.809578, 96.748367, 96.689514,\n",
+       "        96.633156, 96.5755  , 96.520111, 96.463196, 96.400734, 96.337997,\n",
+       "        96.272827, 96.201469, 96.12648 , 96.054184, 95.983742, 95.915627,\n",
+       "        95.848991, 95.780182, 95.711349, 95.642471, 95.569954, 95.495193,\n",
+       "        95.42202 , 95.350594, 95.280113, 95.205093, 95.123619, 95.039825,\n",
+       "        94.955643, 94.872665, 94.787575, 94.697647]),\n",
+       " array([ 99.346558,  99.432762,  99.515373,  99.596008,  99.675117,\n",
+       "         99.750107,  99.825089,  99.899704,  99.975922, 100.053299,\n",
+       "        100.129631, 100.208115, 100.288483, 100.366562, 100.442299,\n",
+       "        100.514381, 100.582359, 100.64888 , 100.712738, 100.776558,\n",
+       "        100.842163, 100.908134, 100.97319 , 101.03849 , 101.101776,\n",
+       "        101.16317 , 101.221558, 101.27446 , 101.326065, 101.377304,\n",
+       "        101.427361,  97.944496,  97.91925 ,  97.889549,  97.852753,\n",
+       "         97.812248,  97.770691,  97.72863 ,  97.686401,  97.642685,\n",
+       "         97.593391,  97.541107,  97.490105,  97.43943 ,  97.390724,\n",
+       "         97.340416,  97.285583,  97.232933,  97.180138,  97.121193,\n",
+       "         97.060707,  97.001106,  96.942886,  96.88485 ,  96.825508,\n",
+       "         96.765892,  96.704544,  96.642113,  96.575768,  96.50602 ,\n",
+       "         92.901695,  93.040787,  93.178177,  93.314102,  93.449219,\n",
+       "         93.585564,  93.727364,  93.868706,  94.006271,  94.148071,\n",
+       "         94.295883,  94.449921,  94.610703,  94.769112,  94.930931,\n",
+       "         95.106384,  95.290192,  95.475311,  95.661987,  95.850449,\n",
+       "         96.034912,  96.211174,  96.377075,  96.53804 ,  96.698959,\n",
+       "         96.853653,  97.002502,  97.151535,  97.302307,  97.453423,\n",
+       "         97.603645,  97.758751,  97.917229,  98.074348,  98.231834,\n",
+       "         98.388863,  98.54406 ,  98.699921,  98.855423,  99.005508,\n",
+       "         99.152901,  99.299507,  99.440727,  99.576485,  99.710182,\n",
+       "         99.842575,  99.974648, 100.107399, 100.239235, 100.368004,\n",
+       "        100.493881, 100.617271, 100.736313, 100.853485, 100.969055,\n",
+       "        101.079903, 101.1875  , 101.290352, 101.386185, 101.477798,\n",
+       "        101.565857, 101.646774, 101.723701, 101.803375, 101.883041,\n",
+       "        101.957771, 102.027557, 102.088768, 102.140366, 102.188385,\n",
+       "        102.235733, 102.279739, 102.319153, 102.352928, 102.38279 ,\n",
+       "        102.413429, 102.440956, 102.462952, 102.478241, 102.486946,\n",
+       "        102.496727,  99.016754,  98.967056,  98.920532,  98.872719,\n",
+       "         98.819893,  98.770149,  98.726311,  98.681557,  98.634903,\n",
+       "         98.590027,  98.548264,  98.504669,  98.458588,  98.409882,\n",
+       "         98.359978,  98.30793 ,  98.248901,  98.188606,  98.127716,\n",
+       "         98.064865,  97.99971 ,  97.931343,  97.860939,  97.78933 ,\n",
+       "         97.718414,  97.646843,  97.576988,  97.511162,  97.446716,\n",
+       "         97.380089,  97.311905,  97.243233,  97.176056,  97.112701,\n",
+       "         97.051689,  96.98954 ,  96.921463,  96.849266,  96.776451,\n",
+       "         96.699509,  96.620766,  96.547256,  96.478188,  96.412453,\n",
+       "         96.347267,  96.279701,  96.214638,  96.149582,  96.077744,\n",
+       "         96.004562,  95.93383 ,  95.866829,  95.808449,  95.755791,\n",
+       "         95.704567,  95.65303 ,  95.597137,  95.538528,  95.481125,\n",
+       "         95.428535,  95.38192 ,  95.336235,  95.292564,  95.251709,\n",
+       "         95.215508,  95.187149,  95.157349,  95.119095,  95.074135,\n",
+       "         93.843002,  93.904266,  93.965111,  94.031342,  94.104385,\n",
+       "         94.177368,  94.246002,  94.313667,  94.383507,  94.451263,\n",
+       "         94.511604,  94.567627,  94.625351,  94.68174 ,  94.736191,\n",
+       "         94.792465,  94.850029,  94.911842,  94.980423,  95.048592,\n",
+       "         95.110336,  95.165985,  95.218102,  95.270638,  95.325279,\n",
+       "         95.382202,  95.437744,  95.495209,  95.556976,  95.617462,\n",
+       "         95.676674,  95.733093,  95.789284,  98.344971,  98.292725,\n",
+       "         98.251793,  98.216354,  98.179131,  98.143463,  98.110039,\n",
+       "         98.071739,  98.028862,  97.985031,  97.941841,  97.902321,\n",
+       "         97.863411,  97.823082,  97.780884,  97.739052,  97.701973,\n",
+       "         97.664742,  97.625893,  97.585533,  97.546791,  97.509659,\n",
+       "         97.473526,  97.441345,  97.406731,  97.368538,  97.330139,\n",
+       "         97.294044,  97.259514,  97.219284,  97.174797,  97.131271,\n",
+       "         97.083527,  97.037949,  96.999786,  96.960899,  96.921257,\n",
+       "         96.878624,  96.833488,  96.786835,  96.736015,  96.686256,\n",
+       "         96.640549,  96.596664,  96.555992,  96.519745,  96.484352,\n",
+       "         96.447693,  96.405907,  96.36277 ,  96.22171 ,  96.281212,\n",
+       "         96.336555,  96.388885,  96.440544,  96.490822,  96.540894,\n",
+       "         96.588425,  96.6287  ,  96.665871,  96.697075,  96.722382,\n",
+       "         96.747871,  96.772476,  96.795448,  96.813446,  96.825409,\n",
+       "         96.834404,  96.841949,  96.855019,  96.875984,  96.8983  ,\n",
+       "         96.923058,  96.952072,  96.98394 ,  97.015869,  97.044037,\n",
+       "         97.068954,  97.090614,  97.114799,  97.141922,  97.168327,\n",
+       "         97.194153,  97.216698,  97.236969,  97.257103,  97.275528,\n",
+       "         97.292313,  97.306808,  97.319839,  97.331604,  97.344055,\n",
+       "         97.35775 ,  97.364937,  97.365105,  97.362488,  97.356125,\n",
+       "         97.347656,  97.335861,  97.3172  ,  97.290863,  97.255264,\n",
+       "         97.212448,  97.167099,  97.119637,  97.073807,  97.035088,\n",
+       "         96.99868 ,  96.963379,  96.928421,  96.890816,  96.853653,\n",
+       "         96.817863,  96.780235,  96.741615,  96.697403,  96.645493,\n",
+       "         96.594643,  96.544891,  96.491684,  96.437958,  96.38562 ,\n",
+       "         96.33197 ,  96.28093 ,  96.232452,  96.183487,  96.130547,\n",
+       "         96.0728  ,  96.015106,  95.956444,  97.665596,  97.758812,\n",
+       "         97.854683,  97.953781,  98.052917,  98.150467,  98.245682,\n",
+       "         98.338989,  98.427635,  98.512466,  98.594582,  98.671303,\n",
+       "         98.742043,  98.811584,  98.887589,  98.964676,  99.037788,\n",
+       "         99.106789,  99.171631,  99.23555 ,  99.297806,  99.355743,\n",
+       "         99.411018,  99.468445,  99.526192,  99.58194 ,  99.638634,\n",
+       "         99.688713,  99.732307,  99.776978,  99.823608,  99.87133 ,\n",
+       "         99.919975,  99.969292, 100.014923, 100.052933, 100.082733,\n",
+       "        100.106171, 100.124001, 100.139412, 100.153381, 100.165779,\n",
+       "        100.17807 , 100.189644, 100.197655, 100.199638, 100.200264,\n",
+       "        100.201118, 100.201942, 100.203049, 100.202217, 100.201172,\n",
+       "        100.200111, 100.196793, 100.191498, 100.182732, 100.17189 ,\n",
+       "        100.16011 , 100.147835, 100.135307, 100.118095, 100.094543,\n",
+       "        100.072205, 100.056038, 100.039162, 100.019905,  99.998474,\n",
+       "         99.970291,  99.939095,  99.908386,  99.877304,  99.848618,\n",
+       "         99.821518,  99.796371,  99.776199,  99.758095,  99.738342,\n",
+       "         99.71727 ,  99.69326 ,  99.663704,  99.632553,  99.598373,\n",
+       "         99.558006,  99.51413 ,  99.466057,  99.416183,  99.368408,\n",
+       "         99.323914,  99.284744,  99.251175,  99.218735,  99.184509,\n",
+       "         99.14518 ,  99.101059,  99.055534,  99.009956,  98.964302,\n",
+       "         98.917381,  98.869598,  98.822067,  98.778427,  98.738708,\n",
+       "         98.698563,  98.655098,  98.615105,  98.578377,  98.536324,\n",
+       "         98.487587,  98.199356,  98.172333,  98.141563,  98.106293,\n",
+       "         98.06694 ,  98.026436,  97.987686,  97.947243,  97.907242,\n",
+       "         97.874626,  97.843712,  97.813118,  97.788383,  97.766106,\n",
+       "         97.740593,  97.713615,  97.689575,  97.665581,  97.634514,\n",
+       "         97.599503,  97.5625  ,  97.521553,  97.481651,  97.443352,\n",
+       "         97.40963 ,  97.385185,  97.366264,  97.350433,  97.336357,\n",
+       "         97.320946,  97.302849,  97.283028,  97.260612,  97.239944,\n",
+       "         97.224747,  97.211624,  97.19957 ,  97.192108,  97.189911,\n",
+       "         97.185173,  97.174492,  97.161087,  97.14489 ,  97.128876,\n",
+       "         97.115784,  97.105057,  97.098106,  97.093117,  97.089836,\n",
+       "         97.09095 ,  97.097183,  97.108994,  97.12394 ,  97.142319,\n",
+       "         97.168648,  97.200562,  97.232605,  97.269386,  97.313744,\n",
+       "         97.357109,  97.399094,  97.440399,  97.477722,  97.51088 ,\n",
+       "         97.545074,  97.581772,  97.619308,  97.660194,  97.700142,\n",
+       "         98.159355,  98.226746,  98.294868,  98.365273,  98.436874,\n",
+       "         98.509384,  98.587502,  98.671288,  98.752319,  98.826988,\n",
+       "         98.895836,  98.964691,  99.035027,  99.104332,  99.171844,\n",
+       "         99.234436,  99.294601,  99.35878 ,  99.425484,  99.490204,\n",
+       "         99.54937 ,  99.603806,  99.653793,  99.695862,  99.733932,\n",
+       "         99.774681,  99.816139,  99.857803,  99.901482,  99.950134,\n",
+       "        100.000626, 100.047005, 100.090591,  97.18531 ,  97.145393,\n",
+       "         97.1064  ,  97.06839 ,  97.032509,  96.99826 ,  96.964539,\n",
+       "         96.930473,  96.897255,  96.864128,  96.832764,  96.8022  ,\n",
+       "         96.77301 ,  96.749298,  96.722672,  96.689857,  96.657936,\n",
+       "         96.628334,  96.602592,  96.579048,  96.551674,  96.523186,\n",
+       "         96.495331,  96.466957,  96.435463,  96.400497,  96.361794,\n",
+       "         96.324722,  96.295944,  96.269661,  96.238724,  96.204971,\n",
+       "         96.169647,  96.131058,  96.090446,  96.046066,  95.999992,\n",
+       "         95.954842,  95.911758,  95.869064,  95.826416,  95.788055,\n",
+       "         95.756355,  95.735626,  95.721802,  95.710846,  95.704536,\n",
+       "         95.700073,  95.690987,  95.678322,  95.665581,  95.654083,\n",
+       "         99.537422,  99.611557,  99.685829,  99.75589 ,  99.824593,\n",
+       "         99.892181,  99.959885, 100.028084, 100.092827, 100.157188,\n",
+       "        100.22879 , 100.302734, 100.370575, 100.437416, 100.506279,\n",
+       "        100.576317, 100.644089, 100.711304, 100.775787, 100.832664,\n",
+       "        100.885681, 100.93618 , 100.985886, 101.035927, 101.087074,\n",
+       "        101.138649, 101.187943, 101.233894, 101.275528, 101.31562 ,\n",
+       "         96.970177,  97.002243,  97.034653,  97.062119,  97.08709 ,\n",
+       "         97.116119,  97.151085,  97.186806,  97.222893,  97.263069,\n",
+       "         97.306007,  97.346886,  97.385399,  97.426941,  97.467125,\n",
+       "         97.504478,  97.544052,  97.583267,  97.62207 ,  97.663818,\n",
+       "         97.706108,  97.746803,  97.782578,  97.811722,  97.843483,\n",
+       "         97.883675,  97.926552,  97.964149,  97.997635,  98.032082,\n",
+       "         98.070015,  98.105347,  98.135445,  98.162323,  98.185173,\n",
+       "         98.20063 ,  98.213692,  98.230576,  98.247665,  98.267456,\n",
+       "         98.287018,  98.299789,  98.307884,  98.317207,  98.329216,\n",
+       "         98.343597,  98.361763,  98.38501 ,  98.411118,  98.436096,\n",
+       "         98.452377,  98.461304,  96.832039,  96.889153,  96.940941,\n",
+       "         96.989861,  97.038605,  97.085327,  97.132553,  97.182549,\n",
+       "         97.234886,  97.285713,  97.331268,  97.376503,  97.424034,\n",
+       "         97.470825,  97.51899 ,  97.568527,  97.620598,  97.673103,\n",
+       "         97.723824,  97.769646,  97.814415,  97.862686,  97.907784,\n",
+       "         97.947662,  97.985596,  98.026207,  98.06765 ,  98.112022,\n",
+       "         98.158882,  98.204506,  98.247299,  98.29081 ,  98.338333,\n",
+       "         98.386528,  98.432266,  98.476006,  98.520096,  98.564636,\n",
+       "         98.614296,  98.662056,  98.70594 ,  98.754982,  98.811279,\n",
+       "         98.870628,  98.92939 ,  98.988953,  99.049339,  99.108978,\n",
+       "         99.165039,  99.220894,  99.278397,  99.334831,  99.391449,\n",
+       "         99.447784,  99.497009,  99.538773,  99.572754,  99.597511,\n",
+       "         98.557121,  98.48159 ,  98.404915,  98.32814 ,  98.252014,\n",
+       "         98.178802,  98.108681,  98.039421,  97.972939,  97.9123  ,\n",
+       "         97.851921,  97.792526,  97.740265,  97.691971,  97.649841,\n",
+       "         97.617493,  97.590584,  97.562302,  97.524994,  97.483551,\n",
+       "         97.442764,  97.40258 ,  97.365005,  97.329353,  97.2966  ,\n",
+       "         97.260994,  97.216667,  97.169395,  97.122147,  97.076111,\n",
+       "         97.031761]),\n",
+       " array([101.476112, 101.521881, 101.567574, ...,  98.78476 ,  98.707901,\n",
+       "         98.631706]),\n",
+       " array([102.581726, 102.63044 , 102.674484, 102.716759, 102.756111,\n",
+       "        102.788635, 102.816887, 102.840523, 102.862411, 102.880569,\n",
+       "        102.894981, 102.909195, 102.929253, 102.954285, 102.978928,\n",
+       "        103.008537, 103.040833, 103.072243, 103.110336, 103.154564,\n",
+       "        103.196899, 103.237823, 103.277817, 103.317337, 103.355133,\n",
+       "        103.387856, 103.417282, 103.448776, 103.190002, 103.070206,\n",
+       "        102.949837, 102.827187, 102.703499, 102.584114, 102.469528,\n",
+       "        102.358231, 102.249641, 102.145935, 102.04689 , 101.951515,\n",
+       "        101.857574, 101.762276, 101.663559, 101.566147, 101.469215,\n",
+       "        101.371231, 101.278313, 101.191254, 101.109467, 101.032181,\n",
+       "        100.958397, 100.887062, 100.812126, 100.733307, 100.656151,\n",
+       "        100.582268, 100.509377, 100.430664, 100.34848 , 100.272186,\n",
+       "        100.199211, 100.128067, 100.059418,  99.992729,  99.930717,\n",
+       "         99.871315,  99.812569,  99.754829,  99.699814,  99.650444,\n",
+       "         99.604439,  99.554062, 102.768059, 102.75721 , 102.750023,\n",
+       "        102.748619, 102.748482, 102.745461, 102.738724, 102.72863 ,\n",
+       "        102.722237, 102.721786, 102.721695, 102.719894, 102.718163,\n",
+       "        102.712105, 102.699501, 102.686867, 102.675362, 102.664375,\n",
+       "        102.657845, 102.656982, 102.658371, 102.659012, 102.654175,\n",
+       "        102.647873, 102.644279, 102.640007, 102.635597, 102.629326,\n",
+       "        102.626724, 102.63282 , 102.640572, 102.647133, 102.652542,\n",
+       "        104.216278, 104.203941, 104.189751, 104.174583, 104.158119,\n",
+       "        104.140633, 104.12326 , 104.110916, 104.098541, 104.08252 ,\n",
+       "        104.065399, 104.04689 , 104.03241 , 104.019287, 104.010559,\n",
+       "        104.001709, 103.984741, 103.960739, 103.934792, 103.912613,\n",
+       "        103.890495, 103.866341, 103.841377, 103.816925, 103.792892,\n",
+       "        103.774078, 103.762383, 103.752495, 103.740395, 103.724022,\n",
+       "        103.700523, 103.671432, 103.63913 , 103.60527 , 103.56974 ,\n",
+       "        103.531677, 103.490295, 103.444901, 103.397751, 103.347862,\n",
+       "        103.292877, 103.236374, 103.18013 , 103.128807, 103.086571,\n",
+       "        103.045639, 103.005325, 102.967514, 102.934387, 102.903099,\n",
+       "        102.87188 , 102.846024, 102.82309 , 102.798279, 100.172897,\n",
+       "        100.251091, 100.325584, 100.395561, 100.461502, 100.528839,\n",
+       "        100.600639, 100.673401, 100.751076, 100.833031, 100.912827,\n",
+       "        100.989487, 101.068649, 101.14872 , 101.225998, 101.301765,\n",
+       "        101.378792, 101.458374, 101.540588, 101.622467, 101.703941,\n",
+       "        101.785942, 101.872208, 101.967354, 102.064392, 102.157845,\n",
+       "        102.254318, 102.353676, 102.452385, 102.551636, 102.649963,\n",
+       "        102.746292, 102.843498, 102.941177, 103.038544, 103.137581,\n",
+       "        103.236481, 103.334473, 103.43354 , 103.207932, 103.177765,\n",
+       "        103.148277, 103.118752, 103.082367, 103.038506, 102.996834,\n",
+       "        102.955498, 102.91127 , 102.868088, 102.830399, 102.799706,\n",
+       "        102.772102, 102.741089, 102.704414, 102.665443, 102.623131,\n",
+       "        102.576408, 102.52932 , 102.48513 , 102.445427, 102.406128,\n",
+       "        102.366829, 102.330894, 102.297523, 102.266815, 102.239494,\n",
+       "        102.213219, 102.187019, 102.159081, 102.129486, 102.099304,\n",
+       "        102.06559 , 102.032997, 102.004288, 101.976746, 101.949608,\n",
+       "        101.922287, 101.896744, 101.872437, 101.849144, 101.83062 ,\n",
+       "        101.813278, 101.795952, 101.781395, 101.765587, 101.744888,\n",
+       "        101.71489 , 101.678886, 101.642944, 101.607666, 101.575073,\n",
+       "        101.542755, 101.510048, 101.479797, 101.449234, 101.414642,\n",
+       "        101.380127, 101.348274, 101.31601 , 101.284729, 101.256737,\n",
+       "        101.22982 , 101.200935, 101.169449, 101.134911, 101.101151,\n",
+       "        101.065964, 101.026024, 100.987343, 100.950821, 100.912384,\n",
+       "        100.870735, 100.82428 , 100.775856, 100.729408, 100.684822,\n",
+       "        100.642616, 100.603668, 100.568192, 100.533363, 100.49897 ,\n",
+       "        100.464951, 100.432518, 100.405289, 103.508942, 103.588165,\n",
+       "        103.666756, 103.74826 , 103.832344, 103.919342, 104.01165 ,\n",
+       "        104.105629, 104.199341, 104.296127, 104.391205, 104.483986,\n",
+       "        104.579559, 104.673515, 104.760391, 104.839279, 104.905685,\n",
+       "        104.963577, 105.019897, 105.074654, 105.127876, 105.17524 ,\n",
+       "        105.213654, 105.246696, 105.277061, 105.300949, 105.316162,\n",
+       "        105.327179, 105.336998, 105.344719, 105.349548, 105.350082,\n",
+       "        105.344147, 105.333031, 105.314278, 105.288727, 105.260208,\n",
+       "        105.226051, 105.187202, 105.146095, 105.099228, 105.045906,\n",
+       "        104.992432, 104.943146, 104.895393, 104.849785, 104.807137,\n",
+       "        104.763092, 104.717621, 104.677338, 105.234978, 105.270485,\n",
+       "        105.304604, 105.332184, 105.361412, 105.392403, 105.41909 ,\n",
+       "        105.439606, 105.455902, 105.471397, 105.484734, 105.496033,\n",
+       "        105.505768, 105.514572, 105.523788, 105.532669, 105.536758,\n",
+       "        105.534378, 105.528702, 105.525589, 105.528587, 105.536797,\n",
+       "        105.547691, 105.558777, 105.5728  , 105.588501, 105.605446,\n",
+       "        105.623001, 105.636795, 105.646812, 105.660744, 105.681137,\n",
+       "        105.699707, 105.713669, 105.728386, 105.743629, 105.75647 ,\n",
+       "        105.7677  , 105.775139, 105.774002, 105.763763, 105.750824,\n",
+       "        105.737457, 105.721764, 105.701729, 105.679909, 105.658119,\n",
+       "        105.633904, 105.609756, 105.58474 , 105.555359, 105.524681,\n",
+       "        105.4897  , 105.451111, 105.412529, 105.377419, 105.341209,\n",
+       "        105.296989, 105.249214, 105.20076 , 105.153046, 105.110184,\n",
+       "        105.073669, 105.039207, 105.006104, 104.971497, 104.936287,\n",
+       "        104.900154, 104.865021, 104.833221, 104.801353, 104.770668,\n",
+       "        104.181213, 104.185043, 104.184265, 104.178307, 104.168594,\n",
+       "        104.153625, 104.136169, 104.117538, 104.102684, 104.090157,\n",
+       "        104.080292, 104.074707, 104.071045, 104.071297, 104.073158,\n",
+       "        104.072929, 104.071266, 104.070541, 104.071739, 104.072762,\n",
+       "        104.070427, 104.064865, 104.057686, 104.053741, 104.050385,\n",
+       "        104.039772, 104.024124, 104.008057, 103.99295 , 103.976959,\n",
+       "        103.956131, 103.935852, 103.921661, 103.909515, 103.90033 ,\n",
+       "        103.896225, 103.890976, 103.882942, 103.875565, 103.871567,\n",
+       "        103.867905, 103.857368, 103.842636, 103.82975 , 103.81768 ,\n",
+       "        103.803978, 100.637093, 100.653671, 100.670036, 100.680618,\n",
+       "        100.690582, 100.706947, 100.726913, 100.743774, 100.757896,\n",
+       "        100.769562, 100.774933, 100.774628, 100.771713, 100.768456,\n",
+       "        100.76442 , 100.760925, 100.762863, 100.767838, 100.769997,\n",
+       "        100.773468, 100.781448, 100.790131, 106.380554, 106.331154,\n",
+       "        106.278664, 106.227386, 106.180122, 106.129845, 106.076294,\n",
+       "        106.022087, 105.967628, 105.913292, 105.860451, 105.808449,\n",
+       "        105.752312, 105.697418, 105.645882, 105.592659, 105.539085,\n",
+       "        105.485336, 105.430428, 105.374573, 105.317268, 105.260994,\n",
+       "        105.206299, 105.150063, 105.093895, 105.040276, 104.986473,\n",
+       "        104.931236, 104.874268, 104.811913, 104.749908, 104.689598,\n",
+       "        104.625687, 104.564873, 104.509468, 104.457085, 104.406853,\n",
+       "        104.35775 , 104.308098, 104.25872 , 104.21003 , 104.155502,\n",
+       "        104.098259, 104.045288, 103.993927, 103.943794, 103.89579 ,\n",
+       "        103.847397, 103.800392, 103.758316, 103.717773, 103.676979,\n",
+       "        103.637894, 103.600082, 103.566223, 103.536568, 103.509056,\n",
+       "        103.483772, 103.453949, 103.417656, 103.378029, 103.334236,\n",
+       "        103.291565, 103.254303, 103.22036 , 103.188728, 103.158257,\n",
+       "        103.127586, 103.097145, 103.064461, 103.028221, 102.987007,\n",
+       "        102.941559, 102.895111, 102.850365, 102.802216, 102.750366,\n",
+       "        102.696487, 102.636398, 102.577644, 102.525146, 102.473434,\n",
+       "        102.417931, 102.361664, 102.304893, 102.250549, 102.200371,\n",
+       "        102.147339, 102.090958, 102.03344 , 101.97168 , 101.906509,\n",
+       "        101.839859, 101.768936, 101.698326, 101.627426, 101.092377,\n",
+       "        101.077812, 101.060112, 101.04007 , 101.01796 , 100.99276 ,\n",
+       "        100.965538, 100.939636, 100.916206, 100.89183 , 100.866585,\n",
+       "        100.839638, 100.81115 , 100.783157, 100.75605 , 100.728294,\n",
+       "        100.698151, 100.664368, 100.625931, 100.586288, 100.55088 ,\n",
+       "        100.519089, 100.489037, 100.461288, 100.434097, 100.408043,\n",
+       "        100.387108, 100.371849, 100.357971, 100.346855, 100.342361,\n",
+       "        100.340912, 100.343391, 100.348862, 100.353546, 100.36898 ,\n",
+       "        100.391022, 100.410767, 100.432732, 100.458321, 100.487564,\n",
+       "        100.517876, 100.55426 , 100.596756, 100.635994, 100.670555,\n",
+       "        100.706017, 100.743591, 100.781357, 100.818161, 100.852982,\n",
+       "        100.886215, 100.918999, 100.955017, 100.994614, 101.036629,\n",
+       "        101.079834, 101.123825, 101.167915, 101.207489, 101.245636,\n",
+       "        101.285515, 101.327049, 101.370781, 101.418541, 101.46978 ,\n",
+       "        101.520584, 101.572006, 101.622986, 101.671738, 101.715775,\n",
+       "        101.755074, 101.794418, 101.836952, 101.883942, 101.931419,\n",
+       "        101.97522 ,  99.997269,  99.996597,  99.996773,  99.998192,\n",
+       "        100.000938, 100.004433, 100.009743, 100.021751, 100.038223,\n",
+       "        100.05558 , 100.076668, 100.102821, 100.130989, 100.156837,\n",
+       "        100.182129, 100.210388, 100.236275, 100.261635, 100.291039,\n",
+       "        100.320442, 100.343811, 100.362976, 100.384377, 100.405617,\n",
+       "        100.425743, 100.443962, 100.461403, 100.476555, 100.485931,\n",
+       "        100.493896, 100.500275, 100.507759, 100.517296, 100.521973,\n",
+       "        100.521965, 100.520515, 100.517464, 100.516953, 100.519402,\n",
+       "        100.520683, 100.524208, 100.532059, 100.541725, 100.554497,\n",
+       "        100.570961, 100.589119, 100.610481, 100.634209, 100.657578,\n",
+       "        100.679779, 100.702194, 100.720917, 100.735847, 100.754143,\n",
+       "        100.77729 , 100.80616 , 100.835747, 100.864853, 100.899963,\n",
+       "        100.936783, 100.974632, 101.0177  , 101.064644, 101.115471,\n",
+       "        101.168083, 101.220192, 101.277046, 101.339722, 101.402359,\n",
+       "        101.460861, 101.514412, 101.568008, 101.621582, 101.66935 ,\n",
+       "        101.714195, 101.759514, 101.802658, 101.844292, 101.888565,\n",
+       "        101.938492, 101.991615, 102.044205, 102.100227, 102.156525,\n",
+       "        102.209145, 102.262543, 102.316788, 102.372993, 102.43261 ,\n",
+       "        102.493736, 102.55687 , 102.619942, 102.682144, 102.743546,\n",
+       "        102.805252, 102.867996, 102.93338 , 103.003181, 103.070625,\n",
+       "        103.138428, 103.212776, 103.293427, 103.377274, 103.461975,\n",
+       "        103.544136, 103.622307, 103.697792, 103.773453, 103.849403,\n",
+       "        103.923447, 103.993484, 104.063057, 104.131012, 104.189705,\n",
+       "        104.24276 , 104.297577, 104.351349, 104.404175, 104.461319,\n",
+       "        104.521217, 104.583069, 104.649506, 104.721703, 104.794724,\n",
+       "        104.863625, 104.92894 , 104.990021, 105.045006, 105.097466,\n",
+       "        105.149323, 105.198288, 105.242897, 105.285568, 105.32666 ,\n",
+       "        105.365791, 105.407593, 105.455605, 105.506004, 105.555176,\n",
+       "        105.60305 , 105.651237, 105.699249, 105.743805, 105.787537,\n",
+       "        105.833229, 105.880508, 105.925148, 105.969002, 106.011559,\n",
+       "        106.051826, 106.091743, 106.130074, 106.17131 , 106.213829,\n",
+       "        106.254555, 106.290146, 106.318741, 106.34314 , 106.362785,\n",
+       "        106.378929, 106.390373, 106.393272, 106.39296 , 106.39344 ,\n",
+       "        106.393318, 106.390121, 106.383408, 106.37661 , 106.370956,\n",
+       "        106.364166, 106.356079, 106.345299, 106.33271 , 106.318619,\n",
+       "        106.298096, 106.272865, 106.247757, 106.224007, 106.197609,\n",
+       "        106.167778, 106.133965, 106.096527, 106.059639, 106.024605,\n",
+       "        105.988274, 105.948502, 105.907394, 105.864769, 105.820595,\n",
+       "        105.773766, 105.724113, 105.671638, 105.617653, 105.563248,\n",
+       "        105.510239, 105.45961 , 105.407814, 105.34964 , 105.283356,\n",
+       "        105.215569, 105.146988, 105.076851, 105.008171, 102.401024,\n",
+       "        102.338799, 102.274742, 102.209183, 102.143265, 102.074387,\n",
+       "        101.998619, 101.923965, 101.854652, 101.78907 , 101.725876,\n",
+       "        101.663895, 101.601295, 101.537796, 101.475731, 101.410759,\n",
+       "        101.345215, 101.281364, 101.221764, 101.165443, 101.107399,\n",
+       "        101.045967, 100.980919, 100.913521, 100.841599, 100.769386]),\n",
+       " array([103.478836, 103.502983, 103.529747, ..., 102.592232, 102.528137,\n",
+       "        102.464371]),\n",
+       " array([104.434196, 104.479958, 104.534477, ..., 106.408913, 106.291611,\n",
+       "        106.170799]),\n",
+       " array([107.072227, 107.191742, 107.307533, ..., 112.709122, 112.650948,\n",
+       "        112.593094]),\n",
+       " array([110.530731, 110.612854, 110.697357, ..., 113.655632, 113.640152,\n",
+       "        113.620567]),\n",
+       " array([113.414749, 113.524033, 113.630859, ..., 113.86602 , 113.827286,\n",
+       "        113.79467 ]),\n",
+       " array([116.776924, 116.868759, 116.960602, ..., 117.4757  , 117.492203,\n",
+       "        117.507782]),\n",
+       " array([119.869873, 119.950066, 120.03299 , ..., 118.546135, 118.515266,\n",
+       "        118.487137]),\n",
+       " array([122.706421, 122.799843, 122.889587, ..., 124.806168, 124.840591,\n",
+       "        124.875404]),\n",
+       " array([125.194328, 125.27182 , 125.349037, ..., 124.795769, 124.757568,\n",
+       "        124.723244]),\n",
+       " array([128.625702, 128.754166, 128.892044, ..., 127.557693, 127.497673,\n",
+       "        127.435875]),\n",
+       " array([132.395752, 132.537323, 132.679825, ..., 132.315277, 132.304001,\n",
+       "        132.291138]),\n",
+       " array([135.030106, 135.101242, 135.175339, ..., 135.53215 , 135.530731,\n",
+       "        135.529449]),\n",
+       " array([136.765762, 136.805862, 136.843857, ..., 137.457443, 137.424042,\n",
+       "        137.387054]),\n",
+       " array([137.877289, 137.954193, 138.037399, ..., 141.139191, 141.085541,\n",
+       "        141.036987]),\n",
+       " array([140.101791, 140.18187 , 140.266022, ..., 141.276337, 141.228455,\n",
+       "        141.179504]),\n",
+       " array([142.041824, 142.165802, 142.286133, ..., 146.347748, 146.358047,\n",
+       "        146.369888]),\n",
+       " array([145.106155, 145.225601, 145.341843, ..., 146.048294, 146.009567,\n",
+       "        145.974182]),\n",
+       " array([149.093597, 149.177261, 149.255325, ..., 153.78125 , 153.725876,\n",
+       "        153.666901]),\n",
+       " array([151.192429, 151.260971, 151.329208, ..., 154.704483, 154.717514,\n",
+       "        154.731445]),\n",
+       " array([154.376099, 154.450104, 154.531601, ..., 153.411697, 153.476334,\n",
+       "        153.546005]),\n",
+       " array([157.467438, 157.52446 , 157.582062, ..., 153.76442 , 153.666428,\n",
+       "        153.569427]),\n",
+       " array([159.089355, 159.147736, 159.207962, ..., 163.046371, 163.116714,\n",
+       "        163.182587]),\n",
+       " array([160.50885 , 160.559174, 160.611404, ..., 159.011215, 159.119751,\n",
+       "        159.225388]),\n",
+       " array([161.981705, 162.04834 , 162.106155, ..., 168.373276, 168.415085,\n",
+       "        168.453461]),\n",
+       " array([163.794815, 163.894516, 163.996887, ..., 166.037354, 166.134613,\n",
+       "        166.233017]),\n",
+       " array([], dtype=float64),\n",
+       " array([70.94445 , 70.889374, 70.835632, ..., 74.790092, 74.791962,\n",
+       "        74.786705]),\n",
+       " array([73.599541, 73.696945, 73.801033, ..., 72.884613, 72.849976,\n",
+       "        72.812752]),\n",
+       " array([77.469078, 77.517532, 77.565384, ..., 77.158112, 77.167709,\n",
+       "        77.179878]),\n",
+       " array([78.646698, 78.656952, 78.673691, ..., 81.992882, 82.01783 ,\n",
+       "        82.041908]),\n",
+       " array([78.622513, 78.624512, 78.625862, ..., 81.99411 , 81.987717,\n",
+       "        81.978889]),\n",
+       " array([78.877754, 78.902565, 78.927483, ..., 84.121513, 84.098709,\n",
+       "        84.07502 ]),\n",
+       " array([81.663078, 81.738831, 81.815887, ..., 87.551285, 87.606506,\n",
+       "        87.667732]),\n",
+       " array([87.203186, 87.203674, 87.20459 , ..., 89.23262 , 89.24807 ,\n",
+       "        89.256798]),\n",
+       " array([85.881142, 85.88459 , 85.892921, ..., 92.732864, 92.734734,\n",
+       "        92.740166]),\n",
+       " array([86.753708, 86.784157, 86.81884 , ..., 92.243507, 92.250252,\n",
+       "        92.256096]),\n",
+       " array([90.443024, 90.569557, 90.700577, ..., 98.486748, 98.468033,\n",
+       "        98.449638]),\n",
+       " array([99.346558, 99.432762, 99.515373, ..., 96.485039, 96.460182,\n",
+       "        96.439384]),\n",
+       " array([101.476112, 101.521881, 101.567574, ..., 101.243736, 101.252594,\n",
+       "        101.260506]),\n",
+       " array([102.581726, 102.63044 , 102.674484, ..., 101.572098, 101.596901,\n",
+       "        101.621651]),\n",
+       " array([103.478836, 103.502983, 103.529747, ..., 103.763985, 103.763474,\n",
+       "        103.764618]),\n",
+       " array([104.434196, 104.479958, 104.534477, ..., 104.654007, 104.649208,\n",
+       "        104.639755]),\n",
+       " array([107.072227, 107.191742, 107.307533, ..., 109.964691, 109.958572,\n",
+       "        109.955307]),\n",
+       " array([110.530731, 110.612854, 110.697357, ..., 111.283546, 111.287376,\n",
+       "        111.291046]),\n",
+       " array([113.414749, 113.524033, 113.630859, ..., 114.063698, 114.062309,\n",
+       "        114.061401]),\n",
+       " array([116.776924, 116.868759, 116.960602, ..., 117.446114, 117.425339,\n",
+       "        117.403259]),\n",
+       " array([119.869873, 119.950066, 120.03299 , ..., 117.268799, 117.267509,\n",
+       "        117.266541]),\n",
+       " array([122.706421, 122.799843, 122.889587, ..., 119.845001, 119.765831,\n",
+       "        119.683655]),\n",
+       " array([125.194328, 125.27182 , 125.349037, ..., 126.320473, 126.303543,\n",
+       "        126.28199 ]),\n",
+       " array([128.625702, 128.754166, 128.892044, ..., 127.506371, 127.46302 ,\n",
+       "        127.425354]),\n",
+       " array([132.395752, 132.537323, 132.679825, ..., 133.200302, 133.147598,\n",
+       "        133.098099]),\n",
+       " array([135.030106, 135.101242, 135.175339, ..., 134.049042, 134.042343,\n",
+       "        134.038681]),\n",
+       " array([136.765762, 136.805862, 136.843857, ..., 134.980713, 134.930908,\n",
+       "        134.884674]),\n",
+       " array([137.877289, 137.954193, 138.037399, ..., 137.682343, 137.582642,\n",
+       "        137.487106]),\n",
+       " array([140.101791, 140.18187 , 140.266022, ..., 144.261368, 144.202103,\n",
+       "        144.138855]),\n",
+       " array([142.041824, 142.165802, 142.286133, ..., 145.975052, 145.992798,\n",
+       "        146.012787]),\n",
+       " array([145.106155, 145.225601, 145.341843, ..., 148.812195, 148.774597,\n",
+       "        148.731232]),\n",
+       " array([149.093597, 149.177261, 149.255325, ..., 148.772507, 148.776855,\n",
+       "        148.785416]),\n",
+       " array([151.192429, 151.260971, 151.329208, ..., 151.297913, 151.216507,\n",
+       "        151.131363]),\n",
+       " array([154.376099, 154.450104, 154.531601, ..., 158.36087 , 158.281052,\n",
+       "        158.202698]),\n",
+       " array([157.467438, 157.52446 , 157.582062, ..., 159.224976, 159.226364,\n",
+       "        159.228455]),\n",
+       " array([159.089355, 159.147736, 159.207962, ..., 158.304306, 158.340561,\n",
+       "        158.384933]),\n",
+       " array([160.50885 , 160.559174, 160.611404, ..., 157.525284, 157.498779,\n",
+       "        157.469986]),\n",
+       " array([161.981705, 162.04834 , 162.106155, ..., 167.047546, 167.077942,\n",
+       "        167.108841]),\n",
+       " array([163.794815, 163.894516, 163.996887, ..., 166.276199, 166.307159,\n",
+       "        166.336349])]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[*traj1_list, *traj2_list]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "150650d0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[  0.        ,  67.893829  ,   0.62355   ,   0.        ,\n",
+       "         67.893829  ,   0.62355   ],\n",
+       "       [  0.        ,  70.46682363,   0.62355   ,   0.        ,\n",
+       "         70.46682363,   0.62355   ],\n",
+       "       [  0.        ,  73.03981825,   0.62355   ,   0.        ,\n",
+       "         73.03981825,   0.62355   ],\n",
+       "       [  0.        ,  75.61281288,   0.62355   ,   0.        ,\n",
+       "         75.61281288,   0.62355   ],\n",
+       "       [  0.        ,  78.1858075 ,   0.62355   ,   0.        ,\n",
+       "         78.1858075 ,   0.62355   ],\n",
+       "       [  0.        ,  80.75880213,   0.62355   ,   0.        ,\n",
+       "         80.75880213,   0.62355   ],\n",
+       "       [  0.        ,  83.33179675,   0.62355   ,   0.        ,\n",
+       "         83.33179675,   0.62355   ],\n",
+       "       [  0.        ,  85.90479138,   0.62355   ,   0.        ,\n",
+       "         85.90479138,   0.62355   ],\n",
+       "       [  0.        ,  88.477786  ,   0.62355   ,   0.        ,\n",
+       "         88.477786  ,   0.62355   ],\n",
+       "       [  0.        ,  91.05078063,   0.62355   ,   0.        ,\n",
+       "         91.05078063,   0.62355   ],\n",
+       "       [  0.        ,  93.62377525,   0.62355   ,   0.        ,\n",
+       "         93.62377525,   0.62355   ],\n",
+       "       [  0.        ,  96.19676988,   0.62355   ,   0.        ,\n",
+       "         96.19676988,   0.62355   ],\n",
+       "       [  0.        ,  98.7697645 ,   0.62355   ,   0.        ,\n",
+       "         98.7697645 ,   0.62355   ],\n",
+       "       [  0.        , 101.34275913,   0.62355   ,   0.        ,\n",
+       "        101.34275913,   0.62355   ],\n",
+       "       [  0.        , 103.91575375,   0.62355   ,   0.        ,\n",
+       "        103.91575375,   0.62355   ],\n",
+       "       [  0.        , 106.48874838,   0.62355   ,   0.        ,\n",
+       "        106.48874838,   0.62355   ],\n",
+       "       [  0.        , 109.061743  ,   0.62355   ,   0.        ,\n",
+       "        109.061743  ,   0.62355   ],\n",
+       "       [  0.        , 111.63473763,   0.62355   ,   0.        ,\n",
+       "        111.63473763,   0.62355   ],\n",
+       "       [  0.        , 114.20773225,   0.62355   ,   0.        ,\n",
+       "        114.20773225,   0.62355   ],\n",
+       "       [  0.        , 116.78072688,   0.62355   ,   0.        ,\n",
+       "        116.78072688,   0.62355   ],\n",
+       "       [  0.        , 119.3537215 ,   0.62355   ,   0.        ,\n",
+       "        119.3537215 ,   0.62355   ],\n",
+       "       [  0.        , 121.92671613,   0.62355   ,   0.        ,\n",
+       "        121.92671613,   0.62355   ],\n",
+       "       [  0.        , 124.49971075,   0.62355   ,   0.        ,\n",
+       "        124.49971075,   0.62355   ],\n",
+       "       [  0.        , 127.07270538,   0.62355   ,   0.        ,\n",
+       "        127.07270538,   0.62355   ],\n",
+       "       [  0.        , 129.6457    ,   0.62355   ,   0.        ,\n",
+       "        129.6457    ,   0.62355   ],\n",
+       "       [  0.        , 132.21869463,   0.62355   ,   0.        ,\n",
+       "        132.21869463,   0.62355   ],\n",
+       "       [  0.        , 134.79168925,   0.62355   ,   0.        ,\n",
+       "        134.79168925,   0.62355   ],\n",
+       "       [  0.        , 137.36468388,   0.62355   ,   0.        ,\n",
+       "        137.36468388,   0.62355   ],\n",
+       "       [  0.        , 139.9376785 ,   0.62355   ,   0.        ,\n",
+       "        139.9376785 ,   0.62355   ],\n",
+       "       [  0.        , 142.51067313,   0.62355   ,   0.        ,\n",
+       "        142.51067313,   0.62355   ],\n",
+       "       [  0.        , 145.08366775,   0.62355   ,   0.        ,\n",
+       "        145.08366775,   0.62355   ],\n",
+       "       [  0.        , 147.65666238,   0.62355   ,   0.        ,\n",
+       "        147.65666238,   0.62355   ],\n",
+       "       [  0.        , 150.229657  ,   0.62355   ,   0.        ,\n",
+       "        150.229657  ,   0.62355   ],\n",
+       "       [  0.        , 152.80265163,   0.62355   ,   0.        ,\n",
+       "        152.80265163,   0.62355   ],\n",
+       "       [  0.        , 155.37564625,   0.62355   ,   0.        ,\n",
+       "        155.37564625,   0.62355   ],\n",
+       "       [  0.        , 157.94864088,   0.62355   ,   0.        ,\n",
+       "        157.94864088,   0.62355   ],\n",
+       "       [  0.        , 160.5216355 ,   0.62355   ,   0.        ,\n",
+       "        160.5216355 ,   0.62355   ],\n",
+       "       [  0.        , 163.09463013,   0.62355   ,   0.        ,\n",
+       "        163.09463013,   0.62355   ],\n",
+       "       [  0.        , 165.66762475,   0.62355   ,   0.        ,\n",
+       "        165.66762475,   0.62355   ],\n",
+       "       [  0.        , 168.24061938,   0.62355   ,   0.        ,\n",
+       "        168.24061938,   0.62355   ]])"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.append(meta_f1, meta_f2, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "3c47d7fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exp_U4, frames_per_traj4 = mbar.build_boltzmann(\n",
+    "    [*traj1_list, *traj2_list], \n",
+    "    np.append(meta_f1, meta_f2,axis=1), \n",
+    "    equil_temp=300.0,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "19b05f9e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All ready!\n",
+      "\n",
+      "Start of the self-consistent iteration.\n",
+      "========================================================================\n",
+      "Iter    1:\tConv=  1.6341380394\tConv_errvec=   1084.250845\n",
+      "Iter  100:\tConv=  0.0251704285\tConv_errvec=     86.058311\n",
+      "Iter  200:\tConv=  0.0050149238\tConv_errvec=     18.417146\n",
+      "Iter  300:\tConv=  0.0012157271\tConv_errvec=      5.283457\n",
+      "Iter  400:\tConv=  0.0004981859\tConv_errvec=      2.263521\n",
+      "Iter  500:\tConv=  0.0003360481\tConv_errvec=      1.296700\n",
+      "Iter  600:\tConv=  0.0002292389\tConv_errvec=      0.838519\n",
+      "Iter  700:\tConv=  0.0001562783\tConv_errvec=      0.563174\n",
+      "Iter  800:\tConv=  0.0001065208\tConv_errvec=      0.382305\n",
+      "Iter  900:\tConv=  0.0000726022\tConv_errvec=      0.260282\n",
+      "Iter 1000:\tConv=  0.0000494834\tConv_errvec=      0.177347\n",
+      "Iter 1100:\tConv=  0.0000337262\tConv_errvec=      0.120864\n",
+      "Iter 1200:\tConv=  0.0000229867\tConv_errvec=      0.082374\n",
+      "Iter 1300:\tConv=  0.0000156669\tConv_errvec=      0.056143\n",
+      "Iter 1400:\tConv=  0.0000106780\tConv_errvec=      0.038265\n",
+      "Iter 1500:\tConv=  0.0000072778\tConv_errvec=      0.026080\n",
+      "Iter 1600:\tConv=  0.0000049603\tConv_errvec=      0.017775\n",
+      "Iter 1700:\tConv=  0.0000033808\tConv_errvec=      0.012115\n",
+      "Iter 1800:\tConv=  0.0000023042\tConv_errvec=      0.008257\n",
+      "Iter 1900:\tConv=  0.0000015705\tConv_errvec=      0.005628\n",
+      "Iter 2000:\tConv=  0.0000010704\tConv_errvec=      0.003836\n",
+      "Iter 2100:\tConv=  0.0000007295\tConv_errvec=      0.002614\n",
+      "Iter 2200:\tConv=  0.0000004972\tConv_errvec=      0.001782\n",
+      "Iter 2300:\tConv=  0.0000003389\tConv_errvec=      0.001214\n",
+      "Iter 2400:\tConv=  0.0000002310\tConv_errvec=      0.000828\n",
+      "Iter 2500:\tConv=  0.0000001574\tConv_errvec=      0.000564\n",
+      "Iter 2600:\tConv=  0.0000001073\tConv_errvec=      0.000384\n",
+      "========================================================================\n",
+      "Converged after 2619 iterations!\n",
+      "Max error vector:       0.000357\n",
+      "========================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "weights3 = mbar.run_mbar(\n",
+    "    exp_U3,\n",
+    "    frames_per_traj3, \n",
+    "    max_iter=10000,\n",
+    "    conv=1.0e-7,\n",
+    "    conv_errvec=1.0,\n",
+    "    outfreq=100,\n",
+    "    device='cpu',\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "77817264",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pmf5,_ = mbar.pmf_from_weights(grid, np.append(cv1,cv2)[indices3], weights3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "0fc269a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7faef5f06640>]"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(grid,pmf5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "a8cc8c9e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[  0.        ,  67.893829  ,   0.62355   ],\n",
+       "       [  0.        ,  70.46682363,   0.62355   ],\n",
+       "       [  0.        ,  73.03981825,   0.62355   ],\n",
+       "       [  0.        ,  75.61281288,   0.62355   ],\n",
+       "       [  0.        ,  78.1858075 ,   0.62355   ],\n",
+       "       [  0.        ,  80.75880213,   0.62355   ],\n",
+       "       [  0.        ,  83.33179675,   0.62355   ],\n",
+       "       [  0.        ,  85.90479138,   0.62355   ],\n",
+       "       [  0.        ,  88.477786  ,   0.62355   ],\n",
+       "       [  0.        ,  91.05078063,   0.62355   ],\n",
+       "       [  0.        ,  93.62377525,   0.62355   ],\n",
+       "       [  0.        ,  96.19676988,   0.62355   ],\n",
+       "       [  0.        ,  98.7697645 ,   0.62355   ],\n",
+       "       [  0.        , 101.34275913,   0.62355   ],\n",
+       "       [  0.        , 103.91575375,   0.62355   ],\n",
+       "       [  0.        , 106.48874838,   0.62355   ],\n",
+       "       [  0.        , 109.061743  ,   0.62355   ],\n",
+       "       [  0.        , 111.63473763,   0.62355   ],\n",
+       "       [  0.        , 114.20773225,   0.62355   ],\n",
+       "       [  0.        , 116.78072688,   0.62355   ],\n",
+       "       [  0.        , 119.3537215 ,   0.62355   ],\n",
+       "       [  0.        , 121.92671613,   0.62355   ],\n",
+       "       [  0.        , 124.49971075,   0.62355   ],\n",
+       "       [  0.        , 127.07270538,   0.62355   ],\n",
+       "       [  0.        , 129.6457    ,   0.62355   ],\n",
+       "       [  0.        , 132.21869463,   0.62355   ],\n",
+       "       [  0.        , 134.79168925,   0.62355   ],\n",
+       "       [  0.        , 137.36468388,   0.62355   ],\n",
+       "       [  0.        , 139.9376785 ,   0.62355   ],\n",
+       "       [  0.        , 142.51067313,   0.62355   ],\n",
+       "       [  0.        , 145.08366775,   0.62355   ],\n",
+       "       [  0.        , 147.65666238,   0.62355   ],\n",
+       "       [  0.        , 150.229657  ,   0.62355   ],\n",
+       "       [  0.        , 152.80265163,   0.62355   ],\n",
+       "       [  0.        , 155.37564625,   0.62355   ],\n",
+       "       [  0.        , 157.94864088,   0.62355   ],\n",
+       "       [  0.        , 160.5216355 ,   0.62355   ],\n",
+       "       [  0.        , 163.09463013,   0.62355   ],\n",
+       "       [  0.        , 165.66762475,   0.62355   ],\n",
+       "       [  0.        , 168.24061938,   0.62355   ],\n",
+       "       [  0.        ,  67.893829  ,   0.62355   ],\n",
+       "       [  0.        ,  70.46682363,   0.62355   ],\n",
+       "       [  0.        ,  73.03981825,   0.62355   ],\n",
+       "       [  0.        ,  75.61281288,   0.62355   ],\n",
+       "       [  0.        ,  78.1858075 ,   0.62355   ],\n",
+       "       [  0.        ,  80.75880213,   0.62355   ],\n",
+       "       [  0.        ,  83.33179675,   0.62355   ],\n",
+       "       [  0.        ,  85.90479138,   0.62355   ],\n",
+       "       [  0.        ,  88.477786  ,   0.62355   ],\n",
+       "       [  0.        ,  91.05078063,   0.62355   ],\n",
+       "       [  0.        ,  93.62377525,   0.62355   ],\n",
+       "       [  0.        ,  96.19676988,   0.62355   ],\n",
+       "       [  0.        ,  98.7697645 ,   0.62355   ],\n",
+       "       [  0.        , 101.34275913,   0.62355   ],\n",
+       "       [  0.        , 103.91575375,   0.62355   ],\n",
+       "       [  0.        , 106.48874838,   0.62355   ],\n",
+       "       [  0.        , 109.061743  ,   0.62355   ],\n",
+       "       [  0.        , 111.63473763,   0.62355   ],\n",
+       "       [  0.        , 114.20773225,   0.62355   ],\n",
+       "       [  0.        , 116.78072688,   0.62355   ],\n",
+       "       [  0.        , 119.3537215 ,   0.62355   ],\n",
+       "       [  0.        , 121.92671613,   0.62355   ],\n",
+       "       [  0.        , 124.49971075,   0.62355   ],\n",
+       "       [  0.        , 127.07270538,   0.62355   ],\n",
+       "       [  0.        , 129.6457    ,   0.62355   ],\n",
+       "       [  0.        , 132.21869463,   0.62355   ],\n",
+       "       [  0.        , 134.79168925,   0.62355   ],\n",
+       "       [  0.        , 137.36468388,   0.62355   ],\n",
+       "       [  0.        , 139.9376785 ,   0.62355   ],\n",
+       "       [  0.        , 142.51067313,   0.62355   ],\n",
+       "       [  0.        , 145.08366775,   0.62355   ],\n",
+       "       [  0.        , 147.65666238,   0.62355   ],\n",
+       "       [  0.        , 150.229657  ,   0.62355   ],\n",
+       "       [  0.        , 152.80265163,   0.62355   ],\n",
+       "       [  0.        , 155.37564625,   0.62355   ],\n",
+       "       [  0.        , 157.94864088,   0.62355   ],\n",
+       "       [  0.        , 160.5216355 ,   0.62355   ],\n",
+       "       [  0.        , 163.09463013,   0.62355   ],\n",
+       "       [  0.        , 165.66762475,   0.62355   ],\n",
+       "       [  0.        , 168.24061938,   0.62355   ]])"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.concatenate([meta_f1, meta_f2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "b9f796b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def combine_simulations(list_of_trajs: list, list_of_metafs: list):\n",
+    "    meta_f = np.concatenate(list_of_metafs, axis=1)\n",
+    "    traj_list = []\n",
+    "    for traj in list_of_trajs:\n",
+    "        traj_list += traj\n",
+    "    exp_U, frames_per_traj = mbar.build_boltzmann(\n",
+    "        [traj for traj in list_of_trajs], \n",
+    "        meta_f, \n",
+    "        equil_temp=300.0,\n",
+    "    )\n",
+    "    return exp_U, frames_per_traj"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "e8d2057b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All ready!\n",
+      "\n",
+      "Start of the self-consistent iteration.\n",
+      "========================================================================\n",
+      "Iter    1:\tConv=  1.6341380394\tConv_errvec=    916.785316\n",
+      "Iter  100:\tConv=  0.0251704285\tConv_errvec=     71.250597\n",
+      "Iter  200:\tConv=  0.0050149238\tConv_errvec=     15.315728\n",
+      "Iter  300:\tConv=  0.0012157271\tConv_errvec=      4.393731\n",
+      "Iter  400:\tConv=  0.0004981859\tConv_errvec=      1.882348\n",
+      "Iter  500:\tConv=  0.0003360481\tConv_errvec=      1.078338\n",
+      "Iter  600:\tConv=  0.0002292389\tConv_errvec=      0.697314\n",
+      "Iter  700:\tConv=  0.0001562783\tConv_errvec=      0.468336\n",
+      "Iter  800:\tConv=  0.0001065208\tConv_errvec=      0.317925\n",
+      "========================================================================\n",
+      "Converged after 817 iterations!\n",
+      "Max error vector:       0.297778\n",
+      "========================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "# generate windows for all simulations\n",
+    "#   -> each simulation might use its own grid and ext_sigma\n",
+    "#   -> the bin width in the grid should always be chosen <= ext_sigma!\n",
+    "traj_list1, indices1, meta_f1 = mbar.get_windows(\n",
+    "    grid,              \n",
+    "    cv1,               \n",
+    "    la1, \n",
+    "    ext_sigma,         \n",
+    "    equil_temp=300.0   \n",
+    ")\n",
+    "traj_list2, indices2, meta_f2 = mbar.get_windows(\n",
+    "    grid,               \n",
+    "    cv2,               \n",
+    "    la2, \n",
+    "    ext_sigma,         \n",
+    "    equil_temp=300.0\n",
+    ")\n",
+    "\n",
+    "# combine all meta_fs and traj_lists\n",
+    "all_metafs = np.concatenate([meta_f1, meta_f2, ])  \n",
+    "all_trajs = [\n",
+    "    *traj_list1, \n",
+    "    *traj_list2, \n",
+    "]           \n",
+    "\n",
+    "# build boltzmann factors and run MBAR over combined data\n",
+    "exp_U, frames_per_traj = mbar.build_boltzmann(\n",
+    "    all_trajs, \n",
+    "    all_metafs, \n",
+    "    equil_temp=300.0,\n",
+    ")\n",
+    "weights = mbar.run_mbar(\n",
+    "    exp_U,\n",
+    "    frames_per_traj, \n",
+    "    max_iter=10000,\n",
+    "    conv=1.0e-4,\n",
+    "    conv_errvec=1.0,\n",
+    "    outfreq=100,\n",
+    "    device='cpu',\n",
+    ")\n",
+    "\n",
+    "# weights have to be assigned to correct data frame! \n",
+    "cv_data_combined = np.concatenate([cv1[indices1], cv2[indices2], ])\n",
+    "\n",
+    "# get pmf from combined data\n",
+    "#  -> the grid can again be different from before\n",
+    "#  -> reweighting of PMFs to a different CV can be achieved by using the corresponding trajectory\n",
+    "pmf,_ = mbar.pmf_from_weights(\n",
+    "    grid, \n",
+    "    cv_data_combined, \n",
+    "    weights,\n",
+    "    equil_temp=300.0,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "963ae528",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7faef5ee2b80>]"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(grid, pmf)\n",
+    "plt.plot(grid, pmf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dcfa48a2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.9.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/2D_potentials/meta-eabf/MW/W1/md_2d_metaeabf.py b/examples/2D_potentials/meta-eabf/MW/W1/md_2d_metaeabf.py
new file mode 100644
index 0000000..17943aa
--- /dev/null
+++ b/examples/2D_potentials/meta-eabf/MW/W1/md_2d_metaeabf.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+import random
+from adaptive_sampling.sampling_tools.metaeabf import WTMeABF
+from adaptive_sampling.interface.interfaceMD_2D import *
+from adaptive_sampling.units import *
+
+################# Imput Section ####################
+# MD
+seed = random.randint(0,10000)
+nsteps = 100000  # number of MD steps
+dt = 5.0e0  # stepsize in fs
+target_temp = 300.0  # Kelvin
+mass = 10.0  # a.u.
+potential = "1"
+
+# eABF
+ats = [["x", [], 70.0, 170.0, 2.0]]
+N_full = 100
+
+step_count = 0
+coords = [71.0, 0]
+the_md = MD(
+    mass_in=mass,
+    coords_in=coords,
+    potential=potential,
+    dt_in=dt,
+    target_temp_in=target_temp,
+    seed_in=seed,
+)
+the_abm = WTMeABF(
+    2.0,
+    20.0,
+    2.0,
+    4.0,
+    the_md,
+    ats,
+    hill_drop_freq=20,
+    output_freq=1000,
+    f_conf=1000.0,
+    equil_temp=300.0,
+    force_from_grid=True,
+    multiple_walker=True,
+)
+# the_abm.restart()
+
+step_dict = {
+    'mw_file': '../shared_bias1', 
+    'sync_interval': 5000,
+    'output_file': 'wtmeabf1.out',
+    'traj_file': 'CV_traj1.dat',
+    'restart_file': 'restart_wtmeabf1',
+}
+
+the_md.calc_init()
+the_md.forces += the_abm.step_bias(**step_dict)
+the_md.calc_etvp()
+
+################# the MD loop ####################
+print(
+    "%11s\t%14s\t%14s\t%14s\t%14s\t%14s\t%14s"
+    % ("time [fs]", "x", "y", "E_pot", "E_kin", "E_tot", "T")
+)
+print(
+    "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+    % (
+        the_md.step * the_md.dt * atomic_to_fs,
+        the_md.coords[0],
+        the_md.coords[1],
+        the_md.epot,
+        the_md.ekin,
+        the_md.epot + the_md.ekin,
+        the_md.temp,
+    )
+)
+
+while step_count < nsteps:
+    the_md.step += 1
+    step_count += 1
+
+    the_md.propagate(langevin=True)
+    the_md.calc()
+
+    the_md.forces += the_abm.step_bias(**step_dict)
+
+    the_md.up_momenta(langevin=True)
+    the_md.calc_etvp()
+
+    print(
+        "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+        % (
+            the_md.step * the_md.dt * atomic_to_fs,
+            the_md.coords[0],
+            the_md.coords[1],
+            the_md.epot,
+            the_md.ekin,
+            the_md.epot + the_md.ekin,
+            the_md.temp,
+        )
+    )
diff --git a/examples/2D_potentials/meta-eabf/MW/W2/md_2d_metaeabf.py b/examples/2D_potentials/meta-eabf/MW/W2/md_2d_metaeabf.py
new file mode 100644
index 0000000..17943aa
--- /dev/null
+++ b/examples/2D_potentials/meta-eabf/MW/W2/md_2d_metaeabf.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+import random
+from adaptive_sampling.sampling_tools.metaeabf import WTMeABF
+from adaptive_sampling.interface.interfaceMD_2D import *
+from adaptive_sampling.units import *
+
+################# Imput Section ####################
+# MD
+seed = random.randint(0,10000)
+nsteps = 100000  # number of MD steps
+dt = 5.0e0  # stepsize in fs
+target_temp = 300.0  # Kelvin
+mass = 10.0  # a.u.
+potential = "1"
+
+# eABF
+ats = [["x", [], 70.0, 170.0, 2.0]]
+N_full = 100
+
+step_count = 0
+coords = [71.0, 0]
+the_md = MD(
+    mass_in=mass,
+    coords_in=coords,
+    potential=potential,
+    dt_in=dt,
+    target_temp_in=target_temp,
+    seed_in=seed,
+)
+the_abm = WTMeABF(
+    2.0,
+    20.0,
+    2.0,
+    4.0,
+    the_md,
+    ats,
+    hill_drop_freq=20,
+    output_freq=1000,
+    f_conf=1000.0,
+    equil_temp=300.0,
+    force_from_grid=True,
+    multiple_walker=True,
+)
+# the_abm.restart()
+
+step_dict = {
+    'mw_file': '../shared_bias1', 
+    'sync_interval': 5000,
+    'output_file': 'wtmeabf1.out',
+    'traj_file': 'CV_traj1.dat',
+    'restart_file': 'restart_wtmeabf1',
+}
+
+the_md.calc_init()
+the_md.forces += the_abm.step_bias(**step_dict)
+the_md.calc_etvp()
+
+################# the MD loop ####################
+print(
+    "%11s\t%14s\t%14s\t%14s\t%14s\t%14s\t%14s"
+    % ("time [fs]", "x", "y", "E_pot", "E_kin", "E_tot", "T")
+)
+print(
+    "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+    % (
+        the_md.step * the_md.dt * atomic_to_fs,
+        the_md.coords[0],
+        the_md.coords[1],
+        the_md.epot,
+        the_md.ekin,
+        the_md.epot + the_md.ekin,
+        the_md.temp,
+    )
+)
+
+while step_count < nsteps:
+    the_md.step += 1
+    step_count += 1
+
+    the_md.propagate(langevin=True)
+    the_md.calc()
+
+    the_md.forces += the_abm.step_bias(**step_dict)
+
+    the_md.up_momenta(langevin=True)
+    the_md.calc_etvp()
+
+    print(
+        "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+        % (
+            the_md.step * the_md.dt * atomic_to_fs,
+            the_md.coords[0],
+            the_md.coords[1],
+            the_md.epot,
+            the_md.ekin,
+            the_md.epot + the_md.ekin,
+            the_md.temp,
+        )
+    )
diff --git a/examples/2D_potentials/meta-eabf/MW/mbar_analysis.py b/examples/2D_potentials/meta-eabf/MW/mbar_analysis.py
new file mode 100644
index 0000000..2671ac6
--- /dev/null
+++ b/examples/2D_potentials/meta-eabf/MW/mbar_analysis.py
@@ -0,0 +1,73 @@
+import numpy as np
+from adaptive_sampling.processing_tools import mbar
+
+traj1 = np.loadtxt("W1/CV_traj1.dat", skiprows=1)
+traj2 = np.loadtxt("W2/CV_traj1.dat", skiprows=1)
+
+ext_sigma = 2.0
+
+minimum   = traj1.min()
+maximum   = traj1.max()
+bin_width = 2.0
+
+grid = np.arange(minimum, maximum, bin_width)
+
+cv1 = traj1[:,1]  # trajectory of collective variable
+la1 = traj1[:,2]  # trajectory of extended system (for US: center of window)
+
+traj1_list, indices1, meta_f1 = mbar.get_windows(grid, cv1, la1, ext_sigma, equil_temp=300.0)
+
+exp_U1, frames_per_traj1 = mbar.build_boltzmann(
+    traj1_list,
+    meta_f1,
+    equil_temp=300.0,
+)
+
+weights1 = mbar.run_mbar(
+    exp_U1,
+    frames_per_traj1,
+    max_iter=10000,
+    conv=1.0e-7,
+    conv_errvec=1.0,
+    outfreq=100,
+    device='cpu',
+)
+
+pmf1, _ = mbar.pmf_from_weights(grid, cv1[indices1], weights1, equil_temp=300.0)
+
+cv2 = traj2[:,1]  # trajectory of collective variable
+la2 = traj2[:,2]  # trajectory of extended system (for US: center of window)
+
+traj2_list, indices2, meta_f2 = mbar.get_windows(grid, cv2, la2, ext_sigma, equil_temp=300.0)
+
+exp_U2, frames_per_traj2 = mbar.build_boltzmann(
+    traj2_list,
+    meta_f2,
+    equil_temp=300.0,
+)
+
+weights2 = mbar.run_mbar(
+    exp_U2,
+    frames_per_traj2,
+    max_iter=10000,
+    conv=1.0e-7,
+    conv_errvec=1.0,
+    outfreq=100,
+    device='cpu',
+)
+
+pmf2, _ = mbar.pmf_from_weights(grid, cv2[indices1], weights2, equil_temp=300.0)
+
+weights_full = np.append(weigths1, weights2)
+weights_full /= weights_full.sum()
+
+cv_full      = np.append(cv1[indices1], cv2[indices2])
+
+pmf_full, _ = mbar.pmf_from_weights(grid, cv_full, weights_full, equil_temp=300.0)
+
+np.savez(
+    "results",
+    pmf1=pmf1,
+    pmf2=pmf2,
+    pmf=pmf_full,
+)
diff --git a/examples/2D_potentials/path_cv/P1/confined/guess_path.xyz b/examples/2D_potentials/path_cv/P1/confined/guess_path.xyz
new file mode 100644
index 0000000..ff68d3c
--- /dev/null
+++ b/examples/2D_potentials/path_cv/P1/confined/guess_path.xyz
@@ -0,0 +1,33 @@
+1
+
+H    70.0     0.0    0.0
+1
+
+H    80.0     0.0    0.0 
+1
+
+H    90.0     0.0    0.0
+1
+
+H   100.0     0.0    0.0
+1
+
+H   110.0     0.0    0.0
+1
+
+H   120.0     0.0    0.0
+1
+
+H   130.0     0.0    0.0
+1
+
+H   140.0     0.0    0.0
+1
+
+H   150.0     0.0    0.0
+1
+
+H   160.0     0.0    0.0
+1
+
+H   170.0     0.0    0.0
diff --git a/examples/2D_potentials/path_cv/P1/confined/guess_path2.xyz b/examples/2D_potentials/path_cv/P1/confined/guess_path2.xyz
new file mode 100644
index 0000000..8880b2f
--- /dev/null
+++ b/examples/2D_potentials/path_cv/P1/confined/guess_path2.xyz
@@ -0,0 +1,33 @@
+1
+
+H    70.0     0.0     0.0
+1
+
+H    80.0     0.5     0.0 
+1
+
+H    90.0     1.0     0.0
+1
+
+H   100.0     1.5     0.0
+1
+
+H   110.0     2.0     0.0
+1
+
+H   120.0     2.25    0.0
+1
+
+H   130.0     2.0     0.0
+1
+
+H   140.0     1.5     0.0
+1
+
+H   150.0     1.0     0.0
+1
+
+H   160.0     0.5     0.0
+1
+
+H   170.0     0.00    0.0
diff --git a/examples/2D_potentials/path_cv/P1/confined/md_2d_metaeabf.py b/examples/2D_potentials/path_cv/P1/confined/md_2d_metaeabf.py
new file mode 100644
index 0000000..1244b3f
--- /dev/null
+++ b/examples/2D_potentials/path_cv/P1/confined/md_2d_metaeabf.py
@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+from adaptive_sampling.sampling_tools import WTM, eABF, Reference, WTMeABF
+from adaptive_sampling.interface.interfaceMD_2D import *
+from adaptive_sampling.units import *
+
+################# Imput Section ####################
+# MD
+seed = 42
+nsteps = 200000  # number of MD steps
+dt = 5.0e0  # stepsize in fs
+target_temp = 300.0  # Kelvin
+mass = 10.0  # a.u.
+potential = "1"
+
+# eABF
+dev = [
+    {
+        "guess_path": "guess_path2.xyz",
+        "metric": "2d",
+        "verbose": True,
+        "n_interpolate": 1,
+        "adaptive": True,
+        "update_interval": 1000,
+        "half_life": 5000,
+        }
+]
+tube = True
+
+ats = [["path", dev, 0.0, 1.0, 0.05]]
+
+conf = [["GPath_distance", dev, 0.0, 0.0, 0.0]]
+
+N_full = 100
+
+step_count = 0
+coords = [80.0, 1.0]
+the_md = MD(
+    mass_in=mass,
+    coords_in=coords,
+    potential=potential,
+    dt_in=dt,
+    target_temp_in=target_temp,
+    seed_in=seed,
+)
+the_abm = WTMeABF(
+    0.05,
+    40.0,
+    0.5,
+    0.1,
+    the_md,
+    ats,
+    nfull=100,
+    output_freq=10,
+    f_conf=1000.0,
+    equil_temp=300.0,
+    multiple_walker=False,
+)
+if tube:
+    the_conf = Reference(
+        the_md,
+        conf,
+        nfull=100,
+        output_freq=1000,
+        f_conf=5.0,
+        equil_temp=300.0,
+        multiple_walker=False,
+    )
+
+# the_abm.restart()
+
+the_md.calc_init()
+the_abm.step_bias()
+if tube:
+    the_conf.step_bias()
+the_md.calc_etvp()
+
+
+################# the MD loop ####################
+print(
+    "%11s\t%14s\t%14s\t%14s\t%14s\t%14s\t%14s"
+    % ("time [fs]", "x", "y", "E_pot", "E_kin", "E_tot", "T")
+)
+print(
+    "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+    % (
+        the_md.step * the_md.dt * atomic_to_fs,
+        the_md.coords[0],
+        the_md.coords[1],
+        the_md.epot,
+        the_md.ekin,
+        the_md.epot + the_md.ekin,
+        the_md.temp,
+    )
+)
+
+while step_count < nsteps:
+    the_md.step += 1
+    step_count += 1
+
+    the_md.propagate(langevin=True)
+    the_md.calc()
+    
+    the_abm.the_cv.pathcv.adaptive = True
+    the_md.forces += the_abm.step_bias()
+    if tube:
+        the_abm.the_cv.pathcv.adaptive = False
+        the_md.forces += the_conf.step_bias()
+
+    the_md.up_momenta(langevin=True)
+    the_md.calc_etvp()
+
+    print(
+        "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+        % (
+            the_md.step * the_md.dt * atomic_to_fs,
+            the_md.coords[0],
+            the_md.coords[1],
+            the_md.epot,
+            the_md.ekin,
+            the_md.epot + the_md.ekin,
+            the_md.temp,
+        )
+    )
+    if not the_md.step % 10000 and dev[0]["adaptive"]:
+        the_abm.the_cv.pathcv.write_path(filename=f'path_{step_count}.npy')
diff --git a/examples/2D_potentials/path_cv/P1/unconfined/guess_path.xyz b/examples/2D_potentials/path_cv/P1/unconfined/guess_path.xyz
new file mode 100644
index 0000000..ff68d3c
--- /dev/null
+++ b/examples/2D_potentials/path_cv/P1/unconfined/guess_path.xyz
@@ -0,0 +1,33 @@
+1
+
+H    70.0     0.0    0.0
+1
+
+H    80.0     0.0    0.0 
+1
+
+H    90.0     0.0    0.0
+1
+
+H   100.0     0.0    0.0
+1
+
+H   110.0     0.0    0.0
+1
+
+H   120.0     0.0    0.0
+1
+
+H   130.0     0.0    0.0
+1
+
+H   140.0     0.0    0.0
+1
+
+H   150.0     0.0    0.0
+1
+
+H   160.0     0.0    0.0
+1
+
+H   170.0     0.0    0.0
diff --git a/examples/2D_potentials/path_cv/P1/unconfined/guess_path2.xyz b/examples/2D_potentials/path_cv/P1/unconfined/guess_path2.xyz
new file mode 100644
index 0000000..8880b2f
--- /dev/null
+++ b/examples/2D_potentials/path_cv/P1/unconfined/guess_path2.xyz
@@ -0,0 +1,33 @@
+1
+
+H    70.0     0.0     0.0
+1
+
+H    80.0     0.5     0.0 
+1
+
+H    90.0     1.0     0.0
+1
+
+H   100.0     1.5     0.0
+1
+
+H   110.0     2.0     0.0
+1
+
+H   120.0     2.25    0.0
+1
+
+H   130.0     2.0     0.0
+1
+
+H   140.0     1.5     0.0
+1
+
+H   150.0     1.0     0.0
+1
+
+H   160.0     0.5     0.0
+1
+
+H   170.0     0.00    0.0
diff --git a/examples/2D_potentials/path_cv/P1/unconfined/md_2d_metaeabf.py b/examples/2D_potentials/path_cv/P1/unconfined/md_2d_metaeabf.py
new file mode 100644
index 0000000..e806927
--- /dev/null
+++ b/examples/2D_potentials/path_cv/P1/unconfined/md_2d_metaeabf.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+from adaptive_sampling.sampling_tools import WTM, eABF, Reference, WTMeABF
+from adaptive_sampling.interface.interfaceMD_2D import *
+from adaptive_sampling.units import *
+
+################# Imput Section ####################
+# MD
+seed = 42
+nsteps = 200000  # number of MD steps
+dt = 5.0e0  # stepsize in fs
+target_temp = 300.0  # Kelvin
+mass = 10.0  # a.u.
+potential = "1"
+
+# eABF
+dev = {
+    "guess_path": "guess_path2.xyz",
+    "metric": "RMSD",
+    "coordinates": "Cartesian",
+    "ndim": 2,
+    "verbose": True,
+    "n_interpolate": 1,
+    "adaptive": True,
+    "update_interval": 1000,
+    "half_life": 5000,
+}
+
+tube = False
+
+ats = [["path", dev, 0.0, 1.0, 0.05]]
+
+conf = [["GPath_distance", dev, 0.0, 0.0, 0.0]]
+
+N_full = 100
+
+step_count = 0
+coords = [80.0, 1.0]
+the_md = MD(
+    mass_in=mass,
+    coords_in=coords,
+    potential=potential,
+    dt_in=dt,
+    target_temp_in=target_temp,
+    seed_in=seed,
+)
+the_abm = WTMeABF(
+    0.05,
+    40.0,
+    0.5,
+    0.1,
+    the_md,
+    ats,
+    nfull=100,
+    output_freq=10,
+    f_conf=1000.0,
+    equil_temp=300.0,
+    multiple_walker=False,
+)
+if tube:
+    the_conf = Reference(
+        the_md,
+        conf,
+        nfull=100,
+        output_freq=1000,
+        f_conf=5.0,
+        equil_temp=300.0,
+        multiple_walker=False,
+    )
+
+# the_abm.restart()
+
+the_md.calc_init()
+the_abm.step_bias()
+if tube:
+    the_conf.step_bias()
+the_md.calc_etvp()
+
+
+################# the MD loop ####################
+print(
+    "%11s\t%14s\t%14s\t%14s\t%14s\t%14s\t%14s"
+    % ("time [fs]", "x", "y", "E_pot", "E_kin", "E_tot", "T")
+)
+print(
+    "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+    % (
+        the_md.step * the_md.dt * atomic_to_fs,
+        the_md.coords[0],
+        the_md.coords[1],
+        the_md.epot,
+        the_md.ekin,
+        the_md.epot + the_md.ekin,
+        the_md.temp,
+    )
+)
+
+while step_count < nsteps:
+    the_md.step += 1
+    step_count += 1
+
+    the_md.propagate(langevin=True)
+    the_md.calc()
+    
+    the_abm.the_cv.pathcv.adaptive = True
+    the_md.forces += the_abm.step_bias()
+    if tube:
+        the_abm.the_cv.pathcv.adaptive = False
+        the_md.forces += the_conf.step_bias()
+
+    the_md.up_momenta(langevin=True)
+    the_md.calc_etvp()
+
+    print(
+        "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+        % (
+            the_md.step * the_md.dt * atomic_to_fs,
+            the_md.coords[0],
+            the_md.coords[1],
+            the_md.epot,
+            the_md.ekin,
+            the_md.epot + the_md.ekin,
+            the_md.temp,
+        )
+    )
+    if not the_md.step % 10000 and dev[0]["adaptive"]:
+        the_abm.the_cv.pathcv.write_path(filename=f'path_{step_count}.npy')
diff --git a/examples/2D_potentials/path_cv/P2/guess_path.xyz b/examples/2D_potentials/path_cv/P2/guess_path.xyz
new file mode 100644
index 0000000..54983e2
--- /dev/null
+++ b/examples/2D_potentials/path_cv/P2/guess_path.xyz
@@ -0,0 +1,63 @@
+1
+
+H    -50.0    -30.0    0.0
+1
+
+H    -45.0    -27.0    0.0
+1
+
+H    -40.0    -24.0    0.0
+1
+
+H    -35.0    -21.0    0.0
+1
+
+H    -30.0    -18.0     0.0
+1
+
+H    -25.0    -15.0     0.0
+1
+
+H    -20.0    -12.0     0.0
+1
+
+H    -15.0     -9.0     0.0
+1
+
+H    -10.0     -6.0     0.0
+1
+
+H    -5.0      -3.0     0.0
+1
+
+H     0.0       0.0     0.0
+1
+
+H      5.0      3.0    0.0
+1
+
+H     10.6      6.0    0.0
+1
+
+H     15.0      9.0    0.0
+1
+
+H     20.0     12.0    0.0
+1
+
+H     25.0     15.0    0.0
+1
+
+H     30.0     18.0    0.0
+1
+
+H     35.0     21.0    0.0
+1
+
+H     40.0     24.0    0.0
+1
+
+H     45.0     27.0    0.0
+1
+
+H     50.0     30.0    0.0
diff --git a/examples/2D_potentials/path_cv/P2/md_2d_metaeabf.py b/examples/2D_potentials/path_cv/P2/md_2d_metaeabf.py
new file mode 100644
index 0000000..e7017ef
--- /dev/null
+++ b/examples/2D_potentials/path_cv/P2/md_2d_metaeabf.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+import time
+from adaptive_sampling.sampling_tools import WTM, eABF, Reference, WTMeABF
+from adaptive_sampling.interface.interfaceMD_2D import *
+from adaptive_sampling.units import *
+
+################# Imput Section ####################
+# MD
+seed = 42
+nsteps = 100000  # number of MD steps
+dt = 5.0e0  # stepsize in fs
+target_temp = 300.0  # Kelvin
+mass = 10.0  # a.u.
+potential = "2"
+
+# eABF
+dev = [
+    {
+        "guess_path": "guess_path.xyz",
+        "metric": "2d",
+        "verbose": True,
+        "n_interpolate": 0,
+        "adaptive": True,
+        "update_interval": 1000,
+        "half_life": 100,
+        }
+]
+tube = False
+
+ats = [["path", dev, 0.0, 1.0, 0.05]]
+conf = [["GPath_tube", dev, 0.0, 0.0, 0.0]]
+N_full = 100
+
+step_count = 0
+coords = [-50.0, -30.0]
+the_md = MD(
+    mass_in=mass,
+    coords_in=coords,
+    potential=potential,
+    dt_in=dt,
+    target_temp_in=target_temp,
+    seed_in=seed,
+)
+the_abm = WTMeABF(
+    0.05,
+    40.0,
+    0.5,
+    0.1,
+    the_md,
+    ats,
+    nfull=100,
+    output_freq=10,
+    f_conf=1000.0,
+    equil_temp=300.0,
+    multiple_walker=False,
+)
+if tube:
+    the_conf = Reference(
+        the_md,
+        conf,
+        nfull=100,
+        output_freq=1000,
+        f_conf=50.0,
+        equil_temp=300.0,
+        multiple_walker=False,
+    )
+
+# the_abm.restart()
+the_md.calc_init()
+the_abm.step_bias()
+if tube:
+    the_conf.step_bias()
+the_md.calc_etvp()
+
+
+################# the MD loop ####################
+print(
+    "%11s\t%14s\t%14s\t%14s\t%14s\t%14s\t%14s"
+    % ("time [fs]", "x", "y", "E_pot", "E_kin", "E_tot", "T")
+)
+print(
+    "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+    % (
+        the_md.step * the_md.dt * atomic_to_fs,
+        the_md.coords[0],
+        the_md.coords[1],
+        the_md.epot,
+        the_md.ekin,
+        the_md.epot + the_md.ekin,
+        the_md.temp,
+    )
+)
+
+while step_count < nsteps:
+    the_md.step += 1
+    step_count += 1
+
+    the_md.propagate(langevin=True)
+    t = time.perf_counter()
+    the_md.calc()
+    calc_time = time.perf_counter() - t
+    t = time.perf_counter()
+    the_md.forces += the_abm.step_bias()
+    bias_time = time.perf_counter() - t 
+    if tube:
+        the_md.forces += the_conf.step_bias()
+
+    the_md.up_momenta(langevin=True)
+    the_md.calc_etvp()
+
+    print(
+        "%11.2f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f\t%14.6f"
+        % (
+            the_md.step * the_md.dt * atomic_to_fs,
+            the_md.coords[0],
+            the_md.coords[1],
+            the_md.epot,
+            the_md.ekin,
+            the_md.epot + the_md.ekin,
+            the_md.temp,
+            calc_time,
+            bias_time,
+        )
+    )
+    if not the_md.step % 1000 and dev[0]["adaptive"]:
+        the_abm.the_cv.pathcv.write_path(filename=f'path_{step_count}.npy')
diff --git a/examples/JCP_2022_mbar_and_eabf/skewed_potential/analysis.ipynb b/examples/JCP_2022_mbar_and_eabf/skewed_potential/analysis.ipynb
index a04ae14..49fe443 100644
--- a/examples/JCP_2022_mbar_and_eabf/skewed_potential/analysis.ipynb
+++ b/examples/JCP_2022_mbar_and_eabf/skewed_potential/analysis.ipynb
@@ -25,7 +25,15 @@
   },
   {
    "cell_type": "code",
+<<<<<<< HEAD
+<<<<<<< Updated upstream
+   "execution_count": 11,
+=======
+   "execution_count": 2,
+>>>>>>> Stashed changes
+=======
    "execution_count": null,
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
    "id": "ec7c7d81",
    "metadata": {},
    "outputs": [],
@@ -35,7 +43,15 @@
   },
   {
    "cell_type": "code",
+<<<<<<< HEAD
+<<<<<<< Updated upstream
+   "execution_count": 12,
+=======
+   "execution_count": 3,
+>>>>>>> Stashed changes
+=======
    "execution_count": null,
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
    "id": "c5c713d6",
    "metadata": {},
    "outputs": [],
@@ -54,10 +70,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "4febea7a",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f093b6bb3d0>]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.plot(cv)\n",
     "plt.plot(la)"
@@ -71,9 +110,37 @@
    "outputs": [],
    "source": [
     "# run MBAR and compute free energy profile and probability density from statistical weights\n",
+<<<<<<< Updated upstream
     "traj_list, indices, meta_f = mbar.get_windows(grid, cv, la, ext_sigma, equil_temp=300.0)\n",
+<<<<<<< HEAD
+    "weights = mbar.run_mbar(traj_list, meta_f, conv=1.0e-4, conv_errvec=None, outfreq=100, equil_temp=300.0)"
+=======
+    "traj_list, indices, meta_f = mbar.get_windows(\n",
+    "    grid, \n",
+    "    cv, \n",
+    "    la, \n",
+    "    ext_sigma, \n",
+    "    equil_temp=300.0\n",
+    ")\n",
+    "exp_U, frames_per_traj = mbar.build_boltzmann(\n",
+    "    traj_list, \n",
+    "    meta_f, \n",
+    "    equil_temp=300.0\n",
+    ")\n",
+    "weights = mbar.run_mbar(\n",
+    "    exp_U, \n",
+    "    frames_per_traj, \n",
+    "    max_iter=10000, \n",
+    "    conv=1.0e-4, \n",
+    "    conv_errvec=1.0, \n",
+    "    outfreq=100, \n",
+    "    device='cpu'\n",
+    ")"
+>>>>>>> Stashed changes
+=======
     "exp_U, frames_per_traj = mbar.build_boltzmann(traj_list, meta_f, equil_temp=300.0)\n",
     "weights = mbar.run_mbar(exp_U, frames_per_traj, max_iter=10000, conv=1.0e-4, conv_errvec=1.0, outfreq=100, device='cpu')"
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
    ]
   },
   {
@@ -136,7 +203,15 @@
   },
   {
    "cell_type": "code",
+<<<<<<< HEAD
+<<<<<<< Updated upstream
+   "execution_count": 13,
+=======
+   "execution_count": 85,
+>>>>>>> Stashed changes
+=======
    "execution_count": null,
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
    "id": "cdf887bf",
    "metadata": {},
    "outputs": [],
@@ -146,7 +221,15 @@
   },
   {
    "cell_type": "code",
+<<<<<<< HEAD
+<<<<<<< Updated upstream
+   "execution_count": 14,
+=======
+   "execution_count": 86,
+>>>>>>> Stashed changes
+=======
    "execution_count": null,
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
    "id": "46f5b5fb",
    "metadata": {},
    "outputs": [],
@@ -158,10 +241,55 @@
   },
   {
    "cell_type": "code",
+<<<<<<< HEAD
+<<<<<<< Updated upstream
+   "execution_count": 15,
+=======
+   "execution_count": 87,
+>>>>>>> Stashed changes
+   "id": "c8f82862",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+<<<<<<< Updated upstream
+       "[<matplotlib.lines.Line2D at 0x7fc7b8790730>]"
+      ]
+     },
+     "execution_count": 15,
+=======
+       "[<matplotlib.lines.Line2D at 0x7f092f663a90>]"
+      ]
+     },
+     "execution_count": 87,
+>>>>>>> Stashed changes
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+<<<<<<< Updated upstream
+      "image/png": "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\n",
+=======
+      "image/png": "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\n",
+>>>>>>> Stashed changes
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+=======
    "execution_count": null,
    "id": "c8f82862",
    "metadata": {},
    "outputs": [],
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
    "source": [
     "plt.plot(cv)\n",
     "plt.plot(la)"
@@ -169,21 +297,116 @@
   },
   {
    "cell_type": "code",
+<<<<<<< HEAD
+<<<<<<< Updated upstream
+   "execution_count": 16,
+=======
+   "execution_count": 88,
+>>>>>>> Stashed changes
+   "id": "b059cb98",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+<<<<<<< Updated upstream
+      "Making Boltzmann factors\n",
+      "\n",
+=======
+>>>>>>> Stashed changes
+      "All ready!\n",
+      "\n",
+      "Start of the self-consistent iteration.\n",
+      "========================================================================\n",
+<<<<<<< Updated upstream
+      "Iter    1:\tConv=  0.0367285320\tConv_errvec=    513.943248\n",
+      "Iter  100:\tConv=  0.0011664181\tConv_errvec=     30.442355\n",
+      "Iter  200:\tConv=  0.0007158388\tConv_errvec=     16.592697\n",
+      "Iter  300:\tConv=  0.0004416551\tConv_errvec=      9.952015\n",
+      "Iter  400:\tConv=  0.0002725440\tConv_errvec=      6.129032\n",
+      "Iter  500:\tConv=  0.0001681903\tConv_errvec=      3.789181\n",
+      "Iter  600:\tConv=  0.0001037929\tConv_errvec=      2.339308\n",
+      "========================================================================\n",
+      "Converged after 608 iterations!\n",
+      "Max error vector: 2.250724530684238\n",
+=======
+      "Iter    1:\tConv=  0.0389956944\tConv_errvec=    557.234657\n",
+      "Iter  100:\tConv=  0.0006535118\tConv_errvec=     18.162725\n",
+      "Iter  200:\tConv=  0.0003502178\tConv_errvec=      8.112046\n",
+      "Iter  300:\tConv=  0.0002170335\tConv_errvec=      4.668850\n",
+      "Iter  400:\tConv=  0.0001345971\tConv_errvec=      2.910957\n",
+      "Iter  500:\tConv=  0.0000834728\tConv_errvec=      1.813296\n",
+      "Iter  600:\tConv=  0.0000517669\tConv_errvec=      1.125652\n",
+      "========================================================================\n",
+      "Converged after 625 iterations!\n",
+      "Max error vector:       0.999009\n",
+>>>>>>> Stashed changes
+      "========================================================================\n"
+     ]
+    }
+   ],
+=======
    "execution_count": null,
    "id": "b059cb98",
    "metadata": {},
    "outputs": [],
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
    "source": [
     "# run MBAR and compute free energy profile and probability density from statistical weights\n",
+<<<<<<< Updated upstream
     "traj_list, indices, meta_f = mbar.get_windows(grid, cv, la, ext_sigma, equil_temp=300.0)\n",
     "pot_list, _, _ = mbar.get_windows(grid, deltaU, la, ext_sigma, equil_temp=300.0)\n",
+<<<<<<< HEAD
+    "weights = mbar.run_mbar(traj_list, meta_f, conv=1.0e-4, conv_errvec=None, outfreq=100, equil_temp=300.0, dU_list=pot_list)"
+=======
+    "traj_list, indices, meta_f = mbar.get_windows(\n",
+    "    grid, \n",
+    "    cv, \n",
+    "    la, \n",
+    "    ext_sigma, \n",
+    "    equil_temp=300.0\n",
+    ")\n",
+    "pot_list, _, _ = mbar.get_windows(\n",
+    "    grid, \n",
+    "    deltaU, \n",
+    "    la, \n",
+    "    ext_sigma, \n",
+    "    equil_temp=300.0\n",
+    ")\n",
+    "exp_U, frames_per_traj = mbar.build_boltzmann(\n",
+    "    traj_list, \n",
+    "    meta_f, \n",
+    "    dU_list=pot_list,   # adds gamd pot to boltzmann weights\n",
+    "    equil_temp=300.0, \n",
+    ")\n",
+    "weights = mbar.run_mbar(\n",
+    "    exp_U, \n",
+    "    frames_per_traj, \n",
+    "    max_iter=10000, \n",
+    "    conv=1.0e-4, \n",
+    "    conv_errvec=1.0, \n",
+    "    outfreq=100, \n",
+    "    device='cpu'\n",
+    ")"
+>>>>>>> Stashed changes
+=======
     "exp_U, frames_per_traj = mbar.build_boltzmann(traj_list, meta_f, equil_temp=300.0, dU_list=pot_list)\n",
     "weights = mbar.run_mbar(exp_U, frames_per_traj, max_iter=10000, conv=1.0e-4, conv_errvec=1.0, outfreq=100, device='cpu')"
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
    ]
   },
   {
    "cell_type": "code",
+<<<<<<< HEAD
+<<<<<<< Updated upstream
+   "execution_count": 17,
+=======
+   "execution_count": 89,
+>>>>>>> Stashed changes
+=======
    "execution_count": null,
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
    "id": "977b5279",
    "metadata": {},
    "outputs": [],
@@ -194,12 +417,30 @@
   },
   {
    "cell_type": "code",
+<<<<<<< HEAD
+<<<<<<< Updated upstream
+   "execution_count": 18,
+=======
+   "execution_count": 90,
+>>>>>>> Stashed changes
+=======
    "execution_count": null,
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
    "id": "53b9cee4",
    "metadata": {},
    "outputs": [],
    "source": [
     "# czar free energy estimate\n",
+<<<<<<< HEAD
+    "czar_force = thermodynamic_integration.czar(\n",
+    "    grid, \n",
+    "    cv, \n",
+    "    la, \n",
+    "    ext_sigma, \n",
+    "    equil_temp=300.0,\n",
+    ")\n",
+    "pmf_ti2, rho_ti2 = thermodynamic_integration.integrate(czar_force, bin_width, equil_temp=300.0)\n",
+=======
     "czar_force = thermodynamic_integration.czar(grid, cv, la, ext_sigma, equil_temp=300.0)\n",
     "pmf_ti2, rho_ti2 = thermodynamic_integration.integrate(czar_force, bin_width, equil_temp=300.0)"
    ]
@@ -214,11 +455,67 @@
     "# correction from GaMD\n",
     "correction = gamd.gamd_correction_n(grid, cv, deltaU * atomic_to_kJmol, korder=2, equil_temp=2)\n",
     "pmf_ti2 += correction\n",
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
     "pmf_ti2 -= pmf_ti2.min()"
    ]
   },
   {
    "cell_type": "code",
+<<<<<<< HEAD
+<<<<<<< Updated upstream
+   "execution_count": 19,
+=======
+   "execution_count": 93,
+>>>>>>> Stashed changes
+   "id": "1ebcfbed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# correction from GaMD\n",
+    "correction = gamd.gamd_correction_n(\n",
+    "    grid, \n",
+    "    cv, \n",
+    "    deltaU, \n",
+    "    korder=2, \n",
+    "    equil_temp=300.0,\n",
+    ")\n",
+    "pmf_ti2c = pmf_ti2 + correction\n",
+    "pmf_ti2c -= pmf_ti2c.min()"
+   ]
+  },
+  {
+   "cell_type": "code",
+<<<<<<< Updated upstream
+   "execution_count": 20,
+=======
+   "execution_count": 94,
+>>>>>>> Stashed changes
+   "id": "077d9fb8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+<<<<<<< Updated upstream
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGoCAYAAABL+58oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAB5NElEQVR4nO3dd3hUZfbA8e9JCL13BUIvIioIgoqCimBvYG9g3+KqP1111XV1XdvqurprWTsW3BV7RxQUERFBFBGR3nvvkBByfn/cmcy9U5KZybTMnM/zzOO9733vvSdByMlbRVUxxhhjjMkmeekOwBhjjDEm0SzBMcYYY0zWsQTHGGOMMVnHEhxjjDHGZB1LcIwxxhiTdSzBMcYYY0zWsQQny4nIiyKyTkRmRVG3rYiMF5GZIjJBRFqnIkZjjDEm0SzByX4vASdGWfcfwCuqejBwD/BAsoIyxhhjkskSnCynqhOBTe4yEekoIp+KyHQR+VpEuvkudQfG+46/BM5IYajGGGNMwliCk5ueBf6gqr2BPwJP+cp/Aob5js8C6olIkzTEZ4wxxlRKtXQHYFJLROoCRwJvioi/uIbvv38EnhCREcBEYCVQkuoYjTHGmMqyBCf35AFbVLVn8AVVXQUMhbJEaJiqbk1teMYYY0zlWRdVjlHVbcBiETkHQByH+I6bioj//4nbgBfTFKYxxhhTKZbgZDkR+R/wLdBVRFaIyBXARcAVIvIT8AuBwcTHAHNFZB7QArgvDSEbY4wxlSaqmu4YjDHGGGMSysbgZCERsazVGGNMTlFVcZ9bF5Uxxhhjso4lOMYYY4zJOtZFleVsjJUxxphs5VrPLYS14BhjjDEm61iCY4wxxpisYwmOMcYYY7KOJTjGGGOMyTo5n+CISAMROVdE/iMi34nIRhHZKyKbReQnEXlKRA5LwnvriMiNIvKNiKwTkT0islRERovICYl+nzHGGJNLcnolYxG5BbiHwG7a5RkFXKOquxLw3l7AW0CHcqr9F7hMVYvjeH7ZH2ou//kaY4zJbu5ZVMEL/eX6NPEuBJKbRcA4YAawAWgEDAKGAfnAxUBzETlJVUvjfaGItAXG4Oz1BDAVJ3naABwEXA00AS4ESoFL4n2XMcYYk6tyvQXnOWA/4GFgoob5ZojI0cAnQF1f0eWqOrIS73wXONN3+iJwlTthEpFC4Gug0Fd0qqp+HOM7rAXHGGNM1iuvBSfXE5xGqro5inrXAo/7Tieq6sA433cITgsRwDKgq6ruCVPvZMCf1HyvqjGNAbIExxhjTC4oL8HJ6UHG0SQ3Pm+6jg+qxCvPcx0/Gy658RkDLPAd9xGRjpV4pzEmFbavhe1r0h2FMcYnpxOcGGx3HdeqxHOGuI4/jVTJ11U21lVks6qMyVSqMPFheLQ7PNINvnoo3REZY7AEJ1o9XMdL43mAiOQBB/hOS4CfKrjl+wjvj/W9YT/GmARQhS/vhy/uhdISQOHL+2DW2+mOzJicZwlOdK52Hcc04NelNVDbd7xSVUsqqO9OpLrE+U5jTDJNeBAmhmmx+eA6WD8v9fEYY8pYglMBETkSuMx3ugd4LM5HNXQdb4ii/sYI9xpjMsGEB+GrB8NfK94Bb1wKxTtTG5MxpowlOOUQkZbAGwS+T3eq6vI4H1fXdRxpcLHbbtdxvTjfaYxJhq8ehgkPeMvyq3vP1/8KH93odGMZY1IuZQmOiDQXkQEiMiBV76wMEakDvA+08hV9DDySoMen7F88VQ37McbEackk+PJeb1n1ejDiEzjoXG/5zNfhh5dTF5sxpkwqVzI+CRiJszpvRq+gLCI1gQ+Avr6ib4Dzwi0EGIMdruNoZmK562yPWMsYk1pT/uM9r14XLn4b2hwGzQ+ANTNh/ZzA9Y9vgnW/woCboU7T1MZqTA5LRxdVRk/hEZHqwDvAcb6iqcDJqlrZzvQtruMmUdR319kSqZIxJoW2rYK5Y7xl57wMhf2c4xp14dxXoKBO4HppCXz3NPyrp9O1ZeNyjEkJG4PjIiIFOIv6neQr+hE4UVW3JeDxKwD/Rp2tRaSiVqy2rmObjmFMJvjhVdB9gfPm3aHTIG+dZl3h9H+H3lu83ena+ncvmPE/G5tjTJJZguPjSzj+B5zuK/oZGBzDasfl8u039avvtBpwSAW39HEdz0pEDMaYSthXEjqepvdlEG5dqYPOhvNeg4aFodd2rIX3fgMvnQrr5oReN8YkRIVjYUTkiwS9q2WCnpNwIpIPvIqzczjAbOB4Vd0Y+a64jAV6+45PAKZHiEfwrl48Nlw9Y0wKLfgctq0MnBfUhkPOi1z/gFOh82CY9oKz0vHuTd7rSyfB0/3hyD/AgFugeu3wzzHGxKXCzTZFpJTEzfoRnJ0I8hP0vErzrTA8ErjUVzQPGKiqCd9UxjbbNKYKe+0cmP9Z4LzXxXDGk9Hdu2crTHoMpjwFJWFWiWjUDoa9AK37hF4zxkSUqM02JQGfjOJrKXmGQHKzADg2nuRGRF4SEfV97g5XR1V/At7znRYCT/gSLPdzCgH3NI2wzzLGpNCWZTD/c29Zn8ujv79mAzj+Lvjdt9Dp+NDrm5fAiyfA1/+E0tJKhWqMcUQzXXs1TvfSh6p6RrwvEpHhOC0lmeQ+4Erf8V7g30DfKPZq+kxVd1VUKYIbgCOAFsAVQA8ReRVn5eKDgGsIzKB6TVXj3RrCGJMo01/G05Dd8mDY/9DYn9O4A1z0Fsx+Hz79E2xfHbhWWgLj/wqLJsBZz0D9/SobtTE5LZoEZypwBhBTN0kVcaTruAAnwYlGe2BJPC9U1aUichLwFtAB6Of7BPsvEMOviMaYpNi3F3581VvW5/Lwg4ujIQIHnunMvhp3N0x73nt98VfO2JwL37AuK2MqIZouqmm+/7YQkdbJDCZXqOqPwMHATcC3OHtTFQHL8U1TV9WLVLU4fVEaYwCY+4kz88mvel1nllRl1agHpzwC5/8PajX2Xtu10dnLau/u8PcaYyoUzSDj44HPcNpnz1bVd+N6UaCLKqMGGWcjG2RsTIKUlsLIE2H5d4GyPpfDqY8m9j3bVsE7V8OSr73lg/4CR9+U2HcZk0UqO8h4GrAUZ9ZP+0rEMQP4K3BPJZ5hjDGpM/VZb3IDzto3iVZ/f7j0fTj0Um/514/Czg2Jf58xOaDCFhxT9VgLjjEJsGEBPH0UlLi6iTod7+w7lSy7NztbOuzZEijrezWc/HDy3mlMFZaoaeLGGJMbSvfBe7/1Jjc16sNp/0rue2s1cjbldPv+RSfZMsbExBIcY4wJ9u0TsGKqt+zEB6FBCuZZ9L0KGrq2oistgfF3J/+9xmQZS3CMMcZt3Rz44j5vWZcToeeFqXl/tRrO4GK3Xz+EZd+Fr2+MCcsSHGOM8dtX4myEua8oUFazodM1Fe+6N/HoMSx0IcHP/mw7kBsTA0twjDHG79cPYNWP3rJTHoF6Kd4rWASG3OstWzEVFo5PbRzGVGEJTXBE5C++T+OKaxtjTIb5+S3v+QGnOa0p6dCuP3Q92Vv2y3tpCcWYqijRLTh3A3cBTRP8XGOMSa49W2FB0IaaR/1farumgvW9yns+d4wzw8sYUyHrojLGGIA5n8A+1+4ojdrFt6FmIrU9ypme7rdrA6yYFrm+MaaMJTjGGAPwyzve8wOHprf1BqBadeg8xFs256P0xGJMFWMJjjHG7NoEC7/wlvUYmp5YgnULGocz52ObTWVMFCzBMcaYOR85C+r5NekMLXqkLx63ToMhryBwvmkRrJ+bvniMqSIswTHGmFlB3VM9MqB7yq9mfWg/wFs29+P0xGJMFWIJjjEmt+3cAIsnessOzJDuKb9up3jP51iCY0xFLMExxuS22e+DuqZeN+8OzbulL55wgtfDWTkdtq1OTyzGVBGW4Bhjctsv73rPM631BqD+ftCqt7ds7ifpicWYKsISHGNM7tq+BpZM8pZlyuypYMGtOJbgGFMuS3CMMblr9vuAa8p1y4OhSce0hVOubqd6zxd9BXu2pScWY6oAS3CMMbkreG+nTG29AWjWFRp3CJyX7oUF49IXjzEZzhIcY0xuKt7p7NDtduBZ6YklGiKh3VQ2m8qYiCzBMcbkpmVTvIv7Ne7o7D+VyYK7qeZ/BiXF4esak+MswTHG5KbgwcXtjkpPHLFo0xdqNw2cF22DpZMi1zcmh1mCY4zJTSEJztHpiSMWefnQ9SRv2a+2+aYx4ViCY4zJPUU7YNUP3rKq0IIDod1Ucz+B0tL0xGJMBkt0glMLqK2q8xL8XGOMSZzlQeNvmnRyFtOrCjoMhII6gfPtq2HVj+mLx5gMldAER1WLVLUokc80xpiEq4rjb/wKakGnQd6yOdZNZUww66IyxuSeqjj+xi24m8qmixsTwhIcY0xuKdoOK6vo+Bu/LkMgr1rgfMNc2DA/ffEYk4EswTHG5JZl33l3D2/SGeq1TF888ajVKDQps1YcYzwswTHG5JYlX3vPq1rrjZ91UxlTrmoVVwklIpcmOpBoqeor6Xq3MSYLZEuC0/Uk+OSPgfMV05zd0ataa5QxSRJXggO8hGcL3pSyBMcYE58922DVDG9ZVRtg7NegNezfyzVFXGHuGOhzWVrDMiZTVLaLSlL0wfVfY4yJz/Kg8TdNu0C9FumLp7K6neI9t+nixpSpTIKTyoTDkhtjTOUtnug9r6rdU37B43AWfeW0Uhlj4u6iOjahURhjTCpU5QX+wmnWDRp3gE2LnPPSvc4O4wednd64jMkAcSU4qvpVogMxxpik2rMNVs/wllXV8Td+Ik4rzuR/B8pmv2cJjjHYNHFjTK5YOhnUtSll065Qt3n64kmU7md6z+d/7mwmakyOswTHGJMbFnzuPW9fxVtv/FodCg0KA+cle2Dep+mLx5gMYQmOMSb7qcK8z7xlnYekJ5ZEE4EDz/CWzX4vLaEYk0kswTHGZL/1c2HrssB5fo2qP/7GrftZ3nPrpjImfQmOiLQSkZ4icqzv01NEWqUrHmNMFpsf1HrT/mioXjs9sSSDdVMZEyJlCY6I5InIUBF5R0TWAMuA6cA432c6sExE1ojIu7661sJkjKm84ASn8wnpiSNZrJvKmBApSSBEZAiwEHgTOANoTuRVi5sDp/vqLhSRLPuXyBiTUnu2wrJvvWWdB6cnlmSybipjPJKe4IjIPcAYoC2BFYnL28fKf01893wiIvclL0JjTFZbNAFKSwLnTTpD4/ZpCydpwnVTzR+bvniMSbN4VzKOiojcDPzZd+pOXLYAPwBzga2+svpAF6A30DCo/p9EZKuqPpTMeI0xWSh49lSXLG0UFoHup8O3TwTKfnkXegxLX0zGpFHSEhwR6QbchzdRmQHcDXyiqiUR7ssHTgHuxEl21HfvvSLyoar+mqyYjTFZprQ0dP2bbOye8jtwqDfB8XdT1aibvpiMSZNkdlHdi5NA+bulHgH6qOoHkZIbAFXdp6ofAH2Bh333K5AP/C2J8Rpjss2ambBjbeC8el0oPDJ98SSbdVMZUyYpCY6I1AJOxklMFHhVVW9Wda+TXj513Aq8TGAA8sm+Zycy1nwR6SEiI0TkcRH5VkR2iYj6Pncn+H0aw+elRL7bmJwTPHuqwzFQrXpaQkkJfzeV2y/vpSUUY9ItWS04RwM1cZKSfcDNlXjWLYC/xaeG79mJ9AbwMzASuBY4HEhoEmWMSZOQ6eFZsnpxeQ4Mmk218EsoKU5PLMakUbLG4LTx/VeB71R1fbwPUtX1IvId0N9XVFhe/TjkB51vAjYCnRP8nmC/EBiAHcmyCq4bYyLZuRFWfO8ty+bxN36tekPdFoGuueLtsGIqtDsqvXEZk2LJSnCauo6XJ+B57mc0ScDz3KYCv+IsNDhdVReLyAicFp1k2qCq7yX5HcbkrgXj8KxI0fIgqL9/2sJJGRHoeBz89L9A2YJxluCYnJOsLqrdruN6CXieewrA7oi14qCq96vqbar6lqouTuSzjTFplIvdU36djveeLxiXnjiMSaNkJTj+aQsC9ErA89zPWBuxljHGgDM9fNGX3rJcSnA6HEtgAiuw5mfYviZt4RiTDslKcKb7/qvAfiJyVnmVyyMiZwLuTTh/qERcxphcsO4X2LUxcF6jPrTqk754Uq1OE2fKuNvCL9ITizFpkpQER1UXAAt8pwI8KSIdY32OiLQHniDQkb5QVecnJsq06yoik0Rko4gUi8haEZkoIneJSMt0B2dMlbboK+95u6MgP6kLt2ce66YyOS6ZC/39k8AifS2Bb0Tk7GhvFpEzgEnAfq7nPJqEONOlJc7MsMZAAc4mo0fjrPS8RESuT8RLRCTsx5istjgowWk/MD1xpFNwgrPwCyjdl55YjEmDZP5K8yxwDXAwTnLSHBgtIrOB14HvgPnANt/1BkAnoB9wHtCDQGKjOGvVPJPEeFNpIfAZMBNnSnot4EDgbKADzno/j4lIY1W9K21RGlMVlRTDkm+8ZR1yMMHZ/1Co2RD2bHHOd2+GVT9C6xzqqjM5LWkJjqqWisgpwGSctWv8e0odCNxTwe3uXccFZz2YU2JZCTmDDVTVieEuiMjtOC04/vVx/iIin6vqpFQFZ0yVt3I67N0ZOK/bApp1S1886ZJfDToe62y46bdgnCU4Jmcks4sKVV2F0w3zJd7WGAhsvxD8IajOV8DRqroymbGmSqTkxndtn6reCTznKr4j+VEZk0XCdU/laresjcMxOSypCQ6Aqq5U1UHApcD3eBOZcPzXvweGA8epaiIWC6xK7iaQ5B1bmf23VDXsx5isFTzAOBe7p/w6DvKer5wOuzalJxZjUixl0wpUdRQwSkQ6A0cCvYFmQENflS3Aepwp5pOzaLZUzFR1lYjMA7rijMdph7PasjGmPEU7nG0J3HJxgLFf/f2gRQ9YO8s5V9/6QD2GpTcuY1Ig5fMmfYnLfJxdwk1krkU8aJS2KIypSpZ9C6UlgfPGHaFhm8j1c0GnQYEEB2DBeEtwTE5IeheViZt7z60t6QrCmCpl0QTveS53T/mFG4dj3dQmB1iCk4FEZD+gi++0GFiaxnCMqTps/ZtQbQ6HgjqB8x1rna0bjMlyluBkprsJDMT+SlV3llPXGAOwc0PQD26B9gPSFk7GqFY99PsQPE7JmCxkCU6CiMhLIqK+z90R6jwgIoXlPCNfRO4BrnYV35fgUI3JTouDVmBoeRDUbpyeWDJN8No3q2akJQxjUimlg4xFpCtwCM7sqfo4WxTERFUrWiQw1pjaA1cEFR/sOj5ORIK/T2+r6o9xvO63wK0iMhn4BpgHbMVZybg7cC7OSsZ+96nqVyFPMcaECu6e6nBMWsLISPv38p6vnpGWMIxJpaQnOCLSCLgVuBhnX6nKSmiCA7Sl/MX0jvZ93BYA8SQ44HQ99fd9ItkF3KqqT8T5DmNyj61/E1lwgrPuV9i7BwpqpiceY1IgqQmOiBwP/BdnRpB7cb94hvD7V0Kuyk7ASWyOwBlE3Azne7MPZ1r4TGA88JKq2mpcxkRr81LYvDhwnlcAhUekL55MU7sxNCiErcuc89ISWPsLtO6d3riMSaKkJTgi0hf4EGehOgjsKwXlr2ScUqo6gQTEo6ojgBEV1PkOZ5NRY0wirZjmPW/TF6rXCV83V+1/SCDBAVj9oyU4JqslswXnGZzkxp/Y7AReA77A6eLZBpREvNsYY6IVPO25lf3gDrFfT/j1w8C5DTQ2WS4pCY6IHIwzmNjfpTQdOE1V1yTjfcaYHOdeqRecGVTGywYamxyTrGnih/n+KzitNGdbcmOMSZo1QQlOix7piSOTRRpobEyWSlaC09z3XwW+VVVbidcYkxw7N8AO1+9P+dWhaef0xZOp/AON/fwDjY3JUslKcHa7jlck6R3GGBM6/qZZN8iPeYmt3LD/Id7z1fGudmFM5ktWgjPPdVw/Se8wxpjQBKflweHrGWegsZsNNDZZLFkJzkTA37lr0xmMMckTMsDYxt9EZAONTQ5JSoKjqjuAl3AGGbcUkdOT8R5jjLEBxjGwgcYmhyRzs807gOU4Sc4TItIqie8yxuSikiLYMNdbZi04kdlAY5NDkpbgqOpmYAiwCmgNfCcipybrfcaYHLR+rvND2q9+a6jVKH3xVAU20NjkiKTuRaWqc0WkN/ACcDLwvogsBMYBc3F20i6N8ZmvJDxQY0zVFDLA2FpvKmQrGpsckfTdxHE2kfwQOBJoCHQCOlbieZbgGGMctoJx7GygsckRyd5NvDvwNs7O2RC6G3i0m1z697Oq6ruJG2MSKbgFxwYYVyzSQOOCmumJx5gkSdoYHBFpD0zASW7cu4i7P1E/LqHBGWOqPlVrwYlHuIHG62ygsck+yWzBeRpoSqDVpRT4HGc38YXYbuLGmMrYtgp2bw6cF9SBRu3TF09Vsv8hsHVZ4HzVj7YDu8k6ydpNvAswmEDX0kLgTFW1XxOMMYkR3HrTojvkJXPliyxiA41NDkjWvwZH+f4rOC03Qy25McYk1JqZ3nPrnope8DicRROgNKYJrcZkvGQlOC18/1Vguqr+XF5lY4yJma1gHL82faFarcD51uWwZGL64jEmCZKV4GxxHS9M0juMMbnMBhjHr0Y96B60g86Po9ITizFJkqwEZ7nruFbEWsYYE4/inbDR/buTQPPuaQunSup1sfd89gfeQdvGVHHJSnAmAUW+Y/u1yhiTWOt+xbMsVuP2UKNu2sKpktoeBQ1d08X3FcGst9MXjzEJlqzdxLcA7+AMMm4vIkcn4z3GmBwVPMDYxt/ELi8Pega14lg3lckiyZxTeTuBsTj/EZGGSXyXMSaXBA8wbnlweuKo6npegGcd1VU/2u7iJmskczfxpcDpOAv6HQBMFJGeyXqfMSaHrPrBe26bbManYSF0OMZb9uNraQnFmEQT1eRs7yQiA3yHXYCHcDbaVJztGz4D5hDfbuI2l7ECIlL2h5qsP19j0mbnBni4E54xODfNg3otIt5iyvHzW/D2FYHz2k3gxjlQrXr6YjImSiKBFkhV9WzrlMytGiYQfnPNY3yfeCip2QHdGJOpFn6J55+WlgdZclMZ3U6Bmg1gz1bnfNdGmPdp6DRyY6qYVKxr7s+oFG/CE7zxZrQfY0wuWzjee97p+PTEkS0KasFB53jLZlg3lan6kp3gRNpF3BIVY0zsSkthgSU4CRe8Js78z2DryvTEYkyCJLO757IkPtsYk4vW/gw71wXOq9eD1n3TF0+22K8nND8Q1vlmUGkpfPMvOPmhtIZlTGUkLcFR1ZeT9WxjTI4Kbr1pP8AGwyaCCPS9Cj66IVA2/SU4+kao1zJdURlTKakYg2OMidMtt9yCiCAiXHzxxRXfALRr167sHvcnPz+fRo0a0bdvX+666y42bNgQ8RkjRowI+4zgT7t27cqN5bHHHkNEuOSSS8rKjjnmmLL7q1WrxsqV5XeFFBUV0aRJE+eeATfR7rHtgYudBgGwZMmSiDFWr16dli1bMnjwYJ555hn27t1b8TfR56mnnip7zlFHHRXVPe6vz/2pU6cOHTt25Pzzz2fs2LFRx5AyPS+E+q0D5/uKnFYcY6ooS3CMyVAlJSW8+uqrZedvv/02W7Zsifr+mjVr0qJFi7JPvXr12LJlC9OmTeOee+6hW7duTJ8+vdxn5OXleZ4R/GnWrFm597///vsAnHHGGWGv79u3j1deeaXcZ7z33nts2rQp/EVfguNWv359T4zVqlVj7dq1jBs3jt/85jccfvjhkZ8X5MUXXyw7/uabb5gzZ05U9wEUFBR44iguLmbRokWMHj2aE088kauuuiqzlnGoVgOOusFb9v2LsH1tWsIxprIswTEmQ3388cesWbOG7t27c9xxx7Fnzx7++9//Rn3/eeedx5o1a8o+W7ZsYdu2bTzzzDPUrFmTjRs3ctFFF5X7Q7ZNmzaeZwR/pk2bFvHeTZs2MWnSJGrUqMEJJ5wQct3f+jNy5Mhyvw7/9XatgqaCN+kMjdqF1P/Xv/7liXHXrl2sWLGCG264AYAffviB2267rdx3Avz0009Mnz6dRo0acdFFFwHehKciRx55pCeOPXv28P3333P00c7ONc8//3xMz0uJQy+FevsHzkv2wOR/py8eYyrBEhxjMtQLL7wAwKWXXsqll14KxPYDNpx69epx9dVXc8cddwAwd+7cmFolYvHxxx9TUlLCcccdR7169UKuDxgwgHbt2jF//nwmTZoU9hkrVqzg888/p27dugw7rJX3YpjWm0hatWrFo48+yqBBzj3vvfdehff4v//nnXceV111FQCvvPIKJSUlUb/XLT8/n969e/P+++/TpEkTzzsyRrhWnGkvwI71aQnHmMqwBMeYJFmzZg1/+tOfOOSQQ2jQoAE1a9akQ4cOXHnllcyePbvce1evXs2YMWPIy8vj4osvZtiwYdSpU4fp06fz008/VTq2nj17lh3v2LGj0s8Lx59EROqeEhFGjBgBRG7FeemllygtLeWcs8+m7u7l3otxTA/3f90Vfc1FRUW89pqzFszw4cMZMGAA7du3Z+3atXz88ccxv9etUaNG9OvXD4BffsnAfZ8OHQ51XQOLS3bDt4+nLx5j4mQJjjFJ8NFHH9G5c2f+/ve/M3PmTHbv3k21atVYvHgxL7zwAr169Sp37MnLL79MSUkJgwYNolWrVk4LxrBhQGJ+6/cnSfn5+XTs2LHSzwu2Z88exo4di4hw+umRV8T1D2Z+44032LlzZ8j1l156CYDLhg4JrLQLkF8D2vaPOS7/1921a9dy67377rts2rSJLl26cPjhh3sGSifi++/vFty3b1+ln5VwBTWh//XesqnPw86N6YnHmDjZtgcmau3+VLnfXDPVkgdPSejzpk6dyrBhwyguLuaaa67hhhtuoHPnzuTn57Ns2TL+/ve/89RTT3HFFVfQvXt3+vTpE/IMf1eUv2sKnJaEV155hddee42HH36YGjVqxBzbjh07GD16NPfddx8AV1xxBY0bN47zK41s/Pjx7Ny5k379+rHffvtFrNe2bVuOO+44xo8fz5tvvlnWogPw1VdfsXDhQjp16sTRzbbimSDe9kioXjvqeFavXs0jjzzCuHHjALj55pvLre9PYtyzvy699FLuuecexowZw+rVq8v9usqzefNmpk6dCkCHDh3iekbS9R4Bkx4NrDm0dydMeQoG3ZnWsIyJhbXgGJNg1157LcXFxdx55508/fTTdOvWjfz8fAAKCwt58sknue666ygpKeHee+8NuX/ixInMnz+funXrMnTo0LLyY489ljZt2rBp06aoxpCMHj2ali1bln0aNWpEvXr1uPLKKyksLOT+++/nqaeeKvcZy5cv9zwj+LNt27aw91U0e8rtssucNUGDu6n8Sd5ll10GC8Z5byqne+r666/3xFinTh32339/HnnkEY4++mjefvttLrjggoj3L126lPHjx4dMb+/YsSP9+/enpKSkwplf4ezbt4/p06dzxhlnsHHjxsDXlomq14b+13nLfv0wPbEYEydLcIxJoJ9++olp06ZRUFDATTfdFLGev2Vm3LhxId0U/taDs88+m9q1A60UsXaT7Nmzh7Vr15Z93FPMN23axPr169m1a1e5zygtLfU8I/hTWloaco+q8uGHzg/DaBKcoUOH0qBBAyZOnMjChQsB2L59O2+//TZ5eXkMv/A8WBI0CLmcBGfbtm2eGN1f4/r161m5cmW5M8defPFFVJWBAwfStm1bz7Xhw4eX1anI5MmTPYlWzZo16dOnD19//TUAw4YN49prr63wOWlz6KUgrh8RG+bC9jXpi8eYGFmCY0wC+WcDlZaW0rVr14gtHyeeeCIAO3fuLPttHpwfzm+99Rbg7Z7y8/+AHT9+PEuXLi03luHDh6OqZZ/S0lI2btzIBx98QPPmzXn00Ufp378/69dHniHTtm1bzzOCPw0bNgy5Z8qUKaxZs4ZOnTrRvXv38r9hQK1atTj//POBQCvO6NGj2blzJ0OGDKGVrnIGuvrlVYNmkcfQjBw50hNjSUkJK1as4Omnn2bt2rVcd911XHjhhWGTnNLS0rJxP+G+/+eeey41a9Zk3rx5EWd++e3du9eTaPlnX4kITz75JG+99RYFBQXlPiOtajaA/Xt5yxZ/nZ5YjIlHef942adqfgjs3K4mtW6//XZ1f/+j+SxevLjs/meeeUYBLSws1NLS0rDvOPzwwxXQu+++O+z1tm3bKqDDhw+PGOfy5cu1fv36Cuhll10Wcn348OEKaNu2bWP58lVV9dZbb1VA//jHP4a9PnDgwJD4vvvuOwW0TZs2um/fPj3yyCMV0DfeeEN14iOqd9XXuwZWd2JqVjfkmYsXLy77fo4cOTJibB988EFZvZdffjnk+tixYxXQ2rVr67Zt28I+4/zzz1dAR4wYUe7XN3DgwLKy4uJinT9/vt58880qIlqnTh2dMGFCxDgzxud3q95VP/B57/fpjsgYj6Cfd56fhdaCY0wC+bubunXrFnVC6t7uwN/1tGzZMvLy8sIu+T9lyhQg0FIRj9atW5e1Ir3xxhtxr+0STizjb/z69u1L9+7dWb58OU8++SSTJ0+mcePGzgysFd97K1eLfXC132mnnUbz5s0Bwi6a6P/+79q1i/r164f9/r/++usAvPnmm2zfvj3kGeEUFBTQqVMnHnroIe666y527tzJueeey7p16yq+OZ3aD/CeL56YnjiMiYMlOMYkUMuWzvohixYtCjvtuTyzZs0qm10TDf9g2Hj5x5fs3Lmz3G6qWMybN485c+bQrFkzjjzyyJju9Q+4/eMf/wjAhRdeSI3q1WFF0GrJ+fEnOBD4uhcvXuwp37hxY1lyFo2dO3cyevTomN9/++2307FjR9atW8edd2b4rKQ2/SDftZnplqWweUnawjEmFpbgGJNA/fs7a7MUFxfz7rvvxnSvv/Xg0EMPZfv27eV+zjzzTM898VixYkXZcZ06deJ+jpt/dtepp55KXl5s/7xccsklVKtWjeLiYgAuv/xy2Lo8MFXZL79y41b8X3fw1zxq1CiKiopo3rw5W7duLff7f/31zjox8Xz/CwoK+POf/1x2/7x58yr19SRV9drQuq+3zMbhmCrCEhxjEqhPnz706uUMzLzjjjsqbBnxb/pYXFzMqFGjAGcga926dcv9nHfeeYCzIN3mzZtjjnPDhg18/vnnAHTu3Jn69evH/Ixw/C0g/gQsFi1atODRRx/lpptu4q9//avzfQxuvamkCRMmsHr1aoCQ9Yf8M6OGDh1K/fr1y/3++wdFT5kypcJVqcO5+OKLadu2Lfv27eOvf/1rJb+qJAvppvoqPXEYEyNLcIxJIBHh6aefpkaNGixbtox+/frx1ltveaYqr1y5klGjRjF48GBuvfVWwEkMNmzYAMA555xT4XtOO+00atWq5dlSIBqlpaVMmzaNM888s+x9N954YyxfYkTr1q1jypQp1KpVi8GDB8f1jGuvvZZ//OMf/OUvf3EKgsffxKmoqIj333+/bNPMatWqcd11gXVepk2bxsyZMwEnwazI4YcfTmFhIRDf/mDVqlUrW2zw9ddfjytJSplw43DiHPtlTCpZgmNMgvXt25cPP/yQJk2asHjxYs455xzq169P06ZNqVOnDq1bt+aSSy4pW1UXAl0dvXv3jmp12zp16nDSSSd57g0WvNBfixYtqFOnDn379uWbb74BnOTmN7/5TWW/ZAA+/PBDSktLGTJkCLVq1UrIM+NpwQle6K958+bUrVuXM888k1WrVlG7dm1GjRpFjx49yu7xfw+bN2/OgAEDIj3a4+yzzwacDTj37t0bc5xXXHEFLVu2pLS0lLvuuivm+1OmVW8ocHXn7VgLGzK4W80YH0twjEmCwYMHs2DBAh544AGOOuooGjRowJYtW8jLy6N79+5cccUVfPDBBzz++OMsX768rLsomtYDP3/dGTNm8MMPP4RcD17ob926deTl5dGlSxcuv/xyJk+ezCOPPJKYL5j4Zk+Vq6QIVs+M+bbghf42bNhA7dq16d27N7fccgu//PJLWRcfwO7du8tmRg0bNqxs1emK+L//69evL1vYMBY1a9Ysaz17++23E7KJalJUqw5tj/CW2WwqUwVIvNNMRSTVu8QpsAPYDqwEfgG+Bd5W1dgHIWQxESn7Q433z9eYWOzatYumTZtSVFTEmjVraNasWeUfumI6PH9c4Lx+a7gxA3ffzgXf/As+/0vg/IDT4LxR6YvHGB8RKTtWVXFfq0wLjqT4kwfUB1oBfYERwDPAGhF5UkQaxPVFiOSLSA8RGSEij4vItyKyS0TU97k7nudG8d46InKjiHwjIutEZI+ILBWR0SJyQjLeaUyyjB07lt27d9O/f//EJDcQ2j3VOnRTUpMiIeNwvoYw23QYk0kqu5t4upsHBCgAfgMMEpEBqhrryllvAEMrrJVAItILeAsIHmxR6PucKyL/BS5T1eJUxmZMPOrUqcNdd93F0UcfnbiHhiQ4hyXu2SY2LQ92tm7Ys9U537MF1v4M+x2S1rCMKU9lExypuErSKU4cXYDRwLEx3h/c4b4J2Ah0rnxooUSkLTAGaOErmgqMAjYABwFXA02AC4FS4JIwjzEmowwZMoQhQ4Yk9qErg2ZQWQtO+uTlQ7ujYc5HgbLFEy3BMRkt7i4qVc1L9QeohfPDvydwKeBfSc3fkjRARGL9V3Yq8CBwDtBBVZsA98f7fYnCYwSSmxeBI1T1cVX9n6reDhwKLPNdv1hETkliLMZkph3rvSvm5lWzH6bp1n6g99wGGpsMV9kWnJRS1SKgCNgMzARGichg4EOcriqAYcBnMTwzmcmMh4gcApzpO10G/F5VPR3ZqrpMRH4LfOwrutt1bExuCG69aXkQFCRo6rmJT/A4nKWTYd/eSq8sbUyyVPlp4qr6OfA0ge6y/mkMpyLnuY6fVdU9EeqNARb4jvuISMfkhmVMhgkef9PKuqfSrllXqNM8cF68A1aGLk9gTKao8gmOz3u+/wqB7p9M5O4++zRSJd8W8GNdRTaryuSW4BWMbYBx+onYtg2mSklagiMi7ZPwzHsjXPLvGqhAw0S/NxFEJA84wHdaAlS0qpf7X/geEWtV/N6wH2MyVum+0JYBG2CcGToEjcNZZAmOyVzJbMH5VEQaJ+phIvIX4LYIl/3rpPvXy8lErYHavuOVqlpSQf2lruMuyQnJmAy0fi4Ubw+c12oMjSvevsKkQPBA4xVToXhX+LrGpFkyk4HOwMciUrOyDxKRm3EG24alqktds62iW2c99Rq6jjdEUX9jhHuNyW7hpodbq2NmaNQWGrYNnO8rhmXfpi8eY8qR7NaOvsBoqUSfiIhchzONu6qr6zqONLjYbbfruF6CYzEmc9kCf5ktuJvKpoubDJWK7pxTgf/Ec6OIXIOzbozf1kQElAFStgK0qob9GJOxVs3wnrfqnZYwTAQh6+HYOByTmZKZ4PyHwD5SV4nIn2O5WUSGA08RWKl4O3BSooNMoR2u42gW9HDX2R6xljHZZN9eWD/HW2YL/GWW4ARn1QzYbfsdm8yTzATnWuAD37EAfxWREdHcKCLnAy+47t0JnKqq3yU6yBTa4jpuEkV9d50tkSoZk1U2zHfGdfjVbQl1mqYvHhOqbjNofqCrQGHJpLSFY0wkSUtwfGu5nA/4kxIBnqlop2wRGQq8QqD1Zzdwpqp+naxYU2QF4J9u0FpEKlpF2jWSj3nJCcmYDLN2lve8ZdwrJJhksunipgpI6hgc30q9p+Ksyqs42ym86dtNO4SInAr8D2cDTMHZluFsVR2fzDhTwbclw6++02pARe3u7oU/ZkWsZUw2WfOz97yFJTgZyRb8M1VA0gcZq+pG4ERgPU6SUxf4RETauev5Nsl8EycJEpy1bS5Q1THJjjGFolqd2DfrzH19bKS6xmSVkBacg9IThylf2/4grhU5NsyDbavTF48xYaRkUTxVXYTTkrMLJ8lpAYzxLwQoIsfg7Axew3e9BLhUVd9LRXwp9Ibr+Jpy1gg6CejkO/5eVRcmNyyTqW655Zay1acvvvjiqO5p165d2NWr8/PzadSoEX379uWuu+5iw4bIyzGNGDEi4irY7k+7du3KjeWxxx5DRLjkkkvCXt+2bRuPP/44p512Gm3btqXOFe9T675ttP7ndk5+bRf/fPd71qxZ47nn7rvvjiq2WGMF6Nu3b1n9559/vsL6S5Ysifi9btiwIX369OHWW29l2bJlFT6rSqlZH1od6i2z6eIm00SaRpyMD3AyUAzs832+AQbhzBIq9X1KgEtSGVeYOEfgJFoK3B3lPS9Fcw9OIuev9zyQF3S9EGcVY3+dU+KI33+vmqpr79692rJly7I/y5o1a+rmzZsrvK9t27Zl9Vu0aFH2adCggbr/32jSpIl+//33YZ8xfPhwBTQvL8/zjOBPnz59yo3lmGOOUUDffPPNkGvPP/+8NmrUyBNTrWpogxp4ymrWrKn33ntv2X0PP/xwuTG5P+7nd+3atdxYf/75Z897Dz/88Aq/14sXLy6rX79+/bL3Nm7c2POsOnXq6CeffFLh86qUcfeo3lU/8Hn3t+mOyOSgoJ933p+FwQXJ/gBX+hKZfa5PqavsqhTH0x64N+jzgeubNjHM9V5hnhNtgtMWWOOqOwX4Pc6A7PtwVjn2XxsV59dkCU4WeO+99xTQ7t2763HHHaeAPvnkkxXe509whg8fHnJt27Zt+swzz2jNmjXLfuiXlpaG1PMnOG3bto07/o0bN2q1atW0Ro0aum3bNs+122+/vez/0QMOOEBffvllXTvlzbIflrtur6djr+uhF198sebn5+shhxwS8/tLS0v1jDPOUEDz8/P1s88+K7f+DTfcoICOGDFC69Wrp4D+8ssv5d7jTnBGjhzpubZz504dOXKkNmzYUAFt0KCBbty4MeavI2Mt+sqb4DzSXTXM/0vGJFNGJThOPPzVldCUuj5/SEMsx7i/QVF+RoR5TlQJjq9uL2BhBe94Dage59dkCU4WOO200xTQBx98UF966SUFtHfv3hXeV16C4/e3v/2t7P+R2bNnh1xPRILzyiuvKKAnnXSSp/z1118ve/c555yje/bscS5Mesz7A/O936mq07Jy4YUXxvz+u+66q+w9//jHP8qtW1RUpE2bNlVAp0yZoiNGjFBAb7rppnLvKy/B8fN/HwB95plnYv46MlbxbtW/Nff+mW1YkO6oTI4pL8FJy8aUqnoXTkLg38JBgVtU9fF0xJNqqvojcDBwE/AtTqtNEbAcZ6D1Sap6kaoWR36KyXRr1qzhT3/6E4cccggNGjSgZs2adOjQgSuvvJLZs2eXe+/q1asZM2YMeXl5XHzxxQwbNow6deowffp0fvqpoo3oK9azZ8+y4x07dkSuWAnvvfceAGeccUZZWXFxMTfffDMA3bt355VXXqFGjRrOxTVBA4xbOAOMe/TowauvvhrTu99//33uueceAC688EJuuummCutv2LCBrl270q9fP4YPHw7AK6+8wt69e8u9tyInnnhi2fEvv/xSqWdllIKa0Kaft2zRhLSEYkw4Fa3FEpaIDKi4VoVeAwYC7YBPgKnRPFdVEzqSTVUnEEi0KvOcEThjd6KtvxP4p+9jssxHH33EBRdcUJY8FBQUUL16dRYvXswLL7zAq6++ynPPPcell14a9v6XX36ZkpISBg8eTKtWrQAYNmwYr7zyCi+88AL//ve/KxWfP0nKz8+nY8eOlXpWOHv27GHs2LGICKeffnpZ+fvvv8/y5csBuO2226hZ0zXOvpw1cPLyov9dbM6cOVxyySWoKr169YpqsPALLzjrivr/PAYOHEi7du1YsmQJH374IUOHDo36/eXZt29fQp6TMToM9E4RX/wVHHZF+uIxxiWuBAeYAAnbT0lwBh+fHEVdJf6YTWXd3SDdESTH3Ynd4mzq1KkMGzaM4uJirrnmGm644QY6d+5Mfn4+y5Yt4+9//ztPPfUUV1xxBd27d6dPnz4hz3jxxRcBPAnQ8OHDeeWVV3jttdd4+OGHAy0fMdixYwejR4/mvvvuA+CKK66gcePGcX6lkY0fP56dO3fSr18/9ttvP085OAmLO/GhpMiZauzW4kBitXXrVs444wy2b99Os2bNeO+996hVq/ydUZYvX87nn3/umanmn/n1t7/9jRdffLFSCc6YMYGVLjp06BD3czJS+2OAewLni7+G0lKIISE1Jlkq+3+hVPIDgUQplnuMyVjXXnstxcXF3HnnnTz99NN069aN/HxnzZDCwkKefPJJrrvuOkpKSrj33ntD7p84cSLz58+nbt26nh+sxx57LG3atGHTpk1l3T/lGT16NC1btiz7NGrUiHr16nHllVdSWFjI/fffz1NPPVXuM5YvX+55RvBn27ZtYe97//33AW/3FAS6aDp27Ej9+vUDF9bPgdKSwHmDNlCrUYVfo5uqctFFFzFv3jyqVavGm2++SWFhYYX3jRw5ktLSUo499lhPfX9y+emnn7Jy5cqYYgHYtWsXL7/8Mtdffz0ANWrU4IILLoj5ORlt/55Qw/WLz+5NsPbniNWNSaXKJDiJSDYscTFZ5aeffmLatGkUFBSUO+7D/8Nz3LhxId0W/u6Ss88+m9q1a5eVu9eT8dcpz549e1i7dm3ZZ8uWLWXXNm3axPr169m1a1fkBwClpaWeZwR/SktLQ+5RVT788EMgNMHZuHEjQGirUcj4m9hXML7zzjv5+OOPAfjnP//JwIEDK7xHVRk5ciRASHdhp06dOPLII9m3bx8vv/xyhc+6/vrryxK/Jk2aUKdOHUaMGMGWLVsoKCjg5Zdf9rRmZYW8fGh3lLfMtm0wGSLe7p7LEhqFMVli0iRn08HS0lK6du0asZ4/qdm5cycbN26kefPmgLPw3VtvvQWE/sAFp5vq/vvvZ/z48SxdupS2bdtGfMfw4cN56aWXys5Vlc2bN/PNN99w22238eijjzJu3DjGjx9Ps2bNwj6jbdu2LFmypNyvOdiUKVNYs2YNnTp1onv37p5rzqQHJ1nzqOQeVO+88w73338/4CxS+Ic//CGq+8aPH8+SJUuoU6cOw4YNC7k+fPhwJk+ezMiRI7nttttC43bZtm1b2BatwsJCxo4dS7du3aL8aqqYDgNh7seB88VfQf/r0hePMT5xJTiqWvGvMyb7JHisSjZatWoV4CQwa9eujeoedyvK66+/zq5duygsLOSYY44JqdulSxcOP/xwpkyZwksvvcRdd90VdWwiQuPGjTnttNPo1asXBx54ID///DO33npr2ZifRPB3T5155pkh15o2dXYG97fklKnEHlS//PILw4cPR1Xp27cvTz/9dNT3+r/us846i7p164ZcP++887j++utZsGABEydOLLdVaOTIkYwYMQJwkp0ffviBP//5z3zzzTdcdtllfP7552HfUeW1D/qeLJ0MJcVQrXp64jHGx0aCGZNA/paZbt26Rb1ukXsLAX/X07Jly8jLywu7DcCUKVMA5weqv0UkVq1bty6bvvzGG29QUlJSwR3RizT+BuDAA52BwwsXLgy0dqjGvQfVli1bOPPMM9mxYwctW7bknXfeiXrw9ebNm3n33XcBGDVqVNjvdcOGDdmzZw8QXbegX/369TnmmGP47LPPOPDAA5kyZQrXXntt1PdXKc26Qt2WgfO9u2Dl9+mLxxgfS3CMSaCWLZ1/6BctWsTOnTtjunfWrFlMnTo16vpLly4tm5UUD3/31s6dO1m/fn3cz3GbN28ec+bMoVmzZhx55JEh1wcNGgQ4XXgffPCBU7htFezeHKhUUAcata/wXaWlpVxwwQUsWLCA6tWr8/bbb5dNqY/Ga6+9Vpa8ROPtt9+OOKg6ktq1a/P4487yXi+//DKTJ0+O6f4qQSR0d3Ebh2MygCU4xiRQ//79AWdBO3/rQLT8LQSHHnoo27dvL/fj7/6JpVUh2IoVK8qO69SpE/dz3Pyzu0499dSwa9ecccYZtG7dGoAHHnjASTCCW29adA+ZZhxuMPPtt9/Op59+CsDjjz8eNqEqj/97d/3115f7vd66dSvNmjVj165d/O9//4vpHeDMfvN3bd16660x318ldAjqplpsCY5JP0twjEmgPn360KtXLwDuuOOOCltGNm3aBDgJ0ahRowA499xzqVu3brmf8847D4B3332XzZs3R3x+JBs2bODzzz8HoHPnzt4p25VQ3vgbgOrVq/PQQw8BMHv2bIYPH07x8h+9lYLG38yePTtkwPWbb77J3//+dwCuueYarr766pji/OGHH5gxYwYAF1xwQbnf6/r165dN1483obzjjjsAZxC6//ueVYLH4ayYBkXJWSHbmGhZgmNMAokITz/9NDVq1GDZsmX069ePt956yzOQeOXKlYwaNYrBgweX/Ubv3yoA4JxzzqnwPaeddhq1atWiqKiI1157Ler4SktLmTZtGmeeeWbZ+2688cZYvsSI1q1bx5QpU6hVqxaDBw+OWO+CCy7glltuAZzxP71GPMirPxWzfqevlaZlD/bs2cP48eO5/PLLOeSQQ5g1K9DKM3PmTC67zJnI2b9//7IuoFj4E5XCwkL69etXQW0n6QSYNm2aJ5ZoDR48mMMOOwxwprNnnYZtoLFrRezSElj2bfriMQbSs9mmfZL7wTbbTLvPPvtMmzRpUvbnkJ+fr02aNNHatWt7Noe78sorVVX1hBNOiHozTb+hQ4cqoD179vSU+zfbrFmzprZo0aLs07x587JdxP2fG2+8Meyz49ls8/nnn1dAzzjjjKjqP/PMM2U7bfs/tQvQhvXrectq19aHHnqo7D7/9wrfDt3ur7Giz7Jly3T37t1l761oM02/kpISbd68uQJ6ww03lJVHs9mm37vvvltW96OPPorqvVXKhzd4N9789PZ0R2RyQNDPO+/PwuAC+1T9jyU4mWHz5s36wAMP6FFHHaWNGzfW/Px8rVu3rnbv3l2vuOIK/eCDD3T37t26bNkyzcvLU0D//ve/R/18967c06dPLyv3JzjhPrVr19YuXbro5ZdfrpMnT4747HgSHP/u5y+++GLU92xZt0ofO7GWnty5mrapL1qrGlqjRg1t1aqVnnTSSfqvf/1L169f77ln4MCBEb++ij6LFy/WUaNGlZ1/9913Ucf6m9/8RgFt2rSpFhUVqWpsCU5paan26NFDAT300EOjfm+VMetdb4Lzn/7pjsjkgPISHHGum2wiImV/qPbna1Jh165dNG3alKKiItasWRNx4cAQy6fCC67urEbt4foZSYnRJNmuTfBQBzzbFN68COo0SVtIJvu5F99UVc9KnDYGxxhTaWPHjmX37t30798/+uQGYEXQein790xoXCaFajcOXb9oycT0xGIMtjO3MSYB6tSpw1133cXRRx8d243BC8K1PixxQZnU6zAQ1swMnC+aAAeelbZwTG6zBMcYU2lDhgxhyJAhsd8Y3ILTqk9iAjLp0f4YmOya1WYL/pk0si4qY0x67FgPW5YGzvOqwX4Hpy8eU3ltj4C8gsD55sWwembk+sYkkSU4xpj0CO6eankQFNRKTywmMarXcZIct6/+np5YTM6zBMcYkx7WPZWdDv+993zOR9aKY9Ii7gRHRIaKSGI2sDHG5J4V07znrS3ByQpdToD9e3nLJjyYnlhMTqtMC85bwAYRGSMivxOR1okKyhiT5UpLYVXQHlQ2gyo7iMAxt3nL5n4Mq2akJRyTuyrbRVUdGAI8DiwVkR9E5K8i0rvyoRljstaGeVC0LXBeqxE07pC+eExidR4CrYJ+DFgrjkmxyiQ4uwEJ+hwC/BmYKiIrRORpETlZRGpUPlRjTNYI7p5q1dv5zd9kh3CtOPPGwMof0hOPyUmVSXCaAKcDzwGrfWXuZGd/4CrgQ5yurHdF5HIRaV6JdxpjsoEt8Jf9Oh0fOnDcWnFMCsWd4KjqHlX9SFWvUdVWQD/gXsA9XN6f7NQhkAytEpHJInKbiBxYidiNMVXViunec5tBlX1E4NigVpz5Y0P/7I1JkoRNE1fVaar6F1XtCbQF/gB8DhT7qviTnTxcyZCILBSRx0TkOBHJT1Q8xpgMVbQD1v3iLWt1aHpiMcnVcRC07ust+/7F9MRick5S1sFR1eWq+qSqngA0Bc4FXgU2+qq4u7LaE0iGNojI/0TkAhFpmIzYjDFptnoGaGngvEknZ6NGk31EYMAfvWW2AWdqlJbCl/fDowfB6xfB7i3pjijlkr7Qn6ruUNW3VHU40AIYCPwDmOeq5k92GuAkQ6OAdSLyhYj8n4h0THacxpgUCRlgbN1TWa39AMivHjjfsgw2L41c31SeKnx6q7OK9NZlzmKLk/+d7qhSLqUrGatqqap+raq3qGo3oCtwM/A1sM9XzZ/sVMOVDInILyLyoIgcKWLTLYypsoJXMLYF/rJbQa3QQeRLv0lPLLliwoMw9Vlv2bzPUhvDrk0w8WH4+p9QvDO17/ZJ61YNqjpfVR9R1YFAc+BSnAUEt/uquLuyuhFIhtaIyIsi0ivMY40xmUrVEpxc1O4o7/mSSemJIxdMeRq+CjNbbe2s1HZTvXUZfHEvjP8rvDoU9pWk7t0+GbMXlapuVtVRqnouzridE4AnAH9bpj/RAWgGDAdOS3mgxpj4bVsJO9YEzqvVhBY90hePSY2QBOfr0Do7N8Cst2HjwtTElI1+et3pmgpLYfnU1MSxfi4smhA4Xz4FJv8rNe92yZgEx01V96rq56p6naq2B3oCdwLTyr/TGJPRgltv9jsE8gvSE4tJndaHhY7D2bIscL5jPTx9FLx1OTx1ROp+EGeTxRPhvd+VX2fZ5MS8a+8e+O5Z+Pap8K1Cv34YWvblA7BmVmLeH6WMTHCCqepMVb1PVfvhLCB4DfAxsCu9kRljYmIL/OWmglqhg8mXuMbhfPc0bPetF7uvCD67M3WxZYsv7wfdFzjPK4BDh3vrLP228u9RhdEXw5ibYextTleUqrdOuASndC+8+xsoKQ69liRVIsFxU9W1qvqcqp6uqv9IdzzGmBgsDfoNMni/IpO9Io3D2bcXfhzlvbZ8Ciybkpq4ssHePaGto8Oeg2P+5C1bOR327q7cu35+ExZ8Hjhf+IX33VuWOUtBhLP2Z5j4UOXeH4Mql+CYKmzbKpjzCexYl+5ITDrs2Rq6g3jb/umJxaRepHE488Z6x2X5fZN705rjtnaW00Li17AQDjwL6u8PDdsGykv3OklOvPZshbF3hJZ//0LgOFzrjdvX/0zZataW4JjkWz8P3v0tPHYQvH4BPN7HKTO5Zelk7wJ/zbpBvRbpi8ekVsg4nKXOb/vTXwpff+7H9u9EtIKTFnfLaNsjvdcq00315f2wM8wvqLPecaaFQ2iCM+AWqNsycK774L3fVL4lKQqW4JjkWTUDRl8CT/aFn/4Lpb5pgkVbYdxdaQ3NpMHioBVs2w9ITxwmParXDu2S/Ol1WDAu8j05uDhdXIITnP1dW58UHuG9Fu9A49U/ha6t47evyOlm3L42tGvx0Evg9Me9ZRvmOVPIk8wSHJMcP74Gzx4Dv34AaOj1uZ84CZDJHZbgmOBuqokP4/n3oXpd7/WZo2Hb6qSHVeXF0oKzfGrsa9KUlsLHN3lbYAlab/f7F2HOh3j+PPfr6XSXdRkCh17qrT9ztNPllUSW4JjE274WPr6RsImN21epG2xm0mznBmecQBmx8Te5KDjB2Rc0o2bwX6FRO+/1755OelhV2u4tsHFB4FzynOUX/Jp0gjrNAufFO5zBvrGYMSp0i5UznvR2OW5e7Kyg7HaAa6m6IfdBg0LnuNup8NtvoWaD2OKIkSU4JvEm/xtK9njLWh4ER93oLZv7sdPsabJf8MJu+x1iG2zmotZ9nenL4RTUgYPPgyP/4C3//kXYsy35sVVVwQP3mx0ANVwtYSJQeLi3TizjcHZtgs+DhhR0PQV6XQTdz/CW71zvPT/g9MBxzfpw1n/grGfgvFFQtxnJZgmOSaydG5x/kNyOuxOu+RoG/SW0D37C31MXm0kf654y4IzDibQ1x0FnQ4160PMiqN00UF60DaaPTE18VVFI99ShoXUKgwcax7AX2NePwO5NgfNqteAkX0tNnysi39e0KzTr4i1rdxQccr6TdKWAJTgmsb59Ava61l+s2xKOuNb5H1oEjrnNW99acXJDSIIzMD1xmPQL7qby6z3C+W9BLeh3jffalP9A6b6QW7LWjnUw47+w8MuKx8us/MF7Hi7BaRs80HhK6OJ84WxdAVOf85YN+KMzrgaclqHm3cPf2/308OUpZAmOSZxdm0L/MvS/DgpqBs47HR/aimNjcbLb1pXeMQJ51UKbzE3uCDf2quXBsL9r7+TDroSC2oHz7atDx4Bkoy3LnMG8j/aA934Lr57pLK8x/m+waXH4e8obYOzX4iDvAO5dG2DD/IrjmfCgM0PKr34rOOL3gXMROCxCK84B6d8q0hIckzhT/uMMYPOr0wx6X+atIwIDg1bXnPORteJks+DWm1Z9vGMETG5pE2YcTu8R3m6L2o2h68neOnPHJD20tNmwwFkr7N+9YNrz3qRi+yr4+h/w757w0qmw3JXobVsVunltuBaV/GrO992touni6+fBjNe8ZQNvdVrY3A4+L3T2W8NCJ2lNM0twTGLs3hI62+HIPzh97sE6D/au0wDWipPNbPyNcateB7qeFDiv3RQOOie0nrsOOCseZ6OFXzobjbrXCotkydfw6lmw3ZfUBLfelLd5bawL/n15r3daeJNOzvioYDXqwcHnessOOD1l42zKYwmOSYypzzqDAf1qNY48AC3cWJx5n0LxzuTFZ9JD1RIcE+rkh6HXxc504QvfcGbYBOs0CCQ/cL7+V9i8JGUhpkTxTmcH8JIwq/rW28+ZWRZyz3aY9JhzXN4Cf8GCBxov+NxpFSstDa27cjrMft9bdtydTktQOANuDqxWXLtp6Ey4NLEEx1Tenm3w7ZPesiN+X343ROfB3vUuSkts4b9stGkRbFsROK9W03YQN1CvpbOOyvmvQesIG67WahS6Cu/cT5MfWyp9/U+nC8qtSSc44ym4fib8cS6c9m/v+CRwZqpuWxXd+Bv3Nfe6Nbs2wv/Oh6f7w8w3vFsnjL/He+9+PUOnhLvV3x+unQbDP4Lrf3L+fDOAJTim8n79EPZsCZzXbAB9ry7/HhFoEzTQdMXUhIdm0iy49aZNP++gc2PK0/VE7/m8LBqHs2lR6FYUfa+G30911pipVt3p/uk9HC4f6wzw9dtX5EzfDv6lMNwMKr+CmtBxUGj5utnwzlVwX0u4bz/4Z3dYNMFb5/i7K+5yqlkf2h+dUePrLMHxEcd5IvKRiKwQkSIRWS0i40XkShGJ0DYX17s0hs9LiXpv0gTPbuh9Wfgm52DB62Gs+D5xMZnMYN1TpjK6BI3DWfJN9iz6N/bP3pWc67Zw1grLyw+tW60GHH2Tt2zaC95hATUbQuMO5b/ztMegy4mRr+/dBdtWesvaD4SOx5b/3AyV8gRHRKqJSHMRaS8iXUSktYgkd73mimNqBIwDXgdOAVoB1YGWwHHAc8B3IlKYtiAzWfBKmpHWuQgWPKp/+dTo1mYwVcPGhbDoS2+ZrX9jYtG0EzTuGDgv3QsLv0hfPImyYJyzBpjb4HucFptIel0CDdq4CoL+rWzVu+JWlnot4cLRzsKrBw51tnWoyPFVd2PkhLVKhONLHAYB/YDeQGdgP0J26QIR2QksBWYC3wMTVXV6cL0kxFgdeB842le0HHgWWAC0Bi4HDgAOBcaIyBGqmqhfIX4B/lxBnWUJeldylBQ7TZxu+/WM7t7mBzprXfgXBty5zlkHolHbhIZoUkzV2Vl4zK2w1zVwvHq90LEExlSk60nOAqJ+8z6FA89MWzgxKS2Fn9+ANT9Dk47OEglNOsGYoKUyWveFg84N/wy/atWdRfY+vD789fK6p4LtdzCcMxI2/tnpJpv/OexYGzqL66gbyx/Xk+ESnuCISAvgAuBc4DC8rUTlpZd1gQOB7sD5vmdtAD4BXgPGqybl1/vfEkhufgCOV9XNZQGLPAG8B5zgi+1O4OYEvXuDqr6XoGelx7rZ3mbW+q2i32Mkv5oz6n/ppEDZimmW4FRluzc7/wAHz8AAOODUyLMwjImky4neBGf+Z86qxuG6cjLN9JG+jYdd8qoFJRICJ/0d8qJoTel5kTP2ZkuY33vjSUSadITT/uUcq0LRdmdbhl0bnS6zBq1jf2YGSVgXlYgMFJF3cVpAHsFptcnHm9SUl6Bo0HUBmgGXAmOBZSLyJxFJ2A59vnE1d7jef6k7uQFQ1T2+GPy/iv5BRJokKoYqL7h7Ktbf0EPG4eTAaqXZastyeHpAhOTmNGdqsDGxKjzcu+v0ro1V59+Jqc+GlgW3khx6SfStL/kFMOCW8NfKmyIeDRFn7GSjdk6yVMWTG0hAgiMiJ4vINOAL4HQCrULuxEaAImAh8BVOl9DrwCjgbWAM8BOw3lc3uKVHcMbF3AcsF5FHRCQRW5Eeh5NEgdNC9Eu4Sqq6zhcvQA2gnPlyOWb1DO95tN1TfuHG4Ziq6aP/g61Bv1kW1IbTH4dzXy1/fIExkeQXOFu8uM2rAtPF1/0K6+eUX6dGAzjuL7E995DzvUtsgDM2p16L2J6TA+JOcESkr4hMBj7EGZ8SnJjMAP4FnAN0BeqoahdVPVZVz1LVC1X1UlU9R1VPUdVDVbUl0AgYANyIkwhtcb8WqAXcACwSkbtFpDJzToe4jiv6G+O+Xs4w9BwTPE1x/56x3R+8Jsqamd71GEzVMH+cs3CY2349ncGMh16aEauamioseDZVVVgP55d3ved1W0Cd5oFzyYdT/xl9l75fuFac4PWCDBDnGBzf1OWLCU1qvsFp6XhXVVeFubVCqroVmOT7PCYi+TgJz1CcsT2Nfe+sgzMeZoSIXKyqkyI8sjw9XMcVDWh2z2HuEbFWbLqKyCScQcz1gM3AXGA88Iyqrinv5rQrKYK1QY1esbbg1G0ODdvClqXOeWmJsy+VbcZYdewrgbG3e8sKj4BLP3AGRhpTWf5VjdW3o7h/VePgloxMoRqa4Bx3p7N689YVsHG+8+9ek47h76/IIec7a9X8/AY0KHT2iDIh4m3BuZRAcrMdeBQ4QFWPVtUn401uwlHVfar6par+AdgfuBDw7xImQBucrqZ4dHEdL6mg7grA97eLziIJ+ZW0JdAfJ2krAJrjDHi+G1giIhGGy0dPRMJ+EmLdbGfapl/91rH/NgKhrThVpX89lxTtgLeugEcOgE9uhuJdgWvTR8KGua7KAic+aMmNSZzajUN/6Rlza+a29q6bDRvmBc7zqkG3U5yWzIZtoONx8Sc34AywHvYc3LoErvvBmU5vQlRmDM5m4HagUFVvUtW5Fd1QWaparKqvq+pROK06Yyl/ZlZFGrqON1Tw7hLAPz28Gk4LUmUsBP6DM4vrXGA48BCwyHe9Bk4L1l8r+Z7kqWz3lJ+Nw8l8P7wCs95ylpWf+iyMPMlZKn73ZvjyPm/dnhfF//+CMZEE7y4+71N4daiz0W+mCW696Xick6QlWq1GkTfXNHFPE78feCiB68HEzNcldZKIDACaxvkY95rSe6KovxtnjBA4XUo74nzvQFWdGO6CiNyO04LjXx/nLyLyeZxdcMlV2QHGfraiceZb/p33fPUMePZY589ut2viYUEdGHRnSkMzOaL3CJj2PGxeHChbNhleOgUufjtj9j9CFWa94y078Kz0xJLj4mrBUdU/pzO5cVPViar6TsU1M0ek5MZ3bZ+q3omzerLfHZHqp1Vlp4j7tTjI2YTRb/sqp5/aZI5Ni0LLdqyBOR95y47+v8z5QWOyS426cNkYaN7dW752Frx4AmxaHP6+VFvzM2xaGDjPKwhtfTIpket7UblbYKKZjVXLdbw9wbEEu5vAukDHikitcupGpKphP5VWUgRrg1Ywjrdbolr10NYfG4eTOVSj++HRoA0ccW3y4zG5q/5+cNknoRv1bl4Cb47IjK1egrunOg2CWg3TEkquS1qCIyL3J+vZCbTFdVzu4n2+RQH9O0iWEFj4Lyl8A7X9o9RqAO2S+b6YhRtgXCfenkKgTdBA4+WW4GSMnRug2J3PRxj2dvzdUBBXHm5M9Go1gkvehc4neMtXz0j/+L1ws6eseyptktmC8ycR+U8Sn58IrmHuFSYQrXFWZgaYn6RtI4JtdB03ilgrHRI1wNjPZlJlrs1BrTctDoQzn4Z81yypwiOhx7DUxmVyV/XacP5r0OEYb/nM18NWp2g77NqU9LBY/ZP370t+dWcvLZMWye6iulpE/utr/chEs1zHfSLWCr0+K2KtxHK3Km1J0TujEzL+pmflntc6aCbV6hmwbAos/BLmfOK8LxOan3NR8Pibxu2h5wVwxedw8Hlw2FVwwX9tMT+TWvkF0Pcab9msd5zuc7dpL8ADbeCRbs4msMkU0j11vHebCZNSqUg8zgMaiMgw375OcRMRSXDLyVjgJt/xCTh7aEXiXr046ctoish+BNbpKcbZaT1zhMygquQu0fX3c7q5tvkGF+8rdgYOujXtAn2ucBa5Kq9Pu2g7fHiD0wrU62IYGGHvFhOdkASng/Pf/XvC0DB77RiTKp2Oh9pNnP2pAPZsgXljofvpzvnmJTDmFkBhX5GzIOXB5yVnarV1T2WcZLbgTCbQWX8i8JmI1C+nfrlE5FRgZiICc/kSZ/8rgONF5MAI726Ob4dznOnkYXYTTLi7CXz/vlLVpI75iUkiBxi7BY/DCbZhHnx6K/zzAPjguvAze8BJbma95ayO/OV9sGBc5WPLZZESHGPSrVr10K7RmaMDxxMf9m5uuWdraOtzoswbG1iRHSC/hrMTukmbZCY4xwOfEPgh3R+YEOsmmSLSW0S+wEkquldUPxa+xfv8q5QJ8IqIeMa6+Pa6epnAwn5PqKp7bIy77ksior7P3RHqPCAihZFiEpF8EbkHuNpVfF+k+mmx9hfvAOMGbSo3wNiv0+Do6u3dBT+87OxcvTJoh425Y5zkxm36y5WPLZdZgmMy2SHne8/njXXG22xcCDP+F1p/8VeJj0EVJjzgLet2srM7t0mbpHVRqeoeETkDJzm4EGfKc0/gaxEZrKrLy7tfRNriLCh4HoFtIZIxCOM/wDCcLRIOBX4SkWeABTgDi6/A2SsKYDZwbyXf91vgVt9Gpd/gDHTeijMFvTvOqsbunyD3qWoS/kZWQkj31CGJee7B5zp7zMz7DCTPGUhYUNsZ27F0svc3MXBm9rx+EVz1pdPFtWcrfHRj6HPnjnH+wUvGSqK5IDjBadQ+PXEYE87+h0KTzs7+TuD88jXrbWfBUP/eVW6LJ8KAmxMbw7yxof8uHn1T2KomdZI6BkdV9wEXi8hG4A84CUoXYJKIDAm3vYOINMRZxff3QHWSl9j4Yyz2JWJv4exp1YbwScwPwFm+zUArS3BatPqXU2cXcKuqPpGA9yVWomdQ+eUXwJB7nU+w7Wud7QKmj4RtK13lq+H1C521MT6701kkMJj/H7y+VyUmzlyye7N3peL8GlC/VfriMSaYiNOK88XfAmXfPgFbloWvv+w72LsHCspZ+mzvHvjo/2DZt9DyIKcbrMsJ4ZdBUIWvHvSWdTvVuc+kVUoW+lPV6wmMKVGcJOJrEentryMiBSJyE84eTf+Hs/YLvvqCs5v3kCTFtxmnS+184GNgFc7A3rXAFzjdRf1UNcLfmJicgDOw+S2cMUWrfe/ajbOh5ye+620yMrmBxA8wjka9FjDwZrh+Jhz+O++1VT/AK2c43VaRzHgtufFlq+AF/hq1g7xcXx/UZJyDz/Web14CWhq+7r6iipeh+O5p+Om/zpTvXz+AN4fDw53hnWtg4RfeGZ3zPwsd12O7e2eElE3fVtV7RGQ98LivqCnwhYicCeyHM86kkEAS5E9s5gB3qurbSY5PgdG+T7zPGAGMqKDOd8B35dXJaMkaYByt/GpOC8/GBc4/LH7BeyU1LIQtyylr/Fv1I6z7FZofgImBjb8xVUHDQmh3NCz5Ovz1Bm1gq2tUxOKJ0P7oyM+bHWYeSfF2Z52dma87g4dP+zfUbQ4TwrTe7Hdw7F+DSbiU/iqmqv8BLsJZCVhxNqwcB7wKtCWQ3AhOa8aVQI9kJzcmBpuXehd4S9QA41jk5cOwF6BZtwgVBIY+Bx0Geotn/DfpoWWd4BYcS3BMpjr4vPDlLXrAsbd7yxZH3A7QWbm7oplW8z6Fp/rBZ392WpDdbFmKjJHytmZVHQ38Dm8y4x5nswn4I9BFVV9UjdTOaNKiWRe4bTn8fiqc9Uz6/jLXrA8X/M9Ztj1Y36ug8HDoeZG3fOYbsK8ktL6JLNwif8Zkou5neDft9Tv2dmg/wFu28nso2hFaF2DBeDzDPus0g7otQuvt3uyM9XHrekriJl2YSktpgiMijUXkEZxuKv//Qe4BxG8CHVT1n6paFPIAkxny8qFZV2dg36GXpi+Oxh3g3Fcgz9XT2qAQBt3lHHc7FarXC1zbsQYWfZnaGKs666IyVUXN+tDtFG/Zfj2dnbwbtIbGHQPlpSXOSunhLPjce37ocLjxV7j0A2jTr/wYjrGxN5kkJQmOiNQRkb8Ai4AbCOzc7W69EeAkoG+4ZxgTVvsBcMHr0OIgZz+kS96BGnWda9Vrw4FneutbN1VsLMExVckRvwfxbRko+TDkb4EtRIJbcZaE6aYq3edrwXHpPNj5pa7DQLhsjLOprLub3q/rydZ6k2GSmuD4ZkZdj5PY3EVgN25wEppJwO3APpwkpy7wkYgMTWZcJst0Hgy/nQSXj4Gmnb3Xel7oPZ/zsXfas4msaDvsXBc4z6vmjLkyJlO16g0jPnbWuRn+oTepCR5UHG4czqofYbdrU86aDaCVaxvCvHw46v/g6gneaeD5NeCY2xLyJZjESdosKhG5DCepaUNgNWN/S8084E+q+p6v7iyc2Us1caaHjxaR36nqc8mKz+SIwiOcqc2blzjn+4qc/WL6XJ7OqKqG4AHGDQudWWzGZLK2RzifYO2CEpzVPzm/7LjH8c0P6p7qeFz4/+dbHAhXfgE/vuo856BzbOZUBkpmC84LBJIb/zibDcC1wIH+5AZAVT/C6Z7a7qubDzwtIn9KYnwmF4jAIUGtON/8y2mdMOXbbDOoTBap2xyau3b70VJnhXS34PE35W0fU606HHYFnP7v8qecm7RJ1SDjPTjbLnRS1ad8Kxx7qOpEnJWENxBo6blPRB5OUYwmWx1yPoFGRHw7DNtgwArZ+BuTbYLH4Sx2rZuzcwOsDJry3en45MdkkibZCY4CL+FM+f6zqpb7a7Oq/gAMwFkDx5/k3CgiL4qILZ9q4tOoLfS92ls24zWY9U564qkqLMEx2Sa4m8o9DmfhF3gm9bY82FlB3VRZyUwaPgN6qerlqrqywto+vv2pjsIZpwNOkjMceFtEwgxdNyYKg/8aujDghzf4Vjs2YdkifybbtOuPpzV33S+wY71zHDz+pnM53VOmSkhagqOqJ6rqz3HeuxwnyXG3F54OfJqI2EwOKqjlrH7snt5ZtBXevcaZGmpCWQuOyTa1GoVO5f7gWmew8cKg6eHljb8xVULGdvuo6kbgGOArAuvlDCzvHmPK1bIHHP9Xb9nSb2DSo+mJJ5Pt3e3dtV3ynFlUxlR1HY/1ns/7FJ7sB7s2BspqNoDWh6U2LpNwGZvgAKjqDuBE4MN0x2KyRL/fOFM/3SY8AFtXpCeeTOWfVu/XoDVUq5GWUIxJqCOvg7otvWU71nrPOxxrSyJkgYxOcAB8WzYMBUalOxaTBfLy4Mz/QO0mgbLSElgwLn0xZSLrnjLZqnZjuHIc7N8rch0bf5MVMj7BAVDVfap6Kc4eVsZUTr2WcNhV3rI1s9ITS6YKHmDcyDbZNFmkYRu47FPodXH46zY9PCtUiQTHT1VvSHcMJku4l1kHWGsJjoe14JhsV1ATTn8CTvkn5BUEyjsOcn4JMlWedTKa3BSS4PwCqoGN+XKdJTgmF4g4qxHv3wu+exqq13H2sTJZIa4ER0RaqOraimumhog0V9V1Fdc0xqdhIdRo4EwVByjaBluWOvtWGUtwTG5pdSgMfTbdUZgEi7eLaoGI3CMi9RIaTYxEZKCIfAv8Jp1xmCpIxNkwz83G4TiKd8HWoAUQLfEzxlQx8SY4dYA7gGUicr+IpLTDUkROFZGvgS+Avql8t8kiLXt4z20cjmPheGcjQr9G7aB67bSFY4wx8Yg3wSnCWXivAXArsFRE3hSRE5O1Z5SItBKR20VkAfA+cCSBBQB3J+OdJsu1CEpw1sS18Hb2mfOx97zLSemJwxhjKiHeQcbdgEeBM3ESjAKctWqGAptE5ENgDDAx3rE6IpIP9MbZYfwM4DACCY3fOuB2VX0xvi/D5DRrwQm1by/MHeMt63ZKemIxxphKiCvBUdWlwFARORa4FziCQOLRBGdzzOEAIrIImAn8AiwFVgGbgT1ACVATp8urJdAK6AL0AA72lfu5E5vtwGPAI6q6LZ6vwRiad3e2IPB3x2xeAnu2Qc36lXvu5iXw85vQtCsccFp8M7NU4cdRMHM0tOkLx/7ZWaQw2ZZOhj1bAue1GkPhEcl/rzHGJFilpomr6pdAfxE5AbgZp7XFz/+vekegA05rTyz896vreB3wH+BxVd0UT8zGlCmoBU06wYZ5gbJ1s6Hw8PifuWE+PD8I9vhmZ532L+g9IvbnfHEvfP0P53jJ11CzIfS/Lv64ojXnI+9515NsyXpjTJWUkF8JVXWsqh6P0/Lyb5xEJByp4BP28cA44FKgUFX/asmNSZhEjsMp3gmjLwkkNwDTXoj9OZMeDSQ3flOfg9LS8PUTRTV0/I11TxljqqiEtnmr6mzfasOtcFpzHgJ+BPYROYFx8yc664C3gCuB1qo6RFVHqWpxIuM1JmHjcFTho/+D9b96y9fMhB0xLNE09TkYd3do+dZlsGRifLFFa9WP3h3EC2qHbkxqjDFVRFLanlW1FJjg+/xJRGrgjKnpDLQFmgG1fe/fhTOmZjmwBPhZVVeGPNSYZGgRtKJxvGvhTB/pjJcJZ+GXcMh5FT9jxv/gkz9Gvv7jKOhwTFzhRSW4e6rjcU43njHGVEEp6Vz37Qg+zfcxJnMEb9mwbjaU7oO8/OifsepHGHNr5OsLx1ec4MwfB+//zlvmHgANMPsDOHkz1GoUfWyxCO6eOuC05LzHGGNSoEpttmlMwtVrCbWbBM737grdpqA8OzfAG5fCPlfvafBSUAu/KH/8jCp8eqs3mckrgAted7aU8NtXBLPejj62WGxYAOvnBM4lHzoPSc67jDEmBSzBMblNJP6Bxgu/gKePgi3LvOVn/gequ3Yx2bke1pbzzOXfwcYFrpjyYNjz0OUE6Hmxt+6Po6KLLVbB3VPtjoLajZPzLmOMSQFLcIwJ2VncNw6naDt8cjO8fBp8ehvM/9zZp2nvHuf81bNg+2rvvX2vhkPOhw4DveULxkd+f3DScsBpcOCZznHPC/CMz1/1Y3L2zApOcLqdmvh3GGNMCtkCF8aEtODMgn0lMPpiWDTBKVs8EaY8BfnVnS6t4MQGoN3RMORe57jjcd6kYcF4OPrG0HuKd8Iv73nL3K02DQudgcWLvgyUzXgNTnwgyi8uCttWwYqg4XHdTk7c840xJg0yvgVHHF1E5GwRuSfd8ZgsFG6q+Od3BpIbt33FocmN5MHRN8HF70C1Gk5Zp0HeOsunOC1CwX79EIpd5XVbhE7N7hXUTTVzNJQkaMWEOR/D84O9Zfv3ggatE/N8Y4xJk4xqwRGRRjjTyQ/x/fdgoDvgnqv6lzSEZrJZ067OoN7Svc75tpVOa000GhbCWc9C26DtDBq1g8YdYdNC57y0BBZ/HdoyMuM17/nB54WuHNztVKjZILCA4K6NMO9T6H56dDGGs2UZfHILzBsTes26p4wxWSAtLTgiki8iB4rIBSLygIh8LCLLgQ3AFzgbeV4G9MFZL6e8lY6NqZxq1aFZ18jX67eC3pdBw7be8kMugN9MCk1u/IJbcRYGjcPZsszp+nLreVHocwpqwkHnest+fDVyvBWZ/QE82S98ctO4I/S5PP5nG2NMhkh6C46INCfQGuP/HABUD64adK6+T6TrxiROix7hVzGuVhPO/y/s39M537QIVv7gtNC07lP+MzsOgqnPBs6DBxrP+J/3vFVvaN4t/LN6XQzTngucz/8M5nwS+1iZ0lL4+EZnOryb5MMRv4eBt0KNurE90xhjMlDCEhwRKcDpTvInMf5upmbBVYPO/ZtpatB1d73VwFzfx5jEa9nD2fM+2BlPBpIbgMYdnE802h3l7fravNhJkBp3cBKN4O6pcK03fvsd4nxW/xQoe++38JuvvWvlVGTjAmfaulubfnDKP0PHIhljTBUWd4IjIifiHSvTJczzymuVcScy7iTnQ2AGgYRmrqruiDdOY6ISPJMKoP8NcNDZ8T+zRl2n+8rdDbVgPPTtAMsmw5algfL8GtBjaORnicDJj8DIE53xPAB7tsBbV8Bln0B+QXQxrZ7hPS88EkZ8DHkZP9/AGGNiUpkWnE8ITVb81PVf9zX/8QbgF9fnSVedP6hq0MppxiRZ4eHODKYda53zzkNgUALGs3cc5E1wZo52tlr4+U1vvQNOrXgLhjaHwaC7nBlefiumwhd/g8FRTjBcNcN7XtjPkhtjTFZKRBdVuLEx/rItOAnMLFwJjap6tlcWkScxJp0KasHwD+G7Z6BBKzji2tj2o4qk0yAYd1fgfMW00DVnAHpeGN3zjrgWlnztjMHx++Zfzho8nQdHvs8vuAVnv57RvdcYY6oYUdWKa4W7UaQUb9fSTOB7XAmNqoZZDS3is/A9p7214FSOiJT9ocb752sSRBUe6RpoGQqn3v7wf7OiT6h2bnS2iNi+KlBWuwn85huov1/k+0pL4cFC77o71//kDJg2xpgqSCTQxqKqngaXRLRN+5OcpsBk4F+qOi7a5MaYrCYCh/+2/Dp9r4qttahOEzj7BWfmk9+ujfDlfeXft2mhN7mp2TB06rsxxmSJyrTg/AO4Fme6t/shs4BbVHVsDM+yFpwEshacDFO6D+Z+Aku+cRKMou1QtMNZFbnd0TDgj/F1h038hzP+xk/y4dpp0KRj+Poz34R3rgycdzgGLn0/9vcaY0yGKK8FJ+4Ex/fg9sDDQPD0DwXGAzer6k8hN4Y+xxKcBLIEJ0fsK4Gn+nl3Ij/4fBj6TPj6Y++Ab58InPe/AQb/NakhGmNMMiWti0pVF6vq2cAAnPE3EOiyGgRMF5GXRaRNZd5jjAkjvxoM/JO3bOZoWB9huajgGVTu9X2MMSbLJGR+qKpOUtW+wKXAiqDnXwzM9W3JUD8R7zPG+PQYCs0OcBUoTAiz03hpqXeRQLAZVMaYrJbQBTBUdRTQFbgT2Om6VBO4BVgoIteJSEZt8mlMlZWXD8fe5i375V1YE7TtxKZFoQOMbfaUMSaLJXyFL1Xdo6r3AZ2AF4BS1+UmOBtpzhGRSiwRa4wp0+00aHmQtyy4FSdk/ZtDnBlexhiTpZK2hKmqrlPVq4BDgXF4t2ToAIwWkckiclSyYjAmJ+TlwbF3eMvmfASrfgycu4/Bxt8YY7Je0tdoV9WfVXUIcBowx1+Mk+j0A77CO808LcRxnoh8JCIrRKRIRFaLyHgRuTIZ3WoiUkdEbhSRb0RknYjsEZGlIjJaRE5I9PtMFutyorMbudsXrnVxbPyNMSbHpGwTGlX9GGdTzj8AG12XgtvJo9w1MHFEpBFOK9PrwClAK5z1fVoCxwHPAd+JSAzbNlf4zl44qz8/AhyJs+t6DaAQOBf4VEReE5HqiXqnyWIicOzt3rIFnzube4YbYGwtOMaYLJfSXfZUdZ+qPokzPucfQLH7Mk6yM0lErhWRlCQ6vgTifZxEBmA5ziDpC4CbgV995YcCYxIxE0xE2gJjcLrqAKYC1wEXAg8QSAAvxBnHZEzFOg5ydgd3G3s7bJwPRdsCZTUbQKP2qY3NGGNSrFIL/VX65SLtgIeAs/HuTK44icbdwMuaxCBF5HrgMd/pD8DxqrrZdb0m8B7g7zL6h6reXMl3vguc6Tt9EbhKVUtd1wuBr3FacwBO9bWARft8W+gvV638AZ471lvW9ihYOilw3n6As7GoMcZUcUlbyThRRORI4J9AXwItOfiO5wF3qupbSXhvNWAVTveQAgep6i9h6jUHFgF1gCKglapuDK4X5TsPAWb4TpcBXVV1T5h6JwP+pOZ7VT0shndYgpPL3vsdzHgt8vUjr4Mhf4t83Rhjqohkb7ZZaao6WVUPx1kU0L9Ngz/R6Yoz4+p7ETkxwa8+Die5ARgfLrnxxbcOZ3wOOONkzqjEO89zHT8bLrnxGQP41+DvIyIRNhgyJsigv0D1upGv2/gbY0wOyIgEx09V/wt0A+4AdviLcRKdQ4GPEvzKIa7jTyuo675emUQrqnf6uuXcG5barCoTnXot4eibIl+3GVTGmByQcSsKq2oR8ICIPA/cC1yOk4gJoTOuKquH63h6BXW/dx33iFirHCKSB/jX1S8BKtqINBHvDFseS9dVuz9FPfzHZIgatOfz6s0ozFvvKd+mtTn44V8JrNhgjDHJt+TBU1L+zoxqwXFT1fWqeg3QC/g8Sa/p4jpeUkHdFcA+33FniZQ5lK81UNt3vFJVSyqov9R13CViLWOCFFGd+0ouCimfVdqOxP+eYIwxmSdjExw/VZ2lqifirE8zO8GPb+g63lBBHCWAf65tNZwBx0l7n497IHPDSJWMCWds6WFM3tfdUzZTbSiXMSY3ZHyC46eqY4BDEvxY90jMSIN93Xa7jutVgfeZnCbcWXIZm9T53263VmfUvkFpjskYY1Ij48bglMe9VkwWSMn87URME09H36lJoK0nw/Kp1Gp7JJPqtUx3NMYYkxJVKsFJgh1AI99xTQIztyKp5TreHuf7wj0rWe8zBhq0dj7GGJNDqkwXVZJscR03Ka+ib1FA/zYNJcDOZL4vTJ0tkSoZY4wxxivXE5x5ruN2FdRtDeT7jufHuX3ECmCX/3lR7FDe1nU8L2ItY4wxxnjkeoIzy3Xcp4K67uuzItYqh28MkX/zzmpUPGi60u80xhhjclGuJzixrBTsXr24olWPK/1O3zo77utjI9U1VZ+IeD6marE/v6rN/vyyU0ZstpkucW62uQdobZttmkQK/kfV/tyqFvvzq9rsz6/qyvjNNtPFt3jffb5TAV4RkUbuOiJSE3iZwMJ+T0RKbkTkJRFR3+fuCO/8CXjPd1oIPOHbwsH9nELgP66isM8yxhhjTHi5Pk0cnERiGHA0zoaeP4nIMzg7ebcGriCwf9RsnP2xKusG4Aighe/5PUTkVZyViw8CriEwg+o1VbXNoIwxxpgY5HyCo6rFInIG8BZwHNCG8EnMD8BZqro1Ae9cKiIn+d7ZAejn+wT7L85mo8YYY4yJQU53Ufmp6mbgeOB8nHEvq4BiYC3wBXA10E9VlyXwnT8CBwM3Ad/i7E1VBCwH3gROUtWLVLU4Ue80xhhjckVODzLOVjbIuOqxQY5Vm/35VW3251d1lTfI2BKcLOROcIwxxphcYLOojDHGGJP1LMExxhhjTNaxLipjjDHGZB1rwTHGGGNM1rEExxhjjDFZxxIcY4wxxmQdS3CMMcYYk3UswTHGGGNM1rEExxhjjDFZxxIcY4wxxmQdS3CMMcYYk3UswTHGGGNM1rEEx5g0EpFaInKaiDwqIpNEZJ2IFIvINhH5VURGisigKJ91t4hoDJ92Sf7yspo4zhORj0RkhYgUichqERkvIleKSLV0x5hrRKSBiJwrIv8Rke9EZKOI7BWRzSLyk4g8JSKHRfGcl2L5u5SKr83EzrZqMCZNROQi4GmgbhTVPwUuVdX15TzvbuCuGEJor6pLYqhvfESkEfAWcFw51X4AzlLVZamJKreJyC3APUCNKKqPAq5R1V0RnvUSMDzadwfvYm0yg/2GYUz6tCeQ3KwGPgemAeuAOsDRwAVATeBEYJyIHBHpH+UgdwKzKqizLp6gc52IVAfex/nzAVgOPAssAFoDlwMHAIcCY3x/ZtvSEWuO6UIguVkEjANmABuARsAgYBiQD1wMNBeRk1S1tILnXoP9XamSLMExJr2+AR4ExqjqvqBrI0XkHzj/UO8HHAzcSnStNJNUdUIiAzVlfksgufkBOF5VN/svisgTwHvACUB3nGTz5hTHmIsU+Bh4GJiood0Tz4rI0cAnOL9YDMFppRlZwXM/s5bOqsnG4BiTPk+q6lGq+lGY5AYAVZ0NXO0qGpGSyExYvnE1d/hOFafbcLO7jqruAS4FdvqK/iAiTVIXZc66RVVPVdWvwiQ3AKjq18BtrqIRKYnMpIUlOMakSfAPxnKMIfDDslBE6icpJFOx44BmvuPxqvpLuEqqug543XdaAzgjBbHltBj+Pr3pOj4oGbGYzGAJjjEZzte64x53UytdsRiGuI4/raCu+/qJSYjFxGe769j+LmUxS3CMyXAi0pxAq8EuIOJMKpd7RGShiOzxTTmfLyKv+qak24yP+PVwHU+voO73Ee4z6eX+s1gaRf3nRGSZbxmALSIyW0SeE5EByQrQJIYNMjYm87nH4HwaxawPCAyCBaeLpB7QCWf2yHcicp6qRvOPu/Hq4jpeUkHdFcA+nFk7nUVEIo0NMSnl/vv0cRT1j3cdVwca4MySu1JEPsYZh7UpgfGZBLEEx5gMJiId8A6KfLCCW/YAXwLfAouBYqAlMBBnHEg+0A+YLCJ9VXVlwoPObg1dxxvKq6iqJSKyDWeKcjWcqf87kheaqYiIHAlc5jvdAzxWTvXtOEs3TMVZCmAfzjIAQwh0VZ4CfCUi/W0pgMxjC/0Zk6FEpA4wGWd6ODizrq4tp34PYFWk3yZF5ECc6cudfEXjVHVw4iLOfiJSDBT4TgtUtaSC+iuB/X2n+6vq6mTGZyITkZY43YatfEU3q+o/ItTtDcxR1Z0Rrh+Ns9Bjc1/R86p6VYJDNpVkCY4x5RCRK3F+a6s0Vb07hvfmA+8Ap/uKfgD6+6Ygx01EOgI/ExhcebiqfleZZ+YSS3CqJt8vC18AfX1FHwOnVabLUET6A18DgtO609ZaRDOLJTjGlENEpuB06VRatMu5i0ge8DLOeBmAucAA39TjShORp3FWZwX4m6r+JRHPzQUisgmnywmgnqqW2+UUa32TeCJSEyeh8W+r8Q1wQqTWmRif/SnOgo4AV6jqi5V9pkkcm0VlTAbxzXB6hkBysxAYlKjkxmeC67hrAp+bC7a4jstdvM+3KKB/zaISAmsZmRTxbavxDoHkZipwciKSG58JrmP7u5RhbJCxMeVQ1cNT/MongCt9x0uB45LQ7L3RddwoYi0TzjycPcQA2lH+NOPWOIO6AebbDKrUEpECnEX9TvIV/QicmODBwPZ3KYNZC44xGUJEHgN+5ztdgZPcJGMnanfLw5YkPD+buTcw7VNBXff1ijY+NQnkaz37H4ExbD8Dg2NY7Tha9ncpg1mCY0wGEJGHgOt9p6txkptFSXrdQNfxvCS9I1uNdR2fELGWw716cUWrHpsE8Q3QfxVn53CA2Tgbom6MfFfc7O9SBrNBxsakmYjcS2ADx7XAMao6J0nvCp5F1V9VJyfjXdnI1zKwCmdlaQUOCrcflW/16UU4a9/sAVon6QescfEN0B+Js9kpOEnHQFVdk4R3HQlMwplFVQq0U9XliX6PiZ+14BiTRiLyZwLJzXqcAcUxJze+LRjO9v32GqnOgTgtCf7kZoIlN7HxTQu/z3cqwCsi4hl74Zu18zJOcgPwhCU3yecaoO9PbhYAx8aa3IjIpSIyuLwtTUTkKOBdnP8HAF6x5CbzWAuOMWkiIlcBz7qK7gJmRnHrJFX1rKIrIjcAj+IkSZ8CM4A1wF6gBXAMzkrG/okFq4AjkjTGJ6v5ZuaMI7AdxnKcH6wLcAYWX4GzlD843SNHqurWVMeZa0TkfgKrfu8FbsL5s6nIZ6patpmtbyzc9b57x+K0eK4ndCVjf3LzC3CUqm6p9BdhEsoSHGPSREReAobHceuxqjoh6Fk34CQ40fgauMT2ooqfr9XmLQLTj8P5ATjLksjUEJEJeMfERKu9qi5xPecxAuPhKvIucJW10GUmmyZuTHZ4FVgJHIEze2d/oClON8k2nN9GpwCvBydHJnaqullEjgfOBS4BeuF8vzfj/Eb/OjCyopWOTUZ6GGen+MOBQ3FaQJsCNYGtOHu8TcbplvohXUGailkLjjHGGGOyjg0yNsYYY0zWsQTHGGOMMVnHEhxjjDHGZB1LcIwxxhiTdSzBMcYYY0zWsQTHGGOMMVnHEhxjjDHGZB1LcIwxxhiTdSzBMcYYY0zWsQTHGGOMMVnHEhxjjDHGZB1LcIwxxhiTdSzBMcYYY0zWsQTHGGOMMVnHEhxjjDHGZB1LcIwxxhiTdSzBMcYYY0zWsQTHGGOMMVnHEhxjjImBiIwVEXV9rojyvloiMino3geTHa8xuUpUNd0xGGNMlSEiBwM/EvgFcTnQWVWLyrmnGvAecIqr+DlVvTpZcRqT66wFxxhjYqCqM4FXXEVtgN9Fqi8iAryEN7l5A/hNMuIzxjisBccYY2IkIq2BeUAtX9EGoIOqbg9T91/Ada6iscDpqlqc9ECNyWHWgmOMMTFS1RXAo66ipsBNwfVE5C94k5vJwFBLboxJPmvBMcaYOIhIfWAB0MxXtB2nFWeD7/pvgadct8wEBqrqllTGaUyushYcY4yJg6puA/7qKqoH3AEgIucBT7iuLQCGWHJjTOpYC44xxsTJNzvqF6CLr6gIuBan5abAV7YSOEpVl6Q8QGNymCU4xhhTCSJyFvBOhMsbgQGqOjuFIRljsATHGGMqTUS+Bo4KKt4BDFLVqWkIyZicZ2NwjDGm8j4JU3aWJTfGpI8lOMYYUwkicipwT5hLLVMdizEmwLqojDEmTiIyAPiUwIJ/bsuALuVt4WCMSR5rwTHGmDiIyKHAhwSSm53AW64qhXgX+TPGpJC14BhjTIxEpCvwNYFF/oqB04ApwCKgia98C9BRVTelOkZjcp214BhjTAxEpA3wGYHkphS4WFU/8y3+94CrekPgz6mN0BgD1oJjjDFRE5GmOC033VzFv1XVp111auJsxNnGV1QMdFPVxSkL1BhjLTjGGBMNEamHM6DYndz82Z3cAKjqHrxbOFQH7k9+hMYYN2vBMcaYCvhaZcYAx7iKH1XVGyPUzwdmEUiGFOinqtOSGacxJsBacIwxphy+/aZG401uXgFuinSPqu4D7nQ/Bng4GfEZY8KzFhxjjIlARAR4GbjEVfwhMFRVS6K4fxrQx1V0uqp+mNgojTHhWIJjjDERiMi/8K5lMxE4wTfOJpr7jwc+dxXNBg72tfAYY5LIEhxjjDHGZB0bg2OMMcaYrGMJjjHGGGOyjiU4xhhjjMk6luAYY4wxJutYgmOMMcaYrGMJjjHGGGOyjiU4xhhjjMk6luAYY4wxJutYgmOMMcaYrGMJjjHGGGOyjiU4xhhjjMk6luAYY4wxJutYgmOMMcaYrGMJjjHGGGOyzv8DJTwhc4W+LiQAAAAASUVORK5CYII=\n",
+=======
+      "image/png": "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\n",
+>>>>>>> Stashed changes
+      "text/plain": [
+       "<Figure size 576x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, figsize=(8,6))\n",
+    "\n",
+<<<<<<< Updated upstream
+    "axs.plot(grid, pmf2, linewidth=4, label=r'eABF/MBAR')\n",
+=======
    "execution_count": null,
    "id": "077d9fb8",
    "metadata": {},
@@ -227,7 +524,13 @@
     "fig, axs = plt.subplots(1, figsize=(8,6))\n",
     "\n",
     "#axs.plot(grid, pmf2, linewidth=4, label=r'eABF/MBAR')\n",
+>>>>>>> 652b097388de11a53b5cf5c11673efc2df0edd0a
     "axs.plot(grid+bin_width, pmf_ti2, linewidth=4, label='eABF/CZAR')\n",
+=======
+    "axs.plot(grid, pmf2, linewidth=4, label=r'GaWTM-eABF/MBAR')\n",
+    "axs.plot(grid+bin_width, pmf_ti2, linewidth=4, label='GaWTM-eABF/CZAR')\n",
+    "axs.plot(grid+bin_width, pmf_ti2c, linewidth=4, label='GaWTM-eABF/cCZAR')\n",
+>>>>>>> Stashed changes
     "\n",
     "axs.tick_params(axis='y',length=8,width=4,labelsize=30, pad=10, direction='in')\n",
     "axs.tick_params(axis='x',length=8,width=4,labelsize=30, pad=10, direction='in')\n",


Test patch:
diff --git a/adaptive_sampling/test/colvars/pathCV_test.py b/adaptive_sampling/test/colvars/pathCV_test.py
new file mode 100644
index 0000000..1b6e101
--- /dev/null
+++ b/adaptive_sampling/test/colvars/pathCV_test.py
@@ -0,0 +1,207 @@
+import sys
+import pytest
+import torch
+from math import isclose
+
+from adaptive_sampling.colvars.path_cv import PathCV
+from adaptive_sampling.colvars.utils import *
+from adaptive_sampling.units import BOHR_to_ANGSTROM
+
+sys.path.append("resources/")
+
+@pytest.mark.parametrize(
+    "input, path, bounds", [
+        (
+            "resources/path.xyz", 
+            [
+                torch.tensor([[1.0, 0.0, 0.0], [0.0, 0.0, 0.0]]), 
+                torch.tensor([[3.0, 0.0, 0.0], [0.0, 0.0, 0.0]]),
+                torch.tensor([[5.0, 0.0, 0.0], [0.0, 0.0, 0.0]]),
+            ], 
+            [
+                torch.tensor([[-1.0, 0.0, 0.0], [0.0, 0.0, 0.0]]), 
+                torch.tensor([[7.0, 0.0, 0.0], [0.0, 0.0, 0.0]]),
+            ]
+        )
+    ]
+)
+def test_init_cartesian(input, path, bounds):
+    path = [path[i] / BOHR_to_ANGSTROM for i in range(len(path))]
+    bounds = [bounds[i] / BOHR_to_ANGSTROM for i in range(len(bounds))]
+    
+    cv = PathCV(guess_path=input, metric="RMSD", smooth_damping=0.0, coordinate_system="Cartesian")
+    assert cv.nnodes == len(path)
+    assert torch.allclose(cv.path[0], path[0], atol=1.e-1)
+    assert torch.allclose(cv.path[1], path[1], atol=1.e-1)
+    assert torch.allclose(cv.path[2], path[2], atol=1.e-1)
+    assert torch.allclose(cv.boundary_nodes[0], bounds[0], atol=1.e-1)
+    assert torch.allclose(cv.boundary_nodes[1], bounds[1], atol=1.e-1)
+    
+@pytest.mark.parametrize(
+    "input, path, bounds", [
+        (
+            "resources/path.xyz", 
+            [
+                torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]), 
+                torch.tensor([[0.0, 0.0, 0.0], [3.0, 0.0, 0.0]]),
+                torch.tensor([[0.0, 0.0, 0.0], [5.0, 0.0, 0.0]]),
+            ], 
+            [
+                torch.tensor([[0.0, 0.0, 0.0], [-1.0, 0.0, 0.0]]), 
+                torch.tensor([[0.0, 0.0, 0.0], [7.0, 0.0, 0.0]]),
+            ]
+        )
+    ]
+)
+def test_init_zmatrix(input, path, bounds):
+    path = [path[i] / BOHR_to_ANGSTROM for i in range(len(path))]
+    bounds = [bounds[i] / BOHR_to_ANGSTROM for i in range(len(bounds))]
+    
+    cv = PathCV(guess_path=input, metric="RMSD", smooth_damping=0.0, coordinate_system="ZMatrix")
+
+    assert cv.nnodes == len(path)
+    assert torch.allclose(cv.path[0], path[0], atol=1.e-1)
+    assert torch.allclose(cv.path[1], path[1], atol=1.e-1)
+    assert torch.allclose(cv.path[2], path[2], atol=1.e-1)
+    assert torch.allclose(cv.boundary_nodes[0], bounds[0], atol=1.e-1)
+    assert torch.allclose(cv.boundary_nodes[1], bounds[1], atol=1.e-1)
+
+@pytest.mark.parametrize(
+    "input, path, bounds", [
+        (
+            "resources/path.xyz", 
+            [
+                torch.tensor([1.0]), 
+                torch.tensor([3.0]),
+                torch.tensor([5.0]),
+            ], 
+            [
+                torch.tensor([-1.0]), 
+                torch.tensor([7.0]),
+            ]
+        )
+    ]
+)
+def test_init_cv_space(input, path, bounds):
+    path = [path[i] / BOHR_to_ANGSTROM for i in range(len(path))]
+    bounds = [bounds[i] / BOHR_to_ANGSTROM for i in range(len(bounds))]
+    
+    cv = PathCV(guess_path=input, metric="RMSD", smooth_damping=0.0, coordinate_system="cv_space", active=[[0,1]])
+
+    assert cv.nnodes == len(path)
+    assert torch.allclose(cv.path[0], path[0], atol=1.e-1)
+    assert torch.allclose(cv.path[1], path[1], atol=1.e-1)
+    assert torch.allclose(cv.path[2], path[2], atol=1.e-1)
+    assert torch.allclose(cv.boundary_nodes[0], bounds[0], atol=1.e-1)
+    assert torch.allclose(cv.boundary_nodes[1], bounds[1], atol=1.e-1)
+
+@pytest.mark.parametrize(
+    "input, coords1, coords2, coords3, coords4, coords5", [
+        (
+            "resources/path.xyz", 
+            torch.tensor([1.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+            torch.tensor([2.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+            torch.tensor([3.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+            torch.tensor([4.0, 0.0, 0.0, 0.0, 0.0, 0.0]),            
+            torch.tensor([5.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+        )
+    ]
+)
+def test_calculate_gpath(input, coords1, coords2, coords3, coords4, coords5):
+    coords1 = coords1 / BOHR_to_ANGSTROM
+    coords2 = coords2 / BOHR_to_ANGSTROM 
+    coords3 = coords3 / BOHR_to_ANGSTROM
+    coords4 = coords4 / BOHR_to_ANGSTROM
+    coords5 = coords5 / BOHR_to_ANGSTROM
+
+    cv = PathCV(guess_path=input, metric="RMSD", smooth_damping=0.0, coordinate_system="cv_space", active=[[0,1]])
+    cv1 = cv.calculate_gpath(coords1)
+    cv2 = cv.calculate_gpath(coords2) 
+    cv3 = cv.calculate_gpath(coords3)
+    cv4 = cv.calculate_gpath(coords4)
+    cv5 = cv.calculate_gpath(coords5)
+    assert isclose(float(cv1), float(0.0), abs_tol=1e-2)
+    assert isclose(float(cv2), float(0.25), abs_tol=1e-2)
+    assert isclose(float(cv3), float(0.5), abs_tol=1e-2)
+    assert isclose(float(cv4), float(0.75), abs_tol=1e-2)
+    assert isclose(float(cv5), float(1.0), abs_tol=1e-2)
+
+@pytest.mark.parametrize(
+    "input, coords1, coords2, coords3", [
+        (
+            "resources/path.xyz", 
+            torch.tensor([1.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+            torch.tensor([3.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+            torch.tensor([6.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+        )
+    ]
+)
+def test_calculate_path(input, coords1, coords2, coords3):
+    coords1 = coords1 / BOHR_to_ANGSTROM
+    coords2 = coords2 / BOHR_to_ANGSTROM 
+    coords3 = coords3 / BOHR_to_ANGSTROM
+
+    cv = PathCV(guess_path=input, metric="RMSD", adaptive=True)
+
+    cv1 = cv.calculate_path(coords1)
+    cv2 = cv.calculate_path(coords2) 
+    cv3 = cv.calculate_path(coords3)
+    assert isclose(float(cv1), float(0.1), abs_tol=1e-1)
+    assert isclose(float(cv2), float(0.5), abs_tol=1e-1)
+    assert isclose(float(cv3), float(0.9), abs_tol=1e-1)
+
+@pytest.mark.parametrize(
+    "input, coords1, coords2", [
+        (
+            "resources/path.xyz", 
+            torch.tensor([3.0, 1.0, 0.0, 0.0, 0.0, 0.0]),
+            torch.tensor([3.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+        )
+    ]
+)
+def test_projection_point_on_path(input, coords1, coords2):
+    coords1 = coords1.view(2,3) / BOHR_to_ANGSTROM
+    coords2 = coords2.view(2,3) / BOHR_to_ANGSTROM
+    cv = PathCV(guess_path=input, metric="RMSD")
+    rmsds = cv._get_distance_to_path(coords1)
+    _, q = cv._get_closest_nodes(coords1, rmsds)
+    cv1 = cv._project_coords_on_line(coords1, q)
+    assert torch.allclose(cv1, coords2)
+
+@pytest.mark.parametrize(
+    "coords, zmatrix", [
+        (
+            torch.tensor([0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0]),
+            torch.tensor([
+                [0.0, 0.0000, 0.0000], 
+                [1.0, 0.0000, 0.0000], 
+                [1.0, 1.5708, 0.0000],
+                [1.0, 1.5708, 1.5708],
+            ])
+        )
+    ]
+)
+def test_internals(coords, zmatrix):
+    zm = cartesians_to_internals(coords)
+    assert torch.allclose(zm, zmatrix)
+
+@pytest.mark.parametrize(
+    "input, coords", [
+        (
+            "resources/path.xyz", 
+            torch.tensor([2.0]),
+        )
+    ]
+)
+def test_selected_rmsd(input, coords):
+    coords /= BOHR_to_ANGSTROM
+
+    cv = PathCV(guess_path=input, metric="RMSD", coordinate_system="cv_space", active=[[0,1]])
+
+    rmsd0 = get_rmsd(coords, cv.path[0]) * BOHR_to_ANGSTROM
+    rmsd1 = get_rmsd(coords, cv.path[1]) * BOHR_to_ANGSTROM
+    rmsd2 = get_rmsd(coords, cv.path[2]) * BOHR_to_ANGSTROM
+
+    assert isclose(1.0, rmsd0, abs_tol=1.e-1)
+    assert isclose(1.0, rmsd1, abs_tol=1.e-1)
+    assert isclose(3.0, rmsd2, abs_tol=1.e-1)
\ No newline at end of file
diff --git a/adaptive_sampling/test/colvars/resources/path.xyz b/adaptive_sampling/test/colvars/resources/path.xyz
new file mode 100644
index 0000000..909440d
--- /dev/null
+++ b/adaptive_sampling/test/colvars/resources/path.xyz
@@ -0,0 +1,12 @@
+2
+
+H    1.0    0.0    0.0
+H    0.0    0.0    0.0
+2
+ 
+H    2.0    0.0    0.0 
+H    0.0    0.0    0.0
+2
+
+H    5.0    0.0    0.0
+H    0.0    0.0    0.0
diff --git a/adaptive_sampling/test/colvars/rmsd_test.py b/adaptive_sampling/test/colvars/rmsd_test.py
index 01ab5d2..77b47b5 100644
--- a/adaptive_sampling/test/colvars/rmsd_test.py
+++ b/adaptive_sampling/test/colvars/rmsd_test.py
@@ -2,7 +2,6 @@
 import pytest
 import numpy as np
 from adaptive_sampling.colvars.colvars import CV
-from adaptive_sampling.colvars.kearsley import Kearsley
 from adaptive_sampling.colvars.utils import *
 from adaptive_sampling.interface.sampling_data import SamplingData
 
@@ -51,7 +50,7 @@ def get_sampling_data(self) -> SamplingData:
                 ]
             ),
             26.6020,
-            0.0979,
+            0.0978,
         )
     ],
 )
@@ -59,7 +58,7 @@ def test_kabsch(a, b, expected_nofit, expected_fit):
     a = torch.flatten(a).float()
     b = torch.flatten(b).float()
 
-    rmsd_nofit = rmsd(a, b)
+    rmsd_nofit = get_rmsd(a, b)
     rmsd_kabsch = kabsch_rmsd(a, b)
 
     assert float(rmsd_nofit) == pytest.approx(expected_nofit, rel=1.0e-3)
@@ -95,7 +94,7 @@ def test_kabsch_1(a, b, expected_nofit, expected_fit):
     a = torch.flatten(a).float()
     b = torch.flatten(b).float()
 
-    rmsd_nofit = rmsd(a, b)
+    rmsd_nofit = get_rmsd(a, b)
     rmsd_kabsch = kabsch_rmsd(a, b)
 
     assert float(rmsd_nofit) == pytest.approx(expected_nofit, abs=1.0e-3)
@@ -127,7 +126,7 @@ def test_kabsch_1(a, b, expected_nofit, expected_fit):
                 ]
             ),
             26.6020,
-            0.0979,
+            0.0978,
         )
     ],
 )
@@ -135,7 +134,7 @@ def test_quaternion(a, b, expected_nofit, expected_fit):
     a = torch.flatten(a).float()
     b = torch.flatten(b).float()
 
-    rmsd_nofit = rmsd(a, b)
+    rmsd_nofit = get_rmsd(a, b)
     rmsd_quaternion = quaternion_rmsd(a, b)
 
     assert float(rmsd_nofit) == pytest.approx(expected_nofit, rel=1.0e-3)
@@ -171,7 +170,7 @@ def test_quaternion_1(a, b, expected_nofit, expected_fit):
     a = torch.flatten(a).float()
     b = torch.flatten(b).float()
 
-    rmsd_nofit = rmsd(a, b)
+    rmsd_nofit = get_rmsd(a, b)
     rmsd_quaternion = quaternion_rmsd(a, b)
 
     assert float(rmsd_nofit) == pytest.approx(expected_nofit, abs=1.0e-3)
@@ -201,10 +200,7 @@ def test_rmsd(coords1, coords2, rmsd_fit):
     the_cv = CV(the_md, requires_grad=True)
     f1, grad1 = the_cv.get_cv("rmsd", coords2, method="kabsch")
     f2, grad2 = the_cv.get_cv("rmsd", coords2, method="quaternion")
-    f3, grad3 = the_cv.get_cv("rmsd", coords2, method="kearsley")
     assert f1 == pytest.approx(rmsd_fit, abs=1e-3)
     assert f2 == pytest.approx(rmsd_fit, abs=1e-3)
-    assert f3 == pytest.approx(rmsd_fit, abs=1e-3)
     assert np.allclose(grad1, grad2)
-    assert np.allclose(grad2, grad3)