diff --git a/aeon/classification/feature_based/__init__.py b/aeon/classification/feature_based/__init__.py
index 7e16c0de3c..018ec9c1ba 100644
--- a/aeon/classification/feature_based/__init__.py
+++ b/aeon/classification/feature_based/__init__.py
@@ -10,10 +10,12 @@
     "SummaryClassifier",
     "TSFreshClassifier",
     "FreshPRINCEClassifier",
+    "TDMVDCClassifier",
 ]
 
 from aeon.classification.feature_based._catch22 import Catch22Classifier
 from aeon.classification.feature_based._fresh_prince import FreshPRINCEClassifier
 from aeon.classification.feature_based._signature_classifier import SignatureClassifier
 from aeon.classification.feature_based._summary import SummaryClassifier
+from aeon.classification.feature_based._tdmvdc import TDMVDCClassifier
 from aeon.classification.feature_based._tsfresh import TSFreshClassifier
diff --git a/aeon/classification/feature_based/_tdmvdc.py b/aeon/classification/feature_based/_tdmvdc.py
new file mode 100644
index 0000000000..defb70bc96
--- /dev/null
+++ b/aeon/classification/feature_based/_tdmvdc.py
@@ -0,0 +1,629 @@
+"""Tracking Differentiator-based Multiview Dilated Characteristics (TDMVDC).
+
+Ensemble classifier using TSFresh features and ANOVA,
+with RidgeClassifierCV and hard voting.
+"""
+
+import numpy as np
+from joblib import Parallel, delayed
+from sklearn.feature_selection import f_classif
+from sklearn.linear_model import RidgeClassifierCV
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+
+from aeon.classification.base import BaseClassifier
+from aeon.transformations.collection.feature_based import TSFresh
+from aeon.utils.validation import check_n_jobs
+
+__all__ = ["TDMVDCClassifier"]
+
+
+class TDMVDCClassifier(BaseClassifier):
+    """Tracking Differentiator-based Multiview Dilated Characteristics classifier.
+
+    The TDMVDCClassifier is an advanced ensemble classifier tailored for
+    time series classification tasks. It operates by transforming the
+    input time series data through a tracking differentiator, generating
+    three distinct views: the original signal, the first-order differential,
+    and the second-order differential. Each of these views is further processed
+    using a set of dilation rates, allowing the model to capture temporal
+    dependencies and patterns at multiple scales.
+
+    For each dilated view, the classifier extracts a comprehensive set of
+    features using the TSFresh feature extraction framework. These features are
+    then evaluated using ANOVA F-values to determine their relevance to the
+    classification task. Multiple classifiers are constructed, each trained on a
+    different proportion of the most informative features, as determined by the
+    feature selection process. The ensemble of classifiers provides robust
+    predictions by aggregating their outputs through a hard voting mechanism,
+    which enhances generalization and reduces the risk of overfitting.
+
+    The TDMVDCClassifier is highly parallelized, supporting multi-threaded feature
+    extraction and model training to efficiently handle large datasets. Its design
+    is particularly effective for time series problems where both the original and
+    differential characteristics of the data, as well as multiscale temporal patterns,
+    are important for accurate classification.
+
+    Parameters
+    ----------
+    default_fc_parameters : str, default="efficient"
+        Specifies the set of TSFresh features to extract. Options include "minimal",
+        "efficient", or "comprehensive".
+    k1 : float, default=2
+        Filter parameter for the first tracking differentiator, controlling the
+        generation of first-order differential series.
+    k2 : float, default=2
+        Filter parameter for the second tracking differentiator, controlling the
+        generation of second-order differential series.
+    feature_store_ratios : list, default=None
+        List of feature retention ratios for different feature selectors.
+        If None, defaults to [0.1, 0.2, 0.3, 0.4, 0.5].
+    n_jobs : int, default=1
+        Number of parallel jobs to run for feature extraction and model training.
+        "-1" uses all available processors.
+    parallel_backend : str, ParallelBackendBase instance or None, default=None
+        Specifies the parallelization backend for joblib. Options include "loky",
+        "multiprocessing", "threading", or a custom backend.
+
+    Attributes
+    ----------
+    n_classes_ : int
+        Number of unique classes in the training data.
+    classes_ : ndarray of shape (n_classes_)
+        Array of class labels.
+    clfList_ : list
+        List of trained classifier pipelines for each feature subset.
+    dList_ : ndarray
+        Array of dilation rates used for multiscale feature extraction.
+    tsFreshListR_ : list
+        List of TSFresh feature extractors for original signal at each dilation rate.
+    tsFreshListF_ : list
+        List of TSFresh feature extractors for the first-order differential signal
+        at each dilation rate.
+    tsFreshListS_ : list
+        List of TSFresh feature extractors for the second-order differential signal
+        at each dilation rate.
+    scoreRFS_ : ndarray
+        Array of ANOVA F-values for all extracted features, used for feature selection.
+
+    Notes
+    -----
+    The TDMVDCClassifier is particularly effective for time series datasets where
+    capturing both the original and differential dynamics, as well as multiscale
+    temporal features, is crucial for distinguishing between classes. Its ensemble
+    approach and feature selection strategy help to mitigate overfitting and improve
+    predictive performance on complex datasets.
+
+    For the algorithm details, see [1]_.
+
+    References
+    ----------
+    .. [1] Changchun He, and Xin Huo. "Tracking Differentiator-based Multiview Dilated
+        Characteristics for Time Series Classification." in The 22nd IEEE International
+        Conference on Industrial Informatics (INDIN2024) (2024).
+    """
+
+    _tags = {
+        "capability:multithreading": True,
+        "algorithm_type": "feature",
+        "python_dependencies": "tsfresh",
+    }
+
+    def __init__(
+        self,
+        default_fc_parameters="efficient",
+        k1=2,
+        k2=2,
+        feature_store_ratios=None,
+        n_jobs=1,
+        parallel_backend=None,
+    ):
+        self.default_fc_parameters = default_fc_parameters
+        self.k1 = k1
+        self.k2 = k2
+        self.feature_store_ratios = feature_store_ratios
+        self.n_jobs = n_jobs
+        self.parallel_backend = parallel_backend
+        super().__init__()
+
+    def _series_set_dilation(self, seriesX, d_rate=1):
+        """
+        Map each series of the time series set by dilation mapping.
+
+        Should have the same dilation rate.
+
+        Parameters
+        ----------
+        seriesX : 3D np.ndarray of shape = [n_cases, n_channels, n_timepoints]
+            The set of three dimensional time series set to be dilated.
+        d_rate : int, default=1
+            Dilation rate.
+
+        References
+        ----------
+        .. [1] P. Schaefer and U. Leser, "WEASEL 2.0: a random dilated dictionary
+        transform for fast, accurate and memory constrained time series classification"
+        Machine Learning, vol. 112, no. 12, pp. 4763–4788, Dec.(2024).
+        """
+        n_cases, n_channels, _ = seriesX.shape[:]
+        seriesXE = np.zeros_like(seriesX)  # Initializing the dilated time series set
+        for i in range(n_cases):
+            for j in range(n_channels):
+                series_ = []
+                for d in range(d_rate):
+                    series_.append(seriesX[i, j, d::d_rate])
+                seriesXE[i, j, :] = np.hstack(series_)
+        return seriesXE  # Return the dilated time series set
+
+    def _fhan(self, x1, x2, r, h0):
+        """
+        Calculate differential signal based on optimal control.
+
+        Parameters
+        ----------
+        x1 : float
+            State 1 of the observer.
+        x2 : float
+            State 2 of the observer.
+        r: float
+            Velocity factor used to control tracking speed.
+        h0 : float
+            Step size.
+
+        References
+        ----------
+        .. [1] J. Han, "From PID to active disturbance rejection control" IEEE Trans.
+        Ind. Electron., vol. 56, no. 3, pp. 900-906, Mar. (2009)..
+        """
+        d = r * h0
+        d0 = d * h0
+        y = x1 + h0 * x2  # Computing the differential signal
+        a0 = np.sqrt(d * d + 8 * r * np.abs(y))
+        if np.abs(y) > d0:
+            a = x2 + (a0 - d) / 2.0 * np.sign(y)
+        else:
+            a = x2 + y / h0
+        if np.abs(a) <= d:  # Computing the input u of observer
+            u = -r * a / d
+        else:
+            u = -r * np.sign(a)
+        return u, y  # Return input u of observer, and differential signal y
+
+    def _td(self, signal, r=100, k=3, h=1):
+        """
+        Compute a differential signal using the tracking differentiator.
+
+        with an adjustable filter factor.
+
+        Parameters
+        ----------
+        signal : 1D np.ndarray of shape = [n_timepoints]
+            Original time series
+        r : float
+            Velocity factor used to control tracking speed.
+        k: float
+            Filter factor.
+        h : float
+            Step size.
+
+        References
+        ----------
+        .. [1] J. Han, "From PID to active disturbance rejection control" IEEE Trans.
+        Ind. Electron., vol. 56, no. 3, pp. 900-906, Mar. (2009)..
+        """
+        x1 = signal[0]  # Initializing state 1
+        x2 = -(signal[1] - signal[0]) / h  # Initializing state 2
+        h0 = k * h
+        signalTD = np.zeros(len(signal))
+        dSignal = np.zeros(len(signal))
+        for i in range(len(signal)):
+            v = signal[i]
+            x1k = x1
+            x2k = x2
+            x1 = x1k + h * x2k  # Update state 1
+            u, y = self._fhan(
+                x1k - v, x2k, r, h0
+            )  # Update input u of observer and differential signal y
+            x2 = x2k + h * u  # Update state 2
+            dSignal[i] = y
+            signalTD[i] = x1
+        dSignal = -dSignal / h0  # Scale transform
+        return dSignal[1:]  # Return the differential signal
+
+    def _series_transform(self, seriesX, mode=1, k1=2, k2=2):
+        """
+        Transform each series of the time series set using a tracking differentiator.
+
+        with an adjustable filter factor.
+
+        Parameters
+        ----------
+        seriesX : 3D np.ndarray of shape = [n_cases, n_channels, n_timepoints]
+            The set of three dimensional time series set to be dilated.
+        mode : int, default=1
+            The flag bit of a first-order or second-order derivative is used.
+            Computing the first-order derivative when mode=1,
+            and computing the second-order derivative when mode=2
+        k1 : float, default=2
+            Filter factor 1 of the tracking differentiator 1.
+        k2 : float, default=2
+            Filter factor 2 of the tracking differentiator 2.
+            This parameter is invalid when mode=2.
+
+        References
+        ----------
+        .. [1] J. Han, "From PID to active disturbance rejection control" IEEE Trans.
+        Ind. Electron., vol. 56, no. 3, pp. 900-906, Mar. (2009)..
+        """
+        from sklearn.preprocessing import scale
+
+        n_cases, n_channels, n_timepoints = seriesX.shape[:]
+        if mode == 1:  # First-order derivative
+            seriesFX = np.zeros((n_cases, n_channels, n_timepoints - 1))
+            for i in range(n_cases):
+                for j in range(n_channels):
+                    seriesFX[i, j, :] = self._td(seriesX[i, j, :], k=k1)
+                    seriesFX[i, j, :] = scale(seriesFX[i, j, :])
+            return seriesFX  # Return the first-order differential time series set
+        if mode == 2:  # Second-order derivative
+            seriesSX = np.zeros((n_cases, n_channels, n_timepoints - 2))
+            for i in range(n_cases):
+                for j in range(n_channels):
+                    seriesF_ = self._td(seriesX[i, j, :], k=k1)
+                    seriesSX[i, j, :] = self._td(seriesF_, k=k2)
+                    seriesSX[i, j, :] = scale(seriesSX[i, j, :])
+            return seriesSX  # Return the second-order differential time series set
+
+    def _hard_voting(self, testYList):
+        """
+        Obtain the predicted labels by hard voting.
+
+        to process the labels matrix from multiple classifiers.
+
+        Parameters
+        ----------
+        testYList : 2D np.ndarray of shape = [n_classifierss, n_cases]
+        """
+        uniqueY = np.unique(testYList)  # Holds the label for each class
+        n_classes = len(uniqueY)  # Number of classes
+        n_classifiers, n_cases = testYList.shape[
+            :
+        ]  # Number of classifiers, Number of cases
+        testVY = np.zeros(
+            n_cases, int
+        )  # 1 * n_cases, Initializing the predicted labels
+        testWeightArray = np.zeros(
+            (n_classes, n_cases)
+        )  # n_classes * n_cases, Label weight matrix for samples
+        for i in range(n_cases):
+            for j in range(n_classifiers):
+                label_ = testYList[j, i]
+                index_ = np.arange(n_classes)[uniqueY == label_]
+                testWeightArray[
+                    index_, i
+                ] += 1  # The label weight for the sample is + 1
+        for i in range(n_cases):  # Predicting each sample label
+            testVY[i] = uniqueY[
+                np.argmax(testWeightArray[:, i])
+            ]  # The label is predicted to be the most weighted
+        return testVY  # return the predicted labels
+
+    def _fit(self, X, y):
+        """Fit a pipeline on cases (X, y).
+
+        Parameters
+        ----------
+        X : 3D np.ndarray of shape = [n_cases, n_channels, n_timepoints]
+            The training data.
+        y : array-like, shape = [n_cases]
+            The class labels.
+
+        Returns
+        -------
+        self :
+            Reference to self.
+        """
+        # Initialization of dilation rate parameters
+        n_timepoints = X.shape[2]
+        d_min = 0
+        d_max = int(np.log2(n_timepoints - 1) - 3)
+        d_max = np.min([5, d_max])
+        self.dList_ = 2 ** np.arange(d_min, d_max + 1)
+
+        # Differential transformations by tracking differentiator
+        X_F = self._series_transform(X, mode=1, k1=self.k1)
+        X_S = self._series_transform(X, mode=2, k1=self.k1, k2=self.k2)
+
+        # Feature extraction
+        self.tsFreshListR_ = []
+        self.tsFreshListF_ = []
+        self.tsFreshListS_ = []
+
+        # Train feature sets
+        RXList = []
+        FXList = []
+        SXList = []
+
+        # Use parallel processing for feature extraction
+        threads_to_use = check_n_jobs(self.n_jobs)
+
+        # Extract features for each dilation rate in parallel
+        results = Parallel(
+            n_jobs=threads_to_use, backend=self.parallel_backend, prefer="threads"
+        )(
+            delayed(self._extract_features_for_dilation)(X, X_F, X_S, d_rate, y)
+            for d_rate in self.dList_
+        )
+
+        # Unpack results
+        for tsFreshR, tsFreshF, tsFreshS, RX, FX, SX in results:
+            self.tsFreshListR_.append(tsFreshR)
+            self.tsFreshListF_.append(tsFreshF)
+            self.tsFreshListS_.append(tsFreshS)
+            RXList.append(RX)
+            FXList.append(FX)
+            SXList.append(SX)
+
+        # Concatenating all the dilated features
+        RX = np.hstack(RXList)
+        FX = np.hstack(FXList)
+        SX = np.hstack(SXList)
+
+        # Computing feature scores
+        self.scoreRFS_ = f_classif(np.hstack((RX, FX, SX)), y)[0]
+        self.scoreRFS_[np.isnan(self.scoreRFS_)] = 0
+
+        # Training the classifier on each view
+        self.clfList_ = []
+
+        # Train classifiers for each feature ratio in parallel
+        # Ensure feature_store_ratios is set
+        feature_store_ratios = (
+            self.feature_store_ratios
+            if self.feature_store_ratios is not None
+            else [0.1, 0.2, 0.3, 0.4, 0.5]
+        )
+
+        self.clfList_ = Parallel(
+            n_jobs=threads_to_use, backend=self.parallel_backend, prefer="threads"
+        )(
+            delayed(self._train_classifier_for_ratio)(RX, FX, SX, y, ratio)
+            for ratio in feature_store_ratios
+        )
+
+        return self
+
+    def _extract_features_for_dilation(self, X, X_F, X_S, d_rate, y):
+        """Extract features for a specific dilation rate.
+
+        Parameters
+        ----------
+        X : 3D np.ndarray
+            Original signal.
+        X_F : 3D np.ndarray
+            First-order differential signal.
+        X_S : 3D np.ndarray
+            Second-order differential signal.
+        d_rate : int
+            Dilation rate.
+        y : array-like
+            Class labels.
+
+        Returns
+        -------
+        tuple
+            Tuple containing feature extractors and extracted features.
+        """
+        # Dilation Mapping
+        RX_E = self._series_set_dilation(X, d_rate)
+        FX_E = self._series_set_dilation(X_F, d_rate)
+        SX_E = self._series_set_dilation(X_S, d_rate)
+
+        # Extracting the TSFresh features
+        tsFreshR = TSFresh(
+            default_fc_parameters=self.default_fc_parameters, n_jobs=self._n_jobs
+        )
+        tsFreshR.fit(RX_E, y)
+        RX = np.array(tsFreshR.transform(RX_E))
+
+        tsFreshF = TSFresh(
+            default_fc_parameters=self.default_fc_parameters, n_jobs=self._n_jobs
+        )
+        tsFreshF.fit(FX_E, y)
+        FX = np.array(tsFreshF.transform(FX_E))
+
+        tsFreshS = TSFresh(
+            default_fc_parameters=self.default_fc_parameters, n_jobs=self._n_jobs
+        )
+        tsFreshS.fit(SX_E, y)
+        SX = np.array(tsFreshS.transform(SX_E))
+
+        return tsFreshR, tsFreshF, tsFreshS, RX, FX, SX
+
+    def _train_classifier_for_ratio(self, RX, FX, SX, y, ratio):
+        """Train a classifier for a specific feature ratio.
+
+        Parameters
+        ----------
+        RX : 2D np.ndarray
+            Features from original signal.
+        FX : 2D np.ndarray
+            Features from first-order differential signal.
+        SX : 2D np.ndarray
+            Features from second-order differential signal.
+        y : array-like
+            Class labels.
+        ratio : float
+            Feature store ratio.
+
+        Returns
+        -------
+        Pipeline
+            Trained classifier pipeline.
+        """
+        clf = Pipeline(
+            [
+                ("scaler", StandardScaler()),
+                ("ridge", RidgeClassifierCV(alphas=np.logspace(-3, 3, 10))),
+            ]
+        )
+
+        bestIndex_ = np.argsort(self.scoreRFS_)[::-1][
+            0 : int(len(self.scoreRFS_) * ratio)
+        ]
+
+        clf.fit(np.hstack((RX, FX, SX))[:, bestIndex_], y)
+
+        return clf
+
+    def _predict(self, X):
+        """Predict class values of n instances in X.
+
+        Parameters
+        ----------
+        X : 3D np.ndarray of shape = [n_cases, n_channels, n_timepoints]
+            The data to make predictions for.
+
+        Returns
+        -------
+        y : array-like, shape = [n_cases]
+            Predicted class labels.
+        """
+        X_F = self._series_transform(X, mode=1, k1=self.k1)
+        X_S = self._series_transform(X, mode=2, k1=self.k1, k2=self.k2)
+
+        # Use parallel processing for feature extraction
+        threads_to_use = check_n_jobs(self.n_jobs)
+
+        # Extract features for each dilation rate in parallel
+        results = Parallel(
+            n_jobs=threads_to_use, backend=self.parallel_backend, prefer="threads"
+        )(
+            delayed(self._extract_test_features_for_dilation)(X, X_F, X_S, d_rate, i)
+            for i, d_rate in enumerate(self.dList_)
+        )
+
+        # Unpack results
+        RXList = []
+        FXList = []
+        SXList = []
+
+        for RX, FX, SX in results:
+            RXList.append(RX)
+            FXList.append(FX)
+            SXList.append(SX)
+
+        # Concatenating all the dilated features
+        RX = np.hstack(RXList)
+        FX = np.hstack(FXList)
+        SX = np.hstack(SXList)
+
+        # Ensure feature_store_ratios is set
+        feature_store_ratios = (
+            self.feature_store_ratios
+            if self.feature_store_ratios is not None
+            else [0.1, 0.2, 0.3, 0.4, 0.5]
+        )
+
+        # Predict in parallel for each classifier
+        PYList = Parallel(
+            n_jobs=threads_to_use, backend=self.parallel_backend, prefer="threads"
+        )(
+            delayed(self._predict_with_classifier)(RX, FX, SX, i, ratio)
+            for i, ratio in enumerate(feature_store_ratios)
+        )
+
+        # Convert to numpy array for voting
+        PYList = np.vstack(PYList)
+
+        # Final prediction by hard voting
+        PYV = self._hard_voting(PYList)
+
+        return PYV
+
+    def _extract_test_features_for_dilation(self, X, X_F, X_S, d_rate, i):
+        """Extract test features for a specific dilation rate.
+
+        Parameters
+        ----------
+        X : 3D np.ndarray
+            Original signal.
+        X_F : 3D np.ndarray
+            First-order differential signal.
+        X_S : 3D np.ndarray
+            Second-order differential signal.
+        d_rate : int
+            Dilation rate.
+        i : int
+            Index of dilation rate.
+
+        Returns
+        -------
+        tuple
+            Tuple containing extracted features.
+        """
+        # Dilation Mapping
+        RX_E = self._series_set_dilation(X, d_rate)
+        FX_E = self._series_set_dilation(X_F, d_rate)
+        SX_E = self._series_set_dilation(X_S, d_rate)
+
+        # Extracting the TSFresh features
+        tsFreshR = self.tsFreshListR_[i]
+        RX = np.array(tsFreshR.transform(RX_E))
+
+        tsFreshF = self.tsFreshListF_[i]
+        FX = np.array(tsFreshF.transform(FX_E))
+
+        tsFreshS = self.tsFreshListS_[i]
+        SX = np.array(tsFreshS.transform(SX_E))
+
+        return RX, FX, SX
+
+    def _predict_with_classifier(self, RX, FX, SX, i, ratio):
+        """Make predictions using a specific classifier.
+
+        Parameters
+        ----------
+        RX : 2D np.ndarray
+            Features from original signal.
+        FX : 2D np.ndarray
+            Features from first-order differential signal.
+        SX : 2D np.ndarray
+            Features from second-order differential signal.
+        i : int
+            Index of classifier.
+        ratio : float
+            Feature store ratio.
+
+        Returns
+        -------
+        ndarray
+            Predicted labels.
+        """
+        clf = self.clfList_[i]
+        bestIndex_ = np.argsort(self.scoreRFS_)[::-1][
+            0 : int(len(self.scoreRFS_) * ratio)
+        ]
+
+        return clf.predict(np.hstack((RX, FX, SX))[:, bestIndex_])
+
+    @classmethod
+    def _get_test_params(cls, parameter_set="default"):
+        """Return testing parameter settings for the estimator.
+
+        Parameters
+        ----------
+        parameter_set : str, default="default"
+            Name of the set of test parameters to return.
+
+        Returns
+        -------
+        params : dict
+            Parameters to create testing instances of the class.
+        """
+        return {
+            "k1": 2,
+            "k2": 2,
+            "feature_store_ratios": [0.1, 0.2, 0.3, 0.4, 0.5],
+            "default_fc_parameters": "minimal",
+        }
diff --git a/aeon/classification/feature_based/tests/test_tdmvdc.py b/aeon/classification/feature_based/tests/test_tdmvdc.py
new file mode 100644
index 0000000000..d0775229d9
--- /dev/null
+++ b/aeon/classification/feature_based/tests/test_tdmvdc.py
@@ -0,0 +1,66 @@
+"""Test TDMVDC Classifier."""
+
+import numpy as np
+import pytest
+from sklearn.metrics import accuracy_score
+
+from aeon.classification.feature_based import TDMVDCClassifier
+from aeon.datasets import (
+    load_arrow_head,
+    load_classification,
+    load_gunpoint,
+    load_italy_power_demand,
+)
+from aeon.utils.validation._dependencies import _check_soft_dependencies
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies("tsfresh", severity="none"),
+    reason="skip test if required soft dependency tsfresh not available",
+)
+def test_tdmvdc_classifier():
+    """Test the TDMVDCClassifier."""
+    cls = TDMVDCClassifier()
+    assert cls.k1 == 2 and cls.k2 == 2
+    assert cls.n_jobs == 1
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies("tsfresh", severity="none"),
+    reason="skip test if required soft dependency tsfresh not available",
+)
+@pytest.mark.parametrize(
+    "dataset_name,expected_accuracy",
+    [
+        ("ArrowHead", 0.8114),
+        ("Beef", 0.9667),
+        ("BeetleFly", 0.95),
+        ("GunPoint", 0.993),
+        ("ItalyPowerDemand", 0.965),
+    ],
+)
+def check_tdmvdc_results(dataset_name, expected_accuracy):
+    """Check the results of TDMVDCClassifier with expected accuracy."""
+    # Load the dataset
+    if dataset_name == "ArrowHead":
+        trainSignalX, trainY = load_arrow_head("TRAIN")
+        testSignalX, testY = load_arrow_head("TEST")
+    elif dataset_name == "GunPoint":
+        trainSignalX, trainY = load_gunpoint("TRAIN")
+        testSignalX, testY = load_gunpoint("TEST")
+    elif dataset_name == "ItalyPowerDemand":
+        trainSignalX, trainY = load_italy_power_demand("TRAIN")
+        testSignalX, testY = load_italy_power_demand("TEST")
+    else:
+        trainSignalX, trainY = load_classification(dataset_name, "TRAIN")
+        testSignalX, testY = load_classification(dataset_name, "TEST")
+    trainY, testY = trainY.astype(int), testY.astype(int)
+
+    cls = TDMVDCClassifier(n_jobs=2)
+    cls.fit(trainSignalX, trainY)
+    preds = cls.predict(testSignalX)
+    acc = accuracy_score(testY, preds)
+    assert np.isclose(
+        acc, expected_accuracy, atol=0.02
+    ), f"Accuracy {acc:.2f} not close to expected \
+    {expected_accuracy:.2f} for {dataset_name}"
diff --git a/examples/classification/feature_based.ipynb b/examples/classification/feature_based.ipynb
index 2424486b0c..3ce78e547b 100644
--- a/examples/classification/feature_based.ipynb
+++ b/examples/classification/feature_based.ipynb
@@ -23,27 +23,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 1,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(67, 1, 24) (67,) (50, 1, 24) (50,)\n",
+      "(20, 6, 100) (20,) (20, 6, 100) (20,)\n"
+     ]
+    },
     {
      "data": {
       "text/plain": [
        "[('Catch22Classifier',\n",
-       "  aeon.classification.feature_based._catch22_classifier.Catch22Classifier),\n",
+       "  aeon.classification.feature_based._catch22.Catch22Classifier),\n",
        " ('FreshPRINCEClassifier',\n",
        "  aeon.classification.feature_based._fresh_prince.FreshPRINCEClassifier),\n",
        " ('SignatureClassifier',\n",
        "  aeon.classification.feature_based._signature_classifier.SignatureClassifier),\n",
        " ('SummaryClassifier',\n",
-       "  aeon.classification.feature_based._summary_classifier.SummaryClassifier),\n",
+       "  aeon.classification.feature_based._summary.SummaryClassifier),\n",
+       " ('TDMVDCClassifier',\n",
+       "  aeon.classification.feature_based._tdmvdc.TDMVDCClassifier),\n",
        " ('TSFreshClassifier',\n",
-       "  aeon.classification.feature_based._tsfresh_classifier.TSFreshClassifier)]"
+       "  aeon.classification.feature_based._tsfresh.TSFreshClassifier)]"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 1,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -110,7 +120,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 2,
    "metadata": {
     "collapsed": false
    },
@@ -121,7 +131,7 @@
        "(67, 22)"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -141,7 +151,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 3,
    "metadata": {
     "collapsed": false
    },
@@ -152,7 +162,7 @@
        "0.84"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -164,6 +174,65 @@
     "metrics.accuracy_score(y_test, c22_preds)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Tracking Differentiator-based Multiview Dilated Characteristics (TDMVDC) Classifier\n",
+    "\n",
+    "Time Series Feature Extraction based on Scalable Hypothesis Tests classifier.\n",
+    "\n",
+    "This classifier simply transforms the input data using the TSFresh [1]_\n",
+    "transformer and builds a provided estimator using the transformed data.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Loading time series set\n",
+    "from aeon.datasets import load_arrow_head\n",
+    "\n",
+    "trainSignalX, trainY = load_arrow_head(\"TRAIN\")\n",
+    "testSignalX, testY = load_arrow_head(\"TEST\")\n",
+    "trainY, testY = trainY.astype(int), testY.astype(int)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from aeon.classification.feature_based import TDMVDCClassifier\n",
+    "\n",
+    "td_mvdc = TDMVDCClassifier(n_jobs=5)\n",
+    "td_mvdc.fit(trainSignalX, trainY)\n",
+    "testPY = td_mvdc.predict(testSignalX)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy : 0.8114285714285714\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "accV = np.sum(testPY == testY) / len(testY)\n",
+    "print(\"Accuracy :\", accV)"
+   ]
+  },
   {
    "attachments": {},
    "cell_type": "markdown",
@@ -182,7 +251,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {
     "collapsed": false
    },
@@ -193,7 +262,7 @@
        "0.84"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -247,7 +316,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 8,
    "metadata": {
     "collapsed": false
    },
@@ -259,8 +328,9 @@
       "('Catch22Classifier', <class 'aeon.classification.feature_based._catch22.Catch22Classifier'>)\n",
       "('FreshPRINCEClassifier', <class 'aeon.classification.feature_based._fresh_prince.FreshPRINCEClassifier'>)\n",
       "('SignatureClassifier', <class 'aeon.classification.feature_based._signature_classifier.SignatureClassifier'>)\n",
-      "('SummaryClassifier', <class 'aeon.classification.feature_based._summary_classifier.SummaryClassifier'>)\n",
-      "('TSFreshClassifier', <class 'aeon.classification.feature_based._tsfresh_classifier.TSFreshClassifier'>)\n"
+      "('SummaryClassifier', <class 'aeon.classification.feature_based._summary.SummaryClassifier'>)\n",
+      "('TDMVDCClassifier', <class 'aeon.classification.feature_based._tdmvdc.TDMVDCClassifier'>)\n",
+      "('TSFreshClassifier', <class 'aeon.classification.feature_based._tsfresh.TSFreshClassifier'>)\n"
      ]
     }
    ],
@@ -274,7 +344,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 11,
    "metadata": {
     "collapsed": false
    },
@@ -285,7 +355,7 @@
        "(112, 4)"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -296,6 +366,8 @@
     "\n",
     "names = [t[0].replace(\"Classifier\", \"\") for t in est]\n",
     "names.remove(\"Summary\")\n",
+    "if \"TDMVDC\" in names:\n",
+    "    names.remove(\"TDMVDC\")\n",
     "results, present_names = get_estimator_results_as_array(\n",
     "    names, univariate, include_missing=False\n",
     ")\n",
@@ -304,7 +376,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 12,
    "metadata": {
     "collapsed": false
    },
@@ -315,13 +387,13 @@
        "(<Figure size 600x230 with 1 Axes>, <Axes: >)"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsEAAAD6CAYAAABAk5ozAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA35klEQVR4nO3dd1gUV98+8HvpHRsgCIIdNWADDWKvaGwPVowdzWPBvI8+JtaIGlNeNVETS4xRommKUcQIiYpBxS4GYkPE3rDFDirt+/vDH/u67i6wVHXuz3XtlTjnzMw5O8vsvbNnz6hEREBEREREpCBGZd0AIiIiIqLSxhBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMhfL48WO4urpCpVIhPj6+rJtDJSQ6OhqtW7eGg4MDzM3NUb16dUycOBEPHjwo66ZRCdmwYQN69uwJV1dXWFtbo2HDhli9ejVEpKybRiXk7NmzGD16NBo2bAgTExO89dZbZd0kolJhUtYNoNfTxx9/jKysrLJuBpWwu3fvolmzZnj//fdRsWJFnDhxArNmzcKJEyewffv2sm4elYAvv/wSHh4e+OKLL+Dg4IAdO3Zg1KhRuHLlCkJDQ8u6eVQCTp48iaioKDRr1gw5OTnIyckp6yYRlQqV8OM9Gej06dPw8fHBF198gdGjR+PIkSPw8fEp62ZRKVm5ciXee+89XLt2DS4uLmXdHCpmd+7cQaVKlTSWvffee1i/fj3u3bsHIyN+gfimycnJUR/XYcOGIT4+HidOnCjjVhGVPJ7NyGDjx4/H6NGjUadOnbJuCpWBihUrAgAyMjLKuCVUEl4OwADQqFEjPHz4EGlpaWXQIipp/GBDSsXhEGSQX3/9FcePH8fGjRvx119/lXVzqJRkZ2cjMzMTp06dwpw5c9CjRw94eHiUdbOolOzduxdVqlSBra1tWTeFiKjY8OMfFVh6ejomTpyITz/9FHZ2dmXdHCpF7u7usLS0RJMmTeDs7Iyff/65rJtEpWTv3r1Yt24dJk2aVNZNISIqVgzBVGBz586Fk5MThg8fXtZNoVIWHR2N/fv3Y+XKlUhKSkL37t2RnZ1d1s2iEnb16lX0798fbdu2xfvvv1/WzSEiKlYcDkEFcunSJXzxxReIiIhQT4/1+PFj9X8fP34MGxubsmwilSBvb28AgJ+fH3x9fdGwYUNERESgT58+ZdwyKin3799Hly5dULFiRWzcuJHjRonojcMQTAVy4cIFZGRk4J133tEqa9u2LZo1a4aDBw+WQcuotHl7e8PU1BRnz54t66ZQCXny5Am6deuGBw8e4MCBA7C3ty/rJhERFTuGYCqQhg0bIjY2VmNZYmIiJkyYgG+++Qa+vr5l1DIqbYcOHUJmZiaqV69e1k2hEpCVlYV+/fohKSkJcXFxqFKlSlk3iYioRDAEU4GUK1cObdq00VnWpEkTNG7cuHQbRKUiMDAQPj4+8Pb2hqWlJf7++2/Mnz8f3t7e6NWrV1k3j0rA2LFjsXXrVnzxxRd4+PChxjc8jRo1grm5eRm2jkpCeno6oqOjATwf+vbw4UP8+uuvAKC+YyTRm4g3y6BC27VrF9q2bcubZbzBPv/8c6xfvx7nzp1DTk4OPDw8EBgYiEmTJnGGkDeUh4cHLl26pLPswoULnBrvDXTx4kVUq1ZNZ1lsbKzeCyBErzuGYCIiIiJSHP7cl4iIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmArFx8cHrq6unB9YQXjMlYXHW5l43ElJeMc4KpQbN27g2rVrZd0MKkU85srC461MPO6kJLwSTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExkAE4fpDw85srDY06kDJwijcgAnD5IeXjMlYfHnEgZeCWYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgURyUiUtaNoNePmZkZMjMzYWRkBGdn57JuTqlJTU1FTk7Oa9/vF//sVSpVgdYxtO+F2cerqDDH/E3oO1/rr3/fCyO376ampsjIyCjr5hCVKIZgKhRjY2Pk5OSUdTOIiKgEGBkZITs7u6ybQVSieLMMKhQLCws8ffoUxsbGcHR0LOvmlJpbt24hOzv7te+3iOD69etwcXEp8NUxQ/temH28igpzzN+EvvO1/vr3vTBy+25hYVHWTSEqcbwSTKRAmZmZMDMzQ0ZGBkxNTV/bfbyqlNz3Vw2PBRHpwx/GEREREZHiMAQTERERkeIwBBMRERGR4jAEExEREZHiMAQTERERkeIwBBMRERGR4jAEExEREZHiMAQTERERkeIwBBMRERGR4jAEExEREZHiMAQTERERkeIwBBMRERGR4jAEExEREZHiMAQTERERkeIwBBMRERGR4piUdQOIqHQ8ePAAx48fBwBkZWUBAPbt2wcTk5I5Dejbh5eXF+zt7Utkn0RERAWlEhEp60YQUcnbu3cvWrZsWdbNQFxcHFq0aFHWzShRmZmZMDMzQ0ZGBkxNTcu6OYrGY0FE+nA4BBEREREpDkMwERERESkOxwQTKYSXlxfi4uIAPB+v27ZtW8TGxpbomGBd+/Dy8iqR/RERERmCY4KJFKg0xkkqeSymkvv+quGxICJ9OByCiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYiIiIiBSHIZiIiIiIFIchmIiIiIgUhyGYimz58uXw9vaGnZ0d7Ozs4Ofnh99//z3PdTZs2ABPT09YWFjAy8sL0dHRGuU3b97EsGHD4OLiAisrKwQEBCAlJUWjzo0bNzB48GBUrlwZ1tbWaNy4MTZu3Kguv3jxIoKDg1GtWjVYWlqiRo0aCA0NRUZGRvF1noioiPbs2YPu3bvDxcUFKpUKmzdvznedZ8+eYfr06XB3d4e5uTk8PDywevVqjTr5nWdVKpXOx/z589V1PvnkEzRv3hxWVlYoV65ccXSX6JXBEExF5urqis8//xxHjx5FfHw82rVrh549e+LkyZM66+/fvx9BQUEIDg5GQkICevXqhV69euHEiRMAABFBr169cP78eURGRiIhIQHu7u7o0KED0tLS1NsZMmQIkpOTsWXLFhw/fhyBgYHo168fEhISAACnT59GTk4OVqxYgZMnT2LhwoX45ptvMG3atJJ/UoiICigtLQ0NGjTA0qVLC7xOv379sHPnTqxatQrJycn45ZdfUKdOHXV5fudZAEhNTdV4rF69GiqVCr1791bXycjIQN++fTFmzJji6SzRq0SISkD58uXlu+++01nWr18/eeeddzSWNWvWTP7973+LiEhycrIAkBMnTqjLs7OzxcHBQVauXKleZm1tLWvXrtXYToUKFTTqvGzevHlSrVo1g/vzpsnIyBAAkpGR8Vrv41Wl5L6/al63YwFAIiIi8qzz+++/i729vfzzzz966+R3ntWlZ8+e0q5dO51lYWFhYm9vn2e7iF43ZXYleMeOHRg+fDhq164NOzs7mJubw9nZGR07dsTChQtx+/btsmpanjw8PKBSqXDx4kWD1ktISMBnn32G9u3bw8nJCaampihfvjxatmyJpUuXIjMzU+d6ycnJWLRoEbp27YoqVarAzMwMdnZ28PX1xWeffYbHjx8XQ6+KT3Z2NtatW4e0tDT4+fnprHPgwAF06NBBY1nnzp1x4MABAM+/5gMACwsLdbmRkRHMzc2xd+9e9bLmzZtj/fr1uHv3LnJycrBu3To8ffoUbdq00du+Bw8eoEKFCoXtHhFRmduyZQt8fHwwb948VKlSBbVr18akSZPw5MkTdZ38zrMvu3nzJqKiohAcHFyibS+q3PfgvB6LFi0q62aqFTYzDBs2TKtfJiYmcHBwQMeOHbF27VqIiMY6u3bt0vl82NjYoH79+nj//ffzbEduW7///nuN5d9//716W97e3sjJydG5/t69e6FSqeDh4ZFn3wzNfy/uP69HfvvVxcTgNYrozp07CAoKQkxMDIDnT3rbtm1hbW2NGzduYP/+/YiJicHMmTMRExODZs2aFXpfbdq0we7duxEbG5tnMCppWVlZaNy4MQDAxsYGvr6+cHJywtWrV3HgwAHs3bsXa9euxbZt27TGXLVv3x7Xrl2DhYUFfHx80KpVK9y8eRMHDhxAfHw8Vq1ahT///BNVq1Ytg579n+PHj8PPzw9Pnz6FjY0NIiIiUK9ePZ11b9y4AScnJ41lTk5OuHHjBgDA09MTVatWxdSpU7FixQpYW1tj4cKFuHr1KlJTU9XrhIeHo3///qhYsSJMTExgZWWFiIgI1KxZU+d+z549i6+//hoLFiwopl4TEZW+8+fPY+/evbCwsEBERATu3LmDsWPH4p9//kFYWBiA/M+zL1uzZg1sbW0RGBhY4u0vDv7+/nrP9free15HNWrUQIsWLQAAT58+xYkTJxATE4OYmBhERkYiPDwcxsbGWusNHToUwPPhhVevXsXBgwfx9ddfIywsDNu3b9d7kSo/x48fx48//oghQ4YYvG5R85+1tTX69Omjd/uVKlUyuE2lOhzi/v37UqdOHQEgnp6esmfPHq06T58+lRUrVkjlypXz/UooP61btxYAEhsbW6TtvMjd3V0AyIULFwq8TmZmpjRp0kTCw8Pl6dOnGmXHjh0TZ2dnASDDhw/XWrddu3ayatUqefTokcbyCxcuSP369QWAtG3btlB9KU7Pnj2TlJQUiY+PlylTpkilSpXk5MmTOuuamprKzz//rLFs6dKl4ujoqP53fHy8NGjQQACIsbGxdO7cWbp06SIBAQHqOiEhIdK0aVOJiYmRxMREmTVrltjb28uxY8e09nn16lWpUaOGBAcHF1OPX28cDlGylNz3V83rdixQgOEQHTt2FAsLC7l//7562caNG0WlUkl6erqIFOw8+6I6depISEiI3n2+KsMhct+Dw8LCyropBVKYzCAiMnToUAEgQ4cO1SpbtmyZABAAsmrVKvXy2NhY9fKXXb58WWrVqiUApF69enm29eXnNiwsTACIlZWVABB3d3etLCMiEhcXpy5/WVHyX+7+dW23qEp1OMT48eORnJwMDw8P7Nu3Dy1bttSqY25ujvfeew+JiYmoW7duaTavxJiYmCA+Ph59+/aFubm5RpmXlxfmzZsHAFi3bp3WsIidO3dixIgRsLGx0Vju4eGBb775BgAQGxuLq1evlmAP8mdmZoaaNWuiSZMm+Oyzz9CgQQMsXrxYZ93KlSvj5s2bGstu3ryJypUrq//dpEkTJCYm4v79+0hNTcUff/yBf/75B9WrVwcAnDt3DkuWLMHq1avRvn17NGjQAKGhofDx8dH6ccn169fRtm1bNG/eHN9++20x95yIqHQ5OzujSpUqsLe3Vy+rW7eu+qofULDzbK64uDgkJydj5MiRJdtwKhZjxoxB69atATz/RrQg3NzcMGvWLADAqVOncP78eYP36+fnh6ZNm+LSpUtYtmyZQeu+qvmv1ELw+fPn8fPPPwMAvvzyy3zHZTo5Oal/6fro0SOsXLkSgYGBqFWrFqytrWFtbQ0vLy9Mnz4d9+/f11g3d1zM7t27AQBt27bVGDfy8niXe/fuYc6cOfDx8YG9vT0sLS1RvXp19OvXL8+pvmJjY9GpUyeUL18elpaWaNy4MdauXWvgMwM0atQIAPDkyRPcuXPH4PUA4MqVKwbvtyTl5OSox/a+zM/PDzt37tRYtmPHDp1fz9jb28PBwQEpKSmIj49Hz549AQDp6ekAno8VfpGxsbHGeKVr166hTZs2aNKkCcLCwrTqExG9bvz9/XH9+nWN34ScOXMGRkZGcHV1BWDYeXbVqlVo0qQJGjRoULINL0UvjsWNjIxEu3btUKFCBahUKuzatUtd7969ewgNDUXDhg1ha2sLKysreHl5Ye7cuer3mRfl5OTg22+/hb+/P8qVKwdTU1M4OjqiQYMGGD9+fJ5jbosrMwDPLxQBMGissbe3t/r/X/6AVFD/+7//C+D51HkPHz4s0DpFyX8lrtivLeuxePFiASDlypWTrKwsg9bNvcTu4OAgLVq0kP79+0unTp2kYsWKAkBq1qwpd+7cUddPSkqSoUOHipOTkwCQzp07y9ChQ9WPuLg4dd3ExESpUqWKABB7e3vp2rWr9O/fX/z8/MTS0lJat26t0Zbcrws++ugjUalU0qRJExkwYIC8/fbb6q8hFi5caFD/IiIiBICYmZnp/IpBn4SEBPU+Df2qpThNmTJFdu/eLRcuXJBjx47JlClTRKVSyfbt20VEZPDgwTJlyhR1/X379omJiYksWLBAkpKSJDQ0VExNTeX48ePqOuHh4RIbGyvnzp2TzZs3i7u7uwQGBqrLMzIypGbNmtKyZUs5dOiQnD17VhYsWCAqlUqioqJE5PkQiJo1a0r79u3l6tWrkpqaqn4oHYdDlCwl9/1V8zoci0ePHklCQoL6nP7ll19KQkKCXLp0SUSen2MHDx6sUd/V1VX69OkjJ0+elN27d0utWrVk5MiR6joFOc+KiDx48ECsrKxk+fLlOtt26dIlSUhIkNmzZ4uNjY26nS8P0SstBR0OkVsvJCREAIiPj48EBQVJ69at1V/Fnzx5Utzc3ASAODs7S0BAgHTv3l2dHRo2bKgx5EREZPjw4QJALCwspEOHDhIUFCSdO3dWDzV4eShLYTNDXsMhRERGjhwpAMTb21u9LK/hECLPXxO55efOndP7nOkbDtG+fXsREenSpYsAkGnTpmnU0zccoij578X9l8RwiFILwYMHDxYAeqdfycuVK1ckJiZGsrOzNZanpaXJkCFDBICMHTtWa738xgQ/fvxY/QcwZMgQrT/q+/fvy44dOzSW5b5ITE1N5bffftMoyz1Q9vb26nFZ+cnJyRE/Pz8BoBHyCqJ///4CQBo3bmzQesVtxIgR4u7uLmZmZuLg4CDt27dXB2CR58fh5T/k8PBwqV27tpiZmUn9+vXVwTXX4sWLxdXVVUxNTaVq1aoyY8YMefbsmUadM2fOSGBgoDg6OoqVlZV4e3trTJmWezx0PZSOIbhkKbnvr5rX4Vi8GF5efOSeN4cOHap1QSYpKUk6dOgglpaW4urqKhMnTtR638nvPCsismLFCrG0tNQKe7lyw9jLj+L8rY0hDA3BxsbGEhkZqVWenp4uNWrUEABa7y9paWkSFBSk9VudS5cuCQBxdXXVeTHl1KlT6g8uL7fD0MyQVwhOS0uTqlWrqrNLrvxC8LRp0wSAeHl5SU5OjlZ5QUNwYmKiGBkZiZWVlVy/fl1dT18ILkr+e3H/r3UIDggIEAAyYMCAYt1uWlqamJiYiIODg1ZZfiF40aJF6k97Bf10kvsimThxos5yT09PAaBz0LcuoaGhAkBsbGzkzJkzBVpH5P9eFMbGxhpXtokKgiG4ZCm5768aHos3S+57sL5H7oeF3HojRozQuZ3ly5cLAOnWrZvO8kePHomjo6OYmJjI3bt3RUTk8OHDAkB69OhhcHsNzQy6QvCTJ08kPj5eOnTooH7/P3z4sLpcVwjOycmRy5cvy/z588XMzEzKly+vsY6utuYXgkVEBg0aJAA05p3WF4KLmv/yuqD14uN//ud/DN52qU+RVhT79+9HXFwcLl++jPT0dPUceWZmZrh9+zbu3buH8uXLF3h7f/zxBwAgODhY5xQjeenevbvO5XXr1sXp06dx7dq1fLexdu1azJkzB0ZGRli9ejVq1apVoH3v3LkT//73vwEA8+bNU0+fQkREpAT6pkjz9PTU+Le+KbWioqIAAP3799dZbmNjAx8fH0RHR+PIkSPo1KkTPD09YWtri+joaHzyyScYOHAgqlWrVqD2FjYzrFmzBmvWrNFabmtrixUrVsDX11fneiqVSmtZjRo1sGvXLvW48aL4+OOPER4ejlWrVmHixImoXbt2kbeZn/ymSGvatKnB2yy1EOzg4AAAuHXrlsHr3rp1C71799a4UYIuDx8+NCgEX7p0CYD2H01B6JuX187ODsDz+fzysmHDBowYMQIAsHLlSvTt27dA+927dy969uyJjIwMhIaGYuLEiQa0WjcRQVZWVpG3Q68PfTdnIXpT8TX/6jExMdEZ1gpi5MiRGDZsWL719N1AIXd2hMGDB2Pw4MF5biP35g22trYICwvD8OHDMWPGDMyYMQPOzs54++23ERAQgIEDB2rN5JSrsJnhxXmCjY2NUa5cOTRo0AA9evTQuq/Ai3LnCc7MzMS5c+dw6NAhnDt3DgMHDkRMTAzMzMzy7HN+PDw8MHbsWCxatAjTpk3Dr7/+qrduUfLfiypVqqQ1sUFRlVoIbtKkCX744Qf89ddfyM7ONujK68iRI7F37174+flh9uzZaNCgAcqXLw9TU1MAgIuLC1JTU7XunlKSijLLwKZNmzBw4EDk5ORgxYoV6jCcn/3796Nr165IS0vD9OnT1dOdFFVWVlaR/yDo9WNnZ8fZMuiNZ2RkBDs7O1hbW5d1U+glGRkZ6vfxkmJpaalzee4sQgEBAVo3FXmZu7u7+v979+6NDh06YMuWLYiLi8O+ffsQERGBiIgIzJw5Ezt27ICXl5fWNgp7rm3RokWhgt/L6+zbtw9dunRBXFwcZsyYoZ6atSimT5+O1atXY+PGjTh8+LDeekXJfyWt1EJwt27dMHHiRNy/fx9btmzBv/71rwKtl5aWhujoaBgZGSE6Olrrk09aWpreO+Dkp2rVqkhKSsLp06e1bi9ZUjZv3owBAwYgOzsby5cvx6hRowq03sGDBxEQEIBHjx5h2rRpmDt3brG1ycTEBBkZGcW2PXo9GBkZvVInI6KSYGxsrL61Or1aTEzKbkSmm5sbTp8+jeDg4Dy/YtfF3t5e4wrylStXMH78eERGRiIkJEQ9PeurxN/fHwsXLsTIkSOxePFijB49Wj3vfmFVqlQJH3zwAT766CNMmTIFc+bM0VmvsPmvNJTaK7BGjRoICgrCTz/9hP/+979o3bp1nnPF3bp1C/fu3YOtrS2ys7NRrlw5nZf+f/zxR71XgHOvbur7qj8gIADbtm3D6tWrMWbMmBIPBL/99hv69euHrKwsLF++XD2uNz+HDx9G586d1QH4k08+KdZ2qVSqEv80TkRUVoyNjfmBjzR06dIFO3bsQHh4uMEh+GVubm6YPXs2IiMjkZiYWDwNLAEjRozAkiVLkJiYiNmzZ+sca2yoCRMmYOnSpYiNjdV7X4XC5r/SmCu4VL8L/frrr1GzZk1cuHABLVq00DnGNyMjA6tXr0ajRo2QlJQEJycnlC9fHvfv38cPP/ygUffgwYOYOnWq3v3lDv4+efKkzvKRI0fC1dUVCQkJGDVqFNLS0jTKHz58qL7HdVFFR0ejT58+yMrKwjfffFPgABwfH49OnTrh4cOHJRKAiYiIlOa9996Du7s7NmzYgMmTJ+PRo0dadW7cuIGVK1eq/52QkID169fjyZMnWnV/++03AJpDJ141KpUKn376KQDgp59+wpkzZ4q8TWtra8ycORMAsGjRIr31CpP/SkOpfhdRvnx57Nu3D/3798euXbvQsmVLVKtWDd7e3rCyssLNmzdx+PBhPH78GHZ2dnBxcYGxsTFmzpyJCRMmYMiQIVi6dCmqV6+Oy5cvY//+/Rg0aBD27Nmj/pHbi3r37o2wsDB8+OGHiImJgaOjI1QqFUaMGIHmzZvDxsYGW7ZsQdeuXREWFoaIiAj4+/vDxsYGV65cQUJCApo2bVrkoRK3bt1CYGAgMjIy4Orqiv3792P//v066y5YsACVKlVS/7tTp0548OABypUrh2vXrun9IcCUKVMK9QM/IiIipbG2tkZUVBS6deuGefPm4dtvv4W3tzdcXV2Rnp6OM2fOICkpCY6Ojuphi5cuXcKAAQPUd3tzc3NDVlYWjh8/juTkZJiZmRXLWNuS1KVLF7Rq1Qp79uzB7Nmz8dNPPxV5m6NGjcLChQuRkpKit05h8t/L7ty5k++PIZctWwYrK6uCN75Qk7YVg99//12GDBkiNWvWFBsbGzE1NZXKlStLx44dZdGiRfLPP/9o1N+8ebM0b95cypUrJzY2NuLj4yPLli2TnJwc9dx2uu6atnLlSmncuLFYWVmp55J7eQ6827dvy4wZM8TLy0usra3F0tJSqlevLv3795c//vhDo25e+xL5v7n9XtzHhQsXCjTHna7tFnS9spq4nEgfJc/PquS+E5UkQ2+Wkd/dVB8+fCjz5s0TPz8/KVeunJiamoqzs7P4+vrKBx98IPv371fXTU1Nlc8//1y6du0q1apVEysrK7Gzs5N69erJuHHj5PTp0wa3Q1dmeHG5vjvG6ZLfzTJy7d+/XwCIkZGRnDp1SqutBZkn+GXh4eHqfed3UwtD819B5wkGIPfu3ctz3y9TiZTilApEpBiZmZkwMzMrlV+Av2qU3HciotcF50ciIiIiIsVhCCYiIiIixWEIJiIiIiLFYQgmIiIiIsVhCKYi++yzz+Dr6wtbW1s4OjqiV69eSE5Ozne9RYsWoU6dOrC0tISbmxsmTJigcf/0R48e4T//+Q/c3d1haWmJ5s2b48iRIxrbUKlUOh/z589X1+nRoweqVq0KCwsLODs7Y/Dgwbh+/XrxPQFERIVUmPPnpk2b4OPjg3LlysHa2hoNGzbUmkf/5s2bGDZsGFxcXGBlZYWAgACNKawuXryo9/y5YcMGAMA///yDgIAAuLi4wNzcHG5ubggJCcHDhw+L/4kgKgMMwVRku3fvxrhx43Dw4EHs2LEDmZmZ6NSpk9bNR170888/Y8qUKQgNDUVSUhJWrVqF9evXY9q0aeo6I0eOxI4dO/DDDz/g+PHj6NSpEzp06IBr166p66Smpmo8Vq9eDZVKhd69e6vrtG3bFuHh4UhOTsbGjRtx7ty5It8hiIioOBTm/FmhQgVMnz4dBw4cwLFjxzB8+HAMHz4c27ZtAwCICHr16oXz588jMjISCQkJcHd3R4cOHdTbdXNz0zp/zp49GzY2NujSpQuA57dW79mzJ7Zs2YIzZ87g+++/R0xMDEaPHl3yTwxRaTBoQjWiArh165YAkN27d+utM27cOGnXrp3GsokTJ4q/v7+IiKSnp4uxsbFs3bpVo07jxo1l+vTperfbs2dPre2+LDIyUlQqFedwLWFKnitXyX2noinI+VOXRo0ayYwZM0REJDk5WQDIiRMn1OXZ2dni4OAgK1eu1LuNhg0byogRI/Lcz+LFi8XV1dWgthG9qgp9JTglJQUhISGoV68erK2tYWFhAVdXV/j6+iIkJAQbN27UqN+mTRuoVCrs2rWrCJGdXgcPHjwAgDzvDd68eXMcPXoUhw8fBgCcP38e0dHR6Nq1KwAgKysL2dnZsLCw0FjP0tJS5+0Wgedf/0VFRSE4OFjvfu/evYuffvoJzZs35/ytRPTKKcj580Uigp07dyI5ORmtWrUCADx79gwANM6fRkZGMDc313v+PHr0KBITE/M8f16/fh2bNm1C69atC9S24qRv6EZejzZt2mhsIzY2FgMGDIC7uzssLCxga2uLatWqoW3btpg+fToOHjxYqP1u3ry5dJ6EAsptF+WvULdN3rRpEwYOHIhnz56hYsWK8Pf3h4ODA+7du4fExEQsXboU69at0/hK+nU3bNgwrFmzBmFhYfnetk/JcnJy8J///Af+/v5466239NYbOHAg7ty5gxYtWkBEkJWVhdGjR6uHQ9ja2sLPzw8ff/wx6tatCycnJ/zyyy84cOAAatasqXOba9asga2tLQIDA7XKJk+ejCVLliA9PR1vv/02tm7dWjwdJiIqJgU9fwLPw3KVKlXw7NkzGBsbY9myZejYsSMAwNPTE1WrVsXUqVOxYsUKWFtbY+HChbh69SpSU1N1bm/VqlWoW7cumjdvrlUWFBSEyMhIPHnyBN27d8d3331X9M4aaOjQoVrLbty4oR4Coqvc09NT/f8ffvih+rci1atXR8eOHWFra4vU1FT89ddf2LVrF5KTk/Hrr7/q3H/nzp1RuXJlnWVVq1Y1uD/0ijD00vGNGzfExsZGAMh///tfefLkiVad+Ph4mTJlisayS5cuSVJSkqSlpRX2qnWZ0ndrQ9I0evRocXd3lytXruRZLzY2VpycnGTlypVy7Ngx2bRpk7i5ucmcOXPUdc6ePSutWrUSAGJsbCy+vr7y7rvviqenp85t1qlTR0JCQnSW3b59W5KTk2X79u3i7+8vXbt2lZycnMJ3lPKl5CEBSu47FV5Bz58iz4c3pKSkSEJCgixYsEDs7e0lNjZWXR4fHy8NGjRQnz87d+4sXbp0kYCAAK1tpaeni729vSxYsEDnvlJTUyUpKUkiIyOlXr16MmbMmEL3sTgV9DbBW7duFQBiYmIiv/zyi1Z5RkaGREVFyZIlS7TKcrf/4nP7qivIc0LPGfwsfffddwJAXFxcSqI9ryyG4PyNGzdOXF1d5fz58/nWbdGihUyaNElj2Q8//CCWlpaSnZ2tsfzx48dy/fp1ERHp16+fdO3aVWt7e/bsEQCSmJiY776vXLkiADTuCU/FT8lBUMl9p8Ix5PypS3BwsHTq1Elr+f379+XWrVsiItK0aVMZO3asVp21a9eKqampul5e4uLiBID6nFyWChqCBw0aJAAkKCjI4H0wBL/ZDB4TfPPmTQCAg4ODQevlNSY4LS0NH330EWrVqgVzc3O4uLhgxIgRuHbtGmbNmgWVSoVZs2ZprPPi8tu3b2PcuHFwc3ODmZkZ3NzcMH78eNy/f19rX5mZmfjxxx/x7rvvwtPTE3Z2drC0tESdOnXw/vvva02dlTuNzJo1awAAw4cP1xgLlNuu3HoeHh56nwMPDw+oVCpcvHhR7/LIyEi0a9cOFSpU0Hq+7t27h9DQUDRs2BC2trawsrKCl5cX5s6di/T0dL37LWkigpCQEERERODPP/9EtWrV8l0nPT0dRkaaLz9jY2P19l5kbW0NZ2dn3Lt3D9u2bUPPnj21trdq1So0adIEDRo0yHffOTk5AP5v3BwRUVkpzPlTl5ycHJ3nNHt7ezg4OCAlJQXx8fF6z589evQo0Pv663j+zM0tjo6OJbqfF8fihoWFwc/PD/b29lrv+9evX8fEiRNRt25dWFlZwdbWFr6+vliyZAmysrK0tvvs2TPMnz8fTZo0ga2tLczMzFC5cmX4+vriww8/xN27d/W2aePGjWjRogXs7OxgbW0Nf39/REdHF3vfX1uGpuYffvhB/fVKTExMgddr3bq1zk9Tjx8/Fl9fXwEgNjY20q1bN+nbt684OzuLo6OjDBs2TABIaGioxnqhoaECQEaMGCGurq7i5OQkgYGB0rVrV7G3txcA4uvrq3UlJvcqoL29vbz99tvSt29f6dq1q7i4uAgAcXBwkJSUFHX927dvy9ChQ6VGjRoCQPz9/WXo0KHqR0REhIiIXLhwQQCIu7u73ufA3d1dAMiFCxd0Lg8JCREA4uPjI0FBQdK6dWvZs2ePiIicPHlS3NzcBIA4OztLQECAdO/eXZycnASANGzYUO7fv1/g41GcxowZI/b29rJr1y5JTU1VP9LT09V1Bg8erDFEJjQ0VGxtbeWXX36R8+fPy/bt26VGjRrSr18/dZ0//vhDfv/9d3V5gwYNpFmzZlrH9MGDB2JlZSXLly/XatvBgwfl66+/loSEBLl48aLs3LlTmjdvLjVq1JCnT5+WwLNBuZR8NVTJfSfDFOb8+emnn8r27dvl3LlzcurUKVmwYIGYmJhozPwQHh4usbGxcu7cOdm8ebO4u7tLYGCg1v5TUlJEpVLJ77//rlUWFRUlq1evluPHj8uFCxdk69atUrduXfUsPmWtoFeCg4ODBYBUqVJFrl69atA+YMCV4Ny6ISEhYmRkJC1atJCgoCBp1qyZXLx4UUREdu/eLeXLlxcA4uHhIT169JDOnTurl3Xq1EnjvJGdnS3t27cXAGJnZyddunSRoKAg6dChgzo7JCQk6GzHzJkzRaVSib+/v/Tv3189PEalUsmmTZsMeh7eVAaH4EePHkmVKlXUT2SbNm3k448/lqioqDy/StEXgidMmCAApF69ehpfrzx58kT69OmjPpj6QjAAGTZsmEaguXz5srqNP//8s8Z6Dx8+lMjISHn27JnG8oyMDJk6daoA0Pl1e37DIYojBBsbG0tkZKTWeunp6eoQPmPGDI22p6WlSVBQkACQ4cOH6913Sco9Di8/XnyuWrduLUOHDlX/OzMzU2bNmiU1atQQCwsLcXNzk7Fjx8q9e/fUddavXy/Vq1cXMzMzqVy5sowbN05n0F+xYoVYWlrqLDt27Ji0bdtWKlSoIObm5uLh4SGjR482+ERIhlNyEFRy38kwhTl/Tp8+XWrWrCkWFhZSvnx58fPzk3Xr1mlsN3cqM1NTU6latarWe0euqVOnipubm9YwNBGRP//8U/z8/MTe3l4sLCykVq1aMnnyZI3zdFkqaAg+fPiwmJiYCACxtLSUPn36yKJFi2TPnj35/k6pMCHYzs5ODhw4oFWempoqFStWFJVKJcuWLdN4zu/cuSPt2rUTADJ79mz18t27dwsAadSokTx8+FBrm0eOHJE7d+7obEe5cuXk4MGDGmW52al27dr59kcJCjVo5PTp09KsWTOdf7gNGzaU5cuXS1ZWlsY6ukJwenq6+kd227Zt09rPrVu3xMrKKs8Q7OrqqvNF/Pnnn6uvFBvCxcVFjIyMtF5spRGC9bV1+fLlAkC6deums/zRo0fi6OgoJiYmcvfuXb37JypNSg6CSu47UWkpaAgWEfntt9/E1dVVK7OYmppKx44dZfv27TrX0/chJffx4oeT3GUv/sD7RZMnT1ZfKdbl6tWrYmpqKg4ODuofboeHhwsAef/99/Pt48vt+Oqrr7TKnj59qv62/PLlywXe5puqUFOk1alTBwcPHsThw4cRFRWFQ4cO4a+//sLt27eRmJiIMWPGYOPGjYiKioKZmZne7Rw9ehSPHz9GpUqV0KlTJ61yBwcHdOzYEZGRkXq30b59e1hZWWktr1u3LgBo3F3sRX///Td27tyJCxcuIC0tTT3OKSsrCzk5OTh79iwaNWqU5/NQ3PTdxSwqKgoA0L9/f53lNjY28PHxQXR0NI4cOaLzuSQiIlKqbt26oXPnzti2bRtiYmJw5MgRJCYmIj09HTt27MCOHTswc+ZMzJ49W+f6+qZIa9Gihdaywr6XV6lSBbVq1cKpU6eQkpKC2rVro3HjxjA2Nsbq1atRu3ZtBAYGwtnZuUB97t69u9Yyc3NzVK9eHQkJCbh27Rrc3NwKtK03VaFCcK6mTZuiadOmAJ4P7k9ISMD8+fOxbt06xMTEYPHixfjggw/0rn/16lUAyPfHZHnRNz+fnZ0dAODp06cay9PS0jB48GBERETkud2yuDe6vr6eP38eADB48GAMHjw4z23cvn3b4P3K/5+nl6g4ZWZmlnUTyhyfAyL9TExMSvWmDqampujWrRu6desG4PkPznbt2oUZM2YgPj4ec+bMwTvvvKPONS+aMmWK1s039Mnvvbxly5b5buP27duoXbs2atSogYULF+KDDz5ASEgIQkJC4O7uDj8/P3Tr1g19+/bVe7HR0HykREUKwS9SqVRo3LgxfvnlF6Snp2PLli3YvHlzniH4xXULUwZAa4aB/EydOhURERHw9PTE559/Dl9fX1SqVEn9ImrevDkOHDigNUNBcci92qyPpaVlnusFBATAyckpz224u7sb3K6srKw8r9gTFZadnZ3Bf6NvAiMjI/WvsYlIt4yMjDK9c6e5uTk6d+4Mf39/eHp64tq1a4iMjNQZgg2R33t5nz598j03VKxYUf3/48ePR79+/bBlyxbs3bsXe/fuxbp167Bu3TqEhoYiLi5O59VhJZ57DVVsIfhFnTp1wpYtW3Dnzp0861WpUgUAtKYMe1FeZYURHh4OAFi/fj28vb21ylNSUgq13dwQ+ejRI53lmZmZeu/Ukx83NzecPn0awcHBer9mKQoTExNkZGQU+3aJjIyM1FPfKYmxsTHu3r2b7wdfIiUzMSmRCGIwGxsb+Pn54ddff803txSFm5sbUlJSMHnyZPj4+Bi0rpOTE0aNGoVRo0YBAE6fPo0RI0bgwIEDmDJlinoaVzKMwa9AEcn36uzly5cBAK6urnnWa9KkCaysrHD79m3ExMSgQ4cOGuV37tzBjh07DG1innLn09N1xXTbtm16/wByQ66+YQMODg4wMzPD3bt3cevWLa35CLdt21boIQddunTBjh07EB4eXiIhWKVSlemncaI3kbGxsSI/ABC9aooztxRFly5dkJKSgvDwcIND8Ms8PT0xefJk9OrVC4mJicXTQAUy+Fr5smXLMHToUOzfv1+rTESwadMmLFmyBAAwYMCAPLdlZWWFkSNHAgAmTJigntAaeD5WJyQkBGlpaYY2MU+5P5j7+uuvNZYnJydj9OjRetfL/cM4efKkznJTU1O0atUKADBjxgyNK0B///03QkJCCt3m9957D+7u7tiwYQMmT56s82rzjRs3sHLlykLvg4iI6E0UHByMGTNm4OzZs1plT548waxZs3D48GGYmJiUyIWmXB988AHKlSuHL7/8El988YXOb2AvXLiAH3/8Uf3vP//8E9HR0Vq/LxARbN26FUDhhkHScwZfCc7MzMTatWuxdu1aODg4oFGjRqhUqRLu37+PU6dOqYcvDBo0CMHBwflu75NPPsG+fftw9OhR1KxZE+3atYOFhQX27t2LjIwMDB06FGvWrCm2MauhoaHo06cPPvroI4SHh6N+/fq4desW4uLi0LJlS7i4uOgM+L169cLs2bPx1Vdf4cSJE3Bzc4ORkRF69OiBHj16AADmzp2LPXv2YOXKldi9eze8vb1x7do1xMfHY+DAgdi1axcuXbpkcJutra0RFRWFbt26Yd68efj222/h7e0NV1dXpKen48yZM0hKSoKjo6P6qxIiIiJ6/g1wWFgYPvnkE1SvXh3169eHra0tbt26haNHj+LevXswNjbGV199pb5QVhJcXV0RGRmJ3r17Y9KkSZg3bx7eeustODs748GDB0hKSsK5c+fQrFkzDBo0CABw7NgxTJgwAXZ2dmjcuDFcXFzw5MkT/PXXX7h06RLs7e0xZ86cEmvzm87gEBwcHIxq1aph586dOHToEE6dOoWbN2/CxMQELi4uCAoKwpAhQxAQEFCg7dnY2GDXrl347LPPsG7dOvzxxx+oUKECOnbsiLlz56qnK6lUqZKhTdUpMDAQu3fvxuzZs/H333/j3LlzqF69OmbNmoVJkybpnV7M29sbGzduxIIFC3Do0CHs3LkTIgJXV1d1CG7WrBl2796N0NBQHDx4EFeuXEHt2rWxePFijB49utC3wwSA+vXr49ixY/jmm28QERGBY8eO4cCBA6hUqRJcXV0xadIk/Otf/yr09omIiN5ES5cuRa9evbBz504cP34chw4dwt27d2FpaYlq1arh3XffxejRo1G/fv0Sb0urVq1w8uRJLFmyBFFRUThy5AiePXsGR0dHVK1aFYMGDULv3r3V9bt3744HDx4gLi4OKSkpOHjwICwtLeHm5oYpU6Zg3LhxJTqE402nkpKYBqGYZGZm4q233sKZM2dw9OhRNG7cuKybRERERERvgFdi/oyjR49q/Yr68ePHCAkJwZkzZ+Dt7c0ATERERETF5pW4Euzh4YH09HR4eXnB0dERt27dQmJiIu7evYsKFSogJiam1O/eRkRERERvrlciBH/11VeIiIjA6dOnce/ePRgZGcHd3R2dOnXCpEmTFH9bPyIiIiIqXq9ECCYiIiIiKk2vxJhgIiIiIqLSxBBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREisMQTERERESKwxBMRERERIrDEExEREREivP/ABmK//Bs/ve4AAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 600x230 with 1 Axes>"
       ]
@@ -338,7 +410,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 13,
    "metadata": {
     "collapsed": false
    },
@@ -349,13 +421,13 @@
        "(<Figure size 1000x600 with 1 Axes>, <Axes: >)"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x600 with 1 Axes>"
       ]
@@ -395,7 +467,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "aeon_cenv",
    "language": "python",
    "name": "python3"
   },
@@ -409,7 +481,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.8"
+   "version": "3.11.11"
   }
  },
  "nbformat": 4,