diff --git a/.gitattributes b/.gitattributes
index 002eab79c3cba4da6726940faebec002c5891c1e..b627850e3cd6a7119f7ebda63d7c5bd741be1300 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -504,3 +504,4 @@ material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/_wrapp
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected_4Classes/1908250_cm.tif filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Output/1908272/1908272.tif filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908308_m.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected_4Classes/1908284_cm.tif filter=lfs diff=lfs merge=lfs -text
diff --git a/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_Manual_4connected_4Classes/1908284_cm.tif b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_Manual_4connected_4Classes/1908284_cm.tif
new file mode 100644
index 0000000000000000000000000000000000000000..757f5c86f74a144fe31696e3b60dd932f07dcd75
--- /dev/null
+++ b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_Manual_4connected_4Classes/1908284_cm.tif	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e44302554a21bb6b9e2bff41555e272fff11f458d6c551318ac7b4f17c8e4c99
+size 2162842
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/__pycache__/_cmp.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/__pycache__/_cmp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fed2ed748b7584bbb42ced4747359df611aaa1d
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/__pycache__/_cmp.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/__pycache__/_make.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/__pycache__/_make.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..318ba8c647fe42b92ad1aacf61ddd13d137d6b5a
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/__pycache__/_make.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/__init__.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..09ac19f97671e40ff5bd2ccbc20838cde962bcaf
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/__init__.py
@@ -0,0 +1,70 @@
+# This file also re-exports symbols for wider use. We configure mypy and flake8
+# to be aware that this file does this.
+
+from jedi.inference.compiled.value import CompiledValue, CompiledName, \
+    CompiledValueFilter, CompiledValueName, create_from_access_path
+from jedi.inference.base_value import LazyValueWrapper
+
+
+def builtin_from_name(inference_state, string):
+    typing_builtins_module = inference_state.builtins_module
+    if string in ('None', 'True', 'False'):
+        builtins, = typing_builtins_module.non_stub_value_set
+        filter_ = next(builtins.get_filters())
+    else:
+        filter_ = next(typing_builtins_module.get_filters())
+    name, = filter_.get(string)
+    value, = name.infer()
+    return value
+
+
+class ExactValue(LazyValueWrapper):
+    """
+    This class represents exact values, that makes operations like additions
+    and exact boolean values possible, while still being a "normal" stub.
+    """
+    def __init__(self, compiled_value):
+        self.inference_state = compiled_value.inference_state
+        self._compiled_value = compiled_value
+
+    def __getattribute__(self, name):
+        if name in ('get_safe_value', 'execute_operation', 'access_handle',
+                    'negate', 'py__bool__', 'is_compiled'):
+            return getattr(self._compiled_value, name)
+        return super().__getattribute__(name)
+
+    def _get_wrapped_value(self):
+        instance, = builtin_from_name(
+            self.inference_state, self._compiled_value.name.string_name).execute_with_values()
+        return instance
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._compiled_value)
+
+
+def create_simple_object(inference_state, obj):
+    """
+    Only allows creations of objects that are easily picklable across Python
+    versions.
+    """
+    assert type(obj) in (int, float, str, bytes, slice, complex, bool), repr(obj)
+    compiled_value = create_from_access_path(
+        inference_state,
+        inference_state.compiled_subprocess.create_simple_object(obj)
+    )
+    return ExactValue(compiled_value)
+
+
+def get_string_value_set(inference_state):
+    return builtin_from_name(inference_state, 'str').execute_with_values()
+
+
+def load_module(inference_state, dotted_name, **kwargs):
+    # Temporary, some tensorflow builtins cannot be loaded, so it's tried again
+    # and again and it's really slow.
+    if dotted_name.startswith('tensorflow.'):
+        return None
+    access_path = inference_state.compiled_subprocess.load_module(dotted_name=dotted_name, **kwargs)
+    if access_path is None:
+        return None
+    return create_from_access_path(inference_state, access_path)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/access.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/access.py
new file mode 100644
index 0000000000000000000000000000000000000000..09ed1b64dce199308c5415c97e39a54215d52a93
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/access.py
@@ -0,0 +1,562 @@
+import inspect
+import types
+import traceback
+import sys
+import operator as op
+from collections import namedtuple
+import warnings
+import re
+import builtins
+import typing
+from pathlib import Path
+from typing import Optional, Tuple
+
+from jedi.inference.compiled.getattr_static import getattr_static
+
+ALLOWED_GETITEM_TYPES = (str, list, tuple, bytes, bytearray, dict)
+
+MethodDescriptorType = type(str.replace)
+# These are not considered classes and access is granted even though they have
+# a __class__ attribute.
+NOT_CLASS_TYPES = (
+    types.BuiltinFunctionType,
+    types.CodeType,
+    types.FrameType,
+    types.FunctionType,
+    types.GeneratorType,
+    types.GetSetDescriptorType,
+    types.LambdaType,
+    types.MemberDescriptorType,
+    types.MethodType,
+    types.ModuleType,
+    types.TracebackType,
+    MethodDescriptorType,
+    types.MappingProxyType,
+    types.SimpleNamespace,
+    types.DynamicClassAttribute,
+)
+
+# Those types don't exist in typing.
+MethodDescriptorType = type(str.replace)
+WrapperDescriptorType = type(set.__iter__)
+# `object.__subclasshook__` is an already executed descriptor.
+object_class_dict = type.__dict__["__dict__"].__get__(object)  # type: ignore[index]
+ClassMethodDescriptorType = type(object_class_dict['__subclasshook__'])
+
+_sentinel = object()
+
+# Maps Python syntax to the operator module.
+COMPARISON_OPERATORS = {
+    '==': op.eq,
+    '!=': op.ne,
+    'is': op.is_,
+    'is not': op.is_not,
+    '<': op.lt,
+    '<=': op.le,
+    '>': op.gt,
+    '>=': op.ge,
+}
+
+_OPERATORS = {
+    '+': op.add,
+    '-': op.sub,
+}
+_OPERATORS.update(COMPARISON_OPERATORS)
+
+ALLOWED_DESCRIPTOR_ACCESS = (
+    types.FunctionType,
+    types.GetSetDescriptorType,
+    types.MemberDescriptorType,
+    MethodDescriptorType,
+    WrapperDescriptorType,
+    ClassMethodDescriptorType,
+    staticmethod,
+    classmethod,
+)
+
+
+def safe_getattr(obj, name, default=_sentinel):
+    try:
+        attr, is_get_descriptor = getattr_static(obj, name)
+    except AttributeError:
+        if default is _sentinel:
+            raise
+        return default
+    else:
+        if isinstance(attr, ALLOWED_DESCRIPTOR_ACCESS):
+            # In case of descriptors that have get methods we cannot return
+            # it's value, because that would mean code execution.
+            # Since it's an isinstance call, code execution is still possible,
+            # but this is not really a security feature, but much more of a
+            # safety feature. Code execution is basically always possible when
+            # a module is imported. This is here so people don't shoot
+            # themselves in the foot.
+            return getattr(obj, name)
+    return attr
+
+
+SignatureParam = namedtuple(
+    'SignatureParam',
+    'name has_default default default_string has_annotation annotation annotation_string kind_name'
+)
+
+
+def shorten_repr(func):
+    def wrapper(self):
+        r = func(self)
+        if len(r) > 50:
+            r = r[:50] + '..'
+        return r
+    return wrapper
+
+
+def create_access(inference_state, obj):
+    return inference_state.compiled_subprocess.get_or_create_access_handle(obj)
+
+
+def load_module(inference_state, dotted_name, sys_path):
+    temp, sys.path = sys.path, sys_path
+    try:
+        __import__(dotted_name)
+    except ImportError:
+        # If a module is "corrupt" or not really a Python module or whatever.
+        warnings.warn(
+            "Module %s not importable in path %s." % (dotted_name, sys_path),
+            UserWarning,
+            stacklevel=2,
+        )
+        return None
+    except Exception:
+        # Since __import__ pretty much makes code execution possible, just
+        # catch any error here and print it.
+        warnings.warn(
+            "Cannot import:\n%s" % traceback.format_exc(), UserWarning, stacklevel=2
+        )
+        return None
+    finally:
+        sys.path = temp
+
+    # Just access the cache after import, because of #59 as well as the very
+    # complicated import structure of Python.
+    module = sys.modules[dotted_name]
+    return create_access_path(inference_state, module)
+
+
+class AccessPath:
+    def __init__(self, accesses):
+        self.accesses = accesses
+
+
+def create_access_path(inference_state, obj) -> AccessPath:
+    access = create_access(inference_state, obj)
+    return AccessPath(access.get_access_path_tuples())
+
+
+def get_api_type(obj):
+    if inspect.isclass(obj):
+        return 'class'
+    elif inspect.ismodule(obj):
+        return 'module'
+    elif inspect.isbuiltin(obj) or inspect.ismethod(obj) \
+            or inspect.ismethoddescriptor(obj) or inspect.isfunction(obj):
+        return 'function'
+    # Everything else...
+    return 'instance'
+
+
+class DirectObjectAccess:
+    def __init__(self, inference_state, obj):
+        self._inference_state = inference_state
+        self._obj = obj
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self.get_repr())
+
+    def _create_access(self, obj):
+        return create_access(self._inference_state, obj)
+
+    def _create_access_path(self, obj) -> AccessPath:
+        return create_access_path(self._inference_state, obj)
+
+    def py__bool__(self):
+        return bool(self._obj)
+
+    def py__file__(self) -> Optional[Path]:
+        try:
+            return Path(self._obj.__file__)
+        except AttributeError:
+            return None
+
+    def py__doc__(self):
+        return inspect.getdoc(self._obj) or ''
+
+    def py__name__(self):
+        if not _is_class_instance(self._obj) or \
+                inspect.ismethoddescriptor(self._obj):  # slots
+            cls = self._obj
+        else:
+            try:
+                cls = self._obj.__class__
+            except AttributeError:
+                # happens with numpy.core.umath._UFUNC_API (you get it
+                # automatically by doing `import numpy`.
+                return None
+
+        try:
+            return cls.__name__
+        except AttributeError:
+            return None
+
+    def py__mro__accesses(self):
+        return tuple(self._create_access_path(cls) for cls in self._obj.__mro__[1:])
+
+    def py__getitem__all_values(self):
+        if isinstance(self._obj, dict):
+            return [self._create_access_path(v) for v in self._obj.values()]
+        if isinstance(self._obj, (list, tuple)):
+            return [self._create_access_path(v) for v in self._obj]
+
+        if self.is_instance():
+            cls = DirectObjectAccess(self._inference_state, self._obj.__class__)
+            return cls.py__getitem__all_values()
+
+        try:
+            getitem = self._obj.__getitem__
+        except AttributeError:
+            pass
+        else:
+            annotation = DirectObjectAccess(self._inference_state, getitem).get_return_annotation()
+            if annotation is not None:
+                return [annotation]
+        return None
+
+    def py__simple_getitem__(self, index, *, safe=True):
+        if safe and type(self._obj) not in ALLOWED_GETITEM_TYPES:
+            # Get rid of side effects, we won't call custom `__getitem__`s.
+            return None
+
+        return self._create_access_path(self._obj[index])
+
+    def py__iter__list(self):
+        try:
+            iter_method = self._obj.__iter__
+        except AttributeError:
+            return None
+        else:
+            p = DirectObjectAccess(self._inference_state, iter_method).get_return_annotation()
+            if p is not None:
+                return [p]
+
+        if type(self._obj) not in ALLOWED_GETITEM_TYPES:
+            # Get rid of side effects, we won't call custom `__getitem__`s.
+            return []
+
+        lst = []
+        for i, part in enumerate(self._obj):
+            if i > 20:
+                # Should not go crazy with large iterators
+                break
+            lst.append(self._create_access_path(part))
+        return lst
+
+    def py__class__(self):
+        return self._create_access_path(self._obj.__class__)
+
+    def py__bases__(self):
+        return [self._create_access_path(base) for base in self._obj.__bases__]
+
+    def py__path__(self):
+        paths = getattr(self._obj, '__path__', None)
+        # Avoid some weird hacks that would just fail, because they cannot be
+        # used by pickle.
+        if not isinstance(paths, list) \
+                or not all(isinstance(p, str) for p in paths):
+            return None
+        return paths
+
+    @shorten_repr
+    def get_repr(self):
+        if inspect.ismodule(self._obj):
+            return repr(self._obj)
+        # Try to avoid execution of the property.
+        if safe_getattr(self._obj, '__module__', default='') == 'builtins':
+            return repr(self._obj)
+
+        type_ = type(self._obj)
+        if type_ == type:
+            return type.__repr__(self._obj)
+
+        if safe_getattr(type_, '__module__', default='') == 'builtins':
+            # Allow direct execution of repr for builtins.
+            return repr(self._obj)
+        return object.__repr__(self._obj)
+
+    def is_class(self):
+        return inspect.isclass(self._obj)
+
+    def is_function(self):
+        return inspect.isfunction(self._obj) or inspect.ismethod(self._obj)
+
+    def is_module(self):
+        return inspect.ismodule(self._obj)
+
+    def is_instance(self):
+        return _is_class_instance(self._obj)
+
+    def ismethoddescriptor(self):
+        return inspect.ismethoddescriptor(self._obj)
+
+    def get_qualified_names(self):
+        def try_to_get_name(obj):
+            return getattr(obj, '__qualname__', getattr(obj, '__name__', None))
+
+        if self.is_module():
+            return ()
+        name = try_to_get_name(self._obj)
+        if name is None:
+            name = try_to_get_name(type(self._obj))
+            if name is None:
+                return ()
+        return tuple(name.split('.'))
+
+    def dir(self):
+        return dir(self._obj)
+
+    def has_iter(self):
+        try:
+            iter(self._obj)
+            return True
+        except TypeError:
+            return False
+
+    def is_allowed_getattr(self, name, safe=True) -> Tuple[bool, bool, Optional[AccessPath]]:
+        # TODO this API is ugly.
+        try:
+            attr, is_get_descriptor = getattr_static(self._obj, name)
+        except AttributeError:
+            if not safe:
+                # Unsafe is mostly used to check for __getattr__/__getattribute__.
+                # getattr_static works for properties, but the underscore methods
+                # are just ignored (because it's safer and avoids more code
+                # execution). See also GH #1378.
+
+                # Avoid warnings, see comment in the next function.
+                with warnings.catch_warnings(record=True):
+                    warnings.simplefilter("always")
+                    try:
+                        return hasattr(self._obj, name), False, None
+                    except Exception:
+                        # Obviously has an attribute (probably a property) that
+                        # gets executed, so just avoid all exceptions here.
+                        pass
+            return False, False, None
+        else:
+            if is_get_descriptor and type(attr) not in ALLOWED_DESCRIPTOR_ACCESS:
+                if isinstance(attr, property):
+                    if hasattr(attr.fget, '__annotations__'):
+                        a = DirectObjectAccess(self._inference_state, attr.fget)
+                        return True, True, a.get_return_annotation()
+                # In case of descriptors that have get methods we cannot return
+                # it's value, because that would mean code execution.
+                return True, True, None
+        return True, False, None
+
+    def getattr_paths(self, name, default=_sentinel):
+        try:
+            # Make sure no warnings are printed here, this is autocompletion,
+            # warnings should not be shown. See also GH #1383.
+            with warnings.catch_warnings(record=True):
+                warnings.simplefilter("always")
+                return_obj = getattr(self._obj, name)
+        except Exception as e:
+            if default is _sentinel:
+                if isinstance(e, AttributeError):
+                    # Happens e.g. in properties of
+                    # PyQt4.QtGui.QStyleOptionComboBox.currentText
+                    # -> just set it to None
+                    raise
+                # Just in case anything happens, return an AttributeError. It
+                # should not crash.
+                raise AttributeError
+            return_obj = default
+        access = self._create_access(return_obj)
+        if inspect.ismodule(return_obj):
+            return [access]
+
+        try:
+            module = return_obj.__module__
+        except AttributeError:
+            pass
+        else:
+            if module is not None and isinstance(module, str):
+                try:
+                    __import__(module)
+                    # For some modules like _sqlite3, the __module__ for classes is
+                    # different, in this case it's sqlite3. So we have to try to
+                    # load that "original" module, because it's not loaded yet. If
+                    # we don't do that, we don't really have a "parent" module and
+                    # we would fall back to builtins.
+                except ImportError:
+                    pass
+
+        module = inspect.getmodule(return_obj)
+        if module is None:
+            module = inspect.getmodule(type(return_obj))
+            if module is None:
+                module = builtins
+        return [self._create_access(module), access]
+
+    def get_safe_value(self):
+        if type(self._obj) in (bool, bytes, float, int, str, slice) or self._obj is None:
+            return self._obj
+        raise ValueError("Object is type %s and not simple" % type(self._obj))
+
+    def get_api_type(self):
+        return get_api_type(self._obj)
+
+    def get_array_type(self):
+        if isinstance(self._obj, dict):
+            return 'dict'
+        return None
+
+    def get_key_paths(self):
+        def iter_partial_keys():
+            # We could use list(keys()), but that might take a lot more memory.
+            for (i, k) in enumerate(self._obj.keys()):
+                # Limit key listing at some point. This is artificial, but this
+                # way we don't get stalled because of slow completions
+                if i > 50:
+                    break
+                yield k
+
+        return [self._create_access_path(k) for k in iter_partial_keys()]
+
+    def get_access_path_tuples(self):
+        accesses = [create_access(self._inference_state, o) for o in self._get_objects_path()]
+        return [(access.py__name__(), access) for access in accesses]
+
+    def _get_objects_path(self):
+        def get():
+            obj = self._obj
+            yield obj
+            try:
+                obj = obj.__objclass__
+            except AttributeError:
+                pass
+            else:
+                yield obj
+
+            try:
+                # Returns a dotted string path.
+                imp_plz = obj.__module__
+            except AttributeError:
+                # Unfortunately in some cases like `int` there's no __module__
+                if not inspect.ismodule(obj):
+                    yield builtins
+            else:
+                if imp_plz is None:
+                    # Happens for example in `(_ for _ in []).send.__module__`.
+                    yield builtins
+                else:
+                    try:
+                        yield sys.modules[imp_plz]
+                    except KeyError:
+                        # __module__ can be something arbitrary that doesn't exist.
+                        yield builtins
+
+        return list(reversed(list(get())))
+
+    def execute_operation(self, other_access_handle, operator):
+        other_access = other_access_handle.access
+        op = _OPERATORS[operator]
+        return self._create_access_path(op(self._obj, other_access._obj))
+
+    def get_annotation_name_and_args(self):
+        """
+        Returns Tuple[Optional[str], Tuple[AccessPath, ...]]
+        """
+        name = None
+        args = ()
+        if safe_getattr(self._obj, '__module__', default='') == 'typing':
+            m = re.match(r'typing.(\w+)\[', repr(self._obj))
+            if m is not None:
+                name = m.group(1)
+
+                import typing
+                if sys.version_info >= (3, 8):
+                    args = typing.get_args(self._obj)
+                else:
+                    args = safe_getattr(self._obj, '__args__', default=None)
+        return name, tuple(self._create_access_path(arg) for arg in args)
+
+    def needs_type_completions(self):
+        return inspect.isclass(self._obj) and self._obj != type
+
+    def _annotation_to_str(self, annotation):
+        return inspect.formatannotation(annotation)
+
+    def get_signature_params(self):
+        return [
+            SignatureParam(
+                name=p.name,
+                has_default=p.default is not p.empty,
+                default=self._create_access_path(p.default),
+                default_string=repr(p.default),
+                has_annotation=p.annotation is not p.empty,
+                annotation=self._create_access_path(p.annotation),
+                annotation_string=self._annotation_to_str(p.annotation),
+                kind_name=str(p.kind)
+            ) for p in self._get_signature().parameters.values()
+        ]
+
+    def _get_signature(self):
+        obj = self._obj
+        try:
+            return inspect.signature(obj)
+        except (RuntimeError, TypeError):
+            # Reading the code of the function in Python 3.6 implies there are
+            # at least these errors that might occur if something is wrong with
+            # the signature. In that case we just want a simple escape for now.
+            raise ValueError
+
+    def get_return_annotation(self) -> Optional[AccessPath]:
+        try:
+            o = self._obj.__annotations__.get('return')
+        except AttributeError:
+            return None
+
+        if o is None:
+            return None
+
+        try:
+            o = typing.get_type_hints(self._obj).get('return')
+        except Exception:
+            pass
+
+        return self._create_access_path(o)
+
+    def negate(self):
+        return self._create_access_path(-self._obj)
+
+    def get_dir_infos(self):
+        """
+        Used to return a couple of infos that are needed when accessing the sub
+        objects of an objects
+        """
+        tuples = dict(
+            (name, self.is_allowed_getattr(name))
+            for name in self.dir()
+        )
+        return self.needs_type_completions(), tuples
+
+
+def _is_class_instance(obj):
+    """Like inspect.* methods."""
+    try:
+        cls = obj.__class__
+    except AttributeError:
+        return False
+    else:
+        # The isinstance check for cls is just there so issubclass doesn't
+        # raise an exception.
+        return cls != type and isinstance(cls, type) and not issubclass(cls, NOT_CLASS_TYPES)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/getattr_static.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/getattr_static.py
new file mode 100644
index 0000000000000000000000000000000000000000..03c199eff4b5a1b13085b49483e120bcd36159fc
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/getattr_static.py
@@ -0,0 +1,121 @@
+"""
+A static version of getattr.
+This is a backport of the Python 3 code with a little bit of additional
+information returned to enable Jedi to make decisions.
+"""
+
+import types
+
+from jedi import debug
+
+_sentinel = object()
+
+
+def _check_instance(obj, attr):
+    instance_dict = {}
+    try:
+        instance_dict = object.__getattribute__(obj, "__dict__")
+    except AttributeError:
+        pass
+    return dict.get(instance_dict, attr, _sentinel)
+
+
+def _check_class(klass, attr):
+    for entry in _static_getmro(klass):
+        if _shadowed_dict(type(entry)) is _sentinel:
+            try:
+                return entry.__dict__[attr]
+            except KeyError:
+                pass
+    return _sentinel
+
+
+def _is_type(obj):
+    try:
+        _static_getmro(obj)
+    except TypeError:
+        return False
+    return True
+
+
+def _shadowed_dict(klass):
+    dict_attr = type.__dict__["__dict__"]
+    for entry in _static_getmro(klass):
+        try:
+            class_dict = dict_attr.__get__(entry)["__dict__"]
+        except KeyError:
+            pass
+        else:
+            if not (type(class_dict) is types.GetSetDescriptorType
+                    and class_dict.__name__ == "__dict__"
+                    and class_dict.__objclass__ is entry):
+                return class_dict
+    return _sentinel
+
+
+def _static_getmro(klass):
+    mro = type.__dict__['__mro__'].__get__(klass)
+    if not isinstance(mro, (tuple, list)):
+        # There are unfortunately no tests for this, I was not able to
+        # reproduce this in pure Python. However should still solve the issue
+        # raised in GH #1517.
+        debug.warning('mro of %s returned %s, should be a tuple' % (klass, mro))
+        return ()
+    return mro
+
+
+def _safe_hasattr(obj, name):
+    return _check_class(type(obj), name) is not _sentinel
+
+
+def _safe_is_data_descriptor(obj):
+    return _safe_hasattr(obj, '__set__') or _safe_hasattr(obj, '__delete__')
+
+
+def getattr_static(obj, attr, default=_sentinel):
+    """Retrieve attributes without triggering dynamic lookup via the
+       descriptor protocol,  __getattr__ or __getattribute__.
+
+       Note: this function may not be able to retrieve all attributes
+       that getattr can fetch (like dynamically created attributes)
+       and may find attributes that getattr can't (like descriptors
+       that raise AttributeError). It can also return descriptor objects
+       instead of instance members in some cases. See the
+       documentation for details.
+
+       Returns a tuple `(attr, is_get_descriptor)`. is_get_descripter means that
+       the attribute is a descriptor that has a `__get__` attribute.
+    """
+    instance_result = _sentinel
+    if not _is_type(obj):
+        klass = type(obj)
+        dict_attr = _shadowed_dict(klass)
+        if (dict_attr is _sentinel or type(dict_attr) is types.MemberDescriptorType):
+            instance_result = _check_instance(obj, attr)
+    else:
+        klass = obj
+
+    klass_result = _check_class(klass, attr)
+
+    if instance_result is not _sentinel and klass_result is not _sentinel:
+        if _safe_hasattr(klass_result, '__get__') \
+                and _safe_is_data_descriptor(klass_result):
+            # A get/set descriptor has priority over everything.
+            return klass_result, True
+
+    if instance_result is not _sentinel:
+        return instance_result, False
+    if klass_result is not _sentinel:
+        return klass_result, _safe_hasattr(klass_result, '__get__')
+
+    if obj is klass:
+        # for types we check the metaclass too
+        for entry in _static_getmro(type(klass)):
+            if _shadowed_dict(type(entry)) is _sentinel:
+                try:
+                    return entry.__dict__[attr], False
+                except KeyError:
+                    pass
+    if default is not _sentinel:
+        return default, False
+    raise AttributeError(attr)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/mixed.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/mixed.py
new file mode 100644
index 0000000000000000000000000000000000000000..1bfa34056d58c33742475ce321321d9fd4946fc7
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/mixed.py
@@ -0,0 +1,309 @@
+"""
+Used only for REPL Completion.
+"""
+
+import inspect
+from pathlib import Path
+
+from jedi.parser_utils import get_cached_code_lines
+
+from jedi import settings
+from jedi.cache import memoize_method
+from jedi.inference import compiled
+from jedi.file_io import FileIO
+from jedi.inference.names import NameWrapper
+from jedi.inference.base_value import ValueSet, ValueWrapper, NO_VALUES
+from jedi.inference.value import ModuleValue
+from jedi.inference.cache import inference_state_function_cache, \
+    inference_state_method_cache
+from jedi.inference.compiled.access import ALLOWED_GETITEM_TYPES, get_api_type
+from jedi.inference.gradual.conversion import to_stub
+from jedi.inference.context import CompiledContext, CompiledModuleContext, \
+    TreeContextMixin
+
+_sentinel = object()
+
+
+class MixedObject(ValueWrapper):
+    """
+    A ``MixedObject`` is used in two ways:
+
+    1. It uses the default logic of ``parser.python.tree`` objects,
+    2. except for getattr calls and signatures. The names dicts are generated
+       in a fashion like ``CompiledValue``.
+
+    This combined logic makes it possible to provide more powerful REPL
+    completion. It allows side effects that are not noticable with the default
+    parser structure to still be completable.
+
+    The biggest difference from CompiledValue to MixedObject is that we are
+    generally dealing with Python code and not with C code. This will generate
+    fewer special cases, because we in Python you don't have the same freedoms
+    to modify the runtime.
+    """
+    def __init__(self, compiled_value, tree_value):
+        super().__init__(tree_value)
+        self.compiled_value = compiled_value
+        self.access_handle = compiled_value.access_handle
+
+    def get_filters(self, *args, **kwargs):
+        yield MixedObjectFilter(
+            self.inference_state, self.compiled_value, self._wrapped_value)
+
+    def get_signatures(self):
+        # Prefer `inspect.signature` over somehow analyzing Python code. It
+        # should be very precise, especially for stuff like `partial`.
+        return self.compiled_value.get_signatures()
+
+    @inference_state_method_cache(default=NO_VALUES)
+    def py__call__(self, arguments):
+        # Fallback to the wrapped value if to stub returns no values.
+        values = to_stub(self._wrapped_value)
+        if not values:
+            values = self._wrapped_value
+        return values.py__call__(arguments)
+
+    def get_safe_value(self, default=_sentinel):
+        if default is _sentinel:
+            return self.compiled_value.get_safe_value()
+        else:
+            return self.compiled_value.get_safe_value(default)
+
+    @property
+    def array_type(self):
+        return self.compiled_value.array_type
+
+    def get_key_values(self):
+        return self.compiled_value.get_key_values()
+
+    def py__simple_getitem__(self, index):
+        python_object = self.compiled_value.access_handle.access._obj
+        if type(python_object) in ALLOWED_GETITEM_TYPES:
+            return self.compiled_value.py__simple_getitem__(index)
+        return self._wrapped_value.py__simple_getitem__(index)
+
+    def negate(self):
+        return self.compiled_value.negate()
+
+    def _as_context(self):
+        if self.parent_context is None:
+            return MixedModuleContext(self)
+        return MixedContext(self)
+
+    def __repr__(self):
+        return '<%s: %s; %s>' % (
+            type(self).__name__,
+            self.access_handle.get_repr(),
+            self._wrapped_value,
+        )
+
+
+class MixedContext(CompiledContext, TreeContextMixin):
+    @property
+    def compiled_value(self):
+        return self._value.compiled_value
+
+
+class MixedModuleContext(CompiledModuleContext, MixedContext):
+    pass
+
+
+class MixedName(NameWrapper):
+    """
+    The ``CompiledName._compiled_value`` is our MixedObject.
+    """
+    def __init__(self, wrapped_name, parent_tree_value):
+        super().__init__(wrapped_name)
+        self._parent_tree_value = parent_tree_value
+
+    @property
+    def start_pos(self):
+        values = list(self.infer())
+        if not values:
+            # This means a start_pos that doesn't exist (compiled objects).
+            return 0, 0
+        return values[0].name.start_pos
+
+    @memoize_method
+    def infer(self):
+        compiled_value = self._wrapped_name.infer_compiled_value()
+        tree_value = self._parent_tree_value
+        if tree_value.is_instance() or tree_value.is_class():
+            tree_values = tree_value.py__getattribute__(self.string_name)
+            if compiled_value.is_function():
+                return ValueSet({MixedObject(compiled_value, v) for v in tree_values})
+
+        module_context = tree_value.get_root_context()
+        return _create(self._inference_state, compiled_value, module_context)
+
+
+class MixedObjectFilter(compiled.CompiledValueFilter):
+    def __init__(self, inference_state, compiled_value, tree_value):
+        super().__init__(inference_state, compiled_value)
+        self._tree_value = tree_value
+
+    def _create_name(self, *args, **kwargs):
+        return MixedName(
+            super()._create_name(*args, **kwargs),
+            self._tree_value,
+        )
+
+
+@inference_state_function_cache()
+def _load_module(inference_state, path):
+    return inference_state.parse(
+        path=path,
+        cache=True,
+        diff_cache=settings.fast_parser,
+        cache_path=settings.cache_directory
+    ).get_root_node()
+
+
+def _get_object_to_check(python_object):
+    """Check if inspect.getfile has a chance to find the source."""
+    try:
+        python_object = inspect.unwrap(python_object)
+    except ValueError:
+        # Can return a ValueError when it wraps around
+        pass
+
+    if (inspect.ismodule(python_object)
+            or inspect.isclass(python_object)
+            or inspect.ismethod(python_object)
+            or inspect.isfunction(python_object)
+            or inspect.istraceback(python_object)
+            or inspect.isframe(python_object)
+            or inspect.iscode(python_object)):
+        return python_object
+
+    try:
+        return python_object.__class__
+    except AttributeError:
+        raise TypeError  # Prevents computation of `repr` within inspect.
+
+
+def _find_syntax_node_name(inference_state, python_object):
+    original_object = python_object
+    try:
+        python_object = _get_object_to_check(python_object)
+        path = inspect.getsourcefile(python_object)
+    except (OSError, TypeError):
+        # The type might not be known (e.g. class_with_dict.__weakref__)
+        return None
+    path = None if path is None else Path(path)
+    try:
+        if path is None or not path.exists():
+            # The path might not exist or be e.g. <stdin>.
+            return None
+    except OSError:
+        # Might raise an OSError on Windows:
+        #
+        #     [WinError 123] The filename, directory name, or volume label
+        #     syntax is incorrect: '<string>'
+        return None
+
+    file_io = FileIO(path)
+    module_node = _load_module(inference_state, path)
+
+    if inspect.ismodule(python_object):
+        # We don't need to check names for modules, because there's not really
+        # a way to write a module in a module in Python (and also __name__ can
+        # be something like ``email.utils``).
+        code_lines = get_cached_code_lines(inference_state.grammar, path)
+        return module_node, module_node, file_io, code_lines
+
+    try:
+        name_str = python_object.__name__
+    except AttributeError:
+        # Stuff like python_function.__code__.
+        return None
+
+    if name_str == '<lambda>':
+        return None  # It's too hard to find lambdas.
+
+    # Doesn't always work (e.g. os.stat_result)
+    names = module_node.get_used_names().get(name_str, [])
+    # Only functions and classes are relevant. If a name e.g. points to an
+    # import, it's probably a builtin (like collections.deque) and needs to be
+    # ignored.
+    names = [
+        n for n in names
+        if n.parent.type in ('funcdef', 'classdef') and n.parent.name == n
+    ]
+    if not names:
+        return None
+
+    try:
+        code = python_object.__code__
+        # By using the line number of a code object we make the lookup in a
+        # file pretty easy. There's still a possibility of people defining
+        # stuff like ``a = 3; foo(a); a = 4`` on the same line, but if people
+        # do so we just don't care.
+        line_nr = code.co_firstlineno
+    except AttributeError:
+        pass
+    else:
+        line_names = [name for name in names if name.start_pos[0] == line_nr]
+        # There's a chance that the object is not available anymore, because
+        # the code has changed in the background.
+        if line_names:
+            names = line_names
+
+    code_lines = get_cached_code_lines(inference_state.grammar, path)
+    # It's really hard to actually get the right definition, here as a last
+    # resort we just return the last one. This chance might lead to odd
+    # completions at some points but will lead to mostly correct type
+    # inference, because people tend to define a public name in a module only
+    # once.
+    tree_node = names[-1].parent
+    if tree_node.type == 'funcdef' and get_api_type(original_object) == 'instance':
+        # If an instance is given and we're landing on a function (e.g.
+        # partial in 3.5), something is completely wrong and we should not
+        # return that.
+        return None
+    return module_node, tree_node, file_io, code_lines
+
+
+@inference_state_function_cache()
+def _create(inference_state, compiled_value, module_context):
+    # TODO accessing this is bad, but it probably doesn't matter that much,
+    # because we're working with interpreters only here.
+    python_object = compiled_value.access_handle.access._obj
+    result = _find_syntax_node_name(inference_state, python_object)
+    if result is None:
+        # TODO Care about generics from stuff like `[1]` and don't return like this.
+        if type(python_object) in (dict, list, tuple):
+            return ValueSet({compiled_value})
+
+        tree_values = to_stub(compiled_value)
+        if not tree_values:
+            return ValueSet({compiled_value})
+    else:
+        module_node, tree_node, file_io, code_lines = result
+
+        if module_context is None or module_context.tree_node != module_node:
+            root_compiled_value = compiled_value.get_root_context().get_value()
+            # TODO this __name__ might be wrong.
+            name = root_compiled_value.py__name__()
+            string_names = tuple(name.split('.'))
+            module_value = ModuleValue(
+                inference_state, module_node,
+                file_io=file_io,
+                string_names=string_names,
+                code_lines=code_lines,
+                is_package=root_compiled_value.is_package(),
+            )
+            if name is not None:
+                inference_state.module_cache.add(string_names, ValueSet([module_value]))
+            module_context = module_value.as_context()
+
+        tree_values = ValueSet({module_context.create_value(tree_node)})
+        if tree_node.type == 'classdef':
+            if not compiled_value.is_class():
+                # Is an instance, not a class.
+                tree_values = tree_values.execute_with_values()
+
+    return ValueSet(
+        MixedObject(compiled_value, tree_value=tree_value)
+        for tree_value in tree_values
+    )
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/subprocess/functions.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/subprocess/functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..50c47b83ada57d04a1fce44919c68465bdf74c6b
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/subprocess/functions.py
@@ -0,0 +1,257 @@
+import sys
+import os
+import inspect
+import importlib
+from pathlib import Path
+from zipfile import ZipFile
+from zipimport import zipimporter, ZipImportError
+from importlib.machinery import all_suffixes
+
+from jedi.inference.compiled import access
+from jedi import debug
+from jedi import parser_utils
+from jedi.file_io import KnownContentFileIO, ZipFileIO
+
+
+def get_sys_path():
+    return sys.path
+
+
+def load_module(inference_state, **kwargs):
+    return access.load_module(inference_state, **kwargs)
+
+
+def get_compiled_method_return(inference_state, id, attribute, *args, **kwargs):
+    handle = inference_state.compiled_subprocess.get_access_handle(id)
+    return getattr(handle.access, attribute)(*args, **kwargs)
+
+
+def create_simple_object(inference_state, obj):
+    return access.create_access_path(inference_state, obj)
+
+
+def get_module_info(inference_state, sys_path=None, full_name=None, **kwargs):
+    """
+    Returns Tuple[Union[NamespaceInfo, FileIO, None], Optional[bool]]
+    """
+    if sys_path is not None:
+        sys.path, temp = sys_path, sys.path
+    try:
+        return _find_module(full_name=full_name, **kwargs)
+    except ImportError:
+        return None, None
+    finally:
+        if sys_path is not None:
+            sys.path = temp
+
+
+def get_builtin_module_names(inference_state):
+    return sys.builtin_module_names
+
+
+def _test_raise_error(inference_state, exception_type):
+    """
+    Raise an error to simulate certain problems for unit tests.
+    """
+    raise exception_type
+
+
+def _test_print(inference_state, stderr=None, stdout=None):
+    """
+    Force some prints in the subprocesses. This exists for unit tests.
+    """
+    if stderr is not None:
+        print(stderr, file=sys.stderr)
+        sys.stderr.flush()
+    if stdout is not None:
+        print(stdout)
+        sys.stdout.flush()
+
+
+def _get_init_path(directory_path):
+    """
+    The __init__ file can be searched in a directory. If found return it, else
+    None.
+    """
+    for suffix in all_suffixes():
+        path = os.path.join(directory_path, '__init__' + suffix)
+        if os.path.exists(path):
+            return path
+    return None
+
+
+def safe_literal_eval(inference_state, value):
+    return parser_utils.safe_literal_eval(value)
+
+
+def iter_module_names(*args, **kwargs):
+    return list(_iter_module_names(*args, **kwargs))
+
+
+def _iter_module_names(inference_state, paths):
+    # Python modules/packages
+    for path in paths:
+        try:
+            dir_entries = ((entry.name, entry.is_dir()) for entry in os.scandir(path))
+        except OSError:
+            try:
+                zip_import_info = zipimporter(path)
+                # Unfortunately, there is no public way to access zipimporter's
+                # private _files member. We therefore have to use a
+                # custom function to iterate over the files.
+                dir_entries = _zip_list_subdirectory(
+                    zip_import_info.archive, zip_import_info.prefix)
+            except ZipImportError:
+                # The file might not exist or reading it might lead to an error.
+                debug.warning("Not possible to list directory: %s", path)
+                continue
+        for name, is_dir in dir_entries:
+            # First Namespaces then modules/stubs
+            if is_dir:
+                # pycache is obviously not an interesting namespace. Also the
+                # name must be a valid identifier.
+                if name != '__pycache__' and name.isidentifier():
+                    yield name
+            else:
+                if name.endswith('.pyi'):  # Stub files
+                    modname = name[:-4]
+                else:
+                    modname = inspect.getmodulename(name)
+
+                if modname and '.' not in modname:
+                    if modname != '__init__':
+                        yield modname
+
+
+def _find_module(string, path=None, full_name=None, is_global_search=True):
+    """
+    Provides information about a module.
+
+    This function isolates the differences in importing libraries introduced with
+    python 3.3 on; it gets a module name and optionally a path. It will return a
+    tuple containin an open file for the module (if not builtin), the filename
+    or the name of the module if it is a builtin one and a boolean indicating
+    if the module is contained in a package.
+    """
+    spec = None
+    loader = None
+
+    for finder in sys.meta_path:
+        if is_global_search and finder != importlib.machinery.PathFinder:
+            p = None
+        else:
+            p = path
+        try:
+            find_spec = finder.find_spec
+        except AttributeError:
+            # These are old-school clases that still have a different API, just
+            # ignore those.
+            continue
+
+        spec = find_spec(string, p)
+        if spec is not None:
+            if spec.origin == "frozen":
+                continue
+
+            loader = spec.loader
+
+            if loader is None and not spec.has_location:
+                # This is a namespace package.
+                full_name = string if not path else full_name
+                implicit_ns_info = ImplicitNSInfo(full_name, spec.submodule_search_locations._path)
+                return implicit_ns_info, True
+            break
+
+    return _find_module_py33(string, path, loader)
+
+
+def _find_module_py33(string, path=None, loader=None, full_name=None, is_global_search=True):
+    if not loader:
+        spec = importlib.machinery.PathFinder.find_spec(string, path)
+        if spec is not None:
+            loader = spec.loader
+
+    if loader is None and path is None:  # Fallback to find builtins
+        try:
+            spec = importlib.util.find_spec(string)
+            if spec is not None:
+                loader = spec.loader
+        except ValueError as e:
+            # See #491. Importlib might raise a ValueError, to avoid this, we
+            # just raise an ImportError to fix the issue.
+            raise ImportError("Originally  " + repr(e))
+
+    if loader is None:
+        raise ImportError("Couldn't find a loader for {}".format(string))
+
+    return _from_loader(loader, string)
+
+
+def _from_loader(loader, string):
+    try:
+        is_package_method = loader.is_package
+    except AttributeError:
+        is_package = False
+    else:
+        is_package = is_package_method(string)
+    try:
+        get_filename = loader.get_filename
+    except AttributeError:
+        return None, is_package
+    else:
+        module_path = get_filename(string)
+
+    # To avoid unicode and read bytes, "overwrite" loader.get_source if
+    # possible.
+    try:
+        f = type(loader).get_source
+    except AttributeError:
+        raise ImportError("get_source was not defined on loader")
+
+    if f is not importlib.machinery.SourceFileLoader.get_source:
+        # Unfortunately we are reading unicode here, not bytes.
+        # It seems hard to get bytes, because the zip importer
+        # logic just unpacks the zip file and returns a file descriptor
+        # that we cannot as easily access. Therefore we just read it as
+        # a string in the cases where get_source was overwritten.
+        code = loader.get_source(string)
+    else:
+        code = _get_source(loader, string)
+
+    if code is None:
+        return None, is_package
+    if isinstance(loader, zipimporter):
+        return ZipFileIO(module_path, code, Path(loader.archive)), is_package
+
+    return KnownContentFileIO(module_path, code), is_package
+
+
+def _get_source(loader, fullname):
+    """
+    This method is here as a replacement for SourceLoader.get_source. That
+    method returns unicode, but we prefer bytes.
+    """
+    path = loader.get_filename(fullname)
+    try:
+        return loader.get_data(path)
+    except OSError:
+        raise ImportError('source not available through get_data()',
+                          name=fullname)
+
+
+def _zip_list_subdirectory(zip_path, zip_subdir_path):
+    zip_file = ZipFile(zip_path)
+    zip_subdir_path = Path(zip_subdir_path)
+    zip_content_file_paths = zip_file.namelist()
+    for raw_file_name in zip_content_file_paths:
+        file_path = Path(raw_file_name)
+        if file_path.parent == zip_subdir_path:
+            file_path = file_path.relative_to(zip_subdir_path)
+            yield file_path.name, raw_file_name.endswith("/")
+
+
+class ImplicitNSInfo:
+    """Stores information returned from an implicit namespace spec"""
+    def __init__(self, name, paths):
+        self.name = name
+        self.paths = paths
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/value.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/value.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3a841b1a509c3cc519faf2ce42d151e14ae5cdf
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/compiled/value.py
@@ -0,0 +1,626 @@
+"""
+Imitate the parser representation.
+"""
+import re
+from functools import partial
+from inspect import Parameter
+from pathlib import Path
+from typing import Optional
+
+from jedi import debug
+from jedi.inference.utils import to_list
+from jedi.cache import memoize_method
+from jedi.inference.filters import AbstractFilter
+from jedi.inference.names import AbstractNameDefinition, ValueNameMixin, \
+    ParamNameInterface
+from jedi.inference.base_value import Value, ValueSet, NO_VALUES
+from jedi.inference.lazy_value import LazyKnownValue
+from jedi.inference.compiled.access import _sentinel
+from jedi.inference.cache import inference_state_function_cache
+from jedi.inference.helpers import reraise_getitem_errors
+from jedi.inference.signature import BuiltinSignature
+from jedi.inference.context import CompiledContext, CompiledModuleContext
+
+
+class CheckAttribute:
+    """Raises :exc:`AttributeError` if the attribute X is not available."""
+    def __init__(self, check_name=None):
+        # Remove the py in front of e.g. py__call__.
+        self.check_name = check_name
+
+    def __call__(self, func):
+        self.func = func
+        if self.check_name is None:
+            self.check_name = func.__name__[2:]
+        return self
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+
+        # This might raise an AttributeError. That's wanted.
+        instance.access_handle.getattr_paths(self.check_name)
+        return partial(self.func, instance)
+
+
+class CompiledValue(Value):
+    def __init__(self, inference_state, access_handle, parent_context=None):
+        super().__init__(inference_state, parent_context)
+        self.access_handle = access_handle
+
+    def py__call__(self, arguments):
+        return_annotation = self.access_handle.get_return_annotation()
+        if return_annotation is not None:
+            return create_from_access_path(
+                self.inference_state,
+                return_annotation
+            ).execute_annotation()
+
+        try:
+            self.access_handle.getattr_paths('__call__')
+        except AttributeError:
+            return super().py__call__(arguments)
+        else:
+            if self.access_handle.is_class():
+                from jedi.inference.value import CompiledInstance
+                return ValueSet([
+                    CompiledInstance(self.inference_state, self.parent_context, self, arguments)
+                ])
+            else:
+                return ValueSet(self._execute_function(arguments))
+
+    @CheckAttribute()
+    def py__class__(self):
+        return create_from_access_path(self.inference_state, self.access_handle.py__class__())
+
+    @CheckAttribute()
+    def py__mro__(self):
+        return (self,) + tuple(
+            create_from_access_path(self.inference_state, access)
+            for access in self.access_handle.py__mro__accesses()
+        )
+
+    @CheckAttribute()
+    def py__bases__(self):
+        return tuple(
+            create_from_access_path(self.inference_state, access)
+            for access in self.access_handle.py__bases__()
+        )
+
+    def get_qualified_names(self):
+        return self.access_handle.get_qualified_names()
+
+    def py__bool__(self):
+        return self.access_handle.py__bool__()
+
+    def is_class(self):
+        return self.access_handle.is_class()
+
+    def is_function(self):
+        return self.access_handle.is_function()
+
+    def is_module(self):
+        return self.access_handle.is_module()
+
+    def is_compiled(self):
+        return True
+
+    def is_stub(self):
+        return False
+
+    def is_instance(self):
+        return self.access_handle.is_instance()
+
+    def py__doc__(self):
+        return self.access_handle.py__doc__()
+
+    @to_list
+    def get_param_names(self):
+        try:
+            signature_params = self.access_handle.get_signature_params()
+        except ValueError:  # Has no signature
+            params_str, ret = self._parse_function_doc()
+            if not params_str:
+                tokens = []
+            else:
+                tokens = params_str.split(',')
+            if self.access_handle.ismethoddescriptor():
+                tokens.insert(0, 'self')
+            for p in tokens:
+                name, _, default = p.strip().partition('=')
+                yield UnresolvableParamName(self, name, default)
+        else:
+            for signature_param in signature_params:
+                yield SignatureParamName(self, signature_param)
+
+    def get_signatures(self):
+        _, return_string = self._parse_function_doc()
+        return [BuiltinSignature(self, return_string)]
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.access_handle.get_repr())
+
+    @memoize_method
+    def _parse_function_doc(self):
+        doc = self.py__doc__()
+        if doc is None:
+            return '', ''
+
+        return _parse_function_doc(doc)
+
+    @property
+    def api_type(self):
+        return self.access_handle.get_api_type()
+
+    def get_filters(self, is_instance=False, origin_scope=None):
+        yield self._ensure_one_filter(is_instance)
+
+    @memoize_method
+    def _ensure_one_filter(self, is_instance):
+        return CompiledValueFilter(self.inference_state, self, is_instance)
+
+    def py__simple_getitem__(self, index):
+        with reraise_getitem_errors(IndexError, KeyError, TypeError):
+            try:
+                access = self.access_handle.py__simple_getitem__(
+                    index,
+                    safe=not self.inference_state.allow_unsafe_executions
+                )
+            except AttributeError:
+                return super().py__simple_getitem__(index)
+        if access is None:
+            return super().py__simple_getitem__(index)
+
+        return ValueSet([create_from_access_path(self.inference_state, access)])
+
+    def py__getitem__(self, index_value_set, contextualized_node):
+        all_access_paths = self.access_handle.py__getitem__all_values()
+        if all_access_paths is None:
+            # This means basically that no __getitem__ has been defined on this
+            # object.
+            return super().py__getitem__(index_value_set, contextualized_node)
+        return ValueSet(
+            create_from_access_path(self.inference_state, access)
+            for access in all_access_paths
+        )
+
+    def py__iter__(self, contextualized_node=None):
+        if not self.access_handle.has_iter():
+            yield from super().py__iter__(contextualized_node)
+
+        access_path_list = self.access_handle.py__iter__list()
+        if access_path_list is None:
+            # There is no __iter__ method on this object.
+            return
+
+        for access in access_path_list:
+            yield LazyKnownValue(create_from_access_path(self.inference_state, access))
+
+    def py__name__(self):
+        return self.access_handle.py__name__()
+
+    @property
+    def name(self):
+        name = self.py__name__()
+        if name is None:
+            name = self.access_handle.get_repr()
+        return CompiledValueName(self, name)
+
+    def _execute_function(self, params):
+        from jedi.inference import docstrings
+        from jedi.inference.compiled import builtin_from_name
+        if self.api_type != 'function':
+            return
+
+        for name in self._parse_function_doc()[1].split():
+            try:
+                # TODO wtf is this? this is exactly the same as the thing
+                # below. It uses getattr as well.
+                self.inference_state.builtins_module.access_handle.getattr_paths(name)
+            except AttributeError:
+                continue
+            else:
+                bltn_obj = builtin_from_name(self.inference_state, name)
+                yield from self.inference_state.execute(bltn_obj, params)
+        yield from docstrings.infer_return_types(self)
+
+    def get_safe_value(self, default=_sentinel):
+        try:
+            return self.access_handle.get_safe_value()
+        except ValueError:
+            if default == _sentinel:
+                raise
+            return default
+
+    def execute_operation(self, other, operator):
+        try:
+            return ValueSet([create_from_access_path(
+                self.inference_state,
+                self.access_handle.execute_operation(other.access_handle, operator)
+            )])
+        except TypeError:
+            return NO_VALUES
+
+    def execute_annotation(self):
+        if self.access_handle.get_repr() == 'None':
+            # None as an annotation doesn't need to be executed.
+            return ValueSet([self])
+
+        name, args = self.access_handle.get_annotation_name_and_args()
+        arguments = [
+            ValueSet([create_from_access_path(self.inference_state, path)])
+            for path in args
+        ]
+        if name == 'Union':
+            return ValueSet.from_sets(arg.execute_annotation() for arg in arguments)
+        elif name:
+            # While with_generics only exists on very specific objects, we
+            # should probably be fine, because we control all the typing
+            # objects.
+            return ValueSet([
+                v.with_generics(arguments)
+                for v in self.inference_state.typing_module.py__getattribute__(name)
+            ]).execute_annotation()
+        return super().execute_annotation()
+
+    def negate(self):
+        return create_from_access_path(self.inference_state, self.access_handle.negate())
+
+    def get_metaclasses(self):
+        return NO_VALUES
+
+    def _as_context(self):
+        return CompiledContext(self)
+
+    @property
+    def array_type(self):
+        return self.access_handle.get_array_type()
+
+    def get_key_values(self):
+        return [
+            create_from_access_path(self.inference_state, k)
+            for k in self.access_handle.get_key_paths()
+        ]
+
+    def get_type_hint(self, add_class_info=True):
+        if self.access_handle.get_repr() in ('None', "<class 'NoneType'>"):
+            return 'None'
+        return None
+
+
+class CompiledModule(CompiledValue):
+    file_io = None  # For modules
+
+    def _as_context(self):
+        return CompiledModuleContext(self)
+
+    def py__path__(self):
+        return self.access_handle.py__path__()
+
+    def is_package(self):
+        return self.py__path__() is not None
+
+    @property
+    def string_names(self):
+        # For modules
+        name = self.py__name__()
+        if name is None:
+            return ()
+        return tuple(name.split('.'))
+
+    def py__file__(self) -> Optional[Path]:
+        return self.access_handle.py__file__()  # type: ignore[no-any-return]
+
+
+class CompiledName(AbstractNameDefinition):
+    def __init__(self, inference_state, parent_value, name, is_descriptor):
+        self._inference_state = inference_state
+        self.parent_context = parent_value.as_context()
+        self._parent_value = parent_value
+        self.string_name = name
+        self.is_descriptor = is_descriptor
+
+    def py__doc__(self):
+        return self.infer_compiled_value().py__doc__()
+
+    def _get_qualified_names(self):
+        parent_qualified_names = self.parent_context.get_qualified_names()
+        if parent_qualified_names is None:
+            return None
+        return parent_qualified_names + (self.string_name,)
+
+    def get_defining_qualified_value(self):
+        context = self.parent_context
+        if context.is_module() or context.is_class():
+            return self.parent_context.get_value()  # Might be None
+
+        return None
+
+    def __repr__(self):
+        try:
+            name = self.parent_context.name  # __name__ is not defined all the time
+        except AttributeError:
+            name = None
+        return '<%s: (%s).%s>' % (self.__class__.__name__, name, self.string_name)
+
+    @property
+    def api_type(self):
+        if self.is_descriptor:
+            # In case of properties we want to avoid executions as much as
+            # possible. Since the api_type can be wrong for other reasons
+            # anyway, we just return instance here.
+            return "instance"
+        return self.infer_compiled_value().api_type
+
+    def infer(self):
+        return ValueSet([self.infer_compiled_value()])
+
+    @memoize_method
+    def infer_compiled_value(self):
+        return create_from_name(self._inference_state, self._parent_value, self.string_name)
+
+
+class SignatureParamName(ParamNameInterface, AbstractNameDefinition):
+    def __init__(self, compiled_value, signature_param):
+        self.parent_context = compiled_value.parent_context
+        self._signature_param = signature_param
+
+    @property
+    def string_name(self):
+        return self._signature_param.name
+
+    def to_string(self):
+        s = self._kind_string() + self.string_name
+        if self._signature_param.has_annotation:
+            s += ': ' + self._signature_param.annotation_string
+        if self._signature_param.has_default:
+            s += '=' + self._signature_param.default_string
+        return s
+
+    def get_kind(self):
+        return getattr(Parameter, self._signature_param.kind_name)
+
+    def infer(self):
+        p = self._signature_param
+        inference_state = self.parent_context.inference_state
+        values = NO_VALUES
+        if p.has_default:
+            values = ValueSet([create_from_access_path(inference_state, p.default)])
+        if p.has_annotation:
+            annotation = create_from_access_path(inference_state, p.annotation)
+            values |= annotation.execute_with_values()
+        return values
+
+
+class UnresolvableParamName(ParamNameInterface, AbstractNameDefinition):
+    def __init__(self, compiled_value, name, default):
+        self.parent_context = compiled_value.parent_context
+        self.string_name = name
+        self._default = default
+
+    def get_kind(self):
+        return Parameter.POSITIONAL_ONLY
+
+    def to_string(self):
+        string = self.string_name
+        if self._default:
+            string += '=' + self._default
+        return string
+
+    def infer(self):
+        return NO_VALUES
+
+
+class CompiledValueName(ValueNameMixin, AbstractNameDefinition):
+    def __init__(self, value, name):
+        self.string_name = name
+        self._value = value
+        self.parent_context = value.parent_context
+
+
+class EmptyCompiledName(AbstractNameDefinition):
+    """
+    Accessing some names will raise an exception. To avoid not having any
+    completions, just give Jedi the option to return this object. It infers to
+    nothing.
+    """
+    def __init__(self, inference_state, name):
+        self.parent_context = inference_state.builtins_module
+        self.string_name = name
+
+    def infer(self):
+        return NO_VALUES
+
+
+class CompiledValueFilter(AbstractFilter):
+    def __init__(self, inference_state, compiled_value, is_instance=False):
+        self._inference_state = inference_state
+        self.compiled_value = compiled_value
+        self.is_instance = is_instance
+
+    def get(self, name):
+        access_handle = self.compiled_value.access_handle
+        safe = not self._inference_state.allow_unsafe_executions
+        return self._get(
+            name,
+            lambda name: access_handle.is_allowed_getattr(name, safe=safe),
+            lambda name: name in access_handle.dir(),
+            check_has_attribute=True
+        )
+
+    def _get(self, name, allowed_getattr_callback, in_dir_callback, check_has_attribute=False):
+        """
+        To remove quite a few access calls we introduced the callback here.
+        """
+        has_attribute, is_descriptor, property_return_annotation = allowed_getattr_callback(
+            name,
+        )
+        if property_return_annotation is not None:
+            values = create_from_access_path(
+                self._inference_state,
+                property_return_annotation
+            ).execute_annotation()
+            if values:
+                return [CompiledValueName(v, name) for v in values]
+
+        if check_has_attribute and not has_attribute:
+            return []
+
+        if (is_descriptor or not has_attribute) \
+                and not self._inference_state.allow_unsafe_executions:
+            return [self._get_cached_name(name, is_empty=True)]
+
+        if self.is_instance and not in_dir_callback(name):
+            return []
+        return [self._get_cached_name(name, is_descriptor=is_descriptor)]
+
+    @memoize_method
+    def _get_cached_name(self, name, is_empty=False, *, is_descriptor=False):
+        if is_empty:
+            return EmptyCompiledName(self._inference_state, name)
+        else:
+            return self._create_name(name, is_descriptor=is_descriptor)
+
+    def values(self):
+        from jedi.inference.compiled import builtin_from_name
+        names = []
+        needs_type_completions, dir_infos = self.compiled_value.access_handle.get_dir_infos()
+        # We could use `safe=False` here as well, especially as a parameter to
+        # get_dir_infos. But this would lead to a lot of property executions
+        # that are probably not wanted. The drawback for this is that we
+        # have a different name for `get` and `values`. For `get` we always
+        # execute.
+        for name in dir_infos:
+            names += self._get(
+                name,
+                lambda name: dir_infos[name],
+                lambda name: name in dir_infos,
+            )
+
+        # ``dir`` doesn't include the type names.
+        if not self.is_instance and needs_type_completions:
+            for filter in builtin_from_name(self._inference_state, 'type').get_filters():
+                names += filter.values()
+        return names
+
+    def _create_name(self, name, is_descriptor):
+        return CompiledName(
+            self._inference_state,
+            self.compiled_value,
+            name,
+            is_descriptor,
+        )
+
+    def __repr__(self):
+        return "<%s: %s>" % (self.__class__.__name__, self.compiled_value)
+
+
+docstr_defaults = {
+    'floating point number': 'float',
+    'character': 'str',
+    'integer': 'int',
+    'dictionary': 'dict',
+    'string': 'str',
+}
+
+
+def _parse_function_doc(doc):
+    """
+    Takes a function and returns the params and return value as a tuple.
+    This is nothing more than a docstring parser.
+
+    TODO docstrings like utime(path, (atime, mtime)) and a(b [, b]) -> None
+    TODO docstrings like 'tuple of integers'
+    """
+    # parse round parentheses: def func(a, (b,c))
+    try:
+        count = 0
+        start = doc.index('(')
+        for i, s in enumerate(doc[start:]):
+            if s == '(':
+                count += 1
+            elif s == ')':
+                count -= 1
+            if count == 0:
+                end = start + i
+                break
+        param_str = doc[start + 1:end]
+    except (ValueError, UnboundLocalError):
+        # ValueError for doc.index
+        # UnboundLocalError for undefined end in last line
+        debug.dbg('no brackets found - no param')
+        end = 0
+        param_str = ''
+    else:
+        # remove square brackets, that show an optional param ( = None)
+        def change_options(m):
+            args = m.group(1).split(',')
+            for i, a in enumerate(args):
+                if a and '=' not in a:
+                    args[i] += '=None'
+            return ','.join(args)
+
+        while True:
+            param_str, changes = re.subn(r' ?\[([^\[\]]+)\]',
+                                         change_options, param_str)
+            if changes == 0:
+                break
+    param_str = param_str.replace('-', '_')  # see: isinstance.__doc__
+
+    # parse return value
+    r = re.search('-[>-]* ', doc[end:end + 7])
+    if r is None:
+        ret = ''
+    else:
+        index = end + r.end()
+        # get result type, which can contain newlines
+        pattern = re.compile(r'(,\n|[^\n-])+')
+        ret_str = pattern.match(doc, index).group(0).strip()
+        # New object -> object()
+        ret_str = re.sub(r'[nN]ew (.*)', r'\1()', ret_str)
+
+        ret = docstr_defaults.get(ret_str, ret_str)
+
+    return param_str, ret
+
+
+def create_from_name(inference_state, compiled_value, name):
+    access_paths = compiled_value.access_handle.getattr_paths(name, default=None)
+
+    value = None
+    for access_path in access_paths:
+        value = create_cached_compiled_value(
+            inference_state,
+            access_path,
+            parent_context=None if value is None else value.as_context(),
+        )
+    return value
+
+
+def _normalize_create_args(func):
+    """The cache doesn't care about keyword vs. normal args."""
+    def wrapper(inference_state, obj, parent_context=None):
+        return func(inference_state, obj, parent_context)
+    return wrapper
+
+
+def create_from_access_path(inference_state, access_path):
+    value = None
+    for name, access in access_path.accesses:
+        value = create_cached_compiled_value(
+            inference_state,
+            access,
+            parent_context=None if value is None else value.as_context()
+        )
+    return value
+
+
+@_normalize_create_args
+@inference_state_function_cache()
+def create_cached_compiled_value(inference_state, access_handle, parent_context):
+    assert not isinstance(parent_context, CompiledValue)
+    if parent_context is None:
+        cls = CompiledModule
+    else:
+        cls = CompiledValue
+    return cls(inference_state, access_handle, parent_context)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/base.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/base.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb2cbc622d173214c5a74558a7f2e58a405d81f5
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/base.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/generics.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/generics.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b51803812e971f655d478538208c1c61f1b3f763
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/generics.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/stub_value.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/stub_value.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..467527c7641f98546a91192ce6408a6759b5e5b6
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/stub_value.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/typeshed.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/typeshed.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a448cab3fa8b7a74b34a2265fe72e292130497e1
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/inference/gradual/__pycache__/typeshed.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/__init__.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..93c978876e09af6bdf666328dce8e815ec770f48
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/__init__.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_config.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_config.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d8be28ca15d76c164fe5bbfe2072f965fc9577fc
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_config.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_dask.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_dask.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..01519ee3f45d4f85316275fcf3aa166f996dc62c
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_dask.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_disk.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_disk.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7fc6bc846e817d87f82b998f1583c0bd3b3a2573
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_disk.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_func_inspect_special_encoding.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_func_inspect_special_encoding.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f647fea753514e42dfeb87e2d4cbfc59fa67f41
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_func_inspect_special_encoding.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_hashing.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_hashing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4dd96c96e0bd00b3c95e9e97fb42399697f8515c
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_hashing.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_init.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_init.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ce5bdeb0e1d9986eb0f5660adb1f30db34181d2
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_init.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_logger.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_logger.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..02841b0cfb80d92888e7a0cb1371e5ee14790d53
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_logger.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_memmapping.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_memmapping.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f7d8ce2d981f7c2eae6e7bd1ecb1c3226bbb557a
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_memmapping.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_memory_async.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_memory_async.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8ab86e641a8880ef5cfb768375e24d5cc712a0b1
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_memory_async.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_module.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_module.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..342fdd5ed48b5087d5da385314be71e31e6f94fc
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_module.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_numpy_pickle_compat.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_numpy_pickle_compat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36b8bcb6773bfb6828ef9efb3a0bb065fe0ae3e8
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_numpy_pickle_compat.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_numpy_pickle_utils.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_numpy_pickle_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..929d12240f0255672a0b4254c04a2f1b7a1d22a4
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_numpy_pickle_utils.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_parallel.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_parallel.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a880a84ece76a53a476384272185f6c4e1fe5d5d
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_parallel.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_store_backends.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_store_backends.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..71cf03e7f8d43c990d504601971d9a6afabe7bc7
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_store_backends.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_utils.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..932d5eb9f884b37b6e0432e006c3e0e7ea9812a3
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/test_utils.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/testutils.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/testutils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c8bc96a52dc3e7aa769a85b5f6a652e4d59f636
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/__pycache__/testutils.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py34_np19.pkl.gzip b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py34_np19.pkl.gzip
new file mode 100644
index 0000000000000000000000000000000000000000..02b16b8ebaa36c61da9c0c4cba6ceae88049cb43
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py34_np19.pkl.gzip differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py34_np19.pkl.lzma b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py34_np19.pkl.lzma
new file mode 100644
index 0000000000000000000000000000000000000000..add975b005d9c6fdab5c24c369edb0c7c4cf397c
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py34_np19.pkl.lzma differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.4.dev0_compressed_cache_size_pickle_py35_np19.gz_03.npy.z b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.4.dev0_compressed_cache_size_pickle_py35_np19.gz_03.npy.z
new file mode 100644
index 0000000000000000000000000000000000000000..669602e0a880d308cbea22eed2fda74cea225a9f
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.4.dev0_compressed_cache_size_pickle_py35_np19.gz_03.npy.z differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_backports.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_backports.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f5a3bd42353bf5a3d77243b9c607a3ec2b8cb1d
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_backports.py
@@ -0,0 +1,35 @@
+import mmap
+
+from joblib.backports import make_memmap, concurrency_safe_rename
+from joblib.test.common import with_numpy
+from joblib.testing import parametrize
+from joblib import Parallel, delayed
+
+
+@with_numpy
+def test_memmap(tmpdir):
+    fname = tmpdir.join('test.mmap').strpath
+    size = 5 * mmap.ALLOCATIONGRANULARITY
+    offset = mmap.ALLOCATIONGRANULARITY + 1
+    memmap_obj = make_memmap(fname, shape=size, mode='w+', offset=offset)
+    assert memmap_obj.offset == offset
+
+
+@parametrize('dst_content', [None, 'dst content'])
+@parametrize('backend', [None, 'threading'])
+def test_concurrency_safe_rename(tmpdir, dst_content, backend):
+    src_paths = [tmpdir.join('src_%d' % i) for i in range(4)]
+    for src_path in src_paths:
+        src_path.write('src content')
+    dst_path = tmpdir.join('dst')
+    if dst_content is not None:
+        dst_path.write(dst_content)
+
+    Parallel(n_jobs=4, backend=backend)(
+        delayed(concurrency_safe_rename)(src_path.strpath, dst_path.strpath)
+        for src_path in src_paths
+    )
+    assert dst_path.exists()
+    assert dst_path.read() == 'src content'
+    for src_path in src_paths:
+        assert not src_path.exists()
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_config.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..56eeed31b0db103360771c52cae641d00edb1c3a
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_config.py
@@ -0,0 +1,151 @@
+import os
+
+from joblib.parallel import parallel_config
+from joblib.parallel import parallel_backend
+from joblib.parallel import Parallel, delayed
+
+from joblib.parallel import BACKENDS
+from joblib.parallel import DEFAULT_BACKEND
+from joblib.parallel import EXTERNAL_BACKENDS
+
+from joblib._parallel_backends import LokyBackend
+from joblib._parallel_backends import ThreadingBackend
+from joblib._parallel_backends import MultiprocessingBackend
+
+from joblib.testing import parametrize, raises
+from joblib.test.common import np, with_numpy
+from joblib.test.common import with_multiprocessing
+from joblib.test.test_parallel import check_memmap
+
+
+@parametrize("context", [parallel_config, parallel_backend])
+def test_global_parallel_backend(context):
+    default = Parallel()._backend
+
+    pb = context('threading')
+    try:
+        assert isinstance(Parallel()._backend, ThreadingBackend)
+    finally:
+        pb.unregister()
+    assert type(Parallel()._backend) is type(default)
+
+
+@parametrize("context", [parallel_config, parallel_backend])
+def test_external_backends(context):
+    def register_foo():
+        BACKENDS['foo'] = ThreadingBackend
+
+    EXTERNAL_BACKENDS['foo'] = register_foo
+    try:
+        with context('foo'):
+            assert isinstance(Parallel()._backend, ThreadingBackend)
+    finally:
+        del EXTERNAL_BACKENDS['foo']
+
+
+@with_numpy
+@with_multiprocessing
+def test_parallel_config_no_backend(tmpdir):
+    # Check that parallel_config allows to change the config
+    # even if no backend is set.
+    with parallel_config(n_jobs=2, max_nbytes=1, temp_folder=tmpdir):
+        with Parallel(prefer="processes") as p:
+            assert isinstance(p._backend, LokyBackend)
+            assert p.n_jobs == 2
+
+            # Checks that memmapping is enabled
+            p(delayed(check_memmap)(a) for a in [np.random.random(10)] * 2)
+            assert len(os.listdir(tmpdir)) > 0
+
+
+@with_numpy
+@with_multiprocessing
+def test_parallel_config_params_explicit_set(tmpdir):
+    with parallel_config(n_jobs=3, max_nbytes=1, temp_folder=tmpdir):
+        with Parallel(n_jobs=2, prefer="processes", max_nbytes='1M') as p:
+            assert isinstance(p._backend, LokyBackend)
+            assert p.n_jobs == 2
+
+            # Checks that memmapping is disabled
+            with raises(TypeError, match="Expected np.memmap instance"):
+                p(delayed(check_memmap)(a) for a in [np.random.random(10)] * 2)
+
+
+@parametrize("param", ["prefer", "require"])
+def test_parallel_config_bad_params(param):
+    # Check that an error is raised when setting a wrong backend
+    # hint or constraint
+    with raises(ValueError, match=f"{param}=wrong is not a valid"):
+        with parallel_config(**{param: "wrong"}):
+            Parallel()
+
+
+def test_parallel_config_constructor_params():
+    # Check that an error is raised when backend is None
+    # but backend constructor params are given
+    with raises(ValueError, match="only supported when backend is not None"):
+        with parallel_config(inner_max_num_threads=1):
+            pass
+
+    with raises(ValueError, match="only supported when backend is not None"):
+        with parallel_config(backend_param=1):
+            pass
+
+
+def test_parallel_config_nested():
+    # Check that nested configuration retrieves the info from the
+    # parent config and do not reset them.
+
+    with parallel_config(n_jobs=2):
+        p = Parallel()
+        assert isinstance(p._backend, BACKENDS[DEFAULT_BACKEND])
+        assert p.n_jobs == 2
+
+    with parallel_config(backend='threading'):
+        with parallel_config(n_jobs=2):
+            p = Parallel()
+            assert isinstance(p._backend, ThreadingBackend)
+            assert p.n_jobs == 2
+
+    with parallel_config(verbose=100):
+        with parallel_config(n_jobs=2):
+            p = Parallel()
+            assert p.verbose == 100
+            assert p.n_jobs == 2
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize('backend', ['multiprocessing', 'threading',
+                         MultiprocessingBackend(), ThreadingBackend()])
+@parametrize("context", [parallel_config, parallel_backend])
+def test_threadpool_limitation_in_child_context_error(context, backend):
+
+    with raises(AssertionError, match=r"does not acc.*inner_max_num_threads"):
+        context(backend, inner_max_num_threads=1)
+
+
+@parametrize("context", [parallel_config, parallel_backend])
+def test_parallel_n_jobs_none(context):
+    # Check that n_jobs=None is interpreted as "unset" in Parallel
+    # non regression test for #1473
+    with context(backend="threading", n_jobs=2):
+        with Parallel(n_jobs=None) as p:
+            assert p.n_jobs == 2
+
+    with context(backend="threading"):
+        default_n_jobs = Parallel().n_jobs
+        with Parallel(n_jobs=None) as p:
+            assert p.n_jobs == default_n_jobs
+
+
+@parametrize("context", [parallel_config, parallel_backend])
+def test_parallel_config_n_jobs_none(context):
+    # Check that n_jobs=None is interpreted as "explicitly set" in
+    # parallel_(config/backend)
+    # non regression test for #1473
+    with context(backend="threading", n_jobs=2):
+        with context(backend="threading", n_jobs=None):
+            # n_jobs=None resets n_jobs to backend's default
+            with Parallel() as p:
+                assert p.n_jobs == 1
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_dask.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_dask.py
new file mode 100644
index 0000000000000000000000000000000000000000..aebe65525fc55f4593e6c83b5bfd4ffc76d945a7
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_dask.py
@@ -0,0 +1,499 @@
+from __future__ import print_function, division, absolute_import
+import os
+import warnings
+
+import pytest
+from random import random
+from uuid import uuid4
+from time import sleep
+
+from .. import Parallel, delayed, parallel_config
+from ..parallel import ThreadingBackend, AutoBatchingMixin
+from .._dask import DaskDistributedBackend
+
+distributed = pytest.importorskip('distributed')
+dask = pytest.importorskip('dask')
+
+# These imports need to be after the pytest.importorskip hence the noqa: E402
+from distributed import Client, LocalCluster, get_client  # noqa: E402
+from distributed.metrics import time  # noqa: E402
+# Note: pytest requires to manually import all fixtures used in the test
+# and their dependencies.
+from distributed.utils_test import cluster, inc, cleanup  # noqa: E402, F401
+
+
+def noop(*args, **kwargs):
+    pass
+
+
+def slow_raise_value_error(condition, duration=0.05):
+    sleep(duration)
+    if condition:
+        raise ValueError("condition evaluated to True")
+
+
+def count_events(event_name, client):
+    worker_events = client.run(lambda dask_worker: dask_worker.log)
+    event_counts = {}
+    for w, events in worker_events.items():
+        event_counts[w] = len([event for event in list(events)
+                               if event[1] == event_name])
+    return event_counts
+
+
+def test_simple(loop):
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop) as client:  # noqa: F841
+            with parallel_config(backend='dask'):
+                seq = Parallel()(delayed(inc)(i) for i in range(10))
+                assert seq == [inc(i) for i in range(10)]
+
+                with pytest.raises(ValueError):
+                    Parallel()(delayed(slow_raise_value_error)(i == 3)
+                               for i in range(10))
+
+                seq = Parallel()(delayed(inc)(i) for i in range(10))
+                assert seq == [inc(i) for i in range(10)]
+
+
+def test_dask_backend_uses_autobatching(loop):
+    assert (DaskDistributedBackend.compute_batch_size
+            is AutoBatchingMixin.compute_batch_size)
+
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop) as client:  # noqa: F841
+            with parallel_config(backend='dask'):
+                with Parallel() as parallel:
+                    # The backend should be initialized with a default
+                    # batch size of 1:
+                    backend = parallel._backend
+                    assert isinstance(backend, DaskDistributedBackend)
+                    assert backend.parallel is parallel
+                    assert backend._effective_batch_size == 1
+
+                    # Launch many short tasks that should trigger
+                    # auto-batching:
+                    parallel(
+                        delayed(lambda: None)()
+                        for _ in range(int(1e4))
+                    )
+                    assert backend._effective_batch_size > 10
+
+
+def random2():
+    return random()
+
+
+def test_dont_assume_function_purity(loop):
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop) as client:  # noqa: F841
+            with parallel_config(backend='dask'):
+                x, y = Parallel()(delayed(random2)() for i in range(2))
+                assert x != y
+
+
+@pytest.mark.parametrize("mixed", [True, False])
+def test_dask_funcname(loop, mixed):
+    from joblib._dask import Batch
+    if not mixed:
+        tasks = [delayed(inc)(i) for i in range(4)]
+        batch_repr = 'batch_of_inc_4_calls'
+    else:
+        tasks = [
+            delayed(abs)(i) if i % 2 else delayed(inc)(i) for i in range(4)
+        ]
+        batch_repr = 'mixed_batch_of_inc_4_calls'
+
+    assert repr(Batch(tasks)) == batch_repr
+
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop) as client:
+            with parallel_config(backend='dask'):
+                _ = Parallel(batch_size=2, pre_dispatch='all')(tasks)
+
+            def f(dask_scheduler):
+                return list(dask_scheduler.transition_log)
+            batch_repr = batch_repr.replace('4', '2')
+            log = client.run_on_scheduler(f)
+            assert all('batch_of_inc' in tup[0] for tup in log)
+
+
+def test_no_undesired_distributed_cache_hit():
+    # Dask has a pickle cache for callables that are called many times. Because
+    # the dask backends used to wrap both the functions and the arguments
+    # under instances of the Batch callable class this caching mechanism could
+    # lead to bugs as described in: https://github.com/joblib/joblib/pull/1055
+    # The joblib-dask backend has been refactored to avoid bundling the
+    # arguments as an attribute of the Batch instance to avoid this problem.
+    # This test serves as non-regression problem.
+
+    # Use a large number of input arguments to give the AutoBatchingMixin
+    # enough tasks to kick-in.
+    lists = [[] for _ in range(100)]
+    np = pytest.importorskip('numpy')
+    X = np.arange(int(1e6))
+
+    def isolated_operation(list_, data=None):
+        if data is not None:
+            np.testing.assert_array_equal(data, X)
+        list_.append(uuid4().hex)
+        return list_
+
+    cluster = LocalCluster(n_workers=1, threads_per_worker=2)
+    client = Client(cluster)
+    try:
+        with parallel_config(backend='dask'):
+            # dispatches joblib.parallel.BatchedCalls
+            res = Parallel()(
+                delayed(isolated_operation)(list_) for list_ in lists
+            )
+
+        # The original arguments should not have been mutated as the mutation
+        # happens in the dask worker process.
+        assert lists == [[] for _ in range(100)]
+
+        # Here we did not pass any large numpy array as argument to
+        # isolated_operation so no scattering event should happen under the
+        # hood.
+        counts = count_events('receive-from-scatter', client)
+        assert sum(counts.values()) == 0
+        assert all([len(r) == 1 for r in res])
+
+        with parallel_config(backend='dask'):
+            # Append a large array which will be scattered by dask, and
+            # dispatch joblib._dask.Batch
+            res = Parallel()(
+                delayed(isolated_operation)(list_, data=X) for list_ in lists
+            )
+
+        # This time, auto-scattering should have kicked it.
+        counts = count_events('receive-from-scatter', client)
+        assert sum(counts.values()) > 0
+        assert all([len(r) == 1 for r in res])
+    finally:
+        client.close(timeout=30)
+        cluster.close(timeout=30)
+
+
+class CountSerialized(object):
+    def __init__(self, x):
+        self.x = x
+        self.count = 0
+
+    def __add__(self, other):
+        return self.x + getattr(other, 'x', other)
+
+    __radd__ = __add__
+
+    def __reduce__(self):
+        self.count += 1
+        return (CountSerialized, (self.x,))
+
+
+def add5(a, b, c, d=0, e=0):
+    return a + b + c + d + e
+
+
+def test_manual_scatter(loop):
+    x = CountSerialized(1)
+    y = CountSerialized(2)
+    z = CountSerialized(3)
+
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop) as client:  # noqa: F841
+            with parallel_config(backend='dask', scatter=[x, y]):
+                f = delayed(add5)
+                tasks = [f(x, y, z, d=4, e=5),
+                         f(x, z, y, d=5, e=4),
+                         f(y, x, z, d=x, e=5),
+                         f(z, z, x, d=z, e=y)]
+                expected = [func(*args, **kwargs)
+                            for func, args, kwargs in tasks]
+                results = Parallel()(tasks)
+
+            # Scatter must take a list/tuple
+            with pytest.raises(TypeError):
+                with parallel_config(backend='dask', loop=loop, scatter=1):
+                    pass
+
+    assert results == expected
+
+    # Scattered variables only serialized once
+    assert x.count == 1
+    assert y.count == 1
+    # Depending on the version of distributed, the unscattered z variable
+    # is either pickled 4 or 6 times, possibly because of the memoization
+    # of objects that appear several times in the arguments of a delayed
+    # task.
+    assert z.count in (4, 6)
+
+
+# When the same IOLoop is used for multiple clients in a row, use
+# loop_in_thread instead of loop to prevent the Client from closing it.  See
+# dask/distributed #4112
+def test_auto_scatter(loop_in_thread):
+    np = pytest.importorskip('numpy')
+    data1 = np.ones(int(1e4), dtype=np.uint8)
+    data2 = np.ones(int(1e4), dtype=np.uint8)
+    data_to_process = ([data1] * 3) + ([data2] * 3)
+
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop_in_thread) as client:
+            with parallel_config(backend='dask'):
+                # Passing the same data as arg and kwarg triggers a single
+                # scatter operation whose result is reused.
+                Parallel()(delayed(noop)(data, data, i, opt=data)
+                           for i, data in enumerate(data_to_process))
+            # By default large array are automatically scattered with
+            # broadcast=1 which means that one worker must directly receive
+            # the data from the scatter operation once.
+            counts = count_events('receive-from-scatter', client)
+            assert counts[a['address']] + counts[b['address']] == 2
+
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop_in_thread) as client:
+            with parallel_config(backend='dask'):
+                Parallel()(delayed(noop)(data1[:3], i) for i in range(5))
+            # Small arrays are passed within the task definition without going
+            # through a scatter operation.
+            counts = count_events('receive-from-scatter', client)
+            assert counts[a['address']] == 0
+            assert counts[b['address']] == 0
+
+
+@pytest.mark.parametrize("retry_no", list(range(2)))
+def test_nested_scatter(loop, retry_no):
+
+    np = pytest.importorskip('numpy')
+
+    NUM_INNER_TASKS = 10
+    NUM_OUTER_TASKS = 10
+
+    def my_sum(x, i, j):
+        return np.sum(x)
+
+    def outer_function_joblib(array, i):
+        client = get_client()  # noqa
+        with parallel_config(backend="dask"):
+            results = Parallel()(
+                delayed(my_sum)(array[j:], i, j) for j in range(
+                    NUM_INNER_TASKS)
+            )
+        return sum(results)
+
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop) as _:
+            with parallel_config(backend="dask"):
+                my_array = np.ones(10000)
+                _ = Parallel()(
+                    delayed(outer_function_joblib)(
+                        my_array[i:], i) for i in range(NUM_OUTER_TASKS)
+                )
+
+
+def test_nested_backend_context_manager(loop_in_thread):
+    def get_nested_pids():
+        pids = set(Parallel(n_jobs=2)(delayed(os.getpid)() for _ in range(2)))
+        pids |= set(Parallel(n_jobs=2)(delayed(os.getpid)() for _ in range(2)))
+        return pids
+
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop_in_thread) as client:
+            with parallel_config(backend='dask'):
+                pid_groups = Parallel(n_jobs=2)(
+                    delayed(get_nested_pids)()
+                    for _ in range(10)
+                )
+                for pid_group in pid_groups:
+                    assert len(set(pid_group)) <= 2
+
+        # No deadlocks
+        with Client(s['address'], loop=loop_in_thread) as client:  # noqa: F841
+            with parallel_config(backend='dask'):
+                pid_groups = Parallel(n_jobs=2)(
+                    delayed(get_nested_pids)()
+                    for _ in range(10)
+                )
+                for pid_group in pid_groups:
+                    assert len(set(pid_group)) <= 2
+
+
+def test_nested_backend_context_manager_implicit_n_jobs(loop):
+    # Check that Parallel with no explicit n_jobs value automatically selects
+    # all the dask workers, including in nested calls.
+
+    def _backend_type(p):
+        return p._backend.__class__.__name__
+
+    def get_nested_implicit_n_jobs():
+        with Parallel() as p:
+            return _backend_type(p), p.n_jobs
+
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop) as client:  # noqa: F841
+            with parallel_config(backend='dask'):
+                with Parallel() as p:
+                    assert _backend_type(p) == "DaskDistributedBackend"
+                    assert p.n_jobs == -1
+                    all_nested_n_jobs = p(
+                        delayed(get_nested_implicit_n_jobs)()
+                        for _ in range(2)
+                    )
+                for backend_type, nested_n_jobs in all_nested_n_jobs:
+                    assert backend_type == "DaskDistributedBackend"
+                    assert nested_n_jobs == -1
+
+
+def test_errors(loop):
+    with pytest.raises(ValueError) as info:
+        with parallel_config(backend='dask'):
+            pass
+
+    assert "create a dask client" in str(info.value).lower()
+
+
+def test_correct_nested_backend(loop):
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop) as client:  # noqa: F841
+            # No requirement, should be us
+            with parallel_config(backend='dask'):
+                result = Parallel(n_jobs=2)(
+                    delayed(outer)(nested_require=None) for _ in range(1))
+                assert isinstance(result[0][0][0], DaskDistributedBackend)
+
+            # Require threads, should be threading
+            with parallel_config(backend='dask'):
+                result = Parallel(n_jobs=2)(
+                    delayed(outer)(nested_require='sharedmem')
+                    for _ in range(1))
+                assert isinstance(result[0][0][0], ThreadingBackend)
+
+
+def outer(nested_require):
+    return Parallel(n_jobs=2, prefer='threads')(
+        delayed(middle)(nested_require) for _ in range(1)
+    )
+
+
+def middle(require):
+    return Parallel(n_jobs=2, require=require)(
+        delayed(inner)() for _ in range(1)
+    )
+
+
+def inner():
+    return Parallel()._backend
+
+
+def test_secede_with_no_processes(loop):
+    # https://github.com/dask/distributed/issues/1775
+    with Client(loop=loop, processes=False, set_as_default=True):
+        with parallel_config(backend='dask'):
+            Parallel(n_jobs=4)(delayed(id)(i) for i in range(2))
+
+
+def _worker_address(_):
+    from distributed import get_worker
+    return get_worker().address
+
+
+def test_dask_backend_keywords(loop):
+    with cluster() as (s, [a, b]):
+        with Client(s['address'], loop=loop) as client:  # noqa: F841
+            with parallel_config(backend='dask', workers=a['address']):
+                seq = Parallel()(
+                    delayed(_worker_address)(i) for i in range(10))
+                assert seq == [a['address']] * 10
+
+            with parallel_config(backend='dask', workers=b['address']):
+                seq = Parallel()(
+                    delayed(_worker_address)(i) for i in range(10))
+                assert seq == [b['address']] * 10
+
+
+def test_scheduler_tasks_cleanup(loop):
+    with Client(processes=False, loop=loop) as client:
+        with parallel_config(backend='dask'):
+            Parallel()(delayed(inc)(i) for i in range(10))
+
+        start = time()
+        while client.cluster.scheduler.tasks:
+            sleep(0.01)
+            assert time() < start + 5
+
+        assert not client.futures
+
+
+@pytest.mark.parametrize("cluster_strategy", ["adaptive", "late_scaling"])
+@pytest.mark.skipif(
+    distributed.__version__ <= '2.1.1' and distributed.__version__ >= '1.28.0',
+    reason="distributed bug - https://github.com/dask/distributed/pull/2841")
+def test_wait_for_workers(cluster_strategy):
+    cluster = LocalCluster(n_workers=0, processes=False, threads_per_worker=2)
+    client = Client(cluster)
+    if cluster_strategy == "adaptive":
+        cluster.adapt(minimum=0, maximum=2)
+    elif cluster_strategy == "late_scaling":
+        # Tell the cluster to start workers but this is a non-blocking call
+        # and new workers might take time to connect. In this case the Parallel
+        # call should wait for at least one worker to come up before starting
+        # to schedule work.
+        cluster.scale(2)
+    try:
+        with parallel_config(backend='dask'):
+            # The following should wait a bit for at least one worker to
+            # become available.
+            Parallel()(delayed(inc)(i) for i in range(10))
+    finally:
+        client.close()
+        cluster.close()
+
+
+def test_wait_for_workers_timeout():
+    # Start a cluster with 0 worker:
+    cluster = LocalCluster(n_workers=0, processes=False, threads_per_worker=2)
+    client = Client(cluster)
+    try:
+        with parallel_config(backend='dask', wait_for_workers_timeout=0.1):
+            # Short timeout: DaskDistributedBackend
+            msg = "DaskDistributedBackend has no worker after 0.1 seconds."
+            with pytest.raises(TimeoutError, match=msg):
+                Parallel()(delayed(inc)(i) for i in range(10))
+
+        with parallel_config(backend='dask', wait_for_workers_timeout=0):
+            # No timeout: fallback to generic joblib failure:
+            msg = "DaskDistributedBackend has no active worker"
+            with pytest.raises(RuntimeError, match=msg):
+                Parallel()(delayed(inc)(i) for i in range(10))
+    finally:
+        client.close()
+        cluster.close()
+
+
+@pytest.mark.parametrize("backend", ["loky", "multiprocessing"])
+def test_joblib_warning_inside_dask_daemonic_worker(backend):
+    cluster = LocalCluster(n_workers=2)
+    client = Client(cluster)
+    try:
+
+        def func_using_joblib_parallel():
+            # Somehow trying to check the warning type here (e.g. with
+            # pytest.warns(UserWarning)) make the test hang. Work-around:
+            # return the warning record to the client and the warning check is
+            # done client-side.
+            with warnings.catch_warnings(record=True) as record:
+                Parallel(n_jobs=2, backend=backend)(
+                    delayed(inc)(i) for i in range(10))
+
+            return record
+
+        fut = client.submit(func_using_joblib_parallel)
+        record = fut.result()
+
+        assert len(record) == 1
+        warning = record[0].message
+        assert isinstance(warning, UserWarning)
+        assert "distributed.worker.daemon" in str(warning)
+    finally:
+        client.close(timeout=30)
+        cluster.close(timeout=30)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_hashing.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_hashing.py
new file mode 100644
index 0000000000000000000000000000000000000000..85593d297f6e2387c58cad8d5bceba4d21b1c0aa
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_hashing.py
@@ -0,0 +1,495 @@
+"""
+Test the hashing module.
+"""
+
+# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
+# Copyright (c) 2009 Gael Varoquaux
+# License: BSD Style, 3 clauses.
+
+import time
+import hashlib
+import sys
+import gc
+import io
+import collections
+import itertools
+import pickle
+import random
+from concurrent.futures import ProcessPoolExecutor
+from decimal import Decimal
+
+from joblib.hashing import hash
+from joblib.func_inspect import filter_args
+from joblib.memory import Memory
+from joblib.testing import raises, skipif, fixture, parametrize
+from joblib.test.common import np, with_numpy
+
+
+def unicode(s):
+    return s
+
+
+###############################################################################
+# Helper functions for the tests
+def time_func(func, *args):
+    """ Time function func on *args.
+    """
+    times = list()
+    for _ in range(3):
+        t1 = time.time()
+        func(*args)
+        times.append(time.time() - t1)
+    return min(times)
+
+
+def relative_time(func1, func2, *args):
+    """ Return the relative time between func1 and func2 applied on
+        *args.
+    """
+    time_func1 = time_func(func1, *args)
+    time_func2 = time_func(func2, *args)
+    relative_diff = 0.5 * (abs(time_func1 - time_func2)
+                           / (time_func1 + time_func2))
+    return relative_diff
+
+
+class Klass(object):
+
+    def f(self, x):
+        return x
+
+
+class KlassWithCachedMethod(object):
+
+    def __init__(self, cachedir):
+        mem = Memory(location=cachedir)
+        self.f = mem.cache(self.f)
+
+    def f(self, x):
+        return x
+
+
+###############################################################################
+# Tests
+
+input_list = [1, 2, 1., 2., 1 + 1j, 2. + 1j,
+              'a', 'b',
+              (1,), (1, 1,), [1, ], [1, 1, ],
+              {1: 1}, {1: 2}, {2: 1},
+              None,
+              gc.collect,
+              [1, ].append,
+              # Next 2 sets have unorderable elements in python 3.
+              set(('a', 1)),
+              set(('a', 1, ('a', 1))),
+              # Next 2 dicts have unorderable type of keys in python 3.
+              {'a': 1, 1: 2},
+              {'a': 1, 1: 2, 'd': {'a': 1}}]
+
+
+@parametrize('obj1', input_list)
+@parametrize('obj2', input_list)
+def test_trivial_hash(obj1, obj2):
+    """Smoke test hash on various types."""
+    # Check that 2 objects have the same hash only if they are the same.
+    are_hashes_equal = hash(obj1) == hash(obj2)
+    are_objs_identical = obj1 is obj2
+    assert are_hashes_equal == are_objs_identical
+
+
+def test_hash_methods():
+    # Check that hashing instance methods works
+    a = io.StringIO(unicode('a'))
+    assert hash(a.flush) == hash(a.flush)
+    a1 = collections.deque(range(10))
+    a2 = collections.deque(range(9))
+    assert hash(a1.extend) != hash(a2.extend)
+
+
+@fixture(scope='function')
+@with_numpy
+def three_np_arrays():
+    rnd = np.random.RandomState(0)
+    arr1 = rnd.random_sample((10, 10))
+    arr2 = arr1.copy()
+    arr3 = arr2.copy()
+    arr3[0] += 1
+    return arr1, arr2, arr3
+
+
+def test_hash_numpy_arrays(three_np_arrays):
+    arr1, arr2, arr3 = three_np_arrays
+
+    for obj1, obj2 in itertools.product(three_np_arrays, repeat=2):
+        are_hashes_equal = hash(obj1) == hash(obj2)
+        are_arrays_equal = np.all(obj1 == obj2)
+        assert are_hashes_equal == are_arrays_equal
+
+    assert hash(arr1) != hash(arr1.T)
+
+
+def test_hash_numpy_dict_of_arrays(three_np_arrays):
+    arr1, arr2, arr3 = three_np_arrays
+
+    d1 = {1: arr1, 2: arr2}
+    d2 = {1: arr2, 2: arr1}
+    d3 = {1: arr2, 2: arr3}
+
+    assert hash(d1) == hash(d2)
+    assert hash(d1) != hash(d3)
+
+
+@with_numpy
+@parametrize('dtype', ['datetime64[s]', 'timedelta64[D]'])
+def test_numpy_datetime_array(dtype):
+    # memoryview is not supported for some dtypes e.g. datetime64
+    # see https://github.com/joblib/joblib/issues/188 for more details
+    a_hash = hash(np.arange(10))
+    array = np.arange(0, 10, dtype=dtype)
+    assert hash(array) != a_hash
+
+
+@with_numpy
+def test_hash_numpy_noncontiguous():
+    a = np.asarray(np.arange(6000).reshape((1000, 2, 3)),
+                   order='F')[:, :1, :]
+    b = np.ascontiguousarray(a)
+    assert hash(a) != hash(b)
+
+    c = np.asfortranarray(a)
+    assert hash(a) != hash(c)
+
+
+@with_numpy
+@parametrize('coerce_mmap', [True, False])
+def test_hash_memmap(tmpdir, coerce_mmap):
+    """Check that memmap and arrays hash identically if coerce_mmap is True."""
+    filename = tmpdir.join('memmap_temp').strpath
+    try:
+        m = np.memmap(filename, shape=(10, 10), mode='w+')
+        a = np.asarray(m)
+        are_hashes_equal = (hash(a, coerce_mmap=coerce_mmap) ==
+                            hash(m, coerce_mmap=coerce_mmap))
+        assert are_hashes_equal == coerce_mmap
+    finally:
+        if 'm' in locals():
+            del m
+            # Force a garbage-collection cycle, to be certain that the
+            # object is delete, and we don't run in a problem under
+            # Windows with a file handle still open.
+            gc.collect()
+
+
+@with_numpy
+@skipif(sys.platform == 'win32', reason='This test is not stable under windows'
+                                        ' for some reason')
+def test_hash_numpy_performance():
+    """ Check the performance of hashing numpy arrays:
+
+        In [22]: a = np.random.random(1000000)
+
+        In [23]: %timeit hashlib.md5(a).hexdigest()
+        100 loops, best of 3: 20.7 ms per loop
+
+        In [24]: %timeit hashlib.md5(pickle.dumps(a, protocol=2)).hexdigest()
+        1 loops, best of 3: 73.1 ms per loop
+
+        In [25]: %timeit hashlib.md5(cPickle.dumps(a, protocol=2)).hexdigest()
+        10 loops, best of 3: 53.9 ms per loop
+
+        In [26]: %timeit hash(a)
+        100 loops, best of 3: 20.8 ms per loop
+    """
+    rnd = np.random.RandomState(0)
+    a = rnd.random_sample(1000000)
+
+    def md5_hash(x):
+        return hashlib.md5(memoryview(x)).hexdigest()
+
+    relative_diff = relative_time(md5_hash, hash, a)
+    assert relative_diff < 0.3
+
+    # Check that hashing an tuple of 3 arrays takes approximately
+    # 3 times as much as hashing one array
+    time_hashlib = 3 * time_func(md5_hash, a)
+    time_hash = time_func(hash, (a, a, a))
+    relative_diff = 0.5 * (abs(time_hash - time_hashlib)
+                           / (time_hash + time_hashlib))
+    assert relative_diff < 0.3
+
+
+def test_bound_methods_hash():
+    """ Make sure that calling the same method on two different instances
+    of the same class does resolve to the same hashes.
+    """
+    a = Klass()
+    b = Klass()
+    assert (hash(filter_args(a.f, [], (1, ))) ==
+            hash(filter_args(b.f, [], (1, ))))
+
+
+def test_bound_cached_methods_hash(tmpdir):
+    """ Make sure that calling the same _cached_ method on two different
+    instances of the same class does resolve to the same hashes.
+    """
+    a = KlassWithCachedMethod(tmpdir.strpath)
+    b = KlassWithCachedMethod(tmpdir.strpath)
+    assert (hash(filter_args(a.f.func, [], (1, ))) ==
+            hash(filter_args(b.f.func, [], (1, ))))
+
+
+@with_numpy
+def test_hash_object_dtype():
+    """ Make sure that ndarrays with dtype `object' hash correctly."""
+
+    a = np.array([np.arange(i) for i in range(6)], dtype=object)
+    b = np.array([np.arange(i) for i in range(6)], dtype=object)
+
+    assert hash(a) == hash(b)
+
+
+@with_numpy
+def test_numpy_scalar():
+    # Numpy scalars are built from compiled functions, and lead to
+    # strange pickling paths explored, that can give hash collisions
+    a = np.float64(2.0)
+    b = np.float64(3.0)
+    assert hash(a) != hash(b)
+
+
+def test_dict_hash(tmpdir):
+    # Check that dictionaries hash consistently, even though the ordering
+    # of the keys is not guaranteed
+    k = KlassWithCachedMethod(tmpdir.strpath)
+
+    d = {'#s12069__c_maps.nii.gz': [33],
+         '#s12158__c_maps.nii.gz': [33],
+         '#s12258__c_maps.nii.gz': [33],
+         '#s12277__c_maps.nii.gz': [33],
+         '#s12300__c_maps.nii.gz': [33],
+         '#s12401__c_maps.nii.gz': [33],
+         '#s12430__c_maps.nii.gz': [33],
+         '#s13817__c_maps.nii.gz': [33],
+         '#s13903__c_maps.nii.gz': [33],
+         '#s13916__c_maps.nii.gz': [33],
+         '#s13981__c_maps.nii.gz': [33],
+         '#s13982__c_maps.nii.gz': [33],
+         '#s13983__c_maps.nii.gz': [33]}
+
+    a = k.f(d)
+    b = k.f(a)
+
+    assert hash(a) == hash(b)
+
+
+def test_set_hash(tmpdir):
+    # Check that sets hash consistently, even though their ordering
+    # is not guaranteed
+    k = KlassWithCachedMethod(tmpdir.strpath)
+
+    s = set(['#s12069__c_maps.nii.gz',
+             '#s12158__c_maps.nii.gz',
+             '#s12258__c_maps.nii.gz',
+             '#s12277__c_maps.nii.gz',
+             '#s12300__c_maps.nii.gz',
+             '#s12401__c_maps.nii.gz',
+             '#s12430__c_maps.nii.gz',
+             '#s13817__c_maps.nii.gz',
+             '#s13903__c_maps.nii.gz',
+             '#s13916__c_maps.nii.gz',
+             '#s13981__c_maps.nii.gz',
+             '#s13982__c_maps.nii.gz',
+             '#s13983__c_maps.nii.gz'])
+
+    a = k.f(s)
+    b = k.f(a)
+
+    assert hash(a) == hash(b)
+
+
+def test_set_decimal_hash():
+    # Check that sets containing decimals hash consistently, even though
+    # ordering is not guaranteed
+    assert (hash(set([Decimal(0), Decimal('NaN')])) ==
+            hash(set([Decimal('NaN'), Decimal(0)])))
+
+
+def test_string():
+    # Test that we obtain the same hash for object owning several strings,
+    # whatever the past of these strings (which are immutable in Python)
+    string = 'foo'
+    a = {string: 'bar'}
+    b = {string: 'bar'}
+    c = pickle.loads(pickle.dumps(b))
+    assert hash([a, b]) == hash([a, c])
+
+
+@with_numpy
+def test_numpy_dtype_pickling():
+    # numpy dtype hashing is tricky to get right: see #231, #239, #251 #1080,
+    # #1082, and explanatory comments inside
+    # ``joblib.hashing.NumpyHasher.save``.
+
+    # In this test, we make sure that the pickling of numpy dtypes is robust to
+    # object identity and object copy.
+
+    dt1 = np.dtype('f4')
+    dt2 = np.dtype('f4')
+
+    # simple dtypes objects are interned
+    assert dt1 is dt2
+    assert hash(dt1) == hash(dt2)
+
+    dt1_roundtripped = pickle.loads(pickle.dumps(dt1))
+    assert dt1 is not dt1_roundtripped
+    assert hash(dt1) == hash(dt1_roundtripped)
+
+    assert hash([dt1, dt1]) == hash([dt1_roundtripped, dt1_roundtripped])
+    assert hash([dt1, dt1]) == hash([dt1, dt1_roundtripped])
+
+    complex_dt1 = np.dtype(
+        [('name', np.str_, 16), ('grades', np.float64, (2,))]
+    )
+    complex_dt2 = np.dtype(
+        [('name', np.str_, 16), ('grades', np.float64, (2,))]
+    )
+
+    # complex dtypes objects are not interned
+    assert hash(complex_dt1) == hash(complex_dt2)
+
+    complex_dt1_roundtripped = pickle.loads(pickle.dumps(complex_dt1))
+    assert complex_dt1_roundtripped is not complex_dt1
+    assert hash(complex_dt1) == hash(complex_dt1_roundtripped)
+
+    assert hash([complex_dt1, complex_dt1]) == hash(
+        [complex_dt1_roundtripped, complex_dt1_roundtripped]
+    )
+    assert hash([complex_dt1, complex_dt1]) == hash(
+        [complex_dt1_roundtripped, complex_dt1]
+    )
+
+
+@parametrize('to_hash,expected',
+             [('This is a string to hash',
+               '71b3f47df22cb19431d85d92d0b230b2'),
+              (u"C'est l\xe9t\xe9",
+               '2d8d189e9b2b0b2e384d93c868c0e576'),
+              ((123456, 54321, -98765),
+               'e205227dd82250871fa25aa0ec690aa3'),
+              ([random.Random(42).random() for _ in range(5)],
+               'a11ffad81f9682a7d901e6edc3d16c84'),
+              ({'abcde': 123, 'sadfas': [-9999, 2, 3]},
+                  'aeda150553d4bb5c69f0e69d51b0e2ef')])
+def test_hashes_stay_the_same(to_hash, expected):
+    # We want to make sure that hashes don't change with joblib
+    # version. For end users, that would mean that they have to
+    # regenerate their cache from scratch, which potentially means
+    # lengthy recomputations.
+    # Expected results have been generated with joblib 0.9.2
+    assert hash(to_hash) == expected
+
+
+@with_numpy
+def test_hashes_are_different_between_c_and_fortran_contiguous_arrays():
+    # We want to be sure that the c-contiguous and f-contiguous versions of the
+    # same array produce 2 different hashes.
+    rng = np.random.RandomState(0)
+    arr_c = rng.random_sample((10, 10))
+    arr_f = np.asfortranarray(arr_c)
+    assert hash(arr_c) != hash(arr_f)
+
+
+@with_numpy
+def test_0d_array():
+    hash(np.array(0))
+
+
+@with_numpy
+def test_0d_and_1d_array_hashing_is_different():
+    assert hash(np.array(0)) != hash(np.array([0]))
+
+
+@with_numpy
+def test_hashes_stay_the_same_with_numpy_objects():
+    # Note: joblib used to test numpy objects hashing by comparing the produced
+    # hash of an object with some hard-coded target value to guarantee that
+    # hashing remains the same across joblib versions. However, since numpy
+    # 1.20 and joblib 1.0, joblib relies on potentially unstable implementation
+    # details of numpy to hash np.dtype objects, which makes the stability of
+    # hash values across different environments hard to guarantee and to test.
+    # As a result, hashing stability across joblib versions becomes best-effort
+    # only, and we only test the consistency within a single environment by
+    # making sure:
+    # - the hash of two copies of the same objects is the same
+    # - hashing some object in two different python processes produces the same
+    #   value. This should be viewed as a proxy for testing hash consistency
+    #   through time between Python sessions (provided no change in the
+    #   environment was done between sessions).
+
+    def create_objects_to_hash():
+        rng = np.random.RandomState(42)
+        # Being explicit about dtypes in order to avoid
+        # architecture-related differences. Also using 'f4' rather than
+        # 'f8' for float arrays because 'f8' arrays generated by
+        # rng.random.randn don't seem to be bit-identical on 32bit and
+        # 64bit machines.
+        to_hash_list = [
+            rng.randint(-1000, high=1000, size=50).astype('<i8'),
+            tuple(rng.randn(3).astype('<f4') for _ in range(5)),
+            [rng.randn(3).astype('<f4') for _ in range(5)],
+            {
+                -3333: rng.randn(3, 5).astype('<f4'),
+                0: [
+                    rng.randint(10, size=20).astype('<i8'),
+                    rng.randn(10).astype('<f4')
+                ]
+            },
+            # Non regression cases for
+            # https://github.com/joblib/joblib/issues/308
+            np.arange(100, dtype='<i8').reshape((10, 10)),
+            # Fortran contiguous array
+            np.asfortranarray(np.arange(100, dtype='<i8').reshape((10, 10))),
+            # Non contiguous array
+            np.arange(100, dtype='<i8').reshape((10, 10))[:, :2],
+        ]
+        return to_hash_list
+
+    # Create two lists containing copies of the same objects.  joblib.hash
+    # should return the same hash for to_hash_list_one[i] and
+    # to_hash_list_two[i]
+    to_hash_list_one = create_objects_to_hash()
+    to_hash_list_two = create_objects_to_hash()
+
+    e1 = ProcessPoolExecutor(max_workers=1)
+    e2 = ProcessPoolExecutor(max_workers=1)
+
+    try:
+        for obj_1, obj_2 in zip(to_hash_list_one, to_hash_list_two):
+            # testing consistency of hashes across python processes
+            hash_1 = e1.submit(hash, obj_1).result()
+            hash_2 = e2.submit(hash, obj_1).result()
+            assert hash_1 == hash_2
+
+            # testing consistency when hashing two copies of the same objects.
+            hash_3 = e1.submit(hash, obj_2).result()
+            assert hash_1 == hash_3
+
+    finally:
+        e1.shutdown()
+        e2.shutdown()
+
+
+def test_hashing_pickling_error():
+    def non_picklable():
+        return 42
+
+    with raises(pickle.PicklingError) as excinfo:
+        hash(non_picklable)
+    excinfo.match('PicklingError while hashing')
+
+
+def test_wrong_hash_name():
+    msg = "Valid options for 'hash_name' are"
+    with raises(ValueError, match=msg):
+        data = {'foo': 'bar'}
+        hash(data, hash_name='invalid')
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_logger.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_logger.py
new file mode 100644
index 0000000000000000000000000000000000000000..7cc59d4d1593bc5a4ab637328bf4e0dac068866f
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_logger.py
@@ -0,0 +1,31 @@
+"""
+Test the logger module.
+"""
+
+# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
+# Copyright (c) 2009 Gael Varoquaux
+# License: BSD Style, 3 clauses.
+import re
+
+from joblib.logger import PrintTime
+
+
+def test_print_time(tmpdir, capsys):
+    # A simple smoke test for PrintTime.
+    logfile = tmpdir.join('test.log').strpath
+    print_time = PrintTime(logfile=logfile)
+    print_time('Foo')
+    # Create a second time, to smoke test log rotation.
+    print_time = PrintTime(logfile=logfile)
+    print_time('Foo')
+    # And a third time
+    print_time = PrintTime(logfile=logfile)
+    print_time('Foo')
+
+    out_printed_text, err_printed_text = capsys.readouterr()
+    # Use regexps to be robust to time variations
+    match = r"Foo: 0\..s, 0\..min\nFoo: 0\..s, 0..min\nFoo: " + \
+            r".\..s, 0..min\n"
+    if not re.match(match, err_printed_text):
+        raise AssertionError('Excepted %s, got %s' %
+                             (match, err_printed_text))
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_memmapping.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_memmapping.py
new file mode 100644
index 0000000000000000000000000000000000000000..42a297a9e445d38c0daa03bc7d78e4c4f1fd4571
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_memmapping.py
@@ -0,0 +1,1191 @@
+import os
+import mmap
+import sys
+import platform
+import gc
+import pickle
+import itertools
+from time import sleep
+import subprocess
+import threading
+import faulthandler
+
+import pytest
+
+from joblib.test.common import with_numpy, np
+from joblib.test.common import with_multiprocessing
+from joblib.test.common import with_dev_shm
+from joblib.testing import raises, parametrize, skipif
+from joblib.backports import make_memmap
+from joblib.parallel import Parallel, delayed
+
+from joblib.pool import MemmappingPool
+from joblib.executor import _TestingMemmappingExecutor as TestExecutor
+from joblib._memmapping_reducer import has_shareable_memory
+from joblib._memmapping_reducer import ArrayMemmapForwardReducer
+from joblib._memmapping_reducer import _strided_from_memmap
+from joblib._memmapping_reducer import _get_temp_dir
+from joblib._memmapping_reducer import _WeakArrayKeyMap
+from joblib._memmapping_reducer import _get_backing_memmap
+import joblib._memmapping_reducer as jmr
+
+
+def setup_module():
+    faulthandler.dump_traceback_later(timeout=300, exit=True)
+
+
+def teardown_module():
+    faulthandler.cancel_dump_traceback_later()
+
+
+def check_memmap_and_send_back(array):
+    assert _get_backing_memmap(array) is not None
+    return array
+
+
+def check_array(args):
+    """Dummy helper function to be executed in subprocesses
+
+    Check that the provided array has the expected values in the provided
+    range.
+
+    """
+    data, position, expected = args
+    np.testing.assert_array_equal(data[position], expected)
+
+
+def inplace_double(args):
+    """Dummy helper function to be executed in subprocesses
+
+
+    Check that the input array has the right values in the provided range
+    and perform an inplace modification to double the values in the range by
+    two.
+
+    """
+    data, position, expected = args
+    assert data[position] == expected
+    data[position] *= 2
+    np.testing.assert_array_equal(data[position], 2 * expected)
+
+
+@with_numpy
+@with_multiprocessing
+def test_memmap_based_array_reducing(tmpdir):
+    """Check that it is possible to reduce a memmap backed array"""
+    assert_array_equal = np.testing.assert_array_equal
+    filename = tmpdir.join('test.mmap').strpath
+
+    # Create a file larger than what will be used by a
+    buffer = np.memmap(filename, dtype=np.float64, shape=500, mode='w+')
+
+    # Fill the original buffer with negative markers to detect over of
+    # underflow in case of test failures
+    buffer[:] = - 1.0 * np.arange(buffer.shape[0], dtype=buffer.dtype)
+    buffer.flush()
+
+    # Memmap a 2D fortran array on a offsetted subsection of the previous
+    # buffer
+    a = np.memmap(filename, dtype=np.float64, shape=(3, 5, 4),
+                  mode='r+', order='F', offset=4)
+    a[:] = np.arange(60).reshape(a.shape)
+
+    # Build various views that share the buffer with the original memmap
+
+    # b is an memmap sliced view on an memmap instance
+    b = a[1:-1, 2:-1, 2:4]
+
+    # c and d are array views
+    c = np.asarray(b)
+    d = c.T
+
+    # Array reducer with auto dumping disabled
+    reducer = ArrayMemmapForwardReducer(None, tmpdir.strpath, 'c', True)
+
+    def reconstruct_array_or_memmap(x):
+        cons, args = reducer(x)
+        return cons(*args)
+
+    # Reconstruct original memmap
+    a_reconstructed = reconstruct_array_or_memmap(a)
+    assert has_shareable_memory(a_reconstructed)
+    assert isinstance(a_reconstructed, np.memmap)
+    assert_array_equal(a_reconstructed, a)
+
+    # Reconstruct strided memmap view
+    b_reconstructed = reconstruct_array_or_memmap(b)
+    assert has_shareable_memory(b_reconstructed)
+    assert_array_equal(b_reconstructed, b)
+
+    # Reconstruct arrays views on memmap base
+    c_reconstructed = reconstruct_array_or_memmap(c)
+    assert not isinstance(c_reconstructed, np.memmap)
+    assert has_shareable_memory(c_reconstructed)
+    assert_array_equal(c_reconstructed, c)
+
+    d_reconstructed = reconstruct_array_or_memmap(d)
+    assert not isinstance(d_reconstructed, np.memmap)
+    assert has_shareable_memory(d_reconstructed)
+    assert_array_equal(d_reconstructed, d)
+
+    # Test graceful degradation on fake memmap instances with in-memory
+    # buffers
+    a3 = a * 3
+    assert not has_shareable_memory(a3)
+    a3_reconstructed = reconstruct_array_or_memmap(a3)
+    assert not has_shareable_memory(a3_reconstructed)
+    assert not isinstance(a3_reconstructed, np.memmap)
+    assert_array_equal(a3_reconstructed, a * 3)
+
+    # Test graceful degradation on arrays derived from fake memmap instances
+    b3 = np.asarray(a3)
+    assert not has_shareable_memory(b3)
+
+    b3_reconstructed = reconstruct_array_or_memmap(b3)
+    assert isinstance(b3_reconstructed, np.ndarray)
+    assert not has_shareable_memory(b3_reconstructed)
+    assert_array_equal(b3_reconstructed, b3)
+
+
+@with_multiprocessing
+@skipif((sys.platform != "win32") or (),
+        reason="PermissionError only easily triggerable on Windows")
+def test_resource_tracker_retries_when_permissionerror(tmpdir):
+    # Test resource_tracker retry mechanism when unlinking memmaps.  See more
+    # thorough information in the ``unlink_file`` documentation of joblib.
+    filename = tmpdir.join('test.mmap').strpath
+    cmd = """if 1:
+    import os
+    import numpy as np
+    import time
+    from joblib.externals.loky.backend import resource_tracker
+    resource_tracker.VERBOSE = 1
+
+    # Start the resource tracker
+    resource_tracker.ensure_running()
+    time.sleep(1)
+
+    # Create a file containing numpy data
+    memmap = np.memmap(r"{filename}", dtype=np.float64, shape=10, mode='w+')
+    memmap[:] = np.arange(10).astype(np.int8).data
+    memmap.flush()
+    assert os.path.exists(r"{filename}")
+    del memmap
+
+    # Create a np.memmap backed by this file
+    memmap = np.memmap(r"{filename}", dtype=np.float64, shape=10, mode='w+')
+    resource_tracker.register(r"{filename}", "file")
+
+    # Ask the resource_tracker to delete the file backing the np.memmap , this
+    # should raise PermissionError that the resource_tracker will log.
+    resource_tracker.maybe_unlink(r"{filename}", "file")
+
+    # Wait for the resource_tracker to process the maybe_unlink before cleaning
+    # up the memmap
+    time.sleep(2)
+    """.format(filename=filename)
+    p = subprocess.Popen([sys.executable, '-c', cmd], stderr=subprocess.PIPE,
+                         stdout=subprocess.PIPE)
+    p.wait()
+    out, err = p.communicate()
+    assert p.returncode == 0
+    assert out == b''
+    msg = 'tried to unlink {}, got PermissionError'.format(filename)
+    assert msg in err.decode()
+
+
+@with_numpy
+@with_multiprocessing
+def test_high_dimension_memmap_array_reducing(tmpdir):
+    assert_array_equal = np.testing.assert_array_equal
+
+    filename = tmpdir.join('test.mmap').strpath
+
+    # Create a high dimensional memmap
+    a = np.memmap(filename, dtype=np.float64, shape=(100, 15, 15, 3),
+                  mode='w+')
+    a[:] = np.arange(100 * 15 * 15 * 3).reshape(a.shape)
+
+    # Create some slices/indices at various dimensions
+    b = a[0:10]
+    c = a[:, 5:10]
+    d = a[:, :, :, 0]
+    e = a[1:3:4]
+
+    # Array reducer with auto dumping disabled
+    reducer = ArrayMemmapForwardReducer(None, tmpdir.strpath, 'c', True)
+
+    def reconstruct_array_or_memmap(x):
+        cons, args = reducer(x)
+        return cons(*args)
+
+    a_reconstructed = reconstruct_array_or_memmap(a)
+    assert has_shareable_memory(a_reconstructed)
+    assert isinstance(a_reconstructed, np.memmap)
+    assert_array_equal(a_reconstructed, a)
+
+    b_reconstructed = reconstruct_array_or_memmap(b)
+    assert has_shareable_memory(b_reconstructed)
+    assert_array_equal(b_reconstructed, b)
+
+    c_reconstructed = reconstruct_array_or_memmap(c)
+    assert has_shareable_memory(c_reconstructed)
+    assert_array_equal(c_reconstructed, c)
+
+    d_reconstructed = reconstruct_array_or_memmap(d)
+    assert has_shareable_memory(d_reconstructed)
+    assert_array_equal(d_reconstructed, d)
+
+    e_reconstructed = reconstruct_array_or_memmap(e)
+    assert has_shareable_memory(e_reconstructed)
+    assert_array_equal(e_reconstructed, e)
+
+
+@with_numpy
+def test__strided_from_memmap(tmpdir):
+    fname = tmpdir.join('test.mmap').strpath
+    size = 5 * mmap.ALLOCATIONGRANULARITY
+    offset = mmap.ALLOCATIONGRANULARITY + 1
+    # This line creates the mmap file that is reused later
+    memmap_obj = np.memmap(fname, mode='w+', shape=size + offset)
+    # filename, dtype, mode, offset, order, shape, strides, total_buffer_len
+    memmap_obj = _strided_from_memmap(fname, dtype='uint8', mode='r',
+                                      offset=offset, order='C', shape=size,
+                                      strides=None, total_buffer_len=None,
+                                      unlink_on_gc_collect=False)
+    assert isinstance(memmap_obj, np.memmap)
+    assert memmap_obj.offset == offset
+    memmap_backed_obj = _strided_from_memmap(
+        fname, dtype='uint8', mode='r', offset=offset, order='C',
+        shape=(size // 2,), strides=(2,), total_buffer_len=size,
+        unlink_on_gc_collect=False
+    )
+    assert _get_backing_memmap(memmap_backed_obj).offset == offset
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("factory", [MemmappingPool, TestExecutor.get_memmapping_executor],
+             ids=["multiprocessing", "loky"])
+def test_pool_with_memmap(factory, tmpdir):
+    """Check that subprocess can access and update shared memory memmap"""
+    assert_array_equal = np.testing.assert_array_equal
+
+    # Fork the subprocess before allocating the objects to be passed
+    pool_temp_folder = tmpdir.mkdir('pool').strpath
+    p = factory(10, max_nbytes=2, temp_folder=pool_temp_folder)
+    try:
+        filename = tmpdir.join('test.mmap').strpath
+        a = np.memmap(filename, dtype=np.float32, shape=(3, 5), mode='w+')
+        a.fill(1.0)
+
+        p.map(inplace_double, [(a, (i, j), 1.0)
+                               for i in range(a.shape[0])
+                               for j in range(a.shape[1])])
+
+        assert_array_equal(a, 2 * np.ones(a.shape))
+
+        # Open a copy-on-write view on the previous data
+        b = np.memmap(filename, dtype=np.float32, shape=(5, 3), mode='c')
+
+        p.map(inplace_double, [(b, (i, j), 2.0)
+                               for i in range(b.shape[0])
+                               for j in range(b.shape[1])])
+
+        # Passing memmap instances to the pool should not trigger the creation
+        # of new files on the FS
+        assert os.listdir(pool_temp_folder) == []
+
+        # the original data is untouched
+        assert_array_equal(a, 2 * np.ones(a.shape))
+        assert_array_equal(b, 2 * np.ones(b.shape))
+
+        # readonly maps can be read but not updated
+        c = np.memmap(filename, dtype=np.float32, shape=(10,), mode='r',
+                      offset=5 * 4)
+
+        with raises(AssertionError):
+            p.map(check_array, [(c, i, 3.0) for i in range(c.shape[0])])
+
+        # depending on the version of numpy one can either get a RuntimeError
+        # or a ValueError
+        with raises((RuntimeError, ValueError)):
+            p.map(inplace_double, [(c, i, 2.0) for i in range(c.shape[0])])
+    finally:
+        # Clean all filehandlers held by the pool
+        p.terminate()
+        del p
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("factory", [MemmappingPool, TestExecutor.get_memmapping_executor],
+             ids=["multiprocessing", "loky"])
+def test_pool_with_memmap_array_view(factory, tmpdir):
+    """Check that subprocess can access and update shared memory array"""
+    assert_array_equal = np.testing.assert_array_equal
+
+    # Fork the subprocess before allocating the objects to be passed
+    pool_temp_folder = tmpdir.mkdir('pool').strpath
+    p = factory(10, max_nbytes=2, temp_folder=pool_temp_folder)
+    try:
+
+        filename = tmpdir.join('test.mmap').strpath
+        a = np.memmap(filename, dtype=np.float32, shape=(3, 5), mode='w+')
+        a.fill(1.0)
+
+        # Create an ndarray view on the memmap instance
+        a_view = np.asarray(a)
+        assert not isinstance(a_view, np.memmap)
+        assert has_shareable_memory(a_view)
+
+        p.map(inplace_double, [(a_view, (i, j), 1.0)
+                               for i in range(a.shape[0])
+                               for j in range(a.shape[1])])
+
+        # Both a and the a_view have been updated
+        assert_array_equal(a, 2 * np.ones(a.shape))
+        assert_array_equal(a_view, 2 * np.ones(a.shape))
+
+        # Passing memmap array view to the pool should not trigger the
+        # creation of new files on the FS
+        assert os.listdir(pool_temp_folder) == []
+
+    finally:
+        p.terminate()
+        del p
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("backend", ["multiprocessing", "loky"])
+def test_permission_error_windows_reference_cycle(backend):
+    # Non regression test for:
+    # https://github.com/joblib/joblib/issues/806
+    #
+    # The issue happens when trying to delete a memory mapped file that has
+    # not yet been closed by one of the worker processes.
+    cmd = """if 1:
+        import numpy as np
+        from joblib import Parallel, delayed
+
+
+        data = np.random.rand(int(2e6)).reshape((int(1e6), 2))
+
+        # Build a complex cyclic reference that is likely to delay garbage
+        # collection of the memmapped array in the worker processes.
+        first_list = current_list = [data]
+        for i in range(10):
+            current_list = [current_list]
+        first_list.append(current_list)
+
+        if __name__ == "__main__":
+            results = Parallel(n_jobs=2, backend="{b}")(
+                delayed(len)(current_list) for i in range(10))
+            assert results == [1] * 10
+    """.format(b=backend)
+    p = subprocess.Popen([sys.executable, '-c', cmd], stderr=subprocess.PIPE,
+                         stdout=subprocess.PIPE)
+    p.wait()
+    out, err = p.communicate()
+    assert p.returncode == 0, out.decode() + "\n\n" + err.decode()
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("backend", ["multiprocessing", "loky"])
+def test_permission_error_windows_memmap_sent_to_parent(backend):
+    # Second non-regression test for:
+    # https://github.com/joblib/joblib/issues/806
+    # previously, child process would not convert temporary memmaps to numpy
+    # arrays when sending the data back to the parent process. This would lead
+    # to permission errors on windows when deleting joblib's temporary folder,
+    # as the memmaped files handles would still opened in the parent process.
+    cmd = '''if 1:
+        import os
+        import time
+
+        import numpy as np
+
+        from joblib import Parallel, delayed
+        from testutils import return_slice_of_data
+
+        data = np.ones(int(2e6))
+
+        if __name__ == '__main__':
+            # warm-up call to launch the workers and start the resource_tracker
+            _ = Parallel(n_jobs=2, verbose=5, backend='{b}')(
+                delayed(id)(i) for i in range(20))
+
+            time.sleep(0.5)
+
+            slice_of_data = Parallel(n_jobs=2, verbose=5, backend='{b}')(
+                delayed(return_slice_of_data)(data, 0, 20) for _ in range(10))
+    '''.format(b=backend)
+
+    for _ in range(3):
+        env = os.environ.copy()
+        env['PYTHONPATH'] = os.path.dirname(__file__)
+        p = subprocess.Popen([sys.executable, '-c', cmd],
+                             stderr=subprocess.PIPE,
+                             stdout=subprocess.PIPE, env=env)
+        p.wait()
+        out, err = p.communicate()
+        assert p.returncode == 0, err
+        assert out == b''
+        if sys.version_info[:3] not in [(3, 8, 0), (3, 8, 1)]:
+            # In early versions of Python 3.8, a reference leak
+            # https://github.com/cloudpipe/cloudpickle/issues/327, holds
+            # references to pickled objects, generating race condition during
+            # cleanup finalizers of joblib and noisy resource_tracker outputs.
+            assert b'resource_tracker' not in err
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("backend", ["multiprocessing", "loky"])
+def test_parallel_isolated_temp_folders(backend):
+    # Test that consecutive Parallel call use isolated subfolders, even
+    # for the loky backend that reuses its executor instance across calls.
+    array = np.arange(int(1e2))
+    [filename_1] = Parallel(n_jobs=2, backend=backend, max_nbytes=10)(
+        delayed(getattr)(array, 'filename') for _ in range(1)
+    )
+    [filename_2] = Parallel(n_jobs=2, backend=backend, max_nbytes=10)(
+        delayed(getattr)(array, 'filename') for _ in range(1)
+    )
+    assert os.path.dirname(filename_2) != os.path.dirname(filename_1)
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("backend", ["multiprocessing", "loky"])
+def test_managed_backend_reuse_temp_folder(backend):
+    # Test that calls to a managed parallel object reuse the same memmaps.
+    array = np.arange(int(1e2))
+    with Parallel(n_jobs=2, backend=backend, max_nbytes=10) as p:
+        [filename_1] = p(
+            delayed(getattr)(array, 'filename') for _ in range(1)
+        )
+        [filename_2] = p(
+            delayed(getattr)(array, 'filename') for _ in range(1)
+        )
+    assert os.path.dirname(filename_2) == os.path.dirname(filename_1)
+
+
+@with_numpy
+@with_multiprocessing
+def test_memmapping_temp_folder_thread_safety():
+    # Concurrent calls to Parallel with the loky backend will use the same
+    # executor, and thus the same reducers. Make sure that those reducers use
+    # different temporary folders depending on which Parallel objects called
+    # them, which is necessary to limit potential race conditions during the
+    # garbage collection of temporary memmaps.
+    array = np.arange(int(1e2))
+
+    temp_dirs_thread_1 = set()
+    temp_dirs_thread_2 = set()
+
+    def concurrent_get_filename(array, temp_dirs):
+        with Parallel(backend='loky', n_jobs=2, max_nbytes=10) as p:
+            for i in range(10):
+                [filename] = p(
+                    delayed(getattr)(array, 'filename') for _ in range(1)
+                )
+                temp_dirs.add(os.path.dirname(filename))
+
+    t1 = threading.Thread(
+        target=concurrent_get_filename, args=(array, temp_dirs_thread_1)
+    )
+    t2 = threading.Thread(
+        target=concurrent_get_filename, args=(array, temp_dirs_thread_2)
+    )
+
+    t1.start()
+    t2.start()
+
+    t1.join()
+    t2.join()
+
+    assert len(temp_dirs_thread_1) == 1
+    assert len(temp_dirs_thread_2) == 1
+
+    assert temp_dirs_thread_1 != temp_dirs_thread_2
+
+
+@with_numpy
+@with_multiprocessing
+def test_multithreaded_parallel_termination_resource_tracker_silent():
+    # test that concurrent termination attempts of a same executor does not
+    # emit any spurious error from the resource_tracker. We test various
+    # situations making 0, 1 or both parallel call sending a task that will
+    # make the worker (and thus the whole Parallel call) error out.
+    cmd = '''if 1:
+        import os
+        import numpy as np
+        from joblib import Parallel, delayed
+        from joblib.externals.loky.backend import resource_tracker
+        from concurrent.futures import ThreadPoolExecutor, wait
+
+        resource_tracker.VERBOSE = 0
+
+        array = np.arange(int(1e2))
+
+        temp_dirs_thread_1 = set()
+        temp_dirs_thread_2 = set()
+
+
+        def raise_error(array):
+            raise ValueError
+
+
+        def parallel_get_filename(array, temp_dirs):
+            with Parallel(backend="loky", n_jobs=2, max_nbytes=10) as p:
+                for i in range(10):
+                    [filename] = p(
+                        delayed(getattr)(array, "filename") for _ in range(1)
+                    )
+                    temp_dirs.add(os.path.dirname(filename))
+
+
+        def parallel_raise(array, temp_dirs):
+            with Parallel(backend="loky", n_jobs=2, max_nbytes=10) as p:
+                for i in range(10):
+                    [filename] = p(
+                        delayed(raise_error)(array) for _ in range(1)
+                    )
+                    temp_dirs.add(os.path.dirname(filename))
+
+
+        executor = ThreadPoolExecutor(max_workers=2)
+
+        # both function calls will use the same loky executor, but with a
+        # different Parallel object.
+        future_1 = executor.submit({f1}, array, temp_dirs_thread_1)
+        future_2 = executor.submit({f2}, array, temp_dirs_thread_2)
+
+        # Wait for both threads to terminate their backend
+        wait([future_1, future_2])
+
+        future_1.result()
+        future_2.result()
+    '''
+    functions_and_returncodes = [
+        ("parallel_get_filename", "parallel_get_filename", 0),
+        ("parallel_get_filename", "parallel_raise", 1),
+        ("parallel_raise", "parallel_raise", 1)
+    ]
+
+    for f1, f2, returncode in functions_and_returncodes:
+        p = subprocess.Popen([sys.executable, '-c', cmd.format(f1=f1, f2=f2)],
+                             stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+        p.wait()
+        out, err = p.communicate()
+        assert p.returncode == returncode, out.decode()
+        assert b"resource_tracker" not in err, err.decode()
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("backend", ["multiprocessing", "loky"])
+def test_many_parallel_calls_on_same_object(backend):
+    # After #966 got merged, consecutive Parallel objects were sharing temp
+    # folder, which would lead to race conditions happening during the
+    # temporary resources management with the resource_tracker. This is a
+    # non-regression test that makes sure that consecutive Parallel operations
+    # on the same object do not error out.
+    cmd = '''if 1:
+        import os
+        import time
+
+        import numpy as np
+
+        from joblib import Parallel, delayed
+        from testutils import return_slice_of_data
+
+        data = np.ones(100)
+
+        if __name__ == '__main__':
+            for i in range(5):
+                slice_of_data = Parallel(
+                    n_jobs=2, max_nbytes=1, backend='{b}')(
+                        delayed(return_slice_of_data)(data, 0, 20)
+                        for _ in range(10)
+                    )
+    '''.format(b=backend)
+    env = os.environ.copy()
+    env['PYTHONPATH'] = os.path.dirname(__file__)
+    p = subprocess.Popen(
+        [sys.executable, '-c', cmd],
+        stderr=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        env=env,
+    )
+    p.wait()
+    out, err = p.communicate()
+    assert p.returncode == 0, err
+    assert out == b''
+    if sys.version_info[:3] not in [(3, 8, 0), (3, 8, 1)]:
+        # In early versions of Python 3.8, a reference leak
+        # https://github.com/cloudpipe/cloudpickle/issues/327, holds
+        # references to pickled objects, generating race condition during
+        # cleanup finalizers of joblib and noisy resource_tracker outputs.
+        assert b'resource_tracker' not in err
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("backend", ["multiprocessing", "loky"])
+def test_memmap_returned_as_regular_array(backend):
+    data = np.ones(int(1e3))
+    # Check that child processes send temporary memmaps back as numpy arrays.
+    [result] = Parallel(n_jobs=2, backend=backend, max_nbytes=100)(
+        delayed(check_memmap_and_send_back)(data) for _ in range(1))
+    assert _get_backing_memmap(result) is None
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("backend", ["multiprocessing", "loky"])
+def test_resource_tracker_silent_when_reference_cycles(backend):
+    # There is a variety of reasons that can make joblib with loky backend
+    # output noisy warnings when a reference cycle is preventing a memmap from
+    # being garbage collected. Especially, joblib's main process finalizer
+    # deletes the temporary folder if it was not done before, which can
+    # interact badly with the resource_tracker. We don't risk leaking any
+    # resources, but this will likely make joblib output a lot of low-level
+    # confusing messages.
+    #
+    # This test makes sure that the resource_tracker is silent when a reference
+    # has been collected concurrently on non-Windows platforms.
+    #
+    # Note that the script in ``cmd`` is the exact same script as in
+    # test_permission_error_windows_reference_cycle.
+    if backend == "loky" and sys.platform.startswith('win'):
+        # XXX: on Windows, reference cycles can delay timely garbage collection
+        # and make it impossible to properly delete the temporary folder in the
+        # main process because of permission errors.
+        pytest.xfail(
+            "The temporary folder cannot be deleted on Windows in the "
+            "presence of a reference cycle"
+        )
+
+    cmd = """if 1:
+        import numpy as np
+        from joblib import Parallel, delayed
+
+
+        data = np.random.rand(int(2e6)).reshape((int(1e6), 2))
+
+        # Build a complex cyclic reference that is likely to delay garbage
+        # collection of the memmapped array in the worker processes.
+        first_list = current_list = [data]
+        for i in range(10):
+            current_list = [current_list]
+        first_list.append(current_list)
+
+        if __name__ == "__main__":
+            results = Parallel(n_jobs=2, backend="{b}")(
+                delayed(len)(current_list) for i in range(10))
+            assert results == [1] * 10
+    """.format(b=backend)
+    p = subprocess.Popen([sys.executable, '-c', cmd], stderr=subprocess.PIPE,
+                         stdout=subprocess.PIPE)
+    p.wait()
+    out, err = p.communicate()
+    out = out.decode()
+    err = err.decode()
+    assert p.returncode == 0, out + "\n\n" + err
+    assert "resource_tracker" not in err, err
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("factory", [MemmappingPool, TestExecutor.get_memmapping_executor],
+             ids=["multiprocessing", "loky"])
+def test_memmapping_pool_for_large_arrays(factory, tmpdir):
+    """Check that large arrays are not copied in memory"""
+
+    # Check that the tempfolder is empty
+    assert os.listdir(tmpdir.strpath) == []
+
+    # Build an array reducers that automatically dump large array content
+    # to filesystem backed memmap instances to avoid memory explosion
+    p = factory(3, max_nbytes=40, temp_folder=tmpdir.strpath, verbose=2)
+    try:
+        # The temporary folder for the pool is not provisioned in advance
+        assert os.listdir(tmpdir.strpath) == []
+        assert not os.path.exists(p._temp_folder)
+
+        small = np.ones(5, dtype=np.float32)
+        assert small.nbytes == 20
+        p.map(check_array, [(small, i, 1.0) for i in range(small.shape[0])])
+
+        # Memory has been copied, the pool filesystem folder is unused
+        assert os.listdir(tmpdir.strpath) == []
+
+        # Try with a file larger than the memmap threshold of 40 bytes
+        large = np.ones(100, dtype=np.float64)
+        assert large.nbytes == 800
+        p.map(check_array, [(large, i, 1.0) for i in range(large.shape[0])])
+
+        # The data has been dumped in a temp folder for subprocess to share it
+        # without per-child memory copies
+        assert os.path.isdir(p._temp_folder)
+        dumped_filenames = os.listdir(p._temp_folder)
+        assert len(dumped_filenames) == 1
+
+        # Check that memory mapping is not triggered for arrays with
+        # dtype='object'
+        objects = np.array(['abc'] * 100, dtype='object')
+        results = p.map(has_shareable_memory, [objects])
+        assert not results[0]
+
+    finally:
+        # check FS garbage upon pool termination
+        p.terminate()
+        for i in range(10):
+            sleep(.1)
+            if not os.path.exists(p._temp_folder):
+                break
+        else:  # pragma: no cover
+            raise AssertionError(
+                'temporary folder {} was not deleted'.format(p._temp_folder)
+            )
+        del p
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize(
+    "backend",
+    [
+        pytest.param(
+            "multiprocessing",
+            marks=pytest.mark.xfail(
+                reason='https://github.com/joblib/joblib/issues/1086'
+            ),
+        ),
+        "loky",
+    ]
+)
+def test_child_raises_parent_exits_cleanly(backend):
+    # When a task executed by a child process raises an error, the parent
+    # process's backend is notified, and calls abort_everything.
+    # In loky, abort_everything itself calls shutdown(kill_workers=True) which
+    # sends SIGKILL to the worker, preventing it from running the finalizers
+    # supposed to signal the resource_tracker when the worker is done using
+    # objects relying on a shared resource (e.g np.memmaps). Because this
+    # behavior is prone to :
+    # - cause a resource leak
+    # - make the resource tracker emit noisy resource warnings
+    # we explicitly test that, when the said situation occurs:
+    # - no resources are actually leaked
+    # - the temporary resources are deleted as soon as possible (typically, at
+    #   the end of the failing Parallel call)
+    # - the resource_tracker does not emit any warnings.
+    cmd = """if 1:
+        import os
+        from pathlib import Path
+        from time import sleep
+
+        import numpy as np
+        from joblib import Parallel, delayed
+        from testutils import print_filename_and_raise
+
+        data = np.random.rand(1000)
+
+        def get_temp_folder(parallel_obj, backend):
+            if "{b}" == "loky":
+                return Path(parallel_obj._backend._workers._temp_folder)
+            else:
+                return Path(parallel_obj._backend._pool._temp_folder)
+
+
+        if __name__ == "__main__":
+            try:
+                with Parallel(n_jobs=2, backend="{b}", max_nbytes=100) as p:
+                    temp_folder = get_temp_folder(p, "{b}")
+                    p(delayed(print_filename_and_raise)(data)
+                              for i in range(1))
+            except ValueError as e:
+                # the temporary folder should be deleted by the end of this
+                # call but apparently on some file systems, this takes
+                # some time to be visible.
+                #
+                # We attempt to write into the temporary folder to test for
+                # its existence and we wait for a maximum of 10 seconds.
+                for i in range(100):
+                    try:
+                        with open(temp_folder / "some_file.txt", "w") as f:
+                            f.write("some content")
+                    except FileNotFoundError:
+                        # temp_folder has been deleted, all is fine
+                        break
+
+                    # ... else, wait a bit and try again
+                    sleep(.1)
+                else:
+                    raise AssertionError(
+                        str(temp_folder) + " was not deleted"
+                    ) from e
+    """.format(b=backend)
+    env = os.environ.copy()
+    env['PYTHONPATH'] = os.path.dirname(__file__)
+    p = subprocess.Popen([sys.executable, '-c', cmd], stderr=subprocess.PIPE,
+                         stdout=subprocess.PIPE, env=env)
+    p.wait()
+    out, err = p.communicate()
+    out, err = out.decode(), err.decode()
+    filename = out.split('\n')[0]
+    assert p.returncode == 0, err or out
+    assert err == ''  # no resource_tracker warnings.
+    assert not os.path.exists(filename)
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("factory", [MemmappingPool, TestExecutor.get_memmapping_executor],
+             ids=["multiprocessing", "loky"])
+def test_memmapping_pool_for_large_arrays_disabled(factory, tmpdir):
+    """Check that large arrays memmapping can be disabled"""
+    # Set max_nbytes to None to disable the auto memmapping feature
+    p = factory(3, max_nbytes=None, temp_folder=tmpdir.strpath)
+    try:
+
+        # Check that the tempfolder is empty
+        assert os.listdir(tmpdir.strpath) == []
+
+        # Try with a file largish than the memmap threshold of 40 bytes
+        large = np.ones(100, dtype=np.float64)
+        assert large.nbytes == 800
+        p.map(check_array, [(large, i, 1.0) for i in range(large.shape[0])])
+
+        # Check that the tempfolder is still empty
+        assert os.listdir(tmpdir.strpath) == []
+
+    finally:
+        # Cleanup open file descriptors
+        p.terminate()
+        del p
+
+
+@with_numpy
+@with_multiprocessing
+@with_dev_shm
+@parametrize("factory", [MemmappingPool, TestExecutor.get_memmapping_executor],
+             ids=["multiprocessing", "loky"])
+def test_memmapping_on_large_enough_dev_shm(factory):
+    """Check that memmapping uses /dev/shm when possible"""
+    orig_size = jmr.SYSTEM_SHARED_MEM_FS_MIN_SIZE
+    try:
+        # Make joblib believe that it can use /dev/shm even when running on a
+        # CI container where the size of the /dev/shm is not very large (that
+        # is at least 32 MB instead of 2 GB by default).
+        jmr.SYSTEM_SHARED_MEM_FS_MIN_SIZE = int(32e6)
+        p = factory(3, max_nbytes=10)
+        try:
+            # Check that the pool has correctly detected the presence of the
+            # shared memory filesystem.
+            pool_temp_folder = p._temp_folder
+            folder_prefix = '/dev/shm/joblib_memmapping_folder_'
+            assert pool_temp_folder.startswith(folder_prefix)
+            assert os.path.exists(pool_temp_folder)
+
+            # Try with a file larger than the memmap threshold of 10 bytes
+            a = np.ones(100, dtype=np.float64)
+            assert a.nbytes == 800
+            p.map(id, [a] * 10)
+            # a should have been memmapped to the pool temp folder: the joblib
+            # pickling procedure generate one .pkl file:
+            assert len(os.listdir(pool_temp_folder)) == 1
+
+            # create a new array with content that is different from 'a' so
+            # that it is mapped to a different file in the temporary folder of
+            # the pool.
+            b = np.ones(100, dtype=np.float64) * 2
+            assert b.nbytes == 800
+            p.map(id, [b] * 10)
+            # A copy of both a and b are now stored in the shared memory folder
+            assert len(os.listdir(pool_temp_folder)) == 2
+        finally:
+            # Cleanup open file descriptors
+            p.terminate()
+            del p
+
+        for i in range(100):
+            # The temp folder is cleaned up upon pool termination
+            if not os.path.exists(pool_temp_folder):
+                break
+            sleep(.1)
+        else:  # pragma: no cover
+            raise AssertionError('temporary folder of pool was not deleted')
+    finally:
+        jmr.SYSTEM_SHARED_MEM_FS_MIN_SIZE = orig_size
+
+
+@with_numpy
+@with_multiprocessing
+@with_dev_shm
+@parametrize("factory", [MemmappingPool, TestExecutor.get_memmapping_executor],
+             ids=["multiprocessing", "loky"])
+def test_memmapping_on_too_small_dev_shm(factory):
+    orig_size = jmr.SYSTEM_SHARED_MEM_FS_MIN_SIZE
+    try:
+        # Make joblib believe that it cannot use /dev/shm unless there is
+        # 42 exabytes of available shared memory in /dev/shm
+        jmr.SYSTEM_SHARED_MEM_FS_MIN_SIZE = int(42e18)
+
+        p = factory(3, max_nbytes=10)
+        try:
+            # Check that the pool has correctly detected the presence of the
+            # shared memory filesystem.
+            pool_temp_folder = p._temp_folder
+            assert not pool_temp_folder.startswith('/dev/shm')
+        finally:
+            # Cleanup open file descriptors
+            p.terminate()
+            del p
+
+        # The temp folder is cleaned up upon pool termination
+        assert not os.path.exists(pool_temp_folder)
+    finally:
+        jmr.SYSTEM_SHARED_MEM_FS_MIN_SIZE = orig_size
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("factory", [MemmappingPool, TestExecutor.get_memmapping_executor],
+             ids=["multiprocessing", "loky"])
+def test_memmapping_pool_for_large_arrays_in_return(factory, tmpdir):
+    """Check that large arrays are not copied in memory in return"""
+    assert_array_equal = np.testing.assert_array_equal
+
+    # Build an array reducers that automatically dump large array content
+    # but check that the returned datastructure are regular arrays to avoid
+    # passing a memmap array pointing to a pool controlled temp folder that
+    # might be confusing to the user
+
+    # The MemmappingPool user can always return numpy.memmap object explicitly
+    # to avoid memory copy
+    p = factory(3, max_nbytes=10, temp_folder=tmpdir.strpath)
+    try:
+        res = p.apply_async(np.ones, args=(1000,))
+        large = res.get()
+        assert not has_shareable_memory(large)
+        assert_array_equal(large, np.ones(1000))
+    finally:
+        p.terminate()
+        del p
+
+
+def _worker_multiply(a, n_times):
+    """Multiplication function to be executed by subprocess"""
+    assert has_shareable_memory(a)
+    return a * n_times
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize("factory", [MemmappingPool, TestExecutor.get_memmapping_executor],
+             ids=["multiprocessing", "loky"])
+def test_workaround_against_bad_memmap_with_copied_buffers(factory, tmpdir):
+    """Check that memmaps with a bad buffer are returned as regular arrays
+
+    Unary operations and ufuncs on memmap instances return a new memmap
+    instance with an in-memory buffer (probably a numpy bug).
+    """
+    assert_array_equal = np.testing.assert_array_equal
+
+    p = factory(3, max_nbytes=10, temp_folder=tmpdir.strpath)
+    try:
+        # Send a complex, large-ish view on a array that will be converted to
+        # a memmap in the worker process
+        a = np.asarray(np.arange(6000).reshape((1000, 2, 3)),
+                       order='F')[:, :1, :]
+
+        # Call a non-inplace multiply operation on the worker and memmap and
+        # send it back to the parent.
+        b = p.apply_async(_worker_multiply, args=(a, 3)).get()
+        assert not has_shareable_memory(b)
+        assert_array_equal(b, 3 * a)
+    finally:
+        p.terminate()
+        del p
+
+
+def identity(arg):
+    return arg
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize(
+    "factory,retry_no",
+    list(itertools.product(
+        [MemmappingPool, TestExecutor.get_memmapping_executor], range(3))),
+    ids=['{}, {}'.format(x, y) for x, y in itertools.product(
+        ["multiprocessing", "loky"], map(str, range(3)))])
+def test_pool_memmap_with_big_offset(factory, retry_no, tmpdir):
+    # Test that numpy memmap offset is set correctly if greater than
+    # mmap.ALLOCATIONGRANULARITY, see
+    # https://github.com/joblib/joblib/issues/451 and
+    # https://github.com/numpy/numpy/pull/8443 for more details.
+    fname = tmpdir.join('test.mmap').strpath
+    size = 5 * mmap.ALLOCATIONGRANULARITY
+    offset = mmap.ALLOCATIONGRANULARITY + 1
+    obj = make_memmap(fname, mode='w+', shape=size, dtype='uint8',
+                      offset=offset)
+
+    p = factory(2, temp_folder=tmpdir.strpath)
+    result = p.apply_async(identity, args=(obj,)).get()
+    assert isinstance(result, np.memmap)
+    assert result.offset == offset
+    np.testing.assert_array_equal(obj, result)
+    p.terminate()
+
+
+def test_pool_get_temp_dir(tmpdir):
+    pool_folder_name = 'test.tmpdir'
+    pool_folder, shared_mem = _get_temp_dir(pool_folder_name, tmpdir.strpath)
+    assert shared_mem is False
+    assert pool_folder == tmpdir.join('test.tmpdir').strpath
+
+    pool_folder, shared_mem = _get_temp_dir(pool_folder_name, temp_folder=None)
+    if sys.platform.startswith('win'):
+        assert shared_mem is False
+    assert pool_folder.endswith(pool_folder_name)
+
+
+def test_pool_get_temp_dir_no_statvfs(tmpdir, monkeypatch):
+    """Check that _get_temp_dir works when os.statvfs is not defined
+
+    Regression test for #902
+    """
+    pool_folder_name = 'test.tmpdir'
+    import joblib._memmapping_reducer
+    if hasattr(joblib._memmapping_reducer.os, 'statvfs'):
+        # We are on Unix, since Windows doesn't have this function
+        monkeypatch.delattr(joblib._memmapping_reducer.os, 'statvfs')
+
+    pool_folder, shared_mem = _get_temp_dir(pool_folder_name, temp_folder=None)
+    if sys.platform.startswith('win'):
+        assert shared_mem is False
+    assert pool_folder.endswith(pool_folder_name)
+
+
+@with_numpy
+@skipif(sys.platform == 'win32', reason='This test fails with a '
+        'PermissionError on Windows')
+@parametrize("mmap_mode", ["r+", "w+"])
+def test_numpy_arrays_use_different_memory(mmap_mode):
+    def func(arr, value):
+        arr[:] = value
+        return arr
+
+    arrays = [np.zeros((10, 10), dtype='float64') for i in range(10)]
+
+    results = Parallel(mmap_mode=mmap_mode, max_nbytes=0, n_jobs=2)(
+        delayed(func)(arr, i) for i, arr in enumerate(arrays))
+
+    for i, arr in enumerate(results):
+        np.testing.assert_array_equal(arr, i)
+
+
+@with_numpy
+def test_weak_array_key_map():
+
+    def assert_empty_after_gc_collect(container, retries=100):
+        for i in range(retries):
+            if len(container) == 0:
+                return
+            gc.collect()
+            sleep(.1)
+        assert len(container) == 0
+
+    a = np.ones(42)
+    m = _WeakArrayKeyMap()
+    m.set(a, 'a')
+    assert m.get(a) == 'a'
+
+    b = a
+    assert m.get(b) == 'a'
+    m.set(b, 'b')
+    assert m.get(a) == 'b'
+
+    del a
+    gc.collect()
+    assert len(m._data) == 1
+    assert m.get(b) == 'b'
+
+    del b
+    assert_empty_after_gc_collect(m._data)
+
+    c = np.ones(42)
+    m.set(c, 'c')
+    assert len(m._data) == 1
+    assert m.get(c) == 'c'
+
+    with raises(KeyError):
+        m.get(np.ones(42))
+
+    del c
+    assert_empty_after_gc_collect(m._data)
+
+    # Check that creating and dropping numpy arrays with potentially the same
+    # object id will not cause the map to get confused.
+    def get_set_get_collect(m, i):
+        a = np.ones(42)
+        with raises(KeyError):
+            m.get(a)
+        m.set(a, i)
+        assert m.get(a) == i
+        return id(a)
+
+    unique_ids = set([get_set_get_collect(m, i) for i in range(1000)])
+    if platform.python_implementation() == 'CPython':
+        # On CPython (at least) the same id is often reused many times for the
+        # temporary arrays created under the local scope of the
+        # get_set_get_collect function without causing any spurious lookups /
+        # insertions in the map. Apparently on Python nogil, the id is not
+        # reused as often.
+        max_len_unique_ids = 400 if getattr(sys.flags, 'nogil', False) else 100
+        assert len(unique_ids) < max_len_unique_ids
+
+
+def test_weak_array_key_map_no_pickling():
+    m = _WeakArrayKeyMap()
+    with raises(pickle.PicklingError):
+        pickle.dumps(m)
+
+
+@with_numpy
+@with_multiprocessing
+def test_direct_mmap(tmpdir):
+    testfile = str(tmpdir.join('arr.dat'))
+    a = np.arange(10, dtype='uint8')
+    a.tofile(testfile)
+
+    def _read_array():
+        with open(testfile) as fd:
+            mm = mmap.mmap(fd.fileno(), 0, access=mmap.ACCESS_READ, offset=0)
+        return np.ndarray((10,), dtype=np.uint8, buffer=mm, offset=0)
+
+    def func(x):
+        return x**2
+
+    arr = _read_array()
+
+    # this is expected to work and gives the reference
+    ref = Parallel(n_jobs=2)(delayed(func)(x) for x in [a])
+
+    # now test that it work with the mmap array
+    results = Parallel(n_jobs=2)(delayed(func)(x) for x in [arr])
+    np.testing.assert_array_equal(results, ref)
+
+    # also test with a mmap array read in the subprocess
+    def worker():
+        return _read_array()
+
+    results = Parallel(n_jobs=2)(delayed(worker)() for _ in range(1))
+    np.testing.assert_array_equal(results[0], arr)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_memory.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..f360e2b2619d1883c4475cc88f35251cbcb9d1a7
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_memory.py
@@ -0,0 +1,1526 @@
+"""
+Test the memory module.
+"""
+
+# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
+# Copyright (c) 2009 Gael Varoquaux
+# License: BSD Style, 3 clauses.
+
+import functools
+import gc
+import logging
+import shutil
+import os
+import os.path
+import pathlib
+import pickle
+import sys
+import time
+import datetime
+import textwrap
+
+import pytest
+
+from joblib.memory import Memory
+from joblib.memory import expires_after
+from joblib.memory import MemorizedFunc, NotMemorizedFunc
+from joblib.memory import MemorizedResult, NotMemorizedResult
+from joblib.memory import _FUNCTION_HASHES
+from joblib.memory import register_store_backend, _STORE_BACKENDS
+from joblib.memory import _build_func_identifier, _store_backend_factory
+from joblib.memory import JobLibCollisionWarning
+from joblib.parallel import Parallel, delayed
+from joblib._store_backends import StoreBackendBase, FileSystemStoreBackend
+from joblib.test.common import with_numpy, np
+from joblib.test.common import with_multiprocessing
+from joblib.testing import parametrize, raises, warns
+from joblib.hashing import hash
+
+
+###############################################################################
+# Module-level variables for the tests
+def f(x, y=1):
+    """ A module-level function for testing purposes.
+    """
+    return x ** 2 + y
+
+
+###############################################################################
+# Helper function for the tests
+def check_identity_lazy(func, accumulator, location):
+    """ Given a function and an accumulator (a list that grows every
+        time the function is called), check that the function can be
+        decorated by memory to be a lazy identity.
+    """
+    # Call each function with several arguments, and check that it is
+    # evaluated only once per argument.
+    memory = Memory(location=location, verbose=0)
+    func = memory.cache(func)
+    for i in range(3):
+        for _ in range(2):
+            assert func(i) == i
+            assert len(accumulator) == i + 1
+
+
+def corrupt_single_cache_item(memory):
+    single_cache_item, = memory.store_backend.get_items()
+    output_filename = os.path.join(single_cache_item.path, 'output.pkl')
+    with open(output_filename, 'w') as f:
+        f.write('garbage')
+
+
+def monkeypatch_cached_func_warn(func, monkeypatch_fixture):
+    # Need monkeypatch because pytest does not
+    # capture stdlib logging output (see
+    # https://github.com/pytest-dev/pytest/issues/2079)
+
+    recorded = []
+
+    def append_to_record(item):
+        recorded.append(item)
+    monkeypatch_fixture.setattr(func, 'warn', append_to_record)
+    return recorded
+
+
+###############################################################################
+# Tests
+def test_memory_integration(tmpdir):
+    """ Simple test of memory lazy evaluation.
+    """
+    accumulator = list()
+
+    # Rmk: this function has the same name than a module-level function,
+    # thus it serves as a test to see that both are identified
+    # as different.
+    def f(arg):
+        accumulator.append(1)
+        return arg
+
+    check_identity_lazy(f, accumulator, tmpdir.strpath)
+
+    # Now test clearing
+    for compress in (False, True):
+        for mmap_mode in ('r', None):
+            memory = Memory(location=tmpdir.strpath, verbose=10,
+                            mmap_mode=mmap_mode, compress=compress)
+            # First clear the cache directory, to check that our code can
+            # handle that
+            # NOTE: this line would raise an exception, as the database file is
+            # still open; we ignore the error since we want to test what
+            # happens if the directory disappears
+            shutil.rmtree(tmpdir.strpath, ignore_errors=True)
+            g = memory.cache(f)
+            g(1)
+            g.clear(warn=False)
+            current_accumulator = len(accumulator)
+            out = g(1)
+
+        assert len(accumulator) == current_accumulator + 1
+        # Also, check that Memory.eval works similarly
+        assert memory.eval(f, 1) == out
+        assert len(accumulator) == current_accumulator + 1
+
+    # Now do a smoke test with a function defined in __main__, as the name
+    # mangling rules are more complex
+    f.__module__ = '__main__'
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    memory.cache(f)(1)
+
+
+@parametrize("call_before_reducing", [True, False])
+def test_parallel_call_cached_function_defined_in_jupyter(
+    tmpdir, call_before_reducing
+):
+    # Calling an interactively defined memory.cache()'d function inside a
+    # Parallel call used to clear the existing cache related to the said
+    # function (https://github.com/joblib/joblib/issues/1035)
+
+    # This tests checks that this is no longer the case.
+
+    # TODO: test that the cache related to the function cache persists across
+    # ipython sessions (provided that no code change were made to the
+    # function's source)?
+
+    # The first part of the test makes the necessary low-level calls to emulate
+    # the definition of a function in an jupyter notebook cell. Joblib has
+    # some custom code to treat functions defined specifically in jupyter
+    # notebooks/ipython session -- we want to test this code, which requires
+    # the emulation to be rigorous.
+    for session_no in [0, 1]:
+        ipython_cell_source = '''
+        def f(x):
+            return x
+        '''
+
+        ipython_cell_id = '<ipython-input-{}-000000000000>'.format(session_no)
+
+        exec(
+            compile(
+                textwrap.dedent(ipython_cell_source),
+                filename=ipython_cell_id,
+                mode='exec'
+            )
+        )
+        # f is now accessible in the locals mapping - but for some unknown
+        # reason, f = locals()['f'] throws a KeyError at runtime, we need to
+        # bind locals()['f'] to a different name in the local namespace
+        aliased_f = locals()['f']
+        aliased_f.__module__ = "__main__"
+
+        # Preliminary sanity checks, and tests checking that joblib properly
+        # identified f as an interactive function defined in a jupyter notebook
+        assert aliased_f(1) == 1
+        assert aliased_f.__code__.co_filename == ipython_cell_id
+
+        memory = Memory(location=tmpdir.strpath, verbose=0)
+        cached_f = memory.cache(aliased_f)
+
+        assert len(os.listdir(tmpdir / 'joblib')) == 1
+        f_cache_relative_directory = os.listdir(tmpdir / 'joblib')[0]
+        assert 'ipython-input' in f_cache_relative_directory
+
+        f_cache_directory = tmpdir / 'joblib' / f_cache_relative_directory
+
+        if session_no == 0:
+            # The cache should be empty as cached_f has not been called yet.
+            assert os.listdir(f_cache_directory) == ['f']
+            assert os.listdir(f_cache_directory / 'f') == []
+
+            if call_before_reducing:
+                cached_f(3)
+                # Two files were just created, func_code.py, and a folder
+                # containing the information (inputs hash/ouptput) of
+                # cached_f(3)
+                assert len(os.listdir(f_cache_directory / 'f')) == 2
+
+                # Now, testing  #1035: when calling a cached function, joblib
+                # used to dynamically inspect the underlying function to
+                # extract its source code (to verify it matches the source code
+                # of the function as last inspected by joblib) -- however,
+                # source code introspection fails for dynamic functions sent to
+                # child processes - which would eventually make joblib clear
+                # the cache associated to f
+                res = Parallel(n_jobs=2)(delayed(cached_f)(i) for i in [1, 2])
+            else:
+                # Submit the function to the joblib child processes, although
+                # the function has never been called in the parent yet. This
+                # triggers a specific code branch inside
+                # MemorizedFunc.__reduce__.
+                res = Parallel(n_jobs=2)(delayed(cached_f)(i) for i in [1, 2])
+                assert len(os.listdir(f_cache_directory / 'f')) == 3
+
+                cached_f(3)
+
+            # Making sure f's cache does not get cleared after the parallel
+            # calls, and contains ALL cached functions calls (f(1), f(2), f(3))
+            # and 'func_code.py'
+            assert len(os.listdir(f_cache_directory / 'f')) == 4
+        else:
+            # For the second session, there should be an already existing cache
+            assert len(os.listdir(f_cache_directory / 'f')) == 4
+
+            cached_f(3)
+
+            # The previous cache should not be invalidated after calling the
+            # function in a new session
+            assert len(os.listdir(f_cache_directory / 'f')) == 4
+
+
+def test_no_memory():
+    """ Test memory with location=None: no memoize """
+    accumulator = list()
+
+    def ff(arg):
+        accumulator.append(1)
+        return arg
+
+    memory = Memory(location=None, verbose=0)
+    gg = memory.cache(ff)
+    for _ in range(4):
+        current_accumulator = len(accumulator)
+        gg(1)
+        assert len(accumulator) == current_accumulator + 1
+
+
+def test_memory_kwarg(tmpdir):
+    " Test memory with a function with keyword arguments."
+    accumulator = list()
+
+    def g(arg1=None, arg2=1):
+        accumulator.append(1)
+        return arg1
+
+    check_identity_lazy(g, accumulator, tmpdir.strpath)
+
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    g = memory.cache(g)
+    # Smoke test with an explicit keyword argument:
+    assert g(arg1=30, arg2=2) == 30
+
+
+def test_memory_lambda(tmpdir):
+    " Test memory with a function with a lambda."
+    accumulator = list()
+
+    def helper(x):
+        """ A helper function to define l as a lambda.
+        """
+        accumulator.append(1)
+        return x
+
+    check_identity_lazy(lambda x: helper(x), accumulator, tmpdir.strpath)
+
+
+def test_memory_name_collision(tmpdir):
+    " Check that name collisions with functions will raise warnings"
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+
+    @memory.cache
+    def name_collision(x):
+        """ A first function called name_collision
+        """
+        return x
+
+    a = name_collision
+
+    @memory.cache
+    def name_collision(x):
+        """ A second function called name_collision
+        """
+        return x
+
+    b = name_collision
+
+    with warns(JobLibCollisionWarning) as warninfo:
+        a(1)
+        b(1)
+
+    assert len(warninfo) == 1
+    assert "collision" in str(warninfo[0].message)
+
+
+def test_memory_warning_lambda_collisions(tmpdir):
+    # Check that multiple use of lambda will raise collisions
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    a = memory.cache(lambda x: x)
+    b = memory.cache(lambda x: x + 1)
+
+    with warns(JobLibCollisionWarning) as warninfo:
+        assert a(0) == 0
+        assert b(1) == 2
+        assert a(1) == 1
+
+    # In recent Python versions, we can retrieve the code of lambdas,
+    # thus nothing is raised
+    assert len(warninfo) == 4
+
+
+def test_memory_warning_collision_detection(tmpdir):
+    # Check that collisions impossible to detect will raise appropriate
+    # warnings.
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    a1 = eval('lambda x: x')
+    a1 = memory.cache(a1)
+    b1 = eval('lambda x: x+1')
+    b1 = memory.cache(b1)
+
+    with warns(JobLibCollisionWarning) as warninfo:
+        a1(1)
+        b1(1)
+        a1(0)
+
+    assert len(warninfo) == 2
+    assert "cannot detect" in str(warninfo[0].message).lower()
+
+
+def test_memory_partial(tmpdir):
+    " Test memory with functools.partial."
+    accumulator = list()
+
+    def func(x, y):
+        """ A helper function to define l as a lambda.
+        """
+        accumulator.append(1)
+        return y
+
+    import functools
+    function = functools.partial(func, 1)
+
+    check_identity_lazy(function, accumulator, tmpdir.strpath)
+
+
+def test_memory_eval(tmpdir):
+    " Smoke test memory with a function with a function defined in an eval."
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+
+    m = eval('lambda x: x')
+    mm = memory.cache(m)
+
+    assert mm(1) == 1
+
+
+def count_and_append(x=[]):
+    """ A function with a side effect in its arguments.
+
+        Return the length of its argument and append one element.
+    """
+    len_x = len(x)
+    x.append(None)
+    return len_x
+
+
+def test_argument_change(tmpdir):
+    """ Check that if a function has a side effect in its arguments, it
+        should use the hash of changing arguments.
+    """
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    func = memory.cache(count_and_append)
+    # call the function for the first time, is should cache it with
+    # argument x=[]
+    assert func() == 0
+    # the second time the argument is x=[None], which is not cached
+    # yet, so the functions should be called a second time
+    assert func() == 1
+
+
+@with_numpy
+@parametrize('mmap_mode', [None, 'r'])
+def test_memory_numpy(tmpdir, mmap_mode):
+    " Test memory with a function with numpy arrays."
+    accumulator = list()
+
+    def n(arg=None):
+        accumulator.append(1)
+        return arg
+
+    memory = Memory(location=tmpdir.strpath, mmap_mode=mmap_mode,
+                    verbose=0)
+    cached_n = memory.cache(n)
+
+    rnd = np.random.RandomState(0)
+    for i in range(3):
+        a = rnd.random_sample((10, 10))
+        for _ in range(3):
+            assert np.all(cached_n(a) == a)
+            assert len(accumulator) == i + 1
+
+
+@with_numpy
+def test_memory_numpy_check_mmap_mode(tmpdir, monkeypatch):
+    """Check that mmap_mode is respected even at the first call"""
+
+    memory = Memory(location=tmpdir.strpath, mmap_mode='r', verbose=0)
+
+    @memory.cache()
+    def twice(a):
+        return a * 2
+
+    a = np.ones(3)
+
+    b = twice(a)
+    c = twice(a)
+
+    assert isinstance(c, np.memmap)
+    assert c.mode == 'r'
+
+    assert isinstance(b, np.memmap)
+    assert b.mode == 'r'
+
+    # Corrupts the file,  Deleting b and c mmaps
+    # is necessary to be able edit the file
+    del b
+    del c
+    gc.collect()
+    corrupt_single_cache_item(memory)
+
+    # Make sure that corrupting the file causes recomputation and that
+    # a warning is issued.
+    recorded_warnings = monkeypatch_cached_func_warn(twice, monkeypatch)
+    d = twice(a)
+    assert len(recorded_warnings) == 1
+    exception_msg = 'Exception while loading results'
+    assert exception_msg in recorded_warnings[0]
+    # Asserts that the recomputation returns a mmap
+    assert isinstance(d, np.memmap)
+    assert d.mode == 'r'
+
+
+def test_memory_exception(tmpdir):
+    """ Smoketest the exception handling of Memory.
+    """
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+
+    class MyException(Exception):
+        pass
+
+    @memory.cache
+    def h(exc=0):
+        if exc:
+            raise MyException
+
+    # Call once, to initialise the cache
+    h()
+
+    for _ in range(3):
+        # Call 3 times, to be sure that the Exception is always raised
+        with raises(MyException):
+            h(1)
+
+
+def test_memory_ignore(tmpdir):
+    " Test the ignore feature of memory "
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    accumulator = list()
+
+    @memory.cache(ignore=['y'])
+    def z(x, y=1):
+        accumulator.append(1)
+
+    assert z.ignore == ['y']
+
+    z(0, y=1)
+    assert len(accumulator) == 1
+    z(0, y=1)
+    assert len(accumulator) == 1
+    z(0, y=2)
+    assert len(accumulator) == 1
+
+
+def test_memory_ignore_decorated(tmpdir):
+    " Test the ignore feature of memory on a decorated function "
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    accumulator = list()
+
+    def decorate(f):
+        @functools.wraps(f)
+        def wrapped(*args, **kwargs):
+            return f(*args, **kwargs)
+        return wrapped
+
+    @memory.cache(ignore=['y'])
+    @decorate
+    def z(x, y=1):
+        accumulator.append(1)
+
+    assert z.ignore == ['y']
+
+    z(0, y=1)
+    assert len(accumulator) == 1
+    z(0, y=1)
+    assert len(accumulator) == 1
+    z(0, y=2)
+    assert len(accumulator) == 1
+
+
+def test_memory_args_as_kwargs(tmpdir):
+    """Non-regression test against 0.12.0 changes.
+
+    https://github.com/joblib/joblib/pull/751
+    """
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+
+    @memory.cache
+    def plus_one(a):
+        return a + 1
+
+    # It's possible to call a positional arg as a kwarg.
+    assert plus_one(1) == 2
+    assert plus_one(a=1) == 2
+
+    # However, a positional argument that joblib hadn't seen
+    # before would cause a failure if it was passed as a kwarg.
+    assert plus_one(a=2) == 3
+
+
+@parametrize('ignore, verbose, mmap_mode', [(['x'], 100, 'r'),
+                                            ([], 10, None)])
+def test_partial_decoration(tmpdir, ignore, verbose, mmap_mode):
+    "Check cache may be called with kwargs before decorating"
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+
+    @memory.cache(ignore=ignore, verbose=verbose, mmap_mode=mmap_mode)
+    def z(x):
+        pass
+
+    assert z.ignore == ignore
+    assert z._verbose == verbose
+    assert z.mmap_mode == mmap_mode
+
+
+def test_func_dir(tmpdir):
+    # Test the creation of the memory cache directory for the function.
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    path = __name__.split('.')
+    path.append('f')
+    path = tmpdir.join('joblib', *path).strpath
+
+    g = memory.cache(f)
+    # Test that the function directory is created on demand
+    func_id = _build_func_identifier(f)
+    location = os.path.join(g.store_backend.location, func_id)
+    assert location == path
+    assert os.path.exists(path)
+    assert memory.location == os.path.dirname(g.store_backend.location)
+
+    # Test that the code is stored.
+    # For the following test to be robust to previous execution, we clear
+    # the in-memory store
+    _FUNCTION_HASHES.clear()
+    assert not g._check_previous_func_code()
+    assert os.path.exists(os.path.join(path, 'func_code.py'))
+    assert g._check_previous_func_code()
+
+    # Test the robustness to failure of loading previous results.
+    args_id = g._get_args_id(1)
+    output_dir = os.path.join(g.store_backend.location, g.func_id, args_id)
+    a = g(1)
+    assert os.path.exists(output_dir)
+    os.remove(os.path.join(output_dir, 'output.pkl'))
+    assert a == g(1)
+
+
+def test_persistence(tmpdir):
+    # Test the memorized functions can be pickled and restored.
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    g = memory.cache(f)
+    output = g(1)
+
+    h = pickle.loads(pickle.dumps(g))
+
+    args_id = h._get_args_id(1)
+    output_dir = os.path.join(h.store_backend.location, h.func_id, args_id)
+    assert os.path.exists(output_dir)
+    assert output == h.store_backend.load_item([h.func_id, args_id])
+    memory2 = pickle.loads(pickle.dumps(memory))
+    assert memory.store_backend.location == memory2.store_backend.location
+
+    # Smoke test that pickling a memory with location=None works
+    memory = Memory(location=None, verbose=0)
+    pickle.loads(pickle.dumps(memory))
+    g = memory.cache(f)
+    gp = pickle.loads(pickle.dumps(g))
+    gp(1)
+
+
+def test_check_call_in_cache(tmpdir):
+    for func in (MemorizedFunc(f, tmpdir.strpath),
+                 Memory(location=tmpdir.strpath, verbose=0).cache(f)):
+        result = func.check_call_in_cache(2)
+        assert not result
+        assert isinstance(result, bool)
+        assert func(2) == 5
+        result = func.check_call_in_cache(2)
+        assert result
+        assert isinstance(result, bool)
+        func.clear()
+
+
+def test_call_and_shelve(tmpdir):
+    # Test MemorizedFunc outputting a reference to cache.
+
+    for func, Result in zip((MemorizedFunc(f, tmpdir.strpath),
+                             NotMemorizedFunc(f),
+                             Memory(location=tmpdir.strpath,
+                                    verbose=0).cache(f),
+                             Memory(location=None).cache(f),
+                             ),
+                            (MemorizedResult, NotMemorizedResult,
+                             MemorizedResult, NotMemorizedResult)):
+        assert func(2) == 5
+        result = func.call_and_shelve(2)
+        assert isinstance(result, Result)
+        assert result.get() == 5
+
+        result.clear()
+        with raises(KeyError):
+            result.get()
+        result.clear()  # Do nothing if there is no cache.
+
+
+def test_call_and_shelve_argument_hash(tmpdir):
+    # Verify that a warning is raised when accessing arguments_hash
+    # attribute from MemorizedResult
+    func = Memory(location=tmpdir.strpath, verbose=0).cache(f)
+    result = func.call_and_shelve(2)
+    assert isinstance(result, MemorizedResult)
+    with warns(DeprecationWarning) as w:
+        assert result.argument_hash == result.args_id
+    assert len(w) == 1
+    assert "The 'argument_hash' attribute has been deprecated" \
+        in str(w[-1].message)
+
+
+def test_call_and_shelve_lazily_load_stored_result(tmpdir):
+    """Check call_and_shelve only load stored data if needed."""
+    test_access_time_file = tmpdir.join('test_access')
+    test_access_time_file.write('test_access')
+    test_access_time = os.stat(test_access_time_file.strpath).st_atime
+    # check file system access time stats resolution is lower than test wait
+    # timings.
+    time.sleep(0.5)
+    assert test_access_time_file.read() == 'test_access'
+
+    if test_access_time == os.stat(test_access_time_file.strpath).st_atime:
+        # Skip this test when access time cannot be retrieved with enough
+        # precision from the file system (e.g. NTFS on windows).
+        pytest.skip("filesystem does not support fine-grained access time "
+                    "attribute")
+
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    func = memory.cache(f)
+    args_id = func._get_args_id(2)
+    result_path = os.path.join(memory.store_backend.location,
+                               func.func_id, args_id, 'output.pkl')
+    assert func(2) == 5
+    first_access_time = os.stat(result_path).st_atime
+    time.sleep(1)
+
+    # Should not access the stored data
+    result = func.call_and_shelve(2)
+    assert isinstance(result, MemorizedResult)
+    assert os.stat(result_path).st_atime == first_access_time
+    time.sleep(1)
+
+    # Read the stored data => last access time is greater than first_access
+    assert result.get() == 5
+    assert os.stat(result_path).st_atime > first_access_time
+
+
+def test_memorized_pickling(tmpdir):
+    for func in (MemorizedFunc(f, tmpdir.strpath), NotMemorizedFunc(f)):
+        filename = tmpdir.join('pickling_test.dat').strpath
+        result = func.call_and_shelve(2)
+        with open(filename, 'wb') as fp:
+            pickle.dump(result, fp)
+        with open(filename, 'rb') as fp:
+            result2 = pickle.load(fp)
+        assert result2.get() == result.get()
+        os.remove(filename)
+
+
+def test_memorized_repr(tmpdir):
+    func = MemorizedFunc(f, tmpdir.strpath)
+    result = func.call_and_shelve(2)
+
+    func2 = MemorizedFunc(f, tmpdir.strpath)
+    result2 = func2.call_and_shelve(2)
+    assert result.get() == result2.get()
+    assert repr(func) == repr(func2)
+
+    # Smoke test with NotMemorizedFunc
+    func = NotMemorizedFunc(f)
+    repr(func)
+    repr(func.call_and_shelve(2))
+
+    # Smoke test for message output (increase code coverage)
+    func = MemorizedFunc(f, tmpdir.strpath, verbose=11, timestamp=time.time())
+    result = func.call_and_shelve(11)
+    result.get()
+
+    func = MemorizedFunc(f, tmpdir.strpath, verbose=11)
+    result = func.call_and_shelve(11)
+    result.get()
+
+    func = MemorizedFunc(f, tmpdir.strpath, verbose=5, timestamp=time.time())
+    result = func.call_and_shelve(11)
+    result.get()
+
+    func = MemorizedFunc(f, tmpdir.strpath, verbose=5)
+    result = func.call_and_shelve(11)
+    result.get()
+
+
+def test_memory_file_modification(capsys, tmpdir, monkeypatch):
+    # Test that modifying a Python file after loading it does not lead to
+    # Recomputation
+    dir_name = tmpdir.mkdir('tmp_import').strpath
+    filename = os.path.join(dir_name, 'tmp_joblib_.py')
+    content = 'def f(x):\n    print(x)\n    return x\n'
+    with open(filename, 'w') as module_file:
+        module_file.write(content)
+
+    # Load the module:
+    monkeypatch.syspath_prepend(dir_name)
+    import tmp_joblib_ as tmp
+
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    f = memory.cache(tmp.f)
+    # First call f a few times
+    f(1)
+    f(2)
+    f(1)
+
+    # Now modify the module where f is stored without modifying f
+    with open(filename, 'w') as module_file:
+        module_file.write('\n\n' + content)
+
+    # And call f a couple more times
+    f(1)
+    f(1)
+
+    # Flush the .pyc files
+    shutil.rmtree(dir_name)
+    os.mkdir(dir_name)
+    # Now modify the module where f is stored, modifying f
+    content = 'def f(x):\n    print("x=%s" % x)\n    return x\n'
+    with open(filename, 'w') as module_file:
+        module_file.write(content)
+
+    # And call f more times prior to reloading: the cache should not be
+    # invalidated at this point as the active function definition has not
+    # changed in memory yet.
+    f(1)
+    f(1)
+
+    # Now reload
+    sys.stdout.write('Reloading\n')
+    sys.modules.pop('tmp_joblib_')
+    import tmp_joblib_ as tmp
+    f = memory.cache(tmp.f)
+
+    # And call f more times
+    f(1)
+    f(1)
+
+    out, err = capsys.readouterr()
+    assert out == '1\n2\nReloading\nx=1\n'
+
+
+def _function_to_cache(a, b):
+    # Just a place holder function to be mutated by tests
+    pass
+
+
+def _sum(a, b):
+    return a + b
+
+
+def _product(a, b):
+    return a * b
+
+
+def test_memory_in_memory_function_code_change(tmpdir):
+    _function_to_cache.__code__ = _sum.__code__
+
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    f = memory.cache(_function_to_cache)
+
+    assert f(1, 2) == 3
+    assert f(1, 2) == 3
+
+    with warns(JobLibCollisionWarning):
+        # Check that inline function modification triggers a cache invalidation
+        _function_to_cache.__code__ = _product.__code__
+        assert f(1, 2) == 2
+        assert f(1, 2) == 2
+
+
+def test_clear_memory_with_none_location():
+    memory = Memory(location=None)
+    memory.clear()
+
+
+def func_with_kwonly_args(a, b, *, kw1='kw1', kw2='kw2'):
+    return a, b, kw1, kw2
+
+
+def func_with_signature(a: int, b: float) -> float:
+    return a + b
+
+
+def test_memory_func_with_kwonly_args(tmpdir):
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    func_cached = memory.cache(func_with_kwonly_args)
+
+    assert func_cached(1, 2, kw1=3) == (1, 2, 3, 'kw2')
+
+    # Making sure that providing a keyword-only argument by
+    # position raises an exception
+    with raises(ValueError) as excinfo:
+        func_cached(1, 2, 3, kw2=4)
+    excinfo.match("Keyword-only parameter 'kw1' was passed as positional "
+                  "parameter")
+
+    # Keyword-only parameter passed by position with cached call
+    # should still raise ValueError
+    func_cached(1, 2, kw1=3, kw2=4)
+
+    with raises(ValueError) as excinfo:
+        func_cached(1, 2, 3, kw2=4)
+    excinfo.match("Keyword-only parameter 'kw1' was passed as positional "
+                  "parameter")
+
+    # Test 'ignore' parameter
+    func_cached = memory.cache(func_with_kwonly_args, ignore=['kw2'])
+    assert func_cached(1, 2, kw1=3, kw2=4) == (1, 2, 3, 4)
+    assert func_cached(1, 2, kw1=3, kw2='ignored') == (1, 2, 3, 4)
+
+
+def test_memory_func_with_signature(tmpdir):
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    func_cached = memory.cache(func_with_signature)
+
+    assert func_cached(1, 2.) == 3.
+
+
+def _setup_toy_cache(tmpdir, num_inputs=10):
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+
+    @memory.cache()
+    def get_1000_bytes(arg):
+        return 'a' * 1000
+
+    inputs = list(range(num_inputs))
+    for arg in inputs:
+        get_1000_bytes(arg)
+
+    func_id = _build_func_identifier(get_1000_bytes)
+    hash_dirnames = [get_1000_bytes._get_args_id(arg)
+                     for arg in inputs]
+
+    full_hashdirs = [os.path.join(get_1000_bytes.store_backend.location,
+                                  func_id, dirname)
+                     for dirname in hash_dirnames]
+    return memory, full_hashdirs, get_1000_bytes
+
+
+def test__get_items(tmpdir):
+    memory, expected_hash_dirs, _ = _setup_toy_cache(tmpdir)
+    items = memory.store_backend.get_items()
+    hash_dirs = [ci.path for ci in items]
+    assert set(hash_dirs) == set(expected_hash_dirs)
+
+    def get_files_size(directory):
+        full_paths = [os.path.join(directory, fn)
+                      for fn in os.listdir(directory)]
+        return sum(os.path.getsize(fp) for fp in full_paths)
+
+    expected_hash_cache_sizes = [get_files_size(hash_dir)
+                                 for hash_dir in hash_dirs]
+    hash_cache_sizes = [ci.size for ci in items]
+    assert hash_cache_sizes == expected_hash_cache_sizes
+
+    output_filenames = [os.path.join(hash_dir, 'output.pkl')
+                        for hash_dir in hash_dirs]
+
+    expected_last_accesses = [
+        datetime.datetime.fromtimestamp(os.path.getatime(fn))
+        for fn in output_filenames]
+    last_accesses = [ci.last_access for ci in items]
+    assert last_accesses == expected_last_accesses
+
+
+def test__get_items_to_delete(tmpdir):
+    # test empty cache
+    memory, _, _ = _setup_toy_cache(tmpdir, num_inputs=0)
+    items_to_delete = memory.store_backend._get_items_to_delete('1K')
+    assert items_to_delete == []
+
+    memory, expected_hash_cachedirs, _ = _setup_toy_cache(tmpdir)
+    items = memory.store_backend.get_items()
+    # bytes_limit set to keep only one cache item (each hash cache
+    # folder is about 1000 bytes + metadata)
+    items_to_delete = memory.store_backend._get_items_to_delete('2K')
+    nb_hashes = len(expected_hash_cachedirs)
+    assert set.issubset(set(items_to_delete), set(items))
+    assert len(items_to_delete) == nb_hashes - 1
+
+    # Sanity check bytes_limit=2048 is the same as bytes_limit='2K'
+    items_to_delete_2048b = memory.store_backend._get_items_to_delete(2048)
+    assert sorted(items_to_delete) == sorted(items_to_delete_2048b)
+
+    # bytes_limit greater than the size of the cache
+    items_to_delete_empty = memory.store_backend._get_items_to_delete('1M')
+    assert items_to_delete_empty == []
+
+    # All the cache items need to be deleted
+    bytes_limit_too_small = 500
+    items_to_delete_500b = memory.store_backend._get_items_to_delete(
+        bytes_limit_too_small
+    )
+    assert set(items_to_delete_500b), set(items)
+
+    # Test LRU property: surviving cache items should all have a more
+    # recent last_access that the ones that have been deleted
+    items_to_delete_6000b = memory.store_backend._get_items_to_delete(6000)
+    surviving_items = set(items).difference(items_to_delete_6000b)
+
+    assert (max(ci.last_access for ci in items_to_delete_6000b) <=
+            min(ci.last_access for ci in surviving_items))
+
+
+def test_memory_reduce_size_bytes_limit(tmpdir):
+    memory, _, _ = _setup_toy_cache(tmpdir)
+    ref_cache_items = memory.store_backend.get_items()
+
+    # By default memory.bytes_limit is None and reduce_size is a noop
+    memory.reduce_size()
+    cache_items = memory.store_backend.get_items()
+    assert sorted(ref_cache_items) == sorted(cache_items)
+
+    # No cache items deleted if bytes_limit greater than the size of
+    # the cache
+    memory.reduce_size(bytes_limit='1M')
+    cache_items = memory.store_backend.get_items()
+    assert sorted(ref_cache_items) == sorted(cache_items)
+
+    # bytes_limit is set so that only two cache items are kept
+    memory.reduce_size(bytes_limit='3K')
+    cache_items = memory.store_backend.get_items()
+    assert set.issubset(set(cache_items), set(ref_cache_items))
+    assert len(cache_items) == 2
+
+    # bytes_limit set so that no cache item is kept
+    bytes_limit_too_small = 500
+    memory.reduce_size(bytes_limit=bytes_limit_too_small)
+    cache_items = memory.store_backend.get_items()
+    assert cache_items == []
+
+
+def test_memory_reduce_size_items_limit(tmpdir):
+    memory, _, _ = _setup_toy_cache(tmpdir)
+    ref_cache_items = memory.store_backend.get_items()
+
+    # By default reduce_size is a noop
+    memory.reduce_size()
+    cache_items = memory.store_backend.get_items()
+    assert sorted(ref_cache_items) == sorted(cache_items)
+
+    # No cache items deleted if items_limit greater than the size of
+    # the cache
+    memory.reduce_size(items_limit=10)
+    cache_items = memory.store_backend.get_items()
+    assert sorted(ref_cache_items) == sorted(cache_items)
+
+    # items_limit is set so that only two cache items are kept
+    memory.reduce_size(items_limit=2)
+    cache_items = memory.store_backend.get_items()
+    assert set.issubset(set(cache_items), set(ref_cache_items))
+    assert len(cache_items) == 2
+
+    # item_limit set so that no cache item is kept
+    memory.reduce_size(items_limit=0)
+    cache_items = memory.store_backend.get_items()
+    assert cache_items == []
+
+
+def test_memory_reduce_size_age_limit(tmpdir):
+    import time
+    import datetime
+    memory, _, put_cache = _setup_toy_cache(tmpdir)
+    ref_cache_items = memory.store_backend.get_items()
+
+    # By default reduce_size is a noop
+    memory.reduce_size()
+    cache_items = memory.store_backend.get_items()
+    assert sorted(ref_cache_items) == sorted(cache_items)
+
+    # No cache items deleted if age_limit big.
+    memory.reduce_size(age_limit=datetime.timedelta(days=1))
+    cache_items = memory.store_backend.get_items()
+    assert sorted(ref_cache_items) == sorted(cache_items)
+
+    # age_limit is set so that only two cache items are kept
+    time.sleep(1)
+    put_cache(-1)
+    put_cache(-2)
+    memory.reduce_size(age_limit=datetime.timedelta(seconds=1))
+    cache_items = memory.store_backend.get_items()
+    assert not set.issubset(set(cache_items), set(ref_cache_items))
+    assert len(cache_items) == 2
+
+    # age_limit set so that no cache item is kept
+    memory.reduce_size(age_limit=datetime.timedelta(seconds=0))
+    cache_items = memory.store_backend.get_items()
+    assert cache_items == []
+
+
+def test_memory_clear(tmpdir):
+    memory, _, g = _setup_toy_cache(tmpdir)
+    memory.clear()
+
+    assert os.listdir(memory.store_backend.location) == []
+
+    # Check that the cache for functions hash is also reset.
+    assert not g._check_previous_func_code(stacklevel=4)
+
+
+def fast_func_with_complex_output():
+    complex_obj = ['a' * 1000] * 1000
+    return complex_obj
+
+
+def fast_func_with_conditional_complex_output(complex_output=True):
+    complex_obj = {str(i): i for i in range(int(1e5))}
+    return complex_obj if complex_output else 'simple output'
+
+
+@with_multiprocessing
+def test_cached_function_race_condition_when_persisting_output(tmpdir, capfd):
+    # Test race condition where multiple processes are writing into
+    # the same output.pkl. See
+    # https://github.com/joblib/joblib/issues/490 for more details.
+    memory = Memory(location=tmpdir.strpath)
+    func_cached = memory.cache(fast_func_with_complex_output)
+
+    Parallel(n_jobs=2)(delayed(func_cached)() for i in range(3))
+
+    stdout, stderr = capfd.readouterr()
+
+    # Checking both stdout and stderr (ongoing PR #434 may change
+    # logging destination) to make sure there is no exception while
+    # loading the results
+    exception_msg = 'Exception while loading results'
+    assert exception_msg not in stdout
+    assert exception_msg not in stderr
+
+
+@with_multiprocessing
+def test_cached_function_race_condition_when_persisting_output_2(tmpdir,
+                                                                 capfd):
+    # Test race condition in first attempt at solving
+    # https://github.com/joblib/joblib/issues/490. The race condition
+    # was due to the delay between seeing the cache directory created
+    # (interpreted as the result being cached) and the output.pkl being
+    # pickled.
+    memory = Memory(location=tmpdir.strpath)
+    func_cached = memory.cache(fast_func_with_conditional_complex_output)
+
+    Parallel(n_jobs=2)(delayed(func_cached)(True if i % 2 == 0 else False)
+                       for i in range(3))
+
+    stdout, stderr = capfd.readouterr()
+
+    # Checking both stdout and stderr (ongoing PR #434 may change
+    # logging destination) to make sure there is no exception while
+    # loading the results
+    exception_msg = 'Exception while loading results'
+    assert exception_msg not in stdout
+    assert exception_msg not in stderr
+
+
+def test_memory_recomputes_after_an_error_while_loading_results(
+        tmpdir, monkeypatch):
+    memory = Memory(location=tmpdir.strpath)
+
+    def func(arg):
+        # This makes sure that the timestamp returned by two calls of
+        # func are different. This is needed on Windows where
+        # time.time resolution may not be accurate enough
+        time.sleep(0.01)
+        return arg, time.time()
+
+    cached_func = memory.cache(func)
+    input_arg = 'arg'
+    arg, timestamp = cached_func(input_arg)
+
+    # Make sure the function is correctly cached
+    assert arg == input_arg
+
+    # Corrupting output.pkl to make sure that an error happens when
+    # loading the cached result
+    corrupt_single_cache_item(memory)
+
+    # Make sure that corrupting the file causes recomputation and that
+    # a warning is issued.
+    recorded_warnings = monkeypatch_cached_func_warn(cached_func, monkeypatch)
+    recomputed_arg, recomputed_timestamp = cached_func(arg)
+    assert len(recorded_warnings) == 1
+    exception_msg = 'Exception while loading results'
+    assert exception_msg in recorded_warnings[0]
+    assert recomputed_arg == arg
+    assert recomputed_timestamp > timestamp
+
+    # Corrupting output.pkl to make sure that an error happens when
+    # loading the cached result
+    corrupt_single_cache_item(memory)
+    reference = cached_func.call_and_shelve(arg)
+    try:
+        reference.get()
+        raise AssertionError(
+            "It normally not possible to load a corrupted"
+            " MemorizedResult"
+        )
+    except KeyError as e:
+        message = "is corrupted"
+        assert message in str(e.args)
+
+
+class IncompleteStoreBackend(StoreBackendBase):
+    """This backend cannot be instantiated and should raise a TypeError."""
+    pass
+
+
+class DummyStoreBackend(StoreBackendBase):
+    """A dummy store backend that does nothing."""
+
+    def _open_item(self, *args, **kwargs):
+        """Open an item on store."""
+        "Does nothing"
+
+    def _item_exists(self, location):
+        """Check if an item location exists."""
+        "Does nothing"
+
+    def _move_item(self, src, dst):
+        """Move an item from src to dst in store."""
+        "Does nothing"
+
+    def create_location(self, location):
+        """Create location on store."""
+        "Does nothing"
+
+    def exists(self, obj):
+        """Check if an object exists in the store"""
+        return False
+
+    def clear_location(self, obj):
+        """Clear object on store"""
+        "Does nothing"
+
+    def get_items(self):
+        """Returns the whole list of items available in cache."""
+        return []
+
+    def configure(self, location, *args, **kwargs):
+        """Configure the store"""
+        "Does nothing"
+
+
+@parametrize("invalid_prefix", [None, dict(), list()])
+def test_register_invalid_store_backends_key(invalid_prefix):
+    # verify the right exceptions are raised when passing a wrong backend key.
+    with raises(ValueError) as excinfo:
+        register_store_backend(invalid_prefix, None)
+    excinfo.match(r'Store backend name should be a string*')
+
+
+def test_register_invalid_store_backends_object():
+    # verify the right exceptions are raised when passing a wrong backend
+    # object.
+    with raises(ValueError) as excinfo:
+        register_store_backend("fs", None)
+    excinfo.match(r'Store backend should inherit StoreBackendBase*')
+
+
+def test_memory_default_store_backend():
+    # test an unknown backend falls back into a FileSystemStoreBackend
+    with raises(TypeError) as excinfo:
+        Memory(location='/tmp/joblib', backend='unknown')
+    excinfo.match(r"Unknown location*")
+
+
+def test_warning_on_unknown_location_type():
+    class NonSupportedLocationClass:
+        pass
+    unsupported_location = NonSupportedLocationClass()
+
+    with warns(UserWarning) as warninfo:
+        _store_backend_factory("local", location=unsupported_location)
+
+    expected_mesage = ("Instantiating a backend using a "
+                       "NonSupportedLocationClass as a location is not "
+                       "supported by joblib")
+    assert expected_mesage in str(warninfo[0].message)
+
+
+def test_instanciate_incomplete_store_backend():
+    # Verify that registering an external incomplete store backend raises an
+    # exception when one tries to instantiate it.
+    backend_name = "isb"
+    register_store_backend(backend_name, IncompleteStoreBackend)
+    assert (backend_name, IncompleteStoreBackend) in _STORE_BACKENDS.items()
+    with raises(TypeError) as excinfo:
+        _store_backend_factory(backend_name, "fake_location")
+    excinfo.match(r"Can't instantiate abstract class IncompleteStoreBackend "
+                  "(without an implementation for|with) abstract methods*")
+
+
+def test_dummy_store_backend():
+    # Verify that registering an external store backend works.
+
+    backend_name = "dsb"
+    register_store_backend(backend_name, DummyStoreBackend)
+    assert (backend_name, DummyStoreBackend) in _STORE_BACKENDS.items()
+
+    backend_obj = _store_backend_factory(backend_name, "dummy_location")
+    assert isinstance(backend_obj, DummyStoreBackend)
+
+
+def test_instanciate_store_backend_with_pathlib_path():
+    # Instantiate a FileSystemStoreBackend using a pathlib.Path object
+    path = pathlib.Path("some_folder")
+    backend_obj = _store_backend_factory("local", path)
+    assert backend_obj.location == "some_folder"
+
+
+def test_filesystem_store_backend_repr(tmpdir):
+    # Verify string representation of a filesystem store backend.
+
+    repr_pattern = 'FileSystemStoreBackend(location="{location}")'
+    backend = FileSystemStoreBackend()
+    assert backend.location is None
+
+    repr(backend)  # Should not raise an exception
+
+    assert str(backend) == repr_pattern.format(location=None)
+
+    # backend location is passed explicitly via the configure method (called
+    # by the internal _store_backend_factory function)
+    backend.configure(tmpdir.strpath)
+
+    assert str(backend) == repr_pattern.format(location=tmpdir.strpath)
+
+    repr(backend)  # Should not raise an exception
+
+
+def test_memory_objects_repr(tmpdir):
+    # Verify printable reprs of MemorizedResult, MemorizedFunc and Memory.
+
+    def my_func(a, b):
+        return a + b
+
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    memorized_func = memory.cache(my_func)
+
+    memorized_func_repr = 'MemorizedFunc(func={func}, location={location})'
+
+    assert str(memorized_func) == memorized_func_repr.format(
+        func=my_func,
+        location=memory.store_backend.location)
+
+    memorized_result = memorized_func.call_and_shelve(42, 42)
+
+    memorized_result_repr = ('MemorizedResult(location="{location}", '
+                             'func="{func}", args_id="{args_id}")')
+
+    assert str(memorized_result) == memorized_result_repr.format(
+        location=memory.store_backend.location,
+        func=memorized_result.func_id,
+        args_id=memorized_result.args_id)
+
+    assert str(memory) == 'Memory(location={location})'.format(
+        location=memory.store_backend.location)
+
+
+def test_memorized_result_pickle(tmpdir):
+    # Verify a MemoryResult object can be pickled/depickled. Non regression
+    # test introduced following issue
+    # https://github.com/joblib/joblib/issues/747
+
+    memory = Memory(location=tmpdir.strpath)
+
+    @memory.cache
+    def g(x):
+        return x**2
+
+    memorized_result = g.call_and_shelve(4)
+    memorized_result_pickle = pickle.dumps(memorized_result)
+    memorized_result_loads = pickle.loads(memorized_result_pickle)
+
+    assert memorized_result.store_backend.location == \
+        memorized_result_loads.store_backend.location
+    assert memorized_result.func == memorized_result_loads.func
+    assert memorized_result.args_id == memorized_result_loads.args_id
+    assert str(memorized_result) == str(memorized_result_loads)
+
+
+def compare(left, right, ignored_attrs=None):
+    if ignored_attrs is None:
+        ignored_attrs = []
+
+    left_vars = vars(left)
+    right_vars = vars(right)
+    assert set(left_vars.keys()) == set(right_vars.keys())
+    for attr in left_vars.keys():
+        if attr in ignored_attrs:
+            continue
+        assert left_vars[attr] == right_vars[attr]
+
+
+@pytest.mark.parametrize('memory_kwargs',
+                         [{'compress': 3, 'verbose': 2},
+                          {'mmap_mode': 'r', 'verbose': 5,
+                           'backend_options': {'parameter': 'unused'}}])
+def test_memory_pickle_dump_load(tmpdir, memory_kwargs):
+    memory = Memory(location=tmpdir.strpath, **memory_kwargs)
+
+    memory_reloaded = pickle.loads(pickle.dumps(memory))
+
+    # Compare Memory instance before and after pickle roundtrip
+    compare(memory.store_backend, memory_reloaded.store_backend)
+    compare(memory, memory_reloaded,
+            ignored_attrs=set(['store_backend', 'timestamp', '_func_code_id']))
+    assert hash(memory) == hash(memory_reloaded)
+
+    func_cached = memory.cache(f)
+
+    func_cached_reloaded = pickle.loads(pickle.dumps(func_cached))
+
+    # Compare MemorizedFunc instance before/after pickle roundtrip
+    compare(func_cached.store_backend, func_cached_reloaded.store_backend)
+    compare(func_cached, func_cached_reloaded,
+            ignored_attrs=set(['store_backend', 'timestamp', '_func_code_id']))
+    assert hash(func_cached) == hash(func_cached_reloaded)
+
+    # Compare MemorizedResult instance before/after pickle roundtrip
+    memorized_result = func_cached.call_and_shelve(1)
+    memorized_result_reloaded = pickle.loads(pickle.dumps(memorized_result))
+
+    compare(memorized_result.store_backend,
+            memorized_result_reloaded.store_backend)
+    compare(memorized_result, memorized_result_reloaded,
+            ignored_attrs=set(['store_backend', 'timestamp', '_func_code_id']))
+    assert hash(memorized_result) == hash(memorized_result_reloaded)
+
+
+def test_info_log(tmpdir, caplog):
+    caplog.set_level(logging.INFO)
+    x = 3
+
+    memory = Memory(location=tmpdir.strpath, verbose=20)
+
+    @memory.cache
+    def f(x):
+        return x ** 2
+
+    _ = f(x)
+    assert "Querying" in caplog.text
+    caplog.clear()
+
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+
+    @memory.cache
+    def f(x):
+        return x ** 2
+
+    _ = f(x)
+    assert "Querying" not in caplog.text
+    caplog.clear()
+
+
+def test_deprecated_bytes_limit(tmpdir):
+    from joblib import __version__
+    if __version__ >= "1.5":
+        raise DeprecationWarning(
+            "Bytes limit is deprecated and should be removed by 1.4"
+        )
+    with pytest.warns(DeprecationWarning, match="bytes_limit"):
+        _ = Memory(location=tmpdir.strpath, bytes_limit='1K')
+
+
+class TestCacheValidationCallback:
+    "Tests on parameter `cache_validation_callback`"
+
+    def foo(self, x, d, delay=None):
+        d["run"] = True
+        if delay is not None:
+            time.sleep(delay)
+        return x * 2
+
+    def test_invalid_cache_validation_callback(self, memory):
+        "Test invalid values for `cache_validation_callback"
+        match = "cache_validation_callback needs to be callable. Got True."
+        with pytest.raises(ValueError, match=match):
+            memory.cache(cache_validation_callback=True)
+
+    @pytest.mark.parametrize("consider_cache_valid", [True, False])
+    def test_constant_cache_validation_callback(
+            self, memory, consider_cache_valid
+    ):
+        "Test expiry of old results"
+        f = memory.cache(
+            self.foo, cache_validation_callback=lambda _: consider_cache_valid,
+            ignore=["d"]
+        )
+
+        d1, d2 = {"run": False}, {"run": False}
+        assert f(2, d1) == 4
+        assert f(2, d2) == 4
+
+        assert d1["run"]
+        assert d2["run"] != consider_cache_valid
+
+    def test_memory_only_cache_long_run(self, memory):
+        "Test cache validity based on run duration."
+
+        def cache_validation_callback(metadata):
+            duration = metadata['duration']
+            if duration > 0.1:
+                return True
+
+        f = memory.cache(
+            self.foo, cache_validation_callback=cache_validation_callback,
+            ignore=["d"]
+        )
+
+        # Short run are not cached
+        d1, d2 = {"run": False}, {"run": False}
+        assert f(2, d1, delay=0) == 4
+        assert f(2, d2, delay=0) == 4
+        assert d1["run"]
+        assert d2["run"]
+
+        # Longer run are cached
+        d1, d2 = {"run": False}, {"run": False}
+        assert f(2, d1, delay=0.2) == 4
+        assert f(2, d2, delay=0.2) == 4
+        assert d1["run"]
+        assert not d2["run"]
+
+    def test_memory_expires_after(self, memory):
+        "Test expiry of old cached results"
+
+        f = memory.cache(
+            self.foo, cache_validation_callback=expires_after(seconds=.3),
+            ignore=["d"]
+        )
+
+        d1, d2, d3 = {"run": False}, {"run": False}, {"run": False}
+        assert f(2, d1) == 4
+        assert f(2, d2) == 4
+        time.sleep(.5)
+        assert f(2, d3) == 4
+
+        assert d1["run"]
+        assert not d2["run"]
+        assert d3["run"]
+
+
+class TestMemorizedFunc:
+    "Tests for the MemorizedFunc and NotMemorizedFunc classes"
+
+    @staticmethod
+    def f(x, counter):
+        counter[x] = counter.get(x, 0) + 1
+        return counter[x]
+
+    def test_call_method_memorized(self, memory):
+        "Test calling the function"
+
+        f = memory.cache(self.f, ignore=['counter'])
+
+        counter = {}
+        assert f(2, counter) == 1
+        assert f(2, counter) == 1
+
+        x, meta = f.call(2, counter)
+        assert x == 2, "f has not been called properly"
+        assert isinstance(meta, dict), (
+            "Metadata are not returned by MemorizedFunc.call."
+        )
+
+    def test_call_method_not_memorized(self, memory):
+        "Test calling the function"
+
+        f = NotMemorizedFunc(self.f)
+
+        counter = {}
+        assert f(2, counter) == 1
+        assert f(2, counter) == 2
+
+        x, meta = f.call(2, counter)
+        assert x == 3, "f has not been called properly"
+        assert isinstance(meta, dict), (
+            "Metadata are not returned by MemorizedFunc.call."
+        )
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_memory_async.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_memory_async.py
new file mode 100644
index 0000000000000000000000000000000000000000..53ddeffda4a3e75590d0d02a3628d0d1e81ab6a2
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_memory_async.py
@@ -0,0 +1,170 @@
+import asyncio
+import gc
+import shutil
+
+import pytest
+
+from joblib.memory import (AsyncMemorizedFunc, AsyncNotMemorizedFunc,
+                           MemorizedResult, Memory, NotMemorizedResult)
+from joblib.test.common import np, with_numpy
+from joblib.testing import raises
+
+from .test_memory import (corrupt_single_cache_item,
+                          monkeypatch_cached_func_warn)
+
+
+async def check_identity_lazy_async(func, accumulator, location):
+    """ Similar to check_identity_lazy_async for coroutine functions"""
+    memory = Memory(location=location, verbose=0)
+    func = memory.cache(func)
+    for i in range(3):
+        for _ in range(2):
+            value = await func(i)
+            assert value == i
+            assert len(accumulator) == i + 1
+
+
+@pytest.mark.asyncio
+async def test_memory_integration_async(tmpdir):
+    accumulator = list()
+
+    async def f(n):
+        await asyncio.sleep(0.1)
+        accumulator.append(1)
+        return n
+
+    await check_identity_lazy_async(f, accumulator, tmpdir.strpath)
+
+    # Now test clearing
+    for compress in (False, True):
+        for mmap_mode in ('r', None):
+            memory = Memory(location=tmpdir.strpath, verbose=10,
+                            mmap_mode=mmap_mode, compress=compress)
+            # First clear the cache directory, to check that our code can
+            # handle that
+            # NOTE: this line would raise an exception, as the database
+            # file is still open; we ignore the error since we want to
+            # test what happens if the directory disappears
+            shutil.rmtree(tmpdir.strpath, ignore_errors=True)
+            g = memory.cache(f)
+            await g(1)
+            g.clear(warn=False)
+            current_accumulator = len(accumulator)
+            out = await g(1)
+
+        assert len(accumulator) == current_accumulator + 1
+        # Also, check that Memory.eval works similarly
+        evaled = await memory.eval(f, 1)
+        assert evaled == out
+        assert len(accumulator) == current_accumulator + 1
+
+    # Now do a smoke test with a function defined in __main__, as the name
+    # mangling rules are more complex
+    f.__module__ = '__main__'
+    memory = Memory(location=tmpdir.strpath, verbose=0)
+    await memory.cache(f)(1)
+
+
+@pytest.mark.asyncio
+async def test_no_memory_async():
+    accumulator = list()
+
+    async def ff(x):
+        await asyncio.sleep(0.1)
+        accumulator.append(1)
+        return x
+
+    memory = Memory(location=None, verbose=0)
+    gg = memory.cache(ff)
+    for _ in range(4):
+        current_accumulator = len(accumulator)
+        await gg(1)
+        assert len(accumulator) == current_accumulator + 1
+
+
+@with_numpy
+@pytest.mark.asyncio
+async def test_memory_numpy_check_mmap_mode_async(tmpdir, monkeypatch):
+    """Check that mmap_mode is respected even at the first call"""
+
+    memory = Memory(location=tmpdir.strpath, mmap_mode='r', verbose=0)
+
+    @memory.cache()
+    async def twice(a):
+        return a * 2
+
+    a = np.ones(3)
+    b = await twice(a)
+    c = await twice(a)
+
+    assert isinstance(c, np.memmap)
+    assert c.mode == 'r'
+
+    assert isinstance(b, np.memmap)
+    assert b.mode == 'r'
+
+    # Corrupts the file,  Deleting b and c mmaps
+    # is necessary to be able edit the file
+    del b
+    del c
+    gc.collect()
+    corrupt_single_cache_item(memory)
+
+    # Make sure that corrupting the file causes recomputation and that
+    # a warning is issued.
+    recorded_warnings = monkeypatch_cached_func_warn(twice, monkeypatch)
+    d = await twice(a)
+    assert len(recorded_warnings) == 1
+    exception_msg = 'Exception while loading results'
+    assert exception_msg in recorded_warnings[0]
+    # Asserts that the recomputation returns a mmap
+    assert isinstance(d, np.memmap)
+    assert d.mode == 'r'
+
+
+@pytest.mark.asyncio
+async def test_call_and_shelve_async(tmpdir):
+    async def f(x, y=1):
+        await asyncio.sleep(0.1)
+        return x ** 2 + y
+
+    # Test MemorizedFunc outputting a reference to cache.
+    for func, Result in zip((AsyncMemorizedFunc(f, tmpdir.strpath),
+                             AsyncNotMemorizedFunc(f),
+                             Memory(location=tmpdir.strpath,
+                                    verbose=0).cache(f),
+                             Memory(location=None).cache(f),
+                             ),
+                            (MemorizedResult, NotMemorizedResult,
+                             MemorizedResult, NotMemorizedResult,
+                             )):
+        for _ in range(2):
+            result = await func.call_and_shelve(2)
+            assert isinstance(result, Result)
+            assert result.get() == 5
+
+        result.clear()
+        with raises(KeyError):
+            result.get()
+        result.clear()  # Do nothing if there is no cache.
+
+
+@pytest.mark.asyncio
+async def test_memorized_func_call_async(memory):
+
+    async def ff(x, counter):
+        await asyncio.sleep(0.1)
+        counter[x] = counter.get(x, 0) + 1
+        return counter[x]
+
+    gg = memory.cache(ff, ignore=['counter'])
+
+    counter = {}
+    assert await gg(2, counter) == 1
+    assert await gg(2, counter) == 1
+
+    x, meta = await gg.call(2, counter)
+    assert x == 2, "f has not been called properly"
+    assert isinstance(meta, dict), (
+        "Metadata are not returned by MemorizedFunc.call."
+    )
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_missing_multiprocessing.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_missing_multiprocessing.py
new file mode 100644
index 0000000000000000000000000000000000000000..251925ced5208b4aaf09d9aab305eb44c7102818
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_missing_multiprocessing.py
@@ -0,0 +1,32 @@
+"""
+Pyodide and other single-threaded Python builds will be missing the
+_multiprocessing module. Test that joblib still works in this environment.
+"""
+
+import os
+import subprocess
+import sys
+
+
+def test_missing_multiprocessing(tmp_path):
+    """
+    Test that import joblib works even if _multiprocessing is missing.
+
+    pytest has already imported everything from joblib. The most reasonable way
+    to test importing joblib with modified environment is to invoke a separate
+    Python process. This also ensures that we don't break other tests by
+    importing a bad `_multiprocessing` module.
+    """
+    (tmp_path / "_multiprocessing.py").write_text(
+        'raise ImportError("No _multiprocessing module!")'
+    )
+    env = dict(os.environ)
+    # For subprocess, use current sys.path with our custom version of
+    # multiprocessing inserted.
+    env["PYTHONPATH"] = ":".join([str(tmp_path)] + sys.path)
+    subprocess.check_call(
+        [sys.executable, "-c",
+         "import joblib, math; "
+         "joblib.Parallel(n_jobs=1)("
+         "joblib.delayed(math.sqrt)(i**2) for i in range(10))"
+         ], env=env)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_module.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_module.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2257a4142d79996f3d299cb820927ae48a05810
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_module.py
@@ -0,0 +1,53 @@
+import sys
+import joblib
+from joblib.testing import check_subprocess_call
+from joblib.test.common import with_multiprocessing
+
+
+def test_version():
+    assert hasattr(joblib, '__version__'), (
+        "There are no __version__ argument on the joblib module")
+
+
+@with_multiprocessing
+def test_no_start_method_side_effect_on_import():
+    # check that importing joblib does not implicitly set the global
+    # start_method for multiprocessing.
+    code = """if True:
+        import joblib
+        import multiprocessing as mp
+        # The following line would raise RuntimeError if the
+        # start_method is already set.
+        mp.set_start_method("loky")
+    """
+    check_subprocess_call([sys.executable, '-c', code])
+
+
+@with_multiprocessing
+def test_no_semaphore_tracker_on_import():
+    # check that importing joblib does not implicitly spawn a resource tracker
+    # or a semaphore tracker
+    code = """if True:
+        import joblib
+        from multiprocessing import semaphore_tracker
+        # The following line would raise RuntimeError if the
+        # start_method is already set.
+        msg = "multiprocessing.semaphore_tracker has been spawned on import"
+        assert semaphore_tracker._semaphore_tracker._fd is None, msg"""
+    if sys.version_info >= (3, 8):
+        # semaphore_tracker was renamed in Python 3.8:
+        code = code.replace("semaphore_tracker", "resource_tracker")
+    check_subprocess_call([sys.executable, '-c', code])
+
+
+@with_multiprocessing
+def test_no_resource_tracker_on_import():
+    code = """if True:
+        import joblib
+        from joblib.externals.loky.backend import resource_tracker
+        # The following line would raise RuntimeError if the
+        # start_method is already set.
+        msg = "loky.resource_tracker has been spawned on import"
+        assert resource_tracker._resource_tracker._fd is None, msg
+    """
+    check_subprocess_call([sys.executable, '-c', code])
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_numpy_pickle.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_numpy_pickle.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fee585c79ad219d3a9f8cdc6a55655b50099c09
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_numpy_pickle.py
@@ -0,0 +1,1159 @@
+"""Test the numpy pickler as a replacement of the standard pickler."""
+
+import copy
+import os
+import random
+import re
+import io
+import sys
+import warnings
+import gzip
+import zlib
+import bz2
+import pickle
+import socket
+from contextlib import closing
+import mmap
+from pathlib import Path
+
+try:
+    import lzma
+except ImportError:
+    lzma = None
+
+import pytest
+
+from joblib.test.common import np, with_numpy, with_lz4, without_lz4
+from joblib.test.common import with_memory_profiler, memory_used
+from joblib.testing import parametrize, raises, warns
+
+# numpy_pickle is not a drop-in replacement of pickle, as it takes
+# filenames instead of open files as arguments.
+from joblib import numpy_pickle, register_compressor
+from joblib.test import data
+
+from joblib.numpy_pickle_utils import _IO_BUFFER_SIZE
+from joblib.numpy_pickle_utils import _detect_compressor
+from joblib.numpy_pickle_utils import _is_numpy_array_byte_order_mismatch
+from joblib.numpy_pickle_utils import _ensure_native_byte_order
+from joblib.compressor import (_COMPRESSORS, _LZ4_PREFIX, CompressorWrapper,
+                               LZ4_NOT_INSTALLED_ERROR, BinaryZlibFile)
+
+
+###############################################################################
+# Define a list of standard types.
+# Borrowed from dill, initial author: Micheal McKerns:
+# http://dev.danse.us/trac/pathos/browser/dill/dill_test2.py
+
+typelist = []
+
+# testing types
+_none = None
+typelist.append(_none)
+_type = type
+typelist.append(_type)
+_bool = bool(1)
+typelist.append(_bool)
+_int = int(1)
+typelist.append(_int)
+_float = float(1)
+typelist.append(_float)
+_complex = complex(1)
+typelist.append(_complex)
+_string = str(1)
+typelist.append(_string)
+_tuple = ()
+typelist.append(_tuple)
+_list = []
+typelist.append(_list)
+_dict = {}
+typelist.append(_dict)
+_builtin = len
+typelist.append(_builtin)
+
+
+def _function(x):
+    yield x
+
+
+class _class:
+    def _method(self):
+        pass
+
+
+class _newclass(object):
+    def _method(self):
+        pass
+
+
+typelist.append(_function)
+typelist.append(_class)
+typelist.append(_newclass)  # <type 'type'>
+_instance = _class()
+typelist.append(_instance)
+_object = _newclass()
+typelist.append(_object)  # <type 'class'>
+
+
+###############################################################################
+# Tests
+
+@parametrize('compress', [0, 1])
+@parametrize('member', typelist)
+def test_standard_types(tmpdir, compress, member):
+    # Test pickling and saving with standard types.
+    filename = tmpdir.join('test.pkl').strpath
+    numpy_pickle.dump(member, filename, compress=compress)
+    _member = numpy_pickle.load(filename)
+    # We compare the pickled instance to the reloaded one only if it
+    # can be compared to a copied one
+    if member == copy.deepcopy(member):
+        assert member == _member
+
+
+def test_value_error():
+    # Test inverting the input arguments to dump
+    with raises(ValueError):
+        numpy_pickle.dump('foo', dict())
+
+
+@parametrize('wrong_compress', [-1, 10, dict()])
+def test_compress_level_error(wrong_compress):
+    # Verify that passing an invalid compress argument raises an error.
+    exception_msg = ('Non valid compress level given: '
+                     '"{0}"'.format(wrong_compress))
+    with raises(ValueError) as excinfo:
+        numpy_pickle.dump('dummy', 'foo', compress=wrong_compress)
+    excinfo.match(exception_msg)
+
+
+@with_numpy
+@parametrize('compress', [False, True, 0, 3, 'zlib'])
+def test_numpy_persistence(tmpdir, compress):
+    filename = tmpdir.join('test.pkl').strpath
+    rnd = np.random.RandomState(0)
+    a = rnd.random_sample((10, 2))
+    # We use 'a.T' to have a non C-contiguous array.
+    for index, obj in enumerate(((a,), (a.T,), (a, a), [a, a, a])):
+        filenames = numpy_pickle.dump(obj, filename, compress=compress)
+
+        # All is cached in one file
+        assert len(filenames) == 1
+        # Check that only one file was created
+        assert filenames[0] == filename
+        # Check that this file does exist
+        assert os.path.exists(filenames[0])
+
+        # Unpickle the object
+        obj_ = numpy_pickle.load(filename)
+        # Check that the items are indeed arrays
+        for item in obj_:
+            assert isinstance(item, np.ndarray)
+        # And finally, check that all the values are equal.
+        np.testing.assert_array_equal(np.array(obj), np.array(obj_))
+
+    # Now test with an array subclass
+    obj = np.memmap(filename + 'mmap', mode='w+', shape=4, dtype=np.float64)
+    filenames = numpy_pickle.dump(obj, filename, compress=compress)
+    # All is cached in one file
+    assert len(filenames) == 1
+
+    obj_ = numpy_pickle.load(filename)
+    if (type(obj) is not np.memmap and
+            hasattr(obj, '__array_prepare__')):
+        # We don't reconstruct memmaps
+        assert isinstance(obj_, type(obj))
+
+    np.testing.assert_array_equal(obj_, obj)
+
+    # Test with an object containing multiple numpy arrays
+    obj = ComplexTestObject()
+    filenames = numpy_pickle.dump(obj, filename, compress=compress)
+    # All is cached in one file
+    assert len(filenames) == 1
+
+    obj_loaded = numpy_pickle.load(filename)
+    assert isinstance(obj_loaded, type(obj))
+    np.testing.assert_array_equal(obj_loaded.array_float, obj.array_float)
+    np.testing.assert_array_equal(obj_loaded.array_int, obj.array_int)
+    np.testing.assert_array_equal(obj_loaded.array_obj, obj.array_obj)
+
+
+@with_numpy
+def test_numpy_persistence_bufferred_array_compression(tmpdir):
+    big_array = np.ones((_IO_BUFFER_SIZE + 100), dtype=np.uint8)
+    filename = tmpdir.join('test.pkl').strpath
+    numpy_pickle.dump(big_array, filename, compress=True)
+    arr_reloaded = numpy_pickle.load(filename)
+
+    np.testing.assert_array_equal(big_array, arr_reloaded)
+
+
+@with_numpy
+def test_memmap_persistence(tmpdir):
+    rnd = np.random.RandomState(0)
+    a = rnd.random_sample(10)
+    filename = tmpdir.join('test1.pkl').strpath
+    numpy_pickle.dump(a, filename)
+    b = numpy_pickle.load(filename, mmap_mode='r')
+
+    assert isinstance(b, np.memmap)
+
+    # Test with an object containing multiple numpy arrays
+    filename = tmpdir.join('test2.pkl').strpath
+    obj = ComplexTestObject()
+    numpy_pickle.dump(obj, filename)
+    obj_loaded = numpy_pickle.load(filename, mmap_mode='r')
+    assert isinstance(obj_loaded, type(obj))
+    assert isinstance(obj_loaded.array_float, np.memmap)
+    assert not obj_loaded.array_float.flags.writeable
+    assert isinstance(obj_loaded.array_int, np.memmap)
+    assert not obj_loaded.array_int.flags.writeable
+    # Memory map not allowed for numpy object arrays
+    assert not isinstance(obj_loaded.array_obj, np.memmap)
+    np.testing.assert_array_equal(obj_loaded.array_float,
+                                  obj.array_float)
+    np.testing.assert_array_equal(obj_loaded.array_int,
+                                  obj.array_int)
+    np.testing.assert_array_equal(obj_loaded.array_obj,
+                                  obj.array_obj)
+
+    # Test we can write in memmapped arrays
+    obj_loaded = numpy_pickle.load(filename, mmap_mode='r+')
+    assert obj_loaded.array_float.flags.writeable
+    obj_loaded.array_float[0:10] = 10.0
+    assert obj_loaded.array_int.flags.writeable
+    obj_loaded.array_int[0:10] = 10
+
+    obj_reloaded = numpy_pickle.load(filename, mmap_mode='r')
+    np.testing.assert_array_equal(obj_reloaded.array_float,
+                                  obj_loaded.array_float)
+    np.testing.assert_array_equal(obj_reloaded.array_int,
+                                  obj_loaded.array_int)
+
+    # Test w+ mode is caught and the mode has switched to r+
+    numpy_pickle.load(filename, mmap_mode='w+')
+    assert obj_loaded.array_int.flags.writeable
+    assert obj_loaded.array_int.mode == 'r+'
+    assert obj_loaded.array_float.flags.writeable
+    assert obj_loaded.array_float.mode == 'r+'
+
+
+@with_numpy
+def test_memmap_persistence_mixed_dtypes(tmpdir):
+    # loading datastructures that have sub-arrays with dtype=object
+    # should not prevent memmapping on fixed size dtype sub-arrays.
+    rnd = np.random.RandomState(0)
+    a = rnd.random_sample(10)
+    b = np.array([1, 'b'], dtype=object)
+    construct = (a, b)
+    filename = tmpdir.join('test.pkl').strpath
+    numpy_pickle.dump(construct, filename)
+    a_clone, b_clone = numpy_pickle.load(filename, mmap_mode='r')
+
+    # the floating point array has been memory mapped
+    assert isinstance(a_clone, np.memmap)
+
+    # the object-dtype array has been loaded in memory
+    assert not isinstance(b_clone, np.memmap)
+
+
+@with_numpy
+def test_masked_array_persistence(tmpdir):
+    # The special-case picker fails, because saving masked_array
+    # not implemented, but it just delegates to the standard pickler.
+    rnd = np.random.RandomState(0)
+    a = rnd.random_sample(10)
+    a = np.ma.masked_greater(a, 0.5)
+    filename = tmpdir.join('test.pkl').strpath
+    numpy_pickle.dump(a, filename)
+    b = numpy_pickle.load(filename, mmap_mode='r')
+    assert isinstance(b, np.ma.masked_array)
+
+
+@with_numpy
+def test_compress_mmap_mode_warning(tmpdir):
+    # Test the warning in case of compress + mmap_mode
+    rnd = np.random.RandomState(0)
+    a = rnd.random_sample(10)
+    this_filename = tmpdir.join('test.pkl').strpath
+    numpy_pickle.dump(a, this_filename, compress=1)
+    with warns(UserWarning) as warninfo:
+        numpy_pickle.load(this_filename, mmap_mode='r+')
+    debug_msg = "\n".join([str(w) for w in warninfo])
+    warninfo = [w.message for w in warninfo]
+    assert len(warninfo) == 1, debug_msg
+    assert (
+        str(warninfo[0]) ==
+        'mmap_mode "r+" is not compatible with compressed '
+        f'file {this_filename}. "r+" flag will be ignored.'
+    )
+
+
+@with_numpy
+@parametrize('cache_size', [None, 0, 10])
+def test_cache_size_warning(tmpdir, cache_size):
+    # Check deprecation warning raised when cache size is not None
+    filename = tmpdir.join('test.pkl').strpath
+    rnd = np.random.RandomState(0)
+    a = rnd.random_sample((10, 2))
+
+    warnings.simplefilter("always")
+    with warnings.catch_warnings(record=True) as warninfo:
+        numpy_pickle.dump(a, filename, cache_size=cache_size)
+    expected_nb_warnings = 1 if cache_size is not None else 0
+    assert len(warninfo) == expected_nb_warnings
+    for w in warninfo:
+        assert w.category == DeprecationWarning
+        assert (str(w.message) ==
+                "Please do not set 'cache_size' in joblib.dump, this "
+                "parameter has no effect and will be removed. You "
+                "used 'cache_size={0}'".format(cache_size))
+
+
+@with_numpy
+@with_memory_profiler
+@parametrize('compress', [True, False])
+def test_memory_usage(tmpdir, compress):
+    # Verify memory stays within expected bounds.
+    filename = tmpdir.join('test.pkl').strpath
+    small_array = np.ones((10, 10))
+    big_array = np.ones(shape=100 * int(1e6), dtype=np.uint8)
+
+    for obj in (small_array, big_array):
+        size = obj.nbytes / 1e6
+        obj_filename = filename + str(np.random.randint(0, 1000))
+        mem_used = memory_used(numpy_pickle.dump,
+                               obj, obj_filename, compress=compress)
+
+        # The memory used to dump the object shouldn't exceed the buffer
+        # size used to write array chunks (16MB).
+        write_buf_size = _IO_BUFFER_SIZE + 16 * 1024 ** 2 / 1e6
+        assert mem_used <= write_buf_size
+
+        mem_used = memory_used(numpy_pickle.load, obj_filename)
+        # memory used should be less than array size + buffer size used to
+        # read the array chunk by chunk.
+        read_buf_size = 32 + _IO_BUFFER_SIZE  # MiB
+        assert mem_used < size + read_buf_size
+
+
+@with_numpy
+def test_compressed_pickle_dump_and_load(tmpdir):
+    expected_list = [np.arange(5, dtype=np.dtype('<i8')),
+                     np.arange(5, dtype=np.dtype('>i8')),
+                     np.arange(5, dtype=np.dtype('<f8')),
+                     np.arange(5, dtype=np.dtype('>f8')),
+                     np.array([1, 'abc', {'a': 1, 'b': 2}], dtype='O'),
+                     np.arange(256, dtype=np.uint8).tobytes(),
+                     u"C'est l'\xe9t\xe9 !"]
+
+    fname = tmpdir.join('temp.pkl.gz').strpath
+
+    dumped_filenames = numpy_pickle.dump(expected_list, fname, compress=1)
+    assert len(dumped_filenames) == 1
+    result_list = numpy_pickle.load(fname)
+    for result, expected in zip(result_list, expected_list):
+        if isinstance(expected, np.ndarray):
+            expected = _ensure_native_byte_order(expected)
+            assert result.dtype == expected.dtype
+            np.testing.assert_equal(result, expected)
+        else:
+            assert result == expected
+
+
+def _check_pickle(filename, expected_list, mmap_mode=None):
+    """Helper function to test joblib pickle content.
+
+    Note: currently only pickles containing an iterable are supported
+    by this function.
+    """
+    version_match = re.match(r'.+py(\d)(\d).+', filename)
+    py_version_used_for_writing = int(version_match.group(1))
+
+    py_version_to_default_pickle_protocol = {2: 2, 3: 3}
+    pickle_reading_protocol = py_version_to_default_pickle_protocol.get(3, 4)
+    pickle_writing_protocol = py_version_to_default_pickle_protocol.get(
+        py_version_used_for_writing, 4)
+    if pickle_reading_protocol >= pickle_writing_protocol:
+        try:
+            with warnings.catch_warnings(record=True) as warninfo:
+                warnings.simplefilter('always')
+                warnings.filterwarnings(
+                    'ignore', module='numpy',
+                    message='The compiler package is deprecated')
+                result_list = numpy_pickle.load(filename, mmap_mode=mmap_mode)
+            filename_base = os.path.basename(filename)
+            expected_nb_deprecation_warnings = 1 if (
+                "_0.9" in filename_base or "_0.8.4" in filename_base) else 0
+
+            expected_nb_user_warnings = 3 if (
+                re.search("_0.1.+.pkl$", filename_base) and
+                mmap_mode is not None) else 0
+            expected_nb_warnings = \
+                expected_nb_deprecation_warnings + expected_nb_user_warnings
+            assert len(warninfo) == expected_nb_warnings
+
+            deprecation_warnings = [
+                w for w in warninfo if issubclass(
+                    w.category, DeprecationWarning)]
+            user_warnings = [
+                w for w in warninfo if issubclass(
+                    w.category, UserWarning)]
+            for w in deprecation_warnings:
+                assert (str(w.message) ==
+                        "The file '{0}' has been generated with a joblib "
+                        "version less than 0.10. Please regenerate this "
+                        "pickle file.".format(filename))
+
+            for w in user_warnings:
+                escaped_filename = re.escape(filename)
+                assert re.search(
+                    f"memmapped.+{escaped_filename}.+segmentation fault",
+                    str(w.message))
+
+            for result, expected in zip(result_list, expected_list):
+                if isinstance(expected, np.ndarray):
+                    expected = _ensure_native_byte_order(expected)
+                    assert result.dtype == expected.dtype
+                    np.testing.assert_equal(result, expected)
+                else:
+                    assert result == expected
+        except Exception as exc:
+            # When trying to read with python 3 a pickle generated
+            # with python 2 we expect a user-friendly error
+            if py_version_used_for_writing == 2:
+                assert isinstance(exc, ValueError)
+                message = ('You may be trying to read with '
+                           'python 3 a joblib pickle generated with python 2.')
+                assert message in str(exc)
+            elif filename.endswith('.lz4') and with_lz4.args[0]:
+                assert isinstance(exc, ValueError)
+                assert LZ4_NOT_INSTALLED_ERROR in str(exc)
+            else:
+                raise
+    else:
+        # Pickle protocol used for writing is too high. We expect a
+        # "unsupported pickle protocol" error message
+        try:
+            numpy_pickle.load(filename)
+            raise AssertionError('Numpy pickle loading should '
+                                 'have raised a ValueError exception')
+        except ValueError as e:
+            message = 'unsupported pickle protocol: {0}'.format(
+                pickle_writing_protocol)
+            assert message in str(e.args)
+
+
+@with_numpy
+def test_joblib_pickle_across_python_versions():
+    # We need to be specific about dtypes in particular endianness
+    # because the pickles can be generated on one architecture and
+    # the tests run on another one. See
+    # https://github.com/joblib/joblib/issues/279.
+    expected_list = [np.arange(5, dtype=np.dtype('<i8')),
+                     np.arange(5, dtype=np.dtype('<f8')),
+                     np.array([1, 'abc', {'a': 1, 'b': 2}], dtype='O'),
+                     np.arange(256, dtype=np.uint8).tobytes(),
+                     # np.matrix is a subclass of np.ndarray, here we want
+                     # to verify this type of object is correctly unpickled
+                     # among versions.
+                     np.matrix([0, 1, 2], dtype=np.dtype('<i8')),
+                     u"C'est l'\xe9t\xe9 !"]
+
+    # Testing all the compressed and non compressed
+    # pickles in joblib/test/data. These pickles were generated by
+    # the joblib/test/data/create_numpy_pickle.py script for the
+    # relevant python, joblib and numpy versions.
+    test_data_dir = os.path.dirname(os.path.abspath(data.__file__))
+
+    pickle_extensions = ('.pkl', '.gz', '.gzip', '.bz2', 'lz4')
+    if lzma is not None:
+        pickle_extensions += ('.xz', '.lzma')
+    pickle_filenames = [os.path.join(test_data_dir, fn)
+                        for fn in os.listdir(test_data_dir)
+                        if any(fn.endswith(ext) for ext in pickle_extensions)]
+
+    for fname in pickle_filenames:
+        _check_pickle(fname, expected_list)
+
+
+@with_numpy
+def test_joblib_pickle_across_python_versions_with_mmap():
+    expected_list = [np.arange(5, dtype=np.dtype('<i8')),
+                     np.arange(5, dtype=np.dtype('<f8')),
+                     np.array([1, 'abc', {'a': 1, 'b': 2}], dtype='O'),
+                     np.arange(256, dtype=np.uint8).tobytes(),
+                     # np.matrix is a subclass of np.ndarray, here we want
+                     # to verify this type of object is correctly unpickled
+                     # among versions.
+                     np.matrix([0, 1, 2], dtype=np.dtype('<i8')),
+                     u"C'est l'\xe9t\xe9 !"]
+
+    test_data_dir = os.path.dirname(os.path.abspath(data.__file__))
+
+    pickle_filenames = [
+        os.path.join(test_data_dir, fn)
+        for fn in os.listdir(test_data_dir) if fn.endswith('.pkl')]
+    for fname in pickle_filenames:
+        _check_pickle(fname, expected_list, mmap_mode='r')
+
+
+@with_numpy
+def test_numpy_array_byte_order_mismatch_detection():
+    # List of numpy arrays with big endian byteorder.
+    be_arrays = [np.array([(1, 2.0), (3, 4.0)],
+                          dtype=[('', '>i8'), ('', '>f8')]),
+                 np.arange(3, dtype=np.dtype('>i8')),
+                 np.arange(3, dtype=np.dtype('>f8'))]
+
+    # Verify the byteorder mismatch is correctly detected.
+    for array in be_arrays:
+        if sys.byteorder == 'big':
+            assert not _is_numpy_array_byte_order_mismatch(array)
+        else:
+            assert _is_numpy_array_byte_order_mismatch(array)
+        converted = _ensure_native_byte_order(array)
+        if converted.dtype.fields:
+            for f in converted.dtype.fields.values():
+                f[0].byteorder == '='
+        else:
+            assert converted.dtype.byteorder == "="
+
+    # List of numpy arrays with little endian byteorder.
+    le_arrays = [np.array([(1, 2.0), (3, 4.0)],
+                          dtype=[('', '<i8'), ('', '<f8')]),
+                 np.arange(3, dtype=np.dtype('<i8')),
+                 np.arange(3, dtype=np.dtype('<f8'))]
+
+    # Verify the byteorder mismatch is correctly detected.
+    for array in le_arrays:
+        if sys.byteorder == 'little':
+            assert not _is_numpy_array_byte_order_mismatch(array)
+        else:
+            assert _is_numpy_array_byte_order_mismatch(array)
+        converted = _ensure_native_byte_order(array)
+        if converted.dtype.fields:
+            for f in converted.dtype.fields.values():
+                f[0].byteorder == '='
+        else:
+            assert converted.dtype.byteorder == "="
+
+
+@parametrize('compress_tuple', [('zlib', 3), ('gzip', 3)])
+def test_compress_tuple_argument(tmpdir, compress_tuple):
+    # Verify the tuple is correctly taken into account.
+    filename = tmpdir.join('test.pkl').strpath
+    numpy_pickle.dump("dummy", filename,
+                      compress=compress_tuple)
+    # Verify the file contains the right magic number
+    with open(filename, 'rb') as f:
+        assert _detect_compressor(f) == compress_tuple[0]
+
+
+@parametrize('compress_tuple,message',
+             [(('zlib', 3, 'extra'),        # wrong compress tuple
+               'Compress argument tuple should contain exactly 2 elements'),
+              (('wrong', 3),                # wrong compress method
+               'Non valid compression method given: "{}"'.format('wrong')),
+              (('zlib', 'wrong'),           # wrong compress level
+               'Non valid compress level given: "{}"'.format('wrong'))])
+def test_compress_tuple_argument_exception(tmpdir, compress_tuple, message):
+    filename = tmpdir.join('test.pkl').strpath
+    # Verify setting a wrong compress tuple raises a ValueError.
+    with raises(ValueError) as excinfo:
+        numpy_pickle.dump('dummy', filename, compress=compress_tuple)
+    excinfo.match(message)
+
+
+@parametrize('compress_string', ['zlib', 'gzip'])
+def test_compress_string_argument(tmpdir, compress_string):
+    # Verify the string is correctly taken into account.
+    filename = tmpdir.join('test.pkl').strpath
+    numpy_pickle.dump("dummy", filename,
+                      compress=compress_string)
+    # Verify the file contains the right magic number
+    with open(filename, 'rb') as f:
+        assert _detect_compressor(f) == compress_string
+
+
+@with_numpy
+@parametrize('compress', [1, 3, 6])
+@parametrize('cmethod', _COMPRESSORS)
+def test_joblib_compression_formats(tmpdir, compress, cmethod):
+    filename = tmpdir.join('test.pkl').strpath
+    objects = (np.ones(shape=(100, 100), dtype='f8'),
+               range(10),
+               {'a': 1, 2: 'b'}, [], (), {}, 0, 1.0)
+
+    if cmethod in ("lzma", "xz") and lzma is None:
+        pytest.skip("lzma is support not available")
+
+    elif cmethod == 'lz4' and with_lz4.args[0]:
+        # Skip the test if lz4 is not installed. We here use the with_lz4
+        # skipif fixture whose argument is True when lz4 is not installed
+        pytest.skip("lz4 is not installed.")
+
+    dump_filename = filename + "." + cmethod
+    for obj in objects:
+        numpy_pickle.dump(obj, dump_filename, compress=(cmethod, compress))
+        # Verify the file contains the right magic number
+        with open(dump_filename, 'rb') as f:
+            assert _detect_compressor(f) == cmethod
+        # Verify the reloaded object is correct
+        obj_reloaded = numpy_pickle.load(dump_filename)
+        assert isinstance(obj_reloaded, type(obj))
+        if isinstance(obj, np.ndarray):
+            np.testing.assert_array_equal(obj_reloaded, obj)
+        else:
+            assert obj_reloaded == obj
+
+
+def _gzip_file_decompress(source_filename, target_filename):
+    """Decompress a gzip file."""
+    with closing(gzip.GzipFile(source_filename, "rb")) as fo:
+        buf = fo.read()
+
+    with open(target_filename, "wb") as fo:
+        fo.write(buf)
+
+
+def _zlib_file_decompress(source_filename, target_filename):
+    """Decompress a zlib file."""
+    with open(source_filename, 'rb') as fo:
+        buf = zlib.decompress(fo.read())
+
+    with open(target_filename, 'wb') as fo:
+        fo.write(buf)
+
+
+@parametrize('extension,decompress',
+             [('.z', _zlib_file_decompress),
+              ('.gz', _gzip_file_decompress)])
+def test_load_externally_decompressed_files(tmpdir, extension, decompress):
+    # Test that BinaryZlibFile generates valid gzip and zlib compressed files.
+    obj = "a string to persist"
+    filename_raw = tmpdir.join('test.pkl').strpath
+
+    filename_compressed = filename_raw + extension
+    # Use automatic extension detection to compress with the right method.
+    numpy_pickle.dump(obj, filename_compressed)
+
+    # Decompress with the corresponding method
+    decompress(filename_compressed, filename_raw)
+
+    # Test that the uncompressed pickle can be loaded and
+    # that the result is correct.
+    obj_reloaded = numpy_pickle.load(filename_raw)
+    assert obj == obj_reloaded
+
+
+@parametrize('extension,cmethod',
+             # valid compressor extensions
+             [('.z', 'zlib'),
+              ('.gz', 'gzip'),
+              ('.bz2', 'bz2'),
+              ('.lzma', 'lzma'),
+              ('.xz', 'xz'),
+              # invalid compressor extensions
+              ('.pkl', 'not-compressed'),
+              ('', 'not-compressed')])
+def test_compression_using_file_extension(tmpdir, extension, cmethod):
+    if cmethod in ("lzma", "xz") and lzma is None:
+        pytest.skip("lzma is missing")
+    # test that compression method corresponds to the given filename extension.
+    filename = tmpdir.join('test.pkl').strpath
+    obj = "object to dump"
+
+    dump_fname = filename + extension
+    numpy_pickle.dump(obj, dump_fname)
+    # Verify the file contains the right magic number
+    with open(dump_fname, 'rb') as f:
+        assert _detect_compressor(f) == cmethod
+    # Verify the reloaded object is correct
+    obj_reloaded = numpy_pickle.load(dump_fname)
+    assert isinstance(obj_reloaded, type(obj))
+    assert obj_reloaded == obj
+
+
+@with_numpy
+def test_file_handle_persistence(tmpdir):
+    objs = [np.random.random((10, 10)), "some data"]
+    fobjs = [bz2.BZ2File, gzip.GzipFile]
+    if lzma is not None:
+        fobjs += [lzma.LZMAFile]
+    filename = tmpdir.join('test.pkl').strpath
+
+    for obj in objs:
+        for fobj in fobjs:
+            with fobj(filename, 'wb') as f:
+                numpy_pickle.dump(obj, f)
+
+            # using the same decompressor prevents from internally
+            # decompress again.
+            with fobj(filename, 'rb') as f:
+                obj_reloaded = numpy_pickle.load(f)
+
+            # when needed, the correct decompressor should be used when
+            # passing a raw file handle.
+            with open(filename, 'rb') as f:
+                obj_reloaded_2 = numpy_pickle.load(f)
+
+            if isinstance(obj, np.ndarray):
+                np.testing.assert_array_equal(obj_reloaded, obj)
+                np.testing.assert_array_equal(obj_reloaded_2, obj)
+            else:
+                assert obj_reloaded == obj
+                assert obj_reloaded_2 == obj
+
+
+@with_numpy
+def test_in_memory_persistence():
+    objs = [np.random.random((10, 10)), "some data"]
+    for obj in objs:
+        f = io.BytesIO()
+        numpy_pickle.dump(obj, f)
+        obj_reloaded = numpy_pickle.load(f)
+        if isinstance(obj, np.ndarray):
+            np.testing.assert_array_equal(obj_reloaded, obj)
+        else:
+            assert obj_reloaded == obj
+
+
+@with_numpy
+def test_file_handle_persistence_mmap(tmpdir):
+    obj = np.random.random((10, 10))
+    filename = tmpdir.join('test.pkl').strpath
+
+    with open(filename, 'wb') as f:
+        numpy_pickle.dump(obj, f)
+
+    with open(filename, 'rb') as f:
+        obj_reloaded = numpy_pickle.load(f, mmap_mode='r+')
+
+    np.testing.assert_array_equal(obj_reloaded, obj)
+
+
+@with_numpy
+def test_file_handle_persistence_compressed_mmap(tmpdir):
+    obj = np.random.random((10, 10))
+    filename = tmpdir.join('test.pkl').strpath
+
+    with open(filename, 'wb') as f:
+        numpy_pickle.dump(obj, f, compress=('gzip', 3))
+
+    with closing(gzip.GzipFile(filename, 'rb')) as f:
+        with warns(UserWarning) as warninfo:
+            numpy_pickle.load(f, mmap_mode='r+')
+        assert len(warninfo) == 1
+        assert (str(warninfo[0].message) ==
+                '"%(fileobj)r" is not a raw file, mmap_mode "%(mmap_mode)s" '
+                'flag will be ignored.' % {'fileobj': f, 'mmap_mode': 'r+'})
+
+
+@with_numpy
+def test_file_handle_persistence_in_memory_mmap():
+    obj = np.random.random((10, 10))
+    buf = io.BytesIO()
+
+    numpy_pickle.dump(obj, buf)
+
+    with warns(UserWarning) as warninfo:
+        numpy_pickle.load(buf, mmap_mode='r+')
+    assert len(warninfo) == 1
+    assert (str(warninfo[0].message) ==
+            'In memory persistence is not compatible with mmap_mode '
+            '"%(mmap_mode)s" flag passed. mmap_mode option will be '
+            'ignored.' % {'mmap_mode': 'r+'})
+
+
+@parametrize('data', [b'a little data as bytes.',
+                      # More bytes
+                      10000 * "{}".format(
+                          random.randint(0, 1000) * 1000).encode('latin-1')],
+             ids=["a little data as bytes.", "a large data as bytes."])
+@parametrize('compress_level', [1, 3, 9])
+def test_binary_zlibfile(tmpdir, data, compress_level):
+    filename = tmpdir.join('test.pkl').strpath
+    # Regular cases
+    with open(filename, 'wb') as f:
+        with BinaryZlibFile(f, 'wb',
+                            compresslevel=compress_level) as fz:
+            assert fz.writable()
+            fz.write(data)
+            assert fz.fileno() == f.fileno()
+            with raises(io.UnsupportedOperation):
+                fz._check_can_read()
+
+            with raises(io.UnsupportedOperation):
+                fz._check_can_seek()
+        assert fz.closed
+        with raises(ValueError):
+            fz._check_not_closed()
+
+    with open(filename, 'rb') as f:
+        with BinaryZlibFile(f) as fz:
+            assert fz.readable()
+            assert fz.seekable()
+            assert fz.fileno() == f.fileno()
+            assert fz.read() == data
+            with raises(io.UnsupportedOperation):
+                fz._check_can_write()
+            assert fz.seekable()
+            fz.seek(0)
+            assert fz.tell() == 0
+        assert fz.closed
+
+    # Test with a filename as input
+    with BinaryZlibFile(filename, 'wb',
+                        compresslevel=compress_level) as fz:
+        assert fz.writable()
+        fz.write(data)
+
+    with BinaryZlibFile(filename, 'rb') as fz:
+        assert fz.read() == data
+        assert fz.seekable()
+
+    # Test without context manager
+    fz = BinaryZlibFile(filename, 'wb', compresslevel=compress_level)
+    assert fz.writable()
+    fz.write(data)
+    fz.close()
+
+    fz = BinaryZlibFile(filename, 'rb')
+    assert fz.read() == data
+    fz.close()
+
+
+@parametrize('bad_value', [-1, 10, 15, 'a', (), {}])
+def test_binary_zlibfile_bad_compression_levels(tmpdir, bad_value):
+    filename = tmpdir.join('test.pkl').strpath
+    with raises(ValueError) as excinfo:
+        BinaryZlibFile(filename, 'wb', compresslevel=bad_value)
+    pattern = re.escape("'compresslevel' must be an integer between 1 and 9. "
+                        "You provided 'compresslevel={}'".format(bad_value))
+    excinfo.match(pattern)
+
+
+@parametrize('bad_mode', ['a', 'x', 'r', 'w', 1, 2])
+def test_binary_zlibfile_invalid_modes(tmpdir, bad_mode):
+    filename = tmpdir.join('test.pkl').strpath
+    with raises(ValueError) as excinfo:
+        BinaryZlibFile(filename, bad_mode)
+    excinfo.match("Invalid mode")
+
+
+@parametrize('bad_file', [1, (), {}])
+def test_binary_zlibfile_invalid_filename_type(bad_file):
+    with raises(TypeError) as excinfo:
+        BinaryZlibFile(bad_file, 'rb')
+    excinfo.match("filename must be a str or bytes object, or a file")
+
+
+###############################################################################
+# Test dumping array subclasses
+if np is not None:
+
+    class SubArray(np.ndarray):
+
+        def __reduce__(self):
+            return _load_sub_array, (np.asarray(self), )
+
+    def _load_sub_array(arr):
+        d = SubArray(arr.shape)
+        d[:] = arr
+        return d
+
+    class ComplexTestObject:
+        """A complex object containing numpy arrays as attributes."""
+
+        def __init__(self):
+            self.array_float = np.arange(100, dtype='float64')
+            self.array_int = np.ones(100, dtype='int32')
+            self.array_obj = np.array(['a', 10, 20.0], dtype='object')
+
+
+@with_numpy
+def test_numpy_subclass(tmpdir):
+    filename = tmpdir.join('test.pkl').strpath
+    a = SubArray((10,))
+    numpy_pickle.dump(a, filename)
+    c = numpy_pickle.load(filename)
+    assert isinstance(c, SubArray)
+    np.testing.assert_array_equal(c, a)
+
+
+def test_pathlib(tmpdir):
+    filename = tmpdir.join('test.pkl').strpath
+    value = 123
+    numpy_pickle.dump(value, Path(filename))
+    assert numpy_pickle.load(filename) == value
+    numpy_pickle.dump(value, filename)
+    assert numpy_pickle.load(Path(filename)) == value
+
+
+@with_numpy
+def test_non_contiguous_array_pickling(tmpdir):
+    filename = tmpdir.join('test.pkl').strpath
+
+    for array in [  # Array that triggers a contiguousness issue with nditer,
+                    # see https://github.com/joblib/joblib/pull/352 and see
+                    # https://github.com/joblib/joblib/pull/353
+                    np.asfortranarray([[1, 2], [3, 4]])[1:],
+                    # Non contiguous array with works fine with nditer
+                    np.ones((10, 50, 20), order='F')[:, :1, :]]:
+        assert not array.flags.c_contiguous
+        assert not array.flags.f_contiguous
+        numpy_pickle.dump(array, filename)
+        array_reloaded = numpy_pickle.load(filename)
+        np.testing.assert_array_equal(array_reloaded, array)
+
+
+@with_numpy
+def test_pickle_highest_protocol(tmpdir):
+    # ensure persistence of a numpy array is valid even when using
+    # the pickle HIGHEST_PROTOCOL.
+    # see https://github.com/joblib/joblib/issues/362
+
+    filename = tmpdir.join('test.pkl').strpath
+    test_array = np.zeros(10)
+
+    numpy_pickle.dump(test_array, filename, protocol=pickle.HIGHEST_PROTOCOL)
+    array_reloaded = numpy_pickle.load(filename)
+
+    np.testing.assert_array_equal(array_reloaded, test_array)
+
+
+@with_numpy
+def test_pickle_in_socket():
+    # test that joblib can pickle in sockets
+    test_array = np.arange(10)
+    _ADDR = ("localhost", 12345)
+    listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    listener.bind(_ADDR)
+    listener.listen(1)
+
+    with socket.create_connection(_ADDR) as client:
+        server, client_addr = listener.accept()
+
+        with server.makefile("wb") as sf:
+            numpy_pickle.dump(test_array, sf)
+
+        with client.makefile("rb") as cf:
+            array_reloaded = numpy_pickle.load(cf)
+
+        np.testing.assert_array_equal(array_reloaded, test_array)
+
+        # Check that a byte-aligned numpy array written in a file can be send
+        # over a socket and then read on the other side
+        bytes_to_send = io.BytesIO()
+        numpy_pickle.dump(test_array, bytes_to_send)
+        server.send(bytes_to_send.getvalue())
+
+        with client.makefile("rb") as cf:
+            array_reloaded = numpy_pickle.load(cf)
+
+        np.testing.assert_array_equal(array_reloaded, test_array)
+
+
+@with_numpy
+def test_load_memmap_with_big_offset(tmpdir):
+    # Test that numpy memmap offset is set correctly if greater than
+    # mmap.ALLOCATIONGRANULARITY, see
+    # https://github.com/joblib/joblib/issues/451 and
+    # https://github.com/numpy/numpy/pull/8443 for more details.
+    fname = tmpdir.join('test.mmap').strpath
+    size = mmap.ALLOCATIONGRANULARITY
+    obj = [np.zeros(size, dtype='uint8'), np.ones(size, dtype='uint8')]
+    numpy_pickle.dump(obj, fname)
+    memmaps = numpy_pickle.load(fname, mmap_mode='r')
+    assert isinstance(memmaps[1], np.memmap)
+    assert memmaps[1].offset > size
+    np.testing.assert_array_equal(obj, memmaps)
+
+
+def test_register_compressor(tmpdir):
+    # Check that registering compressor file works.
+    compressor_name = 'test-name'
+    compressor_prefix = 'test-prefix'
+
+    class BinaryCompressorTestFile(io.BufferedIOBase):
+        pass
+
+    class BinaryCompressorTestWrapper(CompressorWrapper):
+
+        def __init__(self):
+            CompressorWrapper.__init__(self, obj=BinaryCompressorTestFile,
+                                       prefix=compressor_prefix)
+
+    register_compressor(compressor_name, BinaryCompressorTestWrapper())
+
+    assert (_COMPRESSORS[compressor_name].fileobj_factory ==
+            BinaryCompressorTestFile)
+    assert _COMPRESSORS[compressor_name].prefix == compressor_prefix
+
+    # Remove this dummy compressor file from extra compressors because other
+    # tests might fail because of this
+    _COMPRESSORS.pop(compressor_name)
+
+
+@parametrize('invalid_name', [1, (), {}])
+def test_register_compressor_invalid_name(invalid_name):
+    # Test that registering an invalid compressor name is not allowed.
+    with raises(ValueError) as excinfo:
+        register_compressor(invalid_name, None)
+    excinfo.match("Compressor name should be a string")
+
+
+def test_register_compressor_invalid_fileobj():
+    # Test that registering an invalid file object is not allowed.
+
+    class InvalidFileObject():
+        pass
+
+    class InvalidFileObjectWrapper(CompressorWrapper):
+        def __init__(self):
+            CompressorWrapper.__init__(self, obj=InvalidFileObject,
+                                       prefix=b'prefix')
+
+    with raises(ValueError) as excinfo:
+        register_compressor('invalid', InvalidFileObjectWrapper())
+
+    excinfo.match("Compressor 'fileobj_factory' attribute should implement "
+                  "the file object interface")
+
+
+class AnotherZlibCompressorWrapper(CompressorWrapper):
+
+    def __init__(self):
+        CompressorWrapper.__init__(self, obj=BinaryZlibFile, prefix=b'prefix')
+
+
+class StandardLibGzipCompressorWrapper(CompressorWrapper):
+
+    def __init__(self):
+        CompressorWrapper.__init__(self, obj=gzip.GzipFile, prefix=b'prefix')
+
+
+def test_register_compressor_already_registered():
+    # Test registration of existing compressor files.
+    compressor_name = 'test-name'
+
+    # register a test compressor
+    register_compressor(compressor_name, AnotherZlibCompressorWrapper())
+
+    with raises(ValueError) as excinfo:
+        register_compressor(compressor_name,
+                            StandardLibGzipCompressorWrapper())
+    excinfo.match("Compressor '{}' already registered."
+                  .format(compressor_name))
+
+    register_compressor(compressor_name, StandardLibGzipCompressorWrapper(),
+                        force=True)
+
+    assert compressor_name in _COMPRESSORS
+    assert _COMPRESSORS[compressor_name].fileobj_factory == gzip.GzipFile
+
+    # Remove this dummy compressor file from extra compressors because other
+    # tests might fail because of this
+    _COMPRESSORS.pop(compressor_name)
+
+
+@with_lz4
+def test_lz4_compression(tmpdir):
+    # Check that lz4 can be used when dependency is available.
+    import lz4.frame
+    compressor = 'lz4'
+    assert compressor in _COMPRESSORS
+    assert _COMPRESSORS[compressor].fileobj_factory == lz4.frame.LZ4FrameFile
+
+    fname = tmpdir.join('test.pkl').strpath
+    data = 'test data'
+    numpy_pickle.dump(data, fname, compress=compressor)
+
+    with open(fname, 'rb') as f:
+        assert f.read(len(_LZ4_PREFIX)) == _LZ4_PREFIX
+    assert numpy_pickle.load(fname) == data
+
+    # Test that LZ4 is applied based on file extension
+    numpy_pickle.dump(data, fname + '.lz4')
+    with open(fname, 'rb') as f:
+        assert f.read(len(_LZ4_PREFIX)) == _LZ4_PREFIX
+    assert numpy_pickle.load(fname) == data
+
+
+@without_lz4
+def test_lz4_compression_without_lz4(tmpdir):
+    # Check that lz4 cannot be used when dependency is not available.
+    fname = tmpdir.join('test.nolz4').strpath
+    data = 'test data'
+    msg = LZ4_NOT_INSTALLED_ERROR
+    with raises(ValueError) as excinfo:
+        numpy_pickle.dump(data, fname, compress='lz4')
+    excinfo.match(msg)
+
+    with raises(ValueError) as excinfo:
+        numpy_pickle.dump(data, fname + '.lz4')
+    excinfo.match(msg)
+
+
+protocols = [pickle.DEFAULT_PROTOCOL]
+if pickle.HIGHEST_PROTOCOL != pickle.DEFAULT_PROTOCOL:
+    protocols.append(pickle.HIGHEST_PROTOCOL)
+
+
+@with_numpy
+@parametrize('protocol', protocols)
+def test_memmap_alignment_padding(tmpdir, protocol):
+    # Test that memmaped arrays returned by numpy.load are correctly aligned
+    fname = tmpdir.join('test.mmap').strpath
+
+    a = np.random.randn(2)
+    numpy_pickle.dump(a, fname, protocol=protocol)
+    memmap = numpy_pickle.load(fname, mmap_mode='r')
+    assert isinstance(memmap, np.memmap)
+    np.testing.assert_array_equal(a, memmap)
+    assert (
+        memmap.ctypes.data % numpy_pickle.NUMPY_ARRAY_ALIGNMENT_BYTES == 0)
+    assert memmap.flags.aligned
+
+    array_list = [
+        np.random.randn(2), np.random.randn(2),
+        np.random.randn(2), np.random.randn(2)
+    ]
+
+    # On Windows OSError 22 if reusing the same path for memmap ...
+    fname = tmpdir.join('test1.mmap').strpath
+    numpy_pickle.dump(array_list, fname, protocol=protocol)
+    l_reloaded = numpy_pickle.load(fname, mmap_mode='r')
+
+    for idx, memmap in enumerate(l_reloaded):
+        assert isinstance(memmap, np.memmap)
+        np.testing.assert_array_equal(array_list[idx], memmap)
+        assert (
+            memmap.ctypes.data % numpy_pickle.NUMPY_ARRAY_ALIGNMENT_BYTES == 0)
+        assert memmap.flags.aligned
+
+    array_dict = {
+        'a0': np.arange(2, dtype=np.uint8),
+        'a1': np.arange(3, dtype=np.uint8),
+        'a2': np.arange(5, dtype=np.uint8),
+        'a3': np.arange(7, dtype=np.uint8),
+        'a4': np.arange(11, dtype=np.uint8),
+        'a5': np.arange(13, dtype=np.uint8),
+        'a6': np.arange(17, dtype=np.uint8),
+        'a7': np.arange(19, dtype=np.uint8),
+        'a8': np.arange(23, dtype=np.uint8),
+    }
+
+    # On Windows OSError 22 if reusing the same path for memmap ...
+    fname = tmpdir.join('test2.mmap').strpath
+    numpy_pickle.dump(array_dict, fname, protocol=protocol)
+    d_reloaded = numpy_pickle.load(fname, mmap_mode='r')
+
+    for key, memmap in d_reloaded.items():
+        assert isinstance(memmap, np.memmap)
+        np.testing.assert_array_equal(array_dict[key], memmap)
+        assert (
+            memmap.ctypes.data % numpy_pickle.NUMPY_ARRAY_ALIGNMENT_BYTES == 0)
+        assert memmap.flags.aligned
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_numpy_pickle_compat.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_numpy_pickle_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e95393b19e979593c7037d0d4fb740e47131dde
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_numpy_pickle_compat.py
@@ -0,0 +1,16 @@
+"""Test the old numpy pickler, compatibility version."""
+
+# numpy_pickle is not a drop-in replacement of pickle, as it takes
+# filenames instead of open files as arguments.
+from joblib import numpy_pickle_compat
+
+
+def test_z_file(tmpdir):
+    # Test saving and loading data with Zfiles.
+    filename = tmpdir.join('test.pkl').strpath
+    data = numpy_pickle_compat.asbytes('Foo, \n Bar, baz, \n\nfoobar')
+    with open(filename, 'wb') as f:
+        numpy_pickle_compat.write_zfile(f, data)
+    with open(filename, 'rb') as f:
+        data_read = numpy_pickle_compat.read_zfile(f)
+    assert data == data_read
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_parallel.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_parallel.py
new file mode 100644
index 0000000000000000000000000000000000000000..f171375a872bccafc1711f935ec5369737bc617c
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_parallel.py
@@ -0,0 +1,2056 @@
+"""
+Test the parallel module.
+"""
+
+# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
+# Copyright (c) 2010-2011 Gael Varoquaux
+# License: BSD Style, 3 clauses.
+
+import os
+import sys
+import time
+import mmap
+import weakref
+import warnings
+import threading
+from traceback import format_exception
+from math import sqrt
+from time import sleep
+from pickle import PicklingError
+from contextlib import nullcontext
+from multiprocessing import TimeoutError
+import pytest
+
+import joblib
+from joblib import parallel
+from joblib import dump, load
+
+from joblib._multiprocessing_helpers import mp
+
+from joblib.test.common import np, with_numpy
+from joblib.test.common import with_multiprocessing
+from joblib.test.common import IS_PYPY, force_gc_pypy
+from joblib.testing import (parametrize, raises, check_subprocess_call,
+                            skipif, warns)
+
+if mp is not None:
+    # Loky is not available if multiprocessing is not
+    from joblib.externals.loky import get_reusable_executor
+
+from queue import Queue
+
+try:
+    import posix
+except ImportError:
+    posix = None
+
+try:
+    from ._openmp_test_helper.parallel_sum import parallel_sum
+except ImportError:
+    parallel_sum = None
+
+try:
+    import distributed
+except ImportError:
+    distributed = None
+
+from joblib._parallel_backends import SequentialBackend
+from joblib._parallel_backends import ThreadingBackend
+from joblib._parallel_backends import MultiprocessingBackend
+from joblib._parallel_backends import ParallelBackendBase
+from joblib._parallel_backends import LokyBackend
+
+from joblib.parallel import Parallel, delayed
+from joblib.parallel import parallel_config
+from joblib.parallel import parallel_backend
+from joblib.parallel import register_parallel_backend
+from joblib.parallel import effective_n_jobs, cpu_count
+
+from joblib.parallel import mp, BACKENDS, DEFAULT_BACKEND
+
+
+RETURN_GENERATOR_BACKENDS = BACKENDS.copy()
+RETURN_GENERATOR_BACKENDS.pop("multiprocessing", None)
+
+ALL_VALID_BACKENDS = [None] + sorted(BACKENDS.keys())
+# Add instances of backend classes deriving from ParallelBackendBase
+ALL_VALID_BACKENDS += [BACKENDS[backend_str]() for backend_str in BACKENDS]
+if mp is None:
+    PROCESS_BACKENDS = []
+else:
+    PROCESS_BACKENDS = ['multiprocessing', 'loky']
+PARALLEL_BACKENDS = PROCESS_BACKENDS + ['threading']
+
+if hasattr(mp, 'get_context'):
+    # Custom multiprocessing context in Python 3.4+
+    ALL_VALID_BACKENDS.append(mp.get_context('spawn'))
+
+DefaultBackend = BACKENDS[DEFAULT_BACKEND]
+
+
+def get_workers(backend):
+    return getattr(backend, '_pool', getattr(backend, '_workers', None))
+
+
+def division(x, y):
+    return x / y
+
+
+def square(x):
+    return x ** 2
+
+
+class MyExceptionWithFinickyInit(Exception):
+    """An exception class with non trivial __init__
+    """
+    def __init__(self, a, b, c, d):
+        pass
+
+
+def exception_raiser(x, custom_exception=False):
+    if x == 7:
+        raise (MyExceptionWithFinickyInit('a', 'b', 'c', 'd')
+               if custom_exception else ValueError)
+    return x
+
+
+def interrupt_raiser(x):
+    time.sleep(.05)
+    raise KeyboardInterrupt
+
+
+def f(x, y=0, z=0):
+    """ A module-level function so that it can be spawn with
+    multiprocessing.
+    """
+    return x ** 2 + y + z
+
+
+def _active_backend_type():
+    return type(parallel.get_active_backend()[0])
+
+
+def parallel_func(inner_n_jobs, backend):
+    return Parallel(n_jobs=inner_n_jobs, backend=backend)(
+        delayed(square)(i) for i in range(3))
+
+
+###############################################################################
+def test_cpu_count():
+    assert cpu_count() > 0
+
+
+def test_effective_n_jobs():
+    assert effective_n_jobs() > 0
+
+
+@parametrize("context", [parallel_config, parallel_backend])
+@pytest.mark.parametrize(
+    "backend_n_jobs, expected_n_jobs",
+    [(3, 3), (-1, effective_n_jobs(n_jobs=-1)), (None, 1)],
+    ids=["positive-int", "negative-int", "None"]
+)
+@with_multiprocessing
+def test_effective_n_jobs_None(context, backend_n_jobs, expected_n_jobs):
+    # check the number of effective jobs when `n_jobs=None`
+    # non-regression test for https://github.com/joblib/joblib/issues/984
+    with context("threading", n_jobs=backend_n_jobs):
+        # when using a backend, the default of number jobs will be the one set
+        # in the backend
+        assert effective_n_jobs(n_jobs=None) == expected_n_jobs
+    # without any backend, None will default to a single job
+    assert effective_n_jobs(n_jobs=None) == 1
+
+
+###############################################################################
+# Test parallel
+
+@parametrize('backend', ALL_VALID_BACKENDS)
+@parametrize('n_jobs', [1, 2, -1, -2])
+@parametrize('verbose', [2, 11, 100])
+def test_simple_parallel(backend, n_jobs, verbose):
+    assert ([square(x) for x in range(5)] ==
+            Parallel(n_jobs=n_jobs, backend=backend,
+                     verbose=verbose)(
+                delayed(square)(x) for x in range(5)))
+
+
+@parametrize('backend', ALL_VALID_BACKENDS)
+def test_main_thread_renamed_no_warning(backend, monkeypatch):
+    # Check that no default backend relies on the name of the main thread:
+    # https://github.com/joblib/joblib/issues/180#issuecomment-253266247
+    # Some programs use a different name for the main thread. This is the case
+    # for uWSGI apps for instance.
+    monkeypatch.setattr(target=threading.current_thread(), name='name',
+                        value='some_new_name_for_the_main_thread')
+
+    with warnings.catch_warnings(record=True) as warninfo:
+        results = Parallel(n_jobs=2, backend=backend)(
+            delayed(square)(x) for x in range(3))
+        assert results == [0, 1, 4]
+
+    # Due to the default parameters of LokyBackend, there is a chance that
+    # warninfo catches Warnings from worker timeouts. We remove it if it exists
+    warninfo = [w for w in warninfo if "worker timeout" not in str(w.message)]
+
+    # The multiprocessing backend will raise a warning when detecting that is
+    # started from the non-main thread. Let's check that there is no false
+    # positive because of the name change.
+    assert len(warninfo) == 0
+
+
+def _assert_warning_nested(backend, inner_n_jobs, expected):
+    with warnings.catch_warnings(record=True) as warninfo:
+        warnings.simplefilter("always")
+        parallel_func(backend=backend, inner_n_jobs=inner_n_jobs)
+
+    warninfo = [w.message for w in warninfo]
+    if expected:
+        if warninfo:
+            warnings_are_correct = all(
+                'backed parallel loops cannot' in each.args[0]
+                for each in warninfo
+            )
+            # With Python nogil, when the outer backend is threading, we might
+            # see more that one warning
+            warnings_have_the_right_length = (
+                len(warninfo) >= 1 if getattr(sys.flags, 'nogil', False)
+                else len(warninfo) == 1)
+            return warnings_are_correct and warnings_have_the_right_length
+
+        return False
+    else:
+        assert not warninfo
+        return True
+
+
+@with_multiprocessing
+@parametrize('parent_backend,child_backend,expected', [
+    ('loky', 'multiprocessing', True),
+    ('loky', 'loky', False),
+    ('multiprocessing', 'multiprocessing', True),
+    ('multiprocessing', 'loky', True),
+    ('threading', 'multiprocessing', True),
+    ('threading', 'loky', True),
+])
+def test_nested_parallel_warnings(parent_backend, child_backend, expected):
+
+    # no warnings if inner_n_jobs=1
+    Parallel(n_jobs=2, backend=parent_backend)(
+        delayed(_assert_warning_nested)(
+            backend=child_backend, inner_n_jobs=1,
+            expected=False)
+        for _ in range(5))
+
+    #  warnings if inner_n_jobs != 1 and expected
+    res = Parallel(n_jobs=2, backend=parent_backend)(
+        delayed(_assert_warning_nested)(
+            backend=child_backend, inner_n_jobs=2,
+            expected=expected)
+        for _ in range(5))
+
+    # warning handling is not thread safe. One thread might see multiple
+    # warning or no warning at all.
+    if parent_backend == "threading":
+        if IS_PYPY and not any(res):
+            # Related to joblib#1426, should be removed once it is solved.
+            pytest.xfail(reason="This test often fails in PyPy.")
+        assert any(res)
+    else:
+        assert all(res)
+
+
+@with_multiprocessing
+@parametrize('backend', ['loky', 'multiprocessing', 'threading'])
+def test_background_thread_parallelism(backend):
+    is_run_parallel = [False]
+
+    def background_thread(is_run_parallel):
+        with warnings.catch_warnings(record=True) as warninfo:
+            Parallel(n_jobs=2)(
+                delayed(sleep)(.1) for _ in range(4))
+        print(len(warninfo))
+        is_run_parallel[0] = len(warninfo) == 0
+
+    t = threading.Thread(target=background_thread, args=(is_run_parallel,))
+    t.start()
+    t.join()
+    assert is_run_parallel[0]
+
+
+def nested_loop(backend):
+    Parallel(n_jobs=2, backend=backend)(
+        delayed(square)(.01) for _ in range(2))
+
+
+@parametrize('child_backend', BACKENDS)
+@parametrize('parent_backend', BACKENDS)
+def test_nested_loop(parent_backend, child_backend):
+    Parallel(n_jobs=2, backend=parent_backend)(
+        delayed(nested_loop)(child_backend) for _ in range(2))
+
+
+def raise_exception(backend):
+    raise ValueError
+
+
+@with_multiprocessing
+def test_nested_loop_with_exception_with_loky():
+    with raises(ValueError):
+        with Parallel(n_jobs=2, backend="loky") as parallel:
+            parallel([delayed(nested_loop)("loky"),
+                      delayed(raise_exception)("loky")])
+
+
+def test_mutate_input_with_threads():
+    """Input is mutable when using the threading backend"""
+    q = Queue(maxsize=5)
+    Parallel(n_jobs=2, backend="threading")(
+        delayed(q.put)(1) for _ in range(5))
+    assert q.full()
+
+
+@parametrize('n_jobs', [1, 2, 3])
+def test_parallel_kwargs(n_jobs):
+    """Check the keyword argument processing of pmap."""
+    lst = range(10)
+    assert ([f(x, y=1) for x in lst] ==
+            Parallel(n_jobs=n_jobs)(delayed(f)(x, y=1) for x in lst))
+
+
+@parametrize('backend', PARALLEL_BACKENDS)
+def test_parallel_as_context_manager(backend):
+    lst = range(10)
+    expected = [f(x, y=1) for x in lst]
+
+    with Parallel(n_jobs=4, backend=backend) as p:
+        # Internally a pool instance has been eagerly created and is managed
+        # via the context manager protocol
+        managed_backend = p._backend
+
+        # We make call with the managed parallel object several times inside
+        # the managed block:
+        assert expected == p(delayed(f)(x, y=1) for x in lst)
+        assert expected == p(delayed(f)(x, y=1) for x in lst)
+
+        # Those calls have all used the same pool instance:
+        if mp is not None:
+            assert get_workers(managed_backend) is get_workers(p._backend)
+
+    # As soon as we exit the context manager block, the pool is terminated and
+    # no longer referenced from the parallel object:
+    if mp is not None:
+        assert get_workers(p._backend) is None
+
+    # It's still possible to use the parallel instance in non-managed mode:
+    assert expected == p(delayed(f)(x, y=1) for x in lst)
+    if mp is not None:
+        assert get_workers(p._backend) is None
+
+
+@with_multiprocessing
+def test_parallel_pickling():
+    """ Check that pmap captures the errors when it is passed an object
+        that cannot be pickled.
+    """
+    class UnpicklableObject(object):
+        def __reduce__(self):
+            raise RuntimeError('123')
+
+    with raises(PicklingError, match=r"the task to send"):
+        Parallel(n_jobs=2, backend='loky')(delayed(id)(
+            UnpicklableObject()) for _ in range(10))
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize('byteorder', ['<', '>', '='])
+def test_parallel_byteorder_corruption(byteorder):
+
+    def inspect_byteorder(x):
+        return x, x.dtype.byteorder
+
+    x = np.arange(6).reshape((2, 3)).view(f'{byteorder}i4')
+
+    initial_np_byteorder = x.dtype.byteorder
+
+    result = Parallel(n_jobs=2, backend='loky')(
+        delayed(inspect_byteorder)(x) for _ in range(3)
+    )
+
+    for x_returned, byteorder_in_worker in result:
+        assert byteorder_in_worker == initial_np_byteorder
+        assert byteorder_in_worker == x_returned.dtype.byteorder
+        np.testing.assert_array_equal(x, x_returned)
+
+
+@parametrize('backend', PARALLEL_BACKENDS)
+def test_parallel_timeout_success(backend):
+    # Check that timeout isn't thrown when function is fast enough
+    assert len(Parallel(n_jobs=2, backend=backend, timeout=30)(
+        delayed(sleep)(0.001) for x in range(10))) == 10
+
+
+@with_multiprocessing
+@parametrize('backend', PARALLEL_BACKENDS)
+def test_parallel_timeout_fail(backend):
+    # Check that timeout properly fails when function is too slow
+    with raises(TimeoutError):
+        Parallel(n_jobs=2, backend=backend, timeout=0.01)(
+            delayed(sleep)(10) for x in range(10))
+
+
+@with_multiprocessing
+@parametrize('backend', PROCESS_BACKENDS)
+def test_error_capture(backend):
+    # Check that error are captured, and that correct exceptions
+    # are raised.
+    if mp is not None:
+        with raises(ZeroDivisionError):
+            Parallel(n_jobs=2, backend=backend)(
+                [delayed(division)(x, y)
+                    for x, y in zip((0, 1), (1, 0))])
+
+        with raises(KeyboardInterrupt):
+            Parallel(n_jobs=2, backend=backend)(
+                [delayed(interrupt_raiser)(x) for x in (1, 0)])
+
+        # Try again with the context manager API
+        with Parallel(n_jobs=2, backend=backend) as parallel:
+            assert get_workers(parallel._backend) is not None
+            original_workers = get_workers(parallel._backend)
+
+            with raises(ZeroDivisionError):
+                parallel([delayed(division)(x, y)
+                          for x, y in zip((0, 1), (1, 0))])
+
+            # The managed pool should still be available and be in a working
+            # state despite the previously raised (and caught) exception
+            assert get_workers(parallel._backend) is not None
+
+            # The pool should have been interrupted and restarted:
+            assert get_workers(parallel._backend) is not original_workers
+
+            assert ([f(x, y=1) for x in range(10)] ==
+                    parallel(delayed(f)(x, y=1) for x in range(10)))
+
+            original_workers = get_workers(parallel._backend)
+            with raises(KeyboardInterrupt):
+                parallel([delayed(interrupt_raiser)(x) for x in (1, 0)])
+
+            # The pool should still be available despite the exception
+            assert get_workers(parallel._backend) is not None
+
+            # The pool should have been interrupted and restarted:
+            assert get_workers(parallel._backend) is not original_workers
+
+            assert ([f(x, y=1) for x in range(10)] ==
+                    parallel(delayed(f)(x, y=1) for x in range(10))), (
+                parallel._iterating, parallel.n_completed_tasks,
+                parallel.n_dispatched_tasks, parallel._aborting
+            )
+
+        # Check that the inner pool has been terminated when exiting the
+        # context manager
+        assert get_workers(parallel._backend) is None
+    else:
+        with raises(KeyboardInterrupt):
+            Parallel(n_jobs=2)(
+                [delayed(interrupt_raiser)(x) for x in (1, 0)])
+
+    # wrapped exceptions should inherit from the class of the original
+    # exception to make it easy to catch them
+    with raises(ZeroDivisionError):
+        Parallel(n_jobs=2)(
+            [delayed(division)(x, y) for x, y in zip((0, 1), (1, 0))])
+
+    with raises(MyExceptionWithFinickyInit):
+        Parallel(n_jobs=2, verbose=0)(
+            (delayed(exception_raiser)(i, custom_exception=True)
+             for i in range(30)))
+
+
+@with_multiprocessing
+@parametrize('backend', BACKENDS)
+def test_error_in_task_iterator(backend):
+
+    def my_generator(raise_at=0):
+        for i in range(20):
+            if i == raise_at:
+                raise ValueError("Iterator Raising Error")
+            yield i
+
+    with Parallel(n_jobs=2, backend=backend) as p:
+        # The error is raised in the pre-dispatch phase
+        with raises(ValueError, match="Iterator Raising Error"):
+            p(delayed(square)(i) for i in my_generator(raise_at=0))
+
+        # The error is raised when dispatching a new task after the
+        # pre-dispatch (likely to happen in a different thread)
+        with raises(ValueError, match="Iterator Raising Error"):
+            p(delayed(square)(i) for i in my_generator(raise_at=5))
+
+        # Same, but raises long after the pre-dispatch phase
+        with raises(ValueError, match="Iterator Raising Error"):
+            p(delayed(square)(i) for i in my_generator(raise_at=19))
+
+
+def consumer(queue, item):
+    queue.append('Consumed %s' % item)
+
+
+@parametrize('backend', BACKENDS)
+@parametrize('batch_size, expected_queue',
+             [(1, ['Produced 0', 'Consumed 0',
+                   'Produced 1', 'Consumed 1',
+                   'Produced 2', 'Consumed 2',
+                   'Produced 3', 'Consumed 3',
+                   'Produced 4', 'Consumed 4',
+                   'Produced 5', 'Consumed 5']),
+              (4, [  # First Batch
+                  'Produced 0', 'Produced 1', 'Produced 2', 'Produced 3',
+                  'Consumed 0', 'Consumed 1', 'Consumed 2', 'Consumed 3',
+                     # Second batch
+                  'Produced 4', 'Produced 5', 'Consumed 4', 'Consumed 5'])])
+def test_dispatch_one_job(backend, batch_size, expected_queue):
+    """ Test that with only one job, Parallel does act as a iterator.
+    """
+    queue = list()
+
+    def producer():
+        for i in range(6):
+            queue.append('Produced %i' % i)
+            yield i
+
+    Parallel(n_jobs=1, batch_size=batch_size, backend=backend)(
+        delayed(consumer)(queue, x) for x in producer())
+    assert queue == expected_queue
+    assert len(queue) == 12
+
+
+@with_multiprocessing
+@parametrize('backend', PARALLEL_BACKENDS)
+def test_dispatch_multiprocessing(backend):
+    """ Check that using pre_dispatch Parallel does indeed dispatch items
+        lazily.
+    """
+    manager = mp.Manager()
+    queue = manager.list()
+
+    def producer():
+        for i in range(6):
+            queue.append('Produced %i' % i)
+            yield i
+
+    Parallel(n_jobs=2, batch_size=1, pre_dispatch=3, backend=backend)(
+        delayed(consumer)(queue, 'any') for _ in producer())
+
+    queue_contents = list(queue)
+    assert queue_contents[0] == 'Produced 0'
+
+    # Only 3 tasks are pre-dispatched out of 6. The 4th task is dispatched only
+    # after any of the first 3 jobs have completed.
+    first_consumption_index = queue_contents[:4].index('Consumed any')
+    assert first_consumption_index > -1
+
+    produced_3_index = queue_contents.index('Produced 3')  # 4th task produced
+    assert produced_3_index > first_consumption_index
+
+    assert len(queue) == 12
+
+
+def test_batching_auto_threading():
+    # batching='auto' with the threading backend leaves the effective batch
+    # size to 1 (no batching) as it has been found to never be beneficial with
+    # this low-overhead backend.
+
+    with Parallel(n_jobs=2, batch_size='auto', backend='threading') as p:
+        p(delayed(id)(i) for i in range(5000))  # many very fast tasks
+        assert p._backend.compute_batch_size() == 1
+
+
+@with_multiprocessing
+@parametrize('backend', PROCESS_BACKENDS)
+def test_batching_auto_subprocesses(backend):
+    with Parallel(n_jobs=2, batch_size='auto', backend=backend) as p:
+        p(delayed(id)(i) for i in range(5000))  # many very fast tasks
+
+        # It should be strictly larger than 1 but as we don't want heisen
+        # failures on clogged CI worker environment be safe and only check that
+        # it's a strictly positive number.
+        assert p._backend.compute_batch_size() > 0
+
+
+def test_exception_dispatch():
+    """Make sure that exception raised during dispatch are indeed captured"""
+    with raises(ValueError):
+        Parallel(n_jobs=2, pre_dispatch=16, verbose=0)(
+            delayed(exception_raiser)(i) for i in range(30))
+
+
+def nested_function_inner(i):
+    Parallel(n_jobs=2)(
+        delayed(exception_raiser)(j) for j in range(30))
+
+
+def nested_function_outer(i):
+    Parallel(n_jobs=2)(
+        delayed(nested_function_inner)(j) for j in range(30))
+
+
+@with_multiprocessing
+@parametrize('backend', PARALLEL_BACKENDS)
+@pytest.mark.xfail(reason="https://github.com/joblib/loky/pull/255")
+def test_nested_exception_dispatch(backend):
+    """Ensure errors for nested joblib cases gets propagated
+
+    We rely on the Python 3 built-in __cause__ system that already
+    report this kind of information to the user.
+    """
+    with raises(ValueError) as excinfo:
+        Parallel(n_jobs=2, backend=backend)(
+            delayed(nested_function_outer)(i) for i in range(30))
+
+    # Check that important information such as function names are visible
+    # in the final error message reported to the user
+    report_lines = format_exception(excinfo.type, excinfo.value, excinfo.tb)
+    report = "".join(report_lines)
+    assert 'nested_function_outer' in report
+    assert 'nested_function_inner' in report
+    assert 'exception_raiser' in report
+
+    assert type(excinfo.value) is ValueError
+
+
+class FakeParallelBackend(SequentialBackend):
+    """Pretends to run concurrently while running sequentially."""
+
+    def configure(self, n_jobs=1, parallel=None, **backend_args):
+        self.n_jobs = self.effective_n_jobs(n_jobs)
+        self.parallel = parallel
+        return n_jobs
+
+    def effective_n_jobs(self, n_jobs=1):
+        if n_jobs < 0:
+            n_jobs = max(mp.cpu_count() + 1 + n_jobs, 1)
+        return n_jobs
+
+
+def test_invalid_backend():
+    with raises(ValueError, match="Invalid backend:"):
+        Parallel(backend='unit-testing')
+
+    with raises(ValueError, match="Invalid backend:"):
+        with parallel_config(backend='unit-testing'):
+            pass
+
+    with raises(ValueError, match="Invalid backend:"):
+        with parallel_config(backend='unit-testing'):
+            pass
+
+
+@parametrize('backend', ALL_VALID_BACKENDS)
+def test_invalid_njobs(backend):
+    with raises(ValueError) as excinfo:
+        Parallel(n_jobs=0, backend=backend)._initialize_backend()
+    assert "n_jobs == 0 in Parallel has no meaning" in str(excinfo.value)
+
+    with raises(ValueError) as excinfo:
+        Parallel(n_jobs=0.5, backend=backend)._initialize_backend()
+    assert "n_jobs == 0 in Parallel has no meaning" in str(excinfo.value)
+
+    with raises(ValueError) as excinfo:
+        Parallel(n_jobs="2.3", backend=backend)._initialize_backend()
+    assert "n_jobs could not be converted to int" in str(excinfo.value)
+
+    with raises(ValueError) as excinfo:
+        Parallel(n_jobs="invalid_str", backend=backend)._initialize_backend()
+    assert "n_jobs could not be converted to int" in str(excinfo.value)
+
+
+@with_multiprocessing
+@parametrize('backend', PARALLEL_BACKENDS)
+@parametrize('n_jobs', ['2', 2.3, 2])
+def test_njobs_converted_to_int(backend, n_jobs):
+    p = Parallel(n_jobs=n_jobs, backend=backend)
+    assert p._effective_n_jobs() == 2
+
+    res = p(delayed(square)(i) for i in range(10))
+    assert all(r == square(i) for i, r in enumerate(res))
+
+
+def test_register_parallel_backend():
+    try:
+        register_parallel_backend("test_backend", FakeParallelBackend)
+        assert "test_backend" in BACKENDS
+        assert BACKENDS["test_backend"] == FakeParallelBackend
+    finally:
+        del BACKENDS["test_backend"]
+
+
+def test_overwrite_default_backend():
+    assert _active_backend_type() == DefaultBackend
+    try:
+        register_parallel_backend("threading", BACKENDS["threading"],
+                                  make_default=True)
+        assert _active_backend_type() == ThreadingBackend
+    finally:
+        # Restore the global default manually
+        parallel.DEFAULT_BACKEND = DEFAULT_BACKEND
+    assert _active_backend_type() == DefaultBackend
+
+
+@skipif(mp is not None, reason="Only without multiprocessing")
+def test_backend_no_multiprocessing():
+    with warns(UserWarning,
+               match="joblib backend '.*' is not available on.*"):
+        Parallel(backend='loky')(delayed(square)(i) for i in range(3))
+
+    # The below should now work without problems
+    with parallel_config(backend='loky'):
+        Parallel()(delayed(square)(i) for i in range(3))
+
+
+def check_backend_context_manager(context, backend_name):
+    with context(backend_name, n_jobs=3):
+        active_backend, active_n_jobs = parallel.get_active_backend()
+        assert active_n_jobs == 3
+        assert effective_n_jobs(3) == 3
+        p = Parallel()
+        assert p.n_jobs == 3
+        if backend_name == 'multiprocessing':
+            assert type(active_backend) is MultiprocessingBackend
+            assert type(p._backend) is MultiprocessingBackend
+        elif backend_name == 'loky':
+            assert type(active_backend) is LokyBackend
+            assert type(p._backend) is LokyBackend
+        elif backend_name == 'threading':
+            assert type(active_backend) is ThreadingBackend
+            assert type(p._backend) is ThreadingBackend
+        elif backend_name.startswith('test_'):
+            assert type(active_backend) is FakeParallelBackend
+            assert type(p._backend) is FakeParallelBackend
+
+
+all_backends_for_context_manager = PARALLEL_BACKENDS[:]
+all_backends_for_context_manager.extend(
+    ['test_backend_%d' % i for i in range(3)]
+)
+
+
+@with_multiprocessing
+@parametrize('backend', all_backends_for_context_manager)
+@parametrize('context', [parallel_backend, parallel_config])
+def test_backend_context_manager(monkeypatch, backend, context):
+    if backend not in BACKENDS:
+        monkeypatch.setitem(BACKENDS, backend, FakeParallelBackend)
+
+    assert _active_backend_type() == DefaultBackend
+    # check that this possible to switch parallel backends sequentially
+    check_backend_context_manager(context, backend)
+
+    # The default backend is restored
+    assert _active_backend_type() == DefaultBackend
+
+    # Check that context manager switching is thread safe:
+    Parallel(n_jobs=2, backend='threading')(
+        delayed(check_backend_context_manager)(context, b)
+        for b in all_backends_for_context_manager if not b)
+
+    # The default backend is again restored
+    assert _active_backend_type() == DefaultBackend
+
+
+class ParameterizedParallelBackend(SequentialBackend):
+    """Pretends to run conncurrently while running sequentially."""
+
+    def __init__(self, param=None):
+        if param is None:
+            raise ValueError('param should not be None')
+        self.param = param
+
+
+@parametrize("context", [parallel_config, parallel_backend])
+def test_parameterized_backend_context_manager(monkeypatch, context):
+    monkeypatch.setitem(BACKENDS, 'param_backend',
+                        ParameterizedParallelBackend)
+    assert _active_backend_type() == DefaultBackend
+
+    with context('param_backend', param=42, n_jobs=3):
+        active_backend, active_n_jobs = parallel.get_active_backend()
+        assert type(active_backend) is ParameterizedParallelBackend
+        assert active_backend.param == 42
+        assert active_n_jobs == 3
+        p = Parallel()
+        assert p.n_jobs == 3
+        assert p._backend is active_backend
+        results = p(delayed(sqrt)(i) for i in range(5))
+    assert results == [sqrt(i) for i in range(5)]
+
+    # The default backend is again restored
+    assert _active_backend_type() == DefaultBackend
+
+
+@parametrize("context", [parallel_config, parallel_backend])
+def test_directly_parameterized_backend_context_manager(context):
+    assert _active_backend_type() == DefaultBackend
+
+    # Check that it's possible to pass a backend instance directly,
+    # without registration
+    with context(ParameterizedParallelBackend(param=43), n_jobs=5):
+        active_backend, active_n_jobs = parallel.get_active_backend()
+        assert type(active_backend) is ParameterizedParallelBackend
+        assert active_backend.param == 43
+        assert active_n_jobs == 5
+        p = Parallel()
+        assert p.n_jobs == 5
+        assert p._backend is active_backend
+        results = p(delayed(sqrt)(i) for i in range(5))
+    assert results == [sqrt(i) for i in range(5)]
+
+    # The default backend is again restored
+    assert _active_backend_type() == DefaultBackend
+
+
+def sleep_and_return_pid():
+    sleep(.1)
+    return os.getpid()
+
+
+def get_nested_pids():
+    assert _active_backend_type() == ThreadingBackend
+    # Assert that the nested backend does not change the default number of
+    # jobs used in Parallel
+    assert Parallel()._effective_n_jobs() == 1
+
+    # Assert that the tasks are running only on one process
+    return Parallel(n_jobs=2)(delayed(sleep_and_return_pid)()
+                              for _ in range(2))
+
+
+class MyBackend(joblib._parallel_backends.LokyBackend):
+    """Backend to test backward compatibility with older backends"""
+    def get_nested_backend(self, ):
+        # Older backends only return a backend, without n_jobs indications.
+        return super(MyBackend, self).get_nested_backend()[0]
+
+
+register_parallel_backend('back_compat_backend', MyBackend)
+
+
+@with_multiprocessing
+@parametrize('backend', ['threading', 'loky', 'multiprocessing',
+                         'back_compat_backend'])
+@parametrize("context", [parallel_config, parallel_backend])
+def test_nested_backend_context_manager(context, backend):
+    # Check that by default, nested parallel calls will always use the
+    # ThreadingBackend
+
+    with context(backend):
+        pid_groups = Parallel(n_jobs=2)(
+            delayed(get_nested_pids)()
+            for _ in range(10)
+        )
+        for pid_group in pid_groups:
+            assert len(set(pid_group)) == 1
+
+
+@with_multiprocessing
+@parametrize('n_jobs', [2, -1, None])
+@parametrize('backend', PARALLEL_BACKENDS)
+@parametrize("context", [parallel_config, parallel_backend])
+def test_nested_backend_in_sequential(backend, n_jobs, context):
+    # Check that by default, nested parallel calls will always use the
+    # ThreadingBackend
+
+    def check_nested_backend(expected_backend_type, expected_n_job):
+        # Assert that the sequential backend at top level, does not change the
+        # backend for nested calls.
+        assert _active_backend_type() == BACKENDS[expected_backend_type]
+
+        # Assert that the nested backend in SequentialBackend does not change
+        # the default number of jobs used in Parallel
+        expected_n_job = effective_n_jobs(expected_n_job)
+        assert Parallel()._effective_n_jobs() == expected_n_job
+
+    Parallel(n_jobs=1)(
+        delayed(check_nested_backend)(DEFAULT_BACKEND, 1)
+        for _ in range(10)
+    )
+
+    with context(backend, n_jobs=n_jobs):
+        Parallel(n_jobs=1)(
+            delayed(check_nested_backend)(backend, n_jobs)
+            for _ in range(10)
+        )
+
+
+def check_nesting_level(context, inner_backend, expected_level):
+    with context(inner_backend) as ctx:
+        if context is parallel_config:
+            backend = ctx["backend"]
+        if context is parallel_backend:
+            backend = ctx[0]
+        assert backend.nesting_level == expected_level
+
+
+@with_multiprocessing
+@parametrize('outer_backend', PARALLEL_BACKENDS)
+@parametrize('inner_backend', PARALLEL_BACKENDS)
+@parametrize("context", [parallel_config, parallel_backend])
+def test_backend_nesting_level(context, outer_backend, inner_backend):
+    # Check that the nesting level for the backend is correctly set
+    check_nesting_level(context, outer_backend, 0)
+
+    Parallel(n_jobs=2, backend=outer_backend)(
+        delayed(check_nesting_level)(context, inner_backend, 1)
+        for _ in range(10)
+    )
+
+    with context(inner_backend, n_jobs=2):
+        Parallel()(delayed(check_nesting_level)(context, inner_backend, 1)
+                   for _ in range(10))
+
+
+@with_multiprocessing
+@parametrize("context", [parallel_config, parallel_backend])
+@parametrize('with_retrieve_callback', [True, False])
+def test_retrieval_context(context, with_retrieve_callback):
+    import contextlib
+
+    class MyBackend(ThreadingBackend):
+        i = 0
+        supports_retrieve_callback = with_retrieve_callback
+
+        @contextlib.contextmanager
+        def retrieval_context(self):
+            self.i += 1
+            yield
+
+    register_parallel_backend("retrieval", MyBackend)
+
+    def nested_call(n):
+        return Parallel(n_jobs=2)(delayed(id)(i) for i in range(n))
+
+    with context("retrieval") as ctx:
+        Parallel(n_jobs=2)(
+            delayed(nested_call)(i)
+            for i in range(5)
+        )
+        if context is parallel_config:
+            assert ctx["backend"].i == 1
+        if context is parallel_backend:
+            assert ctx[0].i == 1
+
+
+###############################################################################
+# Test helpers
+
+@parametrize('batch_size', [0, -1, 1.42])
+def test_invalid_batch_size(batch_size):
+    with raises(ValueError):
+        Parallel(batch_size=batch_size)
+
+
+@parametrize('n_tasks, n_jobs, pre_dispatch, batch_size',
+             [(2, 2, 'all', 'auto'),
+              (2, 2, 'n_jobs', 'auto'),
+              (10, 2, 'n_jobs', 'auto'),
+              (517, 2, 'n_jobs', 'auto'),
+              (10, 2, 'n_jobs', 'auto'),
+              (10, 4, 'n_jobs', 'auto'),
+              (200, 12, 'n_jobs', 'auto'),
+              (25, 12, '2 * n_jobs', 1),
+              (250, 12, 'all', 1),
+              (250, 12, '2 * n_jobs', 7),
+              (200, 12, '2 * n_jobs', 'auto')])
+def test_dispatch_race_condition(n_tasks, n_jobs, pre_dispatch, batch_size):
+    # Check that using (async-)dispatch does not yield a race condition on the
+    # iterable generator that is not thread-safe natively.
+    # This is a non-regression test for the "Pool seems closed" class of error
+    params = {'n_jobs': n_jobs, 'pre_dispatch': pre_dispatch,
+              'batch_size': batch_size}
+    expected = [square(i) for i in range(n_tasks)]
+    results = Parallel(**params)(delayed(square)(i) for i in range(n_tasks))
+    assert results == expected
+
+
+@with_multiprocessing
+def test_default_mp_context():
+    mp_start_method = mp.get_start_method()
+    p = Parallel(n_jobs=2, backend='multiprocessing')
+    context = p._backend_args.get('context')
+    start_method = context.get_start_method()
+    assert start_method == mp_start_method
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize('backend', PROCESS_BACKENDS)
+def test_no_blas_crash_or_freeze_with_subprocesses(backend):
+    if backend == 'multiprocessing':
+        # Use the spawn backend that is both robust and available on all
+        # platforms
+        backend = mp.get_context('spawn')
+
+    # Check that on recent Python version, the 'spawn' start method can make
+    # it possible to use multiprocessing in conjunction of any BLAS
+    # implementation that happens to be used by numpy with causing a freeze or
+    # a crash
+    rng = np.random.RandomState(42)
+
+    # call BLAS DGEMM to force the initialization of the internal thread-pool
+    # in the main process
+    a = rng.randn(1000, 1000)
+    np.dot(a, a.T)
+
+    # check that the internal BLAS thread-pool is not in an inconsistent state
+    # in the worker processes managed by multiprocessing
+    Parallel(n_jobs=2, backend=backend)(
+        delayed(np.dot)(a, a.T) for i in range(2))
+
+
+UNPICKLABLE_CALLABLE_SCRIPT_TEMPLATE_NO_MAIN = """\
+from joblib import Parallel, delayed
+
+def square(x):
+    return x ** 2
+
+backend = "{}"
+if backend == "spawn":
+    from multiprocessing import get_context
+    backend = get_context(backend)
+
+print(Parallel(n_jobs=2, backend=backend)(
+      delayed(square)(i) for i in range(5)))
+"""
+
+
+@with_multiprocessing
+@parametrize('backend', PROCESS_BACKENDS)
+def test_parallel_with_interactively_defined_functions(backend):
+    # When using the "-c" flag, interactive functions defined in __main__
+    # should work with any backend.
+    if backend == "multiprocessing" and mp.get_start_method() != "fork":
+        pytest.skip("Require fork start method to use interactively defined "
+                    "functions with multiprocessing.")
+    code = UNPICKLABLE_CALLABLE_SCRIPT_TEMPLATE_NO_MAIN.format(backend)
+    check_subprocess_call(
+        [sys.executable, '-c', code], timeout=10,
+        stdout_regex=r'\[0, 1, 4, 9, 16\]')
+
+
+UNPICKLABLE_CALLABLE_SCRIPT_TEMPLATE_MAIN = """\
+import sys
+# Make sure that joblib is importable in the subprocess launching this
+# script. This is needed in case we run the tests from the joblib root
+# folder without having installed joblib
+sys.path.insert(0, {joblib_root_folder!r})
+
+from joblib import Parallel, delayed
+
+def run(f, x):
+    return f(x)
+
+{define_func}
+
+if __name__ == "__main__":
+    backend = "{backend}"
+    if backend == "spawn":
+        from multiprocessing import get_context
+        backend = get_context(backend)
+
+    callable_position = "{callable_position}"
+    if callable_position == "delayed":
+        print(Parallel(n_jobs=2, backend=backend)(
+                delayed(square)(i) for i in range(5)))
+    elif callable_position == "args":
+        print(Parallel(n_jobs=2, backend=backend)(
+                delayed(run)(square, i) for i in range(5)))
+    else:
+        print(Parallel(n_jobs=2, backend=backend)(
+                delayed(run)(f=square, x=i) for i in range(5)))
+"""
+
+SQUARE_MAIN = """\
+def square(x):
+    return x ** 2
+"""
+SQUARE_LOCAL = """\
+def gen_square():
+    def square(x):
+        return x ** 2
+    return square
+square = gen_square()
+"""
+SQUARE_LAMBDA = """\
+square = lambda x: x ** 2
+"""
+
+
+@with_multiprocessing
+@parametrize('backend', PROCESS_BACKENDS + ([] if mp is None else ['spawn']))
+@parametrize('define_func', [SQUARE_MAIN, SQUARE_LOCAL, SQUARE_LAMBDA])
+@parametrize('callable_position', ['delayed', 'args', 'kwargs'])
+def test_parallel_with_unpicklable_functions_in_args(
+        backend, define_func, callable_position, tmpdir):
+    if backend in ['multiprocessing', 'spawn'] and (
+            define_func != SQUARE_MAIN or sys.platform == "win32"):
+        pytest.skip("Not picklable with pickle")
+    code = UNPICKLABLE_CALLABLE_SCRIPT_TEMPLATE_MAIN.format(
+        define_func=define_func, backend=backend,
+        callable_position=callable_position,
+        joblib_root_folder=os.path.dirname(os.path.dirname(joblib.__file__)))
+    code_file = tmpdir.join("unpicklable_func_script.py")
+    code_file.write(code)
+    check_subprocess_call(
+        [sys.executable, code_file.strpath], timeout=10,
+        stdout_regex=r'\[0, 1, 4, 9, 16\]')
+
+
+INTERACTIVE_DEFINED_FUNCTION_AND_CLASS_SCRIPT_CONTENT = """\
+import sys
+import faulthandler
+# Make sure that joblib is importable in the subprocess launching this
+# script. This is needed in case we run the tests from the joblib root
+# folder without having installed joblib
+sys.path.insert(0, {joblib_root_folder!r})
+
+from joblib import Parallel, delayed
+from functools import partial
+
+class MyClass:
+    '''Class defined in the __main__ namespace'''
+    def __init__(self, value):
+        self.value = value
+
+
+def square(x, ignored=None, ignored2=None):
+    '''Function defined in the __main__ namespace'''
+    return x.value ** 2
+
+
+square2 = partial(square, ignored2='something')
+
+# Here, we do not need the `if __name__ == "__main__":` safeguard when
+# using the default `loky` backend (even on Windows).
+
+# To make debugging easier
+faulthandler.dump_traceback_later(30, exit=True)
+
+# The following baroque function call is meant to check that joblib
+# introspection rightfully uses cloudpickle instead of the (faster) pickle
+# module of the standard library when necessary. In particular cloudpickle is
+# necessary for functions and instances of classes interactively defined in the
+# __main__ module.
+
+print(Parallel(backend="loky", n_jobs=2)(
+    delayed(square2)(MyClass(i), ignored=[dict(a=MyClass(1))])
+    for i in range(5)
+))
+""".format(joblib_root_folder=os.path.dirname(
+    os.path.dirname(joblib.__file__)))
+
+
+@with_multiprocessing
+def test_parallel_with_interactively_defined_functions_loky(tmpdir):
+    # loky accepts interactive functions defined in __main__ and does not
+    # require if __name__ == '__main__' even when the __main__ module is
+    # defined by the result of the execution of a filesystem script.
+    script = tmpdir.join('joblib_interactively_defined_function.py')
+    script.write(INTERACTIVE_DEFINED_FUNCTION_AND_CLASS_SCRIPT_CONTENT)
+    check_subprocess_call(
+        [sys.executable, script.strpath],
+        stdout_regex=r'\[0, 1, 4, 9, 16\]',
+        timeout=None,  # rely on faulthandler to kill the process
+    )
+
+
+INTERACTIVELY_DEFINED_SUBCLASS_WITH_METHOD_SCRIPT_CONTENT = """\
+import sys
+# Make sure that joblib is importable in the subprocess launching this
+# script. This is needed in case we run the tests from the joblib root
+# folder without having installed joblib
+sys.path.insert(0, {joblib_root_folder!r})
+
+from joblib import Parallel, delayed, hash
+import multiprocessing as mp
+mp.util.log_to_stderr(5)
+
+class MyList(list):
+    '''MyList is interactively defined by MyList.append is a built-in'''
+    def __hash__(self):
+        # XXX: workaround limitation in cloudpickle
+        return hash(self).__hash__()
+
+l = MyList()
+
+print(Parallel(backend="loky", n_jobs=2)(
+    delayed(l.append)(i) for i in range(3)
+))
+""".format(joblib_root_folder=os.path.dirname(
+    os.path.dirname(joblib.__file__)))
+
+
+@with_multiprocessing
+def test_parallel_with_interactively_defined_bound_method_loky(tmpdir):
+    script = tmpdir.join('joblib_interactive_bound_method_script.py')
+    script.write(INTERACTIVELY_DEFINED_SUBCLASS_WITH_METHOD_SCRIPT_CONTENT)
+    check_subprocess_call([sys.executable, script.strpath],
+                          stdout_regex=r'\[None, None, None\]',
+                          stderr_regex=r'LokyProcess',
+                          timeout=15)
+
+
+def test_parallel_with_exhausted_iterator():
+    exhausted_iterator = iter([])
+    assert Parallel(n_jobs=2)(exhausted_iterator) == []
+
+
+def _cleanup_worker():
+    """Helper function to force gc in each worker."""
+    force_gc_pypy()
+    time.sleep(.1)
+
+
+def check_memmap(a):
+    if not isinstance(a, np.memmap):
+        raise TypeError('Expected np.memmap instance, got %r',
+                        type(a))
+    return a.copy()  # return a regular array instead of a memmap
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize('backend', PROCESS_BACKENDS)
+def test_auto_memmap_on_arrays_from_generator(backend):
+    # Non-regression test for a problem with a bad interaction between the
+    # GC collecting arrays recently created during iteration inside the
+    # parallel dispatch loop and the auto-memmap feature of Parallel.
+    # See: https://github.com/joblib/joblib/pull/294
+    def generate_arrays(n):
+        for i in range(n):
+            yield np.ones(10, dtype=np.float32) * i
+    # Use max_nbytes=1 to force the use of memory-mapping even for small
+    # arrays
+    results = Parallel(n_jobs=2, max_nbytes=1, backend=backend)(
+        delayed(check_memmap)(a) for a in generate_arrays(100))
+    for result, expected in zip(results, generate_arrays(len(results))):
+        np.testing.assert_array_equal(expected, result)
+
+    # Second call to force loky to adapt the executor by growing the number
+    # of worker processes. This is a non-regression test for:
+    # https://github.com/joblib/joblib/issues/629.
+    results = Parallel(n_jobs=4, max_nbytes=1, backend=backend)(
+        delayed(check_memmap)(a) for a in generate_arrays(100))
+    for result, expected in zip(results, generate_arrays(len(results))):
+        np.testing.assert_array_equal(expected, result)
+
+
+def identity(arg):
+    return arg
+
+
+@with_numpy
+@with_multiprocessing
+def test_memmap_with_big_offset(tmpdir):
+    fname = tmpdir.join('test.mmap').strpath
+    size = mmap.ALLOCATIONGRANULARITY
+    obj = [np.zeros(size, dtype='uint8'), np.ones(size, dtype='uint8')]
+    dump(obj, fname)
+    memmap = load(fname, mmap_mode='r')
+    result, = Parallel(n_jobs=2)(delayed(identity)(memmap) for _ in [0])
+    assert isinstance(memmap[1], np.memmap)
+    assert memmap[1].offset > size
+    np.testing.assert_array_equal(obj, result)
+
+
+def test_warning_about_timeout_not_supported_by_backend():
+    with warnings.catch_warnings(record=True) as warninfo:
+        Parallel(n_jobs=1, timeout=1)(delayed(square)(i) for i in range(50))
+    assert len(warninfo) == 1
+    w = warninfo[0]
+    assert isinstance(w.message, UserWarning)
+    assert str(w.message) == (
+        "The backend class 'SequentialBackend' does not support timeout. "
+        "You have set 'timeout=1' in Parallel but the 'timeout' parameter "
+        "will not be used.")
+
+
+def set_list_value(input_list, index, value):
+    input_list[index] = value
+    return value
+
+
+@pytest.mark.parametrize('n_jobs', [1, 2, 4])
+def test_parallel_return_order_with_return_as_generator_parameter(n_jobs):
+    # This test inserts values in a list in some expected order
+    # in sequential computing, and then checks that this order has been
+    # respected by Parallel output generator.
+    input_list = [0] * 5
+    result = Parallel(n_jobs=n_jobs, return_as="generator",
+                      backend='threading')(
+        delayed(set_list_value)(input_list, i, i) for i in range(5))
+
+    # Ensure that all the tasks are completed before checking the result
+    result = list(result)
+
+    assert all(v == r for v, r in zip(input_list, result))
+
+
+def _sqrt_with_delay(e, delay):
+    if delay:
+        sleep(30)
+    return sqrt(e)
+
+
+def _test_parallel_unordered_generator_returns_fastest_first(backend, n_jobs):
+    # This test submits 10 tasks, but the second task is super slow. This test
+    # checks that the 9 other tasks return before the slow task is done, when
+    # `return_as` parameter is set to `'generator_unordered'`
+    result = Parallel(n_jobs=n_jobs, return_as="generator_unordered",
+                      backend=backend)(
+        delayed(_sqrt_with_delay)(i**2, (i == 1)) for i in range(10))
+
+    quickly_returned = sorted(next(result) for _ in range(9))
+
+    expected_quickly_returned = [0] + list(range(2, 10))
+
+    assert all(
+        v == r for v, r in zip(expected_quickly_returned, quickly_returned)
+    )
+
+    del result
+    force_gc_pypy()
+
+
+@pytest.mark.parametrize('n_jobs', [2, 4])
+# NB: for this test to work, the backend must be allowed to process tasks
+# concurrently, so at least two jobs with a non-sequential backend are
+# mandatory.
+@with_multiprocessing
+@parametrize('backend', set(RETURN_GENERATOR_BACKENDS) - {"sequential"})
+def test_parallel_unordered_generator_returns_fastest_first(backend, n_jobs):
+    _test_parallel_unordered_generator_returns_fastest_first(backend, n_jobs)
+
+
+@pytest.mark.parametrize('n_jobs', [2, -1])
+@parametrize("context", [parallel_config, parallel_backend])
+@skipif(distributed is None, reason='This test requires dask')
+def test_parallel_unordered_generator_returns_fastest_first_with_dask(
+        n_jobs, context
+):
+    with distributed.Client(
+            n_workers=2, threads_per_worker=2
+    ), context("dask"):
+        _test_parallel_unordered_generator_returns_fastest_first(None, n_jobs)
+
+
+@parametrize('backend', ALL_VALID_BACKENDS)
+@parametrize('n_jobs', [1, 2, -2, -1])
+def test_abort_backend(n_jobs, backend):
+    delays = ["a"] + [10] * 100
+    with raises(TypeError):
+        t_start = time.time()
+        Parallel(n_jobs=n_jobs, backend=backend)(
+            delayed(time.sleep)(i) for i in delays)
+    dt = time.time() - t_start
+    assert dt < 20
+
+
+def get_large_object(arg):
+    result = np.ones(int(5 * 1e5), dtype=bool)
+    result[0] = False
+    return result
+
+
+def _test_deadlock_with_generator(backend, return_as, n_jobs):
+    # Non-regression test for a race condition in the backends when the pickler
+    # is delayed by a large object.
+    with Parallel(n_jobs=n_jobs, backend=backend,
+                  return_as=return_as) as parallel:
+        result = parallel(delayed(get_large_object)(i) for i in range(10))
+        next(result)
+        next(result)
+        del result
+        # The gc in pypy can be delayed. Force it to make sure this test does
+        # not cause timeout on the CI.
+        force_gc_pypy()
+
+
+@with_numpy
+@parametrize('backend', RETURN_GENERATOR_BACKENDS)
+@parametrize('return_as', ["generator", "generator_unordered"])
+@parametrize('n_jobs', [1, 2, -2, -1])
+def test_deadlock_with_generator(backend, return_as, n_jobs):
+    _test_deadlock_with_generator(backend, return_as, n_jobs)
+
+
+@with_numpy
+@pytest.mark.parametrize('n_jobs', [2, -1])
+@parametrize('return_as', ["generator", "generator_unordered"])
+@parametrize("context", [parallel_config, parallel_backend])
+@skipif(distributed is None, reason='This test requires dask')
+def test_deadlock_with_generator_and_dask(context, return_as, n_jobs):
+    with distributed.Client(
+            n_workers=2, threads_per_worker=2
+    ), context("dask"):
+        _test_deadlock_with_generator(None, return_as, n_jobs)
+
+
+@parametrize('backend', RETURN_GENERATOR_BACKENDS)
+@parametrize('return_as', ["generator", "generator_unordered"])
+@parametrize('n_jobs', [1, 2, -2, -1])
+def test_multiple_generator_call(backend, return_as, n_jobs):
+    # Non-regression test that ensures the dispatch of the tasks starts
+    # immediately when Parallel.__call__ is called. This test relies on the
+    # assumption that only one generator can be submitted at a time.
+    with raises(RuntimeError,
+                match="This Parallel instance is already running"):
+        parallel = Parallel(n_jobs, backend=backend, return_as=return_as)
+        g = parallel(delayed(sleep)(1) for _ in range(10))  # noqa: F841
+        t_start = time.time()
+        gen2 = parallel(delayed(id)(i) for i in range(100))  # noqa: F841
+
+    # Make sure that the error is raised quickly
+    assert time.time() - t_start < 2, (
+        "The error should be raised immediatly when submitting a new task "
+        "but it took more than 2s."
+    )
+
+    del g
+    # The gc in pypy can be delayed. Force it to make sure this test does not
+    # cause timeout on the CI.
+    force_gc_pypy()
+
+
+@parametrize('backend', RETURN_GENERATOR_BACKENDS)
+@parametrize('return_as', ["generator", "generator_unordered"])
+@parametrize('n_jobs', [1, 2, -2, -1])
+def test_multiple_generator_call_managed(backend, return_as, n_jobs):
+    # Non-regression test that ensures the dispatch of the tasks starts
+    # immediately when Parallel.__call__ is called. This test relies on the
+    # assumption that only one generator can be submitted at a time.
+    with Parallel(n_jobs, backend=backend,
+                  return_as=return_as) as parallel:
+        g = parallel(delayed(sleep)(10) for _ in range(10))  # noqa: F841
+        t_start = time.time()
+        with raises(RuntimeError,
+                    match="This Parallel instance is already running"):
+            g2 = parallel(delayed(id)(i) for i in range(100))  # noqa: F841
+
+        # Make sure that the error is raised quickly
+        assert time.time() - t_start < 2, (
+            "The error should be raised immediatly when submitting a new task "
+            "but it took more than 2s."
+        )
+
+    # The gc in pypy can be delayed. Force it to make sure this test does not
+    # cause timeout on the CI.
+    del g
+    force_gc_pypy()
+
+
+@parametrize('backend', RETURN_GENERATOR_BACKENDS)
+@parametrize('return_as_1', ["generator", "generator_unordered"])
+@parametrize('return_as_2', ["generator", "generator_unordered"])
+@parametrize('n_jobs', [1, 2, -2, -1])
+def test_multiple_generator_call_separated(
+        backend, return_as_1, return_as_2, n_jobs
+):
+    # Check that for separated Parallel, both tasks are correctly returned.
+    g = Parallel(n_jobs, backend=backend, return_as=return_as_1)(
+        delayed(sqrt)(i ** 2) for i in range(10)
+    )
+    g2 = Parallel(n_jobs, backend=backend, return_as=return_as_2)(
+        delayed(sqrt)(i ** 2) for i in range(10, 20)
+    )
+
+    if return_as_1 == "generator_unordered":
+        g = sorted(g)
+
+    if return_as_2 == "generator_unordered":
+        g2 = sorted(g2)
+
+    assert all(res == i for res, i in zip(g, range(10)))
+    assert all(res == i for res, i in zip(g2, range(10, 20)))
+
+
+@parametrize('backend, error', [
+    ('loky', True),
+    ('threading', False),
+    ('sequential', False),
+])
+@parametrize('return_as_1', ["generator", "generator_unordered"])
+@parametrize('return_as_2', ["generator", "generator_unordered"])
+def test_multiple_generator_call_separated_gc(
+        backend, return_as_1, return_as_2, error
+):
+
+    if (backend == 'loky') and (mp is None):
+        pytest.skip("Requires multiprocessing")
+
+    # Check that in loky, only one call can be run at a time with
+    # a single executor.
+    parallel = Parallel(2, backend=backend, return_as=return_as_1)
+    g = parallel(delayed(sleep)(10) for i in range(10))
+    g_wr = weakref.finalize(g, lambda: print("Generator collected"))
+    ctx = (
+        raises(RuntimeError, match="The executor underlying Parallel")
+        if error else nullcontext()
+    )
+    with ctx:
+        # For loky, this call will raise an error as the gc of the previous
+        # generator will shutdown the shared executor.
+        # For the other backends, as the worker pools are not shared between
+        # the two calls, this should proceed correctly.
+        t_start = time.time()
+        g = Parallel(2, backend=backend, return_as=return_as_2)(
+            delayed(sqrt)(i ** 2) for i in range(10, 20)
+        )
+
+        # The gc in pypy can be delayed. Force it to test the behavior when it
+        # will eventually be collected.
+        force_gc_pypy()
+
+        if return_as_2 == "generator_unordered":
+            g = sorted(g)
+
+        assert all(res == i for res, i in zip(g, range(10, 20)))
+
+    assert time.time() - t_start < 5
+
+    # Make sure that the computation are stopped for the gc'ed generator
+    retry = 0
+    while g_wr.alive and retry < 3:
+        retry += 1
+        time.sleep(.5)
+    assert time.time() - t_start < 5
+
+    if parallel._effective_n_jobs() != 1:
+        # check that the first parallel object is aborting (the final _aborted
+        # state might be delayed).
+        assert parallel._aborting
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize('backend', PROCESS_BACKENDS)
+def test_memmapping_leaks(backend, tmpdir):
+    # Non-regression test for memmapping backends. Ensure that the data
+    # does not stay too long in memory
+    tmpdir = tmpdir.strpath
+
+    # Use max_nbytes=1 to force the use of memory-mapping even for small
+    # arrays
+    with Parallel(n_jobs=2, max_nbytes=1, backend=backend,
+                  temp_folder=tmpdir) as p:
+        p(delayed(check_memmap)(a) for a in [np.random.random(10)] * 2)
+
+        # The memmap folder should not be clean in the context scope
+        assert len(os.listdir(tmpdir)) > 0
+
+        # Cleaning of the memmap folder is triggered by the garbage
+        # collection. With pypy the garbage collection has been observed to be
+        # delayed, sometimes up until the shutdown of the interpreter. This
+        # cleanup job executed in the worker ensures that it's triggered
+        # immediately.
+        p(delayed(_cleanup_worker)() for _ in range(2))
+
+    # Make sure that the shared memory is cleaned at the end when we exit
+    # the context
+    for _ in range(100):
+        if not os.listdir(tmpdir):
+            break
+        sleep(.1)
+    else:
+        raise AssertionError('temporary directory of Parallel was not removed')
+
+    # Make sure that the shared memory is cleaned at the end of a call
+    p = Parallel(n_jobs=2, max_nbytes=1, backend=backend)
+    p(delayed(check_memmap)(a) for a in [np.random.random(10)] * 2)
+    p(delayed(_cleanup_worker)() for _ in range(2))
+
+    for _ in range(100):
+        if not os.listdir(tmpdir):
+            break
+        sleep(.1)
+    else:
+        raise AssertionError('temporary directory of Parallel was not removed')
+
+
+@parametrize('backend',
+             ([None, 'threading'] if mp is None
+              else [None, 'loky', 'threading'])
+             )
+def test_lambda_expression(backend):
+    # cloudpickle is used to pickle delayed callables
+    results = Parallel(n_jobs=2, backend=backend)(
+        delayed(lambda x: x ** 2)(i) for i in range(10))
+    assert results == [i ** 2 for i in range(10)]
+
+
+@with_multiprocessing
+@parametrize('backend', PROCESS_BACKENDS)
+def test_backend_batch_statistics_reset(backend):
+    """Test that a parallel backend correctly resets its batch statistics."""
+    n_jobs = 2
+    n_inputs = 500
+    task_time = 2. / n_inputs
+
+    p = Parallel(verbose=10, n_jobs=n_jobs, backend=backend)
+    p(delayed(time.sleep)(task_time) for i in range(n_inputs))
+    assert (p._backend._effective_batch_size ==
+            p._backend._DEFAULT_EFFECTIVE_BATCH_SIZE)
+    assert (p._backend._smoothed_batch_duration ==
+            p._backend._DEFAULT_SMOOTHED_BATCH_DURATION)
+
+    p(delayed(time.sleep)(task_time) for i in range(n_inputs))
+    assert (p._backend._effective_batch_size ==
+            p._backend._DEFAULT_EFFECTIVE_BATCH_SIZE)
+    assert (p._backend._smoothed_batch_duration ==
+            p._backend._DEFAULT_SMOOTHED_BATCH_DURATION)
+
+
+@with_multiprocessing
+@parametrize("context", [parallel_config, parallel_backend])
+def test_backend_hinting_and_constraints(context):
+    for n_jobs in [1, 2, -1]:
+        assert type(Parallel(n_jobs=n_jobs)._backend) == DefaultBackend
+
+        p = Parallel(n_jobs=n_jobs, prefer='threads')
+        assert type(p._backend) is ThreadingBackend
+
+        p = Parallel(n_jobs=n_jobs, prefer='processes')
+        assert type(p._backend) is DefaultBackend
+
+        p = Parallel(n_jobs=n_jobs, require='sharedmem')
+        assert type(p._backend) is ThreadingBackend
+
+    # Explicit backend selection can override backend hinting although it
+    # is useless to pass a hint when selecting a backend.
+    p = Parallel(n_jobs=2, backend='loky', prefer='threads')
+    assert type(p._backend) is LokyBackend
+
+    with context('loky', n_jobs=2):
+        # Explicit backend selection by the user with the context manager
+        # should be respected when combined with backend hints only.
+        p = Parallel(prefer='threads')
+        assert type(p._backend) is LokyBackend
+        assert p.n_jobs == 2
+
+    with context('loky', n_jobs=2):
+        # Locally hard-coded n_jobs value is respected.
+        p = Parallel(n_jobs=3, prefer='threads')
+        assert type(p._backend) is LokyBackend
+        assert p.n_jobs == 3
+
+    with context('loky', n_jobs=2):
+        # Explicit backend selection by the user with the context manager
+        # should be ignored when the Parallel call has hard constraints.
+        # In this case, the default backend that supports shared mem is
+        # used an the default number of processes is used.
+        p = Parallel(require='sharedmem')
+        assert type(p._backend) is ThreadingBackend
+        assert p.n_jobs == 1
+
+    with context('loky', n_jobs=2):
+        p = Parallel(n_jobs=3, require='sharedmem')
+        assert type(p._backend) is ThreadingBackend
+        assert p.n_jobs == 3
+
+
+@parametrize("context", [parallel_config, parallel_backend])
+def test_backend_hinting_and_constraints_with_custom_backends(
+    capsys, context
+):
+    # Custom backends can declare that they use threads and have shared memory
+    # semantics:
+    class MyCustomThreadingBackend(ParallelBackendBase):
+        supports_sharedmem = True
+        use_threads = True
+
+        def apply_async(self):
+            pass
+
+        def effective_n_jobs(self, n_jobs):
+            return n_jobs
+
+    with context(MyCustomThreadingBackend()):
+        p = Parallel(n_jobs=2, prefer='processes')  # ignored
+        assert type(p._backend) is MyCustomThreadingBackend
+
+        p = Parallel(n_jobs=2, require='sharedmem')
+        assert type(p._backend) is MyCustomThreadingBackend
+
+    class MyCustomProcessingBackend(ParallelBackendBase):
+        supports_sharedmem = False
+        use_threads = False
+
+        def apply_async(self):
+            pass
+
+        def effective_n_jobs(self, n_jobs):
+            return n_jobs
+
+    with context(MyCustomProcessingBackend()):
+        p = Parallel(n_jobs=2, prefer='processes')
+        assert type(p._backend) is MyCustomProcessingBackend
+
+        out, err = capsys.readouterr()
+        assert out == ""
+        assert err == ""
+
+        p = Parallel(n_jobs=2, require='sharedmem', verbose=10)
+        assert type(p._backend) is ThreadingBackend
+
+        out, err = capsys.readouterr()
+        expected = ("Using ThreadingBackend as joblib backend "
+                    "instead of MyCustomProcessingBackend as the latter "
+                    "does not provide shared memory semantics.")
+        assert out.strip() == expected
+        assert err == ""
+
+    with raises(ValueError):
+        Parallel(backend=MyCustomProcessingBackend(), require='sharedmem')
+
+
+def test_invalid_backend_hinting_and_constraints():
+    with raises(ValueError):
+        Parallel(prefer='invalid')
+
+    with raises(ValueError):
+        Parallel(require='invalid')
+
+    with raises(ValueError):
+        # It is inconsistent to prefer process-based parallelism while
+        # requiring shared memory semantics.
+        Parallel(prefer='processes', require='sharedmem')
+
+    if mp is not None:
+        # It is inconsistent to ask explicitly for a process-based
+        # parallelism while requiring shared memory semantics.
+        with raises(ValueError):
+            Parallel(backend='loky', require='sharedmem')
+        with raises(ValueError):
+            Parallel(backend='multiprocessing', require='sharedmem')
+
+
+def _recursive_backend_info(limit=3, **kwargs):
+    """Perform nested parallel calls and introspect the backend on the way"""
+
+    with Parallel(n_jobs=2) as p:
+        this_level = [(type(p._backend).__name__, p._backend.nesting_level)]
+        if limit == 0:
+            return this_level
+        results = p(delayed(_recursive_backend_info)(limit=limit - 1, **kwargs)
+                    for i in range(1))
+        return this_level + results[0]
+
+
+@with_multiprocessing
+@parametrize('backend', ['loky', 'threading'])
+@parametrize("context", [parallel_config, parallel_backend])
+def test_nested_parallelism_limit(context, backend):
+    with context(backend, n_jobs=2):
+        backend_types_and_levels = _recursive_backend_info()
+
+    if cpu_count() == 1:
+        second_level_backend_type = 'SequentialBackend'
+        max_level = 1
+    else:
+        second_level_backend_type = 'ThreadingBackend'
+        max_level = 2
+
+    top_level_backend_type = backend.title() + 'Backend'
+    expected_types_and_levels = [
+        (top_level_backend_type, 0),
+        (second_level_backend_type, 1),
+        ('SequentialBackend', max_level),
+        ('SequentialBackend', max_level)
+    ]
+    assert backend_types_and_levels == expected_types_and_levels
+
+
+@with_numpy
+@parametrize("context", [parallel_config, parallel_backend])
+@skipif(distributed is None, reason='This test requires dask')
+def test_nested_parallelism_with_dask(context):
+    with distributed.Client(n_workers=2, threads_per_worker=2):
+        # 10 MB of data as argument to trigger implicit scattering
+        data = np.ones(int(1e7), dtype=np.uint8)
+        for i in range(2):
+            with context('dask'):
+                backend_types_and_levels = _recursive_backend_info(data=data)
+            assert len(backend_types_and_levels) == 4
+            assert all(name == 'DaskDistributedBackend'
+                       for name, _ in backend_types_and_levels)
+
+        # No argument
+        with context('dask'):
+            backend_types_and_levels = _recursive_backend_info()
+        assert len(backend_types_and_levels) == 4
+        assert all(name == 'DaskDistributedBackend'
+                   for name, _ in backend_types_and_levels)
+
+
+def _recursive_parallel(nesting_limit=None):
+    """A horrible function that does recursive parallel calls"""
+    return Parallel()(delayed(_recursive_parallel)() for i in range(2))
+
+
+@pytest.mark.no_cover
+@parametrize("context", [parallel_config, parallel_backend])
+@parametrize(
+    'backend', (['threading'] if mp is None else ['loky', 'threading'])
+)
+def test_thread_bomb_mitigation(context, backend):
+    # Test that recursive parallelism raises a recursion rather than
+    # saturating the operating system resources by creating a unbounded number
+    # of threads.
+    with context(backend, n_jobs=2):
+        with raises(BaseException) as excinfo:
+            _recursive_parallel()
+    exc = excinfo.value
+    if backend == "loky":
+        # Local import because loky may not be importable for lack of
+        # multiprocessing
+        from joblib.externals.loky.process_executor import TerminatedWorkerError # noqa
+        if isinstance(exc, (TerminatedWorkerError, PicklingError)):
+            # The recursion exception can itself cause an error when
+            # pickling it to be send back to the parent process. In this
+            # case the worker crashes but the original traceback is still
+            # printed on stderr. This could be improved but does not seem
+            # simple to do and this is not critical for users (as long
+            # as there is no process or thread bomb happening).
+            pytest.xfail("Loky worker crash when serializing RecursionError")
+
+    assert isinstance(exc, RecursionError)
+
+
+def _run_parallel_sum():
+    env_vars = {}
+    for var in ['OMP_NUM_THREADS', 'OPENBLAS_NUM_THREADS', 'MKL_NUM_THREADS',
+                'VECLIB_MAXIMUM_THREADS', 'NUMEXPR_NUM_THREADS',
+                'NUMBA_NUM_THREADS', 'ENABLE_IPC']:
+        env_vars[var] = os.environ.get(var)
+    return env_vars, parallel_sum(100)
+
+
+@parametrize("backend", ([None, 'loky'] if mp is not None else [None]))
+@skipif(parallel_sum is None, reason="Need OpenMP helper compiled")
+def test_parallel_thread_limit(backend):
+    results = Parallel(n_jobs=2, backend=backend)(
+        delayed(_run_parallel_sum)() for _ in range(2)
+    )
+    expected_num_threads = max(cpu_count() // 2, 1)
+    for worker_env_vars, omp_num_threads in results:
+        assert omp_num_threads == expected_num_threads
+        for name, value in worker_env_vars.items():
+            if name.endswith("_THREADS"):
+                assert value == str(expected_num_threads)
+            else:
+                assert name == "ENABLE_IPC"
+                assert value == "1"
+
+
+@parametrize("context", [parallel_config, parallel_backend])
+@skipif(distributed is not None, reason='This test requires dask')
+def test_dask_backend_when_dask_not_installed(context):
+    with raises(ValueError, match='Please install dask'):
+        context('dask')
+
+
+@parametrize("context", [parallel_config, parallel_backend])
+def test_zero_worker_backend(context):
+    # joblib.Parallel should reject with an explicit error message parallel
+    # backends that have no worker.
+    class ZeroWorkerBackend(ThreadingBackend):
+        def configure(self, *args, **kwargs):
+            return 0
+
+        def apply_async(self, func, callback=None):   # pragma: no cover
+            raise TimeoutError("No worker available")
+
+        def effective_n_jobs(self, n_jobs):   # pragma: no cover
+            return 0
+
+    expected_msg = "ZeroWorkerBackend has no active worker"
+    with context(ZeroWorkerBackend()):
+        with pytest.raises(RuntimeError, match=expected_msg):
+            Parallel(n_jobs=2)(delayed(id)(i) for i in range(2))
+
+
+def test_globals_update_at_each_parallel_call():
+    # This is a non-regression test related to joblib issues #836 and #833.
+    # Cloudpickle versions between 0.5.4 and 0.7 introduced a bug where global
+    # variables changes in a parent process between two calls to
+    # joblib.Parallel would not be propagated into the workers.
+    global MY_GLOBAL_VARIABLE
+    MY_GLOBAL_VARIABLE = "original value"
+
+    def check_globals():
+        global MY_GLOBAL_VARIABLE
+        return MY_GLOBAL_VARIABLE
+
+    assert check_globals() == "original value"
+
+    workers_global_variable = Parallel(n_jobs=2)(
+        delayed(check_globals)() for i in range(2))
+    assert set(workers_global_variable) == {"original value"}
+
+    # Change the value of MY_GLOBAL_VARIABLE, and make sure this change gets
+    # propagated into the workers environment
+    MY_GLOBAL_VARIABLE = "changed value"
+    assert check_globals() == "changed value"
+
+    workers_global_variable = Parallel(n_jobs=2)(
+        delayed(check_globals)() for i in range(2))
+    assert set(workers_global_variable) == {"changed value"}
+
+
+##############################################################################
+# Test environment variable in child env, in particular for limiting
+# the maximal number of threads in C-library threadpools.
+#
+
+def _check_numpy_threadpool_limits():
+    import numpy as np
+    # Let's call BLAS on a Matrix Matrix multiplication with dimensions large
+    # enough to ensure that the threadpool managed by the underlying BLAS
+    # implementation is actually used so as to force its initialization.
+    a = np.random.randn(100, 100)
+    np.dot(a, a)
+    from threadpoolctl import threadpool_info
+    return threadpool_info()
+
+
+def _parent_max_num_threads_for(child_module, parent_info):
+    for parent_module in parent_info:
+        if parent_module['filepath'] == child_module['filepath']:
+            return parent_module['num_threads']
+    raise ValueError("An unexpected module was loaded in child:\n{}"
+                     .format(child_module))
+
+
+def check_child_num_threads(workers_info, parent_info, num_threads):
+    # Check that the number of threads reported in workers_info is consistent
+    # with the expectation. We need to be careful to handle the cases where
+    # the requested number of threads is below max_num_thread for the library.
+    for child_threadpool_info in workers_info:
+        for child_module in child_threadpool_info:
+            parent_max_num_threads = _parent_max_num_threads_for(
+                child_module, parent_info)
+            expected = {min(num_threads, parent_max_num_threads), num_threads}
+            assert child_module['num_threads'] in expected
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize('n_jobs', [2, 4, -2, -1])
+def test_threadpool_limitation_in_child_loky(n_jobs):
+    # Check that the protection against oversubscription in workers is working
+    # using threadpoolctl functionalities.
+
+    # Skip this test if numpy is not linked to a BLAS library
+    parent_info = _check_numpy_threadpool_limits()
+    if len(parent_info) == 0:
+        pytest.skip(reason="Need a version of numpy linked to BLAS")
+
+    workers_threadpool_infos = Parallel(backend="loky", n_jobs=n_jobs)(
+        delayed(_check_numpy_threadpool_limits)() for i in range(2))
+
+    n_jobs = effective_n_jobs(n_jobs)
+    expected_child_num_threads = max(cpu_count() // n_jobs, 1)
+
+    check_child_num_threads(workers_threadpool_infos, parent_info,
+                            expected_child_num_threads)
+
+
+@with_numpy
+@with_multiprocessing
+@parametrize('inner_max_num_threads', [1, 2, 4, None])
+@parametrize('n_jobs', [2, -1])
+@parametrize("context", [parallel_config, parallel_backend])
+def test_threadpool_limitation_in_child_context(
+    context, n_jobs, inner_max_num_threads
+):
+    # Check that the protection against oversubscription in workers is working
+    # using threadpoolctl functionalities.
+
+    # Skip this test if numpy is not linked to a BLAS library
+    parent_info = _check_numpy_threadpool_limits()
+    if len(parent_info) == 0:
+        pytest.skip(reason="Need a version of numpy linked to BLAS")
+
+    with context('loky', inner_max_num_threads=inner_max_num_threads):
+        workers_threadpool_infos = Parallel(n_jobs=n_jobs)(
+            delayed(_check_numpy_threadpool_limits)() for i in range(2))
+
+    n_jobs = effective_n_jobs(n_jobs)
+    if inner_max_num_threads is None:
+        expected_child_num_threads = max(cpu_count() // n_jobs, 1)
+    else:
+        expected_child_num_threads = inner_max_num_threads
+
+    check_child_num_threads(workers_threadpool_infos, parent_info,
+                            expected_child_num_threads)
+
+
+@with_multiprocessing
+@parametrize('n_jobs', [2, -1])
+@parametrize('var_name', ["OPENBLAS_NUM_THREADS",
+                          "MKL_NUM_THREADS",
+                          "OMP_NUM_THREADS"])
+@parametrize("context", [parallel_config, parallel_backend])
+def test_threadpool_limitation_in_child_override(context, n_jobs, var_name):
+    # Check that environment variables set by the user on the main process
+    # always have the priority.
+
+    # Clean up the existing executor because we change the environment of the
+    # parent at runtime and it is not detected in loky intentionally.
+    get_reusable_executor(reuse=True).shutdown()
+
+    def _get_env(var_name):
+        return os.environ.get(var_name)
+
+    original_var_value = os.environ.get(var_name)
+    try:
+        os.environ[var_name] = "4"
+        # Skip this test if numpy is not linked to a BLAS library
+        results = Parallel(n_jobs=n_jobs)(
+            delayed(_get_env)(var_name) for i in range(2))
+        assert results == ["4", "4"]
+
+        with context('loky', inner_max_num_threads=1):
+            results = Parallel(n_jobs=n_jobs)(
+                delayed(_get_env)(var_name) for i in range(2))
+        assert results == ["1", "1"]
+
+    finally:
+        if original_var_value is None:
+            del os.environ[var_name]
+        else:
+            os.environ[var_name] = original_var_value
+
+
+@with_multiprocessing
+@parametrize('n_jobs', [2, 4, -1])
+def test_loky_reuse_workers(n_jobs):
+    # Non-regression test for issue #967 where the workers are not reused when
+    # calling multiple Parallel loops.
+
+    def parallel_call(n_jobs):
+        x = range(10)
+        Parallel(n_jobs=n_jobs)(delayed(sum)(x) for i in range(10))
+
+    # Run a parallel loop and get the workers used for computations
+    parallel_call(n_jobs)
+    first_executor = get_reusable_executor(reuse=True)
+
+    # Ensure that the workers are reused for the next calls, as the executor is
+    # not restarted.
+    for _ in range(10):
+        parallel_call(n_jobs)
+        executor = get_reusable_executor(reuse=True)
+        assert executor == first_executor
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_store_backends.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_store_backends.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5db16757ea45fd6761e1b8cfd35e5f5a920752f
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/test_store_backends.py
@@ -0,0 +1,94 @@
+
+try:
+    # Python 2.7: use the C pickle to speed up
+    # test_concurrency_safe_write which pickles big python objects
+    import cPickle as cpickle
+except ImportError:
+    import pickle as cpickle
+import functools
+from pickle import PicklingError
+import time
+
+import pytest
+
+from joblib.testing import parametrize, timeout
+from joblib.test.common import with_multiprocessing
+from joblib.backports import concurrency_safe_rename
+from joblib import Parallel, delayed
+from joblib._store_backends import (
+    concurrency_safe_write,
+    FileSystemStoreBackend,
+    CacheWarning,
+)
+
+
+def write_func(output, filename):
+    with open(filename, 'wb') as f:
+        cpickle.dump(output, f)
+
+
+def load_func(expected, filename):
+    for i in range(10):
+        try:
+            with open(filename, 'rb') as f:
+                reloaded = cpickle.load(f)
+            break
+        except (OSError, IOError):
+            # On Windows you can have WindowsError ([Error 5] Access
+            # is denied or [Error 13] Permission denied) when reading the file,
+            # probably because a writer process has a lock on the file
+            time.sleep(0.1)
+    else:
+        raise
+    assert expected == reloaded
+
+
+def concurrency_safe_write_rename(to_write, filename, write_func):
+    temporary_filename = concurrency_safe_write(to_write,
+                                                filename, write_func)
+    concurrency_safe_rename(temporary_filename, filename)
+
+
+@timeout(0)  # No timeout as this test can be long
+@with_multiprocessing
+@parametrize('backend', ['multiprocessing', 'loky', 'threading'])
+def test_concurrency_safe_write(tmpdir, backend):
+    # Add one item to cache
+    filename = tmpdir.join('test.pkl').strpath
+
+    obj = {str(i): i for i in range(int(1e5))}
+    funcs = [functools.partial(concurrency_safe_write_rename,
+                               write_func=write_func)
+             if i % 3 != 2 else load_func for i in range(12)]
+    Parallel(n_jobs=2, backend=backend)(
+        delayed(func)(obj, filename) for func in funcs)
+
+
+def test_warning_on_dump_failure(tmpdir):
+    # Check that a warning is raised when the dump fails for any reason but
+    # a PicklingError.
+    class UnpicklableObject(object):
+        def __reduce__(self):
+            raise RuntimeError("some exception")
+
+    backend = FileSystemStoreBackend()
+    backend.location = tmpdir.join('test_warning_on_pickling_error').strpath
+    backend.compress = None
+
+    with pytest.warns(CacheWarning, match="some exception"):
+        backend.dump_item("testpath", UnpicklableObject())
+
+
+def test_warning_on_pickling_error(tmpdir):
+    # This is separate from test_warning_on_dump_failure because in the
+    # future we will turn this into an exception.
+    class UnpicklableObject(object):
+        def __reduce__(self):
+            raise PicklingError("not picklable")
+
+    backend = FileSystemStoreBackend()
+    backend.location = tmpdir.join('test_warning_on_pickling_error').strpath
+    backend.compress = None
+
+    with pytest.warns(FutureWarning, match="not picklable"):
+        backend.dump_item("testpath", UnpicklableObject())
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/testutils.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/testutils.py
new file mode 100644
index 0000000000000000000000000000000000000000..20ec8c1ba0a50da6be9fce3686ac1950b1a55ab5
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/testutils.py
@@ -0,0 +1,8 @@
+def return_slice_of_data(arr, start_idx, end_idx):
+    return arr[start_idx:end_idx]
+
+
+def print_filename_and_raise(arr):
+    from joblib._memmapping_reducer import _get_backing_memmap
+    print(_get_backing_memmap(arr).filename)
+    raise ValueError
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/INSTALLER b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/METADATA b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..23c78493952bf5a7bbc912b28626a6138c75ab77
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/METADATA
@@ -0,0 +1,142 @@
+Metadata-Version: 2.1
+Name: jupyter-console
+Version: 6.6.3
+Summary: Jupyter terminal console
+Project-URL: Homepage, https://jupyter.org
+Author-email: Jupyter Development Team <jupyter@googlegroups.com>
+License: BSD 3-Clause License
+        
+        - Copyright (c) 2001-2015, IPython Development Team
+        - Copyright (c) 2015-, Jupyter Development Team
+        
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+License-File: LICENSE
+Keywords: Interactive,Interpreter,Shell,Web
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Requires-Dist: ipykernel>=6.14
+Requires-Dist: ipython
+Requires-Dist: jupyter-client>=7.0.0
+Requires-Dist: jupyter-core!=5.0.*,>=4.12
+Requires-Dist: prompt-toolkit>=3.0.30
+Requires-Dist: pygments
+Requires-Dist: pyzmq>=17
+Requires-Dist: traitlets>=5.4
+Provides-Extra: test
+Requires-Dist: flaky; extra == 'test'
+Requires-Dist: pexpect; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Jupyter Console
+[![Build Status](https://travis-ci.org/jupyter/jupyter_console.svg?branch=master)](https://travis-ci.org/jupyter/jupyter_console)
+[![Documentation Status](http://readthedocs.org/projects/jupyter-console/badge/?version=latest)](https://jupyter-console.readthedocs.io/en/latest/?badge=latest)
+
+A terminal-based console frontend for Jupyter kernels.
+This code is based on the single-process IPython terminal.
+
+Install with pip:
+
+    pip install jupyter-console
+
+Install with conda:
+
+    conda install -c conda-forge jupyter_console
+
+Start:
+
+    jupyter console
+
+Help:
+
+    jupyter console -h
+
+Jupyter Console allows for console-based interaction with non-python 
+Jupyter kernels such as IJulia, IRKernel.
+
+To start the console with a particular kernel, ask for it by name::
+
+    jupyter console --kernel=julia-0.4
+
+A list of available kernels can be seen with::
+
+    jupyter kernelspec list
+
+
+### Release build:
+
+```bash
+$ pip install pep517
+$ python -m pep517.build .
+```
+
+
+## Resources
+- [Project Jupyter website](https://jupyter.org)
+- [Documentation for Jupyter Console](https://jupyter-console.readthedocs.io/en/latest/) [[PDF](https://media.readthedocs.org/pdf/jupyter-console/latest/jupyter-console.pdf)]
+- [Documentation for Project Jupyter](https://jupyter.readthedocs.io/en/latest/index.html) [[PDF](https://media.readthedocs.org/pdf/jupyter/latest/jupyter.pdf)]
+- [Issues](https://github.com/jupyter/jupyter_console/issues)
+- [Technical support - Jupyter Google Group](https://groups.google.com/forum/#!forum/jupyter)
+
+## About the Jupyter Development Team
+
+The Jupyter Development Team is the set of all contributors to the Jupyter project.
+This includes all of the Jupyter subprojects.
+
+The core team that coordinates development on GitHub can be found here:
+https://github.com/jupyter/.
+
+## Our Copyright Policy
+
+Jupyter uses a shared copyright model. Each contributor maintains copyright
+over their contributions to Jupyter. But, it is important to note that these
+contributions are typically only changes to the repositories. Thus, the Jupyter
+source code, in its entirety is not the copyright of any single person or
+institution.  Instead, it is the collective copyright of the entire Jupyter
+Development Team.  If individual contributors want to maintain a record of what
+changes/contributions they have specific copyright on, they should indicate
+their copyright in the commit message of the change, when they commit the
+change to one of the Jupyter repositories.
+
+With this in mind, the following banner should be used in any source code file
+to indicate the copyright and license terms:
+
+```
+# Copyright (c) Jupyter Development Team.
+# Distributed under the terms of the Modified BSD License.
+```
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/RECORD b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..a15d138c89ec83ecd4c5b97a44a9ebe72fc4d08f
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/RECORD
@@ -0,0 +1,33 @@
+../../../bin/jupyter-console,sha256=jumIRw_GWEVQWmJYKuEUFCEbHDVQNFySWkbiNwrDB8A,302
+jupyter_console-6.6.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+jupyter_console-6.6.3.dist-info/METADATA,sha256=Jl9bu4rvnFeIsCg9DUYTvhdYWKtajEOAiKl-Ew04KD0,5833
+jupyter_console-6.6.3.dist-info/RECORD,,
+jupyter_console-6.6.3.dist-info/WHEEL,sha256=Fd6mP6ydyRguakwUJ05oBE7fh2IPxgtDN9IwHJ9OqJQ,87
+jupyter_console-6.6.3.dist-info/entry_points.txt,sha256=hgEYjJm5PBhO4wref-74TijoYRlqqRqoeG7IaTaYVRY,61
+jupyter_console-6.6.3.dist-info/licenses/LICENSE,sha256=XKdOTS7rkzCw0SnCX4dNNUShNBO8Yq6NNngZEA0JUHI,1588
+jupyter_console/__init__.py,sha256=eOFC_-OVzzDdVFJDZX3fTG4sOM198_RvSeQ1HyofjyQ,88
+jupyter_console/__main__.py,sha256=9sjVFP9naGVc5XWQ6eh_6Ppfh0bYMQTFzQHTC_0Mxns,90
+jupyter_console/__pycache__/__init__.cpython-310.pyc,,
+jupyter_console/__pycache__/__main__.cpython-310.pyc,,
+jupyter_console/__pycache__/_version.cpython-310.pyc,,
+jupyter_console/__pycache__/app.cpython-310.pyc,,
+jupyter_console/__pycache__/completer.cpython-310.pyc,,
+jupyter_console/__pycache__/ptshell.cpython-310.pyc,,
+jupyter_console/__pycache__/utils.cpython-310.pyc,,
+jupyter_console/__pycache__/zmqhistory.cpython-310.pyc,,
+jupyter_console/_version.py,sha256=TyhQyMM3Ip9WStFBB2EQ4WzFT3rX0Ura_Y8hxKGDjL0,443
+jupyter_console/app.py,sha256=uE3KP6VK-4KnEAfefmWbQU_LtUE72UXD4X-Kr5l38VA,5054
+jupyter_console/completer.py,sha256=PY1LJ8S97F8lcAbIMPDWK59n7xxd_DdGUTbHJ2UrFQY,1399
+jupyter_console/ptshell.py,sha256=fL72QQ5Pj29qJWNrUhmXDu-VwC6MsiVZ6H6aZVPlGJI,38655
+jupyter_console/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jupyter_console/tests/__pycache__/__init__.cpython-310.pyc,,
+jupyter_console/tests/__pycache__/conftest.cpython-310.pyc,,
+jupyter_console/tests/__pycache__/test_console.cpython-310.pyc,,
+jupyter_console/tests/__pycache__/test_image_handler.cpython-310.pyc,,
+jupyter_console/tests/__pycache__/writetofile.cpython-310.pyc,,
+jupyter_console/tests/conftest.py,sha256=XZIIbKgi7ZeKmaFEP_zSgDNj-rshkMIK-rmc7SE63DE,126
+jupyter_console/tests/test_console.py,sha256=GtG2aja-O0EB-EuRc90MbleuXcQGCYdpCbWw1mQQ7Ak,2692
+jupyter_console/tests/test_image_handler.py,sha256=ZaCCnB-xoiNZ404t0O839DRu0poewTA7eeHaDmtRubI,3310
+jupyter_console/tests/writetofile.py,sha256=qSNiiT8PAgNW3sqi-RKL8AQs8JbV29wRsMfyAPCPPtA,783
+jupyter_console/utils.py,sha256=H1scmX8a7KACE9_loaoqt5t9YVSRVZCLyaTuB7oKH5w,616
+jupyter_console/zmqhistory.py,sha256=YCK76ZAe5zmZna3JH9MWxvYUY8v4YFTvkwzKZkDTsTw,3461
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/WHEEL b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..9d727675a8a14d70e4f3f0421e96de8b4207836c
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.13.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/entry_points.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..30d5b2d40e6b7bbf752a8f2a2d3c550065adf2e2
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+jupyter-console = jupyter_console.app:main
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/licenses/LICENSE b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/licenses/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..076177a497fae1482179137af028465c4f6b9c94
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_console-6.6.3.dist-info/licenses/LICENSE
@@ -0,0 +1,31 @@
+BSD 3-Clause License
+
+- Copyright (c) 2001-2015, IPython Development Team
+- Copyright (c) 2015-, Jupyter Development Team
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/_version.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c86ef07fd041fcb4f4c1b6046b4cd7e055cd0ca
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/_version.py
@@ -0,0 +1,21 @@
+"""
+store the current version info of jupyter-events.
+"""
+from __future__ import annotations
+
+import re
+
+# Version string must appear intact for hatch versioning
+__version__ = "0.12.0"
+
+# Build up version_info tuple for backwards compatibility
+pattern = r"(?P<major>\d+).(?P<minor>\d+).(?P<patch>\d+)(?P<rest>.*)"
+match = re.match(pattern, __version__)
+assert match is not None
+parts: list[object] = [int(match[part]) for part in ["major", "minor", "patch"]]
+if match["rest"]:
+    parts.append(match["rest"])
+version_info = tuple(parts)
+
+kernel_protocol_version_info = (5, 3)
+kernel_protocol_version = "{}.{}".format(*kernel_protocol_version_info)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/logger.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/logger.py
new file mode 100644
index 0000000000000000000000000000000000000000..00de2dd5c3d756bab4844897976c721bbf5783e7
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/logger.py
@@ -0,0 +1,442 @@
+"""
+Emit structured, discrete events when various actions happen.
+"""
+from __future__ import annotations
+
+import asyncio
+import copy
+import json
+import logging
+import typing as t
+import warnings
+from datetime import datetime, timezone
+from importlib.metadata import version
+
+from jsonschema import ValidationError
+from packaging.version import parse
+from traitlets import Dict, Instance, Set, default
+from traitlets.config import Config, LoggingConfigurable
+
+from .schema import SchemaType
+from .schema_registry import SchemaRegistry
+from .traits import Handlers
+from .validators import JUPYTER_EVENTS_CORE_VALIDATOR
+
+# Check if the version is greater than 3.1.0
+version_info = version("python-json-logger")
+if parse(version_info) >= parse("3.1.0"):
+    from pythonjsonlogger.json import JsonFormatter
+else:
+    from pythonjsonlogger.jsonlogger import JsonFormatter  # type: ignore[attr-defined]
+
+# Increment this version when the metadata included with each event
+# changes.
+EVENTS_METADATA_VERSION = 1
+
+
+class SchemaNotRegistered(Warning):
+    """A warning to raise when an event is given to the logger
+    but its schema has not be registered with the EventLogger
+    """
+
+
+class ModifierError(Exception):
+    """An exception to raise when a modifier does not
+    show the proper signature.
+    """
+
+
+class CoreMetadataError(Exception):
+    """An exception raised when event core metadata is not valid."""
+
+
+# Only show this warning on the first instance
+# of each event type that fails to emit.
+warnings.simplefilter("once", SchemaNotRegistered)
+
+
+class ListenerError(Exception):
+    """An exception to raise when a listener does not
+    show the proper signature.
+    """
+
+
+class EventLogger(LoggingConfigurable):
+    """
+    An Event logger for emitting structured events.
+
+    Event schemas must be registered with the
+    EventLogger using the `register_schema` or
+    `register_schema_file` methods. Every schema
+    will be validated against Jupyter Event's metaschema.
+    """
+
+    handlers = Handlers(
+        default_value=None,
+        allow_none=True,
+        help="""A list of logging.Handler instances to send events to.
+
+        When set to None (the default), all events are discarded.
+        """,
+    ).tag(config=True)
+
+    schemas = Instance(
+        SchemaRegistry,
+        help="""The SchemaRegistry for caching validated schemas
+        and their jsonschema validators.
+        """,
+    )
+
+    _modifiers = Dict({}, help="A mapping of schemas to their list of modifiers.")
+
+    _modified_listeners = Dict({}, help="A mapping of schemas to the listeners of modified events.")
+
+    _unmodified_listeners = Dict(
+        {}, help="A mapping of schemas to the listeners of unmodified/raw events."
+    )
+
+    _active_listeners: set[asyncio.Task[t.Any]] = Set()  # type:ignore[assignment]
+
+    async def gather_listeners(self) -> list[t.Any]:
+        """Gather all of the active listeners."""
+        return await asyncio.gather(*self._active_listeners, return_exceptions=True)
+
+    @default("schemas")
+    def _default_schemas(self) -> SchemaRegistry:
+        return SchemaRegistry()
+
+    def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:
+        """Initialize the logger."""
+        # We need to initialize the configurable before
+        # adding the logging handlers.
+        super().__init__(*args, **kwargs)
+        # Use a unique name for the logger so that multiple instances of EventLog do not write
+        # to each other's handlers.
+        log_name = __name__ + "." + str(id(self))
+        self._logger = logging.getLogger(log_name)
+        # We don't want events to show up in the default logs
+        self._logger.propagate = False
+        # We will use log.info to emit
+        self._logger.setLevel(logging.INFO)
+        # Add each handler to the logger and format the handlers.
+        if self.handlers:
+            for handler in self.handlers:
+                self.register_handler(handler)
+
+    def _load_config(
+        self,
+        cfg: Config,
+        section_names: list[str] | None = None,  # noqa: ARG002
+        traits: list[str] | None = None,  # type:ignore[override]  # noqa: ARG002
+    ) -> None:
+        """Load EventLogger traits from a Config object, patching the
+        handlers trait in the Config object to avoid deepcopy errors.
+        """
+        my_cfg = self._find_my_config(cfg)
+        handlers: list[logging.Handler] = my_cfg.pop("handlers", [])
+
+        # Turn handlers list into a pickeable function
+        def get_handlers() -> list[logging.Handler]:
+            return handlers
+
+        my_cfg["handlers"] = get_handlers
+
+        # Build a new eventlog config object.
+        eventlogger_cfg = Config({"EventLogger": my_cfg})
+        super()._load_config(eventlogger_cfg, section_names=None, traits=None)
+
+    def register_event_schema(self, schema: SchemaType) -> None:
+        """Register this schema with the schema registry.
+
+        Get this registered schema using the EventLogger.schema.get() method.
+        """
+        event_schema = self.schemas.register(schema)  # type:ignore[arg-type]
+        key = event_schema.id
+        # It's possible that listeners and modifiers have been added for this
+        # schema before the schema is registered.
+        if key not in self._modifiers:
+            self._modifiers[key] = set()
+        if key not in self._modified_listeners:
+            self._modified_listeners[key] = set()
+        if key not in self._unmodified_listeners:
+            self._unmodified_listeners[key] = set()
+
+    def register_handler(self, handler: logging.Handler) -> None:
+        """Register a new logging handler to the Event Logger.
+
+        All outgoing messages will be formatted as a JSON string.
+        """
+
+        def _handle_message_field(record: t.Any, **kwargs: t.Any) -> str:
+            """Python's logger always emits the "message" field with
+            the value as "null" unless it's present in the schema/data.
+            Message happens to be a common field for event logs,
+            so special case it here and only emit it if "message"
+            is found the in the schema's property list.
+            """
+            schema = self.schemas.get(record["__schema__"])
+            if "message" not in schema.properties:
+                del record["message"]
+            return json.dumps(record, **kwargs)
+
+        formatter = JsonFormatter(
+            json_serializer=_handle_message_field,
+        )
+        handler.setFormatter(formatter)
+        self._logger.addHandler(handler)
+        if handler not in self.handlers:
+            self.handlers.append(handler)
+
+    def remove_handler(self, handler: logging.Handler) -> None:
+        """Remove a logging handler from the logger and list of handlers."""
+        self._logger.removeHandler(handler)
+        if handler in self.handlers:
+            self.handlers.remove(handler)
+
+    def add_modifier(
+        self,
+        *,
+        schema_id: str | None = None,
+        modifier: t.Callable[[str, dict[str, t.Any]], dict[str, t.Any]],
+    ) -> None:
+        """Add a modifier (callable) to a registered event.
+
+        Parameters
+        ----------
+        modifier: Callable
+            A callable function/method that executes when the named event occurs.
+            This method enforces a string signature for modifiers:
+
+                (schema_id: str, data: dict) -> dict:
+        """
+        # Ensure that this is a callable function/method
+        if not callable(modifier):
+            msg = "`modifier` must be a callable"  # type:ignore[unreachable]
+            raise TypeError(msg)
+
+        # If the schema ID and version is given, only add
+        # this modifier to that schema
+        if schema_id:
+            # If the schema hasn't been added yet,
+            # start a placeholder set.
+            modifiers = self._modifiers.get(schema_id, set())
+            modifiers.add(modifier)
+            self._modifiers[schema_id] = modifiers
+            return
+        for id_ in self._modifiers:
+            if schema_id is None or id_ == schema_id:
+                self._modifiers[id_].add(modifier)
+
+    def remove_modifier(
+        self,
+        *,
+        schema_id: str | None = None,
+        modifier: t.Callable[[str, dict[str, t.Any]], dict[str, t.Any]],
+    ) -> None:
+        """Remove a modifier from an event or all events.
+
+        Parameters
+        ----------
+        schema_id: str
+            If given, remove this modifier only for a specific event type.
+        modifier: Callable[[str, dict], dict]
+
+            The modifier to remove.
+        """
+        # If schema_id is given remove the modifier from this schema.
+        if schema_id:
+            self._modifiers[schema_id].discard(modifier)
+        # If no schema_id is given, remove the modifier from all events.
+        else:
+            for schema_id in self.schemas.schema_ids:
+                # Remove the modifier if it is found in the list.
+                self._modifiers[schema_id].discard(modifier)
+                self._modifiers[schema_id].discard(modifier)
+
+    def add_listener(
+        self,
+        *,
+        modified: bool = True,
+        schema_id: str | None = None,
+        listener: t.Callable[[EventLogger, str, dict[str, t.Any]], t.Coroutine[t.Any, t.Any, None]],
+    ) -> None:
+        """Add a listener (callable) to a registered event.
+
+        Parameters
+        ----------
+        modified: bool
+            If True (default), listens to the data after it has been mutated/modified
+            by the list of modifiers.
+        schema_id: str
+            $id of the schema
+        listener: Callable
+            A callable function/method that executes when the named event occurs.
+        """
+        if not callable(listener):
+            msg = "`listener` must be a callable"  # type:ignore[unreachable]
+            raise TypeError(msg)
+
+        # If the schema ID and version is given, only add
+        # this modifier to that schema
+        if schema_id:
+            if modified:
+                # If the schema hasn't been added yet,
+                # start a placeholder set.
+                listeners = self._modified_listeners.get(schema_id, set())
+                listeners.add(listener)
+                self._modified_listeners[schema_id] = listeners
+                return
+            listeners = self._unmodified_listeners.get(schema_id, set())
+            listeners.add(listener)
+            self._unmodified_listeners[schema_id] = listeners
+            return
+        for id_ in self.schemas.schema_ids:
+            if schema_id is None or id_ == schema_id:
+                if modified:
+                    self._modified_listeners[id_].add(listener)
+                else:
+                    self._unmodified_listeners[id_].add(listener)
+
+    def remove_listener(
+        self,
+        *,
+        schema_id: str | None = None,
+        listener: t.Callable[[EventLogger, str, dict[str, t.Any]], t.Coroutine[t.Any, t.Any, None]],
+    ) -> None:
+        """Remove a listener from an event or all events.
+
+        Parameters
+        ----------
+        schema_id: str
+            If given, remove this modifier only for a specific event type.
+
+        listener: Callable[[EventLogger, str, dict], dict]
+            The modifier to remove.
+        """
+        # If schema_id is given remove the listener from this schema.
+        if schema_id:
+            self._modified_listeners[schema_id].discard(listener)
+            self._unmodified_listeners[schema_id].discard(listener)
+        # If no schema_id is given, remove the listener from all events.
+        else:
+            for schema_id in self.schemas.schema_ids:
+                # Remove the listener if it is found in the list.
+                self._modified_listeners[schema_id].discard(listener)
+                self._unmodified_listeners[schema_id].discard(listener)
+
+    def emit(
+        self, *, schema_id: str, data: dict[str, t.Any], timestamp_override: datetime | None = None
+    ) -> dict[str, t.Any] | None:
+        """
+        Record given event with schema has occurred.
+
+        Parameters
+        ----------
+        schema_id: str
+            $id of the schema
+        data: dict
+            The event to record
+        timestamp_override: datetime, optional
+            Optionally override the event timestamp. By default it is set to the current timestamp.
+
+        Returns
+        -------
+        dict
+            The recorded event data
+        """
+        # If no handlers are routing these events, there's no need to proceed.
+        if (
+            not self.handlers
+            and not self._modified_listeners.get(schema_id)
+            and not self._unmodified_listeners.get(schema_id)
+        ):
+            return None
+
+        # If the schema hasn't been registered, raise a warning to make sure
+        # this was intended.
+        if schema_id not in self.schemas:
+            warnings.warn(
+                f"{schema_id} has not been registered yet. If "
+                "this was not intentional, please register the schema using the "
+                "`register_event_schema` method.",
+                SchemaNotRegistered,
+                stacklevel=2,
+            )
+            return None
+
+        schema = self.schemas.get(schema_id)
+
+        # Deep copy the data and modify the copy.
+        modified_data = copy.deepcopy(data)
+        for modifier in self._modifiers[schema.id]:
+            modified_data = modifier(schema_id=schema_id, data=modified_data)
+
+        if self._unmodified_listeners[schema.id]:
+            # Process this event, i.e. validate and modify (in place)
+            self.schemas.validate_event(schema_id, data)
+
+        # Validate the modified data.
+        self.schemas.validate_event(schema_id, modified_data)
+
+        # Generate the empty event capsule.
+        timestamp = (
+            datetime.now(tz=timezone.utc) if timestamp_override is None else timestamp_override
+        )
+        capsule = {
+            "__timestamp__": timestamp.isoformat() + "Z",
+            "__schema__": schema_id,
+            "__schema_version__": schema.version,
+            "__metadata_version__": EVENTS_METADATA_VERSION,
+        }
+        try:
+            JUPYTER_EVENTS_CORE_VALIDATOR.validate(capsule)
+        except ValidationError as err:
+            raise CoreMetadataError from err
+
+        capsule.update(modified_data)
+
+        self._logger.info(capsule)
+
+        # callback for removing from finished listeners
+        # from active listeners set.
+        def _listener_task_done(task: asyncio.Task[t.Any]) -> None:
+            # If an exception happens, log it to the main
+            # applications logger
+            err = task.exception()
+            if err:
+                self.log.error(err)
+            self._active_listeners.discard(task)
+
+        # Loop over listeners and execute them.
+        for listener in self._modified_listeners[schema_id]:
+            # Schedule this listener as a task and add
+            # it to the list of active listeners
+            task = asyncio.create_task(
+                listener(
+                    logger=self,
+                    schema_id=schema_id,
+                    data=modified_data,
+                )
+            )
+            self._active_listeners.add(task)
+
+            # Adds the task and cleans it up later if needed.
+            task.add_done_callback(_listener_task_done)
+
+        for listener in self._unmodified_listeners[schema_id]:
+            task = asyncio.create_task(listener(logger=self, schema_id=schema_id, data=data))
+            self._active_listeners.add(task)
+
+            # Remove task from active listeners once its finished.
+            def _listener_task_done(task: asyncio.Task[t.Any]) -> None:
+                # If an exception happens, log it to the main
+                # applications logger
+                err = task.exception()
+                if err:
+                    self.log.error(err)
+                self._active_listeners.discard(task)
+
+            # Adds the task and cleans it up later if needed.
+            task.add_done_callback(_listener_task_done)
+
+        return capsule
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/pytest_plugin.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/pytest_plugin.py
new file mode 100644
index 0000000000000000000000000000000000000000..f181fd676260a69063eec7363d4586a0377e237a
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/pytest_plugin.py
@@ -0,0 +1,63 @@
+"""Fixtures for use with jupyter events."""
+from __future__ import annotations
+
+import io
+import json
+import logging
+from typing import Any, Callable
+
+import pytest
+
+from jupyter_events import EventLogger
+
+
+@pytest.fixture
+def jp_event_sink() -> io.StringIO:
+    """A stream for capture events."""
+    return io.StringIO()
+
+
+@pytest.fixture
+def jp_event_handler(jp_event_sink: io.StringIO) -> logging.Handler:
+    """A logging handler that captures any events emitted by the event handler"""
+    return logging.StreamHandler(jp_event_sink)
+
+
+@pytest.fixture
+def jp_read_emitted_events(
+    jp_event_handler: logging.Handler, jp_event_sink: io.StringIO
+) -> Callable[..., list[str] | None]:
+    """Reads list of events since last time it was called."""
+
+    def _read() -> list[str] | None:
+        jp_event_handler.flush()
+        event_buf = jp_event_sink.getvalue().strip()
+        output = [json.loads(item) for item in event_buf.split("\n")] if event_buf else None
+        # Clear the sink.
+        jp_event_sink.truncate(0)
+        jp_event_sink.seek(0)
+        return output
+
+    return _read
+
+
+@pytest.fixture
+def jp_event_schemas() -> list[Any]:
+    """A list of schema references.
+
+    Each item should be one of the following:
+    - string of serialized JSON/YAML content representing a schema
+    - a pathlib.Path object pointing to a schema file on disk
+    - a dictionary with the schema data.
+    """
+    return []
+
+
+@pytest.fixture
+def jp_event_logger(jp_event_handler: logging.Handler, jp_event_schemas: list[Any]) -> EventLogger:
+    """A pre-configured event logger for tests."""
+    logger = EventLogger()
+    for schema in jp_event_schemas:
+        logger.register_event_schema(schema)
+    logger.register_handler(handler=jp_event_handler)
+    return logger
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schema.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schema.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c6bf850f3c9dbd7a540a2047db9bce1c3cdcf9a
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schema.py
@@ -0,0 +1,153 @@
+"""Event schema objects."""
+from __future__ import annotations
+
+import json
+from pathlib import Path, PurePath
+from typing import Any, Union
+
+from jsonschema import FormatChecker, validators
+from referencing import Registry
+from referencing.jsonschema import DRAFT7
+
+try:
+    from jsonschema.protocols import Validator
+except ImportError:
+    Validator = Any  # type:ignore[assignment, misc]
+
+from . import yaml
+from .validators import draft7_format_checker, validate_schema
+
+
+class EventSchemaUnrecognized(Exception):
+    """An error for an unrecognized event schema."""
+
+
+class EventSchemaLoadingError(Exception):
+    """An error for an event schema loading error."""
+
+
+class EventSchemaFileAbsent(Exception):
+    """An error for an absent event schema file."""
+
+
+SchemaType = Union[dict[str, Any], str, PurePath]
+
+
+class EventSchema:
+    """A validated schema that can be used.
+
+    On instantiation, validate the schema against
+    Jupyter Event's metaschema.
+
+    Parameters
+    ----------
+    schema: dict or str
+        JSON schema to validate against Jupyter Events.
+
+    validator_class: jsonschema.validators
+        The validator class from jsonschema used to validate instances
+        of this event schema. The schema itself will be validated
+        against Jupyter Event's metaschema to ensure that
+        any schema registered here follows the expected form
+        of Jupyter Events.
+
+    registry:
+        Registry for nested JSON schema references.
+    """
+
+    def __init__(
+        self,
+        schema: SchemaType,
+        validator_class: type[Validator] = validators.Draft7Validator,  # type:ignore[assignment]
+        format_checker: FormatChecker = draft7_format_checker,
+        registry: Registry[Any] | None = None,
+    ):
+        """Initialize an event schema."""
+        _schema = self._load_schema(schema)
+        # Validate the schema against Jupyter Events metaschema.
+        validate_schema(_schema)
+
+        if registry is None:
+            registry = DRAFT7.create_resource(_schema) @ Registry()
+
+        # Create a validator for this schema
+        self._validator = validator_class(_schema, registry=registry, format_checker=format_checker)  # type: ignore[call-arg]
+        self._schema = _schema
+
+    def __repr__(self) -> str:
+        """A string repr for an event schema."""
+        return json.dumps(self._schema, indent=2)
+
+    @staticmethod
+    def _ensure_yaml_loaded(schema: SchemaType, was_str: bool = False) -> None:
+        """Ensures schema was correctly loaded into a dictionary. Raises
+        EventSchemaLoadingError otherwise."""
+        if isinstance(schema, dict):
+            return
+
+        error_msg = "Could not deserialize schema into a dictionary."
+
+        def intended_as_path(schema: str) -> bool:
+            path = Path(schema)
+            return path.match("*.yml") or path.match("*.yaml") or path.match("*.json")
+
+        # detect whether the user specified a string but intended a PurePath to
+        # generate a more helpful error message
+        if was_str and intended_as_path(schema):  # type:ignore[arg-type]
+            error_msg += " Paths to schema files must be explicitly wrapped in a Pathlib object."
+        else:
+            error_msg += " Double check the schema and ensure it is in the proper form."
+
+        raise EventSchemaLoadingError(error_msg)
+
+    @staticmethod
+    def _load_schema(schema: SchemaType) -> dict[str, Any]:
+        """Load a JSON schema from different sources/data types.
+
+        `schema` could be a dictionary or serialized string representing the
+        schema itself or a Pathlib object representing a schema file on disk.
+
+        Returns a dictionary with schema data.
+        """
+
+        # if schema is already a dictionary, return it
+        if isinstance(schema, dict):
+            return schema
+
+        # if schema is PurePath, ensure file exists at path and then load from file
+        if isinstance(schema, PurePath):
+            if not Path(schema).exists():
+                msg = f'Schema file not present at path "{schema}".'
+                raise EventSchemaFileAbsent(msg)
+
+            loaded_schema = yaml.load(schema)
+            EventSchema._ensure_yaml_loaded(loaded_schema)
+            return loaded_schema  # type:ignore[no-any-return]
+
+        # finally, if schema is string, attempt to deserialize and return the output
+        if isinstance(schema, str):
+            # note the diff b/w load v.s. loads
+            loaded_schema = yaml.loads(schema)
+            EventSchema._ensure_yaml_loaded(loaded_schema, was_str=True)
+            return loaded_schema  # type:ignore[no-any-return]
+
+        msg = f"Expected a dictionary, string, or PurePath, but instead received {schema.__class__.__name__}."  # type:ignore[unreachable]
+        raise EventSchemaUnrecognized(msg)
+
+    @property
+    def id(self) -> str:
+        """Schema $id field."""
+        return self._schema["$id"]  # type:ignore[no-any-return]
+
+    @property
+    def version(self) -> int:
+        """Schema's version."""
+        return self._schema["version"]  # type:ignore[no-any-return]
+
+    @property
+    def properties(self) -> dict[str, Any]:
+        return self._schema["properties"]  # type:ignore[no-any-return]
+
+    def validate(self, data: dict[str, Any]) -> None:
+        """Validate an incoming instance of this event schema."""
+        self._validator.validate(data)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schema_registry.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schema_registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..52defd3009b9e6007efed4b5c1521ef7bcd6ef73
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schema_registry.py
@@ -0,0 +1,83 @@
+""""An event schema registry."""
+from __future__ import annotations
+
+from typing import Any
+
+from .schema import EventSchema
+
+
+class SchemaRegistryException(Exception):
+    """Exception class for Jupyter Events Schema Registry Errors."""
+
+
+class SchemaRegistry:
+    """A convenient API for storing and searching a group of schemas."""
+
+    def __init__(self, schemas: dict[str, EventSchema] | None = None):
+        """Initialize the registry."""
+        self._schemas: dict[str, EventSchema] = schemas or {}
+
+    def __contains__(self, key: str) -> bool:
+        """Syntax sugar to check if a schema is found in the registry"""
+        return key in self._schemas
+
+    def __repr__(self) -> str:
+        """The str repr of the registry."""
+        return ",\n".join([str(s) for s in self._schemas.values()])
+
+    def _add(self, schema_obj: EventSchema) -> None:
+        if schema_obj.id in self._schemas:
+            msg = (
+                f"The schema, {schema_obj.id}, is already "
+                "registered. Try removing it and registering it again."
+            )
+            raise SchemaRegistryException(msg)
+        self._schemas[schema_obj.id] = schema_obj
+
+    @property
+    def schema_ids(self) -> list[str]:
+        return list(self._schemas.keys())
+
+    def register(self, schema: dict[str, Any] | (str | EventSchema)) -> EventSchema:
+        """Add a valid schema to the registry.
+
+        All schemas are validated against the Jupyter Events meta-schema
+        found here:
+        """
+        if not isinstance(schema, EventSchema):
+            schema = EventSchema(schema)
+        self._add(schema)
+        return schema
+
+    def get(self, id_: str) -> EventSchema:
+        """Fetch a given schema. If the schema is not found,
+        this will raise a KeyError.
+        """
+        try:
+            return self._schemas[id_]
+        except KeyError:
+            msg = (
+                f"The requested schema, {id_}, was not found in the "
+                "schema registry. Are you sure it was previously registered?"
+            )
+            raise KeyError(msg) from None
+
+    def remove(self, id_: str) -> None:
+        """Remove a given schema. If the schema is not found,
+        this will raise a KeyError.
+        """
+        try:
+            del self._schemas[id_]
+        except KeyError:
+            msg = (
+                f"The requested schema, {id_}, was not found in the "
+                "schema registry. Are you sure it was previously registered?"
+            )
+            raise KeyError(msg) from None
+
+    def validate_event(self, id_: str, data: dict[str, Any]) -> None:
+        """Validate an event against a schema within this
+        registry.
+        """
+        schema = self.get(id_)
+        schema.validate(data)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schemas/event-metaschema.yml b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schemas/event-metaschema.yml
new file mode 100644
index 0000000000000000000000000000000000000000..e6cc2d17e516b16bc97b9599bcb05a751005b1de
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schemas/event-metaschema.yml
@@ -0,0 +1,30 @@
+$schema: http://json-schema.org/draft-07/schema
+$id: http://event.jupyter.org/event-metaschema
+version: "1"
+title: Event Metaschema
+description: |
+  A meta schema for validating that all registered Jupyter Event
+  schemas are appropriately defined.
+type: object
+properties:
+  version:
+    type: string
+  title:
+    type: string
+  description:
+    type: string
+  properties:
+    type: object
+    additionalProperties:
+      $ref: http://event.jupyter.org/property-metaschema
+    propertyNames:
+      pattern: ^(?!__.*)
+patternProperties:
+  "\\$id":
+    type: string
+    format: uri
+
+required:
+  - $id
+  - version
+  - properties
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schemas/property-metaschema.yml b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schemas/property-metaschema.yml
new file mode 100644
index 0000000000000000000000000000000000000000..f8fad082457ad73e41fbe66e2117a13ce9d4ca70
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/schemas/property-metaschema.yml
@@ -0,0 +1,28 @@
+$schema: http://json-schema.org/draft-07/schema
+$id: http://event.jupyter.org/property-metaschema
+version: "1"
+title: Property Metaschema
+description: |
+  A metaschema for validating properties within
+  an event schema
+
+properties:
+  title:
+    type: string
+  description:
+    type: string
+  properties:
+    type: object
+    additionalProperties:
+      $ref: http://event.jupyter.org/property-metaschema
+    propertyNames:
+      pattern: ^(?!__.*)
+
+  items:
+    $ref: http://event.jupyter.org/property-metaschema
+
+additionalProperties:
+  $ref: http://event.jupyter.org/property-metaschema
+
+propertyNames:
+  pattern: ^(?!__.*)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/traits.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/traits.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7b38c0973ee05520d06d81c98847e0882d7a6c7
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/traits.py
@@ -0,0 +1,51 @@
+"""Trait types for events."""
+from __future__ import annotations
+
+import logging
+import typing as t
+
+from traitlets import TraitError, TraitType
+
+baseclass = TraitType
+if t.TYPE_CHECKING:
+    baseclass = TraitType[t.Any, t.Any]  # type:ignore[misc]
+
+
+class Handlers(baseclass):  # type:ignore[type-arg]
+    """A trait that takes a list of logging handlers and converts
+    it to a callable that returns that list (thus, making this
+    trait pickleable).
+    """
+
+    info_text = "a list of logging handlers"
+
+    def validate_elements(self, obj: t.Any, value: t.Any) -> None:
+        """Validate the elements of an object."""
+        if len(value) > 0:
+            # Check that all elements are logging handlers.
+            for el in value:
+                if isinstance(el, logging.Handler) is False:
+                    self.element_error(obj)
+
+    def element_error(self, obj: t.Any) -> None:
+        """Raise an error for bad elements."""
+        msg = f"Elements in the '{self.name}' trait of an {obj.__class__.__name__} instance must be Python `logging` handler instances."
+        raise TraitError(msg)
+
+    def validate(self, obj: t.Any, value: t.Any) -> t.Any:
+        """Validate an object."""
+        # If given a callable, call it and set the
+        # value of this trait to the returned list.
+        # Verify that the callable returns a list
+        # of logging handler instances.
+        if callable(value):
+            out = value()
+            self.validate_elements(obj, out)
+            return out
+        # If a list, check it's elements to verify
+        # that each element is a logging handler instance.
+        if isinstance(value, list):
+            self.validate_elements(obj, value)
+            return value
+        self.error(obj, value)
+        return None  # type:ignore[unreachable]
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/utils.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..9df341245f810962915027f03fab65dfc5619ca0
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/utils.py
@@ -0,0 +1,8 @@
+"""
+Various utilities
+"""
+from __future__ import annotations
+
+
+class JupyterEventsVersionWarning(UserWarning):
+    """Emitted when an event schema version is an `int` when it should be `str`."""
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/yaml.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/yaml.py
new file mode 100644
index 0000000000000000000000000000000000000000..80c1c94f7b75b6bdaaf49c1418007f294546f3f8
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_events/yaml.py
@@ -0,0 +1,36 @@
+"""Yaml utilities."""
+from __future__ import annotations
+
+from pathlib import Path, PurePath
+from typing import Any
+
+from yaml import dump as ydump
+from yaml import load as yload
+
+try:
+    from yaml import CSafeDumper as SafeDumper
+    from yaml import CSafeLoader as SafeLoader
+except ImportError:  # pragma: no cover
+    from yaml import SafeDumper, SafeLoader  # type:ignore[assignment]
+
+
+def loads(stream: Any) -> Any:
+    """Load yaml from a stream."""
+    return yload(stream, Loader=SafeLoader)
+
+
+def dumps(stream: Any) -> str:
+    """Parse the first YAML document in a stream as an object."""
+    return ydump(stream, Dumper=SafeDumper)
+
+
+def load(fpath: str | PurePath) -> Any:
+    """Load yaml from a file."""
+    # coerce PurePath into Path, then read its contents
+    data = Path(str(fpath)).read_text(encoding="utf-8")
+    return loads(data)
+
+
+def dump(data: Any, outpath: str | PurePath) -> None:
+    """Parse the a YAML document in a file as an object."""
+    Path(outpath).write_text(dumps(data), encoding="utf-8")
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/INSTALLER b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/RECORD b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..ff86812266597b457b69ef345323ec64cdf5543c
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/RECORD
@@ -0,0 +1,8 @@
+__pycache__/pandocfilters.cpython-310.pyc,,
+pandocfilters-1.5.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pandocfilters-1.5.1.dist-info/LICENSE,sha256=VnZs6ZcqUz_PZzMPGrvrQU4VPH5Ywn3FREG8D6-oFJI,1496
+pandocfilters-1.5.1.dist-info/METADATA,sha256=w--HaNuiYN1GMR4azDpnhjoOVnGp0j_NLhp7claqtS4,8978
+pandocfilters-1.5.1.dist-info/RECORD,,
+pandocfilters-1.5.1.dist-info/WHEEL,sha256=-G_t0oGuE7UD0DrSpVZnq1hHMBV9DD2XkS5v7XpmTnk,110
+pandocfilters-1.5.1.dist-info/top_level.txt,sha256=h7g1ToRWOmlqrfjEEXEnAlRitBAFDoq8mI-rNOCSY_8,14
+pandocfilters.py,sha256=dqDT_lIkshPybYCXQZNnXKuXrsCBx3X8Io9NzZvc8CY,9070
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Co_references.vms b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Co_references.vms
new file mode 100644
index 0000000000000000000000000000000000000000..73c115ccf7bdb485d5523816782faf9f1137e124
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Co_references.vms
@@ -0,0 +1,4460 @@
+VAMAS Surface Chemical Analysis Standard Data Transfer Format 1988 May 4
+Not Specified
+Not Specified
+Not Specified
+Not Specified
+7
+Casa Info Follows CasaXPS Version 2.3.24PR1.0
+0
+Created by SpecsLab Prodigy, Version 4.73.2-r95032 
+SourceAnalyserAngle: Not Specified
+CasaRowLabel:Co metal
+CasaRowLabel:CoO
+CasaRowLabel:Co3O4
+NORM
+REGULAR
+1
+1
+Exp Variable
+d
+0
+0
+0
+0
+3
+Co2p
+Co metal
+2021
+4
+27
+18
+36
+14
+0
+17
+Casa Info Follows
+0
+0
+0
+0
+File = E:/OwnCloud/XPS lab/EX491_S745_Co.sle
+Group = RT in vacuum, #Treatments:4h sputter, #Temp:RT , #Pressure:vacuum , #Atmosphere:{:}, #Comments:  
+First of group = 0
+Spectrum ID = 15
+Analyzer lens = AngleResolvedMode22:1.5kV
+Analyzer slit = 4:7x20c\C:mesh
+Scan mode = FixedAnalyzerTransmission
+Kinetic energy start = 646.61
+PCA Coefs = 117821, -21153.7, -1403.13, 970.754, 1743.34, 
+C:\Users\Mark\Downloads\EX491_S745_Co (1).vms
+c:\users\pielsticker\lukas\mpi-cec\projects\deepxps\xpsdeeplearning\data\references\nicofe\ex491-495 fe, ni, co oxide references.vms
+C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\NiCoFe\EX491-495 FeCo summed.vms
+XPS
+1
+Al
+1486.61
+0
+0
+0
+54.5
+180
+FAT
+20
+1
+4.1408
+0
+0
+0
+0
+0
+Co
+2p
+-1
+kinetic energy
+eV
+646.61
+0.1
+2
+counts
+d
+Transmission
+d
+pulse counting
+0.1
+2
+0
+0
+0
+0
+2
+ESCAPE DEPTH TYPE
+d
+1
+MFP Exponent
+d
+0
+1402
+2120.19
+13889.6
+1
+1
+4565.58
+1
+4573.78
+1
+4592.52
+1
+4594.61
+1
+4589.69
+1
+4625.72
+1
+4632.34
+1
+4631.83
+1
+4617.53
+1
+4622.36
+1
+4628.75
+1
+4610.33
+1
+4632.59
+1
+4652.39
+1
+4642.18
+1
+4638.13
+1
+4638.33
+1
+4636.05
+1
+4663.47
+1
+4659.32
+1
+4661.18
+1
+4667.98
+1
+4662.28
+1
+4655.87
+1
+4634.72
+1
+4634.58
+1
+4621.88
+1
+4640.71
+1
+4643.94
+1
+4641.59
+1
+4631.49
+1
+4605.81
+1
+4636.11
+1
+4633.43
+1
+4611.44
+1
+4623.11
+1
+4605.16
+1
+4584.81
+1
+4595.82
+1
+4589.15
+1
+4578.12
+1
+4587.29
+1
+4580.29
+1
+4540.5
+1
+4526.17
+1
+4526.69
+1
+4532.22
+1
+4489.65
+1
+4503.42
+1
+4509.74
+1
+4497.77
+1
+4503.13
+1
+4497.29
+1
+4512.85
+1
+4485.34
+1
+4494.74
+1
+4483.6
+1
+4474.39
+1
+4469.59
+1
+4451.37
+1
+4425.91
+1
+4467.92
+1
+4467.25
+1
+4444.25
+1
+4463.18
+1
+4484.65
+1
+4500.96
+1
+4465.22
+1
+4441.89
+1
+4448.85
+1
+4476.73
+1
+4486.37
+1
+4491.61
+1
+4511.35
+1
+4526.53
+1
+4512.47
+1
+4515.82
+1
+4521.5
+1
+4519.35
+1
+4519.94
+1
+4541.25
+1
+4560.45
+1
+4612.8
+1
+4626.28
+1
+4638.57
+1
+4605.67
+1
+4629.09
+1
+4643.45
+1
+4655.13
+1
+4652.27
+1
+4667.74
+1
+4654.73
+1
+4691.46
+1
+4699.84
+1
+4681.69
+1
+4657.73
+1
+4685.2
+1
+4652.53
+1
+4660.02
+1
+4649.62
+1
+4616.76
+1
+4623.6
+1
+4618.29
+1
+4610.17
+1
+4578.82
+1
+4569.14
+1
+4515.38
+1
+4510.69
+1
+4484.02
+1
+4465.77
+1
+4433.52
+1
+4385.32
+1
+4354.16
+1
+4367.07
+1
+4324.94
+1
+4286.76
+1
+4258.85
+1
+4232.18
+1
+4189.11
+1
+4181.66
+1
+4174.6
+1
+4162.63
+1
+4147.71
+1
+4100.91
+1
+4083.54
+1
+4068.67
+1
+4055.87
+1
+4063.55
+1
+4036.66
+1
+4038.03
+1
+4002.93
+1
+4013.89
+1
+3994.06
+1
+3977.06
+1
+3986.67
+1
+3986.11
+1
+3961.77
+1
+3941.76
+1
+3968.53
+1
+3960.37
+1
+3954.85
+1
+3917.05
+1
+3915.17
+1
+3928.73
+1
+3917.22
+1
+3947.12
+1
+3931.18
+1
+3917.23
+1
+3902.98
+1
+3872
+1
+3911.59
+1
+3914.28
+1
+3908.09
+1
+3940.57
+1
+3932.52
+1
+3892.21
+1
+3920.19
+1
+3939.9
+1
+3910.85
+1
+3890.28
+1
+3878
+1
+3907.75
+1
+3899.35
+1
+3867.71
+1
+3884.25
+1
+3891.64
+1
+3893.9
+1
+3913.15
+1
+3901.38
+1
+3914.45
+1
+3882.95
+1
+3893.55
+1
+3911.72
+1
+3884.93
+1
+3902.85
+1
+3912.22
+1
+3885.39
+1
+3878.58
+1
+3909.17
+1
+3928.02
+1
+3910.91
+1
+3916.38
+1
+3923.95
+1
+3932.93
+1
+3886.43
+1
+3887.47
+1
+3892.57
+1
+3925.69
+1
+3912.36
+1
+3891.64
+1
+3900.66
+1
+3902.32
+1
+3930.83
+1
+3916.06
+1
+3909.01
+1
+3932.12
+1
+3931.42
+1
+3899.78
+1
+3895.55
+1
+3898.03
+1
+3918.04
+1
+3911.14
+1
+3898.61
+1
+3916.07
+1
+3938.36
+1
+3929.22
+1
+3925.19
+1
+3918.33
+1
+3940.54
+1
+3972.24
+1
+3966.15
+1
+3932.3
+1
+3921.75
+1
+3952.09
+1
+3946.19
+1
+3953.93
+1
+3964.75
+1
+3978.08
+1
+3943.78
+1
+3975.15
+1
+3966.39
+1
+3953.27
+1
+3981.42
+1
+3951.86
+1
+3978.86
+1
+3985.28
+1
+3985.37
+1
+3973.32
+1
+3986.93
+1
+3951.53
+1
+3955.54
+1
+3980.08
+1
+3993.82
+1
+4006.91
+1
+4013.88
+1
+4012.95
+1
+4004.59
+1
+3996.62
+1
+4014.7
+1
+4018.43
+1
+4011.66
+1
+4024.78
+1
+4008.87
+1
+4027.81
+1
+4022.19
+1
+4028.99
+1
+4039.46
+1
+4033.2
+1
+4063.18
+1
+4049.45
+1
+4039.69
+1
+4061.92
+1
+4065.55
+1
+4095.46
+1
+4069.28
+1
+4068.61
+1
+4057.23
+1
+4059.45
+1
+4085.93
+1
+4083.34
+1
+4055.85
+1
+4065.13
+1
+4051.45
+1
+4058.02
+1
+4064.88
+1
+4068.04
+1
+4055.55
+1
+4055.36
+1
+4047.27
+1
+4053.44
+1
+4045.58
+1
+4048.7
+1
+4022.46
+1
+4064.16
+1
+4058.76
+1
+4031.75
+1
+4029.82
+1
+4037.41
+1
+4010.65
+1
+4031.14
+1
+4028.63
+1
+4022.63
+1
+4041.42
+1
+4022.72
+1
+4043.11
+1
+4027.42
+1
+4054.13
+1
+4028.87
+1
+4024.91
+1
+4033.74
+1
+4041.64
+1
+4020.82
+1
+4054.24
+1
+4054.77
+1
+4040.36
+1
+4027.76
+1
+4036.72
+1
+4051.28
+1
+4027.17
+1
+4038.59
+1
+4053.37
+1
+4051.15
+1
+4053.17
+1
+4061.02
+1
+4055.42
+1
+4048.65
+1
+4074.19
+1
+4067.43
+1
+4091.31
+1
+4098.42
+1
+4093.23
+1
+4056.82
+1
+4064.68
+1
+4075.78
+1
+4089.18
+1
+4080.15
+1
+4100.41
+1
+4073.47
+1
+4069.8
+1
+4098.24
+1
+4089.62
+1
+4080.22
+1
+4071.68
+1
+4090.51
+1
+4115.9
+1
+4121.8
+1
+4112.85
+1
+4104.45
+1
+4149.54
+1
+4124.48
+1
+4138.13
+1
+4148.64
+1
+4170.52
+1
+4164.72
+1
+4188.67
+1
+4180.95
+1
+4165.31
+1
+4181.17
+1
+4187.54
+1
+4178.91
+1
+4180.78
+1
+4170.71
+1
+4227.2
+1
+4204.86
+1
+4202.67
+1
+4193.58
+1
+4197.05
+1
+4206.8
+1
+4199.6
+1
+4190.95
+1
+4209.2
+1
+4203.65
+1
+4226.81
+1
+4216.54
+1
+4217.43
+1
+4223.24
+1
+4229.41
+1
+4207.41
+1
+4240.63
+1
+4227.9
+1
+4233.24
+1
+4233.87
+1
+4252.25
+1
+4245.27
+1
+4257.93
+1
+4271.98
+1
+4245.85
+1
+4271.46
+1
+4273.98
+1
+4270.29
+1
+4272.6
+1
+4269.69
+1
+4281.04
+1
+4281.05
+1
+4311.61
+1
+4310.13
+1
+4282.84
+1
+4300.29
+1
+4320.27
+1
+4322.87
+1
+4341.28
+1
+4316.74
+1
+4316.45
+1
+4353.22
+1
+4329.21
+1
+4297.05
+1
+4319.06
+1
+4356.98
+1
+4376.28
+1
+4332.61
+1
+4350.19
+1
+4331.19
+1
+4359.29
+1
+4372.86
+1
+4362.28
+1
+4350.3
+1
+4377.97
+1
+4384.89
+1
+4408.84
+1
+4374.81
+1
+4374.07
+1
+4391.63
+1
+4399.03
+1
+4430.32
+1
+4450.77
+1
+4432.11
+1
+4436.09
+1
+4435.21
+1
+4448.8
+1
+4467.75
+1
+4474.36
+1
+4483.76
+1
+4497.12
+1
+4507.46
+1
+4527.36
+1
+4554.93
+1
+4544.55
+1
+4537.73
+1
+4556.31
+1
+4579.77
+1
+4577.42
+1
+4561.8
+1
+4623.04
+1
+4629.61
+1
+4633.98
+1
+4655.1
+1
+4667.86
+1
+4705.97
+1
+4730.06
+1
+4735.01
+1
+4752.94
+1
+4762.72
+1
+4792.45
+1
+4828.71
+1
+4828.7
+1
+4886.79
+1
+4913.73
+1
+4912.83
+1
+4935.49
+1
+4970.35
+1
+5023.92
+1
+5003.6
+1
+5051.46
+1
+5095.98
+1
+5137.54
+1
+5176.99
+1
+5229.74
+1
+5275.57
+1
+5304.85
+1
+5395.1
+1
+5429.72
+1
+5489.65
+1
+5540.86
+1
+5613.38
+1
+5699.42
+1
+5753.3
+1
+5831.5
+1
+5898.96
+1
+5980.26
+1
+6059.09
+1
+6178.68
+1
+6314.94
+1
+6411.18
+1
+6580.71
+1
+6699.06
+1
+6811.43
+1
+6936.81
+1
+7019.51
+1
+7041.27
+1
+7002.25
+1
+6864.2
+1
+6666.02
+1
+6434.5
+1
+6160.47
+1
+5878.15
+1
+5568.63
+1
+5279.12
+1
+5042.33
+1
+4837.55
+1
+4678.37
+1
+4510.26
+1
+4388.43
+1
+4303.01
+1
+4220.3
+1
+4147.16
+1
+4148.13
+1
+4054.21
+1
+4026.64
+1
+4015.76
+1
+4003.33
+1
+3955.86
+1
+3933.92
+1
+3904.73
+1
+3885.48
+1
+3875.89
+1
+3872.25
+1
+3829.81
+1
+3833.4
+1
+3830.76
+1
+3818.97
+1
+3824.02
+1
+3833.07
+1
+3813.13
+1
+3829
+1
+3808.58
+1
+3816.19
+1
+3820.59
+1
+3836.14
+1
+3851.1
+1
+3846.77
+1
+3837.17
+1
+3852.67
+1
+3853.64
+1
+3858.56
+1
+3896.86
+1
+3906.7
+1
+3901.95
+1
+3898.55
+1
+3884.65
+1
+3907.55
+1
+3933.9
+1
+3938.84
+1
+3931.22
+1
+3945.38
+1
+3945.76
+1
+3973.09
+1
+3988.31
+1
+3951.12
+1
+3970.79
+1
+3978
+1
+4011.65
+1
+4007.99
+1
+4008.87
+1
+4017.56
+1
+4024.89
+1
+4042.1
+1
+4070.59
+1
+4075.64
+1
+4066.28
+1
+4088.84
+1
+4091.6
+1
+4120.27
+1
+4107.12
+1
+4119.94
+1
+4126.51
+1
+4146.41
+1
+4135.17
+1
+4189.59
+1
+4216.82
+1
+4203.09
+1
+4203.86
+1
+4211.39
+1
+4242.9
+1
+4239.47
+1
+4277.85
+1
+4321.15
+1
+4327.86
+1
+4336.87
+1
+4344.37
+1
+4350.66
+1
+4360.84
+1
+4415.33
+1
+4399.67
+1
+4435.12
+1
+4454.85
+1
+4492.73
+1
+4494.65
+1
+4496.45
+1
+4550.34
+1
+4589.65
+1
+4615.25
+1
+4643.2
+1
+4683.1
+1
+4683.46
+1
+4720.65
+1
+4736.58
+1
+4789.94
+1
+4824.6
+1
+4822.89
+1
+4823.44
+1
+4875.44
+1
+4914.05
+1
+4888.3
+1
+4912.45
+1
+4905.75
+1
+4944.81
+1
+4961.19
+1
+4943.26
+1
+4970.8
+1
+5034.78
+1
+5025.78
+1
+5072.26
+1
+5151.96
+1
+5199.74
+1
+5242.44
+1
+5270.47
+1
+5403.71
+1
+5465.66
+1
+5529.36
+1
+5661.11
+1
+5744.31
+1
+5868.5
+1
+5997.12
+1
+6158.41
+1
+6342.74
+1
+6468.35
+1
+6720.09
+1
+6931.28
+1
+7225.09
+1
+7534.2
+1
+7946.21
+1
+8467.86
+1
+9085.86
+1
+9874.31
+1
+10799.3
+1
+11826.9
+1
+12812.9
+1
+13570.3
+1
+13923.1
+1
+13602.9
+1
+12656.8
+1
+11198.9
+1
+9520.84
+1
+7833.75
+1
+6439.82
+1
+5397.08
+1
+4667.5
+1
+4182.13
+1
+3815.72
+1
+3572.46
+1
+3406.33
+1
+3281.26
+1
+3175.14
+1
+3117.13
+1
+3049.81
+1
+2975.06
+1
+2948.42
+1
+2919.17
+1
+2884.24
+1
+2855.6
+1
+2843.81
+1
+2808.89
+1
+2803.59
+1
+2775.38
+1
+2766.78
+1
+2740.08
+1
+2693.98
+1
+2668.73
+1
+2657.65
+1
+2618.4
+1
+2593.98
+1
+2578.61
+1
+2536.15
+1
+2501.95
+1
+2483.01
+1
+2464.76
+1
+2433.08
+1
+2389.5
+1
+2370.49
+1
+2349.62
+1
+2376.13
+1
+2339.65
+1
+2307.94
+1
+2300.04
+1
+2282.35
+1
+2290.45
+1
+2300.01
+1
+2269.94
+1
+2253.01
+1
+2262.6
+1
+2265.68
+1
+2273.46
+1
+2271.7
+1
+2273.8
+1
+2264.05
+1
+2274.8
+1
+2272.8
+1
+2267.31
+1
+2259.87
+1
+2260.94
+1
+2283.3
+1
+2301.67
+1
+2283.84
+1
+2283.05
+1
+2300.14
+1
+2298.28
+1
+2283.51
+1
+2277.61
+1
+2288.35
+1
+2286.29
+1
+2286.73
+1
+2266.66
+1
+2255.9
+1
+2258.2
+1
+2230.89
+1
+2209.46
+1
+2186.02
+1
+2179.3
+1
+2177.35
+1
+2160.91
+1
+2138.65
+1
+Co2p
+CoO
+2021
+4
+29
+9
+50
+16
+0
+17
+Casa Info Follows
+0
+0
+0
+0
+File = E:/OwnCloud/XPS lab/EX491_S745_Co.sle
+Group = Loop 11_ RT in vacuum, #Treatments: , #Temp:RT , #Pressure:vacuum , #Atmosphere: , #Comments:  
+First of group = 0
+Spectrum ID = 61
+Analyzer lens = AngleResolvedMode22:1.5kV
+Analyzer slit = 4:7x20c\C:mesh
+Scan mode = FixedAnalyzerTransmission
+Kinetic energy start = 646.61
+PCA Coefs = 146858, 18127.4, -14522.3, -1131.5, -938.021, 
+C:\Users\Mark\Downloads\EX491_S745_Co (1).vms
+c:\users\pielsticker\lukas\mpi-cec\projects\deepxps\xpsdeeplearning\data\references\nicofe\ex491-495 fe, ni, co oxide references.vms
+C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\NiCoFe\EX491-495 FeCo summed.vms
+XPS
+8
+Al
+1486.61
+0
+0
+0
+54.5
+180
+FAT
+20
+1
+4.1408
+0
+0
+0
+0
+0
+Co
+2p
+-1
+kinetic energy
+eV
+646.61
+0.1
+2
+counts
+d
+Transmission
+d
+pulse counting
+0.1
+3
+0
+0
+0
+0
+2
+ESCAPE DEPTH TYPE
+d
+1
+MFP Exponent
+d
+0
+1402
+2556.35
+10658.9
+1
+1
+5793.49
+1
+5769.83
+1
+5778.71
+1
+5793.63
+1
+5824.14
+1
+5800.77
+1
+5775.7
+1
+5779.5
+1
+5824.43
+1
+5771.05
+1
+5757.64
+1
+5800.48
+1
+5809.69
+1
+5781.79
+1
+5762.01
+1
+5820.93
+1
+5789.52
+1
+5789.72
+1
+5788.65
+1
+5747.62
+1
+5713.6
+1
+5735.09
+1
+5758.97
+1
+5782.19
+1
+5755.33
+1
+5754
+1
+5749.84
+1
+5760.21
+1
+5714.93
+1
+5730.73
+1
+5717.53
+1
+5733.84
+1
+5783.62
+1
+5764.39
+1
+5750.08
+1
+5706.17
+1
+5710.57
+1
+5775.05
+1
+5732.2
+1
+5732.33
+1
+5777.68
+1
+5752.96
+1
+5718.55
+1
+5719.85
+1
+5742.52
+1
+5758.4
+1
+5746.43
+1
+5736.17
+1
+5752.67
+1
+5776.23
+1
+5773.43
+1
+5773.14
+1
+5754.87
+1
+5717.55
+1
+5746.9
+1
+5749.14
+1
+5815.13
+1
+5783.64
+1
+5791.97
+1
+5801.8
+1
+5844.23
+1
+5776.14
+1
+5786.45
+1
+5787.41
+1
+5816.46
+1
+5779.54
+1
+5800.57
+1
+5833.82
+1
+5806.85
+1
+5810.39
+1
+5790.78
+1
+5766.05
+1
+5754.93
+1
+5803.2
+1
+5761.97
+1
+5762.91
+1
+5754.17
+1
+5784.2
+1
+5782.09
+1
+5750.94
+1
+5713.89
+1
+5714.6
+1
+5689.32
+1
+5687.11
+1
+5664.86
+1
+5622.49
+1
+5617.77
+1
+5622.64
+1
+5629.93
+1
+5591.64
+1
+5564.16
+1
+5495.03
+1
+5482.19
+1
+5499.92
+1
+5457.85
+1
+5396.59
+1
+5389.73
+1
+5393.43
+1
+5373.73
+1
+5359.55
+1
+5325.33
+1
+5311.19
+1
+5261.36
+1
+5226.56
+1
+5209.16
+1
+5250.1
+1
+5220.74
+1
+5187.71
+1
+5195.49
+1
+5147.97
+1
+5142.86
+1
+5137.96
+1
+5143.73
+1
+5071.07
+1
+5055.82
+1
+5061.95
+1
+5050.19
+1
+5084.71
+1
+5093.97
+1
+5024.79
+1
+5028.16
+1
+5022.74
+1
+4982
+1
+5011.43
+1
+4999.29
+1
+5000.47
+1
+4988.08
+1
+4978
+1
+4947.82
+1
+4990.69
+1
+4976.88
+1
+4985.71
+1
+4961.71
+1
+4955.57
+1
+4943.25
+1
+4928.93
+1
+4926.53
+1
+4905.66
+1
+4920.49
+1
+4930.85
+1
+4939.62
+1
+4921.31
+1
+4928.34
+1
+4902.63
+1
+4938.92
+1
+4917.99
+1
+4941.64
+1
+4939.42
+1
+4893.49
+1
+4892.88
+1
+4944.97
+1
+4896.84
+1
+4909.48
+1
+4881.53
+1
+4871.26
+1
+4919.57
+1
+4885.68
+1
+4846
+1
+4888.58
+1
+4911.27
+1
+4920.47
+1
+4925.96
+1
+4941.63
+1
+4917.94
+1
+4920.7
+1
+4906.33
+1
+4906.68
+1
+4931.43
+1
+4904.64
+1
+4922.6
+1
+4941.17
+1
+4914.76
+1
+4918.11
+1
+4946.79
+1
+4945.94
+1
+4897.61
+1
+4931.64
+1
+4952.05
+1
+4932
+1
+4918.49
+1
+4923.74
+1
+4933.57
+1
+4926.89
+1
+4898.44
+1
+4951.9
+1
+4938.59
+1
+4935
+1
+4967.75
+1
+4987.1
+1
+4979.03
+1
+4898.93
+1
+4958.6
+1
+4958.07
+1
+4954.99
+1
+4919.84
+1
+4935.87
+1
+4932
+1
+4956.8
+1
+4976.97
+1
+4943.39
+1
+4937.77
+1
+4967.86
+1
+4951.02
+1
+4962.1
+1
+4931.93
+1
+4946.7
+1
+4945.08
+1
+4941.64
+1
+4911.94
+1
+4886.15
+1
+4941.61
+1
+4917.3
+1
+4950.51
+1
+4915.77
+1
+4921.33
+1
+4939.12
+1
+4960.52
+1
+4934.6
+1
+4926.02
+1
+4893.77
+1
+4930.18
+1
+4896.72
+1
+4875.85
+1
+4914.02
+1
+4906.59
+1
+4914.23
+1
+4871.98
+1
+4861.96
+1
+4885.18
+1
+4896.42
+1
+4890.41
+1
+4859.55
+1
+4825.29
+1
+4845.6
+1
+4856.34
+1
+4841.85
+1
+4848.07
+1
+4842.62
+1
+4813.11
+1
+4793.02
+1
+4801.65
+1
+4775.01
+1
+4805.73
+1
+4779
+1
+4782.77
+1
+4734.47
+1
+4708.07
+1
+4729.81
+1
+4725.29
+1
+4705.84
+1
+4743
+1
+4715.95
+1
+4725.42
+1
+4701.5
+1
+4707.99
+1
+4698.6
+1
+4678.59
+1
+4621.68
+1
+4612.6
+1
+4634.59
+1
+4651.45
+1
+4615.01
+1
+4607.39
+1
+4609.12
+1
+4606.3
+1
+4621.14
+1
+4624.87
+1
+4592.67
+1
+4606.97
+1
+4570.15
+1
+4583.4
+1
+4594.43
+1
+4565.83
+1
+4563.91
+1
+4509.29
+1
+4551.23
+1
+4536.8
+1
+4521.57
+1
+4519.04
+1
+4528.22
+1
+4528.2
+1
+4514.42
+1
+4514.77
+1
+4525.51
+1
+4502.34
+1
+4496.64
+1
+4474.79
+1
+4480.22
+1
+4453.43
+1
+4444.93
+1
+4471.44
+1
+4469.89
+1
+4466.88
+1
+4465.54
+1
+4466.6
+1
+4458.35
+1
+4486.88
+1
+4488.34
+1
+4532.02
+1
+4475.85
+1
+4480.26
+1
+4494.58
+1
+4465.39
+1
+4464.14
+1
+4470.03
+1
+4487.05
+1
+4481.48
+1
+4488.48
+1
+4470
+1
+4460.89
+1
+4500.81
+1
+4553.73
+1
+4517.95
+1
+4529.47
+1
+4528.81
+1
+4573.75
+1
+4579.93
+1
+4608.2
+1
+4598.7
+1
+4640.74
+1
+4639.3
+1
+4634.6
+1
+4676.24
+1
+4739.9
+1
+4755.43
+1
+4710.06
+1
+4743.32
+1
+4774.89
+1
+4783.31
+1
+4758.91
+1
+4808.5
+1
+4837.09
+1
+4876.9
+1
+4866.84
+1
+4868.18
+1
+4913.6
+1
+4973.16
+1
+5006.32
+1
+5031.18
+1
+5094.28
+1
+5075.39
+1
+5124.06
+1
+5138.35
+1
+5157.11
+1
+5211.01
+1
+5253.13
+1
+5327.67
+1
+5353.55
+1
+5386.65
+1
+5418.48
+1
+5467.19
+1
+5527.44
+1
+5603.21
+1
+5638.88
+1
+5721.5
+1
+5788.28
+1
+5880.47
+1
+5949.27
+1
+6008.12
+1
+6089.39
+1
+6115.14
+1
+6213.68
+1
+6304.39
+1
+6342.57
+1
+6400.14
+1
+6535.83
+1
+6509.01
+1
+6550.05
+1
+6644.98
+1
+6655.68
+1
+6648.49
+1
+6623.17
+1
+6626.63
+1
+6589.09
+1
+6583.64
+1
+6552.61
+1
+6572.91
+1
+6441.04
+1
+6387.56
+1
+6362.13
+1
+6260.24
+1
+6213.49
+1
+6158.92
+1
+6114.09
+1
+6074.97
+1
+6000.26
+1
+5929.25
+1
+5851.27
+1
+5770.74
+1
+5760.73
+1
+5710.76
+1
+5667.82
+1
+5590.33
+1
+5554.29
+1
+5507.89
+1
+5494.05
+1
+5467.73
+1
+5443.64
+1
+5433.62
+1
+5405.48
+1
+5433.82
+1
+5417.93
+1
+5428.88
+1
+5445.45
+1
+5456.05
+1
+5488.54
+1
+5526.37
+1
+5547.86
+1
+5608.75
+1
+5667.34
+1
+5721.86
+1
+5774.46
+1
+5827.32
+1
+5902.81
+1
+6030.63
+1
+6105.55
+1
+6171.92
+1
+6227.55
+1
+6378.61
+1
+6460.31
+1
+6591.71
+1
+6670.09
+1
+6750.79
+1
+6777.2
+1
+6918.69
+1
+7056.07
+1
+7085.33
+1
+7121.49
+1
+7161.43
+1
+7222.61
+1
+7326.94
+1
+7344.73
+1
+7357.04
+1
+7385.39
+1
+7454.66
+1
+7461.28
+1
+7452.56
+1
+7464.74
+1
+7416.4
+1
+7403.89
+1
+7340.47
+1
+7331.99
+1
+7242.78
+1
+7131.03
+1
+7032.57
+1
+6991.16
+1
+6838.79
+1
+6660.16
+1
+6542.54
+1
+6354.83
+1
+6214.31
+1
+6054.99
+1
+5929.5
+1
+5718.51
+1
+5512.59
+1
+5345.22
+1
+5207.94
+1
+5051.97
+1
+4967.01
+1
+4882.2
+1
+4722.67
+1
+4660.17
+1
+4631.1
+1
+4591.16
+1
+4516.73
+1
+4494.35
+1
+4481.47
+1
+4454.85
+1
+4428.37
+1
+4416.59
+1
+4462.29
+1
+4432.81
+1
+4445.67
+1
+4462.12
+1
+4474.55
+1
+4516.75
+1
+4539.79
+1
+4517.93
+1
+4560.66
+1
+4585.08
+1
+4673.1
+1
+4696.88
+1
+4711.66
+1
+4727.76
+1
+4776.91
+1
+4765.07
+1
+4821.82
+1
+4874.11
+1
+4898.68
+1
+4907.77
+1
+4927.68
+1
+4969.74
+1
+4971.48
+1
+5018.38
+1
+5067.95
+1
+5056.2
+1
+5078.07
+1
+5098.25
+1
+5165.26
+1
+5182.56
+1
+5219.14
+1
+5245.78
+1
+5327.71
+1
+5341.41
+1
+5406.1
+1
+5434.44
+1
+5517.26
+1
+5602.97
+1
+5653.28
+1
+5735.73
+1
+5841.38
+1
+5884.38
+1
+5935.56
+1
+6026.6
+1
+6140.52
+1
+6243.54
+1
+6314.72
+1
+6337.17
+1
+6419.21
+1
+6501.65
+1
+6587.89
+1
+6626.41
+1
+6646.42
+1
+6740.91
+1
+6817.7
+1
+6846.04
+1
+6953.91
+1
+6953.9
+1
+7015.85
+1
+7047.98
+1
+7101.75
+1
+7165.33
+1
+7218.87
+1
+7266.27
+1
+7348
+1
+7371.05
+1
+7316.21
+1
+7382.63
+1
+7324.9
+1
+7293.03
+1
+7245.04
+1
+7177.46
+1
+7142.49
+1
+7045.02
+1
+7023.8
+1
+6895.23
+1
+6830.41
+1
+6739.48
+1
+6643.74
+1
+6632.25
+1
+6630.32
+1
+6591.83
+1
+6598.33
+1
+6575.15
+1
+6531.98
+1
+6613.92
+1
+6640.59
+1
+6651.93
+1
+6703.61
+1
+6743.4
+1
+6836.81
+1
+6923.2
+1
+6988.41
+1
+7081.4
+1
+7184.37
+1
+7309.88
+1
+7444.86
+1
+7566.28
+1
+7690.3
+1
+7807.2
+1
+7891.8
+1
+7959.14
+1
+8091.18
+1
+8233.31
+1
+8334.37
+1
+8417.31
+1
+8509.89
+1
+8613.45
+1
+8740.49
+1
+8852.38
+1
+8954.2
+1
+9055.61
+1
+9244.31
+1
+9333.22
+1
+9423.61
+1
+9568.04
+1
+9720.64
+1
+9835.06
+1
+9957.61
+1
+10032.5
+1
+10123.1
+1
+10254.2
+1
+10362.2
+1
+10486.6
+1
+10495.8
+1
+10500.9
+1
+10547.4
+1
+10490
+1
+10496.6
+1
+10331.7
+1
+10209.8
+1
+10073.6
+1
+9854.09
+1
+9648.25
+1
+9457.95
+1
+9177.54
+1
+8819.24
+1
+8416.77
+1
+8038.94
+1
+7675.15
+1
+7209.58
+1
+6694.9
+1
+6258.65
+1
+5863.55
+1
+5465.44
+1
+5114.25
+1
+4748.5
+1
+4484.21
+1
+4248.08
+1
+4071.84
+1
+3928.19
+1
+3848.2
+1
+3749.03
+1
+3687.68
+1
+3642.69
+1
+3563.91
+1
+3545.61
+1
+3541.72
+1
+3480.46
+1
+3484.22
+1
+3494.43
+1
+3428.99
+1
+3402.28
+1
+3393.13
+1
+3349.96
+1
+3340.49
+1
+3301.33
+1
+3313.93
+1
+3300.39
+1
+3295.76
+1
+3260.03
+1
+3221.01
+1
+3217.27
+1
+3215.73
+1
+3197.69
+1
+3178
+1
+3171.31
+1
+3186.18
+1
+3144.98
+1
+3147
+1
+3139.48
+1
+3094.96
+1
+3104.28
+1
+3102.71
+1
+3080.88
+1
+3092.66
+1
+3068.87
+1
+3061.28
+1
+3054.32
+1
+3047.58
+1
+3008.9
+1
+3022.82
+1
+3022.41
+1
+3026.81
+1
+3022.62
+1
+3013.82
+1
+2983.56
+1
+2994.07
+1
+3002.59
+1
+2952.01
+1
+2993.31
+1
+2985.52
+1
+2957.78
+1
+2975.44
+1
+2935.4
+1
+2942.52
+1
+2932.42
+1
+2944.54
+1
+2954.26
+1
+2946.27
+1
+2923.9
+1
+2912.64
+1
+2924.42
+1
+2942.57
+1
+2896.78
+1
+2881.23
+1
+2856.98
+1
+2848.07
+1
+2836.05
+1
+2813.23
+1
+2826.89
+1
+2817.17
+1
+2786.8
+1
+2732.04
+1
+2750.86
+1
+2744.78
+1
+2710.28
+1
+2679.96
+1
+2629.85
+1
+2620.59
+1
+2572.15
+1
+Co2p
+Co3O4
+2021
+4
+28
+14
+3
+32
+0
+18
+Casa Info Follows
+0
+0
+0
+0
+File = E:/OwnCloud/XPS lab/EX491_S745_Co.sle
+Group = Loop 5_ RT in vacuum, #Treatments: , #Temp:RT , #Pressure:vacuum , #Atmosphere: , #Comments:  
+First of group = 0
+Spectrum ID = 35
+Analyzer lens = AngleResolvedMode22:1.5kV
+Analyzer slit = 4:7x20c\C:mesh
+Scan mode = FixedAnalyzerTransmission
+Kinetic energy start = 646.61
+PCA Coefs = 121097, 10503.5, 4030.21, -1208.61, 399.219, 
+C:\Users\Mark\Downloads\EX491_S745_Co (1).vms
+c:\users\pielsticker\lukas\mpi-cec\projects\deepxps\xpsdeeplearning\data\references\nicofe\ex491-495 fe, ni, co oxide references.vms
+C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\NiCoFe\EX491-495 FeCo summed.vms
+CasaXP2
+XPS
+2
+Al
+1486.61
+0
+0
+0
+54.5
+180
+FAT
+20
+1
+4.1408
+0
+0
+0
+0
+0
+Co
+2p
+-1
+kinetic energy
+eV
+646.61
+0.1
+2
+counts
+d
+Transmission
+d
+pulse counting
+0.1
+3
+0
+0
+0
+0
+2
+ESCAPE DEPTH TYPE
+d
+1
+MFP Exponent
+d
+0
+1402
+2338.41
+9790.8
+1
+1
+4874.31
+1
+4899.15
+1
+4906.93
+1
+4914.08
+1
+4923.15
+1
+4897.92
+1
+4907
+1
+4928.19
+1
+4927.38
+1
+4947.5
+1
+4931.35
+1
+4913.69
+1
+4931.09
+1
+4936.01
+1
+4933.23
+1
+4935.56
+1
+4923.07
+1
+4909.71
+1
+4931.01
+1
+4933.03
+1
+4921.09
+1
+4904.73
+1
+4928.58
+1
+4916.7
+1
+4914.77
+1
+4922.88
+1
+4918.25
+1
+4918
+1
+4905.29
+1
+4910.8
+1
+4893.82
+1
+4890.32
+1
+4916.98
+1
+4909.28
+1
+4897.06
+1
+4900.35
+1
+4881.96
+1
+4878.58
+1
+4874.58
+1
+4868.89
+1
+4859.94
+1
+4872.63
+1
+4875.84
+1
+4859.41
+1
+4856.38
+1
+4866.25
+1
+4863.03
+1
+4872.76
+1
+4874.43
+1
+4862.53
+1
+4863.39
+1
+4878.97
+1
+4871.59
+1
+4866.55
+1
+4879.81
+1
+4872.64
+1
+4862.51
+1
+4866
+1
+4887.22
+1
+4866.54
+1
+4875.13
+1
+4880.45
+1
+4884.2
+1
+4885.64
+1
+4911.21
+1
+4895.37
+1
+4893.96
+1
+4892.06
+1
+4879.67
+1
+4885.18
+1
+4898.59
+1
+4879.6
+1
+4895.94
+1
+4892.78
+1
+4904.13
+1
+4899.4
+1
+4912.61
+1
+4905.63
+1
+4906.53
+1
+4898.28
+1
+4889.43
+1
+4876.57
+1
+4886.18
+1
+4885.57
+1
+4869.18
+1
+4865.32
+1
+4859.71
+1
+4886.91
+1
+4850.27
+1
+4859.12
+1
+4853.83
+1
+4833.74
+1
+4810.63
+1
+4819.77
+1
+4783.83
+1
+4775.12
+1
+4779.85
+1
+4765.22
+1
+4741.95
+1
+4709.28
+1
+4709.57
+1
+4680.19
+1
+4677.36
+1
+4646.65
+1
+4635.91
+1
+4618.38
+1
+4601.06
+1
+4588.43
+1
+4579.29
+1
+4568.01
+1
+4547.84
+1
+4529.83
+1
+4504.66
+1
+4494.87
+1
+4472.73
+1
+4472.21
+1
+4447.87
+1
+4431.17
+1
+4411.71
+1
+4397.97
+1
+4401.1
+1
+4393.04
+1
+4366.72
+1
+4368.73
+1
+4355.94
+1
+4357.21
+1
+4346.01
+1
+4324.82
+1
+4337.11
+1
+4327.33
+1
+4327.34
+1
+4324.08
+1
+4307.18
+1
+4300.96
+1
+4305.88
+1
+4302.02
+1
+4280.74
+1
+4281.88
+1
+4261.55
+1
+4277.74
+1
+4287
+1
+4287.11
+1
+4283.06
+1
+4270.49
+1
+4264.07
+1
+4274.99
+1
+4280.63
+1
+4279.19
+1
+4259.87
+1
+4263.41
+1
+4270.62
+1
+4264.62
+1
+4288.64
+1
+4272.78
+1
+4268.18
+1
+4255.22
+1
+4255.89
+1
+4264.57
+1
+4261.38
+1
+4264.49
+1
+4269
+1
+4272.93
+1
+4266.43
+1
+4262.87
+1
+4264.77
+1
+4266.04
+1
+4259.46
+1
+4252.46
+1
+4266.86
+1
+4269.63
+1
+4249.45
+1
+4274.79
+1
+4257.9
+1
+4270.52
+1
+4262.44
+1
+4253.34
+1
+4252.18
+1
+4255.8
+1
+4256.1
+1
+4268.83
+1
+4266.45
+1
+4262.11
+1
+4249.59
+1
+4245.01
+1
+4251.15
+1
+4250.65
+1
+4230.82
+1
+4241.03
+1
+4230.47
+1
+4242.17
+1
+4235.59
+1
+4234.01
+1
+4232.32
+1
+4226.46
+1
+4237.5
+1
+4233.36
+1
+4221.24
+1
+4215.75
+1
+4226.08
+1
+4221.33
+1
+4218.31
+1
+4194.32
+1
+4193.69
+1
+4222.88
+1
+4206.47
+1
+4210.82
+1
+4209.14
+1
+4190.1
+1
+4202.72
+1
+4213.22
+1
+4197.28
+1
+4202.51
+1
+4198.43
+1
+4198.24
+1
+4174.86
+1
+4205.3
+1
+4188.78
+1
+4213.26
+1
+4195.94
+1
+4175.4
+1
+4180.73
+1
+4194.95
+1
+4200.21
+1
+4179.21
+1
+4171.22
+1
+4182.66
+1
+4174.57
+1
+4179.69
+1
+4182.3
+1
+4176.19
+1
+4170.34
+1
+4160.72
+1
+4161.9
+1
+4155.85
+1
+4148.16
+1
+4143.33
+1
+4163.24
+1
+4160.28
+1
+4150.58
+1
+4130.58
+1
+4148.63
+1
+4138.35
+1
+4119.16
+1
+4132.09
+1
+4130.89
+1
+4122.1
+1
+4112.57
+1
+4126.78
+1
+4128.76
+1
+4122.8
+1
+4106.94
+1
+4122.81
+1
+4108.75
+1
+4080.16
+1
+4082.61
+1
+4092.82
+1
+4101.54
+1
+4095.26
+1
+4092.09
+1
+4089.29
+1
+4103.81
+1
+4101.88
+1
+4066.33
+1
+4077.52
+1
+4082.57
+1
+4079.97
+1
+4072.21
+1
+4061.75
+1
+4059.76
+1
+4084.85
+1
+4087.77
+1
+4069.49
+1
+4050.3
+1
+4044.91
+1
+4028.05
+1
+4035.71
+1
+4031.63
+1
+4035.52
+1
+4038.22
+1
+4054.74
+1
+4050.15
+1
+4038.64
+1
+4032.06
+1
+4049.43
+1
+4066.04
+1
+4048.56
+1
+4048.15
+1
+4046.02
+1
+4057.15
+1
+4043.91
+1
+4039.32
+1
+4025.58
+1
+4031.26
+1
+4052.58
+1
+4049.91
+1
+4051.36
+1
+4041.61
+1
+4050.99
+1
+4051.17
+1
+4041.52
+1
+4045.76
+1
+4055.7
+1
+4057.68
+1
+4067.44
+1
+4067.58
+1
+4085.2
+1
+4058.9
+1
+4072.51
+1
+4065.12
+1
+4062.82
+1
+4070.23
+1
+4081.36
+1
+4086.62
+1
+4094.61
+1
+4098
+1
+4109.49
+1
+4110.18
+1
+4112.97
+1
+4125.26
+1
+4131.37
+1
+4129.82
+1
+4135.6
+1
+4139.11
+1
+4168.39
+1
+4173.6
+1
+4176.69
+1
+4180.51
+1
+4202.47
+1
+4224.5
+1
+4234.54
+1
+4250.62
+1
+4240.57
+1
+4274.75
+1
+4292.37
+1
+4313.79
+1
+4300.02
+1
+4307.72
+1
+4324.11
+1
+4339.06
+1
+4355.56
+1
+4368.93
+1
+4391.69
+1
+4394.09
+1
+4410.25
+1
+4411.09
+1
+4416.37
+1
+4435.45
+1
+4437.73
+1
+4444.36
+1
+4443.04
+1
+4463.29
+1
+4468.71
+1
+4483.88
+1
+4498.57
+1
+4493.55
+1
+4488.97
+1
+4485.23
+1
+4509.55
+1
+4496.9
+1
+4499.54
+1
+4493.29
+1
+4511.05
+1
+4485.14
+1
+4477.99
+1
+4492.92
+1
+4462
+1
+4463.13
+1
+4454.8
+1
+4457.56
+1
+4496.3
+1
+4465.78
+1
+4448.27
+1
+4445.75
+1
+4422.14
+1
+4417.93
+1
+4430.44
+1
+4411.52
+1
+4394.04
+1
+4388.04
+1
+4396.1
+1
+4368.86
+1
+4344.1
+1
+4328.66
+1
+4328.53
+1
+4323.9
+1
+4320.32
+1
+4310.36
+1
+4294.49
+1
+4279.33
+1
+4285.18
+1
+4264.6
+1
+4254.3
+1
+4260.26
+1
+4266.56
+1
+4250.34
+1
+4259.19
+1
+4222.73
+1
+4233.84
+1
+4243.42
+1
+4227.15
+1
+4240.16
+1
+4232.69
+1
+4249.78
+1
+4270.57
+1
+4257.24
+1
+4257.31
+1
+4297.98
+1
+4296.09
+1
+4317.76
+1
+4324.68
+1
+4348.62
+1
+4364.09
+1
+4398.79
+1
+4434.87
+1
+4461.77
+1
+4476.97
+1
+4534.53
+1
+4550.6
+1
+4593.12
+1
+4641.15
+1
+4692.36
+1
+4734.51
+1
+4798.94
+1
+4849.38
+1
+4906.09
+1
+4949.11
+1
+5024.6
+1
+5074.91
+1
+5142.5
+1
+5218.83
+1
+5298.92
+1
+5356.14
+1
+5417.11
+1
+5477.49
+1
+5552.38
+1
+5613.86
+1
+5683.78
+1
+5719.11
+1
+5783.45
+1
+5834.78
+1
+5873.96
+1
+5927.19
+1
+5957.87
+1
+6001.83
+1
+6036.13
+1
+6066.22
+1
+6085.84
+1
+6098.26
+1
+6118.13
+1
+6171.88
+1
+6208.49
+1
+6286.47
+1
+6359.09
+1
+6454.42
+1
+6498.75
+1
+6530.91
+1
+6502.89
+1
+6390.96
+1
+6199.28
+1
+5917.75
+1
+5629.04
+1
+5330.71
+1
+5033.71
+1
+4779.03
+1
+4579.33
+1
+4415.86
+1
+4294.43
+1
+4166.49
+1
+4084.86
+1
+4029.51
+1
+3972.13
+1
+3934.55
+1
+3909.31
+1
+3897.8
+1
+3883.61
+1
+3887.62
+1
+3890.26
+1
+3903.02
+1
+3903.27
+1
+3910.82
+1
+3924.78
+1
+3952.53
+1
+3977.47
+1
+4003.03
+1
+4020.01
+1
+4048.03
+1
+4077.04
+1
+4100.84
+1
+4135.59
+1
+4141.37
+1
+4165.67
+1
+4203.83
+1
+4231.55
+1
+4252.87
+1
+4269.62
+1
+4284.29
+1
+4287.87
+1
+4312.89
+1
+4353.23
+1
+4354.76
+1
+4357.38
+1
+4390.48
+1
+4385.98
+1
+4383.54
+1
+4376.09
+1
+4388.08
+1
+4419.72
+1
+4430.92
+1
+4422.59
+1
+4419.68
+1
+4428.82
+1
+4438.57
+1
+4417.75
+1
+4427.88
+1
+4410.86
+1
+4397.29
+1
+4386.68
+1
+4387.34
+1
+4367.17
+1
+4359.31
+1
+4362.92
+1
+4341.28
+1
+4346.8
+1
+4352.16
+1
+4335.05
+1
+4313.14
+1
+4326.59
+1
+4323.22
+1
+4311.38
+1
+4313.79
+1
+4354.23
+1
+4345.21
+1
+4331.29
+1
+4353.98
+1
+4346.32
+1
+4335.09
+1
+4328.45
+1
+4352.2
+1
+4351.18
+1
+4351.28
+1
+4355.18
+1
+4342.83
+1
+4388.3
+1
+4381.54
+1
+4367.99
+1
+4362.96
+1
+4370.83
+1
+4363.65
+1
+4374.72
+1
+4358.86
+1
+4347.83
+1
+4373.41
+1
+4381.21
+1
+4392.96
+1
+4396.55
+1
+4408.13
+1
+4423.04
+1
+4419.83
+1
+4432.86
+1
+4446.5
+1
+4480.98
+1
+4523.46
+1
+4547.07
+1
+4588.3
+1
+4643.98
+1
+4681.43
+1
+4715.67
+1
+4780.82
+1
+4852.2
+1
+4921.26
+1
+4981.57
+1
+5042.33
+1
+5149.32
+1
+5239.38
+1
+5342.77
+1
+5451.05
+1
+5561.95
+1
+5682.33
+1
+5800.56
+1
+5954.24
+1
+6116.08
+1
+6232.67
+1
+6389.51
+1
+6572.71
+1
+6732.83
+1
+6880.6
+1
+7041.13
+1
+7201.61
+1
+7363.26
+1
+7552.24
+1
+7710.33
+1
+7869.82
+1
+8061.76
+1
+8221.06
+1
+8351.72
+1
+8494.8
+1
+8586.38
+1
+8655.17
+1
+8748.39
+1
+8778.47
+1
+8930.03
+1
+9060.56
+1
+9202.25
+1
+9430.15
+1
+9637.46
+1
+9777.93
+1
+9762.67
+1
+9542.68
+1
+9061.49
+1
+8419.58
+1
+7660.66
+1
+6875.64
+1
+6185.17
+1
+5625.52
+1
+5170.82
+1
+4825.73
+1
+4535.96
+1
+4251.39
+1
+3997.96
+1
+3782.67
+1
+3580.5
+1
+3422.18
+1
+3282.22
+1
+3203.44
+1
+3143.96
+1
+3072.56
+1
+3022.36
+1
+3007.79
+1
+2966.76
+1
+2954.79
+1
+2926.19
+1
+2922.46
+1
+2891.52
+1
+2870.36
+1
+2858.07
+1
+2848.05
+1
+2820.37
+1
+2804.29
+1
+2792.29
+1
+2771.25
+1
+2766.01
+1
+2757.26
+1
+2739.59
+1
+2724.12
+1
+2715.66
+1
+2710.67
+1
+2696.93
+1
+2668.03
+1
+2662.11
+1
+2660.77
+1
+2653.28
+1
+2643.89
+1
+2623.28
+1
+2630.83
+1
+2616.75
+1
+2619.83
+1
+2606.83
+1
+2593.88
+1
+2594.84
+1
+2595.47
+1
+2580.89
+1
+2575.78
+1
+2574.82
+1
+2559.33
+1
+2557.45
+1
+2558.59
+1
+2544.08
+1
+2550.95
+1
+2538.87
+1
+2534.03
+1
+2519.94
+1
+2506.31
+1
+2514.19
+1
+2514.21
+1
+2501.68
+1
+2502.88
+1
+2495.23
+1
+2494.96
+1
+2496.17
+1
+2484.58
+1
+2489.46
+1
+2481.78
+1
+2503.19
+1
+2493.2
+1
+2469.32
+1
+2479.95
+1
+2479.42
+1
+2486.47
+1
+2474.39
+1
+2465.76
+1
+2472.4
+1
+2462.19
+1
+2458.47
+1
+2444.63
+1
+2432.51
+1
+2428
+1
+2430.73
+1
+2437.06
+1
+2427.84
+1
+2415.98
+1
+2401.99
+1
+end of experiment
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Cu2p_Cu_metal.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Cu2p_Cu_metal.txt
new file mode 100644
index 0000000000000000000000000000000000000000..edbc734327f93dcbb1be34e9692b9b713861f13d
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Cu2p_Cu_metal.txt
@@ -0,0 +1,1041 @@
+Cu2p Cu metal
+971.95	598.968
+971.9	602.72
+971.85	596.683
+971.8	583.623
+971.75	596.66
+971.7	601.737
+971.65	597.085
+971.6	617.46
+971.55	606.703
+971.5	593.23
+971.45	600.803
+971.4	601.243
+971.35	595.738
+971.3	588.658
+971.25	592.445
+971.2	607.652
+971.15	609.737
+971.1	595.038
+971.05	592.837
+971	575.63
+970.95	593.695
+970.9	582.623
+970.85	588.83
+970.8	584.793
+970.75	589.29
+970.7	600.41
+970.65	610.775
+970.6	621.195
+970.55	610.022
+970.5	600.028
+970.45	596.298
+970.4	595.282
+970.35	594.38
+970.3	579.698
+970.25	586.317
+970.2	583.955
+970.15	592.24
+970.1	585.035
+970.05	600.665
+970	600.835
+969.95	602.323
+969.9	596.747
+969.85	590.11
+969.8	596.168
+969.75	592.18
+969.7	601.755
+969.65	596.173
+969.6	596.553
+969.55	596.697
+969.5	599.335
+969.45	595.648
+969.4	594.122
+969.35	605.123
+969.3	621.59
+969.25	595.765
+969.2	591.987
+969.15	606.62
+969.1	588.157
+969.05	606.788
+969	608.59
+968.95	598.708
+968.9	595.382
+968.85	590.48
+968.8	599.472
+968.75	597.162
+968.7	594.49
+968.65	603.642
+968.6	597.102
+968.55	588.973
+968.5	587.045
+968.45	598.588
+968.4	581.378
+968.35	597.23
+968.3	621.657
+968.25	609.13
+968.2	585.837
+968.15	589.983
+968.1	603.052
+968.05	606.673
+968	599.847
+967.95	604.283
+967.9	605.907
+967.85	604.66
+967.8	600.087
+967.75	590.2
+967.7	588.097
+967.65	596.468
+967.6	617.568
+967.55	588.315
+967.5	592.498
+967.45	610.423
+967.4	606.422
+967.35	595.403
+967.3	604.843
+967.25	602.545
+967.2	600.705
+967.15	603.642
+967.1	609.427
+967.05	595.32
+967	581.847
+966.95	594.637
+966.9	585.378
+966.85	602.46
+966.8	613.307
+966.75	606.245
+966.7	598.86
+966.65	595.237
+966.6	613.462
+966.55	607.23
+966.5	597.512
+966.45	595.917
+966.4	600.475
+966.35	602.625
+966.3	599.123
+966.25	590.877
+966.2	604.58
+966.15	611.792
+966.1	611.045
+966.05	605.408
+966	605.527
+965.95	602.278
+965.9	598.407
+965.85	607.767
+965.8	620.205
+965.75	614.117
+965.7	613.853
+965.65	611.42
+965.6	627.223
+965.55	602.16
+965.5	606.453
+965.45	623.562
+965.4	619.067
+965.35	617.512
+965.3	606.677
+965.25	606.638
+965.2	628.733
+965.15	618.077
+965.1	623.32
+965.05	616.182
+965	610.857
+964.95	621.025
+964.9	615.7
+964.85	620.413
+964.8	624.437
+964.75	628.427
+964.7	612.377
+964.65	612.3
+964.6	611.157
+964.55	603.655
+964.5	620.82
+964.45	618.193
+964.4	614
+964.35	595.673
+964.3	585.438
+964.25	597.017
+964.2	594.96
+964.15	601.07
+964.1	603.958
+964.05	602.752
+964	599.19
+963.95	592.132
+963.9	581.743
+963.85	600.837
+963.8	611.455
+963.75	599.785
+963.7	574.922
+963.65	595.617
+963.6	596.565
+963.55	593.53
+963.5	586.35
+963.45	595.51
+963.4	591.798
+963.35	592.485
+963.3	583.575
+963.25	588.585
+963.2	579.42
+963.15	587.563
+963.1	585.51
+963.05	583.483
+963	582.108
+962.95	571.3
+962.9	567.01
+962.85	586.432
+962.8	586.232
+962.75	577.72
+962.7	578.253
+962.65	590.84
+962.6	595.015
+962.55	582.628
+962.5	576.343
+962.45	589.143
+962.4	572.68
+962.35	574.603
+962.3	591.427
+962.25	576.282
+962.2	572.957
+962.15	584.46
+962.1	579.968
+962.05	575.558
+962	567.652
+961.95	576.413
+961.9	566.815
+961.85	580.5
+961.8	577.44
+961.75	583.078
+961.7	576.117
+961.65	568.855
+961.6	578.545
+961.55	569.59
+961.5	584.473
+961.45	567.603
+961.4	584.217
+961.35	573.683
+961.3	581.955
+961.25	578
+961.2	573.405
+961.15	572.698
+961.1	579.393
+961.05	583.178
+961	595.192
+960.95	601.558
+960.9	590.607
+960.85	567.913
+960.8	570.208
+960.75	588.928
+960.7	576.007
+960.65	586.705
+960.6	592.943
+960.55	592.888
+960.5	575.298
+960.45	566.263
+960.4	566.675
+960.35	581.457
+960.3	579.163
+960.25	578.928
+960.2	593.53
+960.15	579.655
+960.1	580.573
+960.05	568.098
+960	575.722
+959.95	588.525
+959.9	572.5
+959.85	584.028
+959.8	583.577
+959.75	577.547
+959.7	579.842
+959.65	572.19
+959.6	573.867
+959.55	568.792
+959.5	577.957
+959.45	586.722
+959.4	587.415
+959.35	594.115
+959.3	587.445
+959.25	590.693
+959.2	597.515
+959.15	587.803
+959.1	582.038
+959.05	584.282
+959	586.077
+958.95	585.705
+958.9	578.182
+958.85	579.125
+958.8	579.558
+958.75	589.007
+958.7	580.105
+958.65	578.802
+958.6	574.047
+958.55	586.75
+958.5	596.798
+958.45	583.662
+958.4	588.667
+958.35	588.295
+958.3	599.893
+958.25	588.948
+958.2	580.972
+958.15	583.39
+958.1	593.362
+958.05	586.887
+958	576.043
+957.95	579.872
+957.9	576.157
+957.85	590.157
+957.8	591.323
+957.75	577.897
+957.7	577.193
+957.65	590.543
+957.6	582.078
+957.55	576.825
+957.5	579.262
+957.45	595.64
+957.4	592.505
+957.35	608.027
+957.3	591.642
+957.25	590.147
+957.2	593.977
+957.15	585.883
+957.1	607.237
+957.05	603.587
+957	612.718
+956.95	608.565
+956.9	589.743
+956.85	596.285
+956.8	595.623
+956.75	606.842
+956.7	610.022
+956.65	602.818
+956.6	598.943
+956.55	601.822
+956.5	606.932
+956.45	604.763
+956.4	606.658
+956.35	606.622
+956.3	606.257
+956.25	613.735
+956.2	615.43
+956.15	614.25
+956.1	633.002
+956.05	623.217
+956	610.578
+955.95	614.65
+955.9	616.367
+955.85	615.847
+955.8	624.78
+955.75	620.912
+955.7	622.745
+955.65	634.732
+955.6	628.398
+955.55	640.888
+955.5	641.813
+955.45	634.295
+955.4	638.282
+955.35	636.692
+955.3	632.953
+955.25	643.208
+955.2	646.548
+955.15	635.87
+955.1	649.068
+955.05	656.65
+955	653.852
+954.95	667.572
+954.9	674.767
+954.85	660.303
+954.8	678.342
+954.75	676.482
+954.7	670.213
+954.65	681.262
+954.6	692.123
+954.55	678.683
+954.5	710.025
+954.45	720.95
+954.4	726.813
+954.35	731.018
+954.3	721.477
+954.25	731.895
+954.2	743.778
+954.15	748.482
+954.1	761.762
+954.05	771
+954	783.707
+953.95	784.713
+953.9	803.443
+953.85	822.298
+953.8	832.817
+953.75	854.365
+953.7	870.423
+953.65	891.213
+953.6	909.625
+953.55	925.613
+953.5	954.635
+953.45	975.292
+953.4	1019.94
+953.35	1056.18
+953.3	1094.62
+953.25	1128.29
+953.2	1165.97
+953.15	1203.49
+953.1	1248.38
+953.05	1280.3
+953	1340.33
+952.95	1383.74
+952.9	1439.1
+952.85	1472.09
+952.8	1519.12
+952.75	1547.9
+952.7	1592.91
+952.65	1608.02
+952.6	1634.78
+952.55	1660.65
+952.5	1647.07
+952.45	1655.81
+952.4	1626.87
+952.35	1567.75
+952.3	1559.7
+952.25	1535.1
+952.2	1486.44
+952.15	1411.06
+952.1	1352.9
+952.05	1333.66
+952	1254.94
+951.95	1189.1
+951.9	1162.9
+951.85	1111.82
+951.8	1082.96
+951.75	1042.56
+951.7	997.293
+951.65	965.662
+951.6	953.45
+951.55	900.023
+951.5	893.698
+951.45	853.535
+951.4	831.935
+951.35	809.972
+951.3	778.508
+951.25	771.612
+951.2	752.813
+951.15	746.037
+951.1	728.745
+951.05	726.743
+951	702.262
+950.95	690.447
+950.9	693.577
+950.85	684.07
+950.8	672.623
+950.75	671.94
+950.7	654.055
+950.65	646.235
+950.6	663.355
+950.55	637.728
+950.5	638.548
+950.45	636.302
+950.4	617.458
+950.35	632.397
+950.3	616.683
+950.25	616.302
+950.2	609.652
+950.15	607.907
+950.1	588.038
+950.05	605.165
+950	603.693
+949.95	592.632
+949.9	583.768
+949.85	585.455
+949.8	580.295
+949.75	580.94
+949.7	580.143
+949.65	566.602
+949.6	576.065
+949.55	577.335
+949.5	564.632
+949.45	553.922
+949.4	559.953
+949.35	566.217
+949.3	563.128
+949.25	554.507
+949.2	557.513
+949.15	540.478
+949.1	550.613
+949.05	545.977
+949	525.787
+948.95	543.083
+948.9	536.905
+948.85	545.98
+948.8	530.958
+948.75	532.07
+948.7	535.765
+948.65	537.463
+948.6	532.803
+948.55	534.613
+948.5	534.99
+948.45	537.507
+948.4	536.07
+948.35	540.185
+948.3	534.507
+948.25	538.778
+948.2	550.238
+948.15	542.867
+948.1	546.838
+948.05	537.097
+948	526.58
+947.95	537.148
+947.9	543.513
+947.85	542.008
+947.8	545.742
+947.75	526.367
+947.7	531.61
+947.65	535.28
+947.6	535.05
+947.55	540.352
+947.5	535.397
+947.45	525.825
+947.4	534.975
+947.35	536.45
+947.3	534.872
+947.25	523.068
+947.2	524.805
+947.15	527.358
+947.1	522.488
+947.05	516.28
+947	527.532
+946.95	534.79
+946.9	539.407
+946.85	520.453
+946.8	526.765
+946.75	520.998
+946.7	530.715
+946.65	530.638
+946.6	525.737
+946.55	518.163
+946.5	525.8
+946.45	536.405
+946.4	520.08
+946.35	516.102
+946.3	526.605
+946.25	536.95
+946.2	530.445
+946.15	517.848
+946.1	523.982
+946.05	530.735
+946	513.608
+945.95	525.437
+945.9	524.055
+945.85	533.343
+945.8	527.548
+945.75	520.213
+945.7	522.388
+945.65	528.02
+945.6	522.553
+945.55	518.19
+945.5	508.06
+945.45	499.762
+945.4	492.74
+945.35	516.493
+945.3	507.597
+945.25	498.668
+945.2	490.01
+945.15	497.687
+945.1	502.82
+945.05	505.792
+945	489.925
+944.95	503.012
+944.9	505.048
+944.85	510.14
+944.8	497.308
+944.75	495.34
+944.7	500.135
+944.65	486.743
+944.6	490.088
+944.55	493.11
+944.5	496.145
+944.45	500.668
+944.4	496.178
+944.35	507.142
+944.3	496.21
+944.25	483.797
+944.2	477.267
+944.15	498.732
+944.1	499.632
+944.05	500.672
+944	484.322
+943.95	497.672
+943.9	480.642
+943.85	474.433
+943.8	487.797
+943.75	494.363
+943.7	499.77
+943.65	485.25
+943.6	480.563
+943.55	471.56
+943.5	473.598
+943.45	476.242
+943.4	465.06
+943.35	475.263
+943.3	475.113
+943.25	475.54
+943.2	476.985
+943.15	461.473
+943.1	469.015
+943.05	473.805
+943	468.427
+942.95	466.69
+942.9	461.073
+942.85	466.925
+942.8	458.705
+942.75	453.962
+942.7	451.048
+942.65	461.61
+942.6	464.728
+942.55	458.28
+942.5	457.537
+942.45	456.032
+942.4	459.777
+942.35	450.98
+942.3	448.44
+942.25	452.673
+942.2	454.547
+942.15	448.167
+942.1	453.332
+942.05	440.29
+942	443.54
+941.95	442.993
+941.9	437.665
+941.85	438.483
+941.8	422.08
+941.75	430.657
+941.7	433.565
+941.65	438.993
+941.6	431.375
+941.55	419.155
+941.5	430.615
+941.45	430.655
+941.4	438.763
+941.35	419.848
+941.3	429.625
+941.25	431.445
+941.2	430.552
+941.15	414.09
+941.1	417.777
+941.05	415.565
+941	422.672
+940.95	435.253
+940.9	433.547
+940.85	427.838
+940.8	435.122
+940.75	423.803
+940.7	432.727
+940.65	425.965
+940.6	422.363
+940.55	423.93
+940.5	423.023
+940.45	416.563
+940.4	413.59
+940.35	420.413
+940.3	420.985
+940.25	433.933
+940.2	426.042
+940.15	441.738
+940.1	447.09
+940.05	426.528
+940	429.872
+939.95	438.895
+939.9	424.687
+939.85	430.51
+939.8	437.282
+939.75	428.002
+939.7	437.398
+939.65	424.428
+939.6	412.403
+939.55	416.1
+939.5	429.428
+939.45	431.33
+939.4	425.86
+939.35	422.578
+939.3	427.158
+939.25	432.287
+939.2	417.272
+939.15	422.357
+939.1	420.502
+939.05	420.092
+939	422.748
+938.95	417.875
+938.9	417.487
+938.85	421.082
+938.8	417.472
+938.75	420.148
+938.7	425.813
+938.65	407.303
+938.6	429.057
+938.55	423.957
+938.5	417.36
+938.45	434.412
+938.4	420.168
+938.35	427.487
+938.3	421.397
+938.25	432.885
+938.2	423.038
+938.15	430.352
+938.1	435.74
+938.05	424.972
+938	420.233
+937.95	429.352
+937.9	426.99
+937.85	432.922
+937.8	436.51
+937.75	427.007
+937.7	436.707
+937.65	446.855
+937.6	432.915
+937.55	439.625
+937.5	437.992
+937.45	439.307
+937.4	439.93
+937.35	440.877
+937.3	436.352
+937.25	427.667
+937.2	437.168
+937.15	444.575
+937.1	430.817
+937.05	442.093
+937	436.917
+936.95	440.06
+936.9	441.942
+936.85	436.508
+936.8	443.605
+936.75	437.233
+936.7	446.703
+936.65	454.613
+936.6	436.775
+936.55	439.472
+936.5	450.147
+936.45	447.742
+936.4	438.5
+936.35	440.125
+936.3	452.045
+936.25	446.05
+936.2	447.477
+936.15	448.883
+936.1	444.782
+936.05	459.113
+936	459.357
+935.95	457.37
+935.9	452.168
+935.85	442.313
+935.8	443.725
+935.75	459.448
+935.7	460.782
+935.65	455.295
+935.6	440.415
+935.55	459.925
+935.5	464.343
+935.45	457.755
+935.4	451.96
+935.35	474.805
+935.3	460.675
+935.25	464.115
+935.2	463.825
+935.15	464.512
+935.1	465.28
+935.05	476.63
+935	472.322
+934.95	481.343
+934.9	486.295
+934.85	486.533
+934.8	483.272
+934.75	501.62
+934.7	510.122
+934.65	508.312
+934.6	510.188
+934.55	514.285
+934.5	523.628
+934.45	545.707
+934.4	551.487
+934.35	553.562
+934.3	566.003
+934.25	574.655
+934.2	582.652
+934.15	626.278
+934.1	623.908
+934.05	659.113
+934	673.323
+933.95	688.922
+933.9	723.782
+933.85	758.845
+933.8	805.662
+933.75	841.873
+933.7	880.583
+933.65	930.032
+933.6	987.57
+933.55	1059.62
+933.5	1137.4
+933.45	1227.21
+933.4	1349.65
+933.35	1481.33
+933.3	1653.62
+933.25	1810.17
+933.2	1976.57
+933.15	2181.03
+933.1	2446.27
+933.05	2733.2
+933	3004.85
+932.95	3275.5
+932.9	3563.25
+932.85	3806.32
+932.8	3961.02
+932.75	4044.85
+932.7	4094.27
+932.65	4072.62
+932.6	3945.93
+932.55	3730.87
+932.5	3467.58
+932.45	3177.73
+932.4	2875.73
+932.35	2554.73
+932.3	2309.05
+932.25	2053.73
+932.2	1821.33
+932.15	1609.64
+932.1	1448.14
+932.05	1300.44
+932	1187
+931.95	1110.87
+931.9	1017.93
+931.85	910.203
+931.8	853.192
+931.75	796.772
+931.7	742.363
+931.65	691.753
+931.6	664.647
+931.55	626.53
+931.5	588.435
+931.45	585.847
+931.4	562.137
+931.35	525.078
+931.3	512.722
+931.25	491.16
+931.2	484.722
+931.15	457.607
+931.1	453.168
+931.05	439.28
+931	439.8
+930.95	430.687
+930.9	420.88
+930.85	412.848
+930.8	402.16
+930.75	394.967
+930.7	387.832
+930.65	380.743
+930.6	374.202
+930.55	365.642
+930.5	368.135
+930.45	375.958
+930.4	357.337
+930.35	346.783
+930.3	349.038
+930.25	342.163
+930.2	345.482
+930.15	341.147
+930.1	338.922
+930.05	334.105
+930	334.885
+929.95	344.927
+929.9	327.652
+929.85	314.938
+929.8	331.447
+929.75	318.105
+929.7	325.69
+929.65	313.85
+929.6	310.395
+929.55	309.938
+929.5	317.598
+929.45	304.88
+929.4	317.932
+929.35	307.775
+929.3	319.3
+929.25	308.945
+929.2	305.452
+929.15	302.705
+929.1	299.802
+929.05	305.388
+929	304.435
+928.95	302.91
+928.9	300.492
+928.85	305.138
+928.8	301.183
+928.75	300.227
+928.7	300.368
+928.65	289.845
+928.6	285.45
+928.55	289.912
+928.5	284.333
+928.45	290.688
+928.4	296.44
+928.35	296.018
+928.3	285.643
+928.25	296.018
+928.2	285.928
+928.15	295.992
+928.1	293.673
+928.05	285.538
+928	283.445
+927.95	288.003
+927.9	278.243
+927.85	279.372
+927.8	280.647
+927.75	280.538
+927.7	283.522
+927.65	277.023
+927.6	275.622
+927.55	282.507
+927.5	285.457
+927.45	277.52
+927.4	287.355
+927.35	287.813
+927.3	280.325
+927.25	282.178
+927.2	284.692
+927.15	280.373
+927.1	267.595
+927.05	276.18
+927	271.847
+926.95	276.442
+926.9	279.908
+926.85	275.642
+926.8	281.272
+926.75	282.672
+926.7	278.665
+926.65	281.985
+926.6	278.173
+926.55	285.95
+926.5	280.307
+926.45	267.777
+926.4	273.442
+926.35	260.25
+926.3	271.318
+926.25	265.825
+926.2	278.372
+926.15	268.018
+926.1	266.772
+926.05	270.968
+926	270.198
+925.95	266.925
+925.9	275.817
+925.85	278.875
+925.8	282.555
+925.75	276.512
+925.7	278.778
+925.65	272.24
+925.6	272.668
+925.55	275.938
+925.5	272.165
+925.45	272.973
+925.4	269.265
+925.35	271.668
+925.3	278.088
+925.25	279.047
+925.2	268.287
+925.15	274.608
+925.1	269.713
+925.05	281.588
+925	282.817
+924.95	275.672
+924.9	281.887
+924.85	272.38
+924.8	275.61
+924.75	276.56
+924.7	272.075
+924.65	276.478
+924.6	273.093
+924.55	279.715
+924.5	274.778
+924.45	284.602
+924.4	260.293
+924.35	260.135
+924.3	270.068
+924.25	274.252
+924.2	272.545
+924.15	271.083
+924.1	277.848
+924.05	267.108
+924	268.378
+923.95	262.362
+923.9	272.757
+923.85	271.252
+923.8	265.288
+923.75	269.89
+923.7	271.703
+923.65	270.113
+923.6	268.995
+923.55	269.025
+923.5	260.132
+923.45	263.158
+923.4	274.912
+923.35	282.188
+923.3	274.285
+923.25	266.497
+923.2	266.957
+923.15	269.905
+923.1	271.262
+923.05	271.857
+923	281.672
+922.95	273.325
+922.9	265.737
+922.85	269.033
+922.8	262.358
+922.75	264.262
+922.7	265.683
+922.65	264.183
+922.6	269.028
+922.55	274.32
+922.5	263.17
+922.45	261.183
+922.4	270.497
+922.35	269.725
+922.3	274.243
+922.25	271.13
+922.2	268.36
+922.15	270.645
+922.1	278.443
+922.05	272.197
+922	266.837
+921.95	271.78
+921.9	275.803
+921.85	281.322
+921.8	277.583
+921.75	267.043
+921.7	270.492
+921.65	270.635
+921.6	272.665
+921.55	272.38
+921.5	271.723
+921.45	276.883
+921.4	277.528
+921.35	269.153
+921.3	268.192
+921.25	271.397
+921.2	271.44
+921.15	271.23
+921.1	271.117
+921.05	279.68
+921	274.165
+920.95	269.517
+920.9	269.717
+920.85	271.48
+920.8	276.007
+920.75	262.288
+920.7	261.967
+920.65	269.365
+920.6	273.088
+920.55	268.25
+920.5	272.732
+920.45	273.003
+920.4	267.513
+920.35	268.74
+920.3	277.203
+920.25	266.928
+920.2	266.883
+920.15	265.598
+920.1	261.572
+920.05	269.62
+920	266.267
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe3O4.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe3O4.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a5f3a4693efb0ae2804de2fb93466afc42774b86
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe3O4.txt
@@ -0,0 +1,1122 @@
+Fe2p Fe3O4
+7.500000e+002	1.891355e+004		
+7.499500e+002	1.891355e+004		
+7.499000e+002	1.906867e+004		
+7.498500e+002	1.906867e+004		
+7.498000e+002	1.918422e+004		
+7.497500e+002	1.918422e+004		
+7.497000e+002	1.911855e+004		
+7.496500e+002	1.911855e+004		
+7.496000e+002	1.921322e+004		
+7.495500e+002	1.921322e+004		
+7.495000e+002	1.931478e+004		
+7.494500e+002	1.931478e+004		
+7.494000e+002	1.914478e+004		
+7.493500e+002	1.914478e+004		
+7.493000e+002	1.907133e+004		
+7.492500e+002	1.907133e+004		
+7.492000e+002	1.914333e+004		
+7.491500e+002	1.914333e+004		
+7.491000e+002	1.909200e+004		
+7.490500e+002	1.909200e+004		
+7.490000e+002	1.927078e+004		
+7.489500e+002	1.927078e+004		
+7.489000e+002	1.931067e+004		
+7.488500e+002	1.931067e+004		
+7.488000e+002	1.933900e+004		
+7.487500e+002	1.933900e+004		
+7.487000e+002	1.930122e+004		
+7.486500e+002	1.930122e+004		
+7.486000e+002	1.929667e+004		
+7.485500e+002	1.929667e+004		
+7.485000e+002	1.943422e+004		
+7.484500e+002	1.943422e+004		
+7.484000e+002	1.946844e+004		
+7.483500e+002	1.946844e+004		
+7.483000e+002	1.944967e+004		
+7.482500e+002	1.944967e+004		
+7.482000e+002	1.952289e+004		
+7.481500e+002	1.952289e+004		
+7.481000e+002	1.949778e+004		
+7.480500e+002	1.949778e+004		
+7.480000e+002	1.935811e+004		
+7.479500e+002	1.935811e+004		
+7.479000e+002	1.926833e+004		
+7.478500e+002	1.926833e+004		
+7.478000e+002	1.937167e+004		
+7.477500e+002	1.937167e+004		
+7.477000e+002	1.948367e+004		
+7.476500e+002	1.948367e+004		
+7.476000e+002	1.953478e+004		
+7.475500e+002	1.953478e+004		
+7.475000e+002	1.952822e+004		
+7.474500e+002	1.952822e+004		
+7.474000e+002	1.955933e+004		
+7.473500e+002	1.955933e+004		
+7.473000e+002	1.950911e+004		
+7.472500e+002	1.950911e+004		
+7.472000e+002	1.947011e+004		
+7.471500e+002	1.947011e+004		
+7.471000e+002	1.942633e+004		
+7.470500e+002	1.942633e+004		
+7.470000e+002	1.963067e+004		
+7.469500e+002	1.963067e+004		
+7.469000e+002	1.971344e+004		
+7.468500e+002	1.971344e+004		
+7.468000e+002	1.952855e+004		
+7.467500e+002	1.952855e+004		
+7.467000e+002	1.943333e+004		
+7.466500e+002	1.943333e+004		
+7.466000e+002	1.965378e+004		
+7.465500e+002	1.965378e+004		
+7.465000e+002	1.967622e+004		
+7.464500e+002	1.967622e+004		
+7.464000e+002	1.970633e+004		
+7.463500e+002	1.970633e+004		
+7.463000e+002	1.963700e+004		
+7.462500e+002	1.963700e+004		
+7.462000e+002	1.965311e+004		
+7.461500e+002	1.965311e+004		
+7.461000e+002	1.962078e+004		
+7.460500e+002	1.962078e+004		
+7.460000e+002	1.969822e+004		
+7.459500e+002	1.969822e+004		
+7.459000e+002	1.971678e+004		
+7.458500e+002	1.971678e+004		
+7.458000e+002	1.976044e+004		
+7.457500e+002	1.976044e+004		
+7.457000e+002	1.986600e+004		
+7.456500e+002	1.986600e+004		
+7.456000e+002	1.989956e+004		
+7.455500e+002	1.989956e+004		
+7.455000e+002	2.004978e+004		
+7.454500e+002	2.004978e+004		
+7.454000e+002	1.999533e+004		
+7.453500e+002	1.999533e+004		
+7.453000e+002	2.004555e+004		
+7.452500e+002	2.004555e+004		
+7.452000e+002	2.009822e+004		
+7.451500e+002	2.009822e+004		
+7.451000e+002	2.016289e+004		
+7.450500e+002	2.016289e+004		
+7.450000e+002	2.013211e+004		
+7.449500e+002	2.013211e+004		
+7.449000e+002	2.006689e+004		
+7.448500e+002	2.006689e+004		
+7.448000e+002	2.013633e+004		
+7.447500e+002	2.013633e+004		
+7.447000e+002	2.036244e+004		
+7.446500e+002	2.036244e+004		
+7.446000e+002	2.024089e+004		
+7.445500e+002	2.024089e+004		
+7.445000e+002	2.037189e+004		
+7.444500e+002	2.037189e+004		
+7.444000e+002	2.029911e+004		
+7.443500e+002	2.029911e+004		
+7.443000e+002	2.034389e+004		
+7.442500e+002	2.034389e+004		
+7.442000e+002	2.038378e+004		
+7.441500e+002	2.038378e+004		
+7.441000e+002	2.063633e+004		
+7.440500e+002	2.063633e+004		
+7.440000e+002	2.060900e+004		
+7.439500e+002	2.060900e+004		
+7.439000e+002	2.033855e+004		
+7.438500e+002	2.033855e+004		
+7.438000e+002	2.049700e+004		
+7.437500e+002	2.049700e+004		
+7.437000e+002	2.056733e+004		
+7.436500e+002	2.056733e+004		
+7.436000e+002	2.058089e+004		
+7.435500e+002	2.058089e+004		
+7.435000e+002	2.057589e+004		
+7.434500e+002	2.057589e+004		
+7.434000e+002	2.070200e+004		
+7.433500e+002	2.070200e+004		
+7.433000e+002	2.076644e+004		
+7.432500e+002	2.076644e+004		
+7.432000e+002	2.065800e+004		
+7.431500e+002	2.065800e+004		
+7.431000e+002	2.072355e+004		
+7.430500e+002	2.072355e+004		
+7.430000e+002	2.048911e+004		
+7.429500e+002	2.048911e+004		
+7.429000e+002	2.054089e+004		
+7.428500e+002	2.054089e+004		
+7.428000e+002	2.070467e+004		
+7.427500e+002	2.070467e+004		
+7.427000e+002	2.058755e+004		
+7.426500e+002	2.058755e+004		
+7.426000e+002	2.047411e+004		
+7.425500e+002	2.047411e+004		
+7.425000e+002	2.039933e+004		
+7.424500e+002	2.039933e+004		
+7.424000e+002	2.053555e+004		
+7.423500e+002	2.053555e+004		
+7.423000e+002	2.055689e+004		
+7.422500e+002	2.055689e+004		
+7.422000e+002	2.061589e+004		
+7.421500e+002	2.061589e+004		
+7.421000e+002	2.048133e+004		
+7.420500e+002	2.048133e+004		
+7.420000e+002	2.043900e+004		
+7.419500e+002	2.043900e+004		
+7.419000e+002	2.028967e+004		
+7.418500e+002	2.028967e+004		
+7.418000e+002	2.012667e+004		
+7.417500e+002	2.012667e+004		
+7.417000e+002	2.041278e+004		
+7.416500e+002	2.041278e+004		
+7.416000e+002	2.038667e+004		
+7.415500e+002	2.038667e+004		
+7.415000e+002	2.032678e+004		
+7.414500e+002	2.032678e+004		
+7.414000e+002	2.032355e+004		
+7.413500e+002	2.032355e+004		
+7.413000e+002	2.015289e+004		
+7.412500e+002	2.015289e+004		
+7.412000e+002	2.019555e+004		
+7.411500e+002	2.019555e+004		
+7.411000e+002	2.011089e+004		
+7.410500e+002	2.011089e+004		
+7.410000e+002	2.008000e+004		
+7.409500e+002	2.008000e+004		
+7.409000e+002	2.011278e+004		
+7.408500e+002	2.011278e+004		
+7.408000e+002	2.006489e+004		
+7.407500e+002	2.006489e+004		
+7.407000e+002	2.006611e+004		
+7.406500e+002	2.006611e+004		
+7.406000e+002	2.020011e+004		
+7.405500e+002	2.020011e+004		
+7.405000e+002	2.006055e+004		
+7.404500e+002	2.006055e+004		
+7.404000e+002	1.993922e+004		
+7.403500e+002	1.993922e+004		
+7.403000e+002	2.008578e+004		
+7.402500e+002	2.008578e+004		
+7.402000e+002	2.007111e+004		
+7.401500e+002	2.007111e+004		
+7.401000e+002	2.003811e+004		
+7.400500e+002	2.003811e+004		
+7.400000e+002	2.018311e+004		
+7.399500e+002	2.018311e+004		
+7.399000e+002	2.010311e+004		
+7.398500e+002	2.010311e+004		
+7.398000e+002	2.004889e+004		
+7.397500e+002	2.004889e+004		
+7.397000e+002	2.003811e+004		
+7.396500e+002	2.003811e+004		
+7.396000e+002	2.017311e+004		
+7.395500e+002	2.017311e+004		
+7.395000e+002	2.018122e+004		
+7.394500e+002	2.018122e+004		
+7.394000e+002	2.020022e+004		
+7.393500e+002	2.020022e+004		
+7.393000e+002	2.023956e+004		
+7.392500e+002	2.023956e+004		
+7.392000e+002	2.007522e+004		
+7.391500e+002	2.007522e+004		
+7.391000e+002	2.022755e+004		
+7.390500e+002	2.022755e+004		
+7.390000e+002	2.022900e+004		
+7.389500e+002	2.022900e+004		
+7.389000e+002	2.041200e+004		
+7.388500e+002	2.041200e+004		
+7.388000e+002	2.020078e+004		
+7.387500e+002	2.020078e+004		
+7.387000e+002	2.034500e+004		
+7.386500e+002	2.034500e+004		
+7.386000e+002	2.041555e+004		
+7.385500e+002	2.041555e+004		
+7.385000e+002	2.025044e+004		
+7.384500e+002	2.025044e+004		
+7.384000e+002	2.031744e+004		
+7.383500e+002	2.031744e+004		
+7.383000e+002	2.051822e+004		
+7.382500e+002	2.051822e+004		
+7.382000e+002	2.045344e+004		
+7.381500e+002	2.045344e+004		
+7.381000e+002	2.050055e+004		
+7.380500e+002	2.050055e+004		
+7.380000e+002	2.032011e+004		
+7.379500e+002	2.032011e+004		
+7.379000e+002	2.052100e+004		
+7.378500e+002	2.052100e+004		
+7.378000e+002	2.067978e+004		
+7.377500e+002	2.067978e+004		
+7.377000e+002	2.061644e+004		
+7.376500e+002	2.061644e+004		
+7.376000e+002	2.081744e+004		
+7.375500e+002	2.081744e+004		
+7.375000e+002	2.083089e+004		
+7.374500e+002	2.083089e+004		
+7.374000e+002	2.082256e+004		
+7.373500e+002	2.082256e+004		
+7.373000e+002	2.071511e+004		
+7.372500e+002	2.071511e+004		
+7.372000e+002	2.074411e+004		
+7.371500e+002	2.074411e+004		
+7.371000e+002	2.089855e+004		
+7.370500e+002	2.089855e+004		
+7.370000e+002	2.102867e+004		
+7.369500e+002	2.102867e+004		
+7.369000e+002	2.095344e+004		
+7.368500e+002	2.095344e+004		
+7.368000e+002	2.100778e+004		
+7.367500e+002	2.100778e+004		
+7.367000e+002	2.111300e+004		
+7.366500e+002	2.111300e+004		
+7.366000e+002	2.119844e+004		
+7.365500e+002	2.119844e+004		
+7.365000e+002	2.143578e+004		
+7.364500e+002	2.143578e+004		
+7.364000e+002	2.144833e+004		
+7.363500e+002	2.144833e+004		
+7.363000e+002	2.132922e+004		
+7.362500e+002	2.132922e+004		
+7.362000e+002	2.163378e+004		
+7.361500e+002	2.163378e+004		
+7.361000e+002	2.165400e+004		
+7.360500e+002	2.165400e+004		
+7.360000e+002	2.153067e+004		
+7.359500e+002	2.153067e+004		
+7.359000e+002	2.149555e+004		
+7.358500e+002	2.149555e+004		
+7.358000e+002	2.167989e+004		
+7.357500e+002	2.167989e+004		
+7.357000e+002	2.165211e+004		
+7.356500e+002	2.165211e+004		
+7.356000e+002	2.187500e+004		
+7.355500e+002	2.187500e+004		
+7.355000e+002	2.188400e+004		
+7.354500e+002	2.188400e+004		
+7.354000e+002	2.182367e+004		
+7.353500e+002	2.182367e+004		
+7.353000e+002	2.206156e+004		
+7.352500e+002	2.206156e+004		
+7.352000e+002	2.205011e+004		
+7.351500e+002	2.205011e+004		
+7.351000e+002	2.205511e+004		
+7.350500e+002	2.205511e+004		
+7.350000e+002	2.219078e+004		
+7.349500e+002	2.219078e+004		
+7.349000e+002	2.221855e+004		
+7.348500e+002	2.221855e+004		
+7.348000e+002	2.230956e+004		
+7.347500e+002	2.230956e+004		
+7.347000e+002	2.235478e+004		
+7.346500e+002	2.235478e+004		
+7.346000e+002	2.238044e+004		
+7.345500e+002	2.238044e+004		
+7.345000e+002	2.246355e+004		
+7.344500e+002	2.246355e+004		
+7.344000e+002	2.249456e+004		
+7.343500e+002	2.249456e+004		
+7.343000e+002	2.251589e+004		
+7.342500e+002	2.251589e+004		
+7.342000e+002	2.263645e+004		
+7.341500e+002	2.263645e+004		
+7.341000e+002	2.286878e+004		
+7.340500e+002	2.286878e+004		
+7.340000e+002	2.282311e+004		
+7.339500e+002	2.282311e+004		
+7.339000e+002	2.289233e+004		
+7.338500e+002	2.289233e+004		
+7.338000e+002	2.304411e+004		
+7.337500e+002	2.304411e+004		
+7.337000e+002	2.293411e+004		
+7.336500e+002	2.293411e+004		
+7.336000e+002	2.305278e+004		
+7.335500e+002	2.305278e+004		
+7.335000e+002	2.325633e+004		
+7.334500e+002	2.325633e+004		
+7.334000e+002	2.317666e+004		
+7.333500e+002	2.317666e+004		
+7.333000e+002	2.329511e+004		
+7.332500e+002	2.329511e+004		
+7.332000e+002	2.317867e+004		
+7.331500e+002	2.317867e+004		
+7.331000e+002	2.330956e+004		
+7.330500e+002	2.330956e+004		
+7.330000e+002	2.339267e+004		
+7.329500e+002	2.339267e+004		
+7.329000e+002	2.344555e+004		
+7.328500e+002	2.344555e+004		
+7.328000e+002	2.350522e+004		
+7.327500e+002	2.350522e+004		
+7.327000e+002	2.353578e+004		
+7.326500e+002	2.353578e+004		
+7.326000e+002	2.376322e+004		
+7.325500e+002	2.376322e+004		
+7.325000e+002	2.390166e+004		
+7.324500e+002	2.390166e+004		
+7.324000e+002	2.370111e+004		
+7.323500e+002	2.370111e+004		
+7.323000e+002	2.385722e+004		
+7.322500e+002	2.385722e+004		
+7.322000e+002	2.386722e+004		
+7.321500e+002	2.386722e+004		
+7.321000e+002	2.412700e+004		
+7.320500e+002	2.412700e+004		
+7.320000e+002	2.405367e+004		
+7.319500e+002	2.405367e+004		
+7.319000e+002	2.416522e+004		
+7.318500e+002	2.416522e+004		
+7.318000e+002	2.404433e+004		
+7.317500e+002	2.404433e+004		
+7.317000e+002	2.443244e+004		
+7.316500e+002	2.443244e+004		
+7.316000e+002	2.434300e+004		
+7.315500e+002	2.434300e+004		
+7.315000e+002	2.429167e+004		
+7.314500e+002	2.429167e+004		
+7.314000e+002	2.448178e+004		
+7.313500e+002	2.448178e+004		
+7.313000e+002	2.465533e+004		
+7.312500e+002	2.465533e+004		
+7.312000e+002	2.470189e+004		
+7.311500e+002	2.470189e+004		
+7.311000e+002	2.484611e+004		
+7.310500e+002	2.484611e+004		
+7.310000e+002	2.485989e+004		
+7.309500e+002	2.485989e+004		
+7.309000e+002	2.479778e+004		
+7.308500e+002	2.479778e+004		
+7.308000e+002	2.498200e+004		
+7.307500e+002	2.498200e+004		
+7.307000e+002	2.513800e+004		
+7.306500e+002	2.513800e+004		
+7.306000e+002	2.519055e+004		
+7.305500e+002	2.519055e+004		
+7.305000e+002	2.544611e+004		
+7.304500e+002	2.544611e+004		
+7.304000e+002	2.545889e+004		
+7.303500e+002	2.545889e+004		
+7.303000e+002	2.569600e+004		
+7.302500e+002	2.569600e+004		
+7.302000e+002	2.559289e+004		
+7.301500e+002	2.559289e+004		
+7.301000e+002	2.568244e+004		
+7.300500e+002	2.568244e+004		
+7.300000e+002	2.568078e+004		
+7.299500e+002	2.568078e+004		
+7.299000e+002	2.578755e+004		
+7.298500e+002	2.578755e+004		
+7.298000e+002	2.575255e+004		
+7.297500e+002	2.575255e+004		
+7.297000e+002	2.585333e+004		
+7.296500e+002	2.585333e+004		
+7.296000e+002	2.594367e+004		
+7.295500e+002	2.594367e+004		
+7.295000e+002	2.576344e+004		
+7.294500e+002	2.576344e+004		
+7.294000e+002	2.589467e+004		
+7.293500e+002	2.589467e+004		
+7.293000e+002	2.604767e+004		
+7.292500e+002	2.604767e+004		
+7.292000e+002	2.594533e+004		
+7.291500e+002	2.594533e+004		
+7.291000e+002	2.595333e+004		
+7.290500e+002	2.595333e+004		
+7.290000e+002	2.607544e+004		
+7.289500e+002	2.607544e+004		
+7.289000e+002	2.606255e+004		
+7.288500e+002	2.606255e+004		
+7.288000e+002	2.601355e+004		
+7.287500e+002	2.601355e+004		
+7.287000e+002	2.594100e+004		
+7.286500e+002	2.594100e+004		
+7.286000e+002	2.616711e+004		
+7.285500e+002	2.616711e+004		
+7.285000e+002	2.611878e+004		
+7.284500e+002	2.611878e+004		
+7.284000e+002	2.608133e+004		
+7.283500e+002	2.608133e+004		
+7.283000e+002	2.634933e+004		
+7.282500e+002	2.634933e+004		
+7.282000e+002	2.621922e+004		
+7.281500e+002	2.621922e+004		
+7.281000e+002	2.640755e+004		
+7.280500e+002	2.640755e+004		
+7.280000e+002	2.656500e+004		
+7.279500e+002	2.656500e+004		
+7.279000e+002	2.606300e+004		
+7.278500e+002	2.606300e+004		
+7.278000e+002	2.617789e+004		
+7.277500e+002	2.617789e+004		
+7.277000e+002	2.623567e+004		
+7.276500e+002	2.623567e+004		
+7.276000e+002	2.642722e+004		
+7.275500e+002	2.642722e+004		
+7.275000e+002	2.664845e+004		
+7.274500e+002	2.664845e+004		
+7.274000e+002	2.649589e+004		
+7.273500e+002	2.649589e+004		
+7.273000e+002	2.663766e+004		
+7.272500e+002	2.663766e+004		
+7.272000e+002	2.664856e+004		
+7.271500e+002	2.664856e+004		
+7.271000e+002	2.696400e+004		
+7.270500e+002	2.696400e+004		
+7.270000e+002	2.702811e+004		
+7.269500e+002	2.702811e+004		
+7.269000e+002	2.695478e+004		
+7.268500e+002	2.695478e+004		
+7.268000e+002	2.730967e+004		
+7.267500e+002	2.730967e+004		
+7.267000e+002	2.719933e+004		
+7.266500e+002	2.719933e+004		
+7.266000e+002	2.739133e+004		
+7.265500e+002	2.739133e+004		
+7.265000e+002	2.768122e+004		
+7.264500e+002	2.768122e+004		
+7.264000e+002	2.777856e+004		
+7.263500e+002	2.777856e+004		
+7.263000e+002	2.796189e+004		
+7.262500e+002	2.796189e+004		
+7.262000e+002	2.790522e+004		
+7.261500e+002	2.790522e+004		
+7.261000e+002	2.813855e+004		
+7.260500e+002	2.813855e+004		
+7.260000e+002	2.821922e+004		
+7.259500e+002	2.821922e+004		
+7.259000e+002	2.845022e+004		
+7.258500e+002	2.845022e+004		
+7.258000e+002	2.862622e+004		
+7.257500e+002	2.862622e+004		
+7.257000e+002	2.867511e+004		
+7.256500e+002	2.867511e+004		
+7.256000e+002	2.884111e+004		
+7.255500e+002	2.884111e+004		
+7.255000e+002	2.907356e+004		
+7.254500e+002	2.907356e+004		
+7.254000e+002	2.919889e+004		
+7.253500e+002	2.919889e+004		
+7.253000e+002	2.957300e+004		
+7.252500e+002	2.957300e+004		
+7.252000e+002	2.978244e+004		
+7.251500e+002	2.978244e+004		
+7.251000e+002	2.993633e+004		
+7.250500e+002	2.993633e+004		
+7.250000e+002	3.014889e+004		
+7.249500e+002	3.014889e+004		
+7.249000e+002	3.040144e+004		
+7.248500e+002	3.040144e+004		
+7.248000e+002	3.037522e+004		
+7.247500e+002	3.037522e+004		
+7.247000e+002	3.067611e+004		
+7.246500e+002	3.067611e+004		
+7.246000e+002	3.089822e+004		
+7.245500e+002	3.089822e+004		
+7.245000e+002	3.106211e+004		
+7.244500e+002	3.106211e+004		
+7.244000e+002	3.126955e+004		
+7.243500e+002	3.126955e+004		
+7.243000e+002	3.129500e+004		
+7.242500e+002	3.129500e+004		
+7.242000e+002	3.134722e+004		
+7.241500e+002	3.134722e+004		
+7.241000e+002	3.153256e+004		
+7.240500e+002	3.153256e+004		
+7.240000e+002	3.181167e+004		
+7.239500e+002	3.181167e+004		
+7.239000e+002	3.211689e+004		
+7.238500e+002	3.211689e+004		
+7.238000e+002	3.223145e+004		
+7.237500e+002	3.223145e+004		
+7.237000e+002	3.232511e+004		
+7.236500e+002	3.232511e+004		
+7.236000e+002	3.241744e+004		
+7.235500e+002	3.241744e+004		
+7.235000e+002	3.251767e+004		
+7.234500e+002	3.251767e+004		
+7.234000e+002	3.257844e+004		
+7.233500e+002	3.257844e+004		
+7.233000e+002	3.271145e+004		
+7.232500e+002	3.271145e+004		
+7.232000e+002	3.266433e+004		
+7.231500e+002	3.266433e+004		
+7.231000e+002	3.277400e+004		
+7.230500e+002	3.277400e+004		
+7.230000e+002	3.273989e+004		
+7.229500e+002	3.273989e+004		
+7.229000e+002	3.269933e+004		
+7.228500e+002	3.269933e+004		
+7.228000e+002	3.248011e+004		
+7.227500e+002	3.248011e+004		
+7.227000e+002	3.235034e+004		
+7.226500e+002	3.235034e+004		
+7.226000e+002	3.206589e+004		
+7.225500e+002	3.206589e+004		
+7.225000e+002	3.185344e+004		
+7.224500e+002	3.185344e+004		
+7.224000e+002	3.171378e+004		
+7.223500e+002	3.171378e+004		
+7.223000e+002	3.134378e+004		
+7.222500e+002	3.134378e+004		
+7.222000e+002	3.111555e+004		
+7.221500e+002	3.111555e+004		
+7.221000e+002	3.085578e+004		
+7.220500e+002	3.085578e+004		
+7.220000e+002	3.054267e+004		
+7.219500e+002	3.054267e+004		
+7.219000e+002	2.995422e+004		
+7.218500e+002	2.995422e+004		
+7.218000e+002	2.963544e+004		
+7.217500e+002	2.963544e+004		
+7.217000e+002	2.907466e+004		
+7.216500e+002	2.907466e+004		
+7.216000e+002	2.856966e+004		
+7.215500e+002	2.856966e+004		
+7.215000e+002	2.798889e+004		
+7.214500e+002	2.798889e+004		
+7.214000e+002	2.724011e+004		
+7.213500e+002	2.724011e+004		
+7.213000e+002	2.669978e+004		
+7.212500e+002	2.669978e+004		
+7.212000e+002	2.628055e+004		
+7.211500e+002	2.628055e+004		
+7.211000e+002	2.582200e+004		
+7.210500e+002	2.582200e+004		
+7.210000e+002	2.529422e+004		
+7.209500e+002	2.529422e+004		
+7.209000e+002	2.478055e+004		
+7.208500e+002	2.478055e+004		
+7.208000e+002	2.450589e+004		
+7.207500e+002	2.450589e+004		
+7.207000e+002	2.402844e+004		
+7.206500e+002	2.402844e+004		
+7.206000e+002	2.369333e+004		
+7.205500e+002	2.369333e+004		
+7.205000e+002	2.360844e+004		
+7.204500e+002	2.360844e+004		
+7.204000e+002	2.342100e+004		
+7.203500e+002	2.342100e+004		
+7.203000e+002	2.304311e+004		
+7.202500e+002	2.304311e+004		
+7.202000e+002	2.303900e+004		
+7.201500e+002	2.303900e+004		
+7.201000e+002	2.297500e+004		
+7.200500e+002	2.297500e+004		
+7.200000e+002	2.280978e+004		
+7.199500e+002	2.280978e+004		
+7.199000e+002	2.256778e+004		
+7.198500e+002	2.256778e+004		
+7.198000e+002	2.267622e+004		
+7.197500e+002	2.267622e+004		
+7.197000e+002	2.255844e+004		
+7.196500e+002	2.255844e+004		
+7.196000e+002	2.245833e+004		
+7.195500e+002	2.245833e+004		
+7.195000e+002	2.233078e+004		
+7.194500e+002	2.233078e+004		
+7.194000e+002	2.225078e+004		
+7.193500e+002	2.225078e+004		
+7.193000e+002	2.228878e+004		
+7.192500e+002	2.228878e+004		
+7.192000e+002	2.229389e+004		
+7.191500e+002	2.229389e+004		
+7.191000e+002	2.207278e+004		
+7.190500e+002	2.207278e+004		
+7.190000e+002	2.215044e+004		
+7.189500e+002	2.215044e+004		
+7.189000e+002	2.217211e+004		
+7.188500e+002	2.217211e+004		
+7.188000e+002	2.210478e+004		
+7.187500e+002	2.210478e+004		
+7.187000e+002	2.206678e+004		
+7.186500e+002	2.206678e+004		
+7.186000e+002	2.205144e+004		
+7.185500e+002	2.205144e+004		
+7.185000e+002	2.208344e+004		
+7.184500e+002	2.208344e+004		
+7.184000e+002	2.214289e+004		
+7.183500e+002	2.214289e+004		
+7.183000e+002	2.225667e+004		
+7.182500e+002	2.225667e+004		
+7.182000e+002	2.230422e+004		
+7.181500e+002	2.230422e+004		
+7.181000e+002	2.239611e+004		
+7.180500e+002	2.239611e+004		
+7.180000e+002	2.222800e+004		
+7.179500e+002	2.222800e+004		
+7.179000e+002	2.247411e+004		
+7.178500e+002	2.247411e+004		
+7.178000e+002	2.266822e+004		
+7.177500e+002	2.266822e+004		
+7.177000e+002	2.258733e+004		
+7.176500e+002	2.258733e+004		
+7.176000e+002	2.261544e+004		
+7.175500e+002	2.261544e+004		
+7.175000e+002	2.283656e+004		
+7.174500e+002	2.283656e+004		
+7.174000e+002	2.286200e+004		
+7.173500e+002	2.286200e+004		
+7.173000e+002	2.291255e+004		
+7.172500e+002	2.291255e+004		
+7.172000e+002	2.295989e+004		
+7.171500e+002	2.295989e+004		
+7.171000e+002	2.304355e+004		
+7.170500e+002	2.304355e+004		
+7.170000e+002	2.322244e+004		
+7.169500e+002	2.322244e+004		
+7.169000e+002	2.325067e+004		
+7.168500e+002	2.325067e+004		
+7.168000e+002	2.341333e+004		
+7.167500e+002	2.341333e+004		
+7.167000e+002	2.375222e+004		
+7.166500e+002	2.375222e+004		
+7.166000e+002	2.354989e+004		
+7.165500e+002	2.354989e+004		
+7.165000e+002	2.342378e+004		
+7.164500e+002	2.342378e+004		
+7.164000e+002	2.360989e+004		
+7.163500e+002	2.360989e+004		
+7.163000e+002	2.375867e+004		
+7.162500e+002	2.375867e+004		
+7.162000e+002	2.376178e+004		
+7.161500e+002	2.376178e+004		
+7.161000e+002	2.391956e+004		
+7.160500e+002	2.391956e+004		
+7.160000e+002	2.407767e+004		
+7.159500e+002	2.407767e+004		
+7.159000e+002	2.393722e+004		
+7.158500e+002	2.393722e+004		
+7.158000e+002	2.407867e+004		
+7.157500e+002	2.407867e+004		
+7.157000e+002	2.419967e+004		
+7.156500e+002	2.419967e+004		
+7.156000e+002	2.416111e+004		
+7.155500e+002	2.416111e+004		
+7.155000e+002	2.428645e+004		
+7.154500e+002	2.428645e+004		
+7.154000e+002	2.434467e+004		
+7.153500e+002	2.434467e+004		
+7.153000e+002	2.447733e+004		
+7.152500e+002	2.447733e+004		
+7.152000e+002	2.440089e+004		
+7.151500e+002	2.440089e+004		
+7.151000e+002	2.450067e+004		
+7.150500e+002	2.450067e+004		
+7.150000e+002	2.474700e+004		
+7.149500e+002	2.474700e+004		
+7.149000e+002	2.468645e+004		
+7.148500e+002	2.468645e+004		
+7.148000e+002	2.480211e+004		
+7.147500e+002	2.480211e+004		
+7.147000e+002	2.495867e+004		
+7.146500e+002	2.495867e+004		
+7.146000e+002	2.521855e+004		
+7.145500e+002	2.521855e+004		
+7.145000e+002	2.525555e+004		
+7.144500e+002	2.525555e+004		
+7.144000e+002	2.536544e+004		
+7.143500e+002	2.536544e+004		
+7.143000e+002	2.563411e+004		
+7.142500e+002	2.563411e+004		
+7.142000e+002	2.571055e+004		
+7.141500e+002	2.571055e+004		
+7.141000e+002	2.592689e+004		
+7.140500e+002	2.592689e+004		
+7.140000e+002	2.607611e+004		
+7.139500e+002	2.607611e+004		
+7.139000e+002	2.631422e+004		
+7.138500e+002	2.631422e+004		
+7.138000e+002	2.682922e+004		
+7.137500e+002	2.682922e+004		
+7.137000e+002	2.705567e+004		
+7.136500e+002	2.705567e+004		
+7.136000e+002	2.713444e+004		
+7.135500e+002	2.713444e+004		
+7.135000e+002	2.755767e+004		
+7.134500e+002	2.755767e+004		
+7.134000e+002	2.764778e+004		
+7.133500e+002	2.764778e+004		
+7.133000e+002	2.793656e+004		
+7.132500e+002	2.793656e+004		
+7.132000e+002	2.827333e+004		
+7.131500e+002	2.827333e+004		
+7.131000e+002	2.841289e+004		
+7.130500e+002	2.841289e+004		
+7.130000e+002	2.873678e+004		
+7.129500e+002	2.873678e+004		
+7.129000e+002	2.898022e+004		
+7.128500e+002	2.898022e+004		
+7.128000e+002	2.941789e+004		
+7.127500e+002	2.941789e+004		
+7.127000e+002	2.994845e+004		
+7.126500e+002	2.994845e+004		
+7.126000e+002	3.029333e+004		
+7.125500e+002	3.029333e+004		
+7.125000e+002	3.041667e+004		
+7.124500e+002	3.041667e+004		
+7.124000e+002	3.043544e+004		
+7.123500e+002	3.043544e+004		
+7.123000e+002	3.073622e+004		
+7.122500e+002	3.073622e+004		
+7.122000e+002	3.120300e+004		
+7.121500e+002	3.120300e+004		
+7.121000e+002	3.154111e+004		
+7.120500e+002	3.154111e+004		
+7.120000e+002	3.179067e+004		
+7.119500e+002	3.179067e+004		
+7.119000e+002	3.220400e+004		
+7.118500e+002	3.220400e+004		
+7.118000e+002	3.255589e+004		
+7.117500e+002	3.255589e+004		
+7.117000e+002	3.290300e+004		
+7.116500e+002	3.290300e+004		
+7.116000e+002	3.330089e+004		
+7.115500e+002	3.330089e+004		
+7.115000e+002	3.347333e+004		
+7.114500e+002	3.347333e+004		
+7.114000e+002	3.376911e+004		
+7.113500e+002	3.376911e+004		
+7.113000e+002	3.426089e+004		
+7.112500e+002	3.426089e+004		
+7.112000e+002	3.452411e+004		
+7.111500e+002	3.452411e+004		
+7.111000e+002	3.496567e+004		
+7.110500e+002	3.496567e+004		
+7.110000e+002	3.508833e+004		
+7.109500e+002	3.508833e+004		
+7.109000e+002	3.547567e+004		
+7.108500e+002	3.547567e+004		
+7.108000e+002	3.551500e+004		
+7.107500e+002	3.551500e+004		
+7.107000e+002	3.547900e+004		
+7.106500e+002	3.547900e+004		
+7.106000e+002	3.567511e+004		
+7.105500e+002	3.567511e+004		
+7.105000e+002	3.586056e+004		
+7.104500e+002	3.586056e+004		
+7.104000e+002	3.594800e+004		
+7.103500e+002	3.594800e+004		
+7.103000e+002	3.608011e+004		
+7.102500e+002	3.608011e+004		
+7.102000e+002	3.607633e+004		
+7.101500e+002	3.607633e+004		
+7.101000e+002	3.616855e+004		
+7.100500e+002	3.616855e+004		
+7.100000e+002	3.581133e+004		
+7.099500e+002	3.581133e+004		
+7.099000e+002	3.583233e+004		
+7.098500e+002	3.583233e+004		
+7.098000e+002	3.535789e+004		
+7.097500e+002	3.535789e+004		
+7.097000e+002	3.486033e+004		
+7.096500e+002	3.486033e+004		
+7.096000e+002	3.458489e+004		
+7.095500e+002	3.458489e+004		
+7.095000e+002	3.412378e+004		
+7.094500e+002	3.412378e+004		
+7.094000e+002	3.368500e+004		
+7.093500e+002	3.368500e+004		
+7.093000e+002	3.309955e+004		
+7.092500e+002	3.309955e+004		
+7.092000e+002	3.270767e+004		
+7.091500e+002	3.270767e+004		
+7.091000e+002	3.218022e+004		
+7.090500e+002	3.218022e+004		
+7.090000e+002	3.160767e+004		
+7.089500e+002	3.160767e+004		
+7.089000e+002	3.085667e+004		
+7.088500e+002	3.085667e+004		
+7.088000e+002	3.015089e+004		
+7.087500e+002	3.015089e+004		
+7.087000e+002	2.939833e+004		
+7.086500e+002	2.939833e+004		
+7.086000e+002	2.836767e+004		
+7.085500e+002	2.836767e+004		
+7.085000e+002	2.742289e+004		
+7.084500e+002	2.742289e+004		
+7.084000e+002	2.617233e+004		
+7.083500e+002	2.617233e+004		
+7.083000e+002	2.466478e+004		
+7.082500e+002	2.466478e+004		
+7.082000e+002	2.328145e+004		
+7.081500e+002	2.328145e+004		
+7.081000e+002	2.173256e+004		
+7.080500e+002	2.173256e+004		
+7.080000e+002	1.993333e+004		
+7.079500e+002	1.993333e+004		
+7.079000e+002	1.824111e+004		
+7.078500e+002	1.824111e+004		
+7.078000e+002	1.649833e+004		
+7.077500e+002	1.649833e+004		
+7.077000e+002	1.478389e+004		
+7.076500e+002	1.478389e+004		
+7.076000e+002	1.331911e+004		
+7.075500e+002	1.331911e+004		
+7.075000e+002	1.189800e+004		
+7.074500e+002	1.189800e+004		
+7.074000e+002	1.080352e+004		
+7.073500e+002	1.080352e+004		
+7.073000e+002	9.919277e+003		
+7.072500e+002	9.919277e+003		
+7.072000e+002	9.132210e+003		
+7.071500e+002	9.132210e+003		
+7.071000e+002	8.503089e+003		
+7.070500e+002	8.503089e+003		
+7.070000e+002	8.018455e+003		
+7.069500e+002	8.018455e+003		
+7.069000e+002	7.595745e+003		
+7.068500e+002	7.595745e+003		
+7.068000e+002	7.256833e+003		
+7.067500e+002	7.256833e+003		
+7.067000e+002	6.929122e+003		
+7.066500e+002	6.929122e+003		
+7.066000e+002	6.688967e+003		
+7.065500e+002	6.688967e+003		
+7.065000e+002	6.419189e+003		
+7.064500e+002	6.419189e+003		
+7.064000e+002	6.186300e+003		
+7.063500e+002	6.186300e+003		
+7.063000e+002	5.862522e+003		
+7.062500e+002	5.862522e+003		
+7.062000e+002	5.822399e+003		
+7.061500e+002	5.822399e+003		
+7.061000e+002	5.690800e+003		
+7.060500e+002	5.690800e+003		
+7.060000e+002	5.552855e+003		
+7.059500e+002	5.552855e+003		
+7.059000e+002	5.332399e+003		
+7.058500e+002	5.332399e+003		
+7.058000e+002	5.295022e+003		
+7.057500e+002	5.295022e+003		
+7.057000e+002	5.250011e+003		
+7.056500e+002	5.250011e+003		
+7.056000e+002	5.238234e+003		
+7.055500e+002	5.238234e+003		
+7.055000e+002	5.101789e+003		
+7.054500e+002	5.101789e+003		
+7.054000e+002	5.067478e+003		
+7.053500e+002	5.067478e+003		
+7.053000e+002	5.018333e+003		
+7.052500e+002	5.018333e+003		
+7.052000e+002	4.985311e+003		
+7.051500e+002	4.985311e+003		
+7.051000e+002	4.982399e+003		
+7.050500e+002	4.982399e+003		
+7.050000e+002	4.936089e+003		
+7.049500e+002	4.936089e+003		
+7.049000e+002	4.923333e+003		
+7.048500e+002	4.923333e+003		
+7.048000e+002	4.901267e+003		
+7.047500e+002	4.901267e+003		
+7.047000e+002	4.929867e+003		
+7.046500e+002	4.929867e+003		
+7.046000e+002	4.869822e+003		
+7.045500e+002	4.869822e+003		
+7.045000e+002	4.898389e+003		
+7.044500e+002	4.898389e+003		
+7.044000e+002	4.746567e+003		
+7.043500e+002	4.746567e+003		
+7.043000e+002	4.797644e+003		
+7.042500e+002	4.797644e+003		
+7.042000e+002	4.835456e+003		
+7.041500e+002	4.835456e+003		
+7.041000e+002	4.819922e+003		
+7.040500e+002	4.819922e+003		
+7.040000e+002	4.802300e+003		
+7.039500e+002	4.802300e+003		
+7.039000e+002	4.704766e+003		
+7.038500e+002	4.704766e+003		
+7.038000e+002	4.659834e+003		
+7.037500e+002	4.659834e+003		
+7.037000e+002	4.696200e+003		
+7.036500e+002	4.696200e+003		
+7.036000e+002	4.703422e+003		
+7.035500e+002	4.703422e+003		
+7.035000e+002	4.732466e+003		
+7.034500e+002	4.732466e+003		
+7.034000e+002	4.803000e+003		
+7.033500e+002	4.803000e+003		
+7.033000e+002	4.796489e+003		
+7.032500e+002	4.796489e+003		
+7.032000e+002	4.655889e+003		
+7.031500e+002	4.655889e+003		
+7.031000e+002	4.606722e+003		
+7.030500e+002	4.606722e+003		
+7.030000e+002	4.620233e+003		
+7.029500e+002	4.620233e+003		
+7.029000e+002	4.705955e+003		
+7.028500e+002	4.705955e+003		
+7.028000e+002	4.644056e+003		
+7.027500e+002	4.644056e+003		
+7.027000e+002	4.661067e+003		
+7.026500e+002	4.661067e+003		
+7.026000e+002	4.588955e+003		
+7.025500e+002	4.588955e+003		
+7.025000e+002	4.543400e+003		
+7.024500e+002	4.543400e+003		
+7.024000e+002	4.613478e+003		
+7.023500e+002	4.613478e+003		
+7.023000e+002	4.592711e+003		
+7.022500e+002	4.592711e+003		
+7.022000e+002	4.576800e+003		
+7.021500e+002	4.576800e+003		
+7.021000e+002	4.609266e+003		
+7.020500e+002	4.609266e+003		
+7.020000e+002	4.644767e+003		
+7.019500e+002	4.644767e+003		
+7.019000e+002	4.573900e+003		
+7.018500e+002	4.573900e+003		
+7.018000e+002	4.589722e+003		
+7.017500e+002	4.589722e+003		
+7.017000e+002	4.534934e+003		
+7.016500e+002	4.534934e+003		
+7.016000e+002	4.622111e+003		
+7.015500e+002	4.622111e+003		
+7.015000e+002	4.616077e+003		
+7.014500e+002	4.616077e+003		
+7.014000e+002	4.549278e+003		
+7.013500e+002	4.549278e+003		
+7.013000e+002	4.524178e+003		
+7.012500e+002	4.524178e+003		
+7.012000e+002	4.576489e+003		
+7.011500e+002	4.576489e+003		
+7.011000e+002	4.558744e+003		
+7.010500e+002	4.558744e+003		
+7.010000e+002	4.581578e+003		
+7.009500e+002	4.581578e+003		
+7.009000e+002	4.581067e+003		
+7.008500e+002	4.581067e+003		
+7.008000e+002	4.553766e+003		
+7.007500e+002	4.553766e+003		
+7.007000e+002	4.537378e+003		
+7.006500e+002	4.537378e+003		
+7.006000e+002	4.535022e+003		
+7.005500e+002	4.535022e+003		
+7.005000e+002	4.473455e+003		
+7.004500e+002	4.473455e+003		
+7.004000e+002	4.539211e+003		
+7.003500e+002	4.539211e+003		
+7.003000e+002	4.545356e+003		
+7.002500e+002	4.545356e+003		
+7.002000e+002	4.541678e+003		
+7.001500e+002	4.541678e+003		
+7.001000e+002	4.600455e+003		
+7.000500e+002	4.600455e+003		
+7.000000e+002	4.525944e+003		
+6.999500e+002	4.525944e+003		
+6.999000e+002	4.469755e+003		
+6.998500e+002	4.469755e+003		
+6.998000e+002	4.545278e+003		
+6.997500e+002	4.545278e+003		
+6.997000e+002	4.564000e+003		
+6.996500e+002	4.564000e+003		
+6.996000e+002	4.558733e+003		
+6.995500e+002	4.558733e+003		
+6.995000e+002	4.590066e+003		
+6.994500e+002	4.590066e+003		
+6.994000e+002	4.478422e+003		
+6.993500e+002	4.478422e+003		
+6.993000e+002	4.586067e+003		
+6.992500e+002	4.586067e+003		
+6.992000e+002	4.560811e+003		
+6.991500e+002	4.560811e+003		
+6.991000e+002	4.570067e+003		
+6.990500e+002	4.570067e+003		
+6.990000e+002	4.577111e+003		
+6.989500e+002	4.577111e+003		
+6.989000e+002	4.586367e+003		
+6.988500e+002	4.586367e+003		
+6.988000e+002	4.514655e+003		
+6.987500e+002	4.514655e+003		
+6.987000e+002	4.536822e+003		
+6.986500e+002	4.536822e+003		
+6.986000e+002	4.547011e+003		
+6.985500e+002	4.547011e+003		
+6.985000e+002	4.506400e+003		
+6.984500e+002	4.506400e+003		
+6.984000e+002	4.541078e+003		
+6.983500e+002	4.541078e+003		
+6.983000e+002	4.534667e+003		
+6.982500e+002	4.534667e+003		
+6.982000e+002	4.569855e+003		
+6.981500e+002	4.569855e+003		
+6.981000e+002	4.577211e+003		
+6.980500e+002	4.577211e+003		
+6.980000e+002	4.554256e+003		
+6.979500e+002	4.554256e+003		
+6.979000e+002	4.523055e+003		
+6.978500e+002	4.523055e+003		
+6.978000e+002	4.455722e+003		
+6.977500e+002	4.455722e+003		
+6.977000e+002	4.509133e+003		
+6.976500e+002	4.509133e+003		
+6.976000e+002	4.535855e+003		
+6.975500e+002	4.535855e+003		
+6.975000e+002	4.494700e+003		
+6.974500e+002	4.494700e+003		
+6.974000e+002	4.545367e+003		
+6.973500e+002	4.545367e+003		
+6.973000e+002	4.527755e+003		
+6.972500e+002	4.527755e+003		
+6.972000e+002	4.594078e+003		
+6.971500e+002	4.594078e+003		
+6.971000e+002	4.583189e+003		
+6.970500e+002	4.583189e+003		
+6.970000e+002	4.474011e+003		
+6.969500e+002	4.474011e+003		
+6.969000e+002	4.514889e+003		
+6.968500e+002	4.514889e+003		
+6.968000e+002	4.502367e+003		
+6.967500e+002	4.502367e+003		
+6.967000e+002	4.561144e+003		
+6.966500e+002	4.561144e+003		
+6.966000e+002	4.499711e+003		
+6.965500e+002	4.499711e+003		
+6.965000e+002	4.543444e+003		
+6.964500e+002	4.543444e+003		
+6.964000e+002	4.537155e+003		
+6.963500e+002	4.537155e+003		
+6.963000e+002	4.510444e+003		
+6.962500e+002	4.510444e+003		
+6.962000e+002	4.594811e+003		
+6.961500e+002	4.594811e+003		
+6.961000e+002	4.590700e+003		
+6.960500e+002	4.590700e+003		
+6.960000e+002	4.555966e+003		
+6.959500e+002	4.555966e+003		
+6.959000e+002	4.523089e+003		
+6.958500e+002	4.523089e+003		
+6.958000e+002	4.494133e+003		
+6.957500e+002	4.494133e+003		
+6.957000e+002	4.519811e+003		
+6.956500e+002	4.519811e+003		
+6.956000e+002	4.493833e+003		
+6.955500e+002	4.493833e+003		
+6.955000e+002	4.503478e+003		
+6.954500e+002	4.503478e+003		
+6.954000e+002	4.448311e+003		
+6.953500e+002	4.448311e+003		
+6.953000e+002	4.533955e+003		
+6.952500e+002	4.533955e+003		
+6.952000e+002	4.534411e+003		
+6.951500e+002	4.534411e+003		
+6.951000e+002	4.562456e+003		
+6.950500e+002	4.562456e+003		
+6.950000e+002	4.525333e+003		
+6.949500e+002	4.525333e+003		
+6.949000e+002	4.427456e+003		
+6.948500e+002	4.427456e+003		
+6.948000e+002	4.530578e+003		
+6.947500e+002	4.530578e+003		
+6.947000e+002	4.541956e+003		
+6.946500e+002	4.541956e+003		
+6.946000e+002	4.548478e+003		
+6.945500e+002	4.548478e+003		
+6.945000e+002	4.553678e+003		
+6.944500e+002	4.553678e+003		
+6.944000e+002	4.525267e+003		
+6.943500e+002	4.525267e+003		
+6.943000e+002	4.603422e+003		
+6.942500e+002	4.603422e+003		
+6.942000e+002	4.506678e+003		
+6.941500e+002	4.506678e+003		
+6.941000e+002	4.488000e+003		
+6.940500e+002	4.488000e+003		
+6.940000e+002	4.462278e+003		
\ No newline at end of file
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe3O4_Mark_shifted.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe3O4_Mark_shifted.txt
new file mode 100644
index 0000000000000000000000000000000000000000..216bb2709cbfd76baec7fa43a5e7484e1440aacc
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe3O4_Mark_shifted.txt
@@ -0,0 +1,1122 @@
+Fe2p Fe3O4
+7.500000e+02 6.422620e+04
+7.499500e+02 6.451310e+04
+7.499000e+02 6.480000e+04
+7.498500e+02 6.481490e+04
+7.498000e+02 6.482980e+04
+7.497500e+02 6.462930e+04
+7.497000e+02 6.442880e+04
+7.496500e+02 6.463390e+04
+7.496000e+02 6.483900e+04
+7.495500e+02 6.487940e+04
+7.495000e+02 6.491980e+04
+7.494500e+02 6.469170e+04
+7.494000e+02 6.446360e+04
+7.493500e+02 6.447430e+04
+7.493000e+02 6.448500e+04
+7.492500e+02 6.443640e+04
+7.492000e+02 6.438780e+04
+7.491500e+02 6.466600e+04
+7.491000e+02 6.494420e+04
+7.490500e+02 6.489290e+04
+7.490000e+02 6.484160e+04
+7.489500e+02 6.464070e+04
+7.489000e+02 6.443980e+04
+7.488500e+02 6.494690e+04
+7.488000e+02 6.545400e+04
+7.487500e+02 6.546490e+04
+7.487000e+02 6.547580e+04
+7.486500e+02 6.547980e+04
+7.486000e+02 6.548380e+04
+7.485500e+02 6.553800e+04
+7.485000e+02 6.559220e+04
+7.484500e+02 6.561700e+04
+7.484000e+02 6.564180e+04
+7.483500e+02 6.545910e+04
+7.483000e+02 6.527640e+04
+7.482500e+02 6.519290e+04
+7.482000e+02 6.510940e+04
+7.481500e+02 6.510380e+04
+7.481000e+02 6.509820e+04
+7.480500e+02 6.509320e+04
+7.480000e+02 6.508820e+04
+7.479500e+02 6.507010e+04
+7.479000e+02 6.505200e+04
+7.478500e+02 6.534430e+04
+7.478000e+02 6.563660e+04
+7.477500e+02 6.587590e+04
+7.477000e+02 6.611520e+04
+7.476500e+02 6.574500e+04
+7.476000e+02 6.537480e+04
+7.475500e+02 6.541640e+04
+7.475000e+02 6.545800e+04
+7.474500e+02 6.564240e+04
+7.474000e+02 6.582680e+04
+7.473500e+02 6.574780e+04
+7.473000e+02 6.566880e+04
+7.472500e+02 6.584180e+04
+7.472000e+02 6.601480e+04
+7.471500e+02 6.610570e+04
+7.471000e+02 6.619660e+04
+7.470500e+02 6.632820e+04
+7.470000e+02 6.645980e+04
+7.469500e+02 6.622690e+04
+7.469000e+02 6.599400e+04
+7.468500e+02 6.620490e+04
+7.468000e+02 6.641580e+04
+7.467500e+02 6.663500e+04
+7.467000e+02 6.685420e+04
+7.466500e+02 6.699770e+04
+7.466000e+02 6.714120e+04
+7.465500e+02 6.714200e+04
+7.465000e+02 6.714280e+04
+7.464500e+02 6.703390e+04
+7.464000e+02 6.692500e+04
+7.463500e+02 6.720840e+04
+7.463000e+02 6.749180e+04
+7.462500e+02 6.745050e+04
+7.462000e+02 6.740920e+04
+7.461500e+02 6.736840e+04
+7.461000e+02 6.732760e+04
+7.460500e+02 6.766320e+04
+7.460000e+02 6.799880e+04
+7.459500e+02 6.811440e+04
+7.459000e+02 6.823000e+04
+7.458500e+02 6.822920e+04
+7.458000e+02 6.822840e+04
+7.457500e+02 6.835770e+04
+7.457000e+02 6.848700e+04
+7.456500e+02 6.848360e+04
+7.456000e+02 6.848020e+04
+7.455500e+02 6.864780e+04
+7.455000e+02 6.881540e+04
+7.454500e+02 6.899610e+04
+7.454000e+02 6.917680e+04
+7.453500e+02 6.907960e+04
+7.453000e+02 6.898240e+04
+7.452500e+02 6.917800e+04
+7.452000e+02 6.937360e+04
+7.451500e+02 6.947610e+04
+7.451000e+02 6.957860e+04
+7.450500e+02 6.986320e+04
+7.450000e+02 7.014780e+04
+7.449500e+02 7.032850e+04
+7.449000e+02 7.050920e+04
+7.448500e+02 7.034270e+04
+7.448000e+02 7.017620e+04
+7.447500e+02 7.023000e+04
+7.447000e+02 7.028380e+04
+7.446500e+02 7.039010e+04
+7.446000e+02 7.049640e+04
+7.445500e+02 7.053570e+04
+7.445000e+02 7.057500e+04
+7.444500e+02 7.079450e+04
+7.444000e+02 7.101400e+04
+7.443500e+02 7.071330e+04
+7.443000e+02 7.041260e+04
+7.442500e+02 7.065390e+04
+7.442000e+02 7.089520e+04
+7.441500e+02 7.111870e+04
+7.441000e+02 7.134220e+04
+7.440500e+02 7.147090e+04
+7.440000e+02 7.159960e+04
+7.439500e+02 7.143220e+04
+7.439000e+02 7.126480e+04
+7.438500e+02 7.143920e+04
+7.438000e+02 7.161360e+04
+7.437500e+02 7.138560e+04
+7.437000e+02 7.115760e+04
+7.436500e+02 7.106650e+04
+7.436000e+02 7.097540e+04
+7.435500e+02 7.118950e+04
+7.435000e+02 7.140360e+04
+7.434500e+02 7.151990e+04
+7.434000e+02 7.163620e+04
+7.433500e+02 7.115940e+04
+7.433000e+02 7.068260e+04
+7.432500e+02 7.104690e+04
+7.432000e+02 7.141120e+04
+7.431500e+02 7.150630e+04
+7.431000e+02 7.160140e+04
+7.430500e+02 7.142930e+04
+7.430000e+02 7.125720e+04
+7.429500e+02 7.116640e+04
+7.429000e+02 7.107560e+04
+7.428500e+02 7.114210e+04
+7.428000e+02 7.120860e+04
+7.427500e+02 7.104120e+04
+7.427000e+02 7.087380e+04
+7.426500e+02 7.084100e+04
+7.426000e+02 7.080820e+04
+7.425500e+02 7.092750e+04
+7.425000e+02 7.104680e+04
+7.424500e+02 7.055990e+04
+7.424000e+02 7.007300e+04
+7.423500e+02 7.021640e+04
+7.423000e+02 7.035980e+04
+7.422500e+02 7.043630e+04
+7.422000e+02 7.051280e+04
+7.421500e+02 7.044300e+04
+7.421000e+02 7.037320e+04
+7.420500e+02 7.021350e+04
+7.420000e+02 7.005380e+04
+7.419500e+02 6.987610e+04
+7.419000e+02 6.969840e+04
+7.418500e+02 6.984480e+04
+7.418000e+02 6.999120e+04
+7.417500e+02 6.992000e+04
+7.417000e+02 6.984880e+04
+7.416500e+02 6.979710e+04
+7.416000e+02 6.974540e+04
+7.415500e+02 6.932660e+04
+7.415000e+02 6.890780e+04
+7.414500e+02 6.913160e+04
+7.414000e+02 6.935540e+04
+7.413500e+02 6.947340e+04
+7.413000e+02 6.959140e+04
+7.412500e+02 6.943880e+04
+7.412000e+02 6.928620e+04
+7.411500e+02 6.885620e+04
+7.411000e+02 6.842620e+04
+7.410500e+02 6.880470e+04
+7.410000e+02 6.918320e+04
+7.409500e+02 6.905350e+04
+7.409000e+02 6.892380e+04
+7.408500e+02 6.911590e+04
+7.408000e+02 6.930800e+04
+7.407500e+02 6.911270e+04
+7.407000e+02 6.891740e+04
+7.406500e+02 6.901360e+04
+7.406000e+02 6.910980e+04
+7.405500e+02 6.920260e+04
+7.405000e+02 6.929540e+04
+7.404500e+02 6.923100e+04
+7.404000e+02 6.916660e+04
+7.403500e+02 6.910130e+04
+7.403000e+02 6.903600e+04
+7.402500e+02 6.912980e+04
+7.402000e+02 6.922360e+04
+7.401500e+02 6.921370e+04
+7.401000e+02 6.920380e+04
+7.400500e+02 6.941380e+04
+7.400000e+02 6.962380e+04
+7.399500e+02 6.959370e+04
+7.399000e+02 6.956360e+04
+7.398500e+02 6.946510e+04
+7.398000e+02 6.936660e+04
+7.397500e+02 6.944290e+04
+7.397000e+02 6.951920e+04
+7.396500e+02 6.976230e+04
+7.396000e+02 7.000540e+04
+7.395500e+02 6.999630e+04
+7.395000e+02 6.998720e+04
+7.394500e+02 7.022110e+04
+7.394000e+02 7.045500e+04
+7.393500e+02 7.018700e+04
+7.393000e+02 6.991900e+04
+7.392500e+02 7.017440e+04
+7.392000e+02 7.042980e+04
+7.391500e+02 7.049970e+04
+7.391000e+02 7.056960e+04
+7.390500e+02 7.070380e+04
+7.390000e+02 7.083800e+04
+7.389500e+02 7.087920e+04
+7.389000e+02 7.092040e+04
+7.388500e+02 7.080260e+04
+7.388000e+02 7.068480e+04
+7.387500e+02 7.068210e+04
+7.387000e+02 7.067940e+04
+7.386500e+02 7.130890e+04
+7.386000e+02 7.193840e+04
+7.385500e+02 7.182280e+04
+7.385000e+02 7.170720e+04
+7.384500e+02 7.148550e+04
+7.384000e+02 7.126380e+04
+7.383500e+02 7.129600e+04
+7.383000e+02 7.132820e+04
+7.382500e+02 7.164000e+04
+7.382000e+02 7.195180e+04
+7.381500e+02 7.197840e+04
+7.381000e+02 7.200500e+04
+7.380500e+02 7.226390e+04
+7.380000e+02 7.252280e+04
+7.379500e+02 7.249580e+04
+7.379000e+02 7.246880e+04
+7.378500e+02 7.264260e+04
+7.378000e+02 7.281640e+04
+7.377500e+02 7.296590e+04
+7.377000e+02 7.311540e+04
+7.376500e+02 7.316550e+04
+7.376000e+02 7.321560e+04
+7.375500e+02 7.353670e+04
+7.375000e+02 7.385780e+04
+7.374500e+02 7.385920e+04
+7.374000e+02 7.386060e+04
+7.373500e+02 7.372450e+04
+7.373000e+02 7.358840e+04
+7.372500e+02 7.419530e+04
+7.372000e+02 7.480220e+04
+7.371500e+02 7.485410e+04
+7.371000e+02 7.490600e+04
+7.370500e+02 7.480700e+04
+7.370000e+02 7.470800e+04
+7.369500e+02 7.516320e+04
+7.369000e+02 7.561840e+04
+7.368500e+02 7.545820e+04
+7.368000e+02 7.529800e+04
+7.367500e+02 7.541780e+04
+7.367000e+02 7.553760e+04
+7.366500e+02 7.553360e+04
+7.366000e+02 7.552960e+04
+7.365500e+02 7.591290e+04
+7.365000e+02 7.629620e+04
+7.364500e+02 7.628880e+04
+7.364000e+02 7.628140e+04
+7.363500e+02 7.637340e+04
+7.363000e+02 7.646540e+04
+7.362500e+02 7.672810e+04
+7.362000e+02 7.699080e+04
+7.361500e+02 7.700820e+04
+7.361000e+02 7.702560e+04
+7.360500e+02 7.716270e+04
+7.360000e+02 7.729980e+04
+7.359500e+02 7.758030e+04
+7.359000e+02 7.786080e+04
+7.358500e+02 7.789760e+04
+7.358000e+02 7.793440e+04
+7.357500e+02 7.813790e+04
+7.357000e+02 7.834140e+04
+7.356500e+02 7.863840e+04
+7.356000e+02 7.893540e+04
+7.355500e+02 7.927470e+04
+7.355000e+02 7.961400e+04
+7.354500e+02 7.962340e+04
+7.354000e+02 7.963280e+04
+7.353500e+02 7.952290e+04
+7.353000e+02 7.941300e+04
+7.352500e+02 7.956180e+04
+7.352000e+02 7.971060e+04
+7.351500e+02 7.981690e+04
+7.351000e+02 7.992320e+04
+7.350500e+02 8.004930e+04
+7.350000e+02 8.017540e+04
+7.349500e+02 8.065380e+04
+7.349000e+02 8.113220e+04
+7.348500e+02 8.100370e+04
+7.348000e+02 8.087520e+04
+7.347500e+02 8.079570e+04
+7.347000e+02 8.071620e+04
+7.346500e+02 8.097050e+04
+7.346000e+02 8.122480e+04
+7.345500e+02 8.111000e+04
+7.345000e+02 8.099520e+04
+7.344500e+02 8.154790e+04
+7.344000e+02 8.210060e+04
+7.343500e+02 8.218710e+04
+7.343000e+02 8.227360e+04
+7.342500e+02 8.205020e+04
+7.342000e+02 8.182680e+04
+7.341500e+02 8.212090e+04
+7.341000e+02 8.241500e+04
+7.340500e+02 8.232290e+04
+7.340000e+02 8.223080e+04
+7.339500e+02 8.218740e+04
+7.339000e+02 8.214400e+04
+7.338500e+02 8.226090e+04
+7.338000e+02 8.237780e+04
+7.337500e+02 8.255540e+04
+7.337000e+02 8.273300e+04
+7.336500e+02 8.275100e+04
+7.336000e+02 8.276900e+04
+7.335500e+02 8.301920e+04
+7.335000e+02 8.326940e+04
+7.334500e+02 8.321810e+04
+7.334000e+02 8.316680e+04
+7.333500e+02 8.310630e+04
+7.333000e+02 8.304580e+04
+7.332500e+02 8.299890e+04
+7.332000e+02 8.295200e+04
+7.331500e+02 8.318810e+04
+7.331000e+02 8.342420e+04
+7.330500e+02 8.375500e+04
+7.330000e+02 8.408580e+04
+7.329500e+02 8.441840e+04
+7.329000e+02 8.475100e+04
+7.328500e+02 8.454460e+04
+7.328000e+02 8.433820e+04
+7.327500e+02 8.435480e+04
+7.327000e+02 8.437140e+04
+7.326500e+02 8.432670e+04
+7.326000e+02 8.428200e+04
+7.325500e+02 8.427650e+04
+7.325000e+02 8.427100e+04
+7.324500e+02 8.452080e+04
+7.324000e+02 8.477060e+04
+7.323500e+02 8.495290e+04
+7.323000e+02 8.513520e+04
+7.322500e+02 8.524550e+04
+7.322000e+02 8.535580e+04
+7.321500e+02 8.581600e+04
+7.321000e+02 8.627620e+04
+7.320500e+02 8.616330e+04
+7.320000e+02 8.605040e+04
+7.319500e+02 8.641350e+04
+7.319000e+02 8.677660e+04
+7.318500e+02 8.655670e+04
+7.318000e+02 8.633680e+04
+7.317500e+02 8.636780e+04
+7.317000e+02 8.639880e+04
+7.316500e+02 8.642420e+04
+7.316000e+02 8.644960e+04
+7.315500e+02 8.674250e+04
+7.315000e+02 8.703540e+04
+7.314500e+02 8.739960e+04
+7.314000e+02 8.776380e+04
+7.313500e+02 8.759540e+04
+7.313000e+02 8.742700e+04
+7.312500e+02 8.774410e+04
+7.312000e+02 8.806120e+04
+7.311500e+02 8.835220e+04
+7.311000e+02 8.864320e+04
+7.310500e+02 8.835180e+04
+7.310000e+02 8.806040e+04
+7.309500e+02 8.823450e+04
+7.309000e+02 8.840860e+04
+7.308500e+02 8.861150e+04
+7.308000e+02 8.881440e+04
+7.307500e+02 8.867850e+04
+7.307000e+02 8.854260e+04
+7.306500e+02 8.880650e+04
+7.306000e+02 8.907040e+04
+7.305500e+02 8.926380e+04
+7.305000e+02 8.945720e+04
+7.304500e+02 8.971350e+04
+7.304000e+02 8.996980e+04
+7.303500e+02 8.997530e+04
+7.303000e+02 8.998080e+04
+7.302500e+02 9.037560e+04
+7.302000e+02 9.077040e+04
+7.301500e+02 9.091700e+04
+7.301000e+02 9.106360e+04
+7.300500e+02 9.079490e+04
+7.300000e+02 9.052620e+04
+7.299500e+02 9.086570e+04
+7.299000e+02 9.120520e+04
+7.298500e+02 9.122100e+04
+7.298000e+02 9.123680e+04
+7.297500e+02 9.159290e+04
+7.297000e+02 9.194900e+04
+7.296500e+02 9.208670e+04
+7.296000e+02 9.222440e+04
+7.295500e+02 9.227670e+04
+7.295000e+02 9.232900e+04
+7.294500e+02 9.223890e+04
+7.294000e+02 9.214880e+04
+7.293500e+02 9.240930e+04
+7.293000e+02 9.266980e+04
+7.292500e+02 9.304980e+04
+7.292000e+02 9.342980e+04
+7.291500e+02 9.361370e+04
+7.291000e+02 9.379760e+04
+7.290500e+02 9.379980e+04
+7.290000e+02 9.380200e+04
+7.289500e+02 9.384020e+04
+7.289000e+02 9.387840e+04
+7.288500e+02 9.400210e+04
+7.288000e+02 9.412580e+04
+7.287500e+02 9.442470e+04
+7.287000e+02 9.472360e+04
+7.286500e+02 9.474050e+04
+7.286000e+02 9.475740e+04
+7.285500e+02 9.500610e+04
+7.285000e+02 9.525480e+04
+7.284500e+02 9.561920e+04
+7.284000e+02 9.598360e+04
+7.283500e+02 9.587500e+04
+7.283000e+02 9.576640e+04
+7.282500e+02 9.621440e+04
+7.282000e+02 9.666240e+04
+7.281500e+02 9.688360e+04
+7.281000e+02 9.710480e+04
+7.280500e+02 9.757010e+04
+7.280000e+02 9.803540e+04
+7.279500e+02 9.816750e+04
+7.279000e+02 9.829960e+04
+7.278500e+02 9.856780e+04
+7.278000e+02 9.883600e+04
+7.277500e+02 9.929430e+04
+7.277000e+02 9.975260e+04
+7.276500e+02 9.957020e+04
+7.276000e+02 9.938780e+04
+7.275500e+02 9.998000e+04
+7.275000e+02 1.005722e+05
+7.274500e+02 1.006012e+05
+7.274000e+02 1.006302e+05
+7.273500e+02 1.012068e+05
+7.273000e+02 1.017834e+05
+7.272500e+02 1.018873e+05
+7.272000e+02 1.019912e+05
+7.271500e+02 1.022715e+05
+7.271000e+02 1.025518e+05
+7.270500e+02 1.031590e+05
+7.270000e+02 1.037662e+05
+7.269500e+02 1.038929e+05
+7.269000e+02 1.040196e+05
+7.268500e+02 1.044024e+05
+7.268000e+02 1.047852e+05
+7.267500e+02 1.051009e+05
+7.267000e+02 1.054166e+05
+7.266500e+02 1.055262e+05
+7.266000e+02 1.056358e+05
+7.265500e+02 1.060578e+05
+7.265000e+02 1.064798e+05
+7.264500e+02 1.061881e+05
+7.264000e+02 1.058964e+05
+7.263500e+02 1.065153e+05
+7.263000e+02 1.071342e+05
+7.262500e+02 1.077833e+05
+7.262000e+02 1.084324e+05
+7.261500e+02 1.086842e+05
+7.261000e+02 1.089360e+05
+7.260500e+02 1.087935e+05
+7.260000e+02 1.086510e+05
+7.259500e+02 1.086743e+05
+7.259000e+02 1.086976e+05
+7.258500e+02 1.093115e+05
+7.258000e+02 1.099254e+05
+7.257500e+02 1.100999e+05
+7.257000e+02 1.102744e+05
+7.256500e+02 1.102604e+05
+7.256000e+02 1.102464e+05
+7.255500e+02 1.105435e+05
+7.255000e+02 1.108406e+05
+7.254500e+02 1.111207e+05
+7.254000e+02 1.114008e+05
+7.253500e+02 1.117366e+05
+7.253000e+02 1.120724e+05
+7.252500e+02 1.120412e+05
+7.252000e+02 1.120100e+05
+7.251500e+02 1.120492e+05
+7.251000e+02 1.120884e+05
+7.250500e+02 1.118387e+05
+7.250000e+02 1.115890e+05
+7.249500e+02 1.118468e+05
+7.249000e+02 1.121046e+05
+7.248500e+02 1.120531e+05
+7.248000e+02 1.120016e+05
+7.247500e+02 1.115870e+05
+7.247000e+02 1.111724e+05
+7.246500e+02 1.110604e+05
+7.246000e+02 1.109484e+05
+7.245500e+02 1.113386e+05
+7.245000e+02 1.117288e+05
+7.244500e+02 1.113269e+05
+7.244000e+02 1.109250e+05
+7.243500e+02 1.111554e+05
+7.243000e+02 1.113858e+05
+7.242500e+02 1.109273e+05
+7.242000e+02 1.104688e+05
+7.241500e+02 1.100823e+05
+7.241000e+02 1.096958e+05
+7.240500e+02 1.092527e+05
+7.240000e+02 1.088096e+05
+7.239500e+02 1.085761e+05
+7.239000e+02 1.083426e+05
+7.238500e+02 1.081572e+05
+7.238000e+02 1.079718e+05
+7.237500e+02 1.078292e+05
+7.237000e+02 1.076866e+05
+7.236500e+02 1.069489e+05
+7.236000e+02 1.062112e+05
+7.235500e+02 1.059599e+05
+7.235000e+02 1.057086e+05
+7.234500e+02 1.052619e+05
+7.234000e+02 1.048152e+05
+7.233500e+02 1.042040e+05
+7.233000e+02 1.035928e+05
+7.232500e+02 1.032633e+05
+7.232000e+02 1.029338e+05
+7.231500e+02 1.021801e+05
+7.231000e+02 1.014264e+05
+7.230500e+02 1.009377e+05
+7.230000e+02 1.004490e+05
+7.229500e+02 9.985300e+04
+7.229000e+02 9.925700e+04
+7.228500e+02 9.833740e+04
+7.228000e+02 9.741780e+04
+7.227500e+02 9.729160e+04
+7.227000e+02 9.716540e+04
+7.226500e+02 9.688540e+04
+7.226000e+02 9.660540e+04
+7.225500e+02 9.604050e+04
+7.225000e+02 9.547560e+04
+7.224500e+02 9.462180e+04
+7.224000e+02 9.376800e+04
+7.223500e+02 9.319880e+04
+7.223000e+02 9.262960e+04
+7.222500e+02 9.179540e+04
+7.222000e+02 9.096120e+04
+7.221500e+02 9.019460e+04
+7.221000e+02 8.942800e+04
+7.220500e+02 8.908930e+04
+7.220000e+02 8.875060e+04
+7.219500e+02 8.794210e+04
+7.219000e+02 8.713360e+04
+7.218500e+02 8.680660e+04
+7.218000e+02 8.647960e+04
+7.217500e+02 8.618020e+04
+7.217000e+02 8.588080e+04
+7.216500e+02 8.539020e+04
+7.216000e+02 8.489960e+04
+7.215500e+02 8.448710e+04
+7.215000e+02 8.407460e+04
+7.214500e+02 8.364820e+04
+7.214000e+02 8.322180e+04
+7.213500e+02 8.310310e+04
+7.213000e+02 8.298440e+04
+7.212500e+02 8.274020e+04
+7.212000e+02 8.249600e+04
+7.211500e+02 8.211160e+04
+7.211000e+02 8.172720e+04
+7.210500e+02 8.165560e+04
+7.210000e+02 8.158400e+04
+7.209500e+02 8.150580e+04
+7.209000e+02 8.142760e+04
+7.208500e+02 8.139010e+04
+7.208000e+02 8.135260e+04
+7.207500e+02 8.110050e+04
+7.207000e+02 8.084840e+04
+7.206500e+02 8.091390e+04
+7.206000e+02 8.097940e+04
+7.205500e+02 8.080810e+04
+7.205000e+02 8.063680e+04
+7.204500e+02 8.026910e+04
+7.204000e+02 7.990140e+04
+7.203500e+02 7.999380e+04
+7.203000e+02 8.008620e+04
+7.202500e+02 8.005220e+04
+7.202000e+02 8.001820e+04
+7.201500e+02 7.987120e+04
+7.201000e+02 7.972420e+04
+7.200500e+02 7.956730e+04
+7.200000e+02 7.941040e+04
+7.199500e+02 7.931510e+04
+7.199000e+02 7.921980e+04
+7.198500e+02 7.908610e+04
+7.198000e+02 7.895240e+04
+7.197500e+02 7.880860e+04
+7.197000e+02 7.866480e+04
+7.196500e+02 7.885410e+04
+7.196000e+02 7.904340e+04
+7.195500e+02 7.919470e+04
+7.195000e+02 7.934600e+04
+7.194500e+02 7.906010e+04
+7.194000e+02 7.877420e+04
+7.193500e+02 7.876670e+04
+7.193000e+02 7.875920e+04
+7.192500e+02 7.874090e+04
+7.192000e+02 7.872260e+04
+7.191500e+02 7.902280e+04
+7.191000e+02 7.932300e+04
+7.190500e+02 7.899140e+04
+7.190000e+02 7.865980e+04
+7.189500e+02 7.873720e+04
+7.189000e+02 7.881460e+04
+7.188500e+02 7.863890e+04
+7.188000e+02 7.846320e+04
+7.187500e+02 7.835930e+04
+7.187000e+02 7.825540e+04
+7.186500e+02 7.819050e+04
+7.186000e+02 7.812560e+04
+7.185500e+02 7.822950e+04
+7.185000e+02 7.833340e+04
+7.184500e+02 7.843850e+04
+7.184000e+02 7.854360e+04
+7.183500e+02 7.846020e+04
+7.183000e+02 7.837680e+04
+7.182500e+02 7.833380e+04
+7.182000e+02 7.829080e+04
+7.181500e+02 7.834750e+04
+7.181000e+02 7.840420e+04
+7.180500e+02 7.848130e+04
+7.180000e+02 7.855840e+04
+7.179500e+02 7.867760e+04
+7.179000e+02 7.879680e+04
+7.178500e+02 7.871460e+04
+7.178000e+02 7.863240e+04
+7.177500e+02 7.898170e+04
+7.177000e+02 7.933100e+04
+7.176500e+02 7.918550e+04
+7.176000e+02 7.904000e+04
+7.175500e+02 7.917500e+04
+7.175000e+02 7.931000e+04
+7.174500e+02 7.955580e+04
+7.174000e+02 7.980160e+04
+7.173500e+02 7.986770e+04
+7.173000e+02 7.993380e+04
+7.172500e+02 8.018140e+04
+7.172000e+02 8.042900e+04
+7.171500e+02 8.033440e+04
+7.171000e+02 8.023980e+04
+7.170500e+02 8.059450e+04
+7.170000e+02 8.094920e+04
+7.169500e+02 8.092790e+04
+7.169000e+02 8.090660e+04
+7.168500e+02 8.104930e+04
+7.168000e+02 8.119200e+04
+7.167500e+02 8.142630e+04
+7.167000e+02 8.166060e+04
+7.166500e+02 8.172410e+04
+7.166000e+02 8.178760e+04
+7.165500e+02 8.195230e+04
+7.165000e+02 8.211700e+04
+7.164500e+02 8.227330e+04
+7.164000e+02 8.242960e+04
+7.163500e+02 8.246490e+04
+7.163000e+02 8.250020e+04
+7.162500e+02 8.274310e+04
+7.162000e+02 8.298600e+04
+7.161500e+02 8.349840e+04
+7.161000e+02 8.401080e+04
+7.160500e+02 8.405040e+04
+7.160000e+02 8.409000e+04
+7.159500e+02 8.424910e+04
+7.159000e+02 8.440820e+04
+7.158500e+02 8.486390e+04
+7.158000e+02 8.531960e+04
+7.157500e+02 8.546940e+04
+7.157000e+02 8.561920e+04
+7.156500e+02 8.573700e+04
+7.156000e+02 8.585480e+04
+7.155500e+02 8.635170e+04
+7.155000e+02 8.684860e+04
+7.154500e+02 8.746760e+04
+7.154000e+02 8.808660e+04
+7.153500e+02 8.839620e+04
+7.153000e+02 8.870580e+04
+7.152500e+02 8.899320e+04
+7.152000e+02 8.928060e+04
+7.151500e+02 8.961890e+04
+7.151000e+02 8.995720e+04
+7.150500e+02 9.062660e+04
+7.150000e+02 9.129600e+04
+7.149500e+02 9.188210e+04
+7.149000e+02 9.246820e+04
+7.148500e+02 9.266120e+04
+7.148000e+02 9.285420e+04
+7.147500e+02 9.362980e+04
+7.147000e+02 9.440540e+04
+7.146500e+02 9.478120e+04
+7.146000e+02 9.515700e+04
+7.145500e+02 9.582290e+04
+7.145000e+02 9.648880e+04
+7.144500e+02 9.686660e+04
+7.144000e+02 9.724440e+04
+7.143500e+02 9.768320e+04
+7.143000e+02 9.812200e+04
+7.142500e+02 9.877980e+04
+7.142000e+02 9.943760e+04
+7.141500e+02 9.983660e+04
+7.141000e+02 1.002356e+05
+7.140500e+02 1.010047e+05
+7.140000e+02 1.017738e+05
+7.139500e+02 1.020920e+05
+7.139000e+02 1.024102e+05
+7.138500e+02 1.032594e+05
+7.138000e+02 1.041086e+05
+7.137500e+02 1.049765e+05
+7.137000e+02 1.058444e+05
+7.136500e+02 1.063804e+05
+7.136000e+02 1.069164e+05
+7.135500e+02 1.073815e+05
+7.135000e+02 1.078466e+05
+7.134500e+02 1.084772e+05
+7.134000e+02 1.091078e+05
+7.133500e+02 1.097762e+05
+7.133000e+02 1.104446e+05
+7.132500e+02 1.110878e+05
+7.132000e+02 1.117310e+05
+7.131500e+02 1.124868e+05
+7.131000e+02 1.132426e+05
+7.130500e+02 1.142664e+05
+7.130000e+02 1.152902e+05
+7.129500e+02 1.156072e+05
+7.129000e+02 1.159242e+05
+7.128500e+02 1.165035e+05
+7.128000e+02 1.170828e+05
+7.127500e+02 1.175639e+05
+7.127000e+02 1.180450e+05
+7.126500e+02 1.185303e+05
+7.126000e+02 1.190156e+05
+7.125500e+02 1.199341e+05
+7.125000e+02 1.208526e+05
+7.124500e+02 1.212151e+05
+7.124000e+02 1.215776e+05
+7.123500e+02 1.218851e+05
+7.123000e+02 1.221926e+05
+7.122500e+02 1.224357e+05
+7.122000e+02 1.226788e+05
+7.121500e+02 1.230093e+05
+7.121000e+02 1.233398e+05
+7.120500e+02 1.234487e+05
+7.120000e+02 1.235576e+05
+7.119500e+02 1.238031e+05
+7.119000e+02 1.240486e+05
+7.118500e+02 1.243432e+05
+7.118000e+02 1.246378e+05
+7.117500e+02 1.245736e+05
+7.117000e+02 1.245094e+05
+7.116500e+02 1.238734e+05
+7.116000e+02 1.232374e+05
+7.115500e+02 1.231370e+05
+7.115000e+02 1.230366e+05
+7.114500e+02 1.230874e+05
+7.114000e+02 1.231382e+05
+7.113500e+02 1.226941e+05
+7.113000e+02 1.222500e+05
+7.112500e+02 1.213175e+05
+7.112000e+02 1.203850e+05
+7.111500e+02 1.193811e+05
+7.111000e+02 1.183772e+05
+7.110500e+02 1.177741e+05
+7.110000e+02 1.171710e+05
+7.109500e+02 1.164330e+05
+7.109000e+02 1.156950e+05
+7.108500e+02 1.144974e+05
+7.108000e+02 1.132998e+05
+7.107500e+02 1.124013e+05
+7.107000e+02 1.115028e+05
+7.106500e+02 1.101898e+05
+7.106000e+02 1.088768e+05
+7.105500e+02 1.078008e+05
+7.105000e+02 1.067248e+05
+7.104500e+02 1.051746e+05
+7.104000e+02 1.036244e+05
+7.103500e+02 1.016017e+05
+7.103000e+02 9.957900e+04
+7.102500e+02 9.844160e+04
+7.102000e+02 9.730420e+04
+7.101500e+02 9.589350e+04
+7.101000e+02 9.448280e+04
+7.100500e+02 9.297690e+04
+7.100000e+02 9.147100e+04
+7.099500e+02 9.020920e+04
+7.099000e+02 8.894740e+04
+7.098500e+02 8.712890e+04
+7.098000e+02 8.531040e+04
+7.097500e+02 8.350400e+04
+7.097000e+02 8.169760e+04
+7.096500e+02 8.045510e+04
+7.096000e+02 7.921260e+04
+7.095500e+02 7.759120e+04
+7.095000e+02 7.596980e+04
+7.094500e+02 7.433680e+04
+7.094000e+02 7.270380e+04
+7.093500e+02 7.108840e+04
+7.093000e+02 6.947300e+04
+7.092500e+02 6.758510e+04
+7.092000e+02 6.569720e+04
+7.091500e+02 6.402920e+04
+7.091000e+02 6.236120e+04
+7.090500e+02 6.047590e+04
+7.090000e+02 5.859060e+04
+7.089500e+02 5.689360e+04
+7.089000e+02 5.519660e+04
+7.088500e+02 5.318910e+04
+7.088000e+02 5.118160e+04
+7.087500e+02 4.970460e+04
+7.087000e+02 4.822760e+04
+7.086500e+02 4.637900e+04
+7.086000e+02 4.453040e+04
+7.085500e+02 4.309080e+04
+7.085000e+02 4.165120e+04
+7.084500e+02 4.019820e+04
+7.084000e+02 3.874520e+04
+7.083500e+02 3.684840e+04
+7.083000e+02 3.495160e+04
+7.082500e+02 3.365880e+04
+7.082000e+02 3.236600e+04
+7.081500e+02 3.112790e+04
+7.081000e+02 2.988980e+04
+7.080500e+02 2.905110e+04
+7.080000e+02 2.821240e+04
+7.079500e+02 2.692740e+04
+7.079000e+02 2.564240e+04
+7.078500e+02 2.490400e+04
+7.078000e+02 2.416560e+04
+7.077500e+02 2.346620e+04
+7.077000e+02 2.276680e+04
+7.076500e+02 2.212380e+04
+7.076000e+02 2.148080e+04
+7.075500e+02 2.095170e+04
+7.075000e+02 2.042260e+04
+7.074500e+02 1.987715e+04
+7.074000e+02 1.933170e+04
+7.073500e+02 1.902296e+04
+7.073000e+02 1.871422e+04
+7.072500e+02 1.828517e+04
+7.072000e+02 1.785612e+04
+7.071500e+02 1.762921e+04
+7.071000e+02 1.740230e+04
+7.070500e+02 1.730189e+04
+7.070000e+02 1.720148e+04
+7.069500e+02 1.699166e+04
+7.069000e+02 1.678184e+04
+7.068500e+02 1.664022e+04
+7.068000e+02 1.649860e+04
+7.067500e+02 1.618071e+04
+7.067000e+02 1.586282e+04
+7.066500e+02 1.592906e+04
+7.066000e+02 1.599530e+04
+7.065500e+02 1.583431e+04
+7.065000e+02 1.567332e+04
+7.064500e+02 1.558125e+04
+7.064000e+02 1.548918e+04
+7.063500e+02 1.535918e+04
+7.063000e+02 1.522918e+04
+7.062500e+02 1.520849e+04
+7.062000e+02 1.518780e+04
+7.061500e+02 1.504014e+04
+7.061000e+02 1.489248e+04
+7.060500e+02 1.485882e+04
+7.060000e+02 1.482516e+04
+7.059500e+02 1.476571e+04
+7.059000e+02 1.470626e+04
+7.058500e+02 1.462634e+04
+7.058000e+02 1.454642e+04
+7.057500e+02 1.468308e+04
+7.057000e+02 1.481974e+04
+7.056500e+02 1.465913e+04
+7.056000e+02 1.449852e+04
+7.055500e+02 1.446722e+04
+7.055000e+02 1.443592e+04
+7.054500e+02 1.440468e+04
+7.054000e+02 1.437344e+04
+7.053500e+02 1.433662e+04
+7.053000e+02 1.429980e+04
+7.052500e+02 1.431139e+04
+7.052000e+02 1.432298e+04
+7.051500e+02 1.404248e+04
+7.051000e+02 1.376198e+04
+7.050500e+02 1.387725e+04
+7.050000e+02 1.399252e+04
+7.049500e+02 1.397795e+04
+7.049000e+02 1.396338e+04
+7.048500e+02 1.397371e+04
+7.048000e+02 1.398404e+04
+7.047500e+02 1.398268e+04
+7.047000e+02 1.398132e+04
+7.046500e+02 1.408938e+04
+7.046000e+02 1.419744e+04
+7.045500e+02 1.412100e+04
+7.045000e+02 1.404456e+04
+7.044500e+02 1.386145e+04
+7.044000e+02 1.367834e+04
+7.043500e+02 1.365572e+04
+7.043000e+02 1.363310e+04
+7.042500e+02 1.365079e+04
+7.042000e+02 1.366848e+04
+7.041500e+02 1.368956e+04
+7.041000e+02 1.371064e+04
+7.040500e+02 1.369324e+04
+7.040000e+02 1.367584e+04
+7.039500e+02 1.372972e+04
+7.039000e+02 1.378360e+04
+7.038500e+02 1.371133e+04
+7.038000e+02 1.363906e+04
+7.037500e+02 1.373424e+04
+7.037000e+02 1.382942e+04
+7.036500e+02 1.373245e+04
+7.036000e+02 1.363548e+04
+7.035500e+02 1.361710e+04
+7.035000e+02 1.359872e+04
+7.034500e+02 1.363867e+04
+7.034000e+02 1.367862e+04
+7.033500e+02 1.352976e+04
+7.033000e+02 1.338090e+04
+7.032500e+02 1.347655e+04
+7.032000e+02 1.357220e+04
+7.031500e+02 1.348499e+04
+7.031000e+02 1.339778e+04
+7.030500e+02 1.346804e+04
+7.030000e+02 1.353830e+04
+7.029500e+02 1.356230e+04
+7.029000e+02 1.358630e+04
+7.028500e+02 1.363342e+04
+7.028000e+02 1.368054e+04
+7.027500e+02 1.370696e+04
+7.027000e+02 1.373338e+04
+7.026500e+02 1.374989e+04
+7.026000e+02 1.376640e+04
+7.025500e+02 1.381360e+04
+7.025000e+02 1.386080e+04
+7.024500e+02 1.367518e+04
+7.024000e+02 1.348956e+04
+7.023500e+02 1.360148e+04
+7.023000e+02 1.371340e+04
+7.022500e+02 1.369530e+04
+7.022000e+02 1.367720e+04
+7.021500e+02 1.359624e+04
+7.021000e+02 1.351528e+04
+7.020500e+02 1.348459e+04
+7.020000e+02 1.345390e+04
+7.019500e+02 1.342643e+04
+7.019000e+02 1.339896e+04
+7.018500e+02 1.346381e+04
+7.018000e+02 1.352866e+04
+7.017500e+02 1.340781e+04
+7.017000e+02 1.328696e+04
+7.016500e+02 1.333649e+04
+7.016000e+02 1.338602e+04
+7.015500e+02 1.336277e+04
+7.015000e+02 1.333952e+04
+7.014500e+02 1.329193e+04
+7.014000e+02 1.324434e+04
+7.013500e+02 1.329340e+04
+7.013000e+02 1.334246e+04
+7.012500e+02 1.329641e+04
+7.012000e+02 1.325036e+04
+7.011500e+02 1.329224e+04
+7.011000e+02 1.333412e+04
+7.010500e+02 1.330163e+04
+7.010000e+02 1.326914e+04
+7.009500e+02 1.327024e+04
+7.009000e+02 1.327134e+04
+7.008500e+02 1.330011e+04
+7.008000e+02 1.332888e+04
+7.007500e+02 1.328904e+04
+7.007000e+02 1.324920e+04
+7.006500e+02 1.325055e+04
+7.006000e+02 1.325190e+04
+7.005500e+02 1.323434e+04
+7.005000e+02 1.321678e+04
+7.004500e+02 1.331766e+04
+7.004000e+02 1.341854e+04
+7.003500e+02 1.347466e+04
+7.003000e+02 1.353078e+04
+7.002500e+02 1.343424e+04
+7.002000e+02 1.333770e+04
+7.001500e+02 1.334602e+04
+7.001000e+02 1.335434e+04
+7.000500e+02 1.322668e+04
+7.000000e+02 1.309902e+04
+6.999500e+02 1.309902e+04
+6.999000e+02 1.309902e+04
+6.998500e+02 1.309902e+04
+6.998000e+02 1.309902e+04
+6.997500e+02 1.309902e+04
+6.997000e+02 1.309902e+04
+6.996500e+02 1.309902e+04
+6.996000e+02 1.309902e+04
+6.995500e+02 1.309902e+04
+6.995000e+02 1.309902e+04
+6.994500e+02 1.309902e+04
+6.994000e+02 1.309902e+04
+6.993500e+02 1.309902e+04
+6.993000e+02 1.309902e+04
+6.992500e+02 1.309902e+04
+6.992000e+02 1.309902e+04
+6.991500e+02 1.309902e+04
+6.991000e+02 1.309902e+04
+6.990500e+02 1.309902e+04
+6.990000e+02 1.309902e+04
+6.989500e+02 1.309902e+04
+6.989000e+02 1.309902e+04
+6.988500e+02 1.309902e+04
+6.988000e+02 1.309902e+04
+6.987500e+02 1.309902e+04
+6.987000e+02 1.309902e+04
+6.986500e+02 1.309902e+04
+6.986000e+02 1.309902e+04
+6.985500e+02 1.309902e+04
+6.985000e+02 1.309902e+04
+6.984500e+02 1.309902e+04
+6.984000e+02 1.309902e+04
+6.983500e+02 1.309902e+04
+6.983000e+02 1.309902e+04
+6.982500e+02 1.309902e+04
+6.982000e+02 1.309902e+04
+6.981500e+02 1.309902e+04
+6.981000e+02 1.309902e+04
+6.980500e+02 1.309902e+04
+6.980000e+02 1.309902e+04
+6.979500e+02 1.309902e+04
+6.979000e+02 1.309902e+04
+6.978500e+02 1.309902e+04
+6.978000e+02 1.309902e+04
+6.977500e+02 1.309902e+04
+6.977000e+02 1.309902e+04
+6.976500e+02 1.309902e+04
+6.976000e+02 1.309902e+04
+6.975500e+02 1.309902e+04
+6.975000e+02 1.309902e+04
+6.974500e+02 1.309902e+04
+6.974000e+02 1.309902e+04
+6.973500e+02 1.309902e+04
+6.973000e+02 1.309902e+04
+6.972500e+02 1.309902e+04
+6.972000e+02 1.309902e+04
+6.971500e+02 1.309902e+04
+6.971000e+02 1.309902e+04
+6.970500e+02 1.309902e+04
+6.970000e+02 1.309902e+04
+6.969500e+02 1.309902e+04
+6.969000e+02 1.309902e+04
+6.968500e+02 1.309902e+04
+6.968000e+02 1.309902e+04
+6.967500e+02 1.309902e+04
+6.967000e+02 1.309902e+04
+6.966500e+02 1.309902e+04
+6.966000e+02 1.309902e+04
+6.965500e+02 1.309902e+04
+6.965000e+02 1.309902e+04
+6.964500e+02 1.309902e+04
+6.964000e+02 1.309902e+04
+6.963500e+02 1.309902e+04
+6.963000e+02 1.309902e+04
+6.962500e+02 1.309902e+04
+6.962000e+02 1.309902e+04
+6.961500e+02 1.309902e+04
+6.961000e+02 1.309902e+04
+6.960500e+02 1.309902e+04
+6.960000e+02 1.309902e+04
+6.959500e+02 1.309902e+04
+6.959000e+02 1.309902e+04
+6.958500e+02 1.309902e+04
+6.958000e+02 1.309902e+04
+6.957500e+02 1.309902e+04
+6.957000e+02 1.309902e+04
+6.956500e+02 1.309902e+04
+6.956000e+02 1.309902e+04
+6.955500e+02 1.309902e+04
+6.955000e+02 1.309902e+04
+6.954500e+02 1.309902e+04
+6.954000e+02 1.309902e+04
+6.953500e+02 1.309902e+04
+6.953000e+02 1.309902e+04
+6.952500e+02 1.309902e+04
+6.952000e+02 1.309902e+04
+6.951500e+02 1.309902e+04
+6.951000e+02 1.309902e+04
+6.950500e+02 1.309902e+04
+6.950000e+02 1.309902e+04
+6.949500e+02 1.309902e+04
+6.949000e+02 1.309902e+04
+6.948500e+02 1.309902e+04
+6.948000e+02 1.309902e+04
+6.947500e+02 1.309902e+04
+6.947000e+02 1.309902e+04
+6.946500e+02 1.309902e+04
+6.946000e+02 1.309902e+04
+6.945500e+02 1.309902e+04
+6.945000e+02 1.309902e+04
+6.944500e+02 1.309902e+04
+6.944000e+02 1.309902e+04
+6.943500e+02 1.309902e+04
+6.943000e+02 1.309902e+04
+6.942500e+02 1.309902e+04
+6.942000e+02 1.309902e+04
+6.941500e+02 1.309902e+04
+6.941000e+02 1.309902e+04
+6.940500e+02 1.309902e+04
+6.940000e+02 1.309902e+04
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Mn2p_Mn2O3.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Mn2p_Mn2O3.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5e71ee29d1a890e2074d0b7f1cdada5a724721a3
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Mn2p_Mn2O3.txt
@@ -0,0 +1,401 @@
+Mn2p Mn2O3
+6.699000e+002	5.156280e+002		
+6.698000e+002	5.156920e+002		
+6.697000e+002	5.209680e+002		
+6.696000e+002	5.224580e+002		
+6.695000e+002	5.217470e+002		
+6.694000e+002	5.198250e+002		
+6.693000e+002	5.202260e+002		
+6.692000e+002	5.228650e+002		
+6.691000e+002	5.213510e+002		
+6.690000e+002	5.202850e+002		
+6.689000e+002	5.215660e+002		
+6.688000e+002	5.241710e+002		
+6.687000e+002	5.252110e+002		
+6.686000e+002	5.249990e+002		
+6.685000e+002	5.269190e+002		
+6.684000e+002	5.165310e+002		
+6.683000e+002	5.248520e+002		
+6.682000e+002	5.275220e+002		
+6.681000e+002	5.323600e+002		
+6.680000e+002	5.323990e+002		
+6.679000e+002	5.305840e+002		
+6.678000e+002	5.311450e+002		
+6.677000e+002	5.307520e+002		
+6.676000e+002	5.283000e+002		
+6.675000e+002	5.285530e+002		
+6.674000e+002	5.286240e+002		
+6.673000e+002	5.315950e+002		
+6.672000e+002	5.333700e+002		
+6.671000e+002	5.331350e+002		
+6.670000e+002	5.360890e+002		
+6.669000e+002	5.383610e+002		
+6.668000e+002	5.392880e+002		
+6.667000e+002	5.398960e+002		
+6.666000e+002	5.327390e+002		
+6.665000e+002	5.356140e+002		
+6.664000e+002	5.387820e+002		
+6.663000e+002	5.444010e+002		
+6.662000e+002	5.421780e+002		
+6.661000e+002	5.444450e+002		
+6.660000e+002	5.488910e+002		
+6.659000e+002	5.498780e+002		
+6.658000e+002	5.475150e+002		
+6.657000e+002	5.543110e+002		
+6.656000e+002	5.541950e+002		
+6.655000e+002	5.533210e+002		
+6.654000e+002	5.568770e+002		
+6.653000e+002	5.586710e+002		
+6.652000e+002	5.592070e+002		
+6.651000e+002	5.599550e+002		
+6.650000e+002	5.594110e+002		
+6.649000e+002	5.631670e+002		
+6.648000e+002	5.666990e+002		
+6.647000e+002	5.667240e+002		
+6.646000e+002	5.629710e+002		
+6.645000e+002	5.670040e+002		
+6.644000e+002	5.670590e+002		
+6.643000e+002	5.733410e+002		
+6.642000e+002	5.767560e+002		
+6.641000e+002	5.762040e+002		
+6.640000e+002	5.787810e+002		
+6.639000e+002	5.815910e+002		
+6.638000e+002	5.815290e+002		
+6.637000e+002	5.790510e+002		
+6.636000e+002	5.840190e+002		
+6.635000e+002	5.786780e+002		
+6.634000e+002	5.781910e+002		
+6.633000e+002	5.853890e+002		
+6.632000e+002	5.851680e+002		
+6.631000e+002	5.870210e+002		
+6.630000e+002	5.888020e+002		
+6.629000e+002	5.852820e+002		
+6.628000e+002	5.861130e+002		
+6.627000e+002	5.852820e+002		
+6.626000e+002	5.873620e+002		
+6.625000e+002	5.880690e+002		
+6.624000e+002	5.862510e+002		
+6.623000e+002	5.879640e+002		
+6.622000e+002	5.849270e+002		
+6.621000e+002	5.832450e+002		
+6.620000e+002	5.891220e+002		
+6.619000e+002	5.847720e+002		
+6.618000e+002	5.820710e+002		
+6.617000e+002	5.780260e+002		
+6.616000e+002	5.825750e+002		
+6.615000e+002	5.806070e+002		
+6.614000e+002	5.768520e+002		
+6.613000e+002	5.731830e+002		
+6.612000e+002	5.708690e+002		
+6.611000e+002	5.757290e+002		
+6.610000e+002	5.764410e+002		
+6.609000e+002	5.711550e+002		
+6.608000e+002	5.675940e+002		
+6.607000e+002	5.735260e+002		
+6.606000e+002	5.708030e+002		
+6.605000e+002	5.667160e+002		
+6.604000e+002	5.750260e+002		
+6.603000e+002	5.737190e+002		
+6.602000e+002	5.721510e+002		
+6.601000e+002	5.770160e+002		
+6.600000e+002	5.734680e+002		
+6.599000e+002	5.761020e+002		
+6.598000e+002	5.746990e+002		
+6.597000e+002	5.761780e+002		
+6.596000e+002	5.792480e+002		
+6.595000e+002	5.800130e+002		
+6.594000e+002	5.816940e+002		
+6.593000e+002	5.836310e+002		
+6.592000e+002	5.837580e+002		
+6.591000e+002	5.833890e+002		
+6.590000e+002	5.796910e+002		
+6.589000e+002	5.839310e+002		
+6.588000e+002	5.871280e+002		
+6.587000e+002	5.862040e+002		
+6.586000e+002	5.913640e+002		
+6.585000e+002	5.917150e+002		
+6.584000e+002	5.961390e+002		
+6.583000e+002	5.943440e+002		
+6.582000e+002	5.938940e+002		
+6.581000e+002	5.924600e+002		
+6.580000e+002	5.990820e+002		
+6.579000e+002	5.971410e+002		
+6.578000e+002	5.937850e+002		
+6.577000e+002	5.979230e+002		
+6.576000e+002	6.091700e+002		
+6.575000e+002	6.109020e+002		
+6.574000e+002	6.030100e+002		
+6.573000e+002	6.092860e+002		
+6.572000e+002	6.163980e+002		
+6.571000e+002	6.208180e+002		
+6.570000e+002	6.204990e+002		
+6.569000e+002	6.304680e+002		
+6.568000e+002	6.285900e+002		
+6.567000e+002	6.332450e+002		
+6.566000e+002	6.367900e+002		
+6.565000e+002	6.335310e+002		
+6.564000e+002	6.438750e+002		
+6.563000e+002	6.520800e+002		
+6.562000e+002	6.626060e+002		
+6.561000e+002	6.691980e+002		
+6.560000e+002	6.775900e+002		
+6.559000e+002	6.828950e+002		
+6.558000e+002	6.936410e+002		
+6.557000e+002	6.971580e+002		
+6.556000e+002	7.051850e+002		
+6.555000e+002	7.210160e+002		
+6.554000e+002	7.264590e+002		
+6.553000e+002	7.358570e+002		
+6.552000e+002	7.477690e+002		
+6.551000e+002	7.601430e+002		
+6.550000e+002	7.711770e+002		
+6.549000e+002	7.878270e+002		
+6.548000e+002	8.085500e+002		
+6.547000e+002	8.244390e+002		
+6.546000e+002	8.407330e+002		
+6.545000e+002	8.588410e+002		
+6.544000e+002	8.687160e+002		
+6.543000e+002	8.858890e+002		
+6.542000e+002	9.059450e+002		
+6.541000e+002	9.277710e+002		
+6.540000e+002	9.497480e+002		
+6.539000e+002	9.677650e+002		
+6.538000e+002	9.835150e+002		
+6.537000e+002	1.009360e+003		
+6.536000e+002	1.036590e+003		
+6.535000e+002	1.042610e+003		
+6.534000e+002	1.054580e+003		
+6.533000e+002	1.056630e+003		
+6.532000e+002	1.077250e+003		
+6.531000e+002	1.081150e+003		
+6.530000e+002	1.081020e+003		
+6.529000e+002	1.078760e+003		
+6.528000e+002	1.075210e+003		
+6.527000e+002	1.069310e+003		
+6.526000e+002	1.059390e+003		
+6.525000e+002	1.056250e+003		
+6.524000e+002	1.041120e+003		
+6.523000e+002	1.023150e+003		
+6.522000e+002	1.001580e+003		
+6.521000e+002	9.936740e+002		
+6.520000e+002	9.662020e+002		
+6.519000e+002	9.295910e+002		
+6.518000e+002	9.035060e+002		
+6.517000e+002	8.733190e+002		
+6.516000e+002	8.541430e+002		
+6.515000e+002	8.316900e+002		
+6.514000e+002	8.013090e+002		
+6.513000e+002	7.694760e+002		
+6.512000e+002	7.550690e+002		
+6.511000e+002	7.317520e+002		
+6.510000e+002	7.022780e+002		
+6.509000e+002	6.877060e+002		
+6.508000e+002	6.755910e+002		
+6.507000e+002	6.562900e+002		
+6.506000e+002	6.361060e+002		
+6.505000e+002	6.244510e+002		
+6.504000e+002	6.085300e+002		
+6.503000e+002	5.954910e+002		
+6.502000e+002	5.814270e+002		
+6.501000e+002	5.817800e+002		
+6.500000e+002	5.720650e+002		
+6.499000e+002	5.655140e+002		
+6.498000e+002	5.561130e+002		
+6.497000e+002	5.455480e+002		
+6.496000e+002	5.409520e+002		
+6.495000e+002	5.349550e+002		
+6.494000e+002	5.291290e+002		
+6.493000e+002	5.207150e+002		
+6.492000e+002	5.217840e+002		
+6.491000e+002	5.256940e+002		
+6.490000e+002	5.218150e+002		
+6.489000e+002	5.203670e+002		
+6.488000e+002	5.175080e+002		
+6.487000e+002	5.190970e+002		
+6.486000e+002	5.195040e+002		
+6.485000e+002	5.220520e+002		
+6.484000e+002	5.190280e+002		
+6.483000e+002	5.217090e+002		
+6.482000e+002	5.240880e+002		
+6.481000e+002	5.267230e+002		
+6.480000e+002	5.276450e+002		
+6.479000e+002	5.305770e+002		
+6.478000e+002	5.239970e+002		
+6.477000e+002	5.331080e+002		
+6.476000e+002	5.317110e+002		
+6.475000e+002	5.401790e+002		
+6.474000e+002	5.363570e+002		
+6.473000e+002	5.399830e+002		
+6.472000e+002	5.379390e+002		
+6.471000e+002	5.386280e+002		
+6.470000e+002	5.506680e+002		
+6.469000e+002	5.541690e+002		
+6.468000e+002	5.530750e+002		
+6.467000e+002	5.566270e+002		
+6.466000e+002	5.594950e+002		
+6.465000e+002	5.630910e+002		
+6.464000e+002	5.701080e+002		
+6.463000e+002	5.749410e+002		
+6.462000e+002	5.696590e+002		
+6.461000e+002	5.741290e+002		
+6.460000e+002	5.765640e+002		
+6.459000e+002	5.774530e+002		
+6.458000e+002	5.778740e+002		
+6.457000e+002	5.870230e+002		
+6.456000e+002	5.929760e+002		
+6.455000e+002	6.023370e+002		
+6.454000e+002	6.056830e+002		
+6.453000e+002	6.058950e+002		
+6.452000e+002	6.148750e+002		
+6.451000e+002	6.240640e+002		
+6.450000e+002	6.282350e+002		
+6.449000e+002	6.397100e+002		
+6.448000e+002	6.492820e+002		
+6.447000e+002	6.524130e+002		
+6.446000e+002	6.605140e+002		
+6.445000e+002	6.765490e+002		
+6.444000e+002	6.897690e+002		
+6.443000e+002	6.959600e+002		
+6.442000e+002	7.054700e+002		
+6.441000e+002	7.301040e+002		
+6.440000e+002	7.366430e+002		
+6.439000e+002	7.541640e+002		
+6.438000e+002	7.733060e+002		
+6.437000e+002	7.929460e+002		
+6.436000e+002	8.106590e+002		
+6.435000e+002	8.241050e+002		
+6.434000e+002	8.529460e+002		
+6.433000e+002	8.767450e+002		
+6.432000e+002	9.080040e+002		
+6.431000e+002	9.337470e+002		
+6.430000e+002	9.744470e+002		
+6.429000e+002	9.993390e+002		
+6.428000e+002	1.037490e+003		
+6.427000e+002	1.069010e+003		
+6.426000e+002	1.102200e+003		
+6.425000e+002	1.136620e+003		
+6.424000e+002	1.170150e+003		
+6.423000e+002	1.207570e+003		
+6.422000e+002	1.249450e+003		
+6.421000e+002	1.270330e+003		
+6.420000e+002	1.293300e+003		
+6.419000e+002	1.328720e+003		
+6.418000e+002	1.363840e+003		
+6.417000e+002	1.371980e+003		
+6.416000e+002	1.384990e+003		
+6.415000e+002	1.392710e+003		
+6.414000e+002	1.403440e+003		
+6.413000e+002	1.414070e+003		
+6.412000e+002	1.413670e+003		
+6.411000e+002	1.414470e+003		
+6.410000e+002	1.419540e+003		
+6.409000e+002	1.414700e+003		
+6.408000e+002	1.393170e+003		
+6.407000e+002	1.376010e+003		
+6.406000e+002	1.340480e+003		
+6.405000e+002	1.298820e+003		
+6.404000e+002	1.231970e+003		
+6.403000e+002	1.156850e+003		
+6.402000e+002	1.077120e+003		
+6.401000e+002	9.982240e+002		
+6.400000e+002	9.211490e+002		
+6.399000e+002	8.501910e+002		
+6.398000e+002	7.714840e+002		
+6.397000e+002	7.024390e+002		
+6.396000e+002	6.395650e+002		
+6.395000e+002	5.731870e+002		
+6.394000e+002	5.147890e+002		
+6.393000e+002	4.628200e+002		
+6.392000e+002	4.149230e+002		
+6.391000e+002	3.641480e+002		
+6.390000e+002	3.205080e+002		
+6.389000e+002	2.851950e+002		
+6.388000e+002	2.590490e+002		
+6.387000e+002	2.363210e+002		
+6.386000e+002	2.176800e+002		
+6.385000e+002	2.048170e+002		
+6.384000e+002	2.015510e+002		
+6.383000e+002	1.909760e+002		
+6.382000e+002	1.805850e+002		
+6.381000e+002	1.771330e+002		
+6.380000e+002	1.739810e+002		
+6.379000e+002	1.728690e+002		
+6.378000e+002	1.688620e+002		
+6.377000e+002	1.687950e+002		
+6.376000e+002	1.671510e+002		
+6.375000e+002	1.630800e+002		
+6.374000e+002	1.619580e+002		
+6.373000e+002	1.623990e+002		
+6.372000e+002	1.582140e+002		
+6.371000e+002	1.584950e+002		
+6.370000e+002	1.605520e+002		
+6.369000e+002	1.574550e+002		
+6.368000e+002	1.579340e+002		
+6.367000e+002	1.566980e+002		
+6.366000e+002	1.570050e+002		
+6.365000e+002	1.552350e+002		
+6.364000e+002	1.512760e+002		
+6.363000e+002	1.549760e+002		
+6.362000e+002	1.557540e+002		
+6.361000e+002	1.535940e+002		
+6.360000e+002	1.508760e+002		
+6.359000e+002	1.507070e+002		
+6.358000e+002	1.524920e+002		
+6.357000e+002	1.490290e+002		
+6.356000e+002	1.479190e+002		
+6.355000e+002	1.509050e+002		
+6.354000e+002	1.488170e+002		
+6.353000e+002	1.512030e+002		
+6.352000e+002	1.491120e+002		
+6.351000e+002	1.502260e+002		
+6.350000e+002	1.507610e+002		
+6.349000e+002	1.473750e+002		
+6.348000e+002	1.522430e+002		
+6.347000e+002	1.508600e+002		
+6.346000e+002	1.522610e+002		
+6.345000e+002	1.474820e+002		
+6.344000e+002	1.487840e+002		
+6.343000e+002	1.485500e+002		
+6.342000e+002	1.471500e+002		
+6.341000e+002	1.470570e+002		
+6.340000e+002	1.448980e+002		
+6.339000e+002	1.458180e+002		
+6.338000e+002	1.491840e+002		
+6.337000e+002	1.495880e+002		
+6.336000e+002	1.483800e+002		
+6.335000e+002	1.459530e+002		
+6.334000e+002	1.472220e+002		
+6.333000e+002	1.451490e+002		
+6.332000e+002	1.477810e+002		
+6.331000e+002	1.488950e+002		
+6.330000e+002	1.503880e+002		
+6.329000e+002	1.456630e+002		
+6.328000e+002	1.478540e+002		
+6.327000e+002	1.452660e+002		
+6.326000e+002	1.429600e+002		
+6.325000e+002	1.455410e+002		
+6.324000e+002	1.469360e+002		
+6.323000e+002	1.482890e+002		
+6.322000e+002	1.473400e+002		
+6.321000e+002	1.478610e+002		
+6.320000e+002	1.498700e+002		
+6.319000e+002	1.487080e+002		
+6.318000e+002	1.473470e+002		
+6.317000e+002	1.469470e+002		
+6.316000e+002	1.460580e+002		
+6.315000e+002	1.478950e+002		
+6.314000e+002	1.468060e+002		
+6.313000e+002	1.459230e+002		
+6.312000e+002	1.472960e+002		
+6.311000e+002	1.463140e+002		
+6.310000e+002	1.463550e+002		
+6.309000e+002	1.458210e+002		
+6.308000e+002	1.481490e+002		
+6.307000e+002	1.458090e+002		
+6.306000e+002	1.433380e+002		
+6.305000e+002	1.475360e+002		
+6.304000e+002	1.485520e+002		
+6.303000e+002	1.477380e+002		
+6.302000e+002	1.473260e+002		
+6.301000e+002	1.502980e+002		
+6.300000e+002	1.467240e+002		
\ No newline at end of file
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/NiCoFe/Co2pFe2p_Fe_metal.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/NiCoFe/Co2pFe2p_Fe_metal.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3be40951051cd29bc15f9186b0f1617f32c6d0ed
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/NiCoFe/Co2pFe2p_Fe_metal.txt
@@ -0,0 +1,2922 @@
+Co2pFe2p Fe metal
+8.400000e+02 2.198103e+04
+8.399500e+02 2.198103e+04
+8.399000e+02 2.205187e+04
+8.398500e+02 2.205187e+04
+8.398000e+02 2.213937e+04
+8.397500e+02 2.213937e+04
+8.397000e+02 2.213117e+04
+8.396500e+02 2.213117e+04
+8.396000e+02 2.224053e+04
+8.395500e+02 2.224053e+04
+8.395000e+02 2.226743e+04
+8.394500e+02 2.226743e+04
+8.394000e+02 2.235747e+04
+8.393500e+02 2.235747e+04
+8.393000e+02 2.235503e+04
+8.392500e+02 2.235503e+04
+8.392000e+02 2.240200e+04
+8.391500e+02 2.240200e+04
+8.391000e+02 2.242397e+04
+8.390500e+02 2.242397e+04
+8.390000e+02 2.238833e+04
+8.389500e+02 2.238833e+04
+8.389000e+02 2.239460e+04
+8.388500e+02 2.239460e+04
+8.388000e+02 2.231930e+04
+8.387500e+02 2.231930e+04
+8.387000e+02 2.221323e+04
+8.386500e+02 2.221323e+04
+8.386000e+02 2.225397e+04
+8.385500e+02 2.225397e+04
+8.385000e+02 2.215937e+04
+8.384500e+02 2.215937e+04
+8.384000e+02 2.212767e+04
+8.383500e+02 2.212767e+04
+8.383000e+02 2.190617e+04
+8.382500e+02 2.190617e+04
+8.382000e+02 2.179953e+04
+8.381500e+02 2.179953e+04
+8.381000e+02 2.167473e+04
+8.380500e+02 2.167473e+04
+8.380000e+02 2.162680e+04
+8.379500e+02 2.162680e+04
+8.379000e+02 2.140617e+04
+8.378500e+02 2.140617e+04
+8.378000e+02 2.124857e+04
+8.377500e+02 2.124857e+04
+8.377000e+02 2.109030e+04
+8.376500e+02 2.109030e+04
+8.376000e+02 2.101267e+04
+8.375500e+02 2.101267e+04
+8.375000e+02 2.087793e+04
+8.374500e+02 2.087793e+04
+8.374000e+02 2.071727e+04
+8.373500e+02 2.071727e+04
+8.373000e+02 2.063720e+04
+8.372500e+02 2.063720e+04
+8.372000e+02 2.058993e+04
+8.371500e+02 2.058993e+04
+8.371000e+02 2.050987e+04
+8.370500e+02 2.050987e+04
+8.370000e+02 2.050013e+04
+8.369500e+02 2.050013e+04
+8.369000e+02 2.049137e+04
+8.368500e+02 2.049137e+04
+8.368000e+02 2.053760e+04
+8.367500e+02 2.053760e+04
+8.367000e+02 2.042063e+04
+8.366500e+02 2.042063e+04
+8.366000e+02 2.037933e+04
+8.365500e+02 2.037933e+04
+8.365000e+02 2.022977e+04
+8.364500e+02 2.022977e+04
+8.364000e+02 2.027457e+04
+8.363500e+02 2.027457e+04
+8.363000e+02 2.028920e+04
+8.362500e+02 2.028920e+04
+8.362000e+02 2.022763e+04
+8.361500e+02 2.022763e+04
+8.361000e+02 2.028137e+04
+8.360500e+02 2.028137e+04
+8.360000e+02 2.023357e+04
+8.359500e+02 2.023357e+04
+8.359000e+02 2.028513e+04
+8.358500e+02 2.028513e+04
+8.358000e+02 2.020407e+04
+8.357500e+02 2.020407e+04
+8.357000e+02 2.028083e+04
+8.356500e+02 2.028083e+04
+8.356000e+02 2.041033e+04
+8.355500e+02 2.041033e+04
+8.355000e+02 2.040627e+04
+8.354500e+02 2.040627e+04
+8.354000e+02 2.032503e+04
+8.353500e+02 2.032503e+04
+8.353000e+02 2.048640e+04
+8.352500e+02 2.048640e+04
+8.352000e+02 2.048570e+04
+8.351500e+02 2.048570e+04
+8.351000e+02 2.041590e+04
+8.350500e+02 2.041590e+04
+8.350000e+02 2.033253e+04
+8.349500e+02 2.033253e+04
+8.349000e+02 2.044053e+04
+8.348500e+02 2.044053e+04
+8.348000e+02 2.046030e+04
+8.347500e+02 2.046030e+04
+8.347000e+02 2.036747e+04
+8.346500e+02 2.036747e+04
+8.346000e+02 2.042367e+04
+8.345500e+02 2.042367e+04
+8.345000e+02 2.042913e+04
+8.344500e+02 2.042913e+04
+8.344000e+02 2.032730e+04
+8.343500e+02 2.032730e+04
+8.343000e+02 2.030233e+04
+8.342500e+02 2.030233e+04
+8.342000e+02 2.021933e+04
+8.341500e+02 2.021933e+04
+8.341000e+02 2.004793e+04
+8.340500e+02 2.004793e+04
+8.340000e+02 2.003567e+04
+8.339500e+02 2.003567e+04
+8.339000e+02 2.006247e+04
+8.338500e+02 2.006247e+04
+8.338000e+02 2.004167e+04
+8.337500e+02 2.004167e+04
+8.337000e+02 1.979393e+04
+8.336500e+02 1.979393e+04
+8.336000e+02 1.966683e+04
+8.335500e+02 1.966683e+04
+8.335000e+02 1.964957e+04
+8.334500e+02 1.964957e+04
+8.334000e+02 1.935427e+04
+8.333500e+02 1.935427e+04
+8.333000e+02 1.907887e+04
+8.332500e+02 1.907887e+04
+8.332000e+02 1.904420e+04
+8.331500e+02 1.904420e+04
+8.331000e+02 1.881560e+04
+8.330500e+02 1.881560e+04
+8.330000e+02 1.856567e+04
+8.329500e+02 1.856567e+04
+8.329000e+02 1.831377e+04
+8.328500e+02 1.831377e+04
+8.328000e+02 1.802073e+04
+8.327500e+02 1.802073e+04
+8.327000e+02 1.774447e+04
+8.326500e+02 1.774447e+04
+8.326000e+02 1.734203e+04
+8.325500e+02 1.734203e+04
+8.325000e+02 1.716177e+04
+8.324500e+02 1.716177e+04
+8.324000e+02 1.682677e+04
+8.323500e+02 1.682677e+04
+8.323000e+02 1.651447e+04
+8.322500e+02 1.651447e+04
+8.322000e+02 1.615903e+04
+8.321500e+02 1.615903e+04
+8.321000e+02 1.595367e+04
+8.320500e+02 1.595367e+04
+8.320000e+02 1.561767e+04
+8.319500e+02 1.561767e+04
+8.319000e+02 1.523673e+04
+8.318500e+02 1.523673e+04
+8.318000e+02 1.508780e+04
+8.317500e+02 1.508780e+04
+8.317000e+02 1.496650e+04
+8.316500e+02 1.496650e+04
+8.316000e+02 1.484010e+04
+8.315500e+02 1.484010e+04
+8.315000e+02 1.463320e+04
+8.314500e+02 1.463320e+04
+8.314000e+02 1.446370e+04
+8.313500e+02 1.446370e+04
+8.313000e+02 1.437960e+04
+8.312500e+02 1.437960e+04
+8.312000e+02 1.426363e+04
+8.311500e+02 1.426363e+04
+8.311000e+02 1.417530e+04
+8.310500e+02 1.417530e+04
+8.310000e+02 1.404920e+04
+8.309500e+02 1.404920e+04
+8.309000e+02 1.405187e+04
+8.308500e+02 1.405187e+04
+8.308000e+02 1.398293e+04
+8.307500e+02 1.398293e+04
+8.307000e+02 1.387950e+04
+8.306500e+02 1.387950e+04
+8.306000e+02 1.376577e+04
+8.305500e+02 1.376577e+04
+8.305000e+02 1.380320e+04
+8.304500e+02 1.380320e+04
+8.304000e+02 1.379130e+04
+8.303500e+02 1.379130e+04
+8.303000e+02 1.376907e+04
+8.302500e+02 1.376907e+04
+8.302000e+02 1.370110e+04
+8.301500e+02 1.370110e+04
+8.301000e+02 1.377393e+04
+8.300500e+02 1.377393e+04
+8.300000e+02 1.365570e+04
+8.299500e+02 1.365570e+04
+8.299000e+02 1.376670e+04
+8.298500e+02 1.376670e+04
+8.298000e+02 1.377513e+04
+8.297500e+02 1.377513e+04
+8.297000e+02 1.364007e+04
+8.296500e+02 1.364007e+04
+8.296000e+02 1.364317e+04
+8.295500e+02 1.364317e+04
+8.295000e+02 1.358947e+04
+8.294500e+02 1.358947e+04
+8.294000e+02 1.354947e+04
+8.293500e+02 1.354947e+04
+8.293000e+02 1.364970e+04
+8.292500e+02 1.364970e+04
+8.292000e+02 1.360623e+04
+8.291500e+02 1.360623e+04
+8.291000e+02 1.351023e+04
+8.290500e+02 1.351023e+04
+8.290000e+02 1.354813e+04
+8.289500e+02 1.354813e+04
+8.289000e+02 1.342673e+04
+8.288500e+02 1.342673e+04
+8.288000e+02 1.355060e+04
+8.287500e+02 1.355060e+04
+8.287000e+02 1.345957e+04
+8.286500e+02 1.345957e+04
+8.286000e+02 1.354527e+04
+8.285500e+02 1.354527e+04
+8.285000e+02 1.352720e+04
+8.284500e+02 1.352720e+04
+8.284000e+02 1.343220e+04
+8.283500e+02 1.343220e+04
+8.283000e+02 1.344380e+04
+8.282500e+02 1.344380e+04
+8.282000e+02 1.340783e+04
+8.281500e+02 1.340783e+04
+8.281000e+02 1.334357e+04
+8.280500e+02 1.334357e+04
+8.280000e+02 1.333900e+04
+8.279500e+02 1.333900e+04
+8.279000e+02 1.339473e+04
+8.278500e+02 1.339473e+04
+8.278000e+02 1.339337e+04
+8.277500e+02 1.339337e+04
+8.277000e+02 1.339173e+04
+8.276500e+02 1.339173e+04
+8.276000e+02 1.336460e+04
+8.275500e+02 1.336460e+04
+8.275000e+02 1.331167e+04
+8.274500e+02 1.331167e+04
+8.274000e+02 1.327663e+04
+8.273500e+02 1.327663e+04
+8.273000e+02 1.334927e+04
+8.272500e+02 1.334927e+04
+8.272000e+02 1.339193e+04
+8.271500e+02 1.339193e+04
+8.271000e+02 1.331980e+04
+8.270500e+02 1.331980e+04
+8.270000e+02 1.332803e+04
+8.269500e+02 1.332803e+04
+8.269000e+02 1.339103e+04
+8.268500e+02 1.339103e+04
+8.268000e+02 1.331900e+04
+8.267500e+02 1.331900e+04
+8.267000e+02 1.339430e+04
+8.266500e+02 1.339430e+04
+8.266000e+02 1.323977e+04
+8.265500e+02 1.323977e+04
+8.265000e+02 1.329200e+04
+8.264500e+02 1.329200e+04
+8.264000e+02 1.325040e+04
+8.263500e+02 1.325040e+04
+8.263000e+02 1.330373e+04
+8.262500e+02 1.330373e+04
+8.262000e+02 1.332947e+04
+8.261500e+02 1.332947e+04
+8.261000e+02 1.320580e+04
+8.260500e+02 1.320580e+04
+8.260000e+02 1.326123e+04
+8.259500e+02 1.326123e+04
+8.259000e+02 1.326843e+04
+8.258500e+02 1.326843e+04
+8.258000e+02 1.325193e+04
+8.257500e+02 1.325193e+04
+8.257000e+02 1.331497e+04
+8.256500e+02 1.331497e+04
+8.256000e+02 1.320990e+04
+8.255500e+02 1.320990e+04
+8.255000e+02 1.315340e+04
+8.254500e+02 1.315340e+04
+8.254000e+02 1.315200e+04
+8.253500e+02 1.315200e+04
+8.253000e+02 1.324460e+04
+8.252500e+02 1.324460e+04
+8.252000e+02 1.321177e+04
+8.251500e+02 1.321177e+04
+8.251000e+02 1.316067e+04
+8.250500e+02 1.316067e+04
+8.250000e+02 1.317643e+04
+8.249500e+02 1.317643e+04
+8.249000e+02 1.315477e+04
+8.248500e+02 1.315477e+04
+8.248000e+02 1.309157e+04
+8.247500e+02 1.309157e+04
+8.247000e+02 1.313390e+04
+8.246500e+02 1.313390e+04
+8.246000e+02 1.305190e+04
+8.245500e+02 1.305190e+04
+8.245000e+02 1.306373e+04
+8.244500e+02 1.306373e+04
+8.244000e+02 1.307943e+04
+8.243500e+02 1.307943e+04
+8.243000e+02 1.302030e+04
+8.242500e+02 1.302030e+04
+8.242000e+02 1.312320e+04
+8.241500e+02 1.312320e+04
+8.241000e+02 1.312067e+04
+8.240500e+02 1.312067e+04
+8.240000e+02 1.307643e+04
+8.239500e+02 1.307643e+04
+8.239000e+02 1.303097e+04
+8.238500e+02 1.303097e+04
+8.238000e+02 1.296873e+04
+8.237500e+02 1.296873e+04
+8.237000e+02 1.297570e+04
+8.236500e+02 1.297570e+04
+8.236000e+02 1.306300e+04
+8.235500e+02 1.306300e+04
+8.235000e+02 1.297123e+04
+8.234500e+02 1.297123e+04
+8.234000e+02 1.306170e+04
+8.233500e+02 1.306170e+04
+8.233000e+02 1.304597e+04
+8.232500e+02 1.304597e+04
+8.232000e+02 1.300897e+04
+8.231500e+02 1.300897e+04
+8.231000e+02 1.295167e+04
+8.230500e+02 1.295167e+04
+8.230000e+02 1.289380e+04
+8.229500e+02 1.289380e+04
+8.229000e+02 1.295203e+04
+8.228500e+02 1.295203e+04
+8.228000e+02 1.299527e+04
+8.227500e+02 1.299527e+04
+8.227000e+02 1.295317e+04
+8.226500e+02 1.295317e+04
+8.226000e+02 1.295807e+04
+8.225500e+02 1.295807e+04
+8.225000e+02 1.296603e+04
+8.224500e+02 1.296603e+04
+8.224000e+02 1.292103e+04
+8.223500e+02 1.292103e+04
+8.223000e+02 1.298417e+04
+8.222500e+02 1.298417e+04
+8.222000e+02 1.288890e+04
+8.221500e+02 1.288890e+04
+8.221000e+02 1.288053e+04
+8.220500e+02 1.288053e+04
+8.220000e+02 1.297207e+04
+8.219500e+02 1.297207e+04
+8.219000e+02 1.290563e+04
+8.218500e+02 1.290563e+04
+8.218000e+02 1.283480e+04
+8.217500e+02 1.283480e+04
+8.217000e+02 1.282313e+04
+8.216500e+02 1.282313e+04
+8.216000e+02 1.279667e+04
+8.215500e+02 1.279667e+04
+8.215000e+02 1.290083e+04
+8.214500e+02 1.290083e+04
+8.214000e+02 1.284850e+04
+8.213500e+02 1.284850e+04
+8.213000e+02 1.287623e+04
+8.212500e+02 1.287623e+04
+8.212000e+02 1.279580e+04
+8.211500e+02 1.279580e+04
+8.211000e+02 1.284810e+04
+8.210500e+02 1.284810e+04
+8.210000e+02 1.276090e+04
+8.209500e+02 1.276090e+04
+8.209000e+02 1.273320e+04
+8.208500e+02 1.273320e+04
+8.208000e+02 1.283057e+04
+8.207500e+02 1.283057e+04
+8.207000e+02 1.283160e+04
+8.206500e+02 1.283160e+04
+8.206000e+02 1.265870e+04
+8.205500e+02 1.265870e+04
+8.205000e+02 1.261297e+04
+8.204500e+02 1.261297e+04
+8.204000e+02 1.268603e+04
+8.203500e+02 1.268603e+04
+8.203000e+02 1.269203e+04
+8.202500e+02 1.269203e+04
+8.202000e+02 1.271943e+04
+8.201500e+02 1.271943e+04
+8.201000e+02 1.260513e+04
+8.200500e+02 1.260513e+04
+8.200000e+02 1.264493e+04
+8.199500e+02 1.264493e+04
+8.199000e+02 1.276290e+04
+8.198500e+02 1.276290e+04
+8.198000e+02 1.270040e+04
+8.197500e+02 1.270040e+04
+8.197000e+02 1.257933e+04
+8.196500e+02 1.257933e+04
+8.196000e+02 1.262447e+04
+8.195500e+02 1.262447e+04
+8.195000e+02 1.264523e+04
+8.194500e+02 1.264523e+04
+8.194000e+02 1.263500e+04
+8.193500e+02 1.263500e+04
+8.193000e+02 1.260733e+04
+8.192500e+02 1.260733e+04
+8.192000e+02 1.257227e+04
+8.191500e+02 1.257227e+04
+8.191000e+02 1.253020e+04
+8.190500e+02 1.253020e+04
+8.190000e+02 1.257110e+04
+8.189500e+02 1.257110e+04
+8.189000e+02 1.260093e+04
+8.188500e+02 1.260093e+04
+8.188000e+02 1.260340e+04
+8.187500e+02 1.260340e+04
+8.187000e+02 1.266710e+04
+8.186500e+02 1.266710e+04
+8.186000e+02 1.261803e+04
+8.185500e+02 1.261803e+04
+8.185000e+02 1.261790e+04
+8.184500e+02 1.261790e+04
+8.184000e+02 1.258690e+04
+8.183500e+02 1.258690e+04
+8.183000e+02 1.258397e+04
+8.182500e+02 1.258397e+04
+8.182000e+02 1.258140e+04
+8.181500e+02 1.258140e+04
+8.181000e+02 1.263860e+04
+8.180500e+02 1.263860e+04
+8.180000e+02 1.265713e+04
+8.179500e+02 1.265713e+04
+8.179000e+02 1.258363e+04
+8.178500e+02 1.258363e+04
+8.178000e+02 1.258947e+04
+8.177500e+02 1.258947e+04
+8.177000e+02 1.259277e+04
+8.176500e+02 1.259277e+04
+8.176000e+02 1.260360e+04
+8.175500e+02 1.260360e+04
+8.175000e+02 1.261027e+04
+8.174500e+02 1.261027e+04
+8.174000e+02 1.264453e+04
+8.173500e+02 1.264453e+04
+8.173000e+02 1.265623e+04
+8.172500e+02 1.265623e+04
+8.172000e+02 1.268230e+04
+8.171500e+02 1.268230e+04
+8.171000e+02 1.259420e+04
+8.170500e+02 1.259420e+04
+8.170000e+02 1.257917e+04
+8.169500e+02 1.257917e+04
+8.169000e+02 1.254320e+04
+8.168500e+02 1.254320e+04
+8.168000e+02 1.252970e+04
+8.167500e+02 1.252970e+04
+8.167000e+02 1.263393e+04
+8.166500e+02 1.263393e+04
+8.166000e+02 1.263763e+04
+8.165500e+02 1.263763e+04
+8.165000e+02 1.265687e+04
+8.164500e+02 1.265687e+04
+8.164000e+02 1.269100e+04
+8.163500e+02 1.269100e+04
+8.163000e+02 1.269287e+04
+8.162500e+02 1.269287e+04
+8.162000e+02 1.260117e+04
+8.161500e+02 1.260117e+04
+8.161000e+02 1.265457e+04
+8.160500e+02 1.265457e+04
+8.160000e+02 1.257263e+04
+8.159500e+02 1.257263e+04
+8.159000e+02 1.256333e+04
+8.158500e+02 1.256333e+04
+8.158000e+02 1.268980e+04
+8.157500e+02 1.268980e+04
+8.157000e+02 1.264550e+04
+8.156500e+02 1.264550e+04
+8.156000e+02 1.266737e+04
+8.155500e+02 1.266737e+04
+8.155000e+02 1.268797e+04
+8.154500e+02 1.268797e+04
+8.154000e+02 1.274657e+04
+8.153500e+02 1.274657e+04
+8.153000e+02 1.270500e+04
+8.152500e+02 1.270500e+04
+8.152000e+02 1.259337e+04
+8.151500e+02 1.259337e+04
+8.151000e+02 1.269103e+04
+8.150500e+02 1.269103e+04
+8.150000e+02 1.269437e+04
+8.149500e+02 1.269437e+04
+8.149000e+02 1.263730e+04
+8.148500e+02 1.263730e+04
+8.148000e+02 1.273397e+04
+8.147500e+02 1.273397e+04
+8.147000e+02 1.275013e+04
+8.146500e+02 1.275013e+04
+8.146000e+02 1.271127e+04
+8.145500e+02 1.271127e+04
+8.145000e+02 1.275017e+04
+8.144500e+02 1.275017e+04
+8.144000e+02 1.273653e+04
+8.143500e+02 1.273653e+04
+8.143000e+02 1.272820e+04
+8.142500e+02 1.272820e+04
+8.142000e+02 1.274187e+04
+8.141500e+02 1.274187e+04
+8.141000e+02 1.269200e+04
+8.140500e+02 1.269200e+04
+8.140000e+02 1.273097e+04
+8.139500e+02 1.273097e+04
+8.139000e+02 1.276493e+04
+8.138500e+02 1.276493e+04
+8.138000e+02 1.278147e+04
+8.137500e+02 1.278147e+04
+8.137000e+02 1.285200e+04
+8.136500e+02 1.285200e+04
+8.136000e+02 1.283960e+04
+8.135500e+02 1.283960e+04
+8.135000e+02 1.273993e+04
+8.134500e+02 1.273993e+04
+8.134000e+02 1.275380e+04
+8.133500e+02 1.275380e+04
+8.133000e+02 1.281913e+04
+8.132500e+02 1.281913e+04
+8.132000e+02 1.284503e+04
+8.131500e+02 1.284503e+04
+8.131000e+02 1.284840e+04
+8.130500e+02 1.284840e+04
+8.130000e+02 1.279143e+04
+8.129500e+02 1.279143e+04
+8.129000e+02 1.283310e+04
+8.128500e+02 1.283310e+04
+8.128000e+02 1.284177e+04
+8.127500e+02 1.284177e+04
+8.127000e+02 1.279997e+04
+8.126500e+02 1.279997e+04
+8.126000e+02 1.279960e+04
+8.125500e+02 1.279960e+04
+8.125000e+02 1.285327e+04
+8.124500e+02 1.285327e+04
+8.124000e+02 1.291427e+04
+8.123500e+02 1.291427e+04
+8.123000e+02 1.289020e+04
+8.122500e+02 1.289020e+04
+8.122000e+02 1.293633e+04
+8.121500e+02 1.293633e+04
+8.121000e+02 1.291930e+04
+8.120500e+02 1.291930e+04
+8.120000e+02 1.283893e+04
+8.119500e+02 1.283893e+04
+8.119000e+02 1.291967e+04
+8.118500e+02 1.291967e+04
+8.118000e+02 1.288350e+04
+8.117500e+02 1.288350e+04
+8.117000e+02 1.300463e+04
+8.116500e+02 1.300463e+04
+8.116000e+02 1.293647e+04
+8.115500e+02 1.293647e+04
+8.115000e+02 1.288600e+04
+8.114500e+02 1.288600e+04
+8.114000e+02 1.289757e+04
+8.113500e+02 1.289757e+04
+8.113000e+02 1.287857e+04
+8.112500e+02 1.287857e+04
+8.112000e+02 1.288943e+04
+8.111500e+02 1.288943e+04
+8.111000e+02 1.292110e+04
+8.110500e+02 1.292110e+04
+8.110000e+02 1.288920e+04
+8.109500e+02 1.288920e+04
+8.109000e+02 1.299700e+04
+8.108500e+02 1.299700e+04
+8.108000e+02 1.302450e+04
+8.107500e+02 1.302450e+04
+8.107000e+02 1.306270e+04
+8.106500e+02 1.306270e+04
+8.106000e+02 1.302410e+04
+8.105500e+02 1.302410e+04
+8.105000e+02 1.297187e+04
+8.104500e+02 1.297187e+04
+8.104000e+02 1.289680e+04
+8.103500e+02 1.289680e+04
+8.103000e+02 1.295047e+04
+8.102500e+02 1.295047e+04
+8.102000e+02 1.298730e+04
+8.101500e+02 1.298730e+04
+8.101000e+02 1.303560e+04
+8.100500e+02 1.303560e+04
+8.100000e+02 1.302127e+04
+8.099500e+02 1.302127e+04
+8.099000e+02 1.300317e+04
+8.098500e+02 1.300317e+04
+8.098000e+02 1.294430e+04
+8.097500e+02 1.294430e+04
+8.097000e+02 1.305347e+04
+8.096500e+02 1.305347e+04
+8.096000e+02 1.309867e+04
+8.095500e+02 1.309867e+04
+8.095000e+02 1.307830e+04
+8.094500e+02 1.307830e+04
+8.094000e+02 1.313830e+04
+8.093500e+02 1.313830e+04
+8.093000e+02 1.306507e+04
+8.092500e+02 1.306507e+04
+8.092000e+02 1.307937e+04
+8.091500e+02 1.307937e+04
+8.091000e+02 1.304137e+04
+8.090500e+02 1.304137e+04
+8.090000e+02 1.307840e+04
+8.089500e+02 1.307840e+04
+8.089000e+02 1.329793e+04
+8.088500e+02 1.329793e+04
+8.088000e+02 1.314420e+04
+8.087500e+02 1.314420e+04
+8.087000e+02 1.311047e+04
+8.086500e+02 1.311047e+04
+8.086000e+02 1.316377e+04
+8.085500e+02 1.316377e+04
+8.085000e+02 1.316577e+04
+8.084500e+02 1.316577e+04
+8.084000e+02 1.314460e+04
+8.083500e+02 1.314460e+04
+8.083000e+02 1.317183e+04
+8.082500e+02 1.317183e+04
+8.082000e+02 1.315127e+04
+8.081500e+02 1.315127e+04
+8.081000e+02 1.315073e+04
+8.080500e+02 1.315073e+04
+8.080000e+02 1.315850e+04
+8.079500e+02 1.315850e+04
+8.079000e+02 1.317633e+04
+8.078500e+02 1.317633e+04
+8.078000e+02 1.305830e+04
+8.077500e+02 1.305830e+04
+8.077000e+02 1.311823e+04
+8.076500e+02 1.311823e+04
+8.076000e+02 1.314980e+04
+8.075500e+02 1.314980e+04
+8.075000e+02 1.318470e+04
+8.074500e+02 1.318470e+04
+8.074000e+02 1.320737e+04
+8.073500e+02 1.320737e+04
+8.073000e+02 1.321800e+04
+8.072500e+02 1.321800e+04
+8.072000e+02 1.320910e+04
+8.071500e+02 1.320910e+04
+8.071000e+02 1.314723e+04
+8.070500e+02 1.314723e+04
+8.070000e+02 1.313930e+04
+8.069500e+02 1.313930e+04
+8.069000e+02 1.315797e+04
+8.068500e+02 1.315797e+04
+8.068000e+02 1.318787e+04
+8.067500e+02 1.318787e+04
+8.067000e+02 1.323770e+04
+8.066500e+02 1.323770e+04
+8.066000e+02 1.316143e+04
+8.065500e+02 1.316143e+04
+8.065000e+02 1.316863e+04
+8.064500e+02 1.316863e+04
+8.064000e+02 1.329023e+04
+8.063500e+02 1.329023e+04
+8.063000e+02 1.326267e+04
+8.062500e+02 1.326267e+04
+8.062000e+02 1.326237e+04
+8.061500e+02 1.326237e+04
+8.061000e+02 1.325873e+04
+8.060500e+02 1.325873e+04
+8.060000e+02 1.323050e+04
+8.059500e+02 1.323050e+04
+8.059000e+02 1.324153e+04
+8.058500e+02 1.324153e+04
+8.058000e+02 1.324217e+04
+8.057500e+02 1.324217e+04
+8.057000e+02 1.328367e+04
+8.056500e+02 1.328367e+04
+8.056000e+02 1.323250e+04
+8.055500e+02 1.323250e+04
+8.055000e+02 1.330150e+04
+8.054500e+02 1.330150e+04
+8.054000e+02 1.332540e+04
+8.053500e+02 1.332540e+04
+8.053000e+02 1.323073e+04
+8.052500e+02 1.323073e+04
+8.052000e+02 1.326933e+04
+8.051500e+02 1.326933e+04
+8.051000e+02 1.330857e+04
+8.050500e+02 1.330857e+04
+8.050000e+02 1.329213e+04
+8.049500e+02 1.329213e+04
+8.049000e+02 1.329733e+04
+8.048500e+02 1.329733e+04
+8.048000e+02 1.332283e+04
+8.047500e+02 1.332283e+04
+8.047000e+02 1.319300e+04
+8.046500e+02 1.319300e+04
+8.046000e+02 1.328483e+04
+8.045500e+02 1.328483e+04
+8.045000e+02 1.323017e+04
+8.044500e+02 1.323017e+04
+8.044000e+02 1.329250e+04
+8.043500e+02 1.329250e+04
+8.043000e+02 1.328857e+04
+8.042500e+02 1.328857e+04
+8.042000e+02 1.326730e+04
+8.041500e+02 1.326730e+04
+8.041000e+02 1.326547e+04
+8.040500e+02 1.326547e+04
+8.040000e+02 1.335970e+04
+8.039500e+02 1.335970e+04
+8.039000e+02 1.337647e+04
+8.038500e+02 1.337647e+04
+8.038000e+02 1.326857e+04
+8.037500e+02 1.326857e+04
+8.037000e+02 1.328947e+04
+8.036500e+02 1.328947e+04
+8.036000e+02 1.325363e+04
+8.035500e+02 1.325363e+04
+8.035000e+02 1.326707e+04
+8.034500e+02 1.326707e+04
+8.034000e+02 1.325607e+04
+8.033500e+02 1.325607e+04
+8.033000e+02 1.324343e+04
+8.032500e+02 1.324343e+04
+8.032000e+02 1.321377e+04
+8.031500e+02 1.321377e+04
+8.031000e+02 1.333763e+04
+8.030500e+02 1.333763e+04
+8.030000e+02 1.328840e+04
+8.029500e+02 1.328840e+04
+8.029000e+02 1.334423e+04
+8.028500e+02 1.334423e+04
+8.028000e+02 1.326400e+04
+8.027500e+02 1.326400e+04
+8.027000e+02 1.328410e+04
+8.026500e+02 1.328410e+04
+8.026000e+02 1.330207e+04
+8.025500e+02 1.330207e+04
+8.025000e+02 1.324703e+04
+8.024500e+02 1.324703e+04
+8.024000e+02 1.320200e+04
+8.023500e+02 1.320200e+04
+8.023000e+02 1.327303e+04
+8.022500e+02 1.327303e+04
+8.022000e+02 1.326080e+04
+8.021500e+02 1.326080e+04
+8.021000e+02 1.332027e+04
+8.020500e+02 1.332027e+04
+8.020000e+02 1.336233e+04
+8.019500e+02 1.336233e+04
+8.019000e+02 1.327123e+04
+8.018500e+02 1.327123e+04
+8.018000e+02 1.333897e+04
+8.017500e+02 1.333897e+04
+8.017000e+02 1.331943e+04
+8.016500e+02 1.331943e+04
+8.016000e+02 1.330037e+04
+8.015500e+02 1.330037e+04
+8.015000e+02 1.321880e+04
+8.014500e+02 1.321880e+04
+8.014000e+02 1.333360e+04
+8.013500e+02 1.333360e+04
+8.013000e+02 1.327730e+04
+8.012500e+02 1.327730e+04
+8.012000e+02 1.327140e+04
+8.011500e+02 1.327140e+04
+8.011000e+02 1.325337e+04
+8.010500e+02 1.325337e+04
+8.010000e+02 1.329303e+04
+8.009500e+02 1.329303e+04
+8.009000e+02 1.325050e+04
+8.008500e+02 1.325050e+04
+8.008000e+02 1.320833e+04
+8.007500e+02 1.320833e+04
+8.007000e+02 1.330303e+04
+8.006500e+02 1.330303e+04
+8.006000e+02 1.323807e+04
+8.005500e+02 1.323807e+04
+8.005000e+02 1.322130e+04
+8.004500e+02 1.322130e+04
+8.004000e+02 1.319397e+04
+8.003500e+02 1.319397e+04
+8.003000e+02 1.323393e+04
+8.002500e+02 1.323393e+04
+8.002000e+02 1.324987e+04
+8.001500e+02 1.324987e+04
+8.001000e+02 1.331130e+04
+8.000500e+02 1.331130e+04
+8.000000e+02 1.331813e+04
+7.999500e+02 1.331813e+04
+7.999000e+02 1.327717e+04
+7.998500e+02 1.327717e+04
+7.998000e+02 1.326180e+04
+7.997500e+02 1.326180e+04
+7.997000e+02 1.325967e+04
+7.996500e+02 1.325967e+04
+7.996000e+02 1.328273e+04
+7.995500e+02 1.328273e+04
+7.995000e+02 1.324727e+04
+7.994500e+02 1.324727e+04
+7.994000e+02 1.315527e+04
+7.993500e+02 1.315527e+04
+7.993000e+02 1.312643e+04
+7.992500e+02 1.312643e+04
+7.992000e+02 1.321877e+04
+7.991500e+02 1.321877e+04
+7.991000e+02 1.318867e+04
+7.990500e+02 1.318867e+04
+7.990000e+02 1.315933e+04
+7.989500e+02 1.315933e+04
+7.989000e+02 1.327430e+04
+7.988500e+02 1.327430e+04
+7.988000e+02 1.329857e+04
+7.987500e+02 1.329857e+04
+7.987000e+02 1.331350e+04
+7.986500e+02 1.331350e+04
+7.986000e+02 1.330170e+04
+7.985500e+02 1.330170e+04
+7.985000e+02 1.336710e+04
+7.984500e+02 1.336710e+04
+7.984000e+02 1.331233e+04
+7.983500e+02 1.331233e+04
+7.983000e+02 1.325897e+04
+7.982500e+02 1.325897e+04
+7.982000e+02 1.337250e+04
+7.981500e+02 1.337250e+04
+7.981000e+02 1.340307e+04
+7.980500e+02 1.340307e+04
+7.980000e+02 1.325933e+04
+7.979500e+02 1.325933e+04
+7.979000e+02 1.325727e+04
+7.978500e+02 1.325727e+04
+7.978000e+02 1.326523e+04
+7.977500e+02 1.326523e+04
+7.977000e+02 1.330570e+04
+7.976500e+02 1.330570e+04
+7.976000e+02 1.331447e+04
+7.975500e+02 1.331447e+04
+7.975000e+02 1.316683e+04
+7.974500e+02 1.316683e+04
+7.974000e+02 1.317140e+04
+7.973500e+02 1.317140e+04
+7.973000e+02 1.322833e+04
+7.972500e+02 1.322833e+04
+7.972000e+02 1.331303e+04
+7.971500e+02 1.331303e+04
+7.971000e+02 1.320807e+04
+7.970500e+02 1.320807e+04
+7.970000e+02 1.319537e+04
+7.969500e+02 1.319537e+04
+7.969000e+02 1.324897e+04
+7.968500e+02 1.324897e+04
+7.968000e+02 1.320590e+04
+7.967500e+02 1.320590e+04
+7.967000e+02 1.327487e+04
+7.966500e+02 1.327487e+04
+7.966000e+02 1.328207e+04
+7.965500e+02 1.328207e+04
+7.965000e+02 1.335607e+04
+7.964500e+02 1.335607e+04
+7.964000e+02 1.331963e+04
+7.963500e+02 1.331963e+04
+7.963000e+02 1.331420e+04
+7.962500e+02 1.331420e+04
+7.962000e+02 1.331357e+04
+7.961500e+02 1.331357e+04
+7.961000e+02 1.320723e+04
+7.960500e+02 1.320723e+04
+7.960000e+02 1.337373e+04
+7.959500e+02 1.337373e+04
+7.959000e+02 1.335917e+04
+7.958500e+02 1.335917e+04
+7.958000e+02 1.337387e+04
+7.957500e+02 1.337387e+04
+7.957000e+02 1.335470e+04
+7.956500e+02 1.335470e+04
+7.956000e+02 1.330743e+04
+7.955500e+02 1.330743e+04
+7.955000e+02 1.336583e+04
+7.954500e+02 1.336583e+04
+7.954000e+02 1.335733e+04
+7.953500e+02 1.335733e+04
+7.953000e+02 1.332403e+04
+7.952500e+02 1.332403e+04
+7.952000e+02 1.334847e+04
+7.951500e+02 1.334847e+04
+7.951000e+02 1.339883e+04
+7.950500e+02 1.339883e+04
+7.950000e+02 1.338147e+04
+7.949500e+02 1.338147e+04
+7.949000e+02 1.336307e+04
+7.948500e+02 1.336307e+04
+7.948000e+02 1.339350e+04
+7.947500e+02 1.339350e+04
+7.947000e+02 1.340780e+04
+7.946500e+02 1.340780e+04
+7.946000e+02 1.342607e+04
+7.945500e+02 1.342607e+04
+7.945000e+02 1.336553e+04
+7.944500e+02 1.336553e+04
+7.944000e+02 1.339420e+04
+7.943500e+02 1.339420e+04
+7.943000e+02 1.341863e+04
+7.942500e+02 1.341863e+04
+7.942000e+02 1.342023e+04
+7.941500e+02 1.342023e+04
+7.941000e+02 1.341090e+04
+7.940500e+02 1.341090e+04
+7.940000e+02 1.344083e+04
+7.939500e+02 1.344083e+04
+7.939000e+02 1.352590e+04
+7.938500e+02 1.352590e+04
+7.938000e+02 1.357730e+04
+7.937500e+02 1.357730e+04
+7.937000e+02 1.356407e+04
+7.936500e+02 1.356407e+04
+7.936000e+02 1.342417e+04
+7.935500e+02 1.342417e+04
+7.935000e+02 1.354110e+04
+7.934500e+02 1.354110e+04
+7.934000e+02 1.354680e+04
+7.933500e+02 1.354680e+04
+7.933000e+02 1.355463e+04
+7.932500e+02 1.355463e+04
+7.932000e+02 1.356993e+04
+7.931500e+02 1.356993e+04
+7.931000e+02 1.356580e+04
+7.930500e+02 1.356580e+04
+7.930000e+02 1.354893e+04
+7.929500e+02 1.354893e+04
+7.929000e+02 1.352237e+04
+7.928500e+02 1.352237e+04
+7.928000e+02 1.352707e+04
+7.927500e+02 1.352707e+04
+7.927000e+02 1.355170e+04
+7.926500e+02 1.355170e+04
+7.926000e+02 1.354480e+04
+7.925500e+02 1.354480e+04
+7.925000e+02 1.369157e+04
+7.924500e+02 1.369157e+04
+7.924000e+02 1.351853e+04
+7.923500e+02 1.351853e+04
+7.923000e+02 1.366857e+04
+7.922500e+02 1.366857e+04
+7.922000e+02 1.365883e+04
+7.921500e+02 1.365883e+04
+7.921000e+02 1.373963e+04
+7.920500e+02 1.373963e+04
+7.920000e+02 1.372353e+04
+7.919500e+02 1.372353e+04
+7.919000e+02 1.381933e+04
+7.918500e+02 1.381933e+04
+7.918000e+02 1.377490e+04
+7.917500e+02 1.377490e+04
+7.917000e+02 1.379887e+04
+7.916500e+02 1.379887e+04
+7.916000e+02 1.393527e+04
+7.915500e+02 1.393527e+04
+7.915000e+02 1.387790e+04
+7.914500e+02 1.387790e+04
+7.914000e+02 1.390080e+04
+7.913500e+02 1.390080e+04
+7.913000e+02 1.390610e+04
+7.912500e+02 1.390610e+04
+7.912000e+02 1.396727e+04
+7.911500e+02 1.396727e+04
+7.911000e+02 1.410180e+04
+7.910500e+02 1.410180e+04
+7.910000e+02 1.403630e+04
+7.909500e+02 1.403630e+04
+7.909000e+02 1.404627e+04
+7.908500e+02 1.404627e+04
+7.908000e+02 1.407660e+04
+7.907500e+02 1.407660e+04
+7.907000e+02 1.417137e+04
+7.906500e+02 1.417137e+04
+7.906000e+02 1.416837e+04
+7.905500e+02 1.416837e+04
+7.905000e+02 1.415563e+04
+7.904500e+02 1.415563e+04
+7.904000e+02 1.418750e+04
+7.903500e+02 1.418750e+04
+7.903000e+02 1.427023e+04
+7.902500e+02 1.427023e+04
+7.902000e+02 1.423573e+04
+7.901500e+02 1.423573e+04
+7.901000e+02 1.428217e+04
+7.900500e+02 1.428217e+04
+7.900000e+02 1.425783e+04
+7.899500e+02 1.425783e+04
+7.899000e+02 1.428870e+04
+7.898500e+02 1.428870e+04
+7.898000e+02 1.434883e+04
+7.897500e+02 1.434883e+04
+7.897000e+02 1.433053e+04
+7.896500e+02 1.433053e+04
+7.896000e+02 1.443167e+04
+7.895500e+02 1.443167e+04
+7.895000e+02 1.449420e+04
+7.894500e+02 1.449420e+04
+7.894000e+02 1.458427e+04
+7.893500e+02 1.458427e+04
+7.893000e+02 1.460697e+04
+7.892500e+02 1.460697e+04
+7.892000e+02 1.460373e+04
+7.891500e+02 1.460373e+04
+7.891000e+02 1.466807e+04
+7.890500e+02 1.466807e+04
+7.890000e+02 1.471883e+04
+7.889500e+02 1.471883e+04
+7.889000e+02 1.480210e+04
+7.888500e+02 1.480210e+04
+7.888000e+02 1.491227e+04
+7.887500e+02 1.491227e+04
+7.887000e+02 1.489510e+04
+7.886500e+02 1.489510e+04
+7.886000e+02 1.488003e+04
+7.885500e+02 1.488003e+04
+7.885000e+02 1.487333e+04
+7.884500e+02 1.487333e+04
+7.884000e+02 1.500240e+04
+7.883500e+02 1.500240e+04
+7.883000e+02 1.513350e+04
+7.882500e+02 1.513350e+04
+7.882000e+02 1.519807e+04
+7.881500e+02 1.519807e+04
+7.881000e+02 1.524927e+04
+7.880500e+02 1.524927e+04
+7.880000e+02 1.526290e+04
+7.879500e+02 1.526290e+04
+7.879000e+02 1.527737e+04
+7.878500e+02 1.527737e+04
+7.878000e+02 1.532447e+04
+7.877500e+02 1.532447e+04
+7.877000e+02 1.550680e+04
+7.876500e+02 1.550680e+04
+7.876000e+02 1.558333e+04
+7.875500e+02 1.558333e+04
+7.875000e+02 1.561917e+04
+7.874500e+02 1.561917e+04
+7.874000e+02 1.566980e+04
+7.873500e+02 1.566980e+04
+7.873000e+02 1.567867e+04
+7.872500e+02 1.567867e+04
+7.872000e+02 1.578033e+04
+7.871500e+02 1.578033e+04
+7.871000e+02 1.585417e+04
+7.870500e+02 1.585417e+04
+7.870000e+02 1.586587e+04
+7.869500e+02 1.586587e+04
+7.869000e+02 1.598147e+04
+7.868500e+02 1.598147e+04
+7.868000e+02 1.614213e+04
+7.867500e+02 1.614213e+04
+7.867000e+02 1.621113e+04
+7.866500e+02 1.621113e+04
+7.866000e+02 1.634027e+04
+7.865500e+02 1.634027e+04
+7.865000e+02 1.642330e+04
+7.864500e+02 1.642330e+04
+7.864000e+02 1.649590e+04
+7.863500e+02 1.649590e+04
+7.863000e+02 1.663760e+04
+7.862500e+02 1.663760e+04
+7.862000e+02 1.670373e+04
+7.861500e+02 1.670373e+04
+7.861000e+02 1.678383e+04
+7.860500e+02 1.678383e+04
+7.860000e+02 1.702413e+04
+7.859500e+02 1.702413e+04
+7.859000e+02 1.714727e+04
+7.858500e+02 1.714727e+04
+7.858000e+02 1.728017e+04
+7.857500e+02 1.728017e+04
+7.857000e+02 1.728657e+04
+7.856500e+02 1.728657e+04
+7.856000e+02 1.743817e+04
+7.855500e+02 1.743817e+04
+7.855000e+02 1.760353e+04
+7.854500e+02 1.760353e+04
+7.854000e+02 1.770157e+04
+7.853500e+02 1.770157e+04
+7.853000e+02 1.783420e+04
+7.852500e+02 1.783420e+04
+7.852000e+02 1.806657e+04
+7.851500e+02 1.806657e+04
+7.851000e+02 1.818273e+04
+7.850500e+02 1.818273e+04
+7.850000e+02 1.835230e+04
+7.849500e+02 1.835230e+04
+7.849000e+02 1.832780e+04
+7.848500e+02 1.832780e+04
+7.848000e+02 1.865170e+04
+7.847500e+02 1.865170e+04
+7.847000e+02 1.875273e+04
+7.846500e+02 1.875273e+04
+7.846000e+02 1.888383e+04
+7.845500e+02 1.888383e+04
+7.845000e+02 1.894797e+04
+7.844500e+02 1.894797e+04
+7.844000e+02 1.914487e+04
+7.843500e+02 1.914487e+04
+7.843000e+02 1.924320e+04
+7.842500e+02 1.924320e+04
+7.842000e+02 1.937047e+04
+7.841500e+02 1.937047e+04
+7.841000e+02 1.946657e+04
+7.840500e+02 1.946657e+04
+7.840000e+02 1.959153e+04
+7.839500e+02 1.959153e+04
+7.839000e+02 1.962723e+04
+7.838500e+02 1.962723e+04
+7.838000e+02 1.967310e+04
+7.837500e+02 1.967310e+04
+7.837000e+02 1.960860e+04
+7.836500e+02 1.960860e+04
+7.836000e+02 1.960923e+04
+7.835500e+02 1.960923e+04
+7.835000e+02 1.957250e+04
+7.834500e+02 1.957250e+04
+7.834000e+02 1.952710e+04
+7.833500e+02 1.952710e+04
+7.833000e+02 1.956763e+04
+7.832500e+02 1.956763e+04
+7.832000e+02 1.945663e+04
+7.831500e+02 1.945663e+04
+7.831000e+02 1.939967e+04
+7.830500e+02 1.939967e+04
+7.830000e+02 1.926527e+04
+7.829500e+02 1.926527e+04
+7.829000e+02 1.912447e+04
+7.828500e+02 1.912447e+04
+7.828000e+02 1.899710e+04
+7.827500e+02 1.899710e+04
+7.827000e+02 1.898933e+04
+7.826500e+02 1.898933e+04
+7.826000e+02 1.883930e+04
+7.825500e+02 1.883930e+04
+7.825000e+02 1.860500e+04
+7.824500e+02 1.860500e+04
+7.824000e+02 1.852927e+04
+7.823500e+02 1.852927e+04
+7.823000e+02 1.832617e+04
+7.822500e+02 1.832617e+04
+7.822000e+02 1.813903e+04
+7.821500e+02 1.813903e+04
+7.821000e+02 1.800097e+04
+7.820500e+02 1.800097e+04
+7.820000e+02 1.774730e+04
+7.819500e+02 1.774730e+04
+7.819000e+02 1.758843e+04
+7.818500e+02 1.758843e+04
+7.818000e+02 1.753750e+04
+7.817500e+02 1.753750e+04
+7.817000e+02 1.735467e+04
+7.816500e+02 1.735467e+04
+7.816000e+02 1.711353e+04
+7.815500e+02 1.711353e+04
+7.815000e+02 1.687703e+04
+7.814500e+02 1.687703e+04
+7.814000e+02 1.678667e+04
+7.813500e+02 1.678667e+04
+7.813000e+02 1.654727e+04
+7.812500e+02 1.654727e+04
+7.812000e+02 1.632123e+04
+7.811500e+02 1.632123e+04
+7.811000e+02 1.612153e+04
+7.810500e+02 1.612153e+04
+7.810000e+02 1.601067e+04
+7.809500e+02 1.601067e+04
+7.809000e+02 1.583603e+04
+7.808500e+02 1.583603e+04
+7.808000e+02 1.569153e+04
+7.807500e+02 1.569153e+04
+7.807000e+02 1.539773e+04
+7.806500e+02 1.539773e+04
+7.806000e+02 1.526270e+04
+7.805500e+02 1.526270e+04
+7.805000e+02 1.511960e+04
+7.804500e+02 1.511960e+04
+7.804000e+02 1.493013e+04
+7.803500e+02 1.493013e+04
+7.803000e+02 1.468577e+04
+7.802500e+02 1.468577e+04
+7.802000e+02 1.462830e+04
+7.801500e+02 1.462830e+04
+7.801000e+02 1.456130e+04
+7.800500e+02 1.456130e+04
+7.800000e+02 1.433870e+04
+7.799500e+02 1.433870e+04
+7.799000e+02 1.425900e+04
+7.798500e+02 1.425900e+04
+7.798000e+02 1.408923e+04
+7.797500e+02 1.408923e+04
+7.797000e+02 1.402560e+04
+7.796500e+02 1.402560e+04
+7.796000e+02 1.391627e+04
+7.795500e+02 1.391627e+04
+7.795000e+02 1.374707e+04
+7.794500e+02 1.374707e+04
+7.794000e+02 1.358487e+04
+7.793500e+02 1.358487e+04
+7.793000e+02 1.359330e+04
+7.792500e+02 1.359330e+04
+7.792000e+02 1.350517e+04
+7.791500e+02 1.350517e+04
+7.791000e+02 1.344150e+04
+7.790500e+02 1.344150e+04
+7.790000e+02 1.331193e+04
+7.789500e+02 1.331193e+04
+7.789000e+02 1.327327e+04
+7.788500e+02 1.327327e+04
+7.788000e+02 1.319563e+04
+7.787500e+02 1.319563e+04
+7.787000e+02 1.301527e+04
+7.786500e+02 1.301527e+04
+7.786000e+02 1.300677e+04
+7.785500e+02 1.300677e+04
+7.785000e+02 1.297547e+04
+7.784500e+02 1.297547e+04
+7.784000e+02 1.284420e+04
+7.783500e+02 1.284420e+04
+7.783000e+02 1.282450e+04
+7.782500e+02 1.282450e+04
+7.782000e+02 1.276037e+04
+7.781500e+02 1.276037e+04
+7.781000e+02 1.271757e+04
+7.780500e+02 1.271757e+04
+7.780000e+02 1.273813e+04
+7.779500e+02 1.273813e+04
+7.779000e+02 1.261417e+04
+7.778500e+02 1.261417e+04
+7.778000e+02 1.260547e+04
+7.777500e+02 1.260547e+04
+7.777000e+02 1.258867e+04
+7.776500e+02 1.258867e+04
+7.776000e+02 1.264663e+04
+7.775500e+02 1.264663e+04
+7.775000e+02 1.245237e+04
+7.774500e+02 1.245237e+04
+7.774000e+02 1.247947e+04
+7.773500e+02 1.247947e+04
+7.773000e+02 1.245857e+04
+7.772500e+02 1.245857e+04
+7.772000e+02 1.246423e+04
+7.771500e+02 1.246423e+04
+7.771000e+02 1.246427e+04
+7.770500e+02 1.246427e+04
+7.770000e+02 1.256533e+04
+7.769500e+02 1.256533e+04
+7.769000e+02 1.250950e+04
+7.768500e+02 1.250950e+04
+7.768000e+02 1.243407e+04
+7.767500e+02 1.243407e+04
+7.767000e+02 1.239107e+04
+7.766500e+02 1.239107e+04
+7.766000e+02 1.239260e+04
+7.765500e+02 1.239260e+04
+7.765000e+02 1.229333e+04
+7.764500e+02 1.229333e+04
+7.764000e+02 1.235893e+04
+7.763500e+02 1.235893e+04
+7.763000e+02 1.225570e+04
+7.762500e+02 1.225570e+04
+7.762000e+02 1.235953e+04
+7.761500e+02 1.235953e+04
+7.761000e+02 1.240110e+04
+7.760500e+02 1.240110e+04
+7.760000e+02 1.238160e+04
+7.759500e+02 1.238160e+04
+7.759000e+02 1.222120e+04
+7.758500e+02 1.222120e+04
+7.758000e+02 1.229143e+04
+7.757500e+02 1.229143e+04
+7.757000e+02 1.232070e+04
+7.756500e+02 1.232070e+04
+7.756000e+02 1.227730e+04
+7.755500e+02 1.227730e+04
+7.755000e+02 1.232050e+04
+7.754500e+02 1.232050e+04
+7.754000e+02 1.230887e+04
+7.753500e+02 1.230887e+04
+7.753000e+02 1.222780e+04
+7.752500e+02 1.222780e+04
+7.752000e+02 1.221990e+04
+7.751500e+02 1.221990e+04
+7.751000e+02 1.221053e+04
+7.750500e+02 1.221053e+04
+7.750000e+02 1.232223e+04
+7.749500e+02 1.232223e+04
+7.749000e+02 1.225627e+04
+7.748500e+02 1.225627e+04
+7.748000e+02 1.226510e+04
+7.747500e+02 1.226510e+04
+7.747000e+02 1.225943e+04
+7.746500e+02 1.225943e+04
+7.746000e+02 1.230543e+04
+7.745500e+02 1.230543e+04
+7.745000e+02 1.228860e+04
+7.744500e+02 1.228860e+04
+7.744000e+02 1.226417e+04
+7.743500e+02 1.226417e+04
+7.743000e+02 1.231193e+04
+7.742500e+02 1.231193e+04
+7.742000e+02 1.228550e+04
+7.741500e+02 1.228550e+04
+7.741000e+02 1.228807e+04
+7.740500e+02 1.228807e+04
+7.740000e+02 1.226220e+04
+7.739500e+02 1.226220e+04
+7.739000e+02 1.225540e+04
+7.738500e+02 1.225540e+04
+7.738000e+02 1.225827e+04
+7.737500e+02 1.225827e+04
+7.737000e+02 1.235967e+04
+7.736500e+02 1.235967e+04
+7.736000e+02 1.235553e+04
+7.735500e+02 1.235553e+04
+7.735000e+02 1.235633e+04
+7.734500e+02 1.235633e+04
+7.734000e+02 1.245013e+04
+7.733500e+02 1.245013e+04
+7.733000e+02 1.241320e+04
+7.732500e+02 1.241320e+04
+7.732000e+02 1.235783e+04
+7.731500e+02 1.235783e+04
+7.731000e+02 1.237317e+04
+7.730500e+02 1.237317e+04
+7.730000e+02 1.240170e+04
+7.729500e+02 1.240170e+04
+7.729000e+02 1.242090e+04
+7.728500e+02 1.242090e+04
+7.728000e+02 1.246460e+04
+7.727500e+02 1.246460e+04
+7.727000e+02 1.244793e+04
+7.726500e+02 1.244793e+04
+7.726000e+02 1.238167e+04
+7.725500e+02 1.238167e+04
+7.725000e+02 1.248827e+04
+7.724500e+02 1.248827e+04
+7.724000e+02 1.249427e+04
+7.723500e+02 1.249427e+04
+7.723000e+02 1.258477e+04
+7.722500e+02 1.258477e+04
+7.722000e+02 1.251180e+04
+7.721500e+02 1.251180e+04
+7.721000e+02 1.257623e+04
+7.720500e+02 1.257623e+04
+7.720000e+02 1.255843e+04
+7.719500e+02 1.255843e+04
+7.719000e+02 1.251143e+04
+7.718500e+02 1.251143e+04
+7.718000e+02 1.258267e+04
+7.717500e+02 1.258267e+04
+7.717000e+02 1.266060e+04
+7.716500e+02 1.266060e+04
+7.716000e+02 1.263583e+04
+7.715500e+02 1.263583e+04
+7.715000e+02 1.272277e+04
+7.714500e+02 1.272277e+04
+7.714000e+02 1.272013e+04
+7.713500e+02 1.272013e+04
+7.713000e+02 1.275507e+04
+7.712500e+02 1.275507e+04
+7.712000e+02 1.270343e+04
+7.711500e+02 1.270343e+04
+7.711000e+02 1.279613e+04
+7.710500e+02 1.279613e+04
+7.710000e+02 1.275703e+04
+7.709500e+02 1.275703e+04
+7.709000e+02 1.271980e+04
+7.708500e+02 1.271980e+04
+7.708000e+02 1.277603e+04
+7.707500e+02 1.277603e+04
+7.707000e+02 1.279320e+04
+7.706500e+02 1.279320e+04
+7.706000e+02 1.275100e+04
+7.705500e+02 1.275100e+04
+7.705000e+02 1.281183e+04
+7.704500e+02 1.281183e+04
+7.704000e+02 1.278773e+04
+7.703500e+02 1.278773e+04
+7.703000e+02 1.289853e+04
+7.702500e+02 1.289853e+04
+7.702000e+02 1.282087e+04
+7.701500e+02 1.282087e+04
+7.701000e+02 1.276187e+04
+7.700500e+02 1.276187e+04
+7.700000e+02 1.271530e+04
+7.699500e+02 1.271530e+04
+7.699000e+02 1.264237e+04
+7.698500e+02 1.264237e+04
+7.698000e+02 1.275040e+04
+7.697500e+02 1.275040e+04
+7.697000e+02 1.274703e+04
+7.696500e+02 1.274703e+04
+7.696000e+02 1.267643e+04
+7.695500e+02 1.267643e+04
+7.695000e+02 1.270030e+04
+7.694500e+02 1.270030e+04
+7.694000e+02 1.265630e+04
+7.693500e+02 1.265630e+04
+7.693000e+02 1.264647e+04
+7.692500e+02 1.264647e+04
+7.692000e+02 1.268750e+04
+7.691500e+02 1.268750e+04
+7.691000e+02 1.266227e+04
+7.690500e+02 1.266227e+04
+7.690000e+02 1.261413e+04
+7.689500e+02 1.261413e+04
+7.689000e+02 1.263573e+04
+7.688500e+02 1.263573e+04
+7.688000e+02 1.257803e+04
+7.687500e+02 1.257803e+04
+7.687000e+02 1.259350e+04
+7.686500e+02 1.259350e+04
+7.686000e+02 1.260850e+04
+7.685500e+02 1.260850e+04
+7.685000e+02 1.251627e+04
+7.684500e+02 1.251627e+04
+7.684000e+02 1.243707e+04
+7.683500e+02 1.243707e+04
+7.683000e+02 1.250850e+04
+7.682500e+02 1.250850e+04
+7.682000e+02 1.249407e+04
+7.681500e+02 1.249407e+04
+7.681000e+02 1.241647e+04
+7.680500e+02 1.241647e+04
+7.680000e+02 1.242397e+04
+7.679500e+02 1.242397e+04
+7.679000e+02 1.244067e+04
+7.678500e+02 1.244067e+04
+7.678000e+02 1.235783e+04
+7.677500e+02 1.235783e+04
+7.677000e+02 1.232223e+04
+7.676500e+02 1.232223e+04
+7.676000e+02 1.226930e+04
+7.675500e+02 1.226930e+04
+7.675000e+02 1.228057e+04
+7.674500e+02 1.228057e+04
+7.674000e+02 1.227547e+04
+7.673500e+02 1.227547e+04
+7.673000e+02 1.228203e+04
+7.672500e+02 1.228203e+04
+7.672000e+02 1.217167e+04
+7.671500e+02 1.217167e+04
+7.671000e+02 1.219343e+04
+7.670500e+02 1.219343e+04
+7.670000e+02 1.217217e+04
+7.669500e+02 1.217217e+04
+7.669000e+02 1.220833e+04
+7.668500e+02 1.220833e+04
+7.668000e+02 1.216823e+04
+7.667500e+02 1.216823e+04
+7.667000e+02 1.217883e+04
+7.666500e+02 1.217883e+04
+7.666000e+02 1.215050e+04
+7.665500e+02 1.215050e+04
+7.665000e+02 1.214550e+04
+7.664500e+02 1.214550e+04
+7.664000e+02 1.208947e+04
+7.663500e+02 1.208947e+04
+7.663000e+02 1.209080e+04
+7.662500e+02 1.209080e+04
+7.662000e+02 1.210400e+04
+7.661500e+02 1.210400e+04
+7.661000e+02 1.205203e+04
+7.660500e+02 1.205203e+04
+7.660000e+02 1.208413e+04
+7.659500e+02 1.208413e+04
+7.659000e+02 1.205983e+04
+7.658500e+02 1.205983e+04
+7.658000e+02 1.201577e+04
+7.657500e+02 1.201577e+04
+7.657000e+02 1.211623e+04
+7.656500e+02 1.211623e+04
+7.656000e+02 1.203503e+04
+7.655500e+02 1.203503e+04
+7.655000e+02 1.204027e+04
+7.654500e+02 1.204027e+04
+7.654000e+02 1.204640e+04
+7.653500e+02 1.204640e+04
+7.653000e+02 1.205240e+04
+7.652500e+02 1.205240e+04
+7.652000e+02 1.204033e+04
+7.651500e+02 1.204033e+04
+7.651000e+02 1.206450e+04
+7.650500e+02 1.206450e+04
+7.650000e+02 1.208907e+04
+7.649500e+02 1.208907e+04
+7.649000e+02 1.206347e+04
+7.648500e+02 1.206347e+04
+7.648000e+02 1.200643e+04
+7.647500e+02 1.200643e+04
+7.647000e+02 1.200193e+04
+7.646500e+02 1.200193e+04
+7.646000e+02 1.198157e+04
+7.645500e+02 1.198157e+04
+7.645000e+02 1.202983e+04
+7.644500e+02 1.202983e+04
+7.644000e+02 1.205987e+04
+7.643500e+02 1.205987e+04
+7.643000e+02 1.199247e+04
+7.642500e+02 1.199247e+04
+7.642000e+02 1.204173e+04
+7.641500e+02 1.204173e+04
+7.641000e+02 1.197743e+04
+7.640500e+02 1.197743e+04
+7.640000e+02 1.200790e+04
+7.639500e+02 1.200790e+04
+7.639000e+02 1.192613e+04
+7.638500e+02 1.192613e+04
+7.638000e+02 1.204527e+04
+7.637500e+02 1.204527e+04
+7.637000e+02 1.204063e+04
+7.636500e+02 1.204063e+04
+7.636000e+02 1.202180e+04
+7.635500e+02 1.202180e+04
+7.635000e+02 1.194487e+04
+7.634500e+02 1.194487e+04
+7.634000e+02 1.193387e+04
+7.633500e+02 1.193387e+04
+7.633000e+02 1.197630e+04
+7.632500e+02 1.197630e+04
+7.632000e+02 1.200587e+04
+7.631500e+02 1.200587e+04
+7.631000e+02 1.198810e+04
+7.630500e+02 1.198810e+04
+7.630000e+02 1.194070e+04
+7.629500e+02 1.194070e+04
+7.629000e+02 1.196533e+04
+7.628500e+02 1.196533e+04
+7.628000e+02 1.199783e+04
+7.627500e+02 1.199783e+04
+7.627000e+02 1.199293e+04
+7.626500e+02 1.199293e+04
+7.626000e+02 1.195787e+04
+7.625500e+02 1.195787e+04
+7.625000e+02 1.191593e+04
+7.624500e+02 1.191593e+04
+7.624000e+02 1.196613e+04
+7.623500e+02 1.196613e+04
+7.623000e+02 1.190710e+04
+7.622500e+02 1.190710e+04
+7.622000e+02 1.184143e+04
+7.621500e+02 1.184143e+04
+7.621000e+02 1.194490e+04
+7.620500e+02 1.194490e+04
+7.620000e+02 1.196843e+04
+7.619500e+02 1.196843e+04
+7.619000e+02 1.190047e+04
+7.618500e+02 1.190047e+04
+7.618000e+02 1.187037e+04
+7.617500e+02 1.187037e+04
+7.617000e+02 1.188017e+04
+7.616500e+02 1.188017e+04
+7.616000e+02 1.192827e+04
+7.615500e+02 1.192827e+04
+7.615000e+02 1.190573e+04
+7.614500e+02 1.190573e+04
+7.614000e+02 1.185710e+04
+7.613500e+02 1.185710e+04
+7.613000e+02 1.188530e+04
+7.612500e+02 1.188530e+04
+7.612000e+02 1.184503e+04
+7.611500e+02 1.184503e+04
+7.611000e+02 1.191323e+04
+7.610500e+02 1.191323e+04
+7.610000e+02 1.190413e+04
+7.609500e+02 1.190413e+04
+7.609000e+02 1.188820e+04
+7.608500e+02 1.188820e+04
+7.608000e+02 1.188250e+04
+7.607500e+02 1.188250e+04
+7.607000e+02 1.196090e+04
+7.606500e+02 1.196090e+04
+7.606000e+02 1.187453e+04
+7.605500e+02 1.187453e+04
+7.605000e+02 1.185647e+04
+7.604500e+02 1.185647e+04
+7.604000e+02 1.186047e+04
+7.603500e+02 1.186047e+04
+7.603000e+02 1.190313e+04
+7.602500e+02 1.190313e+04
+7.602000e+02 1.191363e+04
+7.601500e+02 1.191363e+04
+7.601000e+02 1.193403e+04
+7.600500e+02 1.193403e+04
+7.600000e+02 1.201623e+04
+7.599500e+02 1.201623e+04
+7.599000e+02 1.194003e+04
+7.598500e+02 1.194003e+04
+7.598000e+02 1.191370e+04
+7.597500e+02 1.191370e+04
+7.597000e+02 1.189137e+04
+7.596500e+02 1.189137e+04
+7.596000e+02 1.192703e+04
+7.595500e+02 1.192703e+04
+7.595000e+02 1.191327e+04
+7.594500e+02 1.191327e+04
+7.594000e+02 1.186363e+04
+7.593500e+02 1.186363e+04
+7.593000e+02 1.196920e+04
+7.592500e+02 1.196920e+04
+7.592000e+02 1.189050e+04
+7.591500e+02 1.189050e+04
+7.591000e+02 1.197160e+04
+7.590500e+02 1.197160e+04
+7.590000e+02 1.199770e+04
+7.589500e+02 1.199770e+04
+7.589000e+02 1.195550e+04
+7.588500e+02 1.195550e+04
+7.588000e+02 1.194043e+04
+7.587500e+02 1.194043e+04
+7.587000e+02 1.191203e+04
+7.586500e+02 1.191203e+04
+7.586000e+02 1.198707e+04
+7.585500e+02 1.198707e+04
+7.585000e+02 1.196603e+04
+7.584500e+02 1.196603e+04
+7.584000e+02 1.201617e+04
+7.583500e+02 1.201617e+04
+7.583000e+02 1.207980e+04
+7.582500e+02 1.207980e+04
+7.582000e+02 1.208527e+04
+7.581500e+02 1.208527e+04
+7.581000e+02 1.208117e+04
+7.580500e+02 1.208117e+04
+7.580000e+02 1.208753e+04
+7.579500e+02 1.208753e+04
+7.579000e+02 1.208407e+04
+7.578500e+02 1.208407e+04
+7.578000e+02 1.214540e+04
+7.577500e+02 1.214540e+04
+7.577000e+02 1.217993e+04
+7.576500e+02 1.217993e+04
+7.576000e+02 1.209083e+04
+7.575500e+02 1.209083e+04
+7.575000e+02 1.222933e+04
+7.574500e+02 1.222933e+04
+7.574000e+02 1.221093e+04
+7.573500e+02 1.221093e+04
+7.573000e+02 1.215723e+04
+7.572500e+02 1.215723e+04
+7.572000e+02 1.219220e+04
+7.571500e+02 1.219220e+04
+7.571000e+02 1.218740e+04
+7.570500e+02 1.218740e+04
+7.570000e+02 1.220737e+04
+7.569500e+02 1.220737e+04
+7.569000e+02 1.223510e+04
+7.568500e+02 1.223510e+04
+7.568000e+02 1.217427e+04
+7.567500e+02 1.217427e+04
+7.567000e+02 1.227530e+04
+7.566500e+02 1.227530e+04
+7.566000e+02 1.232970e+04
+7.565500e+02 1.232970e+04
+7.565000e+02 1.226217e+04
+7.564500e+02 1.226217e+04
+7.564000e+02 1.231540e+04
+7.563500e+02 1.231540e+04
+7.563000e+02 1.234867e+04
+7.562500e+02 1.234867e+04
+7.562000e+02 1.233093e+04
+7.561500e+02 1.233093e+04
+7.561000e+02 1.232857e+04
+7.560500e+02 1.232857e+04
+7.560000e+02 1.236970e+04
+7.559500e+02 1.236970e+04
+7.559000e+02 1.236817e+04
+7.558500e+02 1.236817e+04
+7.558000e+02 1.233017e+04
+7.557500e+02 1.233017e+04
+7.557000e+02 1.237623e+04
+7.556500e+02 1.237623e+04
+7.556000e+02 1.237253e+04
+7.555500e+02 1.237253e+04
+7.555000e+02 1.236927e+04
+7.554500e+02 1.236927e+04
+7.554000e+02 1.236127e+04
+7.553500e+02 1.236127e+04
+7.553000e+02 1.244207e+04
+7.552500e+02 1.244207e+04
+7.552000e+02 1.246643e+04
+7.551500e+02 1.246643e+04
+7.551000e+02 1.248683e+04
+7.550500e+02 1.248683e+04
+7.550000e+02 1.244923e+04
+7.549500e+02 1.244923e+04
+7.549000e+02 1.248517e+04
+7.548500e+02 1.248517e+04
+7.548000e+02 1.247813e+04
+7.547500e+02 1.247813e+04
+7.547000e+02 1.257093e+04
+7.546500e+02 1.257093e+04
+7.546000e+02 1.257767e+04
+7.545500e+02 1.257767e+04
+7.545000e+02 1.253243e+04
+7.544500e+02 1.253243e+04
+7.544000e+02 1.258187e+04
+7.543500e+02 1.258187e+04
+7.543000e+02 1.256120e+04
+7.542500e+02 1.256120e+04
+7.542000e+02 1.268237e+04
+7.541500e+02 1.268237e+04
+7.541000e+02 1.266967e+04
+7.540500e+02 1.266967e+04
+7.540000e+02 1.255130e+04
+7.539500e+02 1.255130e+04
+7.539000e+02 1.255530e+04
+7.538500e+02 1.255530e+04
+7.538000e+02 1.262367e+04
+7.537500e+02 1.262367e+04
+7.537000e+02 1.264303e+04
+7.536500e+02 1.264303e+04
+7.536000e+02 1.262950e+04
+7.535500e+02 1.262950e+04
+7.535000e+02 1.266947e+04
+7.534500e+02 1.266947e+04
+7.534000e+02 1.274930e+04
+7.533500e+02 1.274930e+04
+7.533000e+02 1.271293e+04
+7.532500e+02 1.271293e+04
+7.532000e+02 1.272210e+04
+7.531500e+02 1.272210e+04
+7.531000e+02 1.272157e+04
+7.530500e+02 1.272157e+04
+7.530000e+02 1.283100e+04
+7.529500e+02 1.283100e+04
+7.529000e+02 1.278940e+04
+7.528500e+02 1.278940e+04
+7.528000e+02 1.280703e+04
+7.527500e+02 1.280703e+04
+7.527000e+02 1.278340e+04
+7.526500e+02 1.278340e+04
+7.526000e+02 1.282317e+04
+7.525500e+02 1.282317e+04
+7.525000e+02 1.284070e+04
+7.524500e+02 1.284070e+04
+7.524000e+02 1.286980e+04
+7.523500e+02 1.286980e+04
+7.523000e+02 1.283363e+04
+7.522500e+02 1.283363e+04
+7.522000e+02 1.288180e+04
+7.521500e+02 1.288180e+04
+7.521000e+02 1.288413e+04
+7.520500e+02 1.288413e+04
+7.520000e+02 1.288983e+04
+7.519500e+02 1.288983e+04
+7.519000e+02 1.288623e+04
+7.518500e+02 1.288623e+04
+7.518000e+02 1.290480e+04
+7.517500e+02 1.290480e+04
+7.517000e+02 1.296320e+04
+7.516500e+02 1.296320e+04
+7.516000e+02 1.295567e+04
+7.515500e+02 1.295567e+04
+7.515000e+02 1.298090e+04
+7.514500e+02 1.298090e+04
+7.514000e+02 1.302207e+04
+7.513500e+02 1.302207e+04
+7.513000e+02 1.297357e+04
+7.512500e+02 1.297357e+04
+7.512000e+02 1.295533e+04
+7.511500e+02 1.295533e+04
+7.511000e+02 1.298557e+04
+7.510500e+02 1.298557e+04
+7.510000e+02 1.303660e+04
+7.509500e+02 1.303660e+04
+7.509000e+02 1.303170e+04
+7.508500e+02 1.303170e+04
+7.508000e+02 1.312063e+04
+7.507500e+02 1.312063e+04
+7.507000e+02 1.311847e+04
+7.506500e+02 1.311847e+04
+7.506000e+02 1.306673e+04
+7.505500e+02 1.306673e+04
+7.505000e+02 1.305830e+04
+7.504500e+02 1.305830e+04
+7.504000e+02 1.309940e+04
+7.503500e+02 1.309940e+04
+7.503000e+02 1.311410e+04
+7.502500e+02 1.311410e+04
+7.502000e+02 1.315703e+04
+7.501500e+02 1.315703e+04
+7.501000e+02 1.308140e+04
+7.500500e+02 1.308140e+04
+7.500000e+02 1.316143e+04
+7.499500e+02 1.316143e+04
+7.499000e+02 1.324677e+04
+7.498500e+02 1.324677e+04
+7.498000e+02 1.317187e+04
+7.497500e+02 1.317187e+04
+7.497000e+02 1.321997e+04
+7.496500e+02 1.321997e+04
+7.496000e+02 1.329893e+04
+7.495500e+02 1.329893e+04
+7.495000e+02 1.336533e+04
+7.494500e+02 1.336533e+04
+7.494000e+02 1.326133e+04
+7.493500e+02 1.326133e+04
+7.493000e+02 1.328577e+04
+7.492500e+02 1.328577e+04
+7.492000e+02 1.334297e+04
+7.491500e+02 1.334297e+04
+7.491000e+02 1.345107e+04
+7.490500e+02 1.345107e+04
+7.490000e+02 1.337627e+04
+7.489500e+02 1.337627e+04
+7.489000e+02 1.337410e+04
+7.488500e+02 1.337410e+04
+7.488000e+02 1.334210e+04
+7.487500e+02 1.334210e+04
+7.487000e+02 1.336313e+04
+7.486500e+02 1.336313e+04
+7.486000e+02 1.345737e+04
+7.485500e+02 1.345737e+04
+7.485000e+02 1.341447e+04
+7.484500e+02 1.341447e+04
+7.484000e+02 1.350077e+04
+7.483500e+02 1.350077e+04
+7.483000e+02 1.351487e+04
+7.482500e+02 1.351487e+04
+7.482000e+02 1.349397e+04
+7.481500e+02 1.349397e+04
+7.481000e+02 1.348407e+04
+7.480500e+02 1.348407e+04
+7.480000e+02 1.354430e+04
+7.479500e+02 1.354430e+04
+7.479000e+02 1.359947e+04
+7.478500e+02 1.359947e+04
+7.478000e+02 1.355407e+04
+7.477500e+02 1.355407e+04
+7.477000e+02 1.358257e+04
+7.476500e+02 1.358257e+04
+7.476000e+02 1.364553e+04
+7.475500e+02 1.364553e+04
+7.475000e+02 1.364313e+04
+7.474500e+02 1.364313e+04
+7.474000e+02 1.364393e+04
+7.473500e+02 1.364393e+04
+7.473000e+02 1.359817e+04
+7.472500e+02 1.359817e+04
+7.472000e+02 1.359340e+04
+7.471500e+02 1.359340e+04
+7.471000e+02 1.369087e+04
+7.470500e+02 1.369087e+04
+7.470000e+02 1.375780e+04
+7.469500e+02 1.375780e+04
+7.469000e+02 1.373070e+04
+7.468500e+02 1.373070e+04
+7.468000e+02 1.372240e+04
+7.467500e+02 1.372240e+04
+7.467000e+02 1.375830e+04
+7.466500e+02 1.375830e+04
+7.466000e+02 1.372483e+04
+7.465500e+02 1.372483e+04
+7.465000e+02 1.374627e+04
+7.464500e+02 1.374627e+04
+7.464000e+02 1.376543e+04
+7.463500e+02 1.376543e+04
+7.463000e+02 1.385883e+04
+7.462500e+02 1.385883e+04
+7.462000e+02 1.385627e+04
+7.461500e+02 1.385627e+04
+7.461000e+02 1.386097e+04
+7.460500e+02 1.386097e+04
+7.460000e+02 1.388883e+04
+7.459500e+02 1.388883e+04
+7.459000e+02 1.388343e+04
+7.458500e+02 1.388343e+04
+7.458000e+02 1.390447e+04
+7.457500e+02 1.390447e+04
+7.457000e+02 1.390343e+04
+7.456500e+02 1.390343e+04
+7.456000e+02 1.393710e+04
+7.455500e+02 1.393710e+04
+7.455000e+02 1.393147e+04
+7.454500e+02 1.393147e+04
+7.454000e+02 1.391910e+04
+7.453500e+02 1.391910e+04
+7.453000e+02 1.399593e+04
+7.452500e+02 1.399593e+04
+7.452000e+02 1.402333e+04
+7.451500e+02 1.402333e+04
+7.451000e+02 1.400953e+04
+7.450500e+02 1.400953e+04
+7.450000e+02 1.405153e+04
+7.449500e+02 1.405153e+04
+7.449000e+02 1.401547e+04
+7.448500e+02 1.401547e+04
+7.448000e+02 1.401063e+04
+7.447500e+02 1.401063e+04
+7.447000e+02 1.405650e+04
+7.446500e+02 1.405650e+04
+7.446000e+02 1.411007e+04
+7.445500e+02 1.411007e+04
+7.445000e+02 1.412723e+04
+7.444500e+02 1.412723e+04
+7.444000e+02 1.422480e+04
+7.443500e+02 1.422480e+04
+7.443000e+02 1.418370e+04
+7.442500e+02 1.418370e+04
+7.442000e+02 1.411857e+04
+7.441500e+02 1.411857e+04
+7.441000e+02 1.413873e+04
+7.440500e+02 1.413873e+04
+7.440000e+02 1.411677e+04
+7.439500e+02 1.411677e+04
+7.439000e+02 1.412273e+04
+7.438500e+02 1.412273e+04
+7.438000e+02 1.416383e+04
+7.437500e+02 1.416383e+04
+7.437000e+02 1.415327e+04
+7.436500e+02 1.415327e+04
+7.436000e+02 1.420503e+04
+7.435500e+02 1.420503e+04
+7.435000e+02 1.419133e+04
+7.434500e+02 1.419133e+04
+7.434000e+02 1.413930e+04
+7.433500e+02 1.413930e+04
+7.433000e+02 1.422660e+04
+7.432500e+02 1.422660e+04
+7.432000e+02 1.422207e+04
+7.431500e+02 1.422207e+04
+7.431000e+02 1.425563e+04
+7.430500e+02 1.425563e+04
+7.430000e+02 1.428723e+04
+7.429500e+02 1.428723e+04
+7.429000e+02 1.421627e+04
+7.428500e+02 1.421627e+04
+7.428000e+02 1.422033e+04
+7.427500e+02 1.422033e+04
+7.427000e+02 1.425153e+04
+7.426500e+02 1.425153e+04
+7.426000e+02 1.434230e+04
+7.425500e+02 1.434230e+04
+7.425000e+02 1.423863e+04
+7.424500e+02 1.423863e+04
+7.424000e+02 1.423237e+04
+7.423500e+02 1.423237e+04
+7.423000e+02 1.428410e+04
+7.422500e+02 1.428410e+04
+7.422000e+02 1.426150e+04
+7.421500e+02 1.426150e+04
+7.421000e+02 1.426310e+04
+7.420500e+02 1.426310e+04
+7.420000e+02 1.428687e+04
+7.419500e+02 1.428687e+04
+7.419000e+02 1.441090e+04
+7.418500e+02 1.441090e+04
+7.418000e+02 1.433647e+04
+7.417500e+02 1.433647e+04
+7.417000e+02 1.430843e+04
+7.416500e+02 1.430843e+04
+7.416000e+02 1.427850e+04
+7.415500e+02 1.427850e+04
+7.415000e+02 1.429033e+04
+7.414500e+02 1.429033e+04
+7.414000e+02 1.435857e+04
+7.413500e+02 1.435857e+04
+7.413000e+02 1.436707e+04
+7.412500e+02 1.436707e+04
+7.412000e+02 1.430773e+04
+7.411500e+02 1.430773e+04
+7.411000e+02 1.434100e+04
+7.410500e+02 1.434100e+04
+7.410000e+02 1.434077e+04
+7.409500e+02 1.434077e+04
+7.409000e+02 1.429837e+04
+7.408500e+02 1.429837e+04
+7.408000e+02 1.429573e+04
+7.407500e+02 1.429573e+04
+7.407000e+02 1.434133e+04
+7.406500e+02 1.434133e+04
+7.406000e+02 1.433987e+04
+7.405500e+02 1.433987e+04
+7.405000e+02 1.432850e+04
+7.404500e+02 1.432850e+04
+7.404000e+02 1.429143e+04
+7.403500e+02 1.429143e+04
+7.403000e+02 1.438773e+04
+7.402500e+02 1.438773e+04
+7.402000e+02 1.434050e+04
+7.401500e+02 1.434050e+04
+7.401000e+02 1.439210e+04
+7.400500e+02 1.439210e+04
+7.400000e+02 1.436557e+04
+7.399500e+02 1.436557e+04
+7.399000e+02 1.441750e+04
+7.398500e+02 1.441750e+04
+7.398000e+02 1.437497e+04
+7.397500e+02 1.437497e+04
+7.397000e+02 1.439050e+04
+7.396500e+02 1.439050e+04
+7.396000e+02 1.439277e+04
+7.395500e+02 1.439277e+04
+7.395000e+02 1.439097e+04
+7.394500e+02 1.439097e+04
+7.394000e+02 1.439470e+04
+7.393500e+02 1.439470e+04
+7.393000e+02 1.452573e+04
+7.392500e+02 1.452573e+04
+7.392000e+02 1.440453e+04
+7.391500e+02 1.440453e+04
+7.391000e+02 1.440227e+04
+7.390500e+02 1.440227e+04
+7.390000e+02 1.440110e+04
+7.389500e+02 1.440110e+04
+7.389000e+02 1.448957e+04
+7.388500e+02 1.448957e+04
+7.388000e+02 1.450877e+04
+7.387500e+02 1.450877e+04
+7.387000e+02 1.449423e+04
+7.386500e+02 1.449423e+04
+7.386000e+02 1.453037e+04
+7.385500e+02 1.453037e+04
+7.385000e+02 1.457167e+04
+7.384500e+02 1.457167e+04
+7.384000e+02 1.455507e+04
+7.383500e+02 1.455507e+04
+7.383000e+02 1.457567e+04
+7.382500e+02 1.457567e+04
+7.382000e+02 1.455387e+04
+7.381500e+02 1.455387e+04
+7.381000e+02 1.459193e+04
+7.380500e+02 1.459193e+04
+7.380000e+02 1.469097e+04
+7.379500e+02 1.469097e+04
+7.379000e+02 1.464123e+04
+7.378500e+02 1.464123e+04
+7.378000e+02 1.465177e+04
+7.377500e+02 1.465177e+04
+7.377000e+02 1.464733e+04
+7.376500e+02 1.464733e+04
+7.376000e+02 1.469097e+04
+7.375500e+02 1.469097e+04
+7.375000e+02 1.466470e+04
+7.374500e+02 1.466470e+04
+7.374000e+02 1.479020e+04
+7.373500e+02 1.479020e+04
+7.373000e+02 1.478587e+04
+7.372500e+02 1.478587e+04
+7.372000e+02 1.481040e+04
+7.371500e+02 1.481040e+04
+7.371000e+02 1.474767e+04
+7.370500e+02 1.474767e+04
+7.370000e+02 1.479023e+04
+7.369500e+02 1.479023e+04
+7.369000e+02 1.477117e+04
+7.368500e+02 1.477117e+04
+7.368000e+02 1.476937e+04
+7.367500e+02 1.476937e+04
+7.367000e+02 1.483770e+04
+7.366500e+02 1.483770e+04
+7.366000e+02 1.479587e+04
+7.365500e+02 1.479587e+04
+7.365000e+02 1.487193e+04
+7.364500e+02 1.487193e+04
+7.364000e+02 1.483470e+04
+7.363500e+02 1.483470e+04
+7.363000e+02 1.485287e+04
+7.362500e+02 1.485287e+04
+7.362000e+02 1.490203e+04
+7.361500e+02 1.490203e+04
+7.361000e+02 1.492643e+04
+7.360500e+02 1.492643e+04
+7.360000e+02 1.498197e+04
+7.359500e+02 1.498197e+04
+7.359000e+02 1.495187e+04
+7.358500e+02 1.495187e+04
+7.358000e+02 1.495633e+04
+7.357500e+02 1.495633e+04
+7.357000e+02 1.492393e+04
+7.356500e+02 1.492393e+04
+7.356000e+02 1.498253e+04
+7.355500e+02 1.498253e+04
+7.355000e+02 1.509967e+04
+7.354500e+02 1.509967e+04
+7.354000e+02 1.510963e+04
+7.353500e+02 1.510963e+04
+7.353000e+02 1.504880e+04
+7.352500e+02 1.504880e+04
+7.352000e+02 1.505090e+04
+7.351500e+02 1.505090e+04
+7.351000e+02 1.514153e+04
+7.350500e+02 1.514153e+04
+7.350000e+02 1.517663e+04
+7.349500e+02 1.517663e+04
+7.349000e+02 1.514247e+04
+7.348500e+02 1.514247e+04
+7.348000e+02 1.509117e+04
+7.347500e+02 1.509117e+04
+7.347000e+02 1.508847e+04
+7.346500e+02 1.508847e+04
+7.346000e+02 1.520053e+04
+7.345500e+02 1.520053e+04
+7.345000e+02 1.518907e+04
+7.344500e+02 1.518907e+04
+7.344000e+02 1.522070e+04
+7.343500e+02 1.522070e+04
+7.343000e+02 1.526753e+04
+7.342500e+02 1.526753e+04
+7.342000e+02 1.525953e+04
+7.341500e+02 1.525953e+04
+7.341000e+02 1.527367e+04
+7.340500e+02 1.527367e+04
+7.340000e+02 1.528960e+04
+7.339500e+02 1.528960e+04
+7.339000e+02 1.535217e+04
+7.338500e+02 1.535217e+04
+7.338000e+02 1.537437e+04
+7.337500e+02 1.537437e+04
+7.337000e+02 1.536957e+04
+7.336500e+02 1.536957e+04
+7.336000e+02 1.537413e+04
+7.335500e+02 1.537413e+04
+7.335000e+02 1.542303e+04
+7.334500e+02 1.542303e+04
+7.334000e+02 1.542733e+04
+7.333500e+02 1.542733e+04
+7.333000e+02 1.540250e+04
+7.332500e+02 1.540250e+04
+7.332000e+02 1.544210e+04
+7.331500e+02 1.544210e+04
+7.331000e+02 1.543200e+04
+7.330500e+02 1.543200e+04
+7.330000e+02 1.548823e+04
+7.329500e+02 1.548823e+04
+7.329000e+02 1.560800e+04
+7.328500e+02 1.560800e+04
+7.328000e+02 1.562057e+04
+7.327500e+02 1.562057e+04
+7.327000e+02 1.551113e+04
+7.326500e+02 1.551113e+04
+7.326000e+02 1.551093e+04
+7.325500e+02 1.551093e+04
+7.325000e+02 1.559353e+04
+7.324500e+02 1.559353e+04
+7.324000e+02 1.555480e+04
+7.323500e+02 1.555480e+04
+7.323000e+02 1.562943e+04
+7.322500e+02 1.562943e+04
+7.322000e+02 1.569650e+04
+7.321500e+02 1.569650e+04
+7.321000e+02 1.566513e+04
+7.320500e+02 1.566513e+04
+7.320000e+02 1.558600e+04
+7.319500e+02 1.558600e+04
+7.319000e+02 1.571230e+04
+7.318500e+02 1.571230e+04
+7.318000e+02 1.574540e+04
+7.317500e+02 1.574540e+04
+7.317000e+02 1.572787e+04
+7.316500e+02 1.572787e+04
+7.316000e+02 1.573627e+04
+7.315500e+02 1.573627e+04
+7.315000e+02 1.573810e+04
+7.314500e+02 1.573810e+04
+7.314000e+02 1.574857e+04
+7.313500e+02 1.574857e+04
+7.313000e+02 1.574203e+04
+7.312500e+02 1.574203e+04
+7.312000e+02 1.583550e+04
+7.311500e+02 1.583550e+04
+7.311000e+02 1.575993e+04
+7.310500e+02 1.575993e+04
+7.310000e+02 1.573980e+04
+7.309500e+02 1.573980e+04
+7.309000e+02 1.579743e+04
+7.308500e+02 1.579743e+04
+7.308000e+02 1.576150e+04
+7.307500e+02 1.576150e+04
+7.307000e+02 1.578410e+04
+7.306500e+02 1.578410e+04
+7.306000e+02 1.581400e+04
+7.305500e+02 1.581400e+04
+7.305000e+02 1.576683e+04
+7.304500e+02 1.576683e+04
+7.304000e+02 1.581920e+04
+7.303500e+02 1.581920e+04
+7.303000e+02 1.574977e+04
+7.302500e+02 1.574977e+04
+7.302000e+02 1.574993e+04
+7.301500e+02 1.574993e+04
+7.301000e+02 1.573827e+04
+7.300500e+02 1.573827e+04
+7.300000e+02 1.580390e+04
+7.299500e+02 1.580390e+04
+7.299000e+02 1.584917e+04
+7.298500e+02 1.584917e+04
+7.298000e+02 1.587577e+04
+7.297500e+02 1.587577e+04
+7.297000e+02 1.577283e+04
+7.296500e+02 1.577283e+04
+7.296000e+02 1.584083e+04
+7.295500e+02 1.584083e+04
+7.295000e+02 1.584450e+04
+7.294500e+02 1.584450e+04
+7.294000e+02 1.585133e+04
+7.293500e+02 1.585133e+04
+7.293000e+02 1.582407e+04
+7.292500e+02 1.582407e+04
+7.292000e+02 1.580363e+04
+7.291500e+02 1.580363e+04
+7.291000e+02 1.589553e+04
+7.290500e+02 1.589553e+04
+7.290000e+02 1.584107e+04
+7.289500e+02 1.584107e+04
+7.289000e+02 1.590310e+04
+7.288500e+02 1.590310e+04
+7.288000e+02 1.578553e+04
+7.287500e+02 1.578553e+04
+7.287000e+02 1.584870e+04
+7.286500e+02 1.584870e+04
+7.286000e+02 1.579573e+04
+7.285500e+02 1.579573e+04
+7.285000e+02 1.579290e+04
+7.284500e+02 1.579290e+04
+7.284000e+02 1.583960e+04
+7.283500e+02 1.583960e+04
+7.283000e+02 1.581560e+04
+7.282500e+02 1.581560e+04
+7.282000e+02 1.583033e+04
+7.281500e+02 1.583033e+04
+7.281000e+02 1.580673e+04
+7.280500e+02 1.580673e+04
+7.280000e+02 1.584537e+04
+7.279500e+02 1.584537e+04
+7.279000e+02 1.588380e+04
+7.278500e+02 1.588380e+04
+7.278000e+02 1.592573e+04
+7.277500e+02 1.592573e+04
+7.277000e+02 1.591767e+04
+7.276500e+02 1.591767e+04
+7.276000e+02 1.579683e+04
+7.275500e+02 1.579683e+04
+7.275000e+02 1.587710e+04
+7.274500e+02 1.587710e+04
+7.274000e+02 1.593630e+04
+7.273500e+02 1.593630e+04
+7.273000e+02 1.597240e+04
+7.272500e+02 1.597240e+04
+7.272000e+02 1.601060e+04
+7.271500e+02 1.601060e+04
+7.271000e+02 1.599407e+04
+7.270500e+02 1.599407e+04
+7.270000e+02 1.595693e+04
+7.269500e+02 1.595693e+04
+7.269000e+02 1.592970e+04
+7.268500e+02 1.592970e+04
+7.268000e+02 1.598090e+04
+7.267500e+02 1.598090e+04
+7.267000e+02 1.600347e+04
+7.266500e+02 1.600347e+04
+7.266000e+02 1.600003e+04
+7.265500e+02 1.600003e+04
+7.265000e+02 1.597160e+04
+7.264500e+02 1.597160e+04
+7.264000e+02 1.610290e+04
+7.263500e+02 1.610290e+04
+7.263000e+02 1.600083e+04
+7.262500e+02 1.600083e+04
+7.262000e+02 1.600587e+04
+7.261500e+02 1.600587e+04
+7.261000e+02 1.611270e+04
+7.260500e+02 1.611270e+04
+7.260000e+02 1.604760e+04
+7.259500e+02 1.604760e+04
+7.259000e+02 1.611650e+04
+7.258500e+02 1.611650e+04
+7.258000e+02 1.616870e+04
+7.257500e+02 1.616870e+04
+7.257000e+02 1.613510e+04
+7.256500e+02 1.613510e+04
+7.256000e+02 1.615733e+04
+7.255500e+02 1.615733e+04
+7.255000e+02 1.628780e+04
+7.254500e+02 1.628780e+04
+7.254000e+02 1.627140e+04
+7.253500e+02 1.627140e+04
+7.253000e+02 1.628600e+04
+7.252500e+02 1.628600e+04
+7.252000e+02 1.621187e+04
+7.251500e+02 1.621187e+04
+7.251000e+02 1.627030e+04
+7.250500e+02 1.627030e+04
+7.250000e+02 1.630847e+04
+7.249500e+02 1.630847e+04
+7.249000e+02 1.628827e+04
+7.248500e+02 1.628827e+04
+7.248000e+02 1.630660e+04
+7.247500e+02 1.630660e+04
+7.247000e+02 1.635783e+04
+7.246500e+02 1.635783e+04
+7.246000e+02 1.638243e+04
+7.245500e+02 1.638243e+04
+7.245000e+02 1.641273e+04
+7.244500e+02 1.641273e+04
+7.244000e+02 1.650950e+04
+7.243500e+02 1.650950e+04
+7.243000e+02 1.647247e+04
+7.242500e+02 1.647247e+04
+7.242000e+02 1.651133e+04
+7.241500e+02 1.651133e+04
+7.241000e+02 1.655367e+04
+7.240500e+02 1.655367e+04
+7.240000e+02 1.656293e+04
+7.239500e+02 1.656293e+04
+7.239000e+02 1.662130e+04
+7.238500e+02 1.662130e+04
+7.238000e+02 1.661983e+04
+7.237500e+02 1.661983e+04
+7.237000e+02 1.671023e+04
+7.236500e+02 1.671023e+04
+7.236000e+02 1.686617e+04
+7.235500e+02 1.686617e+04
+7.235000e+02 1.687830e+04
+7.234500e+02 1.687830e+04
+7.234000e+02 1.701897e+04
+7.233500e+02 1.701897e+04
+7.233000e+02 1.714290e+04
+7.232500e+02 1.714290e+04
+7.232000e+02 1.723110e+04
+7.231500e+02 1.723110e+04
+7.231000e+02 1.723833e+04
+7.230500e+02 1.723833e+04
+7.230000e+02 1.735580e+04
+7.229500e+02 1.735580e+04
+7.229000e+02 1.745743e+04
+7.228500e+02 1.745743e+04
+7.228000e+02 1.763090e+04
+7.227500e+02 1.763090e+04
+7.227000e+02 1.778003e+04
+7.226500e+02 1.778003e+04
+7.226000e+02 1.791320e+04
+7.225500e+02 1.791320e+04
+7.225000e+02 1.803683e+04
+7.224500e+02 1.803683e+04
+7.224000e+02 1.824220e+04
+7.223500e+02 1.824220e+04
+7.223000e+02 1.843373e+04
+7.222500e+02 1.843373e+04
+7.222000e+02 1.863720e+04
+7.221500e+02 1.863720e+04
+7.221000e+02 1.877087e+04
+7.220500e+02 1.877087e+04
+7.220000e+02 1.905300e+04
+7.219500e+02 1.905300e+04
+7.219000e+02 1.920140e+04
+7.218500e+02 1.920140e+04
+7.218000e+02 1.943720e+04
+7.217500e+02 1.943720e+04
+7.217000e+02 1.978467e+04
+7.216500e+02 1.978467e+04
+7.216000e+02 2.006970e+04
+7.215500e+02 2.006970e+04
+7.215000e+02 2.051003e+04
+7.214500e+02 2.051003e+04
+7.214000e+02 2.071327e+04
+7.213500e+02 2.071327e+04
+7.213000e+02 2.098340e+04
+7.212500e+02 2.098340e+04
+7.212000e+02 2.155557e+04
+7.211500e+02 2.155557e+04
+7.211000e+02 2.200147e+04
+7.210500e+02 2.200147e+04
+7.210000e+02 2.253907e+04
+7.209500e+02 2.253907e+04
+7.209000e+02 2.299323e+04
+7.208500e+02 2.299323e+04
+7.208000e+02 2.347660e+04
+7.207500e+02 2.347660e+04
+7.207000e+02 2.414387e+04
+7.206500e+02 2.414387e+04
+7.206000e+02 2.484067e+04
+7.205500e+02 2.484067e+04
+7.205000e+02 2.561653e+04
+7.204500e+02 2.561653e+04
+7.204000e+02 2.651737e+04
+7.203500e+02 2.651737e+04
+7.203000e+02 2.715170e+04
+7.202500e+02 2.715170e+04
+7.202000e+02 2.801513e+04
+7.201500e+02 2.801513e+04
+7.201000e+02 2.886797e+04
+7.200500e+02 2.886797e+04
+7.200000e+02 2.954987e+04
+7.199500e+02 2.954987e+04
+7.199000e+02 3.001853e+04
+7.198500e+02 3.001853e+04
+7.198000e+02 3.029127e+04
+7.197500e+02 3.029127e+04
+7.197000e+02 3.016463e+04
+7.196500e+02 3.016463e+04
+7.196000e+02 2.988390e+04
+7.195500e+02 2.988390e+04
+7.195000e+02 2.917377e+04
+7.194500e+02 2.917377e+04
+7.194000e+02 2.830437e+04
+7.193500e+02 2.830437e+04
+7.193000e+02 2.697530e+04
+7.192500e+02 2.697530e+04
+7.192000e+02 2.554547e+04
+7.191500e+02 2.554547e+04
+7.191000e+02 2.380377e+04
+7.190500e+02 2.380377e+04
+7.190000e+02 2.210697e+04
+7.189500e+02 2.210697e+04
+7.189000e+02 2.054580e+04
+7.188500e+02 2.054580e+04
+7.188000e+02 1.913943e+04
+7.187500e+02 1.913943e+04
+7.187000e+02 1.796653e+04
+7.186500e+02 1.796653e+04
+7.186000e+02 1.703470e+04
+7.185500e+02 1.703470e+04
+7.185000e+02 1.623470e+04
+7.184500e+02 1.623470e+04
+7.184000e+02 1.553020e+04
+7.183500e+02 1.553020e+04
+7.183000e+02 1.494723e+04
+7.182500e+02 1.494723e+04
+7.182000e+02 1.448043e+04
+7.181500e+02 1.448043e+04
+7.181000e+02 1.416327e+04
+7.180500e+02 1.416327e+04
+7.180000e+02 1.387010e+04
+7.179500e+02 1.387010e+04
+7.179000e+02 1.349060e+04
+7.178500e+02 1.349060e+04
+7.178000e+02 1.334963e+04
+7.177500e+02 1.334963e+04
+7.177000e+02 1.318033e+04
+7.176500e+02 1.318033e+04
+7.176000e+02 1.296993e+04
+7.175500e+02 1.296993e+04
+7.175000e+02 1.283520e+04
+7.174500e+02 1.283520e+04
+7.174000e+02 1.268153e+04
+7.173500e+02 1.268153e+04
+7.173000e+02 1.264530e+04
+7.172500e+02 1.264530e+04
+7.172000e+02 1.256367e+04
+7.171500e+02 1.256367e+04
+7.171000e+02 1.247667e+04
+7.170500e+02 1.247667e+04
+7.170000e+02 1.241990e+04
+7.169500e+02 1.241990e+04
+7.169000e+02 1.231143e+04
+7.168500e+02 1.231143e+04
+7.168000e+02 1.227200e+04
+7.167500e+02 1.227200e+04
+7.167000e+02 1.225247e+04
+7.166500e+02 1.225247e+04
+7.166000e+02 1.218837e+04
+7.165500e+02 1.218837e+04
+7.165000e+02 1.220390e+04
+7.164500e+02 1.220390e+04
+7.164000e+02 1.218017e+04
+7.163500e+02 1.218017e+04
+7.163000e+02 1.214343e+04
+7.162500e+02 1.214343e+04
+7.162000e+02 1.211683e+04
+7.161500e+02 1.211683e+04
+7.161000e+02 1.217807e+04
+7.160500e+02 1.217807e+04
+7.160000e+02 1.219520e+04
+7.159500e+02 1.219520e+04
+7.159000e+02 1.215423e+04
+7.158500e+02 1.215423e+04
+7.158000e+02 1.219080e+04
+7.157500e+02 1.219080e+04
+7.157000e+02 1.218723e+04
+7.156500e+02 1.218723e+04
+7.156000e+02 1.223710e+04
+7.155500e+02 1.223710e+04
+7.155000e+02 1.223553e+04
+7.154500e+02 1.223553e+04
+7.154000e+02 1.228597e+04
+7.153500e+02 1.228597e+04
+7.153000e+02 1.224827e+04
+7.152500e+02 1.224827e+04
+7.152000e+02 1.223740e+04
+7.151500e+02 1.223740e+04
+7.151000e+02 1.230367e+04
+7.150500e+02 1.230367e+04
+7.150000e+02 1.229807e+04
+7.149500e+02 1.229807e+04
+7.149000e+02 1.243123e+04
+7.148500e+02 1.243123e+04
+7.148000e+02 1.244200e+04
+7.147500e+02 1.244200e+04
+7.147000e+02 1.252347e+04
+7.146500e+02 1.252347e+04
+7.146000e+02 1.253003e+04
+7.145500e+02 1.253003e+04
+7.145000e+02 1.254350e+04
+7.144500e+02 1.254350e+04
+7.144000e+02 1.255893e+04
+7.143500e+02 1.255893e+04
+7.143000e+02 1.260687e+04
+7.142500e+02 1.260687e+04
+7.142000e+02 1.265230e+04
+7.141500e+02 1.265230e+04
+7.141000e+02 1.273337e+04
+7.140500e+02 1.273337e+04
+7.140000e+02 1.268763e+04
+7.139500e+02 1.268763e+04
+7.139000e+02 1.277510e+04
+7.138500e+02 1.277510e+04
+7.138000e+02 1.283420e+04
+7.137500e+02 1.283420e+04
+7.137000e+02 1.286200e+04
+7.136500e+02 1.286200e+04
+7.136000e+02 1.294317e+04
+7.135500e+02 1.294317e+04
+7.135000e+02 1.301090e+04
+7.134500e+02 1.301090e+04
+7.134000e+02 1.303573e+04
+7.133500e+02 1.303573e+04
+7.133000e+02 1.302490e+04
+7.132500e+02 1.302490e+04
+7.132000e+02 1.303520e+04
+7.131500e+02 1.303520e+04
+7.131000e+02 1.317643e+04
+7.130500e+02 1.317643e+04
+7.130000e+02 1.316137e+04
+7.129500e+02 1.316137e+04
+7.129000e+02 1.319357e+04
+7.128500e+02 1.319357e+04
+7.128000e+02 1.323173e+04
+7.127500e+02 1.323173e+04
+7.127000e+02 1.328497e+04
+7.126500e+02 1.328497e+04
+7.126000e+02 1.329760e+04
+7.125500e+02 1.329760e+04
+7.125000e+02 1.323597e+04
+7.124500e+02 1.323597e+04
+7.124000e+02 1.336137e+04
+7.123500e+02 1.336137e+04
+7.123000e+02 1.342340e+04
+7.122500e+02 1.342340e+04
+7.122000e+02 1.353197e+04
+7.121500e+02 1.353197e+04
+7.121000e+02 1.359620e+04
+7.120500e+02 1.359620e+04
+7.120000e+02 1.356523e+04
+7.119500e+02 1.356523e+04
+7.119000e+02 1.362623e+04
+7.118500e+02 1.362623e+04
+7.118000e+02 1.381080e+04
+7.117500e+02 1.381080e+04
+7.117000e+02 1.390190e+04
+7.116500e+02 1.390190e+04
+7.116000e+02 1.392100e+04
+7.115500e+02 1.392100e+04
+7.115000e+02 1.400667e+04
+7.114500e+02 1.400667e+04
+7.114000e+02 1.417183e+04
+7.113500e+02 1.417183e+04
+7.113000e+02 1.424513e+04
+7.112500e+02 1.424513e+04
+7.112000e+02 1.434007e+04
+7.111500e+02 1.434007e+04
+7.111000e+02 1.447380e+04
+7.110500e+02 1.447380e+04
+7.110000e+02 1.461950e+04
+7.109500e+02 1.461950e+04
+7.109000e+02 1.481250e+04
+7.108500e+02 1.481250e+04
+7.108000e+02 1.492323e+04
+7.107500e+02 1.492323e+04
+7.107000e+02 1.501293e+04
+7.106500e+02 1.501293e+04
+7.106000e+02 1.523677e+04
+7.105500e+02 1.523677e+04
+7.105000e+02 1.535517e+04
+7.104500e+02 1.535517e+04
+7.104000e+02 1.544843e+04
+7.103500e+02 1.544843e+04
+7.103000e+02 1.554237e+04
+7.102500e+02 1.554237e+04
+7.102000e+02 1.576620e+04
+7.101500e+02 1.576620e+04
+7.101000e+02 1.583847e+04
+7.100500e+02 1.583847e+04
+7.100000e+02 1.606287e+04
+7.099500e+02 1.606287e+04
+7.099000e+02 1.619443e+04
+7.098500e+02 1.619443e+04
+7.098000e+02 1.636793e+04
+7.097500e+02 1.636793e+04
+7.097000e+02 1.658953e+04
+7.096500e+02 1.658953e+04
+7.096000e+02 1.670607e+04
+7.095500e+02 1.670607e+04
+7.095000e+02 1.691077e+04
+7.094500e+02 1.691077e+04
+7.094000e+02 1.716780e+04
+7.093500e+02 1.716780e+04
+7.093000e+02 1.742053e+04
+7.092500e+02 1.742053e+04
+7.092000e+02 1.758837e+04
+7.091500e+02 1.758837e+04
+7.091000e+02 1.792643e+04
+7.090500e+02 1.792643e+04
+7.090000e+02 1.837023e+04
+7.089500e+02 1.837023e+04
+7.089000e+02 1.867743e+04
+7.088500e+02 1.867743e+04
+7.088000e+02 1.902057e+04
+7.087500e+02 1.902057e+04
+7.087000e+02 1.952217e+04
+7.086500e+02 1.952217e+04
+7.086000e+02 2.009560e+04
+7.085500e+02 2.009560e+04
+7.085000e+02 2.065010e+04
+7.084500e+02 2.065010e+04
+7.084000e+02 2.127270e+04
+7.083500e+02 2.127270e+04
+7.083000e+02 2.205103e+04
+7.082500e+02 2.205103e+04
+7.082000e+02 2.308727e+04
+7.081500e+02 2.308727e+04
+7.081000e+02 2.416107e+04
+7.080500e+02 2.416107e+04
+7.080000e+02 2.533107e+04
+7.079500e+02 2.533107e+04
+7.079000e+02 2.669173e+04
+7.078500e+02 2.669173e+04
+7.078000e+02 2.857163e+04
+7.077500e+02 2.857163e+04
+7.077000e+02 3.039197e+04
+7.076500e+02 3.039197e+04
+7.076000e+02 3.234240e+04
+7.075500e+02 3.234240e+04
+7.075000e+02 3.443967e+04
+7.074500e+02 3.443967e+04
+7.074000e+02 3.636933e+04
+7.073500e+02 3.636933e+04
+7.073000e+02 3.813367e+04
+7.072500e+02 3.813367e+04
+7.072000e+02 3.976033e+04
+7.071500e+02 3.976033e+04
+7.071000e+02 4.163033e+04
+7.070500e+02 4.163033e+04
+7.070000e+02 4.407833e+04
+7.069500e+02 4.407833e+04
+7.069000e+02 4.692367e+04
+7.068500e+02 4.692367e+04
+7.068000e+02 5.021800e+04
+7.067500e+02 5.021800e+04
+7.067000e+02 5.320933e+04
+7.066500e+02 5.320933e+04
+7.066000e+02 5.485033e+04
+7.065500e+02 5.485033e+04
+7.065000e+02 5.413000e+04
+7.064500e+02 5.413000e+04
+7.064000e+02 5.024800e+04
+7.063500e+02 5.024800e+04
+7.063000e+02 4.361400e+04
+7.062500e+02 4.361400e+04
+7.062000e+02 3.516700e+04
+7.061500e+02 3.516700e+04
+7.061000e+02 2.672047e+04
+7.060500e+02 2.672047e+04
+7.060000e+02 1.951670e+04
+7.059500e+02 1.951670e+04
+7.059000e+02 1.424440e+04
+7.058500e+02 1.424440e+04
+7.058000e+02 1.065797e+04
+7.057500e+02 1.065797e+04
+7.057000e+02 8.352367e+03
+7.056500e+02 8.352367e+03
+7.056000e+02 6.853267e+03
+7.055500e+02 6.853267e+03
+7.055000e+02 5.783200e+03
+7.054500e+02 5.783200e+03
+7.054000e+02 5.015800e+03
+7.053500e+02 5.015800e+03
+7.053000e+02 4.427133e+03
+7.052500e+02 4.427133e+03
+7.052000e+02 4.015733e+03
+7.051500e+02 4.015733e+03
+7.051000e+02 3.682033e+03
+7.050500e+02 3.682033e+03
+7.050000e+02 3.439767e+03
+7.049500e+02 3.439767e+03
+7.049000e+02 3.221873e+03
+7.048500e+02 3.221873e+03
+7.048000e+02 3.029637e+03
+7.047500e+02 3.029637e+03
+7.047000e+02 2.864947e+03
+7.046500e+02 2.864947e+03
+7.046000e+02 2.695263e+03
+7.045500e+02 2.695263e+03
+7.045000e+02 2.541727e+03
+7.044500e+02 2.541727e+03
+7.044000e+02 2.435330e+03
+7.043500e+02 2.435330e+03
+7.043000e+02 2.375573e+03
+7.042500e+02 2.375573e+03
+7.042000e+02 2.308283e+03
+7.041500e+02 2.308283e+03
+7.041000e+02 2.216300e+03
+7.040500e+02 2.216300e+03
+7.040000e+02 2.158980e+03
+7.039500e+02 2.158980e+03
+7.039000e+02 2.074823e+03
+7.038500e+02 2.074823e+03
+7.038000e+02 2.022230e+03
+7.037500e+02 2.022230e+03
+7.037000e+02 1.995260e+03
+7.036500e+02 1.995260e+03
+7.036000e+02 1.950510e+03
+7.035500e+02 1.950510e+03
+7.035000e+02 1.896397e+03
+7.034500e+02 1.896397e+03
+7.034000e+02 1.834487e+03
+7.033500e+02 1.834487e+03
+7.033000e+02 1.782963e+03
+7.032500e+02 1.782963e+03
+7.032000e+02 1.774073e+03
+7.031500e+02 1.774073e+03
+7.031000e+02 1.732453e+03
+7.030500e+02 1.732453e+03
+7.030000e+02 1.703070e+03
+7.029500e+02 1.703070e+03
+7.029000e+02 1.713040e+03
+7.028500e+02 1.713040e+03
+7.028000e+02 1.655590e+03
+7.027500e+02 1.655590e+03
+7.027000e+02 1.656197e+03
+7.026500e+02 1.656197e+03
+7.026000e+02 1.633673e+03
+7.025500e+02 1.633673e+03
+7.025000e+02 1.603027e+03
+7.024500e+02 1.603027e+03
+7.024000e+02 1.603283e+03
+7.023500e+02 1.603283e+03
+7.023000e+02 1.578747e+03
+7.022500e+02 1.578747e+03
+7.022000e+02 1.570627e+03
+7.021500e+02 1.570627e+03
+7.021000e+02 1.547140e+03
+7.020500e+02 1.547140e+03
+7.020000e+02 1.516600e+03
+7.019500e+02 1.516600e+03
+7.019000e+02 1.508973e+03
+7.018500e+02 1.508973e+03
+7.018000e+02 1.495770e+03
+7.017500e+02 1.495770e+03
+7.017000e+02 1.474473e+03
+7.016500e+02 1.474473e+03
+7.016000e+02 1.463280e+03
+7.015500e+02 1.463280e+03
+7.015000e+02 1.446327e+03
+7.014500e+02 1.446327e+03
+7.014000e+02 1.456023e+03
+7.013500e+02 1.456023e+03
+7.013000e+02 1.425110e+03
+7.012500e+02 1.425110e+03
+7.012000e+02 1.394570e+03
+7.011500e+02 1.394570e+03
+7.011000e+02 1.405323e+03
+7.010500e+02 1.405323e+03
+7.010000e+02 1.385343e+03
+7.009500e+02 1.385343e+03
+7.009000e+02 1.396943e+03
+7.008500e+02 1.396943e+03
+7.008000e+02 1.398830e+03
+7.007500e+02 1.398830e+03
+7.007000e+02 1.394027e+03
+7.006500e+02 1.394027e+03
+7.006000e+02 1.381977e+03
+7.005500e+02 1.381977e+03
+7.005000e+02 1.369710e+03
+7.004500e+02 1.369710e+03
+7.004000e+02 1.353727e+03
+7.003500e+02 1.353727e+03
+7.003000e+02 1.336587e+03
+7.002500e+02 1.336587e+03
+7.002000e+02 1.331057e+03
+7.001500e+02 1.331057e+03
+7.001000e+02 1.352020e+03
+7.000500e+02 1.352020e+03
+7.000000e+02 1.330413e+03
+6.999500e+02 1.330413e+03
+6.999000e+02 1.317973e+03
+6.998500e+02 1.317973e+03
+6.998000e+02 1.302593e+03
+6.997500e+02 1.302593e+03
+6.997000e+02 1.291273e+03
+6.996500e+02 1.291273e+03
+6.996000e+02 1.311937e+03
+6.995500e+02 1.311937e+03
+6.995000e+02 1.310150e+03
+6.994500e+02 1.310150e+03
+6.994000e+02 1.293153e+03
+6.993500e+02 1.293153e+03
+6.993000e+02 1.288663e+03
+6.992500e+02 1.288663e+03
+6.992000e+02 1.285823e+03
+6.991500e+02 1.285823e+03
+6.991000e+02 1.305353e+03
+6.990500e+02 1.305353e+03
+6.990000e+02 1.297250e+03
+6.989500e+02 1.297250e+03
+6.989000e+02 1.276420e+03
+6.988500e+02 1.276420e+03
+6.988000e+02 1.273183e+03
+6.987500e+02 1.273183e+03
+6.987000e+02 1.268837e+03
+6.986500e+02 1.268837e+03
+6.986000e+02 1.281217e+03
+6.985500e+02 1.281217e+03
+6.985000e+02 1.284917e+03
+6.984500e+02 1.284917e+03
+6.984000e+02 1.288283e+03
+6.983500e+02 1.288283e+03
+6.983000e+02 1.285647e+03
+6.982500e+02 1.285647e+03
+6.982000e+02 1.257090e+03
+6.981500e+02 1.257090e+03
+6.981000e+02 1.279000e+03
+6.980500e+02 1.279000e+03
+6.980000e+02 1.256560e+03
+6.979500e+02 1.256560e+03
+6.979000e+02 1.257673e+03
+6.978500e+02 1.257673e+03
+6.978000e+02 1.258797e+03
+6.977500e+02 1.258797e+03
+6.977000e+02 1.255660e+03
+6.976500e+02 1.255660e+03
+6.976000e+02 1.243003e+03
+6.975500e+02 1.243003e+03
+6.975000e+02 1.256273e+03
+6.974500e+02 1.256273e+03
+6.974000e+02 1.214677e+03
+6.973500e+02 1.214677e+03
+6.973000e+02 1.234697e+03
+6.972500e+02 1.234697e+03
+6.972000e+02 1.222113e+03
+6.971500e+02 1.222113e+03
+6.971000e+02 1.231710e+03
+6.970500e+02 1.231710e+03
+6.970000e+02 1.229630e+03
+6.969500e+02 1.229630e+03
+6.969000e+02 1.231923e+03
+6.968500e+02 1.231923e+03
+6.968000e+02 1.227113e+03
+6.967500e+02 1.227113e+03
+6.967000e+02 1.227287e+03
+6.966500e+02 1.227287e+03
+6.966000e+02 1.240517e+03
+6.965500e+02 1.240517e+03
+6.965000e+02 1.224910e+03
+6.964500e+02 1.224910e+03
+6.964000e+02 1.204783e+03
+6.963500e+02 1.204783e+03
+6.963000e+02 1.211727e+03
+6.962500e+02 1.211727e+03
+6.962000e+02 1.225397e+03
+6.961500e+02 1.225397e+03
+6.961000e+02 1.215387e+03
+6.960500e+02 1.215387e+03
+6.960000e+02 1.208483e+03
+6.959500e+02 1.208483e+03
+6.959000e+02 1.223107e+03
+6.958500e+02 1.223107e+03
+6.958000e+02 1.226523e+03
+6.957500e+02 1.226523e+03
+6.957000e+02 1.206467e+03
+6.956500e+02 1.206467e+03
+6.956000e+02 1.191263e+03
+6.955500e+02 1.191263e+03
+6.955000e+02 1.208387e+03
+6.954500e+02 1.208387e+03
+6.954000e+02 1.214387e+03
+6.953500e+02 1.214387e+03
+6.953000e+02 1.208923e+03
+6.952500e+02 1.208923e+03
+6.952000e+02 1.204790e+03
+6.951500e+02 1.204790e+03
+6.951000e+02 1.201137e+03
+6.950500e+02 1.201137e+03
+6.950000e+02 1.203933e+03
+6.949500e+02 1.203933e+03
+6.949000e+02 1.190553e+03
+6.948500e+02 1.190553e+03
+6.948000e+02 1.190693e+03
+6.947500e+02 1.190693e+03
+6.947000e+02 1.189670e+03
+6.946500e+02 1.189670e+03
+6.946000e+02 1.184720e+03
+6.945500e+02 1.184720e+03
+6.945000e+02 1.200230e+03
+6.944500e+02 1.200230e+03
+6.944000e+02 1.176260e+03
+6.943500e+02 1.176260e+03
+6.943000e+02 1.155047e+03
+6.942500e+02 1.155047e+03
+6.942000e+02 1.182923e+03
+6.941500e+02 1.182923e+03
+6.941000e+02 1.190330e+03
+6.940500e+02 1.190330e+03
+6.940000e+02 1.164773e+03
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ni_references.vms b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ni_references.vms
new file mode 100644
index 0000000000000000000000000000000000000000..b25ee306340cb2398cae8c6c645e18168a572a4d
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ni_references.vms
@@ -0,0 +1,7136 @@
+VAMAS Surface Chemical Analysis Standard Data Transfer Format 1988 May 4
+Not Specified
+Not Specified
+Not Specified
+Not Specified
+6
+Casa Info Follows CasaXPS Version 2.3.25PR1.0
+0
+Created by SpecsLab Prodigy, Version 4.73.2-r95032 
+SourceAnalyserAngle: Not Specified
+CasaRowLabel:Ni
+CasaRowLabel:NiO
+NORM
+REGULAR
+0
+1
+Exp Variable
+d
+0
+0
+0
+0
+4
+Survey
+Ni
+2021
+4
+29
+13
+43
+28
+0
+17
+Casa Info Follows
+0
+0
+0
+0
+File = E:/OwnCloud/XPS lab/EX492_S776_Ni Oxidation.sle
+Group = RT in vacuum, #Treatments:30min sputter, #Temp:RT , #Pressure:vacuum , #Atmosphere:{:}, #Comments:  
+First of group = 1
+Spectrum ID = 3
+Analyzer lens = LargeArea:1.5kV
+Analyzer slit = 4:7x20c\C:mesh
+Scan mode = FixedAnalyzerTransmission
+Kinetic energy start = 286.61
+PCA Coefs = 183133, -17152.6, -29.7063, -194.128, 
+C:\Users\Mark\Downloads\EX492_S776_Ni Oxidation.vms
+c:\users\mark\downloads\ex492_ni references.vms
+C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\NiCoFe\EX491-495 Fe, Ni, Co oxide references.vms
+XPS
+3
+Al
+1486.61
+0
+0
+0
+54.5
+180
+FAT
+100
+1
+4.1408
+0
+0
+0
+0
+0
+Survey
+
+-1
+kinetic energy
+eV
+286.61
+1
+2
+counts
+d
+Transmission
+d
+pulse counting
+0.1
+1
+0
+0
+0
+0
+2
+ESCAPE DEPTH TYPE
+d
+1
+MFP Exponent
+d
+0
+2402
+297.34
+23925.8
+1
+1
+4699.45
+1
+4711.84
+1
+4756.39
+1
+4739.41
+1
+4769.21
+1
+4767.2
+1
+4785.55
+1
+4796.73
+1
+4786.26
+1
+4821.66
+1
+4842.97
+1
+4857.94
+1
+4854.65
+1
+4866.86
+1
+4882.58
+1
+4884.61
+1
+4869.18
+1
+4902.97
+1
+4901.28
+1
+4952.19
+1
+5004.7
+1
+4978.68
+1
+4982.68
+1
+4980.08
+1
+4977.32
+1
+5023.29
+1
+4997.95
+1
+5031.01
+1
+5042.9
+1
+5081.65
+1
+5109.06
+1
+5103.86
+1
+5115.32
+1
+5156.99
+1
+5124.36
+1
+5154.89
+1
+5148.94
+1
+5149.3
+1
+5198.96
+1
+5196.32
+1
+5216.57
+1
+5247.88
+1
+5221.61
+1
+5254.21
+1
+5248.04
+1
+5274.07
+1
+5322.32
+1
+5312.85
+1
+5278
+1
+5300.56
+1
+5334.7
+1
+5323.64
+1
+5409.71
+1
+5431.31
+1
+5414.39
+1
+5439.14
+1
+5435.12
+1
+5464.02
+1
+5470.5
+1
+5488.32
+1
+5525.82
+1
+5545.28
+1
+5521.21
+1
+5557.72
+1
+5566.52
+1
+5578.92
+1
+5599.6
+1
+5633.68
+1
+5658.16
+1
+5658.92
+1
+5651.48
+1
+5718.1
+1
+5726.94
+1
+5722.06
+1
+5741.87
+1
+5762.12
+1
+5801.96
+1
+5815.79
+1
+5821.6
+1
+5822.84
+1
+5823.41
+1
+5834.23
+1
+5836.77
+1
+5854.92
+1
+5928.24
+1
+5921.31
+1
+5901.12
+1
+5931.68
+1
+5965.17
+1
+6018.48
+1
+6064.23
+1
+6023.05
+1
+6028.98
+1
+6046.58
+1
+6101.58
+1
+6138.56
+1
+6135.7
+1
+6130.28
+1
+6178.23
+1
+6223.22
+1
+6199.45
+1
+6219.48
+1
+6254.64
+1
+6272.31
+1
+6289.39
+1
+6238.54
+1
+6260.46
+1
+6341.71
+1
+6339.96
+1
+6355.07
+1
+6405.35
+1
+6426
+1
+6397.67
+1
+6444.8
+1
+6444.46
+1
+6447.52
+1
+6513.58
+1
+6510
+1
+6536.56
+1
+6545.2
+1
+6567.79
+1
+6622.92
+1
+6611.54
+1
+6624.43
+1
+6643.01
+1
+6653.56
+1
+6708.02
+1
+6727.22
+1
+6741.95
+1
+6742.7
+1
+6786.56
+1
+6829.28
+1
+6789.78
+1
+6851.28
+1
+6865.48
+1
+6886.71
+1
+6897.19
+1
+6952.96
+1
+6924.04
+1
+6953.54
+1
+6980.7
+1
+7024.95
+1
+7071.7
+1
+7060.7
+1
+7078.36
+1
+7118.11
+1
+7185.19
+1
+7209.65
+1
+7215.52
+1
+7197.97
+1
+7272.44
+1
+7290.63
+1
+7322.52
+1
+7362.36
+1
+7391.49
+1
+7362.89
+1
+7434.5
+1
+7446.08
+1
+7470.84
+1
+7491.39
+1
+7494.94
+1
+7503.1
+1
+7556.59
+1
+7638.88
+1
+7662.07
+1
+7641.17
+1
+7722.36
+1
+7754.09
+1
+7745.15
+1
+7751.1
+1
+7817.42
+1
+7884.72
+1
+7820.54
+1
+7861.23
+1
+7900.33
+1
+7909.8
+1
+7930.16
+1
+7962.4
+1
+8067.45
+1
+8066.95
+1
+8105.27
+1
+8196.69
+1
+8202.25
+1
+8244.6
+1
+8326.53
+1
+8457.48
+1
+8542.71
+1
+8660.07
+1
+8791.36
+1
+8933.09
+1
+9046.58
+1
+9092.66
+1
+9107.66
+1
+8917.83
+1
+8694.36
+1
+8389.67
+1
+8163.53
+1
+7999.89
+1
+7918.97
+1
+7775.96
+1
+7729.55
+1
+7685.82
+1
+7680.14
+1
+7678.65
+1
+7693.85
+1
+7704.14
+1
+7736.14
+1
+7672.02
+1
+7641.5
+1
+7704.02
+1
+7690.98
+1
+7680.76
+1
+7695.31
+1
+7740.99
+1
+7751.73
+1
+7761.53
+1
+7765.91
+1
+7804.17
+1
+7886.03
+1
+7836.41
+1
+7843.42
+1
+7927.06
+1
+7942.33
+1
+7972.94
+1
+7962.01
+1
+8004.42
+1
+8048.49
+1
+8033.31
+1
+8098.12
+1
+8121.48
+1
+8103.29
+1
+8058.79
+1
+8130.48
+1
+8132.96
+1
+8156.99
+1
+8147.22
+1
+8164.18
+1
+8141.35
+1
+8176.13
+1
+8226.16
+1
+8243.58
+1
+8220.16
+1
+8268.96
+1
+8289.66
+1
+8324.96
+1
+8366.3
+1
+8368.15
+1
+8402.6
+1
+8436.1
+1
+8513.66
+1
+8536.6
+1
+8519.14
+1
+8608.14
+1
+8548.37
+1
+8548.03
+1
+8620.14
+1
+8647.66
+1
+8659.61
+1
+8703.54
+1
+8785.05
+1
+8726.03
+1
+8727.8
+1
+8841.89
+1
+8878.5
+1
+8899.59
+1
+8866.93
+1
+8963.42
+1
+8992.54
+1
+8963.4
+1
+9048.3
+1
+9093.3
+1
+9111.13
+1
+9117.82
+1
+9188.15
+1
+9270.06
+1
+9286.82
+1
+9321.73
+1
+9300.59
+1
+9414
+1
+9392.04
+1
+9465.6
+1
+9538.19
+1
+9542.95
+1
+9583.2
+1
+9651.22
+1
+9688.13
+1
+9751.39
+1
+9826.62
+1
+9870.36
+1
+9941.61
+1
+10000.9
+1
+10041.7
+1
+10088.3
+1
+10152.3
+1
+10160.5
+1
+10256.8
+1
+10394.7
+1
+10434.4
+1
+10435.3
+1
+10585.2
+1
+10617.2
+1
+10628.9
+1
+10678.8
+1
+10787.1
+1
+10826
+1
+10883.7
+1
+10990.4
+1
+11032.5
+1
+11178.5
+1
+11172
+1
+11268
+1
+11328.8
+1
+11406.1
+1
+11547.3
+1
+11706.7
+1
+11736.7
+1
+11792.7
+1
+11888
+1
+11936.7
+1
+11882.2
+1
+11939.3
+1
+12167.3
+1
+12536.2
+1
+12932.5
+1
+13427.8
+1
+13829.6
+1
+13942.2
+1
+14230.1
+1
+15442.1
+1
+17259.1
+1
+17109.5
+1
+14410.9
+1
+11970.8
+1
+11007.8
+1
+10674.4
+1
+10581.9
+1
+10493.6
+1
+10586
+1
+10936.8
+1
+11619.5
+1
+12454.4
+1
+13051.2
+1
+13035.8
+1
+12847.4
+1
+13359.6
+1
+15822.1
+1
+21929.6
+1
+23869.7
+1
+16812.1
+1
+9266.23
+1
+7076.43
+1
+6574.16
+1
+6347.21
+1
+6242.77
+1
+6191.24
+1
+6221.19
+1
+6174.81
+1
+6195.86
+1
+6205.47
+1
+6244.69
+1
+6244.83
+1
+6247.59
+1
+6284.73
+1
+6316.98
+1
+6342.5
+1
+6388.69
+1
+6393.23
+1
+6411.39
+1
+6481.25
+1
+6480.69
+1
+6597.82
+1
+6586.56
+1
+6641.66
+1
+6695.8
+1
+6741.59
+1
+6783.44
+1
+6802.82
+1
+6740.38
+1
+6716.98
+1
+6694.85
+1
+6634.72
+1
+6663.98
+1
+6705.36
+1
+6755.67
+1
+6836.21
+1
+6902.57
+1
+6981.59
+1
+7024.09
+1
+7088.38
+1
+7061
+1
+6968.79
+1
+6842.09
+1
+6851.43
+1
+6829.72
+1
+6826.4
+1
+6820.64
+1
+6829.27
+1
+6901.11
+1
+6888.03
+1
+6892.81
+1
+6908.8
+1
+7009.44
+1
+7082.5
+1
+7129.84
+1
+7141.9
+1
+7205.54
+1
+7224.17
+1
+7231.17
+1
+7264.68
+1
+7338.72
+1
+7425.59
+1
+7498.5
+1
+7562.79
+1
+7600.22
+1
+7694.11
+1
+7792.23
+1
+7882.01
+1
+7936.88
+1
+8084.24
+1
+8251.27
+1
+8412.8
+1
+8541.23
+1
+8517.72
+1
+8434.19
+1
+8186.36
+1
+8028.98
+1
+7945.49
+1
+8000.44
+1
+8087.94
+1
+7985.78
+1
+7655.72
+1
+7221.23
+1
+6745.12
+1
+6384.51
+1
+6151.19
+1
+6011.26
+1
+5956.66
+1
+5931.68
+1
+5870.67
+1
+5810.94
+1
+5831.48
+1
+5752.92
+1
+5729.11
+1
+5697.08
+1
+5648.46
+1
+5717.46
+1
+5749.17
+1
+5788.31
+1
+5823.3
+1
+5786.96
+1
+5739.51
+1
+5659.24
+1
+5590.5
+1
+5487.37
+1
+5540.43
+1
+5534.76
+1
+5532.33
+1
+5503.35
+1
+5534.89
+1
+5589.86
+1
+5618.63
+1
+5641.51
+1
+5658.02
+1
+5722.75
+1
+5770.26
+1
+5804.97
+1
+5881.85
+1
+5926.9
+1
+5970.77
+1
+5973.52
+1
+6069.01
+1
+6085.76
+1
+6139.93
+1
+6182.79
+1
+6280.81
+1
+6335.81
+1
+6383.65
+1
+6454.32
+1
+6541.79
+1
+6690.6
+1
+6808.85
+1
+6992.58
+1
+7086.94
+1
+7220.61
+1
+7438.24
+1
+7847.18
+1
+8394.28
+1
+8939.95
+1
+8796.97
+1
+8052.33
+1
+7368.39
+1
+6979.77
+1
+6887.87
+1
+7015.03
+1
+7154.97
+1
+6955.71
+1
+6503.98
+1
+6034.47
+1
+5586.15
+1
+5150.42
+1
+4759.57
+1
+4456.16
+1
+4334.66
+1
+4294.17
+1
+4258.35
+1
+4205.11
+1
+4082.99
+1
+3947.82
+1
+3863.28
+1
+3804.58
+1
+3790.76
+1
+3758.46
+1
+3735.47
+1
+3651.62
+1
+3587.39
+1
+3584.03
+1
+3548.34
+1
+3531.14
+1
+3525.37
+1
+3560.86
+1
+3560.43
+1
+3597.06
+1
+3625.72
+1
+3668.04
+1
+3709.91
+1
+3758.39
+1
+3810.72
+1
+3824.18
+1
+3859.11
+1
+3881.89
+1
+3940.21
+1
+3961.65
+1
+3997.84
+1
+4031.7
+1
+4074.79
+1
+4096.77
+1
+4116.13
+1
+4141.52
+1
+4154.53
+1
+4171.04
+1
+4202.28
+1
+4236.25
+1
+4274.11
+1
+4345.37
+1
+4410.84
+1
+4511.83
+1
+4561.39
+1
+4646.48
+1
+4751.19
+1
+4893.82
+1
+5110.16
+1
+5428.86
+1
+5655.05
+1
+5793.85
+1
+6024.9
+1
+6419.41
+1
+7019.79
+1
+8010.19
+1
+9496.72
+1
+10394.5
+1
+9760.16
+1
+8266.54
+1
+6901.12
+1
+5874.6
+1
+4835.88
+1
+3618.47
+1
+2698.1
+1
+2287.41
+1
+2142.15
+1
+2090.25
+1
+2014.91
+1
+1939.47
+1
+1902.18
+1
+1907.29
+1
+1977.15
+1
+2056.68
+1
+2128.13
+1
+2046.28
+1
+1853.97
+1
+1662.72
+1
+1510.28
+1
+1346.59
+1
+1166.1
+1
+1024.01
+1
+933.557
+1
+892.728
+1
+869.089
+1
+870.537
+1
+853.423
+1
+847.078
+1
+843.092
+1
+845.637
+1
+850.404
+1
+837.323
+1
+826.453
+1
+829.73
+1
+833.135
+1
+826.842
+1
+832.116
+1
+853.165
+1
+849.736
+1
+860.984
+1
+854.911
+1
+837.403
+1
+841.038
+1
+847.095
+1
+845.643
+1
+837.818
+1
+826.455
+1
+828.329
+1
+822.983
+1
+822.294
+1
+821.227
+1
+813.99
+1
+815.085
+1
+826.461
+1
+822.778
+1
+814.049
+1
+818.541
+1
+833.558
+1
+820.108
+1
+823.218
+1
+817.383
+1
+812.711
+1
+820.861
+1
+846.202
+1
+822.745
+1
+827.286
+1
+831.688
+1
+831.817
+1
+841.229
+1
+855.854
+1
+841.369
+1
+838.962
+1
+846.136
+1
+856.319
+1
+849.174
+1
+844.622
+1
+845.864
+1
+846.034
+1
+841.264
+1
+849.834
+1
+859.227
+1
+841.45
+1
+839.966
+1
+850.55
+1
+847.247
+1
+864.768
+1
+860.876
+1
+861.104
+1
+855.974
+1
+856.608
+1
+851.328
+1
+852.559
+1
+858.513
+1
+867.55
+1
+867.979
+1
+872.483
+1
+874.626
+1
+886.469
+1
+869.956
+1
+875.121
+1
+863.664
+1
+886.696
+1
+883.987
+1
+911.408
+1
+951.851
+1
+1018.57
+1
+1101.75
+1
+1115.74
+1
+1054.39
+1
+942.988
+1
+872.44
+1
+857.346
+1
+837.802
+1
+838.161
+1
+846.093
+1
+849.586
+1
+854.658
+1
+857.729
+1
+862.396
+1
+860.115
+1
+837.596
+1
+862.135
+1
+866.828
+1
+861.721
+1
+871.381
+1
+879.934
+1
+872.484
+1
+880.171
+1
+870.231
+1
+874.447
+1
+864.048
+1
+872.842
+1
+864.603
+1
+879.018
+1
+882.366
+1
+883.61
+1
+889.35
+1
+887.649
+1
+889.721
+1
+886.978
+1
+883.065
+1
+895.011
+1
+893.947
+1
+898.993
+1
+900.295
+1
+905.899
+1
+913.145
+1
+922.936
+1
+925.138
+1
+916.439
+1
+929.682
+1
+916.215
+1
+925.987
+1
+934.021
+1
+912.706
+1
+907.342
+1
+916.217
+1
+901.216
+1
+900.327
+1
+915.086
+1
+912.407
+1
+905.294
+1
+900.855
+1
+908.461
+1
+910.578
+1
+903.403
+1
+895.854
+1
+901.908
+1
+905.267
+1
+895.077
+1
+900.875
+1
+913.564
+1
+920.197
+1
+916.272
+1
+914.822
+1
+914.288
+1
+918.524
+1
+913.639
+1
+914.347
+1
+906.819
+1
+933.767
+1
+912.342
+1
+916.32
+1
+925.738
+1
+926.991
+1
+938.112
+1
+930.568
+1
+929.232
+1
+952.463
+1
+930.37
+1
+932.59
+1
+947.831
+1
+943.113
+1
+937.956
+1
+945.417
+1
+947.771
+1
+936.094
+1
+946.999
+1
+934.677
+1
+955.125
+1
+952.645
+1
+947.699
+1
+941.865
+1
+958.54
+1
+943.428
+1
+954.106
+1
+968.1
+1
+956.36
+1
+957.89
+1
+957.652
+1
+961.495
+1
+968.069
+1
+979.446
+1
+971.532
+1
+972.107
+1
+975.559
+1
+977.825
+1
+980.982
+1
+986.314
+1
+991.321
+1
+998.812
+1
+985.099
+1
+978.006
+1
+965.944
+1
+969.859
+1
+964.531
+1
+978.608
+1
+988.281
+1
+987.44
+1
+997.28
+1
+1003.04
+1
+999.28
+1
+996.739
+1
+1001.33
+1
+992.747
+1
+996.433
+1
+1014.16
+1
+1009.91
+1
+1024.15
+1
+1025.41
+1
+1038.52
+1
+1035.41
+1
+1020.84
+1
+1015.64
+1
+1013.47
+1
+1028.27
+1
+1019.76
+1
+1024.16
+1
+1033.73
+1
+1021.53
+1
+1033.52
+1
+1043.12
+1
+1022.78
+1
+1031.77
+1
+1049.33
+1
+1038.21
+1
+1048.45
+1
+1040.06
+1
+1056.18
+1
+1051.05
+1
+1058.48
+1
+1041.72
+1
+1049.97
+1
+1042.17
+1
+1049.21
+1
+1052.64
+1
+1050.27
+1
+1054.49
+1
+1079.04
+1
+1064.43
+1
+1075.61
+1
+1056.98
+1
+1067.36
+1
+1074.74
+1
+1062.27
+1
+1082.17
+1
+1074.55
+1
+1081.14
+1
+1071.44
+1
+1068.3
+1
+1094.86
+1
+1104.31
+1
+1103.85
+1
+1103.92
+1
+1075.37
+1
+1102.39
+1
+1108.38
+1
+1112.43
+1
+1108.15
+1
+1103.52
+1
+1121.75
+1
+1131.82
+1
+1121.03
+1
+1122.25
+1
+1118.41
+1
+1131.02
+1
+1136.99
+1
+1136.33
+1
+1124.8
+1
+1111.25
+1
+1129.05
+1
+1140.54
+1
+1148.63
+1
+1136.86
+1
+1124.23
+1
+1124.46
+1
+1123.62
+1
+1134.16
+1
+1138.41
+1
+1144.55
+1
+1139.47
+1
+1142.64
+1
+1150.07
+1
+1156.13
+1
+1171.12
+1
+1184.09
+1
+1210.64
+1
+1237.32
+1
+1284.53
+1
+1281.15
+1
+1233.45
+1
+1200.3
+1
+1173.72
+1
+1172.13
+1
+1166.39
+1
+1156.29
+1
+1172.33
+1
+1190.2
+1
+1174.74
+1
+1177.08
+1
+1172.72
+1
+1180.11
+1
+1176.12
+1
+1200.51
+1
+1184.25
+1
+1188.37
+1
+1181.31
+1
+1181.6
+1
+1176.87
+1
+1183.74
+1
+1177.72
+1
+1191.77
+1
+1191.71
+1
+1198.57
+1
+1203.51
+1
+1214.95
+1
+1226.46
+1
+1216.32
+1
+1207.22
+1
+1232.01
+1
+1255.21
+1
+1278.39
+1
+1333.58
+1
+1433.96
+1
+1454.69
+1
+1321.39
+1
+1221.82
+1
+1211.79
+1
+1188.89
+1
+1188.38
+1
+1198.47
+1
+1199.37
+1
+1192.46
+1
+1181.59
+1
+1191.03
+1
+1205.51
+1
+1213.43
+1
+1223.19
+1
+1236.16
+1
+1221.12
+1
+1231.42
+1
+1236.42
+1
+1225.58
+1
+1234.91
+1
+1221.16
+1
+1222.35
+1
+1212.08
+1
+1218.73
+1
+1220.09
+1
+1221.02
+1
+1221.72
+1
+1211.14
+1
+1215.51
+1
+1227.64
+1
+1242.7
+1
+1235.48
+1
+1218.52
+1
+1222.41
+1
+1236.11
+1
+1238.51
+1
+1252.8
+1
+1269.2
+1
+1294.22
+1
+1372.9
+1
+1448.82
+1
+1529.67
+1
+1561.17
+1
+1402.1
+1
+1260.06
+1
+1226.09
+1
+1227.85
+1
+1233.31
+1
+1239.31
+1
+1235.91
+1
+1246.05
+1
+1218.7
+1
+1231.08
+1
+1261.53
+1
+1242.85
+1
+1250.9
+1
+1259.42
+1
+1272.23
+1
+1254.08
+1
+1262.78
+1
+1276.37
+1
+1261.64
+1
+1269.83
+1
+1265.8
+1
+1255.8
+1
+1290.66
+1
+1258.85
+1
+1255.74
+1
+1276.49
+1
+1299
+1
+1300.41
+1
+1298.16
+1
+1321.22
+1
+1307.95
+1
+1288.19
+1
+1292.89
+1
+1279.74
+1
+1310.75
+1
+1312.66
+1
+1320.04
+1
+1320.74
+1
+1332.92
+1
+1332.76
+1
+1347.73
+1
+1327.52
+1
+1351.21
+1
+1345.46
+1
+1334.12
+1
+1337.12
+1
+1357.22
+1
+1361.66
+1
+1362.73
+1
+1356.29
+1
+1360.61
+1
+1379.3
+1
+1374.9
+1
+1380.93
+1
+1404.35
+1
+1383.85
+1
+1388.39
+1
+1408.55
+1
+1397.12
+1
+1384.36
+1
+1403.51
+1
+1418.36
+1
+1414.79
+1
+1414.87
+1
+1425.03
+1
+1412.61
+1
+1422.66
+1
+1418.69
+1
+1436.59
+1
+1423.24
+1
+1432.14
+1
+1447.24
+1
+1460.34
+1
+1467.04
+1
+1467.61
+1
+1469.29
+1
+1462.97
+1
+1477.45
+1
+1509.87
+1
+1498
+1
+1499.08
+1
+1504.75
+1
+1521.29
+1
+1512.61
+1
+1553.31
+1
+1551.21
+1
+1546.63
+1
+1549.41
+1
+1542.57
+1
+1567.95
+1
+1585.74
+1
+1592.51
+1
+1584.31
+1
+1621.85
+1
+1625.09
+1
+1617.88
+1
+1645.45
+1
+1663.09
+1
+1662.57
+1
+1673.1
+1
+1693.44
+1
+1692.92
+1
+1702.97
+1
+1710.2
+1
+1723.97
+1
+1727.71
+1
+1723.05
+1
+1717.39
+1
+1711.65
+1
+1720.13
+1
+1741.13
+1
+1754.41
+1
+1775.92
+1
+1764.35
+1
+1788.79
+1
+1824.09
+1
+1822.27
+1
+1823.69
+1
+1857.1
+1
+1886.05
+1
+1919.09
+1
+1986.8
+1
+2088.5
+1
+2137.77
+1
+2174.3
+1
+2242.76
+1
+2315.89
+1
+2492.88
+1
+2767.74
+1
+3129.22
+1
+3192.2
+1
+2736.07
+1
+2230.25
+1
+1891.95
+1
+1729.42
+1
+1656.96
+1
+1641.91
+1
+1649.43
+1
+1643.11
+1
+1637.71
+1
+1650.58
+1
+1687.08
+1
+1682.98
+1
+1707.66
+1
+1726.16
+1
+1710.18
+1
+1722.2
+1
+1751.73
+1
+1778.1
+1
+1770.56
+1
+1765.83
+1
+1776.78
+1
+1779.09
+1
+1736.14
+1
+1727.2
+1
+1742.69
+1
+1740.99
+1
+1757.27
+1
+1777.22
+1
+1854.14
+1
+1902.54
+1
+2000.09
+1
+2071.3
+1
+2030.02
+1
+1907.91
+1
+1912.44
+1
+1974.27
+1
+2089.34
+1
+2250.82
+1
+2432.21
+1
+2676.45
+1
+3177.26
+1
+4060.19
+1
+4899.79
+1
+5191.53
+1
+4155.76
+1
+2412.44
+1
+1273.93
+1
+806.856
+1
+611.307
+1
+505.526
+1
+444.691
+1
+406.359
+1
+367.408
+1
+364.856
+1
+353.755
+1
+335.852
+1
+328.046
+1
+326.134
+1
+332.494
+1
+327.797
+1
+330.19
+1
+329.943
+1
+320.262
+1
+322.317
+1
+326.62
+1
+323.635
+1
+325.032
+1
+329.258
+1
+334.709
+1
+325.916
+1
+342.336
+1
+351.983
+1
+365.185
+1
+357.567
+1
+360.252
+1
+374.167
+1
+374.155
+1
+376.868
+1
+388.747
+1
+380.992
+1
+380.338
+1
+377.905
+1
+377.479
+1
+374.456
+1
+377.737
+1
+379.588
+1
+398.68
+1
+407.172
+1
+393.758
+1
+381.913
+1
+376.548
+1
+368.051
+1
+360.905
+1
+369.06
+1
+373.06
+1
+387.565
+1
+388.327
+1
+404.704
+1
+428.773
+1
+454.826
+1
+499.374
+1
+566.312
+1
+617.513
+1
+682.051
+1
+740.101
+1
+800.407
+1
+971.997
+1
+1327.61
+1
+1637.15
+1
+1368.55
+1
+636.463
+1
+Ni2p
+Ni
+2021
+4
+29
+13
+47
+1
+0
+17
+Casa Info Follows
+0
+0
+0
+0
+File = E:/OwnCloud/XPS lab/EX492_S776_Ni Oxidation.sle
+Group = RT in vacuum, #Treatments:30min sputter, #Temp:RT , #Pressure:vacuum , #Atmosphere:{:}, #Comments:  
+First of group = 0
+Spectrum ID = 4
+Analyzer lens = AngleResolvedMode22:1.5kV
+Analyzer slit = 4:7x20c\C:mesh
+Scan mode = FixedAnalyzerTransmission
+Kinetic energy start = 596.61
+PCA Coefs = 190810, -40055.7, -202.957, -142.327, 70.9683, 
+C:\Users\Mark\Downloads\EX492_S776_Ni Oxidation.vms
+c:\users\mark\downloads\ex492_ni references.vms
+C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\NiCoFe\EX491-495 Fe, Ni, Co oxide references.vms
+XPS
+4
+Al
+1486.61
+0
+0
+0
+54.5
+180
+FAT
+20
+1
+4.1408
+0
+0
+0
+0
+0
+Ni
+2p
+-1
+kinetic energy
+eV
+596.61
+0.1
+2
+counts
+d
+Transmission
+d
+pulse counting
+0.1
+3
+0
+0
+0
+0
+2
+ESCAPE DEPTH TYPE
+d
+1
+MFP Exponent
+d
+0
+1002
+4049.78
+27322.3
+1
+1
+7694.49
+1
+7709.97
+1
+7774.09
+1
+7767.08
+1
+7793.16
+1
+7805.07
+1
+7794.91
+1
+7780.07
+1
+7726.26
+1
+7809.02
+1
+7820.68
+1
+7809.69
+1
+7803.3
+1
+7825.53
+1
+7862.65
+1
+7807.74
+1
+7816.49
+1
+7836.62
+1
+7815.06
+1
+7800.96
+1
+7861.02
+1
+7897.82
+1
+7863.47
+1
+7890.83
+1
+7872.82
+1
+7879.83
+1
+7924.06
+1
+7904.55
+1
+7951.42
+1
+7942.64
+1
+7876.86
+1
+7902.57
+1
+7913.54
+1
+7947.92
+1
+7882.93
+1
+7940.03
+1
+7953.88
+1
+7959.18
+1
+7962.96
+1
+7966.93
+1
+7918.34
+1
+7987.57
+1
+8014.74
+1
+8041.56
+1
+8033.48
+1
+7994.67
+1
+7967.4
+1
+7982.5
+1
+8053.52
+1
+8055.77
+1
+8009.96
+1
+8007.74
+1
+8017.1
+1
+8072.37
+1
+8062.71
+1
+8078.81
+1
+8056.22
+1
+8062.66
+1
+8069
+1
+8085.57
+1
+8083.31
+1
+8089.68
+1
+8107.8
+1
+8112.24
+1
+8123.94
+1
+8089.07
+1
+8082.05
+1
+8108.13
+1
+8116.91
+1
+8086.85
+1
+8130.15
+1
+8175.5
+1
+8183.5
+1
+8179.95
+1
+8162.14
+1
+8166.09
+1
+8211.19
+1
+8228.81
+1
+8222.44
+1
+8222.1
+1
+8239.74
+1
+8195.04
+1
+8201.44
+1
+8140.65
+1
+8200
+1
+8160.42
+1
+8166.75
+1
+8177.4
+1
+8182.68
+1
+8142.5
+1
+8122.83
+1
+8156.52
+1
+8155.76
+1
+8185.26
+1
+8147.92
+1
+8131.86
+1
+8118.86
+1
+8095.23
+1
+8125.77
+1
+8142.79
+1
+8132.58
+1
+8201.08
+1
+8170.91
+1
+8203.25
+1
+8148.61
+1
+8213.76
+1
+8194.45
+1
+8172.03
+1
+8229.16
+1
+8233.19
+1
+8231.02
+1
+8247.06
+1
+8315.53
+1
+8294.29
+1
+8243.64
+1
+8295.08
+1
+8362.68
+1
+8361.67
+1
+8391.15
+1
+8404.75
+1
+8424.2
+1
+8418.62
+1
+8462.51
+1
+8492.66
+1
+8514.99
+1
+8534.59
+1
+8565.17
+1
+8638.67
+1
+8607.93
+1
+8663.39
+1
+8687.29
+1
+8717.93
+1
+8718.34
+1
+8848.84
+1
+8794.06
+1
+8849.43
+1
+8956.96
+1
+8973.83
+1
+8970.52
+1
+9013.27
+1
+9095.81
+1
+9061.21
+1
+9120.03
+1
+9141.98
+1
+9229.89
+1
+9250.21
+1
+9361.42
+1
+9429.43
+1
+9430.17
+1
+9418.92
+1
+9446.67
+1
+9524.08
+1
+9556.45
+1
+9574.46
+1
+9559.65
+1
+9647.85
+1
+9679.14
+1
+9597.89
+1
+9561.74
+1
+9592.43
+1
+9590.3
+1
+9536.1
+1
+9565.25
+1
+9530.35
+1
+9463.56
+1
+9497.82
+1
+9510.55
+1
+9471.51
+1
+9493.36
+1
+9498.63
+1
+9447.48
+1
+9460.44
+1
+9452.55
+1
+9495.66
+1
+9493.28
+1
+9499.08
+1
+9564.26
+1
+9536.76
+1
+9644.48
+1
+9709.81
+1
+9799.29
+1
+9906.24
+1
+10007.9
+1
+10108
+1
+10184.4
+1
+10307.3
+1
+10458.6
+1
+10663.4
+1
+10812.9
+1
+11019.4
+1
+11306.5
+1
+11573.2
+1
+11809.1
+1
+12231.4
+1
+12604.5
+1
+12873.3
+1
+13248.7
+1
+13595.7
+1
+13946.8
+1
+14187.3
+1
+14364.4
+1
+14427.1
+1
+14295.5
+1
+13981.6
+1
+13657.1
+1
+13151.6
+1
+12636.4
+1
+12115.7
+1
+11510
+1
+10949.2
+1
+10388.1
+1
+9977.92
+1
+9590.44
+1
+9242.71
+1
+8973.91
+1
+8724.96
+1
+8535.48
+1
+8359.85
+1
+8243.03
+1
+8056.85
+1
+7956.54
+1
+7880.86
+1
+7832.67
+1
+7725.57
+1
+7681.87
+1
+7629.58
+1
+7562.65
+1
+7484.62
+1
+7494.67
+1
+7440.28
+1
+7359.28
+1
+7307.3
+1
+7301.19
+1
+7265.38
+1
+7299.7
+1
+7234.61
+1
+7220.37
+1
+7200.34
+1
+7274.55
+1
+7227.68
+1
+7189.85
+1
+7186.69
+1
+7214.85
+1
+7212.74
+1
+7150.56
+1
+7180.89
+1
+7153.77
+1
+7147.19
+1
+7172.19
+1
+7160.16
+1
+7174.67
+1
+7151.19
+1
+7153.06
+1
+7175.32
+1
+7164.31
+1
+7126.04
+1
+7101.48
+1
+7107.77
+1
+7137.05
+1
+7097
+1
+7084.59
+1
+7091.38
+1
+7103.17
+1
+7085.27
+1
+7068.53
+1
+7051.69
+1
+7117.12
+1
+7080.05
+1
+7102.67
+1
+7063.9
+1
+7115.33
+1
+7120.77
+1
+7117.41
+1
+7095.56
+1
+7126.87
+1
+7197.04
+1
+7149.84
+1
+7200.63
+1
+7219.65
+1
+7220.18
+1
+7259.62
+1
+7290.63
+1
+7264.22
+1
+7307.94
+1
+7296.23
+1
+7358.69
+1
+7431.44
+1
+7467.53
+1
+7512.25
+1
+7536.07
+1
+7559.35
+1
+7621.85
+1
+7713.06
+1
+7762.17
+1
+7796.89
+1
+7881.68
+1
+7985.02
+1
+8023.5
+1
+8087.94
+1
+8182.57
+1
+8234.9
+1
+8284.36
+1
+8426.42
+1
+8508.79
+1
+8587.12
+1
+8655.56
+1
+8716.25
+1
+8856.62
+1
+8897.45
+1
+8946.22
+1
+9010.38
+1
+9091.22
+1
+9195.63
+1
+9259.72
+1
+9297.86
+1
+9273.08
+1
+9267.54
+1
+9273.67
+1
+9172.16
+1
+9142.43
+1
+9050.77
+1
+8999.35
+1
+8926.02
+1
+8819.58
+1
+8760.66
+1
+8694.04
+1
+8655.5
+1
+8638.29
+1
+8619.23
+1
+8595.05
+1
+8582.18
+1
+8553.45
+1
+8528.59
+1
+8521.69
+1
+8498.66
+1
+8479.56
+1
+8556.71
+1
+8582.05
+1
+8512.43
+1
+8523.98
+1
+8553.39
+1
+8565.28
+1
+8647.66
+1
+8662.3
+1
+8656.01
+1
+8722.97
+1
+8756.4
+1
+8785.59
+1
+8791.78
+1
+8926.6
+1
+9007.82
+1
+9185.3
+1
+9310.65
+1
+9425.41
+1
+9566.78
+1
+9779.53
+1
+10039
+1
+10275.2
+1
+10564.1
+1
+10908.3
+1
+11286.5
+1
+11781.5
+1
+12386.2
+1
+13080.8
+1
+13911.4
+1
+14894.6
+1
+16193.6
+1
+17614.8
+1
+19349.4
+1
+21253
+1
+23244.7
+1
+25132
+1
+26670
+1
+27449.8
+1
+27309.6
+1
+26105
+1
+24020.3
+1
+21275.8
+1
+18223.9
+1
+15300.1
+1
+12762
+1
+10763.1
+1
+9274.81
+1
+8177.48
+1
+7389.31
+1
+6774.59
+1
+6305.5
+1
+5991.37
+1
+5694.54
+1
+5479.07
+1
+5320.76
+1
+5211.68
+1
+5097.4
+1
+5012.48
+1
+4910.29
+1
+4822.75
+1
+4760.3
+1
+4715.5
+1
+4668.12
+1
+4597.89
+1
+4555.5
+1
+4535.78
+1
+4492.83
+1
+4421.45
+1
+4407.44
+1
+4381.45
+1
+4396.78
+1
+4374.99
+1
+4352.61
+1
+4329.43
+1
+4338.79
+1
+4322.35
+1
+4286.62
+1
+4309.25
+1
+4272.53
+1
+4243.82
+1
+4253.81
+1
+4251.07
+1
+4245.72
+1
+4215.23
+1
+4246.71
+1
+4238.07
+1
+4227.06
+1
+4163.92
+1
+4200.79
+1
+4202.27
+1
+4205.69
+1
+4223.21
+1
+4201.59
+1
+4196
+1
+4202.24
+1
+4194.46
+1
+4188.09
+1
+4187.69
+1
+4172.62
+1
+4160.99
+1
+4146.58
+1
+4119.79
+1
+4191.35
+1
+4162.66
+1
+4139.87
+1
+4156.6
+1
+4143.4
+1
+4153.15
+1
+4165.43
+1
+4149.67
+1
+4142.3
+1
+4127.57
+1
+4126.69
+1
+4146.55
+1
+4158.11
+1
+4143.14
+1
+4125.33
+1
+4150.67
+1
+4140.71
+1
+4142.69
+1
+4136.8
+1
+4125.1
+1
+4137.28
+1
+4135.68
+1
+4171.39
+1
+4165.16
+1
+4141.13
+1
+4138.53
+1
+4149.84
+1
+4180.7
+1
+4182.47
+1
+4155.57
+1
+4140.71
+1
+4128.32
+1
+4134.3
+1
+4155.23
+1
+4140.17
+1
+4164.02
+1
+4131.8
+1
+4150.11
+1
+4124.71
+1
+4139.84
+1
+4136.4
+1
+4161.91
+1
+4179.52
+1
+4153.11
+1
+4202.13
+1
+4193.98
+1
+4193.96
+1
+4153.98
+1
+4163.3
+1
+4121.79
+1
+4160.11
+1
+4171.19
+1
+4172.88
+1
+4180.07
+1
+4128.17
+1
+4167.1
+1
+4187.27
+1
+4174.84
+1
+4186.69
+1
+4181.21
+1
+4199.12
+1
+4182.87
+1
+4171.84
+1
+Survey
+NiO
+2021
+4
+29
+23
+25
+58
+0
+17
+Casa Info Follows
+0
+0
+0
+0
+File = E:/OwnCloud/XPS lab/EX492_S776_Ni Oxidation.sle
+Group = RT in vacuum, #Treatments: , #Temp:RT , #Pressure:vacuum , #Atmosphere:, #Comments:  
+First of group = 1
+Spectrum ID = 19
+Analyzer lens = LargeArea:1.5kV
+Analyzer slit = 4:7x20c\C:mesh
+Scan mode = FixedAnalyzerTransmission
+Kinetic energy start = 286.61
+PCA Coefs = 144137, 9370.22, -1718.27, 1048.98, 
+C:\Users\Mark\Downloads\EX492_S776_Ni Oxidation.vms
+c:\users\mark\downloads\ex492_ni references.vms
+C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\NiCoFe\EX491-495 Fe, Ni, Co oxide references.vms
+XPS
+15
+Al
+1486.61
+0
+0
+0
+54.5
+180
+FAT
+100
+1
+4.1408
+0
+0
+0
+0
+0
+Survey
+
+-1
+kinetic energy
+eV
+286.61
+1
+2
+counts
+d
+Transmission
+d
+pulse counting
+0.1
+1
+0
+0
+0
+0
+2
+ESCAPE DEPTH TYPE
+d
+1
+MFP Exponent
+d
+0
+2402
+106.665
+13566.8
+1
+1
+4025.6
+1
+4055.22
+1
+4076.4
+1
+4059.62
+1
+4116.38
+1
+4116.66
+1
+4064.5
+1
+4086.43
+1
+4101.6
+1
+4150.96
+1
+4141.52
+1
+4139.77
+1
+4162.58
+1
+4167.49
+1
+4179.91
+1
+4225.19
+1
+4228.4
+1
+4211.03
+1
+4228.14
+1
+4231.34
+1
+4232.72
+1
+4246.14
+1
+4239.06
+1
+4244.83
+1
+4273.05
+1
+4306.67
+1
+4311.25
+1
+4346.39
+1
+4341.38
+1
+4328.93
+1
+4386.42
+1
+4368.1
+1
+4407.19
+1
+4432.95
+1
+4449.97
+1
+4439.32
+1
+4428.45
+1
+4475.74
+1
+4457.44
+1
+4461.42
+1
+4477.68
+1
+4512.19
+1
+4492.57
+1
+4525.66
+1
+4530.14
+1
+4545.18
+1
+4572.85
+1
+4599.57
+1
+4587.22
+1
+4611.88
+1
+4621.6
+1
+4656.6
+1
+4652.53
+1
+4676.53
+1
+4665.46
+1
+4641.49
+1
+4712.2
+1
+4719.34
+1
+4714.77
+1
+4708.45
+1
+4731.03
+1
+4771.33
+1
+4783.68
+1
+4792.02
+1
+4800.19
+1
+4844.52
+1
+4830.49
+1
+4837.28
+1
+4850.78
+1
+4877.21
+1
+4877.77
+1
+4887.84
+1
+4902.04
+1
+4915.27
+1
+4952.8
+1
+4961.25
+1
+4979.02
+1
+4978.54
+1
+5011.64
+1
+5026.69
+1
+5039.6
+1
+5060.02
+1
+5030.43
+1
+5076.76
+1
+5074.1
+1
+5113.22
+1
+5057.08
+1
+5092.89
+1
+5107.2
+1
+5148
+1
+5165.81
+1
+5191.11
+1
+5178.69
+1
+5171.77
+1
+5198.82
+1
+5187.54
+1
+5225.36
+1
+5264.62
+1
+5267.33
+1
+5263.6
+1
+5304.41
+1
+5286.74
+1
+5322.55
+1
+5301.32
+1
+5331.05
+1
+5339.72
+1
+5338.65
+1
+5382.49
+1
+5380.09
+1
+5407.78
+1
+5441.5
+1
+5441.92
+1
+5485.44
+1
+5498.22
+1
+5484.36
+1
+5534.21
+1
+5559.16
+1
+5542.67
+1
+5523.04
+1
+5570.32
+1
+5607.53
+1
+5609.85
+1
+5594.44
+1
+5635.8
+1
+5639.13
+1
+5642.97
+1
+5698.63
+1
+5670.59
+1
+5733.37
+1
+5756
+1
+5778.98
+1
+5753.29
+1
+5797.79
+1
+5825.71
+1
+5820.41
+1
+5868.61
+1
+5858.58
+1
+5860.25
+1
+5885.03
+1
+5880.61
+1
+5936.19
+1
+5957.96
+1
+5933.98
+1
+5956.01
+1
+5977.75
+1
+6015.63
+1
+6001.19
+1
+6027.23
+1
+6049.42
+1
+6061.81
+1
+6062.34
+1
+6081.62
+1
+6104.14
+1
+6120.9
+1
+6140.46
+1
+6226.39
+1
+6198.46
+1
+6212.86
+1
+6199.04
+1
+6248.45
+1
+6311.27
+1
+6252.08
+1
+6325.49
+1
+6301.87
+1
+6357.45
+1
+6370.69
+1
+6399.6
+1
+6412.1
+1
+6409.48
+1
+6399.17
+1
+6399.23
+1
+6417.74
+1
+6423.32
+1
+6450.85
+1
+6514.76
+1
+6553.45
+1
+6608.36
+1
+6660.75
+1
+6746.68
+1
+6821.5
+1
+6935.73
+1
+7037.75
+1
+7146.72
+1
+7216.15
+1
+7271.93
+1
+7329.85
+1
+7366.06
+1
+7345.07
+1
+7411.64
+1
+7461.69
+1
+7455.56
+1
+7306.57
+1
+7190.91
+1
+6991.78
+1
+6874.3
+1
+6760.87
+1
+6672.65
+1
+6632.42
+1
+6582.63
+1
+6574.6
+1
+6570.83
+1
+6606.92
+1
+6656.87
+1
+6692.44
+1
+6794.2
+1
+6799.98
+1
+6785.21
+1
+6742.42
+1
+6648.37
+1
+6599.95
+1
+6589.64
+1
+6628.71
+1
+6595.04
+1
+6580.67
+1
+6589.11
+1
+6602.1
+1
+6609.14
+1
+6613.59
+1
+6620.01
+1
+6698.65
+1
+6772.71
+1
+6914.94
+1
+7117.14
+1
+7357.96
+1
+7526.69
+1
+7593.86
+1
+7518.58
+1
+7315.14
+1
+7153.78
+1
+7020.58
+1
+6951.64
+1
+6883
+1
+6777.45
+1
+6703.5
+1
+6726.89
+1
+6652.7
+1
+6567.32
+1
+6591.95
+1
+6550.05
+1
+6551.7
+1
+6543
+1
+6553.66
+1
+6515.46
+1
+6549
+1
+6555.47
+1
+6589.39
+1
+6587.09
+1
+6594.38
+1
+6642.47
+1
+6657.52
+1
+6657.33
+1
+6717.33
+1
+6727.04
+1
+6723.44
+1
+6723.35
+1
+6750.7
+1
+6753.86
+1
+6819.33
+1
+6834.13
+1
+6832.69
+1
+6836.19
+1
+6854.24
+1
+6860.26
+1
+6891.23
+1
+6857.28
+1
+6907.59
+1
+6930.49
+1
+6959.15
+1
+7037.76
+1
+7046.24
+1
+7024.56
+1
+7093.96
+1
+7071.33
+1
+7139.72
+1
+7115.35
+1
+7134.47
+1
+7152.77
+1
+7221.91
+1
+7238.23
+1
+7272.13
+1
+7257.35
+1
+7261.94
+1
+7261.72
+1
+7302.22
+1
+7339.47
+1
+7392.24
+1
+7443.77
+1
+7483.3
+1
+7557.25
+1
+7533.08
+1
+7562.73
+1
+7605.99
+1
+7614.84
+1
+7626.37
+1
+7660.89
+1
+7670.91
+1
+7714.22
+1
+7740.78
+1
+7733.7
+1
+7786.52
+1
+7842.64
+1
+7836.19
+1
+7903.49
+1
+7967.74
+1
+7903.14
+1
+7918.74
+1
+7897.39
+1
+7858.62
+1
+7812.52
+1
+7854.63
+1
+7767.29
+1
+7723.19
+1
+7721.43
+1
+7750.17
+1
+7826.16
+1
+8076.75
+1
+8481.66
+1
+8979.38
+1
+9573.83
+1
+10005.2
+1
+10207.1
+1
+10115.4
+1
+9839.59
+1
+9526.79
+1
+9417.19
+1
+9719.12
+1
+10269.9
+1
+10545.7
+1
+10324.1
+1
+9206.29
+1
+7837.73
+1
+7305.49
+1
+7547.03
+1
+7918.72
+1
+8228.34
+1
+8714.58
+1
+9545.89
+1
+10468.1
+1
+11155.7
+1
+11219.2
+1
+10503.5
+1
+9812.68
+1
+10196.3
+1
+11612.7
+1
+12902.9
+1
+13690.9
+1
+12343.1
+1
+8759
+1
+5958.05
+1
+5222.54
+1
+5079.54
+1
+4968.66
+1
+4911.23
+1
+4915.86
+1
+4888.37
+1
+4864.19
+1
+4891.18
+1
+4890.67
+1
+4921.65
+1
+4935.27
+1
+4942.34
+1
+4951.65
+1
+4967.61
+1
+5003.84
+1
+5030.08
+1
+5033.05
+1
+5078.96
+1
+5101.76
+1
+5137.23
+1
+5165.08
+1
+5159.1
+1
+5168.86
+1
+5203.64
+1
+5251.43
+1
+5303.12
+1
+5276.48
+1
+5252.98
+1
+5239.21
+1
+5223.72
+1
+5237.85
+1
+5215.32
+1
+5234.26
+1
+5262.47
+1
+5323.16
+1
+5363.77
+1
+5415.56
+1
+5421.43
+1
+5465.69
+1
+5407.61
+1
+5391.39
+1
+5366.37
+1
+5293.76
+1
+5252.48
+1
+5231.09
+1
+5232.06
+1
+5270.36
+1
+5246.12
+1
+5289.75
+1
+5298.79
+1
+5284.5
+1
+5326.29
+1
+5371.88
+1
+5372.72
+1
+5400.94
+1
+5382.8
+1
+5384.76
+1
+5471.48
+1
+5497.21
+1
+5504.67
+1
+5525.49
+1
+5600.56
+1
+5633.39
+1
+5665.37
+1
+5741.08
+1
+5803.91
+1
+5855.56
+1
+5942.51
+1
+6023.27
+1
+6100.15
+1
+6192.55
+1
+6235.06
+1
+6283.26
+1
+6190.52
+1
+6178.36
+1
+6222.4
+1
+6160.41
+1
+6175.26
+1
+6057.09
+1
+5904.7
+1
+5759.07
+1
+5541.4
+1
+5352.69
+1
+5145.41
+1
+4995.24
+1
+4847.7
+1
+4774.7
+1
+4789.51
+1
+4765.2
+1
+4720.56
+1
+4690.61
+1
+4654.97
+1
+4678
+1
+4677.21
+1
+4639.19
+1
+4606.22
+1
+4587.47
+1
+4562.35
+1
+4514.5
+1
+4522.39
+1
+4460.94
+1
+4438.55
+1
+4401.3
+1
+4391.78
+1
+4375.04
+1
+4335.79
+1
+4338.32
+1
+4328.15
+1
+4334.42
+1
+4346.04
+1
+4363.07
+1
+4374.17
+1
+4357.89
+1
+4367.48
+1
+4404.78
+1
+4411.78
+1
+4471.38
+1
+4493.37
+1
+4477.63
+1
+4498.5
+1
+4567.04
+1
+4568.76
+1
+4574.26
+1
+4578.42
+1
+4634.78
+1
+4724.17
+1
+4819.87
+1
+4896.01
+1
+4974.33
+1
+4995.44
+1
+5012.76
+1
+5043.5
+1
+5069.1
+1
+5186.65
+1
+5326.17
+1
+5469.71
+1
+5667.04
+1
+5856.6
+1
+6073.55
+1
+6094.19
+1
+5913.3
+1
+5702.12
+1
+5500.18
+1
+5398.43
+1
+5265.78
+1
+5186.7
+1
+5116.47
+1
+4977.4
+1
+4670.55
+1
+4339.78
+1
+4036.3
+1
+3863.72
+1
+3727.85
+1
+3631.17
+1
+3606.81
+1
+3564.6
+1
+3532.08
+1
+3478.37
+1
+3417.32
+1
+3374.85
+1
+3316.29
+1
+3256.14
+1
+3224.94
+1
+3159.62
+1
+3140.63
+1
+3101.43
+1
+3082.48
+1
+3036.02
+1
+2996.84
+1
+3000.63
+1
+2976.31
+1
+3029.75
+1
+3018.91
+1
+3015.13
+1
+3034.92
+1
+3033.42
+1
+3063.97
+1
+3037.33
+1
+3078.79
+1
+3081.01
+1
+3079.34
+1
+3114.18
+1
+3124.57
+1
+3177.53
+1
+3198.81
+1
+3209.86
+1
+3244.94
+1
+3272.73
+1
+3280.51
+1
+3281.23
+1
+3290.84
+1
+3299.63
+1
+3302.19
+1
+3314
+1
+3311.16
+1
+3266.95
+1
+3244.73
+1
+3286.64
+1
+3393.95
+1
+3511.72
+1
+3656.02
+1
+3824.99
+1
+4068.02
+1
+4413.12
+1
+4740.84
+1
+5091.05
+1
+5362.62
+1
+5526.96
+1
+5584.3
+1
+5508.01
+1
+5446.11
+1
+5418.15
+1
+5376.68
+1
+5310.29
+1
+4986.91
+1
+4199
+1
+3396.89
+1
+2735
+1
+2320.49
+1
+2103.76
+1
+2057.67
+1
+2060.52
+1
+2074.2
+1
+2101.57
+1
+2131.08
+1
+2120.69
+1
+2113.22
+1
+2114.93
+1
+2112.21
+1
+2083.08
+1
+2040.47
+1
+1920.88
+1
+1755.92
+1
+1568.38
+1
+1429.52
+1
+1342.95
+1
+1288.64
+1
+1286.34
+1
+1280.25
+1
+1262.69
+1
+1260.31
+1
+1269.52
+1
+1264.35
+1
+1273.16
+1
+1283.2
+1
+1288.16
+1
+1289.74
+1
+1289.58
+1
+1312.49
+1
+1301.76
+1
+1314.23
+1
+1312.48
+1
+1303.1
+1
+1323.15
+1
+1315.41
+1
+1301.36
+1
+1284.99
+1
+1273.76
+1
+1293.94
+1
+1280.2
+1
+1297.18
+1
+1304.93
+1
+1299.08
+1
+1316.75
+1
+1316.88
+1
+1318.9
+1
+1309.67
+1
+1302.02
+1
+1308.75
+1
+1339.52
+1
+1344.72
+1
+1344.82
+1
+1370.9
+1
+1378.01
+1
+1365.8
+1
+1380.13
+1
+1400.35
+1
+1414.66
+1
+1398.15
+1
+1408.31
+1
+1405.45
+1
+1409.67
+1
+1412.83
+1
+1401.55
+1
+1393.11
+1
+1390.27
+1
+1386.94
+1
+1380.41
+1
+1371.55
+1
+1389.29
+1
+1378.9
+1
+1409.85
+1
+1415.64
+1
+1407.85
+1
+1452.31
+1
+1528.79
+1
+1611.36
+1
+1664.68
+1
+1672.05
+1
+1662.66
+1
+1590.69
+1
+1532.5
+1
+1460.07
+1
+1383.09
+1
+1344.18
+1
+1309.58
+1
+1277.99
+1
+1238.45
+1
+1208.18
+1
+1164.01
+1
+1129.89
+1
+1122.99
+1
+1121.67
+1
+1140.17
+1
+1151.8
+1
+1183.21
+1
+1208.42
+1
+1380.78
+1
+1956.98
+1
+2913.88
+1
+5322.25
+1
+7324.81
+1
+5226.63
+1
+1954.43
+1
+940.425
+1
+816.164
+1
+769.064
+1
+736.149
+1
+720.011
+1
+701.738
+1
+697.545
+1
+701.608
+1
+690.702
+1
+705.456
+1
+697.18
+1
+694.829
+1
+696.982
+1
+704.108
+1
+712
+1
+703.255
+1
+697.268
+1
+696.925
+1
+709.297
+1
+698.52
+1
+715.722
+1
+720.206
+1
+716.118
+1
+707.139
+1
+717.705
+1
+711.35
+1
+718.167
+1
+730.517
+1
+721.728
+1
+724.488
+1
+719.301
+1
+726.153
+1
+733.755
+1
+722.522
+1
+732.365
+1
+715.112
+1
+727.826
+1
+739.328
+1
+728
+1
+736.22
+1
+745.243
+1
+728.554
+1
+731.632
+1
+721.406
+1
+730.498
+1
+731.608
+1
+721.588
+1
+725.628
+1
+728.005
+1
+720.147
+1
+716.423
+1
+716.687
+1
+713.903
+1
+725.373
+1
+734.745
+1
+734.113
+1
+710.127
+1
+721.402
+1
+718.429
+1
+719.51
+1
+721.132
+1
+737.813
+1
+744.331
+1
+743.334
+1
+729.244
+1
+713.1
+1
+726.588
+1
+739.692
+1
+750.751
+1
+743.825
+1
+746.918
+1
+741.197
+1
+739.457
+1
+750.578
+1
+752.115
+1
+749.849
+1
+749.382
+1
+733.73
+1
+743.288
+1
+737.595
+1
+745.352
+1
+743.333
+1
+761.396
+1
+758.023
+1
+756.455
+1
+761.295
+1
+764.493
+1
+759.365
+1
+771.654
+1
+764.946
+1
+767.999
+1
+762.122
+1
+762.924
+1
+754.64
+1
+758.315
+1
+765.549
+1
+778.438
+1
+783.729
+1
+770.226
+1
+761.526
+1
+776.309
+1
+766.248
+1
+769.095
+1
+754.867
+1
+767.356
+1
+784.184
+1
+773.375
+1
+773.132
+1
+774.916
+1
+781.444
+1
+781.069
+1
+775.802
+1
+777.115
+1
+797.646
+1
+784.817
+1
+794.41
+1
+787.571
+1
+777.719
+1
+787.926
+1
+783.271
+1
+782.715
+1
+796.973
+1
+786.374
+1
+795.997
+1
+811.175
+1
+813.764
+1
+812.448
+1
+814.551
+1
+821.97
+1
+796.406
+1
+783.831
+1
+797.167
+1
+807.338
+1
+807.089
+1
+810.011
+1
+808.723
+1
+818.338
+1
+817.054
+1
+809.987
+1
+805.25
+1
+814.416
+1
+815.932
+1
+805.614
+1
+804.71
+1
+816.236
+1
+832.541
+1
+819.279
+1
+825.772
+1
+816.891
+1
+834.013
+1
+825.913
+1
+821.82
+1
+841.664
+1
+832.787
+1
+828.09
+1
+827.77
+1
+827.037
+1
+834.002
+1
+843.945
+1
+841.942
+1
+855.12
+1
+833.547
+1
+843.862
+1
+837.676
+1
+849.768
+1
+854.17
+1
+841.002
+1
+854.087
+1
+847.188
+1
+851.61
+1
+856.987
+1
+862.841
+1
+838.116
+1
+844.542
+1
+850.48
+1
+858.303
+1
+860.993
+1
+868.454
+1
+865.319
+1
+868.033
+1
+866.687
+1
+868.955
+1
+856.685
+1
+870.584
+1
+857.714
+1
+870.206
+1
+866.414
+1
+861.032
+1
+881.763
+1
+883.296
+1
+882.138
+1
+880.352
+1
+895.288
+1
+898.316
+1
+898.509
+1
+890.4
+1
+895.565
+1
+903.997
+1
+884.368
+1
+885.731
+1
+904.22
+1
+887.722
+1
+895.54
+1
+908.124
+1
+906.799
+1
+914.203
+1
+926.679
+1
+916.173
+1
+909.866
+1
+927.99
+1
+901.978
+1
+920.768
+1
+930.311
+1
+918.204
+1
+924.014
+1
+920.659
+1
+897.054
+1
+913.861
+1
+930.868
+1
+907.821
+1
+930.919
+1
+934.626
+1
+927.104
+1
+926.88
+1
+925.493
+1
+929.369
+1
+924.559
+1
+930.611
+1
+934.36
+1
+930.286
+1
+930.487
+1
+935.106
+1
+946.058
+1
+938.313
+1
+940.168
+1
+943.382
+1
+951.895
+1
+992.445
+1
+1019.67
+1
+1047.79
+1
+1089.95
+1
+1167.8
+1
+1136.58
+1
+1023.4
+1
+958.776
+1
+955.592
+1
+931.931
+1
+950.466
+1
+954.055
+1
+963.687
+1
+947.114
+1
+957.686
+1
+954.116
+1
+947.817
+1
+973.328
+1
+963.506
+1
+970.971
+1
+973.52
+1
+986.337
+1
+968.219
+1
+958.897
+1
+962.837
+1
+945.974
+1
+948.943
+1
+955.224
+1
+962.326
+1
+957.54
+1
+963.175
+1
+967.575
+1
+958.598
+1
+955.56
+1
+989.779
+1
+980.461
+1
+981.292
+1
+979.398
+1
+975.858
+1
+989.377
+1
+987.058
+1
+986.16
+1
+981.207
+1
+992.699
+1
+1006.08
+1
+1018.89
+1
+1017.61
+1
+1012.58
+1
+1013.65
+1
+1000.95
+1
+998.119
+1
+1001.86
+1
+1010.2
+1
+1000.68
+1
+987.901
+1
+1020.67
+1
+1015.63
+1
+1015.38
+1
+1032.51
+1
+1006.04
+1
+1012.23
+1
+1010.75
+1
+1025.55
+1
+1031.5
+1
+1013.03
+1
+1010.17
+1
+1015.87
+1
+1034.2
+1
+1031.17
+1
+1046.8
+1
+1022.41
+1
+1009.55
+1
+1032.76
+1
+1042.49
+1
+1035.22
+1
+1040.15
+1
+1046.22
+1
+1046.93
+1
+1053.82
+1
+1058.52
+1
+1035.96
+1
+1042.97
+1
+1075.18
+1
+1061.79
+1
+1057.87
+1
+1058.95
+1
+1050.92
+1
+1062.84
+1
+1061.9
+1
+1081.95
+1
+1102.83
+1
+1081.02
+1
+1102.97
+1
+1081.5
+1
+1090.27
+1
+1070.06
+1
+1063.03
+1
+1077.54
+1
+1087.56
+1
+1098.47
+1
+1090.54
+1
+1094.66
+1
+1087.9
+1
+1105.68
+1
+1099.17
+1
+1102.82
+1
+1098.87
+1
+1113.69
+1
+1120.64
+1
+1119.77
+1
+1111.16
+1
+1128.65
+1
+1124.02
+1
+1117.38
+1
+1125.24
+1
+1115.88
+1
+1103.24
+1
+1127.41
+1
+1134.96
+1
+1141.09
+1
+1167.62
+1
+1163.62
+1
+1155.58
+1
+1165.11
+1
+1148.69
+1
+1139.72
+1
+1158.65
+1
+1161.57
+1
+1170.8
+1
+1168.72
+1
+1174.58
+1
+1164.49
+1
+1179.63
+1
+1201.78
+1
+1202.6
+1
+1208.38
+1
+1194.76
+1
+1199.77
+1
+1213.39
+1
+1203.8
+1
+1211.23
+1
+1221.66
+1
+1223.97
+1
+1254.05
+1
+1263.45
+1
+1271
+1
+1284.6
+1
+1257.7
+1
+1274.82
+1
+1271.65
+1
+1290.99
+1
+1273.88
+1
+1278.87
+1
+1268.07
+1
+1261.29
+1
+1251.33
+1
+1247.48
+1
+1252.28
+1
+1233.69
+1
+1228.34
+1
+1205.66
+1
+1208.7
+1
+1216.94
+1
+1237.53
+1
+1272.78
+1
+1288.24
+1
+1357.41
+1
+1433.76
+1
+1485.04
+1
+1567.13
+1
+1626.97
+1
+1720.68
+1
+1765.32
+1
+1790.18
+1
+1834.49
+1
+1933.84
+1
+2036.39
+1
+2139.18
+1
+2115.92
+1
+1883.42
+1
+1546.72
+1
+1309.04
+1
+1200.99
+1
+1160.16
+1
+1145.19
+1
+1153.02
+1
+1136.32
+1
+1142.1
+1
+1116.72
+1
+1103.12
+1
+1106.85
+1
+1100.83
+1
+1103.88
+1
+1124.49
+1
+1126.1
+1
+1113.08
+1
+1143.98
+1
+1157.87
+1
+1165.11
+1
+1206.91
+1
+1277.55
+1
+1302.46
+1
+1307.37
+1
+1259.49
+1
+1172.56
+1
+1133.06
+1
+1146.34
+1
+1180.55
+1
+1255.5
+1
+1312.11
+1
+1341.44
+1
+1373.93
+1
+1408.47
+1
+1483
+1
+1590.4
+1
+1747.35
+1
+1914.32
+1
+2017.25
+1
+2096.42
+1
+2222.83
+1
+2528.25
+1
+3042.19
+1
+3391.35
+1
+3000.78
+1
+1889.98
+1
+954.421
+1
+579.678
+1
+445.673
+1
+378.375
+1
+354.962
+1
+327.769
+1
+301.981
+1
+293.522
+1
+287.522
+1
+285.518
+1
+279.335
+1
+278.646
+1
+284.288
+1
+278.819
+1
+284.827
+1
+274.183
+1
+279.482
+1
+284.299
+1
+290.818
+1
+292.004
+1
+293.747
+1
+285.498
+1
+299.033
+1
+296.779
+1
+286.788
+1
+280.83
+1
+275.047
+1
+268.241
+1
+261.528
+1
+261.741
+1
+269.176
+1
+278.56
+1
+267.367
+1
+276.127
+1
+282.496
+1
+301.322
+1
+298.05
+1
+304.167
+1
+315.94
+1
+333.644
+1
+347.716
+1
+381.91
+1
+455.808
+1
+493.779
+1
+446.211
+1
+342.186
+1
+250.005
+1
+203.821
+1
+189.457
+1
+188.821
+1
+209.897
+1
+240.697
+1
+294.353
+1
+377.599
+1
+480.549
+1
+555.99
+1
+578.498
+1
+560.868
+1
+564.034
+1
+589.111
+1
+675.989
+1
+843.075
+1
+1035.45
+1
+905.206
+1
+453.062
+1
+106.868
+1
+Ni2p
+NiO
+2021
+4
+29
+23
+29
+30
+0
+17
+Casa Info Follows
+0
+0
+0
+0
+File = E:/OwnCloud/XPS lab/EX492_S776_Ni Oxidation.sle
+Group = RT in vacuum, #Treatments: , #Temp:RT , #Pressure:vacuum , #Atmosphere:, #Comments:  
+First of group = 0
+Spectrum ID = 20
+Analyzer lens = AngleResolvedMode22:1.5kV
+Analyzer slit = 4:7x20c\C:mesh
+Scan mode = FixedAnalyzerTransmission
+Kinetic energy start = 596.61
+PCA Coefs = 135146, 22871.4, -962.346, 884.156, -199.619, 
+C:\Users\Mark\Downloads\EX492_S776_Ni Oxidation.vms
+c:\users\mark\downloads\ex492_ni references.vms
+C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\NiCoFe\EX491-495 Fe, Ni, Co oxide references.vms
+XPS
+14
+Al
+1486.61
+0
+0
+0
+54.5
+180
+FAT
+20
+1
+4.1408
+0
+0
+0
+0
+0
+Ni
+2p
+-1
+kinetic energy
+eV
+596.61
+0.1
+2
+counts
+d
+Transmission
+d
+pulse counting
+0.1
+3
+0
+0
+0
+0
+2
+ESCAPE DEPTH TYPE
+d
+1
+MFP Exponent
+d
+0
+1002
+3223.86
+12109.2
+1
+1
+5414.88
+1
+5405.62
+1
+5374.87
+1
+5370.56
+1
+5355.25
+1
+5348.96
+1
+5333.13
+1
+5347.02
+1
+5388.81
+1
+5377.63
+1
+5380.12
+1
+5308.46
+1
+5352.28
+1
+5333.11
+1
+5341.6
+1
+5366.67
+1
+5315.82
+1
+5321.27
+1
+5296.23
+1
+5310.11
+1
+5343.29
+1
+5336.14
+1
+5308.48
+1
+5300.28
+1
+5332.6
+1
+5345.76
+1
+5345.57
+1
+5320.6
+1
+5305.24
+1
+5308.07
+1
+5319.57
+1
+5316.68
+1
+5377.35
+1
+5355.33
+1
+5354.05
+1
+5327.17
+1
+5360.24
+1
+5354.78
+1
+5322.74
+1
+5316.97
+1
+5351.37
+1
+5388.86
+1
+5332.51
+1
+5330.32
+1
+5341.09
+1
+5370.67
+1
+5450.75
+1
+5453.63
+1
+5432.88
+1
+5469.56
+1
+5484.82
+1
+5478.29
+1
+5539.09
+1
+5531.07
+1
+5546.63
+1
+5595.22
+1
+5593.53
+1
+5609.36
+1
+5688.64
+1
+5669.05
+1
+5715.19
+1
+5755.02
+1
+5804.86
+1
+5800.21
+1
+5869.68
+1
+5923.83
+1
+5947.94
+1
+5984.71
+1
+5989.83
+1
+6021.77
+1
+6083.71
+1
+6066.97
+1
+6116.08
+1
+6107.11
+1
+6196.66
+1
+6206.61
+1
+6245.59
+1
+6264.98
+1
+6359.98
+1
+6412.38
+1
+6486.75
+1
+6525.82
+1
+6602.39
+1
+6660.56
+1
+6749.95
+1
+6775.82
+1
+6869.34
+1
+6945.31
+1
+7004.53
+1
+6992.89
+1
+6996.65
+1
+7000.77
+1
+7060.25
+1
+7062.32
+1
+7112.42
+1
+7104.6
+1
+7090.83
+1
+7103.44
+1
+7143.81
+1
+7168.15
+1
+7160.08
+1
+7159.99
+1
+7216.34
+1
+7189.66
+1
+7216.64
+1
+7207.49
+1
+7211.35
+1
+7189.56
+1
+7187.85
+1
+7170.74
+1
+7192.74
+1
+7162.79
+1
+7125.21
+1
+7084.41
+1
+7085.86
+1
+7072.12
+1
+7043.44
+1
+7014.84
+1
+7022.15
+1
+6923.8
+1
+6934.83
+1
+6922.58
+1
+6847.17
+1
+6847.36
+1
+6807.09
+1
+6750.18
+1
+6731.01
+1
+6712.7
+1
+6655.4
+1
+6662.97
+1
+6649.34
+1
+6572.41
+1
+6532.41
+1
+6548.26
+1
+6543.03
+1
+6485.75
+1
+6503.62
+1
+6478.8
+1
+6481.3
+1
+6451.05
+1
+6438.54
+1
+6421.2
+1
+6413.33
+1
+6433.37
+1
+6408.89
+1
+6428.84
+1
+6429.25
+1
+6441.99
+1
+6487.83
+1
+6522.23
+1
+6522.64
+1
+6530.09
+1
+6561.45
+1
+6591.16
+1
+6683.59
+1
+6739.36
+1
+6777.81
+1
+6841.87
+1
+6864.02
+1
+6888.04
+1
+7016.48
+1
+7037.08
+1
+7077.98
+1
+7164.51
+1
+7199.9
+1
+7233.01
+1
+7272.53
+1
+7314.5
+1
+7363.88
+1
+7408.56
+1
+7433.48
+1
+7452.5
+1
+7479.31
+1
+7498.47
+1
+7526.23
+1
+7522
+1
+7509.14
+1
+7514.94
+1
+7558.77
+1
+7567.51
+1
+7545.29
+1
+7514.02
+1
+7458.91
+1
+7505.07
+1
+7504.02
+1
+7545.99
+1
+7549.67
+1
+7495.49
+1
+7467.74
+1
+7413.97
+1
+7368.88
+1
+7237.47
+1
+7037.76
+1
+6849.03
+1
+6649.27
+1
+6351.56
+1
+6078.15
+1
+5820.72
+1
+5613.1
+1
+5423.9
+1
+5269.05
+1
+5110.33
+1
+5004.7
+1
+4930.43
+1
+4879.71
+1
+4797.94
+1
+4785.82
+1
+4736.56
+1
+4717.82
+1
+4741.18
+1
+4724.19
+1
+4728.32
+1
+4756.73
+1
+4794.73
+1
+4784.77
+1
+4841.57
+1
+4871.84
+1
+4922.31
+1
+4965.95
+1
+5011.7
+1
+5046.86
+1
+5072.93
+1
+5117.41
+1
+5117.17
+1
+5162.28
+1
+5183.2
+1
+5256.83
+1
+5284.78
+1
+5257.98
+1
+5295.62
+1
+5354.55
+1
+5358.49
+1
+5399.74
+1
+5438.89
+1
+5491.98
+1
+5514.2
+1
+5559.69
+1
+5588.56
+1
+5586.78
+1
+5563.7
+1
+5582.27
+1
+5552.81
+1
+5542.23
+1
+5516.92
+1
+5543.51
+1
+5565.52
+1
+5569.92
+1
+5608.85
+1
+5682.84
+1
+5676.95
+1
+5740.99
+1
+5746.65
+1
+5824.15
+1
+5935.46
+1
+5964.53
+1
+6077.11
+1
+6102.77
+1
+6163.01
+1
+6202.23
+1
+6308.51
+1
+6342.35
+1
+6357.23
+1
+6407.73
+1
+6455.29
+1
+6508.24
+1
+6531.16
+1
+6569.17
+1
+6670.93
+1
+6712.75
+1
+6749.68
+1
+6804.8
+1
+6870.22
+1
+6913.2
+1
+7009.71
+1
+7128.07
+1
+7202.46
+1
+7271.39
+1
+7376.21
+1
+7480.22
+1
+7619.24
+1
+7624.01
+1
+7758.52
+1
+7857.26
+1
+7925.13
+1
+8014.32
+1
+8064.85
+1
+8172.34
+1
+8270.76
+1
+8296.69
+1
+8297.53
+1
+8292.39
+1
+8236.96
+1
+8254.89
+1
+8177.83
+1
+8117.89
+1
+8064.36
+1
+7964.17
+1
+7918.73
+1
+7756.55
+1
+7654.17
+1
+7650.88
+1
+7523.45
+1
+7425.16
+1
+7311.05
+1
+7218.78
+1
+7069.26
+1
+6942.26
+1
+6870.42
+1
+6761.38
+1
+6690.7
+1
+6567.77
+1
+6479.25
+1
+6417.09
+1
+6404.18
+1
+6311.91
+1
+6323.48
+1
+6286.94
+1
+6332.76
+1
+6281.78
+1
+6262.05
+1
+6353.27
+1
+6399.16
+1
+6430.13
+1
+6488.69
+1
+6562.74
+1
+6718.8
+1
+6835.04
+1
+6909.32
+1
+7083.59
+1
+7219.26
+1
+7433.08
+1
+7656.56
+1
+7817.59
+1
+8005.22
+1
+8186.25
+1
+8396.19
+1
+8569.5
+1
+8764.13
+1
+8963.79
+1
+9067.84
+1
+9185.75
+1
+9344.87
+1
+9378.33
+1
+9373.15
+1
+9402.9
+1
+9316.69
+1
+9214.51
+1
+9165.07
+1
+9133.21
+1
+9101.02
+1
+9106.64
+1
+9161.45
+1
+9201.65
+1
+9367.23
+1
+9555.46
+1
+9779.3
+1
+10026.7
+1
+10388
+1
+10821.8
+1
+11195.3
+1
+11634.6
+1
+11924.4
+1
+12085.8
+1
+11908
+1
+11483.2
+1
+10774
+1
+9858.13
+1
+8784.28
+1
+7741.67
+1
+6788.31
+1
+6038.31
+1
+5443.7
+1
+5031.78
+1
+4706.17
+1
+4422.91
+1
+4239.59
+1
+4067.76
+1
+3973.73
+1
+3918.02
+1
+3823.29
+1
+3743.67
+1
+3700.26
+1
+3646.11
+1
+3624
+1
+3594.98
+1
+3583.18
+1
+3574.2
+1
+3549.34
+1
+3506.26
+1
+3476.88
+1
+3457.86
+1
+3466.86
+1
+3464.39
+1
+3452.03
+1
+3426.78
+1
+3451.6
+1
+3443.72
+1
+3410.76
+1
+3418.11
+1
+3407.97
+1
+3404.37
+1
+3443.6
+1
+3430.9
+1
+3409.56
+1
+3405.78
+1
+3358.1
+1
+3387.29
+1
+3361.71
+1
+3373.91
+1
+3369.59
+1
+3343.36
+1
+3356.37
+1
+3353.38
+1
+3371.93
+1
+3369.76
+1
+3352.66
+1
+3365.3
+1
+3349.52
+1
+3315
+1
+3320.93
+1
+3332.88
+1
+3344.66
+1
+3343.83
+1
+3368.99
+1
+3322.01
+1
+3327.87
+1
+3329.08
+1
+3333.07
+1
+3314.84
+1
+3319.48
+1
+3348.68
+1
+3342.65
+1
+3335.36
+1
+3335.73
+1
+3325.45
+1
+3334.97
+1
+3337.72
+1
+3322.92
+1
+3322
+1
+3339.08
+1
+3333.72
+1
+3320.4
+1
+3329.95
+1
+3318.59
+1
+3308.25
+1
+3337.63
+1
+3312.4
+1
+3312.73
+1
+3346.89
+1
+3353.7
+1
+3339.35
+1
+3321.95
+1
+3322.12
+1
+3334.9
+1
+3333.22
+1
+3308.42
+1
+3318.55
+1
+3320.12
+1
+3322.55
+1
+3337.65
+1
+3301.81
+1
+3328.31
+1
+3331.75
+1
+3327.8
+1
+3333.99
+1
+3310.91
+1
+3298.38
+1
+3327.25
+1
+3306.58
+1
+3329.73
+1
+3317.17
+1
+3329.46
+1
+3366.01
+1
+3327.92
+1
+3319.81
+1
+3330.82
+1
+3311.83
+1
+3327.07
+1
+3324.16
+1
+3306.88
+1
+3300.95
+1
+3288.7
+1
+3304.94
+1
+3319.94
+1
+3348.09
+1
+3348.03
+1
+3326.59
+1
+3334.39
+1
+3337.95
+1
+3323.56
+1
+3348.58
+1
+3339.43
+1
+3345.49
+1
+3341.26
+1
+3346.39
+1
+3344.39
+1
+3314.26
+1
+3373.9
+1
+3358.16
+1
+3334.45
+1
+3362.27
+1
+end of experiment
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Pd3d_Pd_metal.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Pd3d_Pd_metal.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fce8c27805848c5dcd9f8cf15e35d63bf7f09f3e
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Pd3d_Pd_metal.txt
@@ -0,0 +1,1042 @@
+Pd3d Pd metal
+3.830000e+02 2.378653e+03
+3.829500e+02 2.397532e+03
+3.829000e+02 2.397532e+03
+3.828500e+02 2.397532e+03
+3.828000e+02 2.416410e+03
+3.827500e+02 2.423989e+03
+3.827000e+02 2.423989e+03
+3.826500e+02 2.423989e+03
+3.826000e+02 2.431568e+03
+3.825500e+02 2.429547e+03
+3.825000e+02 2.429547e+03
+3.824500e+02 2.429547e+03
+3.824000e+02 2.427525e+03
+3.823500e+02 2.438771e+03
+3.823000e+02 2.438771e+03
+3.822500e+02 2.438771e+03
+3.822000e+02 2.450017e+03
+3.821500e+02 2.446926e+03
+3.821000e+02 2.446926e+03
+3.820500e+02 2.446926e+03
+3.820000e+02 2.443835e+03
+3.819500e+02 2.445778e+03
+3.819000e+02 2.445778e+03
+3.818500e+02 2.445778e+03
+3.818000e+02 2.447720e+03
+3.817500e+02 2.436760e+03
+3.817000e+02 2.436760e+03
+3.816500e+02 2.436760e+03
+3.816000e+02 2.425800e+03
+3.815500e+02 2.427968e+03
+3.815000e+02 2.427968e+03
+3.814500e+02 2.427968e+03
+3.814000e+02 2.430135e+03
+3.813500e+02 2.441648e+03
+3.813000e+02 2.441648e+03
+3.812500e+02 2.441648e+03
+3.812000e+02 2.453160e+03
+3.811500e+02 2.460858e+03
+3.811000e+02 2.460858e+03
+3.810500e+02 2.460858e+03
+3.810000e+02 2.468557e+03
+3.809500e+02 2.470685e+03
+3.809000e+02 2.470685e+03
+3.808500e+02 2.470685e+03
+3.808000e+02 2.472813e+03
+3.807500e+02 2.476532e+03
+3.807000e+02 2.476532e+03
+3.806500e+02 2.476532e+03
+3.806000e+02 2.480250e+03
+3.805500e+02 2.481418e+03
+3.805000e+02 2.481418e+03
+3.804500e+02 2.481418e+03
+3.804000e+02 2.482585e+03
+3.803500e+02 2.473319e+03
+3.803000e+02 2.473319e+03
+3.802500e+02 2.473319e+03
+3.802000e+02 2.464052e+03
+3.801500e+02 2.464536e+03
+3.801000e+02 2.464536e+03
+3.800500e+02 2.464536e+03
+3.800000e+02 2.465020e+03
+3.799500e+02 2.468417e+03
+3.799000e+02 2.468417e+03
+3.798500e+02 2.468417e+03
+3.798000e+02 2.471813e+03
+3.797500e+02 2.480628e+03
+3.797000e+02 2.480628e+03
+3.796500e+02 2.480628e+03
+3.796000e+02 2.489443e+03
+3.795500e+02 2.484724e+03
+3.795000e+02 2.484724e+03
+3.794500e+02 2.484724e+03
+3.794000e+02 2.480005e+03
+3.793500e+02 2.464821e+03
+3.793000e+02 2.464821e+03
+3.792500e+02 2.464821e+03
+3.792000e+02 2.449637e+03
+3.791500e+02 2.456620e+03
+3.791000e+02 2.456620e+03
+3.790500e+02 2.456620e+03
+3.790000e+02 2.463603e+03
+3.789500e+02 2.472939e+03
+3.789000e+02 2.472939e+03
+3.788500e+02 2.472939e+03
+3.788000e+02 2.482275e+03
+3.787500e+02 2.492600e+03
+3.787000e+02 2.492600e+03
+3.786500e+02 2.492600e+03
+3.786000e+02 2.502925e+03
+3.785500e+02 2.497823e+03
+3.785000e+02 2.497823e+03
+3.784500e+02 2.497823e+03
+3.784000e+02 2.492720e+03
+3.783500e+02 2.501472e+03
+3.783000e+02 2.501472e+03
+3.782500e+02 2.501472e+03
+3.782000e+02 2.510225e+03
+3.781500e+02 2.512387e+03
+3.781000e+02 2.512387e+03
+3.780500e+02 2.512387e+03
+3.780000e+02 2.514550e+03
+3.779500e+02 2.519075e+03
+3.779000e+02 2.519075e+03
+3.778500e+02 2.519075e+03
+3.778000e+02 2.523600e+03
+3.777500e+02 2.522387e+03
+3.777000e+02 2.522387e+03
+3.776500e+02 2.522387e+03
+3.776000e+02 2.521175e+03
+3.775500e+02 2.536163e+03
+3.775000e+02 2.536163e+03
+3.774500e+02 2.536163e+03
+3.774000e+02 2.551150e+03
+3.773500e+02 2.539238e+03
+3.773000e+02 2.539238e+03
+3.772500e+02 2.539238e+03
+3.772000e+02 2.527325e+03
+3.771500e+02 2.544162e+03
+3.771000e+02 2.544162e+03
+3.770500e+02 2.544162e+03
+3.770000e+02 2.561000e+03
+3.769500e+02 2.561375e+03
+3.769000e+02 2.561375e+03
+3.768500e+02 2.561375e+03
+3.768000e+02 2.561750e+03
+3.767500e+02 2.572725e+03
+3.767000e+02 2.572725e+03
+3.766500e+02 2.572725e+03
+3.766000e+02 2.583700e+03
+3.765500e+02 2.584938e+03
+3.765000e+02 2.584938e+03
+3.764500e+02 2.584938e+03
+3.764000e+02 2.586175e+03
+3.763500e+02 2.573213e+03
+3.763000e+02 2.573213e+03
+3.762500e+02 2.573213e+03
+3.762000e+02 2.560250e+03
+3.761500e+02 2.547150e+03
+3.761000e+02 2.547150e+03
+3.760500e+02 2.547150e+03
+3.760000e+02 2.534050e+03
+3.759500e+02 2.550438e+03
+3.759000e+02 2.550438e+03
+3.758500e+02 2.550438e+03
+3.758000e+02 2.566825e+03
+3.757500e+02 2.587300e+03
+3.757000e+02 2.587300e+03
+3.756500e+02 2.587300e+03
+3.756000e+02 2.607775e+03
+3.755500e+02 2.593562e+03
+3.755000e+02 2.593562e+03
+3.754500e+02 2.593562e+03
+3.754000e+02 2.579350e+03
+3.753500e+02 2.580375e+03
+3.753000e+02 2.580375e+03
+3.752500e+02 2.580375e+03
+3.752000e+02 2.581400e+03
+3.751500e+02 2.576350e+03
+3.751000e+02 2.576350e+03
+3.750500e+02 2.576350e+03
+3.750000e+02 2.571300e+03
+3.749500e+02 2.590675e+03
+3.749000e+02 2.590675e+03
+3.748500e+02 2.590675e+03
+3.748000e+02 2.610050e+03
+3.747500e+02 2.608663e+03
+3.747000e+02 2.608663e+03
+3.746500e+02 2.608663e+03
+3.746000e+02 2.607275e+03
+3.745500e+02 2.608175e+03
+3.745000e+02 2.608175e+03
+3.744500e+02 2.608175e+03
+3.744000e+02 2.609075e+03
+3.743500e+02 2.619900e+03
+3.743000e+02 2.619900e+03
+3.742500e+02 2.619900e+03
+3.742000e+02 2.630725e+03
+3.741500e+02 2.630425e+03
+3.741000e+02 2.630425e+03
+3.740500e+02 2.630425e+03
+3.740000e+02 2.630125e+03
+3.739500e+02 2.666537e+03
+3.739000e+02 2.666537e+03
+3.738500e+02 2.666537e+03
+3.738000e+02 2.702950e+03
+3.737500e+02 2.697762e+03
+3.737000e+02 2.697762e+03
+3.736500e+02 2.697762e+03
+3.736000e+02 2.692575e+03
+3.735500e+02 2.692375e+03
+3.735000e+02 2.692375e+03
+3.734500e+02 2.692375e+03
+3.734000e+02 2.692175e+03
+3.733500e+02 2.682713e+03
+3.733000e+02 2.682713e+03
+3.732500e+02 2.682713e+03
+3.732000e+02 2.673250e+03
+3.731500e+02 2.669975e+03
+3.731000e+02 2.669975e+03
+3.730500e+02 2.669975e+03
+3.730000e+02 2.666700e+03
+3.729500e+02 2.672837e+03
+3.729000e+02 2.672837e+03
+3.728500e+02 2.672837e+03
+3.728000e+02 2.678975e+03
+3.727500e+02 2.677087e+03
+3.727000e+02 2.677087e+03
+3.726500e+02 2.677087e+03
+3.726000e+02 2.675200e+03
+3.725500e+02 2.674875e+03
+3.725000e+02 2.674875e+03
+3.724500e+02 2.674875e+03
+3.724000e+02 2.674550e+03
+3.723500e+02 2.660038e+03
+3.723000e+02 2.660038e+03
+3.722500e+02 2.660038e+03
+3.722000e+02 2.645525e+03
+3.721500e+02 2.668588e+03
+3.721000e+02 2.668588e+03
+3.720500e+02 2.668588e+03
+3.720000e+02 2.691650e+03
+3.719500e+02 2.663762e+03
+3.719000e+02 2.663762e+03
+3.718500e+02 2.663762e+03
+3.718000e+02 2.635875e+03
+3.717500e+02 2.631887e+03
+3.717000e+02 2.631887e+03
+3.716500e+02 2.631887e+03
+3.716000e+02 2.627900e+03
+3.715500e+02 2.655475e+03
+3.715000e+02 2.655475e+03
+3.714500e+02 2.655475e+03
+3.714000e+02 2.683050e+03
+3.713500e+02 2.696413e+03
+3.713000e+02 2.696413e+03
+3.712500e+02 2.696413e+03
+3.712000e+02 2.709775e+03
+3.711500e+02 2.701025e+03
+3.711000e+02 2.701025e+03
+3.710500e+02 2.701025e+03
+3.710000e+02 2.692275e+03
+3.709500e+02 2.688637e+03
+3.709000e+02 2.688637e+03
+3.708500e+02 2.688637e+03
+3.708000e+02 2.685000e+03
+3.707500e+02 2.682238e+03
+3.707000e+02 2.682238e+03
+3.706500e+02 2.682238e+03
+3.706000e+02 2.679475e+03
+3.705500e+02 2.685450e+03
+3.705000e+02 2.685450e+03
+3.704500e+02 2.685450e+03
+3.704000e+02 2.691425e+03
+3.703500e+02 2.700062e+03
+3.703000e+02 2.700062e+03
+3.702500e+02 2.700062e+03
+3.702000e+02 2.708700e+03
+3.701500e+02 2.702562e+03
+3.701000e+02 2.702562e+03
+3.700500e+02 2.702562e+03
+3.700000e+02 2.696425e+03
+3.699500e+02 2.710838e+03
+3.699000e+02 2.710838e+03
+3.698500e+02 2.710838e+03
+3.698000e+02 2.725250e+03
+3.697500e+02 2.725463e+03
+3.697000e+02 2.725463e+03
+3.696500e+02 2.725463e+03
+3.696000e+02 2.725675e+03
+3.695500e+02 2.734025e+03
+3.695000e+02 2.734025e+03
+3.694500e+02 2.734025e+03
+3.694000e+02 2.742375e+03
+3.693500e+02 2.765125e+03
+3.693000e+02 2.765125e+03
+3.692500e+02 2.765125e+03
+3.692000e+02 2.787875e+03
+3.691500e+02 2.783925e+03
+3.691000e+02 2.783925e+03
+3.690500e+02 2.783925e+03
+3.690000e+02 2.779975e+03
+3.689500e+02 2.758637e+03
+3.689000e+02 2.758637e+03
+3.688500e+02 2.758637e+03
+3.688000e+02 2.737300e+03
+3.687500e+02 2.731925e+03
+3.687000e+02 2.731925e+03
+3.686500e+02 2.731925e+03
+3.686000e+02 2.726550e+03
+3.685500e+02 2.775562e+03
+3.685000e+02 2.775562e+03
+3.684500e+02 2.775562e+03
+3.684000e+02 2.824575e+03
+3.683500e+02 2.808200e+03
+3.683000e+02 2.808200e+03
+3.682500e+02 2.808200e+03
+3.682000e+02 2.791825e+03
+3.681500e+02 2.801775e+03
+3.681000e+02 2.801775e+03
+3.680500e+02 2.801775e+03
+3.680000e+02 2.811725e+03
+3.679500e+02 2.792188e+03
+3.679000e+02 2.792188e+03
+3.678500e+02 2.792188e+03
+3.678000e+02 2.772650e+03
+3.677500e+02 2.805600e+03
+3.677000e+02 2.805600e+03
+3.676500e+02 2.805600e+03
+3.676000e+02 2.838550e+03
+3.675500e+02 2.838913e+03
+3.675000e+02 2.838913e+03
+3.674500e+02 2.838913e+03
+3.674000e+02 2.839275e+03
+3.673500e+02 2.829113e+03
+3.673000e+02 2.829113e+03
+3.672500e+02 2.829113e+03
+3.672000e+02 2.818950e+03
+3.671500e+02 2.785800e+03
+3.671000e+02 2.785800e+03
+3.670500e+02 2.785800e+03
+3.670000e+02 2.752650e+03
+3.669500e+02 2.734575e+03
+3.669000e+02 2.734575e+03
+3.668500e+02 2.734575e+03
+3.668000e+02 2.716500e+03
+3.667500e+02 2.722838e+03
+3.667000e+02 2.722838e+03
+3.666500e+02 2.722838e+03
+3.666000e+02 2.729175e+03
+3.665500e+02 2.736062e+03
+3.665000e+02 2.736062e+03
+3.664500e+02 2.736062e+03
+3.664000e+02 2.742950e+03
+3.663500e+02 2.727387e+03
+3.663000e+02 2.727387e+03
+3.662500e+02 2.727387e+03
+3.662000e+02 2.711825e+03
+3.661500e+02 2.699912e+03
+3.661000e+02 2.699912e+03
+3.660500e+02 2.699912e+03
+3.660000e+02 2.688000e+03
+3.659500e+02 2.711575e+03
+3.659000e+02 2.711575e+03
+3.658500e+02 2.711575e+03
+3.658000e+02 2.735150e+03
+3.657500e+02 2.730363e+03
+3.657000e+02 2.730363e+03
+3.656500e+02 2.730363e+03
+3.656000e+02 2.725575e+03
+3.655500e+02 2.719400e+03
+3.655000e+02 2.719400e+03
+3.654500e+02 2.719400e+03
+3.654000e+02 2.713225e+03
+3.653500e+02 2.697100e+03
+3.653000e+02 2.697100e+03
+3.652500e+02 2.697100e+03
+3.652000e+02 2.680975e+03
+3.651500e+02 2.661863e+03
+3.651000e+02 2.661863e+03
+3.650500e+02 2.661863e+03
+3.650000e+02 2.642750e+03
+3.649500e+02 2.659550e+03
+3.649000e+02 2.659550e+03
+3.648500e+02 2.659550e+03
+3.648000e+02 2.676350e+03
+3.647500e+02 2.709375e+03
+3.647000e+02 2.709375e+03
+3.646500e+02 2.709375e+03
+3.646000e+02 2.742400e+03
+3.645500e+02 2.713075e+03
+3.645000e+02 2.713075e+03
+3.644500e+02 2.713075e+03
+3.644000e+02 2.683750e+03
+3.643500e+02 2.678400e+03
+3.643000e+02 2.678400e+03
+3.642500e+02 2.678400e+03
+3.642000e+02 2.673050e+03
+3.641500e+02 2.697038e+03
+3.641000e+02 2.697038e+03
+3.640500e+02 2.697038e+03
+3.640000e+02 2.721025e+03
+3.639500e+02 2.715038e+03
+3.639000e+02 2.715038e+03
+3.638500e+02 2.715038e+03
+3.638000e+02 2.709050e+03
+3.637500e+02 2.690238e+03
+3.637000e+02 2.690238e+03
+3.636500e+02 2.690238e+03
+3.636000e+02 2.671425e+03
+3.635500e+02 2.682038e+03
+3.635000e+02 2.682038e+03
+3.634500e+02 2.682038e+03
+3.634000e+02 2.692650e+03
+3.633500e+02 2.692850e+03
+3.633000e+02 2.692850e+03
+3.632500e+02 2.692850e+03
+3.632000e+02 2.693050e+03
+3.631500e+02 2.708775e+03
+3.631000e+02 2.708775e+03
+3.630500e+02 2.708775e+03
+3.630000e+02 2.724500e+03
+3.629500e+02 2.701025e+03
+3.629000e+02 2.701025e+03
+3.628500e+02 2.701025e+03
+3.628000e+02 2.677550e+03
+3.627500e+02 2.696637e+03
+3.627000e+02 2.696637e+03
+3.626500e+02 2.696637e+03
+3.626000e+02 2.715725e+03
+3.625500e+02 2.711500e+03
+3.625000e+02 2.711500e+03
+3.624500e+02 2.711500e+03
+3.624000e+02 2.707275e+03
+3.623500e+02 2.687113e+03
+3.623000e+02 2.687113e+03
+3.622500e+02 2.687113e+03
+3.622000e+02 2.666950e+03
+3.621500e+02 2.655537e+03
+3.621000e+02 2.655537e+03
+3.620500e+02 2.655537e+03
+3.620000e+02 2.644125e+03
+3.619500e+02 2.652738e+03
+3.619000e+02 2.652738e+03
+3.618500e+02 2.652738e+03
+3.618000e+02 2.661350e+03
+3.617500e+02 2.676837e+03
+3.617000e+02 2.676837e+03
+3.616500e+02 2.676837e+03
+3.616000e+02 2.692325e+03
+3.615500e+02 2.685900e+03
+3.615000e+02 2.685900e+03
+3.614500e+02 2.685900e+03
+3.614000e+02 2.679475e+03
+3.613500e+02 2.677950e+03
+3.613000e+02 2.677950e+03
+3.612500e+02 2.677950e+03
+3.612000e+02 2.676425e+03
+3.611500e+02 2.690938e+03
+3.611000e+02 2.690938e+03
+3.610500e+02 2.690938e+03
+3.610000e+02 2.705450e+03
+3.609500e+02 2.682025e+03
+3.609000e+02 2.682025e+03
+3.608500e+02 2.682025e+03
+3.608000e+02 2.658600e+03
+3.607500e+02 2.650238e+03
+3.607000e+02 2.650238e+03
+3.606500e+02 2.650238e+03
+3.606000e+02 2.641875e+03
+3.605500e+02 2.670700e+03
+3.605000e+02 2.670700e+03
+3.604500e+02 2.670700e+03
+3.604000e+02 2.699525e+03
+3.603500e+02 2.684650e+03
+3.603000e+02 2.684650e+03
+3.602500e+02 2.684650e+03
+3.602000e+02 2.669775e+03
+3.601500e+02 2.663675e+03
+3.601000e+02 2.663675e+03
+3.600500e+02 2.663675e+03
+3.600000e+02 2.657575e+03
+3.599500e+02 2.647587e+03
+3.599000e+02 2.647587e+03
+3.598500e+02 2.647587e+03
+3.598000e+02 2.637600e+03
+3.597500e+02 2.627225e+03
+3.597000e+02 2.627225e+03
+3.596500e+02 2.627225e+03
+3.596000e+02 2.616850e+03
+3.595500e+02 2.624537e+03
+3.595000e+02 2.624537e+03
+3.594500e+02 2.624537e+03
+3.594000e+02 2.632225e+03
+3.593500e+02 2.616212e+03
+3.593000e+02 2.616212e+03
+3.592500e+02 2.616212e+03
+3.592000e+02 2.600200e+03
+3.591500e+02 2.613762e+03
+3.591000e+02 2.613762e+03
+3.590500e+02 2.613762e+03
+3.590000e+02 2.627325e+03
+3.589500e+02 2.622875e+03
+3.589000e+02 2.622875e+03
+3.588500e+02 2.622875e+03
+3.588000e+02 2.618425e+03
+3.587500e+02 2.634500e+03
+3.587000e+02 2.634500e+03
+3.586500e+02 2.634500e+03
+3.586000e+02 2.650575e+03
+3.585500e+02 2.651062e+03
+3.585000e+02 2.651062e+03
+3.584500e+02 2.651062e+03
+3.584000e+02 2.651550e+03
+3.583500e+02 2.631300e+03
+3.583000e+02 2.631300e+03
+3.582500e+02 2.631300e+03
+3.582000e+02 2.611050e+03
+3.581500e+02 2.620863e+03
+3.581000e+02 2.620863e+03
+3.580500e+02 2.620863e+03
+3.580000e+02 2.630675e+03
+3.579500e+02 2.617213e+03
+3.579000e+02 2.617213e+03
+3.578500e+02 2.617213e+03
+3.578000e+02 2.603750e+03
+3.577500e+02 2.586400e+03
+3.577000e+02 2.586400e+03
+3.576500e+02 2.586400e+03
+3.576000e+02 2.569050e+03
+3.575500e+02 2.576100e+03
+3.575000e+02 2.576100e+03
+3.574500e+02 2.576100e+03
+3.574000e+02 2.583150e+03
+3.573500e+02 2.591788e+03
+3.573000e+02 2.591788e+03
+3.572500e+02 2.591788e+03
+3.572000e+02 2.600425e+03
+3.571500e+02 2.597400e+03
+3.571000e+02 2.597400e+03
+3.570500e+02 2.597400e+03
+3.570000e+02 2.594375e+03
+3.569500e+02 2.613188e+03
+3.569000e+02 2.613188e+03
+3.568500e+02 2.613188e+03
+3.568000e+02 2.632000e+03
+3.567500e+02 2.621537e+03
+3.567000e+02 2.621537e+03
+3.566500e+02 2.621537e+03
+3.566000e+02 2.611075e+03
+3.565500e+02 2.590725e+03
+3.565000e+02 2.590725e+03
+3.564500e+02 2.590725e+03
+3.564000e+02 2.570375e+03
+3.563500e+02 2.563412e+03
+3.563000e+02 2.563412e+03
+3.562500e+02 2.563412e+03
+3.562000e+02 2.556450e+03
+3.561500e+02 2.584188e+03
+3.561000e+02 2.584188e+03
+3.560500e+02 2.584188e+03
+3.560000e+02 2.611925e+03
+3.559500e+02 2.585100e+03
+3.559000e+02 2.585100e+03
+3.558500e+02 2.585100e+03
+3.558000e+02 2.558275e+03
+3.557500e+02 2.544375e+03
+3.557000e+02 2.544375e+03
+3.556500e+02 2.544375e+03
+3.556000e+02 2.530475e+03
+3.555500e+02 2.562900e+03
+3.555000e+02 2.562900e+03
+3.554500e+02 2.562900e+03
+3.554000e+02 2.595325e+03
+3.553500e+02 2.587625e+03
+3.553000e+02 2.587625e+03
+3.552500e+02 2.587625e+03
+3.552000e+02 2.579925e+03
+3.551500e+02 2.573575e+03
+3.551000e+02 2.573575e+03
+3.550500e+02 2.573575e+03
+3.550000e+02 2.567225e+03
+3.549500e+02 2.571262e+03
+3.549000e+02 2.571262e+03
+3.548500e+02 2.571262e+03
+3.548000e+02 2.575300e+03
+3.547500e+02 2.573988e+03
+3.547000e+02 2.573988e+03
+3.546500e+02 2.573988e+03
+3.546000e+02 2.572675e+03
+3.545500e+02 2.573750e+03
+3.545000e+02 2.573750e+03
+3.544500e+02 2.573750e+03
+3.544000e+02 2.574825e+03
+3.543500e+02 2.586300e+03
+3.543000e+02 2.586300e+03
+3.542500e+02 2.586300e+03
+3.542000e+02 2.597775e+03
+3.541500e+02 2.591750e+03
+3.541000e+02 2.591750e+03
+3.540500e+02 2.591750e+03
+3.540000e+02 2.585725e+03
+3.539500e+02 2.596000e+03
+3.539000e+02 2.596000e+03
+3.538500e+02 2.596000e+03
+3.538000e+02 2.606275e+03
+3.537500e+02 2.612725e+03
+3.537000e+02 2.612725e+03
+3.536500e+02 2.612725e+03
+3.536000e+02 2.619175e+03
+3.535500e+02 2.618163e+03
+3.535000e+02 2.618163e+03
+3.534500e+02 2.618163e+03
+3.534000e+02 2.617150e+03
+3.533500e+02 2.612875e+03
+3.533000e+02 2.612875e+03
+3.532500e+02 2.612875e+03
+3.532000e+02 2.608600e+03
+3.531500e+02 2.588475e+03
+3.531000e+02 2.588475e+03
+3.530500e+02 2.588475e+03
+3.530000e+02 2.568350e+03
+3.529500e+02 2.593150e+03
+3.529000e+02 2.593150e+03
+3.528500e+02 2.593150e+03
+3.528000e+02 2.617950e+03
+3.527500e+02 2.635837e+03
+3.527000e+02 2.635837e+03
+3.526500e+02 2.635837e+03
+3.526000e+02 2.653725e+03
+3.525500e+02 2.648613e+03
+3.525000e+02 2.648613e+03
+3.524500e+02 2.648613e+03
+3.524000e+02 2.643500e+03
+3.523500e+02 2.666175e+03
+3.523000e+02 2.666175e+03
+3.522500e+02 2.666175e+03
+3.522000e+02 2.688850e+03
+3.521500e+02 2.700337e+03
+3.521000e+02 2.700337e+03
+3.520500e+02 2.700337e+03
+3.520000e+02 2.711825e+03
+3.519500e+02 2.741238e+03
+3.519000e+02 2.741238e+03
+3.518500e+02 2.741238e+03
+3.518000e+02 2.770650e+03
+3.517500e+02 2.793512e+03
+3.517000e+02 2.793512e+03
+3.516500e+02 2.793512e+03
+3.516000e+02 2.816375e+03
+3.515500e+02 2.804650e+03
+3.515000e+02 2.804650e+03
+3.514500e+02 2.804650e+03
+3.514000e+02 2.792925e+03
+3.513500e+02 2.825575e+03
+3.513000e+02 2.825575e+03
+3.512500e+02 2.825575e+03
+3.512000e+02 2.858225e+03
+3.511500e+02 2.870562e+03
+3.511000e+02 2.870562e+03
+3.510500e+02 2.870562e+03
+3.510000e+02 2.882900e+03
+3.509500e+02 2.893887e+03
+3.509000e+02 2.893887e+03
+3.508500e+02 2.893887e+03
+3.508000e+02 2.904875e+03
+3.507500e+02 2.914675e+03
+3.507000e+02 2.914675e+03
+3.506500e+02 2.914675e+03
+3.506000e+02 2.924475e+03
+3.505500e+02 2.945475e+03
+3.505000e+02 2.945475e+03
+3.504500e+02 2.945475e+03
+3.504000e+02 2.966475e+03
+3.503500e+02 2.987375e+03
+3.503000e+02 2.987375e+03
+3.502500e+02 2.987375e+03
+3.502000e+02 3.008275e+03
+3.501500e+02 3.019350e+03
+3.501000e+02 3.019350e+03
+3.500500e+02 3.019350e+03
+3.500000e+02 3.030425e+03
+3.499500e+02 3.057775e+03
+3.499000e+02 3.057775e+03
+3.498500e+02 3.057775e+03
+3.498000e+02 3.085125e+03
+3.497500e+02 3.099762e+03
+3.497000e+02 3.099762e+03
+3.496500e+02 3.099762e+03
+3.496000e+02 3.114400e+03
+3.495500e+02 3.138663e+03
+3.495000e+02 3.138663e+03
+3.494500e+02 3.138663e+03
+3.494000e+02 3.162925e+03
+3.493500e+02 3.186475e+03
+3.493000e+02 3.186475e+03
+3.492500e+02 3.186475e+03
+3.492000e+02 3.210025e+03
+3.491500e+02 3.228913e+03
+3.491000e+02 3.228913e+03
+3.490500e+02 3.228913e+03
+3.490000e+02 3.247800e+03
+3.489500e+02 3.282225e+03
+3.489000e+02 3.282225e+03
+3.488500e+02 3.282225e+03
+3.488000e+02 3.316650e+03
+3.487500e+02 3.340775e+03
+3.487000e+02 3.340775e+03
+3.486500e+02 3.340775e+03
+3.486000e+02 3.364900e+03
+3.485500e+02 3.385312e+03
+3.485000e+02 3.385312e+03
+3.484500e+02 3.385312e+03
+3.484000e+02 3.405725e+03
+3.483500e+02 3.438275e+03
+3.483000e+02 3.438275e+03
+3.482500e+02 3.438275e+03
+3.482000e+02 3.470825e+03
+3.481500e+02 3.516100e+03
+3.481000e+02 3.516100e+03
+3.480500e+02 3.516100e+03
+3.480000e+02 3.561375e+03
+3.479500e+02 3.562975e+03
+3.479000e+02 3.562975e+03
+3.478500e+02 3.562975e+03
+3.478000e+02 3.564575e+03
+3.477500e+02 3.601175e+03
+3.477000e+02 3.601175e+03
+3.476500e+02 3.601175e+03
+3.476000e+02 3.637775e+03
+3.475500e+02 3.678225e+03
+3.475000e+02 3.678225e+03
+3.474500e+02 3.678225e+03
+3.474000e+02 3.718675e+03
+3.473500e+02 3.752863e+03
+3.473000e+02 3.752863e+03
+3.472500e+02 3.752863e+03
+3.472000e+02 3.787050e+03
+3.471500e+02 3.839463e+03
+3.471000e+02 3.839463e+03
+3.470500e+02 3.839463e+03
+3.470000e+02 3.891875e+03
+3.469500e+02 3.917713e+03
+3.469000e+02 3.917713e+03
+3.468500e+02 3.917713e+03
+3.468000e+02 3.943550e+03
+3.467500e+02 3.947938e+03
+3.467000e+02 3.947938e+03
+3.466500e+02 3.947938e+03
+3.466000e+02 3.952325e+03
+3.465500e+02 3.945988e+03
+3.465000e+02 3.945988e+03
+3.464500e+02 3.945988e+03
+3.464000e+02 3.939650e+03
+3.463500e+02 3.883975e+03
+3.463000e+02 3.883975e+03
+3.462500e+02 3.883975e+03
+3.462000e+02 3.828300e+03
+3.461500e+02 3.774825e+03
+3.461000e+02 3.774825e+03
+3.460500e+02 3.774825e+03
+3.460000e+02 3.721350e+03
+3.459500e+02 3.678438e+03
+3.459000e+02 3.678438e+03
+3.458500e+02 3.678438e+03
+3.458000e+02 3.635525e+03
+3.457500e+02 3.600650e+03
+3.457000e+02 3.600650e+03
+3.456500e+02 3.600650e+03
+3.456000e+02 3.565775e+03
+3.455500e+02 3.561088e+03
+3.455000e+02 3.561088e+03
+3.454500e+02 3.561088e+03
+3.454000e+02 3.556400e+03
+3.453500e+02 3.548950e+03
+3.453000e+02 3.548950e+03
+3.452500e+02 3.548950e+03
+3.452000e+02 3.541500e+03
+3.451500e+02 3.540137e+03
+3.451000e+02 3.540137e+03
+3.450500e+02 3.540137e+03
+3.450000e+02 3.538775e+03
+3.449500e+02 3.565088e+03
+3.449000e+02 3.565088e+03
+3.448500e+02 3.565088e+03
+3.448000e+02 3.591400e+03
+3.447500e+02 3.650775e+03
+3.447000e+02 3.650775e+03
+3.446500e+02 3.650775e+03
+3.446000e+02 3.710150e+03
+3.445500e+02 3.730538e+03
+3.445000e+02 3.730538e+03
+3.444500e+02 3.730538e+03
+3.444000e+02 3.750925e+03
+3.443500e+02 3.826213e+03
+3.443000e+02 3.826213e+03
+3.442500e+02 3.826213e+03
+3.442000e+02 3.901500e+03
+3.441500e+02 3.929725e+03
+3.441000e+02 3.929725e+03
+3.440500e+02 3.929725e+03
+3.440000e+02 3.957950e+03
+3.439500e+002	4.028350e+003		
+3.439000e+002	4.124650e+003		
+3.438500e+002	4.109025e+003		
+3.438000e+002	4.164950e+003		
+3.437500e+002	4.210225e+003		
+3.437000e+002	4.196450e+003		
+3.436500e+002	4.268125e+003		
+3.436000e+002	4.266625e+003		
+3.435500e+002	4.305500e+003		
+3.435000e+002	4.340400e+003		
+3.434500e+002	4.385825e+003		
+3.434000e+002	4.398900e+003		
+3.433500e+002	4.408975e+003		
+3.433000e+002	4.458675e+003		
+3.432500e+002	4.514100e+003		
+3.432000e+002	4.538250e+003		
+3.431500e+002	4.608950e+003		
+3.431000e+002	4.592625e+003		
+3.430500e+002	4.680450e+003		
+3.430000e+002	4.724075e+003		
+3.429500e+002	4.787225e+003		
+3.429000e+002	4.820775e+003		
+3.428500e+002	4.821625e+003		
+3.428000e+002	4.878800e+003		
+3.427500e+002	4.969450e+003		
+3.427000e+002	4.986525e+003		
+3.426500e+002	5.078150e+003		
+3.426000e+002	5.152800e+003		
+3.425500e+002	5.191275e+003		
+3.425000e+002	5.238700e+003		
+3.424500e+002	5.365250e+003		
+3.424000e+002	5.418200e+003		
+3.423500e+002	5.484750e+003		
+3.423000e+002	5.544900e+003		
+3.422500e+002	5.729500e+003		
+3.422000e+002	5.759250e+003		
+3.421500e+002	5.863800e+003		
+3.421000e+002	6.025025e+003		
+3.420500e+002	6.109350e+003		
+3.420000e+002	6.198675e+003		
+3.419500e+002	6.354525e+003		
+3.419000e+002	6.552250e+003		
+3.418500e+002	6.717700e+003		
+3.418000e+002	6.930475e+003		
+3.417500e+002	7.069075e+003		
+3.417000e+002	7.332550e+003		
+3.416500e+002	7.554725e+003		
+3.416000e+002	7.703150e+003		
+3.415500e+002	7.994150e+003		
+3.415000e+002	8.282175e+003		
+3.414500e+002	8.621875e+003		
+3.414000e+002	9.011450e+003		
+3.413500e+002	9.368075e+003		
+3.413000e+002	9.682975e+003		
+3.412500e+002	1.011963e+004		
+3.412000e+002	1.064138e+004		
+3.411500e+002	1.113073e+004		
+3.411000e+002	1.168878e+004		
+3.410500e+002	1.225458e+004		
+3.410000e+002	1.279498e+004		
+3.409500e+002	1.333720e+004		
+3.409000e+002	1.398250e+004		
+3.408500e+002	1.468060e+004		
+3.408000e+002	1.537373e+004		
+3.407500e+002	1.588567e+004		
+3.407000e+002	1.639203e+004		
+3.406500e+002	1.692442e+004		
+3.406000e+002	1.732275e+004		
+3.405500e+002	1.769095e+004		
+3.405000e+002	1.805345e+004		
+3.404500e+002	1.818090e+004		
+3.404000e+002	1.800250e+004		
+3.403500e+002	1.765790e+004		
+3.403000e+002	1.708595e+004		
+3.402500e+002	1.615285e+004		
+3.402000e+002	1.519813e+004		
+3.401500e+002	1.381050e+004		
+3.401000e+002	1.239663e+004		
+3.400500e+002	1.105753e+004		
+3.400000e+002	9.748600e+003		
+3.399500e+002	8.526600e+003		
+3.399000e+002	7.363625e+003		
+3.398500e+002	6.422550e+003		
+3.398000e+002	5.700100e+003		
+3.397500e+002	5.145025e+003		
+3.397000e+002	4.595650e+003		
+3.396500e+002	4.227900e+003		
+3.396000e+002	3.955175e+003		
+3.395500e+002	3.779675e+003		
+3.395000e+002	3.587400e+003		
+3.394500e+002	3.447425e+003		
+3.394000e+002	3.348100e+003		
+3.393500e+002	3.247100e+003		
+3.393000e+002	3.195750e+003		
+3.392500e+002	3.105000e+003		
+3.392000e+002	3.074200e+003		
+3.391500e+002	3.008875e+003		
+3.391000e+002	3.004350e+003		
+3.390500e+002	2.977750e+003		
+3.390000e+002	2.925675e+003		
+3.389500e+002	2.966250e+003		
+3.389000e+002	2.914675e+003		
+3.388500e+002	2.915825e+003		
+3.388000e+002	2.920275e+003		
+3.387500e+002	2.900175e+003		
+3.387000e+002	2.943025e+003		
+3.386500e+002	2.940450e+003		
+3.386000e+002	2.936975e+003		
+3.385500e+002	2.931700e+003		
+3.385000e+002	2.971850e+003		
+3.384500e+002	2.952600e+003		
+3.384000e+002	2.937250e+003		
+3.383500e+002	3.018850e+003		
+3.383000e+002	2.988200e+003		
+3.382500e+002	3.006550e+003		
+3.382000e+002	3.048125e+003		
+3.381500e+002	3.000750e+003		
+3.381000e+002	3.064525e+003		
+3.380500e+002	3.090800e+003		
+3.380000e+002	3.094550e+003		
+3.379500e+002	3.190625e+003		
+3.379000e+002	3.185150e+003		
+3.378500e+002	3.219175e+003		
+3.378000e+002	3.219325e+003		
+3.377500e+002	3.277400e+003		
+3.377000e+002	3.269950e+003		
+3.376500e+002	3.341225e+003		
+3.376000e+002	3.398200e+003		
+3.375500e+002	3.418375e+003		
+3.375000e+002	3.446200e+003		
+3.374500e+002	3.499675e+003		
+3.374000e+002	3.550400e+003		
+3.373500e+002	3.662850e+003		
+3.373000e+002	3.771450e+003		
+3.372500e+002	3.798175e+003		
+3.372000e+002	3.886875e+003		
+3.371500e+002	3.924425e+003		
+3.371000e+002	4.018200e+003		
+3.370500e+002	4.103700e+003		
+3.370000e+002	4.277950e+003		
+3.369500e+002	4.385300e+003		
+3.369000e+002	4.486825e+003		
+3.368500e+002	4.622375e+003		
+3.368000e+002	4.747075e+003		
+3.367500e+002	4.939200e+003		
+3.367000e+002	5.123850e+003		
+3.366500e+002	5.367650e+003		
+3.366000e+002	5.606900e+003		
+3.365500e+002	5.851725e+003		
+3.365000e+002	6.051075e+003		
+3.364500e+002	6.353175e+003		
+3.364000e+002	6.758350e+003		
+3.363500e+002	7.038450e+003		
+3.363000e+002	7.449700e+003		
+3.362500e+002	7.922150e+003		
+3.362000e+002	8.467600e+003		
+3.361500e+002	8.841700e+003		
+3.361000e+002	9.472275e+003		
+3.360500e+002	1.011105e+004		
+3.360000e+002	1.078913e+004		
+3.359500e+002	1.154538e+004		
+3.359000e+002	1.229550e+004		
+3.358500e+002	1.319050e+004		
+3.358000e+002	1.406908e+004		
+3.357500e+002	1.497975e+004		
+3.357000e+002	1.603188e+004		
+3.356500e+002	1.701580e+004		
+3.356000e+002	1.797915e+004		
+3.355500e+002	1.901825e+004		
+3.355000e+002	2.004288e+004		
+3.354500e+002	2.098083e+004		
+3.354000e+002	2.184333e+004		
+3.353500e+002	2.265978e+004		
+3.353000e+002	2.329255e+004		
+3.352500e+002	2.400830e+004		
+3.352000e+002	2.425213e+004		
+3.351500e+002	2.413113e+004		
+3.351000e+002	2.390558e+004		
+3.350500e+002	2.326510e+004		
+3.350000e+002	2.199585e+004		
+3.349500e+002	2.060092e+004		
+3.349000e+002	1.872908e+004		
+3.348500e+002	1.664333e+004		
+3.348000e+002	1.435895e+004		
+3.347500e+002	1.212235e+004		
+3.347000e+002	1.011233e+004		
+3.346500e+002	8.266550e+003		
+3.346000e+002	6.671325e+003		
+3.345500e+002	5.460700e+003		
+3.345000e+002	4.433000e+003		
+3.344500e+002	3.677225e+003		
+3.344000e+002	3.075500e+003		
+3.343500e+002	2.612775e+003		
+3.343000e+002	2.279528e+003		
+3.342500e+002	2.031795e+003		
+3.342000e+002	1.814797e+003		
+3.341500e+002	1.640198e+003		
+3.341000e+002	1.484160e+003		
+3.340500e+002	1.383783e+003		
+3.340000e+002	1.270040e+003		
+3.339500e+002	1.210547e+003		
+3.339000e+002	1.128358e+003		
+3.338500e+002	1.072885e+003		
+3.338000e+002	1.033435e+003		
+3.337500e+002	9.876800e+002		
+3.337000e+002	9.114800e+002		
+3.336500e+002	8.777200e+002		
+3.336000e+002	8.436925e+002		
+3.335500e+002	8.354050e+002		
+3.335000e+002	8.065975e+002		
+3.334500e+002	7.844300e+002		
+3.334000e+002	7.519275e+002		
+3.333500e+002	7.133575e+002		
+3.333000e+002	7.040450e+002		
+3.332500e+002	7.043500e+002		
+3.332000e+002	7.022925e+002		
+3.331500e+002	6.946950e+002		
+3.331000e+002	6.504025e+002		
+3.330500e+002	6.242175e+002		
+3.330000e+002	6.309700e+002		
+3.329500e+002	6.201650e+002		
+3.329000e+002	5.863125e+002		
+3.328500e+002	6.053975e+002		
+3.328000e+002	6.068300e+002		
+3.327500e+002	5.860225e+002		
+3.327000e+002	5.741250e+002		
+3.326500e+002	5.687900e+002		
+3.326000e+002	5.608300e+002		
+3.325500e+002	5.469950e+002		
+3.325000e+002	5.323300e+002		
+3.324500e+002	5.347450e+002		
+3.324000e+002	5.188250e+002		
+3.323500e+002	5.215700e+002		
+3.323000e+002	5.261850e+002		
+3.322500e+002	5.206075e+002		
+3.322000e+002	5.240350e+002		
+3.321500e+002	5.153925e+002		
+3.321000e+002	5.035050e+002		
+3.320500e+002	5.001150e+002		
+3.320000e+002	4.877525e+002		
+3.319500e+002	4.865475e+002		
+3.319000e+002	4.909225e+002		
+3.318500e+002	4.967050e+002		
+3.318000e+002	4.902750e+002		
+3.317500e+002	4.718075e+002		
+3.317000e+002	4.683025e+002		
+3.316500e+002	4.744275e+002		
+3.316000e+002	4.619100e+002		
+3.315500e+002	4.576775e+002		
+3.315000e+002	4.610175e+002		
+3.314500e+002	4.512975e+002		
+3.314000e+002	4.475725e+002		
+3.313500e+002	4.625825e+002		
+3.313000e+002	4.511950e+002		
+3.312500e+002	4.520850e+002		
+3.312000e+002	4.372500e+002		
+3.311500e+002	4.432050e+002		
+3.311000e+002	4.540500e+002		
+3.310500e+002	4.426950e+002		
+3.310000e+002	4.309875e+002
\ No newline at end of file
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Pd_references.vms b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Pd_references.vms
new file mode 100644
index 0000000000000000000000000000000000000000..d6a63c38083e743edac4918c6b7b31e4cf2aecd8
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Pd_references.vms
@@ -0,0 +1,1687 @@
+VAMAS Surface Chemical Analysis Standard Data Transfer Format 1988 May 4
+Not Specified
+Not Specified
+Not Specified
+Not Specified
+5
+Casa Info Follows CasaXPS Version 2.3.24PR1.0
+0
+SourceAnalyserAngle: Not Specified
+CasaRowLabel:Pd metal
+CasaRowLabel:PdO
+NORM
+REGULAR
+0
+1
+Exp Variable
+d
+0
+0
+0
+0
+2
+Pd 3d
+Pd metal
+1
+2021
+6
+15
+32
+52
+0
+11
+Casa Info Follows
+0
+0
+0
+0
+none
+Group: none
+Analyzer Lens: none
+Analyzer Slit: none
+Scan Mode: none
+C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Pd3d_Pd_metal_narrow.txt_new.vms
+XPS
+0
+Al
+1486.61
+0
+0
+0
+56.5
+180
+FAT
+20
+1
+4.1408
+0
+0
+0
+0
+0
+Pd
+3d
+-1
+kinetic energy
+eV
+1136.61
+0.05
+2
+counts
+d
+Transmission
+d
+pulse counting
+1
+1
+0
+0
+0
+0
+2
+ESCAPE DEPTH TYPE
+d
+0
+MFP Exponent
+d
+0
+762
+430.988
+24252.1
+1
+1
+3030.43
+1
+3057.78
+1
+3057.78
+1
+3057.78
+1
+3085.13
+1
+3099.76
+1
+3099.76
+1
+3099.76
+1
+3114.4
+1
+3138.66
+1
+3138.66
+1
+3138.66
+1
+3162.93
+1
+3186.47
+1
+3186.47
+1
+3186.47
+1
+3210.03
+1
+3228.91
+1
+3228.91
+1
+3228.91
+1
+3247.8
+1
+3282.22
+1
+3282.22
+1
+3282.22
+1
+3316.65
+1
+3340.78
+1
+3340.78
+1
+3340.78
+1
+3364.9
+1
+3385.31
+1
+3385.31
+1
+3385.31
+1
+3405.72
+1
+3438.28
+1
+3438.28
+1
+3438.28
+1
+3470.82
+1
+3516.1
+1
+3516.1
+1
+3516.1
+1
+3561.38
+1
+3562.97
+1
+3562.97
+1
+3562.97
+1
+3564.57
+1
+3601.18
+1
+3601.18
+1
+3601.18
+1
+3637.78
+1
+3678.22
+1
+3678.22
+1
+3678.22
+1
+3718.68
+1
+3752.86
+1
+3752.86
+1
+3752.86
+1
+3787.05
+1
+3839.46
+1
+3839.46
+1
+3839.46
+1
+3891.88
+1
+3917.71
+1
+3917.71
+1
+3917.71
+1
+3943.55
+1
+3947.94
+1
+3947.94
+1
+3947.94
+1
+3952.32
+1
+3945.99
+1
+3945.99
+1
+3945.99
+1
+3939.65
+1
+3883.97
+1
+3883.97
+1
+3883.97
+1
+3828.3
+1
+3774.82
+1
+3774.82
+1
+3774.82
+1
+3721.35
+1
+3678.44
+1
+3678.44
+1
+3678.44
+1
+3635.53
+1
+3600.65
+1
+3600.65
+1
+3600.65
+1
+3565.78
+1
+3561.09
+1
+3561.09
+1
+3561.09
+1
+3556.4
+1
+3548.95
+1
+3548.95
+1
+3548.95
+1
+3541.5
+1
+3540.14
+1
+3540.14
+1
+3540.14
+1
+3538.78
+1
+3565.09
+1
+3565.09
+1
+3565.09
+1
+3591.4
+1
+3650.78
+1
+3650.78
+1
+3650.78
+1
+3710.15
+1
+3730.54
+1
+3730.54
+1
+3730.54
+1
+3750.93
+1
+3826.21
+1
+3826.21
+1
+3826.21
+1
+3901.5
+1
+3929.72
+1
+3929.72
+1
+3929.72
+1
+3957.95
+1
+4028.35
+1
+4124.65
+1
+4109.02
+1
+4164.95
+1
+4210.23
+1
+4196.45
+1
+4268.13
+1
+4266.63
+1
+4305.5
+1
+4340.4
+1
+4385.82
+1
+4398.9
+1
+4408.98
+1
+4458.68
+1
+4514.1
+1
+4538.25
+1
+4608.95
+1
+4592.63
+1
+4680.45
+1
+4724.07
+1
+4787.23
+1
+4820.77
+1
+4821.63
+1
+4878.8
+1
+4969.45
+1
+4986.52
+1
+5078.15
+1
+5152.8
+1
+5191.27
+1
+5238.7
+1
+5365.25
+1
+5418.2
+1
+5484.75
+1
+5544.9
+1
+5729.5
+1
+5759.25
+1
+5863.8
+1
+6025.02
+1
+6109.35
+1
+6198.68
+1
+6354.52
+1
+6552.25
+1
+6717.7
+1
+6930.48
+1
+7069.07
+1
+7332.55
+1
+7554.73
+1
+7703.15
+1
+7994.15
+1
+8282.17
+1
+8621.88
+1
+9011.45
+1
+9368.08
+1
+9682.98
+1
+10119.6
+1
+10641.4
+1
+11130.7
+1
+11688.8
+1
+12254.6
+1
+12795
+1
+13337.2
+1
+13982.5
+1
+14680.6
+1
+15373.7
+1
+15885.7
+1
+16392
+1
+16924.4
+1
+17322.8
+1
+17691
+1
+18053.5
+1
+18180.9
+1
+18002.5
+1
+17657.9
+1
+17086
+1
+16152.9
+1
+15198.1
+1
+13810.5
+1
+12396.6
+1
+11057.5
+1
+9748.6
+1
+8526.6
+1
+7363.63
+1
+6422.55
+1
+5700.1
+1
+5145.02
+1
+4595.65
+1
+4227.9
+1
+3955.18
+1
+3779.68
+1
+3587.4
+1
+3447.43
+1
+3348.1
+1
+3247.1
+1
+3195.75
+1
+3105
+1
+3074.2
+1
+3008.88
+1
+3004.35
+1
+2977.75
+1
+2925.68
+1
+2966.25
+1
+2914.68
+1
+2915.82
+1
+2920.28
+1
+2900.18
+1
+2943.03
+1
+2940.45
+1
+2936.97
+1
+2931.7
+1
+2971.85
+1
+2952.6
+1
+2937.25
+1
+3018.85
+1
+2988.2
+1
+3006.55
+1
+3048.13
+1
+3000.75
+1
+3064.53
+1
+3090.8
+1
+3094.55
+1
+3190.63
+1
+3185.15
+1
+3219.18
+1
+3219.32
+1
+3277.4
+1
+3269.95
+1
+3341.22
+1
+3398.2
+1
+3418.38
+1
+3446.2
+1
+3499.68
+1
+3550.4
+1
+3662.85
+1
+3771.45
+1
+3798.18
+1
+3886.88
+1
+3924.43
+1
+4018.2
+1
+4103.7
+1
+4277.95
+1
+4385.3
+1
+4486.82
+1
+4622.38
+1
+4747.07
+1
+4939.2
+1
+5123.85
+1
+5367.65
+1
+5606.9
+1
+5851.73
+1
+6051.07
+1
+6353.18
+1
+6758.35
+1
+7038.45
+1
+7449.7
+1
+7922.15
+1
+8467.6
+1
+8841.7
+1
+9472.27
+1
+10111
+1
+10789.1
+1
+11545.4
+1
+12295.5
+1
+13190.5
+1
+14069.1
+1
+14979.8
+1
+16031.9
+1
+17015.8
+1
+17979.2
+1
+19018.3
+1
+20042.9
+1
+20980.8
+1
+21843.3
+1
+22659.8
+1
+23292.5
+1
+24008.3
+1
+24252.1
+1
+24131.1
+1
+23905.6
+1
+23265.1
+1
+21995.8
+1
+20600.9
+1
+18729.1
+1
+16643.3
+1
+14359
+1
+12122.4
+1
+10112.3
+1
+8266.55
+1
+6671.32
+1
+5460.7
+1
+4433
+1
+3677.22
+1
+3075.5
+1
+2612.78
+1
+2279.53
+1
+2031.8
+1
+1814.8
+1
+1640.2
+1
+1484.16
+1
+1383.78
+1
+1270.04
+1
+1210.55
+1
+1128.36
+1
+1072.89
+1
+1033.43
+1
+987.68
+1
+911.48
+1
+877.72
+1
+843.693
+1
+835.405
+1
+806.597
+1
+784.43
+1
+751.928
+1
+713.357
+1
+704.045
+1
+704.35
+1
+702.293
+1
+694.695
+1
+650.403
+1
+624.217
+1
+630.97
+1
+620.165
+1
+586.313
+1
+605.398
+1
+606.83
+1
+586.023
+1
+574.125
+1
+568.79
+1
+560.83
+1
+546.995
+1
+532.33
+1
+534.745
+1
+518.825
+1
+521.57
+1
+526.185
+1
+520.607
+1
+524.035
+1
+515.393
+1
+503.505
+1
+500.115
+1
+487.753
+1
+486.548
+1
+490.923
+1
+496.705
+1
+490.275
+1
+471.808
+1
+468.303
+1
+474.428
+1
+461.91
+1
+457.678
+1
+461.017
+1
+451.298
+1
+447.572
+1
+462.582
+1
+451.195
+1
+452.085
+1
+437.25
+1
+443.205
+1
+454.05
+1
+442.695
+1
+430.988
+1
+Pd 3d
+PdO
+1
+2021
+6
+15
+32
+52
+0
+11
+Casa Info Follows
+0
+0
+0
+0
+none
+Group: none
+Analyzer Lens: none
+Analyzer Slit: none
+Scan Mode: none
+C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Pd3d_PdO_narrow.txt_new.vms
+XPS
+0
+Al
+1486.61
+0
+0
+0
+56.5
+180
+FAT
+20
+1
+4.1408
+0
+0
+0
+0
+0
+Pd
+3d
+-1
+kinetic energy
+eV
+1136.61
+0.05
+2
+counts
+d
+Transmission
+d
+pulse counting
+1
+1
+0
+0
+0
+0
+2
+ESCAPE DEPTH TYPE
+d
+0
+MFP Exponent
+d
+0
+762
+307.257
+20303.2
+1
+1
+2197.63
+1
+2188.82
+1
+2188.82
+1
+2188.82
+1
+2180.02
+1
+2208.03
+1
+2208.03
+1
+2208.03
+1
+2236.05
+1
+2235.37
+1
+2235.37
+1
+2235.37
+1
+2234.68
+1
+2192.28
+1
+2192.28
+1
+2192.28
+1
+2149.87
+1
+2152.77
+1
+2152.77
+1
+2152.77
+1
+2155.67
+1
+2114.68
+1
+2114.68
+1
+2114.68
+1
+2073.7
+1
+2176.8
+1
+2176.8
+1
+2176.8
+1
+2279.9
+1
+2242.2
+1
+2242.2
+1
+2242.2
+1
+2204.5
+1
+2228.74
+1
+2228.74
+1
+2228.74
+1
+2252.98
+1
+2332.55
+1
+2368.69
+1
+2475.24
+1
+2266.42
+1
+2328.22
+1
+2374.51
+1
+2363.7
+1
+2306.87
+1
+2343.47
+1
+2392.33
+1
+2443.7
+1
+2422.91
+1
+2405.28
+1
+2504.94
+1
+2468.69
+1
+2507.03
+1
+2618.51
+1
+2556.43
+1
+2585.41
+1
+2565.26
+1
+2554.64
+1
+2584.63
+1
+2639.29
+1
+2579.29
+1
+2631.47
+1
+2640.74
+1
+2627.86
+1
+2730.43
+1
+2697.52
+1
+2721.09
+1
+2771.1
+1
+2751.59
+1
+2746.06
+1
+2791.74
+1
+2787.38
+1
+2773.77
+1
+2777.43
+1
+2861.1
+1
+2854.07
+1
+2892.19
+1
+2999.87
+1
+2961.32
+1
+2931.4
+1
+3003.94
+1
+2966.28
+1
+3030.46
+1
+3050.38
+1
+3060.07
+1
+3147.73
+1
+3125.98
+1
+3136.57
+1
+3128.72
+1
+3147.69
+1
+3154.1
+1
+3238.56
+1
+3174.93
+1
+3233.63
+1
+3211.42
+1
+3229.24
+1
+3103.22
+1
+3185.35
+1
+3232.22
+1
+3239.12
+1
+3192.1
+1
+3131.74
+1
+3112.23
+1
+3153.47
+1
+3150.57
+1
+3094.33
+1
+3009.53
+1
+3034.97
+1
+2983.88
+1
+2937.74
+1
+2901.37
+1
+3022.43
+1
+2985.67
+1
+2903.19
+1
+2924.36
+1
+2948.82
+1
+2954.51
+1
+2959.21
+1
+2963.15
+1
+2981.82
+1
+2977.93
+1
+3026.61
+1
+3093.93
+1
+3111.18
+1
+3088.87
+1
+3203.81
+1
+3339.35
+1
+3434.43
+1
+3521.37
+1
+3660.17
+1
+3720.76
+1
+3934.87
+1
+4071.47
+1
+4292.5
+1
+4496.24
+1
+4723.06
+1
+4894.24
+1
+5182.97
+1
+5568.43
+1
+5875.63
+1
+6245.88
+1
+6487.62
+1
+7051.17
+1
+7489.93
+1
+7787.52
+1
+8378.33
+1
+8853.58
+1
+9242
+1
+9702.58
+1
+10147.7
+1
+10295.8
+1
+10493.8
+1
+10814.3
+1
+10919.3
+1
+11009.3
+1
+10846.9
+1
+10742.4
+1
+10514.2
+1
+10223.8
+1
+9874.33
+1
+9363.17
+1
+8788.83
+1
+8377.25
+1
+7743.75
+1
+7207.33
+1
+6770.73
+1
+6480.76
+1
+5961.29
+1
+5409.02
+1
+5131.62
+1
+4746.1
+1
+4448.18
+1
+4255.13
+1
+3843.51
+1
+3736.36
+1
+3537.61
+1
+3405.13
+1
+3171.43
+1
+3025.75
+1
+2934.81
+1
+2763.26
+1
+2718.57
+1
+2677.35
+1
+2571.56
+1
+2494.72
+1
+2477.31
+1
+2295.79
+1
+2329.9
+1
+2293.97
+1
+2280.76
+1
+2254.37
+1
+2294.03
+1
+2279.69
+1
+2279.12
+1
+2312.97
+1
+2295.67
+1
+2304.22
+1
+2403.1
+1
+2529.5
+1
+2459.93
+1
+2528.78
+1
+2582.18
+1
+2600.2
+1
+2620.03
+1
+2573.45
+1
+2680.93
+1
+2686.48
+1
+2750.77
+1
+2741.96
+1
+2590.47
+1
+2618.72
+1
+2703.33
+1
+2563.16
+1
+2651.78
+1
+2636.45
+1
+2517.88
+1
+2459.29
+1
+2439.93
+1
+2460.82
+1
+2365.59
+1
+2411.08
+1
+2299.37
+1
+2290.32
+1
+2421.78
+1
+2363.8
+1
+2411.57
+1
+2430.07
+1
+2454.28
+1
+2436.69
+1
+2443.47
+1
+2493.44
+1
+2612.7
+1
+2615.65
+1
+2755.33
+1
+2770.37
+1
+2863.87
+1
+3039.57
+1
+3190.32
+1
+3401.88
+1
+3603.28
+1
+3810.72
+1
+4075.82
+1
+4495.95
+1
+4818.37
+1
+5318.09
+1
+5816.49
+1
+6322.59
+1
+7106.67
+1
+7881.12
+1
+8584.75
+1
+9654.58
+1
+10530.8
+1
+11584
+1
+12819.9
+1
+13790.2
+1
+14932.1
+1
+16205.3
+1
+17329.3
+1
+18176.5
+1
+18892.4
+1
+19612.7
+1
+20303.2
+1
+20233
+1
+19763.3
+1
+19224.4
+1
+18263.2
+1
+17150.1
+1
+15664.8
+1
+14076
+1
+12465.2
+1
+10785.7
+1
+9155
+1
+7815.25
+1
+6585.46
+1
+5510.75
+1
+4571.4
+1
+3831.32
+1
+3292.48
+1
+2843.35
+1
+2427.27
+1
+2117.79
+1
+1847.53
+1
+1623.11
+1
+1444.9
+1
+1322.11
+1
+1224.28
+1
+1154.33
+1
+1035.72
+1
+998.075
+1
+950.733
+1
+910.483
+1
+809.87
+1
+786.79
+1
+794.795
+1
+708.003
+1
+694.123
+1
+653.437
+1
+636.866
+1
+646.489
+1
+584.881
+1
+573.482
+1
+538.603
+1
+555.145
+1
+566.058
+1
+535.354
+1
+505.261
+1
+506.248
+1
+489.879
+1
+461.141
+1
+454.582
+1
+455.534
+1
+440.819
+1
+437.626
+1
+456.598
+1
+444.005
+1
+418.868
+1
+431.231
+1
+425.892
+1
+411.276
+1
+410.563
+1
+428.758
+1
+424.108
+1
+419.803
+1
+393.612
+1
+397.052
+1
+397.986
+1
+388.638
+1
+396.083
+1
+376.361
+1
+378.586
+1
+364.729
+1
+396.717
+1
+375.137
+1
+359.262
+1
+360.153
+1
+350.459
+1
+391.632
+1
+382.886
+1
+365.986
+1
+389.053
+1
+387.068
+1
+378.602
+1
+369.072
+1
+353.892
+1
+348.553
+1
+355.742
+1
+369.232
+1
+362.997
+1
+363.095
+1
+318.993
+1
+367.734
+1
+345.293
+1
+350.444
+1
+340.623
+1
+349.982
+1
+347.978
+1
+335.687
+1
+351.904
+1
+339.345
+1
+346.197
+1
+330.462
+1
+340.036
+1
+349.267
+1
+346.913
+1
+327.198
+1
+313.187
+1
+320.789
+1
+357.823
+1
+353.642
+1
+313.175
+1
+307.257
+1
+320.483
+1
+328.227
+1
+319.029
+1
+328.503
+1
+338.752
+1
+321.619
+1
+331.68
+1
+333.668
+1
+316.447
+1
+336.34
+1
+end of experiment
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ti2p_Ti2O3.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ti2p_Ti2O3.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ea0bed88100f0da59371a2ff4a82fd795bd4cb6b
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ti2p_Ti2O3.txt
@@ -0,0 +1,1058 @@
+Ti2p Ti2O3
+4.990000e+02 2.548860e+03
+4.989500e+02 2.548860e+03
+4.989000e+02 2.550285e+03
+4.988500e+02 2.551710e+03
+4.988000e+02 2.553140e+03
+4.987500e+02 2.554570e+03
+4.987000e+02 2.556000e+03
+4.986500e+02 2.557430e+03
+4.986000e+02 2.558860e+03
+4.985500e+02 2.560290e+03
+4.985000e+02 2.561720e+03
+4.984500e+02 2.563150e+03
+4.984000e+02 2.564585e+03
+4.983500e+02 2.566020e+03
+4.983000e+02 2.567455e+03
+4.982500e+02 2.568890e+03
+4.982000e+02 2.570330e+03
+4.981500e+02 2.571770e+03
+4.981000e+02 2.573210e+03
+4.980500e+02 2.574650e+03
+4.980000e+02 2.576090e+03
+4.979500e+02 2.577530e+03
+4.979000e+02 2.578975e+03
+4.978500e+02 2.580420e+03
+4.978000e+02 2.581865e+03
+4.977500e+02 2.583310e+03
+4.977000e+02 2.584760e+03
+4.976500e+02 2.586210e+03
+4.976000e+02 2.587655e+03
+4.975500e+02 2.589100e+03
+4.975000e+02 2.590555e+03
+4.974500e+02 2.592010e+03
+4.974000e+02 2.593465e+03
+4.973500e+02 2.594920e+03
+4.973000e+02 2.596375e+03
+4.972500e+02 2.597830e+03
+4.972000e+02 2.599280e+03
+4.971500e+02 2.600730e+03
+4.971000e+02 2.602190e+03
+4.970500e+02 2.603650e+03
+4.970000e+02 2.605115e+03
+4.969500e+02 2.606580e+03
+4.969000e+02 2.608040e+03
+4.968500e+02 2.609500e+03
+4.968000e+02 2.610965e+03
+4.967500e+02 2.612430e+03
+4.967000e+02 2.613915e+03
+4.966500e+02 2.615400e+03
+4.966000e+02 2.617000e+03
+4.965500e+02 2.618600e+03
+4.965000e+02 2.620200e+03
+4.964500e+02 2.621800e+03
+4.964000e+02 2.623400e+03
+4.963500e+02 2.625000e+03
+4.963000e+02 2.626605e+03
+4.962500e+02 2.628210e+03
+4.962000e+02 2.629815e+03
+4.961500e+02 2.631420e+03
+4.961000e+02 2.633035e+03
+4.960500e+02 2.634650e+03
+4.960000e+02 2.636260e+03
+4.959500e+02 2.637870e+03
+4.959000e+02 2.639480e+03
+4.958500e+02 2.641090e+03
+4.958000e+02 2.642705e+03
+4.957500e+02 2.644320e+03
+4.957000e+02 2.645940e+03
+4.956500e+02 2.647560e+03
+4.956000e+02 2.649185e+03
+4.955500e+02 2.650810e+03
+4.955000e+02 2.652430e+03
+4.954500e+02 2.654050e+03
+4.954000e+02 2.655670e+03
+4.953500e+02 2.657290e+03
+4.953000e+02 2.658920e+03
+4.952500e+02 2.660550e+03
+4.952000e+02 2.662185e+03
+4.951500e+02 2.663820e+03
+4.951000e+02 2.665450e+03
+4.950500e+02 2.667080e+03
+4.950000e+02 2.668710e+03
+4.949500e+02 2.670340e+03
+4.949000e+02 2.671980e+03
+4.948500e+02 2.673620e+03
+4.948000e+02 2.675260e+03
+4.947500e+02 2.676900e+03
+4.947000e+02 2.678545e+03
+4.946500e+02 2.680190e+03
+4.946000e+02 2.681830e+03
+4.945500e+02 2.683470e+03
+4.945000e+02 2.685115e+03
+4.944500e+02 2.686760e+03
+4.944000e+02 2.688415e+03
+4.943500e+02 2.690070e+03
+4.943000e+02 2.691725e+03
+4.942500e+02 2.693380e+03
+4.942000e+02 2.695035e+03
+4.941500e+02 2.696690e+03
+4.941000e+02 2.698340e+03
+4.940500e+02 2.699990e+03
+4.940000e+02 2.701655e+03
+4.939500e+02 2.703320e+03
+4.939000e+02 2.704990e+03
+4.938500e+02 2.706660e+03
+4.938000e+02 2.708325e+03
+4.937500e+02 2.709990e+03
+4.937000e+02 2.711660e+03
+4.936500e+02 2.713330e+03
+4.936000e+02 2.715000e+03
+4.935500e+02 2.716670e+03
+4.935000e+02 2.718350e+03
+4.934500e+02 2.720030e+03
+4.934000e+02 2.721710e+03
+4.933500e+02 2.723390e+03
+4.933000e+02 2.725175e+03
+4.932500e+02 2.726960e+03
+4.932000e+02 2.728815e+03
+4.931500e+02 2.730670e+03
+4.931000e+02 2.732535e+03
+4.930500e+02 2.734400e+03
+4.930000e+02 2.736265e+03
+4.929500e+02 2.738130e+03
+4.929000e+02 2.739995e+03
+4.928500e+02 2.741860e+03
+4.928000e+02 2.743725e+03
+4.927500e+02 2.745590e+03
+4.927000e+02 2.747470e+03
+4.926500e+02 2.749350e+03
+4.926000e+02 2.751225e+03
+4.925500e+02 2.753100e+03
+4.925000e+02 2.754980e+03
+4.924500e+02 2.756860e+03
+4.924000e+02 2.758740e+03
+4.923500e+02 2.760620e+03
+4.923000e+02 2.762505e+03
+4.922500e+02 2.764390e+03
+4.922000e+02 2.766280e+03
+4.921500e+02 2.768170e+03
+4.921000e+02 2.770065e+03
+4.920500e+02 2.771960e+03
+4.920000e+02 2.773850e+03
+4.919500e+02 2.775740e+03
+4.919000e+02 2.777635e+03
+4.918500e+02 2.779530e+03
+4.918000e+02 2.781440e+03
+4.917500e+02 2.783350e+03
+4.917000e+02 2.785260e+03
+4.916500e+02 2.787170e+03
+4.916000e+02 2.789080e+03
+4.915500e+02 2.790990e+03
+4.915000e+02 2.792895e+03
+4.914500e+02 2.794800e+03
+4.914000e+02 2.796720e+03
+4.913500e+02 2.798640e+03
+4.913000e+02 2.800565e+03
+4.912500e+02 2.802490e+03
+4.912000e+02 2.804415e+03
+4.911500e+02 2.806340e+03
+4.911000e+02 2.808265e+03
+4.910500e+02 2.810190e+03
+4.910000e+02 2.812115e+03
+4.909500e+02 2.814040e+03
+4.909000e+02 2.815980e+03
+4.908500e+02 2.817920e+03
+4.908000e+02 2.819860e+03
+4.907500e+02 2.821800e+03
+4.907000e+02 2.823740e+03
+4.906500e+02 2.825680e+03
+4.906000e+02 2.827615e+03
+4.905500e+02 2.829550e+03
+4.905000e+02 2.831505e+03
+4.904500e+02 2.833460e+03
+4.904000e+02 2.835415e+03
+4.903500e+02 2.837370e+03
+4.903000e+02 2.839325e+03
+4.902500e+02 2.841280e+03
+4.902000e+02 2.843235e+03
+4.901500e+02 2.845190e+03
+4.901000e+02 2.847155e+03
+4.900500e+02 2.849120e+03
+4.900000e+02 2.851105e+03
+4.899500e+02 2.853090e+03
+4.899000e+02 2.855275e+03
+4.898500e+02 2.857460e+03
+4.898000e+02 2.859650e+03
+4.897500e+02 2.861840e+03
+4.897000e+02 2.864035e+03
+4.896500e+02 2.866230e+03
+4.896000e+02 2.868440e+03
+4.895500e+02 2.870650e+03
+4.895000e+02 2.872855e+03
+4.894500e+02 2.875060e+03
+4.894000e+02 2.877270e+03
+4.893500e+02 2.879480e+03
+4.893000e+02 2.881690e+03
+4.892500e+02 2.883900e+03
+4.892000e+02 2.886120e+03
+4.891500e+02 2.888340e+03
+4.891000e+02 2.890565e+03
+4.890500e+02 2.892790e+03
+4.890000e+02 2.895015e+03
+4.889500e+02 2.897240e+03
+4.889000e+02 2.899465e+03
+4.888500e+02 2.901690e+03
+4.888000e+02 2.903925e+03
+4.887500e+02 2.906160e+03
+4.887000e+02 2.908405e+03
+4.886500e+02 2.910650e+03
+4.886000e+02 2.912890e+03
+4.885500e+02 2.915130e+03
+4.885000e+02 2.917375e+03
+4.884500e+02 2.919620e+03
+4.884000e+02 2.921865e+03
+4.883500e+02 2.924110e+03
+4.883000e+02 2.925380e+03
+4.882500e+02 2.926650e+03
+4.882000e+02 2.928915e+03
+4.881500e+02 2.931180e+03
+4.881000e+02 2.933455e+03
+4.880500e+02 2.935730e+03
+4.880000e+02 2.938005e+03
+4.879500e+02 2.940280e+03
+4.879000e+02 2.942585e+03
+4.878500e+02 2.944890e+03
+4.878000e+02 2.947200e+03
+4.877500e+02 2.949510e+03
+4.877000e+02 2.951830e+03
+4.876500e+02 2.954150e+03
+4.876000e+02 2.956475e+03
+4.875500e+02 2.958800e+03
+4.875000e+02 2.961150e+03
+4.874500e+02 2.963500e+03
+4.874000e+02 2.965860e+03
+4.873500e+02 2.968220e+03
+4.873000e+02 2.970595e+03
+4.872500e+02 2.972970e+03
+4.872000e+02 2.975350e+03
+4.871500e+02 2.977730e+03
+4.871000e+02 2.980115e+03
+4.870500e+02 2.982500e+03
+4.870000e+02 2.984915e+03
+4.869500e+02 2.987330e+03
+4.869000e+02 2.989750e+03
+4.868500e+02 2.992170e+03
+4.868000e+02 2.994595e+03
+4.867500e+02 2.997020e+03
+4.867000e+02 2.999455e+03
+4.866500e+02 3.001890e+03
+4.866000e+02 3.004345e+03
+4.865500e+02 3.006800e+03
+4.865000e+02 3.009270e+03
+4.864500e+02 3.011740e+03
+4.864000e+02 3.014215e+03
+4.863500e+02 3.016690e+03
+4.863000e+02 3.019175e+03
+4.862500e+02 3.021660e+03
+4.862000e+02 3.024155e+03
+4.861500e+02 3.026650e+03
+4.861000e+02 3.029170e+03
+4.860500e+02 3.031690e+03
+4.860000e+02 3.034215e+03
+4.859500e+02 3.036740e+03
+4.859000e+02 3.039270e+03
+4.858500e+02 3.041800e+03
+4.858000e+02 3.044340e+03
+4.857500e+02 3.046880e+03
+4.857000e+02 3.049450e+03
+4.856500e+02 3.052020e+03
+4.856000e+02 3.054595e+03
+4.855500e+02 3.057170e+03
+4.855000e+02 3.059750e+03
+4.854500e+02 3.062330e+03
+4.854000e+02 3.064925e+03
+4.853500e+02 3.067520e+03
+4.853000e+02 3.070135e+03
+4.852500e+02 3.072750e+03
+4.852000e+02 3.075380e+03
+4.851500e+02 3.078010e+03
+4.851000e+02 3.080650e+03
+4.850500e+02 3.083290e+03
+4.850000e+02 3.085935e+03
+4.849500e+02 3.088580e+03
+4.849000e+02 3.091240e+03
+4.848500e+02 3.093900e+03
+4.848000e+02 3.096580e+03
+4.847500e+02 3.099260e+03
+4.847000e+02 3.101950e+03
+4.846500e+02 3.104640e+03
+4.846000e+02 3.107335e+03
+4.845500e+02 3.110030e+03
+4.845000e+02 3.112735e+03
+4.844500e+02 3.115440e+03
+4.844000e+02 3.118165e+03
+4.843500e+02 3.120890e+03
+4.843000e+02 3.123625e+03
+4.842500e+02 3.126360e+03
+4.842000e+02 3.129105e+03
+4.841500e+02 3.131850e+03
+4.841000e+02 3.134605e+03
+4.840500e+02 3.137360e+03
+4.840000e+02 3.140130e+03
+4.839500e+02 3.142900e+03
+4.839000e+02 3.145680e+03
+4.838500e+02 3.148460e+03
+4.838000e+02 3.151255e+03
+4.837500e+02 3.154050e+03
+4.837000e+02 3.156845e+03
+4.836500e+02 3.159640e+03
+4.836000e+02 3.162455e+03
+4.835500e+02 3.165270e+03
+4.835000e+02 3.168100e+03
+4.834500e+02 3.170930e+03
+4.834000e+02 3.173765e+03
+4.833500e+02 3.176600e+03
+4.833000e+02 3.179445e+03
+4.832500e+02 3.182290e+03
+4.832000e+02 3.185160e+03
+4.831500e+02 3.188030e+03
+4.831000e+02 3.190915e+03
+4.830500e+02 3.193800e+03
+4.830000e+02 3.196695e+03
+4.829500e+02 3.199590e+03
+4.829000e+02 3.202495e+03
+4.828500e+02 3.205400e+03
+4.828000e+02 3.208315e+03
+4.827500e+02 3.211230e+03
+4.827000e+02 3.214155e+03
+4.826500e+02 3.217080e+03
+4.826000e+02 3.220020e+03
+4.825500e+02 3.222960e+03
+4.825000e+02 3.225905e+03
+4.824500e+02 3.228850e+03
+4.824000e+02 3.231805e+03
+4.823500e+02 3.234760e+03
+4.823000e+02 3.237725e+03
+4.822500e+02 3.240690e+03
+4.822000e+02 3.243670e+03
+4.821500e+02 3.246650e+03
+4.821000e+02 3.249640e+03
+4.820500e+02 3.252630e+03
+4.820000e+02 3.255625e+03
+4.819500e+02 3.258620e+03
+4.819000e+02 3.261625e+03
+4.818500e+02 3.264630e+03
+4.818000e+02 3.267645e+03
+4.817500e+02 3.270660e+03
+4.817000e+02 3.273690e+03
+4.816500e+02 3.276720e+03
+4.816000e+02 3.279755e+03
+4.815500e+02 3.282790e+03
+4.815000e+02 3.285830e+03
+4.814500e+02 3.288870e+03
+4.814000e+02 3.291920e+03
+4.813500e+02 3.294970e+03
+4.813000e+02 3.298030e+03
+4.812500e+02 3.301090e+03
+4.812000e+02 3.304160e+03
+4.811500e+02 3.307230e+03
+4.811000e+02 3.310315e+03
+4.810500e+02 3.313400e+03
+4.810000e+02 3.316510e+03
+4.809500e+02 3.319620e+03
+4.809000e+02 3.322735e+03
+4.808500e+02 3.325850e+03
+4.808000e+02 3.328970e+03
+4.807500e+02 3.332090e+03
+4.807000e+02 3.335220e+03
+4.806500e+02 3.338350e+03
+4.806000e+02 3.341490e+03
+4.805500e+02 3.344630e+03
+4.805000e+02 3.347775e+03
+4.804500e+02 3.350920e+03
+4.804000e+02 3.354065e+03
+4.803500e+02 3.357210e+03
+4.803000e+02 3.360370e+03
+4.802500e+02 3.363530e+03
+4.802000e+02 3.366690e+03
+4.801500e+02 3.369850e+03
+4.801000e+02 3.373020e+03
+4.800500e+02 3.376190e+03
+4.800000e+02 3.379275e+03
+4.799500e+02 3.382360e+03
+4.799000e+02 3.385540e+03
+4.798500e+02 3.388720e+03
+4.798000e+02 3.391905e+03
+4.797500e+02 3.395090e+03
+4.797000e+02 3.398285e+03
+4.796500e+02 3.401480e+03
+4.796000e+02 3.404665e+03
+4.795500e+02 3.407850e+03
+4.795000e+02 3.411050e+03
+4.794500e+02 3.414250e+03
+4.794000e+02 3.417455e+03
+4.793500e+02 3.420660e+03
+4.793000e+02 3.423875e+03
+4.792500e+02 3.427090e+03
+4.792000e+02 3.430300e+03
+4.791500e+02 3.433510e+03
+4.791000e+02 3.436715e+03
+4.790500e+02 3.439920e+03
+4.790000e+02 3.443140e+03
+4.789500e+02 3.446360e+03
+4.789000e+02 3.449590e+03
+4.788500e+02 3.452820e+03
+4.788000e+02 3.456045e+03
+4.787500e+02 3.459270e+03
+4.787000e+02 3.462480e+03
+4.786500e+02 3.465690e+03
+4.786000e+02 3.468910e+03
+4.785500e+02 3.472130e+03
+4.785000e+02 3.475360e+03
+4.784500e+02 3.478590e+03
+4.784000e+02 3.481830e+03
+4.783500e+02 3.485070e+03
+4.783000e+02 3.488275e+03
+4.782500e+02 3.491480e+03
+4.782000e+02 3.494690e+03
+4.781500e+02 3.497900e+03
+4.781000e+02 3.501120e+03
+4.780500e+02 3.504340e+03
+4.780000e+02 3.507570e+03
+4.779500e+02 3.510800e+03
+4.779000e+02 3.514005e+03
+4.778500e+02 3.517210e+03
+4.778000e+02 3.520395e+03
+4.777500e+02 3.523580e+03
+4.777000e+02 3.526775e+03
+4.776500e+02 3.529970e+03
+4.776000e+02 3.533175e+03
+4.775500e+02 3.536380e+03
+4.775000e+02 3.539580e+03
+4.774500e+02 3.542780e+03
+4.774000e+02 3.545915e+03
+4.773500e+02 3.549050e+03
+4.773000e+02 3.552200e+03
+4.772500e+02 3.555350e+03
+4.772000e+02 3.558510e+03
+4.771500e+02 3.561670e+03
+4.771000e+02 3.564845e+03
+4.770500e+02 3.568020e+03
+4.770000e+02 3.571100e+03
+4.769500e+02 3.574180e+03
+4.769000e+02 3.577255e+03
+4.768500e+02 3.580330e+03
+4.768000e+02 3.583420e+03
+4.767500e+02 3.586510e+03
+4.767000e+02 3.589610e+03
+4.766500e+02 3.592710e+03
+4.766000e+02 3.595745e+03
+4.765500e+02 3.598780e+03
+4.765000e+02 3.601745e+03
+4.764500e+02 3.604710e+03
+4.764000e+02 3.607690e+03
+4.763500e+02 3.610670e+03
+4.763000e+02 3.613665e+03
+4.762500e+02 3.616660e+03
+4.762000e+02 3.619635e+03
+4.761500e+02 3.622610e+03
+4.761000e+02 3.625420e+03
+4.760500e+02 3.628230e+03
+4.760000e+02 3.631060e+03
+4.759500e+02 3.633890e+03
+4.759000e+02 3.636730e+03
+4.758500e+02 3.639570e+03
+4.758000e+02 3.642425e+03
+4.757500e+02 3.645280e+03
+4.757000e+02 3.647935e+03
+4.756500e+02 3.650590e+03
+4.756000e+02 3.653205e+03
+4.755500e+02 3.655820e+03
+4.755000e+02 3.658445e+03
+4.754500e+02 3.661070e+03
+4.754000e+02 3.663715e+03
+4.753500e+02 3.666360e+03
+4.753000e+02 3.668875e+03
+4.752500e+02 3.671390e+03
+4.752000e+02 3.673720e+03
+4.751500e+02 3.676050e+03
+4.751000e+02 3.678395e+03
+4.750500e+02 3.680740e+03
+4.750000e+02 3.683105e+03
+4.749500e+02 3.685470e+03
+4.749000e+02 3.687820e+03
+4.748500e+02 3.690170e+03
+4.748000e+02 3.692130e+03
+4.747500e+02 3.694090e+03
+4.747000e+02 3.696065e+03
+4.746500e+02 3.698040e+03
+4.746000e+02 3.700040e+03
+4.745500e+02 3.702040e+03
+4.745000e+02 3.704055e+03
+4.744500e+02 3.706070e+03
+4.744000e+02 3.707710e+03
+4.743500e+02 3.709350e+03
+4.743000e+02 3.710860e+03
+4.742500e+02 3.712370e+03
+4.742000e+02 3.713900e+03
+4.741500e+02 3.715430e+03
+4.741000e+02 3.716985e+03
+4.740500e+02 3.718540e+03
+4.740000e+02 3.719875e+03
+4.739500e+02 3.721210e+03
+4.739000e+02 3.722135e+03
+4.738500e+02 3.723060e+03
+4.738000e+02 3.724010e+03
+4.737500e+02 3.724960e+03
+4.737000e+02 3.725940e+03
+4.736500e+02 3.726920e+03
+4.736000e+02 3.727925e+03
+4.735500e+02 3.728930e+03
+4.735000e+02 3.729150e+03
+4.734500e+02 3.729370e+03
+4.734000e+02 3.729620e+03
+4.733500e+02 3.729870e+03
+4.733000e+02 3.730155e+03
+4.732500e+02 3.730440e+03
+4.732000e+02 3.730755e+03
+4.731500e+02 3.731070e+03
+4.731000e+02 3.730815e+03
+4.730500e+02 3.730560e+03
+4.730000e+02 3.729995e+03
+4.729500e+02 3.729430e+03
+4.729000e+02 3.728900e+03
+4.728500e+02 3.728370e+03
+4.728000e+02 3.727880e+03
+4.727500e+02 3.727390e+03
+4.727000e+02 3.726635e+03
+4.726500e+02 3.725880e+03
+4.726000e+02 3.724380e+03
+4.725500e+02 3.722880e+03
+4.725000e+02 3.721425e+03
+4.724500e+02 3.719970e+03
+4.724000e+02 3.718565e+03
+4.723500e+02 3.717160e+03
+4.723000e+02 3.715805e+03
+4.722500e+02 3.714450e+03
+4.722000e+02 3.712030e+03
+4.721500e+02 3.709610e+03
+4.721000e+02 3.707145e+03
+4.720500e+02 3.704680e+03
+4.720000e+02 3.702280e+03
+4.719500e+02 3.699880e+03
+4.719000e+02 3.697540e+03
+4.718500e+02 3.695200e+03
+4.718000e+02 3.692180e+03
+4.717500e+02 3.689160e+03
+4.717000e+02 3.685630e+03
+4.716500e+02 3.682100e+03
+4.716000e+02 3.678650e+03
+4.715500e+02 3.675200e+03
+4.715000e+02 3.671825e+03
+4.714500e+02 3.668450e+03
+4.714000e+02 3.664875e+03
+4.713500e+02 3.661300e+03
+4.713000e+02 3.656710e+03
+4.712500e+02 3.652120e+03
+4.712000e+02 3.647630e+03
+4.711500e+02 3.643140e+03
+4.711000e+02 3.638755e+03
+4.710500e+02 3.634370e+03
+4.710000e+02 3.630105e+03
+4.709500e+02 3.625840e+03
+4.709000e+02 3.620660e+03
+4.708500e+02 3.615110e+03
+4.708000e+02 3.609620e+03
+4.707500e+02 3.604190e+03
+4.707000e+02 3.598850e+03
+4.706500e+02 3.593580e+03
+4.706000e+02 3.588380e+03
+4.705500e+02 3.583280e+03
+4.705000e+02 3.578250e+03
+4.704500e+02 3.571920e+03
+4.704000e+02 3.565640e+03
+4.703500e+02 3.559450e+03
+4.703000e+02 3.553380e+03
+4.702500e+02 3.547410e+03
+4.702000e+02 3.541560e+03
+4.701500e+02 3.535810e+03
+4.701000e+02 3.530190e+03
+4.700500e+02 3.524340e+03
+4.700000e+02 3.517600e+03
+4.699500e+02 3.511010e+03
+4.699000e+02 3.504550e+03
+4.698500e+02 3.498240e+03
+4.698000e+02 3.492090e+03
+4.697500e+02 3.486100e+03
+4.697000e+02 3.480280e+03
+4.696500e+02 3.474630e+03
+4.696000e+02 3.468500e+03
+4.695500e+02 3.461970e+03
+4.695000e+02 3.455650e+03
+4.694500e+02 3.449550e+03
+4.694000e+02 3.443660e+03
+4.693500e+02 3.438030e+03
+4.693000e+02 3.432650e+03
+4.692500e+02 3.427550e+03
+4.692000e+02 3.422730e+03
+4.691500e+02 3.417270e+03
+4.691000e+02 3.411930e+03
+4.690500e+02 3.406890e+03
+4.690000e+02 3.402170e+03
+4.689500e+02 3.397800e+03
+4.689000e+02 3.393780e+03
+4.688500e+02 3.390140e+03
+4.688000e+02 3.386890e+03
+4.687500e+02 3.383950e+03
+4.687000e+02 3.380660e+03
+4.686500e+02 3.377820e+03
+4.686000e+02 3.375460e+03
+4.685500e+02 3.373580e+03
+4.685000e+02 3.372220e+03
+4.684500e+02 3.371390e+03
+4.684000e+02 3.371110e+03
+4.683500e+02 3.371430e+03
+4.683000e+02 3.372100e+03
+4.682500e+02 3.373000e+03
+4.682000e+02 3.374570e+03
+4.681500e+02 3.376800e+03
+4.681000e+02 3.379750e+03
+4.680500e+02 3.383450e+03
+4.680000e+02 3.387950e+03
+4.679500e+02 3.393250e+03
+4.679000e+02 3.399360e+03
+4.678500e+02 3.406040e+03
+4.678000e+02 3.413450e+03
+4.677500e+02 3.421760e+03
+4.677000e+02 3.431010e+03
+4.676500e+02 3.441200e+03
+4.676000e+02 3.452410e+03
+4.675500e+02 3.464610e+03
+4.675000e+02 3.477860e+03
+4.674500e+02 3.492190e+03
+4.674000e+02 3.507440e+03
+4.673500e+02 3.523900e+03
+4.673000e+02 3.541560e+03
+4.672500e+02 3.560420e+03
+4.672000e+02 3.580480e+03
+4.671500e+02 3.601750e+03
+4.671000e+02 3.624260e+03
+4.670500e+02 3.648010e+03
+4.670000e+02 3.673040e+03
+4.669500e+02 3.699400e+03
+4.669000e+02 3.727030e+03
+4.668500e+02 3.755980e+03
+4.668000e+02 3.786210e+03
+4.667500e+02 3.817740e+03
+4.667000e+02 3.850680e+03
+4.666500e+02 3.884920e+03
+4.666000e+02 3.920460e+03
+4.665500e+02 3.957410e+03
+4.665000e+02 3.995780e+03
+4.664500e+02 4.035380e+03
+4.664000e+02 4.076210e+03
+4.663500e+02 4.118220e+03
+4.663000e+02 4.161530e+03
+4.662500e+02 4.206020e+03
+4.662000e+02 4.251590e+03
+4.661500e+02 4.298200e+03
+4.661000e+02 4.346190e+03
+4.660500e+02 4.395270e+03
+4.660000e+02 4.445240e+03
+4.659500e+02 4.496010e+03
+4.659000e+02 4.547510e+03
+4.658500e+02 4.599650e+03
+4.658000e+02 4.651630e+03
+4.657500e+02 4.704830e+03
+4.657000e+02 4.758520e+03
+4.656500e+02 4.813160e+03
+4.656000e+02 4.868010e+03
+4.655500e+02 4.923030e+03
+4.655000e+02 4.978030e+03
+4.654500e+02 5.032970e+03
+4.654000e+02 5.087710e+03
+4.653500e+02 5.142110e+03
+4.653000e+02 5.196100e+03
+4.652500e+02 5.249770e+03
+4.652000e+02 5.303310e+03
+4.651500e+02 5.356040e+03
+4.651000e+02 5.407820e+03
+4.650500e+02 5.458610e+03
+4.650000e+02 5.508130e+03
+4.649500e+02 5.556410e+03
+4.649000e+02 5.603240e+03
+4.648500e+02 5.648510e+03
+4.648000e+02 5.692750e+03
+4.647500e+02 5.735410e+03
+4.647000e+02 5.776080e+03
+4.646500e+02 5.814660e+03
+4.646000e+02 5.851070e+03
+4.645500e+02 5.885270e+03
+4.645000e+02 5.916990e+03
+4.644500e+02 5.946310e+03
+4.644000e+02 5.973000e+03
+4.643500e+02 5.997950e+03
+4.643000e+02 6.020280e+03
+4.642500e+02 6.039670e+03
+4.642000e+02 6.056290e+03
+4.641500e+02 6.069860e+03
+4.641000e+02 6.080450e+03
+4.640500e+02 6.087810e+03
+4.640000e+02 6.091920e+03
+4.639500e+02 6.093250e+03
+4.639000e+02 6.092130e+03
+4.638500e+02 6.087920e+03
+4.638000e+02 6.080600e+03
+4.637500e+02 6.070030e+03
+4.637000e+02 6.056480e+03
+4.636500e+02 6.039720e+03
+4.636000e+02 6.019980e+03
+4.635500e+02 5.997270e+03
+4.635000e+02 5.972050e+03
+4.634500e+02 5.944620e+03
+4.634000e+02 5.914080e+03
+4.633500e+02 5.880870e+03
+4.633000e+02 5.845080e+03
+4.632500e+02 5.806760e+03
+4.632000e+02 5.766230e+03
+4.631500e+02 5.723320e+03
+4.631000e+02 5.678440e+03
+4.630500e+02 5.632410e+03
+4.630000e+02 5.584790e+03
+4.629500e+02 5.535690e+03
+4.629000e+02 5.484990e+03
+4.628500e+02 5.433150e+03
+4.628000e+02 5.380230e+03
+4.627500e+02 5.326340e+03
+4.627000e+02 5.271830e+03
+4.626500e+02 5.216770e+03
+4.626000e+02 5.162510e+03
+4.625500e+02 5.108200e+03
+4.625000e+02 5.054090e+03
+4.624500e+02 5.000490e+03
+4.624000e+02 4.947420e+03
+4.623500e+02 4.895340e+03
+4.623000e+02 4.844330e+03
+4.622500e+02 4.794670e+03
+4.622000e+02 4.746970e+03
+4.621500e+02 4.701600e+03
+4.621000e+02 4.658340e+03
+4.620500e+02 4.617330e+03
+4.620000e+02 4.578850e+03
+4.619500e+02 4.543150e+03
+4.619000e+02 4.510370e+03
+4.618500e+02 4.480830e+03
+4.618000e+02 4.454660e+03
+4.617500e+02 4.432650e+03
+4.617000e+02 4.414770e+03
+4.616500e+02 4.400880e+03
+4.616000e+02 4.391180e+03
+4.615500e+02 4.385830e+03
+4.615000e+02 4.385020e+03
+4.614500e+02 4.388870e+03
+4.614000e+02 4.397650e+03
+4.613500e+02 4.411380e+03
+4.613000e+02 4.430930e+03
+4.612500e+02 4.455730e+03
+4.612000e+02 4.485790e+03
+4.611500e+02 4.521230e+03
+4.611000e+02 4.562050e+03
+4.610500e+02 4.608350e+03
+4.610000e+02 4.660110e+03
+4.609500e+02 4.717330e+03
+4.609000e+02 4.780210e+03
+4.608500e+02 4.849050e+03
+4.608000e+02 4.923350e+03
+4.607500e+02 5.003010e+03
+4.607000e+02 5.087930e+03
+4.606500e+02 5.178010e+03
+4.606000e+02 5.273000e+03
+4.605500e+02 5.372920e+03
+4.605000e+02 5.477430e+03
+4.604500e+02 5.586720e+03
+4.604000e+02 5.700640e+03
+4.603500e+02 5.818490e+03
+4.603000e+02 5.940200e+03
+4.602500e+02 6.065310e+03
+4.602000e+02 6.193610e+03
+4.601500e+02 6.324810e+03
+4.601000e+02 6.458480e+03
+4.600500e+02 6.594510e+03
+4.600000e+02 6.732710e+03
+4.599500e+02 6.872490e+03
+4.599000e+02 7.013320e+03
+4.598500e+02 7.154680e+03
+4.598000e+02 7.296370e+03
+4.597500e+02 7.437730e+03
+4.597000e+02 7.578440e+03
+4.596500e+02 7.718050e+03
+4.596000e+02 7.856030e+03
+4.595500e+02 7.992590e+03
+4.595000e+02 8.126580e+03
+4.594500e+02 8.257690e+03
+4.594000e+02 8.385440e+03
+4.593500e+02 8.509300e+03
+4.593000e+02 8.628950e+03
+4.592500e+02 8.743800e+03
+4.592000e+02 8.853550e+03
+4.591500e+02 8.957880e+03
+4.591000e+02 9.056520e+03
+4.590500e+02 9.148900e+03
+4.590000e+02 9.234500e+03
+4.589500e+02 9.313100e+03
+4.589000e+02 9.384300e+03
+4.588500e+02 9.447800e+03
+4.588000e+02 9.503410e+03
+4.587500e+02 9.550780e+03
+4.587000e+02 9.590020e+03
+4.586500e+02 9.620760e+03
+4.586000e+02 9.642690e+03
+4.585500e+02 9.655720e+03
+4.585000e+02 9.659650e+03
+4.584500e+02 9.654500e+03
+4.584000e+02 9.640160e+03
+4.583500e+02 9.616610e+03
+4.583000e+02 9.583920e+03
+4.582500e+02 9.542380e+03
+4.582000e+02 9.491870e+03
+4.581500e+02 9.432380e+03
+4.581000e+02 9.364100e+03
+4.580500e+02 9.287190e+03
+4.580000e+02 9.201790e+03
+4.579500e+02 9.108210e+03
+4.579000e+02 9.006600e+03
+4.578500e+02 8.897330e+03
+4.578000e+02 8.780910e+03
+4.577500e+02 8.657330e+03
+4.577000e+02 8.527020e+03
+4.576500e+02 8.390240e+03
+4.576000e+02 8.247410e+03
+4.575500e+02 8.098890e+03
+4.575000e+02 7.945050e+03
+4.574500e+02 7.786370e+03
+4.574000e+02 7.623310e+03
+4.573500e+02 7.456330e+03
+4.573000e+02 7.285730e+03
+4.572500e+02 7.111880e+03
+4.572000e+02 6.935270e+03
+4.571500e+02 6.756280e+03
+4.571000e+02 6.575340e+03
+4.570500e+02 6.392880e+03
+4.570000e+02 6.209280e+03
+4.569500e+02 6.025160e+03
+4.569000e+02 5.840770e+03
+4.568500e+02 5.656430e+03
+4.568000e+02 5.472530e+03
+4.567500e+02 5.289400e+03
+4.567000e+02 5.107420e+03
+4.566500e+02 4.926870e+03
+4.566000e+02 4.748100e+03
+4.565500e+02 4.571380e+03
+4.565000e+02 4.397200e+03
+4.564500e+02 4.225620e+03
+4.564000e+02 4.056860e+03
+4.563500e+02 3.891170e+03
+4.563000e+02 3.728740e+03
+4.562500e+02 3.569740e+03
+4.562000e+02 3.414360e+03
+4.561500e+02 3.262730e+03
+4.561000e+02 3.115040e+03
+4.560500e+02 2.971480e+03
+4.560000e+02 2.832000e+03
+4.559500e+02 2.696690e+03
+4.559000e+02 2.565600e+03
+4.558500e+02 2.438780e+03
+4.558000e+02 2.316250e+03
+4.557500e+02 2.198030e+03
+4.557000e+02 2.084120e+03
+4.556500e+02 1.974590e+03
+4.556000e+02 1.869400e+03
+4.555500e+02 1.768440e+03
+4.555000e+02 1.671650e+03
+4.554500e+02 1.579000e+03
+4.554000e+02 1.490400e+03
+4.553500e+02 1.405790e+03
+4.553000e+02 1.325070e+03
+4.552500e+02 1.248160e+03
+4.552000e+02 1.175090e+03
+4.551500e+02 1.105650e+03
+4.551000e+02 1.039720e+03
+4.550500e+02 9.771940e+02
+4.550000e+02 9.179570e+02
+4.549500e+02 8.618980e+02
+4.549000e+02 8.088970e+02
+4.548500e+02 7.588480e+02
+4.548000e+02 7.116430e+02
+4.547500e+02 6.672530e+02
+4.547000e+02 6.254610e+02
+4.546500e+02 5.861490e+02
+4.546000e+02 5.492120e+02
+4.545500e+02 5.145290e+02
+4.545000e+02 4.819960e+02
+4.544500e+02 4.515040e+02
+4.544000e+02 4.229450e+02
+4.543500e+02 3.962680e+02
+4.543000e+02 3.713780e+02
+4.542500e+02 3.481280e+02
+4.542000e+02 3.264230e+02
+4.541500e+02 3.061710e+02
+4.541000e+02 2.872930e+02
+4.540500e+02 2.696980e+02
+4.540000e+02 2.533120e+02
+4.539500e+02 2.380560e+02
+4.539000e+02 2.239200e+02
+4.538500e+02 2.108000e+02
+4.538000e+02 1.986020e+02
+4.537500e+02 1.872680e+02
+4.537000e+02 1.767360e+02
+4.536500e+02 1.669500e+02
+4.536000e+02 1.578600e+02
+4.535500e+02 1.494130e+02
+4.535000e+02 1.415660e+02
+4.534500e+02 1.343480e+02
+4.534000e+02 1.276420e+02
+4.533500e+02 1.214120e+02
+4.533000e+02 1.156180e+02
+4.532500e+02 1.102310e+02
+4.532000e+02 1.052160e+02
+4.531500e+02 1.005450e+02
+4.531000e+02 9.619140e+01
+4.530500e+02 9.214570e+01
+4.530000e+02 8.841620e+01
+4.529500e+02 8.493170e+01
+4.529000e+02 8.167280e+01
+4.528500e+02 7.862160e+01
+4.528000e+02 7.575910e+01
+4.527500e+02 7.307190e+01
+4.527000e+02 7.054260e+01
+4.526500e+02 6.815850e+01
+4.526000e+02 6.593950e+01
+4.525500e+02 6.386510e+01
+4.525000e+02 6.190270e+01
+4.524500e+02 6.004020e+01
+4.524000e+02 5.826980e+01
+4.523500e+02 5.658420e+01
+4.523000e+02 5.497500e+01
+4.522500e+02 5.343910e+01
+4.522000e+02 5.196900e+01
+4.521500e+02 5.060380e+01
+4.521000e+02 4.930590e+01
+4.520500e+02 4.806320e+01
+4.520000e+02 4.687490e+01
+4.519500e+02 4.573510e+01
+4.519000e+02 4.464130e+01
+4.518500e+02 4.358940e+01
+4.518000e+02 4.257440e+01
+4.517500e+02 4.160010e+01
+4.517000e+02 4.069270e+01
+4.516500e+02 3.981320e+01
+4.516000e+02 3.895850e+01
+4.515500e+02 3.812570e+01
+4.515000e+02 3.731420e+01
+4.514500e+02 3.652060e+01
+4.514000e+02 3.574460e+01
+4.513500e+02 3.498410e+01
+4.513000e+02 3.425310e+01
+4.512500e+02 3.355830e+01
+4.512000e+02 3.287550e+01
+4.511500e+02 3.220490e+01
+4.511000e+02 3.154530e+01
+4.510500e+02 3.089590e+01
+4.510000e+02 3.025710e+01
+4.509500e+02 2.962700e+01
+4.509000e+02 2.927770e+01
+4.508500e+02 2.867640e+01
+4.508000e+02 2.808850e+01
+4.507500e+02 2.750430e+01
+4.507000e+02 2.692270e+01
+4.506500e+02 2.634490e+01
+4.506000e+02 2.576990e+01
+4.505500e+02 2.519780e+01
+4.505000e+02 2.462910e+01
+4.504500e+02 2.406290e+01
+4.504000e+02 2.356400e+01
+4.503500e+02 2.309800e+01
+4.503000e+02 2.263470e+01
+4.502500e+02 2.217450e+01
+4.502000e+02 2.171650e+01
+4.501500e+02 2.126180e+01
+4.501000e+02 2.080930e+01
+4.500500e+02 2.035940e+01
+4.500000e+02 1.991860e+01
+4.499500e+02 1.949830e+01
+4.499000e+02 1.908090e+01
+4.498500e+02 1.866550e+01
+4.498000e+02 1.825240e+01
+4.497500e+02 1.784180e+01
+4.497000e+02 1.743310e+01
+4.496500e+02 1.702710e+01
+4.496000e+02 1.662290e+01
+4.495500e+02 1.623260e+01
+4.495000e+02 1.585460e+01
+4.494500e+02 1.547840e+01
+4.494000e+02 1.512070e+01
+4.493500e+02 1.477270e+01
+4.493000e+02 1.442680e+01
+4.492500e+02 1.408290e+01
+4.492000e+02 1.374060e+01
+4.491500e+02 1.340050e+01
+4.491000e+02 1.307770e+01
+4.490500e+02 1.276010e+01
+4.490000e+02 1.244440e+01
+4.489500e+02 1.213010e+01
+4.489000e+02 1.181790e+01
+4.488500e+02 1.150720e+01
+4.488000e+02 1.119830e+01
+4.487500e+02 1.089100e+01
+4.487000e+02 1.058690e+01
+4.486500e+02 1.029960e+01
+4.486000e+02 1.001370e+01
+4.485500e+02 9.729410e+00
+4.485000e+02 9.446580e+00
+4.484500e+02 9.165110e+00
+4.484000e+02 8.894000e+00
+4.483500e+02 8.626570e+00
+4.483000e+02 8.360720e+00
+4.482500e+02 8.101930e+00
+4.482000e+02 7.853430e+00
+4.481500e+02 7.606530e+00
+4.481000e+02 7.360730e+00
+4.480500e+02 7.116420e+00
+4.480000e+02 6.873300e+00
+4.479500e+02 6.631380e+00
+4.479000e+02 6.390850e+00
+4.478500e+02 6.151340e+00
+4.478000e+02 5.921980e+00
+4.477500e+02 5.697960e+00
+4.477000e+02 5.475080e+00
+4.476500e+02 5.253470e+00
+4.476000e+02 5.032800e+00
+4.475500e+02 4.981390e+00
+4.475000e+02 4.761870e+00
+4.474500e+02 4.542730e+00
+4.474000e+02 4.329250e+00
+4.473500e+02 4.127570e+00
+4.473000e+02 3.926980e+00
+4.472500e+02 0.000000e+00
+4.472000e+02 0.000000e+00
+4.471500e+02 0.000000e+00
+4.471000e+02 0.000000e+00
+4.470500e+02 0.000000e+00
+4.470000e+02 0.000000e+00
+4.469500e+02 0.000000e+00
+4.469000e+02 0.000000e+00
+4.468500e+02 0.000000e+00
+4.468000e+02 0.000000e+00
+4.467500e+02 0.000000e+00
+4.467000e+02 0.000000e+00
+4.466500e+02 0.000000e+00
+4.466000e+02 0.000000e+00
+4.465500e+02 0.000000e+00
+4.465000e+02 0.000000e+00
+4.464500e+02 0.000000e+00
+4.464000e+02 0.000000e+00
+4.463500e+02 0.000000e+00
+4.463000e+02 0.000000e+00
+4.462500e+02 0.000000e+00
+4.462000e+02 0.000000e+00
\ No newline at end of file