diff --git a/.gitattributes b/.gitattributes index 0fba370e10a89bcbb77d41042cfb5dd2436a1d8a..002eab79c3cba4da6726940faebec002c5891c1e 100644 --- a/.gitattributes +++ b/.gitattributes @@ -501,3 +501,6 @@ material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space: material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected_4Classes/1908270_cm.tif filter=lfs diff=lfs merge=lfs -text material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/h5py.libs/libhdf5_hl-a45b8ce6.so.310.0.6 filter=lfs diff=lfs merge=lfs -text material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/_wrappers.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +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 diff --git a/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_Manual_4connected/1908308_m.tif b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_Manual_4connected/1908308_m.tif new file mode 100644 index 0000000000000000000000000000000000000000..ff04eb20a089e1636dd60ca05dc9019391867402 --- /dev/null +++ b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_Manual_4connected/1908308_m.tif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6a77689878b3eb462bb3a88eb3ffa063c5b8d837e1c156e4d269826245b95f29 +size 787398 diff --git a/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_Manual_4connected_4Classes/1908250_cm.tif b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_Manual_4connected_4Classes/1908250_cm.tif new file mode 100644 index 0000000000000000000000000000000000000000..aafd245baef5ef1ddfaaf066a8dcbb05667c955b --- /dev/null +++ b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_Manual_4connected_4Classes/1908250_cm.tif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:59e23a55661ad78c0f755653fb1e4c5205089f829d0463594b7e6e30fca6ba02 +size 2162842 diff --git a/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_TSEM/Image_Registration/Output/1908272/1908272.tif b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_TSEM/Image_Registration/Output/1908272/1908272.tif new file mode 100644 index 0000000000000000000000000000000000000000..c6d4a099254781de00eb5024f23601a13142381a --- /dev/null +++ b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_TSEM/Image_Registration/Output/1908272/1908272.tif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:58e470217e9e835e5ed01bdda356c4ffea31b06da6a3090c58a9c3d40f6b4811 +size 739375 diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/__pycache__/filters.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/__pycache__/filters.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4133e7937cb6a4e72f93aecfb5c6a783866f221e Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/__pycache__/filters.cpython-310.pyc differ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_cmp.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_cmp.py new file mode 100644 index 0000000000000000000000000000000000000000..09bab491f83ef4d15129f34b5f5a9e69bb34d63c --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_cmp.py @@ -0,0 +1,160 @@ +# SPDX-License-Identifier: MIT + + +import functools +import types + +from ._make import __ne__ + + +_operation_names = {"eq": "==", "lt": "<", "le": "<=", "gt": ">", "ge": ">="} + + +def cmp_using( + eq=None, + lt=None, + le=None, + gt=None, + ge=None, + require_same_type=True, + class_name="Comparable", +): + """ + Create a class that can be passed into `attrs.field`'s ``eq``, ``order``, + and ``cmp`` arguments to customize field comparison. + + The resulting class will have a full set of ordering methods if at least + one of ``{lt, le, gt, ge}`` and ``eq`` are provided. + + Args: + eq (typing.Callable | None): + Callable used to evaluate equality of two objects. + + lt (typing.Callable | None): + Callable used to evaluate whether one object is less than another + object. + + le (typing.Callable | None): + Callable used to evaluate whether one object is less than or equal + to another object. + + gt (typing.Callable | None): + Callable used to evaluate whether one object is greater than + another object. + + ge (typing.Callable | None): + Callable used to evaluate whether one object is greater than or + equal to another object. + + require_same_type (bool): + When `True`, equality and ordering methods will return + `NotImplemented` if objects are not of the same type. + + class_name (str | None): Name of class. Defaults to "Comparable". + + See `comparison` for more details. + + .. versionadded:: 21.1.0 + """ + + body = { + "__slots__": ["value"], + "__init__": _make_init(), + "_requirements": [], + "_is_comparable_to": _is_comparable_to, + } + + # Add operations. + num_order_functions = 0 + has_eq_function = False + + if eq is not None: + has_eq_function = True + body["__eq__"] = _make_operator("eq", eq) + body["__ne__"] = __ne__ + + if lt is not None: + num_order_functions += 1 + body["__lt__"] = _make_operator("lt", lt) + + if le is not None: + num_order_functions += 1 + body["__le__"] = _make_operator("le", le) + + if gt is not None: + num_order_functions += 1 + body["__gt__"] = _make_operator("gt", gt) + + if ge is not None: + num_order_functions += 1 + body["__ge__"] = _make_operator("ge", ge) + + type_ = types.new_class( + class_name, (object,), {}, lambda ns: ns.update(body) + ) + + # Add same type requirement. + if require_same_type: + type_._requirements.append(_check_same_type) + + # Add total ordering if at least one operation was defined. + if 0 < num_order_functions < 4: + if not has_eq_function: + # functools.total_ordering requires __eq__ to be defined, + # so raise early error here to keep a nice stack. + msg = "eq must be define is order to complete ordering from lt, le, gt, ge." + raise ValueError(msg) + type_ = functools.total_ordering(type_) + + return type_ + + +def _make_init(): + """ + Create __init__ method. + """ + + def __init__(self, value): + """ + Initialize object with *value*. + """ + self.value = value + + return __init__ + + +def _make_operator(name, func): + """ + Create operator method. + """ + + def method(self, other): + if not self._is_comparable_to(other): + return NotImplemented + + result = func(self.value, other.value) + if result is NotImplemented: + return NotImplemented + + return result + + method.__name__ = f"__{name}__" + method.__doc__ = ( + f"Return a {_operation_names[name]} b. Computed by attrs." + ) + + return method + + +def _is_comparable_to(self, other): + """ + Check whether `other` is comparable to `self`. + """ + return all(func(self, other) for func in self._requirements) + + +def _check_same_type(self, other): + """ + Return True if *self* and *other* are of the same type, False otherwise. + """ + return other.value.__class__ is self.value.__class__ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_cmp.pyi b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_cmp.pyi new file mode 100644 index 0000000000000000000000000000000000000000..cc7893b04520afa719b1412c7646c3c1b39bf94b --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_cmp.pyi @@ -0,0 +1,13 @@ +from typing import Any, Callable + +_CompareWithType = Callable[[Any, Any], bool] + +def cmp_using( + eq: _CompareWithType | None = ..., + lt: _CompareWithType | None = ..., + le: _CompareWithType | None = ..., + gt: _CompareWithType | None = ..., + ge: _CompareWithType | None = ..., + require_same_type: bool = ..., + class_name: str = ..., +) -> type: ... diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_config.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_config.py new file mode 100644 index 0000000000000000000000000000000000000000..4b257726fb1e8b95583ecc3eee8d153336dc4089 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_config.py @@ -0,0 +1,31 @@ +# SPDX-License-Identifier: MIT + +__all__ = ["get_run_validators", "set_run_validators"] + +_run_validators = True + + +def set_run_validators(run): + """ + Set whether or not validators are run. By default, they are run. + + .. deprecated:: 21.3.0 It will not be removed, but it also will not be + moved to new ``attrs`` namespace. Use `attrs.validators.set_disabled()` + instead. + """ + if not isinstance(run, bool): + msg = "'run' must be bool." + raise TypeError(msg) + global _run_validators + _run_validators = run + + +def get_run_validators(): + """ + Return whether or not validators are run. + + .. deprecated:: 21.3.0 It will not be removed, but it also will not be + moved to new ``attrs`` namespace. Use `attrs.validators.get_disabled()` + instead. + """ + return _run_validators diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_next_gen.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_next_gen.py new file mode 100644 index 0000000000000000000000000000000000000000..9290664b2dca9285855a4c4c38bb09ca9e616f69 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_next_gen.py @@ -0,0 +1,623 @@ +# SPDX-License-Identifier: MIT + +""" +These are keyword-only APIs that call `attr.s` and `attr.ib` with different +default values. +""" + +from functools import partial + +from . import setters +from ._funcs import asdict as _asdict +from ._funcs import astuple as _astuple +from ._make import ( + _DEFAULT_ON_SETATTR, + NOTHING, + _frozen_setattrs, + attrib, + attrs, +) +from .exceptions import UnannotatedAttributeError + + +def define( + maybe_cls=None, + *, + these=None, + repr=None, + unsafe_hash=None, + hash=None, + init=None, + slots=True, + frozen=False, + weakref_slot=True, + str=False, + auto_attribs=None, + kw_only=False, + cache_hash=False, + auto_exc=True, + eq=None, + order=False, + auto_detect=True, + getstate_setstate=None, + on_setattr=None, + field_transformer=None, + match_args=True, +): + r""" + A class decorator that adds :term:`dunder methods` according to + :term:`fields ` specified using :doc:`type annotations `, + `field()` calls, or the *these* argument. + + Since *attrs* patches or replaces an existing class, you cannot use + `object.__init_subclass__` with *attrs* classes, because it runs too early. + As a replacement, you can define ``__attrs_init_subclass__`` on your class. + It will be called by *attrs* classes that subclass it after they're + created. See also :ref:`init-subclass`. + + Args: + slots (bool): + Create a :term:`slotted class ` that's more + memory-efficient. Slotted classes are generally superior to the + default dict classes, but have some gotchas you should know about, + so we encourage you to read the :term:`glossary entry `. + + auto_detect (bool): + Instead of setting the *init*, *repr*, *eq*, and *hash* arguments + explicitly, assume they are set to True **unless any** of the + involved methods for one of the arguments is implemented in the + *current* class (meaning, it is *not* inherited from some base + class). + + So, for example by implementing ``__eq__`` on a class yourself, + *attrs* will deduce ``eq=False`` and will create *neither* + ``__eq__`` *nor* ``__ne__`` (but Python classes come with a + sensible ``__ne__`` by default, so it *should* be enough to only + implement ``__eq__`` in most cases). + + Passing True or False` to *init*, *repr*, *eq*, or *hash* + overrides whatever *auto_detect* would determine. + + auto_exc (bool): + If the class subclasses `BaseException` (which implicitly includes + any subclass of any exception), the following happens to behave + like a well-behaved Python exception class: + + - the values for *eq*, *order*, and *hash* are ignored and the + instances compare and hash by the instance's ids [#]_ , + - all attributes that are either passed into ``__init__`` or have a + default value are additionally available as a tuple in the + ``args`` attribute, + - the value of *str* is ignored leaving ``__str__`` to base + classes. + + .. [#] + Note that *attrs* will *not* remove existing implementations of + ``__hash__`` or the equality methods. It just won't add own + ones. + + on_setattr (~typing.Callable | list[~typing.Callable] | None | ~typing.Literal[attrs.setters.NO_OP]): + A callable that is run whenever the user attempts to set an + attribute (either by assignment like ``i.x = 42`` or by using + `setattr` like ``setattr(i, "x", 42)``). It receives the same + arguments as validators: the instance, the attribute that is being + modified, and the new value. + + If no exception is raised, the attribute is set to the return value + of the callable. + + If a list of callables is passed, they're automatically wrapped in + an `attrs.setters.pipe`. + + If left None, the default behavior is to run converters and + validators whenever an attribute is set. + + init (bool): + Create a ``__init__`` method that initializes the *attrs* + attributes. Leading underscores are stripped for the argument name, + unless an alias is set on the attribute. + + .. seealso:: + `init` shows advanced ways to customize the generated + ``__init__`` method, including executing code before and after. + + repr(bool): + Create a ``__repr__`` method with a human readable representation + of *attrs* attributes. + + str (bool): + Create a ``__str__`` method that is identical to ``__repr__``. This + is usually not necessary except for `Exception`\ s. + + eq (bool | None): + If True or None (default), add ``__eq__`` and ``__ne__`` methods + that check two instances for equality. + + .. seealso:: + `comparison` describes how to customize the comparison behavior + going as far comparing NumPy arrays. + + order (bool | None): + If True, add ``__lt__``, ``__le__``, ``__gt__``, and ``__ge__`` + methods that behave like *eq* above and allow instances to be + ordered. + + They compare the instances as if they were tuples of their *attrs* + attributes if and only if the types of both classes are + *identical*. + + If `None` mirror value of *eq*. + + .. seealso:: `comparison` + + unsafe_hash (bool | None): + If None (default), the ``__hash__`` method is generated according + how *eq* and *frozen* are set. + + 1. If *both* are True, *attrs* will generate a ``__hash__`` for + you. + 2. If *eq* is True and *frozen* is False, ``__hash__`` will be set + to None, marking it unhashable (which it is). + 3. If *eq* is False, ``__hash__`` will be left untouched meaning + the ``__hash__`` method of the base class will be used. If the + base class is `object`, this means it will fall back to id-based + hashing. + + Although not recommended, you can decide for yourself and force + *attrs* to create one (for example, if the class is immutable even + though you didn't freeze it programmatically) by passing True or + not. Both of these cases are rather special and should be used + carefully. + + .. seealso:: + + - Our documentation on `hashing`, + - Python's documentation on `object.__hash__`, + - and the `GitHub issue that led to the default \ behavior + `_ for more + details. + + hash (bool | None): + Deprecated alias for *unsafe_hash*. *unsafe_hash* takes precedence. + + cache_hash (bool): + Ensure that the object's hash code is computed only once and stored + on the object. If this is set to True, hashing must be either + explicitly or implicitly enabled for this class. If the hash code + is cached, avoid any reassignments of fields involved in hash code + computation or mutations of the objects those fields point to after + object creation. If such changes occur, the behavior of the + object's hash code is undefined. + + frozen (bool): + Make instances immutable after initialization. If someone attempts + to modify a frozen instance, `attrs.exceptions.FrozenInstanceError` + is raised. + + .. note:: + + 1. This is achieved by installing a custom ``__setattr__`` + method on your class, so you can't implement your own. + + 2. True immutability is impossible in Python. + + 3. This *does* have a minor a runtime performance `impact + ` when initializing new instances. In other + words: ``__init__`` is slightly slower with ``frozen=True``. + + 4. If a class is frozen, you cannot modify ``self`` in + ``__attrs_post_init__`` or a self-written ``__init__``. You + can circumvent that limitation by using + ``object.__setattr__(self, "attribute_name", value)``. + + 5. Subclasses of a frozen class are frozen too. + + kw_only (bool): + Make all attributes keyword-only in the generated ``__init__`` (if + *init* is False, this parameter is ignored). + + weakref_slot (bool): + Make instances weak-referenceable. This has no effect unless + *slots* is True. + + field_transformer (~typing.Callable | None): + A function that is called with the original class object and all + fields right before *attrs* finalizes the class. You can use this, + for example, to automatically add converters or validators to + fields based on their types. + + .. seealso:: `transform-fields` + + match_args (bool): + If True (default), set ``__match_args__`` on the class to support + :pep:`634` (*Structural Pattern Matching*). It is a tuple of all + non-keyword-only ``__init__`` parameter names on Python 3.10 and + later. Ignored on older Python versions. + + collect_by_mro (bool): + If True, *attrs* collects attributes from base classes correctly + according to the `method resolution order + `_. If False, *attrs* + will mimic the (wrong) behavior of `dataclasses` and :pep:`681`. + + See also `issue #428 + `_. + + getstate_setstate (bool | None): + .. note:: + + This is usually only interesting for slotted classes and you + should probably just set *auto_detect* to True. + + If True, ``__getstate__`` and ``__setstate__`` are generated and + attached to the class. This is necessary for slotted classes to be + pickleable. If left None, it's True by default for slotted classes + and False for dict classes. + + If *auto_detect* is True, and *getstate_setstate* is left None, and + **either** ``__getstate__`` or ``__setstate__`` is detected + directly on the class (meaning: not inherited), it is set to False + (this is usually what you want). + + auto_attribs (bool | None): + If True, look at type annotations to determine which attributes to + use, like `dataclasses`. If False, it will only look for explicit + :func:`field` class attributes, like classic *attrs*. + + If left None, it will guess: + + 1. If any attributes are annotated and no unannotated + `attrs.field`\ s are found, it assumes *auto_attribs=True*. + 2. Otherwise it assumes *auto_attribs=False* and tries to collect + `attrs.field`\ s. + + If *attrs* decides to look at type annotations, **all** fields + **must** be annotated. If *attrs* encounters a field that is set to + a :func:`field` / `attr.ib` but lacks a type annotation, an + `attrs.exceptions.UnannotatedAttributeError` is raised. Use + ``field_name: typing.Any = field(...)`` if you don't want to set a + type. + + .. warning:: + + For features that use the attribute name to create decorators + (for example, :ref:`validators `), you still *must* + assign :func:`field` / `attr.ib` to them. Otherwise Python will + either not find the name or try to use the default value to + call, for example, ``validator`` on it. + + Attributes annotated as `typing.ClassVar`, and attributes that are + neither annotated nor set to an `field()` are **ignored**. + + these (dict[str, object]): + A dictionary of name to the (private) return value of `field()` + mappings. This is useful to avoid the definition of your attributes + within the class body because you can't (for example, if you want + to add ``__repr__`` methods to Django models) or don't want to. + + If *these* is not `None`, *attrs* will *not* search the class body + for attributes and will *not* remove any attributes from it. + + The order is deduced from the order of the attributes inside + *these*. + + Arguably, this is a rather obscure feature. + + .. versionadded:: 20.1.0 + .. versionchanged:: 21.3.0 Converters are also run ``on_setattr``. + .. versionadded:: 22.2.0 + *unsafe_hash* as an alias for *hash* (for :pep:`681` compliance). + .. versionchanged:: 24.1.0 + Instances are not compared as tuples of attributes anymore, but using a + big ``and`` condition. This is faster and has more correct behavior for + uncomparable values like `math.nan`. + .. versionadded:: 24.1.0 + If a class has an *inherited* classmethod called + ``__attrs_init_subclass__``, it is executed after the class is created. + .. deprecated:: 24.1.0 *hash* is deprecated in favor of *unsafe_hash*. + .. versionadded:: 24.3.0 + Unless already present, a ``__replace__`` method is automatically + created for `copy.replace` (Python 3.13+ only). + + .. note:: + + The main differences to the classic `attr.s` are: + + - Automatically detect whether or not *auto_attribs* should be `True` + (c.f. *auto_attribs* parameter). + - Converters and validators run when attributes are set by default -- + if *frozen* is `False`. + - *slots=True* + + Usually, this has only upsides and few visible effects in everyday + programming. But it *can* lead to some surprising behaviors, so + please make sure to read :term:`slotted classes`. + + - *auto_exc=True* + - *auto_detect=True* + - *order=False* + - Some options that were only relevant on Python 2 or were kept around + for backwards-compatibility have been removed. + + """ + + def do_it(cls, auto_attribs): + return attrs( + maybe_cls=cls, + these=these, + repr=repr, + hash=hash, + unsafe_hash=unsafe_hash, + init=init, + slots=slots, + frozen=frozen, + weakref_slot=weakref_slot, + str=str, + auto_attribs=auto_attribs, + kw_only=kw_only, + cache_hash=cache_hash, + auto_exc=auto_exc, + eq=eq, + order=order, + auto_detect=auto_detect, + collect_by_mro=True, + getstate_setstate=getstate_setstate, + on_setattr=on_setattr, + field_transformer=field_transformer, + match_args=match_args, + ) + + def wrap(cls): + """ + Making this a wrapper ensures this code runs during class creation. + + We also ensure that frozen-ness of classes is inherited. + """ + nonlocal frozen, on_setattr + + had_on_setattr = on_setattr not in (None, setters.NO_OP) + + # By default, mutable classes convert & validate on setattr. + if frozen is False and on_setattr is None: + on_setattr = _DEFAULT_ON_SETATTR + + # However, if we subclass a frozen class, we inherit the immutability + # and disable on_setattr. + for base_cls in cls.__bases__: + if base_cls.__setattr__ is _frozen_setattrs: + if had_on_setattr: + msg = "Frozen classes can't use on_setattr (frozen-ness was inherited)." + raise ValueError(msg) + + on_setattr = setters.NO_OP + break + + if auto_attribs is not None: + return do_it(cls, auto_attribs) + + try: + return do_it(cls, True) + except UnannotatedAttributeError: + return do_it(cls, False) + + # maybe_cls's type depends on the usage of the decorator. It's a class + # if it's used as `@attrs` but `None` if used as `@attrs()`. + if maybe_cls is None: + return wrap + + return wrap(maybe_cls) + + +mutable = define +frozen = partial(define, frozen=True, on_setattr=None) + + +def field( + *, + default=NOTHING, + validator=None, + repr=True, + hash=None, + init=True, + metadata=None, + type=None, + converter=None, + factory=None, + kw_only=False, + eq=None, + order=None, + on_setattr=None, + alias=None, +): + """ + Create a new :term:`field` / :term:`attribute` on a class. + + .. warning:: + + Does **nothing** unless the class is also decorated with + `attrs.define` (or similar)! + + Args: + default: + A value that is used if an *attrs*-generated ``__init__`` is used + and no value is passed while instantiating or the attribute is + excluded using ``init=False``. + + If the value is an instance of `attrs.Factory`, its callable will + be used to construct a new value (useful for mutable data types + like lists or dicts). + + If a default is not set (or set manually to `attrs.NOTHING`), a + value *must* be supplied when instantiating; otherwise a + `TypeError` will be raised. + + .. seealso:: `defaults` + + factory (~typing.Callable): + Syntactic sugar for ``default=attr.Factory(factory)``. + + validator (~typing.Callable | list[~typing.Callable]): + Callable that is called by *attrs*-generated ``__init__`` methods + after the instance has been initialized. They receive the + initialized instance, the :func:`~attrs.Attribute`, and the passed + value. + + The return value is *not* inspected so the validator has to throw + an exception itself. + + If a `list` is passed, its items are treated as validators and must + all pass. + + Validators can be globally disabled and re-enabled using + `attrs.validators.get_disabled` / `attrs.validators.set_disabled`. + + The validator can also be set using decorator notation as shown + below. + + .. seealso:: :ref:`validators` + + repr (bool | ~typing.Callable): + Include this attribute in the generated ``__repr__`` method. If + True, include the attribute; if False, omit it. By default, the + built-in ``repr()`` function is used. To override how the attribute + value is formatted, pass a ``callable`` that takes a single value + and returns a string. Note that the resulting string is used as-is, + which means it will be used directly *instead* of calling + ``repr()`` (the default). + + eq (bool | ~typing.Callable): + If True (default), include this attribute in the generated + ``__eq__`` and ``__ne__`` methods that check two instances for + equality. To override how the attribute value is compared, pass a + callable that takes a single value and returns the value to be + compared. + + .. seealso:: `comparison` + + order (bool | ~typing.Callable): + If True (default), include this attributes in the generated + ``__lt__``, ``__le__``, ``__gt__`` and ``__ge__`` methods. To + override how the attribute value is ordered, pass a callable that + takes a single value and returns the value to be ordered. + + .. seealso:: `comparison` + + hash (bool | None): + Include this attribute in the generated ``__hash__`` method. If + None (default), mirror *eq*'s value. This is the correct behavior + according the Python spec. Setting this value to anything else + than None is *discouraged*. + + .. seealso:: `hashing` + + init (bool): + Include this attribute in the generated ``__init__`` method. + + It is possible to set this to False and set a default value. In + that case this attributed is unconditionally initialized with the + specified default value or factory. + + .. seealso:: `init` + + converter (typing.Callable | Converter): + A callable that is called by *attrs*-generated ``__init__`` methods + to convert attribute's value to the desired format. + + If a vanilla callable is passed, it is given the passed-in value as + the only positional argument. It is possible to receive additional + arguments by wrapping the callable in a `Converter`. + + Either way, the returned value will be used as the new value of the + attribute. The value is converted before being passed to the + validator, if any. + + .. seealso:: :ref:`converters` + + metadata (dict | None): + An arbitrary mapping, to be used by third-party code. + + .. seealso:: `extending-metadata`. + + type (type): + The type of the attribute. Nowadays, the preferred method to + specify the type is using a variable annotation (see :pep:`526`). + This argument is provided for backwards-compatibility and for usage + with `make_class`. Regardless of the approach used, the type will + be stored on ``Attribute.type``. + + Please note that *attrs* doesn't do anything with this metadata by + itself. You can use it as part of your own code or for `static type + checking `. + + kw_only (bool): + Make this attribute keyword-only in the generated ``__init__`` (if + ``init`` is False, this parameter is ignored). + + on_setattr (~typing.Callable | list[~typing.Callable] | None | ~typing.Literal[attrs.setters.NO_OP]): + Allows to overwrite the *on_setattr* setting from `attr.s`. If left + None, the *on_setattr* value from `attr.s` is used. Set to + `attrs.setters.NO_OP` to run **no** `setattr` hooks for this + attribute -- regardless of the setting in `define()`. + + alias (str | None): + Override this attribute's parameter name in the generated + ``__init__`` method. If left None, default to ``name`` stripped + of leading underscores. See `private-attributes`. + + .. versionadded:: 20.1.0 + .. versionchanged:: 21.1.0 + *eq*, *order*, and *cmp* also accept a custom callable + .. versionadded:: 22.2.0 *alias* + .. versionadded:: 23.1.0 + The *type* parameter has been re-added; mostly for `attrs.make_class`. + Please note that type checkers ignore this metadata. + + .. seealso:: + + `attr.ib` + """ + return attrib( + default=default, + validator=validator, + repr=repr, + hash=hash, + init=init, + metadata=metadata, + type=type, + converter=converter, + factory=factory, + kw_only=kw_only, + eq=eq, + order=order, + on_setattr=on_setattr, + alias=alias, + ) + + +def asdict(inst, *, recurse=True, filter=None, value_serializer=None): + """ + Same as `attr.asdict`, except that collections types are always retained + and dict is always used as *dict_factory*. + + .. versionadded:: 21.3.0 + """ + return _asdict( + inst=inst, + recurse=recurse, + filter=filter, + value_serializer=value_serializer, + retain_collection_types=True, + ) + + +def astuple(inst, *, recurse=True, filter=None): + """ + Same as `attr.astuple`, except that collections types are always retained + and `tuple` is always used as the *tuple_factory*. + + .. versionadded:: 21.3.0 + """ + return _astuple( + inst=inst, recurse=recurse, filter=filter, retain_collection_types=True + ) diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_version_info.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_version_info.py new file mode 100644 index 0000000000000000000000000000000000000000..51a1312f9759f21063caea779a62882d7f7c86ae --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/_version_info.py @@ -0,0 +1,86 @@ +# SPDX-License-Identifier: MIT + + +from functools import total_ordering + +from ._funcs import astuple +from ._make import attrib, attrs + + +@total_ordering +@attrs(eq=False, order=False, slots=True, frozen=True) +class VersionInfo: + """ + A version object that can be compared to tuple of length 1--4: + + >>> attr.VersionInfo(19, 1, 0, "final") <= (19, 2) + True + >>> attr.VersionInfo(19, 1, 0, "final") < (19, 1, 1) + True + >>> vi = attr.VersionInfo(19, 2, 0, "final") + >>> vi < (19, 1, 1) + False + >>> vi < (19,) + False + >>> vi == (19, 2,) + True + >>> vi == (19, 2, 1) + False + + .. versionadded:: 19.2 + """ + + year = attrib(type=int) + minor = attrib(type=int) + micro = attrib(type=int) + releaselevel = attrib(type=str) + + @classmethod + def _from_version_string(cls, s): + """ + Parse *s* and return a _VersionInfo. + """ + v = s.split(".") + if len(v) == 3: + v.append("final") + + return cls( + year=int(v[0]), minor=int(v[1]), micro=int(v[2]), releaselevel=v[3] + ) + + def _ensure_tuple(self, other): + """ + Ensure *other* is a tuple of a valid length. + + Returns a possibly transformed *other* and ourselves as a tuple of + the same length as *other*. + """ + + if self.__class__ is other.__class__: + other = astuple(other) + + if not isinstance(other, tuple): + raise NotImplementedError + + if not (1 <= len(other) <= 4): + raise NotImplementedError + + return astuple(self)[: len(other)], other + + def __eq__(self, other): + try: + us, them = self._ensure_tuple(other) + except NotImplementedError: + return NotImplemented + + return us == them + + def __lt__(self, other): + try: + us, them = self._ensure_tuple(other) + except NotImplementedError: + return NotImplemented + + # Since alphabetically "dev0" < "final" < "post1" < "post2", we don't + # have to do anything special with releaselevel for now. + return us < them diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/converters.pyi b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/converters.pyi new file mode 100644 index 0000000000000000000000000000000000000000..12bd0c4f17bdc60fb8904598af0a3d56d5874a9e --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/converters.pyi @@ -0,0 +1,19 @@ +from typing import Callable, Any, overload + +from attrs import _ConverterType, _CallableConverterType + +@overload +def pipe(*validators: _CallableConverterType) -> _CallableConverterType: ... +@overload +def pipe(*validators: _ConverterType) -> _ConverterType: ... +@overload +def optional(converter: _CallableConverterType) -> _CallableConverterType: ... +@overload +def optional(converter: _ConverterType) -> _ConverterType: ... +@overload +def default_if_none(default: Any) -> _CallableConverterType: ... +@overload +def default_if_none( + *, factory: Callable[[], Any] +) -> _CallableConverterType: ... +def to_bool(val: str | int | bool) -> bool: ... diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/setters.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/setters.py new file mode 100644 index 0000000000000000000000000000000000000000..78b08398a6713fc5fa827c2dc853e0d05de743c4 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/setters.py @@ -0,0 +1,79 @@ +# SPDX-License-Identifier: MIT + +""" +Commonly used hooks for on_setattr. +""" + +from . import _config +from .exceptions import FrozenAttributeError + + +def pipe(*setters): + """ + Run all *setters* and return the return value of the last one. + + .. versionadded:: 20.1.0 + """ + + def wrapped_pipe(instance, attrib, new_value): + rv = new_value + + for setter in setters: + rv = setter(instance, attrib, rv) + + return rv + + return wrapped_pipe + + +def frozen(_, __, ___): + """ + Prevent an attribute to be modified. + + .. versionadded:: 20.1.0 + """ + raise FrozenAttributeError + + +def validate(instance, attrib, new_value): + """ + Run *attrib*'s validator on *new_value* if it has one. + + .. versionadded:: 20.1.0 + """ + if _config._run_validators is False: + return new_value + + v = attrib.validator + if not v: + return new_value + + v(instance, attrib, new_value) + + return new_value + + +def convert(instance, attrib, new_value): + """ + Run *attrib*'s converter -- if it has one -- on *new_value* and return the + result. + + .. versionadded:: 20.1.0 + """ + c = attrib.converter + if c: + # This can be removed once we drop 3.8 and use attrs.Converter instead. + from ._make import Converter + + if not isinstance(c, Converter): + return c(new_value) + + return c(new_value, instance, attrib) + + return new_value + + +# Sentinel for disabling class-wide *on_setattr* hooks for certain attributes. +# Sphinx's autodata stopped working, so the docstring is inlined in the API +# docs. +NO_OP = object() diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/setters.pyi b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/setters.pyi new file mode 100644 index 0000000000000000000000000000000000000000..73abf36e7d5b0f5f56e7fddeee716824c1c60d58 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/setters.pyi @@ -0,0 +1,20 @@ +from typing import Any, NewType, NoReturn, TypeVar + +from . import Attribute +from attrs import _OnSetAttrType + +_T = TypeVar("_T") + +def frozen( + instance: Any, attribute: Attribute[Any], new_value: Any +) -> NoReturn: ... +def pipe(*setters: _OnSetAttrType) -> _OnSetAttrType: ... +def validate(instance: Any, attribute: Attribute[_T], new_value: _T) -> _T: ... + +# convert is allowed to return Any, because they can be chained using pipe. +def convert( + instance: Any, attribute: Attribute[Any], new_value: Any +) -> Any: ... + +_NoOpType = NewType("_NoOpType", object) +NO_OP: _NoOpType diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/validators.pyi b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/validators.pyi new file mode 100644 index 0000000000000000000000000000000000000000..a0fdda7c8773f791103938fca0d4b448859aff1f --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attr/validators.pyi @@ -0,0 +1,86 @@ +from types import UnionType +from typing import ( + Any, + AnyStr, + Callable, + Container, + ContextManager, + Iterable, + Mapping, + Match, + Pattern, + TypeVar, + overload, +) + +from attrs import _ValidatorType +from attrs import _ValidatorArgType + +_T = TypeVar("_T") +_T1 = TypeVar("_T1") +_T2 = TypeVar("_T2") +_T3 = TypeVar("_T3") +_I = TypeVar("_I", bound=Iterable) +_K = TypeVar("_K") +_V = TypeVar("_V") +_M = TypeVar("_M", bound=Mapping) + +def set_disabled(run: bool) -> None: ... +def get_disabled() -> bool: ... +def disabled() -> ContextManager[None]: ... + +# To be more precise on instance_of use some overloads. +# If there are more than 3 items in the tuple then we fall back to Any +@overload +def instance_of(type: type[_T]) -> _ValidatorType[_T]: ... +@overload +def instance_of(type: tuple[type[_T]]) -> _ValidatorType[_T]: ... +@overload +def instance_of( + type: tuple[type[_T1], type[_T2]], +) -> _ValidatorType[_T1 | _T2]: ... +@overload +def instance_of( + type: tuple[type[_T1], type[_T2], type[_T3]], +) -> _ValidatorType[_T1 | _T2 | _T3]: ... +@overload +def instance_of(type: tuple[type, ...]) -> _ValidatorType[Any]: ... +@overload +def instance_of(type: UnionType) -> _ValidatorType[Any]: ... +def optional( + validator: ( + _ValidatorType[_T] + | list[_ValidatorType[_T]] + | tuple[_ValidatorType[_T]] + ), +) -> _ValidatorType[_T | None]: ... +def in_(options: Container[_T]) -> _ValidatorType[_T]: ... +def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ... +def matches_re( + regex: Pattern[AnyStr] | AnyStr, + flags: int = ..., + func: Callable[[AnyStr, AnyStr, int], Match[AnyStr] | None] | None = ..., +) -> _ValidatorType[AnyStr]: ... +def deep_iterable( + member_validator: _ValidatorArgType[_T], + iterable_validator: _ValidatorType[_I] | None = ..., +) -> _ValidatorType[_I]: ... +def deep_mapping( + key_validator: _ValidatorType[_K], + value_validator: _ValidatorType[_V], + mapping_validator: _ValidatorType[_M] | None = ..., +) -> _ValidatorType[_M]: ... +def is_callable() -> _ValidatorType[_T]: ... +def lt(val: _T) -> _ValidatorType[_T]: ... +def le(val: _T) -> _ValidatorType[_T]: ... +def ge(val: _T) -> _ValidatorType[_T]: ... +def gt(val: _T) -> _ValidatorType[_T]: ... +def max_len(length: int) -> _ValidatorType[_T]: ... +def min_len(length: int) -> _ValidatorType[_T]: ... +def not_( + validator: _ValidatorType[_T], + *, + msg: str | None = None, + exc_types: type[Exception] | Iterable[type[Exception]] = ..., +) -> _ValidatorType[_T]: ... +def or_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ... diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/INSTALLER b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/LICENSE b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..0e09a3e90900cb576f297c9558916a926312a5df --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/LICENSE @@ -0,0 +1,610 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +----------------------------------------------------------- + +BSD 3-Clause License + +Copyright 2016, Google Inc. + +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. + +----------------------------------------------------------- + +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/METADATA b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..364cd7f5d091dc24b2136ec87a1f3b59135ad2fc --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/METADATA @@ -0,0 +1,129 @@ +Metadata-Version: 2.1 +Name: grpcio +Version: 1.71.0 +Summary: HTTP/2-based RPC framework +Home-page: https://grpc.io +Author: The gRPC Authors +Author-email: grpc-io@googlegroups.com +License: Apache License 2.0 +Project-URL: Source Code, https://github.com/grpc/grpc +Project-URL: Bug Tracker, https://github.com/grpc/grpc/issues +Project-URL: Documentation, https://grpc.github.io/grpc/python +Classifier: Development Status :: 5 - Production/Stable +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: License :: OSI Approved :: Apache Software License +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-File: LICENSE +Provides-Extra: protobuf +Requires-Dist: grpcio-tools >=1.71.0 ; extra == 'protobuf' + +gRPC Python +=========== + +|compat_check_pypi| + +Package for gRPC Python. + +.. |compat_check_pypi| image:: https://python-compatibility-tools.appspot.com/one_badge_image?package=grpcio + :target: https://python-compatibility-tools.appspot.com/one_badge_target?package=grpcio + + +Installation +------------ + +gRPC Python is available for Linux, macOS, and Windows. + +Installing From PyPI +~~~~~~~~~~~~~~~~~~~~ + +If you are installing locally... + +:: + + $ pip install grpcio + +Else system wide (on Ubuntu)... + +:: + + $ sudo pip install grpcio + +If you're on Windows make sure that you installed the :code:`pip.exe` component +when you installed Python (if not go back and install it!) then invoke: + +:: + + $ pip.exe install grpcio + +Windows users may need to invoke :code:`pip.exe` from a command line ran as +administrator. + +n.b. On Windows and on Mac OS X one *must* have a recent release of :code:`pip` +to retrieve the proper wheel from PyPI. Be sure to upgrade to the latest +version! + +Installing From Source +~~~~~~~~~~~~~~~~~~~~~~ + +Building from source requires that you have the Python headers (usually a +package named :code:`python-dev`). + +:: + + $ export REPO_ROOT=grpc # REPO_ROOT can be any directory of your choice + $ git clone -b RELEASE_TAG_HERE https://github.com/grpc/grpc $REPO_ROOT + $ cd $REPO_ROOT + $ git submodule update --init + + # To include systemd socket-activation feature in the build, + # first install the `libsystemd-dev` package, then : + $ export GRPC_PYTHON_BUILD_WITH_SYSTEMD=1 + + # For the next two commands do `sudo pip install` if you get permission-denied errors + $ pip install -r requirements.txt + $ GRPC_PYTHON_BUILD_WITH_CYTHON=1 pip install . + +You cannot currently install Python from source on Windows. Things might work +out for you in MSYS2 (follow the Linux instructions), but it isn't officially +supported at the moment. + +Troubleshooting +~~~~~~~~~~~~~~~ + +Help, I ... + +* **... see the following error on some platforms** + + :: + + /tmp/pip-build-U8pSsr/cython/Cython/Plex/Scanners.c:4:20: fatal error: Python.h: No such file or directory + #include "Python.h" + ^ + compilation terminated. + + You can fix it by installing `python-dev` package. i.e + + :: + + sudo apt-get install python-dev + + +Versioning +~~~~~~~~~~ + +gRPC Python is developed in a monorepo shared with implementations of gRPC in +other programming languages. While the minor versions are released in +lock-step with other languages in the repo (e.g. 1.63.0 is guaranteed to exist +for all languages), patch versions may be specific to only a single +language. For example, if 1.63.1 is a C++-specific patch, 1.63.1 may not be +uploaded to PyPi. As a result, it is __not__ a good assumption that the latest +patch for a given minor version on Github is also the latest patch for that +same minor version on PyPi. + diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/RECORD b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..314b85364c11a66be0e9c05e3b53a1decb41e37e --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/RECORD @@ -0,0 +1,120 @@ +grpc/__init__.py,sha256=RUN1ZIKXNgRqOEaUbqKJP2sDpn7C1wCcompDQsS_UkA,82333 +grpc/__pycache__/__init__.cpython-310.pyc,, +grpc/__pycache__/_auth.cpython-310.pyc,, +grpc/__pycache__/_channel.cpython-310.pyc,, +grpc/__pycache__/_common.cpython-310.pyc,, +grpc/__pycache__/_compression.cpython-310.pyc,, +grpc/__pycache__/_grpcio_metadata.cpython-310.pyc,, +grpc/__pycache__/_interceptor.cpython-310.pyc,, +grpc/__pycache__/_observability.cpython-310.pyc,, +grpc/__pycache__/_plugin_wrapping.cpython-310.pyc,, +grpc/__pycache__/_runtime_protos.cpython-310.pyc,, +grpc/__pycache__/_server.cpython-310.pyc,, +grpc/__pycache__/_simple_stubs.cpython-310.pyc,, +grpc/__pycache__/_typing.cpython-310.pyc,, +grpc/__pycache__/_utilities.cpython-310.pyc,, +grpc/_auth.py,sha256=UNjlkWE4rTsTZlVzJRpgupTJgEJYop-fpTkgJmvien4,2635 +grpc/_channel.py,sha256=sPVbiPQ5BuDx1rgBPlajXi9XH958XCeGGsKXie08Ttw,81346 +grpc/_common.py,sha256=PQdgX83qEG3BUCfXlQVnrv9t5yFD9wjHhrckvX_UkfA,6784 +grpc/_compression.py,sha256=0P9yfNIn33BmcQmOdnMUTogbLIPR0eT_Lmmnm3llcFg,1983 +grpc/_cython/__init__.py,sha256=w3kqSAyaZgP-W0890xR4L4WeBPGrtsQCQJe0FUFR0K0,577 +grpc/_cython/__pycache__/__init__.cpython-310.pyc,, +grpc/_cython/_credentials/roots.pem,sha256=lhQzRMSuEJWIElssQdXa9lSl-vxuI_rDf3uj0p2n53Y,264440 +grpc/_cython/_cygrpc/__init__.py,sha256=w3kqSAyaZgP-W0890xR4L4WeBPGrtsQCQJe0FUFR0K0,577 +grpc/_cython/_cygrpc/__pycache__/__init__.cpython-310.pyc,, +grpc/_cython/cygrpc.cpython-310-x86_64-linux-gnu.so,sha256=fHECq94cyFAodZrdm3ZojlnPWRWnwsnlkGHNC-4tYlQ,13677208 +grpc/_grpcio_metadata.py,sha256=hosqFnNPgE2xb-JI6HqOw66DCXylY7jiEVcaGLejuFQ,26 +grpc/_interceptor.py,sha256=5qiM2lQWabbBd8IeR6VHzTJKmhz7R2_Tf3m5Xp3C6Y0,25862 +grpc/_observability.py,sha256=JVe0NZ1uGNwSAt-oo9_KS6k2eYlcA5P1h1id8BsJImA,10417 +grpc/_plugin_wrapping.py,sha256=sbJLmw0reHc0aBaSQuPuFr9hHnzllEVoDYgrkre7bkk,4382 +grpc/_runtime_protos.py,sha256=2JtQGu0T8NlZn_GfzH_lpmTwVJPE1rkB5X9jcE7UXos,5805 +grpc/_server.py,sha256=VXOqgBjwXURqLTnIA1AaxO3VdxkuAhQSLATgsTkMP8E,50885 +grpc/_simple_stubs.py,sha256=2hK8LsbRdWhG8kT5DR1p0gLNr5Q818XYox8Sv__w0ws,24610 +grpc/_typing.py,sha256=-wdtuGJpvR10J6r4LSUYTDeRCWpMsQTo67HwowaVOCk,2758 +grpc/_utilities.py,sha256=befrEhsHGPfSuVPEMTNEVaQCPwTD8tKV8yIrge7I4Vo,7043 +grpc/aio/__init__.py,sha256=80Ho1FolpueFqIIvyl7d5b9FJgvw5ilZgHcXxN1NmUs,3160 +grpc/aio/__pycache__/__init__.cpython-310.pyc,, +grpc/aio/__pycache__/_base_call.cpython-310.pyc,, +grpc/aio/__pycache__/_base_channel.cpython-310.pyc,, +grpc/aio/__pycache__/_base_server.cpython-310.pyc,, +grpc/aio/__pycache__/_call.cpython-310.pyc,, +grpc/aio/__pycache__/_channel.cpython-310.pyc,, +grpc/aio/__pycache__/_interceptor.cpython-310.pyc,, +grpc/aio/__pycache__/_metadata.cpython-310.pyc,, +grpc/aio/__pycache__/_server.cpython-310.pyc,, +grpc/aio/__pycache__/_typing.cpython-310.pyc,, +grpc/aio/__pycache__/_utils.cpython-310.pyc,, +grpc/aio/_base_call.py,sha256=THFXG0o0ISn40Jrw0sNlcFzfobD8UrjgjddMWtg8ZJA,7560 +grpc/aio/_base_channel.py,sha256=wVwElJ73bfTTkYC9J6NZjCq-q2MEvTOLSbOseNPzr8k,13893 +grpc/aio/_base_server.py,sha256=_bBNGAy6feBwyE4aIuwjKVdCy2wQYpiBOtFg2rXaZ-8,12560 +grpc/aio/_call.py,sha256=N9rbvu8-0B_rV7RthtSlp-nZakDoshHgptOozEuVqtU,25356 +grpc/aio/_channel.py,sha256=J1opppQ_zkyhYTqh0cxo85tX14wdki3qccp1BFSUzd0,22099 +grpc/aio/_interceptor.py,sha256=mXz0ivpOBkbBpMQyxInHmFCqVm1HrYX0GRq4IZwWCFQ,41345 +grpc/aio/_metadata.py,sha256=Bhxf6d8r90FQe-HPEUEOrowfAb-DA_6OfaQejcYJjog,5009 +grpc/aio/_server.py,sha256=_7v2-W92W1Ag1LINrxCED-647nAquGFUKbgGnKN06_s,8931 +grpc/aio/_typing.py,sha256=xMlG33vn_UkdkRv39Udx421BWVgt5RHCu8gJXAQ18do,1378 +grpc/aio/_utils.py,sha256=Bh5-lQO2xszdZeTFAWFfFhhaKy20ll4kucD6f_YZTlg,821 +grpc/beta/__init__.py,sha256=w3kqSAyaZgP-W0890xR4L4WeBPGrtsQCQJe0FUFR0K0,577 +grpc/beta/__pycache__/__init__.cpython-310.pyc,, +grpc/beta/__pycache__/_client_adaptations.cpython-310.pyc,, +grpc/beta/__pycache__/_metadata.cpython-310.pyc,, +grpc/beta/__pycache__/_server_adaptations.cpython-310.pyc,, +grpc/beta/__pycache__/implementations.cpython-310.pyc,, +grpc/beta/__pycache__/interfaces.cpython-310.pyc,, +grpc/beta/__pycache__/utilities.cpython-310.pyc,, +grpc/beta/_client_adaptations.py,sha256=q4rwPyIv9ratLPhC3xmq9M1_fuAVTW71slsBChHP4T0,27023 +grpc/beta/_metadata.py,sha256=pC2-RLU3nHhTXTk_RMyoA3WwmRhm_woLbB-13lKO-aY,1638 +grpc/beta/_server_adaptations.py,sha256=-f_hSbqBZqNgaz55B1zbE7TK-kwc1oHnngXHMDU-kKk,14611 +grpc/beta/implementations.py,sha256=0yITggzqKKo8Lb8ZwPx2zIu414mIQxfan3jmenchIHk,12058 +grpc/beta/interfaces.py,sha256=mtQnvm7Bg2u5MQZf2_nmxUxKFCANDw7VUOHHvE7cBhM,6082 +grpc/beta/utilities.py,sha256=h_2yPH_5sCsFWKr9bBfa-JXj0CnSFaSa-_snKqtUUTo,5005 +grpc/experimental/__init__.py,sha256=uUcQbntsX9ROKozWD6eTVnAYJ6Dea7VUSpGGv1L5Hz0,4103 +grpc/experimental/__pycache__/__init__.cpython-310.pyc,, +grpc/experimental/__pycache__/gevent.cpython-310.pyc,, +grpc/experimental/__pycache__/session_cache.cpython-310.pyc,, +grpc/experimental/aio/__init__.py,sha256=bIyDdGBbNHi5F_kHvwByONjc4M_74thy53YmBDr1ZPo,660 +grpc/experimental/aio/__pycache__/__init__.cpython-310.pyc,, +grpc/experimental/gevent.py,sha256=_YAk9aH2PCZCpaCnW9uGY77W21342dEWm8wOVApTx88,973 +grpc/experimental/session_cache.py,sha256=wAauvDzxvTC6-p3jMbPnTc7y74nhDKSRjb0ktfMPCm8,1533 +grpc/framework/__init__.py,sha256=w3kqSAyaZgP-W0890xR4L4WeBPGrtsQCQJe0FUFR0K0,577 +grpc/framework/__pycache__/__init__.cpython-310.pyc,, +grpc/framework/common/__init__.py,sha256=w3kqSAyaZgP-W0890xR4L4WeBPGrtsQCQJe0FUFR0K0,577 +grpc/framework/common/__pycache__/__init__.cpython-310.pyc,, +grpc/framework/common/__pycache__/cardinality.cpython-310.pyc,, +grpc/framework/common/__pycache__/style.cpython-310.pyc,, +grpc/framework/common/cardinality.py,sha256=ygWtrjjsk-SOPLHaey6-7ekD23Qhu3k4QUNmYI1ScVU,988 +grpc/framework/common/style.py,sha256=X9wN-af8T7WWhFfdtmFkdqPN5PbpI8FJsKGdmPivaAU,824 +grpc/framework/foundation/__init__.py,sha256=w3kqSAyaZgP-W0890xR4L4WeBPGrtsQCQJe0FUFR0K0,577 +grpc/framework/foundation/__pycache__/__init__.cpython-310.pyc,, +grpc/framework/foundation/__pycache__/abandonment.cpython-310.pyc,, +grpc/framework/foundation/__pycache__/callable_util.cpython-310.pyc,, +grpc/framework/foundation/__pycache__/future.cpython-310.pyc,, +grpc/framework/foundation/__pycache__/logging_pool.cpython-310.pyc,, +grpc/framework/foundation/__pycache__/stream.cpython-310.pyc,, +grpc/framework/foundation/__pycache__/stream_util.cpython-310.pyc,, +grpc/framework/foundation/abandonment.py,sha256=AF4Y734bGIVaX0CL8W9XaaPYuPUacgciBEZ9Wb4fpGA,878 +grpc/framework/foundation/callable_util.py,sha256=_uvikTKQnBPQv0Bfo59FkzwvclWDLxssFqHhdn-qqEY,3151 +grpc/framework/foundation/future.py,sha256=djoeNq-Wd5_tkzQwF_ZeL1nYAWKJ5rwzelGoTPdR1ME,8373 +grpc/framework/foundation/logging_pool.py,sha256=j8PFaWarQrnDebsDxmcJMzfFsJH8xGY2A4z6Plo_Q9c,2248 +grpc/framework/foundation/stream.py,sha256=F6XQUJC8rT-ciybPtHP7PTMlMXNoVXyzmnRwYKos0Ms,1377 +grpc/framework/foundation/stream_util.py,sha256=CUx6geCSB9zwgdlE0XHXcPSbuLeuNfClsZFyjsQVMB0,4772 +grpc/framework/interfaces/__init__.py,sha256=w3kqSAyaZgP-W0890xR4L4WeBPGrtsQCQJe0FUFR0K0,577 +grpc/framework/interfaces/__pycache__/__init__.cpython-310.pyc,, +grpc/framework/interfaces/base/__init__.py,sha256=w3kqSAyaZgP-W0890xR4L4WeBPGrtsQCQJe0FUFR0K0,577 +grpc/framework/interfaces/base/__pycache__/__init__.cpython-310.pyc,, +grpc/framework/interfaces/base/__pycache__/base.cpython-310.pyc,, +grpc/framework/interfaces/base/__pycache__/utilities.cpython-310.pyc,, +grpc/framework/interfaces/base/base.py,sha256=aDW-nCVA4brDc3ZRf_b1-MOZ4Jv7ss_F4V6jIeJugTc,12234 +grpc/framework/interfaces/base/utilities.py,sha256=buvlDv3ulHgsF4ej6DzQecoPGXwfMV2eyZ70lPMJfNA,2362 +grpc/framework/interfaces/face/__init__.py,sha256=w3kqSAyaZgP-W0890xR4L4WeBPGrtsQCQJe0FUFR0K0,577 +grpc/framework/interfaces/face/__pycache__/__init__.cpython-310.pyc,, +grpc/framework/interfaces/face/__pycache__/face.cpython-310.pyc,, +grpc/framework/interfaces/face/__pycache__/utilities.cpython-310.pyc,, +grpc/framework/interfaces/face/face.py,sha256=OGyApdjsZ8BF9nNq-2sd6WXd9bPpbvj4jvXrGdJu-nY,39700 +grpc/framework/interfaces/face/utilities.py,sha256=jRmAmV0hXPXcN5a6Vg7OlBbcltGB6B10bUfoqqHJmUc,6777 +grpcio-1.71.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +grpcio-1.71.0.dist-info/LICENSE,sha256=WQGY4_MF8sNH_eZNY3xlSSu-9VTbbINk4UnNN143l-4,29687 +grpcio-1.71.0.dist-info/METADATA,sha256=E-somUcBTIs_ie0p-F7XMRZ29pybhbm-DeAQKCsjpdA,3838 +grpcio-1.71.0.dist-info/RECORD,, +grpcio-1.71.0.dist-info/WHEEL,sha256=CzQQWV-lNyM92gr3iaBk8dvO35YDHRxgzkZ-dxumUIM,152 +grpcio-1.71.0.dist-info/top_level.txt,sha256=eEd2Jq_aVQFp38bWW8Pfwjz_5iibqeOFT-2zXlPAq_8,5 diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/WHEEL b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..9bb86cf30c63df9170e9af3dd246ce6f41270402 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.43.0) +Root-Is-Purelib: false +Tag: cp310-cp310-manylinux_2_17_x86_64 +Tag: cp310-cp310-manylinux2014_x86_64 + diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/top_level.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..3b2fe54cba7bccaa783f551549920c8e8927cf1e --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/grpcio-1.71.0.dist-info/top_level.txt @@ -0,0 +1 @@ +grpc diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/httpx/_models.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/httpx/_models.py new file mode 100644 index 0000000000000000000000000000000000000000..67d74bf86bfc80e22d9a4a3153572845accd9039 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/httpx/_models.py @@ -0,0 +1,1277 @@ +from __future__ import annotations + +import codecs +import datetime +import email.message +import json as jsonlib +import re +import typing +import urllib.request +from collections.abc import Mapping +from http.cookiejar import Cookie, CookieJar + +from ._content import ByteStream, UnattachedStream, encode_request, encode_response +from ._decoders import ( + SUPPORTED_DECODERS, + ByteChunker, + ContentDecoder, + IdentityDecoder, + LineDecoder, + MultiDecoder, + TextChunker, + TextDecoder, +) +from ._exceptions import ( + CookieConflict, + HTTPStatusError, + RequestNotRead, + ResponseNotRead, + StreamClosed, + StreamConsumed, + request_context, +) +from ._multipart import get_multipart_boundary_from_content_type +from ._status_codes import codes +from ._types import ( + AsyncByteStream, + CookieTypes, + HeaderTypes, + QueryParamTypes, + RequestContent, + RequestData, + RequestExtensions, + RequestFiles, + ResponseContent, + ResponseExtensions, + SyncByteStream, +) +from ._urls import URL +from ._utils import to_bytes_or_str, to_str + +__all__ = ["Cookies", "Headers", "Request", "Response"] + +SENSITIVE_HEADERS = {"authorization", "proxy-authorization"} + + +def _is_known_encoding(encoding: str) -> bool: + """ + Return `True` if `encoding` is a known codec. + """ + try: + codecs.lookup(encoding) + except LookupError: + return False + return True + + +def _normalize_header_key(key: str | bytes, encoding: str | None = None) -> bytes: + """ + Coerce str/bytes into a strictly byte-wise HTTP header key. + """ + return key if isinstance(key, bytes) else key.encode(encoding or "ascii") + + +def _normalize_header_value(value: str | bytes, encoding: str | None = None) -> bytes: + """ + Coerce str/bytes into a strictly byte-wise HTTP header value. + """ + if isinstance(value, bytes): + return value + if not isinstance(value, str): + raise TypeError(f"Header value must be str or bytes, not {type(value)}") + return value.encode(encoding or "ascii") + + +def _parse_content_type_charset(content_type: str) -> str | None: + # We used to use `cgi.parse_header()` here, but `cgi` became a dead battery. + # See: https://peps.python.org/pep-0594/#cgi + msg = email.message.Message() + msg["content-type"] = content_type + return msg.get_content_charset(failobj=None) + + +def _parse_header_links(value: str) -> list[dict[str, str]]: + """ + Returns a list of parsed link headers, for more info see: + https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link + The generic syntax of those is: + Link: < uri-reference >; param1=value1; param2="value2" + So for instance: + Link; '; type="image/jpeg",;' + would return + [ + {"url": "http:/.../front.jpeg", "type": "image/jpeg"}, + {"url": "http://.../back.jpeg"}, + ] + :param value: HTTP Link entity-header field + :return: list of parsed link headers + """ + links: list[dict[str, str]] = [] + replace_chars = " '\"" + value = value.strip(replace_chars) + if not value: + return links + for val in re.split(", *<", value): + try: + url, params = val.split(";", 1) + except ValueError: + url, params = val, "" + link = {"url": url.strip("<> '\"")} + for param in params.split(";"): + try: + key, value = param.split("=") + except ValueError: + break + link[key.strip(replace_chars)] = value.strip(replace_chars) + links.append(link) + return links + + +def _obfuscate_sensitive_headers( + items: typing.Iterable[tuple[typing.AnyStr, typing.AnyStr]], +) -> typing.Iterator[tuple[typing.AnyStr, typing.AnyStr]]: + for k, v in items: + if to_str(k.lower()) in SENSITIVE_HEADERS: + v = to_bytes_or_str("[secure]", match_type_of=v) + yield k, v + + +class Headers(typing.MutableMapping[str, str]): + """ + HTTP headers, as a case-insensitive multi-dict. + """ + + def __init__( + self, + headers: HeaderTypes | None = None, + encoding: str | None = None, + ) -> None: + self._list = [] # type: typing.List[typing.Tuple[bytes, bytes, bytes]] + + if isinstance(headers, Headers): + self._list = list(headers._list) + elif isinstance(headers, Mapping): + for k, v in headers.items(): + bytes_key = _normalize_header_key(k, encoding) + bytes_value = _normalize_header_value(v, encoding) + self._list.append((bytes_key, bytes_key.lower(), bytes_value)) + elif headers is not None: + for k, v in headers: + bytes_key = _normalize_header_key(k, encoding) + bytes_value = _normalize_header_value(v, encoding) + self._list.append((bytes_key, bytes_key.lower(), bytes_value)) + + self._encoding = encoding + + @property + def encoding(self) -> str: + """ + Header encoding is mandated as ascii, but we allow fallbacks to utf-8 + or iso-8859-1. + """ + if self._encoding is None: + for encoding in ["ascii", "utf-8"]: + for key, value in self.raw: + try: + key.decode(encoding) + value.decode(encoding) + except UnicodeDecodeError: + break + else: + # The else block runs if 'break' did not occur, meaning + # all values fitted the encoding. + self._encoding = encoding + break + else: + # The ISO-8859-1 encoding covers all 256 code points in a byte, + # so will never raise decode errors. + self._encoding = "iso-8859-1" + return self._encoding + + @encoding.setter + def encoding(self, value: str) -> None: + self._encoding = value + + @property + def raw(self) -> list[tuple[bytes, bytes]]: + """ + Returns a list of the raw header items, as byte pairs. + """ + return [(raw_key, value) for raw_key, _, value in self._list] + + def keys(self) -> typing.KeysView[str]: + return {key.decode(self.encoding): None for _, key, value in self._list}.keys() + + def values(self) -> typing.ValuesView[str]: + values_dict: dict[str, str] = {} + for _, key, value in self._list: + str_key = key.decode(self.encoding) + str_value = value.decode(self.encoding) + if str_key in values_dict: + values_dict[str_key] += f", {str_value}" + else: + values_dict[str_key] = str_value + return values_dict.values() + + def items(self) -> typing.ItemsView[str, str]: + """ + Return `(key, value)` items of headers. Concatenate headers + into a single comma separated value when a key occurs multiple times. + """ + values_dict: dict[str, str] = {} + for _, key, value in self._list: + str_key = key.decode(self.encoding) + str_value = value.decode(self.encoding) + if str_key in values_dict: + values_dict[str_key] += f", {str_value}" + else: + values_dict[str_key] = str_value + return values_dict.items() + + def multi_items(self) -> list[tuple[str, str]]: + """ + Return a list of `(key, value)` pairs of headers. Allow multiple + occurrences of the same key without concatenating into a single + comma separated value. + """ + return [ + (key.decode(self.encoding), value.decode(self.encoding)) + for _, key, value in self._list + ] + + def get(self, key: str, default: typing.Any = None) -> typing.Any: + """ + Return a header value. If multiple occurrences of the header occur + then concatenate them together with commas. + """ + try: + return self[key] + except KeyError: + return default + + def get_list(self, key: str, split_commas: bool = False) -> list[str]: + """ + Return a list of all header values for a given key. + If `split_commas=True` is passed, then any comma separated header + values are split into multiple return strings. + """ + get_header_key = key.lower().encode(self.encoding) + + values = [ + item_value.decode(self.encoding) + for _, item_key, item_value in self._list + if item_key.lower() == get_header_key + ] + + if not split_commas: + return values + + split_values = [] + for value in values: + split_values.extend([item.strip() for item in value.split(",")]) + return split_values + + def update(self, headers: HeaderTypes | None = None) -> None: # type: ignore + headers = Headers(headers) + for key in headers.keys(): + if key in self: + self.pop(key) + self._list.extend(headers._list) + + def copy(self) -> Headers: + return Headers(self, encoding=self.encoding) + + def __getitem__(self, key: str) -> str: + """ + Return a single header value. + + If there are multiple headers with the same key, then we concatenate + them with commas. See: https://tools.ietf.org/html/rfc7230#section-3.2.2 + """ + normalized_key = key.lower().encode(self.encoding) + + items = [ + header_value.decode(self.encoding) + for _, header_key, header_value in self._list + if header_key == normalized_key + ] + + if items: + return ", ".join(items) + + raise KeyError(key) + + def __setitem__(self, key: str, value: str) -> None: + """ + Set the header `key` to `value`, removing any duplicate entries. + Retains insertion order. + """ + set_key = key.encode(self._encoding or "utf-8") + set_value = value.encode(self._encoding or "utf-8") + lookup_key = set_key.lower() + + found_indexes = [ + idx + for idx, (_, item_key, _) in enumerate(self._list) + if item_key == lookup_key + ] + + for idx in reversed(found_indexes[1:]): + del self._list[idx] + + if found_indexes: + idx = found_indexes[0] + self._list[idx] = (set_key, lookup_key, set_value) + else: + self._list.append((set_key, lookup_key, set_value)) + + def __delitem__(self, key: str) -> None: + """ + Remove the header `key`. + """ + del_key = key.lower().encode(self.encoding) + + pop_indexes = [ + idx + for idx, (_, item_key, _) in enumerate(self._list) + if item_key.lower() == del_key + ] + + if not pop_indexes: + raise KeyError(key) + + for idx in reversed(pop_indexes): + del self._list[idx] + + def __contains__(self, key: typing.Any) -> bool: + header_key = key.lower().encode(self.encoding) + return header_key in [key for _, key, _ in self._list] + + def __iter__(self) -> typing.Iterator[typing.Any]: + return iter(self.keys()) + + def __len__(self) -> int: + return len(self._list) + + def __eq__(self, other: typing.Any) -> bool: + try: + other_headers = Headers(other) + except ValueError: + return False + + self_list = [(key, value) for _, key, value in self._list] + other_list = [(key, value) for _, key, value in other_headers._list] + return sorted(self_list) == sorted(other_list) + + def __repr__(self) -> str: + class_name = self.__class__.__name__ + + encoding_str = "" + if self.encoding != "ascii": + encoding_str = f", encoding={self.encoding!r}" + + as_list = list(_obfuscate_sensitive_headers(self.multi_items())) + as_dict = dict(as_list) + + no_duplicate_keys = len(as_dict) == len(as_list) + if no_duplicate_keys: + return f"{class_name}({as_dict!r}{encoding_str})" + return f"{class_name}({as_list!r}{encoding_str})" + + +class Request: + def __init__( + self, + method: str, + url: URL | str, + *, + params: QueryParamTypes | None = None, + headers: HeaderTypes | None = None, + cookies: CookieTypes | None = None, + content: RequestContent | None = None, + data: RequestData | None = None, + files: RequestFiles | None = None, + json: typing.Any | None = None, + stream: SyncByteStream | AsyncByteStream | None = None, + extensions: RequestExtensions | None = None, + ) -> None: + self.method = method.upper() + self.url = URL(url) if params is None else URL(url, params=params) + self.headers = Headers(headers) + self.extensions = {} if extensions is None else dict(extensions) + + if cookies: + Cookies(cookies).set_cookie_header(self) + + if stream is None: + content_type: str | None = self.headers.get("content-type") + headers, stream = encode_request( + content=content, + data=data, + files=files, + json=json, + boundary=get_multipart_boundary_from_content_type( + content_type=content_type.encode(self.headers.encoding) + if content_type + else None + ), + ) + self._prepare(headers) + self.stream = stream + # Load the request body, except for streaming content. + if isinstance(stream, ByteStream): + self.read() + else: + # There's an important distinction between `Request(content=...)`, + # and `Request(stream=...)`. + # + # Using `content=...` implies automatically populated `Host` and content + # headers, of either `Content-Length: ...` or `Transfer-Encoding: chunked`. + # + # Using `stream=...` will not automatically include *any* + # auto-populated headers. + # + # As an end-user you don't really need `stream=...`. It's only + # useful when: + # + # * Preserving the request stream when copying requests, eg for redirects. + # * Creating request instances on the *server-side* of the transport API. + self.stream = stream + + def _prepare(self, default_headers: dict[str, str]) -> None: + for key, value in default_headers.items(): + # Ignore Transfer-Encoding if the Content-Length has been set explicitly. + if key.lower() == "transfer-encoding" and "Content-Length" in self.headers: + continue + self.headers.setdefault(key, value) + + auto_headers: list[tuple[bytes, bytes]] = [] + + has_host = "Host" in self.headers + has_content_length = ( + "Content-Length" in self.headers or "Transfer-Encoding" in self.headers + ) + + if not has_host and self.url.host: + auto_headers.append((b"Host", self.url.netloc)) + if not has_content_length and self.method in ("POST", "PUT", "PATCH"): + auto_headers.append((b"Content-Length", b"0")) + + self.headers = Headers(auto_headers + self.headers.raw) + + @property + def content(self) -> bytes: + if not hasattr(self, "_content"): + raise RequestNotRead() + return self._content + + def read(self) -> bytes: + """ + Read and return the request content. + """ + if not hasattr(self, "_content"): + assert isinstance(self.stream, typing.Iterable) + self._content = b"".join(self.stream) + if not isinstance(self.stream, ByteStream): + # If a streaming request has been read entirely into memory, then + # we can replace the stream with a raw bytes implementation, + # to ensure that any non-replayable streams can still be used. + self.stream = ByteStream(self._content) + return self._content + + async def aread(self) -> bytes: + """ + Read and return the request content. + """ + if not hasattr(self, "_content"): + assert isinstance(self.stream, typing.AsyncIterable) + self._content = b"".join([part async for part in self.stream]) + if not isinstance(self.stream, ByteStream): + # If a streaming request has been read entirely into memory, then + # we can replace the stream with a raw bytes implementation, + # to ensure that any non-replayable streams can still be used. + self.stream = ByteStream(self._content) + return self._content + + def __repr__(self) -> str: + class_name = self.__class__.__name__ + url = str(self.url) + return f"<{class_name}({self.method!r}, {url!r})>" + + def __getstate__(self) -> dict[str, typing.Any]: + return { + name: value + for name, value in self.__dict__.items() + if name not in ["extensions", "stream"] + } + + def __setstate__(self, state: dict[str, typing.Any]) -> None: + for name, value in state.items(): + setattr(self, name, value) + self.extensions = {} + self.stream = UnattachedStream() + + +class Response: + def __init__( + self, + status_code: int, + *, + headers: HeaderTypes | None = None, + content: ResponseContent | None = None, + text: str | None = None, + html: str | None = None, + json: typing.Any = None, + stream: SyncByteStream | AsyncByteStream | None = None, + request: Request | None = None, + extensions: ResponseExtensions | None = None, + history: list[Response] | None = None, + default_encoding: str | typing.Callable[[bytes], str] = "utf-8", + ) -> None: + self.status_code = status_code + self.headers = Headers(headers) + + self._request: Request | None = request + + # When follow_redirects=False and a redirect is received, + # the client will set `response.next_request`. + self.next_request: Request | None = None + + self.extensions = {} if extensions is None else dict(extensions) + self.history = [] if history is None else list(history) + + self.is_closed = False + self.is_stream_consumed = False + + self.default_encoding = default_encoding + + if stream is None: + headers, stream = encode_response(content, text, html, json) + self._prepare(headers) + self.stream = stream + if isinstance(stream, ByteStream): + # Load the response body, except for streaming content. + self.read() + else: + # There's an important distinction between `Response(content=...)`, + # and `Response(stream=...)`. + # + # Using `content=...` implies automatically populated content headers, + # of either `Content-Length: ...` or `Transfer-Encoding: chunked`. + # + # Using `stream=...` will not automatically include any content headers. + # + # As an end-user you don't really need `stream=...`. It's only + # useful when creating response instances having received a stream + # from the transport API. + self.stream = stream + + self._num_bytes_downloaded = 0 + + def _prepare(self, default_headers: dict[str, str]) -> None: + for key, value in default_headers.items(): + # Ignore Transfer-Encoding if the Content-Length has been set explicitly. + if key.lower() == "transfer-encoding" and "content-length" in self.headers: + continue + self.headers.setdefault(key, value) + + @property + def elapsed(self) -> datetime.timedelta: + """ + Returns the time taken for the complete request/response + cycle to complete. + """ + if not hasattr(self, "_elapsed"): + raise RuntimeError( + "'.elapsed' may only be accessed after the response " + "has been read or closed." + ) + return self._elapsed + + @elapsed.setter + def elapsed(self, elapsed: datetime.timedelta) -> None: + self._elapsed = elapsed + + @property + def request(self) -> Request: + """ + Returns the request instance associated to the current response. + """ + if self._request is None: + raise RuntimeError( + "The request instance has not been set on this response." + ) + return self._request + + @request.setter + def request(self, value: Request) -> None: + self._request = value + + @property + def http_version(self) -> str: + try: + http_version: bytes = self.extensions["http_version"] + except KeyError: + return "HTTP/1.1" + else: + return http_version.decode("ascii", errors="ignore") + + @property + def reason_phrase(self) -> str: + try: + reason_phrase: bytes = self.extensions["reason_phrase"] + except KeyError: + return codes.get_reason_phrase(self.status_code) + else: + return reason_phrase.decode("ascii", errors="ignore") + + @property + def url(self) -> URL: + """ + Returns the URL for which the request was made. + """ + return self.request.url + + @property + def content(self) -> bytes: + if not hasattr(self, "_content"): + raise ResponseNotRead() + return self._content + + @property + def text(self) -> str: + if not hasattr(self, "_text"): + content = self.content + if not content: + self._text = "" + else: + decoder = TextDecoder(encoding=self.encoding or "utf-8") + self._text = "".join([decoder.decode(self.content), decoder.flush()]) + return self._text + + @property + def encoding(self) -> str | None: + """ + Return an encoding to use for decoding the byte content into text. + The priority for determining this is given by... + + * `.encoding = <>` has been set explicitly. + * The encoding as specified by the charset parameter in the Content-Type header. + * The encoding as determined by `default_encoding`, which may either be + a string like "utf-8" indicating the encoding to use, or may be a callable + which enables charset autodetection. + """ + if not hasattr(self, "_encoding"): + encoding = self.charset_encoding + if encoding is None or not _is_known_encoding(encoding): + if isinstance(self.default_encoding, str): + encoding = self.default_encoding + elif hasattr(self, "_content"): + encoding = self.default_encoding(self._content) + self._encoding = encoding or "utf-8" + return self._encoding + + @encoding.setter + def encoding(self, value: str) -> None: + """ + Set the encoding to use for decoding the byte content into text. + + If the `text` attribute has been accessed, attempting to set the + encoding will throw a ValueError. + """ + if hasattr(self, "_text"): + raise ValueError( + "Setting encoding after `text` has been accessed is not allowed." + ) + self._encoding = value + + @property + def charset_encoding(self) -> str | None: + """ + Return the encoding, as specified by the Content-Type header. + """ + content_type = self.headers.get("Content-Type") + if content_type is None: + return None + + return _parse_content_type_charset(content_type) + + def _get_content_decoder(self) -> ContentDecoder: + """ + Returns a decoder instance which can be used to decode the raw byte + content, depending on the Content-Encoding used in the response. + """ + if not hasattr(self, "_decoder"): + decoders: list[ContentDecoder] = [] + values = self.headers.get_list("content-encoding", split_commas=True) + for value in values: + value = value.strip().lower() + try: + decoder_cls = SUPPORTED_DECODERS[value] + decoders.append(decoder_cls()) + except KeyError: + continue + + if len(decoders) == 1: + self._decoder = decoders[0] + elif len(decoders) > 1: + self._decoder = MultiDecoder(children=decoders) + else: + self._decoder = IdentityDecoder() + + return self._decoder + + @property + def is_informational(self) -> bool: + """ + A property which is `True` for 1xx status codes, `False` otherwise. + """ + return codes.is_informational(self.status_code) + + @property + def is_success(self) -> bool: + """ + A property which is `True` for 2xx status codes, `False` otherwise. + """ + return codes.is_success(self.status_code) + + @property + def is_redirect(self) -> bool: + """ + A property which is `True` for 3xx status codes, `False` otherwise. + + Note that not all responses with a 3xx status code indicate a URL redirect. + + Use `response.has_redirect_location` to determine responses with a properly + formed URL redirection. + """ + return codes.is_redirect(self.status_code) + + @property + def is_client_error(self) -> bool: + """ + A property which is `True` for 4xx status codes, `False` otherwise. + """ + return codes.is_client_error(self.status_code) + + @property + def is_server_error(self) -> bool: + """ + A property which is `True` for 5xx status codes, `False` otherwise. + """ + return codes.is_server_error(self.status_code) + + @property + def is_error(self) -> bool: + """ + A property which is `True` for 4xx and 5xx status codes, `False` otherwise. + """ + return codes.is_error(self.status_code) + + @property + def has_redirect_location(self) -> bool: + """ + Returns True for 3xx responses with a properly formed URL redirection, + `False` otherwise. + """ + return ( + self.status_code + in ( + # 301 (Cacheable redirect. Method may change to GET.) + codes.MOVED_PERMANENTLY, + # 302 (Uncacheable redirect. Method may change to GET.) + codes.FOUND, + # 303 (Client should make a GET or HEAD request.) + codes.SEE_OTHER, + # 307 (Equiv. 302, but retain method) + codes.TEMPORARY_REDIRECT, + # 308 (Equiv. 301, but retain method) + codes.PERMANENT_REDIRECT, + ) + and "Location" in self.headers + ) + + def raise_for_status(self) -> Response: + """ + Raise the `HTTPStatusError` if one occurred. + """ + request = self._request + if request is None: + raise RuntimeError( + "Cannot call `raise_for_status` as the request " + "instance has not been set on this response." + ) + + if self.is_success: + return self + + if self.has_redirect_location: + message = ( + "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n" + "Redirect location: '{0.headers[location]}'\n" + "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}" + ) + else: + message = ( + "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n" + "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}" + ) + + status_class = self.status_code // 100 + error_types = { + 1: "Informational response", + 3: "Redirect response", + 4: "Client error", + 5: "Server error", + } + error_type = error_types.get(status_class, "Invalid status code") + message = message.format(self, error_type=error_type) + raise HTTPStatusError(message, request=request, response=self) + + def json(self, **kwargs: typing.Any) -> typing.Any: + return jsonlib.loads(self.content, **kwargs) + + @property + def cookies(self) -> Cookies: + if not hasattr(self, "_cookies"): + self._cookies = Cookies() + self._cookies.extract_cookies(self) + return self._cookies + + @property + def links(self) -> dict[str | None, dict[str, str]]: + """ + Returns the parsed header links of the response, if any + """ + header = self.headers.get("link") + if header is None: + return {} + + return { + (link.get("rel") or link.get("url")): link + for link in _parse_header_links(header) + } + + @property + def num_bytes_downloaded(self) -> int: + return self._num_bytes_downloaded + + def __repr__(self) -> str: + return f"" + + def __getstate__(self) -> dict[str, typing.Any]: + return { + name: value + for name, value in self.__dict__.items() + if name not in ["extensions", "stream", "is_closed", "_decoder"] + } + + def __setstate__(self, state: dict[str, typing.Any]) -> None: + for name, value in state.items(): + setattr(self, name, value) + self.is_closed = True + self.extensions = {} + self.stream = UnattachedStream() + + def read(self) -> bytes: + """ + Read and return the response content. + """ + if not hasattr(self, "_content"): + self._content = b"".join(self.iter_bytes()) + return self._content + + def iter_bytes(self, chunk_size: int | None = None) -> typing.Iterator[bytes]: + """ + A byte-iterator over the decoded response content. + This allows us to handle gzip, deflate, brotli, and zstd encoded responses. + """ + if hasattr(self, "_content"): + chunk_size = len(self._content) if chunk_size is None else chunk_size + for i in range(0, len(self._content), max(chunk_size, 1)): + yield self._content[i : i + chunk_size] + else: + decoder = self._get_content_decoder() + chunker = ByteChunker(chunk_size=chunk_size) + with request_context(request=self._request): + for raw_bytes in self.iter_raw(): + decoded = decoder.decode(raw_bytes) + for chunk in chunker.decode(decoded): + yield chunk + decoded = decoder.flush() + for chunk in chunker.decode(decoded): + yield chunk # pragma: no cover + for chunk in chunker.flush(): + yield chunk + + def iter_text(self, chunk_size: int | None = None) -> typing.Iterator[str]: + """ + A str-iterator over the decoded response content + that handles both gzip, deflate, etc but also detects the content's + string encoding. + """ + decoder = TextDecoder(encoding=self.encoding or "utf-8") + chunker = TextChunker(chunk_size=chunk_size) + with request_context(request=self._request): + for byte_content in self.iter_bytes(): + text_content = decoder.decode(byte_content) + for chunk in chunker.decode(text_content): + yield chunk + text_content = decoder.flush() + for chunk in chunker.decode(text_content): + yield chunk # pragma: no cover + for chunk in chunker.flush(): + yield chunk + + def iter_lines(self) -> typing.Iterator[str]: + decoder = LineDecoder() + with request_context(request=self._request): + for text in self.iter_text(): + for line in decoder.decode(text): + yield line + for line in decoder.flush(): + yield line + + def iter_raw(self, chunk_size: int | None = None) -> typing.Iterator[bytes]: + """ + A byte-iterator over the raw response content. + """ + if self.is_stream_consumed: + raise StreamConsumed() + if self.is_closed: + raise StreamClosed() + if not isinstance(self.stream, SyncByteStream): + raise RuntimeError("Attempted to call a sync iterator on an async stream.") + + self.is_stream_consumed = True + self._num_bytes_downloaded = 0 + chunker = ByteChunker(chunk_size=chunk_size) + + with request_context(request=self._request): + for raw_stream_bytes in self.stream: + self._num_bytes_downloaded += len(raw_stream_bytes) + for chunk in chunker.decode(raw_stream_bytes): + yield chunk + + for chunk in chunker.flush(): + yield chunk + + self.close() + + def close(self) -> None: + """ + Close the response and release the connection. + Automatically called if the response body is read to completion. + """ + if not isinstance(self.stream, SyncByteStream): + raise RuntimeError("Attempted to call an sync close on an async stream.") + + if not self.is_closed: + self.is_closed = True + with request_context(request=self._request): + self.stream.close() + + async def aread(self) -> bytes: + """ + Read and return the response content. + """ + if not hasattr(self, "_content"): + self._content = b"".join([part async for part in self.aiter_bytes()]) + return self._content + + async def aiter_bytes( + self, chunk_size: int | None = None + ) -> typing.AsyncIterator[bytes]: + """ + A byte-iterator over the decoded response content. + This allows us to handle gzip, deflate, brotli, and zstd encoded responses. + """ + if hasattr(self, "_content"): + chunk_size = len(self._content) if chunk_size is None else chunk_size + for i in range(0, len(self._content), max(chunk_size, 1)): + yield self._content[i : i + chunk_size] + else: + decoder = self._get_content_decoder() + chunker = ByteChunker(chunk_size=chunk_size) + with request_context(request=self._request): + async for raw_bytes in self.aiter_raw(): + decoded = decoder.decode(raw_bytes) + for chunk in chunker.decode(decoded): + yield chunk + decoded = decoder.flush() + for chunk in chunker.decode(decoded): + yield chunk # pragma: no cover + for chunk in chunker.flush(): + yield chunk + + async def aiter_text( + self, chunk_size: int | None = None + ) -> typing.AsyncIterator[str]: + """ + A str-iterator over the decoded response content + that handles both gzip, deflate, etc but also detects the content's + string encoding. + """ + decoder = TextDecoder(encoding=self.encoding or "utf-8") + chunker = TextChunker(chunk_size=chunk_size) + with request_context(request=self._request): + async for byte_content in self.aiter_bytes(): + text_content = decoder.decode(byte_content) + for chunk in chunker.decode(text_content): + yield chunk + text_content = decoder.flush() + for chunk in chunker.decode(text_content): + yield chunk # pragma: no cover + for chunk in chunker.flush(): + yield chunk + + async def aiter_lines(self) -> typing.AsyncIterator[str]: + decoder = LineDecoder() + with request_context(request=self._request): + async for text in self.aiter_text(): + for line in decoder.decode(text): + yield line + for line in decoder.flush(): + yield line + + async def aiter_raw( + self, chunk_size: int | None = None + ) -> typing.AsyncIterator[bytes]: + """ + A byte-iterator over the raw response content. + """ + if self.is_stream_consumed: + raise StreamConsumed() + if self.is_closed: + raise StreamClosed() + if not isinstance(self.stream, AsyncByteStream): + raise RuntimeError("Attempted to call an async iterator on an sync stream.") + + self.is_stream_consumed = True + self._num_bytes_downloaded = 0 + chunker = ByteChunker(chunk_size=chunk_size) + + with request_context(request=self._request): + async for raw_stream_bytes in self.stream: + self._num_bytes_downloaded += len(raw_stream_bytes) + for chunk in chunker.decode(raw_stream_bytes): + yield chunk + + for chunk in chunker.flush(): + yield chunk + + await self.aclose() + + async def aclose(self) -> None: + """ + Close the response and release the connection. + Automatically called if the response body is read to completion. + """ + if not isinstance(self.stream, AsyncByteStream): + raise RuntimeError("Attempted to call an async close on an sync stream.") + + if not self.is_closed: + self.is_closed = True + with request_context(request=self._request): + await self.stream.aclose() + + +class Cookies(typing.MutableMapping[str, str]): + """ + HTTP Cookies, as a mutable mapping. + """ + + def __init__(self, cookies: CookieTypes | None = None) -> None: + if cookies is None or isinstance(cookies, dict): + self.jar = CookieJar() + if isinstance(cookies, dict): + for key, value in cookies.items(): + self.set(key, value) + elif isinstance(cookies, list): + self.jar = CookieJar() + for key, value in cookies: + self.set(key, value) + elif isinstance(cookies, Cookies): + self.jar = CookieJar() + for cookie in cookies.jar: + self.jar.set_cookie(cookie) + else: + self.jar = cookies + + def extract_cookies(self, response: Response) -> None: + """ + Loads any cookies based on the response `Set-Cookie` headers. + """ + urllib_response = self._CookieCompatResponse(response) + urllib_request = self._CookieCompatRequest(response.request) + + self.jar.extract_cookies(urllib_response, urllib_request) # type: ignore + + def set_cookie_header(self, request: Request) -> None: + """ + Sets an appropriate 'Cookie:' HTTP header on the `Request`. + """ + urllib_request = self._CookieCompatRequest(request) + self.jar.add_cookie_header(urllib_request) + + def set(self, name: str, value: str, domain: str = "", path: str = "/") -> None: + """ + Set a cookie value by name. May optionally include domain and path. + """ + kwargs = { + "version": 0, + "name": name, + "value": value, + "port": None, + "port_specified": False, + "domain": domain, + "domain_specified": bool(domain), + "domain_initial_dot": domain.startswith("."), + "path": path, + "path_specified": bool(path), + "secure": False, + "expires": None, + "discard": True, + "comment": None, + "comment_url": None, + "rest": {"HttpOnly": None}, + "rfc2109": False, + } + cookie = Cookie(**kwargs) # type: ignore + self.jar.set_cookie(cookie) + + def get( # type: ignore + self, + name: str, + default: str | None = None, + domain: str | None = None, + path: str | None = None, + ) -> str | None: + """ + Get a cookie by name. May optionally include domain and path + in order to specify exactly which cookie to retrieve. + """ + value = None + for cookie in self.jar: + if cookie.name == name: + if domain is None or cookie.domain == domain: + if path is None or cookie.path == path: + if value is not None: + message = f"Multiple cookies exist with name={name}" + raise CookieConflict(message) + value = cookie.value + + if value is None: + return default + return value + + def delete( + self, + name: str, + domain: str | None = None, + path: str | None = None, + ) -> None: + """ + Delete a cookie by name. May optionally include domain and path + in order to specify exactly which cookie to delete. + """ + if domain is not None and path is not None: + return self.jar.clear(domain, path, name) + + remove = [ + cookie + for cookie in self.jar + if cookie.name == name + and (domain is None or cookie.domain == domain) + and (path is None or cookie.path == path) + ] + + for cookie in remove: + self.jar.clear(cookie.domain, cookie.path, cookie.name) + + def clear(self, domain: str | None = None, path: str | None = None) -> None: + """ + Delete all cookies. Optionally include a domain and path in + order to only delete a subset of all the cookies. + """ + args = [] + if domain is not None: + args.append(domain) + if path is not None: + assert domain is not None + args.append(path) + self.jar.clear(*args) + + def update(self, cookies: CookieTypes | None = None) -> None: # type: ignore + cookies = Cookies(cookies) + for cookie in cookies.jar: + self.jar.set_cookie(cookie) + + def __setitem__(self, name: str, value: str) -> None: + return self.set(name, value) + + def __getitem__(self, name: str) -> str: + value = self.get(name) + if value is None: + raise KeyError(name) + return value + + def __delitem__(self, name: str) -> None: + return self.delete(name) + + def __len__(self) -> int: + return len(self.jar) + + def __iter__(self) -> typing.Iterator[str]: + return (cookie.name for cookie in self.jar) + + def __bool__(self) -> bool: + for _ in self.jar: + return True + return False + + def __repr__(self) -> str: + cookies_repr = ", ".join( + [ + f"" + for cookie in self.jar + ] + ) + + return f"" + + class _CookieCompatRequest(urllib.request.Request): + """ + Wraps a `Request` instance up in a compatibility interface suitable + for use with `CookieJar` operations. + """ + + def __init__(self, request: Request) -> None: + super().__init__( + url=str(request.url), + headers=dict(request.headers), + method=request.method, + ) + self.request = request + + def add_unredirected_header(self, key: str, value: str) -> None: + super().add_unredirected_header(key, value) + self.request.headers[key] = value + + class _CookieCompatResponse: + """ + Wraps a `Request` instance up in a compatibility interface suitable + for use with `CookieJar` operations. + """ + + def __init__(self, response: Response) -> None: + self.response = response + + def info(self) -> email.message.Message: + info = email.message.Message() + for key, value in self.response.headers.multi_items(): + # Note that setting `info[key]` here is an "append" operation, + # not a "replace" operation. + # https://docs.python.org/3/library/email.compat32-message.html#email.message.Message.__setitem__ + info[key] = value + return info diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/httpx/_status_codes.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/httpx/_status_codes.py new file mode 100644 index 0000000000000000000000000000000000000000..133a6231a5b53fd2f073799ca1bd07c50abe40ae --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/httpx/_status_codes.py @@ -0,0 +1,162 @@ +from __future__ import annotations + +from enum import IntEnum + +__all__ = ["codes"] + + +class codes(IntEnum): + """HTTP status codes and reason phrases + + Status codes from the following RFCs are all observed: + + * RFC 7231: Hypertext Transfer Protocol (HTTP/1.1), obsoletes 2616 + * RFC 6585: Additional HTTP Status Codes + * RFC 3229: Delta encoding in HTTP + * RFC 4918: HTTP Extensions for WebDAV, obsoletes 2518 + * RFC 5842: Binding Extensions to WebDAV + * RFC 7238: Permanent Redirect + * RFC 2295: Transparent Content Negotiation in HTTP + * RFC 2774: An HTTP Extension Framework + * RFC 7540: Hypertext Transfer Protocol Version 2 (HTTP/2) + * RFC 2324: Hyper Text Coffee Pot Control Protocol (HTCPCP/1.0) + * RFC 7725: An HTTP Status Code to Report Legal Obstacles + * RFC 8297: An HTTP Status Code for Indicating Hints + * RFC 8470: Using Early Data in HTTP + """ + + def __new__(cls, value: int, phrase: str = "") -> codes: + obj = int.__new__(cls, value) + obj._value_ = value + + obj.phrase = phrase # type: ignore[attr-defined] + return obj + + def __str__(self) -> str: + return str(self.value) + + @classmethod + def get_reason_phrase(cls, value: int) -> str: + try: + return codes(value).phrase # type: ignore + except ValueError: + return "" + + @classmethod + def is_informational(cls, value: int) -> bool: + """ + Returns `True` for 1xx status codes, `False` otherwise. + """ + return 100 <= value <= 199 + + @classmethod + def is_success(cls, value: int) -> bool: + """ + Returns `True` for 2xx status codes, `False` otherwise. + """ + return 200 <= value <= 299 + + @classmethod + def is_redirect(cls, value: int) -> bool: + """ + Returns `True` for 3xx status codes, `False` otherwise. + """ + return 300 <= value <= 399 + + @classmethod + def is_client_error(cls, value: int) -> bool: + """ + Returns `True` for 4xx status codes, `False` otherwise. + """ + return 400 <= value <= 499 + + @classmethod + def is_server_error(cls, value: int) -> bool: + """ + Returns `True` for 5xx status codes, `False` otherwise. + """ + return 500 <= value <= 599 + + @classmethod + def is_error(cls, value: int) -> bool: + """ + Returns `True` for 4xx or 5xx status codes, `False` otherwise. + """ + return 400 <= value <= 599 + + # informational + CONTINUE = 100, "Continue" + SWITCHING_PROTOCOLS = 101, "Switching Protocols" + PROCESSING = 102, "Processing" + EARLY_HINTS = 103, "Early Hints" + + # success + OK = 200, "OK" + CREATED = 201, "Created" + ACCEPTED = 202, "Accepted" + NON_AUTHORITATIVE_INFORMATION = 203, "Non-Authoritative Information" + NO_CONTENT = 204, "No Content" + RESET_CONTENT = 205, "Reset Content" + PARTIAL_CONTENT = 206, "Partial Content" + MULTI_STATUS = 207, "Multi-Status" + ALREADY_REPORTED = 208, "Already Reported" + IM_USED = 226, "IM Used" + + # redirection + MULTIPLE_CHOICES = 300, "Multiple Choices" + MOVED_PERMANENTLY = 301, "Moved Permanently" + FOUND = 302, "Found" + SEE_OTHER = 303, "See Other" + NOT_MODIFIED = 304, "Not Modified" + USE_PROXY = 305, "Use Proxy" + TEMPORARY_REDIRECT = 307, "Temporary Redirect" + PERMANENT_REDIRECT = 308, "Permanent Redirect" + + # client error + BAD_REQUEST = 400, "Bad Request" + UNAUTHORIZED = 401, "Unauthorized" + PAYMENT_REQUIRED = 402, "Payment Required" + FORBIDDEN = 403, "Forbidden" + NOT_FOUND = 404, "Not Found" + METHOD_NOT_ALLOWED = 405, "Method Not Allowed" + NOT_ACCEPTABLE = 406, "Not Acceptable" + PROXY_AUTHENTICATION_REQUIRED = 407, "Proxy Authentication Required" + REQUEST_TIMEOUT = 408, "Request Timeout" + CONFLICT = 409, "Conflict" + GONE = 410, "Gone" + LENGTH_REQUIRED = 411, "Length Required" + PRECONDITION_FAILED = 412, "Precondition Failed" + REQUEST_ENTITY_TOO_LARGE = 413, "Request Entity Too Large" + REQUEST_URI_TOO_LONG = 414, "Request-URI Too Long" + UNSUPPORTED_MEDIA_TYPE = 415, "Unsupported Media Type" + REQUESTED_RANGE_NOT_SATISFIABLE = 416, "Requested Range Not Satisfiable" + EXPECTATION_FAILED = 417, "Expectation Failed" + IM_A_TEAPOT = 418, "I'm a teapot" + MISDIRECTED_REQUEST = 421, "Misdirected Request" + UNPROCESSABLE_ENTITY = 422, "Unprocessable Entity" + LOCKED = 423, "Locked" + FAILED_DEPENDENCY = 424, "Failed Dependency" + TOO_EARLY = 425, "Too Early" + UPGRADE_REQUIRED = 426, "Upgrade Required" + PRECONDITION_REQUIRED = 428, "Precondition Required" + TOO_MANY_REQUESTS = 429, "Too Many Requests" + REQUEST_HEADER_FIELDS_TOO_LARGE = 431, "Request Header Fields Too Large" + UNAVAILABLE_FOR_LEGAL_REASONS = 451, "Unavailable For Legal Reasons" + + # server errors + INTERNAL_SERVER_ERROR = 500, "Internal Server Error" + NOT_IMPLEMENTED = 501, "Not Implemented" + BAD_GATEWAY = 502, "Bad Gateway" + SERVICE_UNAVAILABLE = 503, "Service Unavailable" + GATEWAY_TIMEOUT = 504, "Gateway Timeout" + HTTP_VERSION_NOT_SUPPORTED = 505, "HTTP Version Not Supported" + VARIANT_ALSO_NEGOTIATES = 506, "Variant Also Negotiates" + INSUFFICIENT_STORAGE = 507, "Insufficient Storage" + LOOP_DETECTED = 508, "Loop Detected" + NOT_EXTENDED = 510, "Not Extended" + NETWORK_AUTHENTICATION_REQUIRED = 511, "Network Authentication Required" + + +# Include lower-case styles for `requests` compatibility. +for code in codes: + setattr(codes, code._name_.lower(), int(code)) diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/httpx/_urlparse.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/httpx/_urlparse.py new file mode 100644 index 0000000000000000000000000000000000000000..bf190fd560ee4fc8a11af371a15fc5f1dc284d34 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/httpx/_urlparse.py @@ -0,0 +1,527 @@ +""" +An implementation of `urlparse` that provides URL validation and normalization +as described by RFC3986. + +We rely on this implementation rather than the one in Python's stdlib, because: + +* It provides more complete URL validation. +* It properly differentiates between an empty querystring and an absent querystring, + to distinguish URLs with a trailing '?'. +* It handles scheme, hostname, port, and path normalization. +* It supports IDNA hostnames, normalizing them to their encoded form. +* The API supports passing individual components, as well as the complete URL string. + +Previously we relied on the excellent `rfc3986` package to handle URL parsing and +validation, but this module provides a simpler alternative, with less indirection +required. +""" + +from __future__ import annotations + +import ipaddress +import re +import typing + +import idna + +from ._exceptions import InvalidURL + +MAX_URL_LENGTH = 65536 + +# https://datatracker.ietf.org/doc/html/rfc3986.html#section-2.3 +UNRESERVED_CHARACTERS = ( + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~" +) +SUB_DELIMS = "!$&'()*+,;=" + +PERCENT_ENCODED_REGEX = re.compile("%[A-Fa-f0-9]{2}") + +# https://url.spec.whatwg.org/#percent-encoded-bytes + +# The fragment percent-encode set is the C0 control percent-encode set +# and U+0020 SPACE, U+0022 ("), U+003C (<), U+003E (>), and U+0060 (`). +FRAG_SAFE = "".join( + [chr(i) for i in range(0x20, 0x7F) if i not in (0x20, 0x22, 0x3C, 0x3E, 0x60)] +) + +# The query percent-encode set is the C0 control percent-encode set +# and U+0020 SPACE, U+0022 ("), U+0023 (#), U+003C (<), and U+003E (>). +QUERY_SAFE = "".join( + [chr(i) for i in range(0x20, 0x7F) if i not in (0x20, 0x22, 0x23, 0x3C, 0x3E)] +) + +# The path percent-encode set is the query percent-encode set +# and U+003F (?), U+0060 (`), U+007B ({), and U+007D (}). +PATH_SAFE = "".join( + [ + chr(i) + for i in range(0x20, 0x7F) + if i not in (0x20, 0x22, 0x23, 0x3C, 0x3E) + (0x3F, 0x60, 0x7B, 0x7D) + ] +) + +# The userinfo percent-encode set is the path percent-encode set +# and U+002F (/), U+003A (:), U+003B (;), U+003D (=), U+0040 (@), +# U+005B ([) to U+005E (^), inclusive, and U+007C (|). +USERNAME_SAFE = "".join( + [ + chr(i) + for i in range(0x20, 0x7F) + if i + not in (0x20, 0x22, 0x23, 0x3C, 0x3E) + + (0x3F, 0x60, 0x7B, 0x7D) + + (0x2F, 0x3A, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C) + ] +) +PASSWORD_SAFE = "".join( + [ + chr(i) + for i in range(0x20, 0x7F) + if i + not in (0x20, 0x22, 0x23, 0x3C, 0x3E) + + (0x3F, 0x60, 0x7B, 0x7D) + + (0x2F, 0x3A, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C) + ] +) +# Note... The terminology 'userinfo' percent-encode set in the WHATWG document +# is used for the username and password quoting. For the joint userinfo component +# we remove U+003A (:) from the safe set. +USERINFO_SAFE = "".join( + [ + chr(i) + for i in range(0x20, 0x7F) + if i + not in (0x20, 0x22, 0x23, 0x3C, 0x3E) + + (0x3F, 0x60, 0x7B, 0x7D) + + (0x2F, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C) + ] +) + + +# {scheme}: (optional) +# //{authority} (optional) +# {path} +# ?{query} (optional) +# #{fragment} (optional) +URL_REGEX = re.compile( + ( + r"(?:(?P{scheme}):)?" + r"(?://(?P{authority}))?" + r"(?P{path})" + r"(?:\?(?P{query}))?" + r"(?:#(?P{fragment}))?" + ).format( + scheme="([a-zA-Z][a-zA-Z0-9+.-]*)?", + authority="[^/?#]*", + path="[^?#]*", + query="[^#]*", + fragment=".*", + ) +) + +# {userinfo}@ (optional) +# {host} +# :{port} (optional) +AUTHORITY_REGEX = re.compile( + ( + r"(?:(?P{userinfo})@)?" r"(?P{host})" r":?(?P{port})?" + ).format( + userinfo=".*", # Any character sequence. + host="(\\[.*\\]|[^:@]*)", # Either any character sequence excluding ':' or '@', + # or an IPv6 address enclosed within square brackets. + port=".*", # Any character sequence. + ) +) + + +# If we call urlparse with an individual component, then we need to regex +# validate that component individually. +# Note that we're duplicating the same strings as above. Shock! Horror!! +COMPONENT_REGEX = { + "scheme": re.compile("([a-zA-Z][a-zA-Z0-9+.-]*)?"), + "authority": re.compile("[^/?#]*"), + "path": re.compile("[^?#]*"), + "query": re.compile("[^#]*"), + "fragment": re.compile(".*"), + "userinfo": re.compile("[^@]*"), + "host": re.compile("(\\[.*\\]|[^:]*)"), + "port": re.compile(".*"), +} + + +# We use these simple regexs as a first pass before handing off to +# the stdlib 'ipaddress' module for IP address validation. +IPv4_STYLE_HOSTNAME = re.compile(r"^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$") +IPv6_STYLE_HOSTNAME = re.compile(r"^\[.*\]$") + + +class ParseResult(typing.NamedTuple): + scheme: str + userinfo: str + host: str + port: int | None + path: str + query: str | None + fragment: str | None + + @property + def authority(self) -> str: + return "".join( + [ + f"{self.userinfo}@" if self.userinfo else "", + f"[{self.host}]" if ":" in self.host else self.host, + f":{self.port}" if self.port is not None else "", + ] + ) + + @property + def netloc(self) -> str: + return "".join( + [ + f"[{self.host}]" if ":" in self.host else self.host, + f":{self.port}" if self.port is not None else "", + ] + ) + + def copy_with(self, **kwargs: str | None) -> ParseResult: + if not kwargs: + return self + + defaults = { + "scheme": self.scheme, + "authority": self.authority, + "path": self.path, + "query": self.query, + "fragment": self.fragment, + } + defaults.update(kwargs) + return urlparse("", **defaults) + + def __str__(self) -> str: + authority = self.authority + return "".join( + [ + f"{self.scheme}:" if self.scheme else "", + f"//{authority}" if authority else "", + self.path, + f"?{self.query}" if self.query is not None else "", + f"#{self.fragment}" if self.fragment is not None else "", + ] + ) + + +def urlparse(url: str = "", **kwargs: str | None) -> ParseResult: + # Initial basic checks on allowable URLs. + # --------------------------------------- + + # Hard limit the maximum allowable URL length. + if len(url) > MAX_URL_LENGTH: + raise InvalidURL("URL too long") + + # If a URL includes any ASCII control characters including \t, \r, \n, + # then treat it as invalid. + if any(char.isascii() and not char.isprintable() for char in url): + char = next(char for char in url if char.isascii() and not char.isprintable()) + idx = url.find(char) + error = ( + f"Invalid non-printable ASCII character in URL, {char!r} at position {idx}." + ) + raise InvalidURL(error) + + # Some keyword arguments require special handling. + # ------------------------------------------------ + + # Coerce "port" to a string, if it is provided as an integer. + if "port" in kwargs: + port = kwargs["port"] + kwargs["port"] = str(port) if isinstance(port, int) else port + + # Replace "netloc" with "host and "port". + if "netloc" in kwargs: + netloc = kwargs.pop("netloc") or "" + kwargs["host"], _, kwargs["port"] = netloc.partition(":") + + # Replace "username" and/or "password" with "userinfo". + if "username" in kwargs or "password" in kwargs: + username = quote(kwargs.pop("username", "") or "", safe=USERNAME_SAFE) + password = quote(kwargs.pop("password", "") or "", safe=PASSWORD_SAFE) + kwargs["userinfo"] = f"{username}:{password}" if password else username + + # Replace "raw_path" with "path" and "query". + if "raw_path" in kwargs: + raw_path = kwargs.pop("raw_path") or "" + kwargs["path"], seperator, kwargs["query"] = raw_path.partition("?") + if not seperator: + kwargs["query"] = None + + # Ensure that IPv6 "host" addresses are always escaped with "[...]". + if "host" in kwargs: + host = kwargs.get("host") or "" + if ":" in host and not (host.startswith("[") and host.endswith("]")): + kwargs["host"] = f"[{host}]" + + # If any keyword arguments are provided, ensure they are valid. + # ------------------------------------------------------------- + + for key, value in kwargs.items(): + if value is not None: + if len(value) > MAX_URL_LENGTH: + raise InvalidURL(f"URL component '{key}' too long") + + # If a component includes any ASCII control characters including \t, \r, \n, + # then treat it as invalid. + if any(char.isascii() and not char.isprintable() for char in value): + char = next( + char for char in value if char.isascii() and not char.isprintable() + ) + idx = value.find(char) + error = ( + f"Invalid non-printable ASCII character in URL {key} component, " + f"{char!r} at position {idx}." + ) + raise InvalidURL(error) + + # Ensure that keyword arguments match as a valid regex. + if not COMPONENT_REGEX[key].fullmatch(value): + raise InvalidURL(f"Invalid URL component '{key}'") + + # The URL_REGEX will always match, but may have empty components. + url_match = URL_REGEX.match(url) + assert url_match is not None + url_dict = url_match.groupdict() + + # * 'scheme', 'authority', and 'path' may be empty strings. + # * 'query' may be 'None', indicating no trailing "?" portion. + # Any string including the empty string, indicates a trailing "?". + # * 'fragment' may be 'None', indicating no trailing "#" portion. + # Any string including the empty string, indicates a trailing "#". + scheme = kwargs.get("scheme", url_dict["scheme"]) or "" + authority = kwargs.get("authority", url_dict["authority"]) or "" + path = kwargs.get("path", url_dict["path"]) or "" + query = kwargs.get("query", url_dict["query"]) + frag = kwargs.get("fragment", url_dict["fragment"]) + + # The AUTHORITY_REGEX will always match, but may have empty components. + authority_match = AUTHORITY_REGEX.match(authority) + assert authority_match is not None + authority_dict = authority_match.groupdict() + + # * 'userinfo' and 'host' may be empty strings. + # * 'port' may be 'None'. + userinfo = kwargs.get("userinfo", authority_dict["userinfo"]) or "" + host = kwargs.get("host", authority_dict["host"]) or "" + port = kwargs.get("port", authority_dict["port"]) + + # Normalize and validate each component. + # We end up with a parsed representation of the URL, + # with components that are plain ASCII bytestrings. + parsed_scheme: str = scheme.lower() + parsed_userinfo: str = quote(userinfo, safe=USERINFO_SAFE) + parsed_host: str = encode_host(host) + parsed_port: int | None = normalize_port(port, scheme) + + has_scheme = parsed_scheme != "" + has_authority = ( + parsed_userinfo != "" or parsed_host != "" or parsed_port is not None + ) + validate_path(path, has_scheme=has_scheme, has_authority=has_authority) + if has_scheme or has_authority: + path = normalize_path(path) + + parsed_path: str = quote(path, safe=PATH_SAFE) + parsed_query: str | None = None if query is None else quote(query, safe=QUERY_SAFE) + parsed_frag: str | None = None if frag is None else quote(frag, safe=FRAG_SAFE) + + # The parsed ASCII bytestrings are our canonical form. + # All properties of the URL are derived from these. + return ParseResult( + parsed_scheme, + parsed_userinfo, + parsed_host, + parsed_port, + parsed_path, + parsed_query, + parsed_frag, + ) + + +def encode_host(host: str) -> str: + if not host: + return "" + + elif IPv4_STYLE_HOSTNAME.match(host): + # Validate IPv4 hostnames like #.#.#.# + # + # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2 + # + # IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet + try: + ipaddress.IPv4Address(host) + except ipaddress.AddressValueError: + raise InvalidURL(f"Invalid IPv4 address: {host!r}") + return host + + elif IPv6_STYLE_HOSTNAME.match(host): + # Validate IPv6 hostnames like [...] + # + # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2 + # + # "A host identified by an Internet Protocol literal address, version 6 + # [RFC3513] or later, is distinguished by enclosing the IP literal + # within square brackets ("[" and "]"). This is the only place where + # square bracket characters are allowed in the URI syntax." + try: + ipaddress.IPv6Address(host[1:-1]) + except ipaddress.AddressValueError: + raise InvalidURL(f"Invalid IPv6 address: {host!r}") + return host[1:-1] + + elif host.isascii(): + # Regular ASCII hostnames + # + # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2 + # + # reg-name = *( unreserved / pct-encoded / sub-delims ) + WHATWG_SAFE = '"`{}%|\\' + return quote(host.lower(), safe=SUB_DELIMS + WHATWG_SAFE) + + # IDNA hostnames + try: + return idna.encode(host.lower()).decode("ascii") + except idna.IDNAError: + raise InvalidURL(f"Invalid IDNA hostname: {host!r}") + + +def normalize_port(port: str | int | None, scheme: str) -> int | None: + # From https://tools.ietf.org/html/rfc3986#section-3.2.3 + # + # "A scheme may define a default port. For example, the "http" scheme + # defines a default port of "80", corresponding to its reserved TCP + # port number. The type of port designated by the port number (e.g., + # TCP, UDP, SCTP) is defined by the URI scheme. URI producers and + # normalizers should omit the port component and its ":" delimiter if + # port is empty or if its value would be the same as that of the + # scheme's default." + if port is None or port == "": + return None + + try: + port_as_int = int(port) + except ValueError: + raise InvalidURL(f"Invalid port: {port!r}") + + # See https://url.spec.whatwg.org/#url-miscellaneous + default_port = {"ftp": 21, "http": 80, "https": 443, "ws": 80, "wss": 443}.get( + scheme + ) + if port_as_int == default_port: + return None + return port_as_int + + +def validate_path(path: str, has_scheme: bool, has_authority: bool) -> None: + """ + Path validation rules that depend on if the URL contains + a scheme or authority component. + + See https://datatracker.ietf.org/doc/html/rfc3986.html#section-3.3 + """ + if has_authority: + # If a URI contains an authority component, then the path component + # must either be empty or begin with a slash ("/") character." + if path and not path.startswith("/"): + raise InvalidURL("For absolute URLs, path must be empty or begin with '/'") + + if not has_scheme and not has_authority: + # If a URI does not contain an authority component, then the path cannot begin + # with two slash characters ("//"). + if path.startswith("//"): + raise InvalidURL("Relative URLs cannot have a path starting with '//'") + + # In addition, a URI reference (Section 4.1) may be a relative-path reference, + # in which case the first path segment cannot contain a colon (":") character. + if path.startswith(":"): + raise InvalidURL("Relative URLs cannot have a path starting with ':'") + + +def normalize_path(path: str) -> str: + """ + Drop "." and ".." segments from a URL path. + + For example: + + normalize_path("/path/./to/somewhere/..") == "/path/to" + """ + # Fast return when no '.' characters in the path. + if "." not in path: + return path + + components = path.split("/") + + # Fast return when no '.' or '..' components in the path. + if "." not in components and ".." not in components: + return path + + # https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4 + output: list[str] = [] + for component in components: + if component == ".": + pass + elif component == "..": + if output and output != [""]: + output.pop() + else: + output.append(component) + return "/".join(output) + + +def PERCENT(string: str) -> str: + return "".join([f"%{byte:02X}" for byte in string.encode("utf-8")]) + + +def percent_encoded(string: str, safe: str) -> str: + """ + Use percent-encoding to quote a string. + """ + NON_ESCAPED_CHARS = UNRESERVED_CHARACTERS + safe + + # Fast path for strings that don't need escaping. + if not string.rstrip(NON_ESCAPED_CHARS): + return string + + return "".join( + [char if char in NON_ESCAPED_CHARS else PERCENT(char) for char in string] + ) + + +def quote(string: str, safe: str) -> str: + """ + Use percent-encoding to quote a string, omitting existing '%xx' escape sequences. + + See: https://www.rfc-editor.org/rfc/rfc3986#section-2.1 + + * `string`: The string to be percent-escaped. + * `safe`: A string containing characters that may be treated as safe, and do not + need to be escaped. Unreserved characters are always treated as safe. + See: https://www.rfc-editor.org/rfc/rfc3986#section-2.3 + """ + parts = [] + current_position = 0 + for match in re.finditer(PERCENT_ENCODED_REGEX, string): + start_position, end_position = match.start(), match.end() + matched_text = match.group(0) + # Add any text up to the '%xx' escape sequence. + if start_position != current_position: + leading_text = string[current_position:start_position] + parts.append(percent_encoded(leading_text, safe=safe)) + + # Add the '%xx' escape sequence. + parts.append(matched_text) + current_position = end_position + + # Add any text after the final '%xx' escape sequence. + if current_position != len(string): + trailing_text = string[current_position:] + parts.append(percent_encoded(trailing_text, safe=safe)) + + return "".join(parts) diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/__init__.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..477300a7c4797868300c0297d48d9b89ebacde02 Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/__init__.cpython-310.pyc differ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/cache.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/cache.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ac92463db9a4e449a0b9b3bd5d2dd14b7459aef Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/cache.cpython-310.pyc differ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/common.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/common.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75ea9e0931cc97f60a288207d22c6a1253d41fc7 Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/common.cpython-310.pyc differ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/file_io.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/file_io.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97ed30f7384243c27d3250ac89c3c076fab27537 Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/file_io.cpython-310.pyc differ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/parser_utils.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/parser_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e4de545bf798fc7d3c6dbf6c7cf31ccedfaa2642 Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/parser_utils.cpython-310.pyc differ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/settings.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/settings.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..388fc025680d9274694a601b2846ea4832c52b58 Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/settings.cpython-310.pyc differ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/utils.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d27ba9f1c163a96d587b4fcf9aae96bab3d2c95 Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/__pycache__/utils.cpython-310.pyc differ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/classes.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/classes.py new file mode 100644 index 0000000000000000000000000000000000000000..7054788e3fe19f3892513d1430a2fb79808d9eb8 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/classes.py @@ -0,0 +1,895 @@ +""" +There are a couple of classes documented in here: + +- :class:`.BaseName` as an abstact base class for almost everything. +- :class:`.Name` used in a lot of places +- :class:`.Completion` for completions +- :class:`.BaseSignature` as a base class for signatures +- :class:`.Signature` for :meth:`.Script.get_signatures` only +- :class:`.ParamName` used for parameters of signatures +- :class:`.Refactoring` for refactorings +- :class:`.SyntaxError` for :meth:`.Script.get_syntax_errors` only + +These classes are the much biggest part of the API, because they contain +the interesting information about all operations. +""" +import re +from pathlib import Path +from typing import Optional + +from parso.tree import search_ancestor + +from jedi import settings +from jedi import debug +from jedi.inference.utils import unite +from jedi.cache import memoize_method +from jedi.inference.compiled.mixed import MixedName +from jedi.inference.names import ImportName, SubModuleName +from jedi.inference.gradual.stub_value import StubModuleValue +from jedi.inference.gradual.conversion import convert_names, convert_values +from jedi.inference.base_value import ValueSet, HasNoContext +from jedi.api.keywords import KeywordName +from jedi.api import completion_cache +from jedi.api.helpers import filter_follow_imports + + +def _sort_names_by_start_pos(names): + return sorted(names, key=lambda s: s.start_pos or (0, 0)) + + +def defined_names(inference_state, value): + """ + List sub-definitions (e.g., methods in class). + + :type scope: Scope + :rtype: list of Name + """ + try: + context = value.as_context() + except HasNoContext: + return [] + filter = next(context.get_filters()) + names = [name for name in filter.values()] + return [Name(inference_state, n) for n in _sort_names_by_start_pos(names)] + + +def _values_to_definitions(values): + return [Name(c.inference_state, c.name) for c in values] + + +class BaseName: + """ + The base class for all definitions, completions and signatures. + """ + _mapping = { + 'posixpath': 'os.path', + 'riscospath': 'os.path', + 'ntpath': 'os.path', + 'os2emxpath': 'os.path', + 'macpath': 'os.path', + 'genericpath': 'os.path', + 'posix': 'os', + '_io': 'io', + '_functools': 'functools', + '_collections': 'collections', + '_socket': 'socket', + '_sqlite3': 'sqlite3', + } + + _tuple_mapping = dict((tuple(k.split('.')), v) for (k, v) in { + 'argparse._ActionsContainer': 'argparse.ArgumentParser', + }.items()) + + def __init__(self, inference_state, name): + self._inference_state = inference_state + self._name = name + """ + An instance of :class:`parso.python.tree.Name` subclass. + """ + self.is_keyword = isinstance(self._name, KeywordName) + + @memoize_method + def _get_module_context(self): + # This can take a while to complete, because in the worst case of + # imports (consider `import a` completions), we need to load all + # modules starting with a first. + return self._name.get_root_context() + + @property + def module_path(self) -> Optional[Path]: + """ + Shows the file path of a module. e.g. ``/usr/lib/python3.9/os.py`` + """ + module = self._get_module_context() + if module.is_stub() or not module.is_compiled(): + # Compiled modules should not return a module path even if they + # have one. + path: Optional[Path] = self._get_module_context().py__file__() + return path + + return None + + @property + def name(self): + """ + Name of variable/function/class/module. + + For example, for ``x = None`` it returns ``'x'``. + + :rtype: str or None + """ + return self._name.get_public_name() + + @property + def type(self): + """ + The type of the definition. + + Here is an example of the value of this attribute. Let's consider + the following source. As what is in ``variable`` is unambiguous + to Jedi, :meth:`jedi.Script.infer` should return a list of + definition for ``sys``, ``f``, ``C`` and ``x``. + + >>> from jedi import Script + >>> source = ''' + ... import keyword + ... + ... class C: + ... pass + ... + ... class D: + ... pass + ... + ... x = D() + ... + ... def f(): + ... pass + ... + ... for variable in [keyword, f, C, x]: + ... variable''' + + >>> script = Script(source) + >>> defs = script.infer() + + Before showing what is in ``defs``, let's sort it by :attr:`line` + so that it is easy to relate the result to the source code. + + >>> defs = sorted(defs, key=lambda d: d.line) + >>> print(defs) # doctest: +NORMALIZE_WHITESPACE + [, + , + , + ] + + Finally, here is what you can get from :attr:`type`: + + >>> defs = [d.type for d in defs] + >>> defs[0] + 'module' + >>> defs[1] + 'class' + >>> defs[2] + 'instance' + >>> defs[3] + 'function' + + Valid values for type are ``module``, ``class``, ``instance``, ``function``, + ``param``, ``path``, ``keyword``, ``property`` and ``statement``. + + """ + tree_name = self._name.tree_name + resolve = False + if tree_name is not None: + # TODO move this to their respective names. + definition = tree_name.get_definition() + if definition is not None and definition.type == 'import_from' and \ + tree_name.is_definition(): + resolve = True + + if isinstance(self._name, SubModuleName) or resolve: + for value in self._name.infer(): + return value.api_type + return self._name.api_type + + @property + def module_name(self): + """ + The module name, a bit similar to what ``__name__`` is in a random + Python module. + + >>> from jedi import Script + >>> source = 'import json' + >>> script = Script(source, path='example.py') + >>> d = script.infer()[0] + >>> print(d.module_name) # doctest: +ELLIPSIS + json + """ + return self._get_module_context().py__name__() + + def in_builtin_module(self): + """ + Returns True, if this is a builtin module. + """ + value = self._get_module_context().get_value() + if isinstance(value, StubModuleValue): + return any(v.is_compiled() for v in value.non_stub_value_set) + return value.is_compiled() + + @property + def line(self): + """The line where the definition occurs (starting with 1).""" + start_pos = self._name.start_pos + if start_pos is None: + return None + return start_pos[0] + + @property + def column(self): + """The column where the definition occurs (starting with 0).""" + start_pos = self._name.start_pos + if start_pos is None: + return None + return start_pos[1] + + def get_definition_start_position(self): + """ + The (row, column) of the start of the definition range. Rows start with + 1, columns start with 0. + + :rtype: Optional[Tuple[int, int]] + """ + if self._name.tree_name is None: + return None + definition = self._name.tree_name.get_definition() + if definition is None: + return self._name.start_pos + return definition.start_pos + + def get_definition_end_position(self): + """ + The (row, column) of the end of the definition range. Rows start with + 1, columns start with 0. + + :rtype: Optional[Tuple[int, int]] + """ + if self._name.tree_name is None: + return None + definition = self._name.tree_name.get_definition() + if definition is None: + return self._name.tree_name.end_pos + if self.type in ("function", "class"): + last_leaf = definition.get_last_leaf() + if last_leaf.type == "newline": + return last_leaf.get_previous_leaf().end_pos + return last_leaf.end_pos + return definition.end_pos + + def docstring(self, raw=False, fast=True): + r""" + Return a document string for this completion object. + + Example: + + >>> from jedi import Script + >>> source = '''\ + ... def f(a, b=1): + ... "Document for function f." + ... ''' + >>> script = Script(source, path='example.py') + >>> doc = script.infer(1, len('def f'))[0].docstring() + >>> print(doc) + f(a, b=1) + + Document for function f. + + Notice that useful extra information is added to the actual + docstring, e.g. function signatures are prepended to their docstrings. + If you need the actual docstring, use ``raw=True`` instead. + + >>> print(script.infer(1, len('def f'))[0].docstring(raw=True)) + Document for function f. + + :param fast: Don't follow imports that are only one level deep like + ``import foo``, but follow ``from foo import bar``. This makes + sense for speed reasons. Completing `import a` is slow if you use + the ``foo.docstring(fast=False)`` on every object, because it + parses all libraries starting with ``a``. + """ + if isinstance(self._name, ImportName) and fast: + return '' + doc = self._get_docstring() + if raw: + return doc + + signature_text = self._get_docstring_signature() + if signature_text and doc: + return signature_text + '\n\n' + doc + else: + return signature_text + doc + + def _get_docstring(self): + return self._name.py__doc__() + + def _get_docstring_signature(self): + return '\n'.join( + signature.to_string() + for signature in self._get_signatures(for_docstring=True) + ) + + @property + def description(self): + """ + A description of the :class:`.Name` object, which is heavily used + in testing. e.g. for ``isinstance`` it returns ``def isinstance``. + + Example: + + >>> from jedi import Script + >>> source = ''' + ... def f(): + ... pass + ... + ... class C: + ... pass + ... + ... variable = f if random.choice([0,1]) else C''' + >>> script = Script(source) # line is maximum by default + >>> defs = script.infer(column=3) + >>> defs = sorted(defs, key=lambda d: d.line) + >>> print(defs) # doctest: +NORMALIZE_WHITESPACE + [, + ] + >>> str(defs[0].description) + 'def f' + >>> str(defs[1].description) + 'class C' + + """ + typ = self.type + tree_name = self._name.tree_name + if typ == 'param': + return typ + ' ' + self._name.to_string() + if typ in ('function', 'class', 'module', 'instance') or tree_name is None: + if typ == 'function': + # For the description we want a short and a pythonic way. + typ = 'def' + return typ + ' ' + self._name.get_public_name() + + definition = tree_name.get_definition(include_setitem=True) or tree_name + # Remove the prefix, because that's not what we want for get_code + # here. + txt = definition.get_code(include_prefix=False) + # Delete comments: + txt = re.sub(r'#[^\n]+\n', ' ', txt) + # Delete multi spaces/newlines + txt = re.sub(r'\s+', ' ', txt).strip() + return txt + + @property + def full_name(self): + """ + Dot-separated path of this object. + + It is in the form of ``[.[...]][.]``. + It is useful when you want to look up Python manual of the + object at hand. + + Example: + + >>> from jedi import Script + >>> source = ''' + ... import os + ... os.path.join''' + >>> script = Script(source, path='example.py') + >>> print(script.infer(3, len('os.path.join'))[0].full_name) + os.path.join + + Notice that it returns ``'os.path.join'`` instead of (for example) + ``'posixpath.join'``. This is not correct, since the modules name would + be `````. However most users find the latter + more practical. + """ + if not self._name.is_value_name: + return None + + names = self._name.get_qualified_names(include_module_names=True) + if names is None: + return None + + names = list(names) + try: + names[0] = self._mapping[names[0]] + except KeyError: + pass + + return '.'.join(names) + + def is_stub(self): + """ + Returns True if the current name is defined in a stub file. + """ + if not self._name.is_value_name: + return False + + return self._name.get_root_context().is_stub() + + def is_side_effect(self): + """ + Checks if a name is defined as ``self.foo = 3``. In case of self, this + function would return False, for foo it would return True. + """ + tree_name = self._name.tree_name + if tree_name is None: + return False + return tree_name.is_definition() and tree_name.parent.type == 'trailer' + + @debug.increase_indent_cm('goto on name') + def goto(self, *, follow_imports=False, follow_builtin_imports=False, + only_stubs=False, prefer_stubs=False): + + """ + Like :meth:`.Script.goto` (also supports the same params), but does it + for the current name. This is typically useful if you are using + something like :meth:`.Script.get_names()`. + + :param follow_imports: The goto call will follow imports. + :param follow_builtin_imports: If follow_imports is True will try to + look up names in builtins (i.e. compiled or extension modules). + :param only_stubs: Only return stubs for this goto call. + :param prefer_stubs: Prefer stubs to Python objects for this goto call. + :rtype: list of :class:`Name` + """ + if not self._name.is_value_name: + return [] + + names = self._name.goto() + if follow_imports: + names = filter_follow_imports(names, follow_builtin_imports) + names = convert_names( + names, + only_stubs=only_stubs, + prefer_stubs=prefer_stubs, + ) + return [self if n == self._name else Name(self._inference_state, n) + for n in names] + + @debug.increase_indent_cm('infer on name') + def infer(self, *, only_stubs=False, prefer_stubs=False): + """ + Like :meth:`.Script.infer`, it can be useful to understand which type + the current name has. + + Return the actual definitions. I strongly recommend not using it for + your completions, because it might slow down |jedi|. If you want to + read only a few objects (<=20), it might be useful, especially to get + the original docstrings. The basic problem of this function is that it + follows all results. This means with 1000 completions (e.g. numpy), + it's just very, very slow. + + :param only_stubs: Only return stubs for this goto call. + :param prefer_stubs: Prefer stubs to Python objects for this type + inference call. + :rtype: list of :class:`Name` + """ + assert not (only_stubs and prefer_stubs) + + if not self._name.is_value_name: + return [] + + # First we need to make sure that we have stub names (if possible) that + # we can follow. If we don't do that, we can end up with the inferred + # results of Python objects instead of stubs. + names = convert_names([self._name], prefer_stubs=True) + values = convert_values( + ValueSet.from_sets(n.infer() for n in names), + only_stubs=only_stubs, + prefer_stubs=prefer_stubs, + ) + resulting_names = [c.name for c in values] + return [self if n == self._name else Name(self._inference_state, n) + for n in resulting_names] + + def parent(self): + """ + Returns the parent scope of this identifier. + + :rtype: Name + """ + if not self._name.is_value_name: + return None + + if self.type in ('function', 'class', 'param') and self._name.tree_name is not None: + # Since the parent_context doesn't really match what the user + # thinks of that the parent is here, we do these cases separately. + # The reason for this is the following: + # - class: Nested classes parent_context is always the + # parent_context of the most outer one. + # - function: Functions in classes have the module as + # parent_context. + # - param: The parent_context of a param is not its function but + # e.g. the outer class or module. + cls_or_func_node = self._name.tree_name.get_definition() + parent = search_ancestor(cls_or_func_node, 'funcdef', 'classdef', 'file_input') + context = self._get_module_context().create_value(parent).as_context() + else: + context = self._name.parent_context + + if context is None: + return None + while context.name is None: + # Happens for comprehension contexts + context = context.parent_context + + return Name(self._inference_state, context.name) + + def __repr__(self): + return "<%s %sname=%r, description=%r>" % ( + self.__class__.__name__, + 'full_' if self.full_name else '', + self.full_name or self.name, + self.description, + ) + + def get_line_code(self, before=0, after=0): + """ + Returns the line of code where this object was defined. + + :param before: Add n lines before the current line to the output. + :param after: Add n lines after the current line to the output. + + :return str: Returns the line(s) of code or an empty string if it's a + builtin. + """ + if not self._name.is_value_name: + return '' + + lines = self._name.get_root_context().code_lines + if lines is None: + # Probably a builtin module, just ignore in that case. + return '' + + index = self._name.start_pos[0] - 1 + start_index = max(index - before, 0) + return ''.join(lines[start_index:index + after + 1]) + + def _get_signatures(self, for_docstring=False): + if self._name.api_type == 'property': + return [] + if for_docstring and self._name.api_type == 'statement' and not self.is_stub(): + # For docstrings we don't resolve signatures if they are simple + # statements and not stubs. This is a speed optimization. + return [] + + if isinstance(self._name, MixedName): + # While this would eventually happen anyway, it's basically just a + # shortcut to not infer anything tree related, because it's really + # not necessary. + return self._name.infer_compiled_value().get_signatures() + + names = convert_names([self._name], prefer_stubs=True) + return [sig for name in names for sig in name.infer().get_signatures()] + + def get_signatures(self): + """ + Returns all potential signatures for a function or a class. Multiple + signatures are typical if you use Python stubs with ``@overload``. + + :rtype: list of :class:`BaseSignature` + """ + return [ + BaseSignature(self._inference_state, s) + for s in self._get_signatures() + ] + + def execute(self): + """ + Uses type inference to "execute" this identifier and returns the + executed objects. + + :rtype: list of :class:`Name` + """ + return _values_to_definitions(self._name.infer().execute_with_values()) + + def get_type_hint(self): + """ + Returns type hints like ``Iterable[int]`` or ``Union[int, str]``. + + This method might be quite slow, especially for functions. The problem + is finding executions for those functions to return something like + ``Callable[[int, str], str]``. + + :rtype: str + """ + return self._name.infer().get_type_hint() + + +class Completion(BaseName): + """ + ``Completion`` objects are returned from :meth:`.Script.complete`. They + provide additional information about a completion. + """ + def __init__(self, inference_state, name, stack, like_name_length, + is_fuzzy, cached_name=None): + super().__init__(inference_state, name) + + self._like_name_length = like_name_length + self._stack = stack + self._is_fuzzy = is_fuzzy + self._cached_name = cached_name + + # Completion objects with the same Completion name (which means + # duplicate items in the completion) + self._same_name_completions = [] + + def _complete(self, like_name): + append = '' + if settings.add_bracket_after_function \ + and self.type == 'function': + append = '(' + + name = self._name.get_public_name() + if like_name: + name = name[self._like_name_length:] + return name + append + + @property + def complete(self): + """ + Only works with non-fuzzy completions. Returns None if fuzzy + completions are used. + + Return the rest of the word, e.g. completing ``isinstance``:: + + isinstan# <-- Cursor is here + + would return the string 'ce'. It also adds additional stuff, depending + on your ``settings.py``. + + Assuming the following function definition:: + + def foo(param=0): + pass + + completing ``foo(par`` would give a ``Completion`` which ``complete`` + would be ``am=``. + """ + if self._is_fuzzy: + return None + return self._complete(True) + + @property + def name_with_symbols(self): + """ + Similar to :attr:`.name`, but like :attr:`.name` returns also the + symbols, for example assuming the following function definition:: + + def foo(param=0): + pass + + completing ``foo(`` would give a ``Completion`` which + ``name_with_symbols`` would be "param=". + + """ + return self._complete(False) + + def docstring(self, raw=False, fast=True): + """ + Documented under :meth:`BaseName.docstring`. + """ + if self._like_name_length >= 3: + # In this case we can just resolve the like name, because we + # wouldn't load like > 100 Python modules anymore. + fast = False + + return super().docstring(raw=raw, fast=fast) + + def _get_docstring(self): + if self._cached_name is not None: + return completion_cache.get_docstring( + self._cached_name, + self._name.get_public_name(), + lambda: self._get_cache() + ) + return super()._get_docstring() + + def _get_docstring_signature(self): + if self._cached_name is not None: + return completion_cache.get_docstring_signature( + self._cached_name, + self._name.get_public_name(), + lambda: self._get_cache() + ) + return super()._get_docstring_signature() + + def _get_cache(self): + return ( + super().type, + super()._get_docstring_signature(), + super()._get_docstring(), + ) + + @property + def type(self): + """ + Documented under :meth:`BaseName.type`. + """ + # Purely a speed optimization. + if self._cached_name is not None: + return completion_cache.get_type( + self._cached_name, + self._name.get_public_name(), + lambda: self._get_cache() + ) + + return super().type + + def get_completion_prefix_length(self): + """ + Returns the length of the prefix being completed. + For example, completing ``isinstance``:: + + isinstan# <-- Cursor is here + + would return 8, because len('isinstan') == 8. + + Assuming the following function definition:: + + def foo(param=0): + pass + + completing ``foo(par`` would return 3. + """ + return self._like_name_length + + def __repr__(self): + return '<%s: %s>' % (type(self).__name__, self._name.get_public_name()) + + +class Name(BaseName): + """ + *Name* objects are returned from many different APIs including + :meth:`.Script.goto` or :meth:`.Script.infer`. + """ + def __init__(self, inference_state, definition): + super().__init__(inference_state, definition) + + @memoize_method + def defined_names(self): + """ + List sub-definitions (e.g., methods in class). + + :rtype: list of :class:`Name` + """ + defs = self._name.infer() + return sorted( + unite(defined_names(self._inference_state, d) for d in defs), + key=lambda s: s._name.start_pos or (0, 0) + ) + + def is_definition(self): + """ + Returns True, if defined as a name in a statement, function or class. + Returns False, if it's a reference to such a definition. + """ + if self._name.tree_name is None: + return True + else: + return self._name.tree_name.is_definition() + + def __eq__(self, other): + return self._name.start_pos == other._name.start_pos \ + and self.module_path == other.module_path \ + and self.name == other.name \ + and self._inference_state == other._inference_state + + def __ne__(self, other): + return not self.__eq__(other) + + def __hash__(self): + return hash((self._name.start_pos, self.module_path, self.name, self._inference_state)) + + +class BaseSignature(Name): + """ + These signatures are returned by :meth:`BaseName.get_signatures` + calls. + """ + def __init__(self, inference_state, signature): + super().__init__(inference_state, signature.name) + self._signature = signature + + @property + def params(self): + """ + Returns definitions for all parameters that a signature defines. + This includes stuff like ``*args`` and ``**kwargs``. + + :rtype: list of :class:`.ParamName` + """ + return [ParamName(self._inference_state, n) + for n in self._signature.get_param_names(resolve_stars=True)] + + def to_string(self): + """ + Returns a text representation of the signature. This could for example + look like ``foo(bar, baz: int, **kwargs)``. + + :rtype: str + """ + return self._signature.to_string() + + +class Signature(BaseSignature): + """ + A full signature object is the return value of + :meth:`.Script.get_signatures`. + """ + def __init__(self, inference_state, signature, call_details): + super().__init__(inference_state, signature) + self._call_details = call_details + self._signature = signature + + @property + def index(self): + """ + Returns the param index of the current cursor position. + Returns None if the index cannot be found in the curent call. + + :rtype: int + """ + return self._call_details.calculate_index( + self._signature.get_param_names(resolve_stars=True) + ) + + @property + def bracket_start(self): + """ + Returns a line/column tuple of the bracket that is responsible for the + last function call. The first line is 1 and the first column 0. + + :rtype: int, int + """ + return self._call_details.bracket_leaf.start_pos + + def __repr__(self): + return '<%s: index=%r %s>' % ( + type(self).__name__, + self.index, + self._signature.to_string(), + ) + + +class ParamName(Name): + def infer_default(self): + """ + Returns default values like the ``1`` of ``def foo(x=1):``. + + :rtype: list of :class:`.Name` + """ + return _values_to_definitions(self._name.infer_default()) + + def infer_annotation(self, **kwargs): + """ + :param execute_annotation: Default True; If False, values are not + executed and classes are returned instead of instances. + :rtype: list of :class:`.Name` + """ + return _values_to_definitions(self._name.infer_annotation(ignore_stars=True, **kwargs)) + + def to_string(self): + """ + Returns a simple representation of a param, like + ``f: Callable[..., Any]``. + + :rtype: str + """ + return self._name.to_string() + + @property + def kind(self): + """ + Returns an enum instance of :mod:`inspect`'s ``Parameter`` enum. + + :rtype: :py:attr:`inspect.Parameter.kind` + """ + return self._name.get_kind() diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/completion.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/completion.py new file mode 100644 index 0000000000000000000000000000000000000000..3078d83f42686bba3268d40e9c9f89a7d5512a15 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/completion.py @@ -0,0 +1,696 @@ +import re +from textwrap import dedent +from inspect import Parameter + +from parso.python.token import PythonTokenTypes +from parso.python import tree +from parso.tree import search_ancestor, Leaf +from parso import split_lines + +from jedi import debug +from jedi import settings +from jedi.api import classes +from jedi.api import helpers +from jedi.api import keywords +from jedi.api.strings import complete_dict +from jedi.api.file_name import complete_file_name +from jedi.inference import imports +from jedi.inference.base_value import ValueSet +from jedi.inference.helpers import infer_call_of_leaf, parse_dotted_names +from jedi.inference.context import get_global_filters +from jedi.inference.value import TreeInstance +from jedi.inference.docstring_utils import DocstringModule +from jedi.inference.names import ParamNameWrapper, SubModuleName +from jedi.inference.gradual.conversion import convert_values, convert_names +from jedi.parser_utils import cut_value_at_position +from jedi.plugins import plugin_manager + + +class ParamNameWithEquals(ParamNameWrapper): + def get_public_name(self): + return self.string_name + '=' + + +def _get_signature_param_names(signatures, positional_count, used_kwargs): + # Add named params + for call_sig in signatures: + for i, p in enumerate(call_sig.params): + kind = p.kind + if i < positional_count and kind == Parameter.POSITIONAL_OR_KEYWORD: + continue + if kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY) \ + and p.name not in used_kwargs: + yield ParamNameWithEquals(p._name) + + +def _must_be_kwarg(signatures, positional_count, used_kwargs): + if used_kwargs: + return True + + must_be_kwarg = True + for signature in signatures: + for i, p in enumerate(signature.params): + kind = p.kind + if kind is Parameter.VAR_POSITIONAL: + # In case there were not already kwargs, the next param can + # always be a normal argument. + return False + + if i >= positional_count and kind in (Parameter.POSITIONAL_OR_KEYWORD, + Parameter.POSITIONAL_ONLY): + must_be_kwarg = False + break + if not must_be_kwarg: + break + return must_be_kwarg + + +def filter_names(inference_state, completion_names, stack, like_name, fuzzy, + imported_names, cached_name): + comp_dct = set() + if settings.case_insensitive_completion: + like_name = like_name.lower() + for name in completion_names: + string = name.string_name + if string in imported_names and string != like_name: + continue + if settings.case_insensitive_completion: + string = string.lower() + if helpers.match(string, like_name, fuzzy=fuzzy): + new = classes.Completion( + inference_state, + name, + stack, + len(like_name), + is_fuzzy=fuzzy, + cached_name=cached_name, + ) + k = (new.name, new.complete) # key + if k not in comp_dct: + comp_dct.add(k) + tree_name = name.tree_name + if tree_name is not None: + definition = tree_name.get_definition() + if definition is not None and definition.type == 'del_stmt': + continue + yield new + + +def _remove_duplicates(completions, other_completions): + names = {d.name for d in other_completions} + return [c for c in completions if c.name not in names] + + +def get_user_context(module_context, position): + """ + Returns the scope in which the user resides. This includes flows. + """ + leaf = module_context.tree_node.get_leaf_for_position(position, include_prefixes=True) + return module_context.create_context(leaf) + + +def get_flow_scope_node(module_node, position): + node = module_node.get_leaf_for_position(position, include_prefixes=True) + while not isinstance(node, (tree.Scope, tree.Flow)): + node = node.parent + + return node + + +@plugin_manager.decorate() +def complete_param_names(context, function_name, decorator_nodes): + # Basically there's no way to do param completion. The plugins are + # responsible for this. + return [] + + +class Completion: + def __init__(self, inference_state, module_context, code_lines, position, + signatures_callback, fuzzy=False): + self._inference_state = inference_state + self._module_context = module_context + self._module_node = module_context.tree_node + self._code_lines = code_lines + + # The first step of completions is to get the name + self._like_name = helpers.get_on_completion_name(self._module_node, code_lines, position) + # The actual cursor position is not what we need to calculate + # everything. We want the start of the name we're on. + self._original_position = position + self._signatures_callback = signatures_callback + + self._fuzzy = fuzzy + + # Return list of completions in this order: + # - Beginning with what user is typing + # - Public (alphabet) + # - Private ("_xxx") + # - Dunder ("__xxx") + def complete(self): + leaf = self._module_node.get_leaf_for_position( + self._original_position, + include_prefixes=True + ) + string, start_leaf, quote = _extract_string_while_in_string(leaf, self._original_position) + + prefixed_completions = complete_dict( + self._module_context, + self._code_lines, + start_leaf or leaf, + self._original_position, + None if string is None else quote + string, + fuzzy=self._fuzzy, + ) + + if string is not None and not prefixed_completions: + prefixed_completions = list(complete_file_name( + self._inference_state, self._module_context, start_leaf, quote, string, + self._like_name, self._signatures_callback, + self._code_lines, self._original_position, + self._fuzzy + )) + if string is not None: + if not prefixed_completions and '\n' in string: + # Complete only multi line strings + prefixed_completions = self._complete_in_string(start_leaf, string) + return prefixed_completions + + cached_name, completion_names = self._complete_python(leaf) + + imported_names = [] + if leaf.parent is not None and leaf.parent.type in ['import_as_names', 'dotted_as_names']: + imported_names.extend(extract_imported_names(leaf.parent)) + + completions = list(filter_names(self._inference_state, completion_names, + self.stack, self._like_name, + self._fuzzy, imported_names, cached_name=cached_name)) + + return ( + # Removing duplicates mostly to remove False/True/None duplicates. + _remove_duplicates(prefixed_completions, completions) + + sorted(completions, key=lambda x: (not x.name.startswith(self._like_name), + x.name.startswith('__'), + x.name.startswith('_'), + x.name.lower())) + ) + + def _complete_python(self, leaf): + """ + Analyzes the current context of a completion and decides what to + return. + + Technically this works by generating a parser stack and analysing the + current stack for possible grammar nodes. + + Possible enhancements: + - global/nonlocal search global + - yield from / raise from <- could be only exceptions/generators + - In args: */**: no completion + - In params (also lambda): no completion before = + """ + grammar = self._inference_state.grammar + self.stack = stack = None + self._position = ( + self._original_position[0], + self._original_position[1] - len(self._like_name) + ) + cached_name = None + + try: + self.stack = stack = helpers.get_stack_at_position( + grammar, self._code_lines, leaf, self._position + ) + except helpers.OnErrorLeaf as e: + value = e.error_leaf.value + if value == '.': + # After ErrorLeaf's that are dots, we will not do any + # completions since this probably just confuses the user. + return cached_name, [] + + # If we don't have a value, just use global completion. + return cached_name, self._complete_global_scope() + + allowed_transitions = \ + list(stack._allowed_transition_names_and_token_types()) + + if 'if' in allowed_transitions: + leaf = self._module_node.get_leaf_for_position(self._position, include_prefixes=True) + previous_leaf = leaf.get_previous_leaf() + + indent = self._position[1] + if not (leaf.start_pos <= self._position <= leaf.end_pos): + indent = leaf.start_pos[1] + + if previous_leaf is not None: + stmt = previous_leaf + while True: + stmt = search_ancestor( + stmt, 'if_stmt', 'for_stmt', 'while_stmt', 'try_stmt', + 'error_node', + ) + if stmt is None: + break + + type_ = stmt.type + if type_ == 'error_node': + first = stmt.children[0] + if isinstance(first, Leaf): + type_ = first.value + '_stmt' + # Compare indents + if stmt.start_pos[1] == indent: + if type_ == 'if_stmt': + allowed_transitions += ['elif', 'else'] + elif type_ == 'try_stmt': + allowed_transitions += ['except', 'finally', 'else'] + elif type_ == 'for_stmt': + allowed_transitions.append('else') + + completion_names = [] + + kwargs_only = False + if any(t in allowed_transitions for t in (PythonTokenTypes.NAME, + PythonTokenTypes.INDENT)): + # This means that we actually have to do type inference. + + nonterminals = [stack_node.nonterminal for stack_node in stack] + + nodes = _gather_nodes(stack) + if nodes and nodes[-1] in ('as', 'def', 'class'): + # No completions for ``with x as foo`` and ``import x as foo``. + # Also true for defining names as a class or function. + return cached_name, list(self._complete_inherited(is_function=True)) + elif "import_stmt" in nonterminals: + level, names = parse_dotted_names(nodes, "import_from" in nonterminals) + + only_modules = not ("import_from" in nonterminals and 'import' in nodes) + completion_names += self._get_importer_names( + names, + level, + only_modules=only_modules, + ) + elif nonterminals[-1] in ('trailer', 'dotted_name') and nodes[-1] == '.': + dot = self._module_node.get_leaf_for_position(self._position) + if dot.type == "endmarker": + # This is a bit of a weird edge case, maybe we can somehow + # generalize this. + dot = leaf.get_previous_leaf() + cached_name, n = self._complete_trailer(dot.get_previous_leaf()) + completion_names += n + elif self._is_parameter_completion(): + completion_names += self._complete_params(leaf) + else: + # Apparently this looks like it's good enough to filter most cases + # so that signature completions don't randomly appear. + # To understand why this works, three things are important: + # 1. trailer with a `,` in it is either a subscript or an arglist. + # 2. If there's no `,`, it's at the start and only signatures start + # with `(`. Other trailers could start with `.` or `[`. + # 3. Decorators are very primitive and have an optional `(` with + # optional arglist in them. + if nodes[-1] in ['(', ','] \ + and nonterminals[-1] in ('trailer', 'arglist', 'decorator'): + signatures = self._signatures_callback(*self._position) + if signatures: + call_details = signatures[0]._call_details + used_kwargs = list(call_details.iter_used_keyword_arguments()) + positional_count = call_details.count_positional_arguments() + + completion_names += _get_signature_param_names( + signatures, + positional_count, + used_kwargs, + ) + + kwargs_only = _must_be_kwarg(signatures, positional_count, used_kwargs) + + if not kwargs_only: + completion_names += self._complete_global_scope() + completion_names += self._complete_inherited(is_function=False) + + if not kwargs_only: + current_line = self._code_lines[self._position[0] - 1][:self._position[1]] + completion_names += self._complete_keywords( + allowed_transitions, + only_values=not (not current_line or current_line[-1] in ' \t.;' + and current_line[-3:] != '...') + ) + + return cached_name, completion_names + + def _is_parameter_completion(self): + tos = self.stack[-1] + if tos.nonterminal == 'lambdef' and len(tos.nodes) == 1: + # We are at the position `lambda `, where basically the next node + # is a param. + return True + if tos.nonterminal in 'parameters': + # Basically we are at the position `foo(`, there's nothing there + # yet, so we have no `typedargslist`. + return True + # var args is for lambdas and typed args for normal functions + return tos.nonterminal in ('typedargslist', 'varargslist') and tos.nodes[-1] == ',' + + def _complete_params(self, leaf): + stack_node = self.stack[-2] + if stack_node.nonterminal == 'parameters': + stack_node = self.stack[-3] + if stack_node.nonterminal == 'funcdef': + context = get_user_context(self._module_context, self._position) + node = search_ancestor(leaf, 'error_node', 'funcdef') + if node is not None: + if node.type == 'error_node': + n = node.children[0] + if n.type == 'decorators': + decorators = n.children + elif n.type == 'decorator': + decorators = [n] + else: + decorators = [] + else: + decorators = node.get_decorators() + function_name = stack_node.nodes[1] + + return complete_param_names(context, function_name.value, decorators) + return [] + + def _complete_keywords(self, allowed_transitions, only_values): + for k in allowed_transitions: + if isinstance(k, str) and k.isalpha(): + if not only_values or k in ('True', 'False', 'None'): + yield keywords.KeywordName(self._inference_state, k) + + def _complete_global_scope(self): + context = get_user_context(self._module_context, self._position) + debug.dbg('global completion scope: %s', context) + flow_scope_node = get_flow_scope_node(self._module_node, self._position) + filters = get_global_filters( + context, + self._position, + flow_scope_node + ) + completion_names = [] + for filter in filters: + completion_names += filter.values() + return completion_names + + def _complete_trailer(self, previous_leaf): + inferred_context = self._module_context.create_context(previous_leaf) + values = infer_call_of_leaf(inferred_context, previous_leaf) + debug.dbg('trailer completion values: %s', values, color='MAGENTA') + + # The cached name simply exists to make speed optimizations for certain + # modules. + cached_name = None + if len(values) == 1: + v, = values + if v.is_module(): + if len(v.string_names) == 1: + module_name = v.string_names[0] + if module_name in ('numpy', 'tensorflow', 'matplotlib', 'pandas'): + cached_name = module_name + + return cached_name, self._complete_trailer_for_values(values) + + def _complete_trailer_for_values(self, values): + user_context = get_user_context(self._module_context, self._position) + + return complete_trailer(user_context, values) + + def _get_importer_names(self, names, level=0, only_modules=True): + names = [n.value for n in names] + i = imports.Importer(self._inference_state, names, self._module_context, level) + return i.completion_names(self._inference_state, only_modules=only_modules) + + def _complete_inherited(self, is_function=True): + """ + Autocomplete inherited methods when overriding in child class. + """ + leaf = self._module_node.get_leaf_for_position(self._position, include_prefixes=True) + cls = tree.search_ancestor(leaf, 'classdef') + if cls is None: + return + + # Complete the methods that are defined in the super classes. + class_value = self._module_context.create_value(cls) + + if cls.start_pos[1] >= leaf.start_pos[1]: + return + + filters = class_value.get_filters(is_instance=True) + # The first dict is the dictionary of class itself. + next(filters) + for filter in filters: + for name in filter.values(): + # TODO we should probably check here for properties + if (name.api_type == 'function') == is_function: + yield name + + def _complete_in_string(self, start_leaf, string): + """ + To make it possible for people to have completions in doctests or + generally in "Python" code in docstrings, we use the following + heuristic: + + - Having an indented block of code + - Having some doctest code that starts with `>>>` + - Having backticks that doesn't have whitespace inside it + """ + + def iter_relevant_lines(lines): + include_next_line = False + for l in code_lines: + if include_next_line or l.startswith('>>>') or l.startswith(' '): + yield re.sub(r'^( *>>> ?| +)', '', l) + else: + yield None + + include_next_line = bool(re.match(' *>>>', l)) + + string = dedent(string) + code_lines = split_lines(string, keepends=True) + relevant_code_lines = list(iter_relevant_lines(code_lines)) + if relevant_code_lines[-1] is not None: + # Some code lines might be None, therefore get rid of that. + relevant_code_lines = ['\n' if c is None else c for c in relevant_code_lines] + return self._complete_code_lines(relevant_code_lines) + match = re.search(r'`([^`\s]+)', code_lines[-1]) + if match: + return self._complete_code_lines([match.group(1)]) + return [] + + def _complete_code_lines(self, code_lines): + module_node = self._inference_state.grammar.parse(''.join(code_lines)) + module_value = DocstringModule( + in_module_context=self._module_context, + inference_state=self._inference_state, + module_node=module_node, + code_lines=code_lines, + ) + return Completion( + self._inference_state, + module_value.as_context(), + code_lines=code_lines, + position=module_node.end_pos, + signatures_callback=lambda *args, **kwargs: [], + fuzzy=self._fuzzy + ).complete() + + +def _gather_nodes(stack): + nodes = [] + for stack_node in stack: + if stack_node.dfa.from_rule == 'small_stmt': + nodes = [] + else: + nodes += stack_node.nodes + return nodes + + +_string_start = re.compile(r'^\w*(\'{3}|"{3}|\'|")') + + +def _extract_string_while_in_string(leaf, position): + def return_part_of_leaf(leaf): + kwargs = {} + if leaf.line == position[0]: + kwargs['endpos'] = position[1] - leaf.column + match = _string_start.match(leaf.value, **kwargs) + if not match: + return None, None, None + start = match.group(0) + if leaf.line == position[0] and position[1] < leaf.column + match.end(): + return None, None, None + return cut_value_at_position(leaf, position)[match.end():], leaf, start + + if position < leaf.start_pos: + return None, None, None + + if leaf.type == 'string': + return return_part_of_leaf(leaf) + + leaves = [] + while leaf is not None: + if leaf.type == 'error_leaf' and ('"' in leaf.value or "'" in leaf.value): + if len(leaf.value) > 1: + return return_part_of_leaf(leaf) + prefix_leaf = None + if not leaf.prefix: + prefix_leaf = leaf.get_previous_leaf() + if prefix_leaf is None or prefix_leaf.type != 'name' \ + or not all(c in 'rubf' for c in prefix_leaf.value.lower()): + prefix_leaf = None + + return ( + ''.join(cut_value_at_position(l, position) for l in leaves), + prefix_leaf or leaf, + ('' if prefix_leaf is None else prefix_leaf.value) + + cut_value_at_position(leaf, position), + ) + if leaf.line != position[0]: + # Multi line strings are always simple error leaves and contain the + # whole string, single line error leaves are atherefore important + # now and since the line is different, it's not really a single + # line string anymore. + break + leaves.insert(0, leaf) + leaf = leaf.get_previous_leaf() + return None, None, None + + +def complete_trailer(user_context, values): + completion_names = [] + for value in values: + for filter in value.get_filters(origin_scope=user_context.tree_node): + completion_names += filter.values() + + if not value.is_stub() and isinstance(value, TreeInstance): + completion_names += _complete_getattr(user_context, value) + + python_values = convert_values(values) + for c in python_values: + if c not in values: + for filter in c.get_filters(origin_scope=user_context.tree_node): + completion_names += filter.values() + return completion_names + + +def _complete_getattr(user_context, instance): + """ + A heuristic to make completion for proxy objects work. This is not + intended to work in all cases. It works exactly in this case: + + def __getattr__(self, name): + ... + return getattr(any_object, name) + + It is important that the return contains getattr directly, otherwise it + won't work anymore. It's really just a stupid heuristic. It will not + work if you write e.g. `return (getatr(o, name))`, because of the + additional parentheses. It will also not work if you move the getattr + to some other place that is not the return statement itself. + + It is intentional that it doesn't work in all cases. Generally it's + really hard to do even this case (as you can see below). Most people + will write it like this anyway and the other ones, well they are just + out of luck I guess :) ~dave. + """ + names = (instance.get_function_slot_names('__getattr__') + or instance.get_function_slot_names('__getattribute__')) + functions = ValueSet.from_sets( + name.infer() + for name in names + ) + for func in functions: + tree_node = func.tree_node + if tree_node is None or tree_node.type != 'funcdef': + continue + + for return_stmt in tree_node.iter_return_stmts(): + # Basically until the next comment we just try to find out if a + # return statement looks exactly like `return getattr(x, name)`. + if return_stmt.type != 'return_stmt': + continue + atom_expr = return_stmt.children[1] + if atom_expr.type != 'atom_expr': + continue + atom = atom_expr.children[0] + trailer = atom_expr.children[1] + if len(atom_expr.children) != 2 or atom.type != 'name' \ + or atom.value != 'getattr': + continue + arglist = trailer.children[1] + if arglist.type != 'arglist' or len(arglist.children) < 3: + continue + context = func.as_context() + object_node = arglist.children[0] + + # Make sure it's a param: foo in __getattr__(self, foo) + name_node = arglist.children[2] + name_list = context.goto(name_node, name_node.start_pos) + if not any(n.api_type == 'param' for n in name_list): + continue + + # Now that we know that these are most probably completion + # objects, we just infer the object and return them as + # completions. + objects = context.infer_node(object_node) + return complete_trailer(user_context, objects) + return [] + + +def search_in_module(inference_state, module_context, names, wanted_names, + wanted_type, complete=False, fuzzy=False, + ignore_imports=False, convert=False): + for s in wanted_names[:-1]: + new_names = [] + for n in names: + if s == n.string_name: + if n.tree_name is not None and n.api_type in ('module', 'namespace') \ + and ignore_imports: + continue + new_names += complete_trailer( + module_context, + n.infer() + ) + debug.dbg('dot lookup on search %s from %s', new_names, names[:10]) + names = new_names + + last_name = wanted_names[-1].lower() + for n in names: + string = n.string_name.lower() + if complete and helpers.match(string, last_name, fuzzy=fuzzy) \ + or not complete and string == last_name: + if isinstance(n, SubModuleName): + names = [v.name for v in n.infer()] + else: + names = [n] + if convert: + names = convert_names(names) + for n2 in names: + if complete: + def_ = classes.Completion( + inference_state, n2, + stack=None, + like_name_length=len(last_name), + is_fuzzy=fuzzy, + ) + else: + def_ = classes.Name(inference_state, n2) + if not wanted_type or wanted_type == def_.type: + yield def_ + + +def extract_imported_names(node): + imported_names = [] + + if node.type in ['import_as_names', 'dotted_as_names', 'import_as_name']: + for index, child in enumerate(node.children): + if child.type == 'name': + if (index > 0 and node.children[index - 1].type == "keyword" + and node.children[index - 1].value == "as"): + continue + imported_names.append(child.value) + elif child.type == 'import_as_name': + imported_names.extend(extract_imported_names(child)) + + return imported_names diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/completion_cache.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/completion_cache.py new file mode 100644 index 0000000000000000000000000000000000000000..46e9bead210d817399113bed5db11e4e5e69e6cd --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/completion_cache.py @@ -0,0 +1,31 @@ +from typing import Dict, Tuple, Callable + +CacheValues = Tuple[str, str, str] +CacheValuesCallback = Callable[[], CacheValues] + + +_cache: Dict[str, Dict[str, CacheValues]] = {} + + +def save_entry(module_name: str, name: str, cache: CacheValues) -> None: + try: + module_cache = _cache[module_name] + except KeyError: + module_cache = _cache[module_name] = {} + module_cache[name] = cache + + +def _create_get_from_cache(number: int) -> Callable[[str, str, CacheValuesCallback], str]: + def _get_from_cache(module_name: str, name: str, get_cache_values: CacheValuesCallback) -> str: + try: + return _cache[module_name][name][number] + except KeyError: + v = get_cache_values() + save_entry(module_name, name, v) + return v[number] + return _get_from_cache + + +get_type = _create_get_from_cache(0) +get_docstring_signature = _create_get_from_cache(1) +get_docstring = _create_get_from_cache(2) diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/environment.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/environment.py new file mode 100644 index 0000000000000000000000000000000000000000..64b318e1ff7a3302155136afcccb0cca05b78fd1 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/environment.py @@ -0,0 +1,480 @@ +""" +Environments are a way to activate different Python versions or Virtualenvs for +static analysis. The Python binary in that environment is going to be executed. +""" +import os +import sys +import hashlib +import filecmp +from collections import namedtuple +from shutil import which +from typing import TYPE_CHECKING + +from jedi.cache import memoize_method, time_cache +from jedi.inference.compiled.subprocess import CompiledSubprocess, \ + InferenceStateSameProcess, InferenceStateSubprocess + +import parso + +if TYPE_CHECKING: + from jedi.inference import InferenceState + + +_VersionInfo = namedtuple('VersionInfo', 'major minor micro') # type: ignore[name-match] + +_SUPPORTED_PYTHONS = ['3.13', '3.12', '3.11', '3.10', '3.9', '3.8', '3.7', '3.6'] +_SAFE_PATHS = ['/usr/bin', '/usr/local/bin'] +_CONDA_VAR = 'CONDA_PREFIX' +_CURRENT_VERSION = '%s.%s' % (sys.version_info.major, sys.version_info.minor) + + +class InvalidPythonEnvironment(Exception): + """ + If you see this exception, the Python executable or Virtualenv you have + been trying to use is probably not a correct Python version. + """ + + +class _BaseEnvironment: + @memoize_method + def get_grammar(self): + version_string = '%s.%s' % (self.version_info.major, self.version_info.minor) + return parso.load_grammar(version=version_string) + + @property + def _sha256(self): + try: + return self._hash + except AttributeError: + self._hash = _calculate_sha256_for_file(self.executable) + return self._hash + + +def _get_info(): + return ( + sys.executable, + sys.prefix, + sys.version_info[:3], + ) + + +class Environment(_BaseEnvironment): + """ + This class is supposed to be created by internal Jedi architecture. You + should not create it directly. Please use create_environment or the other + functions instead. It is then returned by that function. + """ + _subprocess = None + + def __init__(self, executable, env_vars=None): + self._start_executable = executable + self._env_vars = env_vars + # Initialize the environment + self._get_subprocess() + + def _get_subprocess(self): + if self._subprocess is not None and not self._subprocess.is_crashed: + return self._subprocess + + try: + self._subprocess = CompiledSubprocess(self._start_executable, + env_vars=self._env_vars) + info = self._subprocess._send(None, _get_info) + except Exception as exc: + raise InvalidPythonEnvironment( + "Could not get version information for %r: %r" % ( + self._start_executable, + exc)) + + # Since it could change and might not be the same(?) as the one given, + # set it here. + self.executable = info[0] + """ + The Python executable, matches ``sys.executable``. + """ + self.path = info[1] + """ + The path to an environment, matches ``sys.prefix``. + """ + self.version_info = _VersionInfo(*info[2]) + """ + Like :data:`sys.version_info`: a tuple to show the current + Environment's Python version. + """ + return self._subprocess + + def __repr__(self): + version = '.'.join(str(i) for i in self.version_info) + return '<%s: %s in %s>' % (self.__class__.__name__, version, self.path) + + def get_inference_state_subprocess( + self, + inference_state: 'InferenceState', + ) -> InferenceStateSubprocess: + return InferenceStateSubprocess(inference_state, self._get_subprocess()) + + @memoize_method + def get_sys_path(self): + """ + The sys path for this environment. Does not include potential + modifications from e.g. appending to :data:`sys.path`. + + :returns: list of str + """ + # It's pretty much impossible to generate the sys path without actually + # executing Python. The sys path (when starting with -S) itself depends + # on how the Python version was compiled (ENV variables). + # If you omit -S when starting Python (normal case), additionally + # site.py gets executed. + return self._get_subprocess().get_sys_path() + + +class _SameEnvironmentMixin: + def __init__(self): + self._start_executable = self.executable = sys.executable + self.path = sys.prefix + self.version_info = _VersionInfo(*sys.version_info[:3]) + self._env_vars = None + + +class SameEnvironment(_SameEnvironmentMixin, Environment): + pass + + +class InterpreterEnvironment(_SameEnvironmentMixin, _BaseEnvironment): + def get_inference_state_subprocess( + self, + inference_state: 'InferenceState', + ) -> InferenceStateSameProcess: + return InferenceStateSameProcess(inference_state) + + def get_sys_path(self): + return sys.path + + +def _get_virtual_env_from_var(env_var='VIRTUAL_ENV'): + """Get virtualenv environment from VIRTUAL_ENV environment variable. + + It uses `safe=False` with ``create_environment``, because the environment + variable is considered to be safe / controlled by the user solely. + """ + var = os.environ.get(env_var) + if var: + # Under macOS in some cases - notably when using Pipenv - the + # sys.prefix of the virtualenv is /path/to/env/bin/.. instead of + # /path/to/env so we need to fully resolve the paths in order to + # compare them. + if os.path.realpath(var) == os.path.realpath(sys.prefix): + return _try_get_same_env() + + try: + return create_environment(var, safe=False) + except InvalidPythonEnvironment: + pass + + +def _calculate_sha256_for_file(path): + sha256 = hashlib.sha256() + with open(path, 'rb') as f: + for block in iter(lambda: f.read(filecmp.BUFSIZE), b''): + sha256.update(block) + return sha256.hexdigest() + + +def get_default_environment(): + """ + Tries to return an active Virtualenv or conda environment. + If there is no VIRTUAL_ENV variable or no CONDA_PREFIX variable set + set it will return the latest Python version installed on the system. This + makes it possible to use as many new Python features as possible when using + autocompletion and other functionality. + + :returns: :class:`.Environment` + """ + virtual_env = _get_virtual_env_from_var() + if virtual_env is not None: + return virtual_env + + conda_env = _get_virtual_env_from_var(_CONDA_VAR) + if conda_env is not None: + return conda_env + + return _try_get_same_env() + + +def _try_get_same_env(): + env = SameEnvironment() + if not os.path.basename(env.executable).lower().startswith('python'): + # This tries to counter issues with embedding. In some cases (e.g. + # VIM's Python Mac/Windows, sys.executable is /foo/bar/vim. This + # happens, because for Mac a function called `_NSGetExecutablePath` is + # used and for Windows `GetModuleFileNameW`. These are both platform + # specific functions. For all other systems sys.executable should be + # alright. However here we try to generalize: + # + # 1. Check if the executable looks like python (heuristic) + # 2. In case it's not try to find the executable + # 3. In case we don't find it use an interpreter environment. + # + # The last option will always work, but leads to potential crashes of + # Jedi - which is ok, because it happens very rarely and even less, + # because the code below should work for most cases. + if os.name == 'nt': + # The first case would be a virtualenv and the second a normal + # Python installation. + checks = (r'Scripts\python.exe', 'python.exe') + else: + # For unix it looks like Python is always in a bin folder. + checks = ( + 'bin/python%s.%s' % (sys.version_info[0], sys.version[1]), + 'bin/python%s' % (sys.version_info[0]), + 'bin/python', + ) + for check in checks: + guess = os.path.join(sys.exec_prefix, check) + if os.path.isfile(guess): + # Bingo - We think we have our Python. + return Environment(guess) + # It looks like there is no reasonable Python to be found. + return InterpreterEnvironment() + # If no virtualenv is found, use the environment we're already + # using. + return env + + +def get_cached_default_environment(): + var = os.environ.get('VIRTUAL_ENV') or os.environ.get(_CONDA_VAR) + environment = _get_cached_default_environment() + + # Under macOS in some cases - notably when using Pipenv - the + # sys.prefix of the virtualenv is /path/to/env/bin/.. instead of + # /path/to/env so we need to fully resolve the paths in order to + # compare them. + if var and os.path.realpath(var) != os.path.realpath(environment.path): + _get_cached_default_environment.clear_cache() + return _get_cached_default_environment() + return environment + + +@time_cache(seconds=10 * 60) # 10 Minutes +def _get_cached_default_environment(): + try: + return get_default_environment() + except InvalidPythonEnvironment: + # It's possible that `sys.executable` is wrong. Typically happens + # when Jedi is used in an executable that embeds Python. For further + # information, have a look at: + # https://github.com/davidhalter/jedi/issues/1531 + return InterpreterEnvironment() + + +def find_virtualenvs(paths=None, *, safe=True, use_environment_vars=True): + """ + :param paths: A list of paths in your file system to be scanned for + Virtualenvs. It will search in these paths and potentially execute the + Python binaries. + :param safe: Default True. In case this is False, it will allow this + function to execute potential `python` environments. An attacker might + be able to drop an executable in a path this function is searching by + default. If the executable has not been installed by root, it will not + be executed. + :param use_environment_vars: Default True. If True, the VIRTUAL_ENV + variable will be checked if it contains a valid VirtualEnv. + CONDA_PREFIX will be checked to see if it contains a valid conda + environment. + + :yields: :class:`.Environment` + """ + if paths is None: + paths = [] + + _used_paths = set() + + if use_environment_vars: + # Using this variable should be safe, because attackers might be + # able to drop files (via git) but not environment variables. + virtual_env = _get_virtual_env_from_var() + if virtual_env is not None: + yield virtual_env + _used_paths.add(virtual_env.path) + + conda_env = _get_virtual_env_from_var(_CONDA_VAR) + if conda_env is not None: + yield conda_env + _used_paths.add(conda_env.path) + + for directory in paths: + if not os.path.isdir(directory): + continue + + directory = os.path.abspath(directory) + for path in os.listdir(directory): + path = os.path.join(directory, path) + if path in _used_paths: + # A path shouldn't be inferred twice. + continue + _used_paths.add(path) + + try: + executable = _get_executable_path(path, safe=safe) + yield Environment(executable) + except InvalidPythonEnvironment: + pass + + +def find_system_environments(*, env_vars=None): + """ + Ignores virtualenvs and returns the Python versions that were installed on + your system. This might return nothing, if you're running Python e.g. from + a portable version. + + The environments are sorted from latest to oldest Python version. + + :yields: :class:`.Environment` + """ + for version_string in _SUPPORTED_PYTHONS: + try: + yield get_system_environment(version_string, env_vars=env_vars) + except InvalidPythonEnvironment: + pass + + +# TODO: this function should probably return a list of environments since +# multiple Python installations can be found on a system for the same version. +def get_system_environment(version, *, env_vars=None): + """ + Return the first Python environment found for a string of the form 'X.Y' + where X and Y are the major and minor versions of Python. + + :raises: :exc:`.InvalidPythonEnvironment` + :returns: :class:`.Environment` + """ + exe = which('python' + version) + if exe: + if exe == sys.executable: + return SameEnvironment() + return Environment(exe) + + if os.name == 'nt': + for exe in _get_executables_from_windows_registry(version): + try: + return Environment(exe, env_vars=env_vars) + except InvalidPythonEnvironment: + pass + raise InvalidPythonEnvironment("Cannot find executable python%s." % version) + + +def create_environment(path, *, safe=True, env_vars=None): + """ + Make it possible to manually create an Environment object by specifying a + Virtualenv path or an executable path and optional environment variables. + + :raises: :exc:`.InvalidPythonEnvironment` + :returns: :class:`.Environment` + """ + if os.path.isfile(path): + _assert_safe(path, safe) + return Environment(path, env_vars=env_vars) + return Environment(_get_executable_path(path, safe=safe), env_vars=env_vars) + + +def _get_executable_path(path, safe=True): + """ + Returns None if it's not actually a virtual env. + """ + + if os.name == 'nt': + pythons = [os.path.join(path, 'Scripts', 'python.exe'), os.path.join(path, 'python.exe')] + else: + pythons = [os.path.join(path, 'bin', 'python')] + for python in pythons: + if os.path.exists(python): + break + else: + raise InvalidPythonEnvironment("%s seems to be missing." % python) + + _assert_safe(python, safe) + return python + + +def _get_executables_from_windows_registry(version): + import winreg + + # TODO: support Python Anaconda. + sub_keys = [ + r'SOFTWARE\Python\PythonCore\{version}\InstallPath', + r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}\InstallPath', + r'SOFTWARE\Python\PythonCore\{version}-32\InstallPath', + r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}-32\InstallPath' + ] + for root_key in [winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE]: + for sub_key in sub_keys: + sub_key = sub_key.format(version=version) + try: + with winreg.OpenKey(root_key, sub_key) as key: + prefix = winreg.QueryValueEx(key, '')[0] + exe = os.path.join(prefix, 'python.exe') + if os.path.isfile(exe): + yield exe + except WindowsError: + pass + + +def _assert_safe(executable_path, safe): + if safe and not _is_safe(executable_path): + raise InvalidPythonEnvironment( + "The python binary is potentially unsafe.") + + +def _is_safe(executable_path): + # Resolve sym links. A venv typically is a symlink to a known Python + # binary. Only virtualenvs copy symlinks around. + real_path = os.path.realpath(executable_path) + + if _is_unix_safe_simple(real_path): + return True + + # Just check the list of known Python versions. If it's not in there, + # it's likely an attacker or some Python that was not properly + # installed in the system. + for environment in find_system_environments(): + if environment.executable == real_path: + return True + + # If the versions don't match, just compare the binary files. If we + # don't do that, only venvs will be working and not virtualenvs. + # venvs are symlinks while virtualenvs are actual copies of the + # Python files. + # This still means that if the system Python is updated and the + # virtualenv's Python is not (which is probably never going to get + # upgraded), it will not work with Jedi. IMO that's fine, because + # people should just be using venv. ~ dave + if environment._sha256 == _calculate_sha256_for_file(real_path): + return True + return False + + +def _is_unix_safe_simple(real_path): + if _is_unix_admin(): + # In case we are root, just be conservative and + # only execute known paths. + return any(real_path.startswith(p) for p in _SAFE_PATHS) + + uid = os.stat(real_path).st_uid + # The interpreter needs to be owned by root. This means that it wasn't + # written by a user and therefore attacking Jedi is not as simple. + # The attack could look like the following: + # 1. A user clones a repository. + # 2. The repository has an innocent looking folder called foobar. jedi + # searches for the folder and executes foobar/bin/python --version if + # there's also a foobar/bin/activate. + # 3. The attacker has gained code execution, since he controls + # foobar/bin/python. + return uid == 0 + + +def _is_unix_admin(): + try: + return os.getuid() == 0 + except AttributeError: + return False # Windows diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/exceptions.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..9db12e714de1dc1eb5bb6d3cbe631c456ec7a555 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/exceptions.py @@ -0,0 +1,31 @@ +class _JediError(Exception): + pass + + +class InternalError(_JediError): + """ + This error might happen a subprocess is crashing. The reason for this is + usually broken C code in third party libraries. This is not a very common + thing and it is safe to use Jedi again. However using the same calls might + result in the same error again. + """ + + +class WrongVersion(_JediError): + """ + This error is reserved for the future, shouldn't really be happening at the + moment. + """ + + +class RefactoringError(_JediError): + """ + Refactorings can fail for various reasons. So if you work with refactorings + like :meth:`.Script.rename`, :meth:`.Script.inline`, + :meth:`.Script.extract_variable` and :meth:`.Script.extract_function`, make + sure to catch these. The descriptions in the errors are usually valuable + for end users. + + A typical ``RefactoringError`` would tell the user that inlining is not + possible if no name is under the cursor. + """ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/helpers.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..111f75b44705dfe1f8c9f9ac179874426fe39819 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/helpers.py @@ -0,0 +1,522 @@ +""" +Helpers for the API +""" +import re +from collections import namedtuple +from textwrap import dedent +from itertools import chain +from functools import wraps +from inspect import Parameter + +from parso.python.parser import Parser +from parso.python import tree + +from jedi.inference.base_value import NO_VALUES +from jedi.inference.syntax_tree import infer_atom +from jedi.inference.helpers import infer_call_of_leaf +from jedi.inference.compiled import get_string_value_set +from jedi.cache import signature_time_cache, memoize_method +from jedi.parser_utils import get_parent_scope + + +CompletionParts = namedtuple('CompletionParts', ['path', 'has_dot', 'name']) + + +def _start_match(string, like_name): + return string.startswith(like_name) + + +def _fuzzy_match(string, like_name): + if len(like_name) <= 1: + return like_name in string + pos = string.find(like_name[0]) + if pos >= 0: + return _fuzzy_match(string[pos + 1:], like_name[1:]) + return False + + +def match(string, like_name, fuzzy=False): + if fuzzy: + return _fuzzy_match(string, like_name) + else: + return _start_match(string, like_name) + + +def sorted_definitions(defs): + # Note: `or ''` below is required because `module_path` could be + return sorted(defs, key=lambda x: (str(x.module_path or ''), + x.line or 0, + x.column or 0, + x.name)) + + +def get_on_completion_name(module_node, lines, position): + leaf = module_node.get_leaf_for_position(position) + if leaf is None or leaf.type in ('string', 'error_leaf'): + # Completions inside strings are a bit special, we need to parse the + # string. The same is true for comments and error_leafs. + line = lines[position[0] - 1] + # The first step of completions is to get the name + return re.search(r'(?!\d)\w+$|$', line[:position[1]]).group(0) + elif leaf.type not in ('name', 'keyword'): + return '' + + return leaf.value[:position[1] - leaf.start_pos[1]] + + +def _get_code(code_lines, start_pos, end_pos): + # Get relevant lines. + lines = code_lines[start_pos[0] - 1:end_pos[0]] + # Remove the parts at the end of the line. + lines[-1] = lines[-1][:end_pos[1]] + # Remove first line indentation. + lines[0] = lines[0][start_pos[1]:] + return ''.join(lines) + + +class OnErrorLeaf(Exception): + @property + def error_leaf(self): + return self.args[0] + + +def _get_code_for_stack(code_lines, leaf, position): + # It might happen that we're on whitespace or on a comment. This means + # that we would not get the right leaf. + if leaf.start_pos >= position: + # If we're not on a comment simply get the previous leaf and proceed. + leaf = leaf.get_previous_leaf() + if leaf is None: + return '' # At the beginning of the file. + + is_after_newline = leaf.type == 'newline' + while leaf.type == 'newline': + leaf = leaf.get_previous_leaf() + if leaf is None: + return '' + + if leaf.type == 'error_leaf' or leaf.type == 'string': + if leaf.start_pos[0] < position[0]: + # On a different line, we just begin anew. + return '' + + # Error leafs cannot be parsed, completion in strings is also + # impossible. + raise OnErrorLeaf(leaf) + else: + user_stmt = leaf + while True: + if user_stmt.parent.type in ('file_input', 'suite', 'simple_stmt'): + break + user_stmt = user_stmt.parent + + if is_after_newline: + if user_stmt.start_pos[1] > position[1]: + # This means that it's actually a dedent and that means that we + # start without value (part of a suite). + return '' + + # This is basically getting the relevant lines. + return _get_code(code_lines, user_stmt.get_start_pos_of_prefix(), position) + + +def get_stack_at_position(grammar, code_lines, leaf, pos): + """ + Returns the possible node names (e.g. import_from, xor_test or yield_stmt). + """ + class EndMarkerReached(Exception): + pass + + def tokenize_without_endmarker(code): + # TODO This is for now not an official parso API that exists purely + # for Jedi. + tokens = grammar._tokenize(code) + for token in tokens: + if token.string == safeword: + raise EndMarkerReached() + elif token.prefix.endswith(safeword): + # This happens with comments. + raise EndMarkerReached() + elif token.string.endswith(safeword): + yield token # Probably an f-string literal that was not finished. + raise EndMarkerReached() + else: + yield token + + # The code might be indedented, just remove it. + code = dedent(_get_code_for_stack(code_lines, leaf, pos)) + # We use a word to tell Jedi when we have reached the start of the + # completion. + # Use Z as a prefix because it's not part of a number suffix. + safeword = 'ZZZ_USER_WANTS_TO_COMPLETE_HERE_WITH_JEDI' + code = code + ' ' + safeword + + p = Parser(grammar._pgen_grammar, error_recovery=True) + try: + p.parse(tokens=tokenize_without_endmarker(code)) + except EndMarkerReached: + return p.stack + raise SystemError( + "This really shouldn't happen. There's a bug in Jedi:\n%s" + % list(tokenize_without_endmarker(code)) + ) + + +def infer(inference_state, context, leaf): + if leaf.type == 'name': + return inference_state.infer(context, leaf) + + parent = leaf.parent + definitions = NO_VALUES + if parent.type == 'atom': + # e.g. `(a + b)` + definitions = context.infer_node(leaf.parent) + elif parent.type == 'trailer': + # e.g. `a()` + definitions = infer_call_of_leaf(context, leaf) + elif isinstance(leaf, tree.Literal): + # e.g. `"foo"` or `1.0` + return infer_atom(context, leaf) + elif leaf.type in ('fstring_string', 'fstring_start', 'fstring_end'): + return get_string_value_set(inference_state) + return definitions + + +def filter_follow_imports(names, follow_builtin_imports=False): + for name in names: + if name.is_import(): + new_names = list(filter_follow_imports( + name.goto(), + follow_builtin_imports=follow_builtin_imports, + )) + found_builtin = False + if follow_builtin_imports: + for new_name in new_names: + if new_name.start_pos is None: + found_builtin = True + + if found_builtin: + yield name + else: + yield from new_names + else: + yield name + + +class CallDetails: + def __init__(self, bracket_leaf, children, position): + self.bracket_leaf = bracket_leaf + self._children = children + self._position = position + + @property + def index(self): + return _get_index_and_key(self._children, self._position)[0] + + @property + def keyword_name_str(self): + return _get_index_and_key(self._children, self._position)[1] + + @memoize_method + def _list_arguments(self): + return list(_iter_arguments(self._children, self._position)) + + def calculate_index(self, param_names): + positional_count = 0 + used_names = set() + star_count = -1 + args = self._list_arguments() + if not args: + if param_names: + return 0 + else: + return None + + is_kwarg = False + for i, (star_count, key_start, had_equal) in enumerate(args): + is_kwarg |= had_equal | (star_count == 2) + if star_count: + pass # For now do nothing, we don't know what's in there here. + else: + if i + 1 != len(args): # Not last + if had_equal: + used_names.add(key_start) + else: + positional_count += 1 + + for i, param_name in enumerate(param_names): + kind = param_name.get_kind() + + if not is_kwarg: + if kind == Parameter.VAR_POSITIONAL: + return i + if kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.POSITIONAL_ONLY): + if i == positional_count: + return i + + if key_start is not None and not star_count == 1 or star_count == 2: + if param_name.string_name not in used_names \ + and (kind == Parameter.KEYWORD_ONLY + or kind == Parameter.POSITIONAL_OR_KEYWORD + and positional_count <= i): + if star_count: + return i + if had_equal: + if param_name.string_name == key_start: + return i + else: + if param_name.string_name.startswith(key_start): + return i + + if kind == Parameter.VAR_KEYWORD: + return i + return None + + def iter_used_keyword_arguments(self): + for star_count, key_start, had_equal in list(self._list_arguments()): + if had_equal and key_start: + yield key_start + + def count_positional_arguments(self): + count = 0 + for star_count, key_start, had_equal in self._list_arguments()[:-1]: + if star_count or key_start: + break + count += 1 + return count + + +def _iter_arguments(nodes, position): + def remove_after_pos(name): + if name.type != 'name': + return None + return name.value[:position[1] - name.start_pos[1]] + + # Returns Generator[Tuple[star_count, Optional[key_start: str], had_equal]] + nodes_before = [c for c in nodes if c.start_pos < position] + if nodes_before[-1].type == 'arglist': + yield from _iter_arguments(nodes_before[-1].children, position) + return + + previous_node_yielded = False + stars_seen = 0 + for i, node in enumerate(nodes_before): + if node.type == 'argument': + previous_node_yielded = True + first = node.children[0] + second = node.children[1] + if second == '=': + if second.start_pos < position and first.type == 'name': + yield 0, first.value, True + else: + yield 0, remove_after_pos(first), False + elif first in ('*', '**'): + yield len(first.value), remove_after_pos(second), False + else: + # Must be a Comprehension + first_leaf = node.get_first_leaf() + if first_leaf.type == 'name' and first_leaf.start_pos >= position: + yield 0, remove_after_pos(first_leaf), False + else: + yield 0, None, False + stars_seen = 0 + elif node.type == 'testlist_star_expr': + for n in node.children[::2]: + if n.type == 'star_expr': + stars_seen = 1 + n = n.children[1] + yield stars_seen, remove_after_pos(n), False + stars_seen = 0 + # The count of children is even if there's a comma at the end. + previous_node_yielded = bool(len(node.children) % 2) + elif isinstance(node, tree.PythonLeaf) and node.value == ',': + if not previous_node_yielded: + yield stars_seen, '', False + stars_seen = 0 + previous_node_yielded = False + elif isinstance(node, tree.PythonLeaf) and node.value in ('*', '**'): + stars_seen = len(node.value) + elif node == '=' and nodes_before[-1]: + previous_node_yielded = True + before = nodes_before[i - 1] + if before.type == 'name': + yield 0, before.value, True + else: + yield 0, None, False + # Just ignore the star that is probably a syntax error. + stars_seen = 0 + + if not previous_node_yielded: + if nodes_before[-1].type == 'name': + yield stars_seen, remove_after_pos(nodes_before[-1]), False + else: + yield stars_seen, '', False + + +def _get_index_and_key(nodes, position): + """ + Returns the amount of commas and the keyword argument string. + """ + nodes_before = [c for c in nodes if c.start_pos < position] + if nodes_before[-1].type == 'arglist': + return _get_index_and_key(nodes_before[-1].children, position) + + key_str = None + + last = nodes_before[-1] + if last.type == 'argument' and last.children[1] == '=' \ + and last.children[1].end_pos <= position: + # Checked if the argument + key_str = last.children[0].value + elif last == '=': + key_str = nodes_before[-2].value + + return nodes_before.count(','), key_str + + +def _get_signature_details_from_error_node(node, additional_children, position): + for index, element in reversed(list(enumerate(node.children))): + # `index > 0` means that it's a trailer and not an atom. + if element == '(' and element.end_pos <= position and index > 0: + # It's an error node, we don't want to match too much, just + # until the parentheses is enough. + children = node.children[index:] + name = element.get_previous_leaf() + if name is None: + continue + if name.type == 'name' or name.parent.type in ('trailer', 'atom'): + return CallDetails(element, children + additional_children, position) + + +def get_signature_details(module, position): + leaf = module.get_leaf_for_position(position, include_prefixes=True) + # It's easier to deal with the previous token than the next one in this + # case. + if leaf.start_pos >= position: + # Whitespace / comments after the leaf count towards the previous leaf. + leaf = leaf.get_previous_leaf() + if leaf is None: + return None + + # Now that we know where we are in the syntax tree, we start to look at + # parents for possible function definitions. + node = leaf.parent + while node is not None: + if node.type in ('funcdef', 'classdef', 'decorated', 'async_stmt'): + # Don't show signatures if there's stuff before it that just + # makes it feel strange to have a signature. + return None + + additional_children = [] + for n in reversed(node.children): + if n.start_pos < position: + if n.type == 'error_node': + result = _get_signature_details_from_error_node( + n, additional_children, position + ) + if result is not None: + return result + + additional_children[0:0] = n.children + continue + additional_children.insert(0, n) + + # Find a valid trailer + if node.type == 'trailer' and node.children[0] == '(' \ + or node.type == 'decorator' and node.children[2] == '(': + # Additionally we have to check that an ending parenthesis isn't + # interpreted wrong. There are two cases: + # 1. Cursor before paren -> The current signature is good + # 2. Cursor after paren -> We need to skip the current signature + if not (leaf is node.children[-1] and position >= leaf.end_pos): + leaf = node.get_previous_leaf() + if leaf is None: + return None + return CallDetails( + node.children[0] if node.type == 'trailer' else node.children[2], + node.children, + position + ) + + node = node.parent + + return None + + +@signature_time_cache("call_signatures_validity") +def cache_signatures(inference_state, context, bracket_leaf, code_lines, user_pos): + """This function calculates the cache key.""" + line_index = user_pos[0] - 1 + + before_cursor = code_lines[line_index][:user_pos[1]] + other_lines = code_lines[bracket_leaf.start_pos[0]:line_index] + whole = ''.join(other_lines + [before_cursor]) + before_bracket = re.match(r'.*\(', whole, re.DOTALL) + + module_path = context.get_root_context().py__file__() + if module_path is None: + yield None # Don't cache! + else: + yield (module_path, before_bracket, bracket_leaf.start_pos) + yield infer( + inference_state, + context, + bracket_leaf.get_previous_leaf(), + ) + + +def validate_line_column(func): + @wraps(func) + def wrapper(self, line=None, column=None, *args, **kwargs): + line = max(len(self._code_lines), 1) if line is None else line + if not (0 < line <= len(self._code_lines)): + raise ValueError('`line` parameter is not in a valid range.') + + line_string = self._code_lines[line - 1] + line_len = len(line_string) + if line_string.endswith('\r\n'): + line_len -= 2 + elif line_string.endswith('\n'): + line_len -= 1 + + column = line_len if column is None else column + if not (0 <= column <= line_len): + raise ValueError('`column` parameter (%d) is not in a valid range ' + '(0-%d) for line %d (%r).' % ( + column, line_len, line, line_string)) + return func(self, line, column, *args, **kwargs) + return wrapper + + +def get_module_names(module, all_scopes, definitions=True, references=False): + """ + Returns a dictionary with name parts as keys and their call paths as + values. + """ + def def_ref_filter(name): + is_def = name.is_definition() + return definitions and is_def or references and not is_def + + names = list(chain.from_iterable(module.get_used_names().values())) + if not all_scopes: + # We have to filter all the names that don't have the module as a + # parent_scope. There's None as a parent, because nodes in the module + # node have the parent module and not suite as all the others. + # Therefore it's important to catch that case. + + def is_module_scope_name(name): + parent_scope = get_parent_scope(name) + # async functions have an extra wrapper. Strip it. + if parent_scope and parent_scope.type == 'async_stmt': + parent_scope = parent_scope.parent + return parent_scope in (module, None) + + names = [n for n in names if is_module_scope_name(n)] + return filter(def_ref_filter, names) + + +def split_search_string(name): + type, _, dotted_names = name.rpartition(' ') + if type == 'def': + type = 'function' + return type, dotted_names.split('.') diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/project.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/project.py new file mode 100644 index 0000000000000000000000000000000000000000..8927e7ea27276def440aa92c1ca7f371e405f46c --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/project.py @@ -0,0 +1,448 @@ +""" +Projects are a way to handle Python projects within Jedi. For simpler plugins +you might not want to deal with projects, but if you want to give the user more +flexibility to define sys paths and Python interpreters for a project, +:class:`.Project` is the perfect way to allow for that. + +Projects can be saved to disk and loaded again, to allow project definitions to +be used across repositories. +""" +import json +from pathlib import Path +from itertools import chain + +from jedi import debug +from jedi.api.environment import get_cached_default_environment, create_environment +from jedi.api.exceptions import WrongVersion +from jedi.api.completion import search_in_module +from jedi.api.helpers import split_search_string, get_module_names +from jedi.inference.imports import load_module_from_path, \ + load_namespace_from_path, iter_module_names +from jedi.inference.sys_path import discover_buildout_paths +from jedi.inference.cache import inference_state_as_method_param_cache +from jedi.inference.references import recurse_find_python_folders_and_files, search_in_file_ios +from jedi.file_io import FolderIO + +_CONFIG_FOLDER = '.jedi' +_CONTAINS_POTENTIAL_PROJECT = \ + 'setup.py', '.git', '.hg', 'requirements.txt', 'MANIFEST.in', 'pyproject.toml' + +_SERIALIZER_VERSION = 1 + + +def _try_to_skip_duplicates(func): + def wrapper(*args, **kwargs): + found_tree_nodes = [] + found_modules = [] + for definition in func(*args, **kwargs): + tree_node = definition._name.tree_name + if tree_node is not None and tree_node in found_tree_nodes: + continue + if definition.type == 'module' and definition.module_path is not None: + if definition.module_path in found_modules: + continue + found_modules.append(definition.module_path) + yield definition + found_tree_nodes.append(tree_node) + return wrapper + + +def _remove_duplicates_from_path(path): + used = set() + for p in path: + if p in used: + continue + used.add(p) + yield p + + +class Project: + """ + Projects are a simple way to manage Python folders and define how Jedi does + import resolution. It is mostly used as a parameter to :class:`.Script`. + Additionally there are functions to search a whole project. + """ + _environment = None + + @staticmethod + def _get_config_folder_path(base_path): + return base_path.joinpath(_CONFIG_FOLDER) + + @staticmethod + def _get_json_path(base_path): + return Project._get_config_folder_path(base_path).joinpath('project.json') + + @classmethod + def load(cls, path): + """ + Loads a project from a specific path. You should not provide the path + to ``.jedi/project.json``, but rather the path to the project folder. + + :param path: The path of the directory you want to use as a project. + """ + if isinstance(path, str): + path = Path(path) + with open(cls._get_json_path(path)) as f: + version, data = json.load(f) + + if version == 1: + return cls(**data) + else: + raise WrongVersion( + "The Jedi version of this project seems newer than what we can handle." + ) + + def save(self): + """ + Saves the project configuration in the project in ``.jedi/project.json``. + """ + data = dict(self.__dict__) + data.pop('_environment', None) + data.pop('_django', None) # TODO make django setting public? + data = {k.lstrip('_'): v for k, v in data.items()} + data['path'] = str(data['path']) + + self._get_config_folder_path(self._path).mkdir(parents=True, exist_ok=True) + with open(self._get_json_path(self._path), 'w') as f: + return json.dump((_SERIALIZER_VERSION, data), f) + + def __init__( + self, + path, + *, + environment_path=None, + load_unsafe_extensions=False, + sys_path=None, + added_sys_path=(), + smart_sys_path=True, + ) -> None: + """ + :param path: The base path for this project. + :param environment_path: The Python executable path, typically the path + of a virtual environment. + :param load_unsafe_extensions: Default False, Loads extensions that are not in the + sys path and in the local directories. With this option enabled, + this is potentially unsafe if you clone a git repository and + analyze it's code, because those compiled extensions will be + important and therefore have execution privileges. + :param sys_path: list of str. You can override the sys path if you + want. By default the ``sys.path.`` is generated by the + environment (virtualenvs, etc). + :param added_sys_path: list of str. Adds these paths at the end of the + sys path. + :param smart_sys_path: If this is enabled (default), adds paths from + local directories. Otherwise you will have to rely on your packages + being properly configured on the ``sys.path``. + """ + + if isinstance(path, str): + path = Path(path).absolute() + self._path = path + + self._environment_path = environment_path + if sys_path is not None: + # Remap potential pathlib.Path entries + sys_path = list(map(str, sys_path)) + self._sys_path = sys_path + self._smart_sys_path = smart_sys_path + self._load_unsafe_extensions = load_unsafe_extensions + self._django = False + # Remap potential pathlib.Path entries + self.added_sys_path = list(map(str, added_sys_path)) + """The sys path that is going to be added at the end of the """ + + @property + def path(self): + """ + The base path for this project. + """ + return self._path + + @property + def sys_path(self): + """ + The sys path provided to this project. This can be None and in that + case will be auto generated. + """ + return self._sys_path + + @property + def smart_sys_path(self): + """ + If the sys path is going to be calculated in a smart way, where + additional paths are added. + """ + return self._smart_sys_path + + @property + def load_unsafe_extensions(self): + """ + Wheter the project loads unsafe extensions. + """ + return self._load_unsafe_extensions + + @inference_state_as_method_param_cache() + def _get_base_sys_path(self, inference_state): + # The sys path has not been set explicitly. + sys_path = list(inference_state.environment.get_sys_path()) + try: + sys_path.remove('') + except ValueError: + pass + return sys_path + + @inference_state_as_method_param_cache() + def _get_sys_path(self, inference_state, add_parent_paths=True, add_init_paths=False): + """ + Keep this method private for all users of jedi. However internally this + one is used like a public method. + """ + suffixed = list(self.added_sys_path) + prefixed = [] + + if self._sys_path is None: + sys_path = list(self._get_base_sys_path(inference_state)) + else: + sys_path = list(self._sys_path) + + if self._smart_sys_path: + prefixed.append(str(self._path)) + + if inference_state.script_path is not None: + suffixed += map(str, discover_buildout_paths( + inference_state, + inference_state.script_path + )) + + if add_parent_paths: + # Collect directories in upward search by: + # 1. Skipping directories with __init__.py + # 2. Stopping immediately when above self._path + traversed = [] + for parent_path in inference_state.script_path.parents: + if parent_path == self._path \ + or self._path not in parent_path.parents: + break + if not add_init_paths \ + and parent_path.joinpath("__init__.py").is_file(): + continue + traversed.append(str(parent_path)) + + # AFAIK some libraries have imports like `foo.foo.bar`, which + # leads to the conclusion to by default prefer longer paths + # rather than shorter ones by default. + suffixed += reversed(traversed) + + if self._django: + prefixed.append(str(self._path)) + + path = prefixed + sys_path + suffixed + return list(_remove_duplicates_from_path(path)) + + def get_environment(self): + if self._environment is None: + if self._environment_path is not None: + self._environment = create_environment(self._environment_path, safe=False) + else: + self._environment = get_cached_default_environment() + return self._environment + + def search(self, string, *, all_scopes=False): + """ + Searches a name in the whole project. If the project is very big, + at some point Jedi will stop searching. However it's also very much + recommended to not exhaust the generator. Just display the first ten + results to the user. + + There are currently three different search patterns: + + - ``foo`` to search for a definition foo in any file or a file called + ``foo.py`` or ``foo.pyi``. + - ``foo.bar`` to search for the ``foo`` and then an attribute ``bar`` + in it. + - ``class foo.bar.Bar`` or ``def foo.bar.baz`` to search for a specific + API type. + + :param bool all_scopes: Default False; searches not only for + definitions on the top level of a module level, but also in + functions and classes. + :yields: :class:`.Name` + """ + return self._search_func(string, all_scopes=all_scopes) + + def complete_search(self, string, **kwargs): + """ + Like :meth:`.Script.search`, but completes that string. An empty string + lists all definitions in a project, so be careful with that. + + :param bool all_scopes: Default False; searches not only for + definitions on the top level of a module level, but also in + functions and classes. + :yields: :class:`.Completion` + """ + return self._search_func(string, complete=True, **kwargs) + + @_try_to_skip_duplicates + def _search_func(self, string, complete=False, all_scopes=False): + # Using a Script is they easiest way to get an empty module context. + from jedi import Script + s = Script('', project=self) + inference_state = s._inference_state + empty_module_context = s._get_module_context() + + debug.dbg('Search for string %s, complete=%s', string, complete) + wanted_type, wanted_names = split_search_string(string) + name = wanted_names[0] + stub_folder_name = name + '-stubs' + + ios = recurse_find_python_folders_and_files(FolderIO(str(self._path))) + file_ios = [] + + # 1. Search for modules in the current project + for folder_io, file_io in ios: + if file_io is None: + file_name = folder_io.get_base_name() + if file_name == name or file_name == stub_folder_name: + f = folder_io.get_file_io('__init__.py') + try: + m = load_module_from_path(inference_state, f).as_context() + except FileNotFoundError: + f = folder_io.get_file_io('__init__.pyi') + try: + m = load_module_from_path(inference_state, f).as_context() + except FileNotFoundError: + m = load_namespace_from_path(inference_state, folder_io).as_context() + else: + continue + else: + file_ios.append(file_io) + if Path(file_io.path).name in (name + '.py', name + '.pyi'): + m = load_module_from_path(inference_state, file_io).as_context() + else: + continue + + debug.dbg('Search of a specific module %s', m) + yield from search_in_module( + inference_state, + m, + names=[m.name], + wanted_type=wanted_type, + wanted_names=wanted_names, + complete=complete, + convert=True, + ignore_imports=True, + ) + + # 2. Search for identifiers in the project. + for module_context in search_in_file_ios(inference_state, file_ios, + name, complete=complete): + names = get_module_names(module_context.tree_node, all_scopes=all_scopes) + names = [module_context.create_name(n) for n in names] + names = _remove_imports(names) + yield from search_in_module( + inference_state, + module_context, + names=names, + wanted_type=wanted_type, + wanted_names=wanted_names, + complete=complete, + ignore_imports=True, + ) + + # 3. Search for modules on sys.path + sys_path = [ + p for p in self._get_sys_path(inference_state) + # Exclude the current folder which is handled by recursing the folders. + if p != self._path + ] + names = list(iter_module_names(inference_state, empty_module_context, sys_path)) + yield from search_in_module( + inference_state, + empty_module_context, + names=names, + wanted_type=wanted_type, + wanted_names=wanted_names, + complete=complete, + convert=True, + ) + + def __repr__(self): + return '<%s: %s>' % (self.__class__.__name__, self._path) + + +def _is_potential_project(path): + for name in _CONTAINS_POTENTIAL_PROJECT: + try: + if path.joinpath(name).exists(): + return True + except OSError: + continue + return False + + +def _is_django_path(directory): + """ Detects the path of the very well known Django library (if used) """ + try: + with open(directory.joinpath('manage.py'), 'rb') as f: + return b"DJANGO_SETTINGS_MODULE" in f.read() + except (FileNotFoundError, IsADirectoryError, PermissionError): + return False + + +def get_default_project(path=None): + """ + If a project is not defined by the user, Jedi tries to define a project by + itself as well as possible. Jedi traverses folders until it finds one of + the following: + + 1. A ``.jedi/config.json`` + 2. One of the following files: ``setup.py``, ``.git``, ``.hg``, + ``requirements.txt`` and ``MANIFEST.in``. + """ + if path is None: + path = Path.cwd() + elif isinstance(path, str): + path = Path(path) + + check = path.absolute() + probable_path = None + first_no_init_file = None + for dir in chain([check], check.parents): + try: + return Project.load(dir) + except (FileNotFoundError, IsADirectoryError, PermissionError): + pass + except NotADirectoryError: + continue + + if first_no_init_file is None: + if dir.joinpath('__init__.py').exists(): + # In the case that a __init__.py exists, it's in 99% just a + # Python package and the project sits at least one level above. + continue + elif not dir.is_file(): + first_no_init_file = dir + + if _is_django_path(dir): + project = Project(dir) + project._django = True + return project + + if probable_path is None and _is_potential_project(dir): + probable_path = dir + + if probable_path is not None: + return Project(probable_path) + + if first_no_init_file is not None: + return Project(first_no_init_file) + + curdir = path if path.is_dir() else path.parent + return Project(curdir) + + +def _remove_imports(names): + return [ + n for n in names + if n.tree_name is None or n.api_type not in ('module', 'namespace') + ] diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/refactoring/__init__.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/refactoring/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d453064793c245f252d36bb9cf57644192b43f84 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/refactoring/__init__.py @@ -0,0 +1,264 @@ +import difflib +from pathlib import Path +from typing import Dict, Iterable, Tuple + +from parso import split_lines + +from jedi.api.exceptions import RefactoringError +from jedi.inference.value.namespace import ImplicitNSName + +EXPRESSION_PARTS = ( + 'or_test and_test not_test comparison ' + 'expr xor_expr and_expr shift_expr arith_expr term factor power atom_expr' +).split() + + +class ChangedFile: + def __init__(self, inference_state, from_path, to_path, + module_node, node_to_str_map): + self._inference_state = inference_state + self._from_path = from_path + self._to_path = to_path + self._module_node = module_node + self._node_to_str_map = node_to_str_map + + def get_diff(self): + old_lines = split_lines(self._module_node.get_code(), keepends=True) + new_lines = split_lines(self.get_new_code(), keepends=True) + + # Add a newline at the end if it's missing. Otherwise the diff will be + # very weird. A `diff -u file1 file2` would show the string: + # + # \ No newline at end of file + # + # This is not necessary IMO, because Jedi does not really play with + # newlines and the ending newline does not really matter in Python + # files. ~dave + if old_lines[-1] != '': + old_lines[-1] += '\n' + if new_lines[-1] != '': + new_lines[-1] += '\n' + + project_path = self._inference_state.project.path + if self._from_path is None: + from_p = '' + else: + try: + from_p = self._from_path.relative_to(project_path) + except ValueError: # Happens it the path is not on th project_path + from_p = self._from_path + if self._to_path is None: + to_p = '' + else: + try: + to_p = self._to_path.relative_to(project_path) + except ValueError: + to_p = self._to_path + diff = difflib.unified_diff( + old_lines, new_lines, + fromfile=str(from_p), + tofile=str(to_p), + ) + # Apparently there's a space at the end of the diff - for whatever + # reason. + return ''.join(diff).rstrip(' ') + + def get_new_code(self): + return self._inference_state.grammar.refactor(self._module_node, self._node_to_str_map) + + def apply(self): + if self._from_path is None: + raise RefactoringError( + 'Cannot apply a refactoring on a Script with path=None' + ) + + with open(self._from_path, 'w', newline='') as f: + f.write(self.get_new_code()) + + def __repr__(self): + return '<%s: %s>' % (self.__class__.__name__, self._from_path) + + +class Refactoring: + def __init__(self, inference_state, file_to_node_changes, renames=()): + self._inference_state = inference_state + self._renames = renames + self._file_to_node_changes = file_to_node_changes + + def get_changed_files(self) -> Dict[Path, ChangedFile]: + def calculate_to_path(p): + if p is None: + return p + p = str(p) + for from_, to in renames: + if p.startswith(str(from_)): + p = str(to) + p[len(str(from_)):] + return Path(p) + + renames = self.get_renames() + return { + path: ChangedFile( + self._inference_state, + from_path=path, + to_path=calculate_to_path(path), + module_node=next(iter(map_)).get_root_node(), + node_to_str_map=map_ + ) + # We need to use `or`, because the path can be None + for path, map_ in sorted( + self._file_to_node_changes.items(), + key=lambda x: x[0] or Path("") + ) + } + + def get_renames(self) -> Iterable[Tuple[Path, Path]]: + """ + Files can be renamed in a refactoring. + """ + return sorted(self._renames) + + def get_diff(self): + text = '' + project_path = self._inference_state.project.path + for from_, to in self.get_renames(): + text += 'rename from %s\nrename to %s\n' \ + % (_try_relative_to(from_, project_path), _try_relative_to(to, project_path)) + + return text + ''.join(f.get_diff() for f in self.get_changed_files().values()) + + def apply(self): + """ + Applies the whole refactoring to the files, which includes renames. + """ + for f in self.get_changed_files().values(): + f.apply() + + for old, new in self.get_renames(): + old.rename(new) + + +def _calculate_rename(path, new_name): + dir_ = path.parent + if path.name in ('__init__.py', '__init__.pyi'): + return dir_, dir_.parent.joinpath(new_name) + return path, dir_.joinpath(new_name + path.suffix) + + +def rename(inference_state, definitions, new_name): + file_renames = set() + file_tree_name_map = {} + + if not definitions: + raise RefactoringError("There is no name under the cursor") + + for d in definitions: + # This private access is ok in a way. It's not public to + # protect Jedi users from seeing it. + tree_name = d._name.tree_name + if d.type == 'module' and tree_name is None and d.module_path is not None: + p = Path(d.module_path) + file_renames.add(_calculate_rename(p, new_name)) + elif isinstance(d._name, ImplicitNSName): + for p in d._name._value.py__path__(): + file_renames.add(_calculate_rename(Path(p), new_name)) + else: + if tree_name is not None: + fmap = file_tree_name_map.setdefault(d.module_path, {}) + fmap[tree_name] = tree_name.prefix + new_name + return Refactoring(inference_state, file_tree_name_map, file_renames) + + +def inline(inference_state, names): + if not names: + raise RefactoringError("There is no name under the cursor") + if any(n.api_type in ('module', 'namespace') for n in names): + raise RefactoringError("Cannot inline imports, modules or namespaces") + if any(n.tree_name is None for n in names): + raise RefactoringError("Cannot inline builtins/extensions") + + definitions = [n for n in names if n.tree_name.is_definition()] + if len(definitions) == 0: + raise RefactoringError("No definition found to inline") + if len(definitions) > 1: + raise RefactoringError("Cannot inline a name with multiple definitions") + if len(names) == 1: + raise RefactoringError("There are no references to this name") + + tree_name = definitions[0].tree_name + + expr_stmt = tree_name.get_definition() + if expr_stmt.type != 'expr_stmt': + type_ = dict( + funcdef='function', + classdef='class', + ).get(expr_stmt.type, expr_stmt.type) + raise RefactoringError("Cannot inline a %s" % type_) + + if len(expr_stmt.get_defined_names(include_setitem=True)) > 1: + raise RefactoringError("Cannot inline a statement with multiple definitions") + first_child = expr_stmt.children[1] + if first_child.type == 'annassign' and len(first_child.children) == 4: + first_child = first_child.children[2] + if first_child != '=': + if first_child.type == 'annassign': + raise RefactoringError( + 'Cannot inline a statement that is defined by an annotation' + ) + else: + raise RefactoringError( + 'Cannot inline a statement with "%s"' + % first_child.get_code(include_prefix=False) + ) + + rhs = expr_stmt.get_rhs() + replace_code = rhs.get_code(include_prefix=False) + + references = [n for n in names if not n.tree_name.is_definition()] + file_to_node_changes = {} + for name in references: + tree_name = name.tree_name + path = name.get_root_context().py__file__() + s = replace_code + if rhs.type == 'testlist_star_expr' \ + or tree_name.parent.type in EXPRESSION_PARTS \ + or tree_name.parent.type == 'trailer' \ + and tree_name.parent.get_next_sibling() is not None: + s = '(' + replace_code + ')' + + of_path = file_to_node_changes.setdefault(path, {}) + + n = tree_name + prefix = n.prefix + par = n.parent + if par.type == 'trailer' and par.children[0] == '.': + prefix = par.parent.children[0].prefix + n = par + for some_node in par.parent.children[:par.parent.children.index(par)]: + of_path[some_node] = '' + of_path[n] = prefix + s + + path = definitions[0].get_root_context().py__file__() + changes = file_to_node_changes.setdefault(path, {}) + changes[expr_stmt] = _remove_indent_of_prefix(expr_stmt.get_first_leaf().prefix) + next_leaf = expr_stmt.get_next_leaf() + + # Most of the time we have to remove the newline at the end of the + # statement, but if there's a comment we might not need to. + if next_leaf.prefix.strip(' \t') == '' \ + and (next_leaf.type == 'newline' or next_leaf == ';'): + changes[next_leaf] = '' + return Refactoring(inference_state, file_to_node_changes) + + +def _remove_indent_of_prefix(prefix): + r""" + Removes the last indentation of a prefix, e.g. " \n \n " becomes " \n \n". + """ + return ''.join(split_lines(prefix, keepends=True)[:-1]) + + +def _try_relative_to(path: Path, base: Path) -> Path: + try: + return path.relative_to(base) + except ValueError: + return path diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/replstartup.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/replstartup.py new file mode 100644 index 0000000000000000000000000000000000000000..e0f23d19b71082fad3b92cc760b069dce92faa21 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/replstartup.py @@ -0,0 +1,29 @@ +""" +To use Jedi completion in Python interpreter, add the following in your shell +setup (e.g., ``.bashrc``). This works only on Linux/Mac, because readline is +not available on Windows. If you still want Jedi autocompletion in your REPL, +just use IPython instead:: + + export PYTHONSTARTUP="$(python -m jedi repl)" + +Then you will be able to use Jedi completer in your Python interpreter:: + + $ python + Python 3.9.2+ (default, Jul 20 2020, 22:15:08) + [GCC 4.6.1] on linux2 + Type "help", "copyright", "credits" or "license" for more information. + >>> import os + >>> os.path.join('a', 'b').split().in # doctest: +SKIP + ..dex ..sert + +""" +import jedi.utils +from jedi import __version__ as __jedi_version__ + +print('REPL completion using Jedi %s' % __jedi_version__) +jedi.utils.setup_readline(fuzzy=False) + +del jedi + +# Note: try not to do many things here, as it will contaminate global +# namespace of the interpreter. diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/strings.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/strings.py new file mode 100644 index 0000000000000000000000000000000000000000..7850142c5e1470a0c6c2a3313f205defbd35fb85 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/api/strings.py @@ -0,0 +1,111 @@ +""" +This module is here for string completions. This means mostly stuff where +strings are returned, like `foo = dict(bar=3); foo["ba` would complete to +`"bar"]`. + +It however does the same for numbers. The difference between string completions +and other completions is mostly that this module doesn't return defined +names in a module, but pretty much an arbitrary string. +""" +import re + +from jedi.inference.names import AbstractArbitraryName +from jedi.inference.helpers import infer_call_of_leaf +from jedi.api.classes import Completion +from jedi.parser_utils import cut_value_at_position + +_sentinel = object() + + +class StringName(AbstractArbitraryName): + api_type = 'string' + is_value_name = False + + +def complete_dict(module_context, code_lines, leaf, position, string, fuzzy): + bracket_leaf = leaf + if bracket_leaf != '[': + bracket_leaf = leaf.get_previous_leaf() + + cut_end_quote = '' + if string: + cut_end_quote = get_quote_ending(string, code_lines, position, invert_result=True) + + if bracket_leaf == '[': + if string is None and leaf is not bracket_leaf: + string = cut_value_at_position(leaf, position) + + context = module_context.create_context(bracket_leaf) + + before_node = before_bracket_leaf = bracket_leaf.get_previous_leaf() + if before_node in (')', ']', '}'): + before_node = before_node.parent + if before_node.type in ('atom', 'trailer', 'name'): + values = infer_call_of_leaf(context, before_bracket_leaf) + return list(_completions_for_dicts( + module_context.inference_state, + values, + '' if string is None else string, + cut_end_quote, + fuzzy=fuzzy, + )) + return [] + + +def _completions_for_dicts(inference_state, dicts, literal_string, cut_end_quote, fuzzy): + for dict_key in sorted(_get_python_keys(dicts), key=lambda x: repr(x)): + dict_key_str = _create_repr_string(literal_string, dict_key) + if dict_key_str.startswith(literal_string): + name = StringName(inference_state, dict_key_str[:-len(cut_end_quote) or None]) + yield Completion( + inference_state, + name, + stack=None, + like_name_length=len(literal_string), + is_fuzzy=fuzzy + ) + + +def _create_repr_string(literal_string, dict_key): + if not isinstance(dict_key, (str, bytes)) or not literal_string: + return repr(dict_key) + + r = repr(dict_key) + prefix, quote = _get_string_prefix_and_quote(literal_string) + if quote is None: + return r + if quote == r[0]: + return prefix + r + return prefix + quote + r[1:-1] + quote + + +def _get_python_keys(dicts): + for dct in dicts: + if dct.array_type == 'dict': + for key in dct.get_key_values(): + dict_key = key.get_safe_value(default=_sentinel) + if dict_key is not _sentinel: + yield dict_key + + +def _get_string_prefix_and_quote(string): + match = re.match(r'(\w*)("""|\'{3}|"|\')', string) + if match is None: + return None, None + return match.group(1), match.group(2) + + +def _matches_quote_at_position(code_lines, quote, position): + string = code_lines[position[0] - 1][position[1]:position[1] + len(quote)] + return string == quote + + +def get_quote_ending(string, code_lines, position, invert_result=False): + _, quote = _get_string_prefix_and_quote(string) + if quote is None: + return '' + + # Add a quote only if it's not already there. + if _matches_quote_at_position(code_lines, quote, position) != invert_result: + return '' + return quote diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_cloudpickle_wrapper.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_cloudpickle_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..daf899d04ff513e1ce9c9c41871adcfd72c8fcf7 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_cloudpickle_wrapper.py @@ -0,0 +1,19 @@ +""" +Small shim of loky's cloudpickle_wrapper to avoid failure when +multiprocessing is not available. +""" + + +from ._multiprocessing_helpers import mp + + +def _my_wrap_non_picklable_objects(obj, keep_wrapper=True): + return obj + + +if mp is not None: + from .externals.loky import wrap_non_picklable_objects +else: + wrap_non_picklable_objects = _my_wrap_non_picklable_objects + +__all__ = ["wrap_non_picklable_objects"] diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_memmapping_reducer.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_memmapping_reducer.py new file mode 100644 index 0000000000000000000000000000000000000000..13f5c4a17ef0794dc965ca3e3a3ef216125e2946 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_memmapping_reducer.py @@ -0,0 +1,657 @@ +""" +Reducer using memory mapping for numpy arrays +""" +# Author: Thomas Moreau +# Copyright: 2017, Thomas Moreau +# License: BSD 3 clause + +from mmap import mmap +import errno +import os +import stat +import threading +import atexit +import tempfile +import time +import warnings +import weakref +from uuid import uuid4 +from multiprocessing import util + +from pickle import whichmodule, loads, dumps, HIGHEST_PROTOCOL, PicklingError + +try: + WindowsError +except NameError: + WindowsError = type(None) + +try: + import numpy as np + from numpy.lib.stride_tricks import as_strided +except ImportError: + np = None + +from .numpy_pickle import dump, load, load_temporary_memmap +from .backports import make_memmap +from .disk import delete_folder +from .externals.loky.backend import resource_tracker + +# Some system have a ramdisk mounted by default, we can use it instead of /tmp +# as the default folder to dump big arrays to share with subprocesses. +SYSTEM_SHARED_MEM_FS = '/dev/shm' + +# Minimal number of bytes available on SYSTEM_SHARED_MEM_FS to consider using +# it as the default folder to dump big arrays to share with subprocesses. +SYSTEM_SHARED_MEM_FS_MIN_SIZE = int(2e9) + +# Folder and file permissions to chmod temporary files generated by the +# memmapping pool. Only the owner of the Python process can access the +# temporary files and folder. +FOLDER_PERMISSIONS = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR +FILE_PERMISSIONS = stat.S_IRUSR | stat.S_IWUSR + +# Set used in joblib workers, referencing the filenames of temporary memmaps +# created by joblib to speed up data communication. In child processes, we add +# a finalizer to these memmaps that sends a maybe_unlink call to the +# resource_tracker, in order to free main memory as fast as possible. +JOBLIB_MMAPS = set() + + +def _log_and_unlink(filename): + from .externals.loky.backend.resource_tracker import _resource_tracker + util.debug( + "[FINALIZER CALL] object mapping to {} about to be deleted," + " decrementing the refcount of the file (pid: {})".format( + os.path.basename(filename), os.getpid())) + _resource_tracker.maybe_unlink(filename, "file") + + +def add_maybe_unlink_finalizer(memmap): + util.debug( + "[FINALIZER ADD] adding finalizer to {} (id {}, filename {}, pid {})" + "".format(type(memmap), id(memmap), os.path.basename(memmap.filename), + os.getpid())) + weakref.finalize(memmap, _log_and_unlink, memmap.filename) + + +def unlink_file(filename): + """Wrapper around os.unlink with a retry mechanism. + + The retry mechanism has been implemented primarily to overcome a race + condition happening during the finalizer of a np.memmap: when a process + holding the last reference to a mmap-backed np.memmap/np.array is about to + delete this array (and close the reference), it sends a maybe_unlink + request to the resource_tracker. This request can be processed faster than + it takes for the last reference of the memmap to be closed, yielding (on + Windows) a PermissionError in the resource_tracker loop. + """ + NUM_RETRIES = 10 + for retry_no in range(1, NUM_RETRIES + 1): + try: + os.unlink(filename) + break + except PermissionError: + util.debug( + '[ResourceTracker] tried to unlink {}, got ' + 'PermissionError'.format(filename) + ) + if retry_no == NUM_RETRIES: + raise + else: + time.sleep(.2) + except FileNotFoundError: + # In case of a race condition when deleting the temporary folder, + # avoid noisy FileNotFoundError exception in the resource tracker. + pass + + +resource_tracker._CLEANUP_FUNCS['file'] = unlink_file + + +class _WeakArrayKeyMap: + """A variant of weakref.WeakKeyDictionary for unhashable numpy arrays. + + This datastructure will be used with numpy arrays as obj keys, therefore we + do not use the __get__ / __set__ methods to avoid any conflict with the + numpy fancy indexing syntax. + """ + + def __init__(self): + self._data = {} + + def get(self, obj): + ref, val = self._data[id(obj)] + if ref() is not obj: + # In case of race condition with on_destroy: could never be + # triggered by the joblib tests with CPython. + raise KeyError(obj) + return val + + def set(self, obj, value): + key = id(obj) + try: + ref, _ = self._data[key] + if ref() is not obj: + # In case of race condition with on_destroy: could never be + # triggered by the joblib tests with CPython. + raise KeyError(obj) + except KeyError: + # Insert the new entry in the mapping along with a weakref + # callback to automatically delete the entry from the mapping + # as soon as the object used as key is garbage collected. + def on_destroy(_): + del self._data[key] + ref = weakref.ref(obj, on_destroy) + self._data[key] = ref, value + + def __getstate__(self): + raise PicklingError("_WeakArrayKeyMap is not pickleable") + + +############################################################################### +# Support for efficient transient pickling of numpy data structures + + +def _get_backing_memmap(a): + """Recursively look up the original np.memmap instance base if any.""" + b = getattr(a, 'base', None) + if b is None: + # TODO: check scipy sparse datastructure if scipy is installed + # a nor its descendants do not have a memmap base + return None + + elif isinstance(b, mmap): + # a is already a real memmap instance. + return a + + else: + # Recursive exploration of the base ancestry + return _get_backing_memmap(b) + + +def _get_temp_dir(pool_folder_name, temp_folder=None): + """Get the full path to a subfolder inside the temporary folder. + + Parameters + ---------- + pool_folder_name : str + Sub-folder name used for the serialization of a pool instance. + + temp_folder: str, optional + Folder to be used by the pool for memmapping large arrays + for sharing memory with worker processes. If None, this will try in + order: + + - a folder pointed by the JOBLIB_TEMP_FOLDER environment + variable, + - /dev/shm if the folder exists and is writable: this is a + RAMdisk filesystem available by default on modern Linux + distributions, + - the default system temporary folder that can be + overridden with TMP, TMPDIR or TEMP environment + variables, typically /tmp under Unix operating systems. + + Returns + ------- + pool_folder : str + full path to the temporary folder + use_shared_mem : bool + whether the temporary folder is written to the system shared memory + folder or some other temporary folder. + """ + use_shared_mem = False + if temp_folder is None: + temp_folder = os.environ.get('JOBLIB_TEMP_FOLDER', None) + if temp_folder is None: + if os.path.exists(SYSTEM_SHARED_MEM_FS) and hasattr(os, 'statvfs'): + try: + shm_stats = os.statvfs(SYSTEM_SHARED_MEM_FS) + available_nbytes = shm_stats.f_bsize * shm_stats.f_bavail + if available_nbytes > SYSTEM_SHARED_MEM_FS_MIN_SIZE: + # Try to see if we have write access to the shared mem + # folder only if it is reasonably large (that is 2GB or + # more). + temp_folder = SYSTEM_SHARED_MEM_FS + pool_folder = os.path.join(temp_folder, pool_folder_name) + if not os.path.exists(pool_folder): + os.makedirs(pool_folder) + use_shared_mem = True + except (IOError, OSError): + # Missing rights in the /dev/shm partition, fallback to regular + # temp folder. + temp_folder = None + if temp_folder is None: + # Fallback to the default tmp folder, typically /tmp + temp_folder = tempfile.gettempdir() + temp_folder = os.path.abspath(os.path.expanduser(temp_folder)) + pool_folder = os.path.join(temp_folder, pool_folder_name) + return pool_folder, use_shared_mem + + +def has_shareable_memory(a): + """Return True if a is backed by some mmap buffer directly or not.""" + return _get_backing_memmap(a) is not None + + +def _strided_from_memmap(filename, dtype, mode, offset, order, shape, strides, + total_buffer_len, unlink_on_gc_collect): + """Reconstruct an array view on a memory mapped file.""" + if mode == 'w+': + # Do not zero the original data when unpickling + mode = 'r+' + + if strides is None: + # Simple, contiguous memmap + return make_memmap( + filename, dtype=dtype, shape=shape, mode=mode, offset=offset, + order=order, unlink_on_gc_collect=unlink_on_gc_collect + ) + else: + # For non-contiguous data, memmap the total enclosing buffer and then + # extract the non-contiguous view with the stride-tricks API + base = make_memmap( + filename, dtype=dtype, shape=total_buffer_len, offset=offset, + mode=mode, order=order, unlink_on_gc_collect=unlink_on_gc_collect + ) + return as_strided(base, shape=shape, strides=strides) + + +def _reduce_memmap_backed(a, m): + """Pickling reduction for memmap backed arrays. + + a is expected to be an instance of np.ndarray (or np.memmap) + m is expected to be an instance of np.memmap on the top of the ``base`` + attribute ancestry of a. ``m.base`` should be the real python mmap object. + """ + # offset that comes from the striding differences between a and m + util.debug('[MEMMAP REDUCE] reducing a memmap-backed array ' + '(shape, {}, pid: {})'.format(a.shape, os.getpid())) + try: + from numpy.lib.array_utils import byte_bounds + except (ModuleNotFoundError, ImportError): + # Backward-compat for numpy < 2.0 + from numpy import byte_bounds + a_start, a_end = byte_bounds(a) + m_start = byte_bounds(m)[0] + offset = a_start - m_start + + # offset from the backing memmap + offset += m.offset + + if m.flags['F_CONTIGUOUS']: + order = 'F' + else: + # The backing memmap buffer is necessarily contiguous hence C if not + # Fortran + order = 'C' + + if a.flags['F_CONTIGUOUS'] or a.flags['C_CONTIGUOUS']: + # If the array is a contiguous view, no need to pass the strides + strides = None + total_buffer_len = None + else: + # Compute the total number of items to map from which the strided + # view will be extracted. + strides = a.strides + total_buffer_len = (a_end - a_start) // a.itemsize + + return (_strided_from_memmap, + (m.filename, a.dtype, m.mode, offset, order, a.shape, strides, + total_buffer_len, False)) + + +def reduce_array_memmap_backward(a): + """reduce a np.array or a np.memmap from a child process""" + m = _get_backing_memmap(a) + if isinstance(m, np.memmap) and m.filename not in JOBLIB_MMAPS: + # if a is backed by a memmaped file, reconstruct a using the + # memmaped file. + return _reduce_memmap_backed(a, m) + else: + # a is either a regular (not memmap-backed) numpy array, or an array + # backed by a shared temporary file created by joblib. In the latter + # case, in order to limit the lifespan of these temporary files, we + # serialize the memmap as a regular numpy array, and decref the + # file backing the memmap (done implicitly in a previously registered + # finalizer, see ``unlink_on_gc_collect`` for more details) + return ( + loads, (dumps(np.asarray(a), protocol=HIGHEST_PROTOCOL), ) + ) + + +class ArrayMemmapForwardReducer(object): + """Reducer callable to dump large arrays to memmap files. + + Parameters + ---------- + max_nbytes: int + Threshold to trigger memmapping of large arrays to files created + a folder. + temp_folder_resolver: callable + An callable in charge of resolving a temporary folder name where files + for backing memmapped arrays are created. + mmap_mode: 'r', 'r+' or 'c' + Mode for the created memmap datastructure. See the documentation of + numpy.memmap for more details. Note: 'w+' is coerced to 'r+' + automatically to avoid zeroing the data on unpickling. + verbose: int, optional, 0 by default + If verbose > 0, memmap creations are logged. + If verbose > 1, both memmap creations, reuse and array pickling are + logged. + prewarm: bool, optional, False by default. + Force a read on newly memmapped array to make sure that OS pre-cache it + memory. This can be useful to avoid concurrent disk access when the + same data array is passed to different worker processes. + """ + + def __init__(self, max_nbytes, temp_folder_resolver, mmap_mode, + unlink_on_gc_collect, verbose=0, prewarm=True): + self._max_nbytes = max_nbytes + self._temp_folder_resolver = temp_folder_resolver + self._mmap_mode = mmap_mode + self.verbose = int(verbose) + if prewarm == "auto": + self._prewarm = not self._temp_folder.startswith( + SYSTEM_SHARED_MEM_FS + ) + else: + self._prewarm = prewarm + self._prewarm = prewarm + self._memmaped_arrays = _WeakArrayKeyMap() + self._temporary_memmaped_filenames = set() + self._unlink_on_gc_collect = unlink_on_gc_collect + + @property + def _temp_folder(self): + return self._temp_folder_resolver() + + def __reduce__(self): + # The ArrayMemmapForwardReducer is passed to the children processes: it + # needs to be pickled but the _WeakArrayKeyMap need to be skipped as + # it's only guaranteed to be consistent with the parent process memory + # garbage collection. + # Although this reducer is pickled, it is not needed in its destination + # process (child processes), as we only use this reducer to send + # memmaps from the parent process to the children processes. For this + # reason, we can afford skipping the resolver, (which would otherwise + # be unpicklable), and pass it as None instead. + args = (self._max_nbytes, None, self._mmap_mode, + self._unlink_on_gc_collect) + kwargs = { + 'verbose': self.verbose, + 'prewarm': self._prewarm, + } + return ArrayMemmapForwardReducer, args, kwargs + + def __call__(self, a): + m = _get_backing_memmap(a) + if m is not None and isinstance(m, np.memmap): + # a is already backed by a memmap file, let's reuse it directly + return _reduce_memmap_backed(a, m) + + if (not a.dtype.hasobject and self._max_nbytes is not None and + a.nbytes > self._max_nbytes): + # check that the folder exists (lazily create the pool temp folder + # if required) + try: + os.makedirs(self._temp_folder) + os.chmod(self._temp_folder, FOLDER_PERMISSIONS) + except OSError as e: + if e.errno != errno.EEXIST: + raise e + + try: + basename = self._memmaped_arrays.get(a) + except KeyError: + # Generate a new unique random filename. The process and thread + # ids are only useful for debugging purpose and to make it + # easier to cleanup orphaned files in case of hard process + # kill (e.g. by "kill -9" or segfault). + basename = "{}-{}-{}.pkl".format( + os.getpid(), id(threading.current_thread()), uuid4().hex) + self._memmaped_arrays.set(a, basename) + filename = os.path.join(self._temp_folder, basename) + + # In case the same array with the same content is passed several + # times to the pool subprocess children, serialize it only once + + is_new_memmap = filename not in self._temporary_memmaped_filenames + + # add the memmap to the list of temporary memmaps created by joblib + self._temporary_memmaped_filenames.add(filename) + + if self._unlink_on_gc_collect: + # Bump reference count of the memmap by 1 to account for + # shared usage of the memmap by a child process. The + # corresponding decref call will be executed upon calling + # resource_tracker.maybe_unlink, registered as a finalizer in + # the child. + # the incref/decref calls here are only possible when the child + # and the parent share the same resource_tracker. It is not the + # case for the multiprocessing backend, but it does not matter + # because unlinking a memmap from a child process is only + # useful to control the memory usage of long-lasting child + # processes, while the multiprocessing-based pools terminate + # their workers at the end of a map() call. + resource_tracker.register(filename, "file") + + if is_new_memmap: + # Incref each temporary memmap created by joblib one extra + # time. This means that these memmaps will only be deleted + # once an extra maybe_unlink() is called, which is done once + # all the jobs have completed (or been canceled) in the + # Parallel._terminate_backend() method. + resource_tracker.register(filename, "file") + + if not os.path.exists(filename): + util.debug( + "[ARRAY DUMP] Pickling new array (shape={}, dtype={}) " + "creating a new memmap at {}".format( + a.shape, a.dtype, filename)) + for dumped_filename in dump(a, filename): + os.chmod(dumped_filename, FILE_PERMISSIONS) + + if self._prewarm: + # Warm up the data by accessing it. This operation ensures + # that the disk access required to create the memmapping + # file are performed in the reducing process and avoids + # concurrent memmap creation in multiple children + # processes. + load(filename, mmap_mode=self._mmap_mode).max() + + else: + util.debug( + "[ARRAY DUMP] Pickling known array (shape={}, dtype={}) " + "reusing memmap file: {}".format( + a.shape, a.dtype, os.path.basename(filename))) + + # The worker process will use joblib.load to memmap the data + return ( + (load_temporary_memmap, (filename, self._mmap_mode, + self._unlink_on_gc_collect)) + ) + else: + # do not convert a into memmap, let pickler do its usual copy with + # the default system pickler + util.debug( + '[ARRAY DUMP] Pickling array (NO MEMMAPPING) (shape={}, ' + ' dtype={}).'.format(a.shape, a.dtype)) + return (loads, (dumps(a, protocol=HIGHEST_PROTOCOL),)) + + +def get_memmapping_reducers( + forward_reducers=None, backward_reducers=None, + temp_folder_resolver=None, max_nbytes=1e6, mmap_mode='r', verbose=0, + prewarm=False, unlink_on_gc_collect=True, **kwargs): + """Construct a pair of memmapping reducer linked to a tmpdir. + + This function manage the creation and the clean up of the temporary folders + underlying the memory maps and should be use to get the reducers necessary + to construct joblib pool or executor. + """ + if forward_reducers is None: + forward_reducers = dict() + if backward_reducers is None: + backward_reducers = dict() + + if np is not None: + # Register smart numpy.ndarray reducers that detects memmap backed + # arrays and that is also able to dump to memmap large in-memory + # arrays over the max_nbytes threshold + forward_reduce_ndarray = ArrayMemmapForwardReducer( + max_nbytes, temp_folder_resolver, mmap_mode, unlink_on_gc_collect, + verbose, prewarm=prewarm) + forward_reducers[np.ndarray] = forward_reduce_ndarray + forward_reducers[np.memmap] = forward_reduce_ndarray + + # Communication from child process to the parent process always + # pickles in-memory numpy.ndarray without dumping them as memmap + # to avoid confusing the caller and make it tricky to collect the + # temporary folder + backward_reducers[np.ndarray] = reduce_array_memmap_backward + backward_reducers[np.memmap] = reduce_array_memmap_backward + + return forward_reducers, backward_reducers + + +class TemporaryResourcesManager(object): + """Stateful object able to manage temporary folder and pickles + + It exposes: + - a per-context folder name resolving API that memmap-based reducers will + rely on to know where to pickle the temporary memmaps + - a temporary file/folder management API that internally uses the + resource_tracker. + """ + + def __init__(self, temp_folder_root=None, context_id=None): + self._current_temp_folder = None + self._temp_folder_root = temp_folder_root + self._use_shared_mem = None + self._cached_temp_folders = dict() + self._id = uuid4().hex + self._finalizers = {} + if context_id is None: + # It would be safer to not assign a default context id (less silent + # bugs), but doing this while maintaining backward compatibility + # with the previous, context-unaware version get_memmaping_executor + # exposes too many low-level details. + context_id = uuid4().hex + self.set_current_context(context_id) + + def set_current_context(self, context_id): + self._current_context_id = context_id + self.register_new_context(context_id) + + def register_new_context(self, context_id): + # Prepare a sub-folder name specific to a context (usually a unique id + # generated by each instance of the Parallel class). Do not create in + # advance to spare FS write access if no array is to be dumped). + if context_id in self._cached_temp_folders: + return + else: + # During its lifecycle, one Parallel object can have several + # executors associated to it (for instance, if a loky worker raises + # an exception, joblib shutdowns the executor and instantly + # recreates a new one before raising the error - see + # ``ensure_ready``. Because we don't want two executors tied to + # the same Parallel object (and thus the same context id) to + # register/use/delete the same folder, we also add an id specific + # to the current Manager (and thus specific to its associated + # executor) to the folder name. + new_folder_name = ( + "joblib_memmapping_folder_{}_{}_{}".format( + os.getpid(), self._id, context_id) + ) + new_folder_path, _ = _get_temp_dir( + new_folder_name, self._temp_folder_root + ) + self.register_folder_finalizer(new_folder_path, context_id) + self._cached_temp_folders[context_id] = new_folder_path + + def resolve_temp_folder_name(self): + """Return a folder name specific to the currently activated context""" + return self._cached_temp_folders[self._current_context_id] + + # resource management API + + def register_folder_finalizer(self, pool_subfolder, context_id): + # Register the garbage collector at program exit in case caller forgets + # to call terminate explicitly: note we do not pass any reference to + # ensure that this callback won't prevent garbage collection of + # parallel instance and related file handler resources such as POSIX + # semaphores and pipes + pool_module_name = whichmodule(delete_folder, 'delete_folder') + resource_tracker.register(pool_subfolder, "folder") + + def _cleanup(): + # In some cases the Python runtime seems to set delete_folder to + # None just before exiting when accessing the delete_folder + # function from the closure namespace. So instead we reimport + # the delete_folder function explicitly. + # https://github.com/joblib/joblib/issues/328 + # We cannot just use from 'joblib.pool import delete_folder' + # because joblib should only use relative imports to allow + # easy vendoring. + delete_folder = __import__( + pool_module_name, fromlist=['delete_folder'] + ).delete_folder + try: + delete_folder(pool_subfolder, allow_non_empty=True) + resource_tracker.unregister(pool_subfolder, "folder") + except OSError: + warnings.warn("Failed to delete temporary folder: {}" + .format(pool_subfolder)) + + self._finalizers[context_id] = atexit.register(_cleanup) + + def _clean_temporary_resources(self, context_id=None, force=False, + allow_non_empty=False): + """Clean temporary resources created by a process-based pool""" + if context_id is None: + # Iterates over a copy of the cache keys to avoid Error due to + # iterating over a changing size dictionary. + for context_id in list(self._cached_temp_folders): + self._clean_temporary_resources( + context_id, force=force, allow_non_empty=allow_non_empty + ) + else: + temp_folder = self._cached_temp_folders.get(context_id) + if temp_folder and os.path.exists(temp_folder): + for filename in os.listdir(temp_folder): + if force: + # Some workers have failed and the ref counted might + # be off. The workers should have shut down by this + # time so forcefully clean up the files. + resource_tracker.unregister( + os.path.join(temp_folder, filename), "file" + ) + else: + resource_tracker.maybe_unlink( + os.path.join(temp_folder, filename), "file" + ) + + # When forcing clean-up, try to delete the folder even if some + # files are still in it. Otherwise, try to delete the folder + allow_non_empty |= force + + # Clean up the folder if possible, either if it is empty or + # if none of the files in it are in used and allow_non_empty. + try: + delete_folder( + temp_folder, allow_non_empty=allow_non_empty + ) + # Forget the folder once it has been deleted + self._cached_temp_folders.pop(context_id, None) + resource_tracker.unregister(temp_folder, "folder") + + # Also cancel the finalizers that gets triggered at gc. + finalizer = self._finalizers.pop(context_id, None) + if finalizer is not None: + atexit.unregister(finalizer) + + except OSError: + # Temporary folder cannot be deleted right now. + # This folder will be cleaned up by an atexit + # finalizer registered by the memmapping_reducer. + pass diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_parallel_backends.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_parallel_backends.py new file mode 100644 index 0000000000000000000000000000000000000000..8201c96bcf61b5c6e61821e7073a0babf6510268 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_parallel_backends.py @@ -0,0 +1,649 @@ +""" +Backends for embarrassingly parallel code. +""" + +import gc +import os +import warnings +import threading +import contextlib +from abc import ABCMeta, abstractmethod + +from ._utils import ( + _TracebackCapturingWrapper, + _retrieve_traceback_capturing_wrapped_call +) + +from ._multiprocessing_helpers import mp + +if mp is not None: + from .pool import MemmappingPool + from multiprocessing.pool import ThreadPool + from .executor import get_memmapping_executor + + # Import loky only if multiprocessing is present + from .externals.loky import process_executor, cpu_count + from .externals.loky.process_executor import ShutdownExecutorError + + +class ParallelBackendBase(metaclass=ABCMeta): + """Helper abc which defines all methods a ParallelBackend must implement""" + + supports_inner_max_num_threads = False + supports_retrieve_callback = False + default_n_jobs = 1 + + @property + def supports_return_generator(self): + return self.supports_retrieve_callback + + @property + def supports_timeout(self): + return self.supports_retrieve_callback + + nesting_level = None + + def __init__(self, nesting_level=None, inner_max_num_threads=None, + **kwargs): + super().__init__(**kwargs) + self.nesting_level = nesting_level + self.inner_max_num_threads = inner_max_num_threads + + MAX_NUM_THREADS_VARS = [ + 'OMP_NUM_THREADS', 'OPENBLAS_NUM_THREADS', 'MKL_NUM_THREADS', + 'BLIS_NUM_THREADS', 'VECLIB_MAXIMUM_THREADS', 'NUMBA_NUM_THREADS', + 'NUMEXPR_NUM_THREADS', + ] + + TBB_ENABLE_IPC_VAR = "ENABLE_IPC" + + @abstractmethod + def effective_n_jobs(self, n_jobs): + """Determine the number of jobs that can actually run in parallel + + n_jobs is the number of workers requested by the callers. Passing + n_jobs=-1 means requesting all available workers for instance matching + the number of CPU cores on the worker host(s). + + This method should return a guesstimate of the number of workers that + can actually perform work concurrently. The primary use case is to make + it possible for the caller to know in how many chunks to slice the + work. + + In general working on larger data chunks is more efficient (less + scheduling overhead and better use of CPU cache prefetching heuristics) + as long as all the workers have enough work to do. + """ + + @abstractmethod + def apply_async(self, func, callback=None): + """Schedule a func to be run""" + + def retrieve_result_callback(self, out): + """Called within the callback function passed in apply_async. + + The argument of this function is the argument given to a callback in + the considered backend. It is supposed to return the outcome of a task + if it succeeded or raise the exception if it failed. + """ + + def configure(self, n_jobs=1, parallel=None, prefer=None, require=None, + **backend_args): + """Reconfigure the backend and return the number of workers. + + This makes it possible to reuse an existing backend instance for + successive independent calls to Parallel with different parameters. + """ + self.parallel = parallel + return self.effective_n_jobs(n_jobs) + + def start_call(self): + """Call-back method called at the beginning of a Parallel call""" + + def stop_call(self): + """Call-back method called at the end of a Parallel call""" + + def terminate(self): + """Shutdown the workers and free the shared memory.""" + + def compute_batch_size(self): + """Determine the optimal batch size""" + return 1 + + def batch_completed(self, batch_size, duration): + """Callback indicate how long it took to run a batch""" + + def get_exceptions(self): + """List of exception types to be captured.""" + return [] + + def abort_everything(self, ensure_ready=True): + """Abort any running tasks + + This is called when an exception has been raised when executing a task + and all the remaining tasks will be ignored and can therefore be + aborted to spare computation resources. + + If ensure_ready is True, the backend should be left in an operating + state as future tasks might be re-submitted via that same backend + instance. + + If ensure_ready is False, the implementer of this method can decide + to leave the backend in a closed / terminated state as no new task + are expected to be submitted to this backend. + + Setting ensure_ready to False is an optimization that can be leveraged + when aborting tasks via killing processes from a local process pool + managed by the backend it-self: if we expect no new tasks, there is no + point in re-creating new workers. + """ + # Does nothing by default: to be overridden in subclasses when + # canceling tasks is possible. + pass + + def get_nested_backend(self): + """Backend instance to be used by nested Parallel calls. + + By default a thread-based backend is used for the first level of + nesting. Beyond, switch to sequential backend to avoid spawning too + many threads on the host. + """ + nesting_level = getattr(self, 'nesting_level', 0) + 1 + if nesting_level > 1: + return SequentialBackend(nesting_level=nesting_level), None + else: + return ThreadingBackend(nesting_level=nesting_level), None + + @contextlib.contextmanager + def retrieval_context(self): + """Context manager to manage an execution context. + + Calls to Parallel.retrieve will be made inside this context. + + By default, this does nothing. It may be useful for subclasses to + handle nested parallelism. In particular, it may be required to avoid + deadlocks if a backend manages a fixed number of workers, when those + workers may be asked to do nested Parallel calls. Without + 'retrieval_context' this could lead to deadlock, as all the workers + managed by the backend may be "busy" waiting for the nested parallel + calls to finish, but the backend has no free workers to execute those + tasks. + """ + yield + + def _prepare_worker_env(self, n_jobs): + """Return environment variables limiting threadpools in external libs. + + This function return a dict containing environment variables to pass + when creating a pool of process. These environment variables limit the + number of threads to `n_threads` for OpenMP, MKL, Accelerated and + OpenBLAS libraries in the child processes. + """ + explicit_n_threads = self.inner_max_num_threads + default_n_threads = max(cpu_count() // n_jobs, 1) + + # Set the inner environment variables to self.inner_max_num_threads if + # it is given. Else, default to cpu_count // n_jobs unless the variable + # is already present in the parent process environment. + env = {} + for var in self.MAX_NUM_THREADS_VARS: + if explicit_n_threads is None: + var_value = os.environ.get(var, default_n_threads) + else: + var_value = explicit_n_threads + + env[var] = str(var_value) + + if self.TBB_ENABLE_IPC_VAR not in os.environ: + # To avoid over-subscription when using TBB, let the TBB schedulers + # use Inter Process Communication to coordinate: + env[self.TBB_ENABLE_IPC_VAR] = "1" + return env + + @staticmethod + def in_main_thread(): + return isinstance(threading.current_thread(), threading._MainThread) + + +class SequentialBackend(ParallelBackendBase): + """A ParallelBackend which will execute all batches sequentially. + + Does not use/create any threading objects, and hence has minimal + overhead. Used when n_jobs == 1. + """ + + uses_threads = True + supports_timeout = False + supports_retrieve_callback = False + supports_sharedmem = True + + def effective_n_jobs(self, n_jobs): + """Determine the number of jobs which are going to run in parallel""" + if n_jobs == 0: + raise ValueError('n_jobs == 0 in Parallel has no meaning') + return 1 + + def apply_async(self, func, callback=None): + """Schedule a func to be run""" + raise RuntimeError("Should never be called for SequentialBackend.") + + def retrieve_result_callback(self, out): + raise RuntimeError("Should never be called for SequentialBackend.") + + def get_nested_backend(self): + # import is not top level to avoid cyclic import errors. + from .parallel import get_active_backend + + # SequentialBackend should neither change the nesting level, the + # default backend or the number of jobs. Just return the current one. + return get_active_backend() + + +class PoolManagerMixin(object): + """A helper class for managing pool of workers.""" + + _pool = None + + def effective_n_jobs(self, n_jobs): + """Determine the number of jobs which are going to run in parallel""" + if n_jobs == 0: + raise ValueError('n_jobs == 0 in Parallel has no meaning') + elif mp is None or n_jobs is None: + # multiprocessing is not available or disabled, fallback + # to sequential mode + return 1 + elif n_jobs < 0: + n_jobs = max(cpu_count() + 1 + n_jobs, 1) + return n_jobs + + def terminate(self): + """Shutdown the process or thread pool""" + if self._pool is not None: + self._pool.close() + self._pool.terminate() # terminate does a join() + self._pool = None + + def _get_pool(self): + """Used by apply_async to make it possible to implement lazy init""" + return self._pool + + def apply_async(self, func, callback=None): + """Schedule a func to be run""" + # Here, we need a wrapper to avoid crashes on KeyboardInterruptErrors. + # We also call the callback on error, to make sure the pool does not + # wait on crashed jobs. + return self._get_pool().apply_async( + _TracebackCapturingWrapper(func), (), + callback=callback, error_callback=callback + ) + + def retrieve_result_callback(self, out): + """Mimic concurrent.futures results, raising an error if needed.""" + return _retrieve_traceback_capturing_wrapped_call(out) + + def abort_everything(self, ensure_ready=True): + """Shutdown the pool and restart a new one with the same parameters""" + self.terminate() + if ensure_ready: + self.configure(n_jobs=self.parallel.n_jobs, parallel=self.parallel, + **self.parallel._backend_args) + + +class AutoBatchingMixin(object): + """A helper class for automagically batching jobs.""" + + # In seconds, should be big enough to hide multiprocessing dispatching + # overhead. + # This settings was found by running benchmarks/bench_auto_batching.py + # with various parameters on various platforms. + MIN_IDEAL_BATCH_DURATION = .2 + + # Should not be too high to avoid stragglers: long jobs running alone + # on a single worker while other workers have no work to process any more. + MAX_IDEAL_BATCH_DURATION = 2 + + # Batching counters default values + _DEFAULT_EFFECTIVE_BATCH_SIZE = 1 + _DEFAULT_SMOOTHED_BATCH_DURATION = 0.0 + + def __init__(self, **kwargs): + super().__init__(**kwargs) + self._effective_batch_size = self._DEFAULT_EFFECTIVE_BATCH_SIZE + self._smoothed_batch_duration = self._DEFAULT_SMOOTHED_BATCH_DURATION + + def compute_batch_size(self): + """Determine the optimal batch size""" + old_batch_size = self._effective_batch_size + batch_duration = self._smoothed_batch_duration + if (batch_duration > 0 and + batch_duration < self.MIN_IDEAL_BATCH_DURATION): + # The current batch size is too small: the duration of the + # processing of a batch of task is not large enough to hide + # the scheduling overhead. + ideal_batch_size = int(old_batch_size * + self.MIN_IDEAL_BATCH_DURATION / + batch_duration) + # Multiply by two to limit oscilations between min and max. + ideal_batch_size *= 2 + + # dont increase the batch size too fast to limit huge batch sizes + # potentially leading to starving worker + batch_size = min(2 * old_batch_size, ideal_batch_size) + + batch_size = max(batch_size, 1) + + self._effective_batch_size = batch_size + if self.parallel.verbose >= 10: + self.parallel._print( + f"Batch computation too fast ({batch_duration}s.) " + f"Setting batch_size={batch_size}." + ) + elif (batch_duration > self.MAX_IDEAL_BATCH_DURATION and + old_batch_size >= 2): + # The current batch size is too big. If we schedule overly long + # running batches some CPUs might wait with nothing left to do + # while a couple of CPUs a left processing a few long running + # batches. Better reduce the batch size a bit to limit the + # likelihood of scheduling such stragglers. + + # decrease the batch size quickly to limit potential starving + ideal_batch_size = int( + old_batch_size * self.MIN_IDEAL_BATCH_DURATION / batch_duration + ) + # Multiply by two to limit oscilations between min and max. + batch_size = max(2 * ideal_batch_size, 1) + self._effective_batch_size = batch_size + if self.parallel.verbose >= 10: + self.parallel._print( + f"Batch computation too slow ({batch_duration}s.) " + f"Setting batch_size={batch_size}." + ) + else: + # No batch size adjustment + batch_size = old_batch_size + + if batch_size != old_batch_size: + # Reset estimation of the smoothed mean batch duration: this + # estimate is updated in the multiprocessing apply_async + # CallBack as long as the batch_size is constant. Therefore + # we need to reset the estimate whenever we re-tune the batch + # size. + self._smoothed_batch_duration = \ + self._DEFAULT_SMOOTHED_BATCH_DURATION + + return batch_size + + def batch_completed(self, batch_size, duration): + """Callback indicate how long it took to run a batch""" + if batch_size == self._effective_batch_size: + # Update the smoothed streaming estimate of the duration of a batch + # from dispatch to completion + old_duration = self._smoothed_batch_duration + if old_duration == self._DEFAULT_SMOOTHED_BATCH_DURATION: + # First record of duration for this batch size after the last + # reset. + new_duration = duration + else: + # Update the exponentially weighted average of the duration of + # batch for the current effective size. + new_duration = 0.8 * old_duration + 0.2 * duration + self._smoothed_batch_duration = new_duration + + def reset_batch_stats(self): + """Reset batch statistics to default values. + + This avoids interferences with future jobs. + """ + self._effective_batch_size = self._DEFAULT_EFFECTIVE_BATCH_SIZE + self._smoothed_batch_duration = self._DEFAULT_SMOOTHED_BATCH_DURATION + + +class ThreadingBackend(PoolManagerMixin, ParallelBackendBase): + """A ParallelBackend which will use a thread pool to execute batches in. + + This is a low-overhead backend but it suffers from the Python Global + Interpreter Lock if the called function relies a lot on Python objects. + Mostly useful when the execution bottleneck is a compiled extension that + explicitly releases the GIL (for instance a Cython loop wrapped in a "with + nogil" block or an expensive call to a library such as NumPy). + + The actual thread pool is lazily initialized: the actual thread pool + construction is delayed to the first call to apply_async. + + ThreadingBackend is used as the default backend for nested calls. + """ + + supports_retrieve_callback = True + uses_threads = True + supports_sharedmem = True + + def configure(self, n_jobs=1, parallel=None, **backend_args): + """Build a process or thread pool and return the number of workers""" + n_jobs = self.effective_n_jobs(n_jobs) + if n_jobs == 1: + # Avoid unnecessary overhead and use sequential backend instead. + raise FallbackToBackend( + SequentialBackend(nesting_level=self.nesting_level)) + self.parallel = parallel + self._n_jobs = n_jobs + return n_jobs + + def _get_pool(self): + """Lazily initialize the thread pool + + The actual pool of worker threads is only initialized at the first + call to apply_async. + """ + if self._pool is None: + self._pool = ThreadPool(self._n_jobs) + return self._pool + + +class MultiprocessingBackend(PoolManagerMixin, AutoBatchingMixin, + ParallelBackendBase): + """A ParallelBackend which will use a multiprocessing.Pool. + + Will introduce some communication and memory overhead when exchanging + input and output data with the with the worker Python processes. + However, does not suffer from the Python Global Interpreter Lock. + """ + + supports_retrieve_callback = True + supports_return_generator = False + + def effective_n_jobs(self, n_jobs): + """Determine the number of jobs which are going to run in parallel. + + This also checks if we are attempting to create a nested parallel + loop. + """ + if mp is None: + return 1 + + if mp.current_process().daemon: + # Daemonic processes cannot have children + if n_jobs != 1: + if inside_dask_worker(): + msg = ( + "Inside a Dask worker with daemon=True, " + "setting n_jobs=1.\nPossible work-arounds:\n" + "- dask.config.set(" + "{'distributed.worker.daemon': False})" + "- set the environment variable " + "DASK_DISTRIBUTED__WORKER__DAEMON=False\n" + "before creating your Dask cluster." + ) + else: + msg = ( + 'Multiprocessing-backed parallel loops ' + 'cannot be nested, setting n_jobs=1' + ) + warnings.warn(msg, stacklevel=3) + return 1 + + if process_executor._CURRENT_DEPTH > 0: + # Mixing loky and multiprocessing in nested loop is not supported + if n_jobs != 1: + warnings.warn( + 'Multiprocessing-backed parallel loops cannot be nested,' + ' below loky, setting n_jobs=1', + stacklevel=3) + return 1 + + elif not (self.in_main_thread() or self.nesting_level == 0): + # Prevent posix fork inside in non-main posix threads + if n_jobs != 1: + warnings.warn( + 'Multiprocessing-backed parallel loops cannot be nested' + ' below threads, setting n_jobs=1', + stacklevel=3) + return 1 + + return super(MultiprocessingBackend, self).effective_n_jobs(n_jobs) + + def configure(self, n_jobs=1, parallel=None, prefer=None, require=None, + **memmappingpool_args): + """Build a process or thread pool and return the number of workers""" + n_jobs = self.effective_n_jobs(n_jobs) + if n_jobs == 1: + raise FallbackToBackend( + SequentialBackend(nesting_level=self.nesting_level)) + + # Make sure to free as much memory as possible before forking + gc.collect() + self._pool = MemmappingPool(n_jobs, **memmappingpool_args) + self.parallel = parallel + return n_jobs + + def terminate(self): + """Shutdown the process or thread pool""" + super(MultiprocessingBackend, self).terminate() + self.reset_batch_stats() + + +class LokyBackend(AutoBatchingMixin, ParallelBackendBase): + """Managing pool of workers with loky instead of multiprocessing.""" + + supports_retrieve_callback = True + supports_inner_max_num_threads = True + + def configure(self, n_jobs=1, parallel=None, prefer=None, require=None, + idle_worker_timeout=300, **memmappingexecutor_args): + """Build a process executor and return the number of workers""" + n_jobs = self.effective_n_jobs(n_jobs) + if n_jobs == 1: + raise FallbackToBackend( + SequentialBackend(nesting_level=self.nesting_level)) + + self._workers = get_memmapping_executor( + n_jobs, timeout=idle_worker_timeout, + env=self._prepare_worker_env(n_jobs=n_jobs), + context_id=parallel._id, **memmappingexecutor_args) + self.parallel = parallel + return n_jobs + + def effective_n_jobs(self, n_jobs): + """Determine the number of jobs which are going to run in parallel""" + if n_jobs == 0: + raise ValueError('n_jobs == 0 in Parallel has no meaning') + elif mp is None or n_jobs is None: + # multiprocessing is not available or disabled, fallback + # to sequential mode + return 1 + elif mp.current_process().daemon: + # Daemonic processes cannot have children + if n_jobs != 1: + if inside_dask_worker(): + msg = ( + "Inside a Dask worker with daemon=True, " + "setting n_jobs=1.\nPossible work-arounds:\n" + "- dask.config.set(" + "{'distributed.worker.daemon': False})\n" + "- set the environment variable " + "DASK_DISTRIBUTED__WORKER__DAEMON=False\n" + "before creating your Dask cluster." + ) + else: + msg = ( + 'Loky-backed parallel loops cannot be called in a' + ' multiprocessing, setting n_jobs=1' + ) + warnings.warn(msg, stacklevel=3) + + return 1 + elif not (self.in_main_thread() or self.nesting_level == 0): + # Prevent posix fork inside in non-main posix threads + if n_jobs != 1: + warnings.warn( + 'Loky-backed parallel loops cannot be nested below ' + 'threads, setting n_jobs=1', + stacklevel=3) + return 1 + elif n_jobs < 0: + n_jobs = max(cpu_count() + 1 + n_jobs, 1) + return n_jobs + + def apply_async(self, func, callback=None): + """Schedule a func to be run""" + future = self._workers.submit(func) + if callback is not None: + future.add_done_callback(callback) + return future + + def retrieve_result_callback(self, out): + try: + return out.result() + except ShutdownExecutorError: + raise RuntimeError( + "The executor underlying Parallel has been shutdown. " + "This is likely due to the garbage collection of a previous " + "generator from a call to Parallel with return_as='generator'." + " Make sure the generator is not garbage collected when " + "submitting a new job or that it is first properly exhausted." + ) + + def terminate(self): + if self._workers is not None: + # Don't terminate the workers as we want to reuse them in later + # calls, but cleanup the temporary resources that the Parallel call + # created. This 'hack' requires a private, low-level operation. + self._workers._temp_folder_manager._clean_temporary_resources( + context_id=self.parallel._id, force=False + ) + self._workers = None + + self.reset_batch_stats() + + def abort_everything(self, ensure_ready=True): + """Shutdown the workers and restart a new one with the same parameters + """ + self._workers.terminate(kill_workers=True) + self._workers = None + + if ensure_ready: + self.configure(n_jobs=self.parallel.n_jobs, parallel=self.parallel) + + +class FallbackToBackend(Exception): + """Raised when configuration should fallback to another backend""" + + def __init__(self, backend): + self.backend = backend + + +def inside_dask_worker(): + """Check whether the current function is executed inside a Dask worker. + """ + # This function can not be in joblib._dask because there would be a + # circular import: + # _dask imports _parallel_backend that imports _dask ... + try: + from distributed import get_worker + except ImportError: + return False + + try: + get_worker() + return True + except ValueError: + return False diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_store_backends.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_store_backends.py new file mode 100644 index 0000000000000000000000000000000000000000..68e207c17d452faf7539fe0185dc0739a569774b --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_store_backends.py @@ -0,0 +1,474 @@ +"""Storage providers backends for Memory caching.""" + +from pickle import PicklingError +import re +import os +import os.path +import datetime +import json +import shutil +import time +import warnings +import collections +import operator +import threading +from abc import ABCMeta, abstractmethod + +from .backports import concurrency_safe_rename +from .disk import mkdirp, memstr_to_bytes, rm_subdirs +from .logger import format_time +from . import numpy_pickle + +CacheItemInfo = collections.namedtuple('CacheItemInfo', + 'path size last_access') + + +class CacheWarning(Warning): + """Warning to capture dump failures except for PicklingError.""" + pass + + +def concurrency_safe_write(object_to_write, filename, write_func): + """Writes an object into a unique file in a concurrency-safe way.""" + thread_id = id(threading.current_thread()) + temporary_filename = '{}.thread-{}-pid-{}'.format( + filename, thread_id, os.getpid()) + write_func(object_to_write, temporary_filename) + + return temporary_filename + + +class StoreBackendBase(metaclass=ABCMeta): + """Helper Abstract Base Class which defines all methods that + a StorageBackend must implement.""" + + location = None + + @abstractmethod + def _open_item(self, f, mode): + """Opens an item on the store and return a file-like object. + + This method is private and only used by the StoreBackendMixin object. + + Parameters + ---------- + f: a file-like object + The file-like object where an item is stored and retrieved + mode: string, optional + the mode in which the file-like object is opened allowed valued are + 'rb', 'wb' + + Returns + ------- + a file-like object + """ + + @abstractmethod + def _item_exists(self, location): + """Checks if an item location exists in the store. + + This method is private and only used by the StoreBackendMixin object. + + Parameters + ---------- + location: string + The location of an item. On a filesystem, this corresponds to the + absolute path, including the filename, of a file. + + Returns + ------- + True if the item exists, False otherwise + """ + + @abstractmethod + def _move_item(self, src, dst): + """Moves an item from src to dst in the store. + + This method is private and only used by the StoreBackendMixin object. + + Parameters + ---------- + src: string + The source location of an item + dst: string + The destination location of an item + """ + + @abstractmethod + def create_location(self, location): + """Creates a location on the store. + + Parameters + ---------- + location: string + The location in the store. On a filesystem, this corresponds to a + directory. + """ + + @abstractmethod + def clear_location(self, location): + """Clears a location on the store. + + Parameters + ---------- + location: string + The location in the store. On a filesystem, this corresponds to a + directory or a filename absolute path + """ + + @abstractmethod + def get_items(self): + """Returns the whole list of items available in the store. + + Returns + ------- + The list of items identified by their ids (e.g filename in a + filesystem). + """ + + @abstractmethod + def configure(self, location, verbose=0, backend_options=dict()): + """Configures the store. + + Parameters + ---------- + location: string + The base location used by the store. On a filesystem, this + corresponds to a directory. + verbose: int + The level of verbosity of the store + backend_options: dict + Contains a dictionary of named parameters used to configure the + store backend. + """ + + +class StoreBackendMixin(object): + """Class providing all logic for managing the store in a generic way. + + The StoreBackend subclass has to implement 3 methods: create_location, + clear_location and configure. The StoreBackend also has to provide + a private _open_item, _item_exists and _move_item methods. The _open_item + method has to have the same signature as the builtin open and return a + file-like object. + """ + + def load_item(self, call_id, verbose=1, timestamp=None, metadata=None): + """Load an item from the store given its id as a list of str.""" + full_path = os.path.join(self.location, *call_id) + + if verbose > 1: + ts_string = ('{: <16}'.format(format_time(time.time() - timestamp)) + if timestamp is not None else '') + signature = os.path.basename(call_id[0]) + if metadata is not None and 'input_args' in metadata: + kwargs = ', '.join('{}={}'.format(*item) + for item in metadata['input_args'].items()) + signature += '({})'.format(kwargs) + msg = '[Memory]{}: Loading {}'.format(ts_string, signature) + if verbose < 10: + print('{0}...'.format(msg)) + else: + print('{0} from {1}'.format(msg, full_path)) + + mmap_mode = (None if not hasattr(self, 'mmap_mode') + else self.mmap_mode) + + filename = os.path.join(full_path, 'output.pkl') + if not self._item_exists(filename): + raise KeyError("Non-existing item (may have been " + "cleared).\nFile %s does not exist" % filename) + + # file-like object cannot be used when mmap_mode is set + if mmap_mode is None: + with self._open_item(filename, "rb") as f: + item = numpy_pickle.load(f) + else: + item = numpy_pickle.load(filename, mmap_mode=mmap_mode) + return item + + def dump_item(self, call_id, item, verbose=1): + """Dump an item in the store at the id given as a list of str.""" + try: + item_path = os.path.join(self.location, *call_id) + if not self._item_exists(item_path): + self.create_location(item_path) + filename = os.path.join(item_path, 'output.pkl') + if verbose > 10: + print('Persisting in %s' % item_path) + + def write_func(to_write, dest_filename): + with self._open_item(dest_filename, "wb") as f: + try: + numpy_pickle.dump(to_write, f, compress=self.compress) + except PicklingError as e: + # TODO(1.5) turn into error + warnings.warn( + "Unable to cache to disk: failed to pickle " + "output. In version 1.5 this will raise an " + f"exception. Exception: {e}.", + FutureWarning + ) + + self._concurrency_safe_write(item, filename, write_func) + except Exception as e: # noqa: E722 + warnings.warn( + "Unable to cache to disk. Possibly a race condition in the " + f"creation of the directory. Exception: {e}.", + CacheWarning + ) + + def clear_item(self, call_id): + """Clear the item at the id, given as a list of str.""" + item_path = os.path.join(self.location, *call_id) + if self._item_exists(item_path): + self.clear_location(item_path) + + def contains_item(self, call_id): + """Check if there is an item at the id, given as a list of str.""" + item_path = os.path.join(self.location, *call_id) + filename = os.path.join(item_path, 'output.pkl') + + return self._item_exists(filename) + + def get_item_info(self, call_id): + """Return information about item.""" + return {'location': os.path.join(self.location, *call_id)} + + def get_metadata(self, call_id): + """Return actual metadata of an item.""" + try: + item_path = os.path.join(self.location, *call_id) + filename = os.path.join(item_path, 'metadata.json') + with self._open_item(filename, 'rb') as f: + return json.loads(f.read().decode('utf-8')) + except: # noqa: E722 + return {} + + def store_metadata(self, call_id, metadata): + """Store metadata of a computation.""" + try: + item_path = os.path.join(self.location, *call_id) + self.create_location(item_path) + filename = os.path.join(item_path, 'metadata.json') + + def write_func(to_write, dest_filename): + with self._open_item(dest_filename, "wb") as f: + f.write(json.dumps(to_write).encode('utf-8')) + + self._concurrency_safe_write(metadata, filename, write_func) + except: # noqa: E722 + pass + + def contains_path(self, call_id): + """Check cached function is available in store.""" + func_path = os.path.join(self.location, *call_id) + return self.object_exists(func_path) + + def clear_path(self, call_id): + """Clear all items with a common path in the store.""" + func_path = os.path.join(self.location, *call_id) + if self._item_exists(func_path): + self.clear_location(func_path) + + def store_cached_func_code(self, call_id, func_code=None): + """Store the code of the cached function.""" + func_path = os.path.join(self.location, *call_id) + if not self._item_exists(func_path): + self.create_location(func_path) + + if func_code is not None: + filename = os.path.join(func_path, "func_code.py") + with self._open_item(filename, 'wb') as f: + f.write(func_code.encode('utf-8')) + + def get_cached_func_code(self, call_id): + """Store the code of the cached function.""" + filename = os.path.join(self.location, *call_id, 'func_code.py') + try: + with self._open_item(filename, 'rb') as f: + return f.read().decode('utf-8') + except: # noqa: E722 + raise + + def get_cached_func_info(self, call_id): + """Return information related to the cached function if it exists.""" + return {'location': os.path.join(self.location, *call_id)} + + def clear(self): + """Clear the whole store content.""" + self.clear_location(self.location) + + def enforce_store_limits( + self, bytes_limit, items_limit=None, age_limit=None + ): + """ + Remove the store's oldest files to enforce item, byte, and age limits. + """ + items_to_delete = self._get_items_to_delete( + bytes_limit, items_limit, age_limit + ) + + for item in items_to_delete: + if self.verbose > 10: + print('Deleting item {0}'.format(item)) + try: + self.clear_location(item.path) + except OSError: + # Even with ignore_errors=True shutil.rmtree can raise OSError + # with: + # [Errno 116] Stale file handle if another process has deleted + # the folder already. + pass + + def _get_items_to_delete( + self, bytes_limit, items_limit=None, age_limit=None + ): + """ + Get items to delete to keep the store under size, file, & age limits. + """ + if isinstance(bytes_limit, str): + bytes_limit = memstr_to_bytes(bytes_limit) + + items = self.get_items() + if not items: + return [] + + size = sum(item.size for item in items) + + if bytes_limit is not None: + to_delete_size = size - bytes_limit + else: + to_delete_size = 0 + + if items_limit is not None: + to_delete_items = len(items) - items_limit + else: + to_delete_items = 0 + + if age_limit is not None: + older_item = min(item.last_access for item in items) + deadline = datetime.datetime.now() - age_limit + else: + deadline = None + + if ( + to_delete_size <= 0 and to_delete_items <= 0 + and (deadline is None or older_item > deadline) + ): + return [] + + # We want to delete first the cache items that were accessed a + # long time ago + items.sort(key=operator.attrgetter('last_access')) + + items_to_delete = [] + size_so_far = 0 + items_so_far = 0 + + for item in items: + if ( + (size_so_far >= to_delete_size) + and items_so_far >= to_delete_items + and (deadline is None or deadline < item.last_access) + ): + break + + items_to_delete.append(item) + size_so_far += item.size + items_so_far += 1 + + return items_to_delete + + def _concurrency_safe_write(self, to_write, filename, write_func): + """Writes an object into a file in a concurrency-safe way.""" + temporary_filename = concurrency_safe_write(to_write, + filename, write_func) + self._move_item(temporary_filename, filename) + + def __repr__(self): + """Printable representation of the store location.""" + return '{class_name}(location="{location}")'.format( + class_name=self.__class__.__name__, location=self.location) + + +class FileSystemStoreBackend(StoreBackendBase, StoreBackendMixin): + """A StoreBackend used with local or network file systems.""" + + _open_item = staticmethod(open) + _item_exists = staticmethod(os.path.exists) + _move_item = staticmethod(concurrency_safe_rename) + + def clear_location(self, location): + """Delete location on store.""" + if (location == self.location): + rm_subdirs(location) + else: + shutil.rmtree(location, ignore_errors=True) + + def create_location(self, location): + """Create object location on store""" + mkdirp(location) + + def get_items(self): + """Returns the whole list of items available in the store.""" + items = [] + + for dirpath, _, filenames in os.walk(self.location): + is_cache_hash_dir = re.match('[a-f0-9]{32}', + os.path.basename(dirpath)) + + if is_cache_hash_dir: + output_filename = os.path.join(dirpath, 'output.pkl') + try: + last_access = os.path.getatime(output_filename) + except OSError: + try: + last_access = os.path.getatime(dirpath) + except OSError: + # The directory has already been deleted + continue + + last_access = datetime.datetime.fromtimestamp(last_access) + try: + full_filenames = [os.path.join(dirpath, fn) + for fn in filenames] + dirsize = sum(os.path.getsize(fn) + for fn in full_filenames) + except OSError: + # Either output_filename or one of the files in + # dirpath does not exist any more. We assume this + # directory is being cleaned by another process already + continue + + items.append(CacheItemInfo(dirpath, dirsize, + last_access)) + + return items + + def configure(self, location, verbose=1, backend_options=None): + """Configure the store backend. + + For this backend, valid store options are 'compress' and 'mmap_mode' + """ + if backend_options is None: + backend_options = {} + + # setup location directory + self.location = location + if not os.path.exists(self.location): + mkdirp(self.location) + + # item can be stored compressed for faster I/O + self.compress = backend_options.get('compress', False) + + # FileSystemStoreBackend can be used with mmap_mode options under + # certain conditions. + mmap_mode = backend_options.get('mmap_mode') + if self.compress and mmap_mode is not None: + warnings.warn('Compressed items cannot be memmapped in a ' + 'filesystem store. Option will be ignored.', + stacklevel=2) + + self.mmap_mode = mmap_mode + self.verbose = verbose diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_utils.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..0b7cc64ee51695fe18e2fc8a819696e0246b54f8 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/_utils.py @@ -0,0 +1,83 @@ +# Adapted from https://stackoverflow.com/a/9558001/2536294 + +import ast +from dataclasses import dataclass +import operator as op + + +from ._multiprocessing_helpers import mp + +if mp is not None: + from .externals.loky.process_executor import _ExceptionWithTraceback + + +# supported operators +operators = { + ast.Add: op.add, + ast.Sub: op.sub, + ast.Mult: op.mul, + ast.Div: op.truediv, + ast.FloorDiv: op.floordiv, + ast.Mod: op.mod, + ast.Pow: op.pow, + ast.USub: op.neg, +} + + +def eval_expr(expr): + """ + >>> eval_expr('2*6') + 12 + >>> eval_expr('2**6') + 64 + >>> eval_expr('1 + 2*3**(4) / (6 + -7)') + -161.0 + """ + try: + return eval_(ast.parse(expr, mode="eval").body) + except (TypeError, SyntaxError, KeyError) as e: + raise ValueError( + f"{expr!r} is not a valid or supported arithmetic expression." + ) from e + + +def eval_(node): + if isinstance(node, ast.Constant): # + return node.value + elif isinstance(node, ast.BinOp): # + return operators[type(node.op)](eval_(node.left), eval_(node.right)) + elif isinstance(node, ast.UnaryOp): # e.g., -1 + return operators[type(node.op)](eval_(node.operand)) + else: + raise TypeError(node) + + +@dataclass(frozen=True) +class _Sentinel: + """A sentinel to mark a parameter as not explicitly set""" + default_value: object + + def __repr__(self): + return f"default({self.default_value!r})" + + +class _TracebackCapturingWrapper: + """Protect function call and return error with traceback.""" + + def __init__(self, func): + self.func = func + + def __call__(self, **kwargs): + try: + return self.func(**kwargs) + except BaseException as e: + return _ExceptionWithTraceback(e) + + +def _retrieve_traceback_capturing_wrapped_call(out): + if isinstance(out, _ExceptionWithTraceback): + rebuild, args = out.__reduce__() + out = rebuild(*args) + if isinstance(out, BaseException): + raise out + return out diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/backports.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/backports.py new file mode 100644 index 0000000000000000000000000000000000000000..3a14f107689e82b634da6794d30e658fdc000987 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/backports.py @@ -0,0 +1,177 @@ +""" +Backports of fixes for joblib dependencies +""" +import os +import re +import time + +from os.path import basename +from multiprocessing import util + + +class Version: + """Backport from deprecated distutils + + We maintain this backport to avoid introducing a new dependency on + `packaging`. + + We might rexplore this choice in the future if all major Python projects + introduce a dependency on packaging anyway. + """ + + def __init__(self, vstring=None): + if vstring: + self.parse(vstring) + + def __repr__(self): + return "%s ('%s')" % (self.__class__.__name__, str(self)) + + def __eq__(self, other): + c = self._cmp(other) + if c is NotImplemented: + return c + return c == 0 + + def __lt__(self, other): + c = self._cmp(other) + if c is NotImplemented: + return c + return c < 0 + + def __le__(self, other): + c = self._cmp(other) + if c is NotImplemented: + return c + return c <= 0 + + def __gt__(self, other): + c = self._cmp(other) + if c is NotImplemented: + return c + return c > 0 + + def __ge__(self, other): + c = self._cmp(other) + if c is NotImplemented: + return c + return c >= 0 + + +class LooseVersion(Version): + """Backport from deprecated distutils + + We maintain this backport to avoid introducing a new dependency on + `packaging`. + + We might rexplore this choice in the future if all major Python projects + introduce a dependency on packaging anyway. + """ + + component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE) + + def __init__(self, vstring=None): + if vstring: + self.parse(vstring) + + def parse(self, vstring): + # I've given up on thinking I can reconstruct the version string + # from the parsed tuple -- so I just store the string here for + # use by __str__ + self.vstring = vstring + components = [x for x in self.component_re.split(vstring) + if x and x != '.'] + for i, obj in enumerate(components): + try: + components[i] = int(obj) + except ValueError: + pass + + self.version = components + + def __str__(self): + return self.vstring + + def __repr__(self): + return "LooseVersion ('%s')" % str(self) + + def _cmp(self, other): + if isinstance(other, str): + other = LooseVersion(other) + elif not isinstance(other, LooseVersion): + return NotImplemented + + if self.version == other.version: + return 0 + if self.version < other.version: + return -1 + if self.version > other.version: + return 1 + + +try: + import numpy as np + + def make_memmap(filename, dtype='uint8', mode='r+', offset=0, + shape=None, order='C', unlink_on_gc_collect=False): + """Custom memmap constructor compatible with numpy.memmap. + + This function: + - is a backport the numpy memmap offset fix (See + https://github.com/numpy/numpy/pull/8443 for more details. + The numpy fix is available starting numpy 1.13) + - adds ``unlink_on_gc_collect``, which specifies explicitly whether + the process re-constructing the memmap owns a reference to the + underlying file. If set to True, it adds a finalizer to the + newly-created memmap that sends a maybe_unlink request for the + memmaped file to resource_tracker. + """ + util.debug( + "[MEMMAP READ] creating a memmap (shape {}, filename {}, " + "pid {})".format(shape, basename(filename), os.getpid()) + ) + + mm = np.memmap(filename, dtype=dtype, mode=mode, offset=offset, + shape=shape, order=order) + if LooseVersion(np.__version__) < '1.13': + mm.offset = offset + if unlink_on_gc_collect: + from ._memmapping_reducer import add_maybe_unlink_finalizer + add_maybe_unlink_finalizer(mm) + return mm +except ImportError: + def make_memmap(filename, dtype='uint8', mode='r+', offset=0, + shape=None, order='C', unlink_on_gc_collect=False): + raise NotImplementedError( + "'joblib.backports.make_memmap' should not be used " + 'if numpy is not installed.') + + +if os.name == 'nt': + # https://github.com/joblib/joblib/issues/540 + access_denied_errors = (5, 13) + from os import replace + + def concurrency_safe_rename(src, dst): + """Renames ``src`` into ``dst`` overwriting ``dst`` if it exists. + + On Windows os.replace can yield permission errors if executed by two + different processes. + """ + max_sleep_time = 1 + total_sleep_time = 0 + sleep_time = 0.001 + while total_sleep_time < max_sleep_time: + try: + replace(src, dst) + break + except Exception as exc: + if getattr(exc, 'winerror', None) in access_denied_errors: + time.sleep(sleep_time) + total_sleep_time += sleep_time + sleep_time *= 2 + else: + raise + else: + raise +else: + from os import replace as concurrency_safe_rename # noqa diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/executor.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/executor.py new file mode 100644 index 0000000000000000000000000000000000000000..6837a7d147411cd74034a078ff98cab916ec36ce --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/executor.py @@ -0,0 +1,117 @@ +"""Utility function to construct a loky.ReusableExecutor with custom pickler. + +This module provides efficient ways of working with data stored in +shared memory with numpy.memmap arrays without inducing any memory +copy between the parent and child processes. +""" +# Author: Thomas Moreau +# Copyright: 2017, Thomas Moreau +# License: BSD 3 clause + +from ._memmapping_reducer import get_memmapping_reducers +from ._memmapping_reducer import TemporaryResourcesManager +from .externals.loky.reusable_executor import _ReusablePoolExecutor + + +_executor_args = None + + +def get_memmapping_executor(n_jobs, **kwargs): + return MemmappingExecutor.get_memmapping_executor(n_jobs, **kwargs) + + +class MemmappingExecutor(_ReusablePoolExecutor): + + @classmethod + def get_memmapping_executor(cls, n_jobs, timeout=300, initializer=None, + initargs=(), env=None, temp_folder=None, + context_id=None, **backend_args): + """Factory for ReusableExecutor with automatic memmapping for large + numpy arrays. + """ + global _executor_args + # Check if we can reuse the executor here instead of deferring the test + # to loky as the reducers are objects that changes at each call. + executor_args = backend_args.copy() + executor_args.update(env if env else {}) + executor_args.update(dict( + timeout=timeout, initializer=initializer, initargs=initargs)) + reuse = _executor_args is None or _executor_args == executor_args + _executor_args = executor_args + + manager = TemporaryResourcesManager(temp_folder) + + # reducers access the temporary folder in which to store temporary + # pickles through a call to manager.resolve_temp_folder_name. resolving + # the folder name dynamically is useful to use different folders across + # calls of a same reusable executor + job_reducers, result_reducers = get_memmapping_reducers( + unlink_on_gc_collect=True, + temp_folder_resolver=manager.resolve_temp_folder_name, + **backend_args) + _executor, executor_is_reused = super().get_reusable_executor( + n_jobs, job_reducers=job_reducers, result_reducers=result_reducers, + reuse=reuse, timeout=timeout, initializer=initializer, + initargs=initargs, env=env + ) + + if not executor_is_reused: + # Only set a _temp_folder_manager for new executors. Reused + # executors already have a _temporary_folder_manager that must not + # be re-assigned like that because it is referenced in various + # places in the reducing machinery of the executor. + _executor._temp_folder_manager = manager + + if context_id is not None: + # Only register the specified context once we know which manager + # the current executor is using, in order to not register an atexit + # finalizer twice for the same folder. + _executor._temp_folder_manager.register_new_context(context_id) + + return _executor + + def terminate(self, kill_workers=False): + + self.shutdown(kill_workers=kill_workers) + + # When workers are killed in a brutal manner, they cannot execute the + # finalizer of their shared memmaps. The refcount of those memmaps may + # be off by an unknown number, so instead of decref'ing them, we force + # delete the whole temporary folder, and unregister them. There is no + # risk of PermissionError at folder deletion because at this + # point, all child processes are dead, so all references to temporary + # memmaps are closed. Otherwise, just try to delete as much as possible + # with allow_non_empty=True but if we can't, it will be clean up later + # on by the resource_tracker. + with self._submit_resize_lock: + self._temp_folder_manager._clean_temporary_resources( + force=kill_workers, allow_non_empty=True + ) + + @property + def _temp_folder(self): + # Legacy property in tests. could be removed if we refactored the + # memmapping tests. SHOULD ONLY BE USED IN TESTS! + # We cache this property because it is called late in the tests - at + # this point, all context have been unregistered, and + # resolve_temp_folder_name raises an error. + if getattr(self, '_cached_temp_folder', None) is not None: + return self._cached_temp_folder + else: + self._cached_temp_folder = self._temp_folder_manager.resolve_temp_folder_name() # noqa + return self._cached_temp_folder + + +class _TestingMemmappingExecutor(MemmappingExecutor): + """Wrapper around ReusableExecutor to ease memmapping testing with Pool + and Executor. This is only for testing purposes. + + """ + def apply_async(self, func, args): + """Schedule a func to be run""" + future = self.submit(func, *args) + future.get = future.result + return future + + def map(self, f, *args): + return list(super().map(f, *args)) diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/hashing.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/hashing.py new file mode 100644 index 0000000000000000000000000000000000000000..6c081f06997ae3b6c18fc76b286ef95e008f23cc --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/hashing.py @@ -0,0 +1,265 @@ +""" +Fast cryptographic hash of Python objects, with a special case for fast +hashing of numpy arrays. +""" + +# Author: Gael Varoquaux +# Copyright (c) 2009 Gael Varoquaux +# License: BSD Style, 3 clauses. + +import pickle +import hashlib +import sys +import types +import struct +import io +import decimal + + +Pickler = pickle._Pickler + + +class _ConsistentSet(object): + """ Class used to ensure the hash of Sets is preserved + whatever the order of its items. + """ + def __init__(self, set_sequence): + # Forces order of elements in set to ensure consistent hash. + try: + # Trying first to order the set assuming the type of elements is + # consistent and orderable. + # This fails on python 3 when elements are unorderable + # but we keep it in a try as it's faster. + self._sequence = sorted(set_sequence) + except (TypeError, decimal.InvalidOperation): + # If elements are unorderable, sorting them using their hash. + # This is slower but works in any case. + self._sequence = sorted((hash(e) for e in set_sequence)) + + +class _MyHash(object): + """ Class used to hash objects that won't normally pickle """ + + def __init__(self, *args): + self.args = args + + +class Hasher(Pickler): + """ A subclass of pickler, to do cryptographic hashing, rather than + pickling. + """ + + def __init__(self, hash_name='md5'): + self.stream = io.BytesIO() + # By default we want a pickle protocol that only changes with + # the major python version and not the minor one + protocol = 3 + Pickler.__init__(self, self.stream, protocol=protocol) + # Initialise the hash obj + self._hash = hashlib.new(hash_name) + + def hash(self, obj, return_digest=True): + try: + self.dump(obj) + except pickle.PicklingError as e: + e.args += ('PicklingError while hashing %r: %r' % (obj, e),) + raise + dumps = self.stream.getvalue() + self._hash.update(dumps) + if return_digest: + return self._hash.hexdigest() + + def save(self, obj): + if isinstance(obj, (types.MethodType, type({}.pop))): + # the Pickler cannot pickle instance methods; here we decompose + # them into components that make them uniquely identifiable + if hasattr(obj, '__func__'): + func_name = obj.__func__.__name__ + else: + func_name = obj.__name__ + inst = obj.__self__ + if type(inst) is type(pickle): + obj = _MyHash(func_name, inst.__name__) + elif inst is None: + # type(None) or type(module) do not pickle + obj = _MyHash(func_name, inst) + else: + cls = obj.__self__.__class__ + obj = _MyHash(func_name, inst, cls) + Pickler.save(self, obj) + + def memoize(self, obj): + # We want hashing to be sensitive to value instead of reference. + # For example we want ['aa', 'aa'] and ['aa', 'aaZ'[:2]] + # to hash to the same value and that's why we disable memoization + # for strings + if isinstance(obj, (bytes, str)): + return + Pickler.memoize(self, obj) + + # The dispatch table of the pickler is not accessible in Python + # 3, as these lines are only bugware for IPython, we skip them. + def save_global(self, obj, name=None, pack=struct.pack): + # We have to override this method in order to deal with objects + # defined interactively in IPython that are not injected in + # __main__ + kwargs = dict(name=name, pack=pack) + del kwargs['pack'] + try: + Pickler.save_global(self, obj, **kwargs) + except pickle.PicklingError: + Pickler.save_global(self, obj, **kwargs) + module = getattr(obj, "__module__", None) + if module == '__main__': + my_name = name + if my_name is None: + my_name = obj.__name__ + mod = sys.modules[module] + if not hasattr(mod, my_name): + # IPython doesn't inject the variables define + # interactively in __main__ + setattr(mod, my_name, obj) + + dispatch = Pickler.dispatch.copy() + # builtin + dispatch[type(len)] = save_global + # type + dispatch[type(object)] = save_global + # classobj + dispatch[type(Pickler)] = save_global + # function + dispatch[type(pickle.dump)] = save_global + + def _batch_setitems(self, items): + # forces order of keys in dict to ensure consistent hash. + try: + # Trying first to compare dict assuming the type of keys is + # consistent and orderable. + # This fails on python 3 when keys are unorderable + # but we keep it in a try as it's faster. + Pickler._batch_setitems(self, iter(sorted(items))) + except TypeError: + # If keys are unorderable, sorting them using their hash. This is + # slower but works in any case. + Pickler._batch_setitems(self, iter(sorted((hash(k), v) + for k, v in items))) + + def save_set(self, set_items): + # forces order of items in Set to ensure consistent hash + Pickler.save(self, _ConsistentSet(set_items)) + + dispatch[type(set())] = save_set + + +class NumpyHasher(Hasher): + """ Special case the hasher for when numpy is loaded. + """ + + def __init__(self, hash_name='md5', coerce_mmap=False): + """ + Parameters + ---------- + hash_name: string + The hash algorithm to be used + coerce_mmap: boolean + Make no difference between np.memmap and np.ndarray + objects. + """ + self.coerce_mmap = coerce_mmap + Hasher.__init__(self, hash_name=hash_name) + # delayed import of numpy, to avoid tight coupling + import numpy as np + self.np = np + if hasattr(np, 'getbuffer'): + self._getbuffer = np.getbuffer + else: + self._getbuffer = memoryview + + def save(self, obj): + """ Subclass the save method, to hash ndarray subclass, rather + than pickling them. Off course, this is a total abuse of + the Pickler class. + """ + if isinstance(obj, self.np.ndarray) and not obj.dtype.hasobject: + # Compute a hash of the object + # The update function of the hash requires a c_contiguous buffer. + if obj.shape == (): + # 0d arrays need to be flattened because viewing them as bytes + # raises a ValueError exception. + obj_c_contiguous = obj.flatten() + elif obj.flags.c_contiguous: + obj_c_contiguous = obj + elif obj.flags.f_contiguous: + obj_c_contiguous = obj.T + else: + # Cater for non-single-segment arrays: this creates a + # copy, and thus alleviates this issue. + # XXX: There might be a more efficient way of doing this + obj_c_contiguous = obj.flatten() + + # memoryview is not supported for some dtypes, e.g. datetime64, see + # https://github.com/numpy/numpy/issues/4983. The + # workaround is to view the array as bytes before + # taking the memoryview. + self._hash.update( + self._getbuffer(obj_c_contiguous.view(self.np.uint8))) + + # We store the class, to be able to distinguish between + # Objects with the same binary content, but different + # classes. + if self.coerce_mmap and isinstance(obj, self.np.memmap): + # We don't make the difference between memmap and + # normal ndarrays, to be able to reload previously + # computed results with memmap. + klass = self.np.ndarray + else: + klass = obj.__class__ + # We also return the dtype and the shape, to distinguish + # different views on the same data with different dtypes. + + # The object will be pickled by the pickler hashed at the end. + obj = (klass, ('HASHED', obj.dtype, obj.shape, obj.strides)) + elif isinstance(obj, self.np.dtype): + # numpy.dtype consistent hashing is tricky to get right. This comes + # from the fact that atomic np.dtype objects are interned: + # ``np.dtype('f4') is np.dtype('f4')``. The situation is + # complicated by the fact that this interning does not resist a + # simple pickle.load/dump roundtrip: + # ``pickle.loads(pickle.dumps(np.dtype('f4'))) is not + # np.dtype('f4') Because pickle relies on memoization during + # pickling, it is easy to + # produce different hashes for seemingly identical objects, such as + # ``[np.dtype('f4'), np.dtype('f4')]`` + # and ``[np.dtype('f4'), pickle.loads(pickle.dumps('f4'))]``. + # To prevent memoization from interfering with hashing, we isolate + # the serialization (and thus the pickle memoization) of each dtype + # using each time a different ``pickle.dumps`` call unrelated to + # the current Hasher instance. + self._hash.update("_HASHED_DTYPE".encode('utf-8')) + self._hash.update(pickle.dumps(obj)) + return + Hasher.save(self, obj) + + +def hash(obj, hash_name='md5', coerce_mmap=False): + """ Quick calculation of a hash to identify uniquely Python objects + containing numpy arrays. + + Parameters + ---------- + hash_name: 'md5' or 'sha1' + Hashing algorithm used. sha1 is supposedly safer, but md5 is + faster. + coerce_mmap: boolean + Make no difference between np.memmap and np.ndarray + """ + valid_hash_names = ('md5', 'sha1') + if hash_name not in valid_hash_names: + raise ValueError("Valid options for 'hash_name' are {}. " + "Got hash_name={!r} instead." + .format(valid_hash_names, hash_name)) + if 'numpy' in sys.modules: + hasher = NumpyHasher(hash_name=hash_name, coerce_mmap=coerce_mmap) + else: + hasher = Hasher(hash_name=hash_name) + return hasher.hash(obj) diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/logger.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/logger.py new file mode 100644 index 0000000000000000000000000000000000000000..cf9d258011f3c581334a93ef3ccdac7dfb19b25e --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/logger.py @@ -0,0 +1,162 @@ +""" +Helpers for logging. + +This module needs much love to become useful. +""" + +# Author: Gael Varoquaux +# Copyright (c) 2008 Gael Varoquaux +# License: BSD Style, 3 clauses. + +from __future__ import print_function + +import time +import sys +import os +import shutil +import logging +import pprint + +from .disk import mkdirp + + +def _squeeze_time(t): + """Remove .1s to the time under Windows: this is the time it take to + stat files. This is needed to make results similar to timings under + Unix, for tests + """ + if sys.platform.startswith('win'): + return max(0, t - .1) + else: + return t + + +def format_time(t): + t = _squeeze_time(t) + return "%.1fs, %.1fmin" % (t, t / 60.) + + +def short_format_time(t): + t = _squeeze_time(t) + if t > 60: + return "%4.1fmin" % (t / 60.) + else: + return " %5.1fs" % (t) + + +def pformat(obj, indent=0, depth=3): + if 'numpy' in sys.modules: + import numpy as np + print_options = np.get_printoptions() + np.set_printoptions(precision=6, threshold=64, edgeitems=1) + else: + print_options = None + out = pprint.pformat(obj, depth=depth, indent=indent) + if print_options: + np.set_printoptions(**print_options) + return out + + +############################################################################### +# class `Logger` +############################################################################### +class Logger(object): + """ Base class for logging messages. + """ + + def __init__(self, depth=3, name=None): + """ + Parameters + ---------- + depth: int, optional + The depth of objects printed. + name: str, optional + The namespace to log to. If None, defaults to joblib. + """ + self.depth = depth + self._name = name if name else 'joblib' + + def warn(self, msg): + logging.getLogger(self._name).warning("[%s]: %s" % (self, msg)) + + def info(self, msg): + logging.info("[%s]: %s" % (self, msg)) + + def debug(self, msg): + # XXX: This conflicts with the debug flag used in children class + logging.getLogger(self._name).debug("[%s]: %s" % (self, msg)) + + def format(self, obj, indent=0): + """Return the formatted representation of the object.""" + return pformat(obj, indent=indent, depth=self.depth) + + +############################################################################### +# class `PrintTime` +############################################################################### +class PrintTime(object): + """ Print and log messages while keeping track of time. + """ + + def __init__(self, logfile=None, logdir=None): + if logfile is not None and logdir is not None: + raise ValueError('Cannot specify both logfile and logdir') + # XXX: Need argument docstring + self.last_time = time.time() + self.start_time = self.last_time + if logdir is not None: + logfile = os.path.join(logdir, 'joblib.log') + self.logfile = logfile + if logfile is not None: + mkdirp(os.path.dirname(logfile)) + if os.path.exists(logfile): + # Rotate the logs + for i in range(1, 9): + try: + shutil.move(logfile + '.%i' % i, + logfile + '.%i' % (i + 1)) + except: # noqa: E722 + "No reason failing here" + # Use a copy rather than a move, so that a process + # monitoring this file does not get lost. + try: + shutil.copy(logfile, logfile + '.1') + except: # noqa: E722 + "No reason failing here" + try: + with open(logfile, 'w') as logfile: + logfile.write('\nLogging joblib python script\n') + logfile.write('\n---%s---\n' % time.ctime(self.last_time)) + except: # noqa: E722 + """ Multiprocessing writing to files can create race + conditions. Rather fail silently than crash the + computation. + """ + # XXX: We actually need a debug flag to disable this + # silent failure. + + def __call__(self, msg='', total=False): + """ Print the time elapsed between the last call and the current + call, with an optional message. + """ + if not total: + time_lapse = time.time() - self.last_time + full_msg = "%s: %s" % (msg, format_time(time_lapse)) + else: + # FIXME: Too much logic duplicated + time_lapse = time.time() - self.start_time + full_msg = "%s: %.2fs, %.1f min" % (msg, time_lapse, + time_lapse / 60) + print(full_msg, file=sys.stderr) + if self.logfile is not None: + try: + with open(self.logfile, 'a') as f: + print(full_msg, file=f) + except: # noqa: E722 + """ Multiprocessing writing to files can create race + conditions. Rather fail silently than crash the + calculation. + """ + # XXX: We actually need a debug flag to disable this + # silent failure. + self.last_time = time.time() diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/memory.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/memory.py new file mode 100644 index 0000000000000000000000000000000000000000..b83a855da26edc03e32cc5369d6b6441e7a0203e --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/memory.py @@ -0,0 +1,1172 @@ +""" +A context object for caching a function's return value each time it +is called with the same input arguments. + +""" + +# Author: Gael Varoquaux +# Copyright (c) 2009 Gael Varoquaux +# License: BSD Style, 3 clauses. + + +import asyncio +import datetime +import functools +import inspect +import logging +import os +import pathlib +import pydoc +import re +import textwrap +import time +import tokenize +import traceback +import warnings +import weakref + +from . import hashing +from ._store_backends import CacheWarning # noqa +from ._store_backends import FileSystemStoreBackend, StoreBackendBase +from .func_inspect import (filter_args, format_call, format_signature, + get_func_code, get_func_name) +from .logger import Logger, format_time, pformat + +FIRST_LINE_TEXT = "# first line:" + +# TODO: The following object should have a data store object as a sub +# object, and the interface to persist and query should be separated in +# the data store. +# +# This would enable creating 'Memory' objects with a different logic for +# pickling that would simply span a MemorizedFunc with the same +# store (or do we want to copy it to avoid cross-talks?), for instance to +# implement HDF5 pickling. + +# TODO: Same remark for the logger, and probably use the Python logging +# mechanism. + + +def extract_first_line(func_code): + """ Extract the first line information from the function code + text if available. + """ + if func_code.startswith(FIRST_LINE_TEXT): + func_code = func_code.split('\n') + first_line = int(func_code[0][len(FIRST_LINE_TEXT):]) + func_code = '\n'.join(func_code[1:]) + else: + first_line = -1 + return func_code, first_line + + +class JobLibCollisionWarning(UserWarning): + """ Warn that there might be a collision between names of functions. + """ + + +_STORE_BACKENDS = {'local': FileSystemStoreBackend} + + +def register_store_backend(backend_name, backend): + """Extend available store backends. + + The Memory, MemorizeResult and MemorizeFunc objects are designed to be + agnostic to the type of store used behind. By default, the local file + system is used but this function gives the possibility to extend joblib's + memory pattern with other types of storage such as cloud storage (S3, GCS, + OpenStack, HadoopFS, etc) or blob DBs. + + Parameters + ---------- + backend_name: str + The name identifying the store backend being registered. For example, + 'local' is used with FileSystemStoreBackend. + backend: StoreBackendBase subclass + The name of a class that implements the StoreBackendBase interface. + + """ + if not isinstance(backend_name, str): + raise ValueError("Store backend name should be a string, " + "'{0}' given.".format(backend_name)) + if backend is None or not issubclass(backend, StoreBackendBase): + raise ValueError("Store backend should inherit " + "StoreBackendBase, " + "'{0}' given.".format(backend)) + + _STORE_BACKENDS[backend_name] = backend + + +def _store_backend_factory(backend, location, verbose=0, backend_options=None): + """Return the correct store object for the given location.""" + if backend_options is None: + backend_options = {} + + if isinstance(location, pathlib.Path): + location = str(location) + + if isinstance(location, StoreBackendBase): + return location + elif isinstance(location, str): + obj = None + location = os.path.expanduser(location) + # The location is not a local file system, we look in the + # registered backends if there's one matching the given backend + # name. + for backend_key, backend_obj in _STORE_BACKENDS.items(): + if backend == backend_key: + obj = backend_obj() + + # By default, we assume the FileSystemStoreBackend can be used if no + # matching backend could be found. + if obj is None: + raise TypeError('Unknown location {0} or backend {1}'.format( + location, backend)) + + # The store backend is configured with the extra named parameters, + # some of them are specific to the underlying store backend. + obj.configure(location, verbose=verbose, + backend_options=backend_options) + return obj + elif location is not None: + warnings.warn( + "Instantiating a backend using a {} as a location is not " + "supported by joblib. Returning None instead.".format( + location.__class__.__name__), UserWarning) + + return None + + +def _build_func_identifier(func): + """Build a roughly unique identifier for the cached function.""" + modules, funcname = get_func_name(func) + # We reuse historical fs-like way of building a function identifier + return os.path.join(*modules, funcname) + + +# An in-memory store to avoid looking at the disk-based function +# source code to check if a function definition has changed +_FUNCTION_HASHES = weakref.WeakKeyDictionary() + + +############################################################################### +# class `MemorizedResult` +############################################################################### +class MemorizedResult(Logger): + """Object representing a cached value. + + Attributes + ---------- + location: str + The location of joblib cache. Depends on the store backend used. + + func: function or str + function whose output is cached. The string case is intended only for + instantiation based on the output of repr() on another instance. + (namely eval(repr(memorized_instance)) works). + + argument_hash: str + hash of the function arguments. + + backend: str + Type of store backend for reading/writing cache files. + Default is 'local'. + + mmap_mode: {None, 'r+', 'r', 'w+', 'c'} + The memmapping mode used when loading from cache numpy arrays. See + numpy.load for the meaning of the different values. + + verbose: int + verbosity level (0 means no message). + + timestamp, metadata: string + for internal use only. + """ + def __init__(self, location, call_id, backend='local', mmap_mode=None, + verbose=0, timestamp=None, metadata=None): + Logger.__init__(self) + self._call_id = call_id + self.store_backend = _store_backend_factory(backend, location, + verbose=verbose) + self.mmap_mode = mmap_mode + + if metadata is not None: + self.metadata = metadata + else: + self.metadata = self.store_backend.get_metadata(self._call_id) + + self.duration = self.metadata.get('duration', None) + self.verbose = verbose + self.timestamp = timestamp + + @property + def func(self): + return self.func_id + + @property + def func_id(self): + return self._call_id[0] + + @property + def args_id(self): + return self._call_id[1] + + @property + def argument_hash(self): + warnings.warn( + "The 'argument_hash' attribute has been deprecated in version " + "0.12 and will be removed in version 0.14.\n" + "Use `args_id` attribute instead.", + DeprecationWarning, stacklevel=2) + return self.args_id + + def get(self): + """Read value from cache and return it.""" + try: + return self.store_backend.load_item( + self._call_id, + timestamp=self.timestamp, + metadata=self.metadata, + verbose=self.verbose + ) + except ValueError as exc: + new_exc = KeyError( + "Error while trying to load a MemorizedResult's value. " + "It seems that this folder is corrupted : {}".format( + os.path.join(self.store_backend.location, *self._call_id))) + raise new_exc from exc + + def clear(self): + """Clear value from cache""" + self.store_backend.clear_item(self._call_id) + + def __repr__(self): + return '{}(location="{}", func="{}", args_id="{}")'.format( + self.__class__.__name__, self.store_backend.location, + *self._call_id + ) + + def __getstate__(self): + state = self.__dict__.copy() + state['timestamp'] = None + return state + + +class NotMemorizedResult(object): + """Class representing an arbitrary value. + + This class is a replacement for MemorizedResult when there is no cache. + """ + __slots__ = ('value', 'valid') + + def __init__(self, value): + self.value = value + self.valid = True + + def get(self): + if self.valid: + return self.value + else: + raise KeyError("No value stored.") + + def clear(self): + self.valid = False + self.value = None + + def __repr__(self): + if self.valid: + return ('{class_name}({value})' + .format(class_name=self.__class__.__name__, + value=pformat(self.value))) + else: + return self.__class__.__name__ + ' with no value' + + # __getstate__ and __setstate__ are required because of __slots__ + def __getstate__(self): + return {"valid": self.valid, "value": self.value} + + def __setstate__(self, state): + self.valid = state["valid"] + self.value = state["value"] + + +############################################################################### +# class `NotMemorizedFunc` +############################################################################### +class NotMemorizedFunc(object): + """No-op object decorating a function. + + This class replaces MemorizedFunc when there is no cache. It provides an + identical API but does not write anything on disk. + + Attributes + ---------- + func: callable + Original undecorated function. + """ + # Should be a light as possible (for speed) + def __init__(self, func): + self.func = func + + def __call__(self, *args, **kwargs): + return self.func(*args, **kwargs) + + def call_and_shelve(self, *args, **kwargs): + return NotMemorizedResult(self.func(*args, **kwargs)) + + def __repr__(self): + return '{0}(func={1})'.format(self.__class__.__name__, self.func) + + def clear(self, warn=True): + # Argument "warn" is for compatibility with MemorizedFunc.clear + pass + + def call(self, *args, **kwargs): + return self.func(*args, **kwargs), {} + + def check_call_in_cache(self, *args, **kwargs): + return False + + +############################################################################### +# class `AsyncNotMemorizedFunc` +############################################################################### +class AsyncNotMemorizedFunc(NotMemorizedFunc): + async def call_and_shelve(self, *args, **kwargs): + return NotMemorizedResult(await self.func(*args, **kwargs)) + + +############################################################################### +# class `MemorizedFunc` +############################################################################### +class MemorizedFunc(Logger): + """Callable object decorating a function for caching its return value + each time it is called. + + Methods are provided to inspect the cache or clean it. + + Attributes + ---------- + func: callable + The original, undecorated, function. + + location: string + The location of joblib cache. Depends on the store backend used. + + backend: str + Type of store backend for reading/writing cache files. + Default is 'local', in which case the location is the path to a + disk storage. + + ignore: list or None + List of variable names to ignore when choosing whether to + recompute. + + mmap_mode: {None, 'r+', 'r', 'w+', 'c'} + The memmapping mode used when loading from cache + numpy arrays. See numpy.load for the meaning of the different + values. + + compress: boolean, or integer + Whether to zip the stored data on disk. If an integer is + given, it should be between 1 and 9, and sets the amount + of compression. Note that compressed arrays cannot be + read by memmapping. + + verbose: int, optional + The verbosity flag, controls messages that are issued as + the function is evaluated. + + cache_validation_callback: callable, optional + Callable to check if a result in cache is valid or is to be recomputed. + When the function is called with arguments for which a cache exists, + the callback is called with the cache entry's metadata as its sole + argument. If it returns True, the cached result is returned, else the + cache for these arguments is cleared and the result is recomputed. + """ + # ------------------------------------------------------------------------ + # Public interface + # ------------------------------------------------------------------------ + + def __init__(self, func, location, backend='local', ignore=None, + mmap_mode=None, compress=False, verbose=1, timestamp=None, + cache_validation_callback=None): + Logger.__init__(self) + self.mmap_mode = mmap_mode + self.compress = compress + self.func = func + self.cache_validation_callback = cache_validation_callback + self.func_id = _build_func_identifier(func) + self.ignore = ignore if ignore is not None else [] + self._verbose = verbose + + # retrieve store object from backend type and location. + self.store_backend = _store_backend_factory(backend, location, + verbose=verbose, + backend_options=dict( + compress=compress, + mmap_mode=mmap_mode), + ) + if self.store_backend is not None: + # Create func directory on demand. + self.store_backend.store_cached_func_code([self.func_id]) + + self.timestamp = timestamp if timestamp is not None else time.time() + try: + functools.update_wrapper(self, func) + except Exception: + pass # Objects like ufunc don't like that + if inspect.isfunction(func): + doc = pydoc.TextDoc().document(func) + # Remove blank line + doc = doc.replace('\n', '\n\n', 1) + # Strip backspace-overprints for compatibility with autodoc + doc = re.sub('\x08.', '', doc) + else: + # Pydoc does a poor job on other objects + doc = func.__doc__ + self.__doc__ = 'Memoized version of %s' % doc + + self._func_code_info = None + self._func_code_id = None + + def _is_in_cache_and_valid(self, call_id): + """Check if the function call is cached and valid for given arguments. + + - Compare the function code with the one from the cached function, + asserting if it has changed. + - Check if the function call is present in the cache. + - Call `cache_validation_callback` for user define cache validation. + + Returns True if the function call is in cache and can be used, and + returns False otherwise. + """ + # Check if the code of the function has changed + if not self._check_previous_func_code(stacklevel=4): + return False + + # Check if this specific call is in the cache + if not self.store_backend.contains_item(call_id): + return False + + # Call the user defined cache validation callback + metadata = self.store_backend.get_metadata(call_id) + if (self.cache_validation_callback is not None and + not self.cache_validation_callback(metadata)): + self.store_backend.clear_item(call_id) + return False + + return True + + def _cached_call(self, args, kwargs, shelving): + """Call wrapped function and cache result, or read cache if available. + + This function returns the wrapped function output or a reference to + the cached result. + + Arguments: + ---------- + + args, kwargs: list and dict + input arguments for wrapped function + + shelving: bool + True when called via the call_and_shelve function. + + + Returns + ------- + output: Output of the wrapped function if shelving is false, or a + MemorizedResult reference to the value if shelving is true. + metadata: dict containing the metadata associated with the call. + """ + args_id = self._get_args_id(*args, **kwargs) + call_id = (self.func_id, args_id) + _, func_name = get_func_name(self.func) + func_info = self.store_backend.get_cached_func_info([self.func_id]) + location = func_info['location'] + + if self._verbose >= 20: + logging.basicConfig(level=logging.INFO) + _, signature = format_signature(self.func, *args, **kwargs) + self.info( + textwrap.dedent( + f""" + Querying {func_name} with signature + {signature}. + + (argument hash {args_id}) + + The store location is {location}. + """ + ) + ) + + # Compare the function code with the previous to see if the + # function code has changed and check if the results are present in + # the cache. + if self._is_in_cache_and_valid(call_id): + if shelving: + return self._get_memorized_result(call_id), {} + + try: + start_time = time.time() + output = self._load_item(call_id) + if self._verbose > 4: + self._print_duration(time.time() - start_time, + context='cache loaded ') + return output, {} + except Exception: + # XXX: Should use an exception logger + _, signature = format_signature(self.func, *args, **kwargs) + self.warn('Exception while loading results for ' + '{}\n {}'.format(signature, traceback.format_exc())) + + if self._verbose > 10: + self.warn( + f"Computing func {func_name}, argument hash {args_id} " + f"in location {location}" + ) + + # Returns the output but not the metadata + return self._call(call_id, args, kwargs, shelving) + + @property + def func_code_info(self): + # 3-tuple property containing: the function source code, source file, + # and first line of the code inside the source file + if hasattr(self.func, '__code__'): + if self._func_code_id is None: + self._func_code_id = id(self.func.__code__) + elif id(self.func.__code__) != self._func_code_id: + # Be robust to dynamic reassignments of self.func.__code__ + self._func_code_info = None + + if self._func_code_info is None: + # Cache the source code of self.func . Provided that get_func_code + # (which should be called once on self) gets called in the process + # in which self.func was defined, this caching mechanism prevents + # undesired cache clearing when the cached function is called in + # an environment where the introspection utilities get_func_code + # relies on do not work (typically, in joblib child processes). + # See #1035 for more info + # TODO (pierreglaser): do the same with get_func_name? + self._func_code_info = get_func_code(self.func) + return self._func_code_info + + def call_and_shelve(self, *args, **kwargs): + """Call wrapped function, cache result and return a reference. + + This method returns a reference to the cached result instead of the + result itself. The reference object is small and pickeable, allowing + to send or store it easily. Call .get() on reference object to get + result. + + Returns + ------- + cached_result: MemorizedResult or NotMemorizedResult + reference to the value returned by the wrapped function. The + class "NotMemorizedResult" is used when there is no cache + activated (e.g. location=None in Memory). + """ + # Return the wrapped output, without the metadata + return self._cached_call(args, kwargs, shelving=True)[0] + + def __call__(self, *args, **kwargs): + # Return the output, without the metadata + return self._cached_call(args, kwargs, shelving=False)[0] + + def __getstate__(self): + # Make sure self.func's source is introspected prior to being pickled - + # code introspection utilities typically do not work inside child + # processes + _ = self.func_code_info + + # We don't store the timestamp when pickling, to avoid the hash + # depending from it. + state = self.__dict__.copy() + state['timestamp'] = None + + # Invalidate the code id as id(obj) will be different in the child + state['_func_code_id'] = None + + return state + + def check_call_in_cache(self, *args, **kwargs): + """Check if function call is in the memory cache. + + Does not call the function or do any work besides func inspection + and arg hashing. + + Returns + ------- + is_call_in_cache: bool + Whether or not the result of the function has been cached + for the input arguments that have been passed. + """ + call_id = (self.func_id, self._get_args_id(*args, **kwargs)) + return self.store_backend.contains_item(call_id) + + # ------------------------------------------------------------------------ + # Private interface + # ------------------------------------------------------------------------ + + def _get_args_id(self, *args, **kwargs): + """Return the input parameter hash of a result.""" + return hashing.hash(filter_args(self.func, self.ignore, args, kwargs), + coerce_mmap=self.mmap_mode is not None) + + def _hash_func(self): + """Hash a function to key the online cache""" + func_code_h = hash(getattr(self.func, '__code__', None)) + return id(self.func), hash(self.func), func_code_h + + def _write_func_code(self, func_code, first_line): + """ Write the function code and the filename to a file. + """ + # We store the first line because the filename and the function + # name is not always enough to identify a function: people + # sometimes have several functions named the same way in a + # file. This is bad practice, but joblib should be robust to bad + # practice. + func_code = u'%s %i\n%s' % (FIRST_LINE_TEXT, first_line, func_code) + self.store_backend.store_cached_func_code([self.func_id], func_code) + + # Also store in the in-memory store of function hashes + is_named_callable = (hasattr(self.func, '__name__') and + self.func.__name__ != '') + if is_named_callable: + # Don't do this for lambda functions or strange callable + # objects, as it ends up being too fragile + func_hash = self._hash_func() + try: + _FUNCTION_HASHES[self.func] = func_hash + except TypeError: + # Some callable are not hashable + pass + + def _check_previous_func_code(self, stacklevel=2): + """ + stacklevel is the depth a which this function is called, to + issue useful warnings to the user. + """ + # First check if our function is in the in-memory store. + # Using the in-memory store not only makes things faster, but it + # also renders us robust to variations of the files when the + # in-memory version of the code does not vary + try: + if self.func in _FUNCTION_HASHES: + # We use as an identifier the id of the function and its + # hash. This is more likely to falsely change than have hash + # collisions, thus we are on the safe side. + func_hash = self._hash_func() + if func_hash == _FUNCTION_HASHES[self.func]: + return True + except TypeError: + # Some callables are not hashable + pass + + # Here, we go through some effort to be robust to dynamically + # changing code and collision. We cannot inspect.getsource + # because it is not reliable when using IPython's magic "%run". + func_code, source_file, first_line = self.func_code_info + try: + old_func_code, old_first_line = extract_first_line( + self.store_backend.get_cached_func_code([self.func_id])) + except (IOError, OSError): # some backend can also raise OSError + self._write_func_code(func_code, first_line) + return False + if old_func_code == func_code: + return True + + # We have differing code, is this because we are referring to + # different functions, or because the function we are referring to has + # changed? + + _, func_name = get_func_name(self.func, resolv_alias=False, + win_characters=False) + if old_first_line == first_line == -1 or func_name == '': + if not first_line == -1: + func_description = ("{0} ({1}:{2})" + .format(func_name, source_file, + first_line)) + else: + func_description = func_name + warnings.warn(JobLibCollisionWarning( + "Cannot detect name collisions for function '{0}'" + .format(func_description)), stacklevel=stacklevel) + + # Fetch the code at the old location and compare it. If it is the + # same than the code store, we have a collision: the code in the + # file has not changed, but the name we have is pointing to a new + # code block. + if not old_first_line == first_line and source_file is not None: + if os.path.exists(source_file): + _, func_name = get_func_name(self.func, resolv_alias=False) + num_lines = len(func_code.split('\n')) + with tokenize.open(source_file) as f: + on_disk_func_code = f.readlines()[ + old_first_line - 1:old_first_line - 1 + num_lines - 1] + on_disk_func_code = ''.join(on_disk_func_code) + possible_collision = (on_disk_func_code.rstrip() == + old_func_code.rstrip()) + else: + possible_collision = source_file.startswith(' 10: + _, func_name = get_func_name(self.func, resolv_alias=False) + self.warn("Function {0} (identified by {1}) has changed" + ".".format(func_name, self.func_id)) + self.clear(warn=True) + return False + + def clear(self, warn=True): + """Empty the function's cache.""" + func_id = self.func_id + if self._verbose > 0 and warn: + self.warn("Clearing function cache identified by %s" % func_id) + self.store_backend.clear_path([func_id, ]) + + func_code, _, first_line = self.func_code_info + self._write_func_code(func_code, first_line) + + def call(self, *args, **kwargs): + """Force the execution of the function with the given arguments. + + The output values will be persisted, i.e., the cache will be updated + with any new values. + + Parameters + ---------- + *args: arguments + The arguments. + **kwargs: keyword arguments + Keyword arguments. + + Returns + ------- + output : object + The output of the function call. + metadata : dict + The metadata associated with the call. + """ + call_id = (self.func_id, self._get_args_id(*args, **kwargs)) + + # Return the output and the metadata + return self._call(call_id, args, kwargs) + + def _call(self, call_id, args, kwargs, shelving=False): + # Return the output and the metadata + self._before_call(args, kwargs) + start_time = time.time() + output = self.func(*args, **kwargs) + return self._after_call(call_id, args, kwargs, shelving, + output, start_time) + + def _before_call(self, args, kwargs): + if self._verbose > 0: + print(format_call(self.func, args, kwargs)) + + def _after_call(self, call_id, args, kwargs, shelving, output, start_time): + self.store_backend.dump_item(call_id, output, verbose=self._verbose) + duration = time.time() - start_time + if self._verbose > 0: + self._print_duration(duration) + metadata = self._persist_input(duration, call_id, args, kwargs) + if shelving: + return self._get_memorized_result(call_id, metadata), metadata + + if self.mmap_mode is not None: + # Memmap the output at the first call to be consistent with + # later calls + output = self._load_item(call_id, metadata) + return output, metadata + + def _persist_input(self, duration, call_id, args, kwargs, + this_duration_limit=0.5): + """ Save a small summary of the call using json format in the + output directory. + + output_dir: string + directory where to write metadata. + + duration: float + time taken by hashing input arguments, calling the wrapped + function and persisting its output. + + args, kwargs: list and dict + input arguments for wrapped function + + this_duration_limit: float + Max execution time for this function before issuing a warning. + """ + start_time = time.time() + argument_dict = filter_args(self.func, self.ignore, + args, kwargs) + + input_repr = dict((k, repr(v)) for k, v in argument_dict.items()) + # This can fail due to race-conditions with multiple + # concurrent joblibs removing the file or the directory + metadata = { + "duration": duration, "input_args": input_repr, "time": start_time, + } + + self.store_backend.store_metadata(call_id, metadata) + + this_duration = time.time() - start_time + if this_duration > this_duration_limit: + # This persistence should be fast. It will not be if repr() takes + # time and its output is large, because json.dump will have to + # write a large file. This should not be an issue with numpy arrays + # for which repr() always output a short representation, but can + # be with complex dictionaries. Fixing the problem should be a + # matter of replacing repr() above by something smarter. + warnings.warn("Persisting input arguments took %.2fs to run." + "If this happens often in your code, it can cause " + "performance problems " + "(results will be correct in all cases). " + "The reason for this is probably some large input " + "arguments for a wrapped function." + % this_duration, stacklevel=5) + return metadata + + def _get_memorized_result(self, call_id, metadata=None): + return MemorizedResult(self.store_backend, call_id, + metadata=metadata, timestamp=self.timestamp, + verbose=self._verbose - 1) + + def _load_item(self, call_id, metadata=None): + return self.store_backend.load_item(call_id, metadata=metadata, + timestamp=self.timestamp, + verbose=self._verbose) + + def _print_duration(self, duration, context=''): + _, name = get_func_name(self.func) + msg = f"{name} {context}- {format_time(duration)}" + print(max(0, (80 - len(msg))) * '_' + msg) + + # ------------------------------------------------------------------------ + # Private `object` interface + # ------------------------------------------------------------------------ + + def __repr__(self): + return '{class_name}(func={func}, location={location})'.format( + class_name=self.__class__.__name__, + func=self.func, + location=self.store_backend.location,) + + +############################################################################### +# class `AsyncMemorizedFunc` +############################################################################### +class AsyncMemorizedFunc(MemorizedFunc): + async def __call__(self, *args, **kwargs): + out = self._cached_call(args, kwargs, shelving=False) + out = await out if asyncio.iscoroutine(out) else out + return out[0] # Don't return metadata + + async def call_and_shelve(self, *args, **kwargs): + out = self._cached_call(args, kwargs, shelving=True) + out = await out if asyncio.iscoroutine(out) else out + return out[0] # Don't return metadata + + async def call(self, *args, **kwargs): + out = super().call(*args, **kwargs) + return await out if asyncio.iscoroutine(out) else out + + async def _call(self, call_id, args, kwargs, shelving=False): + self._before_call(args, kwargs) + start_time = time.time() + output = await self.func(*args, **kwargs) + return self._after_call( + call_id, args, kwargs, shelving, output, start_time + ) + + +############################################################################### +# class `Memory` +############################################################################### +class Memory(Logger): + """ A context object for caching a function's return value each time it + is called with the same input arguments. + + All values are cached on the filesystem, in a deep directory + structure. + + Read more in the :ref:`User Guide `. + + Parameters + ---------- + location: str, pathlib.Path or None + The path of the base directory to use as a data store + or None. If None is given, no caching is done and + the Memory object is completely transparent. This option + replaces cachedir since version 0.12. + + backend: str, optional + Type of store backend for reading/writing cache files. + Default: 'local'. + The 'local' backend is using regular filesystem operations to + manipulate data (open, mv, etc) in the backend. + + mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional + The memmapping mode used when loading from cache + numpy arrays. See numpy.load for the meaning of the + arguments. + + compress: boolean, or integer, optional + Whether to zip the stored data on disk. If an integer is + given, it should be between 1 and 9, and sets the amount + of compression. Note that compressed arrays cannot be + read by memmapping. + + verbose: int, optional + Verbosity flag, controls the debug messages that are issued + as functions are evaluated. + + bytes_limit: int | str, optional + Limit in bytes of the size of the cache. By default, the size of + the cache is unlimited. When reducing the size of the cache, + ``joblib`` keeps the most recently accessed items first. If a + str is passed, it is converted to a number of bytes using units + { K | M | G} for kilo, mega, giga. + + **Note:** You need to call :meth:`joblib.Memory.reduce_size` to + actually reduce the cache size to be less than ``bytes_limit``. + + **Note:** This argument has been deprecated. One should give the + value of ``bytes_limit`` directly in + :meth:`joblib.Memory.reduce_size`. + + backend_options: dict, optional + Contains a dictionary of named parameters used to configure + the store backend. + """ + # ------------------------------------------------------------------------ + # Public interface + # ------------------------------------------------------------------------ + + def __init__(self, location=None, backend='local', + mmap_mode=None, compress=False, verbose=1, bytes_limit=None, + backend_options=None): + Logger.__init__(self) + self._verbose = verbose + self.mmap_mode = mmap_mode + self.timestamp = time.time() + if bytes_limit is not None: + warnings.warn( + "bytes_limit argument has been deprecated. It will be removed " + "in version 1.5. Please pass its value directly to " + "Memory.reduce_size.", + category=DeprecationWarning + ) + self.bytes_limit = bytes_limit + self.backend = backend + self.compress = compress + if backend_options is None: + backend_options = {} + self.backend_options = backend_options + + if compress and mmap_mode is not None: + warnings.warn('Compressed results cannot be memmapped', + stacklevel=2) + + self.location = location + if isinstance(location, str): + location = os.path.join(location, 'joblib') + + self.store_backend = _store_backend_factory( + backend, location, verbose=self._verbose, + backend_options=dict(compress=compress, mmap_mode=mmap_mode, + **backend_options)) + + def cache(self, func=None, ignore=None, verbose=None, mmap_mode=False, + cache_validation_callback=None): + """ Decorates the given function func to only compute its return + value for input arguments not cached on disk. + + Parameters + ---------- + func: callable, optional + The function to be decorated + ignore: list of strings + A list of arguments name to ignore in the hashing + verbose: integer, optional + The verbosity mode of the function. By default that + of the memory object is used. + mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional + The memmapping mode used when loading from cache + numpy arrays. See numpy.load for the meaning of the + arguments. By default that of the memory object is used. + cache_validation_callback: callable, optional + Callable to validate whether or not the cache is valid. When + the cached function is called with arguments for which a cache + exists, this callable is called with the metadata of the cached + result as its sole argument. If it returns True, then the + cached result is returned, else the cache for these arguments + is cleared and recomputed. + + Returns + ------- + decorated_func: MemorizedFunc object + The returned object is a MemorizedFunc object, that is + callable (behaves like a function), but offers extra + methods for cache lookup and management. See the + documentation for :class:`joblib.memory.MemorizedFunc`. + """ + if (cache_validation_callback is not None and + not callable(cache_validation_callback)): + raise ValueError( + "cache_validation_callback needs to be callable. " + f"Got {cache_validation_callback}." + ) + if func is None: + # Partial application, to be able to specify extra keyword + # arguments in decorators + return functools.partial( + self.cache, ignore=ignore, + mmap_mode=mmap_mode, + verbose=verbose, + cache_validation_callback=cache_validation_callback + ) + if self.store_backend is None: + cls = (AsyncNotMemorizedFunc + if asyncio.iscoroutinefunction(func) + else NotMemorizedFunc) + return cls(func) + if verbose is None: + verbose = self._verbose + if mmap_mode is False: + mmap_mode = self.mmap_mode + if isinstance(func, MemorizedFunc): + func = func.func + cls = (AsyncMemorizedFunc + if asyncio.iscoroutinefunction(func) + else MemorizedFunc) + return cls( + func, location=self.store_backend, backend=self.backend, + ignore=ignore, mmap_mode=mmap_mode, compress=self.compress, + verbose=verbose, timestamp=self.timestamp, + cache_validation_callback=cache_validation_callback + ) + + def clear(self, warn=True): + """ Erase the complete cache directory. + """ + if warn: + self.warn('Flushing completely the cache') + if self.store_backend is not None: + self.store_backend.clear() + + # As the cache is completely clear, make sure the _FUNCTION_HASHES + # cache is also reset. Else, for a function that is present in this + # table, results cached after this clear will be have cache miss + # as the function code is not re-written. + _FUNCTION_HASHES.clear() + + def reduce_size(self, bytes_limit=None, items_limit=None, age_limit=None): + """Remove cache elements to make the cache fit its limits. + + The limitation can impose that the cache size fits in ``bytes_limit``, + that the number of cache items is no more than ``items_limit``, and + that all files in cache are not older than ``age_limit``. + + Parameters + ---------- + bytes_limit: int | str, optional + Limit in bytes of the size of the cache. By default, the size of + the cache is unlimited. When reducing the size of the cache, + ``joblib`` keeps the most recently accessed items first. If a + str is passed, it is converted to a number of bytes using units + { K | M | G} for kilo, mega, giga. + + items_limit: int, optional + Number of items to limit the cache to. By default, the number of + items in the cache is unlimited. When reducing the size of the + cache, ``joblib`` keeps the most recently accessed items first. + + age_limit: datetime.timedelta, optional + Maximum age of items to limit the cache to. When reducing the size + of the cache, any items last accessed more than the given length of + time ago are deleted. + """ + if bytes_limit is None: + bytes_limit = self.bytes_limit + + if self.store_backend is None: + # No cached results, this function does nothing. + return + + if bytes_limit is None and items_limit is None and age_limit is None: + # No limitation to impose, returning + return + + # Defers the actual limits enforcing to the store backend. + self.store_backend.enforce_store_limits( + bytes_limit, items_limit, age_limit + ) + + def eval(self, func, *args, **kwargs): + """ Eval function func with arguments `*args` and `**kwargs`, + in the context of the memory. + + This method works similarly to the builtin `apply`, except + that the function is called only if the cache is not + up to date. + + """ + if self.store_backend is None: + return func(*args, **kwargs) + return self.cache(func)(*args, **kwargs) + + # ------------------------------------------------------------------------ + # Private `object` interface + # ------------------------------------------------------------------------ + + def __repr__(self): + return '{class_name}(location={location})'.format( + class_name=self.__class__.__name__, + location=(None if self.store_backend is None + else self.store_backend.location)) + + def __getstate__(self): + """ We don't store the timestamp when pickling, to avoid the hash + depending from it. + """ + state = self.__dict__.copy() + state['timestamp'] = None + return state + + +############################################################################### +# cache_validation_callback helpers +############################################################################### + +def expires_after(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, + hours=0, weeks=0): + """Helper cache_validation_callback to force recompute after a duration. + + Parameters + ---------- + days, seconds, microseconds, milliseconds, minutes, hours, weeks: numbers + argument passed to a timedelta. + """ + delta = datetime.timedelta( + days=days, seconds=seconds, microseconds=microseconds, + milliseconds=milliseconds, minutes=minutes, hours=hours, weeks=weeks + ) + + def cache_validation_callback(metadata): + computation_age = time.time() - metadata['time'] + return computation_age < delta.total_seconds() + + return cache_validation_callback diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/numpy_pickle.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/numpy_pickle.py new file mode 100644 index 0000000000000000000000000000000000000000..bf83bb0914571dfa978bbe41a6d0e3a44a9cb947 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/numpy_pickle.py @@ -0,0 +1,659 @@ +"""Utilities for fast persistence of big data, with optional compression.""" + +# Author: Gael Varoquaux +# Copyright (c) 2009 Gael Varoquaux +# License: BSD Style, 3 clauses. + +import pickle +import os +import warnings +import io +from pathlib import Path + +from .compressor import lz4, LZ4_NOT_INSTALLED_ERROR +from .compressor import _COMPRESSORS, register_compressor, BinaryZlibFile +from .compressor import (ZlibCompressorWrapper, GzipCompressorWrapper, + BZ2CompressorWrapper, LZMACompressorWrapper, + XZCompressorWrapper, LZ4CompressorWrapper) +from .numpy_pickle_utils import Unpickler, Pickler +from .numpy_pickle_utils import _read_fileobject, _write_fileobject +from .numpy_pickle_utils import _read_bytes, BUFFER_SIZE +from .numpy_pickle_utils import _ensure_native_byte_order +from .numpy_pickle_compat import load_compatibility +from .numpy_pickle_compat import NDArrayWrapper +# For compatibility with old versions of joblib, we need ZNDArrayWrapper +# to be visible in the current namespace. +# Explicitly skipping next line from flake8 as it triggers an F401 warning +# which we don't care. +from .numpy_pickle_compat import ZNDArrayWrapper # noqa +from .backports import make_memmap + +# Register supported compressors +register_compressor('zlib', ZlibCompressorWrapper()) +register_compressor('gzip', GzipCompressorWrapper()) +register_compressor('bz2', BZ2CompressorWrapper()) +register_compressor('lzma', LZMACompressorWrapper()) +register_compressor('xz', XZCompressorWrapper()) +register_compressor('lz4', LZ4CompressorWrapper()) + + +############################################################################### +# Utility objects for persistence. + +# For convenience, 16 bytes are used to be sure to cover all the possible +# dtypes' alignments. For reference, see: +# https://numpy.org/devdocs/dev/alignment.html +NUMPY_ARRAY_ALIGNMENT_BYTES = 16 + + +class NumpyArrayWrapper(object): + """An object to be persisted instead of numpy arrays. + + This object is used to hack into the pickle machinery and read numpy + array data from our custom persistence format. + More precisely, this object is used for: + * carrying the information of the persisted array: subclass, shape, order, + dtype. Those ndarray metadata are used to correctly reconstruct the array + with low level numpy functions. + * determining if memmap is allowed on the array. + * reading the array bytes from a file. + * reading the array using memorymap from a file. + * writing the array bytes to a file. + + Attributes + ---------- + subclass: numpy.ndarray subclass + Determine the subclass of the wrapped array. + shape: numpy.ndarray shape + Determine the shape of the wrapped array. + order: {'C', 'F'} + Determine the order of wrapped array data. 'C' is for C order, 'F' is + for fortran order. + dtype: numpy.ndarray dtype + Determine the data type of the wrapped array. + allow_mmap: bool + Determine if memory mapping is allowed on the wrapped array. + Default: False. + """ + + def __init__(self, subclass, shape, order, dtype, allow_mmap=False, + numpy_array_alignment_bytes=NUMPY_ARRAY_ALIGNMENT_BYTES): + """Constructor. Store the useful information for later.""" + self.subclass = subclass + self.shape = shape + self.order = order + self.dtype = dtype + self.allow_mmap = allow_mmap + # We make numpy_array_alignment_bytes an instance attribute to allow us + # to change our mind about the default alignment and still load the old + # pickles (with the previous alignment) correctly + self.numpy_array_alignment_bytes = numpy_array_alignment_bytes + + def safe_get_numpy_array_alignment_bytes(self): + # NumpyArrayWrapper instances loaded from joblib <= 1.1 pickles don't + # have an numpy_array_alignment_bytes attribute + return getattr(self, 'numpy_array_alignment_bytes', None) + + def write_array(self, array, pickler): + """Write array bytes to pickler file handle. + + This function is an adaptation of the numpy write_array function + available in version 1.10.1 in numpy/lib/format.py. + """ + # Set buffer size to 16 MiB to hide the Python loop overhead. + buffersize = max(16 * 1024 ** 2 // array.itemsize, 1) + if array.dtype.hasobject: + # We contain Python objects so we cannot write out the data + # directly. Instead, we will pickle it out with version 2 of the + # pickle protocol. + pickle.dump(array, pickler.file_handle, protocol=2) + else: + numpy_array_alignment_bytes = \ + self.safe_get_numpy_array_alignment_bytes() + if numpy_array_alignment_bytes is not None: + current_pos = pickler.file_handle.tell() + pos_after_padding_byte = current_pos + 1 + padding_length = numpy_array_alignment_bytes - ( + pos_after_padding_byte % numpy_array_alignment_bytes) + # A single byte is written that contains the padding length in + # bytes + padding_length_byte = int.to_bytes( + padding_length, length=1, byteorder='little') + pickler.file_handle.write(padding_length_byte) + + if padding_length != 0: + padding = b'\xff' * padding_length + pickler.file_handle.write(padding) + + for chunk in pickler.np.nditer(array, + flags=['external_loop', + 'buffered', + 'zerosize_ok'], + buffersize=buffersize, + order=self.order): + pickler.file_handle.write(chunk.tobytes('C')) + + def read_array(self, unpickler): + """Read array from unpickler file handle. + + This function is an adaptation of the numpy read_array function + available in version 1.10.1 in numpy/lib/format.py. + """ + if len(self.shape) == 0: + count = 1 + else: + # joblib issue #859: we cast the elements of self.shape to int64 to + # prevent a potential overflow when computing their product. + shape_int64 = [unpickler.np.int64(x) for x in self.shape] + count = unpickler.np.multiply.reduce(shape_int64) + # Now read the actual data. + if self.dtype.hasobject: + # The array contained Python objects. We need to unpickle the data. + array = pickle.load(unpickler.file_handle) + else: + numpy_array_alignment_bytes = \ + self.safe_get_numpy_array_alignment_bytes() + if numpy_array_alignment_bytes is not None: + padding_byte = unpickler.file_handle.read(1) + padding_length = int.from_bytes( + padding_byte, byteorder='little') + if padding_length != 0: + unpickler.file_handle.read(padding_length) + + # This is not a real file. We have to read it the + # memory-intensive way. + # crc32 module fails on reads greater than 2 ** 32 bytes, + # breaking large reads from gzip streams. Chunk reads to + # BUFFER_SIZE bytes to avoid issue and reduce memory overhead + # of the read. In non-chunked case count < max_read_count, so + # only one read is performed. + max_read_count = BUFFER_SIZE // min(BUFFER_SIZE, + self.dtype.itemsize) + + array = unpickler.np.empty(count, dtype=self.dtype) + for i in range(0, count, max_read_count): + read_count = min(max_read_count, count - i) + read_size = int(read_count * self.dtype.itemsize) + data = _read_bytes(unpickler.file_handle, + read_size, "array data") + array[i:i + read_count] = \ + unpickler.np.frombuffer(data, dtype=self.dtype, + count=read_count) + del data + + if self.order == 'F': + array.shape = self.shape[::-1] + array = array.transpose() + else: + array.shape = self.shape + + # Detect byte order mismatch and swap as needed. + return _ensure_native_byte_order(array) + + def read_mmap(self, unpickler): + """Read an array using numpy memmap.""" + current_pos = unpickler.file_handle.tell() + offset = current_pos + numpy_array_alignment_bytes = \ + self.safe_get_numpy_array_alignment_bytes() + + if numpy_array_alignment_bytes is not None: + padding_byte = unpickler.file_handle.read(1) + padding_length = int.from_bytes(padding_byte, byteorder='little') + # + 1 is for the padding byte + offset += padding_length + 1 + + if unpickler.mmap_mode == 'w+': + unpickler.mmap_mode = 'r+' + + marray = make_memmap(unpickler.filename, + dtype=self.dtype, + shape=self.shape, + order=self.order, + mode=unpickler.mmap_mode, + offset=offset) + # update the offset so that it corresponds to the end of the read array + unpickler.file_handle.seek(offset + marray.nbytes) + + if (numpy_array_alignment_bytes is None and + current_pos % NUMPY_ARRAY_ALIGNMENT_BYTES != 0): + message = ( + f'The memmapped array {marray} loaded from the file ' + f'{unpickler.file_handle.name} is not byte aligned. ' + 'This may cause segmentation faults if this memmapped array ' + 'is used in some libraries like BLAS or PyTorch. ' + 'To get rid of this warning, regenerate your pickle file ' + 'with joblib >= 1.2.0. ' + 'See https://github.com/joblib/joblib/issues/563 ' + 'for more details' + ) + warnings.warn(message) + + return _ensure_native_byte_order(marray) + + def read(self, unpickler): + """Read the array corresponding to this wrapper. + + Use the unpickler to get all information to correctly read the array. + + Parameters + ---------- + unpickler: NumpyUnpickler + + Returns + ------- + array: numpy.ndarray + + """ + # When requested, only use memmap mode if allowed. + if unpickler.mmap_mode is not None and self.allow_mmap: + array = self.read_mmap(unpickler) + else: + array = self.read_array(unpickler) + + # Manage array subclass case + if (hasattr(array, '__array_prepare__') and + self.subclass not in (unpickler.np.ndarray, + unpickler.np.memmap)): + # We need to reconstruct another subclass + new_array = unpickler.np.core.multiarray._reconstruct( + self.subclass, (0,), 'b') + return new_array.__array_prepare__(array) + else: + return array + +############################################################################### +# Pickler classes + + +class NumpyPickler(Pickler): + """A pickler to persist big data efficiently. + + The main features of this object are: + * persistence of numpy arrays in a single file. + * optional compression with a special care on avoiding memory copies. + + Attributes + ---------- + fp: file + File object handle used for serializing the input object. + protocol: int, optional + Pickle protocol used. Default is pickle.DEFAULT_PROTOCOL. + """ + + dispatch = Pickler.dispatch.copy() + + def __init__(self, fp, protocol=None): + self.file_handle = fp + self.buffered = isinstance(self.file_handle, BinaryZlibFile) + + # By default we want a pickle protocol that only changes with + # the major python version and not the minor one + if protocol is None: + protocol = pickle.DEFAULT_PROTOCOL + + Pickler.__init__(self, self.file_handle, protocol=protocol) + # delayed import of numpy, to avoid tight coupling + try: + import numpy as np + except ImportError: + np = None + self.np = np + + def _create_array_wrapper(self, array): + """Create and returns a numpy array wrapper from a numpy array.""" + order = 'F' if (array.flags.f_contiguous and + not array.flags.c_contiguous) else 'C' + allow_mmap = not self.buffered and not array.dtype.hasobject + + kwargs = {} + try: + self.file_handle.tell() + except io.UnsupportedOperation: + kwargs = {'numpy_array_alignment_bytes': None} + + wrapper = NumpyArrayWrapper(type(array), + array.shape, order, array.dtype, + allow_mmap=allow_mmap, + **kwargs) + + return wrapper + + def save(self, obj): + """Subclass the Pickler `save` method. + + This is a total abuse of the Pickler class in order to use the numpy + persistence function `save` instead of the default pickle + implementation. The numpy array is replaced by a custom wrapper in the + pickle persistence stack and the serialized array is written right + after in the file. Warning: the file produced does not follow the + pickle format. As such it can not be read with `pickle.load`. + """ + if self.np is not None and type(obj) in (self.np.ndarray, + self.np.matrix, + self.np.memmap): + if type(obj) is self.np.memmap: + # Pickling doesn't work with memmapped arrays + obj = self.np.asanyarray(obj) + + # The array wrapper is pickled instead of the real array. + wrapper = self._create_array_wrapper(obj) + Pickler.save(self, wrapper) + + # A framer was introduced with pickle protocol 4 and we want to + # ensure the wrapper object is written before the numpy array + # buffer in the pickle file. + # See https://www.python.org/dev/peps/pep-3154/#framing to get + # more information on the framer behavior. + if self.proto >= 4: + self.framer.commit_frame(force=True) + + # And then array bytes are written right after the wrapper. + wrapper.write_array(obj, self) + return + + return Pickler.save(self, obj) + + +class NumpyUnpickler(Unpickler): + """A subclass of the Unpickler to unpickle our numpy pickles. + + Attributes + ---------- + mmap_mode: str + The memorymap mode to use for reading numpy arrays. + file_handle: file_like + File object to unpickle from. + filename: str + Name of the file to unpickle from. It should correspond to file_handle. + This parameter is required when using mmap_mode. + np: module + Reference to numpy module if numpy is installed else None. + + """ + + dispatch = Unpickler.dispatch.copy() + + def __init__(self, filename, file_handle, mmap_mode=None): + # The next line is for backward compatibility with pickle generated + # with joblib versions less than 0.10. + self._dirname = os.path.dirname(filename) + + self.mmap_mode = mmap_mode + self.file_handle = file_handle + # filename is required for numpy mmap mode. + self.filename = filename + self.compat_mode = False + Unpickler.__init__(self, self.file_handle) + try: + import numpy as np + except ImportError: + np = None + self.np = np + + def load_build(self): + """Called to set the state of a newly created object. + + We capture it to replace our place-holder objects, NDArrayWrapper or + NumpyArrayWrapper, by the array we are interested in. We + replace them directly in the stack of pickler. + NDArrayWrapper is used for backward compatibility with joblib <= 0.9. + """ + Unpickler.load_build(self) + + # For backward compatibility, we support NDArrayWrapper objects. + if isinstance(self.stack[-1], (NDArrayWrapper, NumpyArrayWrapper)): + if self.np is None: + raise ImportError("Trying to unpickle an ndarray, " + "but numpy didn't import correctly") + array_wrapper = self.stack.pop() + # If any NDArrayWrapper is found, we switch to compatibility mode, + # this will be used to raise a DeprecationWarning to the user at + # the end of the unpickling. + if isinstance(array_wrapper, NDArrayWrapper): + self.compat_mode = True + self.stack.append(array_wrapper.read(self)) + + # Be careful to register our new method. + dispatch[pickle.BUILD[0]] = load_build + + +############################################################################### +# Utility functions + +def dump(value, filename, compress=0, protocol=None, cache_size=None): + """Persist an arbitrary Python object into one file. + + Read more in the :ref:`User Guide `. + + Parameters + ---------- + value: any Python object + The object to store to disk. + filename: str, pathlib.Path, or file object. + The file object or path of the file in which it is to be stored. + The compression method corresponding to one of the supported filename + extensions ('.z', '.gz', '.bz2', '.xz' or '.lzma') will be used + automatically. + compress: int from 0 to 9 or bool or 2-tuple, optional + Optional compression level for the data. 0 or False is no compression. + Higher value means more compression, but also slower read and + write times. Using a value of 3 is often a good compromise. + See the notes for more details. + If compress is True, the compression level used is 3. + If compress is a 2-tuple, the first element must correspond to a string + between supported compressors (e.g 'zlib', 'gzip', 'bz2', 'lzma' + 'xz'), the second element must be an integer from 0 to 9, corresponding + to the compression level. + protocol: int, optional + Pickle protocol, see pickle.dump documentation for more details. + cache_size: positive int, optional + This option is deprecated in 0.10 and has no effect. + + Returns + ------- + filenames: list of strings + The list of file names in which the data is stored. If + compress is false, each array is stored in a different file. + + See Also + -------- + joblib.load : corresponding loader + + Notes + ----- + Memmapping on load cannot be used for compressed files. Thus + using compression can significantly slow down loading. In + addition, compressed files take up extra memory during + dump and load. + + """ + + if Path is not None and isinstance(filename, Path): + filename = str(filename) + + is_filename = isinstance(filename, str) + is_fileobj = hasattr(filename, "write") + + compress_method = 'zlib' # zlib is the default compression method. + if compress is True: + # By default, if compress is enabled, we want the default compress + # level of the compressor. + compress_level = None + elif isinstance(compress, tuple): + # a 2-tuple was set in compress + if len(compress) != 2: + raise ValueError( + 'Compress argument tuple should contain exactly 2 elements: ' + '(compress method, compress level), you passed {}' + .format(compress)) + compress_method, compress_level = compress + elif isinstance(compress, str): + compress_method = compress + compress_level = None # Use default compress level + compress = (compress_method, compress_level) + else: + compress_level = compress + + if compress_method == 'lz4' and lz4 is None: + raise ValueError(LZ4_NOT_INSTALLED_ERROR) + + if (compress_level is not None and + compress_level is not False and + compress_level not in range(10)): + # Raising an error if a non valid compress level is given. + raise ValueError( + 'Non valid compress level given: "{}". Possible values are ' + '{}.'.format(compress_level, list(range(10)))) + + if compress_method not in _COMPRESSORS: + # Raising an error if an unsupported compression method is given. + raise ValueError( + 'Non valid compression method given: "{}". Possible values are ' + '{}.'.format(compress_method, _COMPRESSORS)) + + if not is_filename and not is_fileobj: + # People keep inverting arguments, and the resulting error is + # incomprehensible + raise ValueError( + 'Second argument should be a filename or a file-like object, ' + '%s (type %s) was given.' + % (filename, type(filename)) + ) + + if is_filename and not isinstance(compress, tuple): + # In case no explicit compression was requested using both compression + # method and level in a tuple and the filename has an explicit + # extension, we select the corresponding compressor. + + # unset the variable to be sure no compression level is set afterwards. + compress_method = None + for name, compressor in _COMPRESSORS.items(): + if filename.endswith(compressor.extension): + compress_method = name + + if compress_method in _COMPRESSORS and compress_level == 0: + # we choose the default compress_level in case it was not given + # as an argument (using compress). + compress_level = None + + if cache_size is not None: + # Cache size is deprecated starting from version 0.10 + warnings.warn("Please do not set 'cache_size' in joblib.dump, " + "this parameter has no effect and will be removed. " + "You used 'cache_size={}'".format(cache_size), + DeprecationWarning, stacklevel=2) + + if compress_level != 0: + with _write_fileobject(filename, compress=(compress_method, + compress_level)) as f: + NumpyPickler(f, protocol=protocol).dump(value) + elif is_filename: + with open(filename, 'wb') as f: + NumpyPickler(f, protocol=protocol).dump(value) + else: + NumpyPickler(filename, protocol=protocol).dump(value) + + # If the target container is a file object, nothing is returned. + if is_fileobj: + return + + # For compatibility, the list of created filenames (e.g with one element + # after 0.10.0) is returned by default. + return [filename] + + +def _unpickle(fobj, filename="", mmap_mode=None): + """Internal unpickling function.""" + # We are careful to open the file handle early and keep it open to + # avoid race-conditions on renames. + # That said, if data is stored in companion files, which can be + # the case with the old persistence format, moving the directory + # will create a race when joblib tries to access the companion + # files. + unpickler = NumpyUnpickler(filename, fobj, mmap_mode=mmap_mode) + obj = None + try: + obj = unpickler.load() + if unpickler.compat_mode: + warnings.warn("The file '%s' has been generated with a " + "joblib version less than 0.10. " + "Please regenerate this pickle file." + % filename, + DeprecationWarning, stacklevel=3) + except UnicodeDecodeError as exc: + # More user-friendly error message + new_exc = ValueError( + 'You may be trying to read with ' + 'python 3 a joblib pickle generated with python 2. ' + 'This feature is not supported by joblib.') + new_exc.__cause__ = exc + raise new_exc + return obj + + +def load_temporary_memmap(filename, mmap_mode, unlink_on_gc_collect): + from ._memmapping_reducer import JOBLIB_MMAPS, add_maybe_unlink_finalizer + obj = load(filename, mmap_mode) + JOBLIB_MMAPS.add(obj.filename) + if unlink_on_gc_collect: + add_maybe_unlink_finalizer(obj) + return obj + + +def load(filename, mmap_mode=None): + """Reconstruct a Python object from a file persisted with joblib.dump. + + Read more in the :ref:`User Guide `. + + WARNING: joblib.load relies on the pickle module and can therefore + execute arbitrary Python code. It should therefore never be used + to load files from untrusted sources. + + Parameters + ---------- + filename: str, pathlib.Path, or file object. + The file object or path of the file from which to load the object + mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional + If not None, the arrays are memory-mapped from the disk. This + mode has no effect for compressed files. Note that in this + case the reconstructed object might no longer match exactly + the originally pickled object. + + Returns + ------- + result: any Python object + The object stored in the file. + + See Also + -------- + joblib.dump : function to save an object + + Notes + ----- + + This function can load numpy array files saved separately during the + dump. If the mmap_mode argument is given, it is passed to np.load and + arrays are loaded as memmaps. As a consequence, the reconstructed + object might not match the original pickled object. Note that if the + file was saved with compression, the arrays cannot be memmapped. + """ + if Path is not None and isinstance(filename, Path): + filename = str(filename) + + if hasattr(filename, "read"): + fobj = filename + filename = getattr(fobj, 'name', '') + with _read_fileobject(fobj, filename, mmap_mode) as fobj: + obj = _unpickle(fobj) + else: + with open(filename, 'rb') as f: + with _read_fileobject(f, filename, mmap_mode) as fobj: + if isinstance(fobj, str): + # if the returned file object is a string, this means we + # try to load a pickle file generated with an version of + # Joblib so we load it with joblib compatibility function. + return load_compatibility(fobj) + + obj = _unpickle(fobj, filename, mmap_mode) + return obj diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/numpy_pickle_utils.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/numpy_pickle_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..23cfb34ecb19161a2eca6bc85f29c3996162572c --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/numpy_pickle_utils.py @@ -0,0 +1,253 @@ +"""Utilities for fast persistence of big data, with optional compression.""" + +# Author: Gael Varoquaux +# Copyright (c) 2009 Gael Varoquaux +# License: BSD Style, 3 clauses. + +import pickle +import io +import sys +import warnings +import contextlib + +from .compressor import _ZFILE_PREFIX +from .compressor import _COMPRESSORS + +try: + import numpy as np +except ImportError: + np = None + +Unpickler = pickle._Unpickler +Pickler = pickle._Pickler +xrange = range + + +try: + # The python standard library can be built without bz2 so we make bz2 + # usage optional. + # see https://github.com/scikit-learn/scikit-learn/issues/7526 for more + # details. + import bz2 +except ImportError: + bz2 = None + +# Buffer size used in io.BufferedReader and io.BufferedWriter +_IO_BUFFER_SIZE = 1024 ** 2 + + +def _is_raw_file(fileobj): + """Check if fileobj is a raw file object, e.g created with open.""" + fileobj = getattr(fileobj, 'raw', fileobj) + return isinstance(fileobj, io.FileIO) + + +def _get_prefixes_max_len(): + # Compute the max prefix len of registered compressors. + prefixes = [len(compressor.prefix) for compressor in _COMPRESSORS.values()] + prefixes += [len(_ZFILE_PREFIX)] + return max(prefixes) + + +def _is_numpy_array_byte_order_mismatch(array): + """Check if numpy array is having byte order mismatch""" + return ((sys.byteorder == 'big' and + (array.dtype.byteorder == '<' or + (array.dtype.byteorder == '|' and array.dtype.fields and + all(e[0].byteorder == '<' + for e in array.dtype.fields.values())))) or + (sys.byteorder == 'little' and + (array.dtype.byteorder == '>' or + (array.dtype.byteorder == '|' and array.dtype.fields and + all(e[0].byteorder == '>' + for e in array.dtype.fields.values()))))) + + +def _ensure_native_byte_order(array): + """Use the byte order of the host while preserving values + + Does nothing if array already uses the system byte order. + """ + if _is_numpy_array_byte_order_mismatch(array): + array = array.byteswap().view(array.dtype.newbyteorder('=')) + return array + + +############################################################################### +# Cache file utilities +def _detect_compressor(fileobj): + """Return the compressor matching fileobj. + + Parameters + ---------- + fileobj: file object + + Returns + ------- + str in {'zlib', 'gzip', 'bz2', 'lzma', 'xz', 'compat', 'not-compressed'} + """ + # Read the magic number in the first bytes of the file. + max_prefix_len = _get_prefixes_max_len() + if hasattr(fileobj, 'peek'): + # Peek allows to read those bytes without moving the cursor in the + # file whic. + first_bytes = fileobj.peek(max_prefix_len) + else: + # Fallback to seek if the fileobject is not peekable. + first_bytes = fileobj.read(max_prefix_len) + fileobj.seek(0) + + if first_bytes.startswith(_ZFILE_PREFIX): + return "compat" + else: + for name, compressor in _COMPRESSORS.items(): + if first_bytes.startswith(compressor.prefix): + return name + + return "not-compressed" + + +def _buffered_read_file(fobj): + """Return a buffered version of a read file object.""" + return io.BufferedReader(fobj, buffer_size=_IO_BUFFER_SIZE) + + +def _buffered_write_file(fobj): + """Return a buffered version of a write file object.""" + return io.BufferedWriter(fobj, buffer_size=_IO_BUFFER_SIZE) + + +@contextlib.contextmanager +def _read_fileobject(fileobj, filename, mmap_mode=None): + """Utility function opening the right fileobject from a filename. + + The magic number is used to choose between the type of file object to open: + * regular file object (default) + * zlib file object + * gzip file object + * bz2 file object + * lzma file object (for xz and lzma compressor) + + Parameters + ---------- + fileobj: file object + compressor: str in {'zlib', 'gzip', 'bz2', 'lzma', 'xz', 'compat', + 'not-compressed'} + filename: str + filename path corresponding to the fileobj parameter. + mmap_mode: str + memory map mode that should be used to open the pickle file. This + parameter is useful to verify that the user is not trying to one with + compression. Default: None. + + Returns + ------- + a file like object + + """ + # Detect if the fileobj contains compressed data. + compressor = _detect_compressor(fileobj) + + if compressor == 'compat': + # Compatibility with old pickle mode: simply return the input + # filename "as-is" and let the compatibility function be called by the + # caller. + warnings.warn("The file '%s' has been generated with a joblib " + "version less than 0.10. " + "Please regenerate this pickle file." % filename, + DeprecationWarning, stacklevel=2) + yield filename + else: + if compressor in _COMPRESSORS: + # based on the compressor detected in the file, we open the + # correct decompressor file object, wrapped in a buffer. + compressor_wrapper = _COMPRESSORS[compressor] + inst = compressor_wrapper.decompressor_file(fileobj) + fileobj = _buffered_read_file(inst) + + # Checking if incompatible load parameters with the type of file: + # mmap_mode cannot be used with compressed file or in memory buffers + # such as io.BytesIO. + if mmap_mode is not None: + if isinstance(fileobj, io.BytesIO): + warnings.warn('In memory persistence is not compatible with ' + 'mmap_mode "%(mmap_mode)s" flag passed. ' + 'mmap_mode option will be ignored.' + % locals(), stacklevel=2) + elif compressor != 'not-compressed': + warnings.warn('mmap_mode "%(mmap_mode)s" is not compatible ' + 'with compressed file %(filename)s. ' + '"%(mmap_mode)s" flag will be ignored.' + % locals(), stacklevel=2) + elif not _is_raw_file(fileobj): + warnings.warn('"%(fileobj)r" is not a raw file, mmap_mode ' + '"%(mmap_mode)s" flag will be ignored.' + % locals(), stacklevel=2) + + yield fileobj + + +def _write_fileobject(filename, compress=("zlib", 3)): + """Return the right compressor file object in write mode.""" + compressmethod = compress[0] + compresslevel = compress[1] + + if compressmethod in _COMPRESSORS.keys(): + file_instance = _COMPRESSORS[compressmethod].compressor_file( + filename, compresslevel=compresslevel) + return _buffered_write_file(file_instance) + else: + file_instance = _COMPRESSORS['zlib'].compressor_file( + filename, compresslevel=compresslevel) + return _buffered_write_file(file_instance) + + +# Utility functions/variables from numpy required for writing arrays. +# We need at least the functions introduced in version 1.9 of numpy. Here, +# we use the ones from numpy 1.10.2. +BUFFER_SIZE = 2 ** 18 # size of buffer for reading npz files in bytes + + +def _read_bytes(fp, size, error_template="ran out of data"): + """Read from file-like object until size bytes are read. + + TODO python2_drop: is it still needed? The docstring mentions python 2.6 + and it looks like this can be at least simplified ... + + Raises ValueError if not EOF is encountered before size bytes are read. + Non-blocking objects only supported if they derive from io objects. + + Required as e.g. ZipExtFile in python 2.6 can return less data than + requested. + + This function was taken from numpy/lib/format.py in version 1.10.2. + + Parameters + ---------- + fp: file-like object + size: int + error_template: str + + Returns + ------- + a bytes object + The data read in bytes. + + """ + data = bytes() + while True: + # io files (default in python3) return None or raise on + # would-block, python2 file will truncate, probably nothing can be + # done about that. note that regular files can't be non-blocking + try: + r = fp.read(size - len(data)) + data += r + if len(r) == 0 or len(data) == size: + break + except io.BlockingIOError: + pass + if len(data) != size: + msg = "EOF: reading %s, expected %d bytes got %d" + raise ValueError(msg % (error_template, size, len(data))) + else: + return data diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py27_np17.pkl.lzma b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py27_np17.pkl.lzma new file mode 100644 index 0000000000000000000000000000000000000000..92acdd95675978ef8265e261f770749eb68d6f7c Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py27_np17.pkl.lzma differ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py35_np19.pkl.lzma b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py35_np19.pkl.lzma new file mode 100644 index 0000000000000000000000000000000000000000..6664c1772e85fa930dc330550f2cb237ac042328 Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py35_np19.pkl.lzma differ diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/INSTALLER b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/METADATA b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..1c39cae71d3c99f70dd690e5d861037455337870 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/METADATA @@ -0,0 +1,68 @@ +Metadata-Version: 2.1 +Name: jupyter_core +Version: 5.7.2 +Summary: Jupyter core package. A base package on which Jupyter projects rely. +Project-URL: Homepage, https://jupyter.org +Project-URL: Documentation, https://jupyter-core.readthedocs.io/ +Project-URL: Funding, https://numfocus.org/ +Project-URL: Source, https://github.com/jupyter/jupyter_core +Project-URL: Tracker, https://github.com/jupyter/jupyter_core/issues +Author-email: Jupyter Development Team +License: BSD 3-Clause License + + - 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 +Classifier: Framework :: Jupyter +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 +Requires-Python: >=3.8 +Requires-Dist: platformdirs>=2.5 +Requires-Dist: pywin32>=300; sys_platform == 'win32' and platform_python_implementation != 'PyPy' +Requires-Dist: traitlets>=5.3 +Provides-Extra: docs +Requires-Dist: myst-parser; extra == 'docs' +Requires-Dist: pydata-sphinx-theme; extra == 'docs' +Requires-Dist: sphinx-autodoc-typehints; extra == 'docs' +Requires-Dist: sphinxcontrib-github-alt; extra == 'docs' +Requires-Dist: sphinxcontrib-spelling; extra == 'docs' +Requires-Dist: traitlets; extra == 'docs' +Provides-Extra: test +Requires-Dist: ipykernel; extra == 'test' +Requires-Dist: pre-commit; extra == 'test' +Requires-Dist: pytest-cov; extra == 'test' +Requires-Dist: pytest-timeout; extra == 'test' +Requires-Dist: pytest<8; extra == 'test' +Description-Content-Type: text/plain + +There is no reason to install this package on its own. \ No newline at end of file diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/RECORD b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..da06395b61214e5c93b4b1e607659a108496a700 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/RECORD @@ -0,0 +1,30 @@ +../../../bin/jupyter,sha256=NWXQbaAPuSJaVsmOv0F7c27P-DF1Z8MkkllpgpVFcho,303 +../../../bin/jupyter-migrate,sha256=JTqCO7JLW8UiPLVku30NuWcH5kI-Eim59nWn5N8wzZQ,303 +../../../bin/jupyter-troubleshoot,sha256=dAgnCWsHB9gU5utw6pzjYpf0tnmITnprqqwpyaEdobk,308 +__pycache__/jupyter.cpython-310.pyc,, +jupyter.py,sha256=gsV1w0ThBkm_F_oHhFeKZ8achVPM4iHIXMdcPRRExKE,155 +jupyter_core-5.7.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +jupyter_core-5.7.2.dist-info/METADATA,sha256=9EervyuPeHvdMH3iYs4eFYb-oF0twxsycB4pQj0mL2E,3446 +jupyter_core-5.7.2.dist-info/RECORD,, +jupyter_core-5.7.2.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87 +jupyter_core-5.7.2.dist-info/entry_points.txt,sha256=EiJLUbf5Zt207UYCs4ILxYA_EzbMSo8pC98nk7gIfUI,152 +jupyter_core-5.7.2.dist-info/licenses/LICENSE,sha256=RI8YNfX6CN0HUIjkb3b3PrmsnCrvCmyIFr4G0w71ksc,1536 +jupyter_core/__init__.py,sha256=V1l87PR0VEmAjbms74SBsNrsvT7Epsg_QLPkjT-RSjQ,97 +jupyter_core/__main__.py,sha256=V2QuVYbglTKO5JmGSGGA-tbeitRH6YApIbAsqTEhejs,108 +jupyter_core/__pycache__/__init__.cpython-310.pyc,, +jupyter_core/__pycache__/__main__.cpython-310.pyc,, +jupyter_core/__pycache__/application.cpython-310.pyc,, +jupyter_core/__pycache__/command.cpython-310.pyc,, +jupyter_core/__pycache__/migrate.cpython-310.pyc,, +jupyter_core/__pycache__/paths.cpython-310.pyc,, +jupyter_core/__pycache__/troubleshoot.cpython-310.pyc,, +jupyter_core/__pycache__/version.cpython-310.pyc,, +jupyter_core/application.py,sha256=bzc78vwdtZq54wI86PAPZTyhIT3fzOkEds9yKN8wr4o,10374 +jupyter_core/command.py,sha256=pzvthuyn57kWAw8tEb8--ksHGtVq7bzFV9J_OGsoXqA,15699 +jupyter_core/migrate.py,sha256=eL3td5rJCEpD3u6eYzSN1kp4pBxXk10IzkBL6s0ehk0,8658 +jupyter_core/paths.py,sha256=XJk-s3jR_zNJ_BhFzeMhbrV49GwgkypG0yT-cL1892w,35856 +jupyter_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +jupyter_core/troubleshoot.py,sha256=t737JOsfcLZf3Xv_JKN4sNx1MtpzCBmB-0KcQIU5rKQ,3191 +jupyter_core/utils/__init__.py,sha256=GtZPIbxzLBDM4UnY6FfBPGwTU23Vq2L9JWX6RKyIH8Y,7141 +jupyter_core/utils/__pycache__/__init__.cpython-310.pyc,, +jupyter_core/version.py,sha256=O-dkPKSSowtsVcrYOhnSaVPnI2tMoxEQkjvE-1Cevxo,538 diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/WHEEL b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..5998f3aab327ceb8cb346647a3461e220359aebf --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: hatchling 1.21.1 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/entry_points.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..e3e551d1e7a5677772e5b8bd704b2b155ae8e3c3 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/entry_points.txt @@ -0,0 +1,4 @@ +[console_scripts] +jupyter = jupyter_core.command:main +jupyter-migrate = jupyter_core.migrate:main +jupyter-troubleshoot = jupyter_core.troubleshoot:main diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/licenses/LICENSE b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..a44e199a8af58e5922f8ebb696218312c317dedc --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jupyter_core-5.7.2.dist-info/licenses/LICENSE @@ -0,0 +1,30 @@ +BSD 3-Clause License + +- 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/pandocfilters-1.5.1.dist-info/LICENSE b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..330134ec3d174c3399959559b49f42c030572133 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2013, John MacFarlane +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + - Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + - 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. + + - Neither the name of John Macfarlane 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/pandocfilters-1.5.1.dist-info/METADATA b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..d2b615c1447a0b42c6cd4d4e1bd3a4ac426c54f2 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/METADATA @@ -0,0 +1,266 @@ +Metadata-Version: 2.1 +Name: pandocfilters +Version: 1.5.1 +Summary: Utilities for writing pandoc filters in python +Home-page: http://github.com/jgm/pandocfilters +Author: John MacFarlane +Author-email: fiddlosopher@gmail.com +License: BSD-3-Clause +Keywords: pandoc +Classifier: Development Status :: 3 - Alpha +Classifier: Environment :: Console +Classifier: Intended Audience :: End Users/Desktop +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: BSD License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Topic :: Text Processing :: Filters +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.7 +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.4 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.* +License-File: LICENSE + +pandocfilters +============= + +A python module for writing `pandoc `_ filters + +What are pandoc filters? +-------------------------- +Pandoc filters +are pipes that read a JSON serialization of the Pandoc AST +from stdin, transform it in some way, and write it to stdout. +They can be used with pandoc (>= 1.12) either using pipes :: + + pandoc -t json -s | ./caps.py | pandoc -f json + +or using the ``--filter`` (or ``-F``) command-line option. :: + + pandoc --filter ./caps.py -s + +For more on pandoc filters, see the pandoc documentation under ``--filter`` +and `the tutorial on writing filters`__. + +__ http://johnmacfarlane.net/pandoc/scripting.html + +For an alternative library for writing pandoc filters, with +a more "Pythonic" design, see `panflute`__. + +__ https://github.com/sergiocorreia/panflute + +Compatibility +---------------- +Pandoc 1.16 introduced link and image `attributes` to the existing +`caption` and `target` arguments, requiring a change in pandocfilters +that breaks backwards compatibility. Consequently, you should use: + +- pandocfilters version <= 1.2.4 for pandoc versions 1.12--1.15, and +- pandocfilters version >= 1.3.0 for pandoc versions >= 1.16. + +Pandoc 1.17.3 (pandoc-types 1.17.*) introduced a new JSON format. +pandocfilters 1.4.0 should work with both the old and the new +format. + +Installing +-------------- +Run this inside the present directory:: + + python setup.py install + +Or install from PyPI:: + + pip install pandocfilters + +Available functions +---------------------- +The main functions ``pandocfilters`` exports are + +- ``walk(x, action, format, meta)`` + + Walk a tree, applying an action to every object. Returns a modified + tree. An action is a function of the form + ``action(key, value, format, meta)``, where: + + - ``key`` is the type of the pandoc object (e.g. 'Str', 'Para') + - ``value`` is the contents of the object (e.g. a string for 'Str', a list of + inline elements for 'Para') + - ``format`` is the target output format (as supplied by the + ``format`` argument of ``walk``) + - ``meta`` is the document's metadata + + The return of an action is either: + + - ``None``: this means that the object should remain unchanged + - a pandoc object: this will replace the original object + - a list of pandoc objects: these will replace the original object; + the list is merged with the neighbors of the original objects + (spliced into the list the original object belongs to); returning + an empty list deletes the object + +- ``toJSONFilter(action)`` + + Like ``toJSONFilters``, but takes a single action as argument. + +- ``toJSONFilters(actions)`` + + Generate a JSON-to-JSON filter from stdin to stdout + + The filter: + + - reads a JSON-formatted pandoc document from stdin + - transforms it by walking the tree and performing the actions + - returns a new JSON-formatted pandoc document to stdout + + The argument ``actions`` is a list of functions of the form + ``action(key, value, format, meta)``, as described in more detail + under ``walk``. + + This function calls ``applyJSONFilters``, with the ``format`` + argument provided by the first command-line argument, if present. + (Pandoc sets this by default when calling filters.) + +- ``applyJSONFilters(actions, source, format="")`` + + Walk through JSON structure and apply filters + + This: + + - reads a JSON-formatted pandoc document from a source string + - transforms it by walking the tree and performing the actions + - returns a new JSON-formatted pandoc document as a string + + The ``actions`` argument is a list of functions (see ``walk`` for a + full description). + + The argument ``source`` is a string encoded JSON object. + + The argument ``format`` is a string describing the output format. + + Returns a new JSON-formatted pandoc document. + +- ``stringify(x)`` + + Walks the tree x and returns concatenated string content, leaving out + all formatting. + +- ``attributes(attrs)`` + + Returns an attribute list, constructed from the dictionary attrs. + +How to use +---------- +Most users will only need ``toJSONFilter``. Here is a simple example +of its use:: + + #!/usr/bin/env python + + """ + Pandoc filter to convert all regular text to uppercase. + Code, link URLs, etc. are not affected. + """ + + from pandocfilters import toJSONFilter, Str + + def caps(key, value, format, meta): + if key == 'Str': + return Str(value.upper()) + + if __name__ == "__main__": + toJSONFilter(caps) + +Examples +-------- + +The examples subdirectory in the source repository contains the +following filters. These filters should provide a useful starting point +for developing your own pandocfilters. + +``abc.py`` + Pandoc filter to process code blocks with class ``abc`` containing ABC + notation into images. Assumes that abcm2ps and ImageMagick's convert + are in the path. Images are put in the abc-images directory. + +``caps.py`` + Pandoc filter to convert all regular text to uppercase. Code, link + URLs, etc. are not affected. + +``blockdiag.py`` + Pandoc filter to process code blocks with class "blockdiag" into + generated images. Needs utils from http://blockdiag.com. + +``comments.py`` + Pandoc filter that causes everything between + ```` and ```` to be ignored. + The comment lines must appear on lines by themselves, with blank + lines surrounding + +``deemph.py`` + Pandoc filter that causes emphasized text to be displayed in ALL + CAPS. + +``deflists.py`` + Pandoc filter to convert definition lists to bullet lists with the + defined terms in strong emphasis (for compatibility with standard + markdown). + +``gabc.py`` + Pandoc filter to convert code blocks with class "gabc" to LaTeX + \\gabcsnippet commands in LaTeX output, and to images in HTML output. + +``graphviz.py`` + Pandoc filter to process code blocks with class ``graphviz`` into + graphviz-generated images. + +``lilypond.py`` + Pandoc filter to process code blocks with class "ly" containing + Lilypond notation. + +``metavars.py`` + Pandoc filter to allow interpolation of metadata fields into a + document. ``%{fields}`` will be replaced by the field's value, assuming + it is of the type ``MetaInlines`` or ``MetaString``. + +``myemph.py`` + Pandoc filter that causes emphasis to be rendered using the custom + macro ``\myemph{...}`` rather than ``\emph{...}`` in latex. Other output + formats are unaffected. + +``plantuml.py`` + Pandoc filter to process code blocks with class ``plantuml`` to images. + Needs `plantuml.jar` from http://plantuml.com/. + +``ditaa.py`` + Pandoc filter to process code blocks with class ``ditaa`` to images. + Needs `ditaa.jar` from http://ditaa.sourceforge.net/. + +``theorem.py`` + Pandoc filter to convert divs with ``class="theorem"`` to LaTeX theorem + environments in LaTeX output, and to numbered theorems in HTML + output. + +``tikz.py`` + Pandoc filter to process raw latex tikz environments into images. + Assumes that pdflatex is in the path, and that the standalone + package is available. Also assumes that ImageMagick's convert is in + the path. Images are put in the ``tikz-images`` directory. + +API documentation +----------------- + +By default most filters use ``get_filename4code`` to +create a directory ``...-images`` to save temporary +files. This directory doesn't get removed as it can be used as a cache so that +later pandoc runs don't have to recreate files if they already exist. The +directory is generated in the current directory. + +If you prefer to have a clean directory after running pandoc filters, you +can set an environment variable ``PANDOCFILTER_CLEANUP`` to any non-empty value such as `1` +which forces the code to create a temporary directory that will be removed +by the end of execution. diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/WHEEL b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..4724c45738f6ac125bb3a21787855562e6870440 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.42.0) +Root-Is-Purelib: true +Tag: py2-none-any +Tag: py3-none-any + diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/top_level.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..55260b135755cceb22a15dcb47a386f4aaa0451a --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pandocfilters-1.5.1.dist-info/top_level.txt @@ -0,0 +1 @@ +pandocfilters diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/INSTALLER b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/METADATA b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..9c3baa5cb674fd028352dbbaf3d0ee85c733da3e --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/METADATA @@ -0,0 +1,114 @@ +Metadata-Version: 2.3 +Name: soupsieve +Version: 2.6 +Summary: A modern CSS selector implementation for Beautiful Soup. +Project-URL: Homepage, https://github.com/facelessuser/soupsieve +Author-email: Isaac Muse +License-Expression: MIT +License-File: LICENSE.md +Keywords: CSS,HTML,XML,filter,query,selector,soup +Classifier: Development Status :: 5 - Production/Stable +Classifier: Environment :: Console +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Typing :: Typed +Requires-Python: >=3.8 +Description-Content-Type: text/markdown + +[![Donate via PayPal][donate-image]][donate-link] +[![Build][github-ci-image]][github-ci-link] +[![Coverage Status][codecov-image]][codecov-link] +[![PyPI Version][pypi-image]][pypi-link] +[![PyPI Downloads][pypi-down]][pypi-link] +[![PyPI - Python Version][python-image]][pypi-link] +![License][license-image-mit] + +# Soup Sieve + +## Overview + +Soup Sieve is a CSS selector library designed to be used with [Beautiful Soup 4][bs4]. It aims to provide selecting, +matching, and filtering using modern CSS selectors. Soup Sieve currently provides selectors from the CSS level 1 +specifications up through the latest CSS level 4 drafts and beyond (though some are not yet implemented). + +Soup Sieve was written with the intent to replace Beautiful Soup's builtin select feature, and as of Beautiful Soup +version 4.7.0, it now is :confetti_ball:. Soup Sieve can also be imported in order to use its API directly for +more controlled, specialized parsing. + +Soup Sieve has implemented most of the CSS selectors up through the latest CSS draft specifications, though there are a +number that don't make sense in a non-browser environment. Selectors that cannot provide meaningful functionality simply +do not match anything. Some of the supported selectors are: + +- `.classes` +- `#ids` +- `[attributes=value]` +- `parent child` +- `parent > child` +- `sibling ~ sibling` +- `sibling + sibling` +- `:not(element.class, element2.class)` +- `:is(element.class, element2.class)` +- `parent:has(> child)` +- and [many more](https://facelessuser.github.io/soupsieve/selectors/) + + +## Installation + +You must have Beautiful Soup already installed: + +``` +pip install beautifulsoup4 +``` + +In most cases, assuming you've installed version 4.7.0, that should be all you need to do, but if you've installed via +some alternative method, and Soup Sieve is not automatically installed, you can install it directly: + +``` +pip install soupsieve +``` + +If you want to manually install it from source, first ensure that [`build`](https://pypi.org/project/build/) is +installed: + +``` +pip install build +``` + +Then navigate to the root of the project and build the wheel and install (replacing `` with the current version): + +``` +python -m build -w +pip install dist/soupsieve--py3-none-any.whl +``` + +## Documentation + +Documentation is found here: https://facelessuser.github.io/soupsieve/. + +## License + +MIT + +[bs4]: https://beautiful-soup-4.readthedocs.io/en/latest/# + +[github-ci-image]: https://github.com/facelessuser/soupsieve/workflows/build/badge.svg?branch=master&event=push +[github-ci-link]: https://github.com/facelessuser/soupsieve/actions?query=workflow%3Abuild+branch%3Amaster +[codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/soupsieve/master.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333 +[codecov-link]: https://codecov.io/github/facelessuser/soupsieve +[pypi-image]: https://img.shields.io/pypi/v/soupsieve.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333 +[pypi-down]: https://img.shields.io/pypi/dm/soupsieve.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333 +[pypi-link]: https://pypi.python.org/pypi/soupsieve +[python-image]: https://img.shields.io/pypi/pyversions/soupsieve?logo=python&logoColor=aaaaaa&labelColor=333333 +[license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333 +[donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal +[donate-link]: https://www.paypal.me/facelessuser diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/RECORD b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..14bd1d7283dc45d128e20bc9452e740b5de6410d --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/RECORD @@ -0,0 +1,20 @@ +soupsieve-2.6.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +soupsieve-2.6.dist-info/METADATA,sha256=XxGCFdd8NozcZhkhLCIRZp6mLALmCsD3MXH7U-EP4x4,4564 +soupsieve-2.6.dist-info/RECORD,, +soupsieve-2.6.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87 +soupsieve-2.6.dist-info/licenses/LICENSE.md,sha256=fh8UyB6ZOe8jtHIXbNoIQQzCOHUtGAq6oBUdihxI9ZQ,1096 +soupsieve/__init__.py,sha256=_7zTjRaLhl42lrvqxMbPnmf8Mle83FXarwHJI028EHI,4599 +soupsieve/__meta__.py,sha256=CzEBcYdeUrKb1aHz33A7vwJU0tCjpvBjbSFNdcsRZ64,6766 +soupsieve/__pycache__/__init__.cpython-310.pyc,, +soupsieve/__pycache__/__meta__.cpython-310.pyc,, +soupsieve/__pycache__/css_match.cpython-310.pyc,, +soupsieve/__pycache__/css_parser.cpython-310.pyc,, +soupsieve/__pycache__/css_types.cpython-310.pyc,, +soupsieve/__pycache__/pretty.cpython-310.pyc,, +soupsieve/__pycache__/util.cpython-310.pyc,, +soupsieve/css_match.py,sha256=gwao2HUzTrwsSz8psfxwG6bS09TiiJrH9zQnrMqC2rc,57960 +soupsieve/css_parser.py,sha256=MaR2J1p9ZNeODC10zvUglknSI8mbmQF_xX0QZjPmWBo,46573 +soupsieve/css_types.py,sha256=qCxBRWX9sGjgLXgU9qmM95-OZCHPZ8kiyaHvn0ik_9w,10192 +soupsieve/pretty.py,sha256=8z9ZNykb57YR-mZUrY4O9YZXDP6BhGLSq9-DA5Y8rww,4033 +soupsieve/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +soupsieve/util.py,sha256=Q0MVH77cUBXMtKV0D2f8Syf90remPe0EfLqe6-msAeI,3352 diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/WHEEL b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..cdd68a497cdfa8d3f2b837225beacef711b85047 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: hatchling 1.25.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/licenses/LICENSE.md b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/licenses/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..d29cfcd196e6a883333f0a75b58cb99c5af872e5 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/soupsieve-2.6.dist-info/licenses/LICENSE.md @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 - 2024 Isaac Muse + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Co2p_Co3O4.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Co2p_Co3O4.txt new file mode 100644 index 0000000000000000000000000000000000000000..d68b5486f72a89e42b68ac020c6c8aa7bdfb3c3e --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Co2p_Co3O4.txt @@ -0,0 +1,702 @@ +Co2p Co3O4 +8.400000e+002 1.624770e+004 +8.399000e+002 1.633050e+004 +8.398000e+002 1.635643e+004 +8.397000e+002 1.638027e+004 +8.396000e+002 1.641050e+004 +8.395000e+002 1.632640e+004 +8.394000e+002 1.635667e+004 +8.393000e+002 1.642730e+004 +8.392000e+002 1.642460e+004 +8.391000e+002 1.649167e+004 +8.390000e+002 1.643783e+004 +8.389000e+002 1.637897e+004 +8.388000e+002 1.643697e+004 +8.387000e+002 1.645337e+004 +8.386000e+002 1.644410e+004 +8.385000e+002 1.645187e+004 +8.384000e+002 1.641023e+004 +8.383000e+002 1.636570e+004 +8.382000e+002 1.643670e+004 +8.381000e+002 1.644343e+004 +8.380000e+002 1.640363e+004 +8.379000e+002 1.634910e+004 +8.378000e+002 1.642860e+004 +8.377000e+002 1.638900e+004 +8.376000e+002 1.638257e+004 +8.375000e+002 1.640960e+004 +8.374000e+002 1.639417e+004 +8.373000e+002 1.639333e+004 +8.372000e+002 1.635097e+004 +8.371000e+002 1.636933e+004 +8.370000e+002 1.631273e+004 +8.369000e+002 1.630107e+004 +8.368000e+002 1.638993e+004 +8.367000e+002 1.636427e+004 +8.366000e+002 1.632353e+004 +8.365000e+002 1.633450e+004 +8.364000e+002 1.627320e+004 +8.363000e+002 1.626193e+004 +8.362000e+002 1.624860e+004 +8.361000e+002 1.622963e+004 +8.360000e+002 1.619980e+004 +8.359000e+002 1.624210e+004 +8.358000e+002 1.625280e+004 +8.357000e+002 1.619803e+004 +8.356000e+002 1.618793e+004 +8.355000e+002 1.622083e+004 +8.354000e+002 1.621010e+004 +8.353000e+002 1.624253e+004 +8.352000e+002 1.624810e+004 +8.351000e+002 1.620843e+004 +8.350000e+002 1.621130e+004 +8.349000e+002 1.626323e+004 +8.348000e+002 1.623863e+004 +8.347000e+002 1.622183e+004 +8.346000e+002 1.626603e+004 +8.345000e+002 1.624213e+004 +8.344000e+002 1.620837e+004 +8.343000e+002 1.622000e+004 +8.342000e+002 1.629073e+004 +8.341000e+002 1.622180e+004 +8.340000e+002 1.625043e+004 +8.339000e+002 1.626817e+004 +8.338000e+002 1.628067e+004 +8.337000e+002 1.628547e+004 +8.336000e+002 1.637070e+004 +8.335000e+002 1.631790e+004 +8.334000e+002 1.631320e+004 +8.333000e+002 1.630687e+004 +8.332000e+002 1.626557e+004 +8.331000e+002 1.628393e+004 +8.330000e+002 1.632863e+004 +8.329000e+002 1.626533e+004 +8.328000e+002 1.631980e+004 +8.327000e+002 1.630927e+004 +8.326000e+002 1.634710e+004 +8.325000e+002 1.633133e+004 +8.324000e+002 1.637537e+004 +8.323000e+002 1.635210e+004 +8.322000e+002 1.635510e+004 +8.321000e+002 1.632760e+004 +8.320000e+002 1.629810e+004 +8.319000e+002 1.625523e+004 +8.318000e+002 1.628727e+004 +8.317000e+002 1.628523e+004 +8.316000e+002 1.623060e+004 +8.315000e+002 1.621773e+004 +8.314000e+002 1.619903e+004 +8.313000e+002 1.628970e+004 +8.312000e+002 1.616757e+004 +8.311000e+002 1.619707e+004 +8.310000e+002 1.617943e+004 +8.309000e+002 1.611247e+004 +8.308000e+002 1.603543e+004 +8.307000e+002 1.606590e+004 +8.306000e+002 1.594610e+004 +8.305000e+002 1.591707e+004 +8.304000e+002 1.593283e+004 +8.303000e+002 1.588407e+004 +8.302000e+002 1.580650e+004 +8.301000e+002 1.569760e+004 +8.300000e+002 1.569857e+004 +8.299000e+002 1.560063e+004 +8.298000e+002 1.559120e+004 +8.297000e+002 1.548883e+004 +8.296000e+002 1.545303e+004 +8.295000e+002 1.539460e+004 +8.294000e+002 1.533687e+004 +8.293000e+002 1.529477e+004 +8.292000e+002 1.526430e+004 +8.291000e+002 1.522670e+004 +8.290000e+002 1.515947e+004 +8.289000e+002 1.509943e+004 +8.288000e+002 1.501553e+004 +8.287000e+002 1.498290e+004 +8.286000e+002 1.490910e+004 +8.285000e+002 1.490737e+004 +8.284000e+002 1.482623e+004 +8.283000e+002 1.477057e+004 +8.282000e+002 1.470570e+004 +8.281000e+002 1.465990e+004 +8.280000e+002 1.467033e+004 +8.279000e+002 1.464347e+004 +8.278000e+002 1.455573e+004 +8.277000e+002 1.456243e+004 +8.276000e+002 1.451980e+004 +8.275000e+002 1.452403e+004 +8.274000e+002 1.448670e+004 +8.273000e+002 1.441607e+004 +8.272000e+002 1.445703e+004 +8.271000e+002 1.442443e+004 +8.270000e+002 1.442447e+004 +8.269000e+002 1.441360e+004 +8.268000e+002 1.435727e+004 +8.267000e+002 1.433653e+004 +8.266000e+002 1.435293e+004 +8.265000e+002 1.434007e+004 +8.264000e+002 1.426913e+004 +8.263000e+002 1.427293e+004 +8.262000e+002 1.420517e+004 +8.261000e+002 1.425913e+004 +8.260000e+002 1.429000e+004 +8.259000e+002 1.429037e+004 +8.258000e+002 1.427687e+004 +8.257000e+002 1.423497e+004 +8.256000e+002 1.421357e+004 +8.255000e+002 1.424997e+004 +8.254000e+002 1.426877e+004 +8.253000e+002 1.426397e+004 +8.252000e+002 1.419957e+004 +8.251000e+002 1.421137e+004 +8.250000e+002 1.423540e+004 +8.249000e+002 1.421540e+004 +8.248000e+002 1.429547e+004 +8.247000e+002 1.424260e+004 +8.246000e+002 1.422727e+004 +8.245000e+002 1.418407e+004 +8.244000e+002 1.418630e+004 +8.243000e+002 1.421523e+004 +8.242000e+002 1.420460e+004 +8.241000e+002 1.421497e+004 +8.240000e+002 1.423000e+004 +8.239000e+002 1.424310e+004 +8.238000e+002 1.422143e+004 +8.237000e+002 1.420957e+004 +8.236000e+002 1.421590e+004 +8.235000e+002 1.422013e+004 +8.234000e+002 1.419820e+004 +8.233000e+002 1.417487e+004 +8.232000e+002 1.422287e+004 +8.231000e+002 1.423210e+004 +8.230000e+002 1.416483e+004 +8.229000e+002 1.424930e+004 +8.228000e+002 1.419300e+004 +8.227000e+002 1.423507e+004 +8.226000e+002 1.420813e+004 +8.225000e+002 1.417780e+004 +8.224000e+002 1.417393e+004 +8.223000e+002 1.418600e+004 +8.222000e+002 1.418700e+004 +8.221000e+002 1.422943e+004 +8.220000e+002 1.422150e+004 +8.219000e+002 1.420703e+004 +8.218000e+002 1.416530e+004 +8.217000e+002 1.415003e+004 +8.216000e+002 1.417050e+004 +8.215000e+002 1.416883e+004 +8.214000e+002 1.410273e+004 +8.213000e+002 1.413677e+004 +8.212000e+002 1.410157e+004 +8.211000e+002 1.414057e+004 +8.210000e+002 1.411863e+004 +8.209000e+002 1.411337e+004 +8.208000e+002 1.410773e+004 +8.207000e+002 1.408820e+004 +8.206000e+002 1.412500e+004 +8.205000e+002 1.411120e+004 +8.204000e+002 1.407080e+004 +8.203000e+002 1.405250e+004 +8.202000e+002 1.408693e+004 +8.201000e+002 1.407110e+004 +8.200000e+002 1.406103e+004 +8.199000e+002 1.398107e+004 +8.198000e+002 1.397897e+004 +8.197000e+002 1.407627e+004 +8.196000e+002 1.402157e+004 +8.195000e+002 1.403607e+004 +8.194000e+002 1.403047e+004 +8.193000e+002 1.396700e+004 +8.192000e+002 1.400907e+004 +8.191000e+002 1.404407e+004 +8.190000e+002 1.399093e+004 +8.189000e+002 1.400837e+004 +8.188000e+002 1.399477e+004 +8.187000e+002 1.399413e+004 +8.186000e+002 1.391620e+004 +8.185000e+002 1.401767e+004 +8.184000e+002 1.396260e+004 +8.183000e+002 1.404420e+004 +8.182000e+002 1.398647e+004 +8.181000e+002 1.391800e+004 +8.180000e+002 1.393577e+004 +8.179000e+002 1.398317e+004 +8.178000e+002 1.400070e+004 +8.177000e+002 1.393070e+004 +8.176000e+002 1.390407e+004 +8.175000e+002 1.394220e+004 +8.174000e+002 1.391523e+004 +8.173000e+002 1.393230e+004 +8.172000e+002 1.394100e+004 +8.171000e+002 1.392063e+004 +8.170000e+002 1.390113e+004 +8.169000e+002 1.386907e+004 +8.168000e+002 1.387300e+004 +8.167000e+002 1.385283e+004 +8.166000e+002 1.382720e+004 +8.165000e+002 1.381110e+004 +8.164000e+002 1.387747e+004 +8.163000e+002 1.386760e+004 +8.162000e+002 1.383527e+004 +8.161000e+002 1.376860e+004 +8.160000e+002 1.382877e+004 +8.159000e+002 1.379450e+004 +8.158000e+002 1.373053e+004 +8.157000e+002 1.377363e+004 +8.156000e+002 1.376963e+004 +8.155000e+002 1.374033e+004 +8.154000e+002 1.370857e+004 +8.153000e+002 1.375593e+004 +8.152000e+002 1.376253e+004 +8.151000e+002 1.374267e+004 +8.150000e+002 1.368980e+004 +8.149000e+002 1.374270e+004 +8.148000e+002 1.369583e+004 +8.147000e+002 1.360053e+004 +8.146000e+002 1.360870e+004 +8.145000e+002 1.364273e+004 +8.144000e+002 1.367180e+004 +8.143000e+002 1.365087e+004 +8.142000e+002 1.364030e+004 +8.141000e+002 1.363097e+004 +8.140000e+002 1.367937e+004 +8.139000e+002 1.367293e+004 +8.138000e+002 1.355443e+004 +8.137000e+002 1.359173e+004 +8.136000e+002 1.360857e+004 +8.135000e+002 1.359990e+004 +8.134000e+002 1.357403e+004 +8.133000e+002 1.353917e+004 +8.132000e+002 1.353253e+004 +8.131000e+002 1.361617e+004 +8.130000e+002 1.362590e+004 +8.129000e+002 1.356497e+004 +8.128000e+002 1.350100e+004 +8.127000e+002 1.348303e+004 +8.126000e+002 1.342683e+004 +8.125000e+002 1.345237e+004 +8.124000e+002 1.343877e+004 +8.123000e+002 1.345173e+004 +8.122000e+002 1.346073e+004 +8.121000e+002 1.351580e+004 +8.120000e+002 1.350050e+004 +8.119000e+002 1.346213e+004 +8.118000e+002 1.344020e+004 +8.117000e+002 1.349810e+004 +8.116000e+002 1.355347e+004 +8.115000e+002 1.349520e+004 +8.114000e+002 1.349383e+004 +8.113000e+002 1.348673e+004 +8.112000e+002 1.352383e+004 +8.111000e+002 1.347970e+004 +8.110000e+002 1.346440e+004 +8.109000e+002 1.341860e+004 +8.108000e+002 1.343753e+004 +8.107000e+002 1.350860e+004 +8.106000e+002 1.349970e+004 +8.105000e+002 1.350453e+004 +8.104000e+002 1.347203e+004 +8.103000e+002 1.350330e+004 +8.102000e+002 1.350390e+004 +8.101000e+002 1.347173e+004 +8.100000e+002 1.348587e+004 +8.099000e+002 1.351900e+004 +8.098000e+002 1.352560e+004 +8.097000e+002 1.355813e+004 +8.096000e+002 1.355860e+004 +8.095000e+002 1.361733e+004 +8.094000e+002 1.352967e+004 +8.093000e+002 1.357503e+004 +8.092000e+002 1.355040e+004 +8.091000e+002 1.354273e+004 +8.090000e+002 1.356743e+004 +8.089000e+002 1.360453e+004 +8.088000e+002 1.362207e+004 +8.087000e+002 1.364870e+004 +8.086000e+002 1.366000e+004 +8.085000e+002 1.369830e+004 +8.084000e+002 1.370060e+004 +8.083000e+002 1.370990e+004 +8.082000e+002 1.375087e+004 +8.081000e+002 1.377123e+004 +8.080000e+002 1.376607e+004 +8.079000e+002 1.378533e+004 +8.078000e+002 1.379703e+004 +8.077000e+002 1.389463e+004 +8.076000e+002 1.391200e+004 +8.075000e+002 1.392230e+004 +8.074000e+002 1.393503e+004 +8.073000e+002 1.400823e+004 +8.072000e+002 1.408167e+004 +8.071000e+002 1.411513e+004 +8.070000e+002 1.416873e+004 +8.069000e+002 1.413523e+004 +8.068000e+002 1.424917e+004 +8.067000e+002 1.430790e+004 +8.066000e+002 1.437930e+004 +8.065000e+002 1.433340e+004 +8.064000e+002 1.435907e+004 +8.063000e+002 1.441370e+004 +8.062000e+002 1.446353e+004 +8.061000e+002 1.451853e+004 +8.060000e+002 1.456310e+004 +8.059000e+002 1.463897e+004 +8.058000e+002 1.464697e+004 +8.057000e+002 1.470083e+004 +8.056000e+002 1.470363e+004 +8.055000e+002 1.472123e+004 +8.054000e+002 1.478483e+004 +8.053000e+002 1.479243e+004 +8.052000e+002 1.481453e+004 +8.051000e+002 1.481013e+004 +8.050000e+002 1.487763e+004 +8.049000e+002 1.489570e+004 +8.048000e+002 1.494627e+004 +8.047000e+002 1.499523e+004 +8.046000e+002 1.497850e+004 +8.045000e+002 1.496323e+004 +8.044000e+002 1.495077e+004 +8.043000e+002 1.503183e+004 +8.042000e+002 1.498967e+004 +8.041000e+002 1.499847e+004 +8.040000e+002 1.497763e+004 +8.039000e+002 1.503683e+004 +8.038000e+002 1.495047e+004 +8.037000e+002 1.492663e+004 +8.036000e+002 1.497640e+004 +8.035000e+002 1.487333e+004 +8.034000e+002 1.487710e+004 +8.033000e+002 1.484933e+004 +8.032000e+002 1.485853e+004 +8.031000e+002 1.498767e+004 +8.030000e+002 1.488593e+004 +8.029000e+002 1.482757e+004 +8.028000e+002 1.481917e+004 +8.027000e+002 1.474047e+004 +8.026000e+002 1.472643e+004 +8.025000e+002 1.476813e+004 +8.024000e+002 1.470507e+004 +8.023000e+002 1.464680e+004 +8.022000e+002 1.462680e+004 +8.021000e+002 1.465367e+004 +8.020000e+002 1.456287e+004 +8.019000e+002 1.448033e+004 +8.018000e+002 1.442887e+004 +8.017000e+002 1.442843e+004 +8.016000e+002 1.441300e+004 +8.015000e+002 1.440107e+004 +8.014000e+002 1.436787e+004 +8.013000e+002 1.431497e+004 +8.012000e+002 1.426443e+004 +8.011000e+002 1.428393e+004 +8.010000e+002 1.421533e+004 +8.009000e+002 1.418100e+004 +8.008000e+002 1.420087e+004 +8.007000e+002 1.422187e+004 +8.006000e+002 1.416780e+004 +8.005000e+002 1.419730e+004 +8.004000e+002 1.407577e+004 +8.003000e+002 1.411280e+004 +8.002000e+002 1.414473e+004 +8.001000e+002 1.409050e+004 +8.000000e+002 1.413387e+004 +7.999000e+002 1.410897e+004 +7.998000e+002 1.416593e+004 +7.997000e+002 1.423523e+004 +7.996000e+002 1.419080e+004 +7.995000e+002 1.419103e+004 +7.994000e+002 1.432660e+004 +7.993000e+002 1.432030e+004 +7.992000e+002 1.439253e+004 +7.991000e+002 1.441560e+004 +7.990000e+002 1.449540e+004 +7.989000e+002 1.454697e+004 +7.988000e+002 1.466263e+004 +7.987000e+002 1.478290e+004 +7.986000e+002 1.487257e+004 +7.985000e+002 1.492323e+004 +7.984000e+002 1.511510e+004 +7.983000e+002 1.516867e+004 +7.982000e+002 1.531040e+004 +7.981000e+002 1.547050e+004 +7.980000e+002 1.564120e+004 +7.979000e+002 1.578170e+004 +7.978000e+002 1.599647e+004 +7.977000e+002 1.616460e+004 +7.976000e+002 1.635363e+004 +7.975000e+002 1.649703e+004 +7.974000e+002 1.674867e+004 +7.973000e+002 1.691637e+004 +7.972000e+002 1.714167e+004 +7.971000e+002 1.739610e+004 +7.970000e+002 1.766307e+004 +7.969000e+002 1.785380e+004 +7.968000e+002 1.805703e+004 +7.967000e+002 1.825830e+004 +7.966000e+002 1.850793e+004 +7.965000e+002 1.871287e+004 +7.964000e+002 1.894593e+004 +7.963000e+002 1.906370e+004 +7.962000e+002 1.927817e+004 +7.961000e+002 1.944927e+004 +7.960000e+002 1.957987e+004 +7.959000e+002 1.975730e+004 +7.958000e+002 1.985957e+004 +7.957000e+002 2.000610e+004 +7.956000e+002 2.012043e+004 +7.955000e+002 2.022073e+004 +7.954000e+002 2.028613e+004 +7.953000e+002 2.032753e+004 +7.952000e+002 2.039377e+004 +7.951000e+002 2.057293e+004 +7.950000e+002 2.069497e+004 +7.949000e+002 2.095490e+004 +7.948000e+002 2.119697e+004 +7.947000e+002 2.151473e+004 +7.946000e+002 2.166250e+004 +7.945000e+002 2.176970e+004 +7.944000e+002 2.167630e+004 +7.943000e+002 2.130320e+004 +7.942000e+002 2.066427e+004 +7.941000e+002 1.972583e+004 +7.940000e+002 1.876347e+004 +7.939000e+002 1.776903e+004 +7.938000e+002 1.677903e+004 +7.937000e+002 1.593010e+004 +7.936000e+002 1.526443e+004 +7.935000e+002 1.471953e+004 +7.934000e+002 1.431477e+004 +7.933000e+002 1.388830e+004 +7.932000e+002 1.361620e+004 +7.931000e+002 1.343170e+004 +7.930000e+002 1.324043e+004 +7.929000e+002 1.311517e+004 +7.928000e+002 1.303103e+004 +7.927000e+002 1.299267e+004 +7.926000e+002 1.294537e+004 +7.925000e+002 1.295873e+004 +7.924000e+002 1.296753e+004 +7.923000e+002 1.301007e+004 +7.922000e+002 1.301090e+004 +7.921000e+002 1.303607e+004 +7.920000e+002 1.308260e+004 +7.919000e+002 1.317510e+004 +7.918000e+002 1.325823e+004 +7.917000e+002 1.334343e+004 +7.916000e+002 1.340003e+004 +7.915000e+002 1.349343e+004 +7.914000e+002 1.359013e+004 +7.913000e+002 1.366947e+004 +7.912000e+002 1.378530e+004 +7.911000e+002 1.380457e+004 +7.910000e+002 1.388557e+004 +7.909000e+002 1.401277e+004 +7.908000e+002 1.410517e+004 +7.907000e+002 1.417623e+004 +7.906000e+002 1.423207e+004 +7.905000e+002 1.428097e+004 +7.904000e+002 1.429290e+004 +7.903000e+002 1.437630e+004 +7.902000e+002 1.451077e+004 +7.901000e+002 1.451587e+004 +7.900000e+002 1.452460e+004 +7.899000e+002 1.463493e+004 +7.898000e+002 1.461993e+004 +7.897000e+002 1.461180e+004 +7.896000e+002 1.458697e+004 +7.895000e+002 1.462693e+004 +7.894000e+002 1.473240e+004 +7.893000e+002 1.476973e+004 +7.892000e+002 1.474197e+004 +7.891000e+002 1.473227e+004 +7.890000e+002 1.476273e+004 +7.889000e+002 1.479523e+004 +7.888000e+002 1.472583e+004 +7.887000e+002 1.475960e+004 +7.886000e+002 1.470287e+004 +7.885000e+002 1.465763e+004 +7.884000e+002 1.462227e+004 +7.883000e+002 1.462447e+004 +7.882000e+002 1.455723e+004 +7.881000e+002 1.453103e+004 +7.880000e+002 1.454307e+004 +7.879000e+002 1.447093e+004 +7.878000e+002 1.448933e+004 +7.877000e+002 1.450720e+004 +7.876000e+002 1.445017e+004 +7.875000e+002 1.437713e+004 +7.874000e+002 1.442197e+004 +7.873000e+002 1.441073e+004 +7.872000e+002 1.437127e+004 +7.871000e+002 1.437930e+004 +7.870000e+002 1.451410e+004 +7.869000e+002 1.448403e+004 +7.868000e+002 1.443763e+004 +7.867000e+002 1.451327e+004 +7.866000e+002 1.448773e+004 +7.865000e+002 1.445030e+004 +7.864000e+002 1.442817e+004 +7.863000e+002 1.450733e+004 +7.862000e+002 1.450393e+004 +7.861000e+002 1.450427e+004 +7.860000e+002 1.451727e+004 +7.859000e+002 1.447610e+004 +7.858000e+002 1.462767e+004 +7.857000e+002 1.460513e+004 +7.856000e+002 1.455997e+004 +7.855000e+002 1.454320e+004 +7.854000e+002 1.456943e+004 +7.853000e+002 1.454550e+004 +7.852000e+002 1.458240e+004 +7.851000e+002 1.452953e+004 +7.850000e+002 1.449277e+004 +7.849000e+002 1.457803e+004 +7.848000e+002 1.460403e+004 +7.847000e+002 1.464320e+004 +7.846000e+002 1.465517e+004 +7.845000e+002 1.469377e+004 +7.844000e+002 1.474347e+004 +7.843000e+002 1.473277e+004 +7.842000e+002 1.477620e+004 +7.841000e+002 1.482167e+004 +7.840000e+002 1.493660e+004 +7.839000e+002 1.507820e+004 +7.838000e+002 1.515690e+004 +7.837000e+002 1.529433e+004 +7.836000e+002 1.547993e+004 +7.835000e+002 1.560477e+004 +7.834000e+002 1.571890e+004 +7.833000e+002 1.593607e+004 +7.832000e+002 1.617400e+004 +7.831000e+002 1.640420e+004 +7.830000e+002 1.660523e+004 +7.829000e+002 1.680777e+004 +7.828000e+002 1.716440e+004 +7.827000e+002 1.746460e+004 +7.826000e+002 1.780923e+004 +7.825000e+002 1.817017e+004 +7.824000e+002 1.853983e+004 +7.823000e+002 1.894110e+004 +7.822000e+002 1.933520e+004 +7.821000e+002 1.984747e+004 +7.820000e+002 2.038693e+004 +7.819000e+002 2.077557e+004 +7.818000e+002 2.129837e+004 +7.817000e+002 2.190903e+004 +7.816000e+002 2.244277e+004 +7.815000e+002 2.293533e+004 +7.814000e+002 2.347043e+004 +7.813000e+002 2.400537e+004 +7.812000e+002 2.454420e+004 +7.811000e+002 2.517413e+004 +7.810000e+002 2.570110e+004 +7.809000e+002 2.623273e+004 +7.808000e+002 2.687253e+004 +7.807000e+002 2.740353e+004 +7.806000e+002 2.783907e+004 +7.805000e+002 2.831600e+004 +7.804000e+002 2.862127e+004 +7.803000e+002 2.885057e+004 +7.802000e+002 2.916130e+004 +7.801000e+002 2.926157e+004 +7.800000e+002 2.976677e+004 +7.799000e+002 3.020187e+004 +7.798000e+002 3.067417e+004 +7.797000e+002 3.143383e+004 +7.796000e+002 3.212487e+004 +7.795000e+002 3.259310e+004 +7.794000e+002 3.254223e+004 +7.793000e+002 3.180893e+004 +7.792000e+002 3.020497e+004 +7.791000e+002 2.806527e+004 +7.790000e+002 2.553553e+004 +7.789000e+002 2.291880e+004 +7.788000e+002 2.061723e+004 +7.787000e+002 1.875173e+004 +7.786000e+002 1.723607e+004 +7.785000e+002 1.608577e+004 +7.784000e+002 1.511987e+004 +7.783000e+002 1.417130e+004 +7.782000e+002 1.332653e+004 +7.781000e+002 1.260890e+004 +7.780000e+002 1.193500e+004 +7.779000e+002 1.140727e+004 +7.778000e+002 1.094073e+004 +7.777000e+002 1.067813e+004 +7.776000e+002 1.047987e+004 +7.775000e+002 1.024187e+004 +7.774000e+002 1.007453e+004 +7.773000e+002 1.002597e+004 +7.772000e+002 9.889200e+003 +7.771000e+002 9.849300e+003 +7.770000e+002 9.753967e+003 +7.769000e+002 9.741533e+003 +7.768000e+002 9.638400e+003 +7.767000e+002 9.567867e+003 +7.766000e+002 9.526900e+003 +7.765000e+002 9.493500e+003 +7.764000e+002 9.401233e+003 +7.763000e+002 9.347633e+003 +7.762000e+002 9.307633e+003 +7.761000e+002 9.237500e+003 +7.760000e+002 9.220033e+003 +7.759000e+002 9.190867e+003 +7.758000e+002 9.131967e+003 +7.757000e+002 9.080400e+003 +7.756000e+002 9.052200e+003 +7.755000e+002 9.035567e+003 +7.754000e+002 8.989767e+003 +7.753000e+002 8.893433e+003 +7.752000e+002 8.873700e+003 +7.751000e+002 8.869233e+003 +7.750000e+002 8.844267e+003 +7.749000e+002 8.812967e+003 +7.748000e+002 8.744267e+003 +7.747000e+002 8.769433e+003 +7.746000e+002 8.722500e+003 +7.745000e+002 8.732767e+003 +7.744000e+002 8.689433e+003 +7.743000e+002 8.646267e+003 +7.742000e+002 8.649467e+003 +7.741000e+002 8.651567e+003 +7.740000e+002 8.602967e+003 +7.739000e+002 8.585933e+003 +7.738000e+002 8.582733e+003 +7.737000e+002 8.531100e+003 +7.736000e+002 8.524833e+003 +7.735000e+002 8.528633e+003 +7.734000e+002 8.480267e+003 +7.733000e+002 8.503167e+003 +7.732000e+002 8.462900e+003 +7.731000e+002 8.446767e+003 +7.730000e+002 8.399800e+003 +7.729000e+002 8.354367e+003 +7.728000e+002 8.380633e+003 +7.727000e+002 8.380700e+003 +7.726000e+002 8.338933e+003 +7.725000e+002 8.342933e+003 +7.724000e+002 8.317433e+003 +7.723000e+002 8.316533e+003 +7.722000e+002 8.320567e+003 +7.721000e+002 8.281933e+003 +7.720000e+002 8.298200e+003 +7.719000e+002 8.272600e+003 +7.718000e+002 8.343967e+003 +7.717000e+002 8.310667e+003 +7.716000e+002 8.231067e+003 +7.715000e+002 8.266500e+003 +7.714000e+002 8.264733e+003 +7.713000e+002 8.288233e+003 +7.712000e+002 8.247967e+003 +7.711000e+002 8.219200e+003 +7.710000e+002 8.241333e+003 +7.709000e+002 8.207300e+003 +7.708000e+002 8.194900e+003 +7.707000e+002 8.148767e+003 +7.706000e+002 8.108367e+003 +7.705000e+002 8.093333e+003 +7.704000e+002 8.102433e+003 +7.703000e+002 8.123533e+003 +7.702000e+002 8.092800e+003 +7.701000e+002 8.053267e+003 +7.700000e+002 8.006633e+003 \ No newline at end of file diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Co2p_Co_metal.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Co2p_Co_metal.txt new file mode 100644 index 0000000000000000000000000000000000000000..eb5157352a1ff2e1a814c6b4073c9b3eae422ce2 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Co2p_Co_metal.txt @@ -0,0 +1,702 @@ +Co2p Co metal +8.400000e+002 2.282790e+004 +8.399000e+002 2.286890e+004 +8.398000e+002 2.296260e+004 +8.397000e+002 2.297305e+004 +8.396000e+002 2.294845e+004 +8.395000e+002 2.312860e+004 +8.394000e+002 2.316170e+004 +8.393000e+002 2.315915e+004 +8.392000e+002 2.308765e+004 +8.391000e+002 2.311180e+004 +8.390000e+002 2.314375e+004 +8.389000e+002 2.305165e+004 +8.388000e+002 2.316295e+004 +8.387000e+002 2.326195e+004 +8.386000e+002 2.321090e+004 +8.385000e+002 2.319065e+004 +8.384000e+002 2.319165e+004 +8.383000e+002 2.318025e+004 +8.382000e+002 2.331735e+004 +8.381000e+002 2.329660e+004 +8.380000e+002 2.330590e+004 +8.379000e+002 2.333990e+004 +8.378000e+002 2.331140e+004 +8.377000e+002 2.327935e+004 +8.376000e+002 2.317360e+004 +8.375000e+002 2.317290e+004 +8.374000e+002 2.310940e+004 +8.373000e+002 2.320355e+004 +8.372000e+002 2.321970e+004 +8.371000e+002 2.320795e+004 +8.370000e+002 2.315745e+004 +8.369000e+002 2.302905e+004 +8.368000e+002 2.318055e+004 +8.367000e+002 2.316715e+004 +8.366000e+002 2.305720e+004 +8.365000e+002 2.311555e+004 +8.364000e+002 2.302580e+004 +8.363000e+002 2.292405e+004 +8.362000e+002 2.297910e+004 +8.361000e+002 2.294575e+004 +8.360000e+002 2.289060e+004 +8.359000e+002 2.293645e+004 +8.358000e+002 2.290145e+004 +8.357000e+002 2.270250e+004 +8.356000e+002 2.263085e+004 +8.355000e+002 2.263345e+004 +8.354000e+002 2.266110e+004 +8.353000e+002 2.244825e+004 +8.352000e+002 2.251710e+004 +8.351000e+002 2.254870e+004 +8.350000e+002 2.248885e+004 +8.349000e+002 2.251565e+004 +8.348000e+002 2.248645e+004 +8.347000e+002 2.256425e+004 +8.346000e+002 2.242670e+004 +8.345000e+002 2.247370e+004 +8.344000e+002 2.241800e+004 +8.343000e+002 2.237195e+004 +8.342000e+002 2.234795e+004 +8.341000e+002 2.225685e+004 +8.340000e+002 2.212955e+004 +8.339000e+002 2.233960e+004 +8.338000e+002 2.233625e+004 +8.337000e+002 2.222125e+004 +8.336000e+002 2.231590e+004 +8.335000e+002 2.242325e+004 +8.334000e+002 2.250480e+004 +8.333000e+002 2.232610e+004 +8.332000e+002 2.220945e+004 +8.331000e+002 2.224425e+004 +8.330000e+002 2.238365e+004 +8.329000e+002 2.243185e+004 +8.328000e+002 2.245805e+004 +8.327000e+002 2.255675e+004 +8.326000e+002 2.263265e+004 +8.325000e+002 2.256235e+004 +8.324000e+002 2.257910e+004 +8.323000e+002 2.260750e+004 +8.322000e+002 2.259675e+004 +8.321000e+002 2.259970e+004 +8.320000e+002 2.270625e+004 +8.319000e+002 2.280225e+004 +8.318000e+002 2.306400e+004 +8.317000e+002 2.313140e+004 +8.316000e+002 2.319285e+004 +8.315000e+002 2.302835e+004 +8.314000e+002 2.314545e+004 +8.313000e+002 2.321725e+004 +8.312000e+002 2.327565e+004 +8.311000e+002 2.326135e+004 +8.310000e+002 2.333870e+004 +8.309000e+002 2.327365e+004 +8.308000e+002 2.345730e+004 +8.307000e+002 2.349920e+004 +8.306000e+002 2.340845e+004 +8.305000e+002 2.328865e+004 +8.304000e+002 2.342600e+004 +8.303000e+002 2.326265e+004 +8.302000e+002 2.330010e+004 +8.301000e+002 2.324810e+004 +8.300000e+002 2.308380e+004 +8.299000e+002 2.311800e+004 +8.298000e+002 2.309145e+004 +8.297000e+002 2.305085e+004 +8.296000e+002 2.289410e+004 +8.295000e+002 2.284570e+004 +8.294000e+002 2.257690e+004 +8.293000e+002 2.255345e+004 +8.292000e+002 2.242010e+004 +8.291000e+002 2.232885e+004 +8.290000e+002 2.216760e+004 +8.289000e+002 2.192660e+004 +8.288000e+002 2.177080e+004 +8.287000e+002 2.183535e+004 +8.286000e+002 2.162470e+004 +8.285000e+002 2.143380e+004 +8.284000e+002 2.129425e+004 +8.283000e+002 2.116090e+004 +8.282000e+002 2.094555e+004 +8.281000e+002 2.090830e+004 +8.280000e+002 2.087300e+004 +8.279000e+002 2.081315e+004 +8.278000e+002 2.073855e+004 +8.277000e+002 2.050455e+004 +8.276000e+002 2.041770e+004 +8.275000e+002 2.034335e+004 +8.274000e+002 2.027935e+004 +8.273000e+002 2.031775e+004 +8.272000e+002 2.018330e+004 +8.271000e+002 2.019015e+004 +8.270000e+002 2.001465e+004 +8.269000e+002 2.006945e+004 +8.268000e+002 1.997030e+004 +8.267000e+002 1.988530e+004 +8.266000e+002 1.993335e+004 +8.265000e+002 1.993055e+004 +8.264000e+002 1.980885e+004 +8.263000e+002 1.970880e+004 +8.262000e+002 1.984265e+004 +8.261000e+002 1.980185e+004 +8.260000e+002 1.977425e+004 +8.259000e+002 1.958525e+004 +8.258000e+002 1.957585e+004 +8.257000e+002 1.964365e+004 +8.256000e+002 1.958610e+004 +8.255000e+002 1.973560e+004 +8.254000e+002 1.965590e+004 +8.253000e+002 1.958615e+004 +8.252000e+002 1.951490e+004 +8.251000e+002 1.936000e+004 +8.250000e+002 1.955795e+004 +8.249000e+002 1.957140e+004 +8.248000e+002 1.954045e+004 +8.247000e+002 1.970285e+004 +8.246000e+002 1.966260e+004 +8.245000e+002 1.946105e+004 +8.244000e+002 1.960095e+004 +8.243000e+002 1.969950e+004 +8.242000e+002 1.955425e+004 +8.241000e+002 1.945140e+004 +8.240000e+002 1.939000e+004 +8.239000e+002 1.953875e+004 +8.238000e+002 1.949675e+004 +8.237000e+002 1.933855e+004 +8.236000e+002 1.942125e+004 +8.235000e+002 1.945820e+004 +8.234000e+002 1.946950e+004 +8.233000e+002 1.956575e+004 +8.232000e+002 1.950690e+004 +8.231000e+002 1.957225e+004 +8.230000e+002 1.941475e+004 +8.229000e+002 1.946775e+004 +8.228000e+002 1.955860e+004 +8.227000e+002 1.942465e+004 +8.226000e+002 1.951425e+004 +8.225000e+002 1.956110e+004 +8.224000e+002 1.942695e+004 +8.223000e+002 1.939290e+004 +8.222000e+002 1.954585e+004 +8.221000e+002 1.964010e+004 +8.220000e+002 1.955455e+004 +8.219000e+002 1.958190e+004 +8.218000e+002 1.961975e+004 +8.217000e+002 1.966465e+004 +8.216000e+002 1.943215e+004 +8.215000e+002 1.943735e+004 +8.214000e+002 1.946285e+004 +8.213000e+002 1.962845e+004 +8.212000e+002 1.956180e+004 +8.211000e+002 1.945820e+004 +8.210000e+002 1.950330e+004 +8.209000e+002 1.951160e+004 +8.208000e+002 1.965415e+004 +8.207000e+002 1.958030e+004 +8.206000e+002 1.954505e+004 +8.205000e+002 1.966060e+004 +8.204000e+002 1.965710e+004 +8.203000e+002 1.949890e+004 +8.202000e+002 1.947775e+004 +8.201000e+002 1.949015e+004 +8.200000e+002 1.959020e+004 +8.199000e+002 1.955570e+004 +8.198000e+002 1.949305e+004 +8.197000e+002 1.958035e+004 +8.196000e+002 1.969180e+004 +8.195000e+002 1.964610e+004 +8.194000e+002 1.962595e+004 +8.193000e+002 1.959165e+004 +8.192000e+002 1.970270e+004 +8.191000e+002 1.986120e+004 +8.190000e+002 1.983075e+004 +8.189000e+002 1.966150e+004 +8.188000e+002 1.960875e+004 +8.187000e+002 1.976045e+004 +8.186000e+002 1.973095e+004 +8.185000e+002 1.976965e+004 +8.184000e+002 1.982375e+004 +8.183000e+002 1.989040e+004 +8.182000e+002 1.971890e+004 +8.181000e+002 1.987575e+004 +8.180000e+002 1.983195e+004 +8.179000e+002 1.976635e+004 +8.178000e+002 1.990710e+004 +8.177000e+002 1.975930e+004 +8.176000e+002 1.989430e+004 +8.175000e+002 1.992640e+004 +8.174000e+002 1.992685e+004 +8.173000e+002 1.986660e+004 +8.172000e+002 1.993465e+004 +8.171000e+002 1.975765e+004 +8.170000e+002 1.977770e+004 +8.169000e+002 1.990040e+004 +8.168000e+002 1.996910e+004 +8.167000e+002 2.003455e+004 +8.166000e+002 2.006940e+004 +8.165000e+002 2.006475e+004 +8.164000e+002 2.002295e+004 +8.163000e+002 1.998310e+004 +8.162000e+002 2.007350e+004 +8.161000e+002 2.009215e+004 +8.160000e+002 2.005830e+004 +8.159000e+002 2.012390e+004 +8.158000e+002 2.004435e+004 +8.157000e+002 2.013905e+004 +8.156000e+002 2.011095e+004 +8.155000e+002 2.014495e+004 +8.154000e+002 2.019730e+004 +8.153000e+002 2.016600e+004 +8.152000e+002 2.031590e+004 +8.151000e+002 2.024725e+004 +8.150000e+002 2.019845e+004 +8.149000e+002 2.030960e+004 +8.148000e+002 2.032775e+004 +8.147000e+002 2.047730e+004 +8.146000e+002 2.034640e+004 +8.145000e+002 2.034305e+004 +8.144000e+002 2.028615e+004 +8.143000e+002 2.029725e+004 +8.142000e+002 2.042965e+004 +8.141000e+002 2.041670e+004 +8.140000e+002 2.027925e+004 +8.139000e+002 2.032565e+004 +8.138000e+002 2.025725e+004 +8.137000e+002 2.029010e+004 +8.136000e+002 2.032440e+004 +8.135000e+002 2.034020e+004 +8.134000e+002 2.027775e+004 +8.133000e+002 2.027680e+004 +8.132000e+002 2.023635e+004 +8.131000e+002 2.026720e+004 +8.130000e+002 2.022790e+004 +8.129000e+002 2.024350e+004 +8.128000e+002 2.011230e+004 +8.127000e+002 2.032080e+004 +8.126000e+002 2.029380e+004 +8.125000e+002 2.015875e+004 +8.124000e+002 2.014910e+004 +8.123000e+002 2.018705e+004 +8.122000e+002 2.005325e+004 +8.121000e+002 2.015570e+004 +8.120000e+002 2.014315e+004 +8.119000e+002 2.011315e+004 +8.118000e+002 2.020710e+004 +8.117000e+002 2.011360e+004 +8.116000e+002 2.021555e+004 +8.115000e+002 2.013710e+004 +8.114000e+002 2.027065e+004 +8.113000e+002 2.014435e+004 +8.112000e+002 2.012455e+004 +8.111000e+002 2.016870e+004 +8.110000e+002 2.020820e+004 +8.109000e+002 2.010410e+004 +8.108000e+002 2.027120e+004 +8.107000e+002 2.027385e+004 +8.106000e+002 2.020180e+004 +8.105000e+002 2.013880e+004 +8.104000e+002 2.018360e+004 +8.103000e+002 2.025640e+004 +8.102000e+002 2.013585e+004 +8.101000e+002 2.019295e+004 +8.100000e+002 2.026685e+004 +8.099000e+002 2.025575e+004 +8.098000e+002 2.026585e+004 +8.097000e+002 2.030510e+004 +8.096000e+002 2.027710e+004 +8.095000e+002 2.024325e+004 +8.094000e+002 2.037095e+004 +8.093000e+002 2.033715e+004 +8.092000e+002 2.045655e+004 +8.091000e+002 2.049210e+004 +8.090000e+002 2.046615e+004 +8.089000e+002 2.028410e+004 +8.088000e+002 2.032340e+004 +8.087000e+002 2.037890e+004 +8.086000e+002 2.044590e+004 +8.085000e+002 2.040075e+004 +8.084000e+002 2.050205e+004 +8.083000e+002 2.036735e+004 +8.082000e+002 2.034900e+004 +8.081000e+002 2.049120e+004 +8.080000e+002 2.044810e+004 +8.079000e+002 2.040110e+004 +8.078000e+002 2.035840e+004 +8.077000e+002 2.045255e+004 +8.076000e+002 2.057950e+004 +8.075000e+002 2.060900e+004 +8.074000e+002 2.056425e+004 +8.073000e+002 2.052225e+004 +8.072000e+002 2.074770e+004 +8.071000e+002 2.062240e+004 +8.070000e+002 2.069065e+004 +8.069000e+002 2.074320e+004 +8.068000e+002 2.085260e+004 +8.067000e+002 2.082360e+004 +8.066000e+002 2.094335e+004 +8.065000e+002 2.090475e+004 +8.064000e+002 2.082655e+004 +8.063000e+002 2.090585e+004 +8.062000e+002 2.093770e+004 +8.061000e+002 2.089455e+004 +8.060000e+002 2.090390e+004 +8.059000e+002 2.085355e+004 +8.058000e+002 2.113600e+004 +8.057000e+002 2.102430e+004 +8.056000e+002 2.101335e+004 +8.055000e+002 2.096790e+004 +8.054000e+002 2.098525e+004 +8.053000e+002 2.103400e+004 +8.052000e+002 2.099800e+004 +8.051000e+002 2.095475e+004 +8.050000e+002 2.104600e+004 +8.049000e+002 2.101825e+004 +8.048000e+002 2.113405e+004 +8.047000e+002 2.108270e+004 +8.046000e+002 2.108715e+004 +8.045000e+002 2.111620e+004 +8.044000e+002 2.114705e+004 +8.043000e+002 2.103705e+004 +8.042000e+002 2.120315e+004 +8.041000e+002 2.113950e+004 +8.040000e+002 2.116620e+004 +8.039000e+002 2.116935e+004 +8.038000e+002 2.126125e+004 +8.037000e+002 2.122635e+004 +8.036000e+002 2.128965e+004 +8.035000e+002 2.135990e+004 +8.034000e+002 2.122925e+004 +8.033000e+002 2.135730e+004 +8.032000e+002 2.136990e+004 +8.031000e+002 2.135145e+004 +8.030000e+002 2.136300e+004 +8.029000e+002 2.134845e+004 +8.028000e+002 2.140520e+004 +8.027000e+002 2.140525e+004 +8.026000e+002 2.155805e+004 +8.025000e+002 2.155065e+004 +8.024000e+002 2.141420e+004 +8.023000e+002 2.150145e+004 +8.022000e+002 2.160135e+004 +8.021000e+002 2.161435e+004 +8.020000e+002 2.170640e+004 +8.019000e+002 2.158370e+004 +8.018000e+002 2.158225e+004 +8.017000e+002 2.176610e+004 +8.016000e+002 2.164605e+004 +8.015000e+002 2.148525e+004 +8.014000e+002 2.159530e+004 +8.013000e+002 2.178490e+004 +8.012000e+002 2.188140e+004 +8.011000e+002 2.166305e+004 +8.010000e+002 2.175095e+004 +8.009000e+002 2.165595e+004 +8.008000e+002 2.179645e+004 +8.007000e+002 2.186430e+004 +8.006000e+002 2.181140e+004 +8.005000e+002 2.175150e+004 +8.004000e+002 2.188985e+004 +8.003000e+002 2.192445e+004 +8.002000e+002 2.204420e+004 +8.001000e+002 2.187405e+004 +8.000000e+002 2.187035e+004 +7.999000e+002 2.195815e+004 +7.998000e+002 2.199515e+004 +7.997000e+002 2.215160e+004 +7.996000e+002 2.225385e+004 +7.995000e+002 2.216055e+004 +7.994000e+002 2.218045e+004 +7.993000e+002 2.217605e+004 +7.992000e+002 2.224400e+004 +7.991000e+002 2.233875e+004 +7.990000e+002 2.237180e+004 +7.989000e+002 2.241880e+004 +7.988000e+002 2.248560e+004 +7.987000e+002 2.253730e+004 +7.986000e+002 2.263680e+004 +7.985000e+002 2.277465e+004 +7.984000e+002 2.272275e+004 +7.983000e+002 2.268865e+004 +7.982000e+002 2.278155e+004 +7.981000e+002 2.289885e+004 +7.980000e+002 2.288710e+004 +7.979000e+002 2.280900e+004 +7.978000e+002 2.311520e+004 +7.977000e+002 2.314805e+004 +7.976000e+002 2.316990e+004 +7.975000e+002 2.327550e+004 +7.974000e+002 2.333930e+004 +7.973000e+002 2.352985e+004 +7.972000e+002 2.365030e+004 +7.971000e+002 2.367505e+004 +7.970000e+002 2.376470e+004 +7.969000e+002 2.381360e+004 +7.968000e+002 2.396225e+004 +7.967000e+002 2.414355e+004 +7.966000e+002 2.414350e+004 +7.965000e+002 2.443395e+004 +7.964000e+002 2.456865e+004 +7.963000e+002 2.456415e+004 +7.962000e+002 2.467745e+004 +7.961000e+002 2.485175e+004 +7.960000e+002 2.511960e+004 +7.959000e+002 2.501800e+004 +7.958000e+002 2.525730e+004 +7.957000e+002 2.547990e+004 +7.956000e+002 2.568770e+004 +7.955000e+002 2.588495e+004 +7.954000e+002 2.614870e+004 +7.953000e+002 2.637785e+004 +7.952000e+002 2.652425e+004 +7.951000e+002 2.697550e+004 +7.950000e+002 2.714860e+004 +7.949000e+002 2.744825e+004 +7.948000e+002 2.770430e+004 +7.947000e+002 2.806690e+004 +7.946000e+002 2.849710e+004 +7.945000e+002 2.876650e+004 +7.944000e+002 2.915750e+004 +7.943000e+002 2.949480e+004 +7.942000e+002 2.990130e+004 +7.941000e+002 3.029545e+004 +7.940000e+002 3.089340e+004 +7.939000e+002 3.157470e+004 +7.938000e+002 3.205590e+004 +7.937000e+002 3.290355e+004 +7.936000e+002 3.349530e+004 +7.935000e+002 3.405715e+004 +7.934000e+002 3.468405e+004 +7.933000e+002 3.509755e+004 +7.932000e+002 3.520635e+004 +7.931000e+002 3.501125e+004 +7.930000e+002 3.432100e+004 +7.929000e+002 3.333010e+004 +7.928000e+002 3.217250e+004 +7.927000e+002 3.080235e+004 +7.926000e+002 2.939075e+004 +7.925000e+002 2.784315e+004 +7.924000e+002 2.639560e+004 +7.923000e+002 2.521165e+004 +7.922000e+002 2.418775e+004 +7.921000e+002 2.339185e+004 +7.920000e+002 2.255130e+004 +7.919000e+002 2.194215e+004 +7.918000e+002 2.151505e+004 +7.917000e+002 2.110150e+004 +7.916000e+002 2.073580e+004 +7.915000e+002 2.074065e+004 +7.914000e+002 2.027105e+004 +7.913000e+002 2.013320e+004 +7.912000e+002 2.007880e+004 +7.911000e+002 2.001665e+004 +7.910000e+002 1.977930e+004 +7.909000e+002 1.966960e+004 +7.908000e+002 1.952365e+004 +7.907000e+002 1.942740e+004 +7.906000e+002 1.937945e+004 +7.905000e+002 1.936125e+004 +7.904000e+002 1.914905e+004 +7.903000e+002 1.916700e+004 +7.902000e+002 1.915380e+004 +7.901000e+002 1.909485e+004 +7.900000e+002 1.912010e+004 +7.899000e+002 1.916535e+004 +7.898000e+002 1.906565e+004 +7.897000e+002 1.914500e+004 +7.896000e+002 1.904290e+004 +7.895000e+002 1.908095e+004 +7.894000e+002 1.910295e+004 +7.893000e+002 1.918070e+004 +7.892000e+002 1.925550e+004 +7.891000e+002 1.923385e+004 +7.890000e+002 1.918585e+004 +7.889000e+002 1.926335e+004 +7.888000e+002 1.926820e+004 +7.887000e+002 1.929280e+004 +7.886000e+002 1.948430e+004 +7.885000e+002 1.953350e+004 +7.884000e+002 1.950975e+004 +7.883000e+002 1.949275e+004 +7.882000e+002 1.942325e+004 +7.881000e+002 1.953775e+004 +7.880000e+002 1.966950e+004 +7.879000e+002 1.969420e+004 +7.878000e+002 1.965610e+004 +7.877000e+002 1.972690e+004 +7.876000e+002 1.972880e+004 +7.875000e+002 1.986545e+004 +7.874000e+002 1.994155e+004 +7.873000e+002 1.975560e+004 +7.872000e+002 1.985395e+004 +7.871000e+002 1.989000e+004 +7.870000e+002 2.005825e+004 +7.869000e+002 2.003995e+004 +7.868000e+002 2.004435e+004 +7.867000e+002 2.008780e+004 +7.866000e+002 2.012445e+004 +7.865000e+002 2.021050e+004 +7.864000e+002 2.035295e+004 +7.863000e+002 2.037820e+004 +7.862000e+002 2.033140e+004 +7.861000e+002 2.044420e+004 +7.860000e+002 2.045800e+004 +7.859000e+002 2.060135e+004 +7.858000e+002 2.053560e+004 +7.857000e+002 2.059970e+004 +7.856000e+002 2.063255e+004 +7.855000e+002 2.073205e+004 +7.854000e+002 2.067585e+004 +7.853000e+002 2.094795e+004 +7.852000e+002 2.108410e+004 +7.851000e+002 2.101545e+004 +7.850000e+002 2.101930e+004 +7.849000e+002 2.105695e+004 +7.848000e+002 2.121450e+004 +7.847000e+002 2.119735e+004 +7.846000e+002 2.138925e+004 +7.845000e+002 2.160575e+004 +7.844000e+002 2.163930e+004 +7.843000e+002 2.168435e+004 +7.842000e+002 2.172185e+004 +7.841000e+002 2.175330e+004 +7.840000e+002 2.180420e+004 +7.839000e+002 2.207665e+004 +7.838000e+002 2.199835e+004 +7.837000e+002 2.217560e+004 +7.836000e+002 2.227425e+004 +7.835000e+002 2.246365e+004 +7.834000e+002 2.247325e+004 +7.833000e+002 2.248225e+004 +7.832000e+002 2.275170e+004 +7.831000e+002 2.294825e+004 +7.830000e+002 2.307625e+004 +7.829000e+002 2.321600e+004 +7.828000e+002 2.341550e+004 +7.827000e+002 2.341730e+004 +7.826000e+002 2.360325e+004 +7.825000e+002 2.368290e+004 +7.824000e+002 2.394970e+004 +7.823000e+002 2.412300e+004 +7.822000e+002 2.411445e+004 +7.821000e+002 2.411720e+004 +7.820000e+002 2.437720e+004 +7.819000e+002 2.457025e+004 +7.818000e+002 2.444150e+004 +7.817000e+002 2.456225e+004 +7.816000e+002 2.452875e+004 +7.815000e+002 2.472405e+004 +7.814000e+002 2.480595e+004 +7.813000e+002 2.471630e+004 +7.812000e+002 2.485400e+004 +7.811000e+002 2.517390e+004 +7.810000e+002 2.512890e+004 +7.809000e+002 2.536130e+004 +7.808000e+002 2.575980e+004 +7.807000e+002 2.599870e+004 +7.806000e+002 2.621220e+004 +7.805000e+002 2.635235e+004 +7.804000e+002 2.701855e+004 +7.803000e+002 2.732830e+004 +7.802000e+002 2.764680e+004 +7.801000e+002 2.830555e+004 +7.800000e+002 2.872155e+004 +7.799000e+002 2.934250e+004 +7.798000e+002 2.998560e+004 +7.797000e+002 3.079205e+004 +7.796000e+002 3.171370e+004 +7.795000e+002 3.234175e+004 +7.794000e+002 3.360045e+004 +7.793000e+002 3.465640e+004 +7.792000e+002 3.612545e+004 +7.791000e+002 3.767100e+004 +7.790000e+002 3.973105e+004 +7.789000e+002 4.233930e+004 +7.788000e+002 4.542930e+004 +7.787000e+002 4.937155e+004 +7.786000e+002 5.399650e+004 +7.785000e+002 5.913450e+004 +7.784000e+002 6.406450e+004 +7.783000e+002 6.785150e+004 +7.782000e+002 6.961550e+004 +7.781000e+002 6.801450e+004 +7.780000e+002 6.328400e+004 +7.779000e+002 5.599450e+004 +7.778000e+002 4.760420e+004 +7.777000e+002 3.916875e+004 +7.776000e+002 3.219910e+004 +7.775000e+002 2.698540e+004 +7.774000e+002 2.333750e+004 +7.773000e+002 2.091065e+004 +7.772000e+002 1.907860e+004 +7.771000e+002 1.786230e+004 +7.770000e+002 1.703165e+004 +7.769000e+002 1.640630e+004 +7.768000e+002 1.587570e+004 +7.767000e+002 1.558565e+004 +7.766000e+002 1.524905e+004 +7.765000e+002 1.487530e+004 +7.764000e+002 1.474210e+004 +7.763000e+002 1.459585e+004 +7.762000e+002 1.442120e+004 +7.761000e+002 1.427800e+004 +7.760000e+002 1.421905e+004 +7.759000e+002 1.404445e+004 +7.758000e+002 1.401795e+004 +7.757000e+002 1.387690e+004 +7.756000e+002 1.383390e+004 +7.755000e+002 1.370040e+004 +7.754000e+002 1.346990e+004 +7.753000e+002 1.334365e+004 +7.752000e+002 1.328825e+004 +7.751000e+002 1.309200e+004 +7.750000e+002 1.296990e+004 +7.749000e+002 1.289305e+004 +7.748000e+002 1.268075e+004 +7.747000e+002 1.250975e+004 +7.746000e+002 1.241505e+004 +7.745000e+002 1.232380e+004 +7.744000e+002 1.216540e+004 +7.743000e+002 1.194750e+004 +7.742000e+002 1.185245e+004 +7.741000e+002 1.174810e+004 +7.740000e+002 1.188065e+004 +7.739000e+002 1.169825e+004 +7.738000e+002 1.153970e+004 +7.737000e+002 1.150020e+004 +7.736000e+002 1.141175e+004 +7.735000e+002 1.145225e+004 +7.734000e+002 1.150005e+004 +7.733000e+002 1.134970e+004 +7.732000e+002 1.126505e+004 +7.731000e+002 1.131300e+004 +7.730000e+002 1.132840e+004 +7.729000e+002 1.136730e+004 +7.728000e+002 1.135850e+004 +7.727000e+002 1.136900e+004 +7.726000e+002 1.132025e+004 +7.725000e+002 1.137400e+004 +7.724000e+002 1.136400e+004 +7.723000e+002 1.133655e+004 +7.722000e+002 1.129935e+004 +7.721000e+002 1.130470e+004 +7.720000e+002 1.141650e+004 +7.719000e+002 1.150835e+004 +7.718000e+002 1.141920e+004 +7.717000e+002 1.141525e+004 +7.716000e+002 1.150070e+004 +7.715000e+002 1.149140e+004 +7.714000e+002 1.141755e+004 +7.713000e+002 1.138805e+004 +7.712000e+002 1.144175e+004 +7.711000e+002 1.143145e+004 +7.710000e+002 1.143365e+004 +7.709000e+002 1.133330e+004 +7.708000e+002 1.127950e+004 +7.707000e+002 1.129100e+004 +7.706000e+002 1.115445e+004 +7.705000e+002 1.104730e+004 +7.704000e+002 1.093010e+004 +7.703000e+002 1.089650e+004 +7.702000e+002 1.088675e+004 +7.701000e+002 1.080455e+004 +7.700000e+002 1.069325e+004 \ No newline at end of file diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Cu_references.vms b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Cu_references.vms new file mode 100644 index 0000000000000000000000000000000000000000..003abce5c7d6d34f7a7aad4923a4778c4aa4bafd --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Cu_references.vms @@ -0,0 +1,20513 @@ +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.24PR1.0 +0 +SourceAnalyserAngle: 56.500000 d +CasaRowLabel:Cu metal +CasaRowLabel:Cu2O +CasaRowLabel:CuO +NORM +REGULAR +4 +1 +Exp Variable +d +0 +0 +0 +0 +11 +Cu2p +Cu metal +2006 +2018 +2 +6 +17 +18 +0 +7 +Casa Info Follows +0 +0 +0 +0 +Sum of 6 spectra in column containing 6 scans +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +1 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +3.808 +0 +0 +0 +0 +0 +Cu +2p +-1 +kinetic energy +eV +514.66 +0.05 +2 +counts +d +Transmission +d +pulse counting +0.6 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +2080 +243.592 +4205.68 +1 +1 +359.381 +1 +361.632 +1 +358.01 +1 +350.174 +1 +357.996 +1 +361.042 +1 +358.251 +1 +370.476 +1 +364.022 +1 +355.938 +1 +360.482 +1 +360.746 +1 +357.443 +1 +353.195 +1 +355.467 +1 +364.591 +1 +365.842 +1 +357.023 +1 +355.702 +1 +345.378 +1 +356.217 +1 +349.574 +1 +353.298 +1 +350.876 +1 +353.574 +1 +360.246 +1 +366.465 +1 +372.717 +1 +366.013 +1 +360.017 +1 +357.779 +1 +357.169 +1 +356.628 +1 +347.819 +1 +351.79 +1 +350.373 +1 +355.344 +1 +351.021 +1 +360.399 +1 +360.501 +1 +361.394 +1 +358.048 +1 +354.066 +1 +357.701 +1 +355.308 +1 +361.053 +1 +357.704 +1 +357.932 +1 +358.018 +1 +359.601 +1 +357.389 +1 +356.473 +1 +363.074 +1 +372.954 +1 +357.459 +1 +355.192 +1 +363.972 +1 +352.894 +1 +364.073 +1 +365.154 +1 +359.225 +1 +357.229 +1 +354.288 +1 +359.683 +1 +358.297 +1 +356.694 +1 +362.185 +1 +358.261 +1 +353.384 +1 +352.227 +1 +359.153 +1 +348.827 +1 +358.338 +1 +372.994 +1 +365.478 +1 +351.502 +1 +353.99 +1 +361.831 +1 +364.004 +1 +359.908 +1 +362.57 +1 +363.544 +1 +362.796 +1 +360.052 +1 +354.12 +1 +352.858 +1 +357.881 +1 +370.541 +1 +352.989 +1 +355.499 +1 +366.254 +1 +363.853 +1 +357.242 +1 +362.906 +1 +361.527 +1 +360.423 +1 +362.185 +1 +365.656 +1 +357.192 +1 +349.108 +1 +356.782 +1 +351.227 +1 +361.476 +1 +367.984 +1 +363.747 +1 +359.316 +1 +357.142 +1 +368.077 +1 +364.338 +1 +358.507 +1 +357.55 +1 +360.285 +1 +361.575 +1 +359.474 +1 +354.526 +1 +362.748 +1 +367.075 +1 +366.627 +1 +363.245 +1 +363.316 +1 +361.367 +1 +359.044 +1 +364.66 +1 +372.123 +1 +368.47 +1 +368.312 +1 +366.852 +1 +376.334 +1 +361.296 +1 +363.872 +1 +374.137 +1 +371.44 +1 +370.507 +1 +364.006 +1 +363.983 +1 +377.24 +1 +370.846 +1 +373.992 +1 +369.709 +1 +366.514 +1 +372.615 +1 +369.42 +1 +372.248 +1 +374.662 +1 +377.056 +1 +367.426 +1 +367.38 +1 +366.694 +1 +362.193 +1 +372.492 +1 +370.916 +1 +368.4 +1 +357.404 +1 +351.263 +1 +358.21 +1 +356.976 +1 +360.642 +1 +362.375 +1 +361.651 +1 +359.514 +1 +355.279 +1 +349.046 +1 +360.502 +1 +366.873 +1 +359.871 +1 +344.953 +1 +357.37 +1 +357.939 +1 +356.118 +1 +351.81 +1 +357.306 +1 +355.079 +1 +355.491 +1 +350.145 +1 +353.151 +1 +347.652 +1 +352.538 +1 +351.306 +1 +350.09 +1 +349.265 +1 +342.78 +1 +340.206 +1 +351.859 +1 +351.739 +1 +346.632 +1 +346.952 +1 +354.504 +1 +357.009 +1 +349.577 +1 +345.806 +1 +353.486 +1 +343.608 +1 +344.762 +1 +354.856 +1 +345.769 +1 +343.774 +1 +350.676 +1 +347.981 +1 +345.335 +1 +340.591 +1 +345.848 +1 +340.089 +1 +348.3 +1 +346.464 +1 +349.847 +1 +345.67 +1 +341.313 +1 +347.127 +1 +341.754 +1 +350.684 +1 +340.562 +1 +350.53 +1 +344.21 +1 +349.173 +1 +346.8 +1 +344.043 +1 +343.619 +1 +347.636 +1 +349.907 +1 +357.115 +1 +360.935 +1 +354.364 +1 +340.748 +1 +342.125 +1 +353.357 +1 +345.604 +1 +352.023 +1 +355.766 +1 +355.733 +1 +345.179 +1 +339.758 +1 +340.005 +1 +348.874 +1 +347.498 +1 +347.357 +1 +356.118 +1 +347.793 +1 +348.344 +1 +340.859 +1 +345.433 +1 +353.115 +1 +343.5 +1 +350.417 +1 +350.146 +1 +346.528 +1 +347.905 +1 +343.314 +1 +344.32 +1 +341.275 +1 +346.774 +1 +352.033 +1 +352.449 +1 +356.469 +1 +352.467 +1 +354.416 +1 +358.509 +1 +352.682 +1 +349.223 +1 +350.569 +1 +351.646 +1 +351.423 +1 +346.909 +1 +347.475 +1 +347.735 +1 +353.404 +1 +348.063 +1 +347.281 +1 +344.428 +1 +352.05 +1 +358.079 +1 +350.197 +1 +353.2 +1 +352.977 +1 +359.936 +1 +353.369 +1 +348.583 +1 +350.034 +1 +356.017 +1 +352.132 +1 +345.626 +1 +347.923 +1 +345.694 +1 +354.094 +1 +354.794 +1 +346.738 +1 +346.316 +1 +354.326 +1 +349.247 +1 +346.095 +1 +347.557 +1 +357.384 +1 +355.503 +1 +364.816 +1 +354.985 +1 +354.088 +1 +356.386 +1 +351.53 +1 +364.342 +1 +362.152 +1 +367.631 +1 +365.139 +1 +353.846 +1 +357.771 +1 +357.374 +1 +364.105 +1 +366.013 +1 +361.691 +1 +359.366 +1 +361.093 +1 +364.159 +1 +362.858 +1 +363.995 +1 +363.973 +1 +363.754 +1 +368.241 +1 +369.258 +1 +368.55 +1 +379.801 +1 +373.93 +1 +366.347 +1 +368.79 +1 +369.82 +1 +369.508 +1 +374.868 +1 +372.547 +1 +373.647 +1 +380.839 +1 +377.039 +1 +384.533 +1 +385.088 +1 +380.577 +1 +382.969 +1 +382.015 +1 +379.772 +1 +385.925 +1 +387.929 +1 +381.522 +1 +389.441 +1 +393.99 +1 +392.311 +1 +400.543 +1 +404.86 +1 +396.182 +1 +407.005 +1 +405.889 +1 +402.128 +1 +408.757 +1 +415.274 +1 +407.21 +1 +426.015 +1 +432.57 +1 +436.088 +1 +438.611 +1 +432.886 +1 +439.137 +1 +446.267 +1 +449.089 +1 +457.057 +1 +462.6 +1 +470.224 +1 +470.828 +1 +482.066 +1 +493.379 +1 +499.69 +1 +512.619 +1 +522.254 +1 +534.728 +1 +545.775 +1 +555.368 +1 +572.781 +1 +585.175 +1 +611.965 +1 +633.705 +1 +656.77 +1 +676.975 +1 +699.582 +1 +722.093 +1 +749.026 +1 +768.178 +1 +804.195 +1 +830.242 +1 +863.46 +1 +883.251 +1 +911.474 +1 +928.741 +1 +955.748 +1 +964.814 +1 +980.866 +1 +996.391 +1 +988.24 +1 +993.483 +1 +976.124 +1 +940.648 +1 +935.82 +1 +921.059 +1 +891.864 +1 +846.634 +1 +811.741 +1 +800.196 +1 +752.967 +1 +713.457 +1 +697.74 +1 +667.093 +1 +649.776 +1 +625.538 +1 +598.376 +1 +579.397 +1 +572.07 +1 +540.014 +1 +536.219 +1 +512.121 +1 +499.161 +1 +485.983 +1 +467.105 +1 +462.967 +1 +451.688 +1 +447.622 +1 +437.247 +1 +436.046 +1 +421.357 +1 +414.268 +1 +416.146 +1 +410.442 +1 +403.574 +1 +403.164 +1 +392.433 +1 +387.741 +1 +398.013 +1 +382.637 +1 +383.129 +1 +381.781 +1 +370.475 +1 +379.438 +1 +370.01 +1 +369.781 +1 +365.791 +1 +364.744 +1 +352.823 +1 +363.099 +1 +362.216 +1 +355.579 +1 +350.261 +1 +351.273 +1 +348.177 +1 +348.564 +1 +348.086 +1 +339.961 +1 +345.639 +1 +346.401 +1 +338.779 +1 +332.353 +1 +335.972 +1 +339.73 +1 +337.877 +1 +332.704 +1 +334.508 +1 +324.287 +1 +330.368 +1 +327.586 +1 +315.472 +1 +325.85 +1 +322.143 +1 +327.588 +1 +318.575 +1 +319.242 +1 +321.459 +1 +322.478 +1 +319.682 +1 +320.768 +1 +320.994 +1 +322.504 +1 +321.642 +1 +324.111 +1 +320.704 +1 +323.267 +1 +330.143 +1 +325.72 +1 +328.103 +1 +322.258 +1 +315.948 +1 +322.289 +1 +326.108 +1 +325.205 +1 +327.445 +1 +315.82 +1 +318.966 +1 +321.168 +1 +321.03 +1 +324.211 +1 +321.238 +1 +315.495 +1 +320.985 +1 +321.87 +1 +320.923 +1 +313.841 +1 +314.883 +1 +316.415 +1 +313.493 +1 +309.768 +1 +316.519 +1 +320.874 +1 +323.644 +1 +312.272 +1 +316.059 +1 +312.599 +1 +318.429 +1 +318.383 +1 +315.442 +1 +310.898 +1 +315.48 +1 +321.843 +1 +312.048 +1 +309.661 +1 +315.963 +1 +322.17 +1 +318.267 +1 +310.709 +1 +314.389 +1 +318.441 +1 +308.165 +1 +315.262 +1 +314.433 +1 +320.006 +1 +316.529 +1 +312.128 +1 +313.433 +1 +316.812 +1 +313.532 +1 +310.914 +1 +304.836 +1 +299.857 +1 +295.644 +1 +309.896 +1 +304.558 +1 +299.201 +1 +294.006 +1 +298.612 +1 +301.692 +1 +303.475 +1 +293.955 +1 +301.807 +1 +303.029 +1 +306.084 +1 +298.385 +1 +297.204 +1 +300.081 +1 +292.046 +1 +294.053 +1 +295.866 +1 +297.687 +1 +300.401 +1 +297.707 +1 +304.285 +1 +297.726 +1 +290.278 +1 +286.36 +1 +299.239 +1 +299.779 +1 +300.403 +1 +290.593 +1 +298.603 +1 +288.385 +1 +284.66 +1 +292.678 +1 +296.618 +1 +299.862 +1 +291.15 +1 +288.338 +1 +282.936 +1 +284.159 +1 +285.745 +1 +279.036 +1 +285.158 +1 +285.068 +1 +285.324 +1 +286.191 +1 +276.884 +1 +281.409 +1 +284.283 +1 +281.056 +1 +280.014 +1 +276.644 +1 +280.155 +1 +275.223 +1 +272.377 +1 +270.629 +1 +276.966 +1 +278.837 +1 +274.968 +1 +274.522 +1 +273.619 +1 +275.866 +1 +270.588 +1 +269.064 +1 +271.604 +1 +272.728 +1 +268.9 +1 +271.999 +1 +264.174 +1 +266.124 +1 +265.796 +1 +262.599 +1 +263.09 +1 +253.248 +1 +258.394 +1 +260.139 +1 +263.396 +1 +258.825 +1 +251.493 +1 +258.369 +1 +258.393 +1 +263.258 +1 +251.909 +1 +257.775 +1 +258.867 +1 +258.331 +1 +248.454 +1 +250.666 +1 +249.339 +1 +253.603 +1 +261.152 +1 +260.128 +1 +256.703 +1 +261.073 +1 +254.282 +1 +259.636 +1 +255.579 +1 +253.418 +1 +254.358 +1 +253.814 +1 +249.938 +1 +248.154 +1 +252.248 +1 +252.591 +1 +260.36 +1 +255.625 +1 +265.043 +1 +268.254 +1 +255.917 +1 +257.923 +1 +263.337 +1 +254.812 +1 +258.306 +1 +262.369 +1 +256.801 +1 +262.439 +1 +254.657 +1 +247.442 +1 +249.66 +1 +257.657 +1 +258.798 +1 +255.516 +1 +253.547 +1 +256.295 +1 +259.372 +1 +250.363 +1 +253.414 +1 +252.301 +1 +252.055 +1 +253.649 +1 +250.725 +1 +250.492 +1 +252.649 +1 +250.483 +1 +252.089 +1 +255.488 +1 +244.382 +1 +257.434 +1 +254.374 +1 +250.416 +1 +260.647 +1 +252.101 +1 +256.492 +1 +252.838 +1 +259.731 +1 +253.823 +1 +258.211 +1 +261.444 +1 +254.983 +1 +252.14 +1 +257.611 +1 +256.194 +1 +259.753 +1 +261.906 +1 +256.204 +1 +262.024 +1 +268.113 +1 +259.749 +1 +263.775 +1 +262.795 +1 +263.584 +1 +263.958 +1 +264.526 +1 +261.811 +1 +256.6 +1 +262.301 +1 +266.745 +1 +258.49 +1 +265.256 +1 +262.15 +1 +264.036 +1 +265.165 +1 +261.905 +1 +266.163 +1 +262.34 +1 +268.022 +1 +272.768 +1 +262.065 +1 +263.683 +1 +270.088 +1 +268.645 +1 +263.1 +1 +264.075 +1 +271.227 +1 +267.63 +1 +268.486 +1 +269.33 +1 +266.869 +1 +275.468 +1 +275.614 +1 +274.422 +1 +271.301 +1 +265.388 +1 +266.235 +1 +275.669 +1 +276.469 +1 +273.177 +1 +264.249 +1 +275.955 +1 +278.606 +1 +274.653 +1 +271.176 +1 +284.883 +1 +276.405 +1 +278.469 +1 +278.295 +1 +278.707 +1 +279.168 +1 +285.978 +1 +283.393 +1 +288.806 +1 +291.777 +1 +291.92 +1 +289.963 +1 +300.972 +1 +306.073 +1 +304.987 +1 +306.113 +1 +308.571 +1 +314.177 +1 +327.424 +1 +330.892 +1 +332.137 +1 +339.602 +1 +344.793 +1 +349.591 +1 +375.767 +1 +374.345 +1 +395.468 +1 +403.994 +1 +413.353 +1 +434.269 +1 +455.307 +1 +483.397 +1 +505.124 +1 +528.35 +1 +558.019 +1 +592.542 +1 +635.773 +1 +682.442 +1 +736.326 +1 +809.789 +1 +888.799 +1 +992.173 +1 +1086.1 +1 +1185.94 +1 +1308.62 +1 +1467.76 +1 +1639.92 +1 +1802.91 +1 +1965.3 +1 +2137.95 +1 +2283.79 +1 +2376.61 +1 +2426.91 +1 +2456.56 +1 +2443.57 +1 +2367.56 +1 +2238.52 +1 +2080.55 +1 +1906.64 +1 +1725.44 +1 +1532.84 +1 +1385.43 +1 +1232.24 +1 +1092.8 +1 +965.783 +1 +868.882 +1 +780.266 +1 +712.202 +1 +666.52 +1 +610.755 +1 +546.122 +1 +511.915 +1 +478.063 +1 +445.418 +1 +415.052 +1 +398.788 +1 +375.918 +1 +353.061 +1 +351.508 +1 +337.282 +1 +315.047 +1 +307.633 +1 +294.696 +1 +290.833 +1 +274.564 +1 +271.901 +1 +263.568 +1 +263.88 +1 +258.412 +1 +252.528 +1 +247.709 +1 +241.296 +1 +236.98 +1 +232.699 +1 +228.446 +1 +224.521 +1 +219.385 +1 +220.881 +1 +225.575 +1 +214.402 +1 +208.07 +1 +209.423 +1 +205.298 +1 +207.289 +1 +204.688 +1 +203.353 +1 +200.463 +1 +200.931 +1 +206.956 +1 +196.591 +1 +188.963 +1 +198.868 +1 +190.863 +1 +195.414 +1 +188.31 +1 +186.237 +1 +185.963 +1 +190.559 +1 +182.928 +1 +190.759 +1 +184.665 +1 +191.58 +1 +185.367 +1 +183.271 +1 +181.623 +1 +179.881 +1 +183.233 +1 +182.661 +1 +181.746 +1 +180.295 +1 +183.083 +1 +180.71 +1 +180.136 +1 +180.221 +1 +173.907 +1 +171.27 +1 +173.947 +1 +170.6 +1 +174.413 +1 +177.864 +1 +177.611 +1 +171.386 +1 +177.611 +1 +171.557 +1 +177.595 +1 +176.204 +1 +171.323 +1 +170.067 +1 +172.802 +1 +166.946 +1 +167.623 +1 +168.388 +1 +168.323 +1 +170.113 +1 +166.214 +1 +165.373 +1 +169.504 +1 +171.274 +1 +166.512 +1 +172.413 +1 +172.688 +1 +168.195 +1 +169.307 +1 +170.815 +1 +168.224 +1 +160.557 +1 +165.708 +1 +163.108 +1 +165.865 +1 +167.945 +1 +165.385 +1 +168.763 +1 +169.603 +1 +167.199 +1 +169.191 +1 +166.904 +1 +171.57 +1 +168.184 +1 +160.666 +1 +164.065 +1 +156.15 +1 +162.791 +1 +159.495 +1 +167.023 +1 +160.811 +1 +160.063 +1 +162.581 +1 +162.119 +1 +160.155 +1 +165.49 +1 +167.325 +1 +169.533 +1 +165.907 +1 +167.267 +1 +163.344 +1 +163.601 +1 +165.563 +1 +163.299 +1 +163.784 +1 +161.559 +1 +163.001 +1 +166.853 +1 +167.428 +1 +160.972 +1 +164.765 +1 +161.828 +1 +168.953 +1 +169.69 +1 +165.403 +1 +169.132 +1 +163.428 +1 +165.366 +1 +165.936 +1 +163.245 +1 +165.887 +1 +163.856 +1 +167.829 +1 +164.867 +1 +170.761 +1 +156.176 +1 +156.081 +1 +162.041 +1 +164.551 +1 +163.527 +1 +162.65 +1 +166.709 +1 +160.265 +1 +161.027 +1 +157.417 +1 +163.654 +1 +162.751 +1 +159.173 +1 +161.934 +1 +163.022 +1 +162.068 +1 +161.397 +1 +161.415 +1 +156.079 +1 +157.895 +1 +164.947 +1 +169.313 +1 +164.571 +1 +159.898 +1 +160.174 +1 +161.943 +1 +162.757 +1 +163.114 +1 +169.003 +1 +163.995 +1 +159.442 +1 +161.42 +1 +157.415 +1 +158.557 +1 +159.41 +1 +158.51 +1 +161.417 +1 +164.592 +1 +157.902 +1 +156.71 +1 +162.298 +1 +161.835 +1 +164.546 +1 +162.678 +1 +161.016 +1 +162.387 +1 +167.066 +1 +163.318 +1 +160.102 +1 +163.068 +1 +165.482 +1 +168.793 +1 +166.55 +1 +160.226 +1 +162.295 +1 +162.381 +1 +163.599 +1 +163.428 +1 +163.034 +1 +166.13 +1 +166.517 +1 +161.492 +1 +160.915 +1 +162.838 +1 +162.864 +1 +162.738 +1 +162.67 +1 +167.808 +1 +164.499 +1 +161.71 +1 +161.83 +1 +162.888 +1 +165.604 +1 +157.373 +1 +157.18 +1 +161.619 +1 +163.853 +1 +160.95 +1 +163.639 +1 +163.802 +1 +160.508 +1 +161.244 +1 +166.322 +1 +160.157 +1 +160.13 +1 +159.359 +1 +156.943 +1 +161.772 +1 +159.76 +1 +Cu LMM +Cu metal +2006 +2018 +2 +6 +17 +18 +0 +7 +Casa Info Follows +0 +0 +0 +0 +Sum of 6 spectra in column containing 6 scans +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +1 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +3.808 +0 +0 +0 +0 +0 +Cu LMM + +-1 +kinetic energy +eV +906.71 +0.1 +2 +counts +d +Transmission +d +pulse counting +0.6 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +500 +103.969 +1084.5 +1 +1 +176.06 +1 +175.639 +1 +170.222 +1 +168.706 +1 +168.807 +1 +172.944 +1 +175.191 +1 +174.21 +1 +176.749 +1 +172.9 +1 +171.503 +1 +174.207 +1 +176.233 +1 +182.821 +1 +178.618 +1 +178.076 +1 +173.831 +1 +178.271 +1 +185.909 +1 +181.948 +1 +180.428 +1 +182.525 +1 +181.407 +1 +181.274 +1 +178.202 +1 +180.005 +1 +185.336 +1 +181.319 +1 +189.834 +1 +186.309 +1 +186.141 +1 +180.186 +1 +183.87 +1 +186.012 +1 +187.505 +1 +192.606 +1 +193.391 +1 +189.528 +1 +188.883 +1 +193.601 +1 +197.649 +1 +188.177 +1 +192.178 +1 +199.985 +1 +201.565 +1 +197.493 +1 +193.764 +1 +188.677 +1 +192.79 +1 +196.339 +1 +193.365 +1 +189.179 +1 +190.408 +1 +198.96 +1 +201.836 +1 +204.691 +1 +203.339 +1 +212.551 +1 +215.617 +1 +223.683 +1 +220.68 +1 +221.755 +1 +226.814 +1 +238.527 +1 +232.526 +1 +232.309 +1 +238.264 +1 +241.798 +1 +250.9 +1 +246.557 +1 +250.616 +1 +255.987 +1 +254.694 +1 +257.287 +1 +255.314 +1 +257.814 +1 +260.746 +1 +254.789 +1 +248.177 +1 +245.019 +1 +244.364 +1 +232.097 +1 +232.817 +1 +237.162 +1 +237.164 +1 +236.68 +1 +239.182 +1 +250.853 +1 +251.991 +1 +259.589 +1 +260.977 +1 +272.974 +1 +275.107 +1 +282.63 +1 +281.748 +1 +277.244 +1 +271.882 +1 +269.232 +1 +264.224 +1 +267.848 +1 +273.184 +1 +268.859 +1 +271.882 +1 +270.448 +1 +267.522 +1 +270.18 +1 +289.231 +1 +297.047 +1 +300.257 +1 +318.838 +1 +341.18 +1 +363.835 +1 +402.123 +1 +450.073 +1 +494.146 +1 +559.451 +1 +602.737 +1 +626.832 +1 +619.532 +1 +578.268 +1 +542.06 +1 +476.653 +1 +420.97 +1 +382.504 +1 +346.261 +1 +325.166 +1 +308.383 +1 +302.829 +1 +285.314 +1 +268.97 +1 +270.119 +1 +247.944 +1 +233.391 +1 +216.423 +1 +200.659 +1 +188.793 +1 +186.708 +1 +189.833 +1 +190.25 +1 +194.725 +1 +208.281 +1 +206.981 +1 +215.163 +1 +224.498 +1 +232.332 +1 +226.012 +1 +220.777 +1 +216.145 +1 +199.434 +1 +185.197 +1 +175.563 +1 +163.047 +1 +148.458 +1 +141.097 +1 +128.792 +1 +124.771 +1 +122.963 +1 +116.351 +1 +109.583 +1 +108.525 +1 +109.441 +1 +107.916 +1 +109.93 +1 +106.113 +1 +101.526 +1 +97.7022 +1 +99.7563 +1 +102.126 +1 +99.5891 +1 +99.9501 +1 +100.722 +1 +102.415 +1 +100.545 +1 +98.5399 +1 +97.9815 +1 +101.434 +1 +98.2199 +1 +96.6161 +1 +96.4176 +1 +94.749 +1 +91.8074 +1 +92.8633 +1 +97.246 +1 +97.0297 +1 +94.3896 +1 +93.9718 +1 +96.8608 +1 +94.8502 +1 +94.895 +1 +92.8011 +1 +91.9848 +1 +92.4718 +1 +92.8982 +1 +94.4083 +1 +91.2908 +1 +90.3564 +1 +88.2809 +1 +93.1085 +1 +91.9537 +1 +91.4175 +1 +90.006 +1 +91.7958 +1 +91.3512 +1 +87.0984 +1 +91.3502 +1 +92.5704 +1 +90.0655 +1 +87.0793 +1 +84.4384 +1 +86.8476 +1 +87.3187 +1 +87.3562 +1 +84.3405 +1 +84.9244 +1 +86.4717 +1 +85.028 +1 +85.194 +1 +84.7898 +1 +88.2223 +1 +85.1722 +1 +83.8297 +1 +86.8617 +1 +83.4916 +1 +82.1316 +1 +85.102 +1 +83.9467 +1 +81.0492 +1 +78.3638 +1 +82.1755 +1 +76.3945 +1 +74.9852 +1 +74.6594 +1 +74.3622 +1 +77.9152 +1 +76.676 +1 +72.2939 +1 +71.8039 +1 +73.4648 +1 +74.9364 +1 +73.272 +1 +71.8762 +1 +73.9608 +1 +73.6555 +1 +74.6263 +1 +75.7706 +1 +75.0258 +1 +71.5153 +1 +70.9967 +1 +70.2968 +1 +71.8444 +1 +O1s +Cu metal +2005 +2018 +2 +16 +13 +31 +0 +7 +Casa Info Follows +0 +0 +0 +0 +Sum of 6 spectra in column containing 6 scans +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +1 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +3.808 +0 +0 +0 +0 +0 +O +1s +-1 +kinetic energy +eV +946.61 +0.1 +2 +counts +d +Transmission +d +pulse counting +0.6 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +402 +22.7619 +64.3284 +1 +1 +30.4085 +1 +34.256 +1 +31.111 +1 +30.7652 +1 +31.7428 +1 +30.8185 +1 +31.0328 +1 +30.8644 +1 +29.8682 +1 +28.8569 +1 +30.4167 +1 +30.8707 +1 +31.7831 +1 +31 +1 +31.9923 +1 +33.1069 +1 +28.4222 +1 +29.7025 +1 +32.7683 +1 +30.3335 +1 +30.1209 +1 +29.4538 +1 +29.4902 +1 +28.2974 +1 +27.9446 +1 +30.0371 +1 +29.771 +1 +29.8672 +1 +30.4445 +1 +28.3941 +1 +27.3167 +1 +31.4216 +1 +29.3095 +1 +27.8245 +1 +29.7858 +1 +30.6972 +1 +27.8866 +1 +28.3476 +1 +27.3081 +1 +27.1963 +1 +29.366 +1 +25.4776 +1 +26.9027 +1 +27.7223 +1 +28.2988 +1 +26.5544 +1 +28.3218 +1 +27.8883 +1 +25.7646 +1 +27.6052 +1 +28.4488 +1 +27.9955 +1 +28.9149 +1 +27.8566 +1 +26.2418 +1 +28.5436 +1 +29.7864 +1 +29.3669 +1 +27.826 +1 +26.6391 +1 +29.6952 +1 +28.1548 +1 +28.2716 +1 +28.4629 +1 +29.1371 +1 +27.9194 +1 +26.8585 +1 +30.9974 +1 +27.188 +1 +26.531 +1 +27.7426 +1 +27.8562 +1 +27.2172 +1 +27.3877 +1 +25.6592 +1 +28.8317 +1 +29.5353 +1 +28.32 +1 +26.8146 +1 +28.448 +1 +29.6098 +1 +28.0549 +1 +27.5145 +1 +27.819 +1 +29.4938 +1 +31.5172 +1 +29.5997 +1 +33.1189 +1 +32.9828 +1 +30.6839 +1 +30.5667 +1 +29.0874 +1 +31.3196 +1 +30.1012 +1 +28.7132 +1 +29.6999 +1 +29.1209 +1 +30.0147 +1 +29.6289 +1 +28.3562 +1 +27.2426 +1 +28.1219 +1 +26.6051 +1 +27.6199 +1 +24.7355 +1 +26.8961 +1 +26.7674 +1 +26.7667 +1 +27.4167 +1 +26.22 +1 +26.3333 +1 +25.8506 +1 +26.6584 +1 +27.4598 +1 +26.0659 +1 +26.2024 +1 +23.7685 +1 +25.2478 +1 +27.4532 +1 +27.1358 +1 +26.1978 +1 +25.8488 +1 +26.0885 +1 +26.1078 +1 +24.0845 +1 +27.737 +1 +25.7481 +1 +26.0917 +1 +25.0615 +1 +27.4454 +1 +25.943 +1 +24.9491 +1 +24.3966 +1 +24.0505 +1 +25.9204 +1 +24.3627 +1 +26.6995 +1 +27.6017 +1 +27.3166 +1 +28.083 +1 +27.0648 +1 +24.9911 +1 +24.6864 +1 +25.0021 +1 +24.6769 +1 +25.1934 +1 +25.2551 +1 +25.2869 +1 +24.6925 +1 +25.6167 +1 +27.6013 +1 +25.6275 +1 +26.0619 +1 +26.2505 +1 +25.2314 +1 +25.0253 +1 +25.2869 +1 +25.264 +1 +24.6958 +1 +26.0054 +1 +24.269 +1 +27.0472 +1 +25.6447 +1 +25.4471 +1 +26.6556 +1 +26.7541 +1 +27.1567 +1 +27.1558 +1 +27.4608 +1 +26.1059 +1 +23.8365 +1 +25.6202 +1 +27.1514 +1 +24.7688 +1 +24.8992 +1 +25.8544 +1 +24.0701 +1 +24.716 +1 +24.3626 +1 +24.6182 +1 +24.3231 +1 +24.1318 +1 +25.2456 +1 +26.7998 +1 +25.7357 +1 +24.951 +1 +23.6557 +1 +25.266 +1 +25.1177 +1 +24.226 +1 +22.8785 +1 +23.7972 +1 +24.8669 +1 +25.1961 +1 +23.4786 +1 +24.5251 +1 +24.5554 +1 +23.1421 +1 +23.6194 +1 +22.8574 +1 +24.74 +1 +Survey +Cu metal +2005 +2018 +2 +14 +31 +39 +0 +7 +Casa Info Follows +0 +0 +0 +0 +corrected by calibrated transmission function +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +1e+037 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +150 +1 +3.808 +0 +0 +0 +0 +0 +Survey + +-1 +kinetic energy +eV +266.61 +0.5 +2 +counts +d +Transmission +d +pulse counting +0.1 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +4802 +121.512 +9112.34 +1 +1 +26701.4 +1 +26964.7 +1 +26076.7 +1 +26105.1 +1 +27537 +1 +26060.4 +1 +26399.2 +1 +26879.4 +1 +26859 +1 +26586.3 +1 +26462.2 +1 +27294.1 +1 +26506.7 +1 +28111 +1 +27399.2 +1 +27780.4 +1 +26112.8 +1 +26939.9 +1 +26826.4 +1 +26578.2 +1 +26652.5 +1 +27478.5 +1 +27202.4 +1 +27321.4 +1 +27547 +1 +27389.7 +1 +26819.1 +1 +27000.8 +1 +27055.1 +1 +27513.1 +1 +26690.6 +1 +27549.4 +1 +27641.2 +1 +26933.2 +1 +26971.3 +1 +27119.1 +1 +27415.1 +1 +27803.1 +1 +27522.1 +1 +27857.6 +1 +27412.7 +1 +27032.1 +1 +28049.7 +1 +28414.2 +1 +27876.7 +1 +27207.3 +1 +27880.9 +1 +27889.7 +1 +27524.1 +1 +28579.4 +1 +28060 +1 +27511.5 +1 +28418.3 +1 +28383.7 +1 +28603.5 +1 +27760.4 +1 +27867.3 +1 +28356.4 +1 +27458.7 +1 +27593.8 +1 +27136.7 +1 +27955.4 +1 +28687.1 +1 +28078.2 +1 +28364.7 +1 +28071.3 +1 +27600.3 +1 +27684.9 +1 +25898.3 +1 +28097 +1 +27803.3 +1 +27734.9 +1 +28644.3 +1 +29457.3 +1 +28614.5 +1 +28358.3 +1 +27781.9 +1 +28389.4 +1 +27607.4 +1 +28603.6 +1 +28618.6 +1 +28717.7 +1 +28957.4 +1 +28998.4 +1 +29490.3 +1 +29108.3 +1 +29067.5 +1 +29050.8 +1 +28403.3 +1 +27967.1 +1 +28260.5 +1 +28725.4 +1 +27993.3 +1 +28081.6 +1 +28572.5 +1 +29163.7 +1 +28809.1 +1 +29533.1 +1 +27663.9 +1 +28777.6 +1 +30083.4 +1 +29319.2 +1 +28654.4 +1 +29881.3 +1 +29231.1 +1 +28695.2 +1 +27822.3 +1 +28067.2 +1 +28698.5 +1 +29490.3 +1 +29749.3 +1 +28869.4 +1 +28333.5 +1 +29073.8 +1 +28805.5 +1 +28135.6 +1 +29529.1 +1 +29155.4 +1 +29019.2 +1 +29894.7 +1 +28271.1 +1 +28795.1 +1 +29838.2 +1 +29130.3 +1 +28941.1 +1 +29451.1 +1 +29842 +1 +29778.2 +1 +29020.6 +1 +29202.4 +1 +29227.8 +1 +29776.2 +1 +29357.9 +1 +29585.3 +1 +28917.2 +1 +29202.4 +1 +29351.7 +1 +29298.9 +1 +28937.2 +1 +28742.5 +1 +27796 +1 +29396.6 +1 +29077.7 +1 +29156 +1 +29953.2 +1 +28779.2 +1 +29285.1 +1 +30034.2 +1 +30187.5 +1 +29964.2 +1 +29773.2 +1 +30221.8 +1 +30820.6 +1 +30380.4 +1 +29579.3 +1 +30277.8 +1 +29919.2 +1 +30227.9 +1 +30142.9 +1 +30042.1 +1 +29527 +1 +29278.6 +1 +31236.8 +1 +30555.7 +1 +30000.3 +1 +29565.2 +1 +30340.4 +1 +31363.2 +1 +31607.4 +1 +30388 +1 +30816.8 +1 +29672.2 +1 +30494.2 +1 +30450.3 +1 +30654.9 +1 +30916.3 +1 +30216.8 +1 +30997.1 +1 +30776.3 +1 +30886.8 +1 +30343.9 +1 +30568.9 +1 +30674.7 +1 +31128.6 +1 +31246.7 +1 +30943.3 +1 +30934.4 +1 +30948.3 +1 +30972.5 +1 +31761.8 +1 +31642.6 +1 +31405.6 +1 +30835.8 +1 +31113.3 +1 +31690.4 +1 +30592.6 +1 +30667.9 +1 +31129.8 +1 +31846.2 +1 +31783.2 +1 +31978.6 +1 +32666.5 +1 +31210.7 +1 +31251.5 +1 +32188.1 +1 +32154.8 +1 +31144 +1 +32094.5 +1 +31940.9 +1 +31679.7 +1 +31486.5 +1 +30863.2 +1 +31648.9 +1 +32418.2 +1 +33115.5 +1 +32430.7 +1 +31806.5 +1 +32154.9 +1 +32245.9 +1 +32012.3 +1 +31929 +1 +32849 +1 +32503.6 +1 +32832.9 +1 +32237 +1 +32015.4 +1 +31883.1 +1 +31648.8 +1 +32815.9 +1 +32364.3 +1 +31054.1 +1 +30554.4 +1 +32443.3 +1 +33331 +1 +32808.5 +1 +32858.5 +1 +33061 +1 +34024.8 +1 +34171 +1 +34512.4 +1 +34479.4 +1 +35512.3 +1 +35634.2 +1 +35456 +1 +36381.7 +1 +37079.3 +1 +38121.8 +1 +38115.4 +1 +37899.6 +1 +36905.4 +1 +35824.9 +1 +35236.5 +1 +34893.4 +1 +33502.2 +1 +33596.5 +1 +32726.5 +1 +31851 +1 +31625.1 +1 +31239.7 +1 +31055.6 +1 +30626.2 +1 +29640.1 +1 +30491.5 +1 +30459.7 +1 +30083.4 +1 +29197 +1 +29655.1 +1 +29315.7 +1 +29698.5 +1 +29465.8 +1 +29932.2 +1 +29851.1 +1 +29450.2 +1 +29111.1 +1 +29153.4 +1 +29950.7 +1 +29594.5 +1 +29711.7 +1 +29712.8 +1 +29588.5 +1 +29376 +1 +29110.4 +1 +29767.2 +1 +28998.1 +1 +29658.5 +1 +29824.4 +1 +29876.7 +1 +29228.4 +1 +29183 +1 +28002.6 +1 +28389.6 +1 +29087.6 +1 +29164.4 +1 +29595.4 +1 +29766.1 +1 +29439 +1 +29945.7 +1 +30367.1 +1 +29678.6 +1 +29323.9 +1 +29201.8 +1 +29317.1 +1 +29026.3 +1 +29620.7 +1 +31076.8 +1 +29721.8 +1 +29620.8 +1 +29788.8 +1 +28965.9 +1 +28813 +1 +29690.3 +1 +30190.3 +1 +29396.6 +1 +29466 +1 +28582.8 +1 +30127.8 +1 +29829.6 +1 +29479.7 +1 +29377.2 +1 +29302.9 +1 +30248.9 +1 +29495.2 +1 +30004.9 +1 +30458.5 +1 +29814.4 +1 +30664.1 +1 +31332.1 +1 +31167.1 +1 +30762.1 +1 +30536.3 +1 +30068.7 +1 +30797.7 +1 +30261.7 +1 +30747 +1 +29863.5 +1 +29264.5 +1 +30879.8 +1 +30962.7 +1 +31128.7 +1 +30080.4 +1 +29761.4 +1 +31001.3 +1 +30999.7 +1 +30632.9 +1 +30592.7 +1 +29487.3 +1 +30088.4 +1 +31157.4 +1 +32243.1 +1 +31308.5 +1 +30974.3 +1 +30083.5 +1 +30805.6 +1 +31188.5 +1 +31778.9 +1 +31417.3 +1 +31635.7 +1 +31314.8 +1 +30657.5 +1 +30658.8 +1 +31578.7 +1 +31825.2 +1 +31082.8 +1 +31728.8 +1 +30627.2 +1 +30625.2 +1 +30445.9 +1 +31273 +1 +30819.7 +1 +31462.6 +1 +30943.6 +1 +31301.2 +1 +32063.3 +1 +31664.2 +1 +30812.3 +1 +30948 +1 +30956.5 +1 +31400.1 +1 +32005.6 +1 +31331.9 +1 +32036.3 +1 +31796.3 +1 +32194.6 +1 +31989.9 +1 +31347 +1 +31328.8 +1 +31833.8 +1 +31746.4 +1 +31720 +1 +31995.8 +1 +32523.7 +1 +32577.5 +1 +32726.4 +1 +32934.4 +1 +32591.4 +1 +32417.1 +1 +31930.1 +1 +31943.2 +1 +33374.3 +1 +31617.7 +1 +31994.8 +1 +32257.8 +1 +32151.7 +1 +33838.2 +1 +32595.4 +1 +32551.9 +1 +32466.8 +1 +32477.7 +1 +33215.8 +1 +32969 +1 +32705.9 +1 +33546.8 +1 +32590.6 +1 +32803.3 +1 +32014.9 +1 +32673.4 +1 +32834.5 +1 +33463.6 +1 +32769.4 +1 +33510.9 +1 +33245.3 +1 +33410.5 +1 +33549.5 +1 +34707.8 +1 +33618.1 +1 +33252.4 +1 +33996.8 +1 +33678 +1 +33508.9 +1 +34139.8 +1 +34450.7 +1 +34352.1 +1 +34183.1 +1 +34687.9 +1 +34013.4 +1 +34054 +1 +34316.9 +1 +35499.2 +1 +35440.9 +1 +34773.1 +1 +33997.1 +1 +34424.2 +1 +34053.7 +1 +34397.9 +1 +35174.4 +1 +35801.8 +1 +34842.2 +1 +35168.6 +1 +35834.8 +1 +35582.7 +1 +35311.9 +1 +35516.9 +1 +35924.8 +1 +35493.7 +1 +35838.6 +1 +36501 +1 +36087 +1 +36402.4 +1 +36254 +1 +36424 +1 +35582.3 +1 +36120.5 +1 +36407.4 +1 +35533.9 +1 +35987.8 +1 +36814.4 +1 +35967.3 +1 +36781.2 +1 +37388.8 +1 +37725.4 +1 +37070.7 +1 +37546.7 +1 +37088.2 +1 +37021.5 +1 +37637 +1 +38070.2 +1 +38469.4 +1 +37653.3 +1 +37589.9 +1 +37746.9 +1 +38700.1 +1 +38078 +1 +38245.5 +1 +38980.6 +1 +38590.2 +1 +38905.5 +1 +39746.5 +1 +39314.9 +1 +38456.7 +1 +38651.1 +1 +39161.9 +1 +39506.4 +1 +39713.5 +1 +39757.4 +1 +40698.4 +1 +40735 +1 +39888.5 +1 +39843.8 +1 +40636.1 +1 +40750.4 +1 +40490.7 +1 +40061.5 +1 +40577.8 +1 +40728.5 +1 +40230 +1 +40091.9 +1 +40990.7 +1 +41909.7 +1 +41790.7 +1 +41187.4 +1 +41172.6 +1 +41227.6 +1 +40862.4 +1 +39730.4 +1 +39089.7 +1 +39896.1 +1 +40913.8 +1 +40060.7 +1 +40930.2 +1 +41291.1 +1 +40088 +1 +40267.2 +1 +39322.3 +1 +40453.2 +1 +40749.7 +1 +41892.3 +1 +41685.7 +1 +41426.5 +1 +43336.5 +1 +46210 +1 +50200.2 +1 +56143.3 +1 +64167.8 +1 +70359.6 +1 +75799.7 +1 +74608.1 +1 +72671.1 +1 +66391.6 +1 +60223.3 +1 +52282.3 +1 +46067.5 +1 +42784.4 +1 +40752.4 +1 +38167.5 +1 +38149.9 +1 +37111.3 +1 +36785.6 +1 +35810.2 +1 +36172.4 +1 +35928.9 +1 +36007.8 +1 +35094.3 +1 +34621.8 +1 +33779.1 +1 +33634 +1 +33693.5 +1 +32586.8 +1 +32001.6 +1 +31352.8 +1 +31375.2 +1 +30517.3 +1 +29943.8 +1 +30672.1 +1 +31669.7 +1 +31357.8 +1 +31874.8 +1 +32953.5 +1 +32378.4 +1 +33999.3 +1 +39999.8 +1 +49425.3 +1 +62195.6 +1 +83295.2 +1 +102071 +1 +109786 +1 +105579 +1 +93860.8 +1 +78603.2 +1 +61905.6 +1 +44875.4 +1 +32184.3 +1 +25472.2 +1 +22931.6 +1 +22026.5 +1 +20818.2 +1 +20335.4 +1 +19666.6 +1 +19667 +1 +19671.3 +1 +18684.8 +1 +18886.6 +1 +18855.6 +1 +18943.1 +1 +19357 +1 +18889.9 +1 +19029.2 +1 +18502.2 +1 +18397.8 +1 +18262 +1 +18907.3 +1 +17902.2 +1 +18385.8 +1 +18600.3 +1 +18445.3 +1 +18690.2 +1 +18819.6 +1 +18034.7 +1 +17753.6 +1 +18434.6 +1 +18285.9 +1 +18084.6 +1 +17886.5 +1 +17554.9 +1 +17774.7 +1 +18305.8 +1 +17936.2 +1 +17720.5 +1 +18276 +1 +17588.2 +1 +17814 +1 +17840.4 +1 +17819.5 +1 +17779.9 +1 +17726.2 +1 +18267.7 +1 +17910.3 +1 +18051 +1 +18407.7 +1 +18305.9 +1 +18651.5 +1 +18731.5 +1 +18010.8 +1 +18692.5 +1 +18487.7 +1 +18134.3 +1 +18417.8 +1 +18335.7 +1 +17875.3 +1 +18050.3 +1 +19049.1 +1 +19021.7 +1 +18594.5 +1 +18054.3 +1 +18397.5 +1 +18253.1 +1 +19086.5 +1 +18513.7 +1 +18473.5 +1 +17768.3 +1 +18449.9 +1 +19013.7 +1 +19302.8 +1 +19576.5 +1 +18438.7 +1 +19072.6 +1 +18947.7 +1 +18719.1 +1 +19574.6 +1 +19384.6 +1 +18815.9 +1 +18245.7 +1 +18878 +1 +18679 +1 +19074.5 +1 +18819.4 +1 +18314.5 +1 +19099.7 +1 +18578.5 +1 +18538.9 +1 +18317.2 +1 +19100 +1 +19237.9 +1 +19227.8 +1 +18907 +1 +18836.5 +1 +18435.5 +1 +18118.1 +1 +18567.1 +1 +19439.2 +1 +18881.5 +1 +18715.6 +1 +18426.8 +1 +18907.5 +1 +18871.2 +1 +18541.6 +1 +18748.2 +1 +19039.4 +1 +18997.4 +1 +19701 +1 +19648 +1 +18881.5 +1 +19747.6 +1 +19376.1 +1 +19274 +1 +19016.4 +1 +18436.5 +1 +18621.9 +1 +18988.6 +1 +18975.5 +1 +19729.5 +1 +19369 +1 +19004.8 +1 +19496 +1 +19199.5 +1 +18935.2 +1 +19304.9 +1 +18957.7 +1 +19343.1 +1 +19983.9 +1 +19985.3 +1 +19735.6 +1 +19864.7 +1 +19324.7 +1 +19730.4 +1 +19793.5 +1 +20502.9 +1 +19519.4 +1 +19594 +1 +19535.3 +1 +19661.8 +1 +20050.9 +1 +19398.3 +1 +19584.7 +1 +20054.2 +1 +19490.4 +1 +19630.4 +1 +20262.4 +1 +19396.1 +1 +19351.4 +1 +18826 +1 +19089.4 +1 +19808.6 +1 +19439.7 +1 +19815.7 +1 +19995.2 +1 +19706.2 +1 +20085.7 +1 +20043.1 +1 +19954.2 +1 +20964.9 +1 +19807.1 +1 +19524.6 +1 +20493 +1 +19941.8 +1 +20169.6 +1 +19859.2 +1 +20419.6 +1 +20544.6 +1 +20405.9 +1 +20710.3 +1 +19793.1 +1 +20469.6 +1 +20634.2 +1 +20512.4 +1 +20474.2 +1 +20594.1 +1 +20490.4 +1 +20165.2 +1 +20869.8 +1 +20178.7 +1 +20347.8 +1 +20521.3 +1 +21520.4 +1 +20834.1 +1 +20767.9 +1 +21016.8 +1 +20865.6 +1 +20023.1 +1 +20271.9 +1 +20152.4 +1 +20393.4 +1 +20867.3 +1 +20826.1 +1 +21164.9 +1 +20986.6 +1 +21124.7 +1 +21406.2 +1 +21212.5 +1 +20899.8 +1 +20473.3 +1 +20808.9 +1 +20623.4 +1 +21288.4 +1 +21775.7 +1 +20783.5 +1 +20896.8 +1 +21019.5 +1 +20931.9 +1 +21397.8 +1 +21671.9 +1 +22231.7 +1 +21625.4 +1 +21741.2 +1 +21660 +1 +21241.7 +1 +21429.8 +1 +21407.3 +1 +21897.4 +1 +21479.1 +1 +20786.6 +1 +20851 +1 +21065.1 +1 +21265.3 +1 +21613.9 +1 +21567.4 +1 +22617 +1 +21911.9 +1 +21107.4 +1 +21545.6 +1 +21082.8 +1 +21659.1 +1 +22424.3 +1 +21996.3 +1 +21798.2 +1 +22341.7 +1 +21744.7 +1 +22100.4 +1 +22596.7 +1 +22942.4 +1 +22097.9 +1 +22044.4 +1 +22662.8 +1 +21773.5 +1 +21779.4 +1 +22909.5 +1 +23069.9 +1 +22437.2 +1 +22640.1 +1 +22085.2 +1 +22493.2 +1 +22604.3 +1 +22401 +1 +22300.5 +1 +22150.6 +1 +22279.3 +1 +22042 +1 +22192.9 +1 +22190 +1 +22714.8 +1 +23699.9 +1 +23051.9 +1 +23231.4 +1 +22412.3 +1 +22745 +1 +22626.1 +1 +22323.1 +1 +22452.2 +1 +22615.6 +1 +21795.7 +1 +22971.5 +1 +23188.8 +1 +22612 +1 +22748.1 +1 +22768 +1 +23140.8 +1 +23165.8 +1 +23354.2 +1 +22854 +1 +23779.7 +1 +23731.6 +1 +24075.4 +1 +23712.6 +1 +23586.5 +1 +23996.9 +1 +23610.5 +1 +23899.8 +1 +24328.9 +1 +23820.4 +1 +23509.5 +1 +23408.1 +1 +24442.3 +1 +24651.4 +1 +24170.7 +1 +24105.6 +1 +24141.5 +1 +24346 +1 +25464.1 +1 +24361.5 +1 +24597.4 +1 +24361 +1 +25026.9 +1 +25093.2 +1 +24902.7 +1 +24780.2 +1 +24194.8 +1 +24824 +1 +25334.7 +1 +25281.1 +1 +25650.6 +1 +25656.5 +1 +25148.9 +1 +24371.6 +1 +24935.4 +1 +25642.3 +1 +25416.7 +1 +25312 +1 +25177.1 +1 +25865.5 +1 +26184.5 +1 +26176 +1 +26458.9 +1 +26360.5 +1 +26690.3 +1 +25470.8 +1 +25790 +1 +25992.3 +1 +26438 +1 +26477.4 +1 +25717.8 +1 +25850.2 +1 +26292.7 +1 +26162 +1 +25499.5 +1 +26181.9 +1 +25904 +1 +25388.9 +1 +26140.8 +1 +25603.1 +1 +25908.1 +1 +26457 +1 +26543.7 +1 +26687.7 +1 +26369.1 +1 +26838.5 +1 +26673.5 +1 +27806.8 +1 +27230.7 +1 +26587.6 +1 +26604.8 +1 +26304.3 +1 +27108.9 +1 +26303.3 +1 +26832.5 +1 +26607.5 +1 +26747.2 +1 +26050.7 +1 +25740.2 +1 +25999 +1 +25375.7 +1 +24779.6 +1 +25824.4 +1 +25890.7 +1 +26272.4 +1 +26371.8 +1 +26837.5 +1 +26864.4 +1 +26172.1 +1 +26183.5 +1 +26140.5 +1 +27364 +1 +26832 +1 +27234.5 +1 +27240.7 +1 +26747.2 +1 +26911.3 +1 +26840.4 +1 +26117.3 +1 +26285.3 +1 +26871.3 +1 +27394.3 +1 +28042.5 +1 +26791.9 +1 +26673.5 +1 +27225.5 +1 +27883 +1 +27235.7 +1 +27366.4 +1 +27529 +1 +27978.3 +1 +28321.9 +1 +28217 +1 +28695.2 +1 +28252.8 +1 +28545.3 +1 +28622 +1 +28750.8 +1 +28628 +1 +28134.7 +1 +28180.5 +1 +29194.2 +1 +30060.9 +1 +30027.2 +1 +29652.5 +1 +30442.5 +1 +30378.5 +1 +30098.5 +1 +30695.3 +1 +30246.5 +1 +30190.5 +1 +30193.1 +1 +29456.6 +1 +30060.1 +1 +29779.3 +1 +30318.9 +1 +31180 +1 +31729.8 +1 +32384.1 +1 +31748 +1 +32047.1 +1 +31834 +1 +31995.6 +1 +32258.1 +1 +32506.8 +1 +33111 +1 +32301.3 +1 +31747.3 +1 +31715.7 +1 +31276.9 +1 +30775.9 +1 +31093.3 +1 +31254.3 +1 +31609.4 +1 +31437.8 +1 +30625.2 +1 +30586.3 +1 +31249.5 +1 +31194.1 +1 +30527.9 +1 +30016.6 +1 +29515.3 +1 +28257.9 +1 +27319.1 +1 +26763 +1 +26035.3 +1 +25493 +1 +24908.9 +1 +25035.3 +1 +24308 +1 +24193.8 +1 +24081.4 +1 +23840.7 +1 +24145.9 +1 +24198.4 +1 +23888.1 +1 +23606.6 +1 +23789.6 +1 +23928.1 +1 +24475.8 +1 +23773.8 +1 +23803.3 +1 +23650 +1 +23707.1 +1 +23182.1 +1 +23185.2 +1 +22938.4 +1 +22547.3 +1 +22925.1 +1 +23147.3 +1 +23869.7 +1 +22826.6 +1 +22656.2 +1 +22919.1 +1 +23189 +1 +23159.5 +1 +22741.5 +1 +23117 +1 +23081.6 +1 +23275.2 +1 +23329.5 +1 +23197.6 +1 +23323.8 +1 +23417.8 +1 +22699.6 +1 +22398.5 +1 +22751.2 +1 +21985.9 +1 +22285.7 +1 +21782.4 +1 +21978.5 +1 +21784.9 +1 +21522.1 +1 +21642.6 +1 +21776.6 +1 +21544.1 +1 +21796 +1 +22352.3 +1 +22080.1 +1 +22236.5 +1 +22185.4 +1 +22460.4 +1 +22377.3 +1 +22228.8 +1 +22877.3 +1 +21487.2 +1 +22494.9 +1 +22103.2 +1 +22220.7 +1 +22442.1 +1 +23030 +1 +22790.2 +1 +22609.6 +1 +22740.9 +1 +23044.4 +1 +22446 +1 +22878.9 +1 +23026.3 +1 +23170.7 +1 +22687 +1 +23017.5 +1 +23868.1 +1 +23836.8 +1 +23706 +1 +23928.2 +1 +23324.4 +1 +23431.7 +1 +24064.3 +1 +24197.4 +1 +23832 +1 +23910.5 +1 +24785.5 +1 +24427.9 +1 +23975.9 +1 +24569.4 +1 +24569.3 +1 +24686.7 +1 +24308.7 +1 +24602.6 +1 +25359.3 +1 +25081.1 +1 +25256.3 +1 +26457.5 +1 +25873.8 +1 +26054.7 +1 +26944.7 +1 +27151.9 +1 +26532.2 +1 +27032.4 +1 +27789.8 +1 +27712 +1 +28101.3 +1 +28250 +1 +27842.6 +1 +27961.8 +1 +28046.5 +1 +29217 +1 +28294.9 +1 +28707.5 +1 +28860.9 +1 +29683.6 +1 +30568.4 +1 +30955.8 +1 +32042.2 +1 +32912.2 +1 +34482.2 +1 +35253.4 +1 +34983.8 +1 +34209.5 +1 +32087 +1 +31099.7 +1 +30025.9 +1 +28797.7 +1 +28708.8 +1 +27790.3 +1 +27182 +1 +26877.6 +1 +26725.6 +1 +26820.8 +1 +26875.1 +1 +27281.4 +1 +27025.5 +1 +26968.2 +1 +27346.7 +1 +26652.6 +1 +26449 +1 +25278.8 +1 +24036.9 +1 +22905.1 +1 +22752.9 +1 +22128.9 +1 +21716 +1 +20509.9 +1 +19640.1 +1 +19517.5 +1 +19531.5 +1 +19209.6 +1 +18917.4 +1 +18722 +1 +19169.2 +1 +18866.6 +1 +18360.2 +1 +18224.8 +1 +19258.3 +1 +18507.9 +1 +18738 +1 +18247.7 +1 +18471.8 +1 +18093.8 +1 +17694.1 +1 +17481.1 +1 +17406.4 +1 +16420.5 +1 +16657.4 +1 +16720.9 +1 +16452.1 +1 +15908.8 +1 +15885.6 +1 +15502.6 +1 +15816.8 +1 +16209.3 +1 +15623.5 +1 +15777.5 +1 +15512.4 +1 +15333.2 +1 +15076 +1 +15171.4 +1 +15262.3 +1 +14739.1 +1 +14737.5 +1 +14693.3 +1 +14549.5 +1 +14649.6 +1 +14860.8 +1 +15093.5 +1 +15011.5 +1 +14893 +1 +14706.7 +1 +14914.8 +1 +15257.1 +1 +15502.5 +1 +15349.8 +1 +15131 +1 +15182.5 +1 +14858.4 +1 +15291.5 +1 +15721.4 +1 +15660.5 +1 +16000.5 +1 +15117.4 +1 +14837.2 +1 +15740.4 +1 +15871.9 +1 +15676 +1 +16091.6 +1 +15718.3 +1 +16299.1 +1 +16514.7 +1 +16085.3 +1 +15951.7 +1 +16715.5 +1 +16531.2 +1 +16907.9 +1 +16547.5 +1 +16819.9 +1 +16778.6 +1 +16942.6 +1 +16671.5 +1 +16914.7 +1 +16937.2 +1 +17320.1 +1 +17713.4 +1 +17379.2 +1 +17269.5 +1 +17604 +1 +17862.2 +1 +17355.6 +1 +17442 +1 +18237.6 +1 +17935.3 +1 +18029.1 +1 +18141.2 +1 +18574.9 +1 +18878.9 +1 +18257.8 +1 +18523.6 +1 +18607.7 +1 +18912.9 +1 +18952.1 +1 +18848 +1 +17917.4 +1 +18379.4 +1 +19045.5 +1 +19256.5 +1 +18928.2 +1 +19107.8 +1 +19479.3 +1 +19488.2 +1 +19401.6 +1 +19009.3 +1 +20417.5 +1 +20553.5 +1 +20762 +1 +20924.3 +1 +21293.6 +1 +21358.2 +1 +21836.1 +1 +22404.3 +1 +22609.7 +1 +23026.5 +1 +24291.4 +1 +24594.3 +1 +24597.3 +1 +25618.5 +1 +26845.9 +1 +28273.2 +1 +29319.8 +1 +29688.2 +1 +29950.2 +1 +30981.8 +1 +32282.2 +1 +33961.1 +1 +36334.8 +1 +39896 +1 +43554.6 +1 +46087 +1 +43909.1 +1 +39940 +1 +37182.4 +1 +33521.3 +1 +28455.3 +1 +24154.1 +1 +21120.1 +1 +19022.8 +1 +16540.6 +1 +14861.3 +1 +13866.3 +1 +13137.9 +1 +12279.9 +1 +11976.7 +1 +11781.8 +1 +11614.3 +1 +11270.1 +1 +10487.1 +1 +10414.2 +1 +10087.8 +1 +10275.2 +1 +9759.58 +1 +9546.92 +1 +9689.28 +1 +9704.78 +1 +9298.62 +1 +9291.85 +1 +9550.55 +1 +9908.31 +1 +9656.87 +1 +9882.16 +1 +9920.2 +1 +9816.33 +1 +9465.25 +1 +9278.72 +1 +9217.26 +1 +9427.02 +1 +9698.71 +1 +10222.5 +1 +10012.8 +1 +9623.3 +1 +9376.26 +1 +8573.03 +1 +7628.43 +1 +6866.82 +1 +6234.5 +1 +5741.51 +1 +4950.43 +1 +4907.42 +1 +4839.16 +1 +4403.54 +1 +4150.88 +1 +4248.58 +1 +4121.79 +1 +3994.01 +1 +3936.36 +1 +3862.56 +1 +3550.74 +1 +3425.56 +1 +3382.85 +1 +3305.55 +1 +3254.23 +1 +3402.4 +1 +3606.11 +1 +3234.56 +1 +3206.09 +1 +3213.91 +1 +3226.66 +1 +3163.38 +1 +3295.77 +1 +3213.07 +1 +3334.82 +1 +3485.8 +1 +2952.1 +1 +3031.18 +1 +3167.84 +1 +3114.54 +1 +3021.01 +1 +3055.22 +1 +3018.72 +1 +3026.36 +1 +3179.96 +1 +2936.42 +1 +2849.3 +1 +2945.33 +1 +2972.37 +1 +2956.34 +1 +3029.67 +1 +3081.65 +1 +2854.28 +1 +2923.68 +1 +2697.09 +1 +2592.37 +1 +3008.63 +1 +3076.32 +1 +3061.94 +1 +2912.11 +1 +2893.36 +1 +2862.61 +1 +2860.97 +1 +2554.12 +1 +2745.91 +1 +2654.87 +1 +2860.81 +1 +2982.32 +1 +2990.48 +1 +2921.08 +1 +2858.18 +1 +2807.14 +1 +2767.78 +1 +2695.38 +1 +2905.3 +1 +2773.94 +1 +2801.67 +1 +2695.67 +1 +2681.01 +1 +2853.6 +1 +2854.72 +1 +2628.64 +1 +2898.24 +1 +2903.65 +1 +2894.42 +1 +2897.33 +1 +2798.05 +1 +2894.41 +1 +3106.58 +1 +3106.43 +1 +2879.92 +1 +2987.27 +1 +2721.73 +1 +2821.47 +1 +2645.29 +1 +2638.07 +1 +2824.86 +1 +2845.3 +1 +2953.2 +1 +2844.32 +1 +2891.3 +1 +2943.9 +1 +3028.34 +1 +3103.33 +1 +2992.94 +1 +2837.03 +1 +2784.92 +1 +2784.58 +1 +2611.96 +1 +2863.9 +1 +2965.33 +1 +2869.01 +1 +3016.87 +1 +3274.84 +1 +3062.82 +1 +3005.21 +1 +2889.82 +1 +2793.31 +1 +2682.07 +1 +2795.46 +1 +2958.45 +1 +2879.8 +1 +2866.24 +1 +2969.31 +1 +3005.89 +1 +2878.69 +1 +2787.95 +1 +2888.65 +1 +3017.9 +1 +2965.64 +1 +3142.49 +1 +2942.4 +1 +3196.45 +1 +3013.18 +1 +2815.03 +1 +2913.56 +1 +3102.21 +1 +2873.34 +1 +2983.65 +1 +2739.62 +1 +2664.99 +1 +2833.82 +1 +2789.72 +1 +3002.83 +1 +2878.67 +1 +2833.14 +1 +3013.49 +1 +3030.79 +1 +2884.25 +1 +2867.84 +1 +2925.07 +1 +2702.71 +1 +2998.56 +1 +2881.66 +1 +2707.11 +1 +2982.34 +1 +2697.74 +1 +2706.04 +1 +2867.78 +1 +3142.25 +1 +2997.8 +1 +2921.43 +1 +2707.1 +1 +2682.93 +1 +2673.33 +1 +2888.57 +1 +3059.49 +1 +2816.08 +1 +2830.29 +1 +2899.62 +1 +2999.17 +1 +2698.85 +1 +2811.92 +1 +2966.43 +1 +2862.64 +1 +2938.55 +1 +2944.55 +1 +2933.43 +1 +2705.57 +1 +2830.47 +1 +2908.41 +1 +3008.23 +1 +2835.42 +1 +2999.12 +1 +2952.27 +1 +3005.26 +1 +3020.34 +1 +3055.01 +1 +3088.78 +1 +2913.15 +1 +2933.88 +1 +2910.69 +1 +2804.72 +1 +2908.37 +1 +3069.27 +1 +2858.43 +1 +2820.81 +1 +2788.92 +1 +2832.21 +1 +2782.77 +1 +3002.12 +1 +2953.01 +1 +2933.73 +1 +2904.02 +1 +3052.59 +1 +2960.09 +1 +2968.69 +1 +2876.68 +1 +2932.08 +1 +2804.42 +1 +2881.08 +1 +2949.18 +1 +3040.14 +1 +2933.34 +1 +2931.56 +1 +2960.7 +1 +3178.08 +1 +2999.95 +1 +2832.21 +1 +2831.8 +1 +2900.98 +1 +2994.08 +1 +3028.81 +1 +3278.81 +1 +2938.76 +1 +2931.96 +1 +3071.24 +1 +3086.88 +1 +2924.64 +1 +2946.75 +1 +3196.44 +1 +3093.71 +1 +2935.24 +1 +2920.47 +1 +3088.6 +1 +3016.91 +1 +3130.86 +1 +2799.03 +1 +2981.17 +1 +3150.29 +1 +3150.86 +1 +3061.25 +1 +3442.14 +1 +3333.86 +1 +3209.68 +1 +3005.99 +1 +3007.78 +1 +3124.15 +1 +2989.8 +1 +2916.71 +1 +3211.03 +1 +3238.02 +1 +2913.81 +1 +3216.13 +1 +3207.75 +1 +3092.34 +1 +2988.48 +1 +2953.88 +1 +3073.11 +1 +2987.64 +1 +3039.32 +1 +2894.9 +1 +3094.85 +1 +3127.92 +1 +3037.67 +1 +3240.49 +1 +3273.98 +1 +3399.29 +1 +3251.08 +1 +3199.84 +1 +2955.46 +1 +3100.5 +1 +3221.84 +1 +3299.29 +1 +3227.21 +1 +3056.14 +1 +3037.17 +1 +2987.18 +1 +3067.25 +1 +2931.94 +1 +3030.17 +1 +3137.18 +1 +3217.53 +1 +3233.75 +1 +3188.71 +1 +3340.1 +1 +3378.65 +1 +2921.6 +1 +3250.61 +1 +3463.96 +1 +3142.83 +1 +2889.84 +1 +3076.76 +1 +3200.38 +1 +3278.35 +1 +3210.27 +1 +3295.31 +1 +3207.05 +1 +3243.68 +1 +3506.09 +1 +3168.97 +1 +2956.94 +1 +3157.64 +1 +2970.94 +1 +3068.26 +1 +3191.25 +1 +3198.96 +1 +3202.25 +1 +3116.44 +1 +3000.32 +1 +3027.63 +1 +2896.43 +1 +2925.74 +1 +3013.52 +1 +3166.02 +1 +3192.8 +1 +3138.1 +1 +3089.28 +1 +2881.14 +1 +3231.76 +1 +3086.86 +1 +3393.4 +1 +3375.27 +1 +3025.18 +1 +3142.77 +1 +3261.52 +1 +3277.56 +1 +3016.76 +1 +3129.51 +1 +3064.47 +1 +2952.04 +1 +3342.54 +1 +3024.65 +1 +3052.12 +1 +3080.49 +1 +2937.25 +1 +2962.58 +1 +3286.09 +1 +3180.58 +1 +3126.42 +1 +3374.23 +1 +3334.5 +1 +3314.24 +1 +3063.16 +1 +3314.22 +1 +3104.67 +1 +3378.17 +1 +3146.01 +1 +2895.73 +1 +3019.9 +1 +3196.92 +1 +3425.46 +1 +3100.07 +1 +3147.43 +1 +3241.02 +1 +3046.29 +1 +3136.16 +1 +3342.17 +1 +3382.38 +1 +3248.44 +1 +3317.97 +1 +3472.53 +1 +3038.89 +1 +3173.88 +1 +3213.55 +1 +3191.18 +1 +3170.99 +1 +3188.76 +1 +3219.21 +1 +3340.33 +1 +3175.58 +1 +3084.45 +1 +3060.43 +1 +2929.68 +1 +3275.54 +1 +3384.95 +1 +3135.18 +1 +3430.54 +1 +3309.48 +1 +3432.22 +1 +3266.38 +1 +3368.47 +1 +3195.56 +1 +3128.88 +1 +3293.76 +1 +3072.86 +1 +3327.1 +1 +3263.41 +1 +2975.61 +1 +3154.58 +1 +3355.76 +1 +3019.51 +1 +3261.62 +1 +3313.92 +1 +3014.73 +1 +3131.98 +1 +3033.75 +1 +3019.5 +1 +3302.96 +1 +3450.39 +1 +3172.03 +1 +3234.4 +1 +3271.28 +1 +3221.69 +1 +3438.86 +1 +3310.08 +1 +3291.07 +1 +3340.66 +1 +3585.81 +1 +3620.14 +1 +3310.28 +1 +3174.75 +1 +3352.09 +1 +3280.39 +1 +3166.83 +1 +3320.36 +1 +3419.46 +1 +3377.64 +1 +3617.93 +1 +3325.6 +1 +3422.89 +1 +3369.08 +1 +3361.27 +1 +3522.85 +1 +3457.68 +1 +3176.71 +1 +3273.89 +1 +3205.65 +1 +3142.81 +1 +3598.55 +1 +3522.9 +1 +3433.57 +1 +3187.84 +1 +3310.36 +1 +3301.21 +1 +3451.58 +1 +3379.62 +1 +3461.8 +1 +3535.75 +1 +3445.63 +1 +3108.33 +1 +3288.01 +1 +3187.99 +1 +3234.48 +1 +3335.79 +1 +3434.86 +1 +3401.54 +1 +3327.52 +1 +3175.21 +1 +3393.88 +1 +3400.24 +1 +3467.32 +1 +3258.86 +1 +3047.04 +1 +3251.31 +1 +3443.11 +1 +3578.14 +1 +3487.02 +1 +3405.69 +1 +3398.74 +1 +3442.84 +1 +3488.23 +1 +3452.21 +1 +3612.99 +1 +3466.96 +1 +3515.24 +1 +3499.16 +1 +3243.08 +1 +3205.97 +1 +3484.65 +1 +3404.58 +1 +3611.33 +1 +3704.76 +1 +3706.53 +1 +3488.47 +1 +3678.46 +1 +3367.84 +1 +3248.48 +1 +3278.1 +1 +3294.28 +1 +3607.36 +1 +3717.02 +1 +3584.63 +1 +3537.85 +1 +3671.61 +1 +3549.32 +1 +3644.87 +1 +3388.77 +1 +3481.01 +1 +3502.19 +1 +3933.38 +1 +3619.56 +1 +3408.06 +1 +3413.92 +1 +3621.27 +1 +3729.27 +1 +3551.87 +1 +3269.53 +1 +3516.26 +1 +3738.15 +1 +3725.79 +1 +3621.47 +1 +3593.27 +1 +3558.57 +1 +3606.29 +1 +3718.79 +1 +3669.19 +1 +3541.45 +1 +3470.71 +1 +3444.92 +1 +3602.3 +1 +3755.51 +1 +3716.37 +1 +3575.08 +1 +3714.05 +1 +3529.36 +1 +3539.72 +1 +3508.59 +1 +3797.97 +1 +3803.55 +1 +3568.57 +1 +3715.27 +1 +3705.98 +1 +3985.75 +1 +3997.18 +1 +3901.94 +1 +3870.93 +1 +4094.31 +1 +4368.64 +1 +4153.35 +1 +4377.57 +1 +4318.49 +1 +4177.7 +1 +4052.73 +1 +3796.74 +1 +3516.24 +1 +3454.74 +1 +3325.46 +1 +3450.14 +1 +3587.96 +1 +3545.38 +1 +3433.81 +1 +3477.41 +1 +3538.6 +1 +3503.24 +1 +3762.15 +1 +3789.3 +1 +3450.21 +1 +3522.18 +1 +3740.14 +1 +3432.44 +1 +3497.8 +1 +3631.66 +1 +3539.78 +1 +4112.91 +1 +4135.46 +1 +3789.24 +1 +3540.89 +1 +3367.97 +1 +3607.59 +1 +3655.63 +1 +3612.94 +1 +3558.4 +1 +3927.24 +1 +3826.6 +1 +3739.76 +1 +3496.74 +1 +3592.03 +1 +3415.16 +1 +3574.35 +1 +4033.4 +1 +3732.27 +1 +3672.25 +1 +3743.49 +1 +3927.31 +1 +3944.79 +1 +3700.02 +1 +3824.03 +1 +3871.85 +1 +3767.65 +1 +3851.17 +1 +3664.28 +1 +3677.15 +1 +3594.34 +1 +3717.01 +1 +3846.37 +1 +3830.19 +1 +3872.15 +1 +3959.71 +1 +4083.44 +1 +3983.65 +1 +3733.63 +1 +3808.26 +1 +3866.85 +1 +3758.52 +1 +3638.09 +1 +3713.5 +1 +3734.55 +1 +3643.48 +1 +3971.67 +1 +3829.92 +1 +3787.18 +1 +3705.51 +1 +3674.49 +1 +4014.69 +1 +3882.51 +1 +3734.97 +1 +3968.19 +1 +3892.38 +1 +4140.75 +1 +3926.86 +1 +3723.61 +1 +3475.93 +1 +3616.32 +1 +3732.78 +1 +3823.13 +1 +3741.12 +1 +3819.32 +1 +3644.91 +1 +3664.93 +1 +3929.23 +1 +3746.54 +1 +4093.21 +1 +3785.67 +1 +3940.19 +1 +4091.56 +1 +4052.21 +1 +3857.92 +1 +3673.46 +1 +3904.1 +1 +4057.75 +1 +3955.37 +1 +3805.19 +1 +4044.72 +1 +3924.5 +1 +4126.57 +1 +3979.66 +1 +3937.18 +1 +3858.53 +1 +4032.03 +1 +3958.88 +1 +4268.26 +1 +4305.79 +1 +3956.22 +1 +4009.37 +1 +4071.78 +1 +4125.46 +1 +4096.93 +1 +4020.16 +1 +4062.98 +1 +3958.5 +1 +4070.13 +1 +3904.05 +1 +4112.59 +1 +3958.13 +1 +3775.71 +1 +3874.34 +1 +4095.31 +1 +4060 +1 +4160.37 +1 +4024.48 +1 +3898.27 +1 +3795.9 +1 +3842.74 +1 +4123.92 +1 +4231.79 +1 +4084.36 +1 +3749.94 +1 +3785.91 +1 +3924.54 +1 +4084.35 +1 +4116.08 +1 +3957.02 +1 +4051.77 +1 +4363.89 +1 +4154.89 +1 +3598.77 +1 +3459.27 +1 +4030.94 +1 +4259.5 +1 +4117.13 +1 +3963.03 +1 +4148.32 +1 +4150.07 +1 +4007.22 +1 +4002.77 +1 +4030.56 +1 +4200.6 +1 +4441.53 +1 +4084.04 +1 +4254.22 +1 +4200.67 +1 +4218.2 +1 +4423.6 +1 +4265.19 +1 +4171.37 +1 +4286.63 +1 +4386.7 +1 +4287.97 +1 +4099.12 +1 +3932.21 +1 +4338.5 +1 +4031.5 +1 +4240.49 +1 +4016.81 +1 +4368.05 +1 +4332.69 +1 +4352.92 +1 +4295.24 +1 +4338.49 +1 +4038.51 +1 +4090.94 +1 +4191.14 +1 +4182.21 +1 +4213.48 +1 +4072.23 +1 +4138 +1 +4301.13 +1 +4382.88 +1 +4312.7 +1 +4239.02 +1 +4183.18 +1 +4046.64 +1 +4390.39 +1 +4497.31 +1 +4255.5 +1 +4190.76 +1 +4390.27 +1 +4461.14 +1 +4641.18 +1 +4601.89 +1 +4593.61 +1 +4553.22 +1 +4527.22 +1 +4451.57 +1 +4283.29 +1 +4224.94 +1 +4461.56 +1 +4557.66 +1 +4475.58 +1 +4664.85 +1 +4873.76 +1 +4666.1 +1 +4719.24 +1 +4571.25 +1 +4650.31 +1 +4652.21 +1 +4582.88 +1 +4663.29 +1 +4538.05 +1 +4836.34 +1 +4770.93 +1 +4687.9 +1 +4752.38 +1 +4585.94 +1 +4569.54 +1 +4680.75 +1 +4905.97 +1 +4692.26 +1 +4584.96 +1 +4823.24 +1 +4691.53 +1 +4721.82 +1 +4746.04 +1 +4741.23 +1 +4897.06 +1 +4615.13 +1 +4827.2 +1 +4797.02 +1 +4779.42 +1 +4545.31 +1 +5208.79 +1 +5262.42 +1 +4996.31 +1 +5019.27 +1 +4944.37 +1 +4903.74 +1 +4982.22 +1 +4634.91 +1 +5122.95 +1 +5151.65 +1 +4953.7 +1 +5065.06 +1 +5055.65 +1 +5175.55 +1 +5064.67 +1 +5210.01 +1 +5045.55 +1 +4947.45 +1 +5179.46 +1 +5223.82 +1 +4965.35 +1 +4952.68 +1 +5095.62 +1 +5144.06 +1 +5410.61 +1 +5271.13 +1 +5434.1 +1 +5654.21 +1 +5313.24 +1 +5460.96 +1 +5370.32 +1 +5427.44 +1 +5397.67 +1 +5445.98 +1 +5622.04 +1 +5504.08 +1 +5550.08 +1 +5576.73 +1 +5497.27 +1 +5488.42 +1 +5404.75 +1 +5756.5 +1 +5831.59 +1 +5732.89 +1 +5656.27 +1 +5653.97 +1 +5351.32 +1 +5438.66 +1 +5814.08 +1 +5807.66 +1 +5715.18 +1 +5599.96 +1 +5546.85 +1 +5883.05 +1 +5952.62 +1 +5462.49 +1 +5946.4 +1 +6065.37 +1 +5804.78 +1 +5870.09 +1 +5870.23 +1 +6043.52 +1 +5841.3 +1 +6050.05 +1 +6082.52 +1 +6080.6 +1 +5555.78 +1 +5874.11 +1 +5861.77 +1 +5630.44 +1 +5887.69 +1 +6013.27 +1 +6058.41 +1 +5846.77 +1 +6123.22 +1 +6825.75 +1 +6846.58 +1 +7333.96 +1 +7880.18 +1 +8657.3 +1 +9845.29 +1 +11085.8 +1 +11884.7 +1 +11964.8 +1 +11404.2 +1 +10597.2 +1 +9596.72 +1 +8293.62 +1 +7456.51 +1 +6541.56 +1 +5846.79 +1 +5834.61 +1 +5549.16 +1 +5189.66 +1 +5398.56 +1 +5224.39 +1 +5241.47 +1 +5338.37 +1 +5320.43 +1 +5241.34 +1 +5036.16 +1 +5222.96 +1 +5339.58 +1 +5308.81 +1 +4969.53 +1 +4804.46 +1 +4922.44 +1 +5128.63 +1 +4783.59 +1 +5000.91 +1 +4862.12 +1 +5175.42 +1 +5110.65 +1 +5151.17 +1 +5323.49 +1 +5297.66 +1 +5477.17 +1 +5709.49 +1 +5481.03 +1 +5357.93 +1 +5485.05 +1 +5612.37 +1 +5620.59 +1 +5751.06 +1 +5449.45 +1 +5847.32 +1 +6056.81 +1 +5611.45 +1 +5627.91 +1 +5771.4 +1 +5608.52 +1 +5910.78 +1 +5797.18 +1 +6044.87 +1 +5948.07 +1 +5882.55 +1 +6045.38 +1 +5975.13 +1 +6165.81 +1 +6108.94 +1 +6001.36 +1 +5640.99 +1 +5865.6 +1 +5523.31 +1 +5711.47 +1 +5632.93 +1 +5689.85 +1 +5689.92 +1 +5426.86 +1 +5351.4 +1 +5508.5 +1 +5411.09 +1 +5892.17 +1 +5697.83 +1 +5661.39 +1 +5431.89 +1 +5471.07 +1 +5506.62 +1 +5469.75 +1 +5342.41 +1 +5459.11 +1 +5524.79 +1 +5633.76 +1 +5960.75 +1 +5815.63 +1 +6178.05 +1 +6517.93 +1 +7050.14 +1 +7802.18 +1 +9030.98 +1 +10338.5 +1 +11837.6 +1 +13791.1 +1 +15205.4 +1 +16559.4 +1 +17879.4 +1 +18908 +1 +19154.9 +1 +18421.4 +1 +16109.2 +1 +13849.3 +1 +11428.6 +1 +8860.38 +1 +6503.6 +1 +5190.2 +1 +3877.89 +1 +3272.67 +1 +3081.58 +1 +2705.97 +1 +2397.46 +1 +2077.93 +1 +1938.74 +1 +1709.45 +1 +1714.09 +1 +1650.33 +1 +1661.71 +1 +1693.12 +1 +1498.59 +1 +1418.15 +1 +1319.2 +1 +1432.68 +1 +1417.09 +1 +1225.57 +1 +1207.77 +1 +1170.04 +1 +1303.75 +1 +1279.33 +1 +1202.03 +1 +1304.92 +1 +1240.46 +1 +1304.89 +1 +1184.22 +1 +1153.85 +1 +1133.09 +1 +1140.45 +1 +1165.21 +1 +1250.33 +1 +1035.15 +1 +1315.89 +1 +1167.16 +1 +1131.81 +1 +1258.28 +1 +1257.99 +1 +1254.71 +1 +1227.53 +1 +1098.29 +1 +1140.86 +1 +1192.22 +1 +1164.12 +1 +1102.6 +1 +1129.82 +1 +1221.3 +1 +1052.64 +1 +1021.08 +1 +1190.6 +1 +1233.56 +1 +1128.27 +1 +1320.02 +1 +1252.74 +1 +1083.03 +1 +1140.99 +1 +1284.83 +1 +1119.01 +1 +1117.42 +1 +1198.44 +1 +1305.25 +1 +1348.24 +1 +1462.31 +1 +1303.05 +1 +1195.79 +1 +1185.64 +1 +1278.89 +1 +1316.93 +1 +1220.05 +1 +1272.85 +1 +1299.06 +1 +1224.12 +1 +1186.22 +1 +1350.89 +1 +1420.72 +1 +1360.96 +1 +1453.01 +1 +1447.45 +1 +1204.68 +1 +1319.96 +1 +1459.67 +1 +1299.81 +1 +1422.29 +1 +1461.33 +1 +1477.2 +1 +1382.24 +1 +1334.75 +1 +1360.41 +1 +1424.15 +1 +1488.08 +1 +1459.4 +1 +1438.46 +1 +1352.02 +1 +1582.21 +1 +1632.32 +1 +1425.57 +1 +1469.27 +1 +1525.92 +1 +1625.13 +1 +1610.96 +1 +1682.97 +1 +1465.18 +1 +1449.45 +1 +24.5575 +1 +Cu2p +Cu2O +2006 +2018 +2 +6 +17 +18 +0 +7 +Casa Info Follows +0 +0 +0 +0 +Sum of 38 spectra in column containing 38 scans +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +3 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +3.808 +0 +0 +0 +0 +0 +Cu 2p + +-1 +kinetic energy +eV +514.66 +0.05 +2 +counts +d +Transmission +d +pulse counting +1.9 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +2080 +105.265 +1697.36 +1 +1 +495.084 +1 +495.921 +1 +502.237 +1 +498.909 +1 +492.712 +1 +493.809 +1 +493.005 +1 +490.209 +1 +486.13 +1 +488.322 +1 +490.567 +1 +498.134 +1 +503.75 +1 +502.118 +1 +502.208 +1 +494.206 +1 +495.136 +1 +497.136 +1 +491.821 +1 +499.949 +1 +491.322 +1 +495.091 +1 +496.279 +1 +494.604 +1 +491.337 +1 +493.795 +1 +498.247 +1 +496.921 +1 +492.768 +1 +491.978 +1 +490.515 +1 +498.096 +1 +488.367 +1 +491.496 +1 +494.834 +1 +495.818 +1 +502.378 +1 +497.081 +1 +493.449 +1 +497.608 +1 +496.89 +1 +486.46 +1 +488.837 +1 +493.367 +1 +491.35 +1 +498.595 +1 +495.674 +1 +490.087 +1 +486.643 +1 +487.972 +1 +492.202 +1 +494.695 +1 +497.49 +1 +492.143 +1 +489.328 +1 +488.014 +1 +492.762 +1 +500.811 +1 +500.741 +1 +498.075 +1 +491.641 +1 +491.639 +1 +496.187 +1 +496.659 +1 +498.506 +1 +498.57 +1 +494.479 +1 +496.583 +1 +496.389 +1 +508.032 +1 +495.394 +1 +498.733 +1 +497.149 +1 +496.819 +1 +496.641 +1 +499.526 +1 +495.383 +1 +497.434 +1 +503.606 +1 +501.48 +1 +501.093 +1 +500.654 +1 +506.188 +1 +504.013 +1 +499.772 +1 +506.828 +1 +510 +1 +505.514 +1 +508.912 +1 +503.081 +1 +502.757 +1 +506.727 +1 +505.482 +1 +502.575 +1 +508.06 +1 +510.703 +1 +514.025 +1 +512.267 +1 +502.835 +1 +510.544 +1 +510.788 +1 +515.394 +1 +513.004 +1 +512.335 +1 +513.495 +1 +515.402 +1 +513.826 +1 +508.987 +1 +508.865 +1 +513.295 +1 +520.558 +1 +521.453 +1 +515.061 +1 +519.917 +1 +515.612 +1 +521.611 +1 +522.888 +1 +518.892 +1 +513.065 +1 +527.621 +1 +522.411 +1 +529.483 +1 +539.647 +1 +534.403 +1 +532.824 +1 +525.61 +1 +530.698 +1 +533.736 +1 +531.531 +1 +539.655 +1 +538.054 +1 +542.338 +1 +537.028 +1 +541.211 +1 +544.041 +1 +551.143 +1 +549.938 +1 +544.983 +1 +546.488 +1 +553.127 +1 +549.334 +1 +547.071 +1 +543.86 +1 +548 +1 +543.517 +1 +542.766 +1 +537.73 +1 +541.731 +1 +541.99 +1 +539.354 +1 +534.935 +1 +542.422 +1 +534.864 +1 +526.869 +1 +528.866 +1 +522.758 +1 +518.133 +1 +517.887 +1 +516.58 +1 +521.378 +1 +514.557 +1 +519.838 +1 +508.748 +1 +509.306 +1 +509.058 +1 +507.515 +1 +509.187 +1 +510.476 +1 +506.061 +1 +506.948 +1 +501.031 +1 +497.456 +1 +492.764 +1 +495.506 +1 +491.756 +1 +491.56 +1 +493.603 +1 +494.086 +1 +490.81 +1 +492.376 +1 +487.056 +1 +489.311 +1 +492.867 +1 +494.197 +1 +486.407 +1 +492.311 +1 +484.793 +1 +482.856 +1 +475.234 +1 +483.81 +1 +478.265 +1 +480.031 +1 +479.809 +1 +474.751 +1 +480.801 +1 +479.552 +1 +479.787 +1 +474.181 +1 +472.409 +1 +477.139 +1 +478.971 +1 +477.7 +1 +476.674 +1 +476.222 +1 +470.274 +1 +473.504 +1 +478.034 +1 +478.174 +1 +476.911 +1 +478.077 +1 +468.403 +1 +481.683 +1 +473.503 +1 +477.938 +1 +476.053 +1 +476.28 +1 +478.188 +1 +479.016 +1 +472.371 +1 +482.086 +1 +482.723 +1 +478.852 +1 +476.811 +1 +478.933 +1 +475.375 +1 +480.052 +1 +476.176 +1 +476.053 +1 +479.806 +1 +483.354 +1 +471.569 +1 +476.267 +1 +478.66 +1 +471.661 +1 +470.137 +1 +476.066 +1 +475.701 +1 +465.762 +1 +471.152 +1 +483.757 +1 +480.02 +1 +485.419 +1 +484.462 +1 +489.021 +1 +478.88 +1 +482.361 +1 +474.956 +1 +476.862 +1 +476.322 +1 +485.437 +1 +485.492 +1 +474.776 +1 +478.409 +1 +482.153 +1 +484.746 +1 +479.276 +1 +483.206 +1 +476.763 +1 +474.315 +1 +480.303 +1 +478.645 +1 +478.108 +1 +473.127 +1 +489.747 +1 +486.196 +1 +486.385 +1 +487.932 +1 +484.082 +1 +483.08 +1 +486.016 +1 +488.56 +1 +492.181 +1 +490.704 +1 +480.209 +1 +482.625 +1 +480.541 +1 +484.522 +1 +483.709 +1 +489.043 +1 +493.993 +1 +486.389 +1 +480.892 +1 +484.293 +1 +486.122 +1 +483.562 +1 +483.503 +1 +494.197 +1 +490.274 +1 +479.141 +1 +484.07 +1 +487.415 +1 +487.775 +1 +488.006 +1 +490.605 +1 +490.392 +1 +489.483 +1 +492.289 +1 +494.97 +1 +493.044 +1 +490.727 +1 +491.561 +1 +492.292 +1 +491.749 +1 +491.706 +1 +488.087 +1 +487.376 +1 +487.59 +1 +491.762 +1 +485.105 +1 +486.987 +1 +497.711 +1 +490.856 +1 +489.009 +1 +487.867 +1 +489.362 +1 +489.249 +1 +494.271 +1 +492.955 +1 +494.667 +1 +493.471 +1 +493.197 +1 +496.245 +1 +494.193 +1 +490.184 +1 +493.526 +1 +488.932 +1 +486.628 +1 +489.526 +1 +488.175 +1 +490.69 +1 +491.823 +1 +498.173 +1 +484.216 +1 +492.913 +1 +487.337 +1 +491.459 +1 +491.932 +1 +497.379 +1 +497.134 +1 +487.335 +1 +483.166 +1 +487.364 +1 +493.378 +1 +497.777 +1 +490.605 +1 +493.198 +1 +497.997 +1 +502.976 +1 +506.649 +1 +502.947 +1 +503.263 +1 +501.348 +1 +503.892 +1 +505.271 +1 +506.338 +1 +520.878 +1 +518.536 +1 +520.342 +1 +518.937 +1 +529.63 +1 +527.091 +1 +541.03 +1 +537.806 +1 +548.975 +1 +559.419 +1 +563.223 +1 +577.127 +1 +588.881 +1 +595.056 +1 +600.709 +1 +616.789 +1 +635.061 +1 +648.982 +1 +678.671 +1 +697.936 +1 +704.66 +1 +724.742 +1 +758.11 +1 +794.474 +1 +819.455 +1 +864.455 +1 +899.3 +1 +936.411 +1 +970.1 +1 +1019.17 +1 +1062.5 +1 +1114.96 +1 +1155.69 +1 +1197.59 +1 +1249.9 +1 +1303.92 +1 +1343.69 +1 +1386.49 +1 +1408.46 +1 +1446.45 +1 +1447.99 +1 +1450.6 +1 +1449.89 +1 +1432.51 +1 +1402.28 +1 +1383.5 +1 +1343.35 +1 +1315.8 +1 +1258.34 +1 +1207.83 +1 +1144.48 +1 +1103.42 +1 +1045.77 +1 +1003.78 +1 +958.491 +1 +915.761 +1 +872.322 +1 +832.671 +1 +799.852 +1 +767.589 +1 +733.987 +1 +705.981 +1 +682.68 +1 +665.392 +1 +641.982 +1 +639.663 +1 +617.16 +1 +601.513 +1 +592.983 +1 +569.18 +1 +560.11 +1 +560.218 +1 +546.421 +1 +551.024 +1 +542.892 +1 +529.51 +1 +521.074 +1 +522.286 +1 +513.909 +1 +503.878 +1 +503.558 +1 +503.91 +1 +491.483 +1 +487.525 +1 +491.886 +1 +499.021 +1 +487.512 +1 +478.404 +1 +468.578 +1 +477.244 +1 +469.453 +1 +472.939 +1 +469.012 +1 +468.737 +1 +470.369 +1 +463.093 +1 +467.55 +1 +459.954 +1 +458.489 +1 +458.164 +1 +458.568 +1 +463.329 +1 +462.534 +1 +459.524 +1 +454.846 +1 +460.755 +1 +459.002 +1 +457.85 +1 +455.601 +1 +454.272 +1 +460.452 +1 +452.761 +1 +455.506 +1 +452.435 +1 +447.486 +1 +455.527 +1 +456.252 +1 +452.158 +1 +456.214 +1 +452.629 +1 +449.732 +1 +451.465 +1 +448.999 +1 +451.988 +1 +452.97 +1 +455.892 +1 +451.878 +1 +452.5 +1 +457.553 +1 +461.739 +1 +465.908 +1 +459.294 +1 +460.437 +1 +454.897 +1 +451.863 +1 +453.635 +1 +464.736 +1 +462.897 +1 +465.327 +1 +472.513 +1 +466.953 +1 +467.837 +1 +473.649 +1 +477.64 +1 +477.514 +1 +486.137 +1 +489.903 +1 +488.245 +1 +490.234 +1 +500.314 +1 +495.674 +1 +506.231 +1 +516.807 +1 +510.872 +1 +511.47 +1 +513 +1 +515.435 +1 +515.512 +1 +516.022 +1 +520.421 +1 +517.433 +1 +515.744 +1 +510.787 +1 +505.205 +1 +506.464 +1 +499.564 +1 +492.628 +1 +486.328 +1 +496.532 +1 +489.204 +1 +489.453 +1 +489.136 +1 +481.69 +1 +479.653 +1 +469.717 +1 +469.178 +1 +465.613 +1 +476.495 +1 +470.961 +1 +470.213 +1 +462.049 +1 +465.495 +1 +471.7 +1 +463.503 +1 +468.203 +1 +473.44 +1 +462.385 +1 +463.633 +1 +465.156 +1 +460.739 +1 +461.122 +1 +457.906 +1 +459.677 +1 +454.925 +1 +453.56 +1 +451.613 +1 +458.316 +1 +448.089 +1 +443.692 +1 +451.074 +1 +450.506 +1 +452.693 +1 +451.723 +1 +449.329 +1 +451.401 +1 +454.739 +1 +446.557 +1 +440.544 +1 +444.847 +1 +451.978 +1 +455.148 +1 +452.896 +1 +449.477 +1 +445.644 +1 +444.367 +1 +441.156 +1 +443.109 +1 +445.541 +1 +440.274 +1 +439.832 +1 +446.217 +1 +441.704 +1 +444.907 +1 +443.077 +1 +436.847 +1 +438.667 +1 +431.457 +1 +428.486 +1 +426.811 +1 +427.856 +1 +416.731 +1 +413.358 +1 +422.472 +1 +408.967 +1 +407.337 +1 +407.078 +1 +407.381 +1 +404.664 +1 +399.243 +1 +399.242 +1 +401.348 +1 +403.519 +1 +404.822 +1 +398.979 +1 +393.475 +1 +387.783 +1 +389.444 +1 +393.185 +1 +391.201 +1 +385.903 +1 +384.677 +1 +387.246 +1 +390.023 +1 +390.855 +1 +385.575 +1 +384.653 +1 +389.559 +1 +389.493 +1 +383.319 +1 +383.052 +1 +386.056 +1 +385.01 +1 +384.232 +1 +381.71 +1 +386.92 +1 +384.408 +1 +378.571 +1 +382.593 +1 +378.771 +1 +385.742 +1 +391.472 +1 +391.838 +1 +387.144 +1 +379.894 +1 +390.147 +1 +389.163 +1 +378.358 +1 +386.821 +1 +390.849 +1 +383.744 +1 +388.395 +1 +391.051 +1 +386.571 +1 +385.907 +1 +384.147 +1 +386.334 +1 +387.007 +1 +381.79 +1 +383.047 +1 +381.626 +1 +385.208 +1 +388.812 +1 +387.852 +1 +384.644 +1 +391.173 +1 +384.702 +1 +386.177 +1 +387.855 +1 +384.208 +1 +389.216 +1 +392.286 +1 +389.749 +1 +384.448 +1 +386.674 +1 +390.572 +1 +389.099 +1 +388.151 +1 +387.304 +1 +394.863 +1 +389.447 +1 +390.685 +1 +400.117 +1 +397.055 +1 +401.33 +1 +397.954 +1 +399.374 +1 +390.538 +1 +391.316 +1 +393.497 +1 +403.321 +1 +399.632 +1 +404.258 +1 +406.229 +1 +399.63 +1 +398.912 +1 +398.65 +1 +398.245 +1 +398.411 +1 +395.587 +1 +391.418 +1 +395.354 +1 +397.12 +1 +405.882 +1 +405.351 +1 +402.093 +1 +394.169 +1 +395.382 +1 +397.839 +1 +396.606 +1 +396.924 +1 +398.484 +1 +399.069 +1 +399.801 +1 +403.23 +1 +398.72 +1 +399.894 +1 +402.142 +1 +396.769 +1 +400.814 +1 +399.813 +1 +404.347 +1 +404.279 +1 +399.279 +1 +396.889 +1 +397.896 +1 +396.195 +1 +396.047 +1 +387.494 +1 +392.725 +1 +393.474 +1 +390.945 +1 +394.242 +1 +394.695 +1 +385.677 +1 +385.786 +1 +385.261 +1 +388.221 +1 +391.986 +1 +392.863 +1 +387.167 +1 +386.418 +1 +388.482 +1 +378.45 +1 +383.162 +1 +383.08 +1 +383.207 +1 +382.013 +1 +383.158 +1 +386.124 +1 +383.111 +1 +382.962 +1 +376.094 +1 +377.047 +1 +372.576 +1 +374.174 +1 +370.266 +1 +371.262 +1 +367.75 +1 +371.103 +1 +366.797 +1 +366.985 +1 +371.449 +1 +372.978 +1 +378.928 +1 +373.599 +1 +374.968 +1 +378.512 +1 +373.712 +1 +377.076 +1 +384.024 +1 +385.935 +1 +397.794 +1 +401.456 +1 +405.889 +1 +412.647 +1 +430.197 +1 +437.336 +1 +447.748 +1 +459.473 +1 +481.808 +1 +502.882 +1 +520.041 +1 +543.494 +1 +567.232 +1 +593.039 +1 +627.271 +1 +663.682 +1 +705.447 +1 +754.679 +1 +811.137 +1 +866.145 +1 +951.348 +1 +1040.02 +1 +1128.21 +1 +1241.15 +1 +1359.05 +1 +1486.95 +1 +1633.14 +1 +1775.25 +1 +1942.99 +1 +2129.7 +1 +2306.13 +1 +2471.11 +1 +2636.96 +1 +2782.72 +1 +2894.5 +1 +3007.03 +1 +3075.15 +1 +3082.32 +1 +3060.9 +1 +2996.11 +1 +2891.98 +1 +2750.06 +1 +2587.43 +1 +2399.8 +1 +2249.67 +1 +2045.16 +1 +1840.1 +1 +1669.95 +1 +1515.34 +1 +1365.01 +1 +1214.51 +1 +1105.26 +1 +1010.07 +1 +925.245 +1 +836.199 +1 +775.377 +1 +729.024 +1 +671.35 +1 +622.608 +1 +582.086 +1 +553.204 +1 +532.175 +1 +508.703 +1 +477.739 +1 +459.669 +1 +443.708 +1 +434.325 +1 +410.789 +1 +397.651 +1 +384.47 +1 +379.423 +1 +367.076 +1 +358.849 +1 +354.773 +1 +354.921 +1 +342.771 +1 +329.903 +1 +327.894 +1 +328.941 +1 +324.935 +1 +322.928 +1 +312.381 +1 +307.374 +1 +308.693 +1 +299.49 +1 +292.668 +1 +294.541 +1 +291.054 +1 +287.063 +1 +285.469 +1 +285.607 +1 +280.038 +1 +280.833 +1 +277.22 +1 +278.896 +1 +274.521 +1 +267.541 +1 +270.447 +1 +270.642 +1 +269.865 +1 +267.562 +1 +262.983 +1 +264.393 +1 +265.709 +1 +263.042 +1 +259.363 +1 +263.173 +1 +264.055 +1 +262.493 +1 +253.92 +1 +255.698 +1 +255.854 +1 +254.046 +1 +256.632 +1 +252.677 +1 +251.88 +1 +251.196 +1 +251.794 +1 +251.129 +1 +251.446 +1 +253.762 +1 +248.78 +1 +252.4 +1 +244.315 +1 +247.342 +1 +249.582 +1 +250.099 +1 +246.779 +1 +247.217 +1 +245.215 +1 +244.934 +1 +244.898 +1 +244.361 +1 +245.406 +1 +246.441 +1 +244.991 +1 +245.074 +1 +235.812 +1 +240.157 +1 +241.182 +1 +237.262 +1 +240.097 +1 +239.322 +1 +244.6 +1 +241.743 +1 +238.511 +1 +237.793 +1 +236.696 +1 +239.414 +1 +240.589 +1 +235.002 +1 +234.075 +1 +235.742 +1 +235.262 +1 +239.742 +1 +239.307 +1 +236.347 +1 +232.37 +1 +239.382 +1 +239.148 +1 +239.429 +1 +237.334 +1 +234.583 +1 +239.992 +1 +239.006 +1 +237.639 +1 +238.223 +1 +237.142 +1 +236.986 +1 +236.934 +1 +232.348 +1 +235.697 +1 +233.877 +1 +237.109 +1 +242.358 +1 +239.983 +1 +239.803 +1 +234.678 +1 +236.819 +1 +236.871 +1 +237.157 +1 +237.816 +1 +235.282 +1 +238.249 +1 +236.543 +1 +235.042 +1 +233.848 +1 +239.166 +1 +233.712 +1 +233.257 +1 +236.02 +1 +233.818 +1 +234.615 +1 +232.355 +1 +231.827 +1 +236.446 +1 +239.217 +1 +238.744 +1 +235.374 +1 +235.806 +1 +232.32 +1 +234.844 +1 +233.639 +1 +236.085 +1 +233.176 +1 +230.395 +1 +229.009 +1 +237.059 +1 +229.742 +1 +233.935 +1 +234.598 +1 +235.729 +1 +235.6 +1 +230.15 +1 +231.835 +1 +233.379 +1 +232.301 +1 +231.323 +1 +231.075 +1 +233.562 +1 +233.819 +1 +237.83 +1 +234.984 +1 +234.406 +1 +230.153 +1 +227.947 +1 +229.656 +1 +237.532 +1 +235.515 +1 +236.882 +1 +232.59 +1 +231.022 +1 +235.272 +1 +237.716 +1 +239.941 +1 +233.484 +1 +234.799 +1 +235.62 +1 +232.77 +1 +230.179 +1 +227.68 +1 +229.992 +1 +231.685 +1 +230.557 +1 +235.688 +1 +239.037 +1 +235.943 +1 +239.096 +1 +238.596 +1 +235.012 +1 +233.414 +1 +228.756 +1 +229.85 +1 +232.019 +1 +233.314 +1 +227.346 +1 +229.605 +1 +228.754 +1 +228.705 +1 +227.848 +1 +235.134 +1 +232.654 +1 +229.85 +1 +230.952 +1 +233.897 +1 +231.266 +1 +225.546 +1 +230.988 +1 +232.079 +1 +233.072 +1 +235.505 +1 +237.139 +1 +233.087 +1 +228.246 +1 +226.708 +1 +234.437 +1 +233.287 +1 +228.153 +1 +230.688 +1 +228.862 +1 +231.186 +1 +230.121 +1 +236.263 +1 +233.508 +1 +Cu LMM +Cu2O +2005 +2018 +2 +20 +15 +47 +0 +7 +Casa Info Follows +0 +0 +0 +0 +Sum of 38 spectra in column containing 38 scans +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +3 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +3.808 +0 +0 +0 +0 +0 +Cu LMM + +-1 +kinetic energy +eV +906.71 +0.1 +2 +counts +d +Transmission +d +pulse counting +1.9 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +500 +49.7144 +337.196 +1 +1 +258.614 +1 +251.98 +1 +261.312 +1 +256.706 +1 +261.1 +1 +262.62 +1 +258.06 +1 +259.564 +1 +260.577 +1 +261.283 +1 +263.367 +1 +263.182 +1 +267.801 +1 +268.259 +1 +270.557 +1 +265.644 +1 +268.256 +1 +269.191 +1 +273.568 +1 +270.796 +1 +271.407 +1 +272.886 +1 +271.545 +1 +274.466 +1 +274.129 +1 +275.571 +1 +279.116 +1 +276.023 +1 +279.432 +1 +286.976 +1 +281.357 +1 +286.219 +1 +286.728 +1 +285.954 +1 +287.153 +1 +288.831 +1 +287.344 +1 +289.985 +1 +292.48 +1 +298.827 +1 +303.565 +1 +304.158 +1 +304.56 +1 +302.553 +1 +305.635 +1 +305.045 +1 +304.839 +1 +311.536 +1 +321.376 +1 +315.777 +1 +313.338 +1 +313.723 +1 +320.996 +1 +321.317 +1 +319.326 +1 +328.303 +1 +330.628 +1 +329.878 +1 +330.959 +1 +333.419 +1 +333.065 +1 +335.028 +1 +330.123 +1 +332.023 +1 +332.581 +1 +327.311 +1 +331.099 +1 +333.28 +1 +328.624 +1 +332.989 +1 +340.808 +1 +328.324 +1 +333.1 +1 +342.675 +1 +346.412 +1 +337.477 +1 +344.541 +1 +346.192 +1 +345.224 +1 +350.186 +1 +347.407 +1 +357.857 +1 +360.178 +1 +369.747 +1 +374.941 +1 +383.001 +1 +392.841 +1 +402.036 +1 +418.998 +1 +431.31 +1 +441.023 +1 +462.322 +1 +495.214 +1 +511.42 +1 +526.843 +1 +556.34 +1 +568.19 +1 +585.769 +1 +595.802 +1 +590.09 +1 +596.253 +1 +582.835 +1 +566.401 +1 +547.835 +1 +526.267 +1 +509.934 +1 +487.122 +1 +463.332 +1 +446.775 +1 +425.398 +1 +412.675 +1 +403.112 +1 +393.217 +1 +382.187 +1 +364.187 +1 +356.083 +1 +344.828 +1 +334.661 +1 +325.437 +1 +321.533 +1 +315.479 +1 +306.483 +1 +302.04 +1 +299.354 +1 +301.089 +1 +287.546 +1 +285.49 +1 +281.118 +1 +270.944 +1 +267.978 +1 +258.72 +1 +251.757 +1 +245.879 +1 +244.573 +1 +236.863 +1 +232.758 +1 +229.77 +1 +227.066 +1 +223.44 +1 +214.66 +1 +217.139 +1 +211.903 +1 +213.754 +1 +213.973 +1 +211.061 +1 +208.776 +1 +205.081 +1 +203.223 +1 +200.285 +1 +198.704 +1 +202.252 +1 +198.256 +1 +197.057 +1 +191.364 +1 +191.528 +1 +186.018 +1 +184.629 +1 +181.231 +1 +178.92 +1 +176.328 +1 +177.678 +1 +174.16 +1 +171.735 +1 +164.059 +1 +158.599 +1 +162.039 +1 +159.315 +1 +156.58 +1 +152.778 +1 +149.523 +1 +145.497 +1 +148.824 +1 +148.444 +1 +148.155 +1 +151.291 +1 +141.918 +1 +138.364 +1 +143.244 +1 +145.136 +1 +146.388 +1 +145.12 +1 +141.923 +1 +142.299 +1 +144.589 +1 +142.301 +1 +141.291 +1 +139.864 +1 +138.533 +1 +140.536 +1 +138.648 +1 +141.042 +1 +139.719 +1 +137.064 +1 +137.195 +1 +137.759 +1 +137 +1 +137.086 +1 +136.135 +1 +133.902 +1 +137.983 +1 +134.784 +1 +133.772 +1 +136.806 +1 +136.702 +1 +136.119 +1 +134.516 +1 +131.518 +1 +127.507 +1 +131.504 +1 +130.68 +1 +129.574 +1 +128.186 +1 +125.417 +1 +129.507 +1 +125.012 +1 +124.904 +1 +124.41 +1 +125.96 +1 +126.093 +1 +125.803 +1 +127.697 +1 +121.169 +1 +121.939 +1 +124.948 +1 +120.554 +1 +121.468 +1 +122.519 +1 +121.355 +1 +121.423 +1 +122.542 +1 +125.811 +1 +123.937 +1 +121.121 +1 +120.426 +1 +126.792 +1 +127.61 +1 +124.291 +1 +121.729 +1 +124.085 +1 +123.071 +1 +127.081 +1 +124.208 +1 +122.258 +1 +128.341 +1 +125.319 +1 +129.252 +1 +127.288 +1 +127.378 +1 +128.655 +1 +128.452 +1 +O1s +Cu2O +2005 +2018 +2 +19 +32 +18 +0 +8 +Casa Info Follows +0 +0 +0 +0 +Sum of 38 spectra in column containing 38 scans + +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +3 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +3.808 +0 +0 +0 +0 +0 +O 1s + +-1 +kinetic energy +eV +946.61 +0.1 +2 +counts +d +Transmission +d +pulse counting +1.9 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +402 +12.1566 +204.73 +1 +1 +63.3072 +1 +61.9162 +1 +61.3964 +1 +61.0797 +1 +60.1196 +1 +58.3574 +1 +59.5925 +1 +60.4829 +1 +61.6927 +1 +59.1139 +1 +57.3578 +1 +57.6496 +1 +58.2062 +1 +57.6232 +1 +56.5106 +1 +59.2276 +1 +58.0327 +1 +58.3029 +1 +56.5581 +1 +56.4405 +1 +57.5591 +1 +55.4171 +1 +56.2945 +1 +53.7721 +1 +54.8544 +1 +55.5653 +1 +60.193 +1 +58.0177 +1 +57.1485 +1 +54.1784 +1 +56.8806 +1 +55.2005 +1 +55.5369 +1 +56.0337 +1 +57.0535 +1 +55.795 +1 +57.8591 +1 +56.6514 +1 +57.578 +1 +58.3391 +1 +57.8174 +1 +59.2748 +1 +62.8061 +1 +58.3774 +1 +60.1603 +1 +60.9015 +1 +61.3269 +1 +62.0307 +1 +61.3004 +1 +62.6365 +1 +62.5727 +1 +59.5742 +1 +58.9304 +1 +56.5688 +1 +55.7846 +1 +57.7874 +1 +58.2509 +1 +57.3009 +1 +57.6636 +1 +57.76 +1 +55.4687 +1 +58.3938 +1 +52.4146 +1 +54.0663 +1 +54.8607 +1 +53.315 +1 +52.8475 +1 +51.2433 +1 +54.0496 +1 +55.8561 +1 +52.3685 +1 +52.7053 +1 +52.6642 +1 +52.9218 +1 +54.7852 +1 +56.711 +1 +57.2467 +1 +58.4234 +1 +58.72 +1 +61.057 +1 +60.5741 +1 +64.109 +1 +64.4623 +1 +66.0887 +1 +66.7604 +1 +70.2042 +1 +74.2033 +1 +81.4876 +1 +86.5706 +1 +95.6368 +1 +111.602 +1 +137.388 +1 +164.944 +1 +216.792 +1 +269.462 +1 +319.908 +1 +369.894 +1 +395.964 +1 +402.879 +1 +382.048 +1 +336.358 +1 +277.861 +1 +208.941 +1 +168.289 +1 +129.968 +1 +103.797 +1 +83.8188 +1 +70.6903 +1 +64.0859 +1 +59.6779 +1 +55.9299 +1 +50.6203 +1 +52.069 +1 +48.0975 +1 +45.5066 +1 +45.1392 +1 +44.0208 +1 +41.7217 +1 +42.2479 +1 +40.4216 +1 +40.0825 +1 +36.417 +1 +37.7696 +1 +40.3274 +1 +39.307 +1 +36.3602 +1 +36.6894 +1 +40.234 +1 +40.221 +1 +38.0673 +1 +36.9766 +1 +37.9369 +1 +38.4799 +1 +37.605 +1 +34.8367 +1 +37.3237 +1 +36.738 +1 +37.2011 +1 +39.073 +1 +38.2927 +1 +39.5271 +1 +37.6023 +1 +39.4154 +1 +36.1045 +1 +37.0639 +1 +36.3169 +1 +38.7453 +1 +36.9798 +1 +37.6384 +1 +38.8409 +1 +39.2392 +1 +37.8129 +1 +37.1404 +1 +35.4815 +1 +36.2944 +1 +35.318 +1 +35.932 +1 +35.8721 +1 +37.0276 +1 +37.63 +1 +37.1448 +1 +35.9293 +1 +36.1835 +1 +36.1087 +1 +36.2661 +1 +37.3276 +1 +36.2997 +1 +36.6733 +1 +37.8587 +1 +38.437 +1 +37.683 +1 +37.6603 +1 +37.1272 +1 +38.681 +1 +36.2166 +1 +35.8946 +1 +36.801 +1 +37.3809 +1 +36.4884 +1 +34.6512 +1 +37.1496 +1 +37.3637 +1 +36.6019 +1 +37.3725 +1 +37.218 +1 +35.9517 +1 +34.8608 +1 +35.7223 +1 +36.644 +1 +36.2906 +1 +36.022 +1 +34.9164 +1 +36.835 +1 +37.3881 +1 +35.6884 +1 +36.8872 +1 +37.561 +1 +35.9557 +1 +38.1122 +1 +37.0327 +1 +35.3345 +1 +Cu2p +CuO +2006 +2018 +2 +9 +46 +56 +0 +7 +Casa Info Follows +0 +0 +0 +0 +Sum of 43 spectra in column containing 43 scans +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +4 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +3.808 +0 +0 +0 +0 +0 +Cu 2p + +-1 +kinetic energy +eV +514.66 +0.05 +2 +counts +d +Transmission +d +pulse counting +2.15 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +2080 +90.6399 +524.355 +1 +1 +493.496 +1 +504.92 +1 +500.827 +1 +496.317 +1 +493.428 +1 +491.085 +1 +495.952 +1 +498.901 +1 +493.456 +1 +490.554 +1 +497.568 +1 +492.532 +1 +485.269 +1 +490.839 +1 +489.957 +1 +490.527 +1 +494.382 +1 +491.323 +1 +489.753 +1 +493.553 +1 +494.838 +1 +487.864 +1 +492.21 +1 +487.59 +1 +490.329 +1 +483.499 +1 +484.846 +1 +489.016 +1 +484.3 +1 +484.14 +1 +482.262 +1 +476.571 +1 +483.319 +1 +485.418 +1 +487.332 +1 +486.955 +1 +483.003 +1 +478.598 +1 +477.794 +1 +485.474 +1 +480.255 +1 +486.39 +1 +485.007 +1 +481.592 +1 +478.035 +1 +480.297 +1 +487.053 +1 +475.106 +1 +470.895 +1 +481.867 +1 +481.281 +1 +476.521 +1 +471.577 +1 +469.031 +1 +480.017 +1 +483.672 +1 +475.163 +1 +477.563 +1 +483.728 +1 +478.743 +1 +476.676 +1 +478.939 +1 +470.866 +1 +469.697 +1 +466.11 +1 +472.603 +1 +479.807 +1 +477.963 +1 +476.92 +1 +476.371 +1 +466.464 +1 +468.247 +1 +477.964 +1 +479.825 +1 +472.471 +1 +472.826 +1 +472.515 +1 +474.114 +1 +466.171 +1 +469.4 +1 +465.646 +1 +469.306 +1 +462.37 +1 +464.316 +1 +469.863 +1 +476.536 +1 +471.665 +1 +472.351 +1 +469.405 +1 +475.939 +1 +470.034 +1 +473.848 +1 +474.626 +1 +474.435 +1 +474.747 +1 +467.293 +1 +465.238 +1 +470.521 +1 +475.806 +1 +472.124 +1 +467.851 +1 +467.866 +1 +467.134 +1 +463.753 +1 +458.938 +1 +468.086 +1 +465.89 +1 +471.481 +1 +472.95 +1 +466.876 +1 +469.927 +1 +469.033 +1 +471.335 +1 +464.918 +1 +466.718 +1 +470.574 +1 +469.425 +1 +467.862 +1 +469.953 +1 +467.676 +1 +467.287 +1 +467.594 +1 +459.845 +1 +466.932 +1 +474.947 +1 +470.154 +1 +472.938 +1 +469.811 +1 +469.943 +1 +472.854 +1 +472.035 +1 +468.045 +1 +469.239 +1 +470.111 +1 +471.923 +1 +473.86 +1 +473.356 +1 +476.182 +1 +474.057 +1 +469.357 +1 +470.646 +1 +474.605 +1 +470.195 +1 +475.334 +1 +476.862 +1 +478.074 +1 +482.999 +1 +481.065 +1 +482.409 +1 +490.139 +1 +479.789 +1 +478.48 +1 +479.277 +1 +488.771 +1 +488.791 +1 +490.175 +1 +495.624 +1 +492.261 +1 +496.77 +1 +504.924 +1 +508.466 +1 +517.203 +1 +515.155 +1 +517.649 +1 +517.5 +1 +519.74 +1 +523.806 +1 +536.152 +1 +539.728 +1 +544.058 +1 +551.821 +1 +551.812 +1 +556.84 +1 +562.852 +1 +566.962 +1 +564.656 +1 +575.85 +1 +592.946 +1 +595.153 +1 +600.344 +1 +604.127 +1 +608.044 +1 +622.951 +1 +627.267 +1 +626.808 +1 +638.205 +1 +648.358 +1 +650.385 +1 +653.291 +1 +669.99 +1 +668.482 +1 +676.988 +1 +689.852 +1 +693.713 +1 +704.764 +1 +711.006 +1 +713.766 +1 +720.158 +1 +730.15 +1 +717.552 +1 +707.4 +1 +718.835 +1 +711.87 +1 +704.539 +1 +698.619 +1 +707.219 +1 +708.317 +1 +694.021 +1 +683.858 +1 +679.289 +1 +676.84 +1 +672.88 +1 +668.661 +1 +657.668 +1 +655.62 +1 +634.486 +1 +632.989 +1 +626.806 +1 +627.464 +1 +627.656 +1 +611.818 +1 +601.014 +1 +596.338 +1 +592.318 +1 +595.255 +1 +580.435 +1 +569.268 +1 +572.892 +1 +576.557 +1 +569.276 +1 +554.297 +1 +551.784 +1 +544.339 +1 +539.601 +1 +533.789 +1 +532.886 +1 +527.995 +1 +521.635 +1 +514.996 +1 +511.769 +1 +506.054 +1 +495.69 +1 +490.237 +1 +493.095 +1 +496.515 +1 +491.663 +1 +481.754 +1 +485.924 +1 +475.088 +1 +475.17 +1 +472.394 +1 +471.76 +1 +461.733 +1 +464.368 +1 +466.546 +1 +464.477 +1 +461.442 +1 +455.258 +1 +457.919 +1 +456.209 +1 +458.279 +1 +454.25 +1 +457.534 +1 +457.15 +1 +450.006 +1 +450.849 +1 +453.372 +1 +450.834 +1 +457.152 +1 +450.888 +1 +451.77 +1 +455.335 +1 +453.049 +1 +451.013 +1 +452.253 +1 +453.577 +1 +458.609 +1 +458.234 +1 +454.056 +1 +453.502 +1 +456.07 +1 +455.876 +1 +451.509 +1 +459.455 +1 +457.451 +1 +460.273 +1 +459.841 +1 +461.419 +1 +464.837 +1 +458.063 +1 +463.078 +1 +457.644 +1 +464.248 +1 +464.702 +1 +462.141 +1 +456.934 +1 +460.382 +1 +467.687 +1 +468.543 +1 +470.892 +1 +472.124 +1 +471.361 +1 +477 +1 +476.51 +1 +472.576 +1 +481.98 +1 +478.991 +1 +478.875 +1 +480.311 +1 +492.209 +1 +480.454 +1 +487.916 +1 +488.272 +1 +487.299 +1 +492.572 +1 +496.603 +1 +499.879 +1 +503.986 +1 +502.39 +1 +501.944 +1 +505.38 +1 +512.43 +1 +509.695 +1 +513.783 +1 +516.339 +1 +512.128 +1 +520.562 +1 +528.98 +1 +529.238 +1 +534.404 +1 +538.156 +1 +540.456 +1 +550.524 +1 +534.891 +1 +547.87 +1 +562.133 +1 +561.261 +1 +566.179 +1 +572.994 +1 +573.191 +1 +574.623 +1 +584.176 +1 +585.261 +1 +588.211 +1 +607.254 +1 +610.821 +1 +611.185 +1 +605.814 +1 +614.852 +1 +620.312 +1 +620.608 +1 +628.928 +1 +629.832 +1 +642.441 +1 +648.832 +1 +649.449 +1 +654.972 +1 +659.475 +1 +668.327 +1 +684.459 +1 +690.023 +1 +691.925 +1 +699.864 +1 +692.975 +1 +703.822 +1 +707.308 +1 +717.819 +1 +717.975 +1 +714.714 +1 +726.884 +1 +728.592 +1 +728.954 +1 +736.776 +1 +741.99 +1 +726.42 +1 +732.821 +1 +738.97 +1 +728.993 +1 +731.228 +1 +727.151 +1 +728.199 +1 +723.485 +1 +724.302 +1 +709.144 +1 +710.97 +1 +705.212 +1 +697.492 +1 +693.619 +1 +681.256 +1 +673.944 +1 +673.543 +1 +661.953 +1 +649.673 +1 +637.597 +1 +634.257 +1 +631.844 +1 +617.886 +1 +610.057 +1 +598.477 +1 +593.454 +1 +583.376 +1 +569.21 +1 +562.56 +1 +554.453 +1 +545.308 +1 +536.425 +1 +522.416 +1 +511.9 +1 +510.711 +1 +488.736 +1 +487.478 +1 +481.26 +1 +474.031 +1 +461.559 +1 +453.12 +1 +447.021 +1 +445.761 +1 +442.535 +1 +440.761 +1 +432.788 +1 +426.984 +1 +423.99 +1 +422.225 +1 +423.111 +1 +416.576 +1 +411.599 +1 +413.494 +1 +408.676 +1 +404.362 +1 +402.668 +1 +397.21 +1 +403.184 +1 +408.467 +1 +396.247 +1 +392.349 +1 +390.354 +1 +390.056 +1 +385.094 +1 +398.713 +1 +397.13 +1 +394.051 +1 +392.73 +1 +389.431 +1 +392.733 +1 +395.625 +1 +391.901 +1 +388.313 +1 +386.607 +1 +387.824 +1 +375.007 +1 +386.751 +1 +389.025 +1 +388.29 +1 +385.88 +1 +379.19 +1 +385.464 +1 +387.71 +1 +385.296 +1 +385.82 +1 +385.058 +1 +380.698 +1 +385.944 +1 +385.448 +1 +379.215 +1 +378.534 +1 +375.097 +1 +376.289 +1 +374.035 +1 +376.433 +1 +376.034 +1 +377.005 +1 +381.148 +1 +381.639 +1 +378.842 +1 +382.076 +1 +378.222 +1 +378.238 +1 +377.974 +1 +381.66 +1 +377.358 +1 +380.272 +1 +375.594 +1 +374.168 +1 +372.18 +1 +375.238 +1 +373.826 +1 +373.074 +1 +375.622 +1 +373.783 +1 +368.222 +1 +373.893 +1 +372.07 +1 +371.613 +1 +372.467 +1 +370.394 +1 +376.806 +1 +377.565 +1 +372.268 +1 +376.175 +1 +375.968 +1 +373.71 +1 +381.379 +1 +373.481 +1 +373.728 +1 +375.083 +1 +372.265 +1 +368.13 +1 +371.049 +1 +372.035 +1 +374.627 +1 +379.078 +1 +382.231 +1 +379.107 +1 +379.263 +1 +378.167 +1 +376.303 +1 +382.462 +1 +378.174 +1 +380.553 +1 +379.373 +1 +381.501 +1 +385.024 +1 +384.432 +1 +381.18 +1 +384.609 +1 +388.851 +1 +391.114 +1 +385.078 +1 +385.535 +1 +391.792 +1 +393.589 +1 +390.189 +1 +391.75 +1 +394.357 +1 +399.419 +1 +404.74 +1 +405.714 +1 +409.302 +1 +414.603 +1 +411.68 +1 +416.884 +1 +422.844 +1 +424.682 +1 +427.441 +1 +433.666 +1 +444.71 +1 +449.126 +1 +459.511 +1 +463.404 +1 +482.357 +1 +487.313 +1 +490.251 +1 +511.336 +1 +513.651 +1 +537.588 +1 +536.361 +1 +551.027 +1 +549.964 +1 +566.908 +1 +587.776 +1 +598.473 +1 +619.957 +1 +618.464 +1 +636.953 +1 +641.909 +1 +645.235 +1 +649.338 +1 +652.604 +1 +664.029 +1 +658.434 +1 +655.147 +1 +654.654 +1 +640.278 +1 +645.618 +1 +644.661 +1 +634.594 +1 +623.246 +1 +617.807 +1 +610.683 +1 +600.141 +1 +597.136 +1 +589.45 +1 +585.857 +1 +600.949 +1 +593.835 +1 +589.851 +1 +597.188 +1 +596.24 +1 +592.928 +1 +585.441 +1 +597.42 +1 +604.714 +1 +602.493 +1 +607.724 +1 +610.431 +1 +607.238 +1 +615.527 +1 +613.534 +1 +612.586 +1 +618.203 +1 +625.2 +1 +621.189 +1 +627.714 +1 +626.874 +1 +622.321 +1 +627.952 +1 +631.175 +1 +633.39 +1 +626.707 +1 +636.281 +1 +632.146 +1 +641.529 +1 +642.907 +1 +642.269 +1 +642.491 +1 +646.324 +1 +650.571 +1 +651.587 +1 +649.029 +1 +658.013 +1 +657.411 +1 +652.118 +1 +655.943 +1 +661.636 +1 +663.047 +1 +663.293 +1 +663.56 +1 +665.43 +1 +662.457 +1 +655.662 +1 +662.922 +1 +656.584 +1 +643.991 +1 +636.07 +1 +622.832 +1 +605.079 +1 +605.37 +1 +588.199 +1 +565.692 +1 +553.316 +1 +538.916 +1 +533.737 +1 +521.68 +1 +501.754 +1 +490.763 +1 +482.488 +1 +469.192 +1 +460.364 +1 +457.196 +1 +444.443 +1 +439.772 +1 +433.547 +1 +420.596 +1 +418.928 +1 +412.645 +1 +409.321 +1 +409.154 +1 +401.525 +1 +400.381 +1 +393.591 +1 +389.519 +1 +388.919 +1 +394.197 +1 +387.119 +1 +393.256 +1 +393.075 +1 +390.642 +1 +390.52 +1 +382.595 +1 +385.264 +1 +389.764 +1 +382.609 +1 +392.189 +1 +393.236 +1 +394.033 +1 +392.879 +1 +389.622 +1 +391.644 +1 +388.38 +1 +391.523 +1 +390.062 +1 +398.014 +1 +393.875 +1 +401.556 +1 +401.276 +1 +403.864 +1 +403.319 +1 +404.034 +1 +402.922 +1 +406.596 +1 +408.499 +1 +409.586 +1 +405.738 +1 +415.045 +1 +414.738 +1 +410.751 +1 +417.494 +1 +420.409 +1 +421.267 +1 +416.937 +1 +422.968 +1 +429.356 +1 +432.471 +1 +436.201 +1 +444.041 +1 +441.686 +1 +445.968 +1 +439.62 +1 +447.097 +1 +451.806 +1 +463.515 +1 +466.451 +1 +475.594 +1 +479.294 +1 +474.483 +1 +480.62 +1 +486.256 +1 +502.795 +1 +501.718 +1 +514.259 +1 +521.987 +1 +523.186 +1 +527.115 +1 +528.624 +1 +546.475 +1 +550.376 +1 +553.986 +1 +559.587 +1 +572.304 +1 +573.332 +1 +586.498 +1 +593.302 +1 +602.779 +1 +609.143 +1 +628.568 +1 +620.968 +1 +628.55 +1 +648.179 +1 +656.964 +1 +667.835 +1 +681.895 +1 +680.672 +1 +696.32 +1 +708.776 +1 +720.432 +1 +740.223 +1 +753.056 +1 +763.141 +1 +781.386 +1 +794.649 +1 +798.318 +1 +809.307 +1 +830.982 +1 +845.766 +1 +860.667 +1 +866.722 +1 +880.092 +1 +903.691 +1 +919.212 +1 +926.504 +1 +945.29 +1 +960.432 +1 +969.96 +1 +992.696 +1 +1004.77 +1 +1023.32 +1 +1027.22 +1 +1043.04 +1 +1042.32 +1 +1034.21 +1 +1047.39 +1 +1059.13 +1 +1069.05 +1 +1057.96 +1 +1057.39 +1 +1053.85 +1 +1058.83 +1 +1046.5 +1 +1031.85 +1 +1040.22 +1 +1019.93 +1 +998.898 +1 +979.907 +1 +966.065 +1 +960.89 +1 +942.672 +1 +918.048 +1 +900.767 +1 +887.25 +1 +863.085 +1 +850.025 +1 +827.256 +1 +805.326 +1 +770.749 +1 +753.727 +1 +729.673 +1 +709.333 +1 +683.969 +1 +657.161 +1 +637.965 +1 +614.169 +1 +585.059 +1 +566.548 +1 +534.791 +1 +517.228 +1 +492.191 +1 +472.663 +1 +446.931 +1 +427.352 +1 +419.147 +1 +403.963 +1 +382.154 +1 +368.8 +1 +362.374 +1 +352.131 +1 +337.294 +1 +331.15 +1 +319.88 +1 +313.001 +1 +311.319 +1 +297.572 +1 +289.676 +1 +294.003 +1 +291.704 +1 +290.102 +1 +281.581 +1 +278.349 +1 +278.735 +1 +275.224 +1 +278.919 +1 +273.524 +1 +269.393 +1 +263.21 +1 +269.899 +1 +265.051 +1 +266.556 +1 +263.764 +1 +261.061 +1 +262.738 +1 +258.58 +1 +260.465 +1 +263.493 +1 +257.116 +1 +256.482 +1 +250.524 +1 +253.904 +1 +254.731 +1 +251.18 +1 +243.684 +1 +250.656 +1 +246.529 +1 +253.007 +1 +245.631 +1 +246.081 +1 +248.863 +1 +247.502 +1 +249.241 +1 +246.021 +1 +240.095 +1 +243.15 +1 +248.91 +1 +245.147 +1 +245.088 +1 +245.996 +1 +242.579 +1 +241.85 +1 +246.061 +1 +244.647 +1 +242.312 +1 +246.415 +1 +245.388 +1 +242.634 +1 +239.105 +1 +242.72 +1 +244.992 +1 +242.862 +1 +240.81 +1 +239.775 +1 +234.256 +1 +240.203 +1 +242.071 +1 +240.079 +1 +241.183 +1 +238.502 +1 +235.332 +1 +236.731 +1 +238.926 +1 +242.674 +1 +241.297 +1 +238.768 +1 +237.866 +1 +236.26 +1 +237.537 +1 +238.377 +1 +240.095 +1 +242.965 +1 +234.608 +1 +235.646 +1 +236.128 +1 +233.686 +1 +238.584 +1 +236.093 +1 +240.371 +1 +236.719 +1 +232.639 +1 +238.199 +1 +237.794 +1 +233.667 +1 +237.035 +1 +232.682 +1 +236.011 +1 +234.062 +1 +238.408 +1 +234.836 +1 +236.452 +1 +239.073 +1 +237.099 +1 +238.082 +1 +236.293 +1 +236.898 +1 +234.365 +1 +234.983 +1 +238.466 +1 +236.921 +1 +237.177 +1 +237.426 +1 +238.959 +1 +238.485 +1 +236.357 +1 +241.052 +1 +233.572 +1 +236.12 +1 +237.998 +1 +238.254 +1 +235.189 +1 +235.105 +1 +236.383 +1 +237.401 +1 +234.837 +1 +237.034 +1 +242.717 +1 +237.846 +1 +234.898 +1 +236.262 +1 +236.859 +1 +233.672 +1 +231.743 +1 +231.373 +1 +231.33 +1 +233.235 +1 +233.689 +1 +237.851 +1 +235.906 +1 +234.727 +1 +234.978 +1 +231.332 +1 +234.41 +1 +232.772 +1 +235.791 +1 +232.186 +1 +228.572 +1 +227.742 +1 +232.122 +1 +234.636 +1 +234.156 +1 +235.466 +1 +240.253 +1 +237.592 +1 +236.219 +1 +235.393 +1 +235.384 +1 +234.95 +1 +237.904 +1 +236.185 +1 +236.681 +1 +234.076 +1 +231.186 +1 +235.888 +1 +234.438 +1 +233.481 +1 +235.378 +1 +235.108 +1 +233.588 +1 +231.752 +1 +234.28 +1 +234.47 +1 +237.015 +1 +237.775 +1 +232.499 +1 +228.015 +1 +235.436 +1 +236.965 +1 +235.204 +1 +232.791 +1 +227.938 +1 +234.994 +1 +236.204 +1 +230.473 +1 +236.06 +1 +237.599 +1 +235.613 +1 +232.555 +1 +232.298 +1 +236.497 +1 +236.553 +1 +235.611 +1 +232.427 +1 +232.212 +1 +234.588 +1 +231.919 +1 +232.991 +1 +235.145 +1 +235.464 +1 +232.892 +1 +236.278 +1 +235.181 +1 +233.316 +1 +233.702 +1 +232.855 +1 +235.119 +1 +232.305 +1 +230.933 +1 +234.496 +1 +236.944 +1 +231.806 +1 +232.075 +1 +235.752 +1 +233.765 +1 +236.194 +1 +235.049 +1 +231.759 +1 +233.748 +1 +232.686 +1 +235.664 +1 +234.272 +1 +236.152 +1 +231.022 +1 +229.09 +1 +233.948 +1 +236.819 +1 +Cu LMM +CuO +2006 +2018 +2 +7 +30 +58 +0 +8 +Casa Info Follows +0 +0 +0 +0 +Sum of 43 spectra in column containing 43 scans + +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +4 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +3.808 +0 +0 +0 +0 +0 +Cu LMM + +-1 +kinetic energy +eV +906.71 +0.1 +2 +counts +d +Transmission +d +pulse counting +2.15 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +500 +51.4732 +257.32 +1 +1 +230.134 +1 +234.217 +1 +228.25 +1 +231.38 +1 +230.213 +1 +233.061 +1 +231.302 +1 +231.061 +1 +227.397 +1 +231.132 +1 +236.66 +1 +234.386 +1 +239.052 +1 +238.882 +1 +233.426 +1 +240.095 +1 +240.843 +1 +239.612 +1 +243.347 +1 +243.799 +1 +239.323 +1 +238.958 +1 +240.694 +1 +248.931 +1 +246.881 +1 +244.44 +1 +248.522 +1 +249.584 +1 +251.123 +1 +247.834 +1 +253.241 +1 +257.312 +1 +255.659 +1 +255.624 +1 +260.275 +1 +263.892 +1 +264.735 +1 +266.664 +1 +272.206 +1 +269.748 +1 +270.175 +1 +279.932 +1 +279.548 +1 +280.148 +1 +283.096 +1 +280.484 +1 +282.003 +1 +290.897 +1 +293.864 +1 +289.189 +1 +297.9 +1 +294.256 +1 +293.013 +1 +295.819 +1 +299.601 +1 +302.008 +1 +298.051 +1 +298.758 +1 +292.077 +1 +299.712 +1 +306.032 +1 +298.435 +1 +301.119 +1 +300.334 +1 +301.854 +1 +304.814 +1 +310.163 +1 +308.304 +1 +304.005 +1 +311.088 +1 +314.86 +1 +313.375 +1 +320.701 +1 +316.978 +1 +313.137 +1 +314.777 +1 +316.649 +1 +313.123 +1 +313.965 +1 +306.799 +1 +306.749 +1 +305.278 +1 +300.547 +1 +300.17 +1 +302.662 +1 +307.779 +1 +305.956 +1 +299.589 +1 +297.624 +1 +302.598 +1 +307.737 +1 +309.967 +1 +311.782 +1 +314.506 +1 +312.649 +1 +317.999 +1 +329.982 +1 +337.044 +1 +337.233 +1 +350.224 +1 +363.47 +1 +374.581 +1 +389.21 +1 +400.702 +1 +415.008 +1 +426.969 +1 +441.352 +1 +448.255 +1 +462.82 +1 +475.13 +1 +489.312 +1 +493.636 +1 +493.528 +1 +490.553 +1 +482.622 +1 +472.614 +1 +460.238 +1 +444.493 +1 +427.549 +1 +415.284 +1 +398.743 +1 +379.565 +1 +369.647 +1 +358.933 +1 +345.573 +1 +333.212 +1 +323.411 +1 +318.604 +1 +311.134 +1 +299.863 +1 +290.411 +1 +285.389 +1 +283.357 +1 +282.498 +1 +274.676 +1 +269.67 +1 +269.558 +1 +265.161 +1 +265.825 +1 +263.329 +1 +256.134 +1 +259.752 +1 +250.983 +1 +243.722 +1 +241.521 +1 +237.778 +1 +231.623 +1 +233.056 +1 +229.333 +1 +223.828 +1 +220.458 +1 +217.512 +1 +215.58 +1 +211.859 +1 +204.873 +1 +203.147 +1 +202.485 +1 +203.709 +1 +200.704 +1 +198.937 +1 +199.184 +1 +196.002 +1 +193.438 +1 +189.897 +1 +189.11 +1 +192.362 +1 +186.215 +1 +184.656 +1 +183.624 +1 +184.552 +1 +179.68 +1 +180.385 +1 +181.949 +1 +172.305 +1 +172.115 +1 +175.371 +1 +174.383 +1 +174.125 +1 +175.165 +1 +174.784 +1 +174.186 +1 +171.524 +1 +170.939 +1 +169.661 +1 +172.857 +1 +168.164 +1 +165.113 +1 +167.463 +1 +169.97 +1 +168.96 +1 +168.366 +1 +166.49 +1 +166.24 +1 +163.797 +1 +158.813 +1 +164.936 +1 +159.926 +1 +157.943 +1 +162.491 +1 +159.721 +1 +155.677 +1 +152.975 +1 +155.854 +1 +155.024 +1 +157.991 +1 +154.429 +1 +152.556 +1 +147.999 +1 +148.55 +1 +144.135 +1 +144.983 +1 +148.64 +1 +145.392 +1 +140.335 +1 +143.982 +1 +140.208 +1 +139.709 +1 +136.649 +1 +133.464 +1 +135.719 +1 +133.864 +1 +134.34 +1 +133.921 +1 +134.999 +1 +131.47 +1 +132.521 +1 +130.247 +1 +130.444 +1 +132.707 +1 +130.45 +1 +128.839 +1 +130.482 +1 +128.053 +1 +131.268 +1 +131.775 +1 +136.262 +1 +132.001 +1 +128.959 +1 +131.933 +1 +134.486 +1 +134.757 +1 +136.604 +1 +137.697 +1 +136.537 +1 +138.208 +1 +140.562 +1 +135.826 +1 +137.46 +1 +141.528 +1 +139.025 +1 +O1s +CuO +2006 +2018 +2 +7 +31 +32 +0 +8 +Casa Info Follows +0 +0 +0 +0 +Sum of 43 spectra in column containing 43 scans + +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +4 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +3.808 +0 +0 +0 +0 +0 +O 1s + +-1 +kinetic energy +eV +946.61 +0.1 +2 +counts +d +Transmission +d +pulse counting +2.15 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +402 +7.30304 +286.567 +1 +1 +75.6189 +1 +78.3553 +1 +77.2469 +1 +74.0311 +1 +74.8343 +1 +74.8689 +1 +72.5596 +1 +72.1124 +1 +70.7395 +1 +70.6745 +1 +71.1402 +1 +69.5402 +1 +70.4369 +1 +73.6458 +1 +68.4267 +1 +68.3089 +1 +66.8737 +1 +67.6996 +1 +66.9152 +1 +68.1612 +1 +64.0221 +1 +63.2446 +1 +61.9821 +1 +61.754 +1 +63.6597 +1 +60.7669 +1 +60.6417 +1 +60.5864 +1 +60.6935 +1 +60.8121 +1 +61.0482 +1 +59.3073 +1 +58.41 +1 +57.979 +1 +57.2597 +1 +57.5439 +1 +56.3608 +1 +57.0951 +1 +57.571 +1 +56.8825 +1 +58.6615 +1 +57.9107 +1 +58.6714 +1 +56.9108 +1 +56.0123 +1 +58.177 +1 +58.4467 +1 +59.3652 +1 +58.8741 +1 +59.2108 +1 +62.241 +1 +58.2623 +1 +59.9347 +1 +57.0067 +1 +61.2252 +1 +58.9051 +1 +62.3306 +1 +63.8036 +1 +63.7483 +1 +63.4192 +1 +61.7928 +1 +62.772 +1 +62.7043 +1 +64.8545 +1 +64.7629 +1 +64.5501 +1 +65.3237 +1 +67.7428 +1 +69.539 +1 +67.8257 +1 +69.147 +1 +68.3173 +1 +68.4253 +1 +68.0212 +1 +67.6748 +1 +70.3665 +1 +71.0669 +1 +71.3539 +1 +73.6364 +1 +76.8029 +1 +77.4949 +1 +79.2785 +1 +85.3777 +1 +86.1962 +1 +91.4623 +1 +94.6358 +1 +97.6271 +1 +100.002 +1 +100.419 +1 +104.482 +1 +106.981 +1 +109.36 +1 +107.189 +1 +110.273 +1 +110.925 +1 +118.915 +1 +128.778 +1 +148.678 +1 +175.519 +1 +216.391 +1 +266.772 +1 +322.606 +1 +390.595 +1 +476.301 +1 +525.651 +1 +577.567 +1 +594.211 +1 +578.99 +1 +546.263 +1 +490.52 +1 +411.709 +1 +333.755 +1 +267.879 +1 +212.382 +1 +163.66 +1 +132.564 +1 +107.046 +1 +89.3767 +1 +74.3858 +1 +65.809 +1 +57.7779 +1 +51.2741 +1 +47.8722 +1 +45.2826 +1 +43.7934 +1 +41.8437 +1 +39.9669 +1 +41.0005 +1 +41.3929 +1 +38.0217 +1 +36.8735 +1 +39.9026 +1 +39.1054 +1 +36.3125 +1 +37.678 +1 +36.562 +1 +35.5846 +1 +36.0939 +1 +36.2625 +1 +35.5267 +1 +35.6649 +1 +35.3602 +1 +37.4223 +1 +35.4632 +1 +34.7641 +1 +35.1275 +1 +35.7889 +1 +34.9162 +1 +35.4501 +1 +33.904 +1 +34.5848 +1 +35.5198 +1 +34.8822 +1 +36.4113 +1 +35.3914 +1 +34.823 +1 +34.4587 +1 +38.1953 +1 +37.3613 +1 +36.3398 +1 +35.9673 +1 +36.4052 +1 +35.8963 +1 +34.5003 +1 +34.6988 +1 +34.9078 +1 +35.4176 +1 +34.0524 +1 +33.9091 +1 +33.3593 +1 +34.6576 +1 +37.0007 +1 +34.9766 +1 +33.6583 +1 +34.5632 +1 +34.2212 +1 +35.0464 +1 +35.3462 +1 +34.5007 +1 +33.4498 +1 +32.7378 +1 +33.7229 +1 +33.7248 +1 +33.8668 +1 +33.7461 +1 +32.0812 +1 +33.2511 +1 +33.1929 +1 +31.8947 +1 +33.8768 +1 +34.0777 +1 +34.2797 +1 +32.1901 +1 +33.374 +1 +32.6419 +1 +31.1142 +1 +33.1222 +1 +34.3858 +1 +31.8281 +1 +31.578 +1 +35.9976 +1 +Survey +CuO +2006 +2018 +2 +10 +32 +17 +0 +7 +Casa Info Follows +0 +0 +0 +0 +corrected with calibrated transmission function +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Cu(111) oxidation.vms +XPS +4 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +150 +1 +3.808 +0 +0 +0 +0 +0 +Survey + +-1 +kinetic energy +eV +286.61 +0.4 +2 +counts +d +Transmission +d +pulse counting +0.1 +1 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +6012 +13.1994 +3766.79 +1 +1 +19029.3 +1 +18636.8 +1 +19474.9 +1 +18586.3 +1 +18722.1 +1 +19585.6 +1 +18191.1 +1 +18883.5 +1 +18292.1 +1 +17986.7 +1 +17990.5 +1 +17996.7 +1 +18897.8 +1 +18814.9 +1 +18386.5 +1 +19030.1 +1 +19279.7 +1 +18525.5 +1 +19098.1 +1 +18695.1 +1 +19733.4 +1 +18825.8 +1 +19368.8 +1 +19364.1 +1 +18687.5 +1 +19038.4 +1 +18521.5 +1 +18536.2 +1 +18678.7 +1 +19480.2 +1 +19200.1 +1 +19469.9 +1 +18680 +1 +19692.6 +1 +19005.2 +1 +19170.3 +1 +19485.4 +1 +19901.4 +1 +19725.9 +1 +19626.6 +1 +19253.4 +1 +19825.2 +1 +19059.7 +1 +19531.1 +1 +19000 +1 +19014.3 +1 +19816.8 +1 +19333.4 +1 +19375.3 +1 +19838.6 +1 +18537.1 +1 +19130.5 +1 +19280 +1 +19957.2 +1 +20065.2 +1 +19647.6 +1 +18947.8 +1 +18896.9 +1 +18886.1 +1 +18908 +1 +19396.5 +1 +19279.2 +1 +19841.7 +1 +19744 +1 +19621.3 +1 +19760.5 +1 +19773.5 +1 +19340.9 +1 +20019 +1 +18945 +1 +19872.2 +1 +20163.6 +1 +19616.4 +1 +20166.7 +1 +19700.3 +1 +19928.1 +1 +20038.3 +1 +19919.7 +1 +19681.1 +1 +20064.9 +1 +19403.6 +1 +19685 +1 +19694.2 +1 +19945.5 +1 +19401.9 +1 +19824.4 +1 +20380.7 +1 +20047.3 +1 +19485.3 +1 +19448.5 +1 +19352.1 +1 +19721.9 +1 +20050.1 +1 +19820.2 +1 +20127.2 +1 +20295.1 +1 +20317.7 +1 +19403.7 +1 +19707.5 +1 +19928.7 +1 +19770 +1 +19350.7 +1 +20357.4 +1 +19909.2 +1 +20409.9 +1 +19889.4 +1 +20633.3 +1 +20042.2 +1 +20036.2 +1 +19649.8 +1 +19517.8 +1 +19889.9 +1 +20525.2 +1 +19916.3 +1 +19517.2 +1 +20337.2 +1 +19487.4 +1 +19881.5 +1 +20265.4 +1 +20156.2 +1 +20915.7 +1 +20336.2 +1 +21147 +1 +20690.1 +1 +20270 +1 +19720.8 +1 +20202.3 +1 +19937.7 +1 +20079.9 +1 +19764.1 +1 +19803.1 +1 +19472.3 +1 +20365.4 +1 +20998.7 +1 +20464 +1 +20089.1 +1 +20664 +1 +21317.3 +1 +21489.4 +1 +19770.2 +1 +19885.9 +1 +19976.6 +1 +20280 +1 +20281.7 +1 +20753.9 +1 +20924.4 +1 +20214.9 +1 +20550.6 +1 +20543.5 +1 +19795.9 +1 +20275.6 +1 +21611.1 +1 +20893.9 +1 +20313.2 +1 +20538.3 +1 +20546.7 +1 +20916.6 +1 +20890.4 +1 +20604.7 +1 +21402.7 +1 +21149.1 +1 +20570 +1 +20021.9 +1 +20749.5 +1 +20565 +1 +19689.2 +1 +20719.1 +1 +21115.1 +1 +20928.7 +1 +20859.1 +1 +20810.8 +1 +22150.8 +1 +20948.2 +1 +20572.9 +1 +20561.4 +1 +20617.4 +1 +21164 +1 +21054.4 +1 +21587 +1 +21136.6 +1 +21188.6 +1 +21506.8 +1 +20306 +1 +20805 +1 +21101.5 +1 +20689.2 +1 +20800.7 +1 +21264.7 +1 +21890.4 +1 +21929.7 +1 +20873.8 +1 +21483.6 +1 +21460.3 +1 +21377.1 +1 +21168.6 +1 +20786.4 +1 +21488.3 +1 +22181.3 +1 +21276.3 +1 +21446.4 +1 +21343.1 +1 +20756.5 +1 +21151.5 +1 +21330.6 +1 +21015.1 +1 +21024.4 +1 +21133.1 +1 +21097.4 +1 +20244.8 +1 +21211 +1 +21637.6 +1 +22528.4 +1 +22612.7 +1 +21726.8 +1 +21858.5 +1 +21464.4 +1 +21572.2 +1 +21951.9 +1 +21919.1 +1 +21921.3 +1 +21162 +1 +21634.3 +1 +21719.4 +1 +22358 +1 +22396.2 +1 +22136 +1 +22930.1 +1 +23878.7 +1 +23093.3 +1 +22015 +1 +23026 +1 +22527 +1 +22509.6 +1 +23131.5 +1 +23290.1 +1 +22785.9 +1 +24209.3 +1 +22666.5 +1 +23524.2 +1 +23671.4 +1 +23380.5 +1 +22844.9 +1 +23595 +1 +23442.4 +1 +22580.3 +1 +23004.8 +1 +24028.3 +1 +23593.9 +1 +23374.3 +1 +23573.7 +1 +23509 +1 +24173.1 +1 +24378.3 +1 +23700.9 +1 +24801.7 +1 +24299.9 +1 +23467.4 +1 +23492.4 +1 +23154.7 +1 +23200.2 +1 +23252.7 +1 +23836.4 +1 +23723.5 +1 +23518.8 +1 +23071.6 +1 +21918.3 +1 +22153.7 +1 +21812.4 +1 +21688.8 +1 +21287.5 +1 +21532.8 +1 +21330.9 +1 +21370.7 +1 +21223.2 +1 +21121 +1 +21094.6 +1 +21172.3 +1 +20470.6 +1 +20601.6 +1 +20383.5 +1 +20200.8 +1 +20079.1 +1 +21097.7 +1 +21307.2 +1 +20475.8 +1 +20046.2 +1 +20100.4 +1 +20759.5 +1 +21271.9 +1 +20605.9 +1 +21209 +1 +20632.7 +1 +20736.3 +1 +20400.4 +1 +20695.3 +1 +21251.5 +1 +20869.9 +1 +21204 +1 +21174 +1 +20192.8 +1 +20691.8 +1 +20932.5 +1 +20219.4 +1 +20033.9 +1 +20066 +1 +20468.6 +1 +20120.3 +1 +21166.8 +1 +21015.6 +1 +20058.4 +1 +21058.6 +1 +21703.4 +1 +20961.9 +1 +21153.4 +1 +20792.1 +1 +20768.2 +1 +20539.1 +1 +20508.8 +1 +20631.8 +1 +21261.6 +1 +20925.3 +1 +21226.2 +1 +20377.9 +1 +20435.8 +1 +20116.8 +1 +20648.5 +1 +21356.5 +1 +20094 +1 +20379.2 +1 +21097 +1 +20467 +1 +21076.1 +1 +20739.2 +1 +21152.2 +1 +21292.4 +1 +20833.3 +1 +20714.6 +1 +20376.7 +1 +21589.4 +1 +21333.3 +1 +20800.7 +1 +20828.9 +1 +21613.5 +1 +21189.5 +1 +21122.7 +1 +21636.8 +1 +21053.4 +1 +21322.4 +1 +22198.6 +1 +21847 +1 +20792.1 +1 +21273.6 +1 +21779.3 +1 +21054.9 +1 +20920.4 +1 +21204.6 +1 +21122.7 +1 +21410.5 +1 +21489.6 +1 +21720.8 +1 +22272.7 +1 +21993.4 +1 +21013.2 +1 +20518 +1 +20590 +1 +20614.9 +1 +21187.2 +1 +20782.6 +1 +20122.1 +1 +20194.2 +1 +20410.5 +1 +21355.7 +1 +21839.6 +1 +21819.7 +1 +21693.6 +1 +20522.1 +1 +21037.4 +1 +21502.9 +1 +21464.7 +1 +22091.6 +1 +21886.7 +1 +21176 +1 +21710.3 +1 +22099.2 +1 +21659.6 +1 +22591.3 +1 +21292.3 +1 +21366.1 +1 +21293 +1 +21342.3 +1 +22065.7 +1 +21482.6 +1 +21093.3 +1 +21792.9 +1 +21967.1 +1 +21634.6 +1 +21288.9 +1 +21919.6 +1 +21795.3 +1 +21840.7 +1 +21794.9 +1 +21733.8 +1 +21925.2 +1 +22406.2 +1 +22232.4 +1 +22664.5 +1 +21935.8 +1 +22104.5 +1 +22421 +1 +22644.6 +1 +21674.4 +1 +22605.5 +1 +22206.1 +1 +22738.7 +1 +23005.8 +1 +21984.3 +1 +22828.9 +1 +22157.3 +1 +22344.7 +1 +22199 +1 +22968.7 +1 +22025.6 +1 +21405.8 +1 +23020.4 +1 +22714.9 +1 +22350.1 +1 +21958.5 +1 +21699.8 +1 +21969.8 +1 +22159.8 +1 +22513.5 +1 +23190.7 +1 +22356 +1 +22114.1 +1 +22685.9 +1 +22194 +1 +22266.8 +1 +22959.2 +1 +22707.2 +1 +22631 +1 +22785.1 +1 +22559.2 +1 +22031.9 +1 +22568.4 +1 +22663 +1 +23067.1 +1 +22781.6 +1 +22873.2 +1 +22717.2 +1 +23019.7 +1 +22464.8 +1 +23398.2 +1 +23034.2 +1 +22500.4 +1 +22646 +1 +22867.5 +1 +22610.7 +1 +21957.3 +1 +22792.2 +1 +23625.4 +1 +23174.8 +1 +23832 +1 +23587.2 +1 +23490.8 +1 +22797.3 +1 +23624.7 +1 +24122 +1 +24093.9 +1 +23827 +1 +23841.9 +1 +22931.9 +1 +23129.6 +1 +24247.1 +1 +24355.1 +1 +24179.6 +1 +24033.6 +1 +24406 +1 +24219.3 +1 +23774.1 +1 +23649.7 +1 +24084.2 +1 +24571.3 +1 +24340 +1 +24236.7 +1 +23966.9 +1 +23962.9 +1 +24063.9 +1 +24689.3 +1 +24502.4 +1 +23973.2 +1 +23063.7 +1 +22896.5 +1 +24012 +1 +24435.4 +1 +23156.5 +1 +23474.3 +1 +24039 +1 +24825.9 +1 +24459.3 +1 +24146.8 +1 +23968.1 +1 +24080.2 +1 +24444.1 +1 +24217.8 +1 +25192.7 +1 +24573.7 +1 +24099.8 +1 +23721.6 +1 +24019 +1 +25127.7 +1 +25629.7 +1 +25844.8 +1 +25845.8 +1 +25534.5 +1 +25149.1 +1 +24579.8 +1 +25403.7 +1 +25365.3 +1 +25822.3 +1 +25012.1 +1 +24543 +1 +25157.6 +1 +23692.5 +1 +24465.9 +1 +24419 +1 +24575 +1 +25007.8 +1 +24948.1 +1 +25470.6 +1 +25828.2 +1 +25460.6 +1 +25772.9 +1 +25824.7 +1 +25279.1 +1 +25327.8 +1 +25542.6 +1 +25497.3 +1 +25547 +1 +25054.3 +1 +24745.9 +1 +25440.8 +1 +25010 +1 +24785.7 +1 +24372.4 +1 +25851.9 +1 +26674.5 +1 +25450.5 +1 +25302.1 +1 +24425.7 +1 +24941.4 +1 +24864.7 +1 +25512.4 +1 +25646.2 +1 +25783.9 +1 +26429.5 +1 +26592.7 +1 +26273.2 +1 +26757.5 +1 +27597.9 +1 +26990.5 +1 +27680.1 +1 +27445 +1 +28002.9 +1 +27596.8 +1 +28131.8 +1 +28800.6 +1 +28876.4 +1 +28776 +1 +28055.9 +1 +28194.4 +1 +27369.3 +1 +27451.2 +1 +26714 +1 +26877.8 +1 +26933.1 +1 +26815 +1 +26747.5 +1 +26815.7 +1 +26525.6 +1 +25838 +1 +25702.5 +1 +25990.2 +1 +26008.2 +1 +26014.4 +1 +26258.3 +1 +26107.4 +1 +26117.1 +1 +26807.7 +1 +27076.3 +1 +27339 +1 +28402.1 +1 +29475.6 +1 +30635.9 +1 +32121.1 +1 +32890.5 +1 +33935.6 +1 +33654.1 +1 +33396.1 +1 +33155.8 +1 +30905 +1 +29055.8 +1 +27533.7 +1 +26860.1 +1 +26455.5 +1 +26046.5 +1 +26413.1 +1 +26277.3 +1 +26173.1 +1 +26642.4 +1 +28944.1 +1 +28570.3 +1 +29815.6 +1 +29884.5 +1 +31089.6 +1 +32681.9 +1 +34310.6 +1 +34729.3 +1 +33960.2 +1 +34945.7 +1 +32465.5 +1 +30618.2 +1 +29332 +1 +27882.6 +1 +25551.1 +1 +24278.7 +1 +23848.8 +1 +23098.5 +1 +23033.3 +1 +21909.6 +1 +21491 +1 +21287.2 +1 +21513 +1 +22213.9 +1 +21650.3 +1 +22171 +1 +22412.9 +1 +23033.6 +1 +25877.8 +1 +25989.6 +1 +27727 +1 +29070 +1 +31283.1 +1 +31964.5 +1 +32256.8 +1 +33573.2 +1 +34841.1 +1 +34270.4 +1 +32815.5 +1 +32541.1 +1 +31223.8 +1 +29984.8 +1 +28270.6 +1 +26349.2 +1 +26090.3 +1 +24460.8 +1 +23986.1 +1 +23751.7 +1 +24479.4 +1 +25803.7 +1 +27138.9 +1 +29646.2 +1 +32254.8 +1 +35507.9 +1 +38459.6 +1 +41676.3 +1 +43851.9 +1 +45425.6 +1 +43834.5 +1 +42958.6 +1 +40007.2 +1 +34890.9 +1 +30225.2 +1 +25809.8 +1 +21626.6 +1 +18957 +1 +16896.6 +1 +15539.3 +1 +15982.2 +1 +15345.7 +1 +13745.4 +1 +14425.1 +1 +13948.8 +1 +13976.9 +1 +13654 +1 +13771.5 +1 +13402.4 +1 +13396.8 +1 +13845.6 +1 +13702 +1 +14098.6 +1 +13981.4 +1 +13945 +1 +13581.8 +1 +12618.6 +1 +12835.7 +1 +12650.6 +1 +13443.4 +1 +13785.2 +1 +12896.3 +1 +13308.9 +1 +13916.1 +1 +13411.4 +1 +13433.8 +1 +12828 +1 +12288.8 +1 +12681.2 +1 +13477.2 +1 +12832.8 +1 +13209.4 +1 +12684.8 +1 +13141.9 +1 +12955.2 +1 +13527.3 +1 +13412.7 +1 +12608.5 +1 +13113.2 +1 +13210.4 +1 +13461.6 +1 +13419.3 +1 +12401.9 +1 +13190.9 +1 +13288.6 +1 +13369.1 +1 +13181.2 +1 +13516.1 +1 +12861.2 +1 +12796.5 +1 +12726.9 +1 +13265.7 +1 +13341.4 +1 +13145.7 +1 +13821.5 +1 +13731.4 +1 +12997.3 +1 +13374.4 +1 +13567.2 +1 +13345.6 +1 +13387.9 +1 +12767.7 +1 +12728.2 +1 +13242.3 +1 +13378 +1 +13390.2 +1 +13190.7 +1 +12985.3 +1 +12736.5 +1 +13384.1 +1 +13293.1 +1 +13851.4 +1 +13793.1 +1 +13324.4 +1 +13984 +1 +13465.3 +1 +13423 +1 +13429.8 +1 +13899 +1 +13834.8 +1 +13188 +1 +13297.1 +1 +13712 +1 +13362.3 +1 +13615.5 +1 +13125.5 +1 +13051.1 +1 +13736.4 +1 +13644.9 +1 +13445.9 +1 +13650.7 +1 +13597.4 +1 +13167.7 +1 +13230.3 +1 +13195.3 +1 +13186 +1 +13275.4 +1 +13765.6 +1 +13273.4 +1 +13332.1 +1 +13854.7 +1 +13436.5 +1 +13412.3 +1 +13281.8 +1 +13660.8 +1 +12920.1 +1 +13776.9 +1 +14040.7 +1 +13786.8 +1 +13967.2 +1 +14141.1 +1 +13376.9 +1 +13558.5 +1 +14282.1 +1 +14021.3 +1 +13907 +1 +13390.4 +1 +12767.6 +1 +13898.3 +1 +13943.7 +1 +13835.5 +1 +13757.7 +1 +14032.8 +1 +13192.4 +1 +13903.3 +1 +13983.5 +1 +13287.6 +1 +13788.1 +1 +13756 +1 +13707 +1 +13509.3 +1 +13689.9 +1 +14009.3 +1 +14128 +1 +14076.1 +1 +14107.2 +1 +13820.9 +1 +14211.5 +1 +13852.8 +1 +13677.8 +1 +14486.7 +1 +14045.5 +1 +14357.3 +1 +14163.8 +1 +14125.4 +1 +14201.9 +1 +14306.6 +1 +13943.9 +1 +13927.4 +1 +13403.2 +1 +13654.8 +1 +14008.1 +1 +13724.4 +1 +13926 +1 +13721.1 +1 +14095.8 +1 +14079.8 +1 +13967.4 +1 +14676.7 +1 +13976.2 +1 +13834.2 +1 +14359.5 +1 +13683 +1 +14296.1 +1 +14086 +1 +14244.1 +1 +13971.4 +1 +13774.2 +1 +13984.3 +1 +14692.5 +1 +14249.4 +1 +13895.8 +1 +14440.4 +1 +14493.6 +1 +14252.4 +1 +14140.7 +1 +14249.3 +1 +15089.2 +1 +14795.2 +1 +14844.6 +1 +14824.6 +1 +15061.5 +1 +14666 +1 +14029.3 +1 +14020.1 +1 +14664.6 +1 +14558.8 +1 +14471.7 +1 +13930 +1 +14426.1 +1 +15086.4 +1 +14728 +1 +14783 +1 +14794.2 +1 +14658.5 +1 +14529.1 +1 +14755.2 +1 +14693.9 +1 +14496.3 +1 +14620.3 +1 +14331.9 +1 +14013.1 +1 +14494.8 +1 +14695.3 +1 +14273.6 +1 +14415.4 +1 +14843 +1 +14484 +1 +14930.8 +1 +14908.4 +1 +14701.5 +1 +14114.4 +1 +14375 +1 +14704.8 +1 +14789.4 +1 +14857 +1 +14577.8 +1 +14177.5 +1 +14760.8 +1 +14604.3 +1 +14671.6 +1 +15223.2 +1 +14958.5 +1 +14934.6 +1 +14598 +1 +14805.4 +1 +14604.4 +1 +15012.1 +1 +15153.9 +1 +14853.8 +1 +15686.5 +1 +15197.5 +1 +14224 +1 +14876.5 +1 +14717.9 +1 +14561.1 +1 +14892.6 +1 +15283 +1 +15340.6 +1 +15207.5 +1 +15228.1 +1 +15033.5 +1 +15601.9 +1 +15740.4 +1 +15341.8 +1 +15237 +1 +15483.4 +1 +15088.9 +1 +14773.9 +1 +15409.3 +1 +15137.1 +1 +14439.3 +1 +15350.4 +1 +15494.2 +1 +15250 +1 +14837.7 +1 +15528.8 +1 +14975.2 +1 +15400.4 +1 +15505.9 +1 +15687.4 +1 +15287.3 +1 +15267.1 +1 +15666.1 +1 +15452.1 +1 +15176 +1 +15821 +1 +16090.7 +1 +15068.4 +1 +15537.2 +1 +15357.4 +1 +15687.1 +1 +15207.7 +1 +15279.7 +1 +15473.3 +1 +15686.5 +1 +15687.6 +1 +15197.5 +1 +15299.6 +1 +15116.3 +1 +15954.9 +1 +16013.4 +1 +15875.6 +1 +15809.3 +1 +15981.9 +1 +15723.4 +1 +15589.1 +1 +15686.2 +1 +15268.2 +1 +15647.5 +1 +15696.4 +1 +15460.4 +1 +16006.6 +1 +15890.3 +1 +15733.1 +1 +15778.3 +1 +16053.5 +1 +15814.6 +1 +15972.1 +1 +15927.5 +1 +15859.6 +1 +16606 +1 +15905.7 +1 +15897.1 +1 +15451.2 +1 +15828.9 +1 +16194.7 +1 +16348.9 +1 +15933.3 +1 +16385.7 +1 +15757.8 +1 +16065.1 +1 +15782.8 +1 +16798 +1 +16195.4 +1 +16515 +1 +16270.1 +1 +16218.6 +1 +16141.4 +1 +16669.4 +1 +16186 +1 +16150.3 +1 +16095.9 +1 +16096.8 +1 +16425.9 +1 +16436.3 +1 +16450 +1 +16494.7 +1 +15938.3 +1 +16060.9 +1 +16259.2 +1 +16347.3 +1 +16643.7 +1 +16771.1 +1 +15962.1 +1 +16526.8 +1 +16425.6 +1 +16257.7 +1 +16309.4 +1 +16149.5 +1 +16315.5 +1 +16613.6 +1 +16913.9 +1 +16838.3 +1 +16423.8 +1 +16662 +1 +16498.3 +1 +16434.9 +1 +16517 +1 +16452.2 +1 +16372.7 +1 +16439.9 +1 +17232.2 +1 +16891.6 +1 +16867.4 +1 +16551.7 +1 +17265.8 +1 +17132.6 +1 +16272.3 +1 +16394 +1 +16509.6 +1 +16634.6 +1 +16738.9 +1 +16456.8 +1 +16493.2 +1 +17250.2 +1 +17027.8 +1 +17333.3 +1 +17059.1 +1 +16989.3 +1 +17426.8 +1 +17134.1 +1 +17374.5 +1 +16920.6 +1 +17708.5 +1 +16989 +1 +16769.3 +1 +16804.3 +1 +16779.9 +1 +17702.3 +1 +17655.4 +1 +17950 +1 +17190 +1 +17725.5 +1 +17593 +1 +17730.6 +1 +17796.1 +1 +17847.8 +1 +17677 +1 +18113.7 +1 +17641.7 +1 +17032.9 +1 +17740.9 +1 +17565.4 +1 +17837.3 +1 +17810 +1 +18384.5 +1 +18526.6 +1 +17605.9 +1 +17713 +1 +17864.4 +1 +18862.8 +1 +18267.9 +1 +17914.9 +1 +17854.5 +1 +17732.8 +1 +17939.9 +1 +17399.6 +1 +17197.6 +1 +17840.9 +1 +17921.5 +1 +18345 +1 +18236.1 +1 +17876.1 +1 +18534.5 +1 +18203.1 +1 +18399 +1 +17471.1 +1 +17728.8 +1 +17918.3 +1 +17937.5 +1 +18270.9 +1 +17930.6 +1 +18336.2 +1 +18354.9 +1 +18266.2 +1 +18210.3 +1 +18302.4 +1 +18620.7 +1 +19000.6 +1 +18308.3 +1 +18545.8 +1 +18305.8 +1 +18114.1 +1 +18293 +1 +18482.3 +1 +18100 +1 +18746.2 +1 +18161.3 +1 +18484.7 +1 +18087.4 +1 +17930.1 +1 +18615.4 +1 +18275.3 +1 +18333 +1 +18208.6 +1 +18786.7 +1 +18316.2 +1 +17973.5 +1 +18051.7 +1 +17966.9 +1 +18376.5 +1 +18176.8 +1 +17885.4 +1 +17648.4 +1 +17671.8 +1 +18130.1 +1 +17886.6 +1 +17284.4 +1 +17578.8 +1 +18289.5 +1 +18425 +1 +17736.1 +1 +18038.8 +1 +18196.5 +1 +18620.9 +1 +18459.2 +1 +18158.7 +1 +18120.7 +1 +18030.7 +1 +18157.8 +1 +18116.9 +1 +18036.7 +1 +18281.6 +1 +18298.1 +1 +18994.2 +1 +18757.4 +1 +18785.6 +1 +18649.1 +1 +19036.9 +1 +18711 +1 +18575.6 +1 +18821.3 +1 +19274.2 +1 +18878.1 +1 +18977.6 +1 +19324.9 +1 +19180.3 +1 +19150.4 +1 +19380 +1 +19284.9 +1 +18752.4 +1 +19157.3 +1 +19495.9 +1 +18816.6 +1 +19114.3 +1 +19233.8 +1 +19711.9 +1 +19242.9 +1 +19731.4 +1 +20055.8 +1 +19727.7 +1 +20289.3 +1 +19960.3 +1 +19473.6 +1 +19297.6 +1 +19430.8 +1 +19469.4 +1 +19848.7 +1 +20210.7 +1 +20111.3 +1 +19872.7 +1 +20623.7 +1 +20619.3 +1 +20394.9 +1 +20641 +1 +20920.9 +1 +20554.4 +1 +20962 +1 +21173.2 +1 +21310.5 +1 +21229.1 +1 +21358.5 +1 +20933.5 +1 +21126.3 +1 +21778.5 +1 +21606.6 +1 +20927.9 +1 +21887.2 +1 +21798 +1 +21131.8 +1 +20986.8 +1 +20279.2 +1 +21005 +1 +20969.7 +1 +20541.3 +1 +20394.8 +1 +20358.1 +1 +20277.8 +1 +20637.6 +1 +20668.1 +1 +20127.4 +1 +19516.5 +1 +19975.3 +1 +19559.7 +1 +19577.7 +1 +19270.2 +1 +18802.8 +1 +18885.1 +1 +18967.4 +1 +18616 +1 +18134.5 +1 +18027.3 +1 +17579.3 +1 +17986.9 +1 +17439.1 +1 +17093.9 +1 +17209.4 +1 +17042.8 +1 +17054.6 +1 +16864.1 +1 +16347.7 +1 +16588.1 +1 +16781.5 +1 +17285.9 +1 +16937.5 +1 +16835.5 +1 +16974 +1 +16537.1 +1 +17383 +1 +17244.5 +1 +16774 +1 +16517.7 +1 +16633 +1 +16761.5 +1 +16869.9 +1 +17199.3 +1 +16823.9 +1 +17129.3 +1 +16788.8 +1 +16562.2 +1 +16311.4 +1 +16555.1 +1 +16190.1 +1 +15856 +1 +15821.9 +1 +16139.5 +1 +16144.6 +1 +16246.1 +1 +15863.3 +1 +16016.4 +1 +15876.5 +1 +16330.2 +1 +16566.5 +1 +15727.7 +1 +15825.2 +1 +16331.8 +1 +16290.9 +1 +16116.4 +1 +14943.6 +1 +15991.8 +1 +15912.7 +1 +16107 +1 +16406.9 +1 +15816.2 +1 +15587.4 +1 +15312 +1 +15343 +1 +15413.2 +1 +15034 +1 +15641.3 +1 +15379.2 +1 +15089.7 +1 +15260.2 +1 +15288.3 +1 +15240.3 +1 +15017.7 +1 +15169.2 +1 +15627.2 +1 +15826.7 +1 +15662.6 +1 +15604.1 +1 +15221.8 +1 +15680 +1 +15795.3 +1 +15529.8 +1 +15492.7 +1 +15670.2 +1 +15478.8 +1 +15416.4 +1 +15481 +1 +14906.7 +1 +15796.2 +1 +15621.6 +1 +15778.6 +1 +15870.1 +1 +15892.9 +1 +15584.6 +1 +15705.5 +1 +15658.9 +1 +15955.4 +1 +15771.4 +1 +16292.9 +1 +16484.7 +1 +15955 +1 +16488.5 +1 +16882.2 +1 +16209 +1 +16511.2 +1 +16706.4 +1 +16618.1 +1 +16170 +1 +16418.8 +1 +16156.6 +1 +16087 +1 +16337 +1 +16563.5 +1 +16141.5 +1 +15717.5 +1 +16630.9 +1 +16652 +1 +16348 +1 +16544.4 +1 +16815.1 +1 +16896 +1 +16701.9 +1 +16978.8 +1 +17187.5 +1 +17843.8 +1 +17055.1 +1 +17458 +1 +17589.7 +1 +17799.1 +1 +18007.2 +1 +18020.3 +1 +18164.6 +1 +18865.4 +1 +18045.7 +1 +18056.9 +1 +18558.2 +1 +18170.2 +1 +18491.1 +1 +18116.1 +1 +18203 +1 +18697.2 +1 +18364.9 +1 +18431.9 +1 +19249.7 +1 +18371.3 +1 +18216.9 +1 +19119.6 +1 +19321 +1 +18890.1 +1 +19246.8 +1 +19471.7 +1 +19867.5 +1 +20001.6 +1 +21027.9 +1 +21394.9 +1 +21964.6 +1 +21795.6 +1 +22226.2 +1 +21879.5 +1 +21749.7 +1 +21347.6 +1 +21368.2 +1 +20804.4 +1 +20139 +1 +19953.1 +1 +19462.8 +1 +19348.4 +1 +18967.4 +1 +18537.4 +1 +18178.8 +1 +17611.8 +1 +18517.5 +1 +18755 +1 +18351.9 +1 +18794.5 +1 +18924.8 +1 +18618.9 +1 +18662.7 +1 +19108.5 +1 +19127.1 +1 +18495 +1 +17897.8 +1 +17301.9 +1 +16662.1 +1 +16612.4 +1 +16015.3 +1 +15937 +1 +15934.1 +1 +15311.9 +1 +14840.4 +1 +14735.8 +1 +14423.9 +1 +14368.2 +1 +13983.1 +1 +14142.4 +1 +14162.1 +1 +14238.1 +1 +14272.1 +1 +14177.9 +1 +14607.7 +1 +15024 +1 +14111.9 +1 +13954.7 +1 +14249 +1 +14410.4 +1 +14970.6 +1 +14213.8 +1 +14059 +1 +14414.9 +1 +13818.6 +1 +13343.2 +1 +13583.1 +1 +13583.4 +1 +13027 +1 +12602.3 +1 +12968.7 +1 +13696.4 +1 +12792.5 +1 +12592.2 +1 +12600.5 +1 +12187.5 +1 +11848.7 +1 +11771.1 +1 +12524.7 +1 +12327.9 +1 +12161.4 +1 +12576.9 +1 +12234.2 +1 +12369.8 +1 +11766.2 +1 +11686.3 +1 +11691.1 +1 +11687.9 +1 +11847.7 +1 +11227.8 +1 +11835.8 +1 +11879.2 +1 +11815.1 +1 +11099.6 +1 +11749.7 +1 +11433.1 +1 +10993.2 +1 +11376.2 +1 +11204.3 +1 +10840.6 +1 +10901.4 +1 +11410.7 +1 +11087.2 +1 +10541.1 +1 +10878.9 +1 +11549.2 +1 +11601.5 +1 +11482.5 +1 +11220.9 +1 +10996.2 +1 +10991.2 +1 +11100.8 +1 +11372.2 +1 +11502.6 +1 +11242 +1 +11383 +1 +11926.2 +1 +11767.8 +1 +11464.8 +1 +11367.8 +1 +12181.9 +1 +11719.3 +1 +11392.4 +1 +11205.6 +1 +12038.6 +1 +11687.9 +1 +11672.7 +1 +11641.3 +1 +11837.4 +1 +11710.7 +1 +12081.5 +1 +11866.5 +1 +11760.5 +1 +11359.4 +1 +11614 +1 +11490.9 +1 +11838.2 +1 +11757.7 +1 +12169.6 +1 +11833.9 +1 +11735.8 +1 +12198.6 +1 +12790.8 +1 +12434.4 +1 +12106.9 +1 +12034.1 +1 +12034.6 +1 +12100.2 +1 +12182.3 +1 +11989.5 +1 +12153.7 +1 +12219.2 +1 +12250.1 +1 +12563.8 +1 +12768 +1 +12848 +1 +12655.6 +1 +12561.7 +1 +12097.9 +1 +12531.1 +1 +12535.7 +1 +12616.7 +1 +12934.9 +1 +12971.7 +1 +12718.7 +1 +12676.7 +1 +13012.4 +1 +13054.6 +1 +13006.7 +1 +12791.6 +1 +13169.4 +1 +13064.8 +1 +12939 +1 +13052.3 +1 +13541.5 +1 +14216.7 +1 +13793 +1 +13606 +1 +13630.5 +1 +14030.9 +1 +13985 +1 +14015.5 +1 +14704.9 +1 +15006.6 +1 +14842 +1 +14258.8 +1 +15244.5 +1 +15495 +1 +15691.9 +1 +15718.4 +1 +16089.4 +1 +16343.6 +1 +16394.1 +1 +17307.9 +1 +18286.4 +1 +18192.7 +1 +18217.7 +1 +18179.1 +1 +18913.9 +1 +18633 +1 +18616.3 +1 +18789.8 +1 +19096.9 +1 +19128.2 +1 +19371.3 +1 +19721.2 +1 +20152.9 +1 +20599.9 +1 +21629.8 +1 +22298.6 +1 +23968 +1 +25148.6 +1 +24810.9 +1 +25391.5 +1 +23967 +1 +23404 +1 +21520.8 +1 +19537.6 +1 +18220.2 +1 +17367.8 +1 +15843.2 +1 +15016.6 +1 +14646.9 +1 +13473.8 +1 +13435.9 +1 +12903.7 +1 +12443 +1 +12254.9 +1 +11698.1 +1 +11459.2 +1 +10970.6 +1 +10581.1 +1 +10346.8 +1 +10217.4 +1 +10174.8 +1 +10010.3 +1 +9975.97 +1 +9997.81 +1 +9549.78 +1 +9098.26 +1 +8899.63 +1 +8848.23 +1 +8758.84 +1 +8851.63 +1 +8693.44 +1 +8393.22 +1 +8712.9 +1 +9039.07 +1 +9113.93 +1 +9211.92 +1 +9543.73 +1 +8892.44 +1 +8836.66 +1 +8758.87 +1 +8549.66 +1 +8529.37 +1 +8734.46 +1 +9258.36 +1 +9178.51 +1 +8937.55 +1 +9523.73 +1 +9670.82 +1 +9679.08 +1 +9389.48 +1 +9286.77 +1 +8571 +1 +8410.88 +1 +7944.79 +1 +7292.3 +1 +6773.01 +1 +6867.69 +1 +6423.54 +1 +6114.58 +1 +6353.16 +1 +5939.85 +1 +5667.32 +1 +5651.61 +1 +5674.72 +1 +5333.4 +1 +5338.66 +1 +5181.01 +1 +4975.69 +1 +5063.23 +1 +5076.72 +1 +5061.58 +1 +4760.4 +1 +4821.79 +1 +4550.64 +1 +4209.27 +1 +4380.54 +1 +4127.61 +1 +3871.14 +1 +3635.97 +1 +3890.74 +1 +4165.01 +1 +4035.35 +1 +3932.17 +1 +4099.88 +1 +4297.97 +1 +4427.79 +1 +4428.44 +1 +4494.29 +1 +4944.13 +1 +5716.67 +1 +5716.1 +1 +6832.24 +1 +8459.91 +1 +10804.1 +1 +13716.7 +1 +16111.6 +1 +17653 +1 +16253 +1 +14242.7 +1 +12542.2 +1 +10028.4 +1 +7129.44 +1 +5130.39 +1 +3799.88 +1 +3207.15 +1 +2728.52 +1 +2620.67 +1 +2520.38 +1 +2519.43 +1 +2482.28 +1 +2340.96 +1 +2495.17 +1 +2336.85 +1 +2383.69 +1 +2362.32 +1 +2189.61 +1 +2238.7 +1 +2119.17 +1 +2005.6 +1 +2348.64 +1 +2308.88 +1 +2205.2 +1 +2293.28 +1 +2152.25 +1 +2242.03 +1 +2328.28 +1 +2272.06 +1 +2344.91 +1 +2191.58 +1 +2152.64 +1 +2228.17 +1 +2310.65 +1 +2324.92 +1 +1988.99 +1 +2045.22 +1 +2162.79 +1 +2150.39 +1 +2149.04 +1 +2117.08 +1 +2029.51 +1 +2173.35 +1 +2002.48 +1 +2228.08 +1 +2221.7 +1 +2087.13 +1 +2060.9 +1 +2146.25 +1 +2170.16 +1 +2168.43 +1 +2221.56 +1 +2174.72 +1 +2273.31 +1 +2130.98 +1 +2027.38 +1 +2260.61 +1 +1972.38 +1 +2218.54 +1 +2048.75 +1 +2245.28 +1 +2197.98 +1 +2127.58 +1 +2238.22 +1 +2206.63 +1 +2086.73 +1 +2359.13 +1 +2214.27 +1 +2158.38 +1 +2275.11 +1 +2179.37 +1 +2188.87 +1 +1997.69 +1 +2088.84 +1 +2005.31 +1 +2179.65 +1 +2338.12 +1 +2225.62 +1 +2412.51 +1 +2274.72 +1 +2170.2 +1 +2120.41 +1 +2112.62 +1 +1911.34 +1 +2254.36 +1 +2254.06 +1 +2374.63 +1 +2314.35 +1 +2207.08 +1 +2083.64 +1 +2098.32 +1 +2097.2 +1 +2297.29 +1 +2141.7 +1 +1868.54 +1 +2146.95 +1 +2138.69 +1 +2132.29 +1 +2031.47 +1 +2021.49 +1 +2100.67 +1 +1992.58 +1 +2110.22 +1 +2032.07 +1 +2241.96 +1 +2203.82 +1 +2253.83 +1 +2180.67 +1 +2109.67 +1 +2243.81 +1 +2157.73 +1 +2228.01 +1 +2103.3 +1 +2158.23 +1 +2240.68 +1 +2136.67 +1 +2166.68 +1 +2286.03 +1 +2067.75 +1 +2007.26 +1 +2066.01 +1 +2134.31 +1 +2088.08 +1 +1977.14 +1 +2030.24 +1 +2089.47 +1 +2271.26 +1 +2137.76 +1 +2024.16 +1 +2295.03 +1 +2085.02 +1 +2202.25 +1 +2082.9 +1 +2281.61 +1 +2080.35 +1 +2178.48 +1 +2288.64 +1 +2249.13 +1 +1961.33 +1 +2194.78 +1 +2021.98 +1 +2174.48 +1 +2165.4 +1 +2249.09 +1 +2167.39 +1 +2130.86 +1 +2242.61 +1 +2120.88 +1 +2157.1 +1 +2109.2 +1 +2095.82 +1 +2151.52 +1 +2246.29 +1 +2145.83 +1 +2196.11 +1 +2175.3 +1 +2159.43 +1 +2020.15 +1 +2067.97 +1 +2129.11 +1 +2105.99 +1 +2267.97 +1 +2452.67 +1 +2205.5 +1 +2183.39 +1 +2172.68 +1 +2182.85 +1 +2296.36 +1 +2157.1 +1 +2030.84 +1 +2308.23 +1 +2114.53 +1 +1923.93 +1 +2094.97 +1 +2182.68 +1 +2000.08 +1 +2160.7 +1 +2089.95 +1 +2249.61 +1 +2116.59 +1 +2148.7 +1 +2136.71 +1 +2245.54 +1 +2142.83 +1 +2093.89 +1 +2165.85 +1 +2162.07 +1 +2195.21 +1 +2026.19 +1 +2141.5 +1 +2229.99 +1 +2188.44 +1 +2109.92 +1 +2170.87 +1 +2463.75 +1 +2117.53 +1 +2279.68 +1 +2303.43 +1 +2053.5 +1 +2186.57 +1 +2229.17 +1 +2135.2 +1 +2142.88 +1 +2406.89 +1 +2275.6 +1 +2078.83 +1 +2127.18 +1 +2090.62 +1 +1986.38 +1 +2173.83 +1 +2240.78 +1 +2334.66 +1 +2416.36 +1 +2327.22 +1 +2344.43 +1 +2178.21 +1 +2212.99 +1 +2306.58 +1 +2278.78 +1 +2118.7 +1 +2156.14 +1 +2382.98 +1 +2060.15 +1 +2299.19 +1 +2205.86 +1 +2038.31 +1 +2185.41 +1 +2106.1 +1 +2067.66 +1 +2242.29 +1 +2320.75 +1 +2418.21 +1 +2371.38 +1 +2125.56 +1 +2232.07 +1 +2217.48 +1 +2183.7 +1 +2197.07 +1 +2338.37 +1 +2503.17 +1 +2351.25 +1 +2241.43 +1 +2259.32 +1 +2399.13 +1 +2237.58 +1 +2066.51 +1 +2268.19 +1 +2397.95 +1 +2370.16 +1 +2229.21 +1 +2358.46 +1 +2291.51 +1 +2282.49 +1 +2455.52 +1 +2383.63 +1 +2015.28 +1 +2173.23 +1 +2342.8 +1 +2152.93 +1 +2345.11 +1 +2192.71 +1 +2333.39 +1 +2348.76 +1 +2443.9 +1 +2300.45 +1 +2130.54 +1 +2234.16 +1 +2285.09 +1 +2322.77 +1 +2119.77 +1 +2288.08 +1 +2510.51 +1 +2300.22 +1 +2314.12 +1 +2407.55 +1 +2377.18 +1 +2401.93 +1 +2316.06 +1 +2262.98 +1 +2185.53 +1 +2339.6 +1 +2479.72 +1 +2388.69 +1 +2382.24 +1 +2423.2 +1 +2438.17 +1 +2441.98 +1 +2152.16 +1 +2287.42 +1 +2318.93 +1 +2497.7 +1 +2428.25 +1 +2414.73 +1 +2497.18 +1 +2358.58 +1 +2529.55 +1 +2409.14 +1 +2346 +1 +2342.08 +1 +2320.7 +1 +2365.49 +1 +2192.11 +1 +2400.02 +1 +2455.09 +1 +2443.5 +1 +2379.61 +1 +2470.79 +1 +2525.23 +1 +2353.73 +1 +2302.72 +1 +2521.71 +1 +2313.83 +1 +2465.62 +1 +2556.49 +1 +2308.93 +1 +2577.95 +1 +2399.1 +1 +2493.04 +1 +2431.14 +1 +2444.78 +1 +2380.04 +1 +2324.26 +1 +2330.73 +1 +2228.89 +1 +2206.98 +1 +2369.99 +1 +2247.5 +1 +2530.3 +1 +2399.75 +1 +2282.9 +1 +2105.14 +1 +2252.25 +1 +2462.84 +1 +2264.18 +1 +2210.31 +1 +2466.54 +1 +2291.71 +1 +2445.06 +1 +2562.28 +1 +2399.58 +1 +2151.94 +1 +2257.42 +1 +2381.65 +1 +2348.03 +1 +2134.8 +1 +2327.82 +1 +2295.13 +1 +2170.69 +1 +2499.66 +1 +2247.64 +1 +2217.3 +1 +2452.38 +1 +2583.34 +1 +2338.96 +1 +2256.67 +1 +2309.72 +1 +2144.53 +1 +2290.21 +1 +2354.59 +1 +2363.19 +1 +2371.69 +1 +2329.15 +1 +2611.34 +1 +2353.34 +1 +2394.76 +1 +2178.77 +1 +2365.37 +1 +2331.05 +1 +2433.25 +1 +2175.08 +1 +2396.43 +1 +2333.95 +1 +2371.77 +1 +2240.39 +1 +2267.35 +1 +2381.57 +1 +2425.39 +1 +2480.21 +1 +2415.17 +1 +2562.4 +1 +2398.48 +1 +2423.76 +1 +2382.9 +1 +2521.58 +1 +2515.06 +1 +2522 +1 +2437.94 +1 +2363.12 +1 +2482.66 +1 +2314.24 +1 +2179.83 +1 +2156.03 +1 +2408.04 +1 +2272.73 +1 +2321.3 +1 +2499.05 +1 +2411.47 +1 +2365.38 +1 +2510.49 +1 +2283.06 +1 +2373.96 +1 +2550.06 +1 +2558.2 +1 +2338.22 +1 +2489.25 +1 +2467.61 +1 +2503.18 +1 +2512.12 +1 +2365.53 +1 +2413.74 +1 +2461.96 +1 +2361.45 +1 +2493.53 +1 +2403.67 +1 +2402.42 +1 +2481.94 +1 +2444.85 +1 +2234.4 +1 +2351.92 +1 +2504.2 +1 +2496.49 +1 +2594.19 +1 +2548.4 +1 +2403.01 +1 +2500.39 +1 +2265.38 +1 +2335.27 +1 +2325.9 +1 +2598.73 +1 +2729.8 +1 +2375.46 +1 +2400.16 +1 +2289.01 +1 +2190.48 +1 +2379.96 +1 +2546.84 +1 +2467.18 +1 +2486.93 +1 +2377.8 +1 +2280.97 +1 +2345.1 +1 +2310.12 +1 +2469.65 +1 +2467.95 +1 +2428.65 +1 +2480.58 +1 +2495.13 +1 +2465.56 +1 +2279.9 +1 +2497.6 +1 +2406.96 +1 +2334.56 +1 +2557.51 +1 +2758.65 +1 +2623.38 +1 +2720.94 +1 +2503.67 +1 +2458.8 +1 +2482.03 +1 +2597.23 +1 +2550.81 +1 +2523.38 +1 +2583.17 +1 +2443.87 +1 +2501.31 +1 +2446.65 +1 +2439.2 +1 +2530.21 +1 +2590.8 +1 +2416.9 +1 +2435.92 +1 +2700.69 +1 +2609.52 +1 +2364.18 +1 +2476.93 +1 +2578.72 +1 +2557.92 +1 +2399.78 +1 +2384.13 +1 +2367.14 +1 +2288.19 +1 +2303.46 +1 +2463.49 +1 +2606.1 +1 +2543.37 +1 +2407.37 +1 +2535.64 +1 +2464.25 +1 +2618.6 +1 +2431.8 +1 +2469.94 +1 +2634.83 +1 +2620.8 +1 +2541.92 +1 +2515.8 +1 +2543.1 +1 +2656.01 +1 +2478.51 +1 +2516.34 +1 +2612.86 +1 +2507.3 +1 +2686.18 +1 +2325.53 +1 +2447.29 +1 +2627.82 +1 +2637.01 +1 +2569.89 +1 +2650.81 +1 +2594.96 +1 +2519.19 +1 +2459.04 +1 +2366.53 +1 +2323.17 +1 +2487.76 +1 +2449.83 +1 +2518.35 +1 +2408 +1 +2630.84 +1 +2654.02 +1 +2481.42 +1 +2518.16 +1 +2775.62 +1 +2609.83 +1 +2684.23 +1 +2700.23 +1 +2433.55 +1 +2585.12 +1 +2602.45 +1 +2618.77 +1 +2688.18 +1 +2276.45 +1 +2601.79 +1 +2502.75 +1 +2578.28 +1 +2472.13 +1 +2658.38 +1 +2450.74 +1 +2600.16 +1 +2654.1 +1 +2792.57 +1 +2586.32 +1 +2416.49 +1 +2568.46 +1 +2524.12 +1 +2447.7 +1 +2658.94 +1 +2806.99 +1 +2576.74 +1 +2682.31 +1 +2792.05 +1 +2628.48 +1 +2599.77 +1 +2725.2 +1 +2670.23 +1 +2523.07 +1 +2384.37 +1 +2627.83 +1 +2468.12 +1 +2789.43 +1 +2330.67 +1 +2716.36 +1 +2751.84 +1 +2696.14 +1 +2724.1 +1 +2652.95 +1 +2427.39 +1 +2581.61 +1 +2693.98 +1 +2812.06 +1 +2494.97 +1 +2649.77 +1 +2564.75 +1 +2843.07 +1 +2627.7 +1 +2580.18 +1 +2665.5 +1 +2481.33 +1 +2636.41 +1 +2827.71 +1 +2761.51 +1 +2450.02 +1 +2569.12 +1 +2767.18 +1 +2608.43 +1 +2583.38 +1 +2784.02 +1 +2503.02 +1 +2595.75 +1 +2529.21 +1 +2691.79 +1 +2903.95 +1 +2659.63 +1 +2358.96 +1 +2658.72 +1 +2672.09 +1 +2792.94 +1 +2884.35 +1 +2759.22 +1 +2895.12 +1 +2728.85 +1 +2593.18 +1 +3016.68 +1 +2756.79 +1 +2744.83 +1 +2794.24 +1 +2706.37 +1 +2881.65 +1 +2610.9 +1 +2811.17 +1 +2694.9 +1 +2732.23 +1 +2986.91 +1 +2914.57 +1 +2850.16 +1 +2772.05 +1 +2927.23 +1 +2654.71 +1 +2758.22 +1 +2793.42 +1 +2740.44 +1 +2694.69 +1 +2598.97 +1 +2691.89 +1 +2904.67 +1 +2606.06 +1 +2713.26 +1 +2746.83 +1 +2676.72 +1 +2625.91 +1 +2603.03 +1 +2832.23 +1 +2662.43 +1 +2887.13 +1 +2696.29 +1 +2656.06 +1 +2577.79 +1 +2703.56 +1 +2876.77 +1 +2799.82 +1 +2809.48 +1 +2758.34 +1 +2922.89 +1 +2831.46 +1 +2822.91 +1 +2804.44 +1 +2813.61 +1 +2629.45 +1 +2883.66 +1 +2898.25 +1 +2595.22 +1 +2922.57 +1 +2800.25 +1 +2733.21 +1 +2769.45 +1 +2721.95 +1 +2584.44 +1 +2518.92 +1 +2762.22 +1 +2651.4 +1 +2764.05 +1 +2681.29 +1 +2980.78 +1 +3113.74 +1 +2993.72 +1 +2871.69 +1 +2866.81 +1 +2843.32 +1 +2821.91 +1 +3105.26 +1 +2794.55 +1 +2818.86 +1 +2837.37 +1 +2672.99 +1 +2827.04 +1 +2976.21 +1 +3063.18 +1 +3053.84 +1 +2924.73 +1 +2993.79 +1 +2860.55 +1 +2766.79 +1 +2845.07 +1 +2801.36 +1 +2718.21 +1 +2803.53 +1 +3126.82 +1 +2910.56 +1 +2727.09 +1 +2760.9 +1 +2953.27 +1 +2881.08 +1 +2876.23 +1 +2849.01 +1 +2869.07 +1 +3056.7 +1 +3056.19 +1 +2862.53 +1 +2827.94 +1 +2742.37 +1 +3007.27 +1 +2904.66 +1 +3167.07 +1 +2914.05 +1 +2658.52 +1 +2742.49 +1 +2903.01 +1 +2904.59 +1 +2914.73 +1 +2868.66 +1 +2738.56 +1 +2785.43 +1 +2890.45 +1 +3045.86 +1 +2844.61 +1 +2767.82 +1 +2897.62 +1 +2749.88 +1 +2778.13 +1 +3049.35 +1 +3021.68 +1 +2898.07 +1 +3193.21 +1 +2998.79 +1 +3085.82 +1 +2897.81 +1 +3045.8 +1 +2877.83 +1 +2972.27 +1 +2986.52 +1 +2853.27 +1 +2997.27 +1 +3038.71 +1 +2929.04 +1 +3046.99 +1 +3096.34 +1 +2947.4 +1 +2857.59 +1 +2906.75 +1 +3087.8 +1 +3154.15 +1 +2905.44 +1 +3044.04 +1 +3008.99 +1 +2801.09 +1 +3000.66 +1 +3155.77 +1 +3259.67 +1 +2932.49 +1 +3102.11 +1 +3060.75 +1 +2913.08 +1 +3119.84 +1 +3130.09 +1 +3176.33 +1 +3161.56 +1 +3179.04 +1 +2985.13 +1 +3130.19 +1 +3109.96 +1 +3052.76 +1 +3056.92 +1 +2925.87 +1 +2955.34 +1 +3038.74 +1 +3102.81 +1 +3149.76 +1 +2966.13 +1 +2856.91 +1 +2938.43 +1 +3152.69 +1 +3170.22 +1 +2938.58 +1 +2790.59 +1 +2875.83 +1 +3033.33 +1 +2912.24 +1 +3004.96 +1 +2944.34 +1 +3028.25 +1 +3138.6 +1 +3090.31 +1 +2859.23 +1 +3123.68 +1 +3103.86 +1 +2971.95 +1 +3152.86 +1 +3076.86 +1 +3292.59 +1 +3008.89 +1 +3031.29 +1 +2949.72 +1 +3206.31 +1 +3193.24 +1 +3081.9 +1 +3254.72 +1 +3137.98 +1 +2999.87 +1 +3097.56 +1 +3143.87 +1 +3180.51 +1 +3255.52 +1 +3261.1 +1 +3221.61 +1 +3002.78 +1 +3223.46 +1 +3046.43 +1 +3145.51 +1 +3167.76 +1 +3131.91 +1 +3186.37 +1 +3046.82 +1 +3097.54 +1 +3130.49 +1 +3099.32 +1 +2930.97 +1 +3005.48 +1 +3126.96 +1 +3333.25 +1 +3073.84 +1 +3277.08 +1 +3227.54 +1 +3102.47 +1 +3302.89 +1 +3459.33 +1 +3239.18 +1 +3334.08 +1 +3506.01 +1 +3320.37 +1 +3159.16 +1 +3299.64 +1 +3562.59 +1 +3482.02 +1 +3424.62 +1 +3024.2 +1 +3089.48 +1 +3192.45 +1 +3126.6 +1 +3175.75 +1 +3332.76 +1 +3093.89 +1 +3138.11 +1 +3070.3 +1 +3067.35 +1 +3095.8 +1 +3119.97 +1 +3251.73 +1 +3322.97 +1 +3375.89 +1 +3227.2 +1 +3363.9 +1 +3333.62 +1 +3543.67 +1 +3126.57 +1 +3149.59 +1 +3214.8 +1 +3512.29 +1 +3311.9 +1 +3238.75 +1 +3442.25 +1 +3416.25 +1 +3189.2 +1 +3276.3 +1 +3143.49 +1 +3205.73 +1 +3348.24 +1 +3235.99 +1 +3295.2 +1 +3369.32 +1 +3330.41 +1 +3311.84 +1 +3304.06 +1 +3208.51 +1 +3332.18 +1 +3200.97 +1 +3411.79 +1 +3558.7 +1 +3421.47 +1 +3438.85 +1 +3352.18 +1 +3380.27 +1 +3289.46 +1 +3324.09 +1 +3379.2 +1 +3554.3 +1 +3535.61 +1 +3401.42 +1 +3373.3 +1 +3323.37 +1 +3489.04 +1 +3682.49 +1 +3427.23 +1 +3316.84 +1 +3187.23 +1 +3335.46 +1 +3497.77 +1 +3375.66 +1 +3446.71 +1 +3361.05 +1 +3391.83 +1 +3540.64 +1 +3781.74 +1 +3472.76 +1 +3464.65 +1 +3465.56 +1 +3618.65 +1 +3446.37 +1 +3574.06 +1 +3464.7 +1 +3511.31 +1 +3593.37 +1 +3690.89 +1 +3534.37 +1 +3698.16 +1 +3855.25 +1 +3373.61 +1 +3521.96 +1 +3501.26 +1 +3561.88 +1 +3567.18 +1 +3668.43 +1 +3535.06 +1 +3670.37 +1 +3458.2 +1 +3514.86 +1 +3699.53 +1 +3717.31 +1 +3578.54 +1 +3602.44 +1 +3696.24 +1 +3616.25 +1 +3565.58 +1 +3776.35 +1 +3803.05 +1 +3521.28 +1 +3538.9 +1 +3430.81 +1 +3430.5 +1 +3654.97 +1 +3649.33 +1 +3599.41 +1 +3648.73 +1 +3735.4 +1 +3805.6 +1 +3700.98 +1 +3670.44 +1 +3735.11 +1 +3698.7 +1 +3585.23 +1 +3504.47 +1 +3776.44 +1 +3589.01 +1 +3294.73 +1 +3529.02 +1 +3766.35 +1 +3649.68 +1 +3640.74 +1 +3606.78 +1 +3614.07 +1 +3863.25 +1 +3850.27 +1 +3678.77 +1 +3528.74 +1 +3595.96 +1 +3799.29 +1 +3748.11 +1 +3694.23 +1 +3809.27 +1 +3935.78 +1 +3937.5 +1 +4077.1 +1 +3676.03 +1 +3873.27 +1 +3980.42 +1 +3792.96 +1 +3969.94 +1 +3798.17 +1 +4083.61 +1 +3964.75 +1 +3951.06 +1 +4142.39 +1 +3757.15 +1 +3699.41 +1 +4051.91 +1 +4171.98 +1 +4209.58 +1 +4337.68 +1 +4116.45 +1 +4315.82 +1 +4547.1 +1 +4515.67 +1 +4798.09 +1 +4811.57 +1 +4867.79 +1 +5006.72 +1 +4850.44 +1 +4909.79 +1 +4985.97 +1 +5177.79 +1 +5083.29 +1 +5025.31 +1 +4676.5 +1 +4761.11 +1 +4597.97 +1 +4829.62 +1 +4736.45 +1 +4959.41 +1 +5068.33 +1 +5471.71 +1 +5451.89 +1 +5863.94 +1 +6048.12 +1 +6008.56 +1 +6513.12 +1 +6376.22 +1 +6594.84 +1 +6597.96 +1 +6280.97 +1 +5785.57 +1 +5474.07 +1 +5018.86 +1 +4669.06 +1 +4271.39 +1 +4156.57 +1 +3992.56 +1 +3938.01 +1 +3618.93 +1 +3292.06 +1 +3331.71 +1 +3602.3 +1 +3584.5 +1 +3560.45 +1 +3573.93 +1 +3344.63 +1 +3360.62 +1 +3577.27 +1 +3484.61 +1 +3481.95 +1 +3562.2 +1 +3357.03 +1 +3577.78 +1 +3704.75 +1 +3737.97 +1 +3376.93 +1 +3455.42 +1 +3292.88 +1 +3436.7 +1 +3694.93 +1 +3403.03 +1 +3221.83 +1 +3454.94 +1 +3313.37 +1 +3459.98 +1 +3404.55 +1 +3461.55 +1 +3329.59 +1 +3527.59 +1 +3435.43 +1 +3286.18 +1 +3518.91 +1 +3469.28 +1 +3437.39 +1 +3356.94 +1 +3416.47 +1 +3668.35 +1 +3558.37 +1 +3579.01 +1 +3404.61 +1 +3559.22 +1 +3332.96 +1 +3310.73 +1 +3841.34 +1 +3817.67 +1 +3730.26 +1 +3650.23 +1 +3397.67 +1 +3354.57 +1 +3655.44 +1 +3848.17 +1 +3872.36 +1 +3711.89 +1 +3625.69 +1 +3933.19 +1 +3811.78 +1 +3683.96 +1 +3663.28 +1 +3691.99 +1 +3760.25 +1 +4000.81 +1 +3997.04 +1 +4117.42 +1 +4290.37 +1 +4246.19 +1 +4351.23 +1 +4505.7 +1 +4142.06 +1 +4097.22 +1 +4184.88 +1 +4060.55 +1 +3791.97 +1 +3952.23 +1 +3716.76 +1 +3724.18 +1 +3785.33 +1 +3916.84 +1 +3981.74 +1 +4128.43 +1 +4441.52 +1 +4566.77 +1 +4609.58 +1 +4490.11 +1 +4707.73 +1 +4917.73 +1 +5001.93 +1 +5078.1 +1 +4913.61 +1 +4830.65 +1 +5142.5 +1 +5320.2 +1 +5086.7 +1 +5148.94 +1 +5834.63 +1 +6139.09 +1 +6656.19 +1 +7319.86 +1 +8425.08 +1 +8524.18 +1 +9015.35 +1 +9824.43 +1 +10042.9 +1 +10067.6 +1 +10117.9 +1 +10254.1 +1 +9950.38 +1 +9315 +1 +8532.19 +1 +8099.37 +1 +6851.5 +1 +5790.28 +1 +4686.92 +1 +3908.32 +1 +3305.52 +1 +2802.65 +1 +2519.82 +1 +2232.4 +1 +1772.01 +1 +1719.48 +1 +1697.8 +1 +1630.02 +1 +1478.59 +1 +1447.79 +1 +1300.78 +1 +1439.38 +1 +1310.56 +1 +1159.8 +1 +1162.3 +1 +1014.68 +1 +987.338 +1 +1024.98 +1 +991.092 +1 +1001.43 +1 +1003.82 +1 +979.636 +1 +980.824 +1 +1011.92 +1 +999.583 +1 +1131.23 +1 +1035.35 +1 +1200.59 +1 +1080.92 +1 +891.859 +1 +995.894 +1 +909.798 +1 +987.313 +1 +988.739 +1 +969.998 +1 +946.391 +1 +1039.3 +1 +962.984 +1 +902.336 +1 +862.067 +1 +832.449 +1 +867.019 +1 +919.644 +1 +895.36 +1 +889.463 +1 +884.962 +1 +1000.73 +1 +986.038 +1 +1149.75 +1 +1090.8 +1 +931.096 +1 +892.787 +1 +859.753 +1 +823.171 +1 +906.758 +1 +929.444 +1 +884.694 +1 +837.049 +1 +873.308 +1 +884.245 +1 +990.36 +1 +970.209 +1 +860.881 +1 +917.504 +1 +1004.81 +1 +895.517 +1 +934.722 +1 +910.376 +1 +922.635 +1 +1001.54 +1 +887.582 +1 +904.439 +1 +956.634 +1 +1040.83 +1 +1028.75 +1 +967.89 +1 +1012.67 +1 +928.105 +1 +1027.75 +1 +901.094 +1 +1020.89 +1 +936.602 +1 +939.89 +1 +1001.7 +1 +971.787 +1 +926.465 +1 +928.983 +1 +921.839 +1 +950.994 +1 +886.871 +1 +895.364 +1 +980.203 +1 +916.349 +1 +1074.22 +1 +1060.79 +1 +999.251 +1 +853.391 +1 +956.697 +1 +934.595 +1 +935.638 +1 +951.159 +1 +924.22 +1 +958.639 +1 +902.17 +1 +1058 +1 +924.33 +1 +1022.46 +1 +1124.35 +1 +1088.18 +1 +1131.09 +1 +1045.71 +1 +947.913 +1 +979.97 +1 +896.476 +1 +1092.29 +1 +1129.3 +1 +1079.52 +1 +1068.57 +1 +1002.43 +1 +980.423 +1 +1054.27 +1 +1085.02 +1 +1081.9 +1 +1156.91 +1 +1199.32 +1 +1332.91 +1 +1448.7 +1 +1397.6 +1 +1519.38 +1 +1559.08 +1 +1480.98 +1 +1318.62 +1 +1330.96 +1 +1243.02 +1 +1219.21 +1 +1141.11 +1 +1014.45 +1 +1040.69 +1 +1016.85 +1 +929.243 +1 +896.528 +1 +931.971 +1 +873.788 +1 +1004.35 +1 +832.33 +1 +788.512 +1 +976.115 +1 +1174.24 +1 +1356.18 +1 +1569.67 +1 +1679.05 +1 +1633.34 +1 +1904.89 +1 +1838.97 +1 +1787.14 +1 +1747.76 +1 +1870.68 +1 +1833.42 +1 +1672.27 +1 +1500.91 +1 +1542.74 +1 +1670 +1 +1685.98 +1 +1940.14 +1 +1910.57 +1 +2252.73 +1 +2331.88 +1 +2342.02 +1 +2710.74 +1 +3138.25 +1 +3353.88 +1 +3578.88 +1 +3669.42 +1 +3899.38 +1 +3950.88 +1 +3546.06 +1 +2683.15 +1 +2270.39 +1 +1701.46 +1 +1288.17 +1 +918.258 +1 +695.738 +1 +327.461 +1 +296.501 +1 +204.075 +1 +178.949 +1 +143.017 +1 +110.942 +1 +end of experiment diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe2O3.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe2O3.txt new file mode 100644 index 0000000000000000000000000000000000000000..76dc07de531118c03f6fb8ab04ef5d83f4d34395 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe2O3.txt @@ -0,0 +1,1122 @@ +Fe2p Fe2O3 +7.500000e+002 1.862011e+004 +7.499500e+002 1.862011e+004 +7.499000e+002 1.864389e+004 +7.498500e+002 1.864389e+004 +7.498000e+002 1.887844e+004 +7.497500e+002 1.887844e+004 +7.497000e+002 1.882367e+004 +7.496500e+002 1.882367e+004 +7.496000e+002 1.883789e+004 +7.495500e+002 1.883789e+004 +7.495000e+002 1.901522e+004 +7.494500e+002 1.901522e+004 +7.494000e+002 1.891555e+004 +7.493500e+002 1.891555e+004 +7.493000e+002 1.884855e+004 +7.492500e+002 1.884855e+004 +7.492000e+002 1.902489e+004 +7.491500e+002 1.902489e+004 +7.491000e+002 1.885766e+004 +7.490500e+002 1.885766e+004 +7.490000e+002 1.895855e+004 +7.489500e+002 1.895855e+004 +7.489000e+002 1.896000e+004 +7.488500e+002 1.896000e+004 +7.488000e+002 1.913155e+004 +7.487500e+002 1.913155e+004 +7.487000e+002 1.923855e+004 +7.486500e+002 1.923855e+004 +7.486000e+002 1.910578e+004 +7.485500e+002 1.910578e+004 +7.485000e+002 1.908089e+004 +7.484500e+002 1.908089e+004 +7.484000e+002 1.920156e+004 +7.483500e+002 1.920156e+004 +7.483000e+002 1.917089e+004 +7.482500e+002 1.917089e+004 +7.482000e+002 1.926656e+004 +7.481500e+002 1.926656e+004 +7.481000e+002 1.925900e+004 +7.480500e+002 1.925900e+004 +7.480000e+002 1.920522e+004 +7.479500e+002 1.920522e+004 +7.479000e+002 1.905822e+004 +7.478500e+002 1.905822e+004 +7.478000e+002 1.924645e+004 +7.477500e+002 1.924645e+004 +7.477000e+002 1.936311e+004 +7.476500e+002 1.936311e+004 +7.476000e+002 1.922489e+004 +7.475500e+002 1.922489e+004 +7.475000e+002 1.929500e+004 +7.474500e+002 1.929500e+004 +7.474000e+002 1.919011e+004 +7.473500e+002 1.919011e+004 +7.473000e+002 1.944033e+004 +7.472500e+002 1.944033e+004 +7.472000e+002 1.922355e+004 +7.471500e+002 1.922355e+004 +7.471000e+002 1.915600e+004 +7.470500e+002 1.915600e+004 +7.470000e+002 1.901733e+004 +7.469500e+002 1.901733e+004 +7.469000e+002 1.901900e+004 +7.468500e+002 1.901900e+004 +7.468000e+002 1.910667e+004 +7.467500e+002 1.910667e+004 +7.467000e+002 1.921033e+004 +7.466500e+002 1.921033e+004 +7.466000e+002 1.944889e+004 +7.465500e+002 1.944889e+004 +7.465000e+002 1.943578e+004 +7.464500e+002 1.943578e+004 +7.464000e+002 1.944156e+004 +7.463500e+002 1.944156e+004 +7.463000e+002 1.940233e+004 +7.462500e+002 1.940233e+004 +7.462000e+002 1.925400e+004 +7.461500e+002 1.925400e+004 +7.461000e+002 1.913456e+004 +7.460500e+002 1.913456e+004 +7.460000e+002 1.920522e+004 +7.459500e+002 1.920522e+004 +7.459000e+002 1.937622e+004 +7.458500e+002 1.937622e+004 +7.458000e+002 1.925511e+004 +7.457500e+002 1.925511e+004 +7.457000e+002 1.924578e+004 +7.456500e+002 1.924578e+004 +7.456000e+002 1.923656e+004 +7.455500e+002 1.923656e+004 +7.455000e+002 1.945567e+004 +7.454500e+002 1.945567e+004 +7.454000e+002 1.941044e+004 +7.453500e+002 1.941044e+004 +7.453000e+002 1.942222e+004 +7.452500e+002 1.942222e+004 +7.452000e+002 1.960655e+004 +7.451500e+002 1.960655e+004 +7.451000e+002 1.955678e+004 +7.450500e+002 1.955678e+004 +7.450000e+002 1.978867e+004 +7.449500e+002 1.978867e+004 +7.449000e+002 1.979622e+004 +7.448500e+002 1.979622e+004 +7.448000e+002 1.990422e+004 +7.447500e+002 1.990422e+004 +7.447000e+002 1.980800e+004 +7.446500e+002 1.980800e+004 +7.446000e+002 1.984811e+004 +7.445500e+002 1.984811e+004 +7.445000e+002 1.978333e+004 +7.444500e+002 1.978333e+004 +7.444000e+002 1.998844e+004 +7.443500e+002 1.998844e+004 +7.443000e+002 1.995766e+004 +7.442500e+002 1.995766e+004 +7.442000e+002 2.013822e+004 +7.441500e+002 2.013822e+004 +7.441000e+002 2.026622e+004 +7.440500e+002 2.026622e+004 +7.440000e+002 2.045478e+004 +7.439500e+002 2.045478e+004 +7.439000e+002 2.046766e+004 +7.438500e+002 2.046766e+004 +7.438000e+002 2.055622e+004 +7.437500e+002 2.055622e+004 +7.437000e+002 2.067922e+004 +7.436500e+002 2.067922e+004 +7.436000e+002 2.085555e+004 +7.435500e+002 2.085555e+004 +7.435000e+002 2.065522e+004 +7.434500e+002 2.065522e+004 +7.434000e+002 2.090289e+004 +7.433500e+002 2.090289e+004 +7.433000e+002 2.086811e+004 +7.432500e+002 2.086811e+004 +7.432000e+002 2.094133e+004 +7.431500e+002 2.094133e+004 +7.431000e+002 2.093144e+004 +7.430500e+002 2.093144e+004 +7.430000e+002 2.092456e+004 +7.429500e+002 2.092456e+004 +7.429000e+002 2.108533e+004 +7.428500e+002 2.108533e+004 +7.428000e+002 2.096867e+004 +7.427500e+002 2.096867e+004 +7.427000e+002 2.102378e+004 +7.426500e+002 2.102378e+004 +7.426000e+002 2.101078e+004 +7.425500e+002 2.101078e+004 +7.425000e+002 2.104722e+004 +7.424500e+002 2.104722e+004 +7.424000e+002 2.109211e+004 +7.423500e+002 2.109211e+004 +7.423000e+002 2.098544e+004 +7.422500e+002 2.098544e+004 +7.422000e+002 2.117333e+004 +7.421500e+002 2.117333e+004 +7.421000e+002 2.129956e+004 +7.420500e+002 2.129956e+004 +7.420000e+002 2.109300e+004 +7.419500e+002 2.109300e+004 +7.419000e+002 2.108933e+004 +7.418500e+002 2.108933e+004 +7.418000e+002 2.104444e+004 +7.417500e+002 2.104444e+004 +7.417000e+002 2.101766e+004 +7.416500e+002 2.101766e+004 +7.416000e+002 2.078667e+004 +7.415500e+002 2.078667e+004 +7.415000e+002 2.082189e+004 +7.414500e+002 2.082189e+004 +7.414000e+002 2.080756e+004 +7.413500e+002 2.080756e+004 +7.413000e+002 2.084400e+004 +7.412500e+002 2.084400e+004 +7.412000e+002 2.060211e+004 +7.411500e+002 2.060211e+004 +7.411000e+002 2.083344e+004 +7.410500e+002 2.083344e+004 +7.410000e+002 2.084956e+004 +7.409500e+002 2.084956e+004 +7.409000e+002 2.045522e+004 +7.408500e+002 2.045522e+004 +7.408000e+002 2.034789e+004 +7.407500e+002 2.034789e+004 +7.407000e+002 2.058478e+004 +7.406500e+002 2.058478e+004 +7.406000e+002 2.049756e+004 +7.405500e+002 2.049756e+004 +7.405000e+002 2.043400e+004 +7.404500e+002 2.043400e+004 +7.404000e+002 2.032855e+004 +7.403500e+002 2.032855e+004 +7.403000e+002 2.031244e+004 +7.402500e+002 2.031244e+004 +7.402000e+002 2.022189e+004 +7.401500e+002 2.022189e+004 +7.401000e+002 2.009533e+004 +7.400500e+002 2.009533e+004 +7.400000e+002 2.041755e+004 +7.399500e+002 2.041755e+004 +7.399000e+002 2.050255e+004 +7.398500e+002 2.050255e+004 +7.398000e+002 2.035578e+004 +7.397500e+002 2.035578e+004 +7.397000e+002 2.030133e+004 +7.396500e+002 2.030133e+004 +7.396000e+002 2.047022e+004 +7.395500e+002 2.047022e+004 +7.395000e+002 2.008078e+004 +7.394500e+002 2.008078e+004 +7.394000e+002 2.009222e+004 +7.393500e+002 2.009222e+004 +7.393000e+002 2.037433e+004 +7.392500e+002 2.037433e+004 +7.392000e+002 2.020633e+004 +7.391500e+002 2.020633e+004 +7.391000e+002 2.014844e+004 +7.390500e+002 2.014844e+004 +7.390000e+002 1.986244e+004 +7.389500e+002 1.986244e+004 +7.389000e+002 2.003833e+004 +7.388500e+002 2.003833e+004 +7.388000e+002 2.024889e+004 +7.387500e+002 2.024889e+004 +7.387000e+002 2.013244e+004 +7.386500e+002 2.013244e+004 +7.386000e+002 2.041267e+004 +7.385500e+002 2.041267e+004 +7.385000e+002 2.015322e+004 +7.384500e+002 2.015322e+004 +7.384000e+002 2.032422e+004 +7.383500e+002 2.032422e+004 +7.383000e+002 2.068467e+004 +7.382500e+002 2.068467e+004 +7.382000e+002 2.037167e+004 +7.381500e+002 2.037167e+004 +7.381000e+002 2.036333e+004 +7.380500e+002 2.036333e+004 +7.380000e+002 2.031433e+004 +7.379500e+002 2.031433e+004 +7.379000e+002 2.051156e+004 +7.378500e+002 2.051156e+004 +7.378000e+002 2.061278e+004 +7.377500e+002 2.061278e+004 +7.377000e+002 2.066656e+004 +7.376500e+002 2.066656e+004 +7.376000e+002 2.090000e+004 +7.375500e+002 2.090000e+004 +7.375000e+002 2.085500e+004 +7.374500e+002 2.085500e+004 +7.374000e+002 2.081700e+004 +7.373500e+002 2.081700e+004 +7.373000e+002 2.102678e+004 +7.372500e+002 2.102678e+004 +7.372000e+002 2.086922e+004 +7.371500e+002 2.086922e+004 +7.371000e+002 2.091811e+004 +7.370500e+002 2.091811e+004 +7.370000e+002 2.099822e+004 +7.369500e+002 2.099822e+004 +7.369000e+002 2.124767e+004 +7.368500e+002 2.124767e+004 +7.368000e+002 2.129266e+004 +7.367500e+002 2.129266e+004 +7.367000e+002 2.127178e+004 +7.366500e+002 2.127178e+004 +7.366000e+002 2.127078e+004 +7.365500e+002 2.127078e+004 +7.365000e+002 2.151967e+004 +7.364500e+002 2.151967e+004 +7.364000e+002 2.137022e+004 +7.363500e+002 2.137022e+004 +7.363000e+002 2.149533e+004 +7.362500e+002 2.149533e+004 +7.362000e+002 2.155756e+004 +7.361500e+002 2.155756e+004 +7.361000e+002 2.153978e+004 +7.360500e+002 2.153978e+004 +7.360000e+002 2.154800e+004 +7.359500e+002 2.154800e+004 +7.359000e+002 2.153645e+004 +7.358500e+002 2.153645e+004 +7.358000e+002 2.160511e+004 +7.357500e+002 2.160511e+004 +7.357000e+002 2.171055e+004 +7.356500e+002 2.171055e+004 +7.356000e+002 2.176244e+004 +7.355500e+002 2.176244e+004 +7.355000e+002 2.201800e+004 +7.354500e+002 2.201800e+004 +7.354000e+002 2.207767e+004 +7.353500e+002 2.207767e+004 +7.353000e+002 2.235156e+004 +7.352500e+002 2.235156e+004 +7.352000e+002 2.218522e+004 +7.351500e+002 2.218522e+004 +7.351000e+002 2.248589e+004 +7.350500e+002 2.248589e+004 +7.350000e+002 2.237322e+004 +7.349500e+002 2.237322e+004 +7.349000e+002 2.238878e+004 +7.348500e+002 2.238878e+004 +7.348000e+002 2.239867e+004 +7.347500e+002 2.239867e+004 +7.347000e+002 2.274378e+004 +7.346500e+002 2.274378e+004 +7.346000e+002 2.297400e+004 +7.345500e+002 2.297400e+004 +7.345000e+002 2.280233e+004 +7.344500e+002 2.280233e+004 +7.344000e+002 2.305200e+004 +7.343500e+002 2.305200e+004 +7.343000e+002 2.315300e+004 +7.342500e+002 2.315300e+004 +7.342000e+002 2.336289e+004 +7.341500e+002 2.336289e+004 +7.341000e+002 2.318777e+004 +7.340500e+002 2.318777e+004 +7.340000e+002 2.322033e+004 +7.339500e+002 2.322033e+004 +7.339000e+002 2.331444e+004 +7.338500e+002 2.331444e+004 +7.338000e+002 2.351322e+004 +7.337500e+002 2.351322e+004 +7.337000e+002 2.358633e+004 +7.336500e+002 2.358633e+004 +7.336000e+002 2.344278e+004 +7.335500e+002 2.344278e+004 +7.335000e+002 2.388344e+004 +7.334500e+002 2.388344e+004 +7.334000e+002 2.374489e+004 +7.333500e+002 2.374489e+004 +7.333000e+002 2.369611e+004 +7.332500e+002 2.369611e+004 +7.332000e+002 2.359111e+004 +7.331500e+002 2.359111e+004 +7.331000e+002 2.382278e+004 +7.330500e+002 2.382278e+004 +7.330000e+002 2.380333e+004 +7.329500e+002 2.380333e+004 +7.329000e+002 2.376867e+004 +7.328500e+002 2.376867e+004 +7.328000e+002 2.373333e+004 +7.327500e+002 2.373333e+004 +7.327000e+002 2.377856e+004 +7.326500e+002 2.377856e+004 +7.326000e+002 2.402555e+004 +7.325500e+002 2.402555e+004 +7.325000e+002 2.385000e+004 +7.324500e+002 2.385000e+004 +7.324000e+002 2.402033e+004 +7.323500e+002 2.402033e+004 +7.323000e+002 2.416644e+004 +7.322500e+002 2.416644e+004 +7.322000e+002 2.389889e+004 +7.321500e+002 2.389889e+004 +7.321000e+002 2.392378e+004 +7.320500e+002 2.392378e+004 +7.320000e+002 2.393622e+004 +7.319500e+002 2.393622e+004 +7.319000e+002 2.392800e+004 +7.318500e+002 2.392800e+004 +7.318000e+002 2.388978e+004 +7.317500e+002 2.388978e+004 +7.317000e+002 2.375766e+004 +7.316500e+002 2.375766e+004 +7.316000e+002 2.371311e+004 +7.315500e+002 2.371311e+004 +7.315000e+002 2.342289e+004 +7.314500e+002 2.342289e+004 +7.314000e+002 2.361467e+004 +7.313500e+002 2.361467e+004 +7.313000e+002 2.362933e+004 +7.312500e+002 2.362933e+004 +7.312000e+002 2.355645e+004 +7.311500e+002 2.355645e+004 +7.311000e+002 2.340645e+004 +7.310500e+002 2.340645e+004 +7.310000e+002 2.340589e+004 +7.309500e+002 2.340589e+004 +7.309000e+002 2.333078e+004 +7.308500e+002 2.333078e+004 +7.308000e+002 2.352778e+004 +7.307500e+002 2.352778e+004 +7.307000e+002 2.334689e+004 +7.306500e+002 2.334689e+004 +7.306000e+002 2.311600e+004 +7.305500e+002 2.311600e+004 +7.305000e+002 2.324456e+004 +7.304500e+002 2.324456e+004 +7.304000e+002 2.327500e+004 +7.303500e+002 2.327500e+004 +7.303000e+002 2.311600e+004 +7.302500e+002 2.311600e+004 +7.302000e+002 2.345711e+004 +7.301500e+002 2.345711e+004 +7.301000e+002 2.321211e+004 +7.300500e+002 2.321211e+004 +7.300000e+002 2.330944e+004 +7.299500e+002 2.330944e+004 +7.299000e+002 2.358911e+004 +7.298500e+002 2.358911e+004 +7.298000e+002 2.335322e+004 +7.297500e+002 2.335322e+004 +7.297000e+002 2.357922e+004 +7.296500e+002 2.357922e+004 +7.296000e+002 2.338611e+004 +7.295500e+002 2.338611e+004 +7.295000e+002 2.342111e+004 +7.294500e+002 2.342111e+004 +7.294000e+002 2.341011e+004 +7.293500e+002 2.341011e+004 +7.293000e+002 2.348055e+004 +7.292500e+002 2.348055e+004 +7.292000e+002 2.357733e+004 +7.291500e+002 2.357733e+004 +7.291000e+002 2.373233e+004 +7.290500e+002 2.373233e+004 +7.290000e+002 2.384956e+004 +7.289500e+002 2.384956e+004 +7.289000e+002 2.403456e+004 +7.288500e+002 2.403456e+004 +7.288000e+002 2.417567e+004 +7.287500e+002 2.417567e+004 +7.287000e+002 2.421245e+004 +7.286500e+002 2.421245e+004 +7.286000e+002 2.434478e+004 +7.285500e+002 2.434478e+004 +7.285000e+002 2.435766e+004 +7.284500e+002 2.435766e+004 +7.284000e+002 2.463800e+004 +7.283500e+002 2.463800e+004 +7.283000e+002 2.496277e+004 +7.282500e+002 2.496277e+004 +7.282000e+002 2.496767e+004 +7.281500e+002 2.496767e+004 +7.281000e+002 2.524856e+004 +7.280500e+002 2.524856e+004 +7.280000e+002 2.514578e+004 +7.279500e+002 2.514578e+004 +7.279000e+002 2.540800e+004 +7.278500e+002 2.540800e+004 +7.278000e+002 2.559533e+004 +7.277500e+002 2.559533e+004 +7.277000e+002 2.572378e+004 +7.276500e+002 2.572378e+004 +7.276000e+002 2.589167e+004 +7.275500e+002 2.589167e+004 +7.275000e+002 2.624189e+004 +7.274500e+002 2.624189e+004 +7.274000e+002 2.612744e+004 +7.273500e+002 2.612744e+004 +7.273000e+002 2.635755e+004 +7.272500e+002 2.635755e+004 +7.272000e+002 2.701245e+004 +7.271500e+002 2.701245e+004 +7.271000e+002 2.717611e+004 +7.270500e+002 2.717611e+004 +7.270000e+002 2.726833e+004 +7.269500e+002 2.726833e+004 +7.269000e+002 2.748811e+004 +7.268500e+002 2.748811e+004 +7.268000e+002 2.774933e+004 +7.267500e+002 2.774933e+004 +7.267000e+002 2.768622e+004 +7.266500e+002 2.768622e+004 +7.266000e+002 2.794100e+004 +7.265500e+002 2.794100e+004 +7.265000e+002 2.810189e+004 +7.264500e+002 2.810189e+004 +7.264000e+002 2.810678e+004 +7.263500e+002 2.810678e+004 +7.263000e+002 2.866544e+004 +7.262500e+002 2.866544e+004 +7.262000e+002 2.879989e+004 +7.261500e+002 2.879989e+004 +7.261000e+002 2.922578e+004 +7.260500e+002 2.922578e+004 +7.260000e+002 2.946089e+004 +7.259500e+002 2.946089e+004 +7.259000e+002 2.969889e+004 +7.258500e+002 2.969889e+004 +7.258000e+002 2.967711e+004 +7.257500e+002 2.967711e+004 +7.257000e+002 3.018289e+004 +7.256500e+002 3.018289e+004 +7.256000e+002 3.025744e+004 +7.255500e+002 3.025744e+004 +7.255000e+002 3.073467e+004 +7.254500e+002 3.073467e+004 +7.254000e+002 3.079089e+004 +7.253500e+002 3.079089e+004 +7.253000e+002 3.105244e+004 +7.252500e+002 3.105244e+004 +7.252000e+002 3.130056e+004 +7.251500e+002 3.130056e+004 +7.251000e+002 3.136822e+004 +7.250500e+002 3.136822e+004 +7.250000e+002 3.148200e+004 +7.249500e+002 3.148200e+004 +7.249000e+002 3.200289e+004 +7.248500e+002 3.200289e+004 +7.248000e+002 3.223389e+004 +7.247500e+002 3.223389e+004 +7.247000e+002 3.221744e+004 +7.246500e+002 3.221744e+004 +7.246000e+002 3.244133e+004 +7.245500e+002 3.244133e+004 +7.245000e+002 3.254978e+004 +7.244500e+002 3.254978e+004 +7.244000e+002 3.260222e+004 +7.243500e+002 3.260222e+004 +7.243000e+002 3.269689e+004 +7.242500e+002 3.269689e+004 +7.242000e+002 3.243722e+004 +7.241500e+002 3.243722e+004 +7.241000e+002 3.229767e+004 +7.240500e+002 3.229767e+004 +7.240000e+002 3.225933e+004 +7.239500e+002 3.225933e+004 +7.239000e+002 3.224222e+004 +7.238500e+002 3.224222e+004 +7.238000e+002 3.180022e+004 +7.237500e+002 3.180022e+004 +7.237000e+002 3.150133e+004 +7.236500e+002 3.150133e+004 +7.236000e+002 3.108622e+004 +7.235500e+002 3.108622e+004 +7.235000e+002 3.061344e+004 +7.234500e+002 3.061344e+004 +7.234000e+002 3.037067e+004 +7.233500e+002 3.037067e+004 +7.233000e+002 3.007944e+004 +7.232500e+002 3.007944e+004 +7.232000e+002 2.959367e+004 +7.231500e+002 2.959367e+004 +7.231000e+002 2.931944e+004 +7.230500e+002 2.931944e+004 +7.230000e+002 2.867644e+004 +7.229500e+002 2.867644e+004 +7.229000e+002 2.815011e+004 +7.228500e+002 2.815011e+004 +7.228000e+002 2.745900e+004 +7.227500e+002 2.745900e+004 +7.227000e+002 2.646055e+004 +7.226500e+002 2.646055e+004 +7.226000e+002 2.542167e+004 +7.225500e+002 2.542167e+004 +7.225000e+002 2.457622e+004 +7.224500e+002 2.457622e+004 +7.224000e+002 2.410356e+004 +7.223500e+002 2.410356e+004 +7.223000e+002 2.345978e+004 +7.222500e+002 2.345978e+004 +7.222000e+002 2.335044e+004 +7.221500e+002 2.335044e+004 +7.221000e+002 2.302689e+004 +7.220500e+002 2.302689e+004 +7.220000e+002 2.262000e+004 +7.219500e+002 2.262000e+004 +7.219000e+002 2.238233e+004 +7.218500e+002 2.238233e+004 +7.218000e+002 2.232567e+004 +7.217500e+002 2.232567e+004 +7.217000e+002 2.225956e+004 +7.216500e+002 2.225956e+004 +7.216000e+002 2.207389e+004 +7.215500e+002 2.207389e+004 +7.215000e+002 2.196378e+004 +7.214500e+002 2.196378e+004 +7.214000e+002 2.205678e+004 +7.213500e+002 2.205678e+004 +7.213000e+002 2.199200e+004 +7.212500e+002 2.199200e+004 +7.212000e+002 2.189578e+004 +7.211500e+002 2.189578e+004 +7.211000e+002 2.198233e+004 +7.210500e+002 2.198233e+004 +7.210000e+002 2.210711e+004 +7.209500e+002 2.210711e+004 +7.209000e+002 2.214244e+004 +7.208500e+002 2.214244e+004 +7.208000e+002 2.243278e+004 +7.207500e+002 2.243278e+004 +7.207000e+002 2.219211e+004 +7.206500e+002 2.219211e+004 +7.206000e+002 2.231300e+004 +7.205500e+002 2.231300e+004 +7.205000e+002 2.255655e+004 +7.204500e+002 2.255655e+004 +7.204000e+002 2.262400e+004 +7.203500e+002 2.262400e+004 +7.203000e+002 2.275422e+004 +7.202500e+002 2.275422e+004 +7.202000e+002 2.289744e+004 +7.201500e+002 2.289744e+004 +7.201000e+002 2.291745e+004 +7.200500e+002 2.291745e+004 +7.200000e+002 2.298255e+004 +7.199500e+002 2.298255e+004 +7.199000e+002 2.294578e+004 +7.198500e+002 2.294578e+004 +7.198000e+002 2.313089e+004 +7.197500e+002 2.313089e+004 +7.197000e+002 2.292544e+004 +7.196500e+002 2.292544e+004 +7.196000e+002 2.302256e+004 +7.195500e+002 2.302256e+004 +7.195000e+002 2.332033e+004 +7.194500e+002 2.332033e+004 +7.194000e+002 2.313111e+004 +7.193500e+002 2.313111e+004 +7.193000e+002 2.288656e+004 +7.192500e+002 2.288656e+004 +7.192000e+002 2.307467e+004 +7.191500e+002 2.307467e+004 +7.191000e+002 2.297422e+004 +7.190500e+002 2.297422e+004 +7.190000e+002 2.314678e+004 +7.189500e+002 2.314678e+004 +7.189000e+002 2.315378e+004 +7.188500e+002 2.315378e+004 +7.188000e+002 2.299744e+004 +7.187500e+002 2.299744e+004 +7.187000e+002 2.315700e+004 +7.186500e+002 2.315700e+004 +7.186000e+002 2.293467e+004 +7.185500e+002 2.293467e+004 +7.185000e+002 2.261678e+004 +7.184500e+002 2.261678e+004 +7.184000e+002 2.229333e+004 +7.183500e+002 2.229333e+004 +7.183000e+002 2.248755e+004 +7.182500e+002 2.248755e+004 +7.182000e+002 2.232489e+004 +7.181500e+002 2.232489e+004 +7.181000e+002 2.239622e+004 +7.180500e+002 2.239622e+004 +7.180000e+002 2.211011e+004 +7.179500e+002 2.211011e+004 +7.179000e+002 2.195222e+004 +7.178500e+002 2.195222e+004 +7.178000e+002 2.160789e+004 +7.177500e+002 2.160789e+004 +7.177000e+002 2.162589e+004 +7.176500e+002 2.162589e+004 +7.176000e+002 2.132311e+004 +7.175500e+002 2.132311e+004 +7.175000e+002 2.131367e+004 +7.174500e+002 2.131367e+004 +7.174000e+002 2.109544e+004 +7.173500e+002 2.109544e+004 +7.173000e+002 2.118411e+004 +7.172500e+002 2.118411e+004 +7.172000e+002 2.085667e+004 +7.171500e+002 2.085667e+004 +7.171000e+002 2.053122e+004 +7.170500e+002 2.053122e+004 +7.170000e+002 2.058733e+004 +7.169500e+002 2.058733e+004 +7.169000e+002 2.036956e+004 +7.168500e+002 2.036956e+004 +7.168000e+002 2.016167e+004 +7.167500e+002 2.016167e+004 +7.167000e+002 2.030211e+004 +7.166500e+002 2.030211e+004 +7.166000e+002 2.003867e+004 +7.165500e+002 2.003867e+004 +7.165000e+002 2.005511e+004 +7.164500e+002 2.005511e+004 +7.164000e+002 1.999855e+004 +7.163500e+002 1.999855e+004 +7.163000e+002 2.008433e+004 +7.162500e+002 2.008433e+004 +7.162000e+002 1.999178e+004 +7.161500e+002 1.999178e+004 +7.161000e+002 1.990355e+004 +7.160500e+002 1.990355e+004 +7.160000e+002 2.028933e+004 +7.159500e+002 2.028933e+004 +7.159000e+002 1.990033e+004 +7.158500e+002 1.990033e+004 +7.158000e+002 1.990456e+004 +7.157500e+002 1.990456e+004 +7.157000e+002 1.991189e+004 +7.156500e+002 1.991189e+004 +7.156000e+002 1.994522e+004 +7.155500e+002 1.994522e+004 +7.155000e+002 1.981000e+004 +7.154500e+002 1.981000e+004 +7.154000e+002 1.992044e+004 +7.153500e+002 1.992044e+004 +7.153000e+002 2.017578e+004 +7.152500e+002 2.017578e+004 +7.152000e+002 2.055133e+004 +7.151500e+002 2.055133e+004 +7.151000e+002 2.087289e+004 +7.150500e+002 2.087289e+004 +7.150000e+002 2.075766e+004 +7.149500e+002 2.075766e+004 +7.149000e+002 2.061689e+004 +7.148500e+002 2.061689e+004 +7.148000e+002 2.096833e+004 +7.147500e+002 2.096833e+004 +7.147000e+002 2.124789e+004 +7.146500e+002 2.124789e+004 +7.146000e+002 2.156733e+004 +7.145500e+002 2.156733e+004 +7.145000e+002 2.191478e+004 +7.144500e+002 2.191478e+004 +7.144000e+002 2.202533e+004 +7.143500e+002 2.202533e+004 +7.143000e+002 2.233378e+004 +7.142500e+002 2.233378e+004 +7.142000e+002 2.243144e+004 +7.141500e+002 2.243144e+004 +7.141000e+002 2.286189e+004 +7.140500e+002 2.286189e+004 +7.140000e+002 2.337511e+004 +7.139500e+002 2.337511e+004 +7.139000e+002 2.387078e+004 +7.138500e+002 2.387078e+004 +7.138000e+002 2.402678e+004 +7.137500e+002 2.402678e+004 +7.137000e+002 2.447522e+004 +7.136500e+002 2.447522e+004 +7.136000e+002 2.490067e+004 +7.135500e+002 2.490067e+004 +7.135000e+002 2.513389e+004 +7.134500e+002 2.513389e+004 +7.134000e+002 2.542333e+004 +7.133500e+002 2.542333e+004 +7.133000e+002 2.614100e+004 +7.132500e+002 2.614100e+004 +7.132000e+002 2.648189e+004 +7.131500e+002 2.648189e+004 +7.131000e+002 2.691722e+004 +7.130500e+002 2.691722e+004 +7.130000e+002 2.712367e+004 +7.129500e+002 2.712367e+004 +7.129000e+002 2.739022e+004 +7.128500e+002 2.739022e+004 +7.128000e+002 2.807511e+004 +7.127500e+002 2.807511e+004 +7.127000e+002 2.878033e+004 +7.126500e+002 2.878033e+004 +7.126000e+002 2.885155e+004 +7.125500e+002 2.885155e+004 +7.125000e+002 2.929133e+004 +7.124500e+002 2.929133e+004 +7.124000e+002 2.959455e+004 +7.123500e+002 2.959455e+004 +7.123000e+002 3.002867e+004 +7.122500e+002 3.002867e+004 +7.122000e+002 3.047478e+004 +7.121500e+002 3.047478e+004 +7.121000e+002 3.113900e+004 +7.120500e+002 3.113900e+004 +7.120000e+002 3.163400e+004 +7.119500e+002 3.163400e+004 +7.119000e+002 3.252600e+004 +7.118500e+002 3.252600e+004 +7.118000e+002 3.310656e+004 +7.117500e+002 3.310656e+004 +7.117000e+002 3.384833e+004 +7.116500e+002 3.384833e+004 +7.116000e+002 3.469156e+004 +7.115500e+002 3.469156e+004 +7.115000e+002 3.517844e+004 +7.114500e+002 3.517844e+004 +7.114000e+002 3.602700e+004 +7.113500e+002 3.602700e+004 +7.113000e+002 3.639100e+004 +7.112500e+002 3.639100e+004 +7.112000e+002 3.659089e+004 +7.111500e+002 3.659089e+004 +7.111000e+002 3.710345e+004 +7.110500e+002 3.710345e+004 +7.110000e+002 3.741789e+004 +7.109500e+002 3.741789e+004 +7.109000e+002 3.717455e+004 +7.108500e+002 3.717455e+004 +7.108000e+002 3.646733e+004 +7.107500e+002 3.646733e+004 +7.107000e+002 3.615267e+004 +7.106500e+002 3.615267e+004 +7.106000e+002 3.576333e+004 +7.105500e+002 3.576333e+004 +7.105000e+002 3.520889e+004 +7.104500e+002 3.520889e+004 +7.104000e+002 3.472045e+004 +7.103500e+002 3.472045e+004 +7.103000e+002 3.471444e+004 +7.102500e+002 3.471444e+004 +7.102000e+002 3.483378e+004 +7.101500e+002 3.483378e+004 +7.101000e+002 3.508855e+004 +7.100500e+002 3.508855e+004 +7.100000e+002 3.501289e+004 +7.099500e+002 3.501289e+004 +7.099000e+002 3.482311e+004 +7.098500e+002 3.482311e+004 +7.098000e+002 3.380411e+004 +7.097500e+002 3.380411e+004 +7.097000e+002 3.207578e+004 +7.096500e+002 3.207578e+004 +7.096000e+002 2.974289e+004 +7.095500e+002 2.974289e+004 +7.095000e+002 2.694544e+004 +7.094500e+002 2.694544e+004 +7.094000e+002 2.341022e+004 +7.093500e+002 2.341022e+004 +7.093000e+002 1.975467e+004 +7.092500e+002 1.975467e+004 +7.092000e+002 1.636889e+004 +7.091500e+002 1.636889e+004 +7.091000e+002 1.375389e+004 +7.090500e+002 1.375389e+004 +7.090000e+002 1.140411e+004 +7.089500e+002 1.140411e+004 +7.089000e+002 9.734700e+003 +7.088500e+002 9.734700e+003 +7.088000e+002 8.790333e+003 +7.087500e+002 8.790333e+003 +7.087000e+002 8.243422e+003 +7.086500e+002 8.243422e+003 +7.086000e+002 7.643878e+003 +7.085500e+002 7.643878e+003 +7.085000e+002 7.165777e+003 +7.084500e+002 7.165777e+003 +7.084000e+002 6.802867e+003 +7.083500e+002 6.802867e+003 +7.083000e+002 6.597811e+003 +7.082500e+002 6.597811e+003 +7.082000e+002 6.333078e+003 +7.081500e+002 6.333078e+003 +7.081000e+002 6.277622e+003 +7.080500e+002 6.277622e+003 +7.080000e+002 6.202200e+003 +7.079500e+002 6.202200e+003 +7.079000e+002 6.052033e+003 +7.078500e+002 6.052033e+003 +7.078000e+002 5.923345e+003 +7.077500e+002 5.923345e+003 +7.077000e+002 5.772866e+003 +7.076500e+002 5.772866e+003 +7.076000e+002 5.735822e+003 +7.075500e+002 5.735822e+003 +7.075000e+002 5.685389e+003 +7.074500e+002 5.685389e+003 +7.074000e+002 5.770022e+003 +7.073500e+002 5.770022e+003 +7.073000e+002 5.691411e+003 +7.072500e+002 5.691411e+003 +7.072000e+002 5.611300e+003 +7.071500e+002 5.611300e+003 +7.071000e+002 5.480489e+003 +7.070500e+002 5.480489e+003 +7.070000e+002 5.359400e+003 +7.069500e+002 5.359400e+003 +7.069000e+002 5.316778e+003 +7.068500e+002 5.316778e+003 +7.068000e+002 5.397277e+003 +7.067500e+002 5.397277e+003 +7.067000e+002 5.338755e+003 +7.066500e+002 5.338755e+003 +7.066000e+002 5.445889e+003 +7.065500e+002 5.445889e+003 +7.065000e+002 5.347733e+003 +7.064500e+002 5.347733e+003 +7.064000e+002 5.495444e+003 +7.063500e+002 5.495444e+003 +7.063000e+002 5.335600e+003 +7.062500e+002 5.335600e+003 +7.062000e+002 5.218256e+003 +7.061500e+002 5.218256e+003 +7.061000e+002 5.245333e+003 +7.060500e+002 5.245333e+003 +7.060000e+002 5.088055e+003 +7.059500e+002 5.088055e+003 +7.059000e+002 5.187578e+003 +7.058500e+002 5.187578e+003 +7.058000e+002 5.197267e+003 +7.057500e+002 5.197267e+003 +7.057000e+002 5.257533e+003 +7.056500e+002 5.257533e+003 +7.056000e+002 5.263444e+003 +7.055500e+002 5.263444e+003 +7.055000e+002 5.078444e+003 +7.054500e+002 5.078444e+003 +7.054000e+002 5.166255e+003 +7.053500e+002 5.166255e+003 +7.053000e+002 5.205489e+003 +7.052500e+002 5.205489e+003 +7.052000e+002 5.107233e+003 +7.051500e+002 5.107233e+003 +7.051000e+002 5.256045e+003 +7.050500e+002 5.256045e+003 +7.050000e+002 5.083645e+003 +7.049500e+002 5.083645e+003 +7.049000e+002 5.066389e+003 +7.048500e+002 5.066389e+003 +7.048000e+002 5.134244e+003 +7.047500e+002 5.134244e+003 +7.047000e+002 4.954766e+003 +7.046500e+002 4.954766e+003 +7.046000e+002 5.039667e+003 +7.045500e+002 5.039667e+003 +7.045000e+002 5.032411e+003 +7.044500e+002 5.032411e+003 +7.044000e+002 5.159311e+003 +7.043500e+002 5.159311e+003 +7.043000e+002 5.024156e+003 +7.042500e+002 5.024156e+003 +7.042000e+002 4.963244e+003 +7.041500e+002 4.963244e+003 +7.041000e+002 4.968244e+003 +7.040500e+002 4.968244e+003 +7.040000e+002 4.995200e+003 +7.039500e+002 4.995200e+003 +7.039000e+002 5.003822e+003 +7.038500e+002 5.003822e+003 +7.038000e+002 4.932611e+003 +7.037500e+002 4.932611e+003 +7.037000e+002 4.888889e+003 +7.036500e+002 4.888889e+003 +7.036000e+002 4.916556e+003 +7.035500e+002 4.916556e+003 +7.035000e+002 5.015177e+003 +7.034500e+002 5.015177e+003 +7.034000e+002 5.098356e+003 +7.033500e+002 5.098356e+003 +7.033000e+002 5.118655e+003 +7.032500e+002 5.118655e+003 +7.032000e+002 5.088822e+003 +7.031500e+002 5.088822e+003 +7.031000e+002 5.028800e+003 +7.030500e+002 5.028800e+003 +7.030000e+002 5.036933e+003 +7.029500e+002 5.036933e+003 +7.029000e+002 4.928989e+003 +7.028500e+002 4.928989e+003 +7.028000e+002 4.986477e+003 +7.027500e+002 4.986477e+003 +7.027000e+002 4.950555e+003 +7.026500e+002 4.950555e+003 +7.026000e+002 4.961789e+003 +7.025500e+002 4.961789e+003 +7.025000e+002 5.013011e+003 +7.024500e+002 5.013011e+003 +7.024000e+002 4.844867e+003 +7.023500e+002 4.844867e+003 +7.023000e+002 4.992944e+003 +7.022500e+002 4.992944e+003 +7.022000e+002 4.953289e+003 +7.021500e+002 4.953289e+003 +7.021000e+002 4.992778e+003 +7.020500e+002 4.992778e+003 +7.020000e+002 5.000500e+003 +7.019500e+002 5.000500e+003 +7.019000e+002 4.956377e+003 +7.018500e+002 4.956377e+003 +7.018000e+002 4.982878e+003 +7.017500e+002 4.982878e+003 +7.017000e+002 4.912011e+003 +7.016500e+002 4.912011e+003 +7.016000e+002 4.939633e+003 +7.015500e+002 4.939633e+003 +7.015000e+002 5.035389e+003 +7.014500e+002 5.035389e+003 +7.014000e+002 4.963156e+003 +7.013500e+002 4.963156e+003 +7.013000e+002 4.867167e+003 +7.012500e+002 4.867167e+003 +7.012000e+002 4.920133e+003 +7.011500e+002 4.920133e+003 +7.011000e+002 4.892367e+003 +7.010500e+002 4.892367e+003 +7.010000e+002 4.857800e+003 +7.009500e+002 4.857800e+003 +7.009000e+002 4.961178e+003 +7.008500e+002 4.961178e+003 +7.008000e+002 4.969289e+003 +7.007500e+002 4.969289e+003 +7.007000e+002 4.919922e+003 +7.006500e+002 4.919922e+003 +7.006000e+002 4.787911e+003 +7.005500e+002 4.787911e+003 +7.005000e+002 4.910300e+003 +7.004500e+002 4.910300e+003 +7.004000e+002 4.926833e+003 +7.003500e+002 4.926833e+003 +7.003000e+002 4.920200e+003 +7.002500e+002 4.920200e+003 +7.002000e+002 4.890889e+003 +7.001500e+002 4.890889e+003 +7.001000e+002 4.890022e+003 +7.000500e+002 4.890022e+003 +7.000000e+002 4.872277e+003 +6.999500e+002 4.872277e+003 +6.999000e+002 4.956056e+003 +6.998500e+002 4.956056e+003 +6.998000e+002 5.017933e+003 +6.997500e+002 5.017933e+003 +6.997000e+002 4.908289e+003 +6.996500e+002 4.908289e+003 +6.996000e+002 4.850333e+003 +6.995500e+002 4.850333e+003 +6.995000e+002 4.890622e+003 +6.994500e+002 4.890622e+003 +6.994000e+002 4.844478e+003 +6.993500e+002 4.844478e+003 +6.993000e+002 4.805544e+003 +6.992500e+002 4.805544e+003 +6.992000e+002 4.871622e+003 +6.991500e+002 4.871622e+003 +6.991000e+002 4.834178e+003 +6.990500e+002 4.834178e+003 +6.990000e+002 4.867889e+003 +6.989500e+002 4.867889e+003 +6.989000e+002 4.936322e+003 +6.988500e+002 4.936322e+003 +6.988000e+002 4.859855e+003 +6.987500e+002 4.859855e+003 +6.987000e+002 4.879256e+003 +6.986500e+002 4.879256e+003 +6.986000e+002 4.875078e+003 +6.985500e+002 4.875078e+003 +6.985000e+002 4.892111e+003 +6.984500e+002 4.892111e+003 +6.984000e+002 4.896267e+003 +6.983500e+002 4.896267e+003 +6.983000e+002 4.835177e+003 +6.982500e+002 4.835177e+003 +6.982000e+002 4.966478e+003 +6.981500e+002 4.966478e+003 +6.981000e+002 4.889011e+003 +6.980500e+002 4.889011e+003 +6.980000e+002 4.849722e+003 +6.979500e+002 4.849722e+003 +6.979000e+002 4.921667e+003 +6.978500e+002 4.921667e+003 +6.978000e+002 4.906722e+003 +6.977500e+002 4.906722e+003 +6.977000e+002 4.858622e+003 +6.976500e+002 4.858622e+003 +6.976000e+002 4.895456e+003 +6.975500e+002 4.895456e+003 +6.975000e+002 4.812967e+003 +6.974500e+002 4.812967e+003 +6.974000e+002 4.865988e+003 +6.973500e+002 4.865988e+003 +6.973000e+002 4.860278e+003 +6.972500e+002 4.860278e+003 +6.972000e+002 4.977767e+003 +6.971500e+002 4.977767e+003 +6.971000e+002 4.911633e+003 +6.970500e+002 4.911633e+003 +6.970000e+002 4.855411e+003 +6.969500e+002 4.855411e+003 +6.969000e+002 4.799899e+003 +6.968500e+002 4.799899e+003 +6.968000e+002 4.862189e+003 +6.967500e+002 4.862189e+003 +6.967000e+002 4.821822e+003 +6.966500e+002 4.821822e+003 +6.966000e+002 4.826689e+003 +6.965500e+002 4.826689e+003 +6.965000e+002 4.933689e+003 +6.964500e+002 4.933689e+003 +6.964000e+002 4.970288e+003 +6.963500e+002 4.970288e+003 +6.963000e+002 4.827255e+003 +6.962500e+002 4.827255e+003 +6.962000e+002 4.937344e+003 +6.961500e+002 4.937344e+003 +6.961000e+002 4.990822e+003 +6.960500e+002 4.990822e+003 +6.960000e+002 4.945567e+003 +6.959500e+002 4.945567e+003 +6.959000e+002 4.956511e+003 +6.958500e+002 4.956511e+003 +6.958000e+002 4.941511e+003 +6.957500e+002 4.941511e+003 +6.957000e+002 4.957567e+003 +6.956500e+002 4.957567e+003 +6.956000e+002 5.003778e+003 +6.955500e+002 5.003778e+003 +6.955000e+002 4.875911e+003 +6.954500e+002 4.875911e+003 +6.954000e+002 4.925944e+003 +6.953500e+002 4.925944e+003 +6.953000e+002 4.944577e+003 +6.952500e+002 4.944577e+003 +6.952000e+002 4.899622e+003 +6.951500e+002 4.899622e+003 +6.951000e+002 4.933978e+003 +6.950500e+002 4.933978e+003 +6.950000e+002 4.881011e+003 +6.949500e+002 4.881011e+003 +6.949000e+002 4.904989e+003 +6.948500e+002 4.904989e+003 +6.948000e+002 4.921267e+003 +6.947500e+002 4.921267e+003 +6.947000e+002 4.958933e+003 +6.946500e+002 4.958933e+003 +6.946000e+002 4.890778e+003 +6.945500e+002 4.890778e+003 +6.945000e+002 5.090978e+003 +6.944500e+002 5.090978e+003 +6.944000e+002 4.985177e+003 +6.943500e+002 4.985177e+003 +6.943000e+002 4.860955e+003 +6.942500e+002 4.860955e+003 +6.942000e+002 4.815644e+003 +6.941500e+002 4.815644e+003 +6.941000e+002 4.836789e+003 +6.940500e+002 4.836789e+003 +6.940000e+002 4.767478e+003 \ No newline at end of file diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_FeO_Mark_shifted.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_FeO_Mark_shifted.txt new file mode 100644 index 0000000000000000000000000000000000000000..0c5a9173631ab3835c1baf11b60ad5fb06fb7af7 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_FeO_Mark_shifted.txt @@ -0,0 +1,1122 @@ +Fe2p FeO +7.500000e+02 7.225380e+04 +7.499500e+02 7.227630e+04 +7.499000e+02 7.229880e+04 +7.498500e+02 7.232590e+04 +7.498000e+02 7.235300e+04 +7.497500e+02 7.243480e+04 +7.497000e+02 7.251660e+04 +7.496500e+02 7.238400e+04 +7.496000e+02 7.225140e+04 +7.495500e+02 7.192660e+04 +7.495000e+02 7.160180e+04 +7.494500e+02 7.198420e+04 +7.494000e+02 7.236660e+04 +7.493500e+02 7.245010e+04 +7.493000e+02 7.253360e+04 +7.492500e+02 7.259430e+04 +7.492000e+02 7.265500e+04 +7.491500e+02 7.273780e+04 +7.491000e+02 7.282060e+04 +7.490500e+02 7.281490e+04 +7.490000e+02 7.280920e+04 +7.489500e+02 7.314880e+04 +7.489000e+02 7.348840e+04 +7.488500e+02 7.347420e+04 +7.488000e+02 7.346000e+04 +7.487500e+02 7.321400e+04 +7.487000e+02 7.296800e+04 +7.486500e+02 7.301070e+04 +7.486000e+02 7.305340e+04 +7.485500e+02 7.306270e+04 +7.485000e+02 7.307200e+04 +7.484500e+02 7.297520e+04 +7.484000e+02 7.287840e+04 +7.483500e+02 7.296700e+04 +7.483000e+02 7.305560e+04 +7.482500e+02 7.339680e+04 +7.482000e+02 7.373800e+04 +7.481500e+02 7.323470e+04 +7.481000e+02 7.273140e+04 +7.480500e+02 7.261710e+04 +7.480000e+02 7.250280e+04 +7.479500e+02 7.267390e+04 +7.479000e+02 7.284500e+04 +7.478500e+02 7.328980e+04 +7.478000e+02 7.373460e+04 +7.477500e+02 7.352610e+04 +7.477000e+02 7.331760e+04 +7.476500e+02 7.306780e+04 +7.476000e+02 7.281800e+04 +7.475500e+02 7.302290e+04 +7.475000e+02 7.322780e+04 +7.474500e+02 7.325170e+04 +7.474000e+02 7.327560e+04 +7.473500e+02 7.333500e+04 +7.473000e+02 7.339440e+04 +7.472500e+02 7.343460e+04 +7.472000e+02 7.347480e+04 +7.471500e+02 7.331480e+04 +7.471000e+02 7.315480e+04 +7.470500e+02 7.334870e+04 +7.470000e+02 7.354260e+04 +7.469500e+02 7.343000e+04 +7.469000e+02 7.331740e+04 +7.468500e+02 7.333260e+04 +7.468000e+02 7.334780e+04 +7.467500e+02 7.316790e+04 +7.467000e+02 7.298800e+04 +7.466500e+02 7.322610e+04 +7.466000e+02 7.346420e+04 +7.465500e+02 7.341610e+04 +7.465000e+02 7.336800e+04 +7.464500e+02 7.355930e+04 +7.464000e+02 7.375060e+04 +7.463500e+02 7.375840e+04 +7.463000e+02 7.376620e+04 +7.462500e+02 7.355300e+04 +7.462000e+02 7.333980e+04 +7.461500e+02 7.369110e+04 +7.461000e+02 7.404240e+04 +7.460500e+02 7.413690e+04 +7.460000e+02 7.423140e+04 +7.459500e+02 7.419260e+04 +7.459000e+02 7.415380e+04 +7.458500e+02 7.381570e+04 +7.458000e+02 7.347760e+04 +7.457500e+02 7.371650e+04 +7.457000e+02 7.395540e+04 +7.456500e+02 7.357120e+04 +7.456000e+02 7.318700e+04 +7.455500e+02 7.366290e+04 +7.455000e+02 7.413880e+04 +7.454500e+02 7.424040e+04 +7.454000e+02 7.434200e+04 +7.453500e+02 7.448360e+04 +7.453000e+02 7.462520e+04 +7.452500e+02 7.453750e+04 +7.452000e+02 7.444980e+04 +7.451500e+02 7.430050e+04 +7.451000e+02 7.415120e+04 +7.450500e+02 7.417060e+04 +7.450000e+02 7.419000e+04 +7.449500e+02 7.410010e+04 +7.449000e+02 7.401020e+04 +7.448500e+02 7.361090e+04 +7.448000e+02 7.321160e+04 +7.447500e+02 7.346440e+04 +7.447000e+02 7.371720e+04 +7.446500e+02 7.373440e+04 +7.446000e+02 7.375160e+04 +7.445500e+02 7.405150e+04 +7.445000e+02 7.435140e+04 +7.444500e+02 7.450300e+04 +7.444000e+02 7.465460e+04 +7.443500e+02 7.444420e+04 +7.443000e+02 7.423380e+04 +7.442500e+02 7.422260e+04 +7.442000e+02 7.421140e+04 +7.441500e+02 7.399540e+04 +7.441000e+02 7.377940e+04 +7.440500e+02 7.373960e+04 +7.440000e+02 7.369980e+04 +7.439500e+02 7.340680e+04 +7.439000e+02 7.311380e+04 +7.438500e+02 7.320210e+04 +7.438000e+02 7.329040e+04 +7.437500e+02 7.354360e+04 +7.437000e+02 7.379680e+04 +7.436500e+02 7.384660e+04 +7.436000e+02 7.389640e+04 +7.435500e+02 7.368410e+04 +7.435000e+02 7.347180e+04 +7.434500e+02 7.365250e+04 +7.434000e+02 7.383320e+04 +7.433500e+02 7.365670e+04 +7.433000e+02 7.348020e+04 +7.432500e+02 7.315660e+04 +7.432000e+02 7.283300e+04 +7.431500e+02 7.327740e+04 +7.431000e+02 7.372180e+04 +7.430500e+02 7.309110e+04 +7.430000e+02 7.246040e+04 +7.429500e+02 7.256230e+04 +7.429000e+02 7.266420e+04 +7.428500e+02 7.277750e+04 +7.428000e+02 7.289080e+04 +7.427500e+02 7.256240e+04 +7.427000e+02 7.223400e+04 +7.426500e+02 7.237010e+04 +7.426000e+02 7.250620e+04 +7.425500e+02 7.254930e+04 +7.425000e+02 7.259240e+04 +7.424500e+02 7.230450e+04 +7.424000e+02 7.201660e+04 +7.423500e+02 7.216150e+04 +7.423000e+02 7.230640e+04 +7.422500e+02 7.228440e+04 +7.422000e+02 7.226240e+04 +7.421500e+02 7.231420e+04 +7.421000e+02 7.236600e+04 +7.420500e+02 7.227950e+04 +7.420000e+02 7.219300e+04 +7.419500e+02 7.194960e+04 +7.419000e+02 7.170620e+04 +7.418500e+02 7.208320e+04 +7.418000e+02 7.246020e+04 +7.417500e+02 7.208790e+04 +7.417000e+02 7.171560e+04 +7.416500e+02 7.170550e+04 +7.416000e+02 7.169540e+04 +7.415500e+02 7.182590e+04 +7.415000e+02 7.195640e+04 +7.414500e+02 7.166060e+04 +7.414000e+02 7.136480e+04 +7.413500e+02 7.151510e+04 +7.413000e+02 7.166540e+04 +7.412500e+02 7.199300e+04 +7.412000e+02 7.232060e+04 +7.411500e+02 7.195180e+04 +7.411000e+02 7.158300e+04 +7.410500e+02 7.161420e+04 +7.410000e+02 7.164540e+04 +7.409500e+02 7.162230e+04 +7.409000e+02 7.159920e+04 +7.408500e+02 7.159080e+04 +7.408000e+02 7.158240e+04 +7.407500e+02 7.170780e+04 +7.407000e+02 7.183320e+04 +7.406500e+02 7.189590e+04 +7.406000e+02 7.195860e+04 +7.405500e+02 7.150040e+04 +7.405000e+02 7.104220e+04 +7.404500e+02 7.130970e+04 +7.404000e+02 7.157720e+04 +7.403500e+02 7.168890e+04 +7.403000e+02 7.180060e+04 +7.402500e+02 7.176250e+04 +7.402000e+02 7.172440e+04 +7.401500e+02 7.153770e+04 +7.401000e+02 7.135100e+04 +7.400500e+02 7.168070e+04 +7.400000e+02 7.201040e+04 +7.399500e+02 7.197560e+04 +7.399000e+02 7.194080e+04 +7.398500e+02 7.167220e+04 +7.398000e+02 7.140360e+04 +7.397500e+02 7.156500e+04 +7.397000e+02 7.172640e+04 +7.396500e+02 7.180250e+04 +7.396000e+02 7.187860e+04 +7.395500e+02 7.164450e+04 +7.395000e+02 7.141040e+04 +7.394500e+02 7.161770e+04 +7.394000e+02 7.182500e+04 +7.393500e+02 7.192140e+04 +7.393000e+02 7.201780e+04 +7.392500e+02 7.228110e+04 +7.392000e+02 7.254440e+04 +7.391500e+02 7.253020e+04 +7.391000e+02 7.251600e+04 +7.390500e+02 7.225710e+04 +7.390000e+02 7.199820e+04 +7.389500e+02 7.239650e+04 +7.389000e+02 7.279480e+04 +7.388500e+02 7.264350e+04 +7.388000e+02 7.249220e+04 +7.387500e+02 7.225710e+04 +7.387000e+02 7.202200e+04 +7.386500e+02 7.251760e+04 +7.386000e+02 7.301320e+04 +7.385500e+02 7.295470e+04 +7.385000e+02 7.289620e+04 +7.384500e+02 7.288310e+04 +7.384000e+02 7.287000e+04 +7.383500e+02 7.261300e+04 +7.383000e+02 7.235600e+04 +7.382500e+02 7.233340e+04 +7.382000e+02 7.231080e+04 +7.381500e+02 7.213330e+04 +7.381000e+02 7.195580e+04 +7.380500e+02 7.234610e+04 +7.380000e+02 7.273640e+04 +7.379500e+02 7.280480e+04 +7.379000e+02 7.287320e+04 +7.378500e+02 7.301850e+04 +7.378000e+02 7.316380e+04 +7.377500e+02 7.317090e+04 +7.377000e+02 7.317800e+04 +7.376500e+02 7.298930e+04 +7.376000e+02 7.280060e+04 +7.375500e+02 7.298240e+04 +7.375000e+02 7.316420e+04 +7.374500e+02 7.320630e+04 +7.374000e+02 7.324840e+04 +7.373500e+02 7.322810e+04 +7.373000e+02 7.320780e+04 +7.372500e+02 7.351190e+04 +7.372000e+02 7.381600e+04 +7.371500e+02 7.385550e+04 +7.371000e+02 7.389500e+04 +7.370500e+02 7.388470e+04 +7.370000e+02 7.387440e+04 +7.369500e+02 7.391090e+04 +7.369000e+02 7.394740e+04 +7.368500e+02 7.391480e+04 +7.368000e+02 7.388220e+04 +7.367500e+02 7.377150e+04 +7.367000e+02 7.366080e+04 +7.366500e+02 7.369030e+04 +7.366000e+02 7.371980e+04 +7.365500e+02 7.389590e+04 +7.365000e+02 7.407200e+04 +7.364500e+02 7.401790e+04 +7.364000e+02 7.396380e+04 +7.363500e+02 7.415680e+04 +7.363000e+02 7.434980e+04 +7.362500e+02 7.462510e+04 +7.362000e+02 7.490040e+04 +7.361500e+02 7.508230e+04 +7.361000e+02 7.526420e+04 +7.360500e+02 7.509440e+04 +7.360000e+02 7.492460e+04 +7.359500e+02 7.500200e+04 +7.359000e+02 7.507940e+04 +7.358500e+02 7.511090e+04 +7.358000e+02 7.514240e+04 +7.357500e+02 7.513770e+04 +7.357000e+02 7.513300e+04 +7.356500e+02 7.526840e+04 +7.356000e+02 7.540380e+04 +7.355500e+02 7.540410e+04 +7.355000e+02 7.540440e+04 +7.354500e+02 7.532910e+04 +7.354000e+02 7.525380e+04 +7.353500e+02 7.547320e+04 +7.353000e+02 7.569260e+04 +7.352500e+02 7.565030e+04 +7.352000e+02 7.560800e+04 +7.351500e+02 7.579770e+04 +7.351000e+02 7.598740e+04 +7.350500e+02 7.608700e+04 +7.350000e+02 7.618660e+04 +7.349500e+02 7.622470e+04 +7.349000e+02 7.626280e+04 +7.348500e+02 7.615530e+04 +7.348000e+02 7.604780e+04 +7.347500e+02 7.602650e+04 +7.347000e+02 7.600520e+04 +7.346500e+02 7.608900e+04 +7.346000e+02 7.617280e+04 +7.345500e+02 7.640810e+04 +7.345000e+02 7.664340e+04 +7.344500e+02 7.673310e+04 +7.344000e+02 7.682280e+04 +7.343500e+02 7.702180e+04 +7.343000e+02 7.722080e+04 +7.342500e+02 7.696320e+04 +7.342000e+02 7.670560e+04 +7.341500e+02 7.686110e+04 +7.341000e+02 7.701660e+04 +7.340500e+02 7.723030e+04 +7.340000e+02 7.744400e+04 +7.339500e+02 7.746260e+04 +7.339000e+02 7.748120e+04 +7.338500e+02 7.762420e+04 +7.338000e+02 7.776720e+04 +7.337500e+02 7.753940e+04 +7.337000e+02 7.731160e+04 +7.336500e+02 7.747660e+04 +7.336000e+02 7.764160e+04 +7.335500e+02 7.781100e+04 +7.335000e+02 7.798040e+04 +7.334500e+02 7.802000e+04 +7.334000e+02 7.805960e+04 +7.333500e+02 7.829820e+04 +7.333000e+02 7.853680e+04 +7.332500e+02 7.862230e+04 +7.332000e+02 7.870780e+04 +7.331500e+02 7.861270e+04 +7.331000e+02 7.851760e+04 +7.330500e+02 7.852910e+04 +7.330000e+02 7.854060e+04 +7.329500e+02 7.881300e+04 +7.329000e+02 7.908540e+04 +7.328500e+02 7.911370e+04 +7.328000e+02 7.914200e+04 +7.327500e+02 7.921530e+04 +7.327000e+02 7.928860e+04 +7.326500e+02 7.958110e+04 +7.326000e+02 7.987360e+04 +7.325500e+02 7.998030e+04 +7.325000e+02 8.008700e+04 +7.324500e+02 8.042540e+04 +7.324000e+02 8.076380e+04 +7.323500e+02 8.065680e+04 +7.323000e+02 8.054980e+04 +7.322500e+02 8.029400e+04 +7.322000e+02 8.003820e+04 +7.321500e+02 8.009010e+04 +7.321000e+02 8.014200e+04 +7.320500e+02 8.025590e+04 +7.320000e+02 8.036980e+04 +7.319500e+02 8.028750e+04 +7.319000e+02 8.020520e+04 +7.318500e+02 8.036550e+04 +7.318000e+02 8.052580e+04 +7.317500e+02 8.092250e+04 +7.317000e+02 8.131920e+04 +7.316500e+02 8.162200e+04 +7.316000e+02 8.192480e+04 +7.315500e+02 8.201220e+04 +7.315000e+02 8.209960e+04 +7.314500e+02 8.204980e+04 +7.314000e+02 8.200000e+04 +7.313500e+02 8.209520e+04 +7.313000e+02 8.219040e+04 +7.312500e+02 8.202980e+04 +7.312000e+02 8.186920e+04 +7.311500e+02 8.178620e+04 +7.311000e+02 8.170320e+04 +7.310500e+02 8.162650e+04 +7.310000e+02 8.154980e+04 +7.309500e+02 8.165670e+04 +7.309000e+02 8.176360e+04 +7.308500e+02 8.152330e+04 +7.308000e+02 8.128300e+04 +7.307500e+02 8.156130e+04 +7.307000e+02 8.183960e+04 +7.306500e+02 8.207880e+04 +7.306000e+02 8.231800e+04 +7.305500e+02 8.249330e+04 +7.305000e+02 8.266860e+04 +7.304500e+02 8.244270e+04 +7.304000e+02 8.221680e+04 +7.303500e+02 8.209770e+04 +7.303000e+02 8.197860e+04 +7.302500e+02 8.178650e+04 +7.302000e+02 8.159440e+04 +7.301500e+02 8.137310e+04 +7.301000e+02 8.115180e+04 +7.300500e+02 8.153900e+04 +7.300000e+02 8.192620e+04 +7.299500e+02 8.175440e+04 +7.299000e+02 8.158260e+04 +7.298500e+02 8.146370e+04 +7.298000e+02 8.134480e+04 +7.297500e+02 8.150800e+04 +7.297000e+02 8.167120e+04 +7.296500e+02 8.138080e+04 +7.296000e+02 8.109040e+04 +7.295500e+02 8.119050e+04 +7.295000e+02 8.129060e+04 +7.294500e+02 8.134190e+04 +7.294000e+02 8.139320e+04 +7.293500e+02 8.128090e+04 +7.293000e+02 8.116860e+04 +7.292500e+02 8.110170e+04 +7.292000e+02 8.103480e+04 +7.291500e+02 8.103770e+04 +7.291000e+02 8.104060e+04 +7.290500e+02 8.083480e+04 +7.290000e+02 8.062900e+04 +7.289500e+02 8.078450e+04 +7.289000e+02 8.094000e+04 +7.288500e+02 8.104260e+04 +7.288000e+02 8.114520e+04 +7.287500e+02 8.127850e+04 +7.287000e+02 8.141180e+04 +7.286500e+02 8.129280e+04 +7.286000e+02 8.117380e+04 +7.285500e+02 8.124000e+04 +7.285000e+02 8.130620e+04 +7.284500e+02 8.151050e+04 +7.284000e+02 8.171480e+04 +7.283500e+02 8.148190e+04 +7.283000e+02 8.124900e+04 +7.282500e+02 8.151630e+04 +7.282000e+02 8.178360e+04 +7.281500e+02 8.185930e+04 +7.281000e+02 8.193500e+04 +7.280500e+02 8.178340e+04 +7.280000e+02 8.163180e+04 +7.279500e+02 8.170780e+04 +7.279000e+02 8.178380e+04 +7.278500e+02 8.195090e+04 +7.278000e+02 8.211800e+04 +7.277500e+02 8.198070e+04 +7.277000e+02 8.184340e+04 +7.276500e+02 8.243500e+04 +7.276000e+02 8.302660e+04 +7.275500e+02 8.337110e+04 +7.275000e+02 8.371560e+04 +7.274500e+02 8.358440e+04 +7.274000e+02 8.345320e+04 +7.273500e+02 8.354690e+04 +7.273000e+02 8.364060e+04 +7.272500e+02 8.408270e+04 +7.272000e+02 8.452480e+04 +7.271500e+02 8.454650e+04 +7.271000e+02 8.456820e+04 +7.270500e+02 8.479670e+04 +7.270000e+02 8.502520e+04 +7.269500e+02 8.511800e+04 +7.269000e+02 8.521080e+04 +7.268500e+02 8.550530e+04 +7.268000e+02 8.579980e+04 +7.267500e+02 8.619020e+04 +7.267000e+02 8.658060e+04 +7.266500e+02 8.649450e+04 +7.266000e+02 8.640840e+04 +7.265500e+02 8.686340e+04 +7.265000e+02 8.731840e+04 +7.264500e+02 8.771220e+04 +7.264000e+02 8.810600e+04 +7.263500e+02 8.869380e+04 +7.263000e+02 8.928160e+04 +7.262500e+02 8.916930e+04 +7.262000e+02 8.905700e+04 +7.261500e+02 8.958920e+04 +7.261000e+02 9.012140e+04 +7.260500e+02 9.014380e+04 +7.260000e+02 9.016620e+04 +7.259500e+02 9.032060e+04 +7.259000e+02 9.047500e+04 +7.258500e+02 9.089450e+04 +7.258000e+02 9.131400e+04 +7.257500e+02 9.158170e+04 +7.257000e+02 9.184940e+04 +7.256500e+02 9.231550e+04 +7.256000e+02 9.278160e+04 +7.255500e+02 9.270470e+04 +7.255000e+02 9.262780e+04 +7.254500e+02 9.321490e+04 +7.254000e+02 9.380200e+04 +7.253500e+02 9.387170e+04 +7.253000e+02 9.394140e+04 +7.252500e+02 9.417190e+04 +7.252000e+02 9.440240e+04 +7.251500e+02 9.427050e+04 +7.251000e+02 9.413860e+04 +7.250500e+02 9.428580e+04 +7.250000e+02 9.443300e+04 +7.249500e+02 9.479790e+04 +7.249000e+02 9.516280e+04 +7.248500e+02 9.563880e+04 +7.248000e+02 9.611480e+04 +7.247500e+02 9.625700e+04 +7.247000e+02 9.639920e+04 +7.246500e+02 9.613290e+04 +7.246000e+02 9.586660e+04 +7.245500e+02 9.562140e+04 +7.245000e+02 9.537620e+04 +7.244500e+02 9.557760e+04 +7.244000e+02 9.577900e+04 +7.243500e+02 9.583000e+04 +7.243000e+02 9.588100e+04 +7.242500e+02 9.592270e+04 +7.242000e+02 9.596440e+04 +7.241500e+02 9.599970e+04 +7.241000e+02 9.603500e+04 +7.240500e+02 9.565040e+04 +7.240000e+02 9.526580e+04 +7.239500e+02 9.500280e+04 +7.239000e+02 9.473980e+04 +7.238500e+02 9.431930e+04 +7.238000e+02 9.389880e+04 +7.237500e+02 9.372390e+04 +7.237000e+02 9.354900e+04 +7.236500e+02 9.320220e+04 +7.236000e+02 9.285540e+04 +7.235500e+02 9.234580e+04 +7.235000e+02 9.183620e+04 +7.234500e+02 9.162880e+04 +7.234000e+02 9.142140e+04 +7.233500e+02 9.083780e+04 +7.233000e+02 9.025420e+04 +7.232500e+02 8.971650e+04 +7.232000e+02 8.917880e+04 +7.231500e+02 8.829250e+04 +7.231000e+02 8.740620e+04 +7.230500e+02 8.662530e+04 +7.230000e+02 8.584440e+04 +7.229500e+02 8.583420e+04 +7.229000e+02 8.582400e+04 +7.228500e+02 8.501210e+04 +7.228000e+02 8.420020e+04 +7.227500e+02 8.361800e+04 +7.227000e+02 8.303580e+04 +7.226500e+02 8.233560e+04 +7.226000e+02 8.163540e+04 +7.225500e+02 8.141730e+04 +7.225000e+02 8.119920e+04 +7.224500e+02 8.048600e+04 +7.224000e+02 7.977280e+04 +7.223500e+02 7.915310e+04 +7.223000e+02 7.853340e+04 +7.222500e+02 7.800360e+04 +7.222000e+02 7.747380e+04 +7.221500e+02 7.674840e+04 +7.221000e+02 7.602300e+04 +7.220500e+02 7.587690e+04 +7.220000e+02 7.573080e+04 +7.219500e+02 7.519060e+04 +7.219000e+02 7.465040e+04 +7.218500e+02 7.428680e+04 +7.218000e+02 7.392320e+04 +7.217500e+02 7.344510e+04 +7.217000e+02 7.296700e+04 +7.216500e+02 7.259310e+04 +7.216000e+02 7.221920e+04 +7.215500e+02 7.229700e+04 +7.215000e+02 7.237480e+04 +7.214500e+02 7.181940e+04 +7.214000e+02 7.126400e+04 +7.213500e+02 7.094210e+04 +7.213000e+02 7.062020e+04 +7.212500e+02 7.072060e+04 +7.212000e+02 7.082100e+04 +7.211500e+02 7.070800e+04 +7.211000e+02 7.059500e+04 +7.210500e+02 7.024310e+04 +7.210000e+02 6.989120e+04 +7.209500e+02 6.954180e+04 +7.209000e+02 6.919240e+04 +7.208500e+02 6.918850e+04 +7.208000e+02 6.918460e+04 +7.207500e+02 6.889060e+04 +7.207000e+02 6.859660e+04 +7.206500e+02 6.840560e+04 +7.206000e+02 6.821460e+04 +7.205500e+02 6.803200e+04 +7.205000e+02 6.784940e+04 +7.204500e+02 6.792880e+04 +7.204000e+02 6.800820e+04 +7.203500e+02 6.769040e+04 +7.203000e+02 6.737260e+04 +7.202500e+02 6.722610e+04 +7.202000e+02 6.707960e+04 +7.201500e+02 6.678880e+04 +7.201000e+02 6.649800e+04 +7.200500e+02 6.642610e+04 +7.200000e+02 6.635420e+04 +7.199500e+02 6.631620e+04 +7.199000e+02 6.627820e+04 +7.198500e+02 6.634510e+04 +7.198000e+02 6.641200e+04 +7.197500e+02 6.610810e+04 +7.197000e+02 6.580420e+04 +7.196500e+02 6.571520e+04 +7.196000e+02 6.562620e+04 +7.195500e+02 6.561520e+04 +7.195000e+02 6.560420e+04 +7.194500e+02 6.552850e+04 +7.194000e+02 6.545280e+04 +7.193500e+02 6.582720e+04 +7.193000e+02 6.620160e+04 +7.192500e+02 6.620070e+04 +7.192000e+02 6.619980e+04 +7.191500e+02 6.622670e+04 +7.191000e+02 6.625360e+04 +7.190500e+02 6.632200e+04 +7.190000e+02 6.639040e+04 +7.189500e+02 6.658780e+04 +7.189000e+02 6.678520e+04 +7.188500e+02 6.713990e+04 +7.188000e+02 6.749460e+04 +7.187500e+02 6.757590e+04 +7.187000e+02 6.765720e+04 +7.186500e+02 6.781200e+04 +7.186000e+02 6.796680e+04 +7.185500e+02 6.821740e+04 +7.185000e+02 6.846800e+04 +7.184500e+02 6.877890e+04 +7.184000e+02 6.908980e+04 +7.183500e+02 6.886230e+04 +7.183000e+02 6.863480e+04 +7.182500e+02 6.871660e+04 +7.182000e+02 6.879840e+04 +7.181500e+02 6.900580e+04 +7.181000e+02 6.921320e+04 +7.180500e+02 6.943250e+04 +7.180000e+02 6.965180e+04 +7.179500e+02 6.959360e+04 +7.179000e+02 6.953540e+04 +7.178500e+02 6.977400e+04 +7.178000e+02 7.001260e+04 +7.177500e+02 7.017350e+04 +7.177000e+02 7.033440e+04 +7.176500e+02 7.041900e+04 +7.176000e+02 7.050360e+04 +7.175500e+02 7.077380e+04 +7.175000e+02 7.104400e+04 +7.174500e+02 7.119140e+04 +7.174000e+02 7.133880e+04 +7.173500e+02 7.155950e+04 +7.173000e+02 7.178020e+04 +7.172500e+02 7.174570e+04 +7.172000e+02 7.171120e+04 +7.171500e+02 7.182900e+04 +7.171000e+02 7.194680e+04 +7.170500e+02 7.207840e+04 +7.170000e+02 7.221000e+04 +7.169500e+02 7.220060e+04 +7.169000e+02 7.219120e+04 +7.168500e+02 7.243510e+04 +7.168000e+02 7.267900e+04 +7.167500e+02 7.296550e+04 +7.167000e+02 7.325200e+04 +7.166500e+02 7.302920e+04 +7.166000e+02 7.280640e+04 +7.165500e+02 7.272990e+04 +7.165000e+02 7.265340e+04 +7.164500e+02 7.281960e+04 +7.164000e+02 7.298580e+04 +7.163500e+02 7.285610e+04 +7.163000e+02 7.272640e+04 +7.162500e+02 7.312920e+04 +7.162000e+02 7.353200e+04 +7.161500e+02 7.384460e+04 +7.161000e+02 7.415720e+04 +7.160500e+02 7.379570e+04 +7.160000e+02 7.343420e+04 +7.159500e+02 7.356130e+04 +7.159000e+02 7.368840e+04 +7.158500e+02 7.378110e+04 +7.158000e+02 7.387380e+04 +7.157500e+02 7.417490e+04 +7.157000e+02 7.447600e+04 +7.156500e+02 7.422980e+04 +7.156000e+02 7.398360e+04 +7.155500e+02 7.441190e+04 +7.155000e+02 7.484020e+04 +7.154500e+02 7.484140e+04 +7.154000e+02 7.484260e+04 +7.153500e+02 7.529960e+04 +7.153000e+02 7.575660e+04 +7.152500e+02 7.603600e+04 +7.152000e+02 7.631540e+04 +7.151500e+02 7.624300e+04 +7.151000e+02 7.617060e+04 +7.150500e+02 7.646380e+04 +7.150000e+02 7.675700e+04 +7.149500e+02 7.774420e+04 +7.149000e+02 7.873140e+04 +7.148500e+02 7.871130e+04 +7.148000e+02 7.869120e+04 +7.147500e+02 7.882160e+04 +7.147000e+02 7.895200e+04 +7.146500e+02 7.918040e+04 +7.146000e+02 7.940880e+04 +7.145500e+02 8.018170e+04 +7.145000e+02 8.095460e+04 +7.144500e+02 8.104480e+04 +7.144000e+02 8.113500e+04 +7.143500e+02 8.148060e+04 +7.143000e+02 8.182620e+04 +7.142500e+02 8.237500e+04 +7.142000e+02 8.292380e+04 +7.141500e+02 8.312760e+04 +7.141000e+02 8.333140e+04 +7.140500e+02 8.365000e+04 +7.140000e+02 8.396860e+04 +7.139500e+02 8.438530e+04 +7.139000e+02 8.480200e+04 +7.138500e+02 8.541090e+04 +7.138000e+02 8.601980e+04 +7.137500e+02 8.620250e+04 +7.137000e+02 8.638520e+04 +7.136500e+02 8.714540e+04 +7.136000e+02 8.790560e+04 +7.135500e+02 8.844760e+04 +7.135000e+02 8.898960e+04 +7.134500e+02 8.939730e+04 +7.134000e+02 8.980500e+04 +7.133500e+02 9.006860e+04 +7.133000e+02 9.033220e+04 +7.132500e+02 9.078270e+04 +7.132000e+02 9.123320e+04 +7.131500e+02 9.157100e+04 +7.131000e+02 9.190880e+04 +7.130500e+02 9.246500e+04 +7.130000e+02 9.302120e+04 +7.129500e+02 9.372660e+04 +7.129000e+02 9.443200e+04 +7.128500e+02 9.509350e+04 +7.128000e+02 9.575500e+04 +7.127500e+02 9.615070e+04 +7.127000e+02 9.654640e+04 +7.126500e+02 9.709700e+04 +7.126000e+02 9.764760e+04 +7.125500e+02 9.820020e+04 +7.125000e+02 9.875280e+04 +7.124500e+02 9.935110e+04 +7.124000e+02 9.994940e+04 +7.123500e+02 1.000845e+05 +7.123000e+02 1.002196e+05 +7.122500e+02 1.007537e+05 +7.122000e+02 1.012878e+05 +7.121500e+02 1.016118e+05 +7.121000e+02 1.019358e+05 +7.120500e+02 1.020674e+05 +7.120000e+02 1.021990e+05 +7.119500e+02 1.026650e+05 +7.119000e+02 1.031310e+05 +7.118500e+02 1.037264e+05 +7.118000e+02 1.043218e+05 +7.117500e+02 1.045238e+05 +7.117000e+02 1.047258e+05 +7.116500e+02 1.048164e+05 +7.116000e+02 1.049070e+05 +7.115500e+02 1.049042e+05 +7.115000e+02 1.049014e+05 +7.114500e+02 1.052140e+05 +7.114000e+02 1.055266e+05 +7.113500e+02 1.056180e+05 +7.113000e+02 1.057094e+05 +7.112500e+02 1.054246e+05 +7.112000e+02 1.051398e+05 +7.111500e+02 1.050304e+05 +7.111000e+02 1.049210e+05 +7.110500e+02 1.050387e+05 +7.110000e+02 1.051564e+05 +7.109500e+02 1.048102e+05 +7.109000e+02 1.044640e+05 +7.108500e+02 1.037588e+05 +7.108000e+02 1.030536e+05 +7.107500e+02 1.030827e+05 +7.107000e+02 1.031118e+05 +7.106500e+02 1.024109e+05 +7.106000e+02 1.017100e+05 +7.105500e+02 1.009083e+05 +7.105000e+02 1.001066e+05 +7.104500e+02 9.935640e+04 +7.104000e+02 9.860620e+04 +7.103500e+02 9.760050e+04 +7.103000e+02 9.659480e+04 +7.102500e+02 9.582840e+04 +7.102000e+02 9.506200e+04 +7.101500e+02 9.397460e+04 +7.101000e+02 9.288720e+04 +7.100500e+02 9.169810e+04 +7.100000e+02 9.050900e+04 +7.099500e+02 8.932750e+04 +7.099000e+02 8.814600e+04 +7.098500e+02 8.669460e+04 +7.098000e+02 8.524320e+04 +7.097500e+02 8.344420e+04 +7.097000e+02 8.164520e+04 +7.096500e+02 7.990650e+04 +7.096000e+02 7.816780e+04 +7.095500e+02 7.659110e+04 +7.095000e+02 7.501440e+04 +7.094500e+02 7.329160e+04 +7.094000e+02 7.156880e+04 +7.093500e+02 6.999080e+04 +7.093000e+02 6.841280e+04 +7.092500e+02 6.668660e+04 +7.092000e+02 6.496040e+04 +7.091500e+02 6.316170e+04 +7.091000e+02 6.136300e+04 +7.090500e+02 5.981500e+04 +7.090000e+02 5.826700e+04 +7.089500e+02 5.661060e+04 +7.089000e+02 5.495420e+04 +7.088500e+02 5.369920e+04 +7.088000e+02 5.244420e+04 +7.087500e+02 5.098720e+04 +7.087000e+02 4.953020e+04 +7.086500e+02 4.846140e+04 +7.086000e+02 4.739260e+04 +7.085500e+02 4.610320e+04 +7.085000e+02 4.481380e+04 +7.084500e+02 4.402320e+04 +7.084000e+02 4.323260e+04 +7.083500e+02 4.237250e+04 +7.083000e+02 4.151240e+04 +7.082500e+02 4.061440e+04 +7.082000e+02 3.971640e+04 +7.081500e+02 3.865210e+04 +7.081000e+02 3.758780e+04 +7.080500e+02 3.660260e+04 +7.080000e+02 3.561740e+04 +7.079500e+02 3.497580e+04 +7.079000e+02 3.433420e+04 +7.078500e+02 3.356850e+04 +7.078000e+02 3.280280e+04 +7.077500e+02 3.187580e+04 +7.077000e+02 3.094880e+04 +7.076500e+02 3.009880e+04 +7.076000e+02 2.924880e+04 +7.075500e+02 2.830310e+04 +7.075000e+02 2.735740e+04 +7.074500e+02 2.644840e+04 +7.074000e+02 2.553940e+04 +7.073500e+02 2.488710e+04 +7.073000e+02 2.423480e+04 +7.072500e+02 2.367210e+04 +7.072000e+02 2.310940e+04 +7.071500e+02 2.242910e+04 +7.071000e+02 2.174880e+04 +7.070500e+02 2.142320e+04 +7.070000e+02 2.109760e+04 +7.069500e+02 2.055100e+04 +7.069000e+02 2.000440e+04 +7.068500e+02 1.959511e+04 +7.068000e+02 1.918582e+04 +7.067500e+02 1.885619e+04 +7.067000e+02 1.852656e+04 +7.066500e+02 1.843577e+04 +7.066000e+02 1.834498e+04 +7.065500e+02 1.808119e+04 +7.065000e+02 1.781740e+04 +7.064500e+02 1.767567e+04 +7.064000e+02 1.753394e+04 +7.063500e+02 1.734022e+04 +7.063000e+02 1.714650e+04 +7.062500e+02 1.708368e+04 +7.062000e+02 1.702086e+04 +7.061500e+02 1.680645e+04 +7.061000e+02 1.659204e+04 +7.060500e+02 1.655760e+04 +7.060000e+02 1.652316e+04 +7.059500e+02 1.646983e+04 +7.059000e+02 1.641650e+04 +7.058500e+02 1.650532e+04 +7.058000e+02 1.659414e+04 +7.057500e+02 1.644141e+04 +7.057000e+02 1.628868e+04 +7.056500e+02 1.626794e+04 +7.056000e+02 1.624720e+04 +7.055500e+02 1.622762e+04 +7.055000e+02 1.620804e+04 +7.054500e+02 1.622836e+04 +7.054000e+02 1.624868e+04 +7.053500e+02 1.616095e+04 +7.053000e+02 1.607322e+04 +7.052500e+02 1.600091e+04 +7.052000e+02 1.592860e+04 +7.051500e+02 1.594476e+04 +7.051000e+02 1.596092e+04 +7.050500e+02 1.593030e+04 +7.050000e+02 1.589968e+04 +7.049500e+02 1.581810e+04 +7.049000e+02 1.573652e+04 +7.048500e+02 1.577881e+04 +7.048000e+02 1.582110e+04 +7.047500e+02 1.592210e+04 +7.047000e+02 1.602310e+04 +7.046500e+02 1.594062e+04 +7.046000e+02 1.585814e+04 +7.045500e+02 1.581329e+04 +7.045000e+02 1.576844e+04 +7.044500e+02 1.562472e+04 +7.044000e+02 1.548100e+04 +7.043500e+02 1.555841e+04 +7.043000e+02 1.563582e+04 +7.042500e+02 1.561696e+04 +7.042000e+02 1.559810e+04 +7.041500e+02 1.556607e+04 +7.041000e+02 1.553404e+04 +7.040500e+02 1.557015e+04 +7.040000e+02 1.560626e+04 +7.039500e+02 1.561778e+04 +7.039000e+02 1.562930e+04 +7.038500e+02 1.555956e+04 +7.038000e+02 1.548982e+04 +7.037500e+02 1.542996e+04 +7.037000e+02 1.537010e+04 +7.036500e+02 1.543257e+04 +7.036000e+02 1.549504e+04 +7.035500e+02 1.544951e+04 +7.035000e+02 1.540398e+04 +7.034500e+02 1.546655e+04 +7.034000e+02 1.552912e+04 +7.033500e+02 1.549409e+04 +7.033000e+02 1.545906e+04 +7.032500e+02 1.556801e+04 +7.032000e+02 1.567696e+04 +7.031500e+02 1.571813e+04 +7.031000e+02 1.575930e+04 +7.030500e+02 1.568680e+04 +7.030000e+02 1.561430e+04 +7.029500e+02 1.530508e+04 +7.029000e+02 1.499586e+04 +7.028500e+02 1.513263e+04 +7.028000e+02 1.526940e+04 +7.027500e+02 1.518240e+04 +7.027000e+02 1.509540e+04 +7.026500e+02 1.512582e+04 +7.026000e+02 1.515624e+04 +7.025500e+02 1.530192e+04 +7.025000e+02 1.544760e+04 +7.024500e+02 1.544336e+04 +7.024000e+02 1.543912e+04 +7.023500e+02 1.549412e+04 +7.023000e+02 1.554912e+04 +7.022500e+02 1.541209e+04 +7.022000e+02 1.527506e+04 +7.021500e+02 1.532739e+04 +7.021000e+02 1.537972e+04 +7.020500e+02 1.518443e+04 +7.020000e+02 1.498914e+04 +7.019500e+02 1.508829e+04 +7.019000e+02 1.518744e+04 +7.018500e+02 1.529796e+04 +7.018000e+02 1.540848e+04 +7.017500e+02 1.520807e+04 +7.017000e+02 1.500766e+04 +7.016500e+02 1.498925e+04 +7.016000e+02 1.497084e+04 +7.015500e+02 1.505711e+04 +7.015000e+02 1.514338e+04 +7.014500e+02 1.527249e+04 +7.014000e+02 1.540160e+04 +7.013500e+02 1.530604e+04 +7.013000e+02 1.521048e+04 +7.012500e+02 1.521229e+04 +7.012000e+02 1.521410e+04 +7.011500e+02 1.517314e+04 +7.011000e+02 1.513218e+04 +7.010500e+02 1.520395e+04 +7.010000e+02 1.527572e+04 +7.009500e+02 1.522925e+04 +7.009000e+02 1.518278e+04 +7.008500e+02 1.517817e+04 +7.008000e+02 1.517356e+04 +7.007500e+02 1.513241e+04 +7.007000e+02 1.509126e+04 +7.006500e+02 1.511443e+04 +7.006000e+02 1.513760e+04 +7.005500e+02 1.519997e+04 +7.005000e+02 1.526234e+04 +7.004500e+02 1.519069e+04 +7.004000e+02 1.511904e+04 +7.003500e+02 1.506209e+04 +7.003000e+02 1.500514e+04 +7.002500e+02 1.492596e+04 +7.002000e+02 1.484678e+04 +7.001500e+02 1.493822e+04 +7.001000e+02 1.502966e+04 +7.000500e+02 1.501746e+04 +7.000000e+02 1.500526e+04 +6.999500e+02 1.500526e+04 +6.999000e+02 1.500526e+04 +6.998500e+02 1.500526e+04 +6.998000e+02 1.500526e+04 +6.997500e+02 1.500526e+04 +6.997000e+02 1.500526e+04 +6.996500e+02 1.500526e+04 +6.996000e+02 1.500526e+04 +6.995500e+02 1.500526e+04 +6.995000e+02 1.500526e+04 +6.994500e+02 1.500526e+04 +6.994000e+02 1.500526e+04 +6.993500e+02 1.500526e+04 +6.993000e+02 1.500526e+04 +6.992500e+02 1.500526e+04 +6.992000e+02 1.500526e+04 +6.991500e+02 1.500526e+04 +6.991000e+02 1.500526e+04 +6.990500e+02 1.500526e+04 +6.990000e+02 1.500526e+04 +6.989500e+02 1.500526e+04 +6.989000e+02 1.500526e+04 +6.988500e+02 1.500526e+04 +6.988000e+02 1.500526e+04 +6.987500e+02 1.500526e+04 +6.987000e+02 1.500526e+04 +6.986500e+02 1.500526e+04 +6.986000e+02 1.500526e+04 +6.985500e+02 1.500526e+04 +6.985000e+02 1.500526e+04 +6.984500e+02 1.500526e+04 +6.984000e+02 1.500526e+04 +6.983500e+02 1.500526e+04 +6.983000e+02 1.500526e+04 +6.982500e+02 1.500526e+04 +6.982000e+02 1.500526e+04 +6.981500e+02 1.500526e+04 +6.981000e+02 1.500526e+04 +6.980500e+02 1.500526e+04 +6.980000e+02 1.500526e+04 +6.979500e+02 1.500526e+04 +6.979000e+02 1.500526e+04 +6.978500e+02 1.500526e+04 +6.978000e+02 1.500526e+04 +6.977500e+02 1.500526e+04 +6.977000e+02 1.500526e+04 +6.976500e+02 1.500526e+04 +6.976000e+02 1.500526e+04 +6.975500e+02 1.500526e+04 +6.975000e+02 1.500526e+04 +6.974500e+02 1.500526e+04 +6.974000e+02 1.500526e+04 +6.973500e+02 1.500526e+04 +6.973000e+02 1.500526e+04 +6.972500e+02 1.500526e+04 +6.972000e+02 1.500526e+04 +6.971500e+02 1.500526e+04 +6.971000e+02 1.500526e+04 +6.970500e+02 1.500526e+04 +6.970000e+02 1.500526e+04 +6.969500e+02 1.500526e+04 +6.969000e+02 1.500526e+04 +6.968500e+02 1.500526e+04 +6.968000e+02 1.500526e+04 +6.967500e+02 1.500526e+04 +6.967000e+02 1.500526e+04 +6.966500e+02 1.500526e+04 +6.966000e+02 1.500526e+04 +6.965500e+02 1.500526e+04 +6.965000e+02 1.500526e+04 +6.964500e+02 1.500526e+04 +6.964000e+02 1.500526e+04 +6.963500e+02 1.500526e+04 +6.963000e+02 1.500526e+04 +6.962500e+02 1.500526e+04 +6.962000e+02 1.500526e+04 +6.961500e+02 1.500526e+04 +6.961000e+02 1.500526e+04 +6.960500e+02 1.500526e+04 +6.960000e+02 1.500526e+04 +6.959500e+02 1.500526e+04 +6.959000e+02 1.500526e+04 +6.958500e+02 1.500526e+04 +6.958000e+02 1.500526e+04 +6.957500e+02 1.500526e+04 +6.957000e+02 1.500526e+04 +6.956500e+02 1.500526e+04 +6.956000e+02 1.500526e+04 +6.955500e+02 1.500526e+04 +6.955000e+02 1.500526e+04 +6.954500e+02 1.500526e+04 +6.954000e+02 1.500526e+04 +6.953500e+02 1.500526e+04 +6.953000e+02 1.500526e+04 +6.952500e+02 1.500526e+04 +6.952000e+02 1.500526e+04 +6.951500e+02 1.500526e+04 +6.951000e+02 1.500526e+04 +6.950500e+02 1.500526e+04 +6.950000e+02 1.500526e+04 +6.949500e+02 1.500526e+04 +6.949000e+02 1.500526e+04 +6.948500e+02 1.500526e+04 +6.948000e+02 1.500526e+04 +6.947500e+02 1.500526e+04 +6.947000e+02 1.500526e+04 +6.946500e+02 1.500526e+04 +6.946000e+02 1.500526e+04 +6.945500e+02 1.500526e+04 +6.945000e+02 1.500526e+04 +6.944500e+02 1.500526e+04 +6.944000e+02 1.500526e+04 +6.943500e+02 1.500526e+04 +6.943000e+02 1.500526e+04 +6.942500e+02 1.500526e+04 +6.942000e+02 1.500526e+04 +6.941500e+02 1.500526e+04 +6.941000e+02 1.500526e+04 +6.940500e+02 1.500526e+04 +6.940000e+02 1.500526e+04 diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe_metal.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe_metal.txt new file mode 100644 index 0000000000000000000000000000000000000000..0e890c81490719ab72c6f1acfc501debc7b6aa89 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe2p_Fe_metal.txt @@ -0,0 +1,1122 @@ +Fe2p Fe metal +7.500000e+002 4.415589e+004 +7.499500e+002 4.415589e+004 +7.499000e+002 4.390622e+004 +7.498500e+002 4.390622e+004 +7.498000e+002 4.406655e+004 +7.497500e+002 4.406655e+004 +7.497000e+002 4.432978e+004 +7.496500e+002 4.432978e+004 +7.496000e+002 4.455111e+004 +7.495500e+002 4.455111e+004 +7.495000e+002 4.420444e+004 +7.494500e+002 4.420444e+004 +7.494000e+002 4.428589e+004 +7.493500e+002 4.428589e+004 +7.493000e+002 4.447655e+004 +7.492500e+002 4.447655e+004 +7.492000e+002 4.483689e+004 +7.491500e+002 4.483689e+004 +7.491000e+002 4.458755e+004 +7.490500e+002 4.458755e+004 +7.490000e+002 4.458034e+004 +7.489500e+002 4.458034e+004 +7.489000e+002 4.447366e+004 +7.488500e+002 4.447366e+004 +7.488000e+002 4.454378e+004 +7.487500e+002 4.454378e+004 +7.487000e+002 4.485789e+004 +7.486500e+002 4.485789e+004 +7.486000e+002 4.471489e+004 +7.485500e+002 4.471489e+004 +7.485000e+002 4.500256e+004 +7.484500e+002 4.500256e+004 +7.484000e+002 4.504955e+004 +7.483500e+002 4.504955e+004 +7.483000e+002 4.497989e+004 +7.482500e+002 4.497989e+004 +7.482000e+002 4.494689e+004 +7.481500e+002 4.494689e+004 +7.481000e+002 4.514767e+004 +7.480500e+002 4.514767e+004 +7.480000e+002 4.533155e+004 +7.479500e+002 4.533155e+004 +7.479000e+002 4.518022e+004 +7.478500e+002 4.518022e+004 +7.478000e+002 4.527522e+004 +7.477500e+002 4.527522e+004 +7.477000e+002 4.548511e+004 +7.476500e+002 4.548511e+004 +7.476000e+002 4.547711e+004 +7.475500e+002 4.547711e+004 +7.475000e+002 4.547978e+004 +7.474500e+002 4.547978e+004 +7.474000e+002 4.532722e+004 +7.473500e+002 4.532722e+004 +7.473000e+002 4.531133e+004 +7.472500e+002 4.531133e+004 +7.472000e+002 4.563622e+004 +7.471500e+002 4.563622e+004 +7.471000e+002 4.585933e+004 +7.470500e+002 4.585933e+004 +7.470000e+002 4.576900e+004 +7.469500e+002 4.576900e+004 +7.469000e+002 4.574134e+004 +7.468500e+002 4.574134e+004 +7.468000e+002 4.586100e+004 +7.467500e+002 4.586100e+004 +7.467000e+002 4.574944e+004 +7.466500e+002 4.574944e+004 +7.466000e+002 4.582089e+004 +7.465500e+002 4.582089e+004 +7.465000e+002 4.588478e+004 +7.464500e+002 4.588478e+004 +7.464000e+002 4.619611e+004 +7.463500e+002 4.619611e+004 +7.463000e+002 4.618755e+004 +7.462500e+002 4.618755e+004 +7.462000e+002 4.620322e+004 +7.461500e+002 4.620322e+004 +7.461000e+002 4.629611e+004 +7.460500e+002 4.629611e+004 +7.460000e+002 4.627811e+004 +7.459500e+002 4.627811e+004 +7.459000e+002 4.634822e+004 +7.458500e+002 4.634822e+004 +7.458000e+002 4.634478e+004 +7.457500e+002 4.634478e+004 +7.457000e+002 4.645700e+004 +7.456500e+002 4.645700e+004 +7.456000e+002 4.643822e+004 +7.455500e+002 4.643822e+004 +7.455000e+002 4.639700e+004 +7.454500e+002 4.639700e+004 +7.454000e+002 4.665311e+004 +7.453500e+002 4.665311e+004 +7.453000e+002 4.674444e+004 +7.452500e+002 4.674444e+004 +7.452000e+002 4.669844e+004 +7.451500e+002 4.669844e+004 +7.451000e+002 4.683844e+004 +7.450500e+002 4.683844e+004 +7.450000e+002 4.671823e+004 +7.449500e+002 4.671823e+004 +7.449000e+002 4.670211e+004 +7.448500e+002 4.670211e+004 +7.448000e+002 4.685500e+004 +7.447500e+002 4.685500e+004 +7.447000e+002 4.703355e+004 +7.446500e+002 4.703355e+004 +7.446000e+002 4.709078e+004 +7.445500e+002 4.709078e+004 +7.445000e+002 4.741600e+004 +7.444500e+002 4.741600e+004 +7.444000e+002 4.727900e+004 +7.443500e+002 4.727900e+004 +7.443000e+002 4.706189e+004 +7.442500e+002 4.706189e+004 +7.442000e+002 4.712911e+004 +7.441500e+002 4.712911e+004 +7.441000e+002 4.705589e+004 +7.440500e+002 4.705589e+004 +7.440000e+002 4.707578e+004 +7.439500e+002 4.707578e+004 +7.439000e+002 4.721278e+004 +7.438500e+002 4.721278e+004 +7.438000e+002 4.717756e+004 +7.437500e+002 4.717756e+004 +7.437000e+002 4.735011e+004 +7.436500e+002 4.735011e+004 +7.436000e+002 4.730444e+004 +7.435500e+002 4.730444e+004 +7.435000e+002 4.713100e+004 +7.434500e+002 4.713100e+004 +7.434000e+002 4.742200e+004 +7.433500e+002 4.742200e+004 +7.433000e+002 4.740689e+004 +7.432500e+002 4.740689e+004 +7.432000e+002 4.751878e+004 +7.431500e+002 4.751878e+004 +7.431000e+002 4.762411e+004 +7.430500e+002 4.762411e+004 +7.430000e+002 4.738755e+004 +7.429500e+002 4.738755e+004 +7.429000e+002 4.740111e+004 +7.428500e+002 4.740111e+004 +7.428000e+002 4.750511e+004 +7.427500e+002 4.750511e+004 +7.427000e+002 4.780767e+004 +7.426500e+002 4.780767e+004 +7.426000e+002 4.746211e+004 +7.425500e+002 4.746211e+004 +7.425000e+002 4.744122e+004 +7.424500e+002 4.744122e+004 +7.424000e+002 4.761367e+004 +7.423500e+002 4.761367e+004 +7.423000e+002 4.753833e+004 +7.422500e+002 4.753833e+004 +7.422000e+002 4.754367e+004 +7.421500e+002 4.754367e+004 +7.421000e+002 4.762289e+004 +7.420500e+002 4.762289e+004 +7.420000e+002 4.803633e+004 +7.419500e+002 4.803633e+004 +7.419000e+002 4.778822e+004 +7.418500e+002 4.778822e+004 +7.418000e+002 4.769478e+004 +7.417500e+002 4.769478e+004 +7.417000e+002 4.759500e+004 +7.416500e+002 4.759500e+004 +7.416000e+002 4.763444e+004 +7.415500e+002 4.763444e+004 +7.415000e+002 4.786189e+004 +7.414500e+002 4.786189e+004 +7.414000e+002 4.789022e+004 +7.413500e+002 4.789022e+004 +7.413000e+002 4.769244e+004 +7.412500e+002 4.769244e+004 +7.412000e+002 4.780333e+004 +7.411500e+002 4.780333e+004 +7.411000e+002 4.780256e+004 +7.410500e+002 4.780256e+004 +7.410000e+002 4.766122e+004 +7.409500e+002 4.766122e+004 +7.409000e+002 4.765245e+004 +7.408500e+002 4.765245e+004 +7.408000e+002 4.780444e+004 +7.407500e+002 4.780444e+004 +7.407000e+002 4.779955e+004 +7.406500e+002 4.779955e+004 +7.406000e+002 4.776166e+004 +7.405500e+002 4.776166e+004 +7.405000e+002 4.763811e+004 +7.404500e+002 4.763811e+004 +7.404000e+002 4.795911e+004 +7.403500e+002 4.795911e+004 +7.403000e+002 4.780167e+004 +7.402500e+002 4.780167e+004 +7.402000e+002 4.797366e+004 +7.401500e+002 4.797366e+004 +7.401000e+002 4.788522e+004 +7.400500e+002 4.788522e+004 +7.400000e+002 4.805833e+004 +7.399500e+002 4.805833e+004 +7.399000e+002 4.791656e+004 +7.398500e+002 4.791656e+004 +7.398000e+002 4.796833e+004 +7.397500e+002 4.796833e+004 +7.397000e+002 4.797589e+004 +7.396500e+002 4.797589e+004 +7.396000e+002 4.796989e+004 +7.395500e+002 4.796989e+004 +7.395000e+002 4.798233e+004 +7.394500e+002 4.798233e+004 +7.394000e+002 4.841911e+004 +7.393500e+002 4.841911e+004 +7.393000e+002 4.801511e+004 +7.392500e+002 4.801511e+004 +7.392000e+002 4.800756e+004 +7.391500e+002 4.800756e+004 +7.391000e+002 4.800367e+004 +7.390500e+002 4.800367e+004 +7.390000e+002 4.829855e+004 +7.389500e+002 4.829855e+004 +7.389000e+002 4.836255e+004 +7.388500e+002 4.836255e+004 +7.388000e+002 4.831411e+004 +7.387500e+002 4.831411e+004 +7.387000e+002 4.843455e+004 +7.386500e+002 4.843455e+004 +7.386000e+002 4.857222e+004 +7.385500e+002 4.857222e+004 +7.385000e+002 4.851689e+004 +7.384500e+002 4.851689e+004 +7.384000e+002 4.858556e+004 +7.383500e+002 4.858556e+004 +7.383000e+002 4.851289e+004 +7.382500e+002 4.851289e+004 +7.382000e+002 4.863978e+004 +7.381500e+002 4.863978e+004 +7.381000e+002 4.896989e+004 +7.380500e+002 4.896989e+004 +7.380000e+002 4.880411e+004 +7.379500e+002 4.880411e+004 +7.379000e+002 4.883922e+004 +7.378500e+002 4.883922e+004 +7.378000e+002 4.882444e+004 +7.377500e+002 4.882444e+004 +7.377000e+002 4.896989e+004 +7.376500e+002 4.896989e+004 +7.376000e+002 4.888233e+004 +7.375500e+002 4.888233e+004 +7.375000e+002 4.930067e+004 +7.374500e+002 4.930067e+004 +7.374000e+002 4.928622e+004 +7.373500e+002 4.928622e+004 +7.373000e+002 4.936800e+004 +7.372500e+002 4.936800e+004 +7.372000e+002 4.915888e+004 +7.371500e+002 4.915888e+004 +7.371000e+002 4.930078e+004 +7.370500e+002 4.930078e+004 +7.370000e+002 4.923722e+004 +7.369500e+002 4.923722e+004 +7.369000e+002 4.923122e+004 +7.368500e+002 4.923122e+004 +7.368000e+002 4.945900e+004 +7.367500e+002 4.945900e+004 +7.367000e+002 4.931955e+004 +7.366500e+002 4.931955e+004 +7.366000e+002 4.957311e+004 +7.365500e+002 4.957311e+004 +7.365000e+002 4.944900e+004 +7.364500e+002 4.944900e+004 +7.364000e+002 4.950955e+004 +7.363500e+002 4.950955e+004 +7.363000e+002 4.967344e+004 +7.362500e+002 4.967344e+004 +7.362000e+002 4.975478e+004 +7.361500e+002 4.975478e+004 +7.361000e+002 4.993989e+004 +7.360500e+002 4.993989e+004 +7.360000e+002 4.983956e+004 +7.359500e+002 4.983956e+004 +7.359000e+002 4.985444e+004 +7.358500e+002 4.985444e+004 +7.358000e+002 4.974645e+004 +7.357500e+002 4.974645e+004 +7.357000e+002 4.994177e+004 +7.356500e+002 4.994177e+004 +7.356000e+002 5.033222e+004 +7.355500e+002 5.033222e+004 +7.355000e+002 5.036545e+004 +7.354500e+002 5.036545e+004 +7.354000e+002 5.016267e+004 +7.353500e+002 5.016267e+004 +7.353000e+002 5.016966e+004 +7.352500e+002 5.016966e+004 +7.352000e+002 5.047177e+004 +7.351500e+002 5.047177e+004 +7.351000e+002 5.058878e+004 +7.350500e+002 5.058878e+004 +7.350000e+002 5.047489e+004 +7.349500e+002 5.047489e+004 +7.349000e+002 5.030389e+004 +7.348500e+002 5.030389e+004 +7.348000e+002 5.029489e+004 +7.347500e+002 5.029489e+004 +7.347000e+002 5.066845e+004 +7.346500e+002 5.066845e+004 +7.346000e+002 5.063022e+004 +7.345500e+002 5.063022e+004 +7.345000e+002 5.073566e+004 +7.344500e+002 5.073566e+004 +7.344000e+002 5.089177e+004 +7.343500e+002 5.089177e+004 +7.343000e+002 5.086511e+004 +7.342500e+002 5.086511e+004 +7.342000e+002 5.091222e+004 +7.341500e+002 5.091222e+004 +7.341000e+002 5.096533e+004 +7.340500e+002 5.096533e+004 +7.340000e+002 5.117389e+004 +7.339500e+002 5.117389e+004 +7.339000e+002 5.124789e+004 +7.338500e+002 5.124789e+004 +7.338000e+002 5.123189e+004 +7.337500e+002 5.123189e+004 +7.337000e+002 5.124711e+004 +7.336500e+002 5.124711e+004 +7.336000e+002 5.141011e+004 +7.335500e+002 5.141011e+004 +7.335000e+002 5.142444e+004 +7.334500e+002 5.142444e+004 +7.334000e+002 5.134167e+004 +7.333500e+002 5.134167e+004 +7.333000e+002 5.147366e+004 +7.332500e+002 5.147366e+004 +7.332000e+002 5.144000e+004 +7.331500e+002 5.144000e+004 +7.331000e+002 5.162745e+004 +7.330500e+002 5.162745e+004 +7.330000e+002 5.202667e+004 +7.329500e+002 5.202667e+004 +7.329000e+002 5.206855e+004 +7.328500e+002 5.206855e+004 +7.328000e+002 5.170378e+004 +7.327500e+002 5.170378e+004 +7.327000e+002 5.170311e+004 +7.326500e+002 5.170311e+004 +7.326000e+002 5.197845e+004 +7.325500e+002 5.197845e+004 +7.325000e+002 5.184933e+004 +7.324500e+002 5.184933e+004 +7.324000e+002 5.209811e+004 +7.323500e+002 5.209811e+004 +7.323000e+002 5.232167e+004 +7.322500e+002 5.232167e+004 +7.322000e+002 5.221711e+004 +7.321500e+002 5.221711e+004 +7.321000e+002 5.195333e+004 +7.320500e+002 5.195333e+004 +7.320000e+002 5.237433e+004 +7.319500e+002 5.237433e+004 +7.319000e+002 5.248466e+004 +7.318500e+002 5.248466e+004 +7.318000e+002 5.242622e+004 +7.317500e+002 5.242622e+004 +7.317000e+002 5.245422e+004 +7.316500e+002 5.245422e+004 +7.316000e+002 5.246034e+004 +7.315500e+002 5.246034e+004 +7.315000e+002 5.249522e+004 +7.314500e+002 5.249522e+004 +7.314000e+002 5.247344e+004 +7.313500e+002 5.247344e+004 +7.313000e+002 5.278500e+004 +7.312500e+002 5.278500e+004 +7.312000e+002 5.253311e+004 +7.311500e+002 5.253311e+004 +7.311000e+002 5.246600e+004 +7.310500e+002 5.246600e+004 +7.310000e+002 5.265811e+004 +7.309500e+002 5.265811e+004 +7.309000e+002 5.253833e+004 +7.308500e+002 5.253833e+004 +7.308000e+002 5.261367e+004 +7.307500e+002 5.261367e+004 +7.307000e+002 5.271333e+004 +7.306500e+002 5.271333e+004 +7.306000e+002 5.255611e+004 +7.305500e+002 5.255611e+004 +7.305000e+002 5.273066e+004 +7.304500e+002 5.273066e+004 +7.304000e+002 5.249922e+004 +7.303500e+002 5.249922e+004 +7.303000e+002 5.249978e+004 +7.302500e+002 5.249978e+004 +7.302000e+002 5.246089e+004 +7.301500e+002 5.246089e+004 +7.301000e+002 5.267966e+004 +7.300500e+002 5.267966e+004 +7.300000e+002 5.283056e+004 +7.299500e+002 5.283056e+004 +7.299000e+002 5.291922e+004 +7.298500e+002 5.291922e+004 +7.298000e+002 5.257611e+004 +7.297500e+002 5.257611e+004 +7.297000e+002 5.280278e+004 +7.296500e+002 5.280278e+004 +7.296000e+002 5.281500e+004 +7.295500e+002 5.281500e+004 +7.295000e+002 5.283778e+004 +7.294500e+002 5.283778e+004 +7.294000e+002 5.274689e+004 +7.293500e+002 5.274689e+004 +7.293000e+002 5.267878e+004 +7.292500e+002 5.267878e+004 +7.292000e+002 5.298511e+004 +7.291500e+002 5.298511e+004 +7.291000e+002 5.280355e+004 +7.290500e+002 5.280355e+004 +7.290000e+002 5.301034e+004 +7.289500e+002 5.301034e+004 +7.289000e+002 5.261845e+004 +7.288500e+002 5.261845e+004 +7.288000e+002 5.282900e+004 +7.287500e+002 5.282900e+004 +7.287000e+002 5.265245e+004 +7.286500e+002 5.265245e+004 +7.286000e+002 5.264300e+004 +7.285500e+002 5.264300e+004 +7.285000e+002 5.279866e+004 +7.284500e+002 5.279866e+004 +7.284000e+002 5.271867e+004 +7.283500e+002 5.271867e+004 +7.283000e+002 5.276778e+004 +7.282500e+002 5.276778e+004 +7.282000e+002 5.268911e+004 +7.281500e+002 5.268911e+004 +7.281000e+002 5.281789e+004 +7.280500e+002 5.281789e+004 +7.280000e+002 5.294600e+004 +7.279500e+002 5.294600e+004 +7.279000e+002 5.308578e+004 +7.278500e+002 5.308578e+004 +7.278000e+002 5.305888e+004 +7.277500e+002 5.305888e+004 +7.277000e+002 5.265611e+004 +7.276500e+002 5.265611e+004 +7.276000e+002 5.292366e+004 +7.275500e+002 5.292366e+004 +7.275000e+002 5.312100e+004 +7.274500e+002 5.312100e+004 +7.274000e+002 5.324134e+004 +7.273500e+002 5.324134e+004 +7.273000e+002 5.336867e+004 +7.272500e+002 5.336867e+004 +7.272000e+002 5.331356e+004 +7.271500e+002 5.331356e+004 +7.271000e+002 5.318978e+004 +7.270500e+002 5.318978e+004 +7.270000e+002 5.309900e+004 +7.269500e+002 5.309900e+004 +7.269000e+002 5.326966e+004 +7.268500e+002 5.326966e+004 +7.268000e+002 5.334489e+004 +7.267500e+002 5.334489e+004 +7.267000e+002 5.333344e+004 +7.266500e+002 5.333344e+004 +7.266000e+002 5.323867e+004 +7.265500e+002 5.323867e+004 +7.265000e+002 5.367633e+004 +7.264500e+002 5.367633e+004 +7.264000e+002 5.333611e+004 +7.263500e+002 5.333611e+004 +7.263000e+002 5.335289e+004 +7.262500e+002 5.335289e+004 +7.262000e+002 5.370900e+004 +7.261500e+002 5.370900e+004 +7.261000e+002 5.349200e+004 +7.260500e+002 5.349200e+004 +7.260000e+002 5.372167e+004 +7.259500e+002 5.372167e+004 +7.259000e+002 5.389566e+004 +7.258500e+002 5.389566e+004 +7.258000e+002 5.378366e+004 +7.257500e+002 5.378366e+004 +7.257000e+002 5.385778e+004 +7.256500e+002 5.385778e+004 +7.256000e+002 5.429267e+004 +7.255500e+002 5.429267e+004 +7.255000e+002 5.423800e+004 +7.254500e+002 5.423800e+004 +7.254000e+002 5.428666e+004 +7.253500e+002 5.428666e+004 +7.253000e+002 5.403956e+004 +7.252500e+002 5.403956e+004 +7.252000e+002 5.423433e+004 +7.251500e+002 5.423433e+004 +7.251000e+002 5.436155e+004 +7.250500e+002 5.436155e+004 +7.250000e+002 5.429422e+004 +7.249500e+002 5.429422e+004 +7.249000e+002 5.435534e+004 +7.248500e+002 5.435534e+004 +7.248000e+002 5.452611e+004 +7.247500e+002 5.452611e+004 +7.247000e+002 5.460811e+004 +7.246500e+002 5.460811e+004 +7.246000e+002 5.470911e+004 +7.245500e+002 5.470911e+004 +7.245000e+002 5.503167e+004 +7.244500e+002 5.503167e+004 +7.244000e+002 5.490822e+004 +7.243500e+002 5.490822e+004 +7.243000e+002 5.503778e+004 +7.242500e+002 5.503778e+004 +7.242000e+002 5.517889e+004 +7.241500e+002 5.517889e+004 +7.241000e+002 5.520977e+004 +7.240500e+002 5.520977e+004 +7.240000e+002 5.540433e+004 +7.239500e+002 5.540433e+004 +7.239000e+002 5.539945e+004 +7.238500e+002 5.539945e+004 +7.238000e+002 5.570077e+004 +7.237500e+002 5.570077e+004 +7.237000e+002 5.622055e+004 +7.236500e+002 5.622055e+004 +7.236000e+002 5.626100e+004 +7.235500e+002 5.626100e+004 +7.235000e+002 5.672989e+004 +7.234500e+002 5.672989e+004 +7.234000e+002 5.714300e+004 +7.233500e+002 5.714300e+004 +7.233000e+002 5.743700e+004 +7.232500e+002 5.743700e+004 +7.232000e+002 5.746111e+004 +7.231500e+002 5.746111e+004 +7.231000e+002 5.785267e+004 +7.230500e+002 5.785267e+004 +7.230000e+002 5.819145e+004 +7.229500e+002 5.819145e+004 +7.229000e+002 5.876967e+004 +7.228500e+002 5.876967e+004 +7.228000e+002 5.926678e+004 +7.227500e+002 5.926678e+004 +7.227000e+002 5.971067e+004 +7.226500e+002 5.971067e+004 +7.226000e+002 6.012277e+004 +7.225500e+002 6.012277e+004 +7.225000e+002 6.080734e+004 +7.224500e+002 6.080734e+004 +7.224000e+002 6.144577e+004 +7.223500e+002 6.144577e+004 +7.223000e+002 6.212400e+004 +7.222500e+002 6.212400e+004 +7.222000e+002 6.256955e+004 +7.221500e+002 6.256955e+004 +7.221000e+002 6.351000e+004 +7.220500e+002 6.351000e+004 +7.220000e+002 6.400467e+004 +7.219500e+002 6.400467e+004 +7.219000e+002 6.479067e+004 +7.218500e+002 6.479067e+004 +7.218000e+002 6.594889e+004 +7.217500e+002 6.594889e+004 +7.217000e+002 6.689900e+004 +7.216500e+002 6.689900e+004 +7.216000e+002 6.836678e+004 +7.215500e+002 6.836678e+004 +7.215000e+002 6.904423e+004 +7.214500e+002 6.904423e+004 +7.214000e+002 6.994467e+004 +7.213500e+002 6.994467e+004 +7.213000e+002 7.185189e+004 +7.212500e+002 7.185189e+004 +7.212000e+002 7.333822e+004 +7.211500e+002 7.333822e+004 +7.211000e+002 7.513023e+004 +7.210500e+002 7.513023e+004 +7.210000e+002 7.664411e+004 +7.209500e+002 7.664411e+004 +7.209000e+002 7.825533e+004 +7.208500e+002 7.825533e+004 +7.208000e+002 8.047956e+004 +7.207500e+002 8.047956e+004 +7.207000e+002 8.280222e+004 +7.206500e+002 8.280222e+004 +7.206000e+002 8.538844e+004 +7.205500e+002 8.538844e+004 +7.205000e+002 8.839122e+004 +7.204500e+002 8.839122e+004 +7.204000e+002 9.050566e+004 +7.203500e+002 9.050566e+004 +7.203000e+002 9.338378e+004 +7.202500e+002 9.338378e+004 +7.202000e+002 9.622656e+004 +7.201500e+002 9.622656e+004 +7.201000e+002 9.849956e+004 +7.200500e+002 9.849956e+004 +7.200000e+002 1.000618e+005 +7.199500e+002 1.000618e+005 +7.199000e+002 1.009709e+005 +7.198500e+002 1.009709e+005 +7.198000e+002 1.005488e+005 +7.197500e+002 1.005488e+005 +7.197000e+002 9.961299e+004 +7.196500e+002 9.961299e+004 +7.196000e+002 9.724589e+004 +7.195500e+002 9.724589e+004 +7.195000e+002 9.434788e+004 +7.194500e+002 9.434788e+004 +7.194000e+002 8.991766e+004 +7.193500e+002 8.991766e+004 +7.193000e+002 8.515156e+004 +7.192500e+002 8.515156e+004 +7.192000e+002 7.934589e+004 +7.191500e+002 7.934589e+004 +7.191000e+002 7.368989e+004 +7.190500e+002 7.368989e+004 +7.190000e+002 6.848600e+004 +7.189500e+002 6.848600e+004 +7.189000e+002 6.379811e+004 +7.188500e+002 6.379811e+004 +7.188000e+002 5.988844e+004 +7.187500e+002 5.988844e+004 +7.187000e+002 5.678234e+004 +7.186500e+002 5.678234e+004 +7.186000e+002 5.411567e+004 +7.185500e+002 5.411567e+004 +7.185000e+002 5.176733e+004 +7.184500e+002 5.176733e+004 +7.184000e+002 4.982411e+004 +7.183500e+002 4.982411e+004 +7.183000e+002 4.826811e+004 +7.182500e+002 4.826811e+004 +7.182000e+002 4.721089e+004 +7.181500e+002 4.721089e+004 +7.181000e+002 4.623366e+004 +7.180500e+002 4.623366e+004 +7.180000e+002 4.496866e+004 +7.179500e+002 4.496866e+004 +7.179000e+002 4.449878e+004 +7.178500e+002 4.449878e+004 +7.178000e+002 4.393444e+004 +7.177500e+002 4.393444e+004 +7.177000e+002 4.323311e+004 +7.176500e+002 4.323311e+004 +7.176000e+002 4.278400e+004 +7.175500e+002 4.278400e+004 +7.175000e+002 4.227177e+004 +7.174500e+002 4.227177e+004 +7.174000e+002 4.215100e+004 +7.173500e+002 4.215100e+004 +7.173000e+002 4.187889e+004 +7.172500e+002 4.187889e+004 +7.172000e+002 4.158889e+004 +7.171500e+002 4.158889e+004 +7.171000e+002 4.139966e+004 +7.170500e+002 4.139966e+004 +7.170000e+002 4.103811e+004 +7.169500e+002 4.103811e+004 +7.169000e+002 4.090667e+004 +7.168500e+002 4.090667e+004 +7.168000e+002 4.084155e+004 +7.167500e+002 4.084155e+004 +7.167000e+002 4.062789e+004 +7.166500e+002 4.062789e+004 +7.166000e+002 4.067966e+004 +7.165500e+002 4.067966e+004 +7.165000e+002 4.060056e+004 +7.164500e+002 4.060056e+004 +7.164000e+002 4.047811e+004 +7.163500e+002 4.047811e+004 +7.163000e+002 4.038944e+004 +7.162500e+002 4.038944e+004 +7.162000e+002 4.059355e+004 +7.161500e+002 4.059355e+004 +7.161000e+002 4.065067e+004 +7.160500e+002 4.065067e+004 +7.160000e+002 4.051411e+004 +7.159500e+002 4.051411e+004 +7.159000e+002 4.063600e+004 +7.158500e+002 4.063600e+004 +7.158000e+002 4.062411e+004 +7.157500e+002 4.062411e+004 +7.157000e+002 4.079033e+004 +7.156500e+002 4.079033e+004 +7.156000e+002 4.078511e+004 +7.155500e+002 4.078511e+004 +7.155000e+002 4.095322e+004 +7.154500e+002 4.095322e+004 +7.154000e+002 4.082756e+004 +7.153500e+002 4.082756e+004 +7.153000e+002 4.079133e+004 +7.152500e+002 4.079133e+004 +7.152000e+002 4.101222e+004 +7.151500e+002 4.101222e+004 +7.151000e+002 4.099355e+004 +7.150500e+002 4.099355e+004 +7.150000e+002 4.143744e+004 +7.149500e+002 4.143744e+004 +7.149000e+002 4.147333e+004 +7.148500e+002 4.147333e+004 +7.148000e+002 4.174489e+004 +7.147500e+002 4.174489e+004 +7.147000e+002 4.176677e+004 +7.146500e+002 4.176677e+004 +7.146000e+002 4.181167e+004 +7.145500e+002 4.181167e+004 +7.145000e+002 4.186311e+004 +7.144500e+002 4.186311e+004 +7.144000e+002 4.202289e+004 +7.143500e+002 4.202289e+004 +7.143000e+002 4.217433e+004 +7.142500e+002 4.217433e+004 +7.142000e+002 4.244455e+004 +7.141500e+002 4.244455e+004 +7.141000e+002 4.229211e+004 +7.140500e+002 4.229211e+004 +7.140000e+002 4.258367e+004 +7.139500e+002 4.258367e+004 +7.139000e+002 4.278066e+004 +7.138500e+002 4.278066e+004 +7.138000e+002 4.287333e+004 +7.137500e+002 4.287333e+004 +7.137000e+002 4.314389e+004 +7.136500e+002 4.314389e+004 +7.136000e+002 4.336966e+004 +7.135500e+002 4.336966e+004 +7.135000e+002 4.345244e+004 +7.134500e+002 4.345244e+004 +7.134000e+002 4.341633e+004 +7.133500e+002 4.341633e+004 +7.133000e+002 4.345067e+004 +7.132500e+002 4.345067e+004 +7.132000e+002 4.392144e+004 +7.131500e+002 4.392144e+004 +7.131000e+002 4.387122e+004 +7.130500e+002 4.387122e+004 +7.130000e+002 4.397855e+004 +7.129500e+002 4.397855e+004 +7.129000e+002 4.410578e+004 +7.128500e+002 4.410578e+004 +7.128000e+002 4.428322e+004 +7.127500e+002 4.428322e+004 +7.127000e+002 4.432534e+004 +7.126500e+002 4.432534e+004 +7.126000e+002 4.411989e+004 +7.125500e+002 4.411989e+004 +7.125000e+002 4.453789e+004 +7.124500e+002 4.453789e+004 +7.124000e+002 4.474466e+004 +7.123500e+002 4.474466e+004 +7.123000e+002 4.510655e+004 +7.122500e+002 4.510655e+004 +7.122000e+002 4.532067e+004 +7.121500e+002 4.532067e+004 +7.121000e+002 4.521744e+004 +7.120500e+002 4.521744e+004 +7.120000e+002 4.542078e+004 +7.119500e+002 4.542078e+004 +7.119000e+002 4.603600e+004 +7.118500e+002 4.603600e+004 +7.118000e+002 4.633966e+004 +7.117500e+002 4.633966e+004 +7.117000e+002 4.640333e+004 +7.116500e+002 4.640333e+004 +7.116000e+002 4.668889e+004 +7.115500e+002 4.668889e+004 +7.115000e+002 4.723944e+004 +7.114500e+002 4.723944e+004 +7.114000e+002 4.748378e+004 +7.113500e+002 4.748378e+004 +7.113000e+002 4.780022e+004 +7.112500e+002 4.780022e+004 +7.112000e+002 4.824600e+004 +7.111500e+002 4.824600e+004 +7.111000e+002 4.873167e+004 +7.110500e+002 4.873167e+004 +7.110000e+002 4.937500e+004 +7.109500e+002 4.937500e+004 +7.109000e+002 4.974411e+004 +7.108500e+002 4.974411e+004 +7.108000e+002 5.004311e+004 +7.107500e+002 5.004311e+004 +7.107000e+002 5.078922e+004 +7.106500e+002 5.078922e+004 +7.106000e+002 5.118388e+004 +7.105500e+002 5.118388e+004 +7.105000e+002 5.149478e+004 +7.104500e+002 5.149478e+004 +7.104000e+002 5.180789e+004 +7.103500e+002 5.180789e+004 +7.103000e+002 5.255400e+004 +7.102500e+002 5.255400e+004 +7.102000e+002 5.279489e+004 +7.101500e+002 5.279489e+004 +7.101000e+002 5.354289e+004 +7.100500e+002 5.354289e+004 +7.100000e+002 5.398145e+004 +7.099500e+002 5.398145e+004 +7.099000e+002 5.455978e+004 +7.098500e+002 5.455978e+004 +7.098000e+002 5.529844e+004 +7.097500e+002 5.529844e+004 +7.097000e+002 5.568689e+004 +7.096500e+002 5.568689e+004 +7.096000e+002 5.636923e+004 +7.095500e+002 5.636923e+004 +7.095000e+002 5.722600e+004 +7.094500e+002 5.722600e+004 +7.094000e+002 5.806844e+004 +7.093500e+002 5.806844e+004 +7.093000e+002 5.862788e+004 +7.092500e+002 5.862788e+004 +7.092000e+002 5.975478e+004 +7.091500e+002 5.975478e+004 +7.091000e+002 6.123411e+004 +7.090500e+002 6.123411e+004 +7.090000e+002 6.225811e+004 +7.089500e+002 6.225811e+004 +7.089000e+002 6.340189e+004 +7.088500e+002 6.340189e+004 +7.088000e+002 6.507389e+004 +7.087500e+002 6.507389e+004 +7.087000e+002 6.698533e+004 +7.086500e+002 6.698533e+004 +7.086000e+002 6.883367e+004 +7.085500e+002 6.883367e+004 +7.085000e+002 7.090900e+004 +7.084500e+002 7.090900e+004 +7.084000e+002 7.350344e+004 +7.083500e+002 7.350344e+004 +7.083000e+002 7.695755e+004 +7.082500e+002 7.695755e+004 +7.082000e+002 8.053688e+004 +7.081500e+002 8.053688e+004 +7.081000e+002 8.443688e+004 +7.080500e+002 8.443688e+004 +7.080000e+002 8.897244e+004 +7.079500e+002 8.897244e+004 +7.079000e+002 9.523878e+004 +7.078500e+002 9.523878e+004 +7.078000e+002 1.013066e+005 +7.077500e+002 1.013066e+005 +7.077000e+002 1.078080e+005 +7.076500e+002 1.078080e+005 +7.076000e+002 1.147989e+005 +7.075500e+002 1.147989e+005 +7.075000e+002 1.212311e+005 +7.074500e+002 1.212311e+005 +7.074000e+002 1.271122e+005 +7.073500e+002 1.271122e+005 +7.073000e+002 1.325344e+005 +7.072500e+002 1.325344e+005 +7.072000e+002 1.387678e+005 +7.071500e+002 1.387678e+005 +7.071000e+002 1.469278e+005 +7.070500e+002 1.469278e+005 +7.070000e+002 1.564122e+005 +7.069500e+002 1.564122e+005 +7.069000e+002 1.673933e+005 +7.068500e+002 1.673933e+005 +7.068000e+002 1.773644e+005 +7.067500e+002 1.773644e+005 +7.067000e+002 1.828344e+005 +7.066500e+002 1.828344e+005 +7.066000e+002 1.804333e+005 +7.065500e+002 1.804333e+005 +7.065000e+002 1.674933e+005 +7.064500e+002 1.674933e+005 +7.064000e+002 1.453800e+005 +7.063500e+002 1.453800e+005 +7.063000e+002 1.172233e+005 +7.062500e+002 1.172233e+005 +7.062000e+002 8.906822e+004 +7.061500e+002 8.906822e+004 +7.061000e+002 6.505567e+004 +7.060500e+002 6.505567e+004 +7.060000e+002 4.748133e+004 +7.059500e+002 4.748133e+004 +7.059000e+002 3.552655e+004 +7.058500e+002 3.552655e+004 +7.058000e+002 2.784122e+004 +7.057500e+002 2.784122e+004 +7.057000e+002 2.284422e+004 +7.056500e+002 2.284422e+004 +7.056000e+002 1.927733e+004 +7.055500e+002 1.927733e+004 +7.055000e+002 1.671933e+004 +7.054500e+002 1.671933e+004 +7.054000e+002 1.475711e+004 +7.053500e+002 1.475711e+004 +7.053000e+002 1.338578e+004 +7.052500e+002 1.338578e+004 +7.052000e+002 1.227344e+004 +7.051500e+002 1.227344e+004 +7.051000e+002 1.146589e+004 +7.050500e+002 1.146589e+004 +7.050000e+002 1.073958e+004 +7.049500e+002 1.073958e+004 +7.049000e+002 1.009879e+004 +7.048500e+002 1.009879e+004 +7.048000e+002 9.549822e+003 +7.047500e+002 9.549822e+003 +7.047000e+002 8.984211e+003 +7.046500e+002 8.984211e+003 +7.046000e+002 8.472423e+003 +7.045500e+002 8.472423e+003 +7.045000e+002 8.117766e+003 +7.044500e+002 8.117766e+003 +7.044000e+002 7.918577e+003 +7.043500e+002 7.918577e+003 +7.043000e+002 7.694277e+003 +7.042500e+002 7.694277e+003 +7.042000e+002 7.387667e+003 +7.041500e+002 7.387667e+003 +7.041000e+002 7.196599e+003 +7.040500e+002 7.196599e+003 +7.040000e+002 6.916078e+003 +7.039500e+002 6.916078e+003 +7.039000e+002 6.740767e+003 +7.038500e+002 6.740767e+003 +7.038000e+002 6.650866e+003 +7.037500e+002 6.650866e+003 +7.037000e+002 6.501700e+003 +7.036500e+002 6.501700e+003 +7.036000e+002 6.321322e+003 +7.035500e+002 6.321322e+003 +7.035000e+002 6.114956e+003 +7.034500e+002 6.114956e+003 +7.034000e+002 5.943211e+003 +7.033500e+002 5.943211e+003 +7.033000e+002 5.913577e+003 +7.032500e+002 5.913577e+003 +7.032000e+002 5.774845e+003 +7.031500e+002 5.774845e+003 +7.031000e+002 5.676900e+003 +7.030500e+002 5.676900e+003 +7.030000e+002 5.710133e+003 +7.029500e+002 5.710133e+003 +7.029000e+002 5.518633e+003 +7.028500e+002 5.518633e+003 +7.028000e+002 5.520656e+003 +7.027500e+002 5.520656e+003 +7.027000e+002 5.445578e+003 +7.026500e+002 5.445578e+003 +7.026000e+002 5.343422e+003 +7.025500e+002 5.343422e+003 +7.025000e+002 5.344277e+003 +7.024500e+002 5.344277e+003 +7.024000e+002 5.262489e+003 +7.023500e+002 5.262489e+003 +7.023000e+002 5.235422e+003 +7.022500e+002 5.235422e+003 +7.022000e+002 5.157133e+003 +7.021500e+002 5.157133e+003 +7.021000e+002 5.055333e+003 +7.020500e+002 5.055333e+003 +7.020000e+002 5.029911e+003 +7.019500e+002 5.029911e+003 +7.019000e+002 4.985900e+003 +7.018500e+002 4.985900e+003 +7.018000e+002 4.914911e+003 +7.017500e+002 4.914911e+003 +7.017000e+002 4.877600e+003 +7.016500e+002 4.877600e+003 +7.016000e+002 4.821089e+003 +7.015500e+002 4.821089e+003 +7.015000e+002 4.853411e+003 +7.014500e+002 4.853411e+003 +7.014000e+002 4.750366e+003 +7.013500e+002 4.750366e+003 +7.013000e+002 4.648567e+003 +7.012500e+002 4.648567e+003 +7.012000e+002 4.684411e+003 +7.011500e+002 4.684411e+003 +7.011000e+002 4.617811e+003 +7.010500e+002 4.617811e+003 +7.010000e+002 4.656478e+003 +7.009500e+002 4.656478e+003 +7.009000e+002 4.662767e+003 +7.008500e+002 4.662767e+003 +7.008000e+002 4.646756e+003 +7.007500e+002 4.646756e+003 +7.007000e+002 4.606589e+003 +7.006500e+002 4.606589e+003 +7.006000e+002 4.565700e+003 +7.005500e+002 4.565700e+003 +7.005000e+002 4.512422e+003 +7.004500e+002 4.512422e+003 +7.004000e+002 4.455289e+003 +7.003500e+002 4.455289e+003 +7.003000e+002 4.436855e+003 +7.002500e+002 4.436855e+003 +7.002000e+002 4.506733e+003 +7.001500e+002 4.506733e+003 +7.001000e+002 4.434711e+003 +7.000500e+002 4.434711e+003 +7.000000e+002 4.393244e+003 +6.999500e+002 4.393244e+003 +6.999000e+002 4.341978e+003 +6.998500e+002 4.341978e+003 +6.998000e+002 4.304244e+003 +6.997500e+002 4.304244e+003 +6.997000e+002 4.373122e+003 +6.996500e+002 4.373122e+003 +6.996000e+002 4.367167e+003 +6.995500e+002 4.367167e+003 +6.995000e+002 4.310511e+003 +6.994500e+002 4.310511e+003 +6.994000e+002 4.295544e+003 +6.993500e+002 4.295544e+003 +6.993000e+002 4.286078e+003 +6.992500e+002 4.286078e+003 +6.992000e+002 4.351178e+003 +6.991500e+002 4.351178e+003 +6.991000e+002 4.324166e+003 +6.990500e+002 4.324166e+003 +6.990000e+002 4.254733e+003 +6.989500e+002 4.254733e+003 +6.989000e+002 4.243944e+003 +6.988500e+002 4.243944e+003 +6.988000e+002 4.229456e+003 +6.987500e+002 4.229456e+003 +6.987000e+002 4.270722e+003 +6.986500e+002 4.270722e+003 +6.986000e+002 4.283055e+003 +6.985500e+002 4.283055e+003 +6.985000e+002 4.294278e+003 +6.984500e+002 4.294278e+003 +6.984000e+002 4.285489e+003 +6.983500e+002 4.285489e+003 +6.983000e+002 4.190300e+003 +6.982500e+002 4.190300e+003 +6.982000e+002 4.263333e+003 +6.981500e+002 4.263333e+003 +6.981000e+002 4.188533e+003 +6.980500e+002 4.188533e+003 +6.980000e+002 4.192244e+003 +6.979500e+002 4.192244e+003 +6.979000e+002 4.195989e+003 +6.978500e+002 4.195989e+003 +6.978000e+002 4.185533e+003 +6.977500e+002 4.185533e+003 +6.977000e+002 4.143344e+003 +6.976500e+002 4.143344e+003 +6.976000e+002 4.187578e+003 +6.975500e+002 4.187578e+003 +6.975000e+002 4.048922e+003 +6.974500e+002 4.048922e+003 +6.974000e+002 4.115656e+003 +6.973500e+002 4.115656e+003 +6.973000e+002 4.073711e+003 +6.972500e+002 4.073711e+003 +6.972000e+002 4.105700e+003 +6.971500e+002 4.105700e+003 +6.971000e+002 4.098767e+003 +6.970500e+002 4.098767e+003 +6.970000e+002 4.106411e+003 +6.969500e+002 4.106411e+003 +6.969000e+002 4.090378e+003 +6.968500e+002 4.090378e+003 +6.968000e+002 4.090956e+003 +6.967500e+002 4.090956e+003 +6.967000e+002 4.135056e+003 +6.966500e+002 4.135056e+003 +6.966000e+002 4.083033e+003 +6.965500e+002 4.083033e+003 +6.965000e+002 4.015944e+003 +6.964500e+002 4.015944e+003 +6.964000e+002 4.039089e+003 +6.963500e+002 4.039089e+003 +6.963000e+002 4.084655e+003 +6.962500e+002 4.084655e+003 +6.962000e+002 4.051289e+003 +6.961500e+002 4.051289e+003 +6.961000e+002 4.028278e+003 +6.960500e+002 4.028278e+003 +6.960000e+002 4.077022e+003 +6.959500e+002 4.077022e+003 +6.959000e+002 4.088411e+003 +6.958500e+002 4.088411e+003 +6.958000e+002 4.021556e+003 +6.957500e+002 4.021556e+003 +6.957000e+002 3.970878e+003 +6.956500e+002 3.970878e+003 +6.956000e+002 4.027955e+003 +6.955500e+002 4.027955e+003 +6.955000e+002 4.047956e+003 +6.954500e+002 4.047956e+003 +6.954000e+002 4.029744e+003 +6.953500e+002 4.029744e+003 +6.953000e+002 4.015967e+003 +6.952500e+002 4.015967e+003 +6.952000e+002 4.003789e+003 +6.951500e+002 4.003789e+003 +6.951000e+002 4.013111e+003 +6.950500e+002 4.013111e+003 +6.950000e+002 3.968511e+003 +6.949500e+002 3.968511e+003 +6.949000e+002 3.968978e+003 +6.948500e+002 3.968978e+003 +6.948000e+002 3.965567e+003 +6.947500e+002 3.965567e+003 +6.947000e+002 3.949067e+003 +6.946500e+002 3.949067e+003 +6.946000e+002 4.000767e+003 +6.945500e+002 4.000767e+003 +6.945000e+002 3.920866e+003 +6.944500e+002 3.920866e+003 +6.944000e+002 3.850156e+003 +6.943500e+002 3.850156e+003 +6.943000e+002 3.943078e+003 +6.942500e+002 3.943078e+003 +6.942000e+002 3.967767e+003 +6.941500e+002 3.967767e+003 +6.941000e+002 3.882578e+003 +6.940500e+002 3.882578e+003 +6.940000e+002 3.841889e+003 \ No newline at end of file diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe_references.vms b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe_references.vms new file mode 100644 index 0000000000000000000000000000000000000000..f8734edabca0934554672d5c766f587197b8969a --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Fe_references.vms @@ -0,0 +1,13913 @@ +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 +SourceAnalyserAngle: Not Specified +CasaRowLabel:Fe metal +CasaRowLabel:FeO +CasaRowLabel:Fe3O4 +CasaRowLabel:Fe2O3 +NORM +REGULAR +0 +1 +Exp Variable +d +0 +0 +0 +0 +4 +Fe2p +Fe metal +2021 +7 +5 +18 +14 +57 +0 +11 +Casa Info Follows +0 +0 +0 +0 +none +Group: none +Analyzer Lens: none +Analyzer Slit: none +Scan Mode: none +C:\Users\pielsticker\Downloads\utils\test fits\new\Fe2p_Fe_metal_new.vms +XPS +0 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +4.1408 +0 +0 +0 +0 +0 +Fe +2p +-1 +kinetic energy +eV +716.61 +0.05 +2 +counts +d +Transmission +d +pulse counting +0.1 +3 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +3402 +1134.46 +54850.3 +1 +1 +12642.4 +1 +12642.4 +1 +12750.4 +1 +12750.4 +1 +12747 +1 +12747 +1 +12676.4 +1 +12676.4 +1 +12700.3 +1 +12700.3 +1 +12656.3 +1 +12656.3 +1 +12646.5 +1 +12646.5 +1 +12687.5 +1 +12687.5 +1 +12662.3 +1 +12662.3 +1 +12614.1 +1 +12614.1 +1 +12635.7 +1 +12635.7 +1 +12578 +1 +12578 +1 +12593.5 +1 +12593.5 +1 +12608.5 +1 +12608.5 +1 +12516.3 +1 +12516.3 +1 +12437.1 +1 +12437.1 +1 +12508.5 +1 +12508.5 +1 +12494.1 +1 +12494.1 +1 +12416.5 +1 +12416.5 +1 +12424 +1 +12424 +1 +12440.7 +1 +12440.7 +1 +12357.8 +1 +12357.8 +1 +12322.2 +1 +12322.2 +1 +12269.3 +1 +12269.3 +1 +12280.6 +1 +12280.6 +1 +12275.5 +1 +12275.5 +1 +12282 +1 +12282 +1 +12171.7 +1 +12171.7 +1 +12193.4 +1 +12193.4 +1 +12172.2 +1 +12172.2 +1 +12208.3 +1 +12208.3 +1 +12168.2 +1 +12168.2 +1 +12178.8 +1 +12178.8 +1 +12150.5 +1 +12150.5 +1 +12145.5 +1 +12145.5 +1 +12089.5 +1 +12089.5 +1 +12090.8 +1 +12090.8 +1 +12104 +1 +12104 +1 +12052 +1 +12052 +1 +12084.1 +1 +12084.1 +1 +12059.8 +1 +12059.8 +1 +12015.8 +1 +12015.8 +1 +12116.2 +1 +12116.2 +1 +12035 +1 +12035 +1 +12040.3 +1 +12040.3 +1 +12046.4 +1 +12046.4 +1 +12052.4 +1 +12052.4 +1 +12040.3 +1 +12040.3 +1 +12064.5 +1 +12064.5 +1 +12089.1 +1 +12089.1 +1 +12063.5 +1 +12063.5 +1 +12006.4 +1 +12006.4 +1 +12001.9 +1 +12001.9 +1 +11981.6 +1 +11981.6 +1 +12029.8 +1 +12029.8 +1 +12059.9 +1 +12059.9 +1 +11992.5 +1 +11992.5 +1 +12041.7 +1 +12041.7 +1 +11977.4 +1 +11977.4 +1 +12007.9 +1 +12007.9 +1 +11926.1 +1 +11926.1 +1 +12045.3 +1 +12045.3 +1 +12040.6 +1 +12040.6 +1 +12021.8 +1 +12021.8 +1 +11944.9 +1 +11944.9 +1 +11933.9 +1 +11933.9 +1 +11976.3 +1 +11976.3 +1 +12005.9 +1 +12005.9 +1 +11988.1 +1 +11988.1 +1 +11940.7 +1 +11940.7 +1 +11965.3 +1 +11965.3 +1 +11997.8 +1 +11997.8 +1 +11992.9 +1 +11992.9 +1 +11957.9 +1 +11957.9 +1 +11915.9 +1 +11915.9 +1 +11966.1 +1 +11966.1 +1 +11907.1 +1 +11907.1 +1 +11841.4 +1 +11841.4 +1 +11944.9 +1 +11944.9 +1 +11968.4 +1 +11968.4 +1 +11900.5 +1 +11900.5 +1 +11870.4 +1 +11870.4 +1 +11880.2 +1 +11880.2 +1 +11928.3 +1 +11928.3 +1 +11905.7 +1 +11905.7 +1 +11857.1 +1 +11857.1 +1 +11885.3 +1 +11885.3 +1 +11845 +1 +11845 +1 +11913.2 +1 +11913.2 +1 +11904.1 +1 +11904.1 +1 +11888.2 +1 +11888.2 +1 +11882.5 +1 +11882.5 +1 +11960.9 +1 +11960.9 +1 +11874.5 +1 +11874.5 +1 +11856.5 +1 +11856.5 +1 +11860.5 +1 +11860.5 +1 +11903.1 +1 +11903.1 +1 +11913.6 +1 +11913.6 +1 +11934 +1 +11934 +1 +12016.2 +1 +12016.2 +1 +11940 +1 +11940 +1 +11913.7 +1 +11913.7 +1 +11891.4 +1 +11891.4 +1 +11927 +1 +11927 +1 +11913.3 +1 +11913.3 +1 +11863.6 +1 +11863.6 +1 +11969.2 +1 +11969.2 +1 +11890.5 +1 +11890.5 +1 +11971.6 +1 +11971.6 +1 +11997.7 +1 +11997.7 +1 +11955.5 +1 +11955.5 +1 +11940.4 +1 +11940.4 +1 +11912 +1 +11912 +1 +11987.1 +1 +11987.1 +1 +11966 +1 +11966 +1 +12016.2 +1 +12016.2 +1 +12079.8 +1 +12079.8 +1 +12085.3 +1 +12085.3 +1 +12081.2 +1 +12081.2 +1 +12087.5 +1 +12087.5 +1 +12084.1 +1 +12084.1 +1 +12145.4 +1 +12145.4 +1 +12179.9 +1 +12179.9 +1 +12090.8 +1 +12090.8 +1 +12229.3 +1 +12229.3 +1 +12210.9 +1 +12210.9 +1 +12157.2 +1 +12157.2 +1 +12192.2 +1 +12192.2 +1 +12187.4 +1 +12187.4 +1 +12207.4 +1 +12207.4 +1 +12235.1 +1 +12235.1 +1 +12174.3 +1 +12174.3 +1 +12275.3 +1 +12275.3 +1 +12329.7 +1 +12329.7 +1 +12262.2 +1 +12262.2 +1 +12315.4 +1 +12315.4 +1 +12348.7 +1 +12348.7 +1 +12330.9 +1 +12330.9 +1 +12328.6 +1 +12328.6 +1 +12369.7 +1 +12369.7 +1 +12368.2 +1 +12368.2 +1 +12330.2 +1 +12330.2 +1 +12376.2 +1 +12376.2 +1 +12372.5 +1 +12372.5 +1 +12369.3 +1 +12369.3 +1 +12361.3 +1 +12361.3 +1 +12442.1 +1 +12442.1 +1 +12466.4 +1 +12466.4 +1 +12486.8 +1 +12486.8 +1 +12449.2 +1 +12449.2 +1 +12485.2 +1 +12485.2 +1 +12478.1 +1 +12478.1 +1 +12570.9 +1 +12570.9 +1 +12577.7 +1 +12577.7 +1 +12532.4 +1 +12532.4 +1 +12581.9 +1 +12581.9 +1 +12561.2 +1 +12561.2 +1 +12682.4 +1 +12682.4 +1 +12669.7 +1 +12669.7 +1 +12551.3 +1 +12551.3 +1 +12555.3 +1 +12555.3 +1 +12623.7 +1 +12623.7 +1 +12643 +1 +12643 +1 +12629.5 +1 +12629.5 +1 +12669.5 +1 +12669.5 +1 +12749.3 +1 +12749.3 +1 +12712.9 +1 +12712.9 +1 +12722.1 +1 +12722.1 +1 +12721.6 +1 +12721.6 +1 +12831 +1 +12831 +1 +12789.4 +1 +12789.4 +1 +12807 +1 +12807 +1 +12783.4 +1 +12783.4 +1 +12823.2 +1 +12823.2 +1 +12840.7 +1 +12840.7 +1 +12869.8 +1 +12869.8 +1 +12833.6 +1 +12833.6 +1 +12881.8 +1 +12881.8 +1 +12884.1 +1 +12884.1 +1 +12889.8 +1 +12889.8 +1 +12886.2 +1 +12886.2 +1 +12904.8 +1 +12904.8 +1 +12963.2 +1 +12963.2 +1 +12955.7 +1 +12955.7 +1 +12980.9 +1 +12980.9 +1 +13022.1 +1 +13022.1 +1 +12973.6 +1 +12973.6 +1 +12955.3 +1 +12955.3 +1 +12985.6 +1 +12985.6 +1 +13036.6 +1 +13036.6 +1 +13031.7 +1 +13031.7 +1 +13120.6 +1 +13120.6 +1 +13118.5 +1 +13118.5 +1 +13066.7 +1 +13066.7 +1 +13058.3 +1 +13058.3 +1 +13099.4 +1 +13099.4 +1 +13114.1 +1 +13114.1 +1 +13157 +1 +13157 +1 +13081.4 +1 +13081.4 +1 +13161.4 +1 +13161.4 +1 +13246.8 +1 +13246.8 +1 +13171.9 +1 +13171.9 +1 +13220 +1 +13220 +1 +13298.9 +1 +13298.9 +1 +13365.3 +1 +13365.3 +1 +13261.3 +1 +13261.3 +1 +13285.8 +1 +13285.8 +1 +13343 +1 +13343 +1 +13451.1 +1 +13451.1 +1 +13376.3 +1 +13376.3 +1 +13374.1 +1 +13374.1 +1 +13342.1 +1 +13342.1 +1 +13363.1 +1 +13363.1 +1 +13457.4 +1 +13457.4 +1 +13414.5 +1 +13414.5 +1 +13500.8 +1 +13500.8 +1 +13514.9 +1 +13514.9 +1 +13494 +1 +13494 +1 +13484.1 +1 +13484.1 +1 +13544.3 +1 +13544.3 +1 +13599.5 +1 +13599.5 +1 +13554.1 +1 +13554.1 +1 +13582.6 +1 +13582.6 +1 +13645.5 +1 +13645.5 +1 +13643.1 +1 +13643.1 +1 +13643.9 +1 +13643.9 +1 +13598.2 +1 +13598.2 +1 +13593.4 +1 +13593.4 +1 +13690.9 +1 +13690.9 +1 +13757.8 +1 +13757.8 +1 +13730.7 +1 +13730.7 +1 +13722.4 +1 +13722.4 +1 +13758.3 +1 +13758.3 +1 +13724.8 +1 +13724.8 +1 +13746.3 +1 +13746.3 +1 +13765.4 +1 +13765.4 +1 +13858.8 +1 +13858.8 +1 +13856.3 +1 +13856.3 +1 +13861 +1 +13861 +1 +13888.8 +1 +13888.8 +1 +13883.4 +1 +13883.4 +1 +13904.5 +1 +13904.5 +1 +13903.4 +1 +13903.4 +1 +13937.1 +1 +13937.1 +1 +13931.5 +1 +13931.5 +1 +13919.1 +1 +13919.1 +1 +13995.9 +1 +13995.9 +1 +14023.3 +1 +14023.3 +1 +14009.5 +1 +14009.5 +1 +14051.5 +1 +14051.5 +1 +14015.5 +1 +14015.5 +1 +14010.6 +1 +14010.6 +1 +14056.5 +1 +14056.5 +1 +14110.1 +1 +14110.1 +1 +14127.2 +1 +14127.2 +1 +14224.8 +1 +14224.8 +1 +14183.7 +1 +14183.7 +1 +14118.6 +1 +14118.6 +1 +14138.7 +1 +14138.7 +1 +14116.8 +1 +14116.8 +1 +14122.7 +1 +14122.7 +1 +14163.8 +1 +14163.8 +1 +14153.3 +1 +14153.3 +1 +14205 +1 +14205 +1 +14191.3 +1 +14191.3 +1 +14139.3 +1 +14139.3 +1 +14226.6 +1 +14226.6 +1 +14222.1 +1 +14222.1 +1 +14255.6 +1 +14255.6 +1 +14287.2 +1 +14287.2 +1 +14216.3 +1 +14216.3 +1 +14220.3 +1 +14220.3 +1 +14251.5 +1 +14251.5 +1 +14342.3 +1 +14342.3 +1 +14238.6 +1 +14238.6 +1 +14232.4 +1 +14232.4 +1 +14284.1 +1 +14284.1 +1 +14261.5 +1 +14261.5 +1 +14263.1 +1 +14263.1 +1 +14286.9 +1 +14286.9 +1 +14410.9 +1 +14410.9 +1 +14336.5 +1 +14336.5 +1 +14308.4 +1 +14308.4 +1 +14278.5 +1 +14278.5 +1 +14290.3 +1 +14290.3 +1 +14358.6 +1 +14358.6 +1 +14367.1 +1 +14367.1 +1 +14307.7 +1 +14307.7 +1 +14341 +1 +14341 +1 +14340.8 +1 +14340.8 +1 +14298.4 +1 +14298.4 +1 +14295.7 +1 +14295.7 +1 +14341.3 +1 +14341.3 +1 +14339.9 +1 +14339.9 +1 +14328.5 +1 +14328.5 +1 +14291.4 +1 +14291.4 +1 +14387.7 +1 +14387.7 +1 +14340.5 +1 +14340.5 +1 +14392.1 +1 +14392.1 +1 +14365.6 +1 +14365.6 +1 +14417.5 +1 +14417.5 +1 +14375 +1 +14375 +1 +14390.5 +1 +14390.5 +1 +14392.8 +1 +14392.8 +1 +14391 +1 +14391 +1 +14394.7 +1 +14394.7 +1 +14525.7 +1 +14525.7 +1 +14404.5 +1 +14404.5 +1 +14402.3 +1 +14402.3 +1 +14401.1 +1 +14401.1 +1 +14489.6 +1 +14489.6 +1 +14508.8 +1 +14508.8 +1 +14494.2 +1 +14494.2 +1 +14530.4 +1 +14530.4 +1 +14571.7 +1 +14571.7 +1 +14555.1 +1 +14555.1 +1 +14575.7 +1 +14575.7 +1 +14553.9 +1 +14553.9 +1 +14591.9 +1 +14591.9 +1 +14691 +1 +14691 +1 +14641.2 +1 +14641.2 +1 +14651.8 +1 +14651.8 +1 +14647.3 +1 +14647.3 +1 +14691 +1 +14691 +1 +14664.7 +1 +14664.7 +1 +14790.2 +1 +14790.2 +1 +14785.9 +1 +14785.9 +1 +14810.4 +1 +14810.4 +1 +14747.7 +1 +14747.7 +1 +14790.2 +1 +14790.2 +1 +14771.2 +1 +14771.2 +1 +14769.4 +1 +14769.4 +1 +14837.7 +1 +14837.7 +1 +14795.9 +1 +14795.9 +1 +14871.9 +1 +14871.9 +1 +14834.7 +1 +14834.7 +1 +14852.9 +1 +14852.9 +1 +14902 +1 +14902 +1 +14926.4 +1 +14926.4 +1 +14982 +1 +14982 +1 +14951.9 +1 +14951.9 +1 +14956.3 +1 +14956.3 +1 +14923.9 +1 +14923.9 +1 +14982.5 +1 +14982.5 +1 +15099.7 +1 +15099.7 +1 +15109.6 +1 +15109.6 +1 +15048.8 +1 +15048.8 +1 +15050.9 +1 +15050.9 +1 +15141.5 +1 +15141.5 +1 +15176.6 +1 +15176.6 +1 +15142.5 +1 +15142.5 +1 +15091.2 +1 +15091.2 +1 +15088.5 +1 +15088.5 +1 +15200.5 +1 +15200.5 +1 +15189.1 +1 +15189.1 +1 +15220.7 +1 +15220.7 +1 +15267.5 +1 +15267.5 +1 +15259.5 +1 +15259.5 +1 +15273.7 +1 +15273.7 +1 +15289.6 +1 +15289.6 +1 +15352.2 +1 +15352.2 +1 +15374.4 +1 +15374.4 +1 +15369.6 +1 +15369.6 +1 +15374.1 +1 +15374.1 +1 +15423 +1 +15423 +1 +15427.3 +1 +15427.3 +1 +15402.5 +1 +15402.5 +1 +15442.1 +1 +15442.1 +1 +15432 +1 +15432 +1 +15488.2 +1 +15488.2 +1 +15608 +1 +15608 +1 +15620.6 +1 +15620.6 +1 +15511.1 +1 +15511.1 +1 +15510.9 +1 +15510.9 +1 +15593.5 +1 +15593.5 +1 +15554.8 +1 +15554.8 +1 +15629.4 +1 +15629.4 +1 +15696.5 +1 +15696.5 +1 +15665.1 +1 +15665.1 +1 +15586 +1 +15586 +1 +15712.3 +1 +15712.3 +1 +15745.4 +1 +15745.4 +1 +15727.9 +1 +15727.9 +1 +15736.3 +1 +15736.3 +1 +15738.1 +1 +15738.1 +1 +15748.6 +1 +15748.6 +1 +15742 +1 +15742 +1 +15835.5 +1 +15835.5 +1 +15759.9 +1 +15759.9 +1 +15739.8 +1 +15739.8 +1 +15797.4 +1 +15797.4 +1 +15761.5 +1 +15761.5 +1 +15784.1 +1 +15784.1 +1 +15814 +1 +15814 +1 +15766.8 +1 +15766.8 +1 +15819.2 +1 +15819.2 +1 +15749.8 +1 +15749.8 +1 +15749.9 +1 +15749.9 +1 +15738.3 +1 +15738.3 +1 +15803.9 +1 +15803.9 +1 +15849.2 +1 +15849.2 +1 +15875.8 +1 +15875.8 +1 +15772.8 +1 +15772.8 +1 +15840.8 +1 +15840.8 +1 +15844.5 +1 +15844.5 +1 +15851.3 +1 +15851.3 +1 +15824.1 +1 +15824.1 +1 +15803.6 +1 +15803.6 +1 +15895.5 +1 +15895.5 +1 +15841.1 +1 +15841.1 +1 +15903.1 +1 +15903.1 +1 +15785.5 +1 +15785.5 +1 +15848.7 +1 +15848.7 +1 +15795.7 +1 +15795.7 +1 +15792.9 +1 +15792.9 +1 +15839.6 +1 +15839.6 +1 +15815.6 +1 +15815.6 +1 +15830.3 +1 +15830.3 +1 +15806.7 +1 +15806.7 +1 +15845.4 +1 +15845.4 +1 +15883.8 +1 +15883.8 +1 +15925.7 +1 +15925.7 +1 +15917.7 +1 +15917.7 +1 +15796.8 +1 +15796.8 +1 +15877.1 +1 +15877.1 +1 +15936.3 +1 +15936.3 +1 +15972.4 +1 +15972.4 +1 +16010.6 +1 +16010.6 +1 +15994.1 +1 +15994.1 +1 +15956.9 +1 +15956.9 +1 +15929.7 +1 +15929.7 +1 +15980.9 +1 +15980.9 +1 +16003.5 +1 +16003.5 +1 +16000 +1 +16000 +1 +15971.6 +1 +15971.6 +1 +16102.9 +1 +16102.9 +1 +16000.8 +1 +16000.8 +1 +16005.9 +1 +16005.9 +1 +16112.7 +1 +16112.7 +1 +16047.6 +1 +16047.6 +1 +16116.5 +1 +16116.5 +1 +16168.7 +1 +16168.7 +1 +16135.1 +1 +16135.1 +1 +16157.3 +1 +16157.3 +1 +16287.8 +1 +16287.8 +1 +16271.4 +1 +16271.4 +1 +16286 +1 +16286 +1 +16211.9 +1 +16211.9 +1 +16270.3 +1 +16270.3 +1 +16308.5 +1 +16308.5 +1 +16288.3 +1 +16288.3 +1 +16306.6 +1 +16306.6 +1 +16357.8 +1 +16357.8 +1 +16382.4 +1 +16382.4 +1 +16412.7 +1 +16412.7 +1 +16509.5 +1 +16509.5 +1 +16472.5 +1 +16472.5 +1 +16511.3 +1 +16511.3 +1 +16553.7 +1 +16553.7 +1 +16562.9 +1 +16562.9 +1 +16621.3 +1 +16621.3 +1 +16619.8 +1 +16619.8 +1 +16710.2 +1 +16710.2 +1 +16866.2 +1 +16866.2 +1 +16878.3 +1 +16878.3 +1 +17019 +1 +17019 +1 +17142.9 +1 +17142.9 +1 +17231.1 +1 +17231.1 +1 +17238.3 +1 +17238.3 +1 +17355.8 +1 +17355.8 +1 +17457.4 +1 +17457.4 +1 +17630.9 +1 +17630.9 +1 +17780 +1 +17780 +1 +17913.2 +1 +17913.2 +1 +18036.8 +1 +18036.8 +1 +18242.2 +1 +18242.2 +1 +18433.7 +1 +18433.7 +1 +18637.2 +1 +18637.2 +1 +18770.9 +1 +18770.9 +1 +19053 +1 +19053 +1 +19201.4 +1 +19201.4 +1 +19437.2 +1 +19437.2 +1 +19784.7 +1 +19784.7 +1 +20069.7 +1 +20069.7 +1 +20510 +1 +20510 +1 +20713.3 +1 +20713.3 +1 +20983.4 +1 +20983.4 +1 +21555.6 +1 +21555.6 +1 +22001.5 +1 +22001.5 +1 +22539.1 +1 +22539.1 +1 +22993.2 +1 +22993.2 +1 +23476.6 +1 +23476.6 +1 +24143.9 +1 +24143.9 +1 +24840.7 +1 +24840.7 +1 +25616.5 +1 +25616.5 +1 +26517.4 +1 +26517.4 +1 +27151.7 +1 +27151.7 +1 +28015.1 +1 +28015.1 +1 +28868 +1 +28868 +1 +29549.9 +1 +29549.9 +1 +30018.5 +1 +30018.5 +1 +30291.3 +1 +30291.3 +1 +30164.6 +1 +30164.6 +1 +29883.9 +1 +29883.9 +1 +29173.8 +1 +29173.8 +1 +28304.4 +1 +28304.4 +1 +26975.3 +1 +26975.3 +1 +25545.5 +1 +25545.5 +1 +23803.8 +1 +23803.8 +1 +22107 +1 +22107 +1 +20545.8 +1 +20545.8 +1 +19139.4 +1 +19139.4 +1 +17966.5 +1 +17966.5 +1 +17034.7 +1 +17034.7 +1 +16234.7 +1 +16234.7 +1 +15530.2 +1 +15530.2 +1 +14947.2 +1 +14947.2 +1 +14480.4 +1 +14480.4 +1 +14163.3 +1 +14163.3 +1 +13870.1 +1 +13870.1 +1 +13490.6 +1 +13490.6 +1 +13349.6 +1 +13349.6 +1 +13180.3 +1 +13180.3 +1 +12969.9 +1 +12969.9 +1 +12835.2 +1 +12835.2 +1 +12681.5 +1 +12681.5 +1 +12645.3 +1 +12645.3 +1 +12563.7 +1 +12563.7 +1 +12476.7 +1 +12476.7 +1 +12419.9 +1 +12419.9 +1 +12311.4 +1 +12311.4 +1 +12272 +1 +12272 +1 +12252.5 +1 +12252.5 +1 +12188.4 +1 +12188.4 +1 +12203.9 +1 +12203.9 +1 +12180.2 +1 +12180.2 +1 +12143.4 +1 +12143.4 +1 +12116.8 +1 +12116.8 +1 +12178.1 +1 +12178.1 +1 +12195.2 +1 +12195.2 +1 +12154.2 +1 +12154.2 +1 +12190.8 +1 +12190.8 +1 +12187.2 +1 +12187.2 +1 +12237.1 +1 +12237.1 +1 +12235.5 +1 +12235.5 +1 +12286 +1 +12286 +1 +12248.3 +1 +12248.3 +1 +12237.4 +1 +12237.4 +1 +12303.7 +1 +12303.7 +1 +12298.1 +1 +12298.1 +1 +12431.2 +1 +12431.2 +1 +12442 +1 +12442 +1 +12523.5 +1 +12523.5 +1 +12530 +1 +12530 +1 +12543.5 +1 +12543.5 +1 +12558.9 +1 +12558.9 +1 +12606.9 +1 +12606.9 +1 +12652.3 +1 +12652.3 +1 +12733.4 +1 +12733.4 +1 +12687.6 +1 +12687.6 +1 +12775.1 +1 +12775.1 +1 +12834.2 +1 +12834.2 +1 +12862 +1 +12862 +1 +12943.2 +1 +12943.2 +1 +13010.9 +1 +13010.9 +1 +13035.7 +1 +13035.7 +1 +13024.9 +1 +13024.9 +1 +13035.2 +1 +13035.2 +1 +13176.4 +1 +13176.4 +1 +13161.4 +1 +13161.4 +1 +13193.6 +1 +13193.6 +1 +13231.7 +1 +13231.7 +1 +13285 +1 +13285 +1 +13297.6 +1 +13297.6 +1 +13236 +1 +13236 +1 +13361.4 +1 +13361.4 +1 +13423.4 +1 +13423.4 +1 +13532 +1 +13532 +1 +13596.2 +1 +13596.2 +1 +13565.2 +1 +13565.2 +1 +13626.2 +1 +13626.2 +1 +13810.8 +1 +13810.8 +1 +13901.9 +1 +13901.9 +1 +13921 +1 +13921 +1 +14006.7 +1 +14006.7 +1 +14171.8 +1 +14171.8 +1 +14245.1 +1 +14245.1 +1 +14340.1 +1 +14340.1 +1 +14473.8 +1 +14473.8 +1 +14619.5 +1 +14619.5 +1 +14812.5 +1 +14812.5 +1 +14923.2 +1 +14923.2 +1 +15012.9 +1 +15012.9 +1 +15236.8 +1 +15236.8 +1 +15355.2 +1 +15355.2 +1 +15448.4 +1 +15448.4 +1 +15542.4 +1 +15542.4 +1 +15766.2 +1 +15766.2 +1 +15838.5 +1 +15838.5 +1 +16062.9 +1 +16062.9 +1 +16194.4 +1 +16194.4 +1 +16367.9 +1 +16367.9 +1 +16589.5 +1 +16589.5 +1 +16706.1 +1 +16706.1 +1 +16910.8 +1 +16910.8 +1 +17167.8 +1 +17167.8 +1 +17420.5 +1 +17420.5 +1 +17588.4 +1 +17588.4 +1 +17926.4 +1 +17926.4 +1 +18370.2 +1 +18370.2 +1 +18677.4 +1 +18677.4 +1 +19020.6 +1 +19020.6 +1 +19522.2 +1 +19522.2 +1 +20095.6 +1 +20095.6 +1 +20650.1 +1 +20650.1 +1 +21272.7 +1 +21272.7 +1 +22051 +1 +22051 +1 +23087.3 +1 +23087.3 +1 +24161.1 +1 +24161.1 +1 +25331.1 +1 +25331.1 +1 +26691.7 +1 +26691.7 +1 +28571.6 +1 +28571.6 +1 +30392 +1 +30392 +1 +32342.4 +1 +32342.4 +1 +34439.7 +1 +34439.7 +1 +36369.3 +1 +36369.3 +1 +38133.7 +1 +38133.7 +1 +39760.3 +1 +39760.3 +1 +41630.3 +1 +41630.3 +1 +44078.3 +1 +44078.3 +1 +46923.7 +1 +46923.7 +1 +50218 +1 +50218 +1 +53209.3 +1 +53209.3 +1 +54850.3 +1 +54850.3 +1 +54130 +1 +54130 +1 +50248 +1 +50248 +1 +43614 +1 +43614 +1 +35167 +1 +35167 +1 +26720.5 +1 +26720.5 +1 +19516.7 +1 +19516.7 +1 +14244.4 +1 +14244.4 +1 +10658 +1 +10658 +1 +8352.37 +1 +8352.37 +1 +6853.27 +1 +6853.27 +1 +5783.2 +1 +5783.2 +1 +5015.8 +1 +5015.8 +1 +4427.13 +1 +4427.13 +1 +4015.73 +1 +4015.73 +1 +3682.03 +1 +3682.03 +1 +3439.77 +1 +3439.77 +1 +3221.87 +1 +3221.87 +1 +3029.64 +1 +3029.64 +1 +2864.95 +1 +2864.95 +1 +2695.26 +1 +2695.26 +1 +2541.73 +1 +2541.73 +1 +2435.33 +1 +2435.33 +1 +2375.57 +1 +2375.57 +1 +2308.28 +1 +2308.28 +1 +2216.3 +1 +2216.3 +1 +2158.98 +1 +2158.98 +1 +2074.82 +1 +2074.82 +1 +2022.23 +1 +2022.23 +1 +1995.26 +1 +1995.26 +1 +1950.51 +1 +1950.51 +1 +1896.4 +1 +1896.4 +1 +1834.49 +1 +1834.49 +1 +1782.96 +1 +1782.96 +1 +1774.07 +1 +1774.07 +1 +1732.45 +1 +1732.45 +1 +1703.07 +1 +1703.07 +1 +1713.04 +1 +1713.04 +1 +1655.59 +1 +1655.59 +1 +1656.2 +1 +1656.2 +1 +1633.67 +1 +1633.67 +1 +1603.03 +1 +1603.03 +1 +1603.28 +1 +1603.28 +1 +1578.75 +1 +1578.75 +1 +1570.63 +1 +1570.63 +1 +1547.14 +1 +1547.14 +1 +1516.6 +1 +1516.6 +1 +1508.97 +1 +1508.97 +1 +1495.77 +1 +1495.77 +1 +1474.47 +1 +1474.47 +1 +1463.28 +1 +1463.28 +1 +1446.33 +1 +1446.33 +1 +1456.02 +1 +1456.02 +1 +1425.11 +1 +1425.11 +1 +1394.57 +1 +1394.57 +1 +1405.32 +1 +1405.32 +1 +1385.34 +1 +1385.34 +1 +1396.94 +1 +1396.94 +1 +1398.83 +1 +1398.83 +1 +1394.03 +1 +1394.03 +1 +1381.98 +1 +1381.98 +1 +1369.71 +1 +1369.71 +1 +1353.73 +1 +1353.73 +1 +1336.59 +1 +1336.59 +1 +1331.06 +1 +1331.06 +1 +1352.02 +1 +1352.02 +1 +1330.41 +1 +1330.41 +1 +1317.97 +1 +1317.97 +1 +1302.59 +1 +1302.59 +1 +1291.27 +1 +1291.27 +1 +1311.94 +1 +1311.94 +1 +1310.15 +1 +1310.15 +1 +1293.15 +1 +1293.15 +1 +1288.66 +1 +1288.66 +1 +1285.82 +1 +1285.82 +1 +1305.35 +1 +1305.35 +1 +1297.25 +1 +1297.25 +1 +1276.42 +1 +1276.42 +1 +1273.18 +1 +1273.18 +1 +1268.84 +1 +1268.84 +1 +1281.22 +1 +1281.22 +1 +1284.92 +1 +1284.92 +1 +1288.28 +1 +1288.28 +1 +1285.65 +1 +1285.65 +1 +1257.09 +1 +1257.09 +1 +1279 +1 +1279 +1 +1256.56 +1 +1256.56 +1 +1257.67 +1 +1257.67 +1 +1258.8 +1 +1258.8 +1 +1255.66 +1 +1255.66 +1 +1243 +1 +1243 +1 +1256.27 +1 +1256.27 +1 +1214.68 +1 +1214.68 +1 +1234.7 +1 +1234.7 +1 +1222.11 +1 +1222.11 +1 +1231.71 +1 +1231.71 +1 +1229.63 +1 +1229.63 +1 +1231.92 +1 +1231.92 +1 +1227.11 +1 +1227.11 +1 +1227.29 +1 +1227.29 +1 +1240.52 +1 +1240.52 +1 +1224.91 +1 +1224.91 +1 +1204.78 +1 +1204.78 +1 +1211.73 +1 +1211.73 +1 +1225.4 +1 +1225.4 +1 +1215.39 +1 +1215.39 +1 +1208.48 +1 +1208.48 +1 +1223.11 +1 +1223.11 +1 +1226.52 +1 +1226.52 +1 +1206.47 +1 +1206.47 +1 +1191.26 +1 +1191.26 +1 +1208.39 +1 +1208.39 +1 +1214.39 +1 +1214.39 +1 +1208.92 +1 +1208.92 +1 +1204.79 +1 +1204.79 +1 +1201.14 +1 +1201.14 +1 +1203.93 +1 +1203.93 +1 +1190.55 +1 +1190.55 +1 +1190.69 +1 +1190.69 +1 +1189.67 +1 +1189.67 +1 +1184.72 +1 +1184.72 +1 +1200.23 +1 +1200.23 +1 +1176.26 +1 +1176.26 +1 +1155.05 +1 +1155.05 +1 +1182.92 +1 +1182.92 +1 +1190.33 +1 +1190.33 +1 +1164.77 +1 +1164.77 +1 +1152.57 +1 +1152.57 +1 +1158.14 +1 +1158.14 +1 +1195.59 +1 +1195.59 +1 +1189.21 +1 +1189.21 +1 +1172.16 +1 +1172.16 +1 +1162.95 +1 +1162.95 +1 +1144.88 +1 +1144.88 +1 +1137.25 +1 +1137.25 +1 +1169.35 +1 +1169.35 +1 +1159.5 +1 +1159.5 +1 +1167.68 +1 +1167.68 +1 +1148.89 +1 +1148.89 +1 +1154.63 +1 +1154.63 +1 +1157.36 +1 +1157.36 +1 +1181.12 +1 +1181.12 +1 +1154.61 +1 +1154.61 +1 +1161.23 +1 +1161.23 +1 +1160.2 +1 +1160.2 +1 +1163.84 +1 +1163.84 +1 +1157.86 +1 +1157.86 +1 +1149.26 +1 +1149.26 +1 +1163.66 +1 +1163.66 +1 +1179.74 +1 +1179.74 +1 +1149.84 +1 +1149.84 +1 +1164.1 +1 +1164.1 +1 +1140.86 +1 +1140.86 +1 +1148.38 +1 +1148.38 +1 +1153.72 +1 +1153.72 +1 +1164.32 +1 +1164.32 +1 +1159.29 +1 +1159.29 +1 +1162.65 +1 +1162.65 +1 +1177.38 +1 +1177.38 +1 +1147.3 +1 +1147.3 +1 +1135.94 +1 +1135.94 +1 +1164.28 +1 +1164.28 +1 +1185.31 +1 +1185.31 +1 +1154.3 +1 +1154.3 +1 +1136.98 +1 +1136.98 +1 +1151.42 +1 +1151.42 +1 +1172.18 +1 +1172.18 +1 +1167.89 +1 +1167.89 +1 +1178.4 +1 +1178.4 +1 +1171.79 +1 +1171.79 +1 +1172.07 +1 +1172.07 +1 +1134.46 +1 +1134.46 +1 +1168.3 +1 +1168.3 +1 +1170.57 +1 +1170.57 +1 +1207.68 +1 +1207.68 +1 +1201.96 +1 +1201.96 +1 +1184.18 +1 +1184.18 +1 +1212.92 +1 +1212.92 +1 +1214.79 +1 +1214.79 +1 +1168.92 +1 +1168.92 +1 +1186.79 +1 +1186.79 +1 +1195.58 +1 +1195.58 +1 +1163.39 +1 +1163.39 +1 +1151.71 +1 +1151.71 +1 +1184.55 +1 +1184.55 +1 +1173.68 +1 +1173.68 +1 +1193.15 +1 +1193.15 +1 +1177.95 +1 +1177.95 +1 +1184.08 +1 +1184.08 +1 +1162.17 +1 +1162.17 +1 +1165.25 +1 +1165.25 +1 +1155.1 +1 +1155.1 +1 +1148.32 +1 +1148.32 +1 +1140.5 +1 +1140.5 +1 +1160.52 +1 +1160.52 +1 +1155.09 +1 +1155.09 +1 +1165.48 +1 +1165.48 +1 +1166.73 +1 +1166.73 +1 +1147.23 +1 +1147.23 +1 +1149.19 +1 +1149.19 +1 +1172.11 +1 +1172.11 +1 +1150.9 +1 +1150.9 +1 +1157.73 +1 +1157.73 +1 +1156.98 +1 +1156.98 +1 +1160.05 +1 +1160.05 +1 +1168.93 +1 +1168.93 +1 +1148.02 +1 +1148.02 +1 +1163.64 +1 +1163.64 +1 +1168.26 +1 +1168.26 +1 +1172.23 +1 +1172.23 +1 +1167.16 +1 +1167.16 +1 +1169.02 +1 +1169.02 +1 +1156.19 +1 +1156.19 +1 +1174.5 +1 +1174.5 +1 +1157.26 +1 +1157.26 +1 +1160.81 +1 +1160.81 +1 +1162.4 +1 +1162.4 +1 +1183.51 +1 +Fe2p +FeO +2021 +6 +5 +9 +41 +29 +0 +11 +Casa Info Follows +0 +0 +0 +0 +none +Group: none +Analyzer Lens: none +Analyzer Slit: none +Scan Mode: none +C:\Users\pielsticker\Downloads\utils\test fits\new\Fe2p_FeO_new.vms +XPS +0 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +4.1408 +0 +0 +0 +0 +0 +Fe +2p +-1 +kinetic energy +eV +716.61 +0.05 +2 +counts +d +Transmission +d +pulse counting +0.1 +3 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +3402 +1124.42 +11907.6 +1 +1 +5360.6 +1 +5360.6 +1 +5367.87 +1 +5367.87 +1 +5330.4 +1 +5330.4 +1 +5348 +1 +5348 +1 +5334.23 +1 +5334.23 +1 +5323.53 +1 +5323.53 +1 +5309.4 +1 +5309.4 +1 +5300.6 +1 +5300.6 +1 +5305.97 +1 +5305.97 +1 +5319.83 +1 +5319.83 +1 +5303.67 +1 +5303.67 +1 +5283.77 +1 +5283.77 +1 +5238.47 +1 +5238.47 +1 +5256.4 +1 +5256.4 +1 +5254.4 +1 +5254.4 +1 +5225.97 +1 +5225.97 +1 +5268.67 +1 +5268.67 +1 +5240.47 +1 +5240.47 +1 +5199.93 +1 +5199.93 +1 +5203.83 +1 +5203.83 +1 +5203.63 +1 +5203.63 +1 +5144.73 +1 +5144.73 +1 +5081.77 +1 +5081.77 +1 +5145.3 +1 +5145.3 +1 +5119.27 +1 +5119.27 +1 +5138.53 +1 +5138.53 +1 +5118.13 +1 +5118.13 +1 +5138.93 +1 +5138.93 +1 +5107.23 +1 +5107.23 +1 +5073.87 +1 +5073.87 +1 +5046.5 +1 +5046.5 +1 +5048.03 +1 +5048.03 +1 +5057.27 +1 +5057.27 +1 +5039.07 +1 +5039.07 +1 +5022.73 +1 +5022.73 +1 +5001.53 +1 +5001.53 +1 +4982.77 +1 +4982.77 +1 +5003.97 +1 +5003.97 +1 +5005.83 +1 +5005.83 +1 +5002.4 +1 +5002.4 +1 +4997.13 +1 +4997.13 +1 +4937.77 +1 +4937.77 +1 +4934.43 +1 +4934.43 +1 +4957.53 +1 +4957.53 +1 +4962.8 +1 +4962.8 +1 +4954.97 +1 +4954.97 +1 +4883.67 +1 +4883.67 +1 +4914.87 +1 +4914.87 +1 +4923.9 +1 +4923.9 +1 +4919.17 +1 +4919.17 +1 +4909.13 +1 +4909.13 +1 +4924.2 +1 +4924.2 +1 +4917.47 +1 +4917.47 +1 +4906.37 +1 +4906.37 +1 +4903.87 +1 +4903.87 +1 +4904.37 +1 +4904.37 +1 +4914.57 +1 +4914.57 +1 +4895.57 +1 +4895.57 +1 +4902.83 +1 +4902.83 +1 +4881.17 +1 +4881.17 +1 +4865 +1 +4865 +1 +4899.1 +1 +4899.1 +1 +4893.23 +1 +4893.23 +1 +4911.53 +1 +4911.53 +1 +4901.4 +1 +4901.4 +1 +4922.23 +1 +4922.23 +1 +4898.23 +1 +4898.23 +1 +4860.7 +1 +4860.7 +1 +4919.73 +1 +4919.73 +1 +4895.07 +1 +4895.07 +1 +4885.37 +1 +4885.37 +1 +4874.03 +1 +4874.03 +1 +4905.3 +1 +4905.3 +1 +4901.37 +1 +4901.37 +1 +4873.13 +1 +4873.13 +1 +4850.6 +1 +4850.6 +1 +4908.87 +1 +4908.87 +1 +4882.83 +1 +4882.83 +1 +4922.7 +1 +4922.7 +1 +4906.07 +1 +4906.07 +1 +4901.1 +1 +4901.1 +1 +4899.87 +1 +4899.87 +1 +4938.87 +1 +4938.87 +1 +4857.3 +1 +4857.3 +1 +4896.13 +1 +4896.13 +1 +4896.7 +1 +4896.7 +1 +4847.47 +1 +4847.47 +1 +4886.63 +1 +4886.63 +1 +4925.73 +1 +4925.73 +1 +4949.2 +1 +4949.2 +1 +4937.33 +1 +4937.33 +1 +4975.8 +1 +4975.8 +1 +4925.87 +1 +4925.87 +1 +4926.2 +1 +4926.2 +1 +4956.67 +1 +4956.67 +1 +4964.67 +1 +4964.67 +1 +4920.73 +1 +4920.73 +1 +4875.07 +1 +4875.07 +1 +4919.27 +1 +4919.27 +1 +4966.13 +1 +4966.13 +1 +4972.57 +1 +4972.57 +1 +4946.57 +1 +4946.57 +1 +4978.6 +1 +4978.6 +1 +4944.23 +1 +4944.23 +1 +4962.83 +1 +4962.83 +1 +4984.9 +1 +4984.9 +1 +4917.87 +1 +4917.87 +1 +4966.8 +1 +4966.8 +1 +4971.3 +1 +4971.3 +1 +4959.07 +1 +4959.07 +1 +5008.5 +1 +5008.5 +1 +4991.13 +1 +4991.13 +1 +4998.03 +1 +4998.03 +1 +5036.47 +1 +5036.47 +1 +5011.57 +1 +5011.57 +1 +5040.53 +1 +5040.53 +1 +5007.93 +1 +5007.93 +1 +5019.63 +1 +5019.63 +1 +5033.87 +1 +5033.87 +1 +5030.97 +1 +5030.97 +1 +5039.07 +1 +5039.07 +1 +5044.5 +1 +5044.5 +1 +5017.1 +1 +5017.1 +1 +5038.73 +1 +5038.73 +1 +5041.53 +1 +5041.53 +1 +5046.53 +1 +5046.53 +1 +5048.13 +1 +5048.13 +1 +5054.3 +1 +5054.3 +1 +5098.5 +1 +5098.5 +1 +5074.4 +1 +5074.4 +1 +5035.77 +1 +5035.77 +1 +5047.33 +1 +5047.33 +1 +5051.7 +1 +5051.7 +1 +5060.37 +1 +5060.37 +1 +5039.13 +1 +5039.13 +1 +5081.5 +1 +5081.5 +1 +5053.07 +1 +5053.07 +1 +5056.9 +1 +5056.9 +1 +5073.63 +1 +5073.63 +1 +5048.77 +1 +5048.77 +1 +5079.77 +1 +5079.77 +1 +5082.83 +1 +5082.83 +1 +5084.23 +1 +5084.23 +1 +5108.47 +1 +5108.47 +1 +5086.83 +1 +5086.83 +1 +5113.5 +1 +5113.5 +1 +5124.33 +1 +5124.33 +1 +5100.3 +1 +5100.3 +1 +5108.1 +1 +5108.1 +1 +5140.83 +1 +5140.83 +1 +5125.4 +1 +5125.4 +1 +5123.07 +1 +5123.07 +1 +5110.03 +1 +5110.03 +1 +5122.13 +1 +5122.13 +1 +5143.47 +1 +5143.47 +1 +5149.73 +1 +5149.73 +1 +5141.17 +1 +5141.17 +1 +5125.3 +1 +5125.3 +1 +5144.47 +1 +5144.47 +1 +5145.93 +1 +5145.93 +1 +5115.17 +1 +5115.17 +1 +5126.8 +1 +5126.8 +1 +5163.77 +1 +5163.77 +1 +5176.87 +1 +5176.87 +1 +5188.5 +1 +5188.5 +1 +5145.77 +1 +5145.77 +1 +5159.33 +1 +5159.33 +1 +5164.5 +1 +5164.5 +1 +5199.63 +1 +5199.63 +1 +5207.5 +1 +5207.5 +1 +5180.9 +1 +5180.9 +1 +5185.43 +1 +5185.43 +1 +5242.87 +1 +5242.87 +1 +5179.5 +1 +5179.5 +1 +5188.57 +1 +5188.57 +1 +5171.6 +1 +5171.6 +1 +5223.17 +1 +5223.17 +1 +5217.73 +1 +5217.73 +1 +5193.3 +1 +5193.3 +1 +5178.57 +1 +5178.57 +1 +5231.57 +1 +5231.57 +1 +5241.53 +1 +5241.53 +1 +5233.73 +1 +5233.73 +1 +5231.67 +1 +5231.67 +1 +5209.9 +1 +5209.9 +1 +5214.63 +1 +5214.63 +1 +5193.93 +1 +5193.93 +1 +5218.03 +1 +5218.03 +1 +5234.1 +1 +5234.1 +1 +5255.13 +1 +5255.13 +1 +5274.1 +1 +5274.1 +1 +5270.6 +1 +5270.6 +1 +5296.1 +1 +5296.1 +1 +5283.17 +1 +5283.17 +1 +5253.6 +1 +5253.6 +1 +5294.83 +1 +5294.83 +1 +5274.8 +1 +5274.8 +1 +5272.63 +1 +5272.63 +1 +5239.83 +1 +5239.83 +1 +5281.23 +1 +5281.23 +1 +5300.1 +1 +5300.1 +1 +5310.27 +1 +5310.27 +1 +5311.43 +1 +5311.43 +1 +5315.07 +1 +5315.07 +1 +5315.93 +1 +5315.93 +1 +5325.13 +1 +5325.13 +1 +5321.7 +1 +5321.7 +1 +5323.27 +1 +5323.27 +1 +5352.77 +1 +5352.77 +1 +5348.37 +1 +5348.37 +1 +5358.9 +1 +5358.9 +1 +5332 +1 +5332 +1 +5327.5 +1 +5327.5 +1 +5349.43 +1 +5349.43 +1 +5409.2 +1 +5409.2 +1 +5393.87 +1 +5393.87 +1 +5373.3 +1 +5373.3 +1 +5325.17 +1 +5325.17 +1 +5385.73 +1 +5385.73 +1 +5425.07 +1 +5425.07 +1 +5419.3 +1 +5419.3 +1 +5379.47 +1 +5379.47 +1 +5412.3 +1 +5412.3 +1 +5421.83 +1 +5421.83 +1 +5417.07 +1 +5417.07 +1 +5402.13 +1 +5402.13 +1 +5416.53 +1 +5416.53 +1 +5399.13 +1 +5399.13 +1 +5418.73 +1 +5418.73 +1 +5460.5 +1 +5460.5 +1 +5453.77 +1 +5453.77 +1 +5472.67 +1 +5472.67 +1 +5455.7 +1 +5455.7 +1 +5437.47 +1 +5437.47 +1 +5433.7 +1 +5433.7 +1 +5419.93 +1 +5419.93 +1 +5491.7 +1 +5491.7 +1 +5477.83 +1 +5477.83 +1 +5461.67 +1 +5461.67 +1 +5490.97 +1 +5490.97 +1 +5487.43 +1 +5487.43 +1 +5529.77 +1 +5529.77 +1 +5508.73 +1 +5508.73 +1 +5489.17 +1 +5489.17 +1 +5504.4 +1 +5504.4 +1 +5512.63 +1 +5512.63 +1 +5534.27 +1 +5534.27 +1 +5532.23 +1 +5532.23 +1 +5543.03 +1 +5543.03 +1 +5560.47 +1 +5560.47 +1 +5536.6 +1 +5536.6 +1 +5560.47 +1 +5560.47 +1 +5562.67 +1 +5562.67 +1 +5542.57 +1 +5542.57 +1 +5530.47 +1 +5530.47 +1 +5601.7 +1 +5601.7 +1 +5580.37 +1 +5580.37 +1 +5563.87 +1 +5563.87 +1 +5546.47 +1 +5546.47 +1 +5549.6 +1 +5549.6 +1 +5608.37 +1 +5608.37 +1 +5581.8 +1 +5581.8 +1 +5576.87 +1 +5576.87 +1 +5540.87 +1 +5540.87 +1 +5539.67 +1 +5539.67 +1 +5577.2 +1 +5577.2 +1 +5578.9 +1 +5578.9 +1 +5567.97 +1 +5567.97 +1 +5604.73 +1 +5604.73 +1 +5550.4 +1 +5550.4 +1 +5539.47 +1 +5539.47 +1 +5546.73 +1 +5546.73 +1 +5540.43 +1 +5540.43 +1 +5498.87 +1 +5498.87 +1 +5524.93 +1 +5524.93 +1 +5530.17 +1 +5530.17 +1 +5500.83 +1 +5500.83 +1 +5518.27 +1 +5518.27 +1 +5506.4 +1 +5506.4 +1 +5509.77 +1 +5509.77 +1 +5510.53 +1 +5510.53 +1 +5494.3 +1 +5494.3 +1 +5467.47 +1 +5467.47 +1 +5461.47 +1 +5461.47 +1 +5484.2 +1 +5484.2 +1 +5449.93 +1 +5449.93 +1 +5472.57 +1 +5472.57 +1 +5464.8 +1 +5464.8 +1 +5443.53 +1 +5443.53 +1 +5460.53 +1 +5460.53 +1 +5410.03 +1 +5410.03 +1 +5457.83 +1 +5457.83 +1 +5439.9 +1 +5439.9 +1 +5425.6 +1 +5425.6 +1 +5423.8 +1 +5423.8 +1 +5373.2 +1 +5373.2 +1 +5417.03 +1 +5417.03 +1 +5417.8 +1 +5417.8 +1 +5432.63 +1 +5432.63 +1 +5358.77 +1 +5358.77 +1 +5433.2 +1 +5433.2 +1 +5422.03 +1 +5422.03 +1 +5451.47 +1 +5451.47 +1 +5470.87 +1 +5470.87 +1 +5430.27 +1 +5430.27 +1 +5441.27 +1 +5441.27 +1 +5456.77 +1 +5456.77 +1 +5456.9 +1 +5456.9 +1 +5434.5 +1 +5434.5 +1 +5454.73 +1 +5454.73 +1 +5462.13 +1 +5462.13 +1 +5414.1 +1 +5414.1 +1 +5431.07 +1 +5431.07 +1 +5405.73 +1 +5405.73 +1 +5467.13 +1 +5467.13 +1 +5462.7 +1 +5462.7 +1 +5472.53 +1 +5472.53 +1 +5464.3 +1 +5464.3 +1 +5479.47 +1 +5479.47 +1 +5488.03 +1 +5488.03 +1 +5472.77 +1 +5472.77 +1 +5461.9 +1 +5461.9 +1 +5474.4 +1 +5474.4 +1 +5511.13 +1 +5511.13 +1 +5474.87 +1 +5474.87 +1 +5440 +1 +5440 +1 +5467.63 +1 +5467.63 +1 +5481.43 +1 +5481.43 +1 +5492.17 +1 +5492.17 +1 +5503.13 +1 +5503.13 +1 +5557.87 +1 +5557.87 +1 +5552.63 +1 +5552.63 +1 +5557.37 +1 +5557.37 +1 +5589.27 +1 +5589.27 +1 +5563.83 +1 +5563.83 +1 +5542.53 +1 +5542.53 +1 +5604.63 +1 +5604.63 +1 +5581.83 +1 +5581.83 +1 +5608.1 +1 +5608.1 +1 +5628.47 +1 +5628.47 +1 +5611.1 +1 +5611.1 +1 +5644.83 +1 +5644.83 +1 +5677.47 +1 +5677.47 +1 +5682.03 +1 +5682.03 +1 +5684.03 +1 +5684.03 +1 +5695.8 +1 +5695.8 +1 +5756.4 +1 +5756.4 +1 +5705.17 +1 +5705.17 +1 +5745.6 +1 +5745.6 +1 +5783.4 +1 +5783.4 +1 +5761.37 +1 +5761.37 +1 +5823.5 +1 +5823.5 +1 +5881.03 +1 +5881.03 +1 +5831.3 +1 +5831.3 +1 +5855.63 +1 +5855.63 +1 +5884.43 +1 +5884.43 +1 +5932.8 +1 +5932.8 +1 +5964.63 +1 +5964.63 +1 +5953.93 +1 +5953.93 +1 +5958.57 +1 +5958.57 +1 +6025.17 +1 +6025.17 +1 +6033.97 +1 +6033.97 +1 +6072.97 +1 +6072.97 +1 +6071.77 +1 +6071.77 +1 +6081.33 +1 +6081.33 +1 +6111.97 +1 +6111.97 +1 +6123.57 +1 +6123.57 +1 +6174.57 +1 +6174.57 +1 +6201.4 +1 +6201.4 +1 +6256.77 +1 +6256.77 +1 +6247.67 +1 +6247.67 +1 +6302.3 +1 +6302.3 +1 +6317.27 +1 +6317.27 +1 +6373.57 +1 +6373.57 +1 +6361.5 +1 +6361.5 +1 +6445.83 +1 +6445.83 +1 +6472.43 +1 +6472.43 +1 +6495.6 +1 +6495.6 +1 +6540.53 +1 +6540.53 +1 +6570.07 +1 +6570.07 +1 +6595.17 +1 +6595.17 +1 +6646.77 +1 +6646.77 +1 +6675.57 +1 +6675.57 +1 +6727.3 +1 +6727.3 +1 +6698.73 +1 +6698.73 +1 +6743.6 +1 +6743.6 +1 +6816.3 +1 +6816.3 +1 +6872.13 +1 +6872.13 +1 +6916.8 +1 +6916.8 +1 +6947.13 +1 +6947.13 +1 +6946.17 +1 +6946.17 +1 +7033.13 +1 +7033.13 +1 +7056.63 +1 +7056.63 +1 +7070.67 +1 +7070.67 +1 +7125.93 +1 +7125.93 +1 +7139.43 +1 +7139.43 +1 +7155.43 +1 +7155.43 +1 +7160.03 +1 +7160.03 +1 +7259.77 +1 +7259.77 +1 +7268.3 +1 +7268.3 +1 +7274.17 +1 +7274.17 +1 +7274.4 +1 +7274.4 +1 +7282.23 +1 +7282.23 +1 +7332.87 +1 +7332.87 +1 +7302.83 +1 +7302.83 +1 +7292.67 +1 +7292.67 +1 +7283.23 +1 +7283.23 +1 +7320.87 +1 +7320.87 +1 +7296.1 +1 +7296.1 +1 +7317.23 +1 +7317.23 +1 +7298.37 +1 +7298.37 +1 +7275.47 +1 +7275.47 +1 +7222.9 +1 +7222.9 +1 +7181.8 +1 +7181.8 +1 +7222.07 +1 +7222.07 +1 +7180.67 +1 +7180.67 +1 +7202.7 +1 +7202.7 +1 +7193.67 +1 +7193.67 +1 +7100.47 +1 +7100.47 +1 +7132.1 +1 +7132.1 +1 +7105.53 +1 +7105.53 +1 +7060.67 +1 +7060.67 +1 +7051 +1 +7051 +1 +7083.6 +1 +7083.6 +1 +7050.13 +1 +7050.13 +1 +7091.3 +1 +7091.3 +1 +7052.4 +1 +7052.4 +1 +7074.83 +1 +7074.83 +1 +7076.77 +1 +7076.77 +1 +7101.4 +1 +7101.4 +1 +7128.97 +1 +7128.97 +1 +7104.63 +1 +7104.63 +1 +7061.33 +1 +7061.33 +1 +7155.23 +1 +7155.23 +1 +7251.07 +1 +7251.07 +1 +7212.67 +1 +7212.67 +1 +7252.63 +1 +7252.63 +1 +7339.4 +1 +7339.4 +1 +7370.6 +1 +7370.6 +1 +7427.03 +1 +7427.03 +1 +7508.63 +1 +7508.63 +1 +7568.4 +1 +7568.4 +1 +7596.9 +1 +7596.9 +1 +7631.3 +1 +7631.3 +1 +7686.07 +1 +7686.07 +1 +7749.2 +1 +7749.2 +1 +7875.1 +1 +7875.1 +1 +7982.07 +1 +7982.07 +1 +8052.07 +1 +8052.07 +1 +8156.13 +1 +8156.13 +1 +8273.37 +1 +8273.37 +1 +8333.8 +1 +8333.8 +1 +8451.47 +1 +8451.47 +1 +8570.17 +1 +8570.17 +1 +8699.57 +1 +8699.57 +1 +8783.9 +1 +8783.9 +1 +8893.1 +1 +8893.1 +1 +8981.57 +1 +8981.57 +1 +9052.2 +1 +9052.2 +1 +9175.07 +1 +9175.07 +1 +9243.43 +1 +9243.43 +1 +9258.63 +1 +9258.63 +1 +9357.33 +1 +9357.33 +1 +9374.1 +1 +9374.1 +1 +9415.23 +1 +9415.23 +1 +9462.43 +1 +9462.43 +1 +9482.5 +1 +9482.5 +1 +9518.4 +1 +9518.4 +1 +9530.07 +1 +9530.07 +1 +9497.37 +1 +9497.37 +1 +9514.87 +1 +9514.87 +1 +9530.5 +1 +9530.5 +1 +9489.9 +1 +9489.9 +1 +9385.5 +1 +9385.5 +1 +9218.97 +1 +9218.97 +1 +9217.6 +1 +9217.6 +1 +9131.2 +1 +9131.2 +1 +8909.7 +1 +8909.7 +1 +8811.1 +1 +8811.1 +1 +8690.57 +1 +8690.57 +1 +8537.97 +1 +8537.97 +1 +8377.13 +1 +8377.13 +1 +8247.37 +1 +8247.37 +1 +8051.87 +1 +8051.87 +1 +7857.37 +1 +7857.37 +1 +7738.73 +1 +7738.73 +1 +7568.57 +1 +7568.57 +1 +7417.2 +1 +7417.2 +1 +7255.17 +1 +7255.17 +1 +7096.23 +1 +7096.23 +1 +6982.73 +1 +6982.73 +1 +6850.93 +1 +6850.93 +1 +6737.03 +1 +6737.03 +1 +6621.83 +1 +6621.83 +1 +6554.97 +1 +6554.97 +1 +6428.93 +1 +6428.93 +1 +6330.33 +1 +6330.33 +1 +6227.43 +1 +6227.43 +1 +6145.53 +1 +6145.53 +1 +6081.63 +1 +6081.63 +1 +6064.67 +1 +6064.67 +1 +6035.13 +1 +6035.13 +1 +6008.27 +1 +6008.27 +1 +5953.27 +1 +5953.27 +1 +5917.07 +1 +5917.07 +1 +5879.1 +1 +5879.1 +1 +5887.27 +1 +5887.27 +1 +5905.03 +1 +5905.03 +1 +5853.63 +1 +5853.63 +1 +5841.03 +1 +5841.03 +1 +5845.47 +1 +5845.47 +1 +5896.97 +1 +5896.97 +1 +5857.4 +1 +5857.4 +1 +5931.13 +1 +5931.13 +1 +5967.4 +1 +5967.4 +1 +5998.5 +1 +5998.5 +1 +6042.53 +1 +6042.53 +1 +6076.3 +1 +6076.3 +1 +6133.6 +1 +6133.6 +1 +6141.3 +1 +6141.3 +1 +6266.53 +1 +6266.53 +1 +6251.53 +1 +6251.53 +1 +6303.7 +1 +6303.7 +1 +6334.73 +1 +6334.73 +1 +6452.73 +1 +6452.73 +1 +6528.5 +1 +6528.5 +1 +6563.97 +1 +6563.97 +1 +6636.63 +1 +6636.63 +1 +6684.97 +1 +6684.97 +1 +6767.2 +1 +6767.2 +1 +6826.87 +1 +6826.87 +1 +6882.27 +1 +6882.27 +1 +6890.83 +1 +6890.83 +1 +6961.93 +1 +6961.93 +1 +7002.97 +1 +7002.97 +1 +7010.3 +1 +7010.3 +1 +7074.57 +1 +7074.57 +1 +7162.03 +1 +7162.03 +1 +7139.57 +1 +7139.57 +1 +7163.9 +1 +7163.9 +1 +7215.77 +1 +7215.77 +1 +7292.93 +1 +7292.93 +1 +7317.8 +1 +7317.8 +1 +7341.4 +1 +7341.4 +1 +7361.47 +1 +7361.47 +1 +7355.63 +1 +7355.63 +1 +7352.7 +1 +7352.7 +1 +7325.2 +1 +7325.2 +1 +7290.27 +1 +7290.27 +1 +7239.53 +1 +7239.53 +1 +7296.13 +1 +7296.13 +1 +7339.2 +1 +7339.2 +1 +7308.47 +1 +7308.47 +1 +7314.83 +1 +7314.83 +1 +7310.77 +1 +7310.77 +1 +7285.5 +1 +7285.5 +1 +7246.97 +1 +7246.97 +1 +7345.33 +1 +7345.33 +1 +7364.4 +1 +7364.4 +1 +7296.7 +1 +7296.7 +1 +7353 +1 +7353 +1 +7442.23 +1 +7442.23 +1 +7413.47 +1 +7413.47 +1 +7485.8 +1 +7485.8 +1 +7585.3 +1 +7585.3 +1 +7625.27 +1 +7625.27 +1 +7731.87 +1 +7731.87 +1 +7772.57 +1 +7772.57 +1 +7868.07 +1 +7868.07 +1 +7949.63 +1 +7949.63 +1 +8062.33 +1 +8062.33 +1 +8134.1 +1 +8134.1 +1 +8194.17 +1 +8194.17 +1 +8295.4 +1 +8295.4 +1 +8453.77 +1 +8453.77 +1 +8565.47 +1 +8565.47 +1 +8707.8 +1 +8707.8 +1 +8794.9 +1 +8794.9 +1 +8926.77 +1 +8926.77 +1 +9092.13 +1 +9092.13 +1 +9291.03 +1 +9291.03 +1 +9441.5 +1 +9441.5 +1 +9556.57 +1 +9556.57 +1 +9726.97 +1 +9726.97 +1 +9829.3 +1 +9829.3 +1 +9998.23 +1 +9998.23 +1 +10183.5 +1 +10183.5 +1 +10357.3 +1 +10357.3 +1 +10458.4 +1 +10458.4 +1 +10595.5 +1 +10595.5 +1 +10827.2 +1 +10827.2 +1 +10975.8 +1 +10975.8 +1 +11129.8 +1 +11129.8 +1 +11249.8 +1 +11249.8 +1 +11296.3 +1 +11296.3 +1 +11398.5 +1 +11398.5 +1 +11530.1 +1 +11530.1 +1 +11595.1 +1 +11595.1 +1 +11775.9 +1 +11775.9 +1 +11743.2 +1 +11743.2 +1 +11874.3 +1 +11874.3 +1 +11907.6 +1 +11907.6 +1 +11863.2 +1 +11863.2 +1 +11852.8 +1 +11852.8 +1 +11799.3 +1 +11799.3 +1 +11705.6 +1 +11705.6 +1 +11586 +1 +11586 +1 +11431.1 +1 +11431.1 +1 +11268.5 +1 +11268.5 +1 +11057.4 +1 +11057.4 +1 +10743.6 +1 +10743.6 +1 +10519.1 +1 +10519.1 +1 +10151.1 +1 +10151.1 +1 +9747.07 +1 +9747.07 +1 +9327.17 +1 +9327.17 +1 +8841.5 +1 +8841.5 +1 +8379.23 +1 +8379.23 +1 +7895.93 +1 +7895.93 +1 +7381.73 +1 +7381.73 +1 +6849.57 +1 +6849.57 +1 +6354.03 +1 +6354.03 +1 +5855.87 +1 +5855.87 +1 +5376.73 +1 +5376.73 +1 +4900.87 +1 +4900.87 +1 +4485.23 +1 +4485.23 +1 +4109.43 +1 +4109.43 +1 +3754.53 +1 +3754.53 +1 +3454.67 +1 +3454.67 +1 +3147.06 +1 +3147.06 +1 +2923.62 +1 +2923.62 +1 +2739.52 +1 +2739.52 +1 +2542.33 +1 +2542.33 +1 +2389.44 +1 +2389.44 +1 +2250.73 +1 +2250.73 +1 +2093.8 +1 +2093.8 +1 +2003.28 +1 +2003.28 +1 +1901.48 +1 +1901.48 +1 +1804.61 +1 +1804.61 +1 +1717.37 +1 +1717.37 +1 +1634.53 +1 +1634.53 +1 +1585.71 +1 +1585.71 +1 +1534.73 +1 +1534.73 +1 +1475.25 +1 +1475.25 +1 +1436.56 +1 +1436.56 +1 +1396.22 +1 +1396.22 +1 +1385.54 +1 +1385.54 +1 +1388.67 +1 +1388.67 +1 +1357.21 +1 +1357.21 +1 +1335.62 +1 +1335.62 +1 +1358.27 +1 +1358.27 +1 +1343.45 +1 +1343.45 +1 +1331.02 +1 +1331.02 +1 +1337.25 +1 +1337.25 +1 +1288.96 +1 +1288.96 +1 +1282.39 +1 +1282.39 +1 +1281.82 +1 +1281.82 +1 +1265.97 +1 +1265.97 +1 +1272.59 +1 +1272.59 +1 +1262.72 +1 +1262.72 +1 +1248.43 +1 +1248.43 +1 +1226.39 +1 +1226.39 +1 +1237.6 +1 +1237.6 +1 +1195.54 +1 +1195.54 +1 +1218.11 +1 +1218.11 +1 +1226.2 +1 +1226.2 +1 +1230.41 +1 +1230.41 +1 +1226.95 +1 +1226.95 +1 +1221.29 +1 +1221.29 +1 +1219.48 +1 +1219.48 +1 +1220.35 +1 +1220.35 +1 +1224.87 +1 +1224.87 +1 +1199.44 +1 +1199.44 +1 +1216.93 +1 +1216.93 +1 +1211.49 +1 +1211.49 +1 +1200.68 +1 +1200.68 +1 +1199.09 +1 +1199.09 +1 +1193.63 +1 +1193.63 +1 +1193.8 +1 +1193.8 +1 +1193.8 +1 +1193.8 +1 +1202.35 +1 +1202.35 +1 +1201.4 +1 +1201.4 +1 +1204.37 +1 +1204.37 +1 +1211.34 +1 +1211.34 +1 +1202.81 +1 +1202.81 +1 +1202.23 +1 +1202.23 +1 +1191.3 +1 +1191.3 +1 +1183.65 +1 +1183.65 +1 +1164.48 +1 +1164.48 +1 +1171.19 +1 +1171.19 +1 +1173.37 +1 +1173.37 +1 +1166.21 +1 +1166.21 +1 +1184.77 +1 +1184.77 +1 +1177.84 +1 +1177.84 +1 +1181.16 +1 +1181.16 +1 +1176.62 +1 +1176.62 +1 +1171.89 +1 +1171.89 +1 +1167.6 +1 +1167.6 +1 +1170.68 +1 +1170.68 +1 +1187.72 +1 +1187.72 +1 +1167.62 +1 +1167.62 +1 +1181.86 +1 +1181.86 +1 +1177.88 +1 +1177.88 +1 +1156.11 +1 +1156.11 +1 +1166.44 +1 +1166.44 +1 +1177.24 +1 +1177.24 +1 +1168.16 +1 +1168.16 +1 +1160.79 +1 +1160.79 +1 +1162.87 +1 +1162.87 +1 +1143.34 +1 +1143.34 +1 +1162.25 +1 +1162.25 +1 +1169.27 +1 +1169.27 +1 +1171.9 +1 +1171.9 +1 +1158.22 +1 +1158.22 +1 +1163.33 +1 +1163.33 +1 +1147.26 +1 +1147.26 +1 +1171.52 +1 +1171.52 +1 +1169.43 +1 +1169.43 +1 +1167.96 +1 +1167.96 +1 +1154.85 +1 +1154.85 +1 +1152.52 +1 +1152.52 +1 +1176.41 +1 +1176.41 +1 +1156.27 +1 +1156.27 +1 +1169.93 +1 +1169.93 +1 +1166.84 +1 +1166.84 +1 +1156.68 +1 +1156.68 +1 +1163.74 +1 +1163.74 +1 +1176.57 +1 +1176.57 +1 +1173.63 +1 +1173.63 +1 +1176.88 +1 +1176.88 +1 +1154.32 +1 +1154.32 +1 +1154.31 +1 +1154.31 +1 +1151.59 +1 +1151.59 +1 +1161.29 +1 +1161.29 +1 +1163.61 +1 +1163.61 +1 +1156.85 +1 +1156.85 +1 +1153.3 +1 +1153.3 +1 +1144.82 +1 +1144.82 +1 +1151.66 +1 +1151.66 +1 +1147.87 +1 +1147.87 +1 +1150.3 +1 +1150.3 +1 +1154.47 +1 +1154.47 +1 +1145.95 +1 +1145.95 +1 +1163.58 +1 +1163.58 +1 +1148.38 +1 +1148.38 +1 +1145.11 +1 +1145.11 +1 +1138.68 +1 +1138.68 +1 +1163.68 +1 +1163.68 +1 +1143.45 +1 +1143.45 +1 +1141.94 +1 +1141.94 +1 +1160.89 +1 +1160.89 +1 +1150.89 +1 +1150.89 +1 +1136.68 +1 +1136.68 +1 +1135.11 +1 +1135.11 +1 +1139.3 +1 +1139.3 +1 +1136.31 +1 +1136.31 +1 +1155.37 +1 +1155.37 +1 +1156.65 +1 +1156.65 +1 +1136.11 +1 +1136.11 +1 +1163.14 +1 +1163.14 +1 +1163.03 +1 +1163.03 +1 +1156.74 +1 +1156.74 +1 +1138.4 +1 +1138.4 +1 +1157.06 +1 +1157.06 +1 +1159.98 +1 +1159.98 +1 +1144.76 +1 +1144.76 +1 +1156.5 +1 +1156.5 +1 +1149.59 +1 +1149.59 +1 +1161.55 +1 +1161.55 +1 +1145.97 +1 +1145.97 +1 +1124.42 +1 +1124.42 +1 +1139.25 +1 +1139.25 +1 +1144.19 +1 +1144.19 +1 +1143.59 +1 +1143.59 +1 +1144.06 +1 +1144.06 +1 +1159.47 +1 +1159.47 +1 +1154.29 +1 +1154.29 +1 +1168.73 +1 +1168.73 +1 +1143.92 +1 +1143.92 +1 +1139.13 +1 +1139.13 +1 +1141.51 +1 +1141.51 +1 +1158.9 +1 +1158.9 +1 +1163.81 +1 +1163.81 +1 +1154.43 +1 +1154.43 +1 +1165.16 +1 +1165.16 +1 +1169.79 +1 +1169.79 +1 +1162.09 +1 +1162.09 +1 +1169.91 +1 +1169.91 +1 +1146.6 +1 +1146.6 +1 +1148.29 +1 +1148.29 +1 +1156.65 +1 +1156.65 +1 +1147.97 +1 +1147.97 +1 +1158.14 +1 +1158.14 +1 +1159.24 +1 +1159.24 +1 +1143.64 +1 +1143.64 +1 +1133.94 +1 +1133.94 +1 +1144.04 +1 +1144.04 +1 +1158.79 +1 +1158.79 +1 +1163.05 +1 +1163.05 +1 +1162.64 +1 +1162.64 +1 +1152.86 +1 +1152.86 +1 +1148.44 +1 +1148.44 +1 +1157.94 +1 +1157.94 +1 +1167.17 +1 +1167.17 +1 +1146.77 +1 +1146.77 +1 +1164.77 +1 +1164.77 +1 +1147.71 +1 +1147.71 +1 +1149.57 +1 +1149.57 +1 +1144.89 +1 +1144.89 +1 +1157.45 +1 +1157.45 +1 +1150.19 +1 +1150.19 +1 +1153.91 +1 +1153.91 +1 +1156.95 +1 +1156.95 +1 +1141.96 +1 +1141.96 +1 +1162.88 +1 +1162.88 +1 +1141.7 +1 +1141.7 +1 +1137.56 +1 +1137.56 +1 +1170.83 +1 +1170.83 +1 +1146.21 +1 +1146.21 +1 +1132.85 +1 +1132.85 +1 +1147.22 +1 +1147.22 +1 +1155.99 +1 +1155.99 +1 +1165.39 +1 +1165.39 +1 +1147.84 +1 +1147.84 +1 +1178.55 +1 +1178.55 +1 +1170.06 +1 +1170.06 +1 +1159.41 +1 +1159.41 +1 +1148.53 +1 +1148.53 +1 +1154.46 +1 +1154.46 +1 +1164.67 +1 +1164.67 +1 +1166.52 +1 +1166.52 +1 +1156.16 +1 +1156.16 +1 +1140.65 +1 +1140.65 +1 +1172.77 +1 +1172.77 +1 +1167.97 +1 +1167.97 +1 +1151.87 +1 +1151.87 +1 +1139.72 +1 +1139.72 +1 +1159.14 +1 +1159.14 +1 +1153.1 +1 +1153.1 +1 +1150.26 +1 +1150.26 +1 +1148.48 +1 +1148.48 +1 +1141.39 +1 +1141.39 +1 +1140.81 +1 +1140.81 +1 +1153.95 +1 +1153.95 +1 +1157.93 +1 +1157.93 +1 +1159.13 +1 +1159.13 +1 +1141.49 +1 +1141.49 +1 +1162.03 +1 +1162.03 +1 +1156.01 +1 +1156.01 +1 +1144.36 +1 +1144.36 +1 +1140.78 +1 +1140.78 +1 +1151.45 +1 +Fe2p +Fe3O4 +2021 +8 +5 +5 +29 +55 +0 +11 +Casa Info Follows +0 +0 +0 +0 +none +Group: none +Analyzer Lens: none +Analyzer Slit: none +Scan Mode: none +C:\Users\pielsticker\Downloads\utils\test fits\new\Fe2p_Fe3O4_new.vms +XPS +0 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +4.1408 +0 +0 +0 +0 +0 +Fe +2p +-1 +kinetic energy +eV +716.61 +0.05 +2 +counts +d +Transmission +d +pulse counting +0.1 +3 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +3402 +1328.24 +10850.6 +1 +1 +5787.97 +1 +5787.97 +1 +5759.4 +1 +5759.4 +1 +5772.77 +1 +5772.77 +1 +5818.43 +1 +5818.43 +1 +5773.47 +1 +5773.47 +1 +5763.53 +1 +5763.53 +1 +5744.77 +1 +5744.77 +1 +5739.03 +1 +5739.03 +1 +5745.73 +1 +5745.73 +1 +5731.47 +1 +5731.47 +1 +5736.03 +1 +5736.03 +1 +5757.3 +1 +5757.3 +1 +5706.9 +1 +5706.9 +1 +5634.9 +1 +5634.9 +1 +5651.47 +1 +5651.47 +1 +5685.87 +1 +5685.87 +1 +5659.6 +1 +5659.6 +1 +5620.67 +1 +5620.67 +1 +5626.9 +1 +5626.9 +1 +5624.33 +1 +5624.33 +1 +5625.87 +1 +5625.87 +1 +5589.4 +1 +5589.4 +1 +5599.5 +1 +5599.5 +1 +5544.3 +1 +5544.3 +1 +5547.43 +1 +5547.43 +1 +5574.43 +1 +5574.43 +1 +5542 +1 +5542 +1 +5550 +1 +5550 +1 +5530.93 +1 +5530.93 +1 +5502.7 +1 +5502.7 +1 +5493.27 +1 +5493.27 +1 +5460.5 +1 +5460.5 +1 +5466.83 +1 +5466.83 +1 +5435.83 +1 +5435.83 +1 +5436.63 +1 +5436.63 +1 +5450.4 +1 +5450.4 +1 +5426.9 +1 +5426.9 +1 +5414.47 +1 +5414.47 +1 +5411.13 +1 +5411.13 +1 +5430.77 +1 +5430.77 +1 +5360.27 +1 +5360.27 +1 +5346.3 +1 +5346.3 +1 +5404.77 +1 +5404.77 +1 +5390.27 +1 +5390.27 +1 +5357.1 +1 +5357.1 +1 +5363.63 +1 +5363.63 +1 +5353.87 +1 +5353.87 +1 +5372.67 +1 +5372.67 +1 +5392.43 +1 +5392.43 +1 +5368.2 +1 +5368.2 +1 +5329.13 +1 +5329.13 +1 +5350.93 +1 +5350.93 +1 +5318.07 +1 +5318.07 +1 +5328.17 +1 +5328.17 +1 +5344.1 +1 +5344.1 +1 +5297.73 +1 +5297.73 +1 +5297.77 +1 +5297.77 +1 +5307.7 +1 +5307.7 +1 +5354.43 +1 +5354.43 +1 +5312.17 +1 +5312.17 +1 +5296.27 +1 +5296.27 +1 +5313.67 +1 +5313.67 +1 +5294.73 +1 +5294.73 +1 +5276.03 +1 +5276.03 +1 +5303.3 +1 +5303.3 +1 +5323.53 +1 +5323.53 +1 +5271.73 +1 +5271.73 +1 +5269.47 +1 +5269.47 +1 +5262.77 +1 +5262.77 +1 +5310.87 +1 +5310.87 +1 +5304.83 +1 +5304.83 +1 +5315.57 +1 +5315.57 +1 +5295.33 +1 +5295.33 +1 +5336.03 +1 +5336.03 +1 +5337.43 +1 +5337.43 +1 +5296.53 +1 +5296.53 +1 +5313.93 +1 +5313.93 +1 +5322.2 +1 +5322.2 +1 +5330.03 +1 +5330.03 +1 +5306.83 +1 +5306.83 +1 +5339.03 +1 +5339.03 +1 +5322.37 +1 +5322.37 +1 +5346.53 +1 +5346.53 +1 +5355.57 +1 +5355.57 +1 +5328.5 +1 +5328.5 +1 +5313.37 +1 +5313.37 +1 +5381.27 +1 +5381.27 +1 +5405.17 +1 +5405.17 +1 +5366.87 +1 +5366.87 +1 +5362.77 +1 +5362.77 +1 +5352.67 +1 +5352.67 +1 +5335.67 +1 +5335.67 +1 +5361.07 +1 +5361.07 +1 +5313.6 +1 +5313.6 +1 +5362.17 +1 +5362.17 +1 +5349.9 +1 +5349.9 +1 +5354.13 +1 +5354.13 +1 +5351.9 +1 +5351.9 +1 +5363.67 +1 +5363.67 +1 +5408.13 +1 +5408.13 +1 +5427.6 +1 +5427.6 +1 +5406.77 +1 +5406.77 +1 +5397.9 +1 +5397.9 +1 +5416.43 +1 +5416.43 +1 +5414.13 +1 +5414.13 +1 +5369 +1 +5369 +1 +5375.87 +1 +5375.87 +1 +5366.4 +1 +5366.4 +1 +5357.7 +1 +5357.7 +1 +5419.5 +1 +5419.5 +1 +5421.1 +1 +5421.1 +1 +5436.83 +1 +5436.83 +1 +5443.87 +1 +5443.87 +1 +5472.6 +1 +5472.6 +1 +5465.33 +1 +5465.33 +1 +5416.73 +1 +5416.73 +1 +5424.8 +1 +5424.8 +1 +5421.93 +1 +5421.93 +1 +5399.53 +1 +5399.53 +1 +5411.4 +1 +5411.4 +1 +5457.57 +1 +5457.57 +1 +5481.13 +1 +5481.13 +1 +5407.33 +1 +5407.33 +1 +5432.93 +1 +5432.93 +1 +5463.67 +1 +5463.67 +1 +5450.37 +1 +5450.37 +1 +5450.13 +1 +5450.13 +1 +5454.2 +1 +5454.2 +1 +5458.7 +1 +5458.7 +1 +5514.83 +1 +5514.83 +1 +5510.57 +1 +5510.57 +1 +5467.9 +1 +5467.9 +1 +5476.8 +1 +5476.8 +1 +5504.7 +1 +5504.7 +1 +5483.13 +1 +5483.13 +1 +5431.2 +1 +5431.2 +1 +5494.47 +1 +5494.47 +1 +5516.03 +1 +5516.03 +1 +5508.77 +1 +5508.77 +1 +5482.9 +1 +5482.9 +1 +5481.2 +1 +5481.2 +1 +5481 +1 +5481 +1 +5546 +1 +5546 +1 +5490.27 +1 +5490.27 +1 +5481.1 +1 +5481.1 +1 +5501.57 +1 +5501.57 +1 +5550.23 +1 +5550.23 +1 +5495.33 +1 +5495.33 +1 +5495.8 +1 +5495.8 +1 +5527.23 +1 +5527.23 +1 +5561.17 +1 +5561.17 +1 +5535.17 +1 +5535.17 +1 +5521.23 +1 +5521.23 +1 +5563.07 +1 +5563.07 +1 +5530.03 +1 +5530.03 +1 +5570.83 +1 +5570.83 +1 +5590.83 +1 +5590.83 +1 +5583.07 +1 +5583.07 +1 +5591.5 +1 +5591.5 +1 +5544.97 +1 +5544.97 +1 +5525.17 +1 +5525.17 +1 +5584.27 +1 +5584.27 +1 +5564.7 +1 +5564.7 +1 +5574.73 +1 +5574.73 +1 +5601.47 +1 +5601.47 +1 +5593.03 +1 +5593.03 +1 +5596.5 +1 +5596.5 +1 +5594.5 +1 +5594.5 +1 +5587.63 +1 +5587.63 +1 +5597.8 +1 +5597.8 +1 +5612.2 +1 +5612.2 +1 +5613.23 +1 +5613.23 +1 +5649.03 +1 +5649.03 +1 +5657.6 +1 +5657.6 +1 +5649.97 +1 +5649.97 +1 +5594.93 +1 +5594.93 +1 +5642.9 +1 +5642.9 +1 +5642.73 +1 +5642.73 +1 +5625.97 +1 +5625.97 +1 +5649.53 +1 +5649.53 +1 +5611.33 +1 +5611.33 +1 +5683.2 +1 +5683.2 +1 +5680.27 +1 +5680.27 +1 +5661.4 +1 +5661.4 +1 +5652.37 +1 +5652.37 +1 +5669.77 +1 +5669.77 +1 +5667.13 +1 +5667.13 +1 +5664 +1 +5664 +1 +5656.6 +1 +5656.6 +1 +5706.03 +1 +5706.03 +1 +5672.83 +1 +5672.83 +1 +5686.23 +1 +5686.23 +1 +5719.7 +1 +5719.7 +1 +5697.83 +1 +5697.83 +1 +5734.03 +1 +5734.03 +1 +5694.9 +1 +5694.9 +1 +5729.43 +1 +5729.43 +1 +5726.37 +1 +5726.37 +1 +5728.57 +1 +5728.57 +1 +5741.93 +1 +5741.93 +1 +5674.07 +1 +5674.07 +1 +5720.6 +1 +5720.6 +1 +5755.27 +1 +5755.27 +1 +5735.57 +1 +5735.57 +1 +5763.97 +1 +5763.97 +1 +5794.43 +1 +5794.43 +1 +5743.43 +1 +5743.43 +1 +5721.4 +1 +5721.4 +1 +5743 +1 +5743 +1 +5727.6 +1 +5727.6 +1 +5781.23 +1 +5781.23 +1 +5793.2 +1 +5793.2 +1 +5801.7 +1 +5801.7 +1 +5790.37 +1 +5790.37 +1 +5789 +1 +5789 +1 +5830.27 +1 +5830.27 +1 +5840.53 +1 +5840.53 +1 +5834.9 +1 +5834.9 +1 +5856.87 +1 +5856.87 +1 +5849.33 +1 +5849.33 +1 +5807.43 +1 +5807.43 +1 +5780.5 +1 +5780.5 +1 +5811.5 +1 +5811.5 +1 +5845.1 +1 +5845.1 +1 +5860.43 +1 +5860.43 +1 +5858.47 +1 +5858.47 +1 +5867.8 +1 +5867.8 +1 +5852.73 +1 +5852.73 +1 +5841.03 +1 +5841.03 +1 +5827.9 +1 +5827.9 +1 +5889.2 +1 +5889.2 +1 +5914.03 +1 +5914.03 +1 +5858.57 +1 +5858.57 +1 +5830 +1 +5830 +1 +5896.13 +1 +5896.13 +1 +5902.87 +1 +5902.87 +1 +5911.9 +1 +5911.9 +1 +5891.1 +1 +5891.1 +1 +5895.93 +1 +5895.93 +1 +5886.23 +1 +5886.23 +1 +5909.47 +1 +5909.47 +1 +5915.03 +1 +5915.03 +1 +5928.13 +1 +5928.13 +1 +5959.8 +1 +5959.8 +1 +5969.87 +1 +5969.87 +1 +6014.93 +1 +6014.93 +1 +5998.6 +1 +5998.6 +1 +6013.67 +1 +6013.67 +1 +6029.47 +1 +6029.47 +1 +6048.87 +1 +6048.87 +1 +6039.63 +1 +6039.63 +1 +6020.07 +1 +6020.07 +1 +6040.9 +1 +6040.9 +1 +6108.73 +1 +6108.73 +1 +6072.27 +1 +6072.27 +1 +6111.57 +1 +6111.57 +1 +6089.73 +1 +6089.73 +1 +6103.17 +1 +6103.17 +1 +6115.13 +1 +6115.13 +1 +6190.9 +1 +6190.9 +1 +6182.7 +1 +6182.7 +1 +6101.57 +1 +6101.57 +1 +6149.1 +1 +6149.1 +1 +6170.2 +1 +6170.2 +1 +6174.27 +1 +6174.27 +1 +6172.77 +1 +6172.77 +1 +6210.6 +1 +6210.6 +1 +6229.93 +1 +6229.93 +1 +6197.4 +1 +6197.4 +1 +6217.07 +1 +6217.07 +1 +6146.73 +1 +6146.73 +1 +6162.27 +1 +6162.27 +1 +6211.4 +1 +6211.4 +1 +6176.27 +1 +6176.27 +1 +6142.23 +1 +6142.23 +1 +6119.8 +1 +6119.8 +1 +6160.67 +1 +6160.67 +1 +6167.07 +1 +6167.07 +1 +6184.77 +1 +6184.77 +1 +6144.4 +1 +6144.4 +1 +6131.7 +1 +6131.7 +1 +6086.9 +1 +6086.9 +1 +6038 +1 +6038 +1 +6123.83 +1 +6123.83 +1 +6116 +1 +6116 +1 +6098.03 +1 +6098.03 +1 +6097.07 +1 +6097.07 +1 +6045.87 +1 +6045.87 +1 +6058.67 +1 +6058.67 +1 +6033.27 +1 +6033.27 +1 +6024 +1 +6024 +1 +6033.83 +1 +6033.83 +1 +6019.47 +1 +6019.47 +1 +6019.83 +1 +6019.83 +1 +6060.03 +1 +6060.03 +1 +6018.17 +1 +6018.17 +1 +5981.77 +1 +5981.77 +1 +6025.73 +1 +6025.73 +1 +6021.33 +1 +6021.33 +1 +6011.43 +1 +6011.43 +1 +6054.93 +1 +6054.93 +1 +6030.93 +1 +6030.93 +1 +6014.67 +1 +6014.67 +1 +6011.43 +1 +6011.43 +1 +6051.93 +1 +6051.93 +1 +6054.37 +1 +6054.37 +1 +6060.07 +1 +6060.07 +1 +6071.87 +1 +6071.87 +1 +6022.57 +1 +6022.57 +1 +6068.27 +1 +6068.27 +1 +6068.7 +1 +6068.7 +1 +6123.6 +1 +6123.6 +1 +6060.23 +1 +6060.23 +1 +6103.5 +1 +6103.5 +1 +6124.67 +1 +6124.67 +1 +6075.13 +1 +6075.13 +1 +6095.23 +1 +6095.23 +1 +6155.47 +1 +6155.47 +1 +6136.03 +1 +6136.03 +1 +6150.17 +1 +6150.17 +1 +6096.03 +1 +6096.03 +1 +6156.3 +1 +6156.3 +1 +6203.93 +1 +6203.93 +1 +6184.93 +1 +6184.93 +1 +6245.23 +1 +6245.23 +1 +6249.27 +1 +6249.27 +1 +6246.77 +1 +6246.77 +1 +6214.53 +1 +6214.53 +1 +6223.23 +1 +6223.23 +1 +6269.57 +1 +6269.57 +1 +6308.6 +1 +6308.6 +1 +6286.03 +1 +6286.03 +1 +6302.33 +1 +6302.33 +1 +6333.9 +1 +6333.9 +1 +6359.53 +1 +6359.53 +1 +6430.73 +1 +6430.73 +1 +6434.5 +1 +6434.5 +1 +6398.77 +1 +6398.77 +1 +6490.13 +1 +6490.13 +1 +6496.2 +1 +6496.2 +1 +6459.2 +1 +6459.2 +1 +6448.67 +1 +6448.67 +1 +6503.97 +1 +6503.97 +1 +6495.63 +1 +6495.63 +1 +6562.5 +1 +6562.5 +1 +6565.2 +1 +6565.2 +1 +6547.1 +1 +6547.1 +1 +6618.47 +1 +6618.47 +1 +6615.03 +1 +6615.03 +1 +6616.53 +1 +6616.53 +1 +6657.23 +1 +6657.23 +1 +6665.57 +1 +6665.57 +1 +6692.87 +1 +6692.87 +1 +6706.43 +1 +6706.43 +1 +6714.13 +1 +6714.13 +1 +6739.07 +1 +6739.07 +1 +6748.37 +1 +6748.37 +1 +6754.77 +1 +6754.77 +1 +6790.93 +1 +6790.93 +1 +6860.63 +1 +6860.63 +1 +6846.93 +1 +6846.93 +1 +6867.7 +1 +6867.7 +1 +6913.23 +1 +6913.23 +1 +6880.23 +1 +6880.23 +1 +6915.83 +1 +6915.83 +1 +6976.9 +1 +6976.9 +1 +6953 +1 +6953 +1 +6988.53 +1 +6988.53 +1 +6953.6 +1 +6953.6 +1 +6992.87 +1 +6992.87 +1 +7017.8 +1 +7017.8 +1 +7033.67 +1 +7033.67 +1 +7051.57 +1 +7051.57 +1 +7060.73 +1 +7060.73 +1 +7128.97 +1 +7128.97 +1 +7170.5 +1 +7170.5 +1 +7110.33 +1 +7110.33 +1 +7157.17 +1 +7157.17 +1 +7160.17 +1 +7160.17 +1 +7238.1 +1 +7238.1 +1 +7216.1 +1 +7216.1 +1 +7249.57 +1 +7249.57 +1 +7213.3 +1 +7213.3 +1 +7329.73 +1 +7329.73 +1 +7302.9 +1 +7302.9 +1 +7287.5 +1 +7287.5 +1 +7344.53 +1 +7344.53 +1 +7396.6 +1 +7396.6 +1 +7410.57 +1 +7410.57 +1 +7453.83 +1 +7453.83 +1 +7457.97 +1 +7457.97 +1 +7439.33 +1 +7439.33 +1 +7494.6 +1 +7494.6 +1 +7541.4 +1 +7541.4 +1 +7557.17 +1 +7557.17 +1 +7633.83 +1 +7633.83 +1 +7637.67 +1 +7637.67 +1 +7708.8 +1 +7708.8 +1 +7677.87 +1 +7677.87 +1 +7704.73 +1 +7704.73 +1 +7704.23 +1 +7704.23 +1 +7736.27 +1 +7736.27 +1 +7725.77 +1 +7725.77 +1 +7756 +1 +7756 +1 +7783.1 +1 +7783.1 +1 +7729.03 +1 +7729.03 +1 +7768.4 +1 +7768.4 +1 +7814.3 +1 +7814.3 +1 +7783.6 +1 +7783.6 +1 +7786 +1 +7786 +1 +7822.63 +1 +7822.63 +1 +7818.77 +1 +7818.77 +1 +7804.07 +1 +7804.07 +1 +7782.3 +1 +7782.3 +1 +7850.13 +1 +7850.13 +1 +7835.63 +1 +7835.63 +1 +7824.4 +1 +7824.4 +1 +7904.8 +1 +7904.8 +1 +7865.77 +1 +7865.77 +1 +7922.27 +1 +7922.27 +1 +7969.5 +1 +7969.5 +1 +7818.9 +1 +7818.9 +1 +7853.37 +1 +7853.37 +1 +7870.7 +1 +7870.7 +1 +7928.17 +1 +7928.17 +1 +7994.53 +1 +7994.53 +1 +7948.77 +1 +7948.77 +1 +7991.3 +1 +7991.3 +1 +7994.57 +1 +7994.57 +1 +8089.2 +1 +8089.2 +1 +8108.43 +1 +8108.43 +1 +8086.43 +1 +8086.43 +1 +8192.9 +1 +8192.9 +1 +8159.8 +1 +8159.8 +1 +8217.4 +1 +8217.4 +1 +8304.37 +1 +8304.37 +1 +8333.57 +1 +8333.57 +1 +8388.57 +1 +8388.57 +1 +8371.57 +1 +8371.57 +1 +8441.57 +1 +8441.57 +1 +8465.77 +1 +8465.77 +1 +8535.07 +1 +8535.07 +1 +8587.87 +1 +8587.87 +1 +8602.53 +1 +8602.53 +1 +8652.33 +1 +8652.33 +1 +8722.07 +1 +8722.07 +1 +8759.67 +1 +8759.67 +1 +8871.9 +1 +8871.9 +1 +8934.73 +1 +8934.73 +1 +8980.9 +1 +8980.9 +1 +9044.67 +1 +9044.67 +1 +9120.43 +1 +9120.43 +1 +9112.57 +1 +9112.57 +1 +9202.83 +1 +9202.83 +1 +9269.47 +1 +9269.47 +1 +9318.63 +1 +9318.63 +1 +9380.87 +1 +9380.87 +1 +9388.5 +1 +9388.5 +1 +9404.17 +1 +9404.17 +1 +9459.77 +1 +9459.77 +1 +9543.5 +1 +9543.5 +1 +9635.07 +1 +9635.07 +1 +9669.43 +1 +9669.43 +1 +9697.53 +1 +9697.53 +1 +9725.23 +1 +9725.23 +1 +9755.3 +1 +9755.3 +1 +9773.53 +1 +9773.53 +1 +9813.43 +1 +9813.43 +1 +9799.3 +1 +9799.3 +1 +9832.2 +1 +9832.2 +1 +9821.97 +1 +9821.97 +1 +9809.8 +1 +9809.8 +1 +9744.03 +1 +9744.03 +1 +9705.1 +1 +9705.1 +1 +9619.77 +1 +9619.77 +1 +9556.03 +1 +9556.03 +1 +9514.13 +1 +9514.13 +1 +9403.13 +1 +9403.13 +1 +9334.67 +1 +9334.67 +1 +9256.73 +1 +9256.73 +1 +9162.8 +1 +9162.8 +1 +8986.27 +1 +8986.27 +1 +8890.63 +1 +8890.63 +1 +8722.4 +1 +8722.4 +1 +8570.9 +1 +8570.9 +1 +8396.67 +1 +8396.67 +1 +8172.03 +1 +8172.03 +1 +8009.93 +1 +8009.93 +1 +7884.17 +1 +7884.17 +1 +7746.6 +1 +7746.6 +1 +7588.27 +1 +7588.27 +1 +7434.17 +1 +7434.17 +1 +7351.77 +1 +7351.77 +1 +7208.53 +1 +7208.53 +1 +7108 +1 +7108 +1 +7082.53 +1 +7082.53 +1 +7026.3 +1 +7026.3 +1 +6912.93 +1 +6912.93 +1 +6911.7 +1 +6911.7 +1 +6892.5 +1 +6892.5 +1 +6842.93 +1 +6842.93 +1 +6770.33 +1 +6770.33 +1 +6802.87 +1 +6802.87 +1 +6767.53 +1 +6767.53 +1 +6737.5 +1 +6737.5 +1 +6699.23 +1 +6699.23 +1 +6675.23 +1 +6675.23 +1 +6686.63 +1 +6686.63 +1 +6688.17 +1 +6688.17 +1 +6621.83 +1 +6621.83 +1 +6645.13 +1 +6645.13 +1 +6651.63 +1 +6651.63 +1 +6631.43 +1 +6631.43 +1 +6620.03 +1 +6620.03 +1 +6615.43 +1 +6615.43 +1 +6625.03 +1 +6625.03 +1 +6642.87 +1 +6642.87 +1 +6677 +1 +6677 +1 +6691.27 +1 +6691.27 +1 +6718.83 +1 +6718.83 +1 +6668.4 +1 +6668.4 +1 +6742.23 +1 +6742.23 +1 +6800.47 +1 +6800.47 +1 +6776.2 +1 +6776.2 +1 +6784.63 +1 +6784.63 +1 +6850.97 +1 +6850.97 +1 +6858.6 +1 +6858.6 +1 +6873.77 +1 +6873.77 +1 +6887.97 +1 +6887.97 +1 +6913.07 +1 +6913.07 +1 +6966.73 +1 +6966.73 +1 +6975.2 +1 +6975.2 +1 +7024 +1 +7024 +1 +7125.67 +1 +7125.67 +1 +7064.97 +1 +7064.97 +1 +7027.13 +1 +7027.13 +1 +7082.97 +1 +7082.97 +1 +7127.6 +1 +7127.6 +1 +7128.53 +1 +7128.53 +1 +7175.87 +1 +7175.87 +1 +7223.3 +1 +7223.3 +1 +7181.17 +1 +7181.17 +1 +7223.6 +1 +7223.6 +1 +7259.9 +1 +7259.9 +1 +7248.33 +1 +7248.33 +1 +7285.93 +1 +7285.93 +1 +7303.4 +1 +7303.4 +1 +7343.2 +1 +7343.2 +1 +7320.27 +1 +7320.27 +1 +7350.2 +1 +7350.2 +1 +7424.1 +1 +7424.1 +1 +7405.93 +1 +7405.93 +1 +7440.63 +1 +7440.63 +1 +7487.6 +1 +7487.6 +1 +7565.57 +1 +7565.57 +1 +7576.67 +1 +7576.67 +1 +7609.63 +1 +7609.63 +1 +7690.23 +1 +7690.23 +1 +7713.17 +1 +7713.17 +1 +7778.07 +1 +7778.07 +1 +7822.83 +1 +7822.83 +1 +7894.27 +1 +7894.27 +1 +8048.77 +1 +8048.77 +1 +8116.7 +1 +8116.7 +1 +8140.33 +1 +8140.33 +1 +8267.3 +1 +8267.3 +1 +8294.33 +1 +8294.33 +1 +8380.97 +1 +8380.97 +1 +8482 +1 +8482 +1 +8523.87 +1 +8523.87 +1 +8621.03 +1 +8621.03 +1 +8694.07 +1 +8694.07 +1 +8825.37 +1 +8825.37 +1 +8984.53 +1 +8984.53 +1 +9088 +1 +9088 +1 +9125 +1 +9125 +1 +9130.63 +1 +9130.63 +1 +9220.87 +1 +9220.87 +1 +9360.9 +1 +9360.9 +1 +9462.33 +1 +9462.33 +1 +9537.2 +1 +9537.2 +1 +9661.2 +1 +9661.2 +1 +9766.77 +1 +9766.77 +1 +9870.9 +1 +9870.9 +1 +9990.27 +1 +9990.27 +1 +10042 +1 +10042 +1 +10130.7 +1 +10130.7 +1 +10278.3 +1 +10278.3 +1 +10357.2 +1 +10357.2 +1 +10489.7 +1 +10489.7 +1 +10526.5 +1 +10526.5 +1 +10642.7 +1 +10642.7 +1 +10654.5 +1 +10654.5 +1 +10643.7 +1 +10643.7 +1 +10702.5 +1 +10702.5 +1 +10758.2 +1 +10758.2 +1 +10784.4 +1 +10784.4 +1 +10824 +1 +10824 +1 +10822.9 +1 +10822.9 +1 +10850.6 +1 +10850.6 +1 +10743.4 +1 +10743.4 +1 +10749.7 +1 +10749.7 +1 +10607.4 +1 +10607.4 +1 +10458.1 +1 +10458.1 +1 +10375.5 +1 +10375.5 +1 +10237.1 +1 +10237.1 +1 +10105.5 +1 +10105.5 +1 +9929.87 +1 +9929.87 +1 +9812.3 +1 +9812.3 +1 +9654.07 +1 +9654.07 +1 +9482.3 +1 +9482.3 +1 +9257 +1 +9257 +1 +9045.27 +1 +9045.27 +1 +8819.5 +1 +8819.5 +1 +8510.3 +1 +8510.3 +1 +8226.87 +1 +8226.87 +1 +7851.7 +1 +7851.7 +1 +7399.43 +1 +7399.43 +1 +6984.43 +1 +6984.43 +1 +6519.77 +1 +6519.77 +1 +5980 +1 +5980 +1 +5472.33 +1 +5472.33 +1 +4949.5 +1 +4949.5 +1 +4435.17 +1 +4435.17 +1 +3995.73 +1 +3995.73 +1 +3569.4 +1 +3569.4 +1 +3241.06 +1 +3241.06 +1 +2975.78 +1 +2975.78 +1 +2739.66 +1 +2739.66 +1 +2550.93 +1 +2550.93 +1 +2405.54 +1 +2405.54 +1 +2278.72 +1 +2278.72 +1 +2177.05 +1 +2177.05 +1 +2078.74 +1 +2078.74 +1 +2006.69 +1 +2006.69 +1 +1925.76 +1 +1925.76 +1 +1855.89 +1 +1855.89 +1 +1758.76 +1 +1758.76 +1 +1746.72 +1 +1746.72 +1 +1707.24 +1 +1707.24 +1 +1665.86 +1 +1665.86 +1 +1599.72 +1 +1599.72 +1 +1588.51 +1 +1588.51 +1 +1575 +1 +1575 +1 +1571.47 +1 +1571.47 +1 +1530.54 +1 +1530.54 +1 +1520.24 +1 +1520.24 +1 +1505.5 +1 +1505.5 +1 +1495.59 +1 +1495.59 +1 +1494.72 +1 +1494.72 +1 +1480.83 +1 +1480.83 +1 +1477 +1 +1477 +1 +1470.38 +1 +1470.38 +1 +1478.96 +1 +1478.96 +1 +1460.95 +1 +1460.95 +1 +1469.52 +1 +1469.52 +1 +1423.97 +1 +1423.97 +1 +1439.29 +1 +1439.29 +1 +1450.64 +1 +1450.64 +1 +1445.98 +1 +1445.98 +1 +1440.69 +1 +1440.69 +1 +1411.43 +1 +1411.43 +1 +1397.95 +1 +1397.95 +1 +1408.86 +1 +1408.86 +1 +1411.03 +1 +1411.03 +1 +1419.74 +1 +1419.74 +1 +1440.9 +1 +1440.9 +1 +1438.95 +1 +1438.95 +1 +1396.77 +1 +1396.77 +1 +1382.02 +1 +1382.02 +1 +1386.07 +1 +1386.07 +1 +1411.79 +1 +1411.79 +1 +1393.22 +1 +1393.22 +1 +1398.32 +1 +1398.32 +1 +1376.69 +1 +1376.69 +1 +1363.02 +1 +1363.02 +1 +1384.04 +1 +1384.04 +1 +1377.81 +1 +1377.81 +1 +1373.04 +1 +1373.04 +1 +1382.78 +1 +1382.78 +1 +1393.43 +1 +1393.43 +1 +1372.17 +1 +1372.17 +1 +1376.92 +1 +1376.92 +1 +1360.48 +1 +1360.48 +1 +1386.63 +1 +1386.63 +1 +1384.82 +1 +1384.82 +1 +1364.78 +1 +1364.78 +1 +1357.25 +1 +1357.25 +1 +1372.95 +1 +1372.95 +1 +1367.62 +1 +1367.62 +1 +1374.47 +1 +1374.47 +1 +1374.32 +1 +1374.32 +1 +1366.13 +1 +1366.13 +1 +1361.21 +1 +1361.21 +1 +1360.51 +1 +1360.51 +1 +1342.04 +1 +1342.04 +1 +1361.76 +1 +1361.76 +1 +1363.61 +1 +1363.61 +1 +1362.5 +1 +1362.5 +1 +1380.14 +1 +1380.14 +1 +1357.78 +1 +1357.78 +1 +1340.93 +1 +1340.93 +1 +1363.58 +1 +1363.58 +1 +1369.2 +1 +1369.2 +1 +1367.62 +1 +1367.62 +1 +1377.02 +1 +1377.02 +1 +1343.53 +1 +1343.53 +1 +1375.82 +1 +1375.82 +1 +1368.24 +1 +1368.24 +1 +1371.02 +1 +1371.02 +1 +1373.13 +1 +1373.13 +1 +1375.91 +1 +1375.91 +1 +1354.4 +1 +1354.4 +1 +1361.05 +1 +1361.05 +1 +1364.1 +1 +1364.1 +1 +1351.92 +1 +1351.92 +1 +1362.32 +1 +1362.32 +1 +1360.4 +1 +1360.4 +1 +1370.96 +1 +1370.96 +1 +1373.16 +1 +1373.16 +1 +1366.28 +1 +1366.28 +1 +1356.92 +1 +1356.92 +1 +1336.72 +1 +1336.72 +1 +1352.74 +1 +1352.74 +1 +1360.76 +1 +1360.76 +1 +1348.41 +1 +1348.41 +1 +1363.61 +1 +1363.61 +1 +1358.33 +1 +1358.33 +1 +1378.22 +1 +1378.22 +1 +1374.96 +1 +1374.96 +1 +1342.2 +1 +1342.2 +1 +1354.47 +1 +1354.47 +1 +1350.71 +1 +1350.71 +1 +1368.34 +1 +1368.34 +1 +1349.91 +1 +1349.91 +1 +1363.03 +1 +1363.03 +1 +1361.15 +1 +1361.15 +1 +1353.13 +1 +1353.13 +1 +1378.44 +1 +1378.44 +1 +1377.21 +1 +1377.21 +1 +1366.79 +1 +1366.79 +1 +1356.93 +1 +1356.93 +1 +1348.24 +1 +1348.24 +1 +1355.94 +1 +1355.94 +1 +1348.15 +1 +1348.15 +1 +1351.04 +1 +1351.04 +1 +1334.49 +1 +1334.49 +1 +1360.19 +1 +1360.19 +1 +1360.32 +1 +1360.32 +1 +1368.74 +1 +1368.74 +1 +1357.6 +1 +1357.6 +1 +1328.24 +1 +1328.24 +1 +1359.17 +1 +1359.17 +1 +1362.59 +1 +1362.59 +1 +1364.54 +1 +1364.54 +1 +1366.1 +1 +1366.1 +1 +1357.58 +1 +1357.58 +1 +1381.03 +1 +1381.03 +1 +1352 +1 +1352 +1 +1346.4 +1 +1346.4 +1 +1338.68 +1 +1338.68 +1 +1357.61 +1 +1357.61 +1 +1352.42 +1 +1352.42 +1 +1359.58 +1 +1359.58 +1 +1373.53 +1 +1373.53 +1 +1366.84 +1 +1366.84 +1 +1345.58 +1 +1345.58 +1 +1364.48 +1 +1364.48 +1 +1359.64 +1 +1359.64 +1 +1375.56 +1 +1375.56 +1 +1357.49 +1 +1357.49 +1 +1346.83 +1 +1346.83 +1 +1344.72 +1 +1344.72 +1 +1360.31 +1 +1360.31 +1 +1364.5 +1 +1364.5 +1 +1347.22 +1 +1347.22 +1 +1330.21 +1 +1330.21 +1 +1360.08 +1 +1360.08 +1 +1358.85 +1 +1358.85 +1 +1353.41 +1 +1353.41 +1 +1374.27 +1 +1374.27 +1 +1362.38 +1 +1362.38 +1 +1375.63 +1 +1375.63 +1 +1346.49 +1 +1346.49 +1 +1352.78 +1 +1352.78 +1 +1352.28 +1 +1352.28 +1 +1359.06 +1 +1359.06 +1 +1370.61 +1 +1370.61 +1 +1350.4 +1 +1350.4 +1 +1360.17 +1 +1360.17 +1 +1345.13 +1 +1345.13 +1 +1342.21 +1 +1342.21 +1 +1340.91 +1 +1340.91 +1 +1361.07 +1 +1361.07 +1 +1355.16 +1 +1355.16 +1 +1346.47 +1 +1346.47 +1 +1360.39 +1 +1360.39 +1 +1366.4 +1 +1366.4 +1 +1350.7 +1 +1350.7 +1 +1353.43 +1 +1353.43 +1 +1348.41 +1 +1348.41 +1 +1336.83 +1 +1336.83 +1 +1355.59 +1 +1355.59 +1 +1357.36 +1 +1357.36 +1 +1375.07 +1 +1375.07 +1 +1352.31 +1 +1352.31 +1 +1352.89 +1 +1352.89 +1 +1346.21 +1 +1346.21 +1 +1340.32 +1 +1340.32 +1 +1347.85 +1 +1347.85 +1 +1379.91 +1 +1379.91 +1 +1359.5 +1 +1359.5 +1 +1358.1 +1 +1358.1 +1 +1348.71 +1 +1348.71 +1 +1340.45 +1 +1340.45 +1 +1355.68 +1 +1355.68 +1 +1351.09 +1 +1351.09 +1 +1362.11 +1 +1362.11 +1 +1351.23 +1 +1351.23 +1 +1371.86 +1 +1371.86 +1 +1364.54 +1 +1364.54 +1 +1340.7 +1 +1340.7 +1 +1345.47 +1 +1345.47 +1 +1379.8 +1 +1379.8 +1 +1369.58 +1 +1369.58 +1 +1347.04 +1 +1347.04 +1 +1345.64 +1 +1345.64 +1 +1362.43 +1 +1362.43 +1 +1351.49 +1 +1351.49 +1 +1348.38 +1 +1348.38 +1 +1360.01 +1 +1360.01 +1 +1360.03 +1 +1360.03 +1 +1370.78 +1 +1370.78 +1 +1369.04 +1 +1369.04 +1 +1370.46 +1 +1370.46 +1 +1366.93 +1 +1366.93 +1 +1347.65 +1 +1347.65 +1 +1354.01 +1 +1354.01 +1 +1353.18 +1 +1353.18 +1 +1361.65 +1 +1361.65 +1 +1353.52 +1 +1353.52 +1 +1359.09 +1 +1359.09 +1 +1361.03 +1 +1361.03 +1 +1366.82 +1 +1366.82 +1 +1369.19 +1 +1369.19 +1 +1353.01 +1 +1353.01 +1 +1352.65 +1 +1352.65 +1 +1361.25 +1 +1361.25 +1 +1372.09 +1 +1372.09 +1 +1368.61 +1 +1368.61 +1 +1377.07 +1 +Fe2p +Fe2O3 +2021 +8 +5 +17 +51 +2 +0 +11 +Casa Info Follows +0 +0 +0 +0 +none +Group: none +Analyzer Lens: none +Analyzer Slit: none +Scan Mode: none +C:\Users\pielsticker\Downloads\utils\test fits\new\Fe2p_Fe2O3_new.vms +XPS +0 +Al +1486.61 +0 +0 +0 +56.5 +180 +FAT +20 +1 +4.1408 +0 +0 +0 +0 +0 +Fe +2p +-1 +kinetic energy +eV +716.61 +0.05 +2 +counts +d +Transmission +d +pulse counting +0.1 +3 +0 +0 +0 +0 +2 +ESCAPE DEPTH TYPE +d +0 +MFP Exponent +d +0 +3402 +1420.39 +11225.4 +1 +1 +5792.37 +1 +5792.37 +1 +5779.4 +1 +5779.4 +1 +5779.67 +1 +5779.67 +1 +5727.2 +1 +5727.2 +1 +5772.57 +1 +5772.57 +1 +5772.27 +1 +5772.27 +1 +5773.43 +1 +5773.43 +1 +5814.9 +1 +5814.9 +1 +5759 +1 +5759 +1 +5682.67 +1 +5682.67 +1 +5750.2 +1 +5750.2 +1 +5745.83 +1 +5745.83 +1 +5764.67 +1 +5764.67 +1 +5680.77 +1 +5680.77 +1 +5695.73 +1 +5695.73 +1 +5755.93 +1 +5755.93 +1 +5758.13 +1 +5758.13 +1 +5622.4 +1 +5622.4 +1 +5605.77 +1 +5605.77 +1 +5676.5 +1 +5676.5 +1 +5749.87 +1 +5749.87 +1 +5694 +1 +5694 +1 +5709.13 +1 +5709.13 +1 +5631.93 +1 +5631.93 +1 +5581.87 +1 +5581.87 +1 +5573.9 +1 +5573.9 +1 +5558 +1 +5558 +1 +5588.97 +1 +5588.97 +1 +5561.97 +1 +5561.97 +1 +5536.23 +1 +5536.23 +1 +5507.17 +1 +5507.17 +1 +5525.1 +1 +5525.1 +1 +5495.5 +1 +5495.5 +1 +5493.7 +1 +5493.7 +1 +5458.1 +1 +5458.1 +1 +5481.37 +1 +5481.37 +1 +5489.3 +1 +5489.3 +1 +5413.43 +1 +5413.43 +1 +5499.17 +1 +5499.17 +1 +5439.13 +1 +5439.13 +1 +5399.67 +1 +5399.67 +1 +5420.7 +1 +5420.7 +1 +5440.73 +1 +5440.73 +1 +5411.9 +1 +5411.9 +1 +5381.93 +1 +5381.93 +1 +5382.97 +1 +5382.97 +1 +5389.3 +1 +5389.3 +1 +5371.6 +1 +5371.6 +1 +5417.7 +1 +5417.7 +1 +5388.63 +1 +5388.63 +1 +5338.53 +1 +5338.53 +1 +5355.43 +1 +5355.43 +1 +5365.5 +1 +5365.5 +1 +5378 +1 +5378 +1 +5379.27 +1 +5379.27 +1 +5362.97 +1 +5362.97 +1 +5346.07 +1 +5346.07 +1 +5434.5 +1 +5434.5 +1 +5363.53 +1 +5363.53 +1 +5358.33 +1 +5358.33 +1 +5348.9 +1 +5348.9 +1 +5322.87 +1 +5322.87 +1 +5378.87 +1 +5378.87 +1 +5393.63 +1 +5393.63 +1 +5368.1 +1 +5368.1 +1 +5316.4 +1 +5316.4 +1 +5356.83 +1 +5356.83 +1 +5363.03 +1 +5363.03 +1 +5383.7 +1 +5383.7 +1 +5381.2 +1 +5381.2 +1 +5384.37 +1 +5384.37 +1 +5337.77 +1 +5337.77 +1 +5339.47 +1 +5339.47 +1 +5314.73 +1 +5314.73 +1 +5342.43 +1 +5342.43 +1 +5389.3 +1 +5389.3 +1 +5323.53 +1 +5323.53 +1 +5290.13 +1 +5290.13 +1 +5325.5 +1 +5325.5 +1 +5324.87 +1 +5324.87 +1 +5327.47 +1 +5327.47 +1 +5355.03 +1 +5355.03 +1 +5358.13 +1 +5358.13 +1 +5391.73 +1 +5391.73 +1 +5329.83 +1 +5329.83 +1 +5320.9 +1 +5320.9 +1 +5411.8 +1 +5411.8 +1 +5402.03 +1 +5402.03 +1 +5251.3 +1 +5251.3 +1 +5351.57 +1 +5351.57 +1 +5425.83 +1 +5425.83 +1 +5433.43 +1 +5433.43 +1 +5307 +1 +5307 +1 +5328.9 +1 +5328.9 +1 +5364.13 +1 +5364.13 +1 +5344.93 +1 +5344.93 +1 +5383.47 +1 +5383.47 +1 +5342.67 +1 +5342.67 +1 +5350.3 +1 +5350.3 +1 +5384.53 +1 +5384.53 +1 +5394.33 +1 +5394.33 +1 +5422.8 +1 +5422.8 +1 +5347.87 +1 +5347.87 +1 +5414.03 +1 +5414.03 +1 +5414.03 +1 +5414.03 +1 +5387.7 +1 +5387.7 +1 +5460.07 +1 +5460.07 +1 +5395.37 +1 +5395.37 +1 +5388.63 +1 +5388.63 +1 +5353.83 +1 +5353.83 +1 +5375.93 +1 +5375.93 +1 +5456.5 +1 +5456.5 +1 +5480.07 +1 +5480.07 +1 +5479.77 +1 +5479.77 +1 +5408.23 +1 +5408.23 +1 +5350.77 +1 +5350.77 +1 +5408.47 +1 +5408.47 +1 +5371.87 +1 +5371.87 +1 +5425.2 +1 +5425.2 +1 +5488.1 +1 +5488.1 +1 +5539.33 +1 +5539.33 +1 +5461.03 +1 +5461.03 +1 +5433.77 +1 +5433.77 +1 +5426.1 +1 +5426.1 +1 +5422.5 +1 +5422.5 +1 +5425.87 +1 +5425.87 +1 +5460.73 +1 +5460.73 +1 +5458.5 +1 +5458.5 +1 +5500.9 +1 +5500.9 +1 +5483.97 +1 +5483.97 +1 +5546.5 +1 +5546.5 +1 +5464.97 +1 +5464.97 +1 +5477.27 +1 +5477.27 +1 +5496.27 +1 +5496.27 +1 +5441.2 +1 +5441.2 +1 +5460.93 +1 +5460.93 +1 +5464.4 +1 +5464.4 +1 +5473.27 +1 +5473.27 +1 +5482.57 +1 +5482.57 +1 +5444.77 +1 +5444.77 +1 +5521.87 +1 +5521.87 +1 +5493.57 +1 +5493.57 +1 +5561.93 +1 +5561.93 +1 +5491.37 +1 +5491.37 +1 +5534.23 +1 +5534.23 +1 +5585 +1 +5585 +1 +5515.63 +1 +5515.63 +1 +5502.43 +1 +5502.43 +1 +5490.03 +1 +5490.03 +1 +5536.4 +1 +5536.4 +1 +5534.53 +1 +5534.53 +1 +5491.9 +1 +5491.9 +1 +5497.2 +1 +5497.2 +1 +5551.6 +1 +5551.6 +1 +5445.57 +1 +5445.57 +1 +5486.57 +1 +5486.57 +1 +5545.5 +1 +5545.5 +1 +5478.53 +1 +5478.53 +1 +5479.27 +1 +5479.27 +1 +5543.27 +1 +5543.27 +1 +5591.03 +1 +5591.03 +1 +5565.5 +1 +5565.5 +1 +5548.2 +1 +5548.2 +1 +5502.23 +1 +5502.23 +1 +5556.27 +1 +5556.27 +1 +5551.63 +1 +5551.63 +1 +5586.4 +1 +5586.4 +1 +5545.27 +1 +5545.27 +1 +5572.13 +1 +5572.13 +1 +5566.67 +1 +5566.67 +1 +5564.53 +1 +5564.53 +1 +5555.73 +1 +5555.73 +1 +5623.43 +1 +5623.43 +1 +5601.03 +1 +5601.03 +1 +5689.4 +1 +5689.4 +1 +5635 +1 +5635 +1 +5571.2 +1 +5571.2 +1 +5619.3 +1 +5619.3 +1 +5623.93 +1 +5623.93 +1 +5579.1 +1 +5579.1 +1 +5600.8 +1 +5600.8 +1 +5655.27 +1 +5655.27 +1 +5650.97 +1 +5650.97 +1 +5577.47 +1 +5577.47 +1 +5619.27 +1 +5619.27 +1 +5636.27 +1 +5636.27 +1 +5551.7 +1 +5551.7 +1 +5655.8 +1 +5655.8 +1 +5601.53 +1 +5601.53 +1 +5586.57 +1 +5586.57 +1 +5596.07 +1 +5596.07 +1 +5703.4 +1 +5703.4 +1 +5648.67 +1 +5648.67 +1 +5667.03 +1 +5667.03 +1 +5671 +1 +5671 +1 +5632.23 +1 +5632.23 +1 +5657.7 +1 +5657.7 +1 +5706.2 +1 +5706.2 +1 +5679.43 +1 +5679.43 +1 +5648.43 +1 +5648.43 +1 +5586.03 +1 +5586.03 +1 +5593.17 +1 +5593.17 +1 +5663.53 +1 +5663.53 +1 +5647.1 +1 +5647.1 +1 +5651.37 +1 +5651.37 +1 +5704.57 +1 +5704.57 +1 +5674.67 +1 +5674.67 +1 +5654.57 +1 +5654.57 +1 +5707.47 +1 +5707.47 +1 +5657.3 +1 +5657.3 +1 +5687.57 +1 +5687.57 +1 +5688 +1 +5688 +1 +5739.47 +1 +5739.47 +1 +5771.57 +1 +5771.57 +1 +5731.73 +1 +5731.73 +1 +5724.27 +1 +5724.27 +1 +5760.47 +1 +5760.47 +1 +5751.27 +1 +5751.27 +1 +5779.97 +1 +5779.97 +1 +5777.7 +1 +5777.7 +1 +5761.57 +1 +5761.57 +1 +5717.47 +1 +5717.47 +1 +5773.93 +1 +5773.93 +1 +5808.93 +1 +5808.93 +1 +5767.47 +1 +5767.47 +1 +5788.5 +1 +5788.5 +1 +5757.03 +1 +5757.03 +1 +5832.1 +1 +5832.1 +1 +5767.07 +1 +5767.07 +1 +5746.8 +1 +5746.8 +1 +5705.2 +1 +5705.2 +1 +5705.7 +1 +5705.7 +1 +5732 +1 +5732 +1 +5763.1 +1 +5763.1 +1 +5834.67 +1 +5834.67 +1 +5830.73 +1 +5830.73 +1 +5832.47 +1 +5832.47 +1 +5820.7 +1 +5820.7 +1 +5776.2 +1 +5776.2 +1 +5740.37 +1 +5740.37 +1 +5761.57 +1 +5761.57 +1 +5812.87 +1 +5812.87 +1 +5776.53 +1 +5776.53 +1 +5773.73 +1 +5773.73 +1 +5770.97 +1 +5770.97 +1 +5836.7 +1 +5836.7 +1 +5823.13 +1 +5823.13 +1 +5826.67 +1 +5826.67 +1 +5881.97 +1 +5881.97 +1 +5867.03 +1 +5867.03 +1 +5936.6 +1 +5936.6 +1 +5938.87 +1 +5938.87 +1 +5971.27 +1 +5971.27 +1 +5942.4 +1 +5942.4 +1 +5954.43 +1 +5954.43 +1 +5935 +1 +5935 +1 +5996.53 +1 +5996.53 +1 +5987.3 +1 +5987.3 +1 +6041.47 +1 +6041.47 +1 +6079.87 +1 +6079.87 +1 +6136.43 +1 +6136.43 +1 +6140.3 +1 +6140.3 +1 +6166.87 +1 +6166.87 +1 +6203.77 +1 +6203.77 +1 +6256.67 +1 +6256.67 +1 +6196.57 +1 +6196.57 +1 +6270.87 +1 +6270.87 +1 +6260.43 +1 +6260.43 +1 +6282.4 +1 +6282.4 +1 +6279.43 +1 +6279.43 +1 +6277.37 +1 +6277.37 +1 +6325.6 +1 +6325.6 +1 +6290.6 +1 +6290.6 +1 +6307.13 +1 +6307.13 +1 +6303.23 +1 +6303.23 +1 +6314.17 +1 +6314.17 +1 +6327.63 +1 +6327.63 +1 +6295.63 +1 +6295.63 +1 +6352 +1 +6352 +1 +6389.87 +1 +6389.87 +1 +6327.9 +1 +6327.9 +1 +6326.8 +1 +6326.8 +1 +6313.33 +1 +6313.33 +1 +6305.3 +1 +6305.3 +1 +6236 +1 +6236 +1 +6246.57 +1 +6246.57 +1 +6242.27 +1 +6242.27 +1 +6253.2 +1 +6253.2 +1 +6180.63 +1 +6180.63 +1 +6250.03 +1 +6250.03 +1 +6254.87 +1 +6254.87 +1 +6136.57 +1 +6136.57 +1 +6104.37 +1 +6104.37 +1 +6175.43 +1 +6175.43 +1 +6149.27 +1 +6149.27 +1 +6130.2 +1 +6130.2 +1 +6098.57 +1 +6098.57 +1 +6093.73 +1 +6093.73 +1 +6066.57 +1 +6066.57 +1 +6028.6 +1 +6028.6 +1 +6125.27 +1 +6125.27 +1 +6150.77 +1 +6150.77 +1 +6106.73 +1 +6106.73 +1 +6090.4 +1 +6090.4 +1 +6141.07 +1 +6141.07 +1 +6024.23 +1 +6024.23 +1 +6027.67 +1 +6027.67 +1 +6112.3 +1 +6112.3 +1 +6061.9 +1 +6061.9 +1 +6044.53 +1 +6044.53 +1 +5958.73 +1 +5958.73 +1 +6011.5 +1 +6011.5 +1 +6074.67 +1 +6074.67 +1 +6039.73 +1 +6039.73 +1 +6123.8 +1 +6123.8 +1 +6045.97 +1 +6045.97 +1 +6097.27 +1 +6097.27 +1 +6205.4 +1 +6205.4 +1 +6111.5 +1 +6111.5 +1 +6109 +1 +6109 +1 +6094.3 +1 +6094.3 +1 +6153.47 +1 +6153.47 +1 +6183.83 +1 +6183.83 +1 +6199.97 +1 +6199.97 +1 +6270 +1 +6270 +1 +6256.5 +1 +6256.5 +1 +6245.1 +1 +6245.1 +1 +6308.03 +1 +6308.03 +1 +6260.77 +1 +6260.77 +1 +6275.43 +1 +6275.43 +1 +6299.47 +1 +6299.47 +1 +6374.3 +1 +6374.3 +1 +6387.8 +1 +6387.8 +1 +6381.53 +1 +6381.53 +1 +6381.23 +1 +6381.23 +1 +6455.9 +1 +6455.9 +1 +6411.07 +1 +6411.07 +1 +6448.6 +1 +6448.6 +1 +6467.27 +1 +6467.27 +1 +6461.93 +1 +6461.93 +1 +6464.4 +1 +6464.4 +1 +6460.93 +1 +6460.93 +1 +6481.53 +1 +6481.53 +1 +6513.17 +1 +6513.17 +1 +6528.73 +1 +6528.73 +1 +6605.4 +1 +6605.4 +1 +6623.3 +1 +6623.3 +1 +6705.47 +1 +6705.47 +1 +6655.57 +1 +6655.57 +1 +6745.77 +1 +6745.77 +1 +6711.97 +1 +6711.97 +1 +6716.63 +1 +6716.63 +1 +6719.6 +1 +6719.6 +1 +6823.13 +1 +6823.13 +1 +6892.2 +1 +6892.2 +1 +6840.7 +1 +6840.7 +1 +6915.6 +1 +6915.6 +1 +6945.9 +1 +6945.9 +1 +7008.87 +1 +7008.87 +1 +6956.33 +1 +6956.33 +1 +6966.1 +1 +6966.1 +1 +6994.33 +1 +6994.33 +1 +7053.97 +1 +7053.97 +1 +7075.9 +1 +7075.9 +1 +7032.83 +1 +7032.83 +1 +7165.03 +1 +7165.03 +1 +7123.47 +1 +7123.47 +1 +7108.83 +1 +7108.83 +1 +7077.33 +1 +7077.33 +1 +7146.83 +1 +7146.83 +1 +7141 +1 +7141 +1 +7130.6 +1 +7130.6 +1 +7120 +1 +7120 +1 +7133.57 +1 +7133.57 +1 +7207.67 +1 +7207.67 +1 +7155 +1 +7155 +1 +7206.1 +1 +7206.1 +1 +7249.93 +1 +7249.93 +1 +7169.67 +1 +7169.67 +1 +7177.13 +1 +7177.13 +1 +7180.87 +1 +7180.87 +1 +7178.4 +1 +7178.4 +1 +7166.93 +1 +7166.93 +1 +7127.3 +1 +7127.3 +1 +7113.93 +1 +7113.93 +1 +7026.87 +1 +7026.87 +1 +7084.4 +1 +7084.4 +1 +7088.8 +1 +7088.8 +1 +7066.93 +1 +7066.93 +1 +7021.93 +1 +7021.93 +1 +7021.77 +1 +7021.77 +1 +6999.23 +1 +6999.23 +1 +7058.33 +1 +7058.33 +1 +7004.07 +1 +7004.07 +1 +6934.8 +1 +6934.8 +1 +6973.37 +1 +6973.37 +1 +6982.5 +1 +6982.5 +1 +6934.8 +1 +6934.8 +1 +7037.13 +1 +7037.13 +1 +6963.63 +1 +6963.63 +1 +6992.83 +1 +6992.83 +1 +7076.73 +1 +7076.73 +1 +7005.97 +1 +7005.97 +1 +7073.77 +1 +7073.77 +1 +7015.83 +1 +7015.83 +1 +7026.33 +1 +7026.33 +1 +7023.03 +1 +7023.03 +1 +7044.17 +1 +7044.17 +1 +7073.2 +1 +7073.2 +1 +7119.7 +1 +7119.7 +1 +7154.87 +1 +7154.87 +1 +7210.37 +1 +7210.37 +1 +7252.7 +1 +7252.7 +1 +7263.73 +1 +7263.73 +1 +7303.43 +1 +7303.43 +1 +7307.3 +1 +7307.3 +1 +7391.4 +1 +7391.4 +1 +7488.83 +1 +7488.83 +1 +7490.3 +1 +7490.3 +1 +7574.57 +1 +7574.57 +1 +7543.73 +1 +7543.73 +1 +7622.4 +1 +7622.4 +1 +7678.6 +1 +7678.6 +1 +7717.13 +1 +7717.13 +1 +7767.5 +1 +7767.5 +1 +7872.57 +1 +7872.57 +1 +7838.23 +1 +7838.23 +1 +7907.27 +1 +7907.27 +1 +8103.73 +1 +8103.73 +1 +8152.83 +1 +8152.83 +1 +8180.5 +1 +8180.5 +1 +8246.43 +1 +8246.43 +1 +8324.8 +1 +8324.8 +1 +8305.87 +1 +8305.87 +1 +8382.3 +1 +8382.3 +1 +8430.57 +1 +8430.57 +1 +8432.03 +1 +8432.03 +1 +8599.63 +1 +8599.63 +1 +8639.97 +1 +8639.97 +1 +8767.73 +1 +8767.73 +1 +8838.27 +1 +8838.27 +1 +8909.67 +1 +8909.67 +1 +8903.13 +1 +8903.13 +1 +9054.87 +1 +9054.87 +1 +9077.23 +1 +9077.23 +1 +9220.4 +1 +9220.4 +1 +9237.27 +1 +9237.27 +1 +9315.73 +1 +9315.73 +1 +9390.17 +1 +9390.17 +1 +9410.47 +1 +9410.47 +1 +9444.6 +1 +9444.6 +1 +9600.87 +1 +9600.87 +1 +9670.17 +1 +9670.17 +1 +9665.23 +1 +9665.23 +1 +9732.4 +1 +9732.4 +1 +9764.93 +1 +9764.93 +1 +9780.67 +1 +9780.67 +1 +9809.07 +1 +9809.07 +1 +9731.17 +1 +9731.17 +1 +9689.3 +1 +9689.3 +1 +9677.8 +1 +9677.8 +1 +9672.67 +1 +9672.67 +1 +9540.07 +1 +9540.07 +1 +9450.4 +1 +9450.4 +1 +9325.87 +1 +9325.87 +1 +9184.03 +1 +9184.03 +1 +9111.2 +1 +9111.2 +1 +9023.83 +1 +9023.83 +1 +8878.1 +1 +8878.1 +1 +8795.83 +1 +8795.83 +1 +8602.93 +1 +8602.93 +1 +8445.03 +1 +8445.03 +1 +8237.7 +1 +8237.7 +1 +7938.17 +1 +7938.17 +1 +7626.5 +1 +7626.5 +1 +7372.87 +1 +7372.87 +1 +7231.07 +1 +7231.07 +1 +7037.93 +1 +7037.93 +1 +7005.13 +1 +7005.13 +1 +6908.07 +1 +6908.07 +1 +6786 +1 +6786 +1 +6714.7 +1 +6714.7 +1 +6697.7 +1 +6697.7 +1 +6677.87 +1 +6677.87 +1 +6622.17 +1 +6622.17 +1 +6589.13 +1 +6589.13 +1 +6617.03 +1 +6617.03 +1 +6597.6 +1 +6597.6 +1 +6568.73 +1 +6568.73 +1 +6594.7 +1 +6594.7 +1 +6632.13 +1 +6632.13 +1 +6642.73 +1 +6642.73 +1 +6729.83 +1 +6729.83 +1 +6657.63 +1 +6657.63 +1 +6693.9 +1 +6693.9 +1 +6766.97 +1 +6766.97 +1 +6787.2 +1 +6787.2 +1 +6826.27 +1 +6826.27 +1 +6869.23 +1 +6869.23 +1 +6875.23 +1 +6875.23 +1 +6894.77 +1 +6894.77 +1 +6883.73 +1 +6883.73 +1 +6939.27 +1 +6939.27 +1 +6877.63 +1 +6877.63 +1 +6906.77 +1 +6906.77 +1 +6996.1 +1 +6996.1 +1 +6939.33 +1 +6939.33 +1 +6865.97 +1 +6865.97 +1 +6922.4 +1 +6922.4 +1 +6892.27 +1 +6892.27 +1 +6944.03 +1 +6944.03 +1 +6946.13 +1 +6946.13 +1 +6899.23 +1 +6899.23 +1 +6947.1 +1 +6947.1 +1 +6880.4 +1 +6880.4 +1 +6785.03 +1 +6785.03 +1 +6688 +1 +6688 +1 +6746.27 +1 +6746.27 +1 +6697.47 +1 +6697.47 +1 +6718.87 +1 +6718.87 +1 +6633.03 +1 +6633.03 +1 +6585.67 +1 +6585.67 +1 +6482.37 +1 +6482.37 +1 +6487.77 +1 +6487.77 +1 +6396.93 +1 +6396.93 +1 +6394.1 +1 +6394.1 +1 +6328.63 +1 +6328.63 +1 +6355.23 +1 +6355.23 +1 +6257 +1 +6257 +1 +6159.37 +1 +6159.37 +1 +6176.2 +1 +6176.2 +1 +6110.87 +1 +6110.87 +1 +6048.5 +1 +6048.5 +1 +6090.63 +1 +6090.63 +1 +6011.6 +1 +6011.6 +1 +6016.53 +1 +6016.53 +1 +5999.57 +1 +5999.57 +1 +6025.3 +1 +6025.3 +1 +5997.53 +1 +5997.53 +1 +5971.07 +1 +5971.07 +1 +6086.8 +1 +6086.8 +1 +5970.1 +1 +5970.1 +1 +5971.37 +1 +5971.37 +1 +5973.57 +1 +5973.57 +1 +5983.57 +1 +5983.57 +1 +5943 +1 +5943 +1 +5976.13 +1 +5976.13 +1 +6052.73 +1 +6052.73 +1 +6165.4 +1 +6165.4 +1 +6261.87 +1 +6261.87 +1 +6227.3 +1 +6227.3 +1 +6185.07 +1 +6185.07 +1 +6290.5 +1 +6290.5 +1 +6374.37 +1 +6374.37 +1 +6470.2 +1 +6470.2 +1 +6574.43 +1 +6574.43 +1 +6607.6 +1 +6607.6 +1 +6700.13 +1 +6700.13 +1 +6729.43 +1 +6729.43 +1 +6858.57 +1 +6858.57 +1 +7012.53 +1 +7012.53 +1 +7161.23 +1 +7161.23 +1 +7208.03 +1 +7208.03 +1 +7342.57 +1 +7342.57 +1 +7470.2 +1 +7470.2 +1 +7540.17 +1 +7540.17 +1 +7627 +1 +7627 +1 +7842.3 +1 +7842.3 +1 +7944.57 +1 +7944.57 +1 +8075.17 +1 +8075.17 +1 +8137.1 +1 +8137.1 +1 +8217.07 +1 +8217.07 +1 +8422.53 +1 +8422.53 +1 +8634.1 +1 +8634.1 +1 +8655.47 +1 +8655.47 +1 +8787.4 +1 +8787.4 +1 +8878.37 +1 +8878.37 +1 +9008.6 +1 +9008.6 +1 +9142.43 +1 +9142.43 +1 +9341.7 +1 +9341.7 +1 +9490.2 +1 +9490.2 +1 +9757.8 +1 +9757.8 +1 +9931.97 +1 +9931.97 +1 +10154.5 +1 +10154.5 +1 +10407.5 +1 +10407.5 +1 +10553.5 +1 +10553.5 +1 +10808.1 +1 +10808.1 +1 +10917.3 +1 +10917.3 +1 +10977.3 +1 +10977.3 +1 +11131 +1 +11131 +1 +11225.4 +1 +11225.4 +1 +11152.4 +1 +11152.4 +1 +10940.2 +1 +10940.2 +1 +10845.8 +1 +10845.8 +1 +10729 +1 +10729 +1 +10562.7 +1 +10562.7 +1 +10416.1 +1 +10416.1 +1 +10414.3 +1 +10414.3 +1 +10450.1 +1 +10450.1 +1 +10526.6 +1 +10526.6 +1 +10503.9 +1 +10503.9 +1 +10446.9 +1 +10446.9 +1 +10141.2 +1 +10141.2 +1 +9622.73 +1 +9622.73 +1 +8922.87 +1 +8922.87 +1 +8083.63 +1 +8083.63 +1 +7023.07 +1 +7023.07 +1 +5926.4 +1 +5926.4 +1 +4910.67 +1 +4910.67 +1 +4126.17 +1 +4126.17 +1 +3421.23 +1 +3421.23 +1 +2920.41 +1 +2920.41 +1 +2637.1 +1 +2637.1 +1 +2473.03 +1 +2473.03 +1 +2293.16 +1 +2293.16 +1 +2149.73 +1 +2149.73 +1 +2040.86 +1 +2040.86 +1 +1979.34 +1 +1979.34 +1 +1899.92 +1 +1899.92 +1 +1883.29 +1 +1883.29 +1 +1860.66 +1 +1860.66 +1 +1815.61 +1 +1815.61 +1 +1777 +1 +1777 +1 +1731.86 +1 +1731.86 +1 +1720.75 +1 +1720.75 +1 +1705.62 +1 +1705.62 +1 +1731.01 +1 +1731.01 +1 +1707.42 +1 +1707.42 +1 +1683.39 +1 +1683.39 +1 +1644.15 +1 +1644.15 +1 +1607.82 +1 +1607.82 +1 +1595.03 +1 +1595.03 +1 +1619.18 +1 +1619.18 +1 +1601.63 +1 +1601.63 +1 +1633.77 +1 +1633.77 +1 +1604.32 +1 +1604.32 +1 +1648.63 +1 +1648.63 +1 +1600.68 +1 +1600.68 +1 +1565.48 +1 +1565.48 +1 +1573.6 +1 +1573.6 +1 +1526.42 +1 +1526.42 +1 +1556.27 +1 +1556.27 +1 +1559.18 +1 +1559.18 +1 +1577.26 +1 +1577.26 +1 +1579.03 +1 +1579.03 +1 +1523.53 +1 +1523.53 +1 +1549.88 +1 +1549.88 +1 +1561.65 +1 +1561.65 +1 +1532.17 +1 +1532.17 +1 +1576.81 +1 +1576.81 +1 +1525.09 +1 +1525.09 +1 +1519.92 +1 +1519.92 +1 +1540.27 +1 +1540.27 +1 +1486.43 +1 +1486.43 +1 +1511.9 +1 +1511.9 +1 +1509.72 +1 +1509.72 +1 +1547.79 +1 +1547.79 +1 +1507.25 +1 +1507.25 +1 +1488.97 +1 +1488.97 +1 +1490.47 +1 +1490.47 +1 +1498.56 +1 +1498.56 +1 +1501.15 +1 +1501.15 +1 +1479.78 +1 +1479.78 +1 +1466.67 +1 +1466.67 +1 +1474.97 +1 +1474.97 +1 +1504.55 +1 +1504.55 +1 +1529.51 +1 +1529.51 +1 +1535.6 +1 +1535.6 +1 +1526.65 +1 +1526.65 +1 +1508.64 +1 +1508.64 +1 +1511.08 +1 +1511.08 +1 +1478.7 +1 +1478.7 +1 +1495.94 +1 +1495.94 +1 +1485.17 +1 +1485.17 +1 +1488.54 +1 +1488.54 +1 +1503.9 +1 +1503.9 +1 +1453.46 +1 +1453.46 +1 +1497.88 +1 +1497.88 +1 +1485.99 +1 +1485.99 +1 +1497.83 +1 +1497.83 +1 +1500.15 +1 +1500.15 +1 +1486.91 +1 +1486.91 +1 +1494.86 +1 +1494.86 +1 +1473.6 +1 +1473.6 +1 +1481.89 +1 +1481.89 +1 +1510.62 +1 +1510.62 +1 +1488.95 +1 +1488.95 +1 +1460.15 +1 +1460.15 +1 +1476.04 +1 +1476.04 +1 +1467.71 +1 +1467.71 +1 +1457.34 +1 +1457.34 +1 +1488.35 +1 +1488.35 +1 +1490.79 +1 +1490.79 +1 +1475.98 +1 +1475.98 +1 +1436.37 +1 +1436.37 +1 +1473.09 +1 +1473.09 +1 +1478.05 +1 +1478.05 +1 +1476.06 +1 +1476.06 +1 +1467.27 +1 +1467.27 +1 +1467.01 +1 +1467.01 +1 +1461.68 +1 +1461.68 +1 +1486.82 +1 +1486.82 +1 +1505.38 +1 +1505.38 +1 +1472.49 +1 +1472.49 +1 +1455.1 +1 +1455.1 +1 +1467.19 +1 +1467.19 +1 +1453.34 +1 +1453.34 +1 +1441.66 +1 +1441.66 +1 +1461.49 +1 +1461.49 +1 +1450.25 +1 +1450.25 +1 +1460.37 +1 +1460.37 +1 +1480.9 +1 +1480.9 +1 +1457.96 +1 +1457.96 +1 +1463.78 +1 +1463.78 +1 +1462.52 +1 +1462.52 +1 +1467.63 +1 +1467.63 +1 +1468.88 +1 +1468.88 +1 +1450.55 +1 +1450.55 +1 +1489.94 +1 +1489.94 +1 +1466.7 +1 +1466.7 +1 +1454.92 +1 +1454.92 +1 +1476.5 +1 +1476.5 +1 +1472.02 +1 +1472.02 +1 +1457.59 +1 +1457.59 +1 +1468.64 +1 +1468.64 +1 +1443.89 +1 +1443.89 +1 +1459.8 +1 +1459.8 +1 +1458.08 +1 +1458.08 +1 +1493.33 +1 +1493.33 +1 +1473.49 +1 +1473.49 +1 +1456.62 +1 +1456.62 +1 +1439.97 +1 +1439.97 +1 +1458.66 +1 +1458.66 +1 +1446.55 +1 +1446.55 +1 +1448.01 +1 +1448.01 +1 +1480.11 +1 +1480.11 +1 +1491.09 +1 +1491.09 +1 +1448.18 +1 +1448.18 +1 +1481.2 +1 +1481.2 +1 +1497.25 +1 +1497.25 +1 +1483.67 +1 +1483.67 +1 +1486.95 +1 +1486.95 +1 +1482.45 +1 +1482.45 +1 +1487.27 +1 +1487.27 +1 +1501.13 +1 +1501.13 +1 +1462.77 +1 +1462.77 +1 +1477.78 +1 +1477.78 +1 +1483.37 +1 +1483.37 +1 +1469.89 +1 +1469.89 +1 +1480.19 +1 +1480.19 +1 +1464.3 +1 +1464.3 +1 +1471.5 +1 +1471.5 +1 +1476.38 +1 +1476.38 +1 +1487.68 +1 +1487.68 +1 +1467.23 +1 +1467.23 +1 +1527.29 +1 +1527.29 +1 +1495.55 +1 +1495.55 +1 +1458.29 +1 +1458.29 +1 +1444.69 +1 +1444.69 +1 +1451.04 +1 +1451.04 +1 +1430.24 +1 +1430.24 +1 +1420.39 +1 +1420.39 +1 +1442.46 +1 +1442.46 +1 +1487.61 +1 +1487.61 +1 +1480.46 +1 +1480.46 +1 +1507.67 +1 +1507.67 +1 +1484.48 +1 +1484.48 +1 +1491.1 +1 +1491.1 +1 +1487.25 +1 +1487.25 +1 +1501.67 +1 +1501.67 +1 +1506.47 +1 +1506.47 +1 +1435.27 +1 +1435.27 +1 +1467.9 +1 +1467.9 +1 +1454.89 +1 +1454.89 +1 +1448.55 +1 +1448.55 +1 +1453.77 +1 +1453.77 +1 +1449.49 +1 +1449.49 +1 +1456.26 +1 +1456.26 +1 +1456.97 +1 +1456.97 +1 +1492.35 +1 +1492.35 +1 +1467.09 +1 +1467.09 +1 +1485.52 +1 +1485.52 +1 +1511.24 +1 +1511.24 +1 +1504.77 +1 +1504.77 +1 +1500.03 +1 +1500.03 +1 +1470.23 +1 +1470.23 +1 +1449.01 +1 +1449.01 +1 +1455.97 +1 +1455.97 +1 +1462.81 +1 +1462.81 +1 +1496.62 +1 +1496.62 +1 +1485.01 +1 +1485.01 +1 +1468.04 +1 +1468.04 +1 +1461.05 +1 +1461.05 +1 +1473.36 +1 +1473.36 +1 +1451.14 +1 +1451.14 +1 +1467.79 +1 +1467.79 +1 +1465.53 +1 +1465.53 +1 +1499.74 +1 +1499.74 +1 +1482.76 +1 +1482.76 +1 +1484.56 +1 +1484.56 +1 +1484.23 +1 +1484.23 +1 +1469.23 +1 +1469.23 +1 +1482.17 +1 +1482.17 +1 +1461.72 +1 +1461.72 +1 +1460.27 +1 +1460.27 +1 +1464.61 +1 +1464.61 +1 +1461.86 +1 +1461.86 +1 +1489.6 +1 +1489.6 +1 +1489.78 +1 +1489.78 +1 +1464 +1 +1464 +1 +1490.64 +1 +1490.64 +1 +1475.03 +1 +1475.03 +1 +1448.88 +1 +1448.88 +1 +1447.07 +1 +1447.07 +1 +1479.33 +1 +1479.33 +1 +1505.62 +1 +1505.62 +1 +1501.99 +1 +1501.99 +1 +1480.26 +1 +1480.26 +1 +1487.98 +1 +1487.98 +1 +1491.65 +1 +1491.65 +1 +1489.76 +1 +1489.76 +1 +1481.77 +1 +1481.77 +1 +1502 +1 +1502 +1 +1477.63 +1 +1477.63 +1 +1498.48 +1 +1498.48 +1 +1478.62 +1 +1478.62 +1 +1513.21 +1 +1513.21 +1 +1477.62 +1 +1477.62 +1 +1487.78 +1 +1487.78 +1 +1449.76 +1 +1449.76 +1 +1508.54 +1 +1508.54 +1 +1501.23 +1 +1501.23 +1 +1489.1 +1 +1489.1 +1 +1455.41 +1 +1455.41 +1 +1508.9 +1 +1508.9 +1 +1490.09 +1 +1490.09 +1 +1488.48 +1 +1488.48 +1 +1476.93 +1 +1476.93 +1 +1463.08 +1 +1463.08 +1 +1461.89 +1 +1461.89 +1 +1486.69 +1 +1486.69 +1 +1484.64 +1 +1484.64 +1 +1516.3 +1 +1516.3 +1 +1493.43 +1 +1493.43 +1 +1497.43 +1 +1497.43 +1 +1480.62 +1 +1480.62 +1 +1464.94 +1 +1464.94 +1 +1507.82 +1 +1507.82 +1 +1497.78 +1 +1497.78 +1 +1489.21 +1 +1489.21 +1 +1507.97 +1 +end of experiment diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Mn2p_MnO2.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Mn2p_MnO2.txt new file mode 100644 index 0000000000000000000000000000000000000000..ee64592ed95f108680fc135e357caf529aff5334 --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Mn2p_MnO2.txt @@ -0,0 +1,401 @@ +Mn2p MnO2 +669.9 1725.94 +669.8 1745.35 +669.7 1758.94 +669.6 1745.89 +669.5 1745.75 +669.4 1736.19 +669.3 1762.84 +669.2 1752.74 +669.1 1765.9 +669 1775.37 +668.9 1759.81 +668.8 1752.8 +668.7 1760.59 +668.6 1744.19 +668.5 1752.69 +668.4 1744.24 +668.3 1753.44 +668.2 1761.16 +668.1 1747.96 +668 1755.89 +667.9 1755.58 +667.8 1764.43 +667.7 1786.26 +667.6 1760.14 +667.5 1772.43 +667.4 1775.9 +667.3 1790.63 +667.2 1783.41 +667.1 1782.59 +667 1799.26 +666.9 1795.02 +666.8 1790.05 +666.7 1798.33 +666.6 1795.97 +666.5 1796.2 +666.4 1810.46 +666.3 1783.04 +666.2 1809.61 +666.1 1796 +666 1802.87 +665.9 1805.46 +665.8 1815.69 +665.7 1839.99 +665.6 1823.14 +665.5 1837.13 +665.4 1827.16 +665.3 1842.75 +665.2 1866.55 +665.1 1846.75 +665 1863.74 +664.9 1863.22 +664.8 1854.14 +664.7 1843.81 +664.6 1879.77 +664.5 1868.47 +664.4 1870.44 +664.3 1885.84 +664.2 1886.26 +664.1 1903.52 +664 1898.27 +663.9 1892.34 +663.8 1905.83 +663.7 1917.79 +663.6 1918.01 +663.5 1905.12 +663.4 1911.25 +663.3 1925.56 +663.2 1926.3 +663.1 1913.9 +663 1915.06 +662.9 1911.04 +662.8 1904.7 +662.7 1898.95 +662.6 1896.61 +662.5 1885.69 +662.4 1890.55 +662.3 1891.79 +662.2 1880.95 +662.1 1899.24 +662 1878.06 +661.9 1866.76 +661.8 1855.75 +661.7 1851.57 +661.6 1836.19 +661.5 1862.77 +661.4 1818.6 +661.3 1815.63 +661.2 1848.4 +661.1 1834.04 +661 1829.02 +660.9 1816.99 +660.8 1817.5 +660.7 1850.96 +660.6 1818.71 +660.5 1832.38 +660.4 1813.36 +660.3 1827.35 +660.2 1821.51 +660.1 1837.16 +660 1830.42 +659.9 1820.21 +659.8 1840.25 +659.7 1824.12 +659.6 1850.06 +659.5 1849.11 +659.4 1855.24 +659.3 1836.62 +659.2 1829.3 +659.1 1862.92 +659 1869.29 +658.9 1866.35 +658.8 1854.55 +658.7 1888.14 +658.6 1890.66 +658.5 1878.34 +658.4 1886.67 +658.3 1881.81 +658.2 1893.47 +658.1 1890.79 +658 1853.29 +657.9 1853.01 +657.8 1886.86 +657.7 1912.54 +657.6 1891.2 +657.5 1919.59 +657.4 1910.89 +657.3 1937.7 +657.2 1933.65 +657.1 1954.05 +657 1971.8 +656.9 1984.54 +656.8 1996.09 +656.7 1983.36 +656.6 2009.77 +656.5 2025.12 +656.4 2057.65 +656.3 2074.24 +656.2 2106.47 +656.1 2145.55 +656 2141.85 +655.9 2180.84 +655.8 2207.05 +655.7 2228.85 +655.6 2295.6 +655.5 2305.28 +655.4 2322.96 +655.3 2368.13 +655.2 2421.67 +655.1 2443.29 +655 2527.7 +654.9 2564 +654.8 2617.64 +654.7 2677.65 +654.6 2725.2 +654.5 2806.46 +654.4 2859.56 +654.3 2909.62 +654.2 2985.26 +654.1 3082.56 +654 3124.89 +653.9 3195.41 +653.8 3241.01 +653.7 3324.81 +653.6 3363.13 +653.5 3395.3 +653.4 3422.61 +653.3 3436.71 +653.2 3464.04 +653.1 3437.9 +653 3412.35 +652.9 3414.95 +652.8 3406.58 +652.7 3368.49 +652.6 3345.63 +652.5 3259.45 +652.4 3202.65 +652.3 3132.97 +652.2 3061.99 +652.1 2938.39 +652 2857.51 +651.9 2759.34 +651.8 2704.16 +651.7 2599.16 +651.6 2528.29 +651.5 2462.1 +651.4 2379.45 +651.3 2323.72 +651.2 2252.55 +651.1 2169.1 +651 2122.24 +650.9 2025.7 +650.8 1988.27 +650.7 1947.6 +650.6 1889.51 +650.5 1854.65 +650.4 1813.52 +650.3 1750.2 +650.2 1746.96 +650.1 1706.07 +650 1694.85 +649.9 1668.81 +649.8 1635.07 +649.7 1651.35 +649.6 1626.76 +649.5 1593.09 +649.4 1610.54 +649.3 1590.3 +649.2 1580.1 +649.1 1590.63 +649 1583.72 +648.9 1580.63 +648.8 1584.41 +648.7 1586.16 +648.6 1614.96 +648.5 1613.47 +648.4 1596.59 +648.3 1582.87 +648.2 1612.98 +648.1 1636.95 +648 1641.06 +647.9 1636.56 +647.8 1644.91 +647.7 1642.59 +647.6 1678.24 +647.5 1658.82 +647.4 1665.7 +647.3 1685.39 +647.2 1681.74 +647.1 1661.41 +647 1694.58 +646.9 1728.54 +646.8 1752.09 +646.7 1734.9 +646.6 1730.02 +646.5 1778.94 +646.4 1766.36 +646.3 1773.33 +646.2 1764.99 +646.1 1810.58 +646 1808.64 +645.9 1792.02 +645.8 1822.54 +645.7 1828.03 +645.6 1850.26 +645.5 1866.05 +645.4 1894.65 +645.3 1908.25 +645.2 1925.12 +645.1 1964.04 +645 1967.59 +644.9 2012.27 +644.8 2043.52 +644.7 2088.25 +644.6 2100.88 +644.5 2139.45 +644.4 2190.56 +644.3 2242.76 +644.2 2287.54 +644.1 2359.46 +644 2392.85 +643.9 2448.38 +643.8 2508.63 +643.7 2592.97 +643.6 2658.37 +643.5 2728.57 +643.4 2817.1 +643.3 2910.74 +643.2 3020.74 +643.1 3146.39 +643 3259.71 +642.9 3362.2 +642.8 3485.85 +642.7 3613.03 +642.6 3722.7 +642.5 3808.37 +642.4 3917.95 +642.3 4060.35 +642.2 4167.29 +642.1 4258.99 +642 4342.32 +641.9 4377.23 +641.8 4386.95 +641.7 4463.13 +641.6 4483.3 +641.5 4459.57 +641.4 4473.86 +641.3 4473.1 +641.2 4545.32 +641.1 4604.56 +641 4648.65 +640.9 4630.67 +640.8 4562.67 +640.7 4375.55 +640.6 4104.22 +640.5 3823.5 +640.4 3504.7 +640.3 3225.92 +640.2 2957.21 +640.1 2724.91 +640 2544.69 +639.9 2418.56 +639.8 2258.27 +639.7 2050.05 +639.6 1841.8 +639.5 1617.96 +639.4 1389.61 +639.3 1196.09 +639.2 1036.3 +639.1 915.555 +639 814.72 +638.9 740.59 +638.8 693.195 +638.7 643.884 +638.6 629.642 +638.5 625.686 +638.4 592.841 +638.3 575.033 +638.2 585.409 +638.1 570.28 +638 555.591 +637.9 552.574 +637.8 533.398 +637.7 544.308 +637.6 544.81 +637.5 529.106 +637.4 525.616 +637.3 533.435 +637.2 527.384 +637.1 527.149 +637 519.349 +636.9 510.82 +636.8 528.779 +636.7 522.414 +636.6 517.265 +636.5 514.195 +636.4 515.702 +636.3 505.395 +636.2 511.879 +636.1 504.787 +636 499.106 +635.9 484.92 +635.8 497.635 +635.7 497.591 +635.6 514.686 +635.5 508.791 +635.4 494.709 +635.3 491.455 +635.2 490.179 +635.1 505.581 +635 501.617 +634.9 499.844 +634.8 508.705 +634.7 480.376 +634.6 484.492 +634.5 485.24 +634.4 500.878 +634.3 498.209 +634.2 500.86 +634.1 492.555 +634 495.58 +633.9 493.353 +633.8 501.95 +633.7 495.285 +633.6 499.783 +633.5 488.055 +633.4 486.101 +633.3 487.321 +633.2 476.443 +633.1 475.004 +633 494.64 +632.9 491.067 +632.8 490.616 +632.7 479.667 +632.6 475.344 +632.5 495.007 +632.4 490.514 +632.3 493.456 +632.2 490.086 +632.1 490.835 +632 488.055 +631.9 483.435 +631.8 476.824 +631.7 488.295 +631.6 486.141 +631.5 493.621 +631.4 495.125 +631.3 490.03 +631.2 488.074 +631.1 492.451 +631 491.831 +630.9 483.068 +630.8 492.364 +630.7 486.907 +630.6 493.095 +630.5 482.465 +630.4 480.879 +630.3 467.306 +630.2 481.238 +630.1 487.771 +630 486.795 diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ni2p_NiO.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ni2p_NiO.txt new file mode 100644 index 0000000000000000000000000000000000000000..84deaa958f7d91c594b4a6175fc6eaef58fcf2fe --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ni2p_NiO.txt @@ -0,0 +1,502 @@ +Ni2p NiO +8.900000e+002 1.804960e+004 +8.899000e+002 1.801873e+004 +8.898000e+002 1.791623e+004 +8.897000e+002 1.790187e+004 +8.896000e+002 1.785083e+004 +8.895000e+002 1.782987e+004 +8.894000e+002 1.777710e+004 +8.893000e+002 1.782340e+004 +8.892000e+002 1.796270e+004 +8.891000e+002 1.792543e+004 +8.890000e+002 1.793373e+004 +8.889000e+002 1.769487e+004 +8.888000e+002 1.784093e+004 +8.887000e+002 1.777703e+004 +8.886000e+002 1.780533e+004 +8.885000e+002 1.788890e+004 +8.884000e+002 1.771940e+004 +8.883000e+002 1.773757e+004 +8.882000e+002 1.765410e+004 +8.881000e+002 1.770037e+004 +8.880000e+002 1.781097e+004 +8.879000e+002 1.778713e+004 +8.878000e+002 1.769493e+004 +8.877000e+002 1.766760e+004 +8.876000e+002 1.777533e+004 +8.875000e+002 1.781920e+004 +8.874000e+002 1.781857e+004 +8.873000e+002 1.773533e+004 +8.872000e+002 1.768413e+004 +8.871000e+002 1.769357e+004 +8.870000e+002 1.773190e+004 +8.869000e+002 1.772227e+004 +8.868000e+002 1.792450e+004 +8.867000e+002 1.785110e+004 +8.866000e+002 1.784683e+004 +8.865000e+002 1.775723e+004 +8.864000e+002 1.786747e+004 +8.863000e+002 1.784927e+004 +8.862000e+002 1.774247e+004 +8.861000e+002 1.772323e+004 +8.860000e+002 1.783790e+004 +8.859000e+002 1.796287e+004 +8.858000e+002 1.777503e+004 +8.857000e+002 1.776773e+004 +8.856000e+002 1.780363e+004 +8.855000e+002 1.790223e+004 +8.854000e+002 1.816917e+004 +8.853000e+002 1.817877e+004 +8.852000e+002 1.810960e+004 +8.851000e+002 1.823187e+004 +8.850000e+002 1.828273e+004 +8.849000e+002 1.826097e+004 +8.848000e+002 1.846363e+004 +8.847000e+002 1.843690e+004 +8.846000e+002 1.848877e+004 +8.845000e+002 1.865073e+004 +8.844000e+002 1.864510e+004 +8.843000e+002 1.869787e+004 +8.842000e+002 1.896213e+004 +8.841000e+002 1.889683e+004 +8.840000e+002 1.905063e+004 +8.839000e+002 1.918340e+004 +8.838000e+002 1.934953e+004 +8.837000e+002 1.933403e+004 +8.836000e+002 1.956560e+004 +8.835000e+002 1.974610e+004 +8.834000e+002 1.982647e+004 +8.833000e+002 1.994903e+004 +8.832000e+002 1.996610e+004 +8.831000e+002 2.007257e+004 +8.830000e+002 2.027903e+004 +8.829000e+002 2.022323e+004 +8.828000e+002 2.038693e+004 +8.827000e+002 2.035703e+004 +8.826000e+002 2.065553e+004 +8.825000e+002 2.068870e+004 +8.824000e+002 2.081863e+004 +8.823000e+002 2.088327e+004 +8.822000e+002 2.119993e+004 +8.821000e+002 2.137460e+004 +8.820000e+002 2.162250e+004 +8.819000e+002 2.175273e+004 +8.818000e+002 2.200797e+004 +8.817000e+002 2.220187e+004 +8.816000e+002 2.249983e+004 +8.815000e+002 2.258607e+004 +8.814000e+002 2.289780e+004 +8.813000e+002 2.315103e+004 +8.812000e+002 2.334843e+004 +8.811000e+002 2.330963e+004 +8.810000e+002 2.332217e+004 +8.809000e+002 2.333590e+004 +8.808000e+002 2.353417e+004 +8.807000e+002 2.354107e+004 +8.806000e+002 2.370807e+004 +8.805000e+002 2.368200e+004 +8.804000e+002 2.363610e+004 +8.803000e+002 2.367813e+004 +8.802000e+002 2.381270e+004 +8.801000e+002 2.389383e+004 +8.800000e+002 2.386693e+004 +8.799000e+002 2.386663e+004 +8.798000e+002 2.405447e+004 +8.797000e+002 2.396553e+004 +8.796000e+002 2.405547e+004 +8.795000e+002 2.402497e+004 +8.794000e+002 2.403783e+004 +8.793000e+002 2.396520e+004 +8.792000e+002 2.395950e+004 +8.791000e+002 2.390247e+004 +8.790000e+002 2.397580e+004 +8.789000e+002 2.387597e+004 +8.788000e+002 2.375070e+004 +8.787000e+002 2.361470e+004 +8.786000e+002 2.361953e+004 +8.785000e+002 2.357373e+004 +8.784000e+002 2.347813e+004 +8.783000e+002 2.338280e+004 +8.782000e+002 2.340717e+004 +8.781000e+002 2.307933e+004 +8.780000e+002 2.311610e+004 +8.779000e+002 2.307527e+004 +8.778000e+002 2.282390e+004 +8.777000e+002 2.282453e+004 +8.776000e+002 2.269030e+004 +8.775000e+002 2.250060e+004 +8.774000e+002 2.243670e+004 +8.773000e+002 2.237567e+004 +8.772000e+002 2.218467e+004 +8.771000e+002 2.220990e+004 +8.770000e+002 2.216447e+004 +8.769000e+002 2.190803e+004 +8.768000e+002 2.177470e+004 +8.767000e+002 2.182753e+004 +8.766000e+002 2.181010e+004 +8.765000e+002 2.161917e+004 +8.764000e+002 2.167873e+004 +8.763000e+002 2.159600e+004 +8.762000e+002 2.160433e+004 +8.761000e+002 2.150350e+004 +8.760000e+002 2.146180e+004 +8.759000e+002 2.140400e+004 +8.758000e+002 2.137777e+004 +8.757000e+002 2.144457e+004 +8.756000e+002 2.136297e+004 +8.755000e+002 2.142947e+004 +8.754000e+002 2.143083e+004 +8.753000e+002 2.147330e+004 +8.752000e+002 2.162610e+004 +8.751000e+002 2.174077e+004 +8.750000e+002 2.174213e+004 +8.749000e+002 2.176697e+004 +8.748000e+002 2.187150e+004 +8.747000e+002 2.197053e+004 +8.746000e+002 2.227863e+004 +8.745000e+002 2.246453e+004 +8.744000e+002 2.259270e+004 +8.743000e+002 2.280623e+004 +8.742000e+002 2.288007e+004 +8.741000e+002 2.296013e+004 +8.740000e+002 2.338827e+004 +8.739000e+002 2.345693e+004 +8.738000e+002 2.359327e+004 +8.737000e+002 2.388170e+004 +8.736000e+002 2.399967e+004 +8.735000e+002 2.411003e+004 +8.734000e+002 2.424177e+004 +8.733000e+002 2.438167e+004 +8.732000e+002 2.454627e+004 +8.731000e+002 2.469520e+004 +8.730000e+002 2.477827e+004 +8.729000e+002 2.484167e+004 +8.728000e+002 2.493103e+004 +8.727000e+002 2.499490e+004 +8.726000e+002 2.508743e+004 +8.725000e+002 2.507333e+004 +8.724000e+002 2.503047e+004 +8.723000e+002 2.504980e+004 +8.722000e+002 2.519590e+004 +8.721000e+002 2.522503e+004 +8.720000e+002 2.515097e+004 +8.719000e+002 2.504673e+004 +8.718000e+002 2.486303e+004 +8.717000e+002 2.501690e+004 +8.716000e+002 2.501340e+004 +8.715000e+002 2.515330e+004 +8.714000e+002 2.516557e+004 +8.713000e+002 2.498497e+004 +8.712000e+002 2.489247e+004 +8.711000e+002 2.471323e+004 +8.710000e+002 2.456293e+004 +8.709000e+002 2.412490e+004 +8.708000e+002 2.345920e+004 +8.707000e+002 2.283010e+004 +8.706000e+002 2.216423e+004 +8.705000e+002 2.117187e+004 +8.704000e+002 2.026050e+004 +8.703000e+002 1.940240e+004 +8.702000e+002 1.871033e+004 +8.701000e+002 1.807967e+004 +8.700000e+002 1.756350e+004 +8.699000e+002 1.703443e+004 +8.698000e+002 1.668233e+004 +8.697000e+002 1.643477e+004 +8.696000e+002 1.626570e+004 +8.695000e+002 1.599313e+004 +8.694000e+002 1.595273e+004 +8.693000e+002 1.578853e+004 +8.692000e+002 1.572607e+004 +8.691000e+002 1.580393e+004 +8.690000e+002 1.574730e+004 +8.689000e+002 1.576107e+004 +8.688000e+002 1.585577e+004 +8.687000e+002 1.598243e+004 +8.686000e+002 1.594923e+004 +8.685000e+002 1.613857e+004 +8.684000e+002 1.623947e+004 +8.683000e+002 1.640770e+004 +8.682000e+002 1.655317e+004 +8.681000e+002 1.670567e+004 +8.680000e+002 1.682287e+004 +8.679000e+002 1.690977e+004 +8.678000e+002 1.705803e+004 +8.677000e+002 1.705723e+004 +8.676000e+002 1.720760e+004 +8.675000e+002 1.727733e+004 +8.674000e+002 1.752277e+004 +8.673000e+002 1.761593e+004 +8.672000e+002 1.752660e+004 +8.671000e+002 1.765207e+004 +8.670000e+002 1.784850e+004 +8.669000e+002 1.786163e+004 +8.668000e+002 1.799913e+004 +8.667000e+002 1.812963e+004 +8.666000e+002 1.830660e+004 +8.665000e+002 1.838067e+004 +8.664000e+002 1.853230e+004 +8.663000e+002 1.862853e+004 +8.662000e+002 1.862260e+004 +8.661000e+002 1.854567e+004 +8.660000e+002 1.860757e+004 +8.659000e+002 1.850937e+004 +8.658000e+002 1.847410e+004 +8.657000e+002 1.838973e+004 +8.656000e+002 1.847837e+004 +8.655000e+002 1.855173e+004 +8.654000e+002 1.856640e+004 +8.653000e+002 1.869617e+004 +8.652000e+002 1.894280e+004 +8.651000e+002 1.892317e+004 +8.650000e+002 1.913663e+004 +8.649000e+002 1.915550e+004 +8.648000e+002 1.941383e+004 +8.647000e+002 1.978487e+004 +8.646000e+002 1.988177e+004 +8.645000e+002 2.025703e+004 +8.644000e+002 2.034257e+004 +8.643000e+002 2.054337e+004 +8.642000e+002 2.067410e+004 +8.641000e+002 2.102837e+004 +8.640000e+002 2.114117e+004 +8.639000e+002 2.119077e+004 +8.638000e+002 2.135910e+004 +8.637000e+002 2.151763e+004 +8.636000e+002 2.169413e+004 +8.635000e+002 2.177053e+004 +8.634000e+002 2.189723e+004 +8.633000e+002 2.223643e+004 +8.632000e+002 2.237583e+004 +8.631000e+002 2.249893e+004 +8.630000e+002 2.268267e+004 +8.629000e+002 2.290073e+004 +8.628000e+002 2.304400e+004 +8.627000e+002 2.336570e+004 +8.626000e+002 2.376023e+004 +8.625000e+002 2.400820e+004 +8.624000e+002 2.423797e+004 +8.623000e+002 2.458737e+004 +8.622000e+002 2.493407e+004 +8.621000e+002 2.539747e+004 +8.620000e+002 2.541337e+004 +8.619000e+002 2.586173e+004 +8.618000e+002 2.619087e+004 +8.617000e+002 2.641710e+004 +8.616000e+002 2.671440e+004 +8.615000e+002 2.688283e+004 +8.614000e+002 2.724113e+004 +8.613000e+002 2.756920e+004 +8.612000e+002 2.765563e+004 +8.611000e+002 2.765843e+004 +8.610000e+002 2.764130e+004 +8.609000e+002 2.745653e+004 +8.608000e+002 2.751630e+004 +8.607000e+002 2.725943e+004 +8.606000e+002 2.705963e+004 +8.605000e+002 2.688120e+004 +8.604000e+002 2.654723e+004 +8.603000e+002 2.639577e+004 +8.602000e+002 2.585517e+004 +8.601000e+002 2.551390e+004 +8.600000e+002 2.550293e+004 +8.599000e+002 2.507817e+004 +8.598000e+002 2.475053e+004 +8.597000e+002 2.437017e+004 +8.596000e+002 2.406260e+004 +8.595000e+002 2.356420e+004 +8.594000e+002 2.314087e+004 +8.593000e+002 2.290140e+004 +8.592000e+002 2.253793e+004 +8.591000e+002 2.230233e+004 +8.590000e+002 2.189257e+004 +8.589000e+002 2.159750e+004 +8.588000e+002 2.139030e+004 +8.587000e+002 2.134727e+004 +8.586000e+002 2.103970e+004 +8.585000e+002 2.107827e+004 +8.584000e+002 2.095647e+004 +8.583000e+002 2.110920e+004 +8.582000e+002 2.093927e+004 +8.581000e+002 2.087350e+004 +8.580000e+002 2.117757e+004 +8.579000e+002 2.133053e+004 +8.578000e+002 2.143377e+004 +8.577000e+002 2.162897e+004 +8.576000e+002 2.187580e+004 +8.575000e+002 2.239600e+004 +8.574000e+002 2.278347e+004 +8.573000e+002 2.303107e+004 +8.572000e+002 2.361197e+004 +8.571000e+002 2.406420e+004 +8.570000e+002 2.477693e+004 +8.569000e+002 2.552187e+004 +8.568000e+002 2.605863e+004 +8.567000e+002 2.668407e+004 +8.566000e+002 2.728750e+004 +8.565000e+002 2.798730e+004 +8.564000e+002 2.856500e+004 +8.563000e+002 2.921377e+004 +8.562000e+002 2.987930e+004 +8.561000e+002 3.022613e+004 +8.560000e+002 3.061917e+004 +8.559000e+002 3.114957e+004 +8.558000e+002 3.126110e+004 +8.557000e+002 3.124383e+004 +8.556000e+002 3.134300e+004 +8.555000e+002 3.105563e+004 +8.554000e+002 3.071503e+004 +8.553000e+002 3.055023e+004 +8.552000e+002 3.044403e+004 +8.551000e+002 3.033673e+004 +8.550000e+002 3.035547e+004 +8.549000e+002 3.053817e+004 +8.548000e+002 3.067217e+004 +8.547000e+002 3.122410e+004 +8.546000e+002 3.185153e+004 +8.545000e+002 3.259767e+004 +8.544000e+002 3.342233e+004 +8.543000e+002 3.462667e+004 +8.542000e+002 3.607267e+004 +8.541000e+002 3.731767e+004 +8.540000e+002 3.878200e+004 +8.539000e+002 3.974800e+004 +8.538000e+002 4.028600e+004 +8.537000e+002 3.969333e+004 +8.536000e+002 3.827733e+004 +8.535000e+002 3.591333e+004 +8.534000e+002 3.286043e+004 +8.533000e+002 2.928093e+004 +8.532000e+002 2.580557e+004 +8.531000e+002 2.262770e+004 +8.530000e+002 2.012770e+004 +8.529000e+002 1.814567e+004 +8.528000e+002 1.677260e+004 +8.527000e+002 1.568723e+004 +8.526000e+002 1.474303e+004 +8.525000e+002 1.413197e+004 +8.524000e+002 1.355920e+004 +8.523000e+002 1.324577e+004 +8.522000e+002 1.306007e+004 +8.521000e+002 1.274430e+004 +8.520000e+002 1.247890e+004 +8.519000e+002 1.233420e+004 +8.518000e+002 1.215370e+004 +8.517000e+002 1.208000e+004 +8.516000e+002 1.198327e+004 +8.515000e+002 1.194393e+004 +8.514000e+002 1.191400e+004 +8.513000e+002 1.183113e+004 +8.512000e+002 1.168753e+004 +8.511000e+002 1.158960e+004 +8.510000e+002 1.152620e+004 +8.509000e+002 1.155620e+004 +8.508000e+002 1.154797e+004 +8.507000e+002 1.150677e+004 +8.506000e+002 1.142260e+004 +8.505000e+002 1.150533e+004 +8.504000e+002 1.147907e+004 +8.503000e+002 1.136920e+004 +8.502000e+002 1.139370e+004 +8.501000e+002 1.135990e+004 +8.500000e+002 1.134790e+004 +8.499000e+002 1.147867e+004 +8.498000e+002 1.143633e+004 +8.497000e+002 1.136520e+004 +8.496000e+002 1.135260e+004 +8.495000e+002 1.119367e+004 +8.494000e+002 1.129097e+004 +8.493000e+002 1.120570e+004 +8.492000e+002 1.124637e+004 +8.491000e+002 1.123197e+004 +8.490000e+002 1.114453e+004 +8.489000e+002 1.118790e+004 +8.488000e+002 1.117793e+004 +8.487000e+002 1.123977e+004 +8.486000e+002 1.123253e+004 +8.485000e+002 1.117553e+004 +8.484000e+002 1.121767e+004 +8.483000e+002 1.116507e+004 +8.482000e+002 1.105000e+004 +8.481000e+002 1.106977e+004 +8.480000e+002 1.110960e+004 +8.479000e+002 1.114887e+004 +8.478000e+002 1.114610e+004 +8.477000e+002 1.122997e+004 +8.476000e+002 1.107337e+004 +8.475000e+002 1.109290e+004 +8.474000e+002 1.109693e+004 +8.473000e+002 1.111023e+004 +8.472000e+002 1.104947e+004 +8.471000e+002 1.106493e+004 +8.470000e+002 1.116227e+004 +8.469000e+002 1.114217e+004 +8.468000e+002 1.111787e+004 +8.467000e+002 1.111910e+004 +8.466000e+002 1.108483e+004 +8.465000e+002 1.111657e+004 +8.464000e+002 1.112573e+004 +8.463000e+002 1.107640e+004 +8.462000e+002 1.107333e+004 +8.461000e+002 1.113027e+004 +8.460000e+002 1.111240e+004 +8.459000e+002 1.106800e+004 +8.458000e+002 1.109983e+004 +8.457000e+002 1.106197e+004 +8.456000e+002 1.102750e+004 +8.455000e+002 1.112543e+004 +8.454000e+002 1.104133e+004 +8.453000e+002 1.104243e+004 +8.452000e+002 1.115630e+004 +8.451000e+002 1.117900e+004 +8.450000e+002 1.113117e+004 +8.449000e+002 1.107317e+004 +8.448000e+002 1.107373e+004 +8.447000e+002 1.111633e+004 +8.446000e+002 1.111073e+004 +8.445000e+002 1.102807e+004 +8.444000e+002 1.106183e+004 +8.443000e+002 1.106707e+004 +8.442000e+002 1.107517e+004 +8.441000e+002 1.112550e+004 +8.440000e+002 1.100603e+004 +8.439000e+002 1.109437e+004 +8.438000e+002 1.110583e+004 +8.437000e+002 1.109267e+004 +8.436000e+002 1.111330e+004 +8.435000e+002 1.103637e+004 +8.434000e+002 1.099460e+004 +8.433000e+002 1.109083e+004 +8.432000e+002 1.102193e+004 +8.431000e+002 1.109910e+004 +8.430000e+002 1.105723e+004 +8.429000e+002 1.109820e+004 +8.428000e+002 1.122003e+004 +8.427000e+002 1.109307e+004 +8.426000e+002 1.106603e+004 +8.425000e+002 1.110273e+004 +8.424000e+002 1.103943e+004 +8.423000e+002 1.109023e+004 +8.422000e+002 1.108053e+004 +8.421000e+002 1.102293e+004 +8.420000e+002 1.100317e+004 +8.419000e+002 1.096233e+004 +8.418000e+002 1.101647e+004 +8.417000e+002 1.106647e+004 +8.416000e+002 1.116030e+004 +8.415000e+002 1.116010e+004 +8.414000e+002 1.108863e+004 +8.413000e+002 1.111463e+004 +8.412000e+002 1.112650e+004 +8.411000e+002 1.107853e+004 +8.410000e+002 1.116193e+004 +8.409000e+002 1.113143e+004 +8.408000e+002 1.115163e+004 +8.407000e+002 1.113753e+004 +8.406000e+002 1.115463e+004 +8.405000e+002 1.114797e+004 +8.404000e+002 1.104753e+004 +8.403000e+002 1.124633e+004 +8.402000e+002 1.119387e+004 +8.401000e+002 1.111483e+004 +8.400000e+002 1.120757e+004 \ No newline at end of file diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ti_references_irregular.vms b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ti_references_irregular.vms new file mode 100644 index 0000000000000000000000000000000000000000..4131c17f656fd32b557359c9eb5237d81037115e --- /dev/null +++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xpsdeeplearning/data/references/Ti_references_irregular.vms @@ -0,0 +1,29800 @@ +VAMAS Surface Chemical Analysis Standard Data Transfer Format 1988 May 4 +Not Specified +Not Specified +Not Specified +Not Specified +8 +Casa Info Follows CasaXPS Version 2.3.25PR1.0 +0 +Created by SpecsLab Prodigy, Version 4.55.1-r82379 +SourceAnalyserAngle: 56.500000 d +CasaRowLabel:Ti metal +CasaRowLabel:TiO +CasaRowLabel:Ti2O3 +CasaRowLabel:TiO2 +NORM +IRREGULAR +3 +1 +Exp Variable +d +0 +0 +0 +0 +12 +Ti2p +Ti metal +0 +0 +0 +0 +0 +0 +0 +12 +Casa Info Follows +0 +0 +0 +0 + +PCA Coefs = 54487.5, 23477.3, -4356.52, 108.165, +PCA Coefs = 54487.5, 23477.3, -4356.52, 108.165, -1011.67, +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +C:\Users\pielsticker\Downloads\Ti\references_irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.61 +1380.79 +1 +986.71 +1379.61 +1 +986.81 +1342.46 +1 +986.91 +1357.98 +1 +987.01 +1384.78 +1 +987.11 +1338.23 +1 +987.21 +1302.73 +1 +987.31 +1369.8 +1 +987.41 +1340.63 +1 +987.51 +1326.81 +1 +987.61 +1308.49 +1 +987.71 +1297.46 +1 +987.81 +1366.09 +1 +987.91 +1417.54 +1 +988.01 +1429.56 +1 +988.11 +1338.43 +1 +988.21 +1307.35 +1 +988.31 +1331.1 +1 +988.41 +1342.77 +1 +988.51 +1352.87 +1 +988.61 +1334.16 +1 +988.71 +1322.33 +1 +988.81 +1336.04 +1 +988.91 +1337.25 +1 +989.01 +1291.69 +1 +989.11 +1331.42 +1 +989.21 +1362.36 +1 +989.31 +1367.73 +1 +989.41 +1321.77 +1 +989.51 +1331.19 +1 +989.61 +1337.59 +1 +989.71 +1354.37 +1 +989.81 +1337.41 +1 +989.91 +1414.58 +1 +990.01 +1375.48 +1 +990.11 +1329.94 +1 +990.21 +1340.48 +1 +990.31 +1299.66 +1 +990.41 +1329.48 +1 +990.51 +1336.35 +1 +990.61 +1374.2 +1 +990.71 +1329.05 +1 +990.81 +1364.6 +1 +990.91 +1275.77 +1 +991.01 +1403.71 +1 +991.11 +1391.23 +1 +991.21 +1385.94 +1 +991.31 +1408.94 +1 +991.41 +1378.4 +1 +991.51 +1311.37 +1 +991.61 +1388.73 +1 +991.71 +1357.91 +1 +991.81 +1398.56 +1 +991.91 +1318.21 +1 +992.01 +1324.53 +1 +992.11 +1390.02 +1 +992.21 +1299.01 +1 +992.31 +1376.27 +1 +992.41 +1368.45 +1 +992.51 +1384.67 +1 +992.61 +1327.26 +1 +992.71 +1345.15 +1 +992.81 +1363.08 +1 +992.91 +1365.75 +1 +993.01 +1307.44 +1 +993.11 +1363.56 +1 +993.21 +1293.28 +1 +993.31 +1339.81 +1 +993.41 +1331.02 +1 +993.51 +1325.31 +1 +993.61 +1339.19 +1 +993.71 +1382.03 +1 +993.81 +1270.13 +1 +993.91 +1311.58 +1 +994.01 +1363.6 +1 +994.11 +1378.17 +1 +994.21 +1289.73 +1 +994.31 +1438.27 +1 +994.41 +1295.38 +1 +994.51 +1371.09 +1 +994.61 +1381.04 +1 +994.71 +1391.69 +1 +994.81 +1354.23 +1 +994.91 +1386.57 +1 +995.01 +1303.35 +1 +995.11 +1321.43 +1 +995.21 +1369.64 +1 +995.31 +1438.72 +1 +995.41 +1409.51 +1 +995.51 +1401.62 +1 +995.61 +1421.9 +1 +995.71 +1412.13 +1 +995.81 +1429.47 +1 +995.91 +1360.03 +1 +996.01 +1401.67 +1 +996.11 +1377.03 +1 +996.21 +1353.26 +1 +996.31 +1442.57 +1 +996.41 +1318.8 +1 +996.51 +1292.64 +1 +996.61 +1475.21 +1 +996.71 +1394.63 +1 +996.81 +1382.38 +1 +996.91 +1497.62 +1 +997.01 +1445.13 +1 +997.11 +1444.74 +1 +997.21 +1423.46 +1 +997.31 +1449.53 +1 +997.41 +1437.41 +1 +997.51 +1436.63 +1 +997.61 +1459.79 +1 +997.71 +1452.47 +1 +997.81 +1374.02 +1 +997.91 +1365.02 +1 +998.01 +1425.56 +1 +998.11 +1477.99 +1 +998.21 +1395.59 +1 +998.31 +1349.93 +1 +998.41 +1406.85 +1 +998.51 +1442.93 +1 +998.61 +1426.26 +1 +998.71 +1425.03 +1 +998.81 +1448.98 +1 +998.91 +1417.89 +1 +999.01 +1363.7 +1 +999.11 +1357.04 +1 +999.21 +1372.19 +1 +999.31 +1451.86 +1 +999.41 +1440.96 +1 +999.51 +1447.06 +1 +999.61 +1472.97 +1 +999.71 +1420.74 +1 +999.81 +1469.9 +1 +999.91 +1469.79 +1 +1000.01 +1410.93 +1 +1000.11 +1469.51 +1 +1000.21 +1427.66 +1 +1000.31 +1474.49 +1 +1000.41 +1484.39 +1 +1000.51 +1499.16 +1 +1000.61 +1439.94 +1 +1000.71 +1501.69 +1 +1000.81 +1473.67 +1 +1000.91 +1424.29 +1 +1001.01 +1510.63 +1 +1001.11 +1439.25 +1 +1001.21 +1504.56 +1 +1001.31 +1449.63 +1 +1001.41 +1499.57 +1 +1001.51 +1516.59 +1 +1001.61 +1470.99 +1 +1001.71 +1446.03 +1 +1001.81 +1491.14 +1 +1001.91 +1482.6 +1 +1002.01 +1458.25 +1 +1002.11 +1464.51 +1 +1002.21 +1528.15 +1 +1002.31 +1599.73 +1 +1002.41 +1519.57 +1 +1002.51 +1464.08 +1 +1002.61 +1500.98 +1 +1002.71 +1491.64 +1 +1002.81 +1506.13 +1 +1002.91 +1493.78 +1 +1003.01 +1490.32 +1 +1003.11 +1562.09 +1 +1003.21 +1609.35 +1 +1003.31 +1533.6 +1 +1003.41 +1496.24 +1 +1003.51 +1515.64 +1 +1003.61 +1520.53 +1 +1003.71 +1584.04 +1 +1003.81 +1479.16 +1 +1003.91 +1498.88 +1 +1004.01 +1597.33 +1 +1004.11 +1576.33 +1 +1004.21 +1609.96 +1 +1004.31 +1589.92 +1 +1004.41 +1588.85 +1 +1004.51 +1571.07 +1 +1004.61 +1564.75 +1 +1004.71 +1641.64 +1 +1004.81 +1614.72 +1 +1004.91 +1545.26 +1 +1005.01 +1584.59 +1 +1005.11 +1642.09 +1 +1005.21 +1624.18 +1 +1005.31 +1587.97 +1 +1005.41 +1664.19 +1 +1005.51 +1622.77 +1 +1005.61 +1631.17 +1 +1005.71 +1685.78 +1 +1005.81 +1639.74 +1 +1005.91 +1667.52 +1 +1006.01 +1660.09 +1 +1006.11 +1692.51 +1 +1006.21 +1740.76 +1 +1006.31 +1741.68 +1 +1006.41 +1670.29 +1 +1006.51 +1597.06 +1 +1006.61 +1699.18 +1 +1006.71 +1670.17 +1 +1006.81 +1693.94 +1 +1006.91 +1620.58 +1 +1007.01 +1651.87 +1 +1007.11 +1653.77 +1 +1007.21 +1699.66 +1 +1007.31 +1772.5 +1 +1007.41 +1760.24 +1 +1007.51 +1777.14 +1 +1007.61 +1729.47 +1 +1007.71 +1707.44 +1 +1007.81 +1685.22 +1 +1007.91 +1823.56 +1 +1008.01 +1773.63 +1 +1008.11 +1798.18 +1 +1008.21 +1658.13 +1 +1008.31 +1712.2 +1 +1008.41 +1712.79 +1 +1008.51 +1786.61 +1 +1008.61 +1802.67 +1 +1008.71 +1800.84 +1 +1008.81 +1845.9 +1 +1008.91 +1794.35 +1 +1009.01 +1683.68 +1 +1009.11 +1746.38 +1 +1009.21 +1813.12 +1 +1009.31 +1744.82 +1 +1009.41 +1813.56 +1 +1009.51 +1879.87 +1 +1009.61 +1808.8 +1 +1009.71 +1876.88 +1 +1009.81 +1852.78 +1 +1009.91 +1811.09 +1 +1010.01 +1835.17 +1 +1010.11 +1720.69 +1 +1010.21 +1870.48 +1 +1010.31 +1845.77 +1 +1010.41 +1890.29 +1 +1010.51 +1887.68 +1 +1010.61 +1915.28 +1 +1010.71 +1897.2 +1 +1010.81 +1843.1 +1 +1010.91 +1882.49 +1 +1011.01 +1923.08 +1 +1011.11 +1869.6 +1 +1011.21 +1931.1 +1 +1011.31 +1872.84 +1 +1011.41 +1856.21 +1 +1011.51 +1754.08 +1 +1011.61 +1854.61 +1 +1011.71 +1836.8 +1 +1011.81 +1858.82 +1 +1011.91 +1916.85 +1 +1012.01 +1958.7 +1 +1012.11 +1946.96 +1 +1012.21 +1843.17 +1 +1012.31 +1901.22 +1 +1012.41 +1979.69 +1 +1012.51 +1873.84 +1 +1012.61 +1820.68 +1 +1012.71 +1919.9 +1 +1012.81 +1879.35 +1 +1012.91 +1933.45 +1 +1013.01 +1916.62 +1 +1013.11 +1825.82 +1 +1013.21 +1825.83 +1 +1013.31 +1934.56 +1 +1013.41 +1951.73 +1 +1013.51 +1848.74 +1 +1013.61 +1941.73 +1 +1013.71 +2018.38 +1 +1013.81 +1930.07 +1 +1013.91 +1920.36 +1 +1014.01 +2013.36 +1 +1014.11 +1984.06 +1 +1014.21 +2007.5 +1 +1014.31 +1948.81 +1 +1014.41 +1946.49 +1 +1014.51 +1951.41 +1 +1014.61 +1930.67 +1 +1014.71 +1969.69 +1 +1014.81 +2028.56 +1 +1014.91 +1991.82 +1 +1015.01 +1942.89 +1 +1015.11 +1909.56 +1 +1015.21 +1915.99 +1 +1015.31 +1955.57 +1 +1015.41 +2015.53 +1 +1015.51 +1852.58 +1 +1015.61 +1963.3 +1 +1015.61 +1933.49 +1 +1015.66 +1941.26 +1 +1015.71 +1965.15 +1 +1015.71 +1877.62 +1 +1015.76 +1971.51 +1 +1015.81 +1973.09 +1 +1015.81 +1768.22 +1 +1015.86 +2021.45 +1 +1015.91 +1933.58 +1 +1015.91 +1947.46 +1 +1015.96 +1956.42 +1 +1016.01 +1980.6 +1 +1016.01 +1869.75 +1 +1016.06 +1855.78 +1 +1016.11 +1938.97 +1 +1016.11 +1872.9 +1 +1016.16 +1999.16 +1 +1016.21 +1972.71 +1 +1016.21 +1929.9 +1 +1016.26 +1973.12 +1 +1016.31 +1848.81 +1 +1016.31 +1885.8 +1 +1016.36 +1938.1 +1 +1016.41 +2018.31 +1 +1016.41 +1808.37 +1 +1016.46 +1981.29 +1 +1016.51 +1823.87 +1 +1016.51 +1951.69 +1 +1016.56 +1940.62 +1 +1016.61 +1889.25 +1 +1016.61 +1812.92 +1 +1016.66 +1904.31 +1 +1016.71 +1895.27 +1 +1016.76 +1935.61 +1 +1016.81 +1942.68 +1 +1016.86 +1929.89 +1 +1016.91 +1882.81 +1 +1016.96 +1902.12 +1 +1017.01 +1901.64 +1 +1017.06 +1902.15 +1 +1017.11 +1889.43 +1 +1017.16 +1937.09 +1 +1017.21 +1926.96 +1 +1017.26 +1910.96 +1 +1017.31 +1844.52 +1 +1017.36 +1896.03 +1 +1017.41 +1863.37 +1 +1017.46 +1931.4 +1 +1017.51 +1887.82 +1 +1017.56 +1865.67 +1 +1017.61 +1912.49 +1 +1017.66 +1895.03 +1 +1017.71 +1966.08 +1 +1017.76 +1927.63 +1 +1017.81 +1876.22 +1 +1017.86 +1850.19 +1 +1017.91 +1906.06 +1 +1017.96 +1938.18 +1 +1018.01 +1950.47 +1 +1018.06 +1817.53 +1 +1018.11 +1766.07 +1 +1018.16 +1759.62 +1 +1018.21 +1838.78 +1 +1018.26 +1838.98 +1 +1018.31 +1809.91 +1 +1018.36 +1803.35 +1 +1018.41 +1828.37 +1 +1018.46 +1830.74 +1 +1018.51 +1836.04 +1 +1018.56 +1808.17 +1 +1018.61 +1865.96 +1 +1018.66 +1815.38 +1 +1018.71 +1796.13 +1 +1018.76 +1857.29 +1 +1018.81 +1805.1 +1 +1018.86 +1890.62 +1 +1018.91 +1837.8 +1 +1018.96 +1821.53 +1 +1019.01 +1816.02 +1 +1019.06 +1822.96 +1 +1019.11 +1846.53 +1 +1019.16 +1843.97 +1 +1019.21 +1816.55 +1 +1019.26 +1844.37 +1 +1019.31 +1751.26 +1 +1019.36 +1801.92 +1 +1019.41 +1833.22 +1 +1019.46 +1792.86 +1 +1019.51 +1794.61 +1 +1019.56 +1781.12 +1 +1019.61 +1772.53 +1 +1019.66 +1779.03 +1 +1019.71 +1816.7 +1 +1019.76 +1731.66 +1 +1019.81 +1753.41 +1 +1019.86 +1744.02 +1 +1019.91 +1781.79 +1 +1019.96 +1769.55 +1 +1020.01 +1744.31 +1 +1020.06 +1728.57 +1 +1020.11 +1709.92 +1 +1020.16 +1750.91 +1 +1020.21 +1729.59 +1 +1020.26 +1691.85 +1 +1020.31 +1661.76 +1 +1020.36 +1641.75 +1 +1020.41 +1691.15 +1 +1020.46 +1696.6 +1 +1020.51 +1641.03 +1 +1020.56 +1664.82 +1 +1020.61 +1685.23 +1 +1020.66 +1734.4 +1 +1020.71 +1743.33 +1 +1020.76 +1725.8 +1 +1020.81 +1641.08 +1 +1020.86 +1659.57 +1 +1020.91 +1642.85 +1 +1020.96 +1653.85 +1 +1021.01 +1642.46 +1 +1021.06 +1596.89 +1 +1021.11 +1655.18 +1 +1021.16 +1631.72 +1 +1021.21 +1677.89 +1 +1021.26 +1615.46 +1 +1021.31 +1575.95 +1 +1021.36 +1635.74 +1 +1021.41 +1637.82 +1 +1021.46 +1621.95 +1 +1021.51 +1624.47 +1 +1021.56 +1602.28 +1 +1021.61 +1617.64 +1 +1021.66 +1661.08 +1 +1021.71 +1601.39 +1 +1021.76 +1597.96 +1 +1021.81 +1634.78 +1 +1021.86 +1515.82 +1 +1021.91 +1529.38 +1 +1021.96 +1589.72 +1 +1022.01 +1631.87 +1 +1022.06 +1600.49 +1 +1022.11 +1609.53 +1 +1022.16 +1621.86 +1 +1022.21 +1618.58 +1 +1022.26 +1588.22 +1 +1022.31 +1611.16 +1 +1022.36 +1538.82 +1 +1022.41 +1555.75 +1 +1022.46 +1623.54 +1 +1022.51 +1596.04 +1 +1022.56 +1598.46 +1 +1022.61 +1625.18 +1 +1022.66 +1625.41 +1 +1022.71 +1559.8 +1 +1022.76 +1590.72 +1 +1022.81 +1603 +1 +1022.86 +1625.45 +1 +1022.91 +1614.94 +1 +1022.96 +1616.31 +1 +1023.01 +1646.62 +1 +1023.06 +1605.99 +1 +1023.11 +1574.2 +1 +1023.16 +1653.07 +1 +1023.21 +1616.84 +1 +1023.26 +1643.5 +1 +1023.31 +1681.81 +1 +1023.36 +1687.59 +1 +1023.41 +1643.74 +1 +1023.46 +1699.56 +1 +1023.51 +1685.63 +1 +1023.56 +1623.89 +1 +1023.61 +1709.65 +1 +1023.66 +1685.35 +1 +1023.71 +1678.15 +1 +1023.76 +1712.26 +1 +1023.81 +1734.06 +1 +1023.86 +1753.33 +1 +1023.91 +1749.23 +1 +1023.96 +1685.39 +1 +1024.01 +1678.21 +1 +1024.06 +1703.71 +1 +1024.11 +1667.25 +1 +1024.16 +1723.33 +1 +1024.21 +1737.96 +1 +1024.26 +1747.16 +1 +1024.31 +1784.91 +1 +1024.36 +1834.63 +1 +1024.41 +1847.48 +1 +1024.46 +1857.75 +1 +1024.51 +1841.84 +1 +1024.56 +1830 +1 +1024.61 +1880.13 +1 +1024.66 +1914.53 +1 +1024.71 +1958.79 +1 +1024.76 +1980.26 +1 +1024.81 +1929.9 +1 +1024.86 +1946.76 +1 +1024.91 +2011.96 +1 +1024.96 +1987.89 +1 +1025.01 +1956.88 +1 +1025.06 +2011.1 +1 +1025.11 +1984.67 +1 +1025.16 +2039.99 +1 +1025.21 +2056.17 +1 +1025.26 +2128.09 +1 +1025.31 +2070.19 +1 +1025.36 +2128.97 +1 +1025.41 +2115.4 +1 +1025.46 +2262.59 +1 +1025.51 +2320.48 +1 +1025.56 +2286.48 +1 +1025.61 +2379.47 +1 +1025.66 +2412.44 +1 +1025.71 +2474.45 +1 +1025.76 +2484.5 +1 +1025.81 +2593.62 +1 +1025.86 +2650.32 +1 +1025.91 +2727.02 +1 +1025.96 +2862.62 +1 +1026.01 +2860.44 +1 +1026.06 +3055.64 +1 +1026.11 +3137.41 +1 +1026.16 +3219.96 +1 +1026.21 +3305.52 +1 +1026.26 +3447.77 +1 +1026.31 +3530.05 +1 +1026.36 +3615.49 +1 +1026.41 +3658.58 +1 +1026.46 +3777.02 +1 +1026.51 +3966.76 +1 +1026.56 +4018.36 +1 +1026.61 +4079.39 +1 +1026.66 +4113.2 +1 +1026.71 +4028.53 +1 +1026.76 +4037.47 +1 +1026.81 +3963.71 +1 +1026.86 +3850.84 +1 +1026.91 +3698.38 +1 +1026.96 +3619.54 +1 +1027.01 +3422.72 +1 +1027.06 +3176.2 +1 +1027.11 +3153.17 +1 +1027.16 +3044.57 +1 +1027.21 +2829.88 +1 +1027.26 +2589.45 +1 +1027.31 +2474.68 +1 +1027.36 +2354.17 +1 +1027.41 +2254.55 +1 +1027.46 +2028.81 +1 +1027.51 +2031.41 +1 +1027.56 +1822.23 +1 +1027.61 +1832.39 +1 +1027.66 +1757.17 +1 +1027.71 +1626.62 +1 +1027.76 +1673.17 +1 +1027.81 +1630.39 +1 +1027.86 +1465.44 +1 +1027.91 +1470.7 +1 +1027.96 +1448.93 +1 +1028.01 +1361.87 +1 +1028.06 +1306.54 +1 +1028.11 +1325.99 +1 +1028.16 +1288.78 +1 +1028.21 +1338 +1 +1028.26 +1353.09 +1 +1028.31 +1321.05 +1 +1028.36 +1320.89 +1 +1028.41 +1233.07 +1 +1028.46 +1219.36 +1 +1028.51 +1236.26 +1 +1028.56 +1258.57 +1 +1028.61 +1202.57 +1 +1028.66 +1213.91 +1 +1028.71 +1188.95 +1 +1028.76 +1237.24 +1 +1028.81 +1213.76 +1 +1028.86 +1175.42 +1 +1028.91 +1218.24 +1 +1028.96 +1226.62 +1 +1029.01 +1264.76 +1 +1029.06 +1243.46 +1 +1029.11 +1216.39 +1 +1029.16 +1275.79 +1 +1029.21 +1290.32 +1 +1029.26 +1184.19 +1 +1029.31 +1207.88 +1 +1029.36 +1225.3 +1 +1029.41 +1256.9 +1 +1029.46 +1249.17 +1 +1029.51 +1235.28 +1 +1029.56 +1277.07 +1 +1029.61 +1330.8 +1 +1029.66 +1323.01 +1 +1029.71 +1324.2 +1 +1029.76 +1344.62 +1 +1029.81 +1308.33 +1 +1029.86 +1333.98 +1 +1029.91 +1324.21 +1 +1029.96 +1308.42 +1 +1030.01 +1352.92 +1 +1030.06 +1376.73 +1 +1030.11 +1373.89 +1 +1030.16 +1427.71 +1 +1030.21 +1426.87 +1 +1030.26 +1481.12 +1 +1030.31 +1499.48 +1 +1030.36 +1465.18 +1 +1030.41 +1526.2 +1 +1030.46 +1531.63 +1 +1030.51 +1530.68 +1 +1030.56 +1558.82 +1 +1030.61 +1578.27 +1 +1030.66 +1606.92 +1 +1030.71 +1658.45 +1 +1030.76 +1627.62 +1 +1030.81 +1707.29 +1 +1030.86 +1783.53 +1 +1030.91 +1789.62 +1 +1030.96 +1818.66 +1 +1031.01 +1794.29 +1 +1031.06 +1841.96 +1 +1031.11 +1842.23 +1 +1031.16 +1919.9 +1 +1031.21 +1996.49 +1 +1031.26 +2097.07 +1 +1031.31 +2098.6 +1 +1031.36 +2159.06 +1 +1031.41 +2191.78 +1 +1031.46 +2365.46 +1 +1031.51 +2365.36 +1 +1031.56 +2361.12 +1 +1031.61 +2539.57 +1 +1031.66 +2612.76 +1 +1031.71 +2578.6 +1 +1031.76 +2815.58 +1 +1031.81 +2917.59 +1 +1031.86 +3025.62 +1 +1031.91 +3160.55 +1 +1031.96 +3234.93 +1 +1032.01 +3381.58 +1 +1032.06 +3530.59 +1 +1032.11 +3778.39 +1 +1032.16 +3966.65 +1 +1032.21 +4160 +1 +1032.26 +4551.55 +1 +1032.31 +4784.78 +1 +1032.36 +5131.12 +1 +1032.41 +5563.98 +1 +1032.46 +5837.79 +1 +1032.51 +6216.12 +1 +1032.56 +6564.46 +1 +1032.61 +6849.11 +1 +1032.66 +7123.46 +1 +1032.71 +7348.28 +1 +1032.76 +7566.48 +1 +1032.81 +7540.43 +1 +1032.86 +7522.43 +1 +1032.91 +7300.02 +1 +1032.96 +7014.46 +1 +1033.01 +6650.6 +1 +1033.06 +6298.39 +1 +1033.11 +5814.3 +1 +1033.16 +5241.1 +1 +1033.21 +4719.32 +1 +1033.26 +4082.49 +1 +1033.31 +3539.61 +1 +1033.36 +2979.52 +1 +1033.41 +2604.1 +1 +1033.46 +2080.86 +1 +1033.51 +1789.26 +1 +1033.56 +1507.07 +1 +1033.61 +1208.84 +1 +1033.66 +1004.87 +1 +1033.71 +840.511 +1 +1033.76 +696.477 +1 +1033.81 +639.592 +1 +1033.86 +534.113 +1 +1033.91 +442.715 +1 +1033.96 +403.622 +1 +1034.01 +325.708 +1 +1034.06 +310.052 +1 +1034.11 +273.502 +1 +1034.16 +251.865 +1 +1034.21 +224.698 +1 +1034.26 +218.158 +1 +1034.31 +189.398 +1 +1034.36 +152.771 +1 +1034.41 +145.057 +1 +1034.46 +158.48 +1 +1034.51 +171.61 +1 +1034.56 +155.34 +1 +1034.61 +126.164 +1 +1034.66 +119.394 +1 +1034.71 +98.7856 +1 +1034.76 +104.416 +1 +1034.81 +102.57 +1 +1034.86 +87.9027 +1 +1034.91 +102.569 +1 +1034.96 +64.2042 +1 +1035.01 +86.0091 +1 +1035.06 +83.7235 +1 +1035.11 +65.2265 +1 +1035.16 +66.9629 +1 +1035.21 +81.7472 +1 +1035.26 +54.5349 +1 +1035.31 +72.9072 +1 +1035.36 +62.729 +1 +1035.41 +54.6963 +1 +1035.46 +52.9836 +1 +1035.51 +51.4427 +1 +1035.56 +66.2454 +1 +1035.61 +27.7958 +1 +1035.66 +22.6612 +1 +1035.71 +47.0201 +1 +1035.76 +48.3473 +1 +1035.81 +31.6776 +1 +1035.86 +42.2973 +1 +1035.91 +39.7689 +1 +1035.96 +43.744 +1 +1036.01 +46.7088 +1 +1036.06 +23.7669 +1 +1036.11 +21.9353 +1 +1036.16 +30.339 +1 +1036.21 +24.5338 +1 +1036.26 +42.0066 +1 +1036.31 +32.2861 +1 +1036.36 +32.8994 +1 +1036.41 +16.5913 +1 +1036.46 +22.0684 +1 +1036.51 +33.4338 +1 +1036.56 +8.30744 +1 +1036.61 +-0.320683 +1 +1036.66 +18.5145 +1 +1036.71 +1.25567 +1 +1036.76 +25.7189 +1 +1036.81 +17.9205 +1 +1036.86 +26.8709 +1 +1036.91 +25.6579 +1 +1036.96 +6.53318 +1 +1037.01 +4.06964 +1 +1037.06 +-1.81192 +1 +1037.11 +-0.175084 +1 +1037.16 +-0.188564 +1 +1037.21 +-11.2699 +1 +1037.26 +-15.6917 +1 +1037.31 +-6.23708 +1 +1037.36 +-6.73301 +1 +1037.41 +-0.235253 +1 +1037.46 +10.3945 +1 +1037.51 +10.0545 +1 +1037.56 +-19.4511 +1 +1037.61 +-5.57347 +1 +1037.66 +-8.28048 +1 +1037.71 +-10.6555 +1 +1037.76 +15.8692 +1 +1037.81 +1.42326 +1 +1037.86 +10.7452 +1 +1037.91 +-15.8064 +1 +1037.96 +4.76975 +1 +1038.01 +-3.04375 +1 +1038.06 +8.44116 +1 +1038.11 +19.9889 +1 +1038.16 +-3.29813 +1 +1038.21 +-3.13742 +1 +1038.26 +9.13695 +1 +1038.31 +-9.16297 +1 +1038.36 +-11.0692 +1 +1038.41 +-16.0218 +1 +1038.46 +-9.66303 +1 +1038.51 +-21.0405 +1 +1038.56 +-8.54283 +1 +1038.61 +4.97534 +1 +1038.66 +-16.1839 +1 +1038.71 +-15.0884 +1 +1038.76 +2.18459 +1 +1038.81 +16.2773 +1 +1038.86 +-4.55229 +1 +1038.91 +-0.530202 +1 +1038.96 +9.59498 +1 +1039.01 +-7.12591 +1 +1039.06 +-11.1653 +1 +1039.11 +-11.6532 +1 +1039.16 +-11.1526 +1 +1039.21 +7.07497 +1 +1039.26 +-12.3676 +1 +1039.31 +-12.9418 +1 +1039.36 +-25.59 +1 +1039.41 +-22.8096 +1 +1039.46 +-4.09079 +1 +1039.51 +-17.3984 +1 +1039.56 +-4.18499 +1 +1039.61 +-8.62249 +1 +1039.66 +-10.5458 +1 +1039.71 +-3.7872 +1 +1039.76 +-11.0384 +1 +1039.81 +-12.3709 +1 +1039.86 +-22.5307 +1 +1039.91 +-13.1936 +1 +1039.96 +-24.3836 +1 +1040.01 +-37.2227 +1 +1040.06 +3.18044 +1 +1040.11 +3.24155 +1 +1040.16 +3.11073 +1 +1040.21 +0 +1 +1040.26 +0 +1 +1040.31 +0 +1 +1040.36 +0 +1 +1040.41 +0 +1 +1040.46 +0 +1 +1040.51 +0 +1 +1040.56 +0 +1 +1040.61 +0 +1 +Ti2p +TiO +0 +0 +0 +0 +0 +0 +0 +14 +Casa Info Follows +0 +0 +0 +0 + +PCA Coefs = 41396.7, -3191.99, 1103.12, 387.504, +PCA Coefs = 41396.7, -3191.99, 1103.12, 387.504, -363.953, +PCA Coefs = 41439, -2585.94, 1104.79, -371.422, -359.987, 128.966, +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +C:\Users\pielsticker\Downloads\Ti\references_irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.61 +0 +1 +986.71 +0 +1 +986.81 +0 +1 +986.91 +0 +1 +987.01 +0 +1 +987.11 +0 +1 +987.21 +0 +1 +987.31 +0 +1 +987.41 +427.081 +1 +987.51 +418.506 +1 +987.61 +421.294 +1 +987.71 +440.148 +1 +987.81 +443.528 +1 +987.91 +430.838 +1 +988.01 +445.739 +1 +988.11 +424.025 +1 +988.21 +434.13 +1 +988.31 +418.792 +1 +988.41 +428.149 +1 +988.51 +454.731 +1 +988.61 +439.937 +1 +988.71 +440.084 +1 +988.81 +432.384 +1 +988.91 +432.304 +1 +989.01 +440.641 +1 +989.11 +446.848 +1 +989.21 +426.341 +1 +989.31 +427.43 +1 +989.41 +433.208 +1 +989.51 +424.875 +1 +989.61 +432.054 +1 +989.71 +420.255 +1 +989.81 +436.188 +1 +989.91 +437.574 +1 +990.01 +442.909 +1 +990.11 +437.73 +1 +990.21 +421.943 +1 +990.31 +412.513 +1 +990.41 +435.891 +1 +990.51 +431.311 +1 +990.61 +432.78 +1 +990.71 +433.572 +1 +990.81 +418.188 +1 +990.91 +409.864 +1 +991.01 +422.085 +1 +991.11 +426.173 +1 +991.21 +444.271 +1 +991.31 +414.74 +1 +991.41 +436.211 +1 +991.51 +426.44 +1 +991.61 +422.63 +1 +991.71 +419.722 +1 +991.81 +433.338 +1 +991.91 +436.796 +1 +992.01 +436.845 +1 +992.11 +430.264 +1 +992.21 +409.348 +1 +992.31 +408.522 +1 +992.41 +437.968 +1 +992.51 +445.551 +1 +992.61 +438.706 +1 +992.71 +442.301 +1 +992.81 +436.554 +1 +992.91 +427.755 +1 +993.01 +444.831 +1 +993.11 +456.361 +1 +993.21 +439.465 +1 +993.31 +450.223 +1 +993.41 +444.027 +1 +993.51 +436.61 +1 +993.61 +442.322 +1 +993.71 +448.84 +1 +993.81 +443.012 +1 +993.91 +447.565 +1 +994.01 +442.503 +1 +994.11 +431.631 +1 +994.21 +441.927 +1 +994.31 +439.397 +1 +994.41 +446.213 +1 +994.51 +436.637 +1 +994.61 +431.379 +1 +994.71 +439.383 +1 +994.81 +437.913 +1 +994.91 +437.081 +1 +995.01 +451.356 +1 +995.11 +441.987 +1 +995.21 +433.982 +1 +995.31 +435.758 +1 +995.41 +438.365 +1 +995.51 +440.249 +1 +995.61 +441.327 +1 +995.71 +470.201 +1 +995.81 +461.681 +1 +995.91 +465.133 +1 +996.01 +457.167 +1 +996.11 +452.422 +1 +996.21 +450.82 +1 +996.31 +465.086 +1 +996.41 +461.236 +1 +996.51 +459.164 +1 +996.61 +447.345 +1 +996.71 +449.258 +1 +996.81 +459.59 +1 +996.91 +458.529 +1 +997.01 +473.17 +1 +997.11 +477.211 +1 +997.21 +459.326 +1 +997.31 +460.033 +1 +997.41 +459.628 +1 +997.51 +445.237 +1 +997.61 +452.9 +1 +997.71 +462.703 +1 +997.81 +459.284 +1 +997.91 +451.872 +1 +998.01 +456.31 +1 +998.11 +469.161 +1 +998.21 +467.634 +1 +998.31 +475.462 +1 +998.41 +474.394 +1 +998.51 +456.623 +1 +998.61 +469.981 +1 +998.71 +480.575 +1 +998.81 +487.905 +1 +998.91 +476.11 +1 +999.01 +472.079 +1 +999.11 +488.889 +1 +999.21 +482.388 +1 +999.31 +473.36 +1 +999.41 +485.498 +1 +999.51 +489.987 +1 +999.61 +486.287 +1 +999.71 +499.989 +1 +999.81 +499.325 +1 +999.91 +503.847 +1 +1000.01 +495.847 +1 +1000.11 +472.305 +1 +1000.21 +495.686 +1 +1000.31 +470.454 +1 +1000.41 +456.9 +1 +1000.51 +470.1 +1 +1000.61 +477.155 +1 +1000.71 +488.566 +1 +1000.81 +501.371 +1 +1000.91 +487.255 +1 +1001.01 +491.032 +1 +1001.11 +485.732 +1 +1001.21 +504.469 +1 +1001.31 +498.971 +1 +1001.41 +487.565 +1 +1001.51 +495.287 +1 +1001.61 +492.023 +1 +1001.71 +515.751 +1 +1001.81 +524.072 +1 +1001.91 +521.562 +1 +1002.01 +511.741 +1 +1002.11 +520.4 +1 +1002.21 +503.72 +1 +1002.31 +510.643 +1 +1002.41 +513.259 +1 +1002.51 +516.99 +1 +1002.61 +517.098 +1 +1002.71 +511.597 +1 +1002.81 +514.602 +1 +1002.91 +518.202 +1 +1003.01 +511.706 +1 +1003.11 +525.184 +1 +1003.21 +517.952 +1 +1003.31 +517.622 +1 +1003.41 +524.306 +1 +1003.51 +508.334 +1 +1003.61 +516.65 +1 +1003.71 +520.695 +1 +1003.81 +527.955 +1 +1003.91 +529.331 +1 +1004.01 +533.794 +1 +1004.11 +532.939 +1 +1004.21 +517.49 +1 +1004.31 +527.727 +1 +1004.41 +538.381 +1 +1004.51 +533.308 +1 +1004.61 +521.561 +1 +1004.71 +544.611 +1 +1004.81 +527.324 +1 +1004.91 +532.448 +1 +1005.01 +570.213 +1 +1005.11 +563.09 +1 +1005.21 +541.792 +1 +1005.31 +542.99 +1 +1005.41 +559.25 +1 +1005.51 +545.665 +1 +1005.61 +543.146 +1 +1005.71 +526.3 +1 +1005.81 +537.531 +1 +1005.91 +572.365 +1 +1006.01 +555.441 +1 +1006.11 +549.727 +1 +1006.21 +551.249 +1 +1006.31 +548.66 +1 +1006.41 +551.261 +1 +1006.51 +563.665 +1 +1006.61 +576.201 +1 +1006.71 +577.334 +1 +1006.81 +567.664 +1 +1006.91 +553.853 +1 +1007.01 +558.785 +1 +1007.11 +584.367 +1 +1007.21 +581.728 +1 +1007.31 +565.461 +1 +1007.41 +575.372 +1 +1007.51 +562.378 +1 +1007.61 +563.918 +1 +1007.71 +558.304 +1 +1007.81 +554.263 +1 +1007.91 +548.855 +1 +1008.01 +560.082 +1 +1008.11 +587.028 +1 +1008.21 +594.404 +1 +1008.31 +582.535 +1 +1008.41 +572.581 +1 +1008.51 +570.811 +1 +1008.61 +557.279 +1 +1008.71 +573.391 +1 +1008.81 +568.03 +1 +1008.91 +560.161 +1 +1009.01 +607.207 +1 +1009.11 +597.167 +1 +1009.21 +578.718 +1 +1009.31 +585.585 +1 +1009.41 +598.421 +1 +1009.51 +580.41 +1 +1009.61 +576.951 +1 +1009.71 +584.575 +1 +1009.81 +563.585 +1 +1009.91 +563.558 +1 +1010.01 +597.413 +1 +1010.11 +592.348 +1 +1010.21 +598.689 +1 +1010.31 +591.048 +1 +1010.41 +575.647 +1 +1010.51 +562.049 +1 +1010.61 +584.689 +1 +1010.71 +613.504 +1 +1010.81 +604.43 +1 +1010.91 +590.102 +1 +1011.01 +598.673 +1 +1011.11 +597.336 +1 +1011.21 +592.662 +1 +1011.31 +580.7 +1 +1011.41 +584.009 +1 +1011.51 +612.752 +1 +1011.61 +604.978 +1 +1011.71 +591.136 +1 +1011.81 +582.187 +1 +1011.91 +581.801 +1 +1012.01 +583.193 +1 +1012.11 +607.547 +1 +1012.21 +625.368 +1 +1012.31 +616.005 +1 +1012.41 +610.544 +1 +1012.51 +606.481 +1 +1012.61 +612.489 +1 +1012.71 +611.253 +1 +1012.81 +586.851 +1 +1012.91 +623.68 +1 +1013.01 +621.663 +1 +1013.11 +618.895 +1 +1013.21 +600.995 +1 +1013.31 +597.049 +1 +1013.41 +591.93 +1 +1013.51 +595.137 +1 +1013.61 +603.223 +1 +1013.71 +596.239 +1 +1013.81 +587.085 +1 +1013.91 +584.361 +1 +1014.01 +619.158 +1 +1014.11 +618.527 +1 +1014.21 +619.188 +1 +1014.31 +606.433 +1 +1014.41 +602.386 +1 +1014.51 +600.324 +1 +1014.61 +589.299 +1 +1014.71 +577.321 +1 +1014.81 +579.679 +1 +1014.91 +594.519 +1 +1015.01 +606.455 +1 +1015.11 +603.592 +1 +1015.21 +592.769 +1 +1015.31 +592.667 +1 +1015.41 +597.347 +1 +1015.51 +598.124 +1 +1015.61 +613.572 +1 +1015.61 +613.572 +1 +1015.66 +606.643 +1 +1015.71 +596.493 +1 +1015.71 +596.493 +1 +1015.76 +589.147 +1 +1015.81 +588.693 +1 +1015.81 +588.693 +1 +1015.86 +579.432 +1 +1015.91 +581.863 +1 +1015.91 +581.863 +1 +1015.96 +590.761 +1 +1016.01 +606.759 +1 +1016.01 +606.759 +1 +1016.06 +609.806 +1 +1016.11 +596.144 +1 +1016.11 +596.144 +1 +1016.16 +592.706 +1 +1016.21 +598.696 +1 +1016.21 +598.696 +1 +1016.26 +611.189 +1 +1016.31 +606.286 +1 +1016.31 +606.286 +1 +1016.36 +599.476 +1 +1016.41 +595.682 +1 +1016.41 +595.682 +1 +1016.46 +596.852 +1 +1016.51 +597.099 +1 +1016.51 +597.099 +1 +1016.56 +598.501 +1 +1016.61 +605.691 +1 +1016.61 +605.691 +1 +1016.66 +610.47 +1 +1016.71 +593.859 +1 +1016.76 +587.774 +1 +1016.81 +596.403 +1 +1016.86 +606.607 +1 +1016.91 +594.915 +1 +1016.96 +590.241 +1 +1017.01 +587.636 +1 +1017.06 +593.328 +1 +1017.11 +606.761 +1 +1017.16 +614.115 +1 +1017.21 +607.689 +1 +1017.26 +606.91 +1 +1017.31 +604.424 +1 +1017.36 +602.25 +1 +1017.41 +596.921 +1 +1017.46 +598.695 +1 +1017.51 +596.989 +1 +1017.56 +616.919 +1 +1017.61 +630.31 +1 +1017.66 +622.391 +1 +1017.71 +607.099 +1 +1017.76 +595.336 +1 +1017.81 +587.203 +1 +1017.86 +595.983 +1 +1017.91 +605.75 +1 +1017.96 +615.677 +1 +1018.01 +625.619 +1 +1018.06 +613.386 +1 +1018.11 +605.926 +1 +1018.16 +617.972 +1 +1018.21 +625.144 +1 +1018.26 +622.84 +1 +1018.31 +627.313 +1 +1018.36 +632.35 +1 +1018.41 +632.086 +1 +1018.46 +627.843 +1 +1018.51 +633.444 +1 +1018.56 +634.983 +1 +1018.61 +644.948 +1 +1018.66 +640.885 +1 +1018.71 +636.764 +1 +1018.76 +635.98 +1 +1018.81 +641.379 +1 +1018.86 +635.21 +1 +1018.91 +637.855 +1 +1018.96 +640.268 +1 +1019.01 +636.099 +1 +1019.06 +639.37 +1 +1019.11 +652.623 +1 +1019.16 +650.936 +1 +1019.21 +641.447 +1 +1019.26 +633.369 +1 +1019.31 +632.682 +1 +1019.36 +655.528 +1 +1019.41 +663.565 +1 +1019.46 +641.491 +1 +1019.51 +635.212 +1 +1019.56 +654.307 +1 +1019.61 +660.336 +1 +1019.66 +646.061 +1 +1019.71 +633.939 +1 +1019.76 +636.468 +1 +1019.81 +654.36 +1 +1019.86 +662.07 +1 +1019.91 +664.706 +1 +1019.96 +657.652 +1 +1020.01 +659.696 +1 +1020.06 +670.068 +1 +1020.11 +657.005 +1 +1020.16 +642.071 +1 +1020.21 +639.889 +1 +1020.26 +652.869 +1 +1020.31 +647.107 +1 +1020.36 +646.274 +1 +1020.41 +650.887 +1 +1020.46 +642.982 +1 +1020.51 +650.078 +1 +1020.56 +652.998 +1 +1020.61 +647.973 +1 +1020.66 +644.93 +1 +1020.71 +642.48 +1 +1020.76 +645.896 +1 +1020.81 +641.294 +1 +1020.86 +639.946 +1 +1020.91 +621.76 +1 +1020.96 +612.865 +1 +1021.01 +633.689 +1 +1021.06 +650.912 +1 +1021.11 +641.391 +1 +1021.16 +635.865 +1 +1021.21 +642.629 +1 +1021.26 +630.395 +1 +1021.31 +625.183 +1 +1021.36 +619.537 +1 +1021.41 +597.361 +1 +1021.46 +601.796 +1 +1021.51 +611.948 +1 +1021.56 +614.391 +1 +1021.61 +603.574 +1 +1021.66 +597.574 +1 +1021.71 +611.698 +1 +1021.76 +624.68 +1 +1021.81 +606.544 +1 +1021.86 +602.935 +1 +1021.91 +598.509 +1 +1021.96 +596.883 +1 +1022.01 +611.599 +1 +1022.06 +620.342 +1 +1022.11 +613.523 +1 +1022.16 +604.326 +1 +1022.21 +590.066 +1 +1022.26 +600.494 +1 +1022.31 +606.824 +1 +1022.36 +609.488 +1 +1022.41 +613.648 +1 +1022.46 +625.965 +1 +1022.51 +630.209 +1 +1022.56 +631.693 +1 +1022.61 +631.426 +1 +1022.66 +622.286 +1 +1022.71 +616.234 +1 +1022.76 +624.195 +1 +1022.81 +617.276 +1 +1022.86 +615.601 +1 +1022.91 +612.854 +1 +1022.96 +614.498 +1 +1023.01 +619.12 +1 +1023.06 +616.276 +1 +1023.11 +616.27 +1 +1023.16 +627.49 +1 +1023.21 +630.329 +1 +1023.26 +633.982 +1 +1023.31 +642.111 +1 +1023.36 +653.565 +1 +1023.41 +661.154 +1 +1023.46 +658.673 +1 +1023.51 +649.041 +1 +1023.56 +654.01 +1 +1023.61 +653.472 +1 +1023.66 +659.6 +1 +1023.71 +672.917 +1 +1023.76 +696.757 +1 +1023.81 +699.632 +1 +1023.86 +700.605 +1 +1023.91 +722.662 +1 +1023.96 +721.115 +1 +1024.01 +707.336 +1 +1024.06 +716.577 +1 +1024.11 +724.502 +1 +1024.16 +727.607 +1 +1024.21 +738.511 +1 +1024.26 +744.571 +1 +1024.31 +762.687 +1 +1024.36 +782.149 +1 +1024.41 +786.671 +1 +1024.46 +807.825 +1 +1024.51 +843.475 +1 +1024.56 +852.08 +1 +1024.61 +861.424 +1 +1024.66 +889.127 +1 +1024.71 +917.206 +1 +1024.76 +947.463 +1 +1024.81 +972.005 +1 +1024.86 +998.212 +1 +1024.91 +1028.03 +1 +1024.96 +1074.52 +1 +1025.01 +1085.06 +1 +1025.06 +1104.14 +1 +1025.11 +1127.84 +1 +1025.16 +1146.89 +1 +1025.21 +1180.85 +1 +1025.26 +1204.02 +1 +1025.31 +1205.46 +1 +1025.36 +1228.78 +1 +1025.41 +1242.28 +1 +1025.46 +1263.49 +1 +1025.51 +1289.05 +1 +1025.56 +1297.93 +1 +1025.61 +1306.35 +1 +1025.66 +1306.82 +1 +1025.71 +1311.04 +1 +1025.76 +1297.79 +1 +1025.81 +1283.7 +1 +1025.86 +1305.61 +1 +1025.91 +1318.77 +1 +1025.96 +1311.91 +1 +1026.01 +1291.32 +1 +1026.06 +1278.79 +1 +1026.11 +1281.26 +1 +1026.16 +1258.34 +1 +1026.21 +1239.21 +1 +1026.26 +1226.52 +1 +1026.31 +1203.76 +1 +1026.36 +1180.8 +1 +1026.41 +1158.37 +1 +1026.46 +1107.57 +1 +1026.51 +1078.51 +1 +1026.56 +1053.42 +1 +1026.61 +1020.15 +1 +1026.66 +966.384 +1 +1026.71 +928.974 +1 +1026.76 +914.815 +1 +1026.81 +889.388 +1 +1026.86 +853.786 +1 +1026.91 +824.393 +1 +1026.96 +813.064 +1 +1027.01 +792 +1 +1027.06 +751.093 +1 +1027.11 +714.097 +1 +1027.16 +710.105 +1 +1027.21 +695.528 +1 +1027.26 +684.222 +1 +1027.31 +685.561 +1 +1027.36 +684.72 +1 +1027.41 +668.26 +1 +1027.46 +627.587 +1 +1027.51 +631.47 +1 +1027.56 +658.623 +1 +1027.61 +637.027 +1 +1027.66 +642.104 +1 +1027.71 +640.778 +1 +1027.76 +633.631 +1 +1027.81 +634.57 +1 +1027.86 +628.873 +1 +1027.91 +618.156 +1 +1027.96 +612.279 +1 +1028.01 +599.723 +1 +1028.06 +604.039 +1 +1028.11 +629.057 +1 +1028.16 +642.082 +1 +1028.21 +620.889 +1 +1028.26 +622.357 +1 +1028.31 +629.837 +1 +1028.36 +619.895 +1 +1028.41 +622.267 +1 +1028.46 +622.023 +1 +1028.51 +620.128 +1 +1028.56 +625.951 +1 +1028.61 +631.855 +1 +1028.66 +614.199 +1 +1028.71 +614.635 +1 +1028.76 +617.21 +1 +1028.81 +598.893 +1 +1028.86 +610.767 +1 +1028.91 +628.933 +1 +1028.96 +626.956 +1 +1029.01 +613.245 +1 +1029.06 +614.639 +1 +1029.11 +626.144 +1 +1029.16 +625.542 +1 +1029.21 +628.511 +1 +1029.26 +632.868 +1 +1029.31 +627.299 +1 +1029.36 +619.494 +1 +1029.41 +627.466 +1 +1029.46 +630.058 +1 +1029.51 +638.279 +1 +1029.56 +659.878 +1 +1029.61 +656.9 +1 +1029.66 +646.594 +1 +1029.71 +664.871 +1 +1029.76 +683.659 +1 +1029.81 +682.119 +1 +1029.86 +681.045 +1 +1029.91 +691.803 +1 +1029.96 +706.242 +1 +1030.01 +711.438 +1 +1030.06 +706.374 +1 +1030.11 +722.547 +1 +1030.16 +762.85 +1 +1030.21 +779.71 +1 +1030.26 +796.785 +1 +1030.31 +818.387 +1 +1030.36 +819.516 +1 +1030.41 +841.578 +1 +1030.46 +865.099 +1 +1030.51 +869.894 +1 +1030.56 +900.825 +1 +1030.61 +953.821 +1 +1030.66 +976.082 +1 +1030.71 +1014.67 +1 +1030.76 +1053.07 +1 +1030.81 +1098.15 +1 +1030.86 +1141.38 +1 +1030.91 +1180.55 +1 +1030.96 +1223.69 +1 +1031.01 +1290.65 +1 +1031.06 +1350.41 +1 +1031.11 +1413.9 +1 +1031.16 +1470.94 +1 +1031.21 +1522.83 +1 +1031.26 +1606.21 +1 +1031.31 +1683.65 +1 +1031.36 +1750.5 +1 +1031.41 +1805.37 +1 +1031.46 +1844.15 +1 +1031.51 +1882.09 +1 +1031.56 +1911.79 +1 +1031.61 +1937.36 +1 +1031.66 +1935.1 +1 +1031.71 +1902.05 +1 +1031.76 +1867.2 +1 +1031.81 +1820.49 +1 +1031.86 +1769.3 +1 +1031.91 +1733.01 +1 +1031.96 +1703.26 +1 +1032.01 +1674.2 +1 +1032.06 +1627.17 +1 +1032.11 +1594.21 +1 +1032.16 +1564.9 +1 +1032.21 +1532.43 +1 +1032.26 +1480 +1 +1032.31 +1412.55 +1 +1032.36 +1341.55 +1 +1032.41 +1276.98 +1 +1032.46 +1208.53 +1 +1032.51 +1103.07 +1 +1032.56 +991.97 +1 +1032.61 +898.867 +1 +1032.66 +801.315 +1 +1032.71 +693.039 +1 +1032.76 +607.106 +1 +1032.81 +524.306 +1 +1032.86 +430.964 +1 +1032.91 +360.997 +1 +1032.96 +316.891 +1 +1033.01 +265.384 +1 +1033.06 +218.663 +1 +1033.11 +184.599 +1 +1033.16 +163.276 +1 +1033.21 +146.727 +1 +1033.26 +128.282 +1 +1033.31 +115.72 +1 +1033.36 +102.206 +1 +1033.41 +84.3599 +1 +1033.46 +76.3419 +1 +1033.51 +73.258 +1 +1033.56 +68.9179 +1 +1033.61 +65.1807 +1 +1033.66 +56.2314 +1 +1033.71 +49.6746 +1 +1033.76 +52.1579 +1 +1033.81 +49.7747 +1 +1033.86 +46.0503 +1 +1033.91 +36.4411 +1 +1033.96 +29.5619 +1 +1034.01 +32.4556 +1 +1034.06 +32.9876 +1 +1034.11 +31.6081 +1 +1034.16 +31.8027 +1 +1034.21 +33.807 +1 +1034.26 +35.8312 +1 +1034.31 +29.7257 +1 +1034.36 +24.3449 +1 +1034.41 +21.9194 +1 +1034.46 +25.1065 +1 +1034.51 +30.7035 +1 +1034.56 +28.6187 +1 +1034.61 +21.3205 +1 +1034.66 +24.2862 +1 +1034.71 +23.786 +1 +1034.76 +21.619 +1 +1034.81 +17.8064 +1 +1034.86 +16.3473 +1 +1034.91 +18.0522 +1 +1034.96 +20.8006 +1 +1035.01 +20.7355 +1 +1035.06 +19.2328 +1 +1035.11 +13.6358 +1 +1035.16 +14.2518 +1 +1035.21 +12.7428 +1 +1035.26 +11.468 +1 +1035.31 +9.25257 +1 +1035.36 +11.8099 +1 +1035.41 +17.8825 +1 +1035.46 +22.5386 +1 +1035.51 +21.1059 +1 +1035.56 +18.5313 +1 +1035.61 +16.1824 +1 +1035.66 +14.0897 +1 +1035.71 +17.0204 +1 +1035.76 +14.6167 +1 +1035.81 +9.60597 +1 +1035.86 +9.16277 +1 +1035.91 +11.145 +1 +1035.96 +9.83835 +1 +1036.01 +12.7076 +1 +1036.06 +14.9464 +1 +1036.11 +16.3768 +1 +1036.16 +13.8208 +1 +1036.21 +9.75438 +1 +1036.26 +6.88693 +1 +1036.31 +6.69721 +1 +1036.36 +8.23845 +1 +1036.41 +7.37087 +1 +1036.46 +6.43268 +1 +1036.51 +5.21011 +1 +1036.56 +4.52699 +1 +1036.61 +8.72831 +1 +1036.66 +9.3681 +1 +1036.71 +3.6229 +1 +1036.76 +3.03928 +1 +1036.81 +3.17743 +1 +1036.86 +4.20203 +1 +1036.91 +1.47699 +1 +1036.96 +6.18683 +1 +1037.01 +9.76206 +1 +1037.06 +7.32739 +1 +1037.11 +5.90447 +1 +1037.16 +5.52773 +1 +1037.21 +5.99246 +1 +1037.26 +1.44937 +1 +1037.31 +3.90965 +1 +1037.36 +6.36227 +1 +1037.41 +5.08157 +1 +1037.46 +4.98903 +1 +1037.51 +6.53262 +1 +1037.56 +7.41351 +1 +1037.61 +6.63376 +1 +1037.66 +5.79297 +1 +1037.71 +4.39155 +1 +1037.76 +4.02456 +1 +1037.81 +0.0817091 +1 +1037.86 +-1.30378 +1 +1037.91 +-0.488158 +1 +1037.96 +2.33727 +1 +1038.01 +3.97329 +1 +1038.06 +0.00398757 +1 +1038.11 +1.92559 +1 +1038.16 +7.03095 +1 +1038.21 +5.79007 +1 +1038.26 +2.50004 +1 +1038.31 +2.19749 +1 +1038.36 +0.677344 +1 +1038.41 +-0.0809204 +1 +1038.46 +1.75695 +1 +1038.51 +4.7773 +1 +1038.56 +4.94552 +1 +1038.61 +8.75129 +1 +1038.66 +8.18276 +1 +1038.71 +3.21884 +1 +1038.76 +0.187503 +1 +1038.81 +-1.35327 +1 +1038.86 +2.13401 +1 +1038.91 +-1.81348 +1 +1038.96 +0.645525 +1 +1039.01 +1.8464 +1 +1039.06 +-1.18018 +1 +1039.11 +3.18172 +1 +1039.16 +5.59011 +1 +1039.21 +1.00807 +1 +1039.26 +-1.82137 +1 +1039.31 +0 +1 +1039.36 +0 +1 +1039.41 +0 +1 +1039.46 +0 +1 +1039.51 +0 +1 +1039.56 +0 +1 +1039.61 +0 +1 +1039.66 +0 +1 +1039.71 +0 +1 +1039.76 +0 +1 +1039.81 +0 +1 +1039.86 +0 +1 +1039.91 +0 +1 +1039.96 +0 +1 +1040.01 +0 +1 +1040.06 +0 +1 +1040.11 +0 +1 +1040.16 +0 +1 +1040.21 +0 +1 +1040.26 +0 +1 +1040.31 +0 +1 +1040.36 +0 +1 +1040.41 +0 +1 +1040.46 +0 +1 +1040.51 +0 +1 +1040.56 +0 +1 +1040.61 +0 +1 +Ti2p +Ti2O3 +0 +0 +0 +0 +0 +0 +0 +13 +Casa Info Follows +0 +0 +0 +0 + +PCA Coefs = 179186, -26548.4, -22890.8, 3691.07, -1602.46, -1706.5, +C:\Users\Mark\ownCloud\Muelheim Group\Projects\TiO2\analyzed data\EX209_CEC303 Ti slow oxidation - curated - irregular.vms +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +CasaXP2 +C:\Users\pielsticker\Downloads\Ti\references_irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.61 +0 +1 +986.71 +0 +1 +986.81 +0 +1 +986.91 +0 +1 +987.01 +0 +1 +987.11 +2534.66 +1 +987.21 +2537.49 +1 +987.31 +2540.32 +1 +987.41 +2543.17 +1 +987.51 +2546.02 +1 +987.61 +2548.86 +1 +987.71 +2551.71 +1 +987.81 +2554.57 +1 +987.91 +2557.43 +1 +988.01 +2560.29 +1 +988.11 +2563.15 +1 +988.21 +2566.02 +1 +988.31 +2568.89 +1 +988.41 +2571.77 +1 +988.51 +2574.65 +1 +988.61 +2577.53 +1 +988.71 +2580.42 +1 +988.81 +2583.31 +1 +988.91 +2586.21 +1 +989.01 +2589.1 +1 +989.11 +2592.01 +1 +989.21 +2594.92 +1 +989.31 +2597.83 +1 +989.41 +2600.73 +1 +989.51 +2603.65 +1 +989.61 +2606.58 +1 +989.71 +2609.5 +1 +989.81 +2612.43 +1 +989.91 +2615.4 +1 +990.01 +2618.6 +1 +990.11 +2621.8 +1 +990.21 +2625 +1 +990.31 +2628.21 +1 +990.41 +2631.42 +1 +990.51 +2634.65 +1 +990.61 +2637.87 +1 +990.71 +2641.09 +1 +990.81 +2644.32 +1 +990.91 +2647.56 +1 +991.01 +2650.81 +1 +991.11 +2654.05 +1 +991.21 +2657.29 +1 +991.31 +2660.55 +1 +991.41 +2663.82 +1 +991.51 +2667.08 +1 +991.61 +2670.34 +1 +991.71 +2673.62 +1 +991.81 +2676.9 +1 +991.91 +2680.19 +1 +992.01 +2683.47 +1 +992.11 +2686.76 +1 +992.21 +2690.07 +1 +992.31 +2693.38 +1 +992.41 +2696.69 +1 +992.51 +2699.99 +1 +992.61 +2703.32 +1 +992.71 +2706.66 +1 +992.81 +2709.99 +1 +992.91 +2713.33 +1 +993.01 +2716.67 +1 +993.11 +2720.03 +1 +993.21 +2723.39 +1 +993.31 +2726.96 +1 +993.41 +2730.67 +1 +993.51 +2734.4 +1 +993.61 +2738.13 +1 +993.71 +2741.86 +1 +993.81 +2745.59 +1 +993.91 +2749.35 +1 +994.01 +2753.1 +1 +994.11 +2756.86 +1 +994.21 +2760.62 +1 +994.31 +2764.39 +1 +994.41 +2768.17 +1 +994.51 +2771.96 +1 +994.61 +2775.74 +1 +994.71 +2779.53 +1 +994.81 +2783.35 +1 +994.91 +2787.17 +1 +995.01 +2790.99 +1 +995.11 +2794.8 +1 +995.21 +2798.64 +1 +995.31 +2802.49 +1 +995.41 +2806.34 +1 +995.51 +2810.19 +1 +995.61 +2814.04 +1 +995.71 +2817.92 +1 +995.81 +2821.8 +1 +995.91 +2825.68 +1 +996.01 +2829.55 +1 +996.11 +2833.46 +1 +996.21 +2837.37 +1 +996.31 +2841.28 +1 +996.41 +2845.19 +1 +996.51 +2849.12 +1 +996.61 +2853.09 +1 +996.71 +2857.46 +1 +996.81 +2861.84 +1 +996.91 +2866.23 +1 +997.01 +2870.65 +1 +997.11 +2875.06 +1 +997.21 +2879.48 +1 +997.31 +2883.9 +1 +997.41 +2888.34 +1 +997.51 +2892.79 +1 +997.61 +2897.24 +1 +997.71 +2901.69 +1 +997.81 +2906.16 +1 +997.91 +2910.65 +1 +998.01 +2915.13 +1 +998.11 +2919.62 +1 +998.21 +2924.11 +1 +998.31 +2926.65 +1 +998.41 +2931.18 +1 +998.51 +2935.73 +1 +998.61 +2940.28 +1 +998.71 +2944.89 +1 +998.81 +2949.51 +1 +998.91 +2954.15 +1 +999.01 +2958.8 +1 +999.11 +2963.5 +1 +999.21 +2968.22 +1 +999.31 +2972.97 +1 +999.41 +2977.73 +1 +999.51 +2982.5 +1 +999.61 +2987.33 +1 +999.71 +2992.17 +1 +999.81 +2997.02 +1 +999.91 +3001.89 +1 +1000.01 +3006.8 +1 +1000.11 +3011.74 +1 +1000.21 +3016.69 +1 +1000.31 +3021.66 +1 +1000.41 +3026.65 +1 +1000.51 +3031.69 +1 +1000.61 +3036.74 +1 +1000.71 +3041.8 +1 +1000.81 +3046.88 +1 +1000.91 +3052.02 +1 +1001.01 +3057.17 +1 +1001.11 +3062.33 +1 +1001.21 +3067.52 +1 +1001.31 +3072.75 +1 +1001.41 +3078.01 +1 +1001.51 +3083.29 +1 +1001.61 +3088.58 +1 +1001.71 +3093.9 +1 +1001.81 +3099.26 +1 +1001.91 +3104.64 +1 +1002.01 +3110.03 +1 +1002.11 +3115.44 +1 +1002.21 +3120.89 +1 +1002.31 +3126.36 +1 +1002.41 +3131.85 +1 +1002.51 +3137.36 +1 +1002.61 +3142.9 +1 +1002.71 +3148.46 +1 +1002.81 +3154.05 +1 +1002.91 +3159.64 +1 +1003.01 +3165.27 +1 +1003.11 +3170.93 +1 +1003.21 +3176.6 +1 +1003.31 +3182.29 +1 +1003.41 +3188.03 +1 +1003.51 +3193.8 +1 +1003.61 +3199.59 +1 +1003.71 +3205.4 +1 +1003.81 +3211.23 +1 +1003.91 +3217.08 +1 +1004.01 +3222.96 +1 +1004.11 +3228.85 +1 +1004.21 +3234.76 +1 +1004.31 +3240.69 +1 +1004.41 +3246.65 +1 +1004.51 +3252.63 +1 +1004.61 +3258.62 +1 +1004.71 +3264.63 +1 +1004.81 +3270.66 +1 +1004.91 +3276.72 +1 +1005.01 +3282.79 +1 +1005.11 +3288.87 +1 +1005.21 +3294.97 +1 +1005.31 +3301.09 +1 +1005.41 +3307.23 +1 +1005.51 +3313.4 +1 +1005.61 +3319.62 +1 +1005.71 +3325.85 +1 +1005.81 +3332.09 +1 +1005.91 +3338.35 +1 +1006.01 +3344.63 +1 +1006.11 +3350.92 +1 +1006.21 +3357.21 +1 +1006.31 +3363.53 +1 +1006.41 +3369.85 +1 +1006.51 +3376.19 +1 +1006.61 +3382.36 +1 +1006.71 +3388.72 +1 +1006.81 +3395.09 +1 +1006.91 +3401.48 +1 +1007.01 +3407.85 +1 +1007.11 +3414.25 +1 +1007.21 +3420.66 +1 +1007.31 +3427.09 +1 +1007.41 +3433.51 +1 +1007.51 +3439.92 +1 +1007.61 +3446.36 +1 +1007.71 +3452.82 +1 +1007.81 +3459.27 +1 +1007.91 +3465.69 +1 +1008.01 +3472.13 +1 +1008.11 +3478.59 +1 +1008.21 +3485.07 +1 +1008.31 +3491.48 +1 +1008.41 +3497.9 +1 +1008.51 +3504.34 +1 +1008.61 +3510.8 +1 +1008.71 +3517.21 +1 +1008.81 +3523.58 +1 +1008.91 +3529.97 +1 +1009.01 +3536.38 +1 +1009.11 +3542.78 +1 +1009.21 +3549.05 +1 +1009.31 +3555.35 +1 +1009.41 +3561.67 +1 +1009.51 +3568.02 +1 +1009.61 +3574.18 +1 +1009.71 +3580.33 +1 +1009.81 +3586.51 +1 +1009.91 +3592.71 +1 +1010.01 +3598.78 +1 +1010.11 +3604.71 +1 +1010.21 +3610.67 +1 +1010.31 +3616.66 +1 +1010.41 +3622.61 +1 +1010.51 +3628.23 +1 +1010.61 +3633.89 +1 +1010.71 +3639.57 +1 +1010.81 +3645.28 +1 +1010.91 +3650.59 +1 +1011.01 +3655.82 +1 +1011.11 +3661.07 +1 +1011.21 +3666.36 +1 +1011.31 +3671.39 +1 +1011.41 +3676.05 +1 +1011.51 +3680.74 +1 +1011.61 +3685.47 +1 +1011.71 +3690.17 +1 +1011.81 +3694.09 +1 +1011.91 +3698.04 +1 +1012.01 +3702.04 +1 +1012.11 +3706.07 +1 +1012.21 +3709.35 +1 +1012.31 +3712.37 +1 +1012.41 +3715.43 +1 +1012.51 +3718.54 +1 +1012.61 +3721.21 +1 +1012.71 +3723.06 +1 +1012.81 +3724.96 +1 +1012.91 +3726.92 +1 +1013.01 +3728.93 +1 +1013.11 +3729.37 +1 +1013.21 +3729.87 +1 +1013.31 +3730.44 +1 +1013.41 +3731.07 +1 +1013.51 +3730.56 +1 +1013.61 +3729.43 +1 +1013.71 +3728.37 +1 +1013.81 +3727.39 +1 +1013.91 +3725.88 +1 +1014.01 +3722.88 +1 +1014.11 +3719.97 +1 +1014.21 +3717.16 +1 +1014.31 +3714.45 +1 +1014.41 +3709.61 +1 +1014.51 +3704.68 +1 +1014.61 +3699.88 +1 +1014.71 +3695.2 +1 +1014.81 +3689.16 +1 +1014.91 +3682.1 +1 +1015.01 +3675.2 +1 +1015.11 +3668.45 +1 +1015.21 +3661.3 +1 +1015.31 +3652.12 +1 +1015.41 +3643.14 +1 +1015.51 +3634.37 +1 +1015.61 +3625.84 +1 +1015.61 +3625.84 +1 +1015.66 +3620.66 +1 +1015.71 +3615.11 +1 +1015.71 +3615.11 +1 +1015.76 +3609.62 +1 +1015.81 +3604.19 +1 +1015.81 +3604.19 +1 +1015.86 +3598.85 +1 +1015.91 +3593.58 +1 +1015.91 +3593.58 +1 +1015.96 +3588.38 +1 +1016.01 +3583.28 +1 +1016.01 +3583.28 +1 +1016.06 +3578.25 +1 +1016.11 +3571.92 +1 +1016.11 +3571.92 +1 +1016.16 +3565.64 +1 +1016.21 +3559.45 +1 +1016.21 +3559.45 +1 +1016.26 +3553.38 +1 +1016.31 +3547.41 +1 +1016.31 +3547.41 +1 +1016.36 +3541.56 +1 +1016.41 +3535.81 +1 +1016.41 +3535.81 +1 +1016.46 +3530.19 +1 +1016.51 +3524.34 +1 +1016.51 +3524.34 +1 +1016.56 +3517.6 +1 +1016.61 +3511.01 +1 +1016.61 +3511.01 +1 +1016.66 +3504.55 +1 +1016.71 +3498.24 +1 +1016.76 +3492.09 +1 +1016.81 +3486.1 +1 +1016.86 +3480.28 +1 +1016.91 +3474.63 +1 +1016.96 +3468.5 +1 +1017.01 +3461.97 +1 +1017.06 +3455.65 +1 +1017.11 +3449.55 +1 +1017.16 +3443.66 +1 +1017.21 +3438.03 +1 +1017.26 +3432.65 +1 +1017.31 +3427.55 +1 +1017.36 +3422.73 +1 +1017.41 +3417.27 +1 +1017.46 +3411.93 +1 +1017.51 +3406.89 +1 +1017.56 +3402.17 +1 +1017.61 +3397.8 +1 +1017.66 +3393.78 +1 +1017.71 +3390.14 +1 +1017.76 +3386.89 +1 +1017.81 +3383.95 +1 +1017.86 +3380.66 +1 +1017.91 +3377.82 +1 +1017.96 +3375.46 +1 +1018.01 +3373.58 +1 +1018.06 +3372.22 +1 +1018.11 +3371.39 +1 +1018.16 +3371.11 +1 +1018.21 +3371.43 +1 +1018.26 +3372.1 +1 +1018.31 +3373 +1 +1018.36 +3374.57 +1 +1018.41 +3376.8 +1 +1018.46 +3379.75 +1 +1018.51 +3383.45 +1 +1018.56 +3387.95 +1 +1018.61 +3393.25 +1 +1018.66 +3399.36 +1 +1018.71 +3406.04 +1 +1018.76 +3413.45 +1 +1018.81 +3421.76 +1 +1018.86 +3431.01 +1 +1018.91 +3441.2 +1 +1018.96 +3452.41 +1 +1019.01 +3464.61 +1 +1019.06 +3477.86 +1 +1019.11 +3492.19 +1 +1019.16 +3507.44 +1 +1019.21 +3523.9 +1 +1019.26 +3541.56 +1 +1019.31 +3560.42 +1 +1019.36 +3580.48 +1 +1019.41 +3601.75 +1 +1019.46 +3624.26 +1 +1019.51 +3648.01 +1 +1019.56 +3673.04 +1 +1019.61 +3699.4 +1 +1019.66 +3727.03 +1 +1019.71 +3755.98 +1 +1019.76 +3786.21 +1 +1019.81 +3817.74 +1 +1019.86 +3850.68 +1 +1019.91 +3884.92 +1 +1019.96 +3920.46 +1 +1020.01 +3957.41 +1 +1020.06 +3995.78 +1 +1020.11 +4035.38 +1 +1020.16 +4076.21 +1 +1020.21 +4118.22 +1 +1020.26 +4161.53 +1 +1020.31 +4206.02 +1 +1020.36 +4251.59 +1 +1020.41 +4298.2 +1 +1020.46 +4346.19 +1 +1020.51 +4395.27 +1 +1020.56 +4445.24 +1 +1020.61 +4496.01 +1 +1020.66 +4547.51 +1 +1020.71 +4599.65 +1 +1020.76 +4651.63 +1 +1020.81 +4704.83 +1 +1020.86 +4758.52 +1 +1020.91 +4813.16 +1 +1020.96 +4868.01 +1 +1021.01 +4923.03 +1 +1021.06 +4978.03 +1 +1021.11 +5032.97 +1 +1021.16 +5087.71 +1 +1021.21 +5142.11 +1 +1021.26 +5196.1 +1 +1021.31 +5249.77 +1 +1021.36 +5303.31 +1 +1021.41 +5356.04 +1 +1021.46 +5407.82 +1 +1021.51 +5458.61 +1 +1021.56 +5508.13 +1 +1021.61 +5556.41 +1 +1021.66 +5603.24 +1 +1021.71 +5648.51 +1 +1021.76 +5692.75 +1 +1021.81 +5735.41 +1 +1021.86 +5776.08 +1 +1021.91 +5814.66 +1 +1021.96 +5851.07 +1 +1022.01 +5885.27 +1 +1022.06 +5916.99 +1 +1022.11 +5946.31 +1 +1022.16 +5973 +1 +1022.21 +5997.95 +1 +1022.26 +6020.28 +1 +1022.31 +6039.67 +1 +1022.36 +6056.29 +1 +1022.41 +6069.86 +1 +1022.46 +6080.45 +1 +1022.51 +6087.81 +1 +1022.56 +6091.92 +1 +1022.61 +6093.25 +1 +1022.66 +6092.13 +1 +1022.71 +6087.92 +1 +1022.76 +6080.6 +1 +1022.81 +6070.03 +1 +1022.86 +6056.48 +1 +1022.91 +6039.72 +1 +1022.96 +6019.98 +1 +1023.01 +5997.27 +1 +1023.06 +5972.05 +1 +1023.11 +5944.62 +1 +1023.16 +5914.08 +1 +1023.21 +5880.87 +1 +1023.26 +5845.08 +1 +1023.31 +5806.76 +1 +1023.36 +5766.23 +1 +1023.41 +5723.32 +1 +1023.46 +5678.44 +1 +1023.51 +5632.41 +1 +1023.56 +5584.79 +1 +1023.61 +5535.69 +1 +1023.66 +5484.99 +1 +1023.71 +5433.15 +1 +1023.76 +5380.23 +1 +1023.81 +5326.34 +1 +1023.86 +5271.83 +1 +1023.91 +5216.77 +1 +1023.96 +5162.51 +1 +1024.01 +5108.2 +1 +1024.06 +5054.09 +1 +1024.11 +5000.49 +1 +1024.16 +4947.42 +1 +1024.21 +4895.34 +1 +1024.26 +4844.33 +1 +1024.31 +4794.67 +1 +1024.36 +4746.97 +1 +1024.41 +4701.6 +1 +1024.46 +4658.34 +1 +1024.51 +4617.33 +1 +1024.56 +4578.85 +1 +1024.61 +4543.15 +1 +1024.66 +4510.37 +1 +1024.71 +4480.83 +1 +1024.76 +4454.66 +1 +1024.81 +4432.65 +1 +1024.86 +4414.77 +1 +1024.91 +4400.88 +1 +1024.96 +4391.18 +1 +1025.01 +4385.83 +1 +1025.06 +4385.02 +1 +1025.11 +4388.87 +1 +1025.16 +4397.65 +1 +1025.21 +4411.38 +1 +1025.26 +4430.93 +1 +1025.31 +4455.73 +1 +1025.36 +4485.79 +1 +1025.41 +4521.23 +1 +1025.46 +4562.05 +1 +1025.51 +4608.35 +1 +1025.56 +4660.11 +1 +1025.61 +4717.33 +1 +1025.66 +4780.21 +1 +1025.71 +4849.05 +1 +1025.76 +4923.35 +1 +1025.81 +5003.01 +1 +1025.86 +5087.93 +1 +1025.91 +5178.01 +1 +1025.96 +5273 +1 +1026.01 +5372.92 +1 +1026.06 +5477.43 +1 +1026.11 +5586.72 +1 +1026.16 +5700.64 +1 +1026.21 +5818.49 +1 +1026.26 +5940.2 +1 +1026.31 +6065.31 +1 +1026.36 +6193.61 +1 +1026.41 +6324.81 +1 +1026.46 +6458.48 +1 +1026.51 +6594.51 +1 +1026.56 +6732.71 +1 +1026.61 +6872.49 +1 +1026.66 +7013.32 +1 +1026.71 +7154.68 +1 +1026.76 +7296.37 +1 +1026.81 +7437.73 +1 +1026.86 +7578.44 +1 +1026.91 +7718.05 +1 +1026.96 +7856.03 +1 +1027.01 +7992.59 +1 +1027.06 +8126.58 +1 +1027.11 +8257.69 +1 +1027.16 +8385.44 +1 +1027.21 +8509.3 +1 +1027.26 +8628.95 +1 +1027.31 +8743.8 +1 +1027.36 +8853.55 +1 +1027.41 +8957.88 +1 +1027.46 +9056.52 +1 +1027.51 +9148.9 +1 +1027.56 +9234.5 +1 +1027.61 +9313.1 +1 +1027.66 +9384.3 +1 +1027.71 +9447.8 +1 +1027.76 +9503.41 +1 +1027.81 +9550.78 +1 +1027.86 +9590.02 +1 +1027.91 +9620.76 +1 +1027.96 +9642.69 +1 +1028.01 +9655.72 +1 +1028.06 +9659.65 +1 +1028.11 +9654.5 +1 +1028.16 +9640.16 +1 +1028.21 +9616.61 +1 +1028.26 +9583.92 +1 +1028.31 +9542.38 +1 +1028.36 +9491.87 +1 +1028.41 +9432.38 +1 +1028.46 +9364.1 +1 +1028.51 +9287.19 +1 +1028.56 +9201.79 +1 +1028.61 +9108.21 +1 +1028.66 +9006.6 +1 +1028.71 +8897.33 +1 +1028.76 +8780.91 +1 +1028.81 +8657.33 +1 +1028.86 +8527.02 +1 +1028.91 +8390.24 +1 +1028.96 +8247.41 +1 +1029.01 +8098.89 +1 +1029.06 +7945.05 +1 +1029.11 +7786.37 +1 +1029.16 +7623.31 +1 +1029.21 +7456.33 +1 +1029.26 +7285.73 +1 +1029.31 +7111.88 +1 +1029.36 +6935.27 +1 +1029.41 +6756.28 +1 +1029.46 +6575.34 +1 +1029.51 +6392.88 +1 +1029.56 +6209.28 +1 +1029.61 +6025.16 +1 +1029.66 +5840.77 +1 +1029.71 +5656.43 +1 +1029.76 +5472.53 +1 +1029.81 +5289.4 +1 +1029.86 +5107.42 +1 +1029.91 +4926.87 +1 +1029.96 +4748.1 +1 +1030.01 +4571.38 +1 +1030.06 +4397.2 +1 +1030.11 +4225.62 +1 +1030.16 +4056.86 +1 +1030.21 +3891.17 +1 +1030.26 +3728.74 +1 +1030.31 +3569.74 +1 +1030.36 +3414.36 +1 +1030.41 +3262.73 +1 +1030.46 +3115.04 +1 +1030.51 +2971.48 +1 +1030.56 +2832 +1 +1030.61 +2696.69 +1 +1030.66 +2565.6 +1 +1030.71 +2438.78 +1 +1030.76 +2316.25 +1 +1030.81 +2198.03 +1 +1030.86 +2084.12 +1 +1030.91 +1974.59 +1 +1030.96 +1869.4 +1 +1031.01 +1768.44 +1 +1031.06 +1671.65 +1 +1031.11 +1579 +1 +1031.16 +1490.4 +1 +1031.21 +1405.79 +1 +1031.26 +1325.07 +1 +1031.31 +1248.16 +1 +1031.36 +1175.09 +1 +1031.41 +1105.65 +1 +1031.46 +1039.72 +1 +1031.51 +977.194 +1 +1031.56 +917.957 +1 +1031.61 +861.898 +1 +1031.66 +808.897 +1 +1031.71 +758.848 +1 +1031.76 +711.643 +1 +1031.81 +667.253 +1 +1031.86 +625.461 +1 +1031.91 +586.149 +1 +1031.96 +549.212 +1 +1032.01 +514.529 +1 +1032.06 +481.996 +1 +1032.11 +451.504 +1 +1032.16 +422.945 +1 +1032.21 +396.268 +1 +1032.26 +371.378 +1 +1032.31 +348.128 +1 +1032.36 +326.423 +1 +1032.41 +306.171 +1 +1032.46 +287.293 +1 +1032.51 +269.698 +1 +1032.56 +253.312 +1 +1032.61 +238.056 +1 +1032.66 +223.92 +1 +1032.71 +210.8 +1 +1032.76 +198.602 +1 +1032.81 +187.268 +1 +1032.86 +176.736 +1 +1032.91 +166.95 +1 +1032.96 +157.86 +1 +1033.01 +149.413 +1 +1033.06 +141.566 +1 +1033.11 +134.348 +1 +1033.16 +127.642 +1 +1033.21 +121.412 +1 +1033.26 +115.618 +1 +1033.31 +110.231 +1 +1033.36 +105.216 +1 +1033.41 +100.545 +1 +1033.46 +96.1914 +1 +1033.51 +92.1457 +1 +1033.56 +88.4162 +1 +1033.61 +84.9317 +1 +1033.66 +81.6728 +1 +1033.71 +78.6216 +1 +1033.76 +75.7591 +1 +1033.81 +73.0719 +1 +1033.86 +70.5426 +1 +1033.91 +68.1585 +1 +1033.96 +65.9395 +1 +1034.01 +63.8651 +1 +1034.06 +61.9027 +1 +1034.11 +60.0402 +1 +1034.16 +58.2698 +1 +1034.21 +56.5842 +1 +1034.26 +54.975 +1 +1034.31 +53.4391 +1 +1034.36 +51.969 +1 +1034.41 +50.6038 +1 +1034.46 +49.3059 +1 +1034.51 +48.0632 +1 +1034.56 +46.8749 +1 +1034.61 +45.7351 +1 +1034.66 +44.6413 +1 +1034.71 +43.5894 +1 +1034.76 +42.5744 +1 +1034.81 +41.6001 +1 +1034.86 +40.6927 +1 +1034.91 +39.8132 +1 +1034.96 +38.9585 +1 +1035.01 +38.1257 +1 +1035.06 +37.3142 +1 +1035.11 +36.5206 +1 +1035.16 +35.7446 +1 +1035.21 +34.9841 +1 +1035.26 +34.2531 +1 +1035.31 +33.5583 +1 +1035.36 +32.8755 +1 +1035.41 +32.2049 +1 +1035.46 +31.5453 +1 +1035.51 +30.8959 +1 +1035.56 +30.2571 +1 +1035.61 +29.627 +1 +1035.66 +29.2777 +1 +1035.71 +28.6764 +1 +1035.76 +28.0885 +1 +1035.81 +27.5043 +1 +1035.86 +26.9227 +1 +1035.91 +26.3449 +1 +1035.96 +25.7699 +1 +1036.01 +25.1978 +1 +1036.06 +24.6291 +1 +1036.11 +24.0629 +1 +1036.16 +23.564 +1 +1036.21 +23.098 +1 +1036.26 +22.6347 +1 +1036.31 +22.1745 +1 +1036.36 +21.7165 +1 +1036.41 +21.2618 +1 +1036.46 +20.8093 +1 +1036.51 +20.3594 +1 +1036.56 +19.9186 +1 +1036.61 +19.4983 +1 +1036.66 +19.0809 +1 +1036.71 +18.6655 +1 +1036.76 +18.2524 +1 +1036.81 +17.8418 +1 +1036.86 +17.4331 +1 +1036.91 +17.0271 +1 +1036.96 +16.6229 +1 +1037.01 +16.2326 +1 +1037.06 +15.8546 +1 +1037.11 +15.4784 +1 +1037.16 +15.1207 +1 +1037.21 +14.7727 +1 +1037.26 +14.4268 +1 +1037.31 +14.0829 +1 +1037.36 +13.7406 +1 +1037.41 +13.4005 +1 +1037.46 +13.0777 +1 +1037.51 +12.7601 +1 +1037.56 +12.4444 +1 +1037.61 +12.1301 +1 +1037.66 +11.8179 +1 +1037.71 +11.5072 +1 +1037.76 +11.1983 +1 +1037.81 +10.891 +1 +1037.86 +10.5869 +1 +1037.91 +10.2996 +1 +1037.96 +10.0137 +1 +1038.01 +9.72941 +1 +1038.06 +9.44658 +1 +1038.11 +9.16511 +1 +1038.16 +8.894 +1 +1038.21 +8.62657 +1 +1038.26 +8.36072 +1 +1038.31 +8.10193 +1 +1038.36 +7.85343 +1 +1038.41 +7.60653 +1 +1038.46 +7.36073 +1 +1038.51 +7.11642 +1 +1038.56 +6.8733 +1 +1038.61 +6.63138 +1 +1038.66 +6.39085 +1 +1038.71 +6.15134 +1 +1038.76 +5.92198 +1 +1038.81 +5.69796 +1 +1038.86 +5.47508 +1 +1038.91 +5.25347 +1 +1038.96 +5.0328 +1 +1039.01 +4.98139 +1 +1039.06 +4.76187 +1 +1039.11 +4.54273 +1 +1039.16 +4.32925 +1 +1039.21 +4.12757 +1 +1039.26 +3.92698 +1 +1039.31 +0 +1 +1039.36 +0 +1 +1039.41 +0 +1 +1039.46 +0 +1 +1039.51 +0 +1 +1039.56 +0 +1 +1039.61 +0 +1 +1039.66 +0 +1 +1039.71 +0 +1 +1039.76 +0 +1 +1039.81 +0 +1 +1039.86 +0 +1 +1039.91 +0 +1 +1039.96 +0 +1 +1040.01 +0 +1 +1040.06 +0 +1 +1040.11 +0 +1 +1040.16 +0 +1 +1040.21 +0 +1 +1040.26 +0 +1 +1040.31 +0 +1 +1040.36 +0 +1 +1040.41 +0 +1 +1040.46 +0 +1 +1040.51 +0 +1 +1040.56 +0 +1 +1040.61 +0 +1 +Ti2p +TiO2 +0 +0 +0 +0 +0 +0 +0 +13 +Casa Info Follows +0 +0 +0 +0 + +PCA Coefs = 41279.5, -30.0911, +CasaXP11_irregular-March172021151537 +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +CasaXP2 +C:\Users\pielsticker\Downloads\Ti\references_irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.41 +0 +1 +986.51 +0 +1 +986.61 +0 +1 +986.71 +768.707 +1 +986.81 +760.553 +1 +986.91 +768.435 +1 +987.01 +755.652 +1 +987.11 +767.617 +1 +987.21 +776.181 +1 +987.31 +795.763 +1 +987.41 +770.688 +1 +987.51 +763.262 +1 +987.61 +746.497 +1 +987.71 +771.299 +1 +987.81 +794.081 +1 +987.91 +798.462 +1 +988.01 +796.086 +1 +988.11 +750.701 +1 +988.21 +764.244 +1 +988.31 +762.703 +1 +988.41 +767.642 +1 +988.51 +809.875 +1 +988.61 +782.735 +1 +988.71 +802.762 +1 +988.81 +781.754 +1 +988.91 +797.075 +1 +989.01 +782.132 +1 +989.11 +772.809 +1 +989.21 +791.69 +1 +989.31 +768.177 +1 +989.41 +753.308 +1 +989.51 +789.669 +1 +989.61 +800.739 +1 +989.71 +779.037 +1 +989.81 +796.667 +1 +989.91 +788.664 +1 +990.01 +781.431 +1 +990.11 +763.133 +1 +990.21 +761.93 +1 +990.31 +770.168 +1 +990.41 +781.989 +1 +990.51 +774.174 +1 +990.61 +783.781 +1 +990.71 +788.367 +1 +990.81 +773.493 +1 +990.91 +805.974 +1 +991.01 +771.994 +1 +991.11 +777.448 +1 +991.21 +789.282 +1 +991.31 +794.388 +1 +991.41 +776.115 +1 +991.51 +783.245 +1 +991.61 +791.547 +1 +991.71 +791.152 +1 +991.81 +811.094 +1 +991.91 +769.968 +1 +992.01 +772.96 +1 +992.11 +796.65 +1 +992.21 +826.989 +1 +992.31 +810.03 +1 +992.41 +818.963 +1 +992.51 +785.408 +1 +992.61 +800.716 +1 +992.71 +788.478 +1 +992.81 +804.164 +1 +992.91 +812.978 +1 +993.01 +822.622 +1 +993.11 +819.208 +1 +993.21 +829.078 +1 +993.31 +792.38 +1 +993.41 +821.361 +1 +993.51 +807.064 +1 +993.61 +809.673 +1 +993.71 +829.266 +1 +993.81 +816.075 +1 +993.91 +811.888 +1 +994.01 +813.957 +1 +994.11 +821.861 +1 +994.21 +833.57 +1 +994.31 +837.714 +1 +994.41 +849.28 +1 +994.51 +857.286 +1 +994.61 +833.549 +1 +994.71 +845.806 +1 +994.81 +836.24 +1 +994.91 +858.359 +1 +995.01 +862.683 +1 +995.11 +844.704 +1 +995.21 +842.124 +1 +995.31 +876.151 +1 +995.41 +850.852 +1 +995.51 +870.002 +1 +995.61 +873.725 +1 +995.71 +872.576 +1 +995.81 +872.903 +1 +995.91 +878.814 +1 +996.01 +867.431 +1 +996.11 +865.276 +1 +996.21 +866.368 +1 +996.31 +877.735 +1 +996.41 +899.413 +1 +996.51 +886.844 +1 +996.61 +869.567 +1 +996.71 +902.856 +1 +996.81 +905.33 +1 +996.91 +874.966 +1 +997.01 +869.403 +1 +997.11 +865.949 +1 +997.21 +886.148 +1 +997.31 +882.212 +1 +997.41 +885.397 +1 +997.51 +898.615 +1 +997.61 +902.991 +1 +997.71 +883.438 +1 +997.81 +896.5 +1 +997.91 +893.677 +1 +998.01 +877.466 +1 +998.11 +900.29 +1 +998.21 +880.029 +1 +998.31 +903.615 +1 +998.41 +893.494 +1 +998.51 +880.647 +1 +998.61 +893.543 +1 +998.71 +873.733 +1 +998.81 +900.388 +1 +998.91 +916.252 +1 +999.01 +902.081 +1 +999.11 +905.374 +1 +999.21 +886.856 +1 +999.31 +911.213 +1 +999.41 +905.309 +1 +999.51 +902.687 +1 +999.61 +913.305 +1 +999.71 +904.045 +1 +999.81 +896.12 +1 +999.91 +897.236 +1 +1000.01 +923.679 +1 +1000.11 +926.681 +1 +1000.21 +926.073 +1 +1000.31 +925.526 +1 +1000.41 +907.704 +1 +1000.51 +896.397 +1 +1000.61 +910.067 +1 +1000.71 +926.249 +1 +1000.81 +920.429 +1 +1000.91 +911.683 +1 +1001.01 +929.617 +1 +1001.11 +950.296 +1 +1001.21 +954.222 +1 +1001.31 +958.371 +1 +1001.41 +948.537 +1 +1001.51 +937.444 +1 +1001.61 +926.521 +1 +1001.71 +914.447 +1 +1001.81 +938.226 +1 +1001.91 +942.783 +1 +1002.01 +945.337 +1 +1002.11 +920.58 +1 +1002.21 +939.262 +1 +1002.31 +943.013 +1 +1002.41 +943.763 +1 +1002.51 +963.942 +1 +1002.61 +929.992 +1 +1002.71 +921.771 +1 +1002.81 +946.545 +1 +1002.91 +951.811 +1 +1003.01 +971.317 +1 +1003.11 +932.785 +1 +1003.21 +938.39 +1 +1003.31 +948.212 +1 +1003.41 +955.917 +1 +1003.51 +950.44 +1 +1003.61 +933.546 +1 +1003.71 +937.391 +1 +1003.81 +934.345 +1 +1003.91 +945.101 +1 +1004.01 +931.364 +1 +1004.11 +934.292 +1 +1004.21 +938.488 +1 +1004.31 +931.659 +1 +1004.41 +941.812 +1 +1004.51 +926.828 +1 +1004.61 +935.58 +1 +1004.71 +914.475 +1 +1004.81 +926.205 +1 +1004.91 +933.151 +1 +1005.01 +894.257 +1 +1005.11 +922.632 +1 +1005.21 +947.099 +1 +1005.31 +942.994 +1 +1005.41 +962.008 +1 +1005.51 +926.796 +1 +1005.61 +950.836 +1 +1005.71 +940.143 +1 +1005.81 +956.34 +1 +1005.91 +956.727 +1 +1006.01 +975.317 +1 +1006.11 +940.591 +1 +1006.21 +947.456 +1 +1006.31 +981.819 +1 +1006.41 +970.555 +1 +1006.51 +1008.37 +1 +1006.61 +1008.11 +1 +1006.71 +1013.6 +1 +1006.81 +996.31 +1 +1006.91 +1014.27 +1 +1007.01 +987.97 +1 +1007.11 +1015.57 +1 +1007.21 +1041.04 +1 +1007.31 +1024.19 +1 +1007.41 +1046.25 +1 +1007.51 +1080.99 +1 +1007.61 +1052.36 +1 +1007.71 +1079.45 +1 +1007.81 +1069.35 +1 +1007.91 +1086.71 +1 +1008.01 +1099.49 +1 +1008.11 +1098.97 +1 +1008.21 +1082.77 +1 +1008.31 +1103.98 +1 +1008.41 +1124.29 +1 +1008.51 +1094.43 +1 +1008.61 +1092.18 +1 +1008.71 +1119.73 +1 +1008.81 +1111.18 +1 +1008.91 +1100.64 +1 +1009.01 +1074.02 +1 +1009.11 +1081.55 +1 +1009.21 +1084.81 +1 +1009.31 +1072.29 +1 +1009.41 +1064.08 +1 +1009.51 +1068.03 +1 +1009.61 +1042.68 +1 +1009.71 +1048.27 +1 +1009.81 +1047.75 +1 +1009.91 +1041.99 +1 +1010.01 +1032.26 +1 +1010.11 +1010.81 +1 +1010.21 +1010.5 +1 +1010.31 +981.444 +1 +1010.41 +994.358 +1 +1010.51 +1016.22 +1 +1010.61 +1023.54 +1 +1010.71 +996.998 +1 +1010.81 +986.877 +1 +1010.91 +990.319 +1 +1011.01 +977.67 +1 +1011.11 +974.063 +1 +1011.21 +990.486 +1 +1011.31 +981.065 +1 +1011.41 +994.019 +1 +1011.51 +977.353 +1 +1011.61 +990.329 +1 +1011.71 +997.831 +1 +1011.81 +976.829 +1 +1011.91 +1023.17 +1 +1012.01 +1048.11 +1 +1012.11 +1057 +1 +1012.21 +1054.53 +1 +1012.31 +1056.94 +1 +1012.41 +1065.11 +1 +1012.51 +1098.57 +1 +1012.61 +1081.96 +1 +1012.71 +1088.82 +1 +1012.81 +1090.24 +1 +1012.91 +1110.64 +1 +1013.01 +1156.04 +1 +1013.11 +1154.69 +1 +1013.21 +1149.48 +1 +1013.31 +1178.23 +1 +1013.41 +1206.08 +1 +1013.51 +1235.84 +1 +1013.61 +1212.04 +1 +1013.71 +1236.37 +1 +1013.81 +1260.29 +1 +1013.91 +1227.79 +1 +1014.01 +1267.25 +1 +1014.11 +1278.21 +1 +1014.21 +1301.9 +1 +1014.31 +1268.86 +1 +1014.41 +1282.91 +1 +1014.51 +1257.63 +1 +1014.61 +1268.26 +1 +1014.71 +1240.09 +1 +1014.81 +1212.45 +1 +1014.91 +1218.87 +1 +1015.01 +1192.01 +1 +1015.11 +1171.19 +1 +1015.21 +1155.17 +1 +1015.31 +1122.54 +1 +1015.41 +1101.79 +1 +1015.41 +1067.41 +1 +1015.46 +1052.35 +1 +1015.51 +1067.29 +1 +1015.51 +1059.44 +1 +1015.56 +1042.15 +1 +1015.61 +1030.58 +1 +1015.61 +1039.02 +1 +1015.66 +1026.23 +1 +1015.71 +1052.82 +1 +1015.71 +1026.07 +1 +1015.76 +1013.77 +1 +1015.81 +1016.71 +1 +1015.81 +984.758 +1 +1015.86 +1003.17 +1 +1015.91 +978.853 +1 +1015.91 +983.593 +1 +1015.96 +992.657 +1 +1016.01 +963.914 +1 +1016.01 +997.976 +1 +1016.06 +945.589 +1 +1016.11 +962.513 +1 +1016.11 +958.563 +1 +1016.16 +978.607 +1 +1016.21 +965.235 +1 +1016.21 +925.061 +1 +1016.26 +931.285 +1 +1016.31 +950.873 +1 +1016.31 +924.092 +1 +1016.36 +914.095 +1 +1016.41 +887.906 +1 +1016.41 +924.448 +1 +1016.46 +892.4 +1 +1016.51 +887.492 +1 +1016.56 +895.285 +1 +1016.61 +879.719 +1 +1016.66 +885.384 +1 +1016.71 +879.291 +1 +1016.76 +836.024 +1 +1016.81 +856.757 +1 +1016.86 +867.567 +1 +1016.91 +879.182 +1 +1016.96 +853.334 +1 +1017.01 +840.365 +1 +1017.06 +844.006 +1 +1017.11 +838.737 +1 +1017.16 +830.23 +1 +1017.21 +813.429 +1 +1017.26 +808.999 +1 +1017.31 +819.672 +1 +1017.36 +805.464 +1 +1017.41 +810.392 +1 +1017.46 +784.829 +1 +1017.51 +797.662 +1 +1017.56 +777.953 +1 +1017.61 +778.964 +1 +1017.66 +772.96 +1 +1017.71 +800.196 +1 +1017.76 +780.125 +1 +1017.81 +749.445 +1 +1017.86 +759.949 +1 +1017.91 +760.85 +1 +1017.96 +766.089 +1 +1018.01 +761.03 +1 +1018.06 +775.909 +1 +1018.11 +783.447 +1 +1018.16 +786.74 +1 +1018.21 +764.45 +1 +1018.26 +755.3 +1 +1018.31 +777.982 +1 +1018.36 +771.937 +1 +1018.41 +777.032 +1 +1018.46 +772.377 +1 +1018.51 +741.676 +1 +1018.56 +789.933 +1 +1018.61 +762.665 +1 +1018.66 +745.3 +1 +1018.71 +752.13 +1 +1018.76 +759.794 +1 +1018.81 +774.162 +1 +1018.86 +794.029 +1 +1018.91 +786.274 +1 +1018.96 +802.151 +1 +1019.01 +783.227 +1 +1019.06 +801.558 +1 +1019.11 +787.6 +1 +1019.16 +821.694 +1 +1019.21 +830.725 +1 +1019.26 +819.337 +1 +1019.31 +865.198 +1 +1019.36 +844.184 +1 +1019.41 +845.633 +1 +1019.46 +854.093 +1 +1019.51 +863.046 +1 +1019.56 +874.417 +1 +1019.61 +913.775 +1 +1019.66 +896.864 +1 +1019.71 +925.225 +1 +1019.76 +932.491 +1 +1019.81 +971.033 +1 +1019.86 +966.216 +1 +1019.91 +972.082 +1 +1019.96 +1029.16 +1 +1020.01 +1031.97 +1 +1020.06 +1049.6 +1 +1020.11 +1079.9 +1 +1020.16 +1095.11 +1 +1020.21 +1142.77 +1 +1020.26 +1185.78 +1 +1020.31 +1234.21 +1 +1020.36 +1275.05 +1 +1020.41 +1301.29 +1 +1020.46 +1354.89 +1 +1020.51 +1402.01 +1 +1020.56 +1465.91 +1 +1020.61 +1505.27 +1 +1020.66 +1542.42 +1 +1020.71 +1564.52 +1 +1020.76 +1643.28 +1 +1020.81 +1699.57 +1 +1020.86 +1778.37 +1 +1020.91 +1802.46 +1 +1020.96 +1858.86 +1 +1021.01 +1969.59 +1 +1021.06 +2010.58 +1 +1021.11 +2061.9 +1 +1021.16 +2155.96 +1 +1021.21 +2171.67 +1 +1021.26 +2266.3 +1 +1021.31 +2257.47 +1 +1021.36 +2311 +1 +1021.41 +2367.68 +1 +1021.46 +2426.42 +1 +1021.51 +2451.52 +1 +1021.56 +2486.56 +1 +1021.61 +2485.79 +1 +1021.66 +2516.09 +1 +1021.71 +2550.8 +1 +1021.76 +2526.8 +1 +1021.81 +2501.27 +1 +1021.86 +2536.75 +1 +1021.91 +2497.04 +1 +1021.96 +2492.25 +1 +1022.01 +2489.07 +1 +1022.06 +2395.72 +1 +1022.11 +2401.55 +1 +1022.16 +2346.97 +1 +1022.21 +2306.04 +1 +1022.26 +2289 +1 +1022.31 +2227.36 +1 +1022.36 +2153.49 +1 +1022.41 +2067.64 +1 +1022.46 +1998.69 +1 +1022.51 +1950.63 +1 +1022.56 +1902.71 +1 +1022.61 +1827.21 +1 +1022.66 +1728.78 +1 +1022.71 +1672.22 +1 +1022.76 +1609.68 +1 +1022.81 +1578.01 +1 +1022.86 +1559.44 +1 +1022.91 +1434.8 +1 +1022.96 +1366.92 +1 +1023.01 +1348.1 +1 +1023.06 +1290.44 +1 +1023.11 +1235.91 +1 +1023.16 +1223.03 +1 +1023.21 +1158.64 +1 +1023.26 +1156.28 +1 +1023.31 +1128.58 +1 +1023.36 +1089.29 +1 +1023.41 +1032.33 +1 +1023.46 +1023.36 +1 +1023.51 +996.215 +1 +1023.56 +948.428 +1 +1023.61 +937.285 +1 +1023.66 +924.02 +1 +1023.71 +904.001 +1 +1023.76 +911.682 +1 +1023.81 +860.988 +1 +1023.86 +840.295 +1 +1023.91 +830.683 +1 +1023.96 +806.105 +1 +1024.01 +814.335 +1 +1024.06 +797.877 +1 +1024.11 +784.465 +1 +1024.16 +798.57 +1 +1024.21 +784.869 +1 +1024.26 +780.672 +1 +1024.31 +778.737 +1 +1024.36 +761.738 +1 +1024.41 +758.673 +1 +1024.46 +741.007 +1 +1024.51 +751.087 +1 +1024.56 +759.106 +1 +1024.61 +748.745 +1 +1024.66 +740.552 +1 +1024.71 +748.907 +1 +1024.76 +754.767 +1 +1024.81 +759.631 +1 +1024.86 +754.448 +1 +1024.91 +746.531 +1 +1024.96 +762.516 +1 +1025.01 +778.526 +1 +1025.06 +758.886 +1 +1025.11 +759.716 +1 +1025.16 +770.626 +1 +1025.21 +777.027 +1 +1025.26 +784.108 +1 +1025.31 +786.215 +1 +1025.36 +784.578 +1 +1025.41 +791.529 +1 +1025.46 +817.551 +1 +1025.51 +813.631 +1 +1025.56 +831.026 +1 +1025.61 +823.737 +1 +1025.66 +843.837 +1 +1025.71 +847.126 +1 +1025.76 +845.529 +1 +1025.81 +871.589 +1 +1025.86 +897.405 +1 +1025.91 +931.456 +1 +1025.96 +943.584 +1 +1026.01 +975.757 +1 +1026.06 +1029.64 +1 +1026.11 +1058.22 +1 +1026.16 +1123.13 +1 +1026.21 +1166.62 +1 +1026.26 +1235.35 +1 +1026.31 +1291.99 +1 +1026.36 +1404.8 +1 +1026.41 +1511.6 +1 +1026.46 +1620.58 +1 +1026.51 +1744.35 +1 +1026.56 +1887.18 +1 +1026.61 +2048.32 +1 +1026.66 +2250.15 +1 +1026.71 +2474.29 +1 +1026.76 +2792.44 +1 +1026.81 +3041.37 +1 +1026.86 +3301.67 +1 +1026.91 +3616.82 +1 +1026.96 +3968.96 +1 +1027.01 +4302.5 +1 +1027.06 +4599.79 +1 +1027.11 +4948.24 +1 +1027.16 +5336.66 +1 +1027.21 +5592.03 +1 +1027.26 +5891.08 +1 +1027.31 +6117.37 +1 +1027.36 +6401.69 +1 +1027.41 +6544.88 +1 +1027.46 +6616.65 +1 +1027.51 +6705.58 +1 +1027.56 +6693.94 +1 +1027.61 +6634.5 +1 +1027.66 +6522.28 +1 +1027.71 +6363.31 +1 +1027.76 +6104.02 +1 +1027.81 +5828.6 +1 +1027.86 +5495.3 +1 +1027.91 +5100.96 +1 +1027.96 +4818.28 +1 +1028.01 +4440.83 +1 +1028.06 +4085.26 +1 +1028.11 +3670.51 +1 +1028.16 +3341.96 +1 +1028.21 +2989.35 +1 +1028.26 +2685.24 +1 +1028.31 +2373.67 +1 +1028.36 +2111.04 +1 +1028.41 +1882.81 +1 +1028.46 +1636.92 +1 +1028.51 +1449.51 +1 +1028.56 +1278.47 +1 +1028.61 +1138.66 +1 +1028.66 +1008.49 +1 +1028.71 +880.955 +1 +1028.76 +784.214 +1 +1028.81 +710.739 +1 +1028.86 +639.553 +1 +1028.91 +593.143 +1 +1028.96 +528.411 +1 +1029.01 +493.952 +1 +1029.06 +460.395 +1 +1029.11 +430.007 +1 +1029.16 +407.676 +1 +1029.21 +375.74 +1 +1029.26 +349.579 +1 +1029.31 +307.498 +1 +1029.36 +298.685 +1 +1029.41 +289.607 +1 +1029.46 +274.535 +1 +1029.51 +261.454 +1 +1029.56 +258.402 +1 +1029.61 +241.45 +1 +1029.66 +226.133 +1 +1029.71 +195.994 +1 +1029.76 +196.912 +1 +1029.81 +178.111 +1 +1029.86 +182.602 +1 +1029.91 +171.642 +1 +1029.96 +139.931 +1 +1030.01 +148.703 +1 +1030.06 +140.236 +1 +1030.11 +122.799 +1 +1030.16 +127.547 +1 +1030.21 +123.658 +1 +1030.26 +117.159 +1 +1030.31 +113.168 +1 +1030.36 +103.043 +1 +1030.41 +89.9611 +1 +1030.46 +79.7678 +1 +1030.51 +82.6402 +1 +1030.56 +78.3794 +1 +1030.61 +71.4293 +1 +1030.66 +76.4138 +1 +1030.71 +75.3822 +1 +1030.76 +78.9603 +1 +1030.81 +65.8195 +1 +1030.86 +59.9979 +1 +1030.91 +53.6695 +1 +1030.96 +50.609 +1 +1031.01 +45.9551 +1 +1031.06 +58.2979 +1 +1031.11 +45.7672 +1 +1031.16 +45.6667 +1 +1031.21 +37.6953 +1 +1031.26 +34.8926 +1 +1031.31 +45.1279 +1 +1031.36 +38.4188 +1 +1031.41 +43.102 +1 +1031.46 +41.5193 +1 +1031.51 +41.8022 +1 +1031.56 +37.3304 +1 +1031.61 +34.3535 +1 +1031.66 +38.0149 +1 +1031.71 +41.0285 +1 +1031.76 +38.7568 +1 +1031.81 +24.1728 +1 +1031.86 +26.7467 +1 +1031.91 +24.8709 +1 +1031.96 +25.2497 +1 +1032.01 +30.3581 +1 +1032.06 +32.8652 +1 +1032.11 +26.7379 +1 +1032.16 +17.5069 +1 +1032.21 +27.4104 +1 +1032.26 +31.9776 +1 +1032.31 +35.0028 +1 +1032.36 +28.3184 +1 +1032.41 +18.7488 +1 +1032.46 +16.2122 +1 +1032.51 +31.8477 +1 +1032.56 +28.849 +1 +1032.61 +28.1205 +1 +1032.66 +19.5003 +1 +1032.71 +22.1481 +1 +1032.76 +14.6862 +1 +1032.81 +23.383 +1 +1032.86 +23.817 +1 +1032.91 +18.631 +1 +1032.96 +16.5573 +1 +1033.01 +12.2888 +1 +1033.06 +14.5476 +1 +1033.11 +16.5876 +1 +1033.16 +14.5942 +1 +1033.21 +13.8555 +1 +1033.26 +14.5433 +1 +1033.31 +7.00553 +1 +1033.36 +19.7495 +1 +1033.41 +9.75463 +1 +1033.46 +16.6813 +1 +1033.51 +10.5411 +1 +1033.56 +11.4887 +1 +1033.61 +9.85089 +1 +1033.66 +21.479 +1 +1033.71 +15.0159 +1 +1033.76 +22.6288 +1 +1033.81 +16.9822 +1 +1033.86 +17.9488 +1 +1033.91 +10.2562 +1 +1033.96 +17.5299 +1 +1034.01 +14.6918 +1 +1034.06 +18.5697 +1 +1034.11 +18.4523 +1 +1034.16 +17.5792 +1 +1034.21 +20.0307 +1 +1034.26 +24.9494 +1 +1034.31 +12.6893 +1 +1034.36 +7.72395 +1 +1034.41 +4.38198 +1 +1034.46 +6.31105 +1 +1034.51 +13.7239 +1 +1034.56 +19.994 +1 +1034.61 +12.7116 +1 +1034.66 +10.1567 +1 +1034.71 +12.2761 +1 +1034.76 +14.2381 +1 +1034.81 +4.75145 +1 +1034.86 +-0.0982386 +1 +1034.91 +11.4553 +1 +1034.96 +8.98422 +1 +1035.01 +19.1661 +1 +1035.06 +11.0729 +1 +1035.11 +14.8176 +1 +1035.16 +14.128 +1 +1035.21 +12.2612 +1 +1035.26 +12.6718 +1 +1035.31 +13.668 +1 +1035.36 +5.73352 +1 +1035.41 +6.80692 +1 +1035.46 +6.00817 +1 +1035.51 +3.57823 +1 +1035.56 +6.26545 +1 +1035.61 +10.8517 +1 +1035.66 +8.11417 +1 +1035.71 +8.48454 +1 +1035.76 +6.19727 +1 +1035.81 +9.99754 +1 +1035.86 +-0.595702 +1 +1035.91 +3.32511 +1 +1035.96 +2.16431 +1 +1036.01 +5.30515 +1 +1036.06 +6.33019 +1 +1036.11 +-0.15255 +1 +1036.16 +-0.160988 +1 +1036.21 +4.10473 +1 +1036.26 +-1.07666 +1 +1036.31 +1.58446 +1 +1036.36 +-0.212021 +1 +1036.41 +12.2091 +1 +1036.46 +6.92326 +1 +1036.51 +14.8672 +1 +1036.56 +6.40831 +1 +1036.61 +4.71866 +1 +1036.66 +7.10513 +1 +1036.71 +9.98924 +1 +1036.76 +1.929 +1 +1036.81 +6.98157 +1 +1036.86 +3.66599 +1 +1036.91 +8.02528 +1 +1036.96 +-0.623079 +1 +1037.01 +-3.58963 +1 +1037.06 +-4.89371 +1 +1037.11 +3.92434 +1 +1037.16 +8.29572 +1 +1037.21 +8.52046 +1 +1037.26 +10.3075 +1 +1037.31 +6.96935 +1 +1037.36 +-0.523693 +1 +1037.41 +-6.73835 +1 +1037.46 +1.34514 +1 +1037.51 +4.97275 +1 +1037.56 +1.15262 +1 +1037.61 +-2.7992 +1 +1037.66 +9.64657 +1 +1037.71 +5.40891 +1 +1037.76 +6.80002 +1 +1037.81 +-3.69174 +1 +1037.86 +4.72394 +1 +1037.91 +2.41516 +1 +1037.96 +2.16941 +1 +1038.01 +3.25827 +1 +1038.06 +6.17699 +1 +1038.11 +-0.126762 +1 +1038.16 +9.74501 +1 +1038.21 +2.44671 +1 +1038.26 +13.5869 +1 +1038.31 +0.257914 +1 +1038.36 +2.84957 +1 +1038.41 +3.89457 +1 +1038.46 +-3.92537 +1 +1038.51 +-5.8306 +1 +1038.56 +-1.07815 +1 +1038.61 +4.5545 +1 +1038.66 +9.49284 +1 +1038.71 +0.264434 +1 +1038.76 +1.19787 +1 +1038.81 +1.67889 +1 +1038.86 +-0.411538 +1 +1038.91 +3.29361 +1 +1038.96 +3.60995 +1 +1039.01 +7.03935 +1 +1039.06 +2.46095 +1 +1039.11 +3.16899 +1 +1039.16 +-3.42998 +1 +1039.21 +7.20019 +1 +1039.26 +-6.66532 +1 +1039.31 +-2.25084 +1 +1039.36 +0.0238542 +1 +1039.41 +-2.53558 +1 +1039.46 +1.21449 +1 +1039.51 +-4.11686 +1 +1039.56 +0.731545 +1 +1039.61 +2.61504 +1 +1039.66 +-1.29684 +1 +1039.71 +-3.20836 +1 +1039.76 +7.83649 +1 +1039.81 +4.38263 +1 +1039.86 +6.31627 +1 +1039.91 +6.05281 +1 +1039.96 +4.76111 +1 +1040.01 +3.3128 +1 +1040.06 +7.77774 +1 +1040.11 +1.48788 +1 +1040.16 +7.11285 +1 +1040.21 +2.66528 +1 +1040.26 +0.887167 +1 +1040.31 +2.751 +1 +1040.36 +-10.7387 +1 +1040.41 +0 +1 +&TiO +TiO +0 +0 +0 +0 +0 +0 +0 +13 +Casa Info Follows +0 +0 +0 +0 + +PCA Coefs = 41396.7, -3191.99, 1103.12, 387.504, +PCA Coefs = 41396.7, -3191.99, 1103.12, 387.504, -363.953, +PCA Coefs = 41439, -2585.94, 1104.79, -371.422, -359.987, 128.966, +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p LS +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.61 +0 +1 +986.71 +0 +1 +986.81 +0 +1 +986.91 +0 +1 +987.01 +0 +1 +987.11 +0 +1 +987.21 +0 +1 +987.31 +0 +1 +987.41 +427.081 +1 +987.51 +418.506 +1 +987.61 +421.294 +1 +987.71 +440.148 +1 +987.81 +443.528 +1 +987.91 +430.838 +1 +988.01 +445.739 +1 +988.11 +424.025 +1 +988.21 +434.13 +1 +988.31 +418.792 +1 +988.41 +428.149 +1 +988.51 +454.731 +1 +988.61 +439.937 +1 +988.71 +440.084 +1 +988.81 +432.384 +1 +988.91 +432.304 +1 +989.01 +440.641 +1 +989.11 +446.848 +1 +989.21 +426.341 +1 +989.31 +427.43 +1 +989.41 +433.208 +1 +989.51 +424.875 +1 +989.61 +432.054 +1 +989.71 +420.255 +1 +989.81 +436.188 +1 +989.91 +437.574 +1 +990.01 +442.909 +1 +990.11 +437.73 +1 +990.21 +421.943 +1 +990.31 +412.513 +1 +990.41 +435.891 +1 +990.51 +431.311 +1 +990.61 +432.78 +1 +990.71 +433.572 +1 +990.81 +418.188 +1 +990.91 +409.864 +1 +991.01 +422.085 +1 +991.11 +426.173 +1 +991.21 +444.271 +1 +991.31 +414.74 +1 +991.41 +436.211 +1 +991.51 +426.44 +1 +991.61 +422.63 +1 +991.71 +419.722 +1 +991.81 +433.338 +1 +991.91 +436.796 +1 +992.01 +436.845 +1 +992.11 +430.264 +1 +992.21 +409.348 +1 +992.31 +408.522 +1 +992.41 +437.968 +1 +992.51 +445.551 +1 +992.61 +438.706 +1 +992.71 +442.301 +1 +992.81 +436.554 +1 +992.91 +427.755 +1 +993.01 +444.831 +1 +993.11 +456.361 +1 +993.21 +439.465 +1 +993.31 +450.223 +1 +993.41 +444.027 +1 +993.51 +436.61 +1 +993.61 +442.322 +1 +993.71 +448.84 +1 +993.81 +443.012 +1 +993.91 +447.565 +1 +994.01 +442.503 +1 +994.11 +431.631 +1 +994.21 +441.927 +1 +994.31 +439.397 +1 +994.41 +446.213 +1 +994.51 +436.637 +1 +994.61 +431.379 +1 +994.71 +439.383 +1 +994.81 +437.913 +1 +994.91 +437.081 +1 +995.01 +451.356 +1 +995.11 +441.987 +1 +995.21 +433.982 +1 +995.31 +435.758 +1 +995.41 +438.365 +1 +995.51 +440.249 +1 +995.61 +441.327 +1 +995.71 +470.201 +1 +995.81 +461.681 +1 +995.91 +465.133 +1 +996.01 +457.167 +1 +996.11 +452.422 +1 +996.21 +450.82 +1 +996.31 +465.086 +1 +996.41 +461.236 +1 +996.51 +459.164 +1 +996.61 +447.345 +1 +996.71 +449.258 +1 +996.81 +459.59 +1 +996.91 +458.529 +1 +997.01 +473.17 +1 +997.11 +477.211 +1 +997.21 +459.326 +1 +997.31 +460.033 +1 +997.41 +459.628 +1 +997.51 +445.237 +1 +997.61 +452.9 +1 +997.71 +462.703 +1 +997.81 +459.284 +1 +997.91 +451.872 +1 +998.01 +456.31 +1 +998.11 +469.161 +1 +998.21 +467.634 +1 +998.31 +475.462 +1 +998.41 +474.394 +1 +998.51 +456.623 +1 +998.61 +469.981 +1 +998.71 +480.575 +1 +998.81 +487.905 +1 +998.91 +476.11 +1 +999.01 +472.079 +1 +999.11 +488.889 +1 +999.21 +482.388 +1 +999.31 +473.36 +1 +999.41 +485.498 +1 +999.51 +489.987 +1 +999.61 +486.287 +1 +999.71 +499.989 +1 +999.81 +499.325 +1 +999.91 +503.847 +1 +1000.01 +495.847 +1 +1000.11 +472.305 +1 +1000.21 +495.686 +1 +1000.31 +470.454 +1 +1000.41 +456.9 +1 +1000.51 +470.1 +1 +1000.61 +477.155 +1 +1000.71 +488.566 +1 +1000.81 +501.371 +1 +1000.91 +487.255 +1 +1001.01 +491.032 +1 +1001.11 +485.732 +1 +1001.21 +504.469 +1 +1001.31 +498.971 +1 +1001.41 +487.565 +1 +1001.51 +495.287 +1 +1001.61 +492.023 +1 +1001.71 +515.751 +1 +1001.81 +524.072 +1 +1001.91 +521.562 +1 +1002.01 +511.741 +1 +1002.11 +520.4 +1 +1002.21 +503.72 +1 +1002.31 +510.643 +1 +1002.41 +513.259 +1 +1002.51 +516.99 +1 +1002.61 +517.098 +1 +1002.71 +511.597 +1 +1002.81 +514.602 +1 +1002.91 +518.202 +1 +1003.01 +511.706 +1 +1003.11 +525.184 +1 +1003.21 +517.952 +1 +1003.31 +517.622 +1 +1003.41 +524.306 +1 +1003.51 +508.334 +1 +1003.61 +516.65 +1 +1003.71 +520.695 +1 +1003.81 +527.955 +1 +1003.91 +529.331 +1 +1004.01 +533.794 +1 +1004.11 +532.939 +1 +1004.21 +517.49 +1 +1004.31 +527.727 +1 +1004.41 +538.381 +1 +1004.51 +533.308 +1 +1004.61 +521.561 +1 +1004.71 +544.611 +1 +1004.81 +527.324 +1 +1004.91 +532.448 +1 +1005.01 +570.213 +1 +1005.11 +563.09 +1 +1005.21 +541.792 +1 +1005.31 +542.99 +1 +1005.41 +559.25 +1 +1005.51 +545.665 +1 +1005.61 +543.146 +1 +1005.71 +526.3 +1 +1005.81 +537.531 +1 +1005.91 +572.365 +1 +1006.01 +555.441 +1 +1006.11 +549.727 +1 +1006.21 +551.249 +1 +1006.31 +548.66 +1 +1006.41 +551.261 +1 +1006.51 +563.665 +1 +1006.61 +576.201 +1 +1006.71 +577.334 +1 +1006.81 +567.664 +1 +1006.91 +553.853 +1 +1007.01 +558.785 +1 +1007.11 +584.367 +1 +1007.21 +581.728 +1 +1007.31 +565.461 +1 +1007.41 +575.372 +1 +1007.51 +562.378 +1 +1007.61 +563.918 +1 +1007.71 +558.304 +1 +1007.81 +554.263 +1 +1007.91 +548.855 +1 +1008.01 +560.082 +1 +1008.11 +587.028 +1 +1008.21 +594.404 +1 +1008.31 +582.535 +1 +1008.41 +572.581 +1 +1008.51 +570.811 +1 +1008.61 +557.279 +1 +1008.71 +573.391 +1 +1008.81 +568.03 +1 +1008.91 +560.161 +1 +1009.01 +607.207 +1 +1009.11 +597.167 +1 +1009.21 +578.718 +1 +1009.31 +585.585 +1 +1009.41 +598.421 +1 +1009.51 +580.41 +1 +1009.61 +576.951 +1 +1009.71 +584.575 +1 +1009.81 +563.585 +1 +1009.91 +563.558 +1 +1010.01 +597.413 +1 +1010.11 +592.348 +1 +1010.21 +598.689 +1 +1010.31 +591.048 +1 +1010.41 +575.647 +1 +1010.51 +562.049 +1 +1010.61 +584.689 +1 +1010.71 +613.504 +1 +1010.81 +604.43 +1 +1010.91 +590.102 +1 +1011.01 +598.673 +1 +1011.11 +597.336 +1 +1011.21 +592.662 +1 +1011.31 +580.7 +1 +1011.41 +584.009 +1 +1011.51 +612.752 +1 +1011.61 +604.978 +1 +1011.71 +591.136 +1 +1011.81 +582.187 +1 +1011.91 +581.801 +1 +1012.01 +583.193 +1 +1012.11 +607.547 +1 +1012.21 +625.368 +1 +1012.31 +616.005 +1 +1012.41 +610.544 +1 +1012.51 +606.481 +1 +1012.61 +612.489 +1 +1012.71 +611.253 +1 +1012.81 +586.851 +1 +1012.91 +623.68 +1 +1013.01 +621.663 +1 +1013.11 +618.895 +1 +1013.21 +600.995 +1 +1013.31 +597.049 +1 +1013.41 +591.93 +1 +1013.51 +595.137 +1 +1013.61 +603.223 +1 +1013.71 +596.239 +1 +1013.81 +587.085 +1 +1013.91 +584.361 +1 +1014.01 +619.158 +1 +1014.11 +618.527 +1 +1014.21 +619.188 +1 +1014.31 +606.433 +1 +1014.41 +602.386 +1 +1014.51 +600.324 +1 +1014.61 +589.299 +1 +1014.71 +577.321 +1 +1014.81 +579.679 +1 +1014.91 +594.519 +1 +1015.01 +606.455 +1 +1015.11 +603.592 +1 +1015.21 +592.769 +1 +1015.31 +592.667 +1 +1015.41 +597.347 +1 +1015.51 +598.124 +1 +1015.61 +613.572 +1 +1015.61 +613.572 +1 +1015.66 +606.643 +1 +1015.71 +596.493 +1 +1015.71 +596.493 +1 +1015.76 +589.147 +1 +1015.81 +588.693 +1 +1015.81 +588.693 +1 +1015.86 +579.432 +1 +1015.91 +581.863 +1 +1015.91 +581.863 +1 +1015.96 +590.761 +1 +1016.01 +606.759 +1 +1016.01 +606.759 +1 +1016.06 +609.806 +1 +1016.11 +596.144 +1 +1016.11 +596.144 +1 +1016.16 +592.706 +1 +1016.21 +598.696 +1 +1016.21 +598.696 +1 +1016.26 +611.189 +1 +1016.31 +606.286 +1 +1016.31 +606.286 +1 +1016.36 +599.476 +1 +1016.41 +595.682 +1 +1016.41 +595.682 +1 +1016.46 +596.852 +1 +1016.51 +597.099 +1 +1016.51 +597.099 +1 +1016.56 +598.501 +1 +1016.61 +605.691 +1 +1016.61 +605.691 +1 +1016.66 +610.47 +1 +1016.71 +593.859 +1 +1016.76 +587.774 +1 +1016.81 +596.403 +1 +1016.86 +606.607 +1 +1016.91 +594.915 +1 +1016.96 +590.241 +1 +1017.01 +587.636 +1 +1017.06 +593.328 +1 +1017.11 +606.761 +1 +1017.16 +614.115 +1 +1017.21 +607.689 +1 +1017.26 +606.91 +1 +1017.31 +604.424 +1 +1017.36 +602.25 +1 +1017.41 +596.921 +1 +1017.46 +598.695 +1 +1017.51 +596.989 +1 +1017.56 +616.919 +1 +1017.61 +630.31 +1 +1017.66 +622.391 +1 +1017.71 +607.099 +1 +1017.76 +595.336 +1 +1017.81 +587.203 +1 +1017.86 +595.983 +1 +1017.91 +605.75 +1 +1017.96 +615.677 +1 +1018.01 +625.619 +1 +1018.06 +613.386 +1 +1018.11 +605.926 +1 +1018.16 +617.972 +1 +1018.21 +625.144 +1 +1018.26 +622.84 +1 +1018.31 +627.313 +1 +1018.36 +632.35 +1 +1018.41 +632.086 +1 +1018.46 +627.843 +1 +1018.51 +633.444 +1 +1018.56 +634.983 +1 +1018.61 +644.948 +1 +1018.66 +640.885 +1 +1018.71 +636.764 +1 +1018.76 +635.98 +1 +1018.81 +641.379 +1 +1018.86 +635.21 +1 +1018.91 +637.855 +1 +1018.96 +640.268 +1 +1019.01 +636.099 +1 +1019.06 +639.37 +1 +1019.11 +652.623 +1 +1019.16 +650.936 +1 +1019.21 +641.447 +1 +1019.26 +633.369 +1 +1019.31 +632.682 +1 +1019.36 +655.528 +1 +1019.41 +663.565 +1 +1019.46 +641.491 +1 +1019.51 +635.212 +1 +1019.56 +654.307 +1 +1019.61 +660.336 +1 +1019.66 +646.061 +1 +1019.71 +633.939 +1 +1019.76 +636.468 +1 +1019.81 +654.36 +1 +1019.86 +662.07 +1 +1019.91 +664.706 +1 +1019.96 +657.652 +1 +1020.01 +659.696 +1 +1020.06 +670.068 +1 +1020.11 +657.005 +1 +1020.16 +642.071 +1 +1020.21 +639.889 +1 +1020.26 +652.869 +1 +1020.31 +647.107 +1 +1020.36 +646.274 +1 +1020.41 +650.887 +1 +1020.46 +642.982 +1 +1020.51 +650.078 +1 +1020.56 +652.998 +1 +1020.61 +647.973 +1 +1020.66 +644.93 +1 +1020.71 +642.48 +1 +1020.76 +645.896 +1 +1020.81 +641.294 +1 +1020.86 +639.946 +1 +1020.91 +621.76 +1 +1020.96 +612.865 +1 +1021.01 +633.689 +1 +1021.06 +650.912 +1 +1021.11 +641.391 +1 +1021.16 +635.865 +1 +1021.21 +642.629 +1 +1021.26 +630.395 +1 +1021.31 +625.183 +1 +1021.36 +619.537 +1 +1021.41 +597.361 +1 +1021.46 +601.796 +1 +1021.51 +611.948 +1 +1021.56 +614.391 +1 +1021.61 +603.574 +1 +1021.66 +597.574 +1 +1021.71 +611.698 +1 +1021.76 +624.68 +1 +1021.81 +606.544 +1 +1021.86 +602.935 +1 +1021.91 +598.509 +1 +1021.96 +596.883 +1 +1022.01 +611.599 +1 +1022.06 +620.342 +1 +1022.11 +613.523 +1 +1022.16 +604.326 +1 +1022.21 +590.066 +1 +1022.26 +600.494 +1 +1022.31 +606.824 +1 +1022.36 +609.488 +1 +1022.41 +613.648 +1 +1022.46 +625.965 +1 +1022.51 +630.209 +1 +1022.56 +631.693 +1 +1022.61 +631.426 +1 +1022.66 +622.286 +1 +1022.71 +616.234 +1 +1022.76 +624.195 +1 +1022.81 +617.276 +1 +1022.86 +615.601 +1 +1022.91 +612.854 +1 +1022.96 +614.498 +1 +1023.01 +619.12 +1 +1023.06 +616.276 +1 +1023.11 +616.27 +1 +1023.16 +627.49 +1 +1023.21 +630.329 +1 +1023.26 +633.982 +1 +1023.31 +642.111 +1 +1023.36 +653.565 +1 +1023.41 +661.154 +1 +1023.46 +658.673 +1 +1023.51 +649.041 +1 +1023.56 +654.01 +1 +1023.61 +653.472 +1 +1023.66 +659.6 +1 +1023.71 +672.917 +1 +1023.76 +696.757 +1 +1023.81 +699.632 +1 +1023.86 +700.605 +1 +1023.91 +722.662 +1 +1023.96 +721.115 +1 +1024.01 +707.336 +1 +1024.06 +716.577 +1 +1024.11 +724.502 +1 +1024.16 +727.607 +1 +1024.21 +738.511 +1 +1024.26 +744.571 +1 +1024.31 +762.687 +1 +1024.36 +782.149 +1 +1024.41 +786.671 +1 +1024.46 +807.825 +1 +1024.51 +843.475 +1 +1024.56 +852.08 +1 +1024.61 +861.424 +1 +1024.66 +889.127 +1 +1024.71 +917.206 +1 +1024.76 +947.463 +1 +1024.81 +972.005 +1 +1024.86 +998.212 +1 +1024.91 +1028.03 +1 +1024.96 +1074.52 +1 +1025.01 +1085.06 +1 +1025.06 +1104.14 +1 +1025.11 +1127.84 +1 +1025.16 +1146.89 +1 +1025.21 +1180.85 +1 +1025.26 +1204.02 +1 +1025.31 +1205.46 +1 +1025.36 +1228.78 +1 +1025.41 +1242.28 +1 +1025.46 +1263.49 +1 +1025.51 +1289.05 +1 +1025.56 +1297.93 +1 +1025.61 +1306.35 +1 +1025.66 +1306.82 +1 +1025.71 +1311.04 +1 +1025.76 +1297.79 +1 +1025.81 +1283.7 +1 +1025.86 +1305.61 +1 +1025.91 +1318.77 +1 +1025.96 +1311.91 +1 +1026.01 +1291.32 +1 +1026.06 +1278.79 +1 +1026.11 +1281.26 +1 +1026.16 +1258.34 +1 +1026.21 +1239.21 +1 +1026.26 +1226.52 +1 +1026.31 +1203.76 +1 +1026.36 +1180.8 +1 +1026.41 +1158.37 +1 +1026.46 +1107.57 +1 +1026.51 +1078.51 +1 +1026.56 +1053.42 +1 +1026.61 +1020.15 +1 +1026.66 +966.384 +1 +1026.71 +928.974 +1 +1026.76 +914.815 +1 +1026.81 +889.388 +1 +1026.86 +853.786 +1 +1026.91 +824.393 +1 +1026.96 +813.064 +1 +1027.01 +792 +1 +1027.06 +751.093 +1 +1027.11 +714.097 +1 +1027.16 +710.105 +1 +1027.21 +695.528 +1 +1027.26 +684.222 +1 +1027.31 +685.561 +1 +1027.36 +684.72 +1 +1027.41 +668.26 +1 +1027.46 +627.587 +1 +1027.51 +631.47 +1 +1027.56 +658.623 +1 +1027.61 +637.027 +1 +1027.66 +642.104 +1 +1027.71 +640.778 +1 +1027.76 +633.631 +1 +1027.81 +634.57 +1 +1027.86 +628.873 +1 +1027.91 +618.156 +1 +1027.96 +612.279 +1 +1028.01 +599.723 +1 +1028.06 +604.039 +1 +1028.11 +629.057 +1 +1028.16 +642.082 +1 +1028.21 +620.889 +1 +1028.26 +622.357 +1 +1028.31 +629.837 +1 +1028.36 +619.895 +1 +1028.41 +622.267 +1 +1028.46 +622.023 +1 +1028.51 +620.128 +1 +1028.56 +625.951 +1 +1028.61 +631.855 +1 +1028.66 +614.199 +1 +1028.71 +614.635 +1 +1028.76 +617.21 +1 +1028.81 +598.893 +1 +1028.86 +610.767 +1 +1028.91 +628.933 +1 +1028.96 +626.956 +1 +1029.01 +613.245 +1 +1029.06 +614.639 +1 +1029.11 +626.144 +1 +1029.16 +625.542 +1 +1029.21 +628.511 +1 +1029.26 +632.868 +1 +1029.31 +627.299 +1 +1029.36 +619.494 +1 +1029.41 +627.466 +1 +1029.46 +630.058 +1 +1029.51 +638.279 +1 +1029.56 +659.878 +1 +1029.61 +656.9 +1 +1029.66 +646.594 +1 +1029.71 +664.871 +1 +1029.76 +683.659 +1 +1029.81 +682.119 +1 +1029.86 +681.045 +1 +1029.91 +691.803 +1 +1029.96 +706.242 +1 +1030.01 +711.438 +1 +1030.06 +706.374 +1 +1030.11 +722.547 +1 +1030.16 +762.85 +1 +1030.21 +779.71 +1 +1030.26 +796.785 +1 +1030.31 +818.387 +1 +1030.36 +819.516 +1 +1030.41 +841.578 +1 +1030.46 +865.099 +1 +1030.51 +869.894 +1 +1030.56 +900.825 +1 +1030.61 +953.821 +1 +1030.66 +976.082 +1 +1030.71 +1014.67 +1 +1030.76 +1053.07 +1 +1030.81 +1098.15 +1 +1030.86 +1141.38 +1 +1030.91 +1180.55 +1 +1030.96 +1223.69 +1 +1031.01 +1290.65 +1 +1031.06 +1350.41 +1 +1031.11 +1413.9 +1 +1031.16 +1470.94 +1 +1031.21 +1522.83 +1 +1031.26 +1606.21 +1 +1031.31 +1683.65 +1 +1031.36 +1750.5 +1 +1031.41 +1805.37 +1 +1031.46 +1844.15 +1 +1031.51 +1882.09 +1 +1031.56 +1911.79 +1 +1031.61 +1937.36 +1 +1031.66 +1935.1 +1 +1031.71 +1902.05 +1 +1031.76 +1867.2 +1 +1031.81 +1820.49 +1 +1031.86 +1769.3 +1 +1031.91 +1733.01 +1 +1031.96 +1703.26 +1 +1032.01 +1674.2 +1 +1032.06 +1627.17 +1 +1032.11 +1594.21 +1 +1032.16 +1564.9 +1 +1032.21 +1532.43 +1 +1032.26 +1480 +1 +1032.31 +1412.55 +1 +1032.36 +1341.55 +1 +1032.41 +1276.98 +1 +1032.46 +1208.53 +1 +1032.51 +1103.07 +1 +1032.56 +991.97 +1 +1032.61 +898.867 +1 +1032.66 +801.315 +1 +1032.71 +693.039 +1 +1032.76 +607.106 +1 +1032.81 +524.306 +1 +1032.86 +430.964 +1 +1032.91 +360.997 +1 +1032.96 +316.891 +1 +1033.01 +265.384 +1 +1033.06 +218.663 +1 +1033.11 +184.599 +1 +1033.16 +163.276 +1 +1033.21 +146.727 +1 +1033.26 +128.282 +1 +1033.31 +115.72 +1 +1033.36 +102.206 +1 +1033.41 +84.3599 +1 +1033.46 +76.3419 +1 +1033.51 +73.258 +1 +1033.56 +68.9179 +1 +1033.61 +65.1807 +1 +1033.66 +56.2314 +1 +1033.71 +49.6746 +1 +1033.76 +52.1579 +1 +1033.81 +49.7747 +1 +1033.86 +46.0503 +1 +1033.91 +36.4411 +1 +1033.96 +29.5619 +1 +1034.01 +32.4556 +1 +1034.06 +32.9876 +1 +1034.11 +31.6081 +1 +1034.16 +31.8027 +1 +1034.21 +33.807 +1 +1034.26 +35.8312 +1 +1034.31 +29.7257 +1 +1034.36 +24.3449 +1 +1034.41 +21.9194 +1 +1034.46 +25.1065 +1 +1034.51 +30.7035 +1 +1034.56 +28.6187 +1 +1034.61 +21.3205 +1 +1034.66 +24.2862 +1 +1034.71 +23.786 +1 +1034.76 +21.619 +1 +1034.81 +17.8064 +1 +1034.86 +16.3473 +1 +1034.91 +18.0522 +1 +1034.96 +20.8006 +1 +1035.01 +20.7355 +1 +1035.06 +19.2328 +1 +1035.11 +13.6358 +1 +1035.16 +14.2518 +1 +1035.21 +12.7428 +1 +1035.26 +11.468 +1 +1035.31 +9.25257 +1 +1035.36 +11.8099 +1 +1035.41 +17.8825 +1 +1035.46 +22.5386 +1 +1035.51 +21.1059 +1 +1035.56 +18.5313 +1 +1035.61 +16.1824 +1 +1035.66 +14.0897 +1 +1035.71 +17.0204 +1 +1035.76 +14.6167 +1 +1035.81 +9.60597 +1 +1035.86 +9.16277 +1 +1035.91 +11.145 +1 +1035.96 +9.83835 +1 +1036.01 +12.7076 +1 +1036.06 +14.9464 +1 +1036.11 +16.3768 +1 +1036.16 +13.8208 +1 +1036.21 +9.75438 +1 +1036.26 +6.88693 +1 +1036.31 +6.69721 +1 +1036.36 +8.23845 +1 +1036.41 +7.37087 +1 +1036.46 +6.43268 +1 +1036.51 +5.21011 +1 +1036.56 +4.52699 +1 +1036.61 +8.72831 +1 +1036.66 +9.3681 +1 +1036.71 +3.6229 +1 +1036.76 +3.03928 +1 +1036.81 +3.17743 +1 +1036.86 +4.20203 +1 +1036.91 +1.47699 +1 +1036.96 +6.18683 +1 +1037.01 +9.76206 +1 +1037.06 +7.32739 +1 +1037.11 +5.90447 +1 +1037.16 +5.52773 +1 +1037.21 +5.99246 +1 +1037.26 +1.44937 +1 +1037.31 +3.90965 +1 +1037.36 +6.36227 +1 +1037.41 +5.08157 +1 +1037.46 +4.98903 +1 +1037.51 +6.53262 +1 +1037.56 +7.41351 +1 +1037.61 +6.63376 +1 +1037.66 +5.79297 +1 +1037.71 +4.39155 +1 +1037.76 +4.02456 +1 +1037.81 +0.0817091 +1 +1037.86 +-1.30378 +1 +1037.91 +-0.488158 +1 +1037.96 +2.33727 +1 +1038.01 +3.97329 +1 +1038.06 +0.00398757 +1 +1038.11 +1.92559 +1 +1038.16 +7.03095 +1 +1038.21 +5.79007 +1 +1038.26 +2.50004 +1 +1038.31 +2.19749 +1 +1038.36 +0.677344 +1 +1038.41 +-0.0809204 +1 +1038.46 +1.75695 +1 +1038.51 +4.7773 +1 +1038.56 +4.94552 +1 +1038.61 +8.75129 +1 +1038.66 +8.18276 +1 +1038.71 +3.21884 +1 +1038.76 +0.187503 +1 +1038.81 +-1.35327 +1 +1038.86 +2.13401 +1 +1038.91 +-1.81348 +1 +1038.96 +0.645525 +1 +1039.01 +1.8464 +1 +1039.06 +-1.18018 +1 +1039.11 +3.18172 +1 +1039.16 +5.59011 +1 +1039.21 +1.00807 +1 +1039.26 +-1.82137 +1 +1039.31 +0 +1 +1039.36 +0 +1 +1039.41 +0 +1 +1039.46 +0 +1 +1039.51 +0 +1 +1039.56 +0 +1 +1039.61 +0 +1 +1039.66 +0 +1 +1039.71 +0 +1 +1039.76 +0 +1 +1039.81 +0 +1 +1039.86 +0 +1 +1039.91 +0 +1 +1039.96 +0 +1 +1040.01 +0 +1 +1040.06 +0 +1 +1040.11 +0 +1 +1040.16 +0 +1 +1040.21 +0 +1 +1040.26 +0 +1 +1040.31 +0 +1 +1040.36 +0 +1 +1040.41 +0 +1 +1040.46 +0 +1 +1040.51 +0 +1 +1040.56 +0 +1 +1040.61 +0 +1 +&Ti2O3 +Ti2O3 +0 +0 +0 +0 +0 +0 +0 +12 +Casa Info Follows +0 +0 +0 +0 + +PCA Coefs = 179186, -26548.4, -22890.8, 3691.07, -1602.46, -1706.5, +C:\Users\Mark\ownCloud\Muelheim Group\Projects\TiO2\analyzed data\EX209_CEC303 Ti slow oxidation - curated - irregular.vms +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +CasaXP2 +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p LS +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.61 +0 +1 +986.71 +0 +1 +986.81 +0 +1 +986.91 +0 +1 +987.01 +0 +1 +987.11 +2534.66 +1 +987.21 +2537.49 +1 +987.31 +2540.32 +1 +987.41 +2543.17 +1 +987.51 +2546.02 +1 +987.61 +2548.86 +1 +987.71 +2551.71 +1 +987.81 +2554.57 +1 +987.91 +2557.43 +1 +988.01 +2560.29 +1 +988.11 +2563.15 +1 +988.21 +2566.02 +1 +988.31 +2568.89 +1 +988.41 +2571.77 +1 +988.51 +2574.65 +1 +988.61 +2577.53 +1 +988.71 +2580.42 +1 +988.81 +2583.31 +1 +988.91 +2586.21 +1 +989.01 +2589.1 +1 +989.11 +2592.01 +1 +989.21 +2594.92 +1 +989.31 +2597.83 +1 +989.41 +2600.73 +1 +989.51 +2603.65 +1 +989.61 +2606.58 +1 +989.71 +2609.5 +1 +989.81 +2612.43 +1 +989.91 +2615.4 +1 +990.01 +2618.6 +1 +990.11 +2621.8 +1 +990.21 +2625 +1 +990.31 +2628.21 +1 +990.41 +2631.42 +1 +990.51 +2634.65 +1 +990.61 +2637.87 +1 +990.71 +2641.09 +1 +990.81 +2644.32 +1 +990.91 +2647.56 +1 +991.01 +2650.81 +1 +991.11 +2654.05 +1 +991.21 +2657.29 +1 +991.31 +2660.55 +1 +991.41 +2663.82 +1 +991.51 +2667.08 +1 +991.61 +2670.34 +1 +991.71 +2673.62 +1 +991.81 +2676.9 +1 +991.91 +2680.19 +1 +992.01 +2683.47 +1 +992.11 +2686.76 +1 +992.21 +2690.07 +1 +992.31 +2693.38 +1 +992.41 +2696.69 +1 +992.51 +2699.99 +1 +992.61 +2703.32 +1 +992.71 +2706.66 +1 +992.81 +2709.99 +1 +992.91 +2713.33 +1 +993.01 +2716.67 +1 +993.11 +2720.03 +1 +993.21 +2723.39 +1 +993.31 +2726.96 +1 +993.41 +2730.67 +1 +993.51 +2734.4 +1 +993.61 +2738.13 +1 +993.71 +2741.86 +1 +993.81 +2745.59 +1 +993.91 +2749.35 +1 +994.01 +2753.1 +1 +994.11 +2756.86 +1 +994.21 +2760.62 +1 +994.31 +2764.39 +1 +994.41 +2768.17 +1 +994.51 +2771.96 +1 +994.61 +2775.74 +1 +994.71 +2779.53 +1 +994.81 +2783.35 +1 +994.91 +2787.17 +1 +995.01 +2790.99 +1 +995.11 +2794.8 +1 +995.21 +2798.64 +1 +995.31 +2802.49 +1 +995.41 +2806.34 +1 +995.51 +2810.19 +1 +995.61 +2814.04 +1 +995.71 +2817.92 +1 +995.81 +2821.8 +1 +995.91 +2825.68 +1 +996.01 +2829.55 +1 +996.11 +2833.46 +1 +996.21 +2837.37 +1 +996.31 +2841.28 +1 +996.41 +2845.19 +1 +996.51 +2849.12 +1 +996.61 +2853.09 +1 +996.71 +2857.46 +1 +996.81 +2861.84 +1 +996.91 +2866.23 +1 +997.01 +2870.65 +1 +997.11 +2875.06 +1 +997.21 +2879.48 +1 +997.31 +2883.9 +1 +997.41 +2888.34 +1 +997.51 +2892.79 +1 +997.61 +2897.24 +1 +997.71 +2901.69 +1 +997.81 +2906.16 +1 +997.91 +2910.65 +1 +998.01 +2915.13 +1 +998.11 +2919.62 +1 +998.21 +2924.11 +1 +998.31 +2926.65 +1 +998.41 +2931.18 +1 +998.51 +2935.73 +1 +998.61 +2940.28 +1 +998.71 +2944.89 +1 +998.81 +2949.51 +1 +998.91 +2954.15 +1 +999.01 +2958.8 +1 +999.11 +2963.5 +1 +999.21 +2968.22 +1 +999.31 +2972.97 +1 +999.41 +2977.73 +1 +999.51 +2982.5 +1 +999.61 +2987.33 +1 +999.71 +2992.17 +1 +999.81 +2997.02 +1 +999.91 +3001.89 +1 +1000.01 +3006.8 +1 +1000.11 +3011.74 +1 +1000.21 +3016.69 +1 +1000.31 +3021.66 +1 +1000.41 +3026.65 +1 +1000.51 +3031.69 +1 +1000.61 +3036.74 +1 +1000.71 +3041.8 +1 +1000.81 +3046.88 +1 +1000.91 +3052.02 +1 +1001.01 +3057.17 +1 +1001.11 +3062.33 +1 +1001.21 +3067.52 +1 +1001.31 +3072.75 +1 +1001.41 +3078.01 +1 +1001.51 +3083.29 +1 +1001.61 +3088.58 +1 +1001.71 +3093.9 +1 +1001.81 +3099.26 +1 +1001.91 +3104.64 +1 +1002.01 +3110.03 +1 +1002.11 +3115.44 +1 +1002.21 +3120.89 +1 +1002.31 +3126.36 +1 +1002.41 +3131.85 +1 +1002.51 +3137.36 +1 +1002.61 +3142.9 +1 +1002.71 +3148.46 +1 +1002.81 +3154.05 +1 +1002.91 +3159.64 +1 +1003.01 +3165.27 +1 +1003.11 +3170.93 +1 +1003.21 +3176.6 +1 +1003.31 +3182.29 +1 +1003.41 +3188.03 +1 +1003.51 +3193.8 +1 +1003.61 +3199.59 +1 +1003.71 +3205.4 +1 +1003.81 +3211.23 +1 +1003.91 +3217.08 +1 +1004.01 +3222.96 +1 +1004.11 +3228.85 +1 +1004.21 +3234.76 +1 +1004.31 +3240.69 +1 +1004.41 +3246.65 +1 +1004.51 +3252.63 +1 +1004.61 +3258.62 +1 +1004.71 +3264.63 +1 +1004.81 +3270.66 +1 +1004.91 +3276.72 +1 +1005.01 +3282.79 +1 +1005.11 +3288.87 +1 +1005.21 +3294.97 +1 +1005.31 +3301.09 +1 +1005.41 +3307.23 +1 +1005.51 +3313.4 +1 +1005.61 +3319.62 +1 +1005.71 +3325.85 +1 +1005.81 +3332.09 +1 +1005.91 +3338.35 +1 +1006.01 +3344.63 +1 +1006.11 +3350.92 +1 +1006.21 +3357.21 +1 +1006.31 +3363.53 +1 +1006.41 +3369.85 +1 +1006.51 +3376.19 +1 +1006.61 +3382.36 +1 +1006.71 +3388.72 +1 +1006.81 +3395.09 +1 +1006.91 +3401.48 +1 +1007.01 +3407.85 +1 +1007.11 +3414.25 +1 +1007.21 +3420.66 +1 +1007.31 +3427.09 +1 +1007.41 +3433.51 +1 +1007.51 +3439.92 +1 +1007.61 +3446.36 +1 +1007.71 +3452.82 +1 +1007.81 +3459.27 +1 +1007.91 +3465.69 +1 +1008.01 +3472.13 +1 +1008.11 +3478.59 +1 +1008.21 +3485.07 +1 +1008.31 +3491.48 +1 +1008.41 +3497.9 +1 +1008.51 +3504.34 +1 +1008.61 +3510.8 +1 +1008.71 +3517.21 +1 +1008.81 +3523.58 +1 +1008.91 +3529.97 +1 +1009.01 +3536.38 +1 +1009.11 +3542.78 +1 +1009.21 +3549.05 +1 +1009.31 +3555.35 +1 +1009.41 +3561.67 +1 +1009.51 +3568.02 +1 +1009.61 +3574.18 +1 +1009.71 +3580.33 +1 +1009.81 +3586.51 +1 +1009.91 +3592.71 +1 +1010.01 +3598.78 +1 +1010.11 +3604.71 +1 +1010.21 +3610.67 +1 +1010.31 +3616.66 +1 +1010.41 +3622.61 +1 +1010.51 +3628.23 +1 +1010.61 +3633.89 +1 +1010.71 +3639.57 +1 +1010.81 +3645.28 +1 +1010.91 +3650.59 +1 +1011.01 +3655.82 +1 +1011.11 +3661.07 +1 +1011.21 +3666.36 +1 +1011.31 +3671.39 +1 +1011.41 +3676.05 +1 +1011.51 +3680.74 +1 +1011.61 +3685.47 +1 +1011.71 +3690.17 +1 +1011.81 +3694.09 +1 +1011.91 +3698.04 +1 +1012.01 +3702.04 +1 +1012.11 +3706.07 +1 +1012.21 +3709.35 +1 +1012.31 +3712.37 +1 +1012.41 +3715.43 +1 +1012.51 +3718.54 +1 +1012.61 +3721.21 +1 +1012.71 +3723.06 +1 +1012.81 +3724.96 +1 +1012.91 +3726.92 +1 +1013.01 +3728.93 +1 +1013.11 +3729.37 +1 +1013.21 +3729.87 +1 +1013.31 +3730.44 +1 +1013.41 +3731.07 +1 +1013.51 +3730.56 +1 +1013.61 +3729.43 +1 +1013.71 +3728.37 +1 +1013.81 +3727.39 +1 +1013.91 +3725.88 +1 +1014.01 +3722.88 +1 +1014.11 +3719.97 +1 +1014.21 +3717.16 +1 +1014.31 +3714.45 +1 +1014.41 +3709.61 +1 +1014.51 +3704.68 +1 +1014.61 +3699.88 +1 +1014.71 +3695.2 +1 +1014.81 +3689.16 +1 +1014.91 +3682.1 +1 +1015.01 +3675.2 +1 +1015.11 +3668.45 +1 +1015.21 +3661.3 +1 +1015.31 +3652.12 +1 +1015.41 +3643.14 +1 +1015.51 +3634.37 +1 +1015.61 +3625.84 +1 +1015.61 +3625.84 +1 +1015.66 +3620.66 +1 +1015.71 +3615.11 +1 +1015.71 +3615.11 +1 +1015.76 +3609.62 +1 +1015.81 +3604.19 +1 +1015.81 +3604.19 +1 +1015.86 +3598.85 +1 +1015.91 +3593.58 +1 +1015.91 +3593.58 +1 +1015.96 +3588.38 +1 +1016.01 +3583.28 +1 +1016.01 +3583.28 +1 +1016.06 +3578.25 +1 +1016.11 +3571.92 +1 +1016.11 +3571.92 +1 +1016.16 +3565.64 +1 +1016.21 +3559.45 +1 +1016.21 +3559.45 +1 +1016.26 +3553.38 +1 +1016.31 +3547.41 +1 +1016.31 +3547.41 +1 +1016.36 +3541.56 +1 +1016.41 +3535.81 +1 +1016.41 +3535.81 +1 +1016.46 +3530.19 +1 +1016.51 +3524.34 +1 +1016.51 +3524.34 +1 +1016.56 +3517.6 +1 +1016.61 +3511.01 +1 +1016.61 +3511.01 +1 +1016.66 +3504.55 +1 +1016.71 +3498.24 +1 +1016.76 +3492.09 +1 +1016.81 +3486.1 +1 +1016.86 +3480.28 +1 +1016.91 +3474.63 +1 +1016.96 +3468.5 +1 +1017.01 +3461.97 +1 +1017.06 +3455.65 +1 +1017.11 +3449.55 +1 +1017.16 +3443.66 +1 +1017.21 +3438.03 +1 +1017.26 +3432.65 +1 +1017.31 +3427.55 +1 +1017.36 +3422.73 +1 +1017.41 +3417.27 +1 +1017.46 +3411.93 +1 +1017.51 +3406.89 +1 +1017.56 +3402.17 +1 +1017.61 +3397.8 +1 +1017.66 +3393.78 +1 +1017.71 +3390.14 +1 +1017.76 +3386.89 +1 +1017.81 +3383.95 +1 +1017.86 +3380.66 +1 +1017.91 +3377.82 +1 +1017.96 +3375.46 +1 +1018.01 +3373.58 +1 +1018.06 +3372.22 +1 +1018.11 +3371.39 +1 +1018.16 +3371.11 +1 +1018.21 +3371.43 +1 +1018.26 +3372.1 +1 +1018.31 +3373 +1 +1018.36 +3374.57 +1 +1018.41 +3376.8 +1 +1018.46 +3379.75 +1 +1018.51 +3383.45 +1 +1018.56 +3387.95 +1 +1018.61 +3393.25 +1 +1018.66 +3399.36 +1 +1018.71 +3406.04 +1 +1018.76 +3413.45 +1 +1018.81 +3421.76 +1 +1018.86 +3431.01 +1 +1018.91 +3441.2 +1 +1018.96 +3452.41 +1 +1019.01 +3464.61 +1 +1019.06 +3477.86 +1 +1019.11 +3492.19 +1 +1019.16 +3507.44 +1 +1019.21 +3523.9 +1 +1019.26 +3541.56 +1 +1019.31 +3560.42 +1 +1019.36 +3580.48 +1 +1019.41 +3601.75 +1 +1019.46 +3624.26 +1 +1019.51 +3648.01 +1 +1019.56 +3673.04 +1 +1019.61 +3699.4 +1 +1019.66 +3727.03 +1 +1019.71 +3755.98 +1 +1019.76 +3786.21 +1 +1019.81 +3817.74 +1 +1019.86 +3850.68 +1 +1019.91 +3884.92 +1 +1019.96 +3920.46 +1 +1020.01 +3957.41 +1 +1020.06 +3995.78 +1 +1020.11 +4035.38 +1 +1020.16 +4076.21 +1 +1020.21 +4118.22 +1 +1020.26 +4161.53 +1 +1020.31 +4206.02 +1 +1020.36 +4251.59 +1 +1020.41 +4298.2 +1 +1020.46 +4346.19 +1 +1020.51 +4395.27 +1 +1020.56 +4445.24 +1 +1020.61 +4496.01 +1 +1020.66 +4547.51 +1 +1020.71 +4599.65 +1 +1020.76 +4651.63 +1 +1020.81 +4704.83 +1 +1020.86 +4758.52 +1 +1020.91 +4813.16 +1 +1020.96 +4868.01 +1 +1021.01 +4923.03 +1 +1021.06 +4978.03 +1 +1021.11 +5032.97 +1 +1021.16 +5087.71 +1 +1021.21 +5142.11 +1 +1021.26 +5196.1 +1 +1021.31 +5249.77 +1 +1021.36 +5303.31 +1 +1021.41 +5356.04 +1 +1021.46 +5407.82 +1 +1021.51 +5458.61 +1 +1021.56 +5508.13 +1 +1021.61 +5556.41 +1 +1021.66 +5603.24 +1 +1021.71 +5648.51 +1 +1021.76 +5692.75 +1 +1021.81 +5735.41 +1 +1021.86 +5776.08 +1 +1021.91 +5814.66 +1 +1021.96 +5851.07 +1 +1022.01 +5885.27 +1 +1022.06 +5916.99 +1 +1022.11 +5946.31 +1 +1022.16 +5973 +1 +1022.21 +5997.95 +1 +1022.26 +6020.28 +1 +1022.31 +6039.67 +1 +1022.36 +6056.29 +1 +1022.41 +6069.86 +1 +1022.46 +6080.45 +1 +1022.51 +6087.81 +1 +1022.56 +6091.92 +1 +1022.61 +6093.25 +1 +1022.66 +6092.13 +1 +1022.71 +6087.92 +1 +1022.76 +6080.6 +1 +1022.81 +6070.03 +1 +1022.86 +6056.48 +1 +1022.91 +6039.72 +1 +1022.96 +6019.98 +1 +1023.01 +5997.27 +1 +1023.06 +5972.05 +1 +1023.11 +5944.62 +1 +1023.16 +5914.08 +1 +1023.21 +5880.87 +1 +1023.26 +5845.08 +1 +1023.31 +5806.76 +1 +1023.36 +5766.23 +1 +1023.41 +5723.32 +1 +1023.46 +5678.44 +1 +1023.51 +5632.41 +1 +1023.56 +5584.79 +1 +1023.61 +5535.69 +1 +1023.66 +5484.99 +1 +1023.71 +5433.15 +1 +1023.76 +5380.23 +1 +1023.81 +5326.34 +1 +1023.86 +5271.83 +1 +1023.91 +5216.77 +1 +1023.96 +5162.51 +1 +1024.01 +5108.2 +1 +1024.06 +5054.09 +1 +1024.11 +5000.49 +1 +1024.16 +4947.42 +1 +1024.21 +4895.34 +1 +1024.26 +4844.33 +1 +1024.31 +4794.67 +1 +1024.36 +4746.97 +1 +1024.41 +4701.6 +1 +1024.46 +4658.34 +1 +1024.51 +4617.33 +1 +1024.56 +4578.85 +1 +1024.61 +4543.15 +1 +1024.66 +4510.37 +1 +1024.71 +4480.83 +1 +1024.76 +4454.66 +1 +1024.81 +4432.65 +1 +1024.86 +4414.77 +1 +1024.91 +4400.88 +1 +1024.96 +4391.18 +1 +1025.01 +4385.83 +1 +1025.06 +4385.02 +1 +1025.11 +4388.87 +1 +1025.16 +4397.65 +1 +1025.21 +4411.38 +1 +1025.26 +4430.93 +1 +1025.31 +4455.73 +1 +1025.36 +4485.79 +1 +1025.41 +4521.23 +1 +1025.46 +4562.05 +1 +1025.51 +4608.35 +1 +1025.56 +4660.11 +1 +1025.61 +4717.33 +1 +1025.66 +4780.21 +1 +1025.71 +4849.05 +1 +1025.76 +4923.35 +1 +1025.81 +5003.01 +1 +1025.86 +5087.93 +1 +1025.91 +5178.01 +1 +1025.96 +5273 +1 +1026.01 +5372.92 +1 +1026.06 +5477.43 +1 +1026.11 +5586.72 +1 +1026.16 +5700.64 +1 +1026.21 +5818.49 +1 +1026.26 +5940.2 +1 +1026.31 +6065.31 +1 +1026.36 +6193.61 +1 +1026.41 +6324.81 +1 +1026.46 +6458.48 +1 +1026.51 +6594.51 +1 +1026.56 +6732.71 +1 +1026.61 +6872.49 +1 +1026.66 +7013.32 +1 +1026.71 +7154.68 +1 +1026.76 +7296.37 +1 +1026.81 +7437.73 +1 +1026.86 +7578.44 +1 +1026.91 +7718.05 +1 +1026.96 +7856.03 +1 +1027.01 +7992.59 +1 +1027.06 +8126.58 +1 +1027.11 +8257.69 +1 +1027.16 +8385.44 +1 +1027.21 +8509.3 +1 +1027.26 +8628.95 +1 +1027.31 +8743.8 +1 +1027.36 +8853.55 +1 +1027.41 +8957.88 +1 +1027.46 +9056.52 +1 +1027.51 +9148.9 +1 +1027.56 +9234.5 +1 +1027.61 +9313.1 +1 +1027.66 +9384.3 +1 +1027.71 +9447.8 +1 +1027.76 +9503.41 +1 +1027.81 +9550.78 +1 +1027.86 +9590.02 +1 +1027.91 +9620.76 +1 +1027.96 +9642.69 +1 +1028.01 +9655.72 +1 +1028.06 +9659.65 +1 +1028.11 +9654.5 +1 +1028.16 +9640.16 +1 +1028.21 +9616.61 +1 +1028.26 +9583.92 +1 +1028.31 +9542.38 +1 +1028.36 +9491.87 +1 +1028.41 +9432.38 +1 +1028.46 +9364.1 +1 +1028.51 +9287.19 +1 +1028.56 +9201.79 +1 +1028.61 +9108.21 +1 +1028.66 +9006.6 +1 +1028.71 +8897.33 +1 +1028.76 +8780.91 +1 +1028.81 +8657.33 +1 +1028.86 +8527.02 +1 +1028.91 +8390.24 +1 +1028.96 +8247.41 +1 +1029.01 +8098.89 +1 +1029.06 +7945.05 +1 +1029.11 +7786.37 +1 +1029.16 +7623.31 +1 +1029.21 +7456.33 +1 +1029.26 +7285.73 +1 +1029.31 +7111.88 +1 +1029.36 +6935.27 +1 +1029.41 +6756.28 +1 +1029.46 +6575.34 +1 +1029.51 +6392.88 +1 +1029.56 +6209.28 +1 +1029.61 +6025.16 +1 +1029.66 +5840.77 +1 +1029.71 +5656.43 +1 +1029.76 +5472.53 +1 +1029.81 +5289.4 +1 +1029.86 +5107.42 +1 +1029.91 +4926.87 +1 +1029.96 +4748.1 +1 +1030.01 +4571.38 +1 +1030.06 +4397.2 +1 +1030.11 +4225.62 +1 +1030.16 +4056.86 +1 +1030.21 +3891.17 +1 +1030.26 +3728.74 +1 +1030.31 +3569.74 +1 +1030.36 +3414.36 +1 +1030.41 +3262.73 +1 +1030.46 +3115.04 +1 +1030.51 +2971.48 +1 +1030.56 +2832 +1 +1030.61 +2696.69 +1 +1030.66 +2565.6 +1 +1030.71 +2438.78 +1 +1030.76 +2316.25 +1 +1030.81 +2198.03 +1 +1030.86 +2084.12 +1 +1030.91 +1974.59 +1 +1030.96 +1869.4 +1 +1031.01 +1768.44 +1 +1031.06 +1671.65 +1 +1031.11 +1579 +1 +1031.16 +1490.4 +1 +1031.21 +1405.79 +1 +1031.26 +1325.07 +1 +1031.31 +1248.16 +1 +1031.36 +1175.09 +1 +1031.41 +1105.65 +1 +1031.46 +1039.72 +1 +1031.51 +977.194 +1 +1031.56 +917.957 +1 +1031.61 +861.898 +1 +1031.66 +808.897 +1 +1031.71 +758.848 +1 +1031.76 +711.643 +1 +1031.81 +667.253 +1 +1031.86 +625.461 +1 +1031.91 +586.149 +1 +1031.96 +549.212 +1 +1032.01 +514.529 +1 +1032.06 +481.996 +1 +1032.11 +451.504 +1 +1032.16 +422.945 +1 +1032.21 +396.268 +1 +1032.26 +371.378 +1 +1032.31 +348.128 +1 +1032.36 +326.423 +1 +1032.41 +306.171 +1 +1032.46 +287.293 +1 +1032.51 +269.698 +1 +1032.56 +253.312 +1 +1032.61 +238.056 +1 +1032.66 +223.92 +1 +1032.71 +210.8 +1 +1032.76 +198.602 +1 +1032.81 +187.268 +1 +1032.86 +176.736 +1 +1032.91 +166.95 +1 +1032.96 +157.86 +1 +1033.01 +149.413 +1 +1033.06 +141.566 +1 +1033.11 +134.348 +1 +1033.16 +127.642 +1 +1033.21 +121.412 +1 +1033.26 +115.618 +1 +1033.31 +110.231 +1 +1033.36 +105.216 +1 +1033.41 +100.545 +1 +1033.46 +96.1914 +1 +1033.51 +92.1457 +1 +1033.56 +88.4162 +1 +1033.61 +84.9317 +1 +1033.66 +81.6728 +1 +1033.71 +78.6216 +1 +1033.76 +75.7591 +1 +1033.81 +73.0719 +1 +1033.86 +70.5426 +1 +1033.91 +68.1585 +1 +1033.96 +65.9395 +1 +1034.01 +63.8651 +1 +1034.06 +61.9027 +1 +1034.11 +60.0402 +1 +1034.16 +58.2698 +1 +1034.21 +56.5842 +1 +1034.26 +54.975 +1 +1034.31 +53.4391 +1 +1034.36 +51.969 +1 +1034.41 +50.6038 +1 +1034.46 +49.3059 +1 +1034.51 +48.0632 +1 +1034.56 +46.8749 +1 +1034.61 +45.7351 +1 +1034.66 +44.6413 +1 +1034.71 +43.5894 +1 +1034.76 +42.5744 +1 +1034.81 +41.6001 +1 +1034.86 +40.6927 +1 +1034.91 +39.8132 +1 +1034.96 +38.9585 +1 +1035.01 +38.1257 +1 +1035.06 +37.3142 +1 +1035.11 +36.5206 +1 +1035.16 +35.7446 +1 +1035.21 +34.9841 +1 +1035.26 +34.2531 +1 +1035.31 +33.5583 +1 +1035.36 +32.8755 +1 +1035.41 +32.2049 +1 +1035.46 +31.5453 +1 +1035.51 +30.8959 +1 +1035.56 +30.2571 +1 +1035.61 +29.627 +1 +1035.66 +29.2777 +1 +1035.71 +28.6764 +1 +1035.76 +28.0885 +1 +1035.81 +27.5043 +1 +1035.86 +26.9227 +1 +1035.91 +26.3449 +1 +1035.96 +25.7699 +1 +1036.01 +25.1978 +1 +1036.06 +24.6291 +1 +1036.11 +24.0629 +1 +1036.16 +23.564 +1 +1036.21 +23.098 +1 +1036.26 +22.6347 +1 +1036.31 +22.1745 +1 +1036.36 +21.7165 +1 +1036.41 +21.2618 +1 +1036.46 +20.8093 +1 +1036.51 +20.3594 +1 +1036.56 +19.9186 +1 +1036.61 +19.4983 +1 +1036.66 +19.0809 +1 +1036.71 +18.6655 +1 +1036.76 +18.2524 +1 +1036.81 +17.8418 +1 +1036.86 +17.4331 +1 +1036.91 +17.0271 +1 +1036.96 +16.6229 +1 +1037.01 +16.2326 +1 +1037.06 +15.8546 +1 +1037.11 +15.4784 +1 +1037.16 +15.1207 +1 +1037.21 +14.7727 +1 +1037.26 +14.4268 +1 +1037.31 +14.0829 +1 +1037.36 +13.7406 +1 +1037.41 +13.4005 +1 +1037.46 +13.0777 +1 +1037.51 +12.7601 +1 +1037.56 +12.4444 +1 +1037.61 +12.1301 +1 +1037.66 +11.8179 +1 +1037.71 +11.5072 +1 +1037.76 +11.1983 +1 +1037.81 +10.891 +1 +1037.86 +10.5869 +1 +1037.91 +10.2996 +1 +1037.96 +10.0137 +1 +1038.01 +9.72941 +1 +1038.06 +9.44658 +1 +1038.11 +9.16511 +1 +1038.16 +8.894 +1 +1038.21 +8.62657 +1 +1038.26 +8.36072 +1 +1038.31 +8.10193 +1 +1038.36 +7.85343 +1 +1038.41 +7.60653 +1 +1038.46 +7.36073 +1 +1038.51 +7.11642 +1 +1038.56 +6.8733 +1 +1038.61 +6.63138 +1 +1038.66 +6.39085 +1 +1038.71 +6.15134 +1 +1038.76 +5.92198 +1 +1038.81 +5.69796 +1 +1038.86 +5.47508 +1 +1038.91 +5.25347 +1 +1038.96 +5.0328 +1 +1039.01 +4.98139 +1 +1039.06 +4.76187 +1 +1039.11 +4.54273 +1 +1039.16 +4.32925 +1 +1039.21 +4.12757 +1 +1039.26 +3.92698 +1 +1039.31 +0 +1 +1039.36 +0 +1 +1039.41 +0 +1 +1039.46 +0 +1 +1039.51 +0 +1 +1039.56 +0 +1 +1039.61 +0 +1 +1039.66 +0 +1 +1039.71 +0 +1 +1039.76 +0 +1 +1039.81 +0 +1 +1039.86 +0 +1 +1039.91 +0 +1 +1039.96 +0 +1 +1040.01 +0 +1 +1040.06 +0 +1 +1040.11 +0 +1 +1040.16 +0 +1 +1040.21 +0 +1 +1040.26 +0 +1 +1040.31 +0 +1 +1040.36 +0 +1 +1040.41 +0 +1 +1040.46 +0 +1 +1040.51 +0 +1 +1040.56 +0 +1 +1040.61 +0 +1 +&TiO2 +TiO2 +0 +0 +0 +0 +0 +0 +0 +12 +Casa Info Follows +0 +0 +0 +0 + +PCA Coefs = 41279.5, -30.0911, +CasaXP11_irregular-March172021151537 +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +CasaXP2 +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p LS +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +2 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.41 +0 +1 +986.51 +0 +1 +986.61 +0 +1 +986.71 +768.707 +1 +986.81 +760.553 +1 +986.91 +768.435 +1 +987.01 +755.652 +1 +987.11 +767.617 +1 +987.21 +776.181 +1 +987.31 +795.763 +1 +987.41 +770.688 +1 +987.51 +763.262 +1 +987.61 +746.497 +1 +987.71 +771.299 +1 +987.81 +794.081 +1 +987.91 +798.462 +1 +988.01 +796.086 +1 +988.11 +750.701 +1 +988.21 +764.244 +1 +988.31 +762.703 +1 +988.41 +767.642 +1 +988.51 +809.875 +1 +988.61 +782.735 +1 +988.71 +802.762 +1 +988.81 +781.754 +1 +988.91 +797.075 +1 +989.01 +782.132 +1 +989.11 +772.809 +1 +989.21 +791.69 +1 +989.31 +768.177 +1 +989.41 +753.308 +1 +989.51 +789.669 +1 +989.61 +800.739 +1 +989.71 +779.037 +1 +989.81 +796.667 +1 +989.91 +788.664 +1 +990.01 +781.431 +1 +990.11 +763.133 +1 +990.21 +761.93 +1 +990.31 +770.168 +1 +990.41 +781.989 +1 +990.51 +774.174 +1 +990.61 +783.781 +1 +990.71 +788.367 +1 +990.81 +773.493 +1 +990.91 +805.974 +1 +991.01 +771.994 +1 +991.11 +777.448 +1 +991.21 +789.282 +1 +991.31 +794.388 +1 +991.41 +776.115 +1 +991.51 +783.245 +1 +991.61 +791.547 +1 +991.71 +791.152 +1 +991.81 +811.094 +1 +991.91 +769.968 +1 +992.01 +772.96 +1 +992.11 +796.65 +1 +992.21 +826.989 +1 +992.31 +810.03 +1 +992.41 +818.963 +1 +992.51 +785.408 +1 +992.61 +800.716 +1 +992.71 +788.478 +1 +992.81 +804.164 +1 +992.91 +812.978 +1 +993.01 +822.622 +1 +993.11 +819.208 +1 +993.21 +829.078 +1 +993.31 +792.38 +1 +993.41 +821.361 +1 +993.51 +807.064 +1 +993.61 +809.673 +1 +993.71 +829.266 +1 +993.81 +816.075 +1 +993.91 +811.888 +1 +994.01 +813.957 +1 +994.11 +821.861 +1 +994.21 +833.57 +1 +994.31 +837.714 +1 +994.41 +849.28 +1 +994.51 +857.286 +1 +994.61 +833.549 +1 +994.71 +845.806 +1 +994.81 +836.24 +1 +994.91 +858.359 +1 +995.01 +862.683 +1 +995.11 +844.704 +1 +995.21 +842.124 +1 +995.31 +876.151 +1 +995.41 +850.852 +1 +995.51 +870.002 +1 +995.61 +873.725 +1 +995.71 +872.576 +1 +995.81 +872.903 +1 +995.91 +878.814 +1 +996.01 +867.431 +1 +996.11 +865.276 +1 +996.21 +866.368 +1 +996.31 +877.735 +1 +996.41 +899.413 +1 +996.51 +886.844 +1 +996.61 +869.567 +1 +996.71 +902.856 +1 +996.81 +905.33 +1 +996.91 +874.966 +1 +997.01 +869.403 +1 +997.11 +865.949 +1 +997.21 +886.148 +1 +997.31 +882.212 +1 +997.41 +885.397 +1 +997.51 +898.615 +1 +997.61 +902.991 +1 +997.71 +883.438 +1 +997.81 +896.5 +1 +997.91 +893.677 +1 +998.01 +877.466 +1 +998.11 +900.29 +1 +998.21 +880.029 +1 +998.31 +903.615 +1 +998.41 +893.494 +1 +998.51 +880.647 +1 +998.61 +893.543 +1 +998.71 +873.733 +1 +998.81 +900.388 +1 +998.91 +916.252 +1 +999.01 +902.081 +1 +999.11 +905.374 +1 +999.21 +886.856 +1 +999.31 +911.213 +1 +999.41 +905.309 +1 +999.51 +902.687 +1 +999.61 +913.305 +1 +999.71 +904.045 +1 +999.81 +896.12 +1 +999.91 +897.236 +1 +1000.01 +923.679 +1 +1000.11 +926.681 +1 +1000.21 +926.073 +1 +1000.31 +925.526 +1 +1000.41 +907.704 +1 +1000.51 +896.397 +1 +1000.61 +910.067 +1 +1000.71 +926.249 +1 +1000.81 +920.429 +1 +1000.91 +911.683 +1 +1001.01 +929.617 +1 +1001.11 +950.296 +1 +1001.21 +954.222 +1 +1001.31 +958.371 +1 +1001.41 +948.537 +1 +1001.51 +937.444 +1 +1001.61 +926.521 +1 +1001.71 +914.447 +1 +1001.81 +938.226 +1 +1001.91 +942.783 +1 +1002.01 +945.337 +1 +1002.11 +920.58 +1 +1002.21 +939.262 +1 +1002.31 +943.013 +1 +1002.41 +943.763 +1 +1002.51 +963.942 +1 +1002.61 +929.992 +1 +1002.71 +921.771 +1 +1002.81 +946.545 +1 +1002.91 +951.811 +1 +1003.01 +971.317 +1 +1003.11 +932.785 +1 +1003.21 +938.39 +1 +1003.31 +948.212 +1 +1003.41 +955.917 +1 +1003.51 +950.44 +1 +1003.61 +933.546 +1 +1003.71 +937.391 +1 +1003.81 +934.345 +1 +1003.91 +945.101 +1 +1004.01 +931.364 +1 +1004.11 +934.292 +1 +1004.21 +938.488 +1 +1004.31 +931.659 +1 +1004.41 +941.812 +1 +1004.51 +926.828 +1 +1004.61 +935.58 +1 +1004.71 +914.475 +1 +1004.81 +926.205 +1 +1004.91 +933.151 +1 +1005.01 +894.257 +1 +1005.11 +922.632 +1 +1005.21 +947.099 +1 +1005.31 +942.994 +1 +1005.41 +962.008 +1 +1005.51 +926.796 +1 +1005.61 +950.836 +1 +1005.71 +940.143 +1 +1005.81 +956.34 +1 +1005.91 +956.727 +1 +1006.01 +975.317 +1 +1006.11 +940.591 +1 +1006.21 +947.456 +1 +1006.31 +981.819 +1 +1006.41 +970.555 +1 +1006.51 +1008.37 +1 +1006.61 +1008.11 +1 +1006.71 +1013.6 +1 +1006.81 +996.31 +1 +1006.91 +1014.27 +1 +1007.01 +987.97 +1 +1007.11 +1015.57 +1 +1007.21 +1041.04 +1 +1007.31 +1024.19 +1 +1007.41 +1046.25 +1 +1007.51 +1080.99 +1 +1007.61 +1052.36 +1 +1007.71 +1079.45 +1 +1007.81 +1069.35 +1 +1007.91 +1086.71 +1 +1008.01 +1099.49 +1 +1008.11 +1098.97 +1 +1008.21 +1082.77 +1 +1008.31 +1103.98 +1 +1008.41 +1124.29 +1 +1008.51 +1094.43 +1 +1008.61 +1092.18 +1 +1008.71 +1119.73 +1 +1008.81 +1111.18 +1 +1008.91 +1100.64 +1 +1009.01 +1074.02 +1 +1009.11 +1081.55 +1 +1009.21 +1084.81 +1 +1009.31 +1072.29 +1 +1009.41 +1064.08 +1 +1009.51 +1068.03 +1 +1009.61 +1042.68 +1 +1009.71 +1048.27 +1 +1009.81 +1047.75 +1 +1009.91 +1041.99 +1 +1010.01 +1032.26 +1 +1010.11 +1010.81 +1 +1010.21 +1010.5 +1 +1010.31 +981.444 +1 +1010.41 +994.358 +1 +1010.51 +1016.22 +1 +1010.61 +1023.54 +1 +1010.71 +996.998 +1 +1010.81 +986.877 +1 +1010.91 +990.319 +1 +1011.01 +977.67 +1 +1011.11 +974.063 +1 +1011.21 +990.486 +1 +1011.31 +981.065 +1 +1011.41 +994.019 +1 +1011.51 +977.353 +1 +1011.61 +990.329 +1 +1011.71 +997.831 +1 +1011.81 +976.829 +1 +1011.91 +1023.17 +1 +1012.01 +1048.11 +1 +1012.11 +1057 +1 +1012.21 +1054.53 +1 +1012.31 +1056.94 +1 +1012.41 +1065.11 +1 +1012.51 +1098.57 +1 +1012.61 +1081.96 +1 +1012.71 +1088.82 +1 +1012.81 +1090.24 +1 +1012.91 +1110.64 +1 +1013.01 +1156.04 +1 +1013.11 +1154.69 +1 +1013.21 +1149.48 +1 +1013.31 +1178.23 +1 +1013.41 +1206.08 +1 +1013.51 +1235.84 +1 +1013.61 +1212.04 +1 +1013.71 +1236.37 +1 +1013.81 +1260.29 +1 +1013.91 +1227.79 +1 +1014.01 +1267.25 +1 +1014.11 +1278.21 +1 +1014.21 +1301.9 +1 +1014.31 +1268.86 +1 +1014.41 +1282.91 +1 +1014.51 +1257.63 +1 +1014.61 +1268.26 +1 +1014.71 +1240.09 +1 +1014.81 +1212.45 +1 +1014.91 +1218.87 +1 +1015.01 +1192.01 +1 +1015.11 +1171.19 +1 +1015.21 +1155.17 +1 +1015.31 +1122.54 +1 +1015.41 +1101.79 +1 +1015.41 +1067.41 +1 +1015.46 +1052.35 +1 +1015.51 +1067.29 +1 +1015.51 +1059.44 +1 +1015.56 +1042.15 +1 +1015.61 +1030.58 +1 +1015.61 +1039.02 +1 +1015.66 +1026.23 +1 +1015.71 +1052.82 +1 +1015.71 +1026.07 +1 +1015.76 +1013.77 +1 +1015.81 +1016.71 +1 +1015.81 +984.758 +1 +1015.86 +1003.17 +1 +1015.91 +978.853 +1 +1015.91 +983.593 +1 +1015.96 +992.657 +1 +1016.01 +963.914 +1 +1016.01 +997.976 +1 +1016.06 +945.589 +1 +1016.11 +962.513 +1 +1016.11 +958.563 +1 +1016.16 +978.607 +1 +1016.21 +965.235 +1 +1016.21 +925.061 +1 +1016.26 +931.285 +1 +1016.31 +950.873 +1 +1016.31 +924.092 +1 +1016.36 +914.095 +1 +1016.41 +887.906 +1 +1016.41 +924.448 +1 +1016.46 +892.4 +1 +1016.51 +887.492 +1 +1016.56 +895.285 +1 +1016.61 +879.719 +1 +1016.66 +885.384 +1 +1016.71 +879.291 +1 +1016.76 +836.024 +1 +1016.81 +856.757 +1 +1016.86 +867.567 +1 +1016.91 +879.182 +1 +1016.96 +853.334 +1 +1017.01 +840.365 +1 +1017.06 +844.006 +1 +1017.11 +838.737 +1 +1017.16 +830.23 +1 +1017.21 +813.429 +1 +1017.26 +808.999 +1 +1017.31 +819.672 +1 +1017.36 +805.464 +1 +1017.41 +810.392 +1 +1017.46 +784.829 +1 +1017.51 +797.662 +1 +1017.56 +777.953 +1 +1017.61 +778.964 +1 +1017.66 +772.96 +1 +1017.71 +800.196 +1 +1017.76 +780.125 +1 +1017.81 +749.445 +1 +1017.86 +759.949 +1 +1017.91 +760.85 +1 +1017.96 +766.089 +1 +1018.01 +761.03 +1 +1018.06 +775.909 +1 +1018.11 +783.447 +1 +1018.16 +786.74 +1 +1018.21 +764.45 +1 +1018.26 +755.3 +1 +1018.31 +777.982 +1 +1018.36 +771.937 +1 +1018.41 +777.032 +1 +1018.46 +772.377 +1 +1018.51 +741.676 +1 +1018.56 +789.933 +1 +1018.61 +762.665 +1 +1018.66 +745.3 +1 +1018.71 +752.13 +1 +1018.76 +759.794 +1 +1018.81 +774.162 +1 +1018.86 +794.029 +1 +1018.91 +786.274 +1 +1018.96 +802.151 +1 +1019.01 +783.227 +1 +1019.06 +801.558 +1 +1019.11 +787.6 +1 +1019.16 +821.694 +1 +1019.21 +830.725 +1 +1019.26 +819.337 +1 +1019.31 +865.198 +1 +1019.36 +844.184 +1 +1019.41 +845.633 +1 +1019.46 +854.093 +1 +1019.51 +863.046 +1 +1019.56 +874.417 +1 +1019.61 +913.775 +1 +1019.66 +896.864 +1 +1019.71 +925.225 +1 +1019.76 +932.491 +1 +1019.81 +971.033 +1 +1019.86 +966.216 +1 +1019.91 +972.082 +1 +1019.96 +1029.16 +1 +1020.01 +1031.97 +1 +1020.06 +1049.6 +1 +1020.11 +1079.9 +1 +1020.16 +1095.11 +1 +1020.21 +1142.77 +1 +1020.26 +1185.78 +1 +1020.31 +1234.21 +1 +1020.36 +1275.05 +1 +1020.41 +1301.29 +1 +1020.46 +1354.89 +1 +1020.51 +1402.01 +1 +1020.56 +1465.91 +1 +1020.61 +1505.27 +1 +1020.66 +1542.42 +1 +1020.71 +1564.52 +1 +1020.76 +1643.28 +1 +1020.81 +1699.57 +1 +1020.86 +1778.37 +1 +1020.91 +1802.46 +1 +1020.96 +1858.86 +1 +1021.01 +1969.59 +1 +1021.06 +2010.58 +1 +1021.11 +2061.9 +1 +1021.16 +2155.96 +1 +1021.21 +2171.67 +1 +1021.26 +2266.3 +1 +1021.31 +2257.47 +1 +1021.36 +2311 +1 +1021.41 +2367.68 +1 +1021.46 +2426.42 +1 +1021.51 +2451.52 +1 +1021.56 +2486.56 +1 +1021.61 +2485.79 +1 +1021.66 +2516.09 +1 +1021.71 +2550.8 +1 +1021.76 +2526.8 +1 +1021.81 +2501.27 +1 +1021.86 +2536.75 +1 +1021.91 +2497.04 +1 +1021.96 +2492.25 +1 +1022.01 +2489.07 +1 +1022.06 +2395.72 +1 +1022.11 +2401.55 +1 +1022.16 +2346.97 +1 +1022.21 +2306.04 +1 +1022.26 +2289 +1 +1022.31 +2227.36 +1 +1022.36 +2153.49 +1 +1022.41 +2067.64 +1 +1022.46 +1998.69 +1 +1022.51 +1950.63 +1 +1022.56 +1902.71 +1 +1022.61 +1827.21 +1 +1022.66 +1728.78 +1 +1022.71 +1672.22 +1 +1022.76 +1609.68 +1 +1022.81 +1578.01 +1 +1022.86 +1559.44 +1 +1022.91 +1434.8 +1 +1022.96 +1366.92 +1 +1023.01 +1348.1 +1 +1023.06 +1290.44 +1 +1023.11 +1235.91 +1 +1023.16 +1223.03 +1 +1023.21 +1158.64 +1 +1023.26 +1156.28 +1 +1023.31 +1128.58 +1 +1023.36 +1089.29 +1 +1023.41 +1032.33 +1 +1023.46 +1023.36 +1 +1023.51 +996.215 +1 +1023.56 +948.428 +1 +1023.61 +937.285 +1 +1023.66 +924.02 +1 +1023.71 +904.001 +1 +1023.76 +911.682 +1 +1023.81 +860.988 +1 +1023.86 +840.295 +1 +1023.91 +830.683 +1 +1023.96 +806.105 +1 +1024.01 +814.335 +1 +1024.06 +797.877 +1 +1024.11 +784.465 +1 +1024.16 +798.57 +1 +1024.21 +784.869 +1 +1024.26 +780.672 +1 +1024.31 +778.737 +1 +1024.36 +761.738 +1 +1024.41 +758.673 +1 +1024.46 +741.007 +1 +1024.51 +751.087 +1 +1024.56 +759.106 +1 +1024.61 +748.745 +1 +1024.66 +740.552 +1 +1024.71 +748.907 +1 +1024.76 +754.767 +1 +1024.81 +759.631 +1 +1024.86 +754.448 +1 +1024.91 +746.531 +1 +1024.96 +762.516 +1 +1025.01 +778.526 +1 +1025.06 +758.886 +1 +1025.11 +759.716 +1 +1025.16 +770.626 +1 +1025.21 +777.027 +1 +1025.26 +784.108 +1 +1025.31 +786.215 +1 +1025.36 +784.578 +1 +1025.41 +791.529 +1 +1025.46 +817.551 +1 +1025.51 +813.631 +1 +1025.56 +831.026 +1 +1025.61 +823.737 +1 +1025.66 +843.837 +1 +1025.71 +847.126 +1 +1025.76 +845.529 +1 +1025.81 +871.589 +1 +1025.86 +897.405 +1 +1025.91 +931.456 +1 +1025.96 +943.584 +1 +1026.01 +975.757 +1 +1026.06 +1029.64 +1 +1026.11 +1058.22 +1 +1026.16 +1123.13 +1 +1026.21 +1166.62 +1 +1026.26 +1235.35 +1 +1026.31 +1291.99 +1 +1026.36 +1404.8 +1 +1026.41 +1511.6 +1 +1026.46 +1620.58 +1 +1026.51 +1744.35 +1 +1026.56 +1887.18 +1 +1026.61 +2048.32 +1 +1026.66 +2250.15 +1 +1026.71 +2474.29 +1 +1026.76 +2792.44 +1 +1026.81 +3041.37 +1 +1026.86 +3301.67 +1 +1026.91 +3616.82 +1 +1026.96 +3968.96 +1 +1027.01 +4302.5 +1 +1027.06 +4599.79 +1 +1027.11 +4948.24 +1 +1027.16 +5336.66 +1 +1027.21 +5592.03 +1 +1027.26 +5891.08 +1 +1027.31 +6117.37 +1 +1027.36 +6401.69 +1 +1027.41 +6544.88 +1 +1027.46 +6616.65 +1 +1027.51 +6705.58 +1 +1027.56 +6693.94 +1 +1027.61 +6634.5 +1 +1027.66 +6522.28 +1 +1027.71 +6363.31 +1 +1027.76 +6104.02 +1 +1027.81 +5828.6 +1 +1027.86 +5495.3 +1 +1027.91 +5100.96 +1 +1027.96 +4818.28 +1 +1028.01 +4440.83 +1 +1028.06 +4085.26 +1 +1028.11 +3670.51 +1 +1028.16 +3341.96 +1 +1028.21 +2989.35 +1 +1028.26 +2685.24 +1 +1028.31 +2373.67 +1 +1028.36 +2111.04 +1 +1028.41 +1882.81 +1 +1028.46 +1636.92 +1 +1028.51 +1449.51 +1 +1028.56 +1278.47 +1 +1028.61 +1138.66 +1 +1028.66 +1008.49 +1 +1028.71 +880.955 +1 +1028.76 +784.214 +1 +1028.81 +710.739 +1 +1028.86 +639.553 +1 +1028.91 +593.143 +1 +1028.96 +528.411 +1 +1029.01 +493.952 +1 +1029.06 +460.395 +1 +1029.11 +430.007 +1 +1029.16 +407.676 +1 +1029.21 +375.74 +1 +1029.26 +349.579 +1 +1029.31 +307.498 +1 +1029.36 +298.685 +1 +1029.41 +289.607 +1 +1029.46 +274.535 +1 +1029.51 +261.454 +1 +1029.56 +258.402 +1 +1029.61 +241.45 +1 +1029.66 +226.133 +1 +1029.71 +195.994 +1 +1029.76 +196.912 +1 +1029.81 +178.111 +1 +1029.86 +182.602 +1 +1029.91 +171.642 +1 +1029.96 +139.931 +1 +1030.01 +148.703 +1 +1030.06 +140.236 +1 +1030.11 +122.799 +1 +1030.16 +127.547 +1 +1030.21 +123.658 +1 +1030.26 +117.159 +1 +1030.31 +113.168 +1 +1030.36 +103.043 +1 +1030.41 +89.9611 +1 +1030.46 +79.7678 +1 +1030.51 +82.6402 +1 +1030.56 +78.3794 +1 +1030.61 +71.4293 +1 +1030.66 +76.4138 +1 +1030.71 +75.3822 +1 +1030.76 +78.9603 +1 +1030.81 +65.8195 +1 +1030.86 +59.9979 +1 +1030.91 +53.6695 +1 +1030.96 +50.609 +1 +1031.01 +45.9551 +1 +1031.06 +58.2979 +1 +1031.11 +45.7672 +1 +1031.16 +45.6667 +1 +1031.21 +37.6953 +1 +1031.26 +34.8926 +1 +1031.31 +45.1279 +1 +1031.36 +38.4188 +1 +1031.41 +43.102 +1 +1031.46 +41.5193 +1 +1031.51 +41.8022 +1 +1031.56 +37.3304 +1 +1031.61 +34.3535 +1 +1031.66 +38.0149 +1 +1031.71 +41.0285 +1 +1031.76 +38.7568 +1 +1031.81 +24.1728 +1 +1031.86 +26.7467 +1 +1031.91 +24.8709 +1 +1031.96 +25.2497 +1 +1032.01 +30.3581 +1 +1032.06 +32.8652 +1 +1032.11 +26.7379 +1 +1032.16 +17.5069 +1 +1032.21 +27.4104 +1 +1032.26 +31.9776 +1 +1032.31 +35.0028 +1 +1032.36 +28.3184 +1 +1032.41 +18.7488 +1 +1032.46 +16.2122 +1 +1032.51 +31.8477 +1 +1032.56 +28.849 +1 +1032.61 +28.1205 +1 +1032.66 +19.5003 +1 +1032.71 +22.1481 +1 +1032.76 +14.6862 +1 +1032.81 +23.383 +1 +1032.86 +23.817 +1 +1032.91 +18.631 +1 +1032.96 +16.5573 +1 +1033.01 +12.2888 +1 +1033.06 +14.5476 +1 +1033.11 +16.5876 +1 +1033.16 +14.5942 +1 +1033.21 +13.8555 +1 +1033.26 +14.5433 +1 +1033.31 +7.00553 +1 +1033.36 +19.7495 +1 +1033.41 +9.75463 +1 +1033.46 +16.6813 +1 +1033.51 +10.5411 +1 +1033.56 +11.4887 +1 +1033.61 +9.85089 +1 +1033.66 +21.479 +1 +1033.71 +15.0159 +1 +1033.76 +22.6288 +1 +1033.81 +16.9822 +1 +1033.86 +17.9488 +1 +1033.91 +10.2562 +1 +1033.96 +17.5299 +1 +1034.01 +14.6918 +1 +1034.06 +18.5697 +1 +1034.11 +18.4523 +1 +1034.16 +17.5792 +1 +1034.21 +20.0307 +1 +1034.26 +24.9494 +1 +1034.31 +12.6893 +1 +1034.36 +7.72395 +1 +1034.41 +4.38198 +1 +1034.46 +6.31105 +1 +1034.51 +13.7239 +1 +1034.56 +19.994 +1 +1034.61 +12.7116 +1 +1034.66 +10.1567 +1 +1034.71 +12.2761 +1 +1034.76 +14.2381 +1 +1034.81 +4.75145 +1 +1034.86 +-0.0982386 +1 +1034.91 +11.4553 +1 +1034.96 +8.98422 +1 +1035.01 +19.1661 +1 +1035.06 +11.0729 +1 +1035.11 +14.8176 +1 +1035.16 +14.128 +1 +1035.21 +12.2612 +1 +1035.26 +12.6718 +1 +1035.31 +13.668 +1 +1035.36 +5.73352 +1 +1035.41 +6.80692 +1 +1035.46 +6.00817 +1 +1035.51 +3.57823 +1 +1035.56 +6.26545 +1 +1035.61 +10.8517 +1 +1035.66 +8.11417 +1 +1035.71 +8.48454 +1 +1035.76 +6.19727 +1 +1035.81 +9.99754 +1 +1035.86 +-0.595702 +1 +1035.91 +3.32511 +1 +1035.96 +2.16431 +1 +1036.01 +5.30515 +1 +1036.06 +6.33019 +1 +1036.11 +-0.15255 +1 +1036.16 +-0.160988 +1 +1036.21 +4.10473 +1 +1036.26 +-1.07666 +1 +1036.31 +1.58446 +1 +1036.36 +-0.212021 +1 +1036.41 +12.2091 +1 +1036.46 +6.92326 +1 +1036.51 +14.8672 +1 +1036.56 +6.40831 +1 +1036.61 +4.71866 +1 +1036.66 +7.10513 +1 +1036.71 +9.98924 +1 +1036.76 +1.929 +1 +1036.81 +6.98157 +1 +1036.86 +3.66599 +1 +1036.91 +8.02528 +1 +1036.96 +-0.623079 +1 +1037.01 +-3.58963 +1 +1037.06 +-4.89371 +1 +1037.11 +3.92434 +1 +1037.16 +8.29572 +1 +1037.21 +8.52046 +1 +1037.26 +10.3075 +1 +1037.31 +6.96935 +1 +1037.36 +-0.523693 +1 +1037.41 +-6.73835 +1 +1037.46 +1.34514 +1 +1037.51 +4.97275 +1 +1037.56 +1.15262 +1 +1037.61 +-2.7992 +1 +1037.66 +9.64657 +1 +1037.71 +5.40891 +1 +1037.76 +6.80002 +1 +1037.81 +-3.69174 +1 +1037.86 +4.72394 +1 +1037.91 +2.41516 +1 +1037.96 +2.16941 +1 +1038.01 +3.25827 +1 +1038.06 +6.17699 +1 +1038.11 +-0.126762 +1 +1038.16 +9.74501 +1 +1038.21 +2.44671 +1 +1038.26 +13.5869 +1 +1038.31 +0.257914 +1 +1038.36 +2.84957 +1 +1038.41 +3.89457 +1 +1038.46 +-3.92537 +1 +1038.51 +-5.8306 +1 +1038.56 +-1.07815 +1 +1038.61 +4.5545 +1 +1038.66 +9.49284 +1 +1038.71 +0.264434 +1 +1038.76 +1.19787 +1 +1038.81 +1.67889 +1 +1038.86 +-0.411538 +1 +1038.91 +3.29361 +1 +1038.96 +3.60995 +1 +1039.01 +7.03935 +1 +1039.06 +2.46095 +1 +1039.11 +3.16899 +1 +1039.16 +-3.42998 +1 +1039.21 +7.20019 +1 +1039.26 +-6.66532 +1 +1039.31 +-2.25084 +1 +1039.36 +0.0238542 +1 +1039.41 +-2.53558 +1 +1039.46 +1.21449 +1 +1039.51 +-4.11686 +1 +1039.56 +0.731545 +1 +1039.61 +2.61504 +1 +1039.66 +-1.29684 +1 +1039.71 +-3.20836 +1 +1039.76 +7.83649 +1 +1039.81 +4.38263 +1 +1039.86 +6.31627 +1 +1039.91 +6.05281 +1 +1039.96 +4.76111 +1 +1040.01 +3.3128 +1 +1040.06 +7.77774 +1 +1040.11 +1.48788 +1 +1040.16 +7.11285 +1 +1040.21 +2.66528 +1 +1040.26 +0.887167 +1 +1040.31 +2.751 +1 +1040.36 +-10.7387 +1 +1040.41 +0 +1 +&Ti_met +Ti metal +0 +0 +0 +0 +0 +0 +0 +12 +Casa Info Follows +0 +0 +0 +0 + +PCA Coefs = 54487.5, 23477.3, -4356.52, 108.165, +PCA Coefs = 54487.5, 23477.3, -4356.52, 108.165, -1011.67, +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p LS +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.61 +1380.79 +1 +986.71 +1379.61 +1 +986.81 +1342.46 +1 +986.91 +1357.98 +1 +987.01 +1384.78 +1 +987.11 +1338.23 +1 +987.21 +1302.73 +1 +987.31 +1369.8 +1 +987.41 +1340.63 +1 +987.51 +1326.81 +1 +987.61 +1308.49 +1 +987.71 +1297.46 +1 +987.81 +1366.09 +1 +987.91 +1417.54 +1 +988.01 +1429.56 +1 +988.11 +1338.43 +1 +988.21 +1307.35 +1 +988.31 +1331.1 +1 +988.41 +1342.77 +1 +988.51 +1352.87 +1 +988.61 +1334.16 +1 +988.71 +1322.33 +1 +988.81 +1336.04 +1 +988.91 +1337.25 +1 +989.01 +1291.69 +1 +989.11 +1331.42 +1 +989.21 +1362.36 +1 +989.31 +1367.73 +1 +989.41 +1321.77 +1 +989.51 +1331.19 +1 +989.61 +1337.59 +1 +989.71 +1354.37 +1 +989.81 +1337.41 +1 +989.91 +1414.58 +1 +990.01 +1375.48 +1 +990.11 +1329.94 +1 +990.21 +1340.48 +1 +990.31 +1299.66 +1 +990.41 +1329.48 +1 +990.51 +1336.35 +1 +990.61 +1374.2 +1 +990.71 +1329.05 +1 +990.81 +1364.6 +1 +990.91 +1275.77 +1 +991.01 +1403.71 +1 +991.11 +1391.23 +1 +991.21 +1385.94 +1 +991.31 +1408.94 +1 +991.41 +1378.4 +1 +991.51 +1311.37 +1 +991.61 +1388.73 +1 +991.71 +1357.91 +1 +991.81 +1398.56 +1 +991.91 +1318.21 +1 +992.01 +1324.53 +1 +992.11 +1390.02 +1 +992.21 +1299.01 +1 +992.31 +1376.27 +1 +992.41 +1368.45 +1 +992.51 +1384.67 +1 +992.61 +1327.26 +1 +992.71 +1345.15 +1 +992.81 +1363.08 +1 +992.91 +1365.75 +1 +993.01 +1307.44 +1 +993.11 +1363.56 +1 +993.21 +1293.28 +1 +993.31 +1339.81 +1 +993.41 +1331.02 +1 +993.51 +1325.31 +1 +993.61 +1339.19 +1 +993.71 +1382.03 +1 +993.81 +1270.13 +1 +993.91 +1311.58 +1 +994.01 +1363.6 +1 +994.11 +1378.17 +1 +994.21 +1289.73 +1 +994.31 +1438.27 +1 +994.41 +1295.38 +1 +994.51 +1371.09 +1 +994.61 +1381.04 +1 +994.71 +1391.69 +1 +994.81 +1354.23 +1 +994.91 +1386.57 +1 +995.01 +1303.35 +1 +995.11 +1321.43 +1 +995.21 +1369.64 +1 +995.31 +1438.72 +1 +995.41 +1409.51 +1 +995.51 +1401.62 +1 +995.61 +1421.9 +1 +995.71 +1412.13 +1 +995.81 +1429.47 +1 +995.91 +1360.03 +1 +996.01 +1401.67 +1 +996.11 +1377.03 +1 +996.21 +1353.26 +1 +996.31 +1442.57 +1 +996.41 +1318.8 +1 +996.51 +1292.64 +1 +996.61 +1475.21 +1 +996.71 +1394.63 +1 +996.81 +1382.38 +1 +996.91 +1497.62 +1 +997.01 +1445.13 +1 +997.11 +1444.74 +1 +997.21 +1423.46 +1 +997.31 +1449.53 +1 +997.41 +1437.41 +1 +997.51 +1436.63 +1 +997.61 +1459.79 +1 +997.71 +1452.47 +1 +997.81 +1374.02 +1 +997.91 +1365.02 +1 +998.01 +1425.56 +1 +998.11 +1477.99 +1 +998.21 +1395.59 +1 +998.31 +1349.93 +1 +998.41 +1406.85 +1 +998.51 +1442.93 +1 +998.61 +1426.26 +1 +998.71 +1425.03 +1 +998.81 +1448.98 +1 +998.91 +1417.89 +1 +999.01 +1363.7 +1 +999.11 +1357.04 +1 +999.21 +1372.19 +1 +999.31 +1451.86 +1 +999.41 +1440.96 +1 +999.51 +1447.06 +1 +999.61 +1472.97 +1 +999.71 +1420.74 +1 +999.81 +1469.9 +1 +999.91 +1469.79 +1 +1000.01 +1410.93 +1 +1000.11 +1469.51 +1 +1000.21 +1427.66 +1 +1000.31 +1474.49 +1 +1000.41 +1484.39 +1 +1000.51 +1499.16 +1 +1000.61 +1439.94 +1 +1000.71 +1501.69 +1 +1000.81 +1473.67 +1 +1000.91 +1424.29 +1 +1001.01 +1510.63 +1 +1001.11 +1439.25 +1 +1001.21 +1504.56 +1 +1001.31 +1449.63 +1 +1001.41 +1499.57 +1 +1001.51 +1516.59 +1 +1001.61 +1470.99 +1 +1001.71 +1446.03 +1 +1001.81 +1491.14 +1 +1001.91 +1482.6 +1 +1002.01 +1458.25 +1 +1002.11 +1464.51 +1 +1002.21 +1528.15 +1 +1002.31 +1599.73 +1 +1002.41 +1519.57 +1 +1002.51 +1464.08 +1 +1002.61 +1500.98 +1 +1002.71 +1491.64 +1 +1002.81 +1506.13 +1 +1002.91 +1493.78 +1 +1003.01 +1490.32 +1 +1003.11 +1562.09 +1 +1003.21 +1609.35 +1 +1003.31 +1533.6 +1 +1003.41 +1496.24 +1 +1003.51 +1515.64 +1 +1003.61 +1520.53 +1 +1003.71 +1584.04 +1 +1003.81 +1479.16 +1 +1003.91 +1498.88 +1 +1004.01 +1597.33 +1 +1004.11 +1576.33 +1 +1004.21 +1609.96 +1 +1004.31 +1589.92 +1 +1004.41 +1588.85 +1 +1004.51 +1571.07 +1 +1004.61 +1564.75 +1 +1004.71 +1641.64 +1 +1004.81 +1614.72 +1 +1004.91 +1545.26 +1 +1005.01 +1584.59 +1 +1005.11 +1642.09 +1 +1005.21 +1624.18 +1 +1005.31 +1587.97 +1 +1005.41 +1664.19 +1 +1005.51 +1622.77 +1 +1005.61 +1631.17 +1 +1005.71 +1685.78 +1 +1005.81 +1639.74 +1 +1005.91 +1667.52 +1 +1006.01 +1660.09 +1 +1006.11 +1692.51 +1 +1006.21 +1740.76 +1 +1006.31 +1741.68 +1 +1006.41 +1670.29 +1 +1006.51 +1597.06 +1 +1006.61 +1699.18 +1 +1006.71 +1670.17 +1 +1006.81 +1693.94 +1 +1006.91 +1620.58 +1 +1007.01 +1651.87 +1 +1007.11 +1653.77 +1 +1007.21 +1699.66 +1 +1007.31 +1772.5 +1 +1007.41 +1760.24 +1 +1007.51 +1777.14 +1 +1007.61 +1729.47 +1 +1007.71 +1707.44 +1 +1007.81 +1685.22 +1 +1007.91 +1823.56 +1 +1008.01 +1773.63 +1 +1008.11 +1798.18 +1 +1008.21 +1658.13 +1 +1008.31 +1712.2 +1 +1008.41 +1712.79 +1 +1008.51 +1786.61 +1 +1008.61 +1802.67 +1 +1008.71 +1800.84 +1 +1008.81 +1845.9 +1 +1008.91 +1794.35 +1 +1009.01 +1683.68 +1 +1009.11 +1746.38 +1 +1009.21 +1813.12 +1 +1009.31 +1744.82 +1 +1009.41 +1813.56 +1 +1009.51 +1879.87 +1 +1009.61 +1808.8 +1 +1009.71 +1876.88 +1 +1009.81 +1852.78 +1 +1009.91 +1811.09 +1 +1010.01 +1835.17 +1 +1010.11 +1720.69 +1 +1010.21 +1870.48 +1 +1010.31 +1845.77 +1 +1010.41 +1890.29 +1 +1010.51 +1887.68 +1 +1010.61 +1915.28 +1 +1010.71 +1897.2 +1 +1010.81 +1843.1 +1 +1010.91 +1882.49 +1 +1011.01 +1923.08 +1 +1011.11 +1869.6 +1 +1011.21 +1931.1 +1 +1011.31 +1872.84 +1 +1011.41 +1856.21 +1 +1011.51 +1754.08 +1 +1011.61 +1854.61 +1 +1011.71 +1836.8 +1 +1011.81 +1858.82 +1 +1011.91 +1916.85 +1 +1012.01 +1958.7 +1 +1012.11 +1946.96 +1 +1012.21 +1843.17 +1 +1012.31 +1901.22 +1 +1012.41 +1979.69 +1 +1012.51 +1873.84 +1 +1012.61 +1820.68 +1 +1012.71 +1919.9 +1 +1012.81 +1879.35 +1 +1012.91 +1933.45 +1 +1013.01 +1916.62 +1 +1013.11 +1825.82 +1 +1013.21 +1825.83 +1 +1013.31 +1934.56 +1 +1013.41 +1951.73 +1 +1013.51 +1848.74 +1 +1013.61 +1941.73 +1 +1013.71 +2018.38 +1 +1013.81 +1930.07 +1 +1013.91 +1920.36 +1 +1014.01 +2013.36 +1 +1014.11 +1984.06 +1 +1014.21 +2007.5 +1 +1014.31 +1948.81 +1 +1014.41 +1946.49 +1 +1014.51 +1951.41 +1 +1014.61 +1930.67 +1 +1014.71 +1969.69 +1 +1014.81 +2028.56 +1 +1014.91 +1991.82 +1 +1015.01 +1942.89 +1 +1015.11 +1909.56 +1 +1015.21 +1915.99 +1 +1015.31 +1955.57 +1 +1015.41 +2015.53 +1 +1015.51 +1852.58 +1 +1015.61 +1963.3 +1 +1015.61 +1933.49 +1 +1015.66 +1941.26 +1 +1015.71 +1965.15 +1 +1015.71 +1877.62 +1 +1015.76 +1971.51 +1 +1015.81 +1973.09 +1 +1015.81 +1768.22 +1 +1015.86 +2021.45 +1 +1015.91 +1933.58 +1 +1015.91 +1947.46 +1 +1015.96 +1956.42 +1 +1016.01 +1980.6 +1 +1016.01 +1869.75 +1 +1016.06 +1855.78 +1 +1016.11 +1938.97 +1 +1016.11 +1872.9 +1 +1016.16 +1999.16 +1 +1016.21 +1972.71 +1 +1016.21 +1929.9 +1 +1016.26 +1973.12 +1 +1016.31 +1848.81 +1 +1016.31 +1885.8 +1 +1016.36 +1938.1 +1 +1016.41 +2018.31 +1 +1016.41 +1808.37 +1 +1016.46 +1981.29 +1 +1016.51 +1823.87 +1 +1016.51 +1951.69 +1 +1016.56 +1940.62 +1 +1016.61 +1889.25 +1 +1016.61 +1812.92 +1 +1016.66 +1904.31 +1 +1016.71 +1895.27 +1 +1016.76 +1935.61 +1 +1016.81 +1942.68 +1 +1016.86 +1929.89 +1 +1016.91 +1882.81 +1 +1016.96 +1902.12 +1 +1017.01 +1901.64 +1 +1017.06 +1902.15 +1 +1017.11 +1889.43 +1 +1017.16 +1937.09 +1 +1017.21 +1926.96 +1 +1017.26 +1910.96 +1 +1017.31 +1844.52 +1 +1017.36 +1896.03 +1 +1017.41 +1863.37 +1 +1017.46 +1931.4 +1 +1017.51 +1887.82 +1 +1017.56 +1865.67 +1 +1017.61 +1912.49 +1 +1017.66 +1895.03 +1 +1017.71 +1966.08 +1 +1017.76 +1927.63 +1 +1017.81 +1876.22 +1 +1017.86 +1850.19 +1 +1017.91 +1906.06 +1 +1017.96 +1938.18 +1 +1018.01 +1950.47 +1 +1018.06 +1817.53 +1 +1018.11 +1766.07 +1 +1018.16 +1759.62 +1 +1018.21 +1838.78 +1 +1018.26 +1838.98 +1 +1018.31 +1809.91 +1 +1018.36 +1803.35 +1 +1018.41 +1828.37 +1 +1018.46 +1830.74 +1 +1018.51 +1836.04 +1 +1018.56 +1808.17 +1 +1018.61 +1865.96 +1 +1018.66 +1815.38 +1 +1018.71 +1796.13 +1 +1018.76 +1857.29 +1 +1018.81 +1805.1 +1 +1018.86 +1890.62 +1 +1018.91 +1837.8 +1 +1018.96 +1821.53 +1 +1019.01 +1816.02 +1 +1019.06 +1822.96 +1 +1019.11 +1846.53 +1 +1019.16 +1843.97 +1 +1019.21 +1816.55 +1 +1019.26 +1844.37 +1 +1019.31 +1751.26 +1 +1019.36 +1801.92 +1 +1019.41 +1833.22 +1 +1019.46 +1792.86 +1 +1019.51 +1794.61 +1 +1019.56 +1781.12 +1 +1019.61 +1772.53 +1 +1019.66 +1779.03 +1 +1019.71 +1816.7 +1 +1019.76 +1731.66 +1 +1019.81 +1753.41 +1 +1019.86 +1744.02 +1 +1019.91 +1781.79 +1 +1019.96 +1769.55 +1 +1020.01 +1744.31 +1 +1020.06 +1728.57 +1 +1020.11 +1709.92 +1 +1020.16 +1750.91 +1 +1020.21 +1729.59 +1 +1020.26 +1691.85 +1 +1020.31 +1661.76 +1 +1020.36 +1641.75 +1 +1020.41 +1691.15 +1 +1020.46 +1696.6 +1 +1020.51 +1641.03 +1 +1020.56 +1664.82 +1 +1020.61 +1685.23 +1 +1020.66 +1734.4 +1 +1020.71 +1743.33 +1 +1020.76 +1725.8 +1 +1020.81 +1641.08 +1 +1020.86 +1659.57 +1 +1020.91 +1642.85 +1 +1020.96 +1653.85 +1 +1021.01 +1642.46 +1 +1021.06 +1596.89 +1 +1021.11 +1655.18 +1 +1021.16 +1631.72 +1 +1021.21 +1677.89 +1 +1021.26 +1615.46 +1 +1021.31 +1575.95 +1 +1021.36 +1635.74 +1 +1021.41 +1637.82 +1 +1021.46 +1621.95 +1 +1021.51 +1624.47 +1 +1021.56 +1602.28 +1 +1021.61 +1617.64 +1 +1021.66 +1661.08 +1 +1021.71 +1601.39 +1 +1021.76 +1597.96 +1 +1021.81 +1634.78 +1 +1021.86 +1515.82 +1 +1021.91 +1529.38 +1 +1021.96 +1589.72 +1 +1022.01 +1631.87 +1 +1022.06 +1600.49 +1 +1022.11 +1609.53 +1 +1022.16 +1621.86 +1 +1022.21 +1618.58 +1 +1022.26 +1588.22 +1 +1022.31 +1611.16 +1 +1022.36 +1538.82 +1 +1022.41 +1555.75 +1 +1022.46 +1623.54 +1 +1022.51 +1596.04 +1 +1022.56 +1598.46 +1 +1022.61 +1625.18 +1 +1022.66 +1625.41 +1 +1022.71 +1559.8 +1 +1022.76 +1590.72 +1 +1022.81 +1603 +1 +1022.86 +1625.45 +1 +1022.91 +1614.94 +1 +1022.96 +1616.31 +1 +1023.01 +1646.62 +1 +1023.06 +1605.99 +1 +1023.11 +1574.2 +1 +1023.16 +1653.07 +1 +1023.21 +1616.84 +1 +1023.26 +1643.5 +1 +1023.31 +1681.81 +1 +1023.36 +1687.59 +1 +1023.41 +1643.74 +1 +1023.46 +1699.56 +1 +1023.51 +1685.63 +1 +1023.56 +1623.89 +1 +1023.61 +1709.65 +1 +1023.66 +1685.35 +1 +1023.71 +1678.15 +1 +1023.76 +1712.26 +1 +1023.81 +1734.06 +1 +1023.86 +1753.33 +1 +1023.91 +1749.23 +1 +1023.96 +1685.39 +1 +1024.01 +1678.21 +1 +1024.06 +1703.71 +1 +1024.11 +1667.25 +1 +1024.16 +1723.33 +1 +1024.21 +1737.96 +1 +1024.26 +1747.16 +1 +1024.31 +1784.91 +1 +1024.36 +1834.63 +1 +1024.41 +1847.48 +1 +1024.46 +1857.75 +1 +1024.51 +1841.84 +1 +1024.56 +1830 +1 +1024.61 +1880.13 +1 +1024.66 +1914.53 +1 +1024.71 +1958.79 +1 +1024.76 +1980.26 +1 +1024.81 +1929.9 +1 +1024.86 +1946.76 +1 +1024.91 +2011.96 +1 +1024.96 +1987.89 +1 +1025.01 +1956.88 +1 +1025.06 +2011.1 +1 +1025.11 +1984.67 +1 +1025.16 +2039.99 +1 +1025.21 +2056.17 +1 +1025.26 +2128.09 +1 +1025.31 +2070.19 +1 +1025.36 +2128.97 +1 +1025.41 +2115.4 +1 +1025.46 +2262.59 +1 +1025.51 +2320.48 +1 +1025.56 +2286.48 +1 +1025.61 +2379.47 +1 +1025.66 +2412.44 +1 +1025.71 +2474.45 +1 +1025.76 +2484.5 +1 +1025.81 +2593.62 +1 +1025.86 +2650.32 +1 +1025.91 +2727.02 +1 +1025.96 +2862.62 +1 +1026.01 +2860.44 +1 +1026.06 +3055.64 +1 +1026.11 +3137.41 +1 +1026.16 +3219.96 +1 +1026.21 +3305.52 +1 +1026.26 +3447.77 +1 +1026.31 +3530.05 +1 +1026.36 +3615.49 +1 +1026.41 +3658.58 +1 +1026.46 +3777.02 +1 +1026.51 +3966.76 +1 +1026.56 +4018.36 +1 +1026.61 +4079.39 +1 +1026.66 +4113.2 +1 +1026.71 +4028.53 +1 +1026.76 +4037.47 +1 +1026.81 +3963.71 +1 +1026.86 +3850.84 +1 +1026.91 +3698.38 +1 +1026.96 +3619.54 +1 +1027.01 +3422.72 +1 +1027.06 +3176.2 +1 +1027.11 +3153.17 +1 +1027.16 +3044.57 +1 +1027.21 +2829.88 +1 +1027.26 +2589.45 +1 +1027.31 +2474.68 +1 +1027.36 +2354.17 +1 +1027.41 +2254.55 +1 +1027.46 +2028.81 +1 +1027.51 +2031.41 +1 +1027.56 +1822.23 +1 +1027.61 +1832.39 +1 +1027.66 +1757.17 +1 +1027.71 +1626.62 +1 +1027.76 +1673.17 +1 +1027.81 +1630.39 +1 +1027.86 +1465.44 +1 +1027.91 +1470.7 +1 +1027.96 +1448.93 +1 +1028.01 +1361.87 +1 +1028.06 +1306.54 +1 +1028.11 +1325.99 +1 +1028.16 +1288.78 +1 +1028.21 +1338 +1 +1028.26 +1353.09 +1 +1028.31 +1321.05 +1 +1028.36 +1320.89 +1 +1028.41 +1233.07 +1 +1028.46 +1219.36 +1 +1028.51 +1236.26 +1 +1028.56 +1258.57 +1 +1028.61 +1202.57 +1 +1028.66 +1213.91 +1 +1028.71 +1188.95 +1 +1028.76 +1237.24 +1 +1028.81 +1213.76 +1 +1028.86 +1175.42 +1 +1028.91 +1218.24 +1 +1028.96 +1226.62 +1 +1029.01 +1264.76 +1 +1029.06 +1243.46 +1 +1029.11 +1216.39 +1 +1029.16 +1275.79 +1 +1029.21 +1290.32 +1 +1029.26 +1184.19 +1 +1029.31 +1207.88 +1 +1029.36 +1225.3 +1 +1029.41 +1256.9 +1 +1029.46 +1249.17 +1 +1029.51 +1235.28 +1 +1029.56 +1277.07 +1 +1029.61 +1330.8 +1 +1029.66 +1323.01 +1 +1029.71 +1324.2 +1 +1029.76 +1344.62 +1 +1029.81 +1308.33 +1 +1029.86 +1333.98 +1 +1029.91 +1324.21 +1 +1029.96 +1308.42 +1 +1030.01 +1352.92 +1 +1030.06 +1376.73 +1 +1030.11 +1373.89 +1 +1030.16 +1427.71 +1 +1030.21 +1426.87 +1 +1030.26 +1481.12 +1 +1030.31 +1499.48 +1 +1030.36 +1465.18 +1 +1030.41 +1526.2 +1 +1030.46 +1531.63 +1 +1030.51 +1530.68 +1 +1030.56 +1558.82 +1 +1030.61 +1578.27 +1 +1030.66 +1606.92 +1 +1030.71 +1658.45 +1 +1030.76 +1627.62 +1 +1030.81 +1707.29 +1 +1030.86 +1783.53 +1 +1030.91 +1789.62 +1 +1030.96 +1818.66 +1 +1031.01 +1794.29 +1 +1031.06 +1841.96 +1 +1031.11 +1842.23 +1 +1031.16 +1919.9 +1 +1031.21 +1996.49 +1 +1031.26 +2097.07 +1 +1031.31 +2098.6 +1 +1031.36 +2159.06 +1 +1031.41 +2191.78 +1 +1031.46 +2365.46 +1 +1031.51 +2365.36 +1 +1031.56 +2361.12 +1 +1031.61 +2539.57 +1 +1031.66 +2612.76 +1 +1031.71 +2578.6 +1 +1031.76 +2815.58 +1 +1031.81 +2917.59 +1 +1031.86 +3025.62 +1 +1031.91 +3160.55 +1 +1031.96 +3234.93 +1 +1032.01 +3381.58 +1 +1032.06 +3530.59 +1 +1032.11 +3778.39 +1 +1032.16 +3966.65 +1 +1032.21 +4160 +1 +1032.26 +4551.55 +1 +1032.31 +4784.78 +1 +1032.36 +5131.12 +1 +1032.41 +5563.98 +1 +1032.46 +5837.79 +1 +1032.51 +6216.12 +1 +1032.56 +6564.46 +1 +1032.61 +6849.11 +1 +1032.66 +7123.46 +1 +1032.71 +7348.28 +1 +1032.76 +7566.48 +1 +1032.81 +7540.43 +1 +1032.86 +7522.43 +1 +1032.91 +7300.02 +1 +1032.96 +7014.46 +1 +1033.01 +6650.6 +1 +1033.06 +6298.39 +1 +1033.11 +5814.3 +1 +1033.16 +5241.1 +1 +1033.21 +4719.32 +1 +1033.26 +4082.49 +1 +1033.31 +3539.61 +1 +1033.36 +2979.52 +1 +1033.41 +2604.1 +1 +1033.46 +2080.86 +1 +1033.51 +1789.26 +1 +1033.56 +1507.07 +1 +1033.61 +1208.84 +1 +1033.66 +1004.87 +1 +1033.71 +840.511 +1 +1033.76 +696.477 +1 +1033.81 +639.592 +1 +1033.86 +534.113 +1 +1033.91 +442.715 +1 +1033.96 +403.622 +1 +1034.01 +325.708 +1 +1034.06 +310.052 +1 +1034.11 +273.502 +1 +1034.16 +251.865 +1 +1034.21 +224.698 +1 +1034.26 +218.158 +1 +1034.31 +189.398 +1 +1034.36 +152.771 +1 +1034.41 +145.057 +1 +1034.46 +158.48 +1 +1034.51 +171.61 +1 +1034.56 +155.34 +1 +1034.61 +126.164 +1 +1034.66 +119.394 +1 +1034.71 +98.7856 +1 +1034.76 +104.416 +1 +1034.81 +102.57 +1 +1034.86 +87.9027 +1 +1034.91 +102.569 +1 +1034.96 +64.2042 +1 +1035.01 +86.0091 +1 +1035.06 +83.7235 +1 +1035.11 +65.2265 +1 +1035.16 +66.9629 +1 +1035.21 +81.7472 +1 +1035.26 +54.5349 +1 +1035.31 +72.9072 +1 +1035.36 +62.729 +1 +1035.41 +54.6963 +1 +1035.46 +52.9836 +1 +1035.51 +51.4427 +1 +1035.56 +66.2454 +1 +1035.61 +27.7958 +1 +1035.66 +22.6612 +1 +1035.71 +47.0201 +1 +1035.76 +48.3473 +1 +1035.81 +31.6776 +1 +1035.86 +42.2973 +1 +1035.91 +39.7689 +1 +1035.96 +43.744 +1 +1036.01 +46.7088 +1 +1036.06 +23.7669 +1 +1036.11 +21.9353 +1 +1036.16 +30.339 +1 +1036.21 +24.5338 +1 +1036.26 +42.0066 +1 +1036.31 +32.2861 +1 +1036.36 +32.8994 +1 +1036.41 +16.5913 +1 +1036.46 +22.0684 +1 +1036.51 +33.4338 +1 +1036.56 +8.30744 +1 +1036.61 +-0.320683 +1 +1036.66 +18.5145 +1 +1036.71 +1.25567 +1 +1036.76 +25.7189 +1 +1036.81 +17.9205 +1 +1036.86 +26.8709 +1 +1036.91 +25.6579 +1 +1036.96 +6.53318 +1 +1037.01 +4.06964 +1 +1037.06 +-1.81192 +1 +1037.11 +-0.175084 +1 +1037.16 +-0.188564 +1 +1037.21 +-11.2699 +1 +1037.26 +-15.6917 +1 +1037.31 +-6.23708 +1 +1037.36 +-6.73301 +1 +1037.41 +-0.235253 +1 +1037.46 +10.3945 +1 +1037.51 +10.0545 +1 +1037.56 +-19.4511 +1 +1037.61 +-5.57347 +1 +1037.66 +-8.28048 +1 +1037.71 +-10.6555 +1 +1037.76 +15.8692 +1 +1037.81 +1.42326 +1 +1037.86 +10.7452 +1 +1037.91 +-15.8064 +1 +1037.96 +4.76975 +1 +1038.01 +-3.04375 +1 +1038.06 +8.44116 +1 +1038.11 +19.9889 +1 +1038.16 +-3.29813 +1 +1038.21 +-3.13742 +1 +1038.26 +9.13695 +1 +1038.31 +-9.16297 +1 +1038.36 +-11.0692 +1 +1038.41 +-16.0218 +1 +1038.46 +-9.66303 +1 +1038.51 +-21.0405 +1 +1038.56 +-8.54283 +1 +1038.61 +4.97534 +1 +1038.66 +-16.1839 +1 +1038.71 +-15.0884 +1 +1038.76 +2.18459 +1 +1038.81 +16.2773 +1 +1038.86 +-4.55229 +1 +1038.91 +-0.530202 +1 +1038.96 +9.59498 +1 +1039.01 +-7.12591 +1 +1039.06 +-11.1653 +1 +1039.11 +-11.6532 +1 +1039.16 +-11.1526 +1 +1039.21 +7.07497 +1 +1039.26 +-12.3676 +1 +1039.31 +-12.9418 +1 +1039.36 +-25.59 +1 +1039.41 +-22.8096 +1 +1039.46 +-4.09079 +1 +1039.51 +-17.3984 +1 +1039.56 +-4.18499 +1 +1039.61 +-8.62249 +1 +1039.66 +-10.5458 +1 +1039.71 +-3.7872 +1 +1039.76 +-11.0384 +1 +1039.81 +-12.3709 +1 +1039.86 +-22.5307 +1 +1039.91 +-13.1936 +1 +1039.96 +-24.3836 +1 +1040.01 +-37.2227 +1 +1040.06 +3.18044 +1 +1040.11 +3.24155 +1 +1040.16 +3.11073 +1 +1040.21 +0 +1 +1040.26 +0 +1 +1040.31 +0 +1 +1040.36 +0 +1 +1040.41 +0 +1 +1040.46 +0 +1 +1040.51 +0 +1 +1040.56 +0 +1 +1040.61 +0 +1 +Ti2p +Ti metal +0 +0 +0 +0 +0 +0 +0 +14 +Casa Info Follows +0 +0 +1 +CASA region (*Ti 2p*) (*Min Limits*) 987.96 1039.26 7.7123335 2 0 0 0 -1643 0 0 (*Ti 2p*) 47.8784 0 7.81 +1 +CASA comp (*Ti metal*) (*&TI_MET*) Area 1.0023163 1e-020 472189.94 -1 1 MFWHM 1 1 1 -1 1 Position 1013.2961 1012.9961 1013.5961 -1 1 RSF 7.7123335 MASS 47.8784 INDEX 0 (*Ti0*) CONST (**) UNCORRECTEDRSF 7.81 + +PCA Coefs = 54487.5, 23477.3, -4356.52, 108.165, +PCA Coefs = 54487.5, 23477.3, -4356.52, 108.165, -1011.67, +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +C:\Users\pielsticker\Downloads\Ti\references_irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p fit +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.61 +1380.79 +1 +986.71 +1379.61 +1 +986.81 +1342.46 +1 +986.91 +1357.98 +1 +987.01 +1384.78 +1 +987.11 +1338.23 +1 +987.21 +1302.73 +1 +987.31 +1369.8 +1 +987.41 +1340.63 +1 +987.51 +1326.81 +1 +987.61 +1308.49 +1 +987.71 +1297.46 +1 +987.81 +1366.09 +1 +987.91 +1417.54 +1 +988.01 +1429.56 +1 +988.11 +1338.43 +1 +988.21 +1307.35 +1 +988.31 +1331.1 +1 +988.41 +1342.77 +1 +988.51 +1352.87 +1 +988.61 +1334.16 +1 +988.71 +1322.33 +1 +988.81 +1336.04 +1 +988.91 +1337.25 +1 +989.01 +1291.69 +1 +989.11 +1331.42 +1 +989.21 +1362.36 +1 +989.31 +1367.73 +1 +989.41 +1321.77 +1 +989.51 +1331.19 +1 +989.61 +1337.59 +1 +989.71 +1354.37 +1 +989.81 +1337.41 +1 +989.91 +1414.58 +1 +990.01 +1375.48 +1 +990.11 +1329.94 +1 +990.21 +1340.48 +1 +990.31 +1299.66 +1 +990.41 +1329.48 +1 +990.51 +1336.35 +1 +990.61 +1374.2 +1 +990.71 +1329.05 +1 +990.81 +1364.6 +1 +990.91 +1275.77 +1 +991.01 +1403.71 +1 +991.11 +1391.23 +1 +991.21 +1385.94 +1 +991.31 +1408.94 +1 +991.41 +1378.4 +1 +991.51 +1311.37 +1 +991.61 +1388.73 +1 +991.71 +1357.91 +1 +991.81 +1398.56 +1 +991.91 +1318.21 +1 +992.01 +1324.53 +1 +992.11 +1390.02 +1 +992.21 +1299.01 +1 +992.31 +1376.27 +1 +992.41 +1368.45 +1 +992.51 +1384.67 +1 +992.61 +1327.26 +1 +992.71 +1345.15 +1 +992.81 +1363.08 +1 +992.91 +1365.75 +1 +993.01 +1307.44 +1 +993.11 +1363.56 +1 +993.21 +1293.28 +1 +993.31 +1339.81 +1 +993.41 +1331.02 +1 +993.51 +1325.31 +1 +993.61 +1339.19 +1 +993.71 +1382.03 +1 +993.81 +1270.13 +1 +993.91 +1311.58 +1 +994.01 +1363.6 +1 +994.11 +1378.17 +1 +994.21 +1289.73 +1 +994.31 +1438.27 +1 +994.41 +1295.38 +1 +994.51 +1371.09 +1 +994.61 +1381.04 +1 +994.71 +1391.69 +1 +994.81 +1354.23 +1 +994.91 +1386.57 +1 +995.01 +1303.35 +1 +995.11 +1321.43 +1 +995.21 +1369.64 +1 +995.31 +1438.72 +1 +995.41 +1409.51 +1 +995.51 +1401.62 +1 +995.61 +1421.9 +1 +995.71 +1412.13 +1 +995.81 +1429.47 +1 +995.91 +1360.03 +1 +996.01 +1401.67 +1 +996.11 +1377.03 +1 +996.21 +1353.26 +1 +996.31 +1442.57 +1 +996.41 +1318.8 +1 +996.51 +1292.64 +1 +996.61 +1475.21 +1 +996.71 +1394.63 +1 +996.81 +1382.38 +1 +996.91 +1497.62 +1 +997.01 +1445.13 +1 +997.11 +1444.74 +1 +997.21 +1423.46 +1 +997.31 +1449.53 +1 +997.41 +1437.41 +1 +997.51 +1436.63 +1 +997.61 +1459.79 +1 +997.71 +1452.47 +1 +997.81 +1374.02 +1 +997.91 +1365.02 +1 +998.01 +1425.56 +1 +998.11 +1477.99 +1 +998.21 +1395.59 +1 +998.31 +1349.93 +1 +998.41 +1406.85 +1 +998.51 +1442.93 +1 +998.61 +1426.26 +1 +998.71 +1425.03 +1 +998.81 +1448.98 +1 +998.91 +1417.89 +1 +999.01 +1363.7 +1 +999.11 +1357.04 +1 +999.21 +1372.19 +1 +999.31 +1451.86 +1 +999.41 +1440.96 +1 +999.51 +1447.06 +1 +999.61 +1472.97 +1 +999.71 +1420.74 +1 +999.81 +1469.9 +1 +999.91 +1469.79 +1 +1000.01 +1410.93 +1 +1000.11 +1469.51 +1 +1000.21 +1427.66 +1 +1000.31 +1474.49 +1 +1000.41 +1484.39 +1 +1000.51 +1499.16 +1 +1000.61 +1439.94 +1 +1000.71 +1501.69 +1 +1000.81 +1473.67 +1 +1000.91 +1424.29 +1 +1001.01 +1510.63 +1 +1001.11 +1439.25 +1 +1001.21 +1504.56 +1 +1001.31 +1449.63 +1 +1001.41 +1499.57 +1 +1001.51 +1516.59 +1 +1001.61 +1470.99 +1 +1001.71 +1446.03 +1 +1001.81 +1491.14 +1 +1001.91 +1482.6 +1 +1002.01 +1458.25 +1 +1002.11 +1464.51 +1 +1002.21 +1528.15 +1 +1002.31 +1599.73 +1 +1002.41 +1519.57 +1 +1002.51 +1464.08 +1 +1002.61 +1500.98 +1 +1002.71 +1491.64 +1 +1002.81 +1506.13 +1 +1002.91 +1493.78 +1 +1003.01 +1490.32 +1 +1003.11 +1562.09 +1 +1003.21 +1609.35 +1 +1003.31 +1533.6 +1 +1003.41 +1496.24 +1 +1003.51 +1515.64 +1 +1003.61 +1520.53 +1 +1003.71 +1584.04 +1 +1003.81 +1479.16 +1 +1003.91 +1498.88 +1 +1004.01 +1597.33 +1 +1004.11 +1576.33 +1 +1004.21 +1609.96 +1 +1004.31 +1589.92 +1 +1004.41 +1588.85 +1 +1004.51 +1571.07 +1 +1004.61 +1564.75 +1 +1004.71 +1641.64 +1 +1004.81 +1614.72 +1 +1004.91 +1545.26 +1 +1005.01 +1584.59 +1 +1005.11 +1642.09 +1 +1005.21 +1624.18 +1 +1005.31 +1587.97 +1 +1005.41 +1664.19 +1 +1005.51 +1622.77 +1 +1005.61 +1631.17 +1 +1005.71 +1685.78 +1 +1005.81 +1639.74 +1 +1005.91 +1667.52 +1 +1006.01 +1660.09 +1 +1006.11 +1692.51 +1 +1006.21 +1740.76 +1 +1006.31 +1741.68 +1 +1006.41 +1670.29 +1 +1006.51 +1597.06 +1 +1006.61 +1699.18 +1 +1006.71 +1670.17 +1 +1006.81 +1693.94 +1 +1006.91 +1620.58 +1 +1007.01 +1651.87 +1 +1007.11 +1653.77 +1 +1007.21 +1699.66 +1 +1007.31 +1772.5 +1 +1007.41 +1760.24 +1 +1007.51 +1777.14 +1 +1007.61 +1729.47 +1 +1007.71 +1707.44 +1 +1007.81 +1685.22 +1 +1007.91 +1823.56 +1 +1008.01 +1773.63 +1 +1008.11 +1798.18 +1 +1008.21 +1658.13 +1 +1008.31 +1712.2 +1 +1008.41 +1712.79 +1 +1008.51 +1786.61 +1 +1008.61 +1802.67 +1 +1008.71 +1800.84 +1 +1008.81 +1845.9 +1 +1008.91 +1794.35 +1 +1009.01 +1683.68 +1 +1009.11 +1746.38 +1 +1009.21 +1813.12 +1 +1009.31 +1744.82 +1 +1009.41 +1813.56 +1 +1009.51 +1879.87 +1 +1009.61 +1808.8 +1 +1009.71 +1876.88 +1 +1009.81 +1852.78 +1 +1009.91 +1811.09 +1 +1010.01 +1835.17 +1 +1010.11 +1720.69 +1 +1010.21 +1870.48 +1 +1010.31 +1845.77 +1 +1010.41 +1890.29 +1 +1010.51 +1887.68 +1 +1010.61 +1915.28 +1 +1010.71 +1897.2 +1 +1010.81 +1843.1 +1 +1010.91 +1882.49 +1 +1011.01 +1923.08 +1 +1011.11 +1869.6 +1 +1011.21 +1931.1 +1 +1011.31 +1872.84 +1 +1011.41 +1856.21 +1 +1011.51 +1754.08 +1 +1011.61 +1854.61 +1 +1011.71 +1836.8 +1 +1011.81 +1858.82 +1 +1011.91 +1916.85 +1 +1012.01 +1958.7 +1 +1012.11 +1946.96 +1 +1012.21 +1843.17 +1 +1012.31 +1901.22 +1 +1012.41 +1979.69 +1 +1012.51 +1873.84 +1 +1012.61 +1820.68 +1 +1012.71 +1919.9 +1 +1012.81 +1879.35 +1 +1012.91 +1933.45 +1 +1013.01 +1916.62 +1 +1013.11 +1825.82 +1 +1013.21 +1825.83 +1 +1013.31 +1934.56 +1 +1013.41 +1951.73 +1 +1013.51 +1848.74 +1 +1013.61 +1941.73 +1 +1013.71 +2018.38 +1 +1013.81 +1930.07 +1 +1013.91 +1920.36 +1 +1014.01 +2013.36 +1 +1014.11 +1984.06 +1 +1014.21 +2007.5 +1 +1014.31 +1948.81 +1 +1014.41 +1946.49 +1 +1014.51 +1951.41 +1 +1014.61 +1930.67 +1 +1014.71 +1969.69 +1 +1014.81 +2028.56 +1 +1014.91 +1991.82 +1 +1015.01 +1942.89 +1 +1015.11 +1909.56 +1 +1015.21 +1915.99 +1 +1015.31 +1955.57 +1 +1015.41 +2015.53 +1 +1015.51 +1852.58 +1 +1015.61 +1963.3 +1 +1015.61 +1933.49 +1 +1015.66 +1941.26 +1 +1015.71 +1965.15 +1 +1015.71 +1877.62 +1 +1015.76 +1971.51 +1 +1015.81 +1973.09 +1 +1015.81 +1768.22 +1 +1015.86 +2021.45 +1 +1015.91 +1933.58 +1 +1015.91 +1947.46 +1 +1015.96 +1956.42 +1 +1016.01 +1980.6 +1 +1016.01 +1869.75 +1 +1016.06 +1855.78 +1 +1016.11 +1938.97 +1 +1016.11 +1872.9 +1 +1016.16 +1999.16 +1 +1016.21 +1972.71 +1 +1016.21 +1929.9 +1 +1016.26 +1973.12 +1 +1016.31 +1848.81 +1 +1016.31 +1885.8 +1 +1016.36 +1938.1 +1 +1016.41 +2018.31 +1 +1016.41 +1808.37 +1 +1016.46 +1981.29 +1 +1016.51 +1823.87 +1 +1016.51 +1951.69 +1 +1016.56 +1940.62 +1 +1016.61 +1889.25 +1 +1016.61 +1812.92 +1 +1016.66 +1904.31 +1 +1016.71 +1895.27 +1 +1016.76 +1935.61 +1 +1016.81 +1942.68 +1 +1016.86 +1929.89 +1 +1016.91 +1882.81 +1 +1016.96 +1902.12 +1 +1017.01 +1901.64 +1 +1017.06 +1902.15 +1 +1017.11 +1889.43 +1 +1017.16 +1937.09 +1 +1017.21 +1926.96 +1 +1017.26 +1910.96 +1 +1017.31 +1844.52 +1 +1017.36 +1896.03 +1 +1017.41 +1863.37 +1 +1017.46 +1931.4 +1 +1017.51 +1887.82 +1 +1017.56 +1865.67 +1 +1017.61 +1912.49 +1 +1017.66 +1895.03 +1 +1017.71 +1966.08 +1 +1017.76 +1927.63 +1 +1017.81 +1876.22 +1 +1017.86 +1850.19 +1 +1017.91 +1906.06 +1 +1017.96 +1938.18 +1 +1018.01 +1950.47 +1 +1018.06 +1817.53 +1 +1018.11 +1766.07 +1 +1018.16 +1759.62 +1 +1018.21 +1838.78 +1 +1018.26 +1838.98 +1 +1018.31 +1809.91 +1 +1018.36 +1803.35 +1 +1018.41 +1828.37 +1 +1018.46 +1830.74 +1 +1018.51 +1836.04 +1 +1018.56 +1808.17 +1 +1018.61 +1865.96 +1 +1018.66 +1815.38 +1 +1018.71 +1796.13 +1 +1018.76 +1857.29 +1 +1018.81 +1805.1 +1 +1018.86 +1890.62 +1 +1018.91 +1837.8 +1 +1018.96 +1821.53 +1 +1019.01 +1816.02 +1 +1019.06 +1822.96 +1 +1019.11 +1846.53 +1 +1019.16 +1843.97 +1 +1019.21 +1816.55 +1 +1019.26 +1844.37 +1 +1019.31 +1751.26 +1 +1019.36 +1801.92 +1 +1019.41 +1833.22 +1 +1019.46 +1792.86 +1 +1019.51 +1794.61 +1 +1019.56 +1781.12 +1 +1019.61 +1772.53 +1 +1019.66 +1779.03 +1 +1019.71 +1816.7 +1 +1019.76 +1731.66 +1 +1019.81 +1753.41 +1 +1019.86 +1744.02 +1 +1019.91 +1781.79 +1 +1019.96 +1769.55 +1 +1020.01 +1744.31 +1 +1020.06 +1728.57 +1 +1020.11 +1709.92 +1 +1020.16 +1750.91 +1 +1020.21 +1729.59 +1 +1020.26 +1691.85 +1 +1020.31 +1661.76 +1 +1020.36 +1641.75 +1 +1020.41 +1691.15 +1 +1020.46 +1696.6 +1 +1020.51 +1641.03 +1 +1020.56 +1664.82 +1 +1020.61 +1685.23 +1 +1020.66 +1734.4 +1 +1020.71 +1743.33 +1 +1020.76 +1725.8 +1 +1020.81 +1641.08 +1 +1020.86 +1659.57 +1 +1020.91 +1642.85 +1 +1020.96 +1653.85 +1 +1021.01 +1642.46 +1 +1021.06 +1596.89 +1 +1021.11 +1655.18 +1 +1021.16 +1631.72 +1 +1021.21 +1677.89 +1 +1021.26 +1615.46 +1 +1021.31 +1575.95 +1 +1021.36 +1635.74 +1 +1021.41 +1637.82 +1 +1021.46 +1621.95 +1 +1021.51 +1624.47 +1 +1021.56 +1602.28 +1 +1021.61 +1617.64 +1 +1021.66 +1661.08 +1 +1021.71 +1601.39 +1 +1021.76 +1597.96 +1 +1021.81 +1634.78 +1 +1021.86 +1515.82 +1 +1021.91 +1529.38 +1 +1021.96 +1589.72 +1 +1022.01 +1631.87 +1 +1022.06 +1600.49 +1 +1022.11 +1609.53 +1 +1022.16 +1621.86 +1 +1022.21 +1618.58 +1 +1022.26 +1588.22 +1 +1022.31 +1611.16 +1 +1022.36 +1538.82 +1 +1022.41 +1555.75 +1 +1022.46 +1623.54 +1 +1022.51 +1596.04 +1 +1022.56 +1598.46 +1 +1022.61 +1625.18 +1 +1022.66 +1625.41 +1 +1022.71 +1559.8 +1 +1022.76 +1590.72 +1 +1022.81 +1603 +1 +1022.86 +1625.45 +1 +1022.91 +1614.94 +1 +1022.96 +1616.31 +1 +1023.01 +1646.62 +1 +1023.06 +1605.99 +1 +1023.11 +1574.2 +1 +1023.16 +1653.07 +1 +1023.21 +1616.84 +1 +1023.26 +1643.5 +1 +1023.31 +1681.81 +1 +1023.36 +1687.59 +1 +1023.41 +1643.74 +1 +1023.46 +1699.56 +1 +1023.51 +1685.63 +1 +1023.56 +1623.89 +1 +1023.61 +1709.65 +1 +1023.66 +1685.35 +1 +1023.71 +1678.15 +1 +1023.76 +1712.26 +1 +1023.81 +1734.06 +1 +1023.86 +1753.33 +1 +1023.91 +1749.23 +1 +1023.96 +1685.39 +1 +1024.01 +1678.21 +1 +1024.06 +1703.71 +1 +1024.11 +1667.25 +1 +1024.16 +1723.33 +1 +1024.21 +1737.96 +1 +1024.26 +1747.16 +1 +1024.31 +1784.91 +1 +1024.36 +1834.63 +1 +1024.41 +1847.48 +1 +1024.46 +1857.75 +1 +1024.51 +1841.84 +1 +1024.56 +1830 +1 +1024.61 +1880.13 +1 +1024.66 +1914.53 +1 +1024.71 +1958.79 +1 +1024.76 +1980.26 +1 +1024.81 +1929.9 +1 +1024.86 +1946.76 +1 +1024.91 +2011.96 +1 +1024.96 +1987.89 +1 +1025.01 +1956.88 +1 +1025.06 +2011.1 +1 +1025.11 +1984.67 +1 +1025.16 +2039.99 +1 +1025.21 +2056.17 +1 +1025.26 +2128.09 +1 +1025.31 +2070.19 +1 +1025.36 +2128.97 +1 +1025.41 +2115.4 +1 +1025.46 +2262.59 +1 +1025.51 +2320.48 +1 +1025.56 +2286.48 +1 +1025.61 +2379.47 +1 +1025.66 +2412.44 +1 +1025.71 +2474.45 +1 +1025.76 +2484.5 +1 +1025.81 +2593.62 +1 +1025.86 +2650.32 +1 +1025.91 +2727.02 +1 +1025.96 +2862.62 +1 +1026.01 +2860.44 +1 +1026.06 +3055.64 +1 +1026.11 +3137.41 +1 +1026.16 +3219.96 +1 +1026.21 +3305.52 +1 +1026.26 +3447.77 +1 +1026.31 +3530.05 +1 +1026.36 +3615.49 +1 +1026.41 +3658.58 +1 +1026.46 +3777.02 +1 +1026.51 +3966.76 +1 +1026.56 +4018.36 +1 +1026.61 +4079.39 +1 +1026.66 +4113.2 +1 +1026.71 +4028.53 +1 +1026.76 +4037.47 +1 +1026.81 +3963.71 +1 +1026.86 +3850.84 +1 +1026.91 +3698.38 +1 +1026.96 +3619.54 +1 +1027.01 +3422.72 +1 +1027.06 +3176.2 +1 +1027.11 +3153.17 +1 +1027.16 +3044.57 +1 +1027.21 +2829.88 +1 +1027.26 +2589.45 +1 +1027.31 +2474.68 +1 +1027.36 +2354.17 +1 +1027.41 +2254.55 +1 +1027.46 +2028.81 +1 +1027.51 +2031.41 +1 +1027.56 +1822.23 +1 +1027.61 +1832.39 +1 +1027.66 +1757.17 +1 +1027.71 +1626.62 +1 +1027.76 +1673.17 +1 +1027.81 +1630.39 +1 +1027.86 +1465.44 +1 +1027.91 +1470.7 +1 +1027.96 +1448.93 +1 +1028.01 +1361.87 +1 +1028.06 +1306.54 +1 +1028.11 +1325.99 +1 +1028.16 +1288.78 +1 +1028.21 +1338 +1 +1028.26 +1353.09 +1 +1028.31 +1321.05 +1 +1028.36 +1320.89 +1 +1028.41 +1233.07 +1 +1028.46 +1219.36 +1 +1028.51 +1236.26 +1 +1028.56 +1258.57 +1 +1028.61 +1202.57 +1 +1028.66 +1213.91 +1 +1028.71 +1188.95 +1 +1028.76 +1237.24 +1 +1028.81 +1213.76 +1 +1028.86 +1175.42 +1 +1028.91 +1218.24 +1 +1028.96 +1226.62 +1 +1029.01 +1264.76 +1 +1029.06 +1243.46 +1 +1029.11 +1216.39 +1 +1029.16 +1275.79 +1 +1029.21 +1290.32 +1 +1029.26 +1184.19 +1 +1029.31 +1207.88 +1 +1029.36 +1225.3 +1 +1029.41 +1256.9 +1 +1029.46 +1249.17 +1 +1029.51 +1235.28 +1 +1029.56 +1277.07 +1 +1029.61 +1330.8 +1 +1029.66 +1323.01 +1 +1029.71 +1324.2 +1 +1029.76 +1344.62 +1 +1029.81 +1308.33 +1 +1029.86 +1333.98 +1 +1029.91 +1324.21 +1 +1029.96 +1308.42 +1 +1030.01 +1352.92 +1 +1030.06 +1376.73 +1 +1030.11 +1373.89 +1 +1030.16 +1427.71 +1 +1030.21 +1426.87 +1 +1030.26 +1481.12 +1 +1030.31 +1499.48 +1 +1030.36 +1465.18 +1 +1030.41 +1526.2 +1 +1030.46 +1531.63 +1 +1030.51 +1530.68 +1 +1030.56 +1558.82 +1 +1030.61 +1578.27 +1 +1030.66 +1606.92 +1 +1030.71 +1658.45 +1 +1030.76 +1627.62 +1 +1030.81 +1707.29 +1 +1030.86 +1783.53 +1 +1030.91 +1789.62 +1 +1030.96 +1818.66 +1 +1031.01 +1794.29 +1 +1031.06 +1841.96 +1 +1031.11 +1842.23 +1 +1031.16 +1919.9 +1 +1031.21 +1996.49 +1 +1031.26 +2097.07 +1 +1031.31 +2098.6 +1 +1031.36 +2159.06 +1 +1031.41 +2191.78 +1 +1031.46 +2365.46 +1 +1031.51 +2365.36 +1 +1031.56 +2361.12 +1 +1031.61 +2539.57 +1 +1031.66 +2612.76 +1 +1031.71 +2578.6 +1 +1031.76 +2815.58 +1 +1031.81 +2917.59 +1 +1031.86 +3025.62 +1 +1031.91 +3160.55 +1 +1031.96 +3234.93 +1 +1032.01 +3381.58 +1 +1032.06 +3530.59 +1 +1032.11 +3778.39 +1 +1032.16 +3966.65 +1 +1032.21 +4160 +1 +1032.26 +4551.55 +1 +1032.31 +4784.78 +1 +1032.36 +5131.12 +1 +1032.41 +5563.98 +1 +1032.46 +5837.79 +1 +1032.51 +6216.12 +1 +1032.56 +6564.46 +1 +1032.61 +6849.11 +1 +1032.66 +7123.46 +1 +1032.71 +7348.28 +1 +1032.76 +7566.48 +1 +1032.81 +7540.43 +1 +1032.86 +7522.43 +1 +1032.91 +7300.02 +1 +1032.96 +7014.46 +1 +1033.01 +6650.6 +1 +1033.06 +6298.39 +1 +1033.11 +5814.3 +1 +1033.16 +5241.1 +1 +1033.21 +4719.32 +1 +1033.26 +4082.49 +1 +1033.31 +3539.61 +1 +1033.36 +2979.52 +1 +1033.41 +2604.1 +1 +1033.46 +2080.86 +1 +1033.51 +1789.26 +1 +1033.56 +1507.07 +1 +1033.61 +1208.84 +1 +1033.66 +1004.87 +1 +1033.71 +840.511 +1 +1033.76 +696.477 +1 +1033.81 +639.592 +1 +1033.86 +534.113 +1 +1033.91 +442.715 +1 +1033.96 +403.622 +1 +1034.01 +325.708 +1 +1034.06 +310.052 +1 +1034.11 +273.502 +1 +1034.16 +251.865 +1 +1034.21 +224.698 +1 +1034.26 +218.158 +1 +1034.31 +189.398 +1 +1034.36 +152.771 +1 +1034.41 +145.057 +1 +1034.46 +158.48 +1 +1034.51 +171.61 +1 +1034.56 +155.34 +1 +1034.61 +126.164 +1 +1034.66 +119.394 +1 +1034.71 +98.7856 +1 +1034.76 +104.416 +1 +1034.81 +102.57 +1 +1034.86 +87.9027 +1 +1034.91 +102.569 +1 +1034.96 +64.2042 +1 +1035.01 +86.0091 +1 +1035.06 +83.7235 +1 +1035.11 +65.2265 +1 +1035.16 +66.9629 +1 +1035.21 +81.7472 +1 +1035.26 +54.5349 +1 +1035.31 +72.9072 +1 +1035.36 +62.729 +1 +1035.41 +54.6963 +1 +1035.46 +52.9836 +1 +1035.51 +51.4427 +1 +1035.56 +66.2454 +1 +1035.61 +27.7958 +1 +1035.66 +22.6612 +1 +1035.71 +47.0201 +1 +1035.76 +48.3473 +1 +1035.81 +31.6776 +1 +1035.86 +42.2973 +1 +1035.91 +39.7689 +1 +1035.96 +43.744 +1 +1036.01 +46.7088 +1 +1036.06 +23.7669 +1 +1036.11 +21.9353 +1 +1036.16 +30.339 +1 +1036.21 +24.5338 +1 +1036.26 +42.0066 +1 +1036.31 +32.2861 +1 +1036.36 +32.8994 +1 +1036.41 +16.5913 +1 +1036.46 +22.0684 +1 +1036.51 +33.4338 +1 +1036.56 +8.30744 +1 +1036.61 +-0.320683 +1 +1036.66 +18.5145 +1 +1036.71 +1.25567 +1 +1036.76 +25.7189 +1 +1036.81 +17.9205 +1 +1036.86 +26.8709 +1 +1036.91 +25.6579 +1 +1036.96 +6.53318 +1 +1037.01 +4.06964 +1 +1037.06 +-1.81192 +1 +1037.11 +-0.175084 +1 +1037.16 +-0.188564 +1 +1037.21 +-11.2699 +1 +1037.26 +-15.6917 +1 +1037.31 +-6.23708 +1 +1037.36 +-6.73301 +1 +1037.41 +-0.235253 +1 +1037.46 +10.3945 +1 +1037.51 +10.0545 +1 +1037.56 +-19.4511 +1 +1037.61 +-5.57347 +1 +1037.66 +-8.28048 +1 +1037.71 +-10.6555 +1 +1037.76 +15.8692 +1 +1037.81 +1.42326 +1 +1037.86 +10.7452 +1 +1037.91 +-15.8064 +1 +1037.96 +4.76975 +1 +1038.01 +-3.04375 +1 +1038.06 +8.44116 +1 +1038.11 +19.9889 +1 +1038.16 +-3.29813 +1 +1038.21 +-3.13742 +1 +1038.26 +9.13695 +1 +1038.31 +-9.16297 +1 +1038.36 +-11.0692 +1 +1038.41 +-16.0218 +1 +1038.46 +-9.66303 +1 +1038.51 +-21.0405 +1 +1038.56 +-8.54283 +1 +1038.61 +4.97534 +1 +1038.66 +-16.1839 +1 +1038.71 +-15.0884 +1 +1038.76 +2.18459 +1 +1038.81 +16.2773 +1 +1038.86 +-4.55229 +1 +1038.91 +-0.530202 +1 +1038.96 +9.59498 +1 +1039.01 +-7.12591 +1 +1039.06 +-11.1653 +1 +1039.11 +-11.6532 +1 +1039.16 +-11.1526 +1 +1039.21 +7.07497 +1 +1039.26 +-12.3676 +1 +1039.31 +-12.9418 +1 +1039.36 +-25.59 +1 +1039.41 +-22.8096 +1 +1039.46 +-4.09079 +1 +1039.51 +-17.3984 +1 +1039.56 +-4.18499 +1 +1039.61 +-8.62249 +1 +1039.66 +-10.5458 +1 +1039.71 +-3.7872 +1 +1039.76 +-11.0384 +1 +1039.81 +-12.3709 +1 +1039.86 +-22.5307 +1 +1039.91 +-13.1936 +1 +1039.96 +-24.3836 +1 +1040.01 +-37.2227 +1 +1040.06 +3.18044 +1 +1040.11 +3.24155 +1 +1040.16 +3.11073 +1 +1040.21 +0 +1 +1040.26 +0 +1 +1040.31 +0 +1 +1040.36 +0 +1 +1040.41 +0 +1 +1040.46 +0 +1 +1040.51 +0 +1 +1040.56 +0 +1 +1040.61 +0 +1 +Ti2p +TiO +0 +0 +0 +0 +0 +0 +0 +16 +Casa Info Follows +0 +0 +1 +CASA region (*Ti 2p*) (*Min Limits*) 987.96 1039.26 7.7123335 2 0 0 0 -1643 0 0 (*Ti 2p*) 47.8784 0 7.81 +1 +CASA comp (*TiO*) (*&TIO*) Area 0.99809292 1e-020 472189.94 -1 1 MFWHM 1 1 1 -1 1 Position 1013.9144 1013.6144 1014.2144 -1 1 RSF 7.7123335 MASS 47.8784 INDEX 1 (*TiO*) CONST (**) UNCORRECTEDRSF 7.81 + +PCA Coefs = 41396.7, -3191.99, 1103.12, 387.504, +PCA Coefs = 41396.7, -3191.99, 1103.12, 387.504, -363.953, +PCA Coefs = 41439, -2585.94, 1104.79, -371.422, -359.987, 128.966, +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +C:\Users\pielsticker\Downloads\Ti\references_irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p fit +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.61 +0 +1 +986.71 +0 +1 +986.81 +0 +1 +986.91 +0 +1 +987.01 +0 +1 +987.11 +0 +1 +987.21 +0 +1 +987.31 +0 +1 +987.41 +427.081 +1 +987.51 +418.506 +1 +987.61 +421.294 +1 +987.71 +440.148 +1 +987.81 +443.528 +1 +987.91 +430.838 +1 +988.01 +445.739 +1 +988.11 +424.025 +1 +988.21 +434.13 +1 +988.31 +418.792 +1 +988.41 +428.149 +1 +988.51 +454.731 +1 +988.61 +439.937 +1 +988.71 +440.084 +1 +988.81 +432.384 +1 +988.91 +432.304 +1 +989.01 +440.641 +1 +989.11 +446.848 +1 +989.21 +426.341 +1 +989.31 +427.43 +1 +989.41 +433.208 +1 +989.51 +424.875 +1 +989.61 +432.054 +1 +989.71 +420.255 +1 +989.81 +436.188 +1 +989.91 +437.574 +1 +990.01 +442.909 +1 +990.11 +437.73 +1 +990.21 +421.943 +1 +990.31 +412.513 +1 +990.41 +435.891 +1 +990.51 +431.311 +1 +990.61 +432.78 +1 +990.71 +433.572 +1 +990.81 +418.188 +1 +990.91 +409.864 +1 +991.01 +422.085 +1 +991.11 +426.173 +1 +991.21 +444.271 +1 +991.31 +414.74 +1 +991.41 +436.211 +1 +991.51 +426.44 +1 +991.61 +422.63 +1 +991.71 +419.722 +1 +991.81 +433.338 +1 +991.91 +436.796 +1 +992.01 +436.845 +1 +992.11 +430.264 +1 +992.21 +409.348 +1 +992.31 +408.522 +1 +992.41 +437.968 +1 +992.51 +445.551 +1 +992.61 +438.706 +1 +992.71 +442.301 +1 +992.81 +436.554 +1 +992.91 +427.755 +1 +993.01 +444.831 +1 +993.11 +456.361 +1 +993.21 +439.465 +1 +993.31 +450.223 +1 +993.41 +444.027 +1 +993.51 +436.61 +1 +993.61 +442.322 +1 +993.71 +448.84 +1 +993.81 +443.012 +1 +993.91 +447.565 +1 +994.01 +442.503 +1 +994.11 +431.631 +1 +994.21 +441.927 +1 +994.31 +439.397 +1 +994.41 +446.213 +1 +994.51 +436.637 +1 +994.61 +431.379 +1 +994.71 +439.383 +1 +994.81 +437.913 +1 +994.91 +437.081 +1 +995.01 +451.356 +1 +995.11 +441.987 +1 +995.21 +433.982 +1 +995.31 +435.758 +1 +995.41 +438.365 +1 +995.51 +440.249 +1 +995.61 +441.327 +1 +995.71 +470.201 +1 +995.81 +461.681 +1 +995.91 +465.133 +1 +996.01 +457.167 +1 +996.11 +452.422 +1 +996.21 +450.82 +1 +996.31 +465.086 +1 +996.41 +461.236 +1 +996.51 +459.164 +1 +996.61 +447.345 +1 +996.71 +449.258 +1 +996.81 +459.59 +1 +996.91 +458.529 +1 +997.01 +473.17 +1 +997.11 +477.211 +1 +997.21 +459.326 +1 +997.31 +460.033 +1 +997.41 +459.628 +1 +997.51 +445.237 +1 +997.61 +452.9 +1 +997.71 +462.703 +1 +997.81 +459.284 +1 +997.91 +451.872 +1 +998.01 +456.31 +1 +998.11 +469.161 +1 +998.21 +467.634 +1 +998.31 +475.462 +1 +998.41 +474.394 +1 +998.51 +456.623 +1 +998.61 +469.981 +1 +998.71 +480.575 +1 +998.81 +487.905 +1 +998.91 +476.11 +1 +999.01 +472.079 +1 +999.11 +488.889 +1 +999.21 +482.388 +1 +999.31 +473.36 +1 +999.41 +485.498 +1 +999.51 +489.987 +1 +999.61 +486.287 +1 +999.71 +499.989 +1 +999.81 +499.325 +1 +999.91 +503.847 +1 +1000.01 +495.847 +1 +1000.11 +472.305 +1 +1000.21 +495.686 +1 +1000.31 +470.454 +1 +1000.41 +456.9 +1 +1000.51 +470.1 +1 +1000.61 +477.155 +1 +1000.71 +488.566 +1 +1000.81 +501.371 +1 +1000.91 +487.255 +1 +1001.01 +491.032 +1 +1001.11 +485.732 +1 +1001.21 +504.469 +1 +1001.31 +498.971 +1 +1001.41 +487.565 +1 +1001.51 +495.287 +1 +1001.61 +492.023 +1 +1001.71 +515.751 +1 +1001.81 +524.072 +1 +1001.91 +521.562 +1 +1002.01 +511.741 +1 +1002.11 +520.4 +1 +1002.21 +503.72 +1 +1002.31 +510.643 +1 +1002.41 +513.259 +1 +1002.51 +516.99 +1 +1002.61 +517.098 +1 +1002.71 +511.597 +1 +1002.81 +514.602 +1 +1002.91 +518.202 +1 +1003.01 +511.706 +1 +1003.11 +525.184 +1 +1003.21 +517.952 +1 +1003.31 +517.622 +1 +1003.41 +524.306 +1 +1003.51 +508.334 +1 +1003.61 +516.65 +1 +1003.71 +520.695 +1 +1003.81 +527.955 +1 +1003.91 +529.331 +1 +1004.01 +533.794 +1 +1004.11 +532.939 +1 +1004.21 +517.49 +1 +1004.31 +527.727 +1 +1004.41 +538.381 +1 +1004.51 +533.308 +1 +1004.61 +521.561 +1 +1004.71 +544.611 +1 +1004.81 +527.324 +1 +1004.91 +532.448 +1 +1005.01 +570.213 +1 +1005.11 +563.09 +1 +1005.21 +541.792 +1 +1005.31 +542.99 +1 +1005.41 +559.25 +1 +1005.51 +545.665 +1 +1005.61 +543.146 +1 +1005.71 +526.3 +1 +1005.81 +537.531 +1 +1005.91 +572.365 +1 +1006.01 +555.441 +1 +1006.11 +549.727 +1 +1006.21 +551.249 +1 +1006.31 +548.66 +1 +1006.41 +551.261 +1 +1006.51 +563.665 +1 +1006.61 +576.201 +1 +1006.71 +577.334 +1 +1006.81 +567.664 +1 +1006.91 +553.853 +1 +1007.01 +558.785 +1 +1007.11 +584.367 +1 +1007.21 +581.728 +1 +1007.31 +565.461 +1 +1007.41 +575.372 +1 +1007.51 +562.378 +1 +1007.61 +563.918 +1 +1007.71 +558.304 +1 +1007.81 +554.263 +1 +1007.91 +548.855 +1 +1008.01 +560.082 +1 +1008.11 +587.028 +1 +1008.21 +594.404 +1 +1008.31 +582.535 +1 +1008.41 +572.581 +1 +1008.51 +570.811 +1 +1008.61 +557.279 +1 +1008.71 +573.391 +1 +1008.81 +568.03 +1 +1008.91 +560.161 +1 +1009.01 +607.207 +1 +1009.11 +597.167 +1 +1009.21 +578.718 +1 +1009.31 +585.585 +1 +1009.41 +598.421 +1 +1009.51 +580.41 +1 +1009.61 +576.951 +1 +1009.71 +584.575 +1 +1009.81 +563.585 +1 +1009.91 +563.558 +1 +1010.01 +597.413 +1 +1010.11 +592.348 +1 +1010.21 +598.689 +1 +1010.31 +591.048 +1 +1010.41 +575.647 +1 +1010.51 +562.049 +1 +1010.61 +584.689 +1 +1010.71 +613.504 +1 +1010.81 +604.43 +1 +1010.91 +590.102 +1 +1011.01 +598.673 +1 +1011.11 +597.336 +1 +1011.21 +592.662 +1 +1011.31 +580.7 +1 +1011.41 +584.009 +1 +1011.51 +612.752 +1 +1011.61 +604.978 +1 +1011.71 +591.136 +1 +1011.81 +582.187 +1 +1011.91 +581.801 +1 +1012.01 +583.193 +1 +1012.11 +607.547 +1 +1012.21 +625.368 +1 +1012.31 +616.005 +1 +1012.41 +610.544 +1 +1012.51 +606.481 +1 +1012.61 +612.489 +1 +1012.71 +611.253 +1 +1012.81 +586.851 +1 +1012.91 +623.68 +1 +1013.01 +621.663 +1 +1013.11 +618.895 +1 +1013.21 +600.995 +1 +1013.31 +597.049 +1 +1013.41 +591.93 +1 +1013.51 +595.137 +1 +1013.61 +603.223 +1 +1013.71 +596.239 +1 +1013.81 +587.085 +1 +1013.91 +584.361 +1 +1014.01 +619.158 +1 +1014.11 +618.527 +1 +1014.21 +619.188 +1 +1014.31 +606.433 +1 +1014.41 +602.386 +1 +1014.51 +600.324 +1 +1014.61 +589.299 +1 +1014.71 +577.321 +1 +1014.81 +579.679 +1 +1014.91 +594.519 +1 +1015.01 +606.455 +1 +1015.11 +603.592 +1 +1015.21 +592.769 +1 +1015.31 +592.667 +1 +1015.41 +597.347 +1 +1015.51 +598.124 +1 +1015.61 +613.572 +1 +1015.61 +613.572 +1 +1015.66 +606.643 +1 +1015.71 +596.493 +1 +1015.71 +596.493 +1 +1015.76 +589.147 +1 +1015.81 +588.693 +1 +1015.81 +588.693 +1 +1015.86 +579.432 +1 +1015.91 +581.863 +1 +1015.91 +581.863 +1 +1015.96 +590.761 +1 +1016.01 +606.759 +1 +1016.01 +606.759 +1 +1016.06 +609.806 +1 +1016.11 +596.144 +1 +1016.11 +596.144 +1 +1016.16 +592.706 +1 +1016.21 +598.696 +1 +1016.21 +598.696 +1 +1016.26 +611.189 +1 +1016.31 +606.286 +1 +1016.31 +606.286 +1 +1016.36 +599.476 +1 +1016.41 +595.682 +1 +1016.41 +595.682 +1 +1016.46 +596.852 +1 +1016.51 +597.099 +1 +1016.51 +597.099 +1 +1016.56 +598.501 +1 +1016.61 +605.691 +1 +1016.61 +605.691 +1 +1016.66 +610.47 +1 +1016.71 +593.859 +1 +1016.76 +587.774 +1 +1016.81 +596.403 +1 +1016.86 +606.607 +1 +1016.91 +594.915 +1 +1016.96 +590.241 +1 +1017.01 +587.636 +1 +1017.06 +593.328 +1 +1017.11 +606.761 +1 +1017.16 +614.115 +1 +1017.21 +607.689 +1 +1017.26 +606.91 +1 +1017.31 +604.424 +1 +1017.36 +602.25 +1 +1017.41 +596.921 +1 +1017.46 +598.695 +1 +1017.51 +596.989 +1 +1017.56 +616.919 +1 +1017.61 +630.31 +1 +1017.66 +622.391 +1 +1017.71 +607.099 +1 +1017.76 +595.336 +1 +1017.81 +587.203 +1 +1017.86 +595.983 +1 +1017.91 +605.75 +1 +1017.96 +615.677 +1 +1018.01 +625.619 +1 +1018.06 +613.386 +1 +1018.11 +605.926 +1 +1018.16 +617.972 +1 +1018.21 +625.144 +1 +1018.26 +622.84 +1 +1018.31 +627.313 +1 +1018.36 +632.35 +1 +1018.41 +632.086 +1 +1018.46 +627.843 +1 +1018.51 +633.444 +1 +1018.56 +634.983 +1 +1018.61 +644.948 +1 +1018.66 +640.885 +1 +1018.71 +636.764 +1 +1018.76 +635.98 +1 +1018.81 +641.379 +1 +1018.86 +635.21 +1 +1018.91 +637.855 +1 +1018.96 +640.268 +1 +1019.01 +636.099 +1 +1019.06 +639.37 +1 +1019.11 +652.623 +1 +1019.16 +650.936 +1 +1019.21 +641.447 +1 +1019.26 +633.369 +1 +1019.31 +632.682 +1 +1019.36 +655.528 +1 +1019.41 +663.565 +1 +1019.46 +641.491 +1 +1019.51 +635.212 +1 +1019.56 +654.307 +1 +1019.61 +660.336 +1 +1019.66 +646.061 +1 +1019.71 +633.939 +1 +1019.76 +636.468 +1 +1019.81 +654.36 +1 +1019.86 +662.07 +1 +1019.91 +664.706 +1 +1019.96 +657.652 +1 +1020.01 +659.696 +1 +1020.06 +670.068 +1 +1020.11 +657.005 +1 +1020.16 +642.071 +1 +1020.21 +639.889 +1 +1020.26 +652.869 +1 +1020.31 +647.107 +1 +1020.36 +646.274 +1 +1020.41 +650.887 +1 +1020.46 +642.982 +1 +1020.51 +650.078 +1 +1020.56 +652.998 +1 +1020.61 +647.973 +1 +1020.66 +644.93 +1 +1020.71 +642.48 +1 +1020.76 +645.896 +1 +1020.81 +641.294 +1 +1020.86 +639.946 +1 +1020.91 +621.76 +1 +1020.96 +612.865 +1 +1021.01 +633.689 +1 +1021.06 +650.912 +1 +1021.11 +641.391 +1 +1021.16 +635.865 +1 +1021.21 +642.629 +1 +1021.26 +630.395 +1 +1021.31 +625.183 +1 +1021.36 +619.537 +1 +1021.41 +597.361 +1 +1021.46 +601.796 +1 +1021.51 +611.948 +1 +1021.56 +614.391 +1 +1021.61 +603.574 +1 +1021.66 +597.574 +1 +1021.71 +611.698 +1 +1021.76 +624.68 +1 +1021.81 +606.544 +1 +1021.86 +602.935 +1 +1021.91 +598.509 +1 +1021.96 +596.883 +1 +1022.01 +611.599 +1 +1022.06 +620.342 +1 +1022.11 +613.523 +1 +1022.16 +604.326 +1 +1022.21 +590.066 +1 +1022.26 +600.494 +1 +1022.31 +606.824 +1 +1022.36 +609.488 +1 +1022.41 +613.648 +1 +1022.46 +625.965 +1 +1022.51 +630.209 +1 +1022.56 +631.693 +1 +1022.61 +631.426 +1 +1022.66 +622.286 +1 +1022.71 +616.234 +1 +1022.76 +624.195 +1 +1022.81 +617.276 +1 +1022.86 +615.601 +1 +1022.91 +612.854 +1 +1022.96 +614.498 +1 +1023.01 +619.12 +1 +1023.06 +616.276 +1 +1023.11 +616.27 +1 +1023.16 +627.49 +1 +1023.21 +630.329 +1 +1023.26 +633.982 +1 +1023.31 +642.111 +1 +1023.36 +653.565 +1 +1023.41 +661.154 +1 +1023.46 +658.673 +1 +1023.51 +649.041 +1 +1023.56 +654.01 +1 +1023.61 +653.472 +1 +1023.66 +659.6 +1 +1023.71 +672.917 +1 +1023.76 +696.757 +1 +1023.81 +699.632 +1 +1023.86 +700.605 +1 +1023.91 +722.662 +1 +1023.96 +721.115 +1 +1024.01 +707.336 +1 +1024.06 +716.577 +1 +1024.11 +724.502 +1 +1024.16 +727.607 +1 +1024.21 +738.511 +1 +1024.26 +744.571 +1 +1024.31 +762.687 +1 +1024.36 +782.149 +1 +1024.41 +786.671 +1 +1024.46 +807.825 +1 +1024.51 +843.475 +1 +1024.56 +852.08 +1 +1024.61 +861.424 +1 +1024.66 +889.127 +1 +1024.71 +917.206 +1 +1024.76 +947.463 +1 +1024.81 +972.005 +1 +1024.86 +998.212 +1 +1024.91 +1028.03 +1 +1024.96 +1074.52 +1 +1025.01 +1085.06 +1 +1025.06 +1104.14 +1 +1025.11 +1127.84 +1 +1025.16 +1146.89 +1 +1025.21 +1180.85 +1 +1025.26 +1204.02 +1 +1025.31 +1205.46 +1 +1025.36 +1228.78 +1 +1025.41 +1242.28 +1 +1025.46 +1263.49 +1 +1025.51 +1289.05 +1 +1025.56 +1297.93 +1 +1025.61 +1306.35 +1 +1025.66 +1306.82 +1 +1025.71 +1311.04 +1 +1025.76 +1297.79 +1 +1025.81 +1283.7 +1 +1025.86 +1305.61 +1 +1025.91 +1318.77 +1 +1025.96 +1311.91 +1 +1026.01 +1291.32 +1 +1026.06 +1278.79 +1 +1026.11 +1281.26 +1 +1026.16 +1258.34 +1 +1026.21 +1239.21 +1 +1026.26 +1226.52 +1 +1026.31 +1203.76 +1 +1026.36 +1180.8 +1 +1026.41 +1158.37 +1 +1026.46 +1107.57 +1 +1026.51 +1078.51 +1 +1026.56 +1053.42 +1 +1026.61 +1020.15 +1 +1026.66 +966.384 +1 +1026.71 +928.974 +1 +1026.76 +914.815 +1 +1026.81 +889.388 +1 +1026.86 +853.786 +1 +1026.91 +824.393 +1 +1026.96 +813.064 +1 +1027.01 +792 +1 +1027.06 +751.093 +1 +1027.11 +714.097 +1 +1027.16 +710.105 +1 +1027.21 +695.528 +1 +1027.26 +684.222 +1 +1027.31 +685.561 +1 +1027.36 +684.72 +1 +1027.41 +668.26 +1 +1027.46 +627.587 +1 +1027.51 +631.47 +1 +1027.56 +658.623 +1 +1027.61 +637.027 +1 +1027.66 +642.104 +1 +1027.71 +640.778 +1 +1027.76 +633.631 +1 +1027.81 +634.57 +1 +1027.86 +628.873 +1 +1027.91 +618.156 +1 +1027.96 +612.279 +1 +1028.01 +599.723 +1 +1028.06 +604.039 +1 +1028.11 +629.057 +1 +1028.16 +642.082 +1 +1028.21 +620.889 +1 +1028.26 +622.357 +1 +1028.31 +629.837 +1 +1028.36 +619.895 +1 +1028.41 +622.267 +1 +1028.46 +622.023 +1 +1028.51 +620.128 +1 +1028.56 +625.951 +1 +1028.61 +631.855 +1 +1028.66 +614.199 +1 +1028.71 +614.635 +1 +1028.76 +617.21 +1 +1028.81 +598.893 +1 +1028.86 +610.767 +1 +1028.91 +628.933 +1 +1028.96 +626.956 +1 +1029.01 +613.245 +1 +1029.06 +614.639 +1 +1029.11 +626.144 +1 +1029.16 +625.542 +1 +1029.21 +628.511 +1 +1029.26 +632.868 +1 +1029.31 +627.299 +1 +1029.36 +619.494 +1 +1029.41 +627.466 +1 +1029.46 +630.058 +1 +1029.51 +638.279 +1 +1029.56 +659.878 +1 +1029.61 +656.9 +1 +1029.66 +646.594 +1 +1029.71 +664.871 +1 +1029.76 +683.659 +1 +1029.81 +682.119 +1 +1029.86 +681.045 +1 +1029.91 +691.803 +1 +1029.96 +706.242 +1 +1030.01 +711.438 +1 +1030.06 +706.374 +1 +1030.11 +722.547 +1 +1030.16 +762.85 +1 +1030.21 +779.71 +1 +1030.26 +796.785 +1 +1030.31 +818.387 +1 +1030.36 +819.516 +1 +1030.41 +841.578 +1 +1030.46 +865.099 +1 +1030.51 +869.894 +1 +1030.56 +900.825 +1 +1030.61 +953.821 +1 +1030.66 +976.082 +1 +1030.71 +1014.67 +1 +1030.76 +1053.07 +1 +1030.81 +1098.15 +1 +1030.86 +1141.38 +1 +1030.91 +1180.55 +1 +1030.96 +1223.69 +1 +1031.01 +1290.65 +1 +1031.06 +1350.41 +1 +1031.11 +1413.9 +1 +1031.16 +1470.94 +1 +1031.21 +1522.83 +1 +1031.26 +1606.21 +1 +1031.31 +1683.65 +1 +1031.36 +1750.5 +1 +1031.41 +1805.37 +1 +1031.46 +1844.15 +1 +1031.51 +1882.09 +1 +1031.56 +1911.79 +1 +1031.61 +1937.36 +1 +1031.66 +1935.1 +1 +1031.71 +1902.05 +1 +1031.76 +1867.2 +1 +1031.81 +1820.49 +1 +1031.86 +1769.3 +1 +1031.91 +1733.01 +1 +1031.96 +1703.26 +1 +1032.01 +1674.2 +1 +1032.06 +1627.17 +1 +1032.11 +1594.21 +1 +1032.16 +1564.9 +1 +1032.21 +1532.43 +1 +1032.26 +1480 +1 +1032.31 +1412.55 +1 +1032.36 +1341.55 +1 +1032.41 +1276.98 +1 +1032.46 +1208.53 +1 +1032.51 +1103.07 +1 +1032.56 +991.97 +1 +1032.61 +898.867 +1 +1032.66 +801.315 +1 +1032.71 +693.039 +1 +1032.76 +607.106 +1 +1032.81 +524.306 +1 +1032.86 +430.964 +1 +1032.91 +360.997 +1 +1032.96 +316.891 +1 +1033.01 +265.384 +1 +1033.06 +218.663 +1 +1033.11 +184.599 +1 +1033.16 +163.276 +1 +1033.21 +146.727 +1 +1033.26 +128.282 +1 +1033.31 +115.72 +1 +1033.36 +102.206 +1 +1033.41 +84.3599 +1 +1033.46 +76.3419 +1 +1033.51 +73.258 +1 +1033.56 +68.9179 +1 +1033.61 +65.1807 +1 +1033.66 +56.2314 +1 +1033.71 +49.6746 +1 +1033.76 +52.1579 +1 +1033.81 +49.7747 +1 +1033.86 +46.0503 +1 +1033.91 +36.4411 +1 +1033.96 +29.5619 +1 +1034.01 +32.4556 +1 +1034.06 +32.9876 +1 +1034.11 +31.6081 +1 +1034.16 +31.8027 +1 +1034.21 +33.807 +1 +1034.26 +35.8312 +1 +1034.31 +29.7257 +1 +1034.36 +24.3449 +1 +1034.41 +21.9194 +1 +1034.46 +25.1065 +1 +1034.51 +30.7035 +1 +1034.56 +28.6187 +1 +1034.61 +21.3205 +1 +1034.66 +24.2862 +1 +1034.71 +23.786 +1 +1034.76 +21.619 +1 +1034.81 +17.8064 +1 +1034.86 +16.3473 +1 +1034.91 +18.0522 +1 +1034.96 +20.8006 +1 +1035.01 +20.7355 +1 +1035.06 +19.2328 +1 +1035.11 +13.6358 +1 +1035.16 +14.2518 +1 +1035.21 +12.7428 +1 +1035.26 +11.468 +1 +1035.31 +9.25257 +1 +1035.36 +11.8099 +1 +1035.41 +17.8825 +1 +1035.46 +22.5386 +1 +1035.51 +21.1059 +1 +1035.56 +18.5313 +1 +1035.61 +16.1824 +1 +1035.66 +14.0897 +1 +1035.71 +17.0204 +1 +1035.76 +14.6167 +1 +1035.81 +9.60597 +1 +1035.86 +9.16277 +1 +1035.91 +11.145 +1 +1035.96 +9.83835 +1 +1036.01 +12.7076 +1 +1036.06 +14.9464 +1 +1036.11 +16.3768 +1 +1036.16 +13.8208 +1 +1036.21 +9.75438 +1 +1036.26 +6.88693 +1 +1036.31 +6.69721 +1 +1036.36 +8.23845 +1 +1036.41 +7.37087 +1 +1036.46 +6.43268 +1 +1036.51 +5.21011 +1 +1036.56 +4.52699 +1 +1036.61 +8.72831 +1 +1036.66 +9.3681 +1 +1036.71 +3.6229 +1 +1036.76 +3.03928 +1 +1036.81 +3.17743 +1 +1036.86 +4.20203 +1 +1036.91 +1.47699 +1 +1036.96 +6.18683 +1 +1037.01 +9.76206 +1 +1037.06 +7.32739 +1 +1037.11 +5.90447 +1 +1037.16 +5.52773 +1 +1037.21 +5.99246 +1 +1037.26 +1.44937 +1 +1037.31 +3.90965 +1 +1037.36 +6.36227 +1 +1037.41 +5.08157 +1 +1037.46 +4.98903 +1 +1037.51 +6.53262 +1 +1037.56 +7.41351 +1 +1037.61 +6.63376 +1 +1037.66 +5.79297 +1 +1037.71 +4.39155 +1 +1037.76 +4.02456 +1 +1037.81 +0.0817091 +1 +1037.86 +-1.30378 +1 +1037.91 +-0.488158 +1 +1037.96 +2.33727 +1 +1038.01 +3.97329 +1 +1038.06 +0.00398757 +1 +1038.11 +1.92559 +1 +1038.16 +7.03095 +1 +1038.21 +5.79007 +1 +1038.26 +2.50004 +1 +1038.31 +2.19749 +1 +1038.36 +0.677344 +1 +1038.41 +-0.0809204 +1 +1038.46 +1.75695 +1 +1038.51 +4.7773 +1 +1038.56 +4.94552 +1 +1038.61 +8.75129 +1 +1038.66 +8.18276 +1 +1038.71 +3.21884 +1 +1038.76 +0.187503 +1 +1038.81 +-1.35327 +1 +1038.86 +2.13401 +1 +1038.91 +-1.81348 +1 +1038.96 +0.645525 +1 +1039.01 +1.8464 +1 +1039.06 +-1.18018 +1 +1039.11 +3.18172 +1 +1039.16 +5.59011 +1 +1039.21 +1.00807 +1 +1039.26 +-1.82137 +1 +1039.31 +0 +1 +1039.36 +0 +1 +1039.41 +0 +1 +1039.46 +0 +1 +1039.51 +0 +1 +1039.56 +0 +1 +1039.61 +0 +1 +1039.66 +0 +1 +1039.71 +0 +1 +1039.76 +0 +1 +1039.81 +0 +1 +1039.86 +0 +1 +1039.91 +0 +1 +1039.96 +0 +1 +1040.01 +0 +1 +1040.06 +0 +1 +1040.11 +0 +1 +1040.16 +0 +1 +1040.21 +0 +1 +1040.26 +0 +1 +1040.31 +0 +1 +1040.36 +0 +1 +1040.41 +0 +1 +1040.46 +0 +1 +1040.51 +0 +1 +1040.56 +0 +1 +1040.61 +0 +1 +Ti2p +Ti2O3 +0 +0 +0 +0 +0 +0 +0 +15 +Casa Info Follows +0 +0 +1 +CASA region (*Ti 2p*) (*Min Limits*) 987.96 1039.26 7.7123335 2 0 0 0 -1643 0 0 (*Ti 2p*) 47.8784 0 7.81 +1 +CASA comp (*Ti2O3*) (*&TI2O3*) Area 0.99917178 1e-020 472189.94 -1 1 MFWHM 1 1 1 -1 1 Position 1012.9114 1012.6114 1013.2114 -1 1 RSF 7.71233 MASS 47.8784 INDEX 2 (*Ti2O3*) CONST (**) UNCORRECTEDRSF 7.81 + +PCA Coefs = 179186, -26548.4, -22890.8, 3691.07, -1602.46, -1706.5, +C:\Users\Mark\ownCloud\Muelheim Group\Projects\TiO2\analyzed data\EX209_CEC303 Ti slow oxidation - curated - irregular.vms +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +CasaXP2 +C:\Users\pielsticker\Downloads\Ti\references_irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p fit +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.61 +0 +1 +986.71 +0 +1 +986.81 +0 +1 +986.91 +0 +1 +987.01 +0 +1 +987.11 +2534.66 +1 +987.21 +2537.49 +1 +987.31 +2540.32 +1 +987.41 +2543.17 +1 +987.51 +2546.02 +1 +987.61 +2548.86 +1 +987.71 +2551.71 +1 +987.81 +2554.57 +1 +987.91 +2557.43 +1 +988.01 +2560.29 +1 +988.11 +2563.15 +1 +988.21 +2566.02 +1 +988.31 +2568.89 +1 +988.41 +2571.77 +1 +988.51 +2574.65 +1 +988.61 +2577.53 +1 +988.71 +2580.42 +1 +988.81 +2583.31 +1 +988.91 +2586.21 +1 +989.01 +2589.1 +1 +989.11 +2592.01 +1 +989.21 +2594.92 +1 +989.31 +2597.83 +1 +989.41 +2600.73 +1 +989.51 +2603.65 +1 +989.61 +2606.58 +1 +989.71 +2609.5 +1 +989.81 +2612.43 +1 +989.91 +2615.4 +1 +990.01 +2618.6 +1 +990.11 +2621.8 +1 +990.21 +2625 +1 +990.31 +2628.21 +1 +990.41 +2631.42 +1 +990.51 +2634.65 +1 +990.61 +2637.87 +1 +990.71 +2641.09 +1 +990.81 +2644.32 +1 +990.91 +2647.56 +1 +991.01 +2650.81 +1 +991.11 +2654.05 +1 +991.21 +2657.29 +1 +991.31 +2660.55 +1 +991.41 +2663.82 +1 +991.51 +2667.08 +1 +991.61 +2670.34 +1 +991.71 +2673.62 +1 +991.81 +2676.9 +1 +991.91 +2680.19 +1 +992.01 +2683.47 +1 +992.11 +2686.76 +1 +992.21 +2690.07 +1 +992.31 +2693.38 +1 +992.41 +2696.69 +1 +992.51 +2699.99 +1 +992.61 +2703.32 +1 +992.71 +2706.66 +1 +992.81 +2709.99 +1 +992.91 +2713.33 +1 +993.01 +2716.67 +1 +993.11 +2720.03 +1 +993.21 +2723.39 +1 +993.31 +2726.96 +1 +993.41 +2730.67 +1 +993.51 +2734.4 +1 +993.61 +2738.13 +1 +993.71 +2741.86 +1 +993.81 +2745.59 +1 +993.91 +2749.35 +1 +994.01 +2753.1 +1 +994.11 +2756.86 +1 +994.21 +2760.62 +1 +994.31 +2764.39 +1 +994.41 +2768.17 +1 +994.51 +2771.96 +1 +994.61 +2775.74 +1 +994.71 +2779.53 +1 +994.81 +2783.35 +1 +994.91 +2787.17 +1 +995.01 +2790.99 +1 +995.11 +2794.8 +1 +995.21 +2798.64 +1 +995.31 +2802.49 +1 +995.41 +2806.34 +1 +995.51 +2810.19 +1 +995.61 +2814.04 +1 +995.71 +2817.92 +1 +995.81 +2821.8 +1 +995.91 +2825.68 +1 +996.01 +2829.55 +1 +996.11 +2833.46 +1 +996.21 +2837.37 +1 +996.31 +2841.28 +1 +996.41 +2845.19 +1 +996.51 +2849.12 +1 +996.61 +2853.09 +1 +996.71 +2857.46 +1 +996.81 +2861.84 +1 +996.91 +2866.23 +1 +997.01 +2870.65 +1 +997.11 +2875.06 +1 +997.21 +2879.48 +1 +997.31 +2883.9 +1 +997.41 +2888.34 +1 +997.51 +2892.79 +1 +997.61 +2897.24 +1 +997.71 +2901.69 +1 +997.81 +2906.16 +1 +997.91 +2910.65 +1 +998.01 +2915.13 +1 +998.11 +2919.62 +1 +998.21 +2924.11 +1 +998.31 +2926.65 +1 +998.41 +2931.18 +1 +998.51 +2935.73 +1 +998.61 +2940.28 +1 +998.71 +2944.89 +1 +998.81 +2949.51 +1 +998.91 +2954.15 +1 +999.01 +2958.8 +1 +999.11 +2963.5 +1 +999.21 +2968.22 +1 +999.31 +2972.97 +1 +999.41 +2977.73 +1 +999.51 +2982.5 +1 +999.61 +2987.33 +1 +999.71 +2992.17 +1 +999.81 +2997.02 +1 +999.91 +3001.89 +1 +1000.01 +3006.8 +1 +1000.11 +3011.74 +1 +1000.21 +3016.69 +1 +1000.31 +3021.66 +1 +1000.41 +3026.65 +1 +1000.51 +3031.69 +1 +1000.61 +3036.74 +1 +1000.71 +3041.8 +1 +1000.81 +3046.88 +1 +1000.91 +3052.02 +1 +1001.01 +3057.17 +1 +1001.11 +3062.33 +1 +1001.21 +3067.52 +1 +1001.31 +3072.75 +1 +1001.41 +3078.01 +1 +1001.51 +3083.29 +1 +1001.61 +3088.58 +1 +1001.71 +3093.9 +1 +1001.81 +3099.26 +1 +1001.91 +3104.64 +1 +1002.01 +3110.03 +1 +1002.11 +3115.44 +1 +1002.21 +3120.89 +1 +1002.31 +3126.36 +1 +1002.41 +3131.85 +1 +1002.51 +3137.36 +1 +1002.61 +3142.9 +1 +1002.71 +3148.46 +1 +1002.81 +3154.05 +1 +1002.91 +3159.64 +1 +1003.01 +3165.27 +1 +1003.11 +3170.93 +1 +1003.21 +3176.6 +1 +1003.31 +3182.29 +1 +1003.41 +3188.03 +1 +1003.51 +3193.8 +1 +1003.61 +3199.59 +1 +1003.71 +3205.4 +1 +1003.81 +3211.23 +1 +1003.91 +3217.08 +1 +1004.01 +3222.96 +1 +1004.11 +3228.85 +1 +1004.21 +3234.76 +1 +1004.31 +3240.69 +1 +1004.41 +3246.65 +1 +1004.51 +3252.63 +1 +1004.61 +3258.62 +1 +1004.71 +3264.63 +1 +1004.81 +3270.66 +1 +1004.91 +3276.72 +1 +1005.01 +3282.79 +1 +1005.11 +3288.87 +1 +1005.21 +3294.97 +1 +1005.31 +3301.09 +1 +1005.41 +3307.23 +1 +1005.51 +3313.4 +1 +1005.61 +3319.62 +1 +1005.71 +3325.85 +1 +1005.81 +3332.09 +1 +1005.91 +3338.35 +1 +1006.01 +3344.63 +1 +1006.11 +3350.92 +1 +1006.21 +3357.21 +1 +1006.31 +3363.53 +1 +1006.41 +3369.85 +1 +1006.51 +3376.19 +1 +1006.61 +3382.36 +1 +1006.71 +3388.72 +1 +1006.81 +3395.09 +1 +1006.91 +3401.48 +1 +1007.01 +3407.85 +1 +1007.11 +3414.25 +1 +1007.21 +3420.66 +1 +1007.31 +3427.09 +1 +1007.41 +3433.51 +1 +1007.51 +3439.92 +1 +1007.61 +3446.36 +1 +1007.71 +3452.82 +1 +1007.81 +3459.27 +1 +1007.91 +3465.69 +1 +1008.01 +3472.13 +1 +1008.11 +3478.59 +1 +1008.21 +3485.07 +1 +1008.31 +3491.48 +1 +1008.41 +3497.9 +1 +1008.51 +3504.34 +1 +1008.61 +3510.8 +1 +1008.71 +3517.21 +1 +1008.81 +3523.58 +1 +1008.91 +3529.97 +1 +1009.01 +3536.38 +1 +1009.11 +3542.78 +1 +1009.21 +3549.05 +1 +1009.31 +3555.35 +1 +1009.41 +3561.67 +1 +1009.51 +3568.02 +1 +1009.61 +3574.18 +1 +1009.71 +3580.33 +1 +1009.81 +3586.51 +1 +1009.91 +3592.71 +1 +1010.01 +3598.78 +1 +1010.11 +3604.71 +1 +1010.21 +3610.67 +1 +1010.31 +3616.66 +1 +1010.41 +3622.61 +1 +1010.51 +3628.23 +1 +1010.61 +3633.89 +1 +1010.71 +3639.57 +1 +1010.81 +3645.28 +1 +1010.91 +3650.59 +1 +1011.01 +3655.82 +1 +1011.11 +3661.07 +1 +1011.21 +3666.36 +1 +1011.31 +3671.39 +1 +1011.41 +3676.05 +1 +1011.51 +3680.74 +1 +1011.61 +3685.47 +1 +1011.71 +3690.17 +1 +1011.81 +3694.09 +1 +1011.91 +3698.04 +1 +1012.01 +3702.04 +1 +1012.11 +3706.07 +1 +1012.21 +3709.35 +1 +1012.31 +3712.37 +1 +1012.41 +3715.43 +1 +1012.51 +3718.54 +1 +1012.61 +3721.21 +1 +1012.71 +3723.06 +1 +1012.81 +3724.96 +1 +1012.91 +3726.92 +1 +1013.01 +3728.93 +1 +1013.11 +3729.37 +1 +1013.21 +3729.87 +1 +1013.31 +3730.44 +1 +1013.41 +3731.07 +1 +1013.51 +3730.56 +1 +1013.61 +3729.43 +1 +1013.71 +3728.37 +1 +1013.81 +3727.39 +1 +1013.91 +3725.88 +1 +1014.01 +3722.88 +1 +1014.11 +3719.97 +1 +1014.21 +3717.16 +1 +1014.31 +3714.45 +1 +1014.41 +3709.61 +1 +1014.51 +3704.68 +1 +1014.61 +3699.88 +1 +1014.71 +3695.2 +1 +1014.81 +3689.16 +1 +1014.91 +3682.1 +1 +1015.01 +3675.2 +1 +1015.11 +3668.45 +1 +1015.21 +3661.3 +1 +1015.31 +3652.12 +1 +1015.41 +3643.14 +1 +1015.51 +3634.37 +1 +1015.61 +3625.84 +1 +1015.61 +3625.84 +1 +1015.66 +3620.66 +1 +1015.71 +3615.11 +1 +1015.71 +3615.11 +1 +1015.76 +3609.62 +1 +1015.81 +3604.19 +1 +1015.81 +3604.19 +1 +1015.86 +3598.85 +1 +1015.91 +3593.58 +1 +1015.91 +3593.58 +1 +1015.96 +3588.38 +1 +1016.01 +3583.28 +1 +1016.01 +3583.28 +1 +1016.06 +3578.25 +1 +1016.11 +3571.92 +1 +1016.11 +3571.92 +1 +1016.16 +3565.64 +1 +1016.21 +3559.45 +1 +1016.21 +3559.45 +1 +1016.26 +3553.38 +1 +1016.31 +3547.41 +1 +1016.31 +3547.41 +1 +1016.36 +3541.56 +1 +1016.41 +3535.81 +1 +1016.41 +3535.81 +1 +1016.46 +3530.19 +1 +1016.51 +3524.34 +1 +1016.51 +3524.34 +1 +1016.56 +3517.6 +1 +1016.61 +3511.01 +1 +1016.61 +3511.01 +1 +1016.66 +3504.55 +1 +1016.71 +3498.24 +1 +1016.76 +3492.09 +1 +1016.81 +3486.1 +1 +1016.86 +3480.28 +1 +1016.91 +3474.63 +1 +1016.96 +3468.5 +1 +1017.01 +3461.97 +1 +1017.06 +3455.65 +1 +1017.11 +3449.55 +1 +1017.16 +3443.66 +1 +1017.21 +3438.03 +1 +1017.26 +3432.65 +1 +1017.31 +3427.55 +1 +1017.36 +3422.73 +1 +1017.41 +3417.27 +1 +1017.46 +3411.93 +1 +1017.51 +3406.89 +1 +1017.56 +3402.17 +1 +1017.61 +3397.8 +1 +1017.66 +3393.78 +1 +1017.71 +3390.14 +1 +1017.76 +3386.89 +1 +1017.81 +3383.95 +1 +1017.86 +3380.66 +1 +1017.91 +3377.82 +1 +1017.96 +3375.46 +1 +1018.01 +3373.58 +1 +1018.06 +3372.22 +1 +1018.11 +3371.39 +1 +1018.16 +3371.11 +1 +1018.21 +3371.43 +1 +1018.26 +3372.1 +1 +1018.31 +3373 +1 +1018.36 +3374.57 +1 +1018.41 +3376.8 +1 +1018.46 +3379.75 +1 +1018.51 +3383.45 +1 +1018.56 +3387.95 +1 +1018.61 +3393.25 +1 +1018.66 +3399.36 +1 +1018.71 +3406.04 +1 +1018.76 +3413.45 +1 +1018.81 +3421.76 +1 +1018.86 +3431.01 +1 +1018.91 +3441.2 +1 +1018.96 +3452.41 +1 +1019.01 +3464.61 +1 +1019.06 +3477.86 +1 +1019.11 +3492.19 +1 +1019.16 +3507.44 +1 +1019.21 +3523.9 +1 +1019.26 +3541.56 +1 +1019.31 +3560.42 +1 +1019.36 +3580.48 +1 +1019.41 +3601.75 +1 +1019.46 +3624.26 +1 +1019.51 +3648.01 +1 +1019.56 +3673.04 +1 +1019.61 +3699.4 +1 +1019.66 +3727.03 +1 +1019.71 +3755.98 +1 +1019.76 +3786.21 +1 +1019.81 +3817.74 +1 +1019.86 +3850.68 +1 +1019.91 +3884.92 +1 +1019.96 +3920.46 +1 +1020.01 +3957.41 +1 +1020.06 +3995.78 +1 +1020.11 +4035.38 +1 +1020.16 +4076.21 +1 +1020.21 +4118.22 +1 +1020.26 +4161.53 +1 +1020.31 +4206.02 +1 +1020.36 +4251.59 +1 +1020.41 +4298.2 +1 +1020.46 +4346.19 +1 +1020.51 +4395.27 +1 +1020.56 +4445.24 +1 +1020.61 +4496.01 +1 +1020.66 +4547.51 +1 +1020.71 +4599.65 +1 +1020.76 +4651.63 +1 +1020.81 +4704.83 +1 +1020.86 +4758.52 +1 +1020.91 +4813.16 +1 +1020.96 +4868.01 +1 +1021.01 +4923.03 +1 +1021.06 +4978.03 +1 +1021.11 +5032.97 +1 +1021.16 +5087.71 +1 +1021.21 +5142.11 +1 +1021.26 +5196.1 +1 +1021.31 +5249.77 +1 +1021.36 +5303.31 +1 +1021.41 +5356.04 +1 +1021.46 +5407.82 +1 +1021.51 +5458.61 +1 +1021.56 +5508.13 +1 +1021.61 +5556.41 +1 +1021.66 +5603.24 +1 +1021.71 +5648.51 +1 +1021.76 +5692.75 +1 +1021.81 +5735.41 +1 +1021.86 +5776.08 +1 +1021.91 +5814.66 +1 +1021.96 +5851.07 +1 +1022.01 +5885.27 +1 +1022.06 +5916.99 +1 +1022.11 +5946.31 +1 +1022.16 +5973 +1 +1022.21 +5997.95 +1 +1022.26 +6020.28 +1 +1022.31 +6039.67 +1 +1022.36 +6056.29 +1 +1022.41 +6069.86 +1 +1022.46 +6080.45 +1 +1022.51 +6087.81 +1 +1022.56 +6091.92 +1 +1022.61 +6093.25 +1 +1022.66 +6092.13 +1 +1022.71 +6087.92 +1 +1022.76 +6080.6 +1 +1022.81 +6070.03 +1 +1022.86 +6056.48 +1 +1022.91 +6039.72 +1 +1022.96 +6019.98 +1 +1023.01 +5997.27 +1 +1023.06 +5972.05 +1 +1023.11 +5944.62 +1 +1023.16 +5914.08 +1 +1023.21 +5880.87 +1 +1023.26 +5845.08 +1 +1023.31 +5806.76 +1 +1023.36 +5766.23 +1 +1023.41 +5723.32 +1 +1023.46 +5678.44 +1 +1023.51 +5632.41 +1 +1023.56 +5584.79 +1 +1023.61 +5535.69 +1 +1023.66 +5484.99 +1 +1023.71 +5433.15 +1 +1023.76 +5380.23 +1 +1023.81 +5326.34 +1 +1023.86 +5271.83 +1 +1023.91 +5216.77 +1 +1023.96 +5162.51 +1 +1024.01 +5108.2 +1 +1024.06 +5054.09 +1 +1024.11 +5000.49 +1 +1024.16 +4947.42 +1 +1024.21 +4895.34 +1 +1024.26 +4844.33 +1 +1024.31 +4794.67 +1 +1024.36 +4746.97 +1 +1024.41 +4701.6 +1 +1024.46 +4658.34 +1 +1024.51 +4617.33 +1 +1024.56 +4578.85 +1 +1024.61 +4543.15 +1 +1024.66 +4510.37 +1 +1024.71 +4480.83 +1 +1024.76 +4454.66 +1 +1024.81 +4432.65 +1 +1024.86 +4414.77 +1 +1024.91 +4400.88 +1 +1024.96 +4391.18 +1 +1025.01 +4385.83 +1 +1025.06 +4385.02 +1 +1025.11 +4388.87 +1 +1025.16 +4397.65 +1 +1025.21 +4411.38 +1 +1025.26 +4430.93 +1 +1025.31 +4455.73 +1 +1025.36 +4485.79 +1 +1025.41 +4521.23 +1 +1025.46 +4562.05 +1 +1025.51 +4608.35 +1 +1025.56 +4660.11 +1 +1025.61 +4717.33 +1 +1025.66 +4780.21 +1 +1025.71 +4849.05 +1 +1025.76 +4923.35 +1 +1025.81 +5003.01 +1 +1025.86 +5087.93 +1 +1025.91 +5178.01 +1 +1025.96 +5273 +1 +1026.01 +5372.92 +1 +1026.06 +5477.43 +1 +1026.11 +5586.72 +1 +1026.16 +5700.64 +1 +1026.21 +5818.49 +1 +1026.26 +5940.2 +1 +1026.31 +6065.31 +1 +1026.36 +6193.61 +1 +1026.41 +6324.81 +1 +1026.46 +6458.48 +1 +1026.51 +6594.51 +1 +1026.56 +6732.71 +1 +1026.61 +6872.49 +1 +1026.66 +7013.32 +1 +1026.71 +7154.68 +1 +1026.76 +7296.37 +1 +1026.81 +7437.73 +1 +1026.86 +7578.44 +1 +1026.91 +7718.05 +1 +1026.96 +7856.03 +1 +1027.01 +7992.59 +1 +1027.06 +8126.58 +1 +1027.11 +8257.69 +1 +1027.16 +8385.44 +1 +1027.21 +8509.3 +1 +1027.26 +8628.95 +1 +1027.31 +8743.8 +1 +1027.36 +8853.55 +1 +1027.41 +8957.88 +1 +1027.46 +9056.52 +1 +1027.51 +9148.9 +1 +1027.56 +9234.5 +1 +1027.61 +9313.1 +1 +1027.66 +9384.3 +1 +1027.71 +9447.8 +1 +1027.76 +9503.41 +1 +1027.81 +9550.78 +1 +1027.86 +9590.02 +1 +1027.91 +9620.76 +1 +1027.96 +9642.69 +1 +1028.01 +9655.72 +1 +1028.06 +9659.65 +1 +1028.11 +9654.5 +1 +1028.16 +9640.16 +1 +1028.21 +9616.61 +1 +1028.26 +9583.92 +1 +1028.31 +9542.38 +1 +1028.36 +9491.87 +1 +1028.41 +9432.38 +1 +1028.46 +9364.1 +1 +1028.51 +9287.19 +1 +1028.56 +9201.79 +1 +1028.61 +9108.21 +1 +1028.66 +9006.6 +1 +1028.71 +8897.33 +1 +1028.76 +8780.91 +1 +1028.81 +8657.33 +1 +1028.86 +8527.02 +1 +1028.91 +8390.24 +1 +1028.96 +8247.41 +1 +1029.01 +8098.89 +1 +1029.06 +7945.05 +1 +1029.11 +7786.37 +1 +1029.16 +7623.31 +1 +1029.21 +7456.33 +1 +1029.26 +7285.73 +1 +1029.31 +7111.88 +1 +1029.36 +6935.27 +1 +1029.41 +6756.28 +1 +1029.46 +6575.34 +1 +1029.51 +6392.88 +1 +1029.56 +6209.28 +1 +1029.61 +6025.16 +1 +1029.66 +5840.77 +1 +1029.71 +5656.43 +1 +1029.76 +5472.53 +1 +1029.81 +5289.4 +1 +1029.86 +5107.42 +1 +1029.91 +4926.87 +1 +1029.96 +4748.1 +1 +1030.01 +4571.38 +1 +1030.06 +4397.2 +1 +1030.11 +4225.62 +1 +1030.16 +4056.86 +1 +1030.21 +3891.17 +1 +1030.26 +3728.74 +1 +1030.31 +3569.74 +1 +1030.36 +3414.36 +1 +1030.41 +3262.73 +1 +1030.46 +3115.04 +1 +1030.51 +2971.48 +1 +1030.56 +2832 +1 +1030.61 +2696.69 +1 +1030.66 +2565.6 +1 +1030.71 +2438.78 +1 +1030.76 +2316.25 +1 +1030.81 +2198.03 +1 +1030.86 +2084.12 +1 +1030.91 +1974.59 +1 +1030.96 +1869.4 +1 +1031.01 +1768.44 +1 +1031.06 +1671.65 +1 +1031.11 +1579 +1 +1031.16 +1490.4 +1 +1031.21 +1405.79 +1 +1031.26 +1325.07 +1 +1031.31 +1248.16 +1 +1031.36 +1175.09 +1 +1031.41 +1105.65 +1 +1031.46 +1039.72 +1 +1031.51 +977.194 +1 +1031.56 +917.957 +1 +1031.61 +861.898 +1 +1031.66 +808.897 +1 +1031.71 +758.848 +1 +1031.76 +711.643 +1 +1031.81 +667.253 +1 +1031.86 +625.461 +1 +1031.91 +586.149 +1 +1031.96 +549.212 +1 +1032.01 +514.529 +1 +1032.06 +481.996 +1 +1032.11 +451.504 +1 +1032.16 +422.945 +1 +1032.21 +396.268 +1 +1032.26 +371.378 +1 +1032.31 +348.128 +1 +1032.36 +326.423 +1 +1032.41 +306.171 +1 +1032.46 +287.293 +1 +1032.51 +269.698 +1 +1032.56 +253.312 +1 +1032.61 +238.056 +1 +1032.66 +223.92 +1 +1032.71 +210.8 +1 +1032.76 +198.602 +1 +1032.81 +187.268 +1 +1032.86 +176.736 +1 +1032.91 +166.95 +1 +1032.96 +157.86 +1 +1033.01 +149.413 +1 +1033.06 +141.566 +1 +1033.11 +134.348 +1 +1033.16 +127.642 +1 +1033.21 +121.412 +1 +1033.26 +115.618 +1 +1033.31 +110.231 +1 +1033.36 +105.216 +1 +1033.41 +100.545 +1 +1033.46 +96.1914 +1 +1033.51 +92.1457 +1 +1033.56 +88.4162 +1 +1033.61 +84.9317 +1 +1033.66 +81.6728 +1 +1033.71 +78.6216 +1 +1033.76 +75.7591 +1 +1033.81 +73.0719 +1 +1033.86 +70.5426 +1 +1033.91 +68.1585 +1 +1033.96 +65.9395 +1 +1034.01 +63.8651 +1 +1034.06 +61.9027 +1 +1034.11 +60.0402 +1 +1034.16 +58.2698 +1 +1034.21 +56.5842 +1 +1034.26 +54.975 +1 +1034.31 +53.4391 +1 +1034.36 +51.969 +1 +1034.41 +50.6038 +1 +1034.46 +49.3059 +1 +1034.51 +48.0632 +1 +1034.56 +46.8749 +1 +1034.61 +45.7351 +1 +1034.66 +44.6413 +1 +1034.71 +43.5894 +1 +1034.76 +42.5744 +1 +1034.81 +41.6001 +1 +1034.86 +40.6927 +1 +1034.91 +39.8132 +1 +1034.96 +38.9585 +1 +1035.01 +38.1257 +1 +1035.06 +37.3142 +1 +1035.11 +36.5206 +1 +1035.16 +35.7446 +1 +1035.21 +34.9841 +1 +1035.26 +34.2531 +1 +1035.31 +33.5583 +1 +1035.36 +32.8755 +1 +1035.41 +32.2049 +1 +1035.46 +31.5453 +1 +1035.51 +30.8959 +1 +1035.56 +30.2571 +1 +1035.61 +29.627 +1 +1035.66 +29.2777 +1 +1035.71 +28.6764 +1 +1035.76 +28.0885 +1 +1035.81 +27.5043 +1 +1035.86 +26.9227 +1 +1035.91 +26.3449 +1 +1035.96 +25.7699 +1 +1036.01 +25.1978 +1 +1036.06 +24.6291 +1 +1036.11 +24.0629 +1 +1036.16 +23.564 +1 +1036.21 +23.098 +1 +1036.26 +22.6347 +1 +1036.31 +22.1745 +1 +1036.36 +21.7165 +1 +1036.41 +21.2618 +1 +1036.46 +20.8093 +1 +1036.51 +20.3594 +1 +1036.56 +19.9186 +1 +1036.61 +19.4983 +1 +1036.66 +19.0809 +1 +1036.71 +18.6655 +1 +1036.76 +18.2524 +1 +1036.81 +17.8418 +1 +1036.86 +17.4331 +1 +1036.91 +17.0271 +1 +1036.96 +16.6229 +1 +1037.01 +16.2326 +1 +1037.06 +15.8546 +1 +1037.11 +15.4784 +1 +1037.16 +15.1207 +1 +1037.21 +14.7727 +1 +1037.26 +14.4268 +1 +1037.31 +14.0829 +1 +1037.36 +13.7406 +1 +1037.41 +13.4005 +1 +1037.46 +13.0777 +1 +1037.51 +12.7601 +1 +1037.56 +12.4444 +1 +1037.61 +12.1301 +1 +1037.66 +11.8179 +1 +1037.71 +11.5072 +1 +1037.76 +11.1983 +1 +1037.81 +10.891 +1 +1037.86 +10.5869 +1 +1037.91 +10.2996 +1 +1037.96 +10.0137 +1 +1038.01 +9.72941 +1 +1038.06 +9.44658 +1 +1038.11 +9.16511 +1 +1038.16 +8.894 +1 +1038.21 +8.62657 +1 +1038.26 +8.36072 +1 +1038.31 +8.10193 +1 +1038.36 +7.85343 +1 +1038.41 +7.60653 +1 +1038.46 +7.36073 +1 +1038.51 +7.11642 +1 +1038.56 +6.8733 +1 +1038.61 +6.63138 +1 +1038.66 +6.39085 +1 +1038.71 +6.15134 +1 +1038.76 +5.92198 +1 +1038.81 +5.69796 +1 +1038.86 +5.47508 +1 +1038.91 +5.25347 +1 +1038.96 +5.0328 +1 +1039.01 +4.98139 +1 +1039.06 +4.76187 +1 +1039.11 +4.54273 +1 +1039.16 +4.32925 +1 +1039.21 +4.12757 +1 +1039.26 +3.92698 +1 +1039.31 +0 +1 +1039.36 +0 +1 +1039.41 +0 +1 +1039.46 +0 +1 +1039.51 +0 +1 +1039.56 +0 +1 +1039.61 +0 +1 +1039.66 +0 +1 +1039.71 +0 +1 +1039.76 +0 +1 +1039.81 +0 +1 +1039.86 +0 +1 +1039.91 +0 +1 +1039.96 +0 +1 +1040.01 +0 +1 +1040.06 +0 +1 +1040.11 +0 +1 +1040.16 +0 +1 +1040.21 +0 +1 +1040.26 +0 +1 +1040.31 +0 +1 +1040.36 +0 +1 +1040.41 +0 +1 +1040.46 +0 +1 +1040.51 +0 +1 +1040.56 +0 +1 +1040.61 +0 +1 +Ti2p +TiO2 +0 +0 +0 +0 +0 +0 +0 +15 +Casa Info Follows +0 +0 +1 +CASA region (*Ti 2p*) (*Min Limits*) 987.96 1039.26 7.7123335 2 0 0 0 -1643 0 0 (*Ti 2p*) 47.8784 0 7.81 +1 +CASA comp (*TiO2*) (*&TIO2*) Area 1.0006404 1e-020 472189.94 -1 1 MFWHM 1 1 1 -1 1 Position 1012.0574 1011.7574 1012.3574 -1 1 RSF 7.71233 MASS 47.8784 INDEX 3 (*TiO2*) CONST (**) UNCORRECTEDRSF 7.81 + +PCA Coefs = 41279.5, -30.0911, +CasaXP11_irregular-March172021151537 +c:\users\mark\owncloud\muelheim group\projects\tio2\analyzed data\experiment 2019-03-28_ti sheet_cec-1303 - vector analysis.vms +C:\Users\pielsticker\Downloads\Ti\EX209_CEC303 Ti slow oxidation - vectro fit - irregular.vms +CasaXP2 +C:\Users\pielsticker\Downloads\Ti\references_irregular.vms +C:\Users\pielsticker\Lukas\MPI-CEC\Projects\deepxps\xpsdeeplearning\data\references\Ti_references_irregular.vms +XPS +1e+037 +Al +1486.61 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +FAT +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +1e+037 +Ti +2p fit +-1 +3 +Kinetic Energy +eV +Intensity +d +transmission +d +pulse counting +1 +1 +1e+037 +1e+037 +1e+037 +1e+037 +3 +MFP Exponent +d +0 +ESCAPE DEPTH TYPE +d +1 +PROPAGATION_CONVERGED +d +1 +2406 +0 +1 +0 +1 +0 +1 +986.41 +0 +1 +986.51 +0 +1 +986.61 +0 +1 +986.71 +768.707 +1 +986.81 +760.553 +1 +986.91 +768.435 +1 +987.01 +755.652 +1 +987.11 +767.617 +1 +987.21 +776.181 +1 +987.31 +795.763 +1 +987.41 +770.688 +1 +987.51 +763.262 +1 +987.61 +746.497 +1 +987.71 +771.299 +1 +987.81 +794.081 +1 +987.91 +798.462 +1 +988.01 +796.086 +1 +988.11 +750.701 +1 +988.21 +764.244 +1 +988.31 +762.703 +1 +988.41 +767.642 +1 +988.51 +809.875 +1 +988.61 +782.735 +1 +988.71 +802.762 +1 +988.81 +781.754 +1 +988.91 +797.075 +1 +989.01 +782.132 +1 +989.11 +772.809 +1 +989.21 +791.69 +1 +989.31 +768.177 +1 +989.41 +753.308 +1 +989.51 +789.669 +1 +989.61 +800.739 +1 +989.71 +779.037 +1 +989.81 +796.667 +1 +989.91 +788.664 +1 +990.01 +781.431 +1 +990.11 +763.133 +1 +990.21 +761.93 +1 +990.31 +770.168 +1 +990.41 +781.989 +1 +990.51 +774.174 +1 +990.61 +783.781 +1 +990.71 +788.367 +1 +990.81 +773.493 +1 +990.91 +805.974 +1 +991.01 +771.994 +1 +991.11 +777.448 +1 +991.21 +789.282 +1 +991.31 +794.388 +1 +991.41 +776.115 +1 +991.51 +783.245 +1 +991.61 +791.547 +1 +991.71 +791.152 +1 +991.81 +811.094 +1 +991.91 +769.968 +1 +992.01 +772.96 +1 +992.11 +796.65 +1 +992.21 +826.989 +1 +992.31 +810.03 +1 +992.41 +818.963 +1 +992.51 +785.408 +1 +992.61 +800.716 +1 +992.71 +788.478 +1 +992.81 +804.164 +1 +992.91 +812.978 +1 +993.01 +822.622 +1 +993.11 +819.208 +1 +993.21 +829.078 +1 +993.31 +792.38 +1 +993.41 +821.361 +1 +993.51 +807.064 +1 +993.61 +809.673 +1 +993.71 +829.266 +1 +993.81 +816.075 +1 +993.91 +811.888 +1 +994.01 +813.957 +1 +994.11 +821.861 +1 +994.21 +833.57 +1 +994.31 +837.714 +1 +994.41 +849.28 +1 +994.51 +857.286 +1 +994.61 +833.549 +1 +994.71 +845.806 +1 +994.81 +836.24 +1 +994.91 +858.359 +1 +995.01 +862.683 +1 +995.11 +844.704 +1 +995.21 +842.124 +1 +995.31 +876.151 +1 +995.41 +850.852 +1 +995.51 +870.002 +1 +995.61 +873.725 +1 +995.71 +872.576 +1 +995.81 +872.903 +1 +995.91 +878.814 +1 +996.01 +867.431 +1 +996.11 +865.276 +1 +996.21 +866.368 +1 +996.31 +877.735 +1 +996.41 +899.413 +1 +996.51 +886.844 +1 +996.61 +869.567 +1 +996.71 +902.856 +1 +996.81 +905.33 +1 +996.91 +874.966 +1 +997.01 +869.403 +1 +997.11 +865.949 +1 +997.21 +886.148 +1 +997.31 +882.212 +1 +997.41 +885.397 +1 +997.51 +898.615 +1 +997.61 +902.991 +1 +997.71 +883.438 +1 +997.81 +896.5 +1 +997.91 +893.677 +1 +998.01 +877.466 +1 +998.11 +900.29 +1 +998.21 +880.029 +1 +998.31 +903.615 +1 +998.41 +893.494 +1 +998.51 +880.647 +1 +998.61 +893.543 +1 +998.71 +873.733 +1 +998.81 +900.388 +1 +998.91 +916.252 +1 +999.01 +902.081 +1 +999.11 +905.374 +1 +999.21 +886.856 +1 +999.31 +911.213 +1 +999.41 +905.309 +1 +999.51 +902.687 +1 +999.61 +913.305 +1 +999.71 +904.045 +1 +999.81 +896.12 +1 +999.91 +897.236 +1 +1000.01 +923.679 +1 +1000.11 +926.681 +1 +1000.21 +926.073 +1 +1000.31 +925.526 +1 +1000.41 +907.704 +1 +1000.51 +896.397 +1 +1000.61 +910.067 +1 +1000.71 +926.249 +1 +1000.81 +920.429 +1 +1000.91 +911.683 +1 +1001.01 +929.617 +1 +1001.11 +950.296 +1 +1001.21 +954.222 +1 +1001.31 +958.371 +1 +1001.41 +948.537 +1 +1001.51 +937.444 +1 +1001.61 +926.521 +1 +1001.71 +914.447 +1 +1001.81 +938.226 +1 +1001.91 +942.783 +1 +1002.01 +945.337 +1 +1002.11 +920.58 +1 +1002.21 +939.262 +1 +1002.31 +943.013 +1 +1002.41 +943.763 +1 +1002.51 +963.942 +1 +1002.61 +929.992 +1 +1002.71 +921.771 +1 +1002.81 +946.545 +1 +1002.91 +951.811 +1 +1003.01 +971.317 +1 +1003.11 +932.785 +1 +1003.21 +938.39 +1 +1003.31 +948.212 +1 +1003.41 +955.917 +1 +1003.51 +950.44 +1 +1003.61 +933.546 +1 +1003.71 +937.391 +1 +1003.81 +934.345 +1 +1003.91 +945.101 +1 +1004.01 +931.364 +1 +1004.11 +934.292 +1 +1004.21 +938.488 +1 +1004.31 +931.659 +1 +1004.41 +941.812 +1 +1004.51 +926.828 +1 +1004.61 +935.58 +1 +1004.71 +914.475 +1 +1004.81 +926.205 +1 +1004.91 +933.151 +1 +1005.01 +894.257 +1 +1005.11 +922.632 +1 +1005.21 +947.099 +1 +1005.31 +942.994 +1 +1005.41 +962.008 +1 +1005.51 +926.796 +1 +1005.61 +950.836 +1 +1005.71 +940.143 +1 +1005.81 +956.34 +1 +1005.91 +956.727 +1 +1006.01 +975.317 +1 +1006.11 +940.591 +1 +1006.21 +947.456 +1 +1006.31 +981.819 +1 +1006.41 +970.555 +1 +1006.51 +1008.37 +1 +1006.61 +1008.11 +1 +1006.71 +1013.6 +1 +1006.81 +996.31 +1 +1006.91 +1014.27 +1 +1007.01 +987.97 +1 +1007.11 +1015.57 +1 +1007.21 +1041.04 +1 +1007.31 +1024.19 +1 +1007.41 +1046.25 +1 +1007.51 +1080.99 +1 +1007.61 +1052.36 +1 +1007.71 +1079.45 +1 +1007.81 +1069.35 +1 +1007.91 +1086.71 +1 +1008.01 +1099.49 +1 +1008.11 +1098.97 +1 +1008.21 +1082.77 +1 +1008.31 +1103.98 +1 +1008.41 +1124.29 +1 +1008.51 +1094.43 +1 +1008.61 +1092.18 +1 +1008.71 +1119.73 +1 +1008.81 +1111.18 +1 +1008.91 +1100.64 +1 +1009.01 +1074.02 +1 +1009.11 +1081.55 +1 +1009.21 +1084.81 +1 +1009.31 +1072.29 +1 +1009.41 +1064.08 +1 +1009.51 +1068.03 +1 +1009.61 +1042.68 +1 +1009.71 +1048.27 +1 +1009.81 +1047.75 +1 +1009.91 +1041.99 +1 +1010.01 +1032.26 +1 +1010.11 +1010.81 +1 +1010.21 +1010.5 +1 +1010.31 +981.444 +1 +1010.41 +994.358 +1 +1010.51 +1016.22 +1 +1010.61 +1023.54 +1 +1010.71 +996.998 +1 +1010.81 +986.877 +1 +1010.91 +990.319 +1 +1011.01 +977.67 +1 +1011.11 +974.063 +1 +1011.21 +990.486 +1 +1011.31 +981.065 +1 +1011.41 +994.019 +1 +1011.51 +977.353 +1 +1011.61 +990.329 +1 +1011.71 +997.831 +1 +1011.81 +976.829 +1 +1011.91 +1023.17 +1 +1012.01 +1048.11 +1 +1012.11 +1057 +1 +1012.21 +1054.53 +1 +1012.31 +1056.94 +1 +1012.41 +1065.11 +1 +1012.51 +1098.57 +1 +1012.61 +1081.96 +1 +1012.71 +1088.82 +1 +1012.81 +1090.24 +1 +1012.91 +1110.64 +1 +1013.01 +1156.04 +1 +1013.11 +1154.69 +1 +1013.21 +1149.48 +1 +1013.31 +1178.23 +1 +1013.41 +1206.08 +1 +1013.51 +1235.84 +1 +1013.61 +1212.04 +1 +1013.71 +1236.37 +1 +1013.81 +1260.29 +1 +1013.91 +1227.79 +1 +1014.01 +1267.25 +1 +1014.11 +1278.21 +1 +1014.21 +1301.9 +1 +1014.31 +1268.86 +1 +1014.41 +1282.91 +1 +1014.51 +1257.63 +1 +1014.61 +1268.26 +1 +1014.71 +1240.09 +1 +1014.81 +1212.45 +1 +1014.91 +1218.87 +1 +1015.01 +1192.01 +1 +1015.11 +1171.19 +1 +1015.21 +1155.17 +1 +1015.31 +1122.54 +1 +1015.41 +1101.79 +1 +1015.41 +1067.41 +1 +1015.46 +1052.35 +1 +1015.51 +1067.29 +1 +1015.51 +1059.44 +1 +1015.56 +1042.15 +1 +1015.61 +1030.58 +1 +1015.61 +1039.02 +1 +1015.66 +1026.23 +1 +1015.71 +1052.82 +1 +1015.71 +1026.07 +1 +1015.76 +1013.77 +1 +1015.81 +1016.71 +1 +1015.81 +984.758 +1 +1015.86 +1003.17 +1 +1015.91 +978.853 +1 +1015.91 +983.593 +1 +1015.96 +992.657 +1 +1016.01 +963.914 +1 +1016.01 +997.976 +1 +1016.06 +945.589 +1 +1016.11 +962.513 +1 +1016.11 +958.563 +1 +1016.16 +978.607 +1 +1016.21 +965.235 +1 +1016.21 +925.061 +1 +1016.26 +931.285 +1 +1016.31 +950.873 +1 +1016.31 +924.092 +1 +1016.36 +914.095 +1 +1016.41 +887.906 +1 +1016.41 +924.448 +1 +1016.46 +892.4 +1 +1016.51 +887.492 +1 +1016.56 +895.285 +1 +1016.61 +879.719 +1 +1016.66 +885.384 +1 +1016.71 +879.291 +1 +1016.76 +836.024 +1 +1016.81 +856.757 +1 +1016.86 +867.567 +1 +1016.91 +879.182 +1 +1016.96 +853.334 +1 +1017.01 +840.365 +1 +1017.06 +844.006 +1 +1017.11 +838.737 +1 +1017.16 +830.23 +1 +1017.21 +813.429 +1 +1017.26 +808.999 +1 +1017.31 +819.672 +1 +1017.36 +805.464 +1 +1017.41 +810.392 +1 +1017.46 +784.829 +1 +1017.51 +797.662 +1 +1017.56 +777.953 +1 +1017.61 +778.964 +1 +1017.66 +772.96 +1 +1017.71 +800.196 +1 +1017.76 +780.125 +1 +1017.81 +749.445 +1 +1017.86 +759.949 +1 +1017.91 +760.85 +1 +1017.96 +766.089 +1 +1018.01 +761.03 +1 +1018.06 +775.909 +1 +1018.11 +783.447 +1 +1018.16 +786.74 +1 +1018.21 +764.45 +1 +1018.26 +755.3 +1 +1018.31 +777.982 +1 +1018.36 +771.937 +1 +1018.41 +777.032 +1 +1018.46 +772.377 +1 +1018.51 +741.676 +1 +1018.56 +789.933 +1 +1018.61 +762.665 +1 +1018.66 +745.3 +1 +1018.71 +752.13 +1 +1018.76 +759.794 +1 +1018.81 +774.162 +1 +1018.86 +794.029 +1 +1018.91 +786.274 +1 +1018.96 +802.151 +1 +1019.01 +783.227 +1 +1019.06 +801.558 +1 +1019.11 +787.6 +1 +1019.16 +821.694 +1 +1019.21 +830.725 +1 +1019.26 +819.337 +1 +1019.31 +865.198 +1 +1019.36 +844.184 +1 +1019.41 +845.633 +1 +1019.46 +854.093 +1 +1019.51 +863.046 +1 +1019.56 +874.417 +1 +1019.61 +913.775 +1 +1019.66 +896.864 +1 +1019.71 +925.225 +1 +1019.76 +932.491 +1 +1019.81 +971.033 +1 +1019.86 +966.216 +1 +1019.91 +972.082 +1 +1019.96 +1029.16 +1 +1020.01 +1031.97 +1 +1020.06 +1049.6 +1 +1020.11 +1079.9 +1 +1020.16 +1095.11 +1 +1020.21 +1142.77 +1 +1020.26 +1185.78 +1 +1020.31 +1234.21 +1 +1020.36 +1275.05 +1 +1020.41 +1301.29 +1 +1020.46 +1354.89 +1 +1020.51 +1402.01 +1 +1020.56 +1465.91 +1 +1020.61 +1505.27 +1 +1020.66 +1542.42 +1 +1020.71 +1564.52 +1 +1020.76 +1643.28 +1 +1020.81 +1699.57 +1 +1020.86 +1778.37 +1 +1020.91 +1802.46 +1 +1020.96 +1858.86 +1 +1021.01 +1969.59 +1 +1021.06 +2010.58 +1 +1021.11 +2061.9 +1 +1021.16 +2155.96 +1 +1021.21 +2171.67 +1 +1021.26 +2266.3 +1 +1021.31 +2257.47 +1 +1021.36 +2311 +1 +1021.41 +2367.68 +1 +1021.46 +2426.42 +1 +1021.51 +2451.52 +1 +1021.56 +2486.56 +1 +1021.61 +2485.79 +1 +1021.66 +2516.09 +1 +1021.71 +2550.8 +1 +1021.76 +2526.8 +1 +1021.81 +2501.27 +1 +1021.86 +2536.75 +1 +1021.91 +2497.04 +1 +1021.96 +2492.25 +1 +1022.01 +2489.07 +1 +1022.06 +2395.72 +1 +1022.11 +2401.55 +1 +1022.16 +2346.97 +1 +1022.21 +2306.04 +1 +1022.26 +2289 +1 +1022.31 +2227.36 +1 +1022.36 +2153.49 +1 +1022.41 +2067.64 +1 +1022.46 +1998.69 +1 +1022.51 +1950.63 +1 +1022.56 +1902.71 +1 +1022.61 +1827.21 +1 +1022.66 +1728.78 +1 +1022.71 +1672.22 +1 +1022.76 +1609.68 +1 +1022.81 +1578.01 +1 +1022.86 +1559.44 +1 +1022.91 +1434.8 +1 +1022.96 +1366.92 +1 +1023.01 +1348.1 +1 +1023.06 +1290.44 +1 +1023.11 +1235.91 +1 +1023.16 +1223.03 +1 +1023.21 +1158.64 +1 +1023.26 +1156.28 +1 +1023.31 +1128.58 +1 +1023.36 +1089.29 +1 +1023.41 +1032.33 +1 +1023.46 +1023.36 +1 +1023.51 +996.215 +1 +1023.56 +948.428 +1 +1023.61 +937.285 +1 +1023.66 +924.02 +1 +1023.71 +904.001 +1 +1023.76 +911.682 +1 +1023.81 +860.988 +1 +1023.86 +840.295 +1 +1023.91 +830.683 +1 +1023.96 +806.105 +1 +1024.01 +814.335 +1 +1024.06 +797.877 +1 +1024.11 +784.465 +1 +1024.16 +798.57 +1 +1024.21 +784.869 +1 +1024.26 +780.672 +1 +1024.31 +778.737 +1 +1024.36 +761.738 +1 +1024.41 +758.673 +1 +1024.46 +741.007 +1 +1024.51 +751.087 +1 +1024.56 +759.106 +1 +1024.61 +748.745 +1 +1024.66 +740.552 +1 +1024.71 +748.907 +1 +1024.76 +754.767 +1 +1024.81 +759.631 +1 +1024.86 +754.448 +1 +1024.91 +746.531 +1 +1024.96 +762.516 +1 +1025.01 +778.526 +1 +1025.06 +758.886 +1 +1025.11 +759.716 +1 +1025.16 +770.626 +1 +1025.21 +777.027 +1 +1025.26 +784.108 +1 +1025.31 +786.215 +1 +1025.36 +784.578 +1 +1025.41 +791.529 +1 +1025.46 +817.551 +1 +1025.51 +813.631 +1 +1025.56 +831.026 +1 +1025.61 +823.737 +1 +1025.66 +843.837 +1 +1025.71 +847.126 +1 +1025.76 +845.529 +1 +1025.81 +871.589 +1 +1025.86 +897.405 +1 +1025.91 +931.456 +1 +1025.96 +943.584 +1 +1026.01 +975.757 +1 +1026.06 +1029.64 +1 +1026.11 +1058.22 +1 +1026.16 +1123.13 +1 +1026.21 +1166.62 +1 +1026.26 +1235.35 +1 +1026.31 +1291.99 +1 +1026.36 +1404.8 +1 +1026.41 +1511.6 +1 +1026.46 +1620.58 +1 +1026.51 +1744.35 +1 +1026.56 +1887.18 +1 +1026.61 +2048.32 +1 +1026.66 +2250.15 +1 +1026.71 +2474.29 +1 +1026.76 +2792.44 +1 +1026.81 +3041.37 +1 +1026.86 +3301.67 +1 +1026.91 +3616.82 +1 +1026.96 +3968.96 +1 +1027.01 +4302.5 +1 +1027.06 +4599.79 +1 +1027.11 +4948.24 +1 +1027.16 +5336.66 +1 +1027.21 +5592.03 +1 +1027.26 +5891.08 +1 +1027.31 +6117.37 +1 +1027.36 +6401.69 +1 +1027.41 +6544.88 +1 +1027.46 +6616.65 +1 +1027.51 +6705.58 +1 +1027.56 +6693.94 +1 +1027.61 +6634.5 +1 +1027.66 +6522.28 +1 +1027.71 +6363.31 +1 +1027.76 +6104.02 +1 +1027.81 +5828.6 +1 +1027.86 +5495.3 +1 +1027.91 +5100.96 +1 +1027.96 +4818.28 +1 +1028.01 +4440.83 +1 +1028.06 +4085.26 +1 +1028.11 +3670.51 +1 +1028.16 +3341.96 +1 +1028.21 +2989.35 +1 +1028.26 +2685.24 +1 +1028.31 +2373.67 +1 +1028.36 +2111.04 +1 +1028.41 +1882.81 +1 +1028.46 +1636.92 +1 +1028.51 +1449.51 +1 +1028.56 +1278.47 +1 +1028.61 +1138.66 +1 +1028.66 +1008.49 +1 +1028.71 +880.955 +1 +1028.76 +784.214 +1 +1028.81 +710.739 +1 +1028.86 +639.553 +1 +1028.91 +593.143 +1 +1028.96 +528.411 +1 +1029.01 +493.952 +1 +1029.06 +460.395 +1 +1029.11 +430.007 +1 +1029.16 +407.676 +1 +1029.21 +375.74 +1 +1029.26 +349.579 +1 +1029.31 +307.498 +1 +1029.36 +298.685 +1 +1029.41 +289.607 +1 +1029.46 +274.535 +1 +1029.51 +261.454 +1 +1029.56 +258.402 +1 +1029.61 +241.45 +1 +1029.66 +226.133 +1 +1029.71 +195.994 +1 +1029.76 +196.912 +1 +1029.81 +178.111 +1 +1029.86 +182.602 +1 +1029.91 +171.642 +1 +1029.96 +139.931 +1 +1030.01 +148.703 +1 +1030.06 +140.236 +1 +1030.11 +122.799 +1 +1030.16 +127.547 +1 +1030.21 +123.658 +1 +1030.26 +117.159 +1 +1030.31 +113.168 +1 +1030.36 +103.043 +1 +1030.41 +89.9611 +1 +1030.46 +79.7678 +1 +1030.51 +82.6402 +1 +1030.56 +78.3794 +1 +1030.61 +71.4293 +1 +1030.66 +76.4138 +1 +1030.71 +75.3822 +1 +1030.76 +78.9603 +1 +1030.81 +65.8195 +1 +1030.86 +59.9979 +1 +1030.91 +53.6695 +1 +1030.96 +50.609 +1 +1031.01 +45.9551 +1 +1031.06 +58.2979 +1 +1031.11 +45.7672 +1 +1031.16 +45.6667 +1 +1031.21 +37.6953 +1 +1031.26 +34.8926 +1 +1031.31 +45.1279 +1 +1031.36 +38.4188 +1 +1031.41 +43.102 +1 +1031.46 +41.5193 +1 +1031.51 +41.8022 +1 +1031.56 +37.3304 +1 +1031.61 +34.3535 +1 +1031.66 +38.0149 +1 +1031.71 +41.0285 +1 +1031.76 +38.7568 +1 +1031.81 +24.1728 +1 +1031.86 +26.7467 +1 +1031.91 +24.8709 +1 +1031.96 +25.2497 +1 +1032.01 +30.3581 +1 +1032.06 +32.8652 +1 +1032.11 +26.7379 +1 +1032.16 +17.5069 +1 +1032.21 +27.4104 +1 +1032.26 +31.9776 +1 +1032.31 +35.0028 +1 +1032.36 +28.3184 +1 +1032.41 +18.7488 +1 +1032.46 +16.2122 +1 +1032.51 +31.8477 +1 +1032.56 +28.849 +1 +1032.61 +28.1205 +1 +1032.66 +19.5003 +1 +1032.71 +22.1481 +1 +1032.76 +14.6862 +1 +1032.81 +23.383 +1 +1032.86 +23.817 +1 +1032.91 +18.631 +1 +1032.96 +16.5573 +1 +1033.01 +12.2888 +1 +1033.06 +14.5476 +1 +1033.11 +16.5876 +1 +1033.16 +14.5942 +1 +1033.21 +13.8555 +1 +1033.26 +14.5433 +1 +1033.31 +7.00553 +1 +1033.36 +19.7495 +1 +1033.41 +9.75463 +1 +1033.46 +16.6813 +1 +1033.51 +10.5411 +1 +1033.56 +11.4887 +1 +1033.61 +9.85089 +1 +1033.66 +21.479 +1 +1033.71 +15.0159 +1 +1033.76 +22.6288 +1 +1033.81 +16.9822 +1 +1033.86 +17.9488 +1 +1033.91 +10.2562 +1 +1033.96 +17.5299 +1 +1034.01 +14.6918 +1 +1034.06 +18.5697 +1 +1034.11 +18.4523 +1 +1034.16 +17.5792 +1 +1034.21 +20.0307 +1 +1034.26 +24.9494 +1 +1034.31 +12.6893 +1 +1034.36 +7.72395 +1 +1034.41 +4.38198 +1 +1034.46 +6.31105 +1 +1034.51 +13.7239 +1 +1034.56 +19.994 +1 +1034.61 +12.7116 +1 +1034.66 +10.1567 +1 +1034.71 +12.2761 +1 +1034.76 +14.2381 +1 +1034.81 +4.75145 +1 +1034.86 +-0.0982386 +1 +1034.91 +11.4553 +1 +1034.96 +8.98422 +1 +1035.01 +19.1661 +1 +1035.06 +11.0729 +1 +1035.11 +14.8176 +1 +1035.16 +14.128 +1 +1035.21 +12.2612 +1 +1035.26 +12.6718 +1 +1035.31 +13.668 +1 +1035.36 +5.73352 +1 +1035.41 +6.80692 +1 +1035.46 +6.00817 +1 +1035.51 +3.57823 +1 +1035.56 +6.26545 +1 +1035.61 +10.8517 +1 +1035.66 +8.11417 +1 +1035.71 +8.48454 +1 +1035.76 +6.19727 +1 +1035.81 +9.99754 +1 +1035.86 +-0.595702 +1 +1035.91 +3.32511 +1 +1035.96 +2.16431 +1 +1036.01 +5.30515 +1 +1036.06 +6.33019 +1 +1036.11 +-0.15255 +1 +1036.16 +-0.160988 +1 +1036.21 +4.10473 +1 +1036.26 +-1.07666 +1 +1036.31 +1.58446 +1 +1036.36 +-0.212021 +1 +1036.41 +12.2091 +1 +1036.46 +6.92326 +1 +1036.51 +14.8672 +1 +1036.56 +6.40831 +1 +1036.61 +4.71866 +1 +1036.66 +7.10513 +1 +1036.71 +9.98924 +1 +1036.76 +1.929 +1 +1036.81 +6.98157 +1 +1036.86 +3.66599 +1 +1036.91 +8.02528 +1 +1036.96 +-0.623079 +1 +1037.01 +-3.58963 +1 +1037.06 +-4.89371 +1 +1037.11 +3.92434 +1 +1037.16 +8.29572 +1 +1037.21 +8.52046 +1 +1037.26 +10.3075 +1 +1037.31 +6.96935 +1 +1037.36 +-0.523693 +1 +1037.41 +-6.73835 +1 +1037.46 +1.34514 +1 +1037.51 +4.97275 +1 +1037.56 +1.15262 +1 +1037.61 +-2.7992 +1 +1037.66 +9.64657 +1 +1037.71 +5.40891 +1 +1037.76 +6.80002 +1 +1037.81 +-3.69174 +1 +1037.86 +4.72394 +1 +1037.91 +2.41516 +1 +1037.96 +2.16941 +1 +1038.01 +3.25827 +1 +1038.06 +6.17699 +1 +1038.11 +-0.126762 +1 +1038.16 +9.74501 +1 +1038.21 +2.44671 +1 +1038.26 +13.5869 +1 +1038.31 +0.257914 +1 +1038.36 +2.84957 +1 +1038.41 +3.89457 +1 +1038.46 +-3.92537 +1 +1038.51 +-5.8306 +1 +1038.56 +-1.07815 +1 +1038.61 +4.5545 +1 +1038.66 +9.49284 +1 +1038.71 +0.264434 +1 +1038.76 +1.19787 +1 +1038.81 +1.67889 +1 +1038.86 +-0.411538 +1 +1038.91 +3.29361 +1 +1038.96 +3.60995 +1 +1039.01 +7.03935 +1 +1039.06 +2.46095 +1 +1039.11 +3.16899 +1 +1039.16 +-3.42998 +1 +1039.21 +7.20019 +1 +1039.26 +-6.66532 +1 +1039.31 +-2.25084 +1 +1039.36 +0.0238542 +1 +1039.41 +-2.53558 +1 +1039.46 +1.21449 +1 +1039.51 +-4.11686 +1 +1039.56 +0.731545 +1 +1039.61 +2.61504 +1 +1039.66 +-1.29684 +1 +1039.71 +-3.20836 +1 +1039.76 +7.83649 +1 +1039.81 +4.38263 +1 +1039.86 +6.31627 +1 +1039.91 +6.05281 +1 +1039.96 +4.76111 +1 +1040.01 +3.3128 +1 +1040.06 +7.77774 +1 +1040.11 +1.48788 +1 +1040.16 +7.11285 +1 +1040.21 +2.66528 +1 +1040.26 +0.887167 +1 +1040.31 +2.751 +1 +1040.36 +-10.7387 +1 +1040.41 +0 +1 +end of experiment