Add files using upload-large-folder tool

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/__init__.py

@@ -0,0 +1,1579 @@
+"""
+An object-oriented plotting library.
+
+A procedural interface is provided by the companion pyplot module,
+which may be imported directly, e.g.::
+
+    import matplotlib.pyplot as plt
+
+or using ipython::
+
+    ipython
+
+at your terminal, followed by::
+
+    In [1]: %matplotlib
+    In [2]: import matplotlib.pyplot as plt
+
+at the ipython shell prompt.
+
+For the most part, direct use of the explicit object-oriented library is
+encouraged when programming; the implicit pyplot interface is primarily for
+working interactively. The exceptions to this suggestion are the pyplot
+functions `.pyplot.figure`, `.pyplot.subplot`, `.pyplot.subplots`, and
+`.pyplot.savefig`, which can greatly simplify scripting.  See
+:ref:`api_interfaces` for an explanation of the tradeoffs between the implicit
+and explicit interfaces.
+
+Modules include:
+
+:mod:`matplotlib.axes`
+    The `~.axes.Axes` class.  Most pyplot functions are wrappers for
+    `~.axes.Axes` methods.  The axes module is the highest level of OO
+    access to the library.
+
+:mod:`matplotlib.figure`
+    The `.Figure` class.
+
+:mod:`matplotlib.artist`
+    The `.Artist` base class for all classes that draw things.
+
+:mod:`matplotlib.lines`
+    The `.Line2D` class for drawing lines and markers.
+
+:mod:`matplotlib.patches`
+    Classes for drawing polygons.
+
+:mod:`matplotlib.text`
+    The `.Text` and `.Annotation` classes.
+
+:mod:`matplotlib.image`
+    The `.AxesImage` and `.FigureImage` classes.
+
+:mod:`matplotlib.collections`
+    Classes for efficient drawing of groups of lines or polygons.
+
+:mod:`matplotlib.colors`
+    Color specifications and making colormaps.
+
+:mod:`matplotlib.cm`
+    Colormaps, and the `.ScalarMappable` mixin class for providing color
+    mapping functionality to other classes.
+
+:mod:`matplotlib.ticker`
+    Calculation of tick mark locations and formatting of tick labels.
+
+:mod:`matplotlib.backends`
+    A subpackage with modules for various GUI libraries and output formats.
+
+The base matplotlib namespace includes:
+
+`~matplotlib.rcParams`
+    Default configuration settings; their defaults may be overridden using
+    a :file:`matplotlibrc` file.
+
+`~matplotlib.use`
+    Setting the Matplotlib backend.  This should be called before any
+    figure is created, because it is not possible to switch between
+    different GUI backends after that.
+
+The following environment variables can be used to customize the behavior:
+
+:envvar:`MPLBACKEND`
+    This optional variable can be set to choose the Matplotlib backend. See
+    :ref:`what-is-a-backend`.
+
+:envvar:`MPLCONFIGDIR`
+    This is the directory used to store user customizations to
+    Matplotlib, as well as some caches to improve performance. If
+    :envvar:`MPLCONFIGDIR` is not defined, :file:`{HOME}/.config/matplotlib`
+    and :file:`{HOME}/.cache/matplotlib` are used on Linux, and
+    :file:`{HOME}/.matplotlib` on other platforms, if they are
+    writable. Otherwise, the Python standard library's `tempfile.gettempdir`
+    is used to find a base directory in which the :file:`matplotlib`
+    subdirectory is created.
+
+Matplotlib was initially written by John D. Hunter (1968-2012) and is now
+developed and maintained by a host of others.
+
+Occasionally the internal documentation (python docstrings) will refer
+to MATLAB®, a registered trademark of The MathWorks, Inc.
+
+"""
+
+__all__ = [
+    "__bibtex__",
+    "__version__",
+    "__version_info__",
+    "set_loglevel",
+    "ExecutableNotFoundError",
+    "get_configdir",
+    "get_cachedir",
+    "get_data_path",
+    "matplotlib_fname",
+    "MatplotlibDeprecationWarning",
+    "RcParams",
+    "rc_params",
+    "rc_params_from_file",
+    "rcParamsDefault",
+    "rcParams",
+    "rcParamsOrig",
+    "defaultParams",
+    "rc",
+    "rcdefaults",
+    "rc_file_defaults",
+    "rc_file",
+    "rc_context",
+    "use",
+    "get_backend",
+    "interactive",
+    "is_interactive",
+    "colormaps",
+    "multivar_colormaps",
+    "bivar_colormaps",
+    "color_sequences",
+]
+
+
+import atexit
+from collections import namedtuple
+from collections.abc import MutableMapping
+import contextlib
+import functools
+import importlib
+import inspect
+from inspect import Parameter
+import locale
+import logging
+import os
+from pathlib import Path
+import pprint
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+
+from packaging.version import parse as parse_version
+
+# cbook must import matplotlib only within function
+# definitions, so it is safe to import from it here.
+from . import _api, _version, cbook, _docstring, rcsetup
+from matplotlib._api import MatplotlibDeprecationWarning
+from matplotlib.rcsetup import cycler  # noqa: F401
+
+
+_log = logging.getLogger(__name__)
+
+__bibtex__ = r"""@Article{Hunter:2007,
+  Author    = {Hunter, J. D.},
+  Title     = {Matplotlib: A 2D graphics environment},
+  Journal   = {Computing in Science \& Engineering},
+  Volume    = {9},
+  Number    = {3},
+  Pages     = {90--95},
+  abstract  = {Matplotlib is a 2D graphics package used for Python
+  for application development, interactive scripting, and
+  publication-quality image generation across user
+  interfaces and operating systems.},
+  publisher = {IEEE COMPUTER SOC},
+  year      = 2007
+}"""
+
+# modelled after sys.version_info
+_VersionInfo = namedtuple('_VersionInfo',
+                          'major, minor, micro, releaselevel, serial')
+
+
+def _parse_to_version_info(version_str):
+    """
+    Parse a version string to a namedtuple analogous to sys.version_info.
+
+    See:
+    https://packaging.pypa.io/en/latest/version.html#packaging.version.parse
+    https://docs.python.org/3/library/sys.html#sys.version_info
+    """
+    v = parse_version(version_str)
+    if v.pre is None and v.post is None and v.dev is None:
+        return _VersionInfo(v.major, v.minor, v.micro, 'final', 0)
+    elif v.dev is not None:
+        return _VersionInfo(v.major, v.minor, v.micro, 'alpha', v.dev)
+    elif v.pre is not None:
+        releaselevel = {
+            'a': 'alpha',
+            'b': 'beta',
+            'rc': 'candidate'}.get(v.pre[0], 'alpha')
+        return _VersionInfo(v.major, v.minor, v.micro, releaselevel, v.pre[1])
+    else:
+        # fallback for v.post: guess-next-dev scheme from setuptools_scm
+        return _VersionInfo(v.major, v.minor, v.micro + 1, 'alpha', v.post)
+
+
+def _get_version():
+    """Return the version string used for __version__."""
+    # Only shell out to a git subprocess if really needed, i.e. when we are in
+    # a matplotlib git repo but not in a shallow clone, such as those used by
+    # CI, as the latter would trigger a warning from setuptools_scm.
+    root = Path(__file__).resolve().parents[2]
+    if ((root / ".matplotlib-repo").exists()
+            and (root / ".git").exists()
+            and not (root / ".git/shallow").exists()):
+        try:
+            import setuptools_scm
+        except ImportError:
+            pass
+        else:
+            return setuptools_scm.get_version(
+                root=root,
+                dist_name="matplotlib",
+                version_scheme="release-branch-semver",
+                local_scheme="node-and-date",
+                fallback_version=_version.version,
+            )
+    # Get the version from the _version.py file if not in repo or setuptools_scm is
+    # unavailable.
+    return _version.version
+
+
+@_api.caching_module_getattr
+class __getattr__:
+    __version__ = property(lambda self: _get_version())
+    __version_info__ = property(
+        lambda self: _parse_to_version_info(self.__version__))
+
+
+def _check_versions():
+
+    # Quickfix to ensure Microsoft Visual C++ redistributable
+    # DLLs are loaded before importing kiwisolver
+    from . import ft2font  # noqa: F401
+
+    for modname, minver in [
+            ("cycler", "0.10"),
+            ("dateutil", "2.7"),
+            ("kiwisolver", "1.3.1"),
+            ("numpy", "1.23"),
+            ("pyparsing", "2.3.1"),
+    ]:
+        module = importlib.import_module(modname)
+        if parse_version(module.__version__) < parse_version(minver):
+            raise ImportError(f"Matplotlib requires {modname}>={minver}; "
+                              f"you have {module.__version__}")
+
+
+_check_versions()
+
+
+# The decorator ensures this always returns the same handler (and it is only
+# attached once).
+@functools.cache
+def _ensure_handler():
+    """
+    The first time this function is called, attach a `StreamHandler` using the
+    same format as `logging.basicConfig` to the Matplotlib root logger.
+
+    Return this handler every time this function is called.
+    """
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(logging.BASIC_FORMAT))
+    _log.addHandler(handler)
+    return handler
+
+
+def set_loglevel(level):
+    """
+    Configure Matplotlib's logging levels.
+
+    Matplotlib uses the standard library `logging` framework under the root
+    logger 'matplotlib'.  This is a helper function to:
+
+    - set Matplotlib's root logger level
+    - set the root logger handler's level, creating the handler
+      if it does not exist yet
+
+    Typically, one should call ``set_loglevel("info")`` or
+    ``set_loglevel("debug")`` to get additional debugging information.
+
+    Users or applications that are installing their own logging handlers
+    may want to directly manipulate ``logging.getLogger('matplotlib')`` rather
+    than use this function.
+
+    Parameters
+    ----------
+    level : {"notset", "debug", "info", "warning", "error", "critical"}
+        The log level of the handler.
+
+    Notes
+    -----
+    The first time this function is called, an additional handler is attached
+    to Matplotlib's root handler; this handler is reused every time and this
+    function simply manipulates the logger and handler's level.
+
+    """
+    _log.setLevel(level.upper())
+    _ensure_handler().setLevel(level.upper())
+
+
+def _logged_cached(fmt, func=None):
+    """
+    Decorator that logs a function's return value, and memoizes that value.
+
+    After ::
+
+        @_logged_cached(fmt)
+        def func(): ...
+
+    the first call to *func* will log its return value at the DEBUG level using
+    %-format string *fmt*, and memoize it; later calls to *func* will directly
+    return that value.
+    """
+    if func is None:  # Return the actual decorator.
+        return functools.partial(_logged_cached, fmt)
+
+    called = False
+    ret = None
+
+    @functools.wraps(func)
+    def wrapper(**kwargs):
+        nonlocal called, ret
+        if not called:
+            ret = func(**kwargs)
+            called = True
+            _log.debug(fmt, ret)
+        return ret
+
+    return wrapper
+
+
+_ExecInfo = namedtuple("_ExecInfo", "executable raw_version version")
+
+
+class ExecutableNotFoundError(FileNotFoundError):
+    """
+    Error raised when an executable that Matplotlib optionally
+    depends on can't be found.
+    """
+    pass
+
+
+@functools.cache
+def _get_executable_info(name):
+    """
+    Get the version of some executable that Matplotlib optionally depends on.
+
+    .. warning::
+       The list of executables that this function supports is set according to
+       Matplotlib's internal needs, and may change without notice.
+
+    Parameters
+    ----------
+    name : str
+        The executable to query.  The following values are currently supported:
+        "dvipng", "gs", "inkscape", "magick", "pdftocairo", "pdftops".  This
+        list is subject to change without notice.
+
+    Returns
+    -------
+    tuple
+        A namedtuple with fields ``executable`` (`str`) and ``version``
+        (`packaging.Version`, or ``None`` if the version cannot be determined).
+
+    Raises
+    ------
+    ExecutableNotFoundError
+        If the executable is not found or older than the oldest version
+        supported by Matplotlib.  For debugging purposes, it is also
+        possible to "hide" an executable from Matplotlib by adding it to the
+        :envvar:`_MPLHIDEEXECUTABLES` environment variable (a comma-separated
+        list), which must be set prior to any calls to this function.
+    ValueError
+        If the executable is not one that we know how to query.
+    """
+
+    def impl(args, regex, min_ver=None, ignore_exit_code=False):
+        # Execute the subprocess specified by args; capture stdout and stderr.
+        # Search for a regex match in the output; if the match succeeds, the
+        # first group of the match is the version.
+        # Return an _ExecInfo if the executable exists, and has a version of
+        # at least min_ver (if set); else, raise ExecutableNotFoundError.
+        try:
+            output = subprocess.check_output(
+                args, stderr=subprocess.STDOUT,
+                text=True, errors="replace", timeout=30)
+        except subprocess.CalledProcessError as _cpe:
+            if ignore_exit_code:
+                output = _cpe.output
+            else:
+                raise ExecutableNotFoundError(str(_cpe)) from _cpe
+        except subprocess.TimeoutExpired as _te:
+            msg = f"Timed out running {cbook._pformat_subprocess(args)}"
+            raise ExecutableNotFoundError(msg) from _te
+        except OSError as _ose:
+            raise ExecutableNotFoundError(str(_ose)) from _ose
+        match = re.search(regex, output)
+        if match:
+            raw_version = match.group(1)
+            version = parse_version(raw_version)
+            if min_ver is not None and version < parse_version(min_ver):
+                raise ExecutableNotFoundError(
+                    f"You have {args[0]} version {version} but the minimum "
+                    f"version supported by Matplotlib is {min_ver}")
+            return _ExecInfo(args[0], raw_version, version)
+        else:
+            raise ExecutableNotFoundError(
+                f"Failed to determine the version of {args[0]} from "
+                f"{' '.join(args)}, which output {output}")
+
+    if name in os.environ.get("_MPLHIDEEXECUTABLES", "").split(","):
+        raise ExecutableNotFoundError(f"{name} was hidden")
+
+    if name == "dvipng":
+        return impl(["dvipng", "-version"], "(?m)^dvipng(?: .*)? (.+)", "1.6")
+    elif name == "gs":
+        execs = (["gswin32c", "gswin64c", "mgs", "gs"]  # "mgs" for miktex.
+                 if sys.platform == "win32" else
+                 ["gs"])
+        for e in execs:
+            try:
+                return impl([e, "--version"], "(.*)", "9")
+            except ExecutableNotFoundError:
+                pass
+        message = "Failed to find a Ghostscript installation"
+        raise ExecutableNotFoundError(message)
+    elif name == "inkscape":
+        try:
+            # Try headless option first (needed for Inkscape version < 1.0):
+            return impl(["inkscape", "--without-gui", "-V"],
+                        "Inkscape ([^ ]*)")
+        except ExecutableNotFoundError:
+            pass  # Suppress exception chaining.
+        # If --without-gui is not accepted, we may be using Inkscape >= 1.0 so
+        # try without it:
+        return impl(["inkscape", "-V"], "Inkscape ([^ ]*)")
+    elif name == "magick":
+        if sys.platform == "win32":
+            # Check the registry to avoid confusing ImageMagick's convert with
+            # Windows's builtin convert.exe.
+            import winreg
+            binpath = ""
+            for flag in [0, winreg.KEY_WOW64_32KEY, winreg.KEY_WOW64_64KEY]:
+                try:
+                    with winreg.OpenKeyEx(
+                            winreg.HKEY_LOCAL_MACHINE,
+                            r"Software\Imagemagick\Current",
+                            0, winreg.KEY_QUERY_VALUE | flag) as hkey:
+                        binpath = winreg.QueryValueEx(hkey, "BinPath")[0]
+                except OSError:
+                    pass
+            path = None
+            if binpath:
+                for name in ["convert.exe", "magick.exe"]:
+                    candidate = Path(binpath, name)
+                    if candidate.exists():
+                        path = str(candidate)
+                        break
+            if path is None:
+                raise ExecutableNotFoundError(
+                    "Failed to find an ImageMagick installation")
+        else:
+            path = "convert"
+        info = impl([path, "--version"], r"^Version: ImageMagick (\S*)")
+        if info.raw_version == "7.0.10-34":
+            # https://github.com/ImageMagick/ImageMagick/issues/2720
+            raise ExecutableNotFoundError(
+                f"You have ImageMagick {info.version}, which is unsupported")
+        return info
+    elif name == "pdftocairo":
+        return impl(["pdftocairo", "-v"], "pdftocairo version (.*)")
+    elif name == "pdftops":
+        info = impl(["pdftops", "-v"], "^pdftops version (.*)",
+                    ignore_exit_code=True)
+        if info and not (
+                3 <= info.version.major or
+                # poppler version numbers.
+                parse_version("0.9") <= info.version < parse_version("1.0")):
+            raise ExecutableNotFoundError(
+                f"You have pdftops version {info.version} but the minimum "
+                f"version supported by Matplotlib is 3.0")
+        return info
+    else:
+        raise ValueError(f"Unknown executable: {name!r}")
+
+
+def _get_xdg_config_dir():
+    """
+    Return the XDG configuration directory, according to the XDG base
+    directory spec:
+
+    https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+    """
+    return os.environ.get('XDG_CONFIG_HOME') or str(Path.home() / ".config")
+
+
+def _get_xdg_cache_dir():
+    """
+    Return the XDG cache directory, according to the XDG base directory spec:
+
+    https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+    """
+    return os.environ.get('XDG_CACHE_HOME') or str(Path.home() / ".cache")
+
+
+def _get_config_or_cache_dir(xdg_base_getter):
+    configdir = os.environ.get('MPLCONFIGDIR')
+    if configdir:
+        configdir = Path(configdir)
+    elif sys.platform.startswith(('linux', 'freebsd')):
+        # Only call _xdg_base_getter here so that MPLCONFIGDIR is tried first,
+        # as _xdg_base_getter can throw.
+        configdir = Path(xdg_base_getter(), "matplotlib")
+    else:
+        configdir = Path.home() / ".matplotlib"
+    # Resolve the path to handle potential issues with inaccessible symlinks.
+    configdir = configdir.resolve()
+    try:
+        configdir.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        _log.warning("mkdir -p failed for path %s: %s", configdir, exc)
+    else:
+        if os.access(str(configdir), os.W_OK) and configdir.is_dir():
+            return str(configdir)
+        _log.warning("%s is not a writable directory", configdir)
+    # If the config or cache directory cannot be created or is not a writable
+    # directory, create a temporary one.
+    try:
+        tmpdir = tempfile.mkdtemp(prefix="matplotlib-")
+    except OSError as exc:
+        raise OSError(
+            f"Matplotlib requires access to a writable cache directory, but there "
+            f"was an issue with the default path ({configdir}), and a temporary "
+            f"directory could not be created; set the MPLCONFIGDIR environment "
+            f"variable to a writable directory") from exc
+    os.environ["MPLCONFIGDIR"] = tmpdir
+    atexit.register(shutil.rmtree, tmpdir)
+    _log.warning(
+        "Matplotlib created a temporary cache directory at %s because there was "
+        "an issue with the default path (%s); it is highly recommended to set the "
+        "MPLCONFIGDIR environment variable to a writable directory, in particular to "
+        "speed up the import of Matplotlib and to better support multiprocessing.",
+        tmpdir, configdir)
+    return tmpdir
+
+
+@_logged_cached('CONFIGDIR=%s')
+def get_configdir():
+    """
+    Return the string path of the configuration directory.
+
+    The directory is chosen as follows:
+
+    1. If the MPLCONFIGDIR environment variable is supplied, choose that.
+    2. On Linux, follow the XDG specification and look first in
+       ``$XDG_CONFIG_HOME``, if defined, or ``$HOME/.config``.  On other
+       platforms, choose ``$HOME/.matplotlib``.
+    3. If the chosen directory exists and is writable, use that as the
+       configuration directory.
+    4. Else, create a temporary directory, and use it as the configuration
+       directory.
+    """
+    return _get_config_or_cache_dir(_get_xdg_config_dir)
+
+
+@_logged_cached('CACHEDIR=%s')
+def get_cachedir():
+    """
+    Return the string path of the cache directory.
+
+    The procedure used to find the directory is the same as for
+    `get_configdir`, except using ``$XDG_CACHE_HOME``/``$HOME/.cache`` instead.
+    """
+    return _get_config_or_cache_dir(_get_xdg_cache_dir)
+
+
+@_logged_cached('matplotlib data path: %s')
+def get_data_path():
+    """Return the path to Matplotlib data."""
+    return str(Path(__file__).with_name("mpl-data"))
+
+
+def matplotlib_fname():
+    """
+    Get the location of the config file.
+
+    The file location is determined in the following order
+
+    - ``$PWD/matplotlibrc``
+    - ``$MATPLOTLIBRC`` if it is not a directory
+    - ``$MATPLOTLIBRC/matplotlibrc``
+    - ``$MPLCONFIGDIR/matplotlibrc``
+    - On Linux,
+        - ``$XDG_CONFIG_HOME/matplotlib/matplotlibrc`` (if ``$XDG_CONFIG_HOME``
+          is defined)
+        - or ``$HOME/.config/matplotlib/matplotlibrc`` (if ``$XDG_CONFIG_HOME``
+          is not defined)
+    - On other platforms,
+      - ``$HOME/.matplotlib/matplotlibrc`` if ``$HOME`` is defined
+    - Lastly, it looks in ``$MATPLOTLIBDATA/matplotlibrc``, which should always
+      exist.
+    """
+
+    def gen_candidates():
+        # rely on down-stream code to make absolute.  This protects us
+        # from having to directly get the current working directory
+        # which can fail if the user has ended up with a cwd that is
+        # non-existent.
+        yield 'matplotlibrc'
+        try:
+            matplotlibrc = os.environ['MATPLOTLIBRC']
+        except KeyError:
+            pass
+        else:
+            yield matplotlibrc
+            yield os.path.join(matplotlibrc, 'matplotlibrc')
+        yield os.path.join(get_configdir(), 'matplotlibrc')
+        yield os.path.join(get_data_path(), 'matplotlibrc')
+
+    for fname in gen_candidates():
+        if os.path.exists(fname) and not os.path.isdir(fname):
+            return fname
+
+    raise RuntimeError("Could not find matplotlibrc file; your Matplotlib "
+                       "install is broken")
+
+
+# rcParams deprecated and automatically mapped to another key.
+# Values are tuples of (version, new_name, f_old2new, f_new2old).
+_deprecated_map = {}
+# rcParams deprecated; some can manually be mapped to another key.
+# Values are tuples of (version, new_name_or_None).
+_deprecated_ignore_map = {}
+# rcParams deprecated; can use None to suppress warnings; remain actually
+# listed in the rcParams.
+# Values are tuples of (version,)
+_deprecated_remain_as_none = {}
+
+
+@_docstring.Substitution(
+    "\n".join(map("- {}".format, sorted(rcsetup._validators, key=str.lower)))
+)
+class RcParams(MutableMapping, dict):
+    """
+    A dict-like key-value store for config parameters, including validation.
+
+    Validating functions are defined and associated with rc parameters in
+    :mod:`matplotlib.rcsetup`.
+
+    The list of rcParams is:
+
+    %s
+
+    See Also
+    --------
+    :ref:`customizing-with-matplotlibrc-files`
+    """
+
+    validate = rcsetup._validators
+
+    # validate values on the way in
+    def __init__(self, *args, **kwargs):
+        self.update(*args, **kwargs)
+
+    def _set(self, key, val):
+        """
+        Directly write data bypassing deprecation and validation logic.
+
+        Notes
+        -----
+        As end user or downstream library you almost always should use
+        ``rcParams[key] = val`` and not ``_set()``.
+
+        There are only very few special cases that need direct data access.
+        These cases previously used ``dict.__setitem__(rcParams, key, val)``,
+        which is now deprecated and replaced by ``rcParams._set(key, val)``.
+
+        Even though private, we guarantee API stability for ``rcParams._set``,
+        i.e. it is subject to Matplotlib's API and deprecation policy.
+
+        :meta public:
+        """
+        dict.__setitem__(self, key, val)
+
+    def _get(self, key):
+        """
+        Directly read data bypassing deprecation, backend and validation
+        logic.
+
+        Notes
+        -----
+        As end user or downstream library you almost always should use
+        ``val = rcParams[key]`` and not ``_get()``.
+
+        There are only very few special cases that need direct data access.
+        These cases previously used ``dict.__getitem__(rcParams, key, val)``,
+        which is now deprecated and replaced by ``rcParams._get(key)``.
+
+        Even though private, we guarantee API stability for ``rcParams._get``,
+        i.e. it is subject to Matplotlib's API and deprecation policy.
+
+        :meta public:
+        """
+        return dict.__getitem__(self, key)
+
+    def _update_raw(self, other_params):
+        """
+        Directly update the data from *other_params*, bypassing deprecation,
+        backend and validation logic on both sides.
+
+        This ``rcParams._update_raw(params)`` replaces the previous pattern
+        ``dict.update(rcParams, params)``.
+
+        Parameters
+        ----------
+        other_params : dict or `.RcParams`
+            The input mapping from which to update.
+        """
+        if isinstance(other_params, RcParams):
+            other_params = dict.items(other_params)
+        dict.update(self, other_params)
+
+    def _ensure_has_backend(self):
+        """
+        Ensure that a "backend" entry exists.
+
+        Normally, the default matplotlibrc file contains *no* entry for "backend" (the
+        corresponding line starts with ##, not #; we fill in _auto_backend_sentinel
+        in that case.  However, packagers can set a different default backend
+        (resulting in a normal `#backend: foo` line) in which case we should *not*
+        fill in _auto_backend_sentinel.
+        """
+        dict.setdefault(self, "backend", rcsetup._auto_backend_sentinel)
+
+    def __setitem__(self, key, val):
+        try:
+            if key in _deprecated_map:
+                version, alt_key, alt_val, inverse_alt = _deprecated_map[key]
+                _api.warn_deprecated(
+                    version, name=key, obj_type="rcparam", alternative=alt_key)
+                key = alt_key
+                val = alt_val(val)
+            elif key in _deprecated_remain_as_none and val is not None:
+                version, = _deprecated_remain_as_none[key]
+                _api.warn_deprecated(version, name=key, obj_type="rcparam")
+            elif key in _deprecated_ignore_map:
+                version, alt_key = _deprecated_ignore_map[key]
+                _api.warn_deprecated(
+                    version, name=key, obj_type="rcparam", alternative=alt_key)
+                return
+            elif key == 'backend':
+                if val is rcsetup._auto_backend_sentinel:
+                    if 'backend' in self:
+                        return
+            try:
+                cval = self.validate[key](val)
+            except ValueError as ve:
+                raise ValueError(f"Key {key}: {ve}") from None
+            self._set(key, cval)
+        except KeyError as err:
+            raise KeyError(
+                f"{key} is not a valid rc parameter (see rcParams.keys() for "
+                f"a list of valid parameters)") from err
+
+    def __getitem__(self, key):
+        if key in _deprecated_map:
+            version, alt_key, alt_val, inverse_alt = _deprecated_map[key]
+            _api.warn_deprecated(
+                version, name=key, obj_type="rcparam", alternative=alt_key)
+            return inverse_alt(self._get(alt_key))
+
+        elif key in _deprecated_ignore_map:
+            version, alt_key = _deprecated_ignore_map[key]
+            _api.warn_deprecated(
+                version, name=key, obj_type="rcparam", alternative=alt_key)
+            return self._get(alt_key) if alt_key else None
+
+        # In theory, this should only ever be used after the global rcParams
+        # has been set up, but better be safe e.g. in presence of breakpoints.
+        elif key == "backend" and self is globals().get("rcParams"):
+            val = self._get(key)
+            if val is rcsetup._auto_backend_sentinel:
+                from matplotlib import pyplot as plt
+                plt.switch_backend(rcsetup._auto_backend_sentinel)
+
+        return self._get(key)
+
+    def _get_backend_or_none(self):
+        """Get the requested backend, if any, without triggering resolution."""
+        backend = self._get("backend")
+        return None if backend is rcsetup._auto_backend_sentinel else backend
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        indent = len(class_name) + 1
+        with _api.suppress_matplotlib_deprecation_warning():
+            repr_split = pprint.pformat(dict(self), indent=1,
+                                        width=80 - indent).split('\n')
+        repr_indented = ('\n' + ' ' * indent).join(repr_split)
+        return f'{class_name}({repr_indented})'
+
+    def __str__(self):
+        return '\n'.join(map('{0[0]}: {0[1]}'.format, sorted(self.items())))
+
+    def __iter__(self):
+        """Yield sorted list of keys."""
+        with _api.suppress_matplotlib_deprecation_warning():
+            yield from sorted(dict.__iter__(self))
+
+    def __len__(self):
+        return dict.__len__(self)
+
+    def find_all(self, pattern):
+        """
+        Return the subset of this RcParams dictionary whose keys match,
+        using :func:`re.search`, the given ``pattern``.
+
+        .. note::
+
+            Changes to the returned dictionary are *not* propagated to
+            the parent RcParams dictionary.
+
+        """
+        pattern_re = re.compile(pattern)
+        return RcParams((key, value)
+                        for key, value in self.items()
+                        if pattern_re.search(key))
+
+    def copy(self):
+        """Copy this RcParams instance."""
+        rccopy = RcParams()
+        for k in self:  # Skip deprecations and revalidation.
+            rccopy._set(k, self._get(k))
+        return rccopy
+
+
+def rc_params(fail_on_error=False):
+    """Construct a `RcParams` instance from the default Matplotlib rc file."""
+    return rc_params_from_file(matplotlib_fname(), fail_on_error)
+
+
+@functools.cache
+def _get_ssl_context():
+    try:
+        import certifi
+    except ImportError:
+        _log.debug("Could not import certifi.")
+        return None
+    import ssl
+    return ssl.create_default_context(cafile=certifi.where())
+
+
+@contextlib.contextmanager
+def _open_file_or_url(fname):
+    if (isinstance(fname, str)
+            and fname.startswith(('http://', 'https://', 'ftp://', 'file:'))):
+        import urllib.request
+        ssl_ctx = _get_ssl_context()
+        if ssl_ctx is None:
+            _log.debug(
+                "Could not get certifi ssl context, https may not work."
+            )
+        with urllib.request.urlopen(fname, context=ssl_ctx) as f:
+            yield (line.decode('utf-8') for line in f)
+    else:
+        fname = os.path.expanduser(fname)
+        with open(fname, encoding='utf-8') as f:
+            yield f
+
+
+def _rc_params_in_file(fname, transform=lambda x: x, fail_on_error=False):
+    """
+    Construct a `RcParams` instance from file *fname*.
+
+    Unlike `rc_params_from_file`, the configuration class only contains the
+    parameters specified in the file (i.e. default values are not filled in).
+
+    Parameters
+    ----------
+    fname : path-like
+        The loaded file.
+    transform : callable, default: the identity function
+        A function called on each individual line of the file to transform it,
+        before further parsing.
+    fail_on_error : bool, default: False
+        Whether invalid entries should result in an exception or a warning.
+    """
+    import matplotlib as mpl
+    rc_temp = {}
+    with _open_file_or_url(fname) as fd:
+        try:
+            for line_no, line in enumerate(fd, 1):
+                line = transform(line)
+                strippedline = cbook._strip_comment(line)
+                if not strippedline:
+                    continue
+                tup = strippedline.split(':', 1)
+                if len(tup) != 2:
+                    _log.warning('Missing colon in file %r, line %d (%r)',
+                                 fname, line_no, line.rstrip('\n'))
+                    continue
+                key, val = tup
+                key = key.strip()
+                val = val.strip()
+                if val.startswith('"') and val.endswith('"'):
+                    val = val[1:-1]  # strip double quotes
+                if key in rc_temp:
+                    _log.warning('Duplicate key in file %r, line %d (%r)',
+                                 fname, line_no, line.rstrip('\n'))
+                rc_temp[key] = (val, line, line_no)
+        except UnicodeDecodeError:
+            _log.warning('Cannot decode configuration file %r as utf-8.',
+                         fname)
+            raise
+
+    config = RcParams()
+
+    for key, (val, line, line_no) in rc_temp.items():
+        if key in rcsetup._validators:
+            if fail_on_error:
+                config[key] = val  # try to convert to proper type or raise
+            else:
+                try:
+                    config[key] = val  # try to convert to proper type or skip
+                except Exception as msg:
+                    _log.warning('Bad value in file %r, line %d (%r): %s',
+                                 fname, line_no, line.rstrip('\n'), msg)
+        elif key in _deprecated_ignore_map:
+            version, alt_key = _deprecated_ignore_map[key]
+            _api.warn_deprecated(
+                version, name=key, alternative=alt_key, obj_type='rcparam',
+                addendum="Please update your matplotlibrc.")
+        else:
+            # __version__ must be looked up as an attribute to trigger the
+            # module-level __getattr__.
+            version = ('main' if '.post' in mpl.__version__
+                       else f'v{mpl.__version__}')
+            _log.warning("""
+Bad key %(key)s in file %(fname)s, line %(line_no)s (%(line)r)
+You probably need to get an updated matplotlibrc file from
+https://github.com/matplotlib/matplotlib/blob/%(version)s/lib/matplotlib/mpl-data/matplotlibrc
+or from the matplotlib source distribution""",
+                         dict(key=key, fname=fname, line_no=line_no,
+                              line=line.rstrip('\n'), version=version))
+    return config
+
+
+def rc_params_from_file(fname, fail_on_error=False, use_default_template=True):
+    """
+    Construct a `RcParams` from file *fname*.
+
+    Parameters
+    ----------
+    fname : str or path-like
+        A file with Matplotlib rc settings.
+    fail_on_error : bool
+        If True, raise an error when the parser fails to convert a parameter.
+    use_default_template : bool
+        If True, initialize with default parameters before updating with those
+        in the given file. If False, the configuration class only contains the
+        parameters specified in the file. (Useful for updating dicts.)
+    """
+    config_from_file = _rc_params_in_file(fname, fail_on_error=fail_on_error)
+
+    if not use_default_template:
+        return config_from_file
+
+    with _api.suppress_matplotlib_deprecation_warning():
+        config = RcParams({**rcParamsDefault, **config_from_file})
+
+    if "".join(config['text.latex.preamble']):
+        _log.info("""
+*****************************************************************
+You have the following UNSUPPORTED LaTeX preamble customizations:
+%s
+Please do not ask for support with these customizations active.
+*****************************************************************
+""", '\n'.join(config['text.latex.preamble']))
+    _log.debug('loaded rc file %s', fname)
+
+    return config
+
+
+rcParamsDefault = _rc_params_in_file(
+    cbook._get_data_path("matplotlibrc"),
+    # Strip leading comment.
+    transform=lambda line: line[1:] if line.startswith("#") else line,
+    fail_on_error=True)
+rcParamsDefault._update_raw(rcsetup._hardcoded_defaults)
+rcParamsDefault._ensure_has_backend()
+
+rcParams = RcParams()  # The global instance.
+rcParams._update_raw(rcParamsDefault)
+rcParams._update_raw(_rc_params_in_file(matplotlib_fname()))
+rcParamsOrig = rcParams.copy()
+with _api.suppress_matplotlib_deprecation_warning():
+    # This also checks that all rcParams are indeed listed in the template.
+    # Assigning to rcsetup.defaultParams is left only for backcompat.
+    defaultParams = rcsetup.defaultParams = {
+        # We want to resolve deprecated rcParams, but not backend...
+        key: [(rcsetup._auto_backend_sentinel if key == "backend" else
+               rcParamsDefault[key]),
+              validator]
+        for key, validator in rcsetup._validators.items()}
+if rcParams['axes.formatter.use_locale']:
+    locale.setlocale(locale.LC_ALL, '')
+
+
+def rc(group, **kwargs):
+    """
+    Set the current `.rcParams`.  *group* is the grouping for the rc, e.g.,
+    for ``lines.linewidth`` the group is ``lines``, for
+    ``axes.facecolor``, the group is ``axes``, and so on.  Group may
+    also be a list or tuple of group names, e.g., (*xtick*, *ytick*).
+    *kwargs* is a dictionary attribute name/value pairs, e.g.,::
+
+      rc('lines', linewidth=2, color='r')
+
+    sets the current `.rcParams` and is equivalent to::
+
+      rcParams['lines.linewidth'] = 2
+      rcParams['lines.color'] = 'r'
+
+    The following aliases are available to save typing for interactive users:
+
+    =====   =================
+    Alias   Property
+    =====   =================
+    'lw'    'linewidth'
+    'ls'    'linestyle'
+    'c'     'color'
+    'fc'    'facecolor'
+    'ec'    'edgecolor'
+    'mew'   'markeredgewidth'
+    'aa'    'antialiased'
+    =====   =================
+
+    Thus you could abbreviate the above call as::
+
+          rc('lines', lw=2, c='r')
+
+    Note you can use python's kwargs dictionary facility to store
+    dictionaries of default parameters.  e.g., you can customize the
+    font rc as follows::
+
+      font = {'family' : 'monospace',
+              'weight' : 'bold',
+              'size'   : 'larger'}
+      rc('font', **font)  # pass in the font dict as kwargs
+
+    This enables you to easily switch between several configurations.  Use
+    ``matplotlib.style.use('default')`` or :func:`~matplotlib.rcdefaults` to
+    restore the default `.rcParams` after changes.
+
+    Notes
+    -----
+    Similar functionality is available by using the normal dict interface, i.e.
+    ``rcParams.update({"lines.linewidth": 2, ...})`` (but ``rcParams.update``
+    does not support abbreviations or grouping).
+    """
+
+    aliases = {
+        'lw':  'linewidth',
+        'ls':  'linestyle',
+        'c':   'color',
+        'fc':  'facecolor',
+        'ec':  'edgecolor',
+        'mew': 'markeredgewidth',
+        'aa':  'antialiased',
+        }
+
+    if isinstance(group, str):
+        group = (group,)
+    for g in group:
+        for k, v in kwargs.items():
+            name = aliases.get(k) or k
+            key = f'{g}.{name}'
+            try:
+                rcParams[key] = v
+            except KeyError as err:
+                raise KeyError(('Unrecognized key "%s" for group "%s" and '
+                                'name "%s"') % (key, g, name)) from err
+
+
+def rcdefaults():
+    """
+    Restore the `.rcParams` from Matplotlib's internal default style.
+
+    Style-blacklisted `.rcParams` (defined in
+    ``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
+
+    See Also
+    --------
+    matplotlib.rc_file_defaults
+        Restore the `.rcParams` from the rc file originally loaded by
+        Matplotlib.
+    matplotlib.style.use
+        Use a specific style file.  Call ``style.use('default')`` to restore
+        the default style.
+    """
+    # Deprecation warnings were already handled when creating rcParamsDefault,
+    # no need to reemit them here.
+    with _api.suppress_matplotlib_deprecation_warning():
+        from .style.core import STYLE_BLACKLIST
+        rcParams.clear()
+        rcParams.update({k: v for k, v in rcParamsDefault.items()
+                         if k not in STYLE_BLACKLIST})
+
+
+def rc_file_defaults():
+    """
+    Restore the `.rcParams` from the original rc file loaded by Matplotlib.
+
+    Style-blacklisted `.rcParams` (defined in
+    ``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
+    """
+    # Deprecation warnings were already handled when creating rcParamsOrig, no
+    # need to reemit them here.
+    with _api.suppress_matplotlib_deprecation_warning():
+        from .style.core import STYLE_BLACKLIST
+        rcParams.update({k: rcParamsOrig[k] for k in rcParamsOrig
+                         if k not in STYLE_BLACKLIST})
+
+
+def rc_file(fname, *, use_default_template=True):
+    """
+    Update `.rcParams` from file.
+
+    Style-blacklisted `.rcParams` (defined in
+    ``matplotlib.style.core.STYLE_BLACKLIST``) are not updated.
+
+    Parameters
+    ----------
+    fname : str or path-like
+        A file with Matplotlib rc settings.
+
+    use_default_template : bool
+        If True, initialize with default parameters before updating with those
+        in the given file. If False, the current configuration persists
+        and only the parameters specified in the file are updated.
+    """
+    # Deprecation warnings were already handled in rc_params_from_file, no need
+    # to reemit them here.
+    with _api.suppress_matplotlib_deprecation_warning():
+        from .style.core import STYLE_BLACKLIST
+        rc_from_file = rc_params_from_file(
+            fname, use_default_template=use_default_template)
+        rcParams.update({k: rc_from_file[k] for k in rc_from_file
+                         if k not in STYLE_BLACKLIST})
+
+
+@contextlib.contextmanager
+def rc_context(rc=None, fname=None):
+    """
+    Return a context manager for temporarily changing rcParams.
+
+    The :rc:`backend` will not be reset by the context manager.
+
+    rcParams changed both through the context manager invocation and
+    in the body of the context will be reset on context exit.
+
+    Parameters
+    ----------
+    rc : dict
+        The rcParams to temporarily set.
+    fname : str or path-like
+        A file with Matplotlib rc settings. If both *fname* and *rc* are given,
+        settings from *rc* take precedence.
+
+    See Also
+    --------
+    :ref:`customizing-with-matplotlibrc-files`
+
+    Examples
+    --------
+    Passing explicit values via a dict::
+
+        with mpl.rc_context({'interactive': False}):
+            fig, ax = plt.subplots()
+            ax.plot(range(3), range(3))
+            fig.savefig('example.png')
+            plt.close(fig)
+
+    Loading settings from a file::
+
+         with mpl.rc_context(fname='print.rc'):
+             plt.plot(x, y)  # uses 'print.rc'
+
+    Setting in the context body::
+
+        with mpl.rc_context():
+            # will be reset
+            mpl.rcParams['lines.linewidth'] = 5
+            plt.plot(x, y)
+
+    """
+    orig = dict(rcParams.copy())
+    del orig['backend']
+    try:
+        if fname:
+            rc_file(fname)
+        if rc:
+            rcParams.update(rc)
+        yield
+    finally:
+        rcParams._update_raw(orig)  # Revert to the original rcs.
+
+
+def use(backend, *, force=True):
+    """
+    Select the backend used for rendering and GUI integration.
+
+    If pyplot is already imported, `~matplotlib.pyplot.switch_backend` is used
+    and if the new backend is different than the current backend, all Figures
+    will be closed.
+
+    Parameters
+    ----------
+    backend : str
+        The backend to switch to.  This can either be one of the standard
+        backend names, which are case-insensitive:
+
+        - interactive backends:
+          GTK3Agg, GTK3Cairo, GTK4Agg, GTK4Cairo, MacOSX, nbAgg, notebook, QtAgg,
+          QtCairo, TkAgg, TkCairo, WebAgg, WX, WXAgg, WXCairo, Qt5Agg, Qt5Cairo
+
+        - non-interactive backends:
+          agg, cairo, pdf, pgf, ps, svg, template
+
+        or a string of the form: ``module://my.module.name``.
+
+        notebook is a synonym for nbAgg.
+
+        Switching to an interactive backend is not possible if an unrelated
+        event loop has already been started (e.g., switching to GTK3Agg if a
+        TkAgg window has already been opened).  Switching to a non-interactive
+        backend is always possible.
+
+    force : bool, default: True
+        If True (the default), raise an `ImportError` if the backend cannot be
+        set up (either because it fails to import, or because an incompatible
+        GUI interactive framework is already running); if False, silently
+        ignore the failure.
+
+    See Also
+    --------
+    :ref:`backends`
+    matplotlib.get_backend
+    matplotlib.pyplot.switch_backend
+
+    """
+    name = rcsetup.validate_backend(backend)
+    # don't (prematurely) resolve the "auto" backend setting
+    if rcParams._get_backend_or_none() == name:
+        # Nothing to do if the requested backend is already set
+        pass
+    else:
+        # if pyplot is not already imported, do not import it.  Doing
+        # so may trigger a `plt.switch_backend` to the _default_ backend
+        # before we get a chance to change to the one the user just requested
+        plt = sys.modules.get('matplotlib.pyplot')
+        # if pyplot is imported, then try to change backends
+        if plt is not None:
+            try:
+                # we need this import check here to re-raise if the
+                # user does not have the libraries to support their
+                # chosen backend installed.
+                plt.switch_backend(name)
+            except ImportError:
+                if force:
+                    raise
+        # if we have not imported pyplot, then we can set the rcParam
+        # value which will be respected when the user finally imports
+        # pyplot
+        else:
+            rcParams['backend'] = backend
+    # if the user has asked for a given backend, do not helpfully
+    # fallback
+    rcParams['backend_fallback'] = False
+
+
+if os.environ.get('MPLBACKEND'):
+    rcParams['backend'] = os.environ.get('MPLBACKEND')
+
+
+def get_backend(*, auto_select=True):
+    """
+    Return the name of the current backend.
+
+    Parameters
+    ----------
+    auto_select : bool, default: True
+        Whether to trigger backend resolution if no backend has been
+        selected so far. If True, this ensures that a valid backend
+        is returned. If False, this returns None if no backend has been
+        selected so far.
+
+        .. versionadded:: 3.10
+
+        .. admonition:: Provisional
+
+           The *auto_select* flag is provisional. It may be changed or removed
+           without prior warning.
+
+    See Also
+    --------
+    matplotlib.use
+    """
+    if auto_select:
+        return rcParams['backend']
+    else:
+        backend = rcParams._get('backend')
+        if backend is rcsetup._auto_backend_sentinel:
+            return None
+        else:
+            return backend
+
+
+def interactive(b):
+    """
+    Set whether to redraw after every plotting command (e.g. `.pyplot.xlabel`).
+    """
+    rcParams['interactive'] = b
+
+
+def is_interactive():
+    """
+    Return whether to redraw after every plotting command.
+
+    .. note::
+
+        This function is only intended for use in backends. End users should
+        use `.pyplot.isinteractive` instead.
+    """
+    return rcParams['interactive']
+
+
+def _val_or_rc(val, rc_name):
+    """
+    If *val* is None, return ``mpl.rcParams[rc_name]``, otherwise return val.
+    """
+    return val if val is not None else rcParams[rc_name]
+
+
+def _init_tests():
+    # The version of FreeType to install locally for running the tests. This must match
+    # the value in `meson.build`.
+    LOCAL_FREETYPE_VERSION = '2.6.1'
+
+    from matplotlib import ft2font
+    if (ft2font.__freetype_version__ != LOCAL_FREETYPE_VERSION or
+            ft2font.__freetype_build_type__ != 'local'):
+        _log.warning(
+            "Matplotlib is not built with the correct FreeType version to run tests.  "
+            "Rebuild without setting system-freetype=true in Meson setup options.  "
+            "Expect many image comparison failures below.  "
+            "Expected freetype version %s.  "
+            "Found freetype version %s.  "
+            "Freetype build type is %slocal.",
+            LOCAL_FREETYPE_VERSION,
+            ft2font.__freetype_version__,
+            "" if ft2font.__freetype_build_type__ == 'local' else "not ")
+
+
+def _replacer(data, value):
+    """
+    Either returns ``data[value]`` or passes ``data`` back, converts either to
+    a sequence.
+    """
+    try:
+        # if key isn't a string don't bother
+        if isinstance(value, str):
+            # try to use __getitem__
+            value = data[value]
+    except Exception:
+        # key does not exist, silently fall back to key
+        pass
+    return cbook.sanitize_sequence(value)
+
+
+def _label_from_arg(y, default_name):
+    try:
+        return y.name
+    except AttributeError:
+        if isinstance(default_name, str):
+            return default_name
+    return None
+
+
+def _add_data_doc(docstring, replace_names):
+    """
+    Add documentation for a *data* field to the given docstring.
+
+    Parameters
+    ----------
+    docstring : str
+        The input docstring.
+    replace_names : list of str or None
+        The list of parameter names which arguments should be replaced by
+        ``data[name]`` (if ``data[name]`` does not throw an exception).  If
+        None, replacement is attempted for all arguments.
+
+    Returns
+    -------
+    str
+        The augmented docstring.
+    """
+    if (docstring is None
+            or replace_names is not None and len(replace_names) == 0):
+        return docstring
+    docstring = inspect.cleandoc(docstring)
+
+    data_doc = ("""\
+    If given, all parameters also accept a string ``s``, which is
+    interpreted as ``data[s]`` if ``s`` is a key in ``data``."""
+                if replace_names is None else f"""\
+    If given, the following parameters also accept a string ``s``, which is
+    interpreted as ``data[s]`` if ``s`` is a key in ``data``:
+
+    {', '.join(map('*{}*'.format, replace_names))}""")
+    # using string replacement instead of formatting has the advantages
+    # 1) simpler indent handling
+    # 2) prevent problems with formatting characters '{', '%' in the docstring
+    if _log.level <= logging.DEBUG:
+        # test_data_parameter_replacement() tests against these log messages
+        # make sure to keep message and test in sync
+        if "data : indexable object, optional" not in docstring:
+            _log.debug("data parameter docstring error: no data parameter")
+        if 'DATA_PARAMETER_PLACEHOLDER' not in docstring:
+            _log.debug("data parameter docstring error: missing placeholder")
+    return docstring.replace('    DATA_PARAMETER_PLACEHOLDER', data_doc)
+
+
+def _preprocess_data(func=None, *, replace_names=None, label_namer=None):
+    """
+    A decorator to add a 'data' kwarg to a function.
+
+    When applied::
+
+        @_preprocess_data()
+        def func(ax, *args, **kwargs): ...
+
+    the signature is modified to ``decorated(ax, *args, data=None, **kwargs)``
+    with the following behavior:
+
+    - if called with ``data=None``, forward the other arguments to ``func``;
+    - otherwise, *data* must be a mapping; for any argument passed in as a
+      string ``name``, replace the argument by ``data[name]`` (if this does not
+      throw an exception), then forward the arguments to ``func``.
+
+    In either case, any argument that is a `MappingView` is also converted to a
+    list.
+
+    Parameters
+    ----------
+    replace_names : list of str or None, default: None
+        The list of parameter names for which lookup into *data* should be
+        attempted. If None, replacement is attempted for all arguments.
+    label_namer : str, default: None
+        If set e.g. to "namer" (which must be a kwarg in the function's
+        signature -- not as ``**kwargs``), if the *namer* argument passed in is
+        a (string) key of *data* and no *label* kwarg is passed, then use the
+        (string) value of the *namer* as *label*. ::
+
+            @_preprocess_data(label_namer="foo")
+            def func(foo, label=None): ...
+
+            func("key", data={"key": value})
+            # is equivalent to
+            func.__wrapped__(value, label="key")
+    """
+
+    if func is None:  # Return the actual decorator.
+        return functools.partial(
+            _preprocess_data,
+            replace_names=replace_names, label_namer=label_namer)
+
+    sig = inspect.signature(func)
+    varargs_name = None
+    varkwargs_name = None
+    arg_names = []
+    params = list(sig.parameters.values())
+    for p in params:
+        if p.kind is Parameter.VAR_POSITIONAL:
+            varargs_name = p.name
+        elif p.kind is Parameter.VAR_KEYWORD:
+            varkwargs_name = p.name
+        else:
+            arg_names.append(p.name)
+    data_param = Parameter("data", Parameter.KEYWORD_ONLY, default=None)
+    if varkwargs_name:
+        params.insert(-1, data_param)
+    else:
+        params.append(data_param)
+    new_sig = sig.replace(parameters=params)
+    arg_names = arg_names[1:]  # remove the first "ax" / self arg
+
+    assert {*arg_names}.issuperset(replace_names or []) or varkwargs_name, (
+        "Matplotlib internal error: invalid replace_names "
+        f"({replace_names!r}) for {func.__name__!r}")
+    assert label_namer is None or label_namer in arg_names, (
+        "Matplotlib internal error: invalid label_namer "
+        f"({label_namer!r}) for {func.__name__!r}")
+
+    @functools.wraps(func)
+    def inner(ax, *args, data=None, **kwargs):
+        if data is None:
+            return func(
+                ax,
+                *map(cbook.sanitize_sequence, args),
+                **{k: cbook.sanitize_sequence(v) for k, v in kwargs.items()})
+
+        bound = new_sig.bind(ax, *args, **kwargs)
+        auto_label = (bound.arguments.get(label_namer)
+                      or bound.kwargs.get(label_namer))
+
+        for k, v in bound.arguments.items():
+            if k == varkwargs_name:
+                for k1, v1 in v.items():
+                    if replace_names is None or k1 in replace_names:
+                        v[k1] = _replacer(data, v1)
+            elif k == varargs_name:
+                if replace_names is None:
+                    bound.arguments[k] = tuple(_replacer(data, v1) for v1 in v)
+            else:
+                if replace_names is None or k in replace_names:
+                    bound.arguments[k] = _replacer(data, v)
+
+        new_args = bound.args
+        new_kwargs = bound.kwargs
+
+        args_and_kwargs = {**bound.arguments, **bound.kwargs}
+        if label_namer and "label" not in args_and_kwargs:
+            new_kwargs["label"] = _label_from_arg(
+                args_and_kwargs.get(label_namer), auto_label)
+
+        return func(*new_args, **new_kwargs)
+
+    inner.__doc__ = _add_data_doc(inner.__doc__, replace_names)
+    inner.__signature__ = new_sig
+    return inner
+
+
+_log.debug('interactive is %s', is_interactive())
+_log.debug('platform is %s', sys.platform)
+
+
+@_api.deprecated("3.10", alternative="matplotlib.cbook.sanitize_sequence")
+def sanitize_sequence(data):
+    return cbook.sanitize_sequence(data)
+
+
+@_api.deprecated("3.10", alternative="matplotlib.rcsetup.validate_backend")
+def validate_backend(s):
+    return rcsetup.validate_backend(s)
+
+
+# workaround: we must defer colormaps import to after loading rcParams, because
+# colormap creation depends on rcParams
+from matplotlib.cm import _colormaps as colormaps  # noqa: E402
+from matplotlib.cm import _multivar_colormaps as multivar_colormaps  # noqa: E402
+from matplotlib.cm import _bivar_colormaps as bivar_colormaps  # noqa: E402
+from matplotlib.colors import _color_sequences as color_sequences  # noqa: E402

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/__init__.pyi

@@ -0,0 +1,124 @@
+__all__ = [
+    "__bibtex__",
+    "__version__",
+    "__version_info__",
+    "set_loglevel",
+    "ExecutableNotFoundError",
+    "get_configdir",
+    "get_cachedir",
+    "get_data_path",
+    "matplotlib_fname",
+    "MatplotlibDeprecationWarning",
+    "RcParams",
+    "rc_params",
+    "rc_params_from_file",
+    "rcParamsDefault",
+    "rcParams",
+    "rcParamsOrig",
+    "defaultParams",
+    "rc",
+    "rcdefaults",
+    "rc_file_defaults",
+    "rc_file",
+    "rc_context",
+    "use",
+    "get_backend",
+    "interactive",
+    "is_interactive",
+    "colormaps",
+    "color_sequences",
+]
+
+import os
+from pathlib import Path
+
+from collections.abc import Callable, Generator
+import contextlib
+from packaging.version import Version
+
+from matplotlib._api import MatplotlibDeprecationWarning
+from typing import Any, Literal, NamedTuple, overload
+
+class _VersionInfo(NamedTuple):
+    major: int
+    minor: int
+    micro: int
+    releaselevel: str
+    serial: int
+
+__bibtex__: str
+__version__: str
+__version_info__: _VersionInfo
+
+def set_loglevel(level: str) -> None: ...
+
+class _ExecInfo(NamedTuple):
+    executable: str
+    raw_version: str
+    version: Version
+
+class ExecutableNotFoundError(FileNotFoundError): ...
+
+def _get_executable_info(name: str) -> _ExecInfo: ...
+def get_configdir() -> str: ...
+def get_cachedir() -> str: ...
+def get_data_path() -> str: ...
+def matplotlib_fname() -> str: ...
+
+class RcParams(dict[str, Any]):
+    validate: dict[str, Callable]
+    def __init__(self, *args, **kwargs) -> None: ...
+    def _set(self, key: str, val: Any) -> None: ...
+    def _get(self, key: str) -> Any: ...
+
+    def _update_raw(self, other_params: dict | RcParams) -> None: ...
+
+    def _ensure_has_backend(self) -> None: ...
+    def __setitem__(self, key: str, val: Any) -> None: ...
+    def __getitem__(self, key: str) -> Any: ...
+    def __iter__(self) -> Generator[str, None, None]: ...
+    def __len__(self) -> int: ...
+    def find_all(self, pattern: str) -> RcParams: ...
+    def copy(self) -> RcParams: ...
+
+def rc_params(fail_on_error: bool = ...) -> RcParams: ...
+def rc_params_from_file(
+    fname: str | Path | os.PathLike,
+    fail_on_error: bool = ...,
+    use_default_template: bool = ...,
+) -> RcParams: ...
+
+rcParamsDefault: RcParams
+rcParams: RcParams
+rcParamsOrig: RcParams
+defaultParams: dict[str, Any]
+
+def rc(group: str, **kwargs) -> None: ...
+def rcdefaults() -> None: ...
+def rc_file_defaults() -> None: ...
+def rc_file(
+    fname: str | Path | os.PathLike, *, use_default_template: bool = ...
+) -> None: ...
+@contextlib.contextmanager
+def rc_context(
+    rc: dict[str, Any] | None = ..., fname: str | Path | os.PathLike | None = ...
+) -> Generator[None, None, None]: ...
+def use(backend: str, *, force: bool = ...) -> None: ...
+@overload
+def get_backend(*, auto_select: Literal[True] = True) -> str: ...
+@overload
+def get_backend(*, auto_select: Literal[False]) -> str | None: ...
+def interactive(b: bool) -> None: ...
+def is_interactive() -> bool: ...
+
+def _preprocess_data(
+    func: Callable | None = ...,
+    *,
+    replace_names: list[str] | None = ...,
+    label_namer: str | None = ...
+) -> Callable: ...
+
+from matplotlib.cm import _colormaps as colormaps  # noqa: E402
+from matplotlib.cm import _multivar_colormaps as multivar_colormaps  # noqa: E402
+from matplotlib.cm import _bivar_colormaps as bivar_colormaps  # noqa: E402
+from matplotlib.colors import _color_sequences as color_sequences  # noqa: E402

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_afm.py

@@ -0,0 +1,532 @@
+"""
+A python interface to Adobe Font Metrics Files.
+
+Although a number of other Python implementations exist, and may be more
+complete than this, it was decided not to go with them because they were
+either:
+
+1) copyrighted or used a non-BSD compatible license
+2) had too many dependencies and a free standing lib was needed
+3) did more than needed and it was easier to write afresh rather than
+   figure out how to get just what was needed.
+
+It is pretty easy to use, and has no external dependencies:
+
+>>> import matplotlib as mpl
+>>> from pathlib import Path
+>>> afm_path = Path(mpl.get_data_path(), 'fonts', 'afm', 'ptmr8a.afm')
+>>>
+>>> from matplotlib.afm import AFM
+>>> with afm_path.open('rb') as fh:
+...     afm = AFM(fh)
+>>> afm.string_width_height('What the heck?')
+(6220.0, 694)
+>>> afm.get_fontname()
+'Times-Roman'
+>>> afm.get_kern_dist('A', 'f')
+0
+>>> afm.get_kern_dist('A', 'y')
+-92.0
+>>> afm.get_bbox_char('!')
+[130, -9, 238, 676]
+
+As in the Adobe Font Metrics File Format Specification, all dimensions
+are given in units of 1/1000 of the scale factor (point size) of the font
+being used.
+"""
+
+from collections import namedtuple
+import logging
+import re
+
+from ._mathtext_data import uni2type1
+
+
+_log = logging.getLogger(__name__)
+
+
+def _to_int(x):
+    # Some AFM files have floats where we are expecting ints -- there is
+    # probably a better way to handle this (support floats, round rather than
+    # truncate).  But I don't know what the best approach is now and this
+    # change to _to_int should at least prevent Matplotlib from crashing on
+    # these.  JDH (2009-11-06)
+    return int(float(x))
+
+
+def _to_float(x):
+    # Some AFM files use "," instead of "." as decimal separator -- this
+    # shouldn't be ambiguous (unless someone is wicked enough to use "," as
+    # thousands separator...).
+    if isinstance(x, bytes):
+        # Encoding doesn't really matter -- if we have codepoints >127 the call
+        # to float() will error anyways.
+        x = x.decode('latin-1')
+    return float(x.replace(',', '.'))
+
+
+def _to_str(x):
+    return x.decode('utf8')
+
+
+def _to_list_of_ints(s):
+    s = s.replace(b',', b' ')
+    return [_to_int(val) for val in s.split()]
+
+
+def _to_list_of_floats(s):
+    return [_to_float(val) for val in s.split()]
+
+
+def _to_bool(s):
+    if s.lower().strip() in (b'false', b'0', b'no'):
+        return False
+    else:
+        return True
+
+
+def _parse_header(fh):
+    """
+    Read the font metrics header (up to the char metrics) and returns
+    a dictionary mapping *key* to *val*.  *val* will be converted to the
+    appropriate python type as necessary; e.g.:
+
+        * 'False'->False
+        * '0'->0
+        * '-168 -218 1000 898'-> [-168, -218, 1000, 898]
+
+    Dictionary keys are
+
+      StartFontMetrics, FontName, FullName, FamilyName, Weight,
+      ItalicAngle, IsFixedPitch, FontBBox, UnderlinePosition,
+      UnderlineThickness, Version, Notice, EncodingScheme, CapHeight,
+      XHeight, Ascender, Descender, StartCharMetrics
+    """
+    header_converters = {
+        b'StartFontMetrics': _to_float,
+        b'FontName': _to_str,
+        b'FullName': _to_str,
+        b'FamilyName': _to_str,
+        b'Weight': _to_str,
+        b'ItalicAngle': _to_float,
+        b'IsFixedPitch': _to_bool,
+        b'FontBBox': _to_list_of_ints,
+        b'UnderlinePosition': _to_float,
+        b'UnderlineThickness': _to_float,
+        b'Version': _to_str,
+        # Some AFM files have non-ASCII characters (which are not allowed by
+        # the spec).  Given that there is actually no public API to even access
+        # this field, just return it as straight bytes.
+        b'Notice': lambda x: x,
+        b'EncodingScheme': _to_str,
+        b'CapHeight': _to_float,  # Is the second version a mistake, or
+        b'Capheight': _to_float,  # do some AFM files contain 'Capheight'? -JKS
+        b'XHeight': _to_float,
+        b'Ascender': _to_float,
+        b'Descender': _to_float,
+        b'StdHW': _to_float,
+        b'StdVW': _to_float,
+        b'StartCharMetrics': _to_int,
+        b'CharacterSet': _to_str,
+        b'Characters': _to_int,
+    }
+    d = {}
+    first_line = True
+    for line in fh:
+        line = line.rstrip()
+        if line.startswith(b'Comment'):
+            continue
+        lst = line.split(b' ', 1)
+        key = lst[0]
+        if first_line:
+            # AFM spec, Section 4: The StartFontMetrics keyword
+            # [followed by a version number] must be the first line in
+            # the file, and the EndFontMetrics keyword must be the
+            # last non-empty line in the file.  We just check the
+            # first header entry.
+            if key != b'StartFontMetrics':
+                raise RuntimeError('Not an AFM file')
+            first_line = False
+        if len(lst) == 2:
+            val = lst[1]
+        else:
+            val = b''
+        try:
+            converter = header_converters[key]
+        except KeyError:
+            _log.error("Found an unknown keyword in AFM header (was %r)", key)
+            continue
+        try:
+            d[key] = converter(val)
+        except ValueError:
+            _log.error('Value error parsing header in AFM: %s, %s', key, val)
+            continue
+        if key == b'StartCharMetrics':
+            break
+    else:
+        raise RuntimeError('Bad parse')
+    return d
+
+
+CharMetrics = namedtuple('CharMetrics', 'width, name, bbox')
+CharMetrics.__doc__ = """
+    Represents the character metrics of a single character.
+
+    Notes
+    -----
+    The fields do currently only describe a subset of character metrics
+    information defined in the AFM standard.
+    """
+CharMetrics.width.__doc__ = """The character width (WX)."""
+CharMetrics.name.__doc__ = """The character name (N)."""
+CharMetrics.bbox.__doc__ = """
+    The bbox of the character (B) as a tuple (*llx*, *lly*, *urx*, *ury*)."""
+
+
+def _parse_char_metrics(fh):
+    """
+    Parse the given filehandle for character metrics information and return
+    the information as dicts.
+
+    It is assumed that the file cursor is on the line behind
+    'StartCharMetrics'.
+
+    Returns
+    -------
+    ascii_d : dict
+         A mapping "ASCII num of the character" to `.CharMetrics`.
+    name_d : dict
+         A mapping "character name" to `.CharMetrics`.
+
+    Notes
+    -----
+    This function is incomplete per the standard, but thus far parses
+    all the sample afm files tried.
+    """
+    required_keys = {'C', 'WX', 'N', 'B'}
+
+    ascii_d = {}
+    name_d = {}
+    for line in fh:
+        # We are defensively letting values be utf8. The spec requires
+        # ascii, but there are non-compliant fonts in circulation
+        line = _to_str(line.rstrip())  # Convert from byte-literal
+        if line.startswith('EndCharMetrics'):
+            return ascii_d, name_d
+        # Split the metric line into a dictionary, keyed by metric identifiers
+        vals = dict(s.strip().split(' ', 1) for s in line.split(';') if s)
+        # There may be other metrics present, but only these are needed
+        if not required_keys.issubset(vals):
+            raise RuntimeError('Bad char metrics line: %s' % line)
+        num = _to_int(vals['C'])
+        wx = _to_float(vals['WX'])
+        name = vals['N']
+        bbox = _to_list_of_floats(vals['B'])
+        bbox = list(map(int, bbox))
+        metrics = CharMetrics(wx, name, bbox)
+        # Workaround: If the character name is 'Euro', give it the
+        # corresponding character code, according to WinAnsiEncoding (see PDF
+        # Reference).
+        if name == 'Euro':
+            num = 128
+        elif name == 'minus':
+            num = ord("\N{MINUS SIGN}")  # 0x2212
+        if num != -1:
+            ascii_d[num] = metrics
+        name_d[name] = metrics
+    raise RuntimeError('Bad parse')
+
+
+def _parse_kern_pairs(fh):
+    """
+    Return a kern pairs dictionary; keys are (*char1*, *char2*) tuples and
+    values are the kern pair value.  For example, a kern pairs line like
+    ``KPX A y -50``
+
+    will be represented as::
+
+      d[ ('A', 'y') ] = -50
+
+    """
+
+    line = next(fh)
+    if not line.startswith(b'StartKernPairs'):
+        raise RuntimeError('Bad start of kern pairs data: %s' % line)
+
+    d = {}
+    for line in fh:
+        line = line.rstrip()
+        if not line:
+            continue
+        if line.startswith(b'EndKernPairs'):
+            next(fh)  # EndKernData
+            return d
+        vals = line.split()
+        if len(vals) != 4 or vals[0] != b'KPX':
+            raise RuntimeError('Bad kern pairs line: %s' % line)
+        c1, c2, val = _to_str(vals[1]), _to_str(vals[2]), _to_float(vals[3])
+        d[(c1, c2)] = val
+    raise RuntimeError('Bad kern pairs parse')
+
+
+CompositePart = namedtuple('CompositePart', 'name, dx, dy')
+CompositePart.__doc__ = """
+    Represents the information on a composite element of a composite char."""
+CompositePart.name.__doc__ = """Name of the part, e.g. 'acute'."""
+CompositePart.dx.__doc__ = """x-displacement of the part from the origin."""
+CompositePart.dy.__doc__ = """y-displacement of the part from the origin."""
+
+
+def _parse_composites(fh):
+    """
+    Parse the given filehandle for composites information return them as a
+    dict.
+
+    It is assumed that the file cursor is on the line behind 'StartComposites'.
+
+    Returns
+    -------
+    dict
+        A dict mapping composite character names to a parts list. The parts
+        list is a list of `.CompositePart` entries describing the parts of
+        the composite.
+
+    Examples
+    --------
+    A composite definition line::
+
+      CC Aacute 2 ; PCC A 0 0 ; PCC acute 160 170 ;
+
+    will be represented as::
+
+      composites['Aacute'] = [CompositePart(name='A', dx=0, dy=0),
+                              CompositePart(name='acute', dx=160, dy=170)]
+
+    """
+    composites = {}
+    for line in fh:
+        line = line.rstrip()
+        if not line:
+            continue
+        if line.startswith(b'EndComposites'):
+            return composites
+        vals = line.split(b';')
+        cc = vals[0].split()
+        name, _num_parts = cc[1], _to_int(cc[2])
+        pccParts = []
+        for s in vals[1:-1]:
+            pcc = s.split()
+            part = CompositePart(pcc[1], _to_float(pcc[2]), _to_float(pcc[3]))
+            pccParts.append(part)
+        composites[name] = pccParts
+
+    raise RuntimeError('Bad composites parse')
+
+
+def _parse_optional(fh):
+    """
+    Parse the optional fields for kern pair data and composites.
+
+    Returns
+    -------
+    kern_data : dict
+        A dict containing kerning information. May be empty.
+        See `._parse_kern_pairs`.
+    composites : dict
+        A dict containing composite information. May be empty.
+        See `._parse_composites`.
+    """
+    optional = {
+        b'StartKernData': _parse_kern_pairs,
+        b'StartComposites':  _parse_composites,
+        }
+
+    d = {b'StartKernData': {},
+         b'StartComposites': {}}
+    for line in fh:
+        line = line.rstrip()
+        if not line:
+            continue
+        key = line.split()[0]
+
+        if key in optional:
+            d[key] = optional[key](fh)
+
+    return d[b'StartKernData'], d[b'StartComposites']
+
+
+class AFM:
+
+    def __init__(self, fh):
+        """Parse the AFM file in file object *fh*."""
+        self._header = _parse_header(fh)
+        self._metrics, self._metrics_by_name = _parse_char_metrics(fh)
+        self._kern, self._composite = _parse_optional(fh)
+
+    def get_bbox_char(self, c, isord=False):
+        if not isord:
+            c = ord(c)
+        return self._metrics[c].bbox
+
+    def string_width_height(self, s):
+        """
+        Return the string width (including kerning) and string height
+        as a (*w*, *h*) tuple.
+        """
+        if not len(s):
+            return 0, 0
+        total_width = 0
+        namelast = None
+        miny = 1e9
+        maxy = 0
+        for c in s:
+            if c == '\n':
+                continue
+            wx, name, bbox = self._metrics[ord(c)]
+
+            total_width += wx + self._kern.get((namelast, name), 0)
+            l, b, w, h = bbox
+            miny = min(miny, b)
+            maxy = max(maxy, b + h)
+
+            namelast = name
+
+        return total_width, maxy - miny
+
+    def get_str_bbox_and_descent(self, s):
+        """Return the string bounding box and the maximal descent."""
+        if not len(s):
+            return 0, 0, 0, 0, 0
+        total_width = 0
+        namelast = None
+        miny = 1e9
+        maxy = 0
+        left = 0
+        if not isinstance(s, str):
+            s = _to_str(s)
+        for c in s:
+            if c == '\n':
+                continue
+            name = uni2type1.get(ord(c), f"uni{ord(c):04X}")
+            try:
+                wx, _, bbox = self._metrics_by_name[name]
+            except KeyError:
+                name = 'question'
+                wx, _, bbox = self._metrics_by_name[name]
+            total_width += wx + self._kern.get((namelast, name), 0)
+            l, b, w, h = bbox
+            left = min(left, l)
+            miny = min(miny, b)
+            maxy = max(maxy, b + h)
+
+            namelast = name
+
+        return left, miny, total_width, maxy - miny, -miny
+
+    def get_str_bbox(self, s):
+        """Return the string bounding box."""
+        return self.get_str_bbox_and_descent(s)[:4]
+
+    def get_name_char(self, c, isord=False):
+        """Get the name of the character, i.e., ';' is 'semicolon'."""
+        if not isord:
+            c = ord(c)
+        return self._metrics[c].name
+
+    def get_width_char(self, c, isord=False):
+        """
+        Get the width of the character from the character metric WX field.
+        """
+        if not isord:
+            c = ord(c)
+        return self._metrics[c].width
+
+    def get_width_from_char_name(self, name):
+        """Get the width of the character from a type1 character name."""
+        return self._metrics_by_name[name].width
+
+    def get_height_char(self, c, isord=False):
+        """Get the bounding box (ink) height of character *c* (space is 0)."""
+        if not isord:
+            c = ord(c)
+        return self._metrics[c].bbox[-1]
+
+    def get_kern_dist(self, c1, c2):
+        """
+        Return the kerning pair distance (possibly 0) for chars *c1* and *c2*.
+        """
+        name1, name2 = self.get_name_char(c1), self.get_name_char(c2)
+        return self.get_kern_dist_from_name(name1, name2)
+
+    def get_kern_dist_from_name(self, name1, name2):
+        """
+        Return the kerning pair distance (possibly 0) for chars
+        *name1* and *name2*.
+        """
+        return self._kern.get((name1, name2), 0)
+
+    def get_fontname(self):
+        """Return the font name, e.g., 'Times-Roman'."""
+        return self._header[b'FontName']
+
+    @property
+    def postscript_name(self):  # For consistency with FT2Font.
+        return self.get_fontname()
+
+    def get_fullname(self):
+        """Return the font full name, e.g., 'Times-Roman'."""
+        name = self._header.get(b'FullName')
+        if name is None:  # use FontName as a substitute
+            name = self._header[b'FontName']
+        return name
+
+    def get_familyname(self):
+        """Return the font family name, e.g., 'Times'."""
+        name = self._header.get(b'FamilyName')
+        if name is not None:
+            return name
+
+        # FamilyName not specified so we'll make a guess
+        name = self.get_fullname()
+        extras = (r'(?i)([ -](regular|plain|italic|oblique|bold|semibold|'
+                  r'light|ultralight|extra|condensed))+$')
+        return re.sub(extras, '', name)
+
+    @property
+    def family_name(self):
+        """The font family name, e.g., 'Times'."""
+        return self.get_familyname()
+
+    def get_weight(self):
+        """Return the font weight, e.g., 'Bold' or 'Roman'."""
+        return self._header[b'Weight']
+
+    def get_angle(self):
+        """Return the fontangle as float."""
+        return self._header[b'ItalicAngle']
+
+    def get_capheight(self):
+        """Return the cap height as float."""
+        return self._header[b'CapHeight']
+
+    def get_xheight(self):
+        """Return the xheight as float."""
+        return self._header[b'XHeight']
+
+    def get_underline_thickness(self):
+        """Return the underline thickness as float."""
+        return self._header[b'UnderlineThickness']
+
+    def get_horizontal_stem_width(self):
+        """
+        Return the standard horizontal stem width as float, or *None* if
+        not specified in AFM file.
+        """
+        return self._header.get(b'StdHW', None)
+
+    def get_vertical_stem_width(self):
+        """
+        Return the standard vertical stem width as float, or *None* if
+        not specified in AFM file.
+        """
+        return self._header.get(b'StdVW', None)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_animation_data.py

@@ -0,0 +1,262 @@
+# JavaScript template for HTMLWriter
+JS_INCLUDE = """
+<link rel="stylesheet"
+href="https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css">
+<script language="javascript">
+  function isInternetExplorer() {
+    ua = navigator.userAgent;
+    /* MSIE used to detect old browsers and Trident used to newer ones*/
+    return ua.indexOf("MSIE ") > -1 || ua.indexOf("Trident/") > -1;
+  }
+
+  /* Define the Animation class */
+  function Animation(frames, img_id, slider_id, interval, loop_select_id){
+    this.img_id = img_id;
+    this.slider_id = slider_id;
+    this.loop_select_id = loop_select_id;
+    this.interval = interval;
+    this.current_frame = 0;
+    this.direction = 0;
+    this.timer = null;
+    this.frames = new Array(frames.length);
+
+    for (var i=0; i<frames.length; i++)
+    {
+     this.frames[i] = new Image();
+     this.frames[i].src = frames[i];
+    }
+    var slider = document.getElementById(this.slider_id);
+    slider.max = this.frames.length - 1;
+    if (isInternetExplorer()) {
+        // switch from oninput to onchange because IE <= 11 does not conform
+        // with W3C specification. It ignores oninput and onchange behaves
+        // like oninput. In contrast, Microsoft Edge behaves correctly.
+        slider.setAttribute('onchange', slider.getAttribute('oninput'));
+        slider.setAttribute('oninput', null);
+    }
+    this.set_frame(this.current_frame);
+  }
+
+  Animation.prototype.get_loop_state = function(){
+    var button_group = document[this.loop_select_id].state;
+    for (var i = 0; i < button_group.length; i++) {
+        var button = button_group[i];
+        if (button.checked) {
+            return button.value;
+        }
+    }
+    return undefined;
+  }
+
+  Animation.prototype.set_frame = function(frame){
+    this.current_frame = frame;
+    document.getElementById(this.img_id).src =
+            this.frames[this.current_frame].src;
+    document.getElementById(this.slider_id).value = this.current_frame;
+  }
+
+  Animation.prototype.next_frame = function()
+  {
+    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));
+  }
+
+  Animation.prototype.previous_frame = function()
+  {
+    this.set_frame(Math.max(0, this.current_frame - 1));
+  }
+
+  Animation.prototype.first_frame = function()
+  {
+    this.set_frame(0);
+  }
+
+  Animation.prototype.last_frame = function()
+  {
+    this.set_frame(this.frames.length - 1);
+  }
+
+  Animation.prototype.slower = function()
+  {
+    this.interval /= 0.7;
+    if(this.direction > 0){this.play_animation();}
+    else if(this.direction < 0){this.reverse_animation();}
+  }
+
+  Animation.prototype.faster = function()
+  {
+    this.interval *= 0.7;
+    if(this.direction > 0){this.play_animation();}
+    else if(this.direction < 0){this.reverse_animation();}
+  }
+
+  Animation.prototype.anim_step_forward = function()
+  {
+    this.current_frame += 1;
+    if(this.current_frame < this.frames.length){
+      this.set_frame(this.current_frame);
+    }else{
+      var loop_state = this.get_loop_state();
+      if(loop_state == "loop"){
+        this.first_frame();
+      }else if(loop_state == "reflect"){
+        this.last_frame();
+        this.reverse_animation();
+      }else{
+        this.pause_animation();
+        this.last_frame();
+      }
+    }
+  }
+
+  Animation.prototype.anim_step_reverse = function()
+  {
+    this.current_frame -= 1;
+    if(this.current_frame >= 0){
+      this.set_frame(this.current_frame);
+    }else{
+      var loop_state = this.get_loop_state();
+      if(loop_state == "loop"){
+        this.last_frame();
+      }else if(loop_state == "reflect"){
+        this.first_frame();
+        this.play_animation();
+      }else{
+        this.pause_animation();
+        this.first_frame();
+      }
+    }
+  }
+
+  Animation.prototype.pause_animation = function()
+  {
+    this.direction = 0;
+    if (this.timer){
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  Animation.prototype.play_animation = function()
+  {
+    this.pause_animation();
+    this.direction = 1;
+    var t = this;
+    if (!this.timer) this.timer = setInterval(function() {
+        t.anim_step_forward();
+    }, this.interval);
+  }
+
+  Animation.prototype.reverse_animation = function()
+  {
+    this.pause_animation();
+    this.direction = -1;
+    var t = this;
+    if (!this.timer) this.timer = setInterval(function() {
+        t.anim_step_reverse();
+    }, this.interval);
+  }
+</script>
+"""
+
+
+# Style definitions for the HTML template
+STYLE_INCLUDE = """
+<style>
+.animation {
+    display: inline-block;
+    text-align: center;
+}
+input[type=range].anim-slider {
+    width: 374px;
+    margin-left: auto;
+    margin-right: auto;
+}
+.anim-buttons {
+    margin: 8px 0px;
+}
+.anim-buttons button {
+    padding: 0;
+    width: 36px;
+}
+.anim-state label {
+    margin-right: 8px;
+}
+.anim-state input {
+    margin: 0;
+    vertical-align: middle;
+}
+</style>
+"""
+
+
+# HTML template for HTMLWriter
+DISPLAY_TEMPLATE = """
+<div class="animation">
+  <img id="_anim_img{id}">
+  <div class="anim-controls">
+    <input id="_anim_slider{id}" type="range" class="anim-slider"
+           name="points" min="0" max="1" step="1" value="0"
+           oninput="anim{id}.set_frame(parseInt(this.value));">
+    <div class="anim-buttons">
+      <button title="Decrease speed" aria-label="Decrease speed" onclick="anim{id}.slower()">
+          <i class="fa fa-minus"></i></button>
+      <button title="First frame" aria-label="First frame" onclick="anim{id}.first_frame()">
+        <i class="fa fa-fast-backward"></i></button>
+      <button title="Previous frame" aria-label="Previous frame" onclick="anim{id}.previous_frame()">
+          <i class="fa fa-step-backward"></i></button>
+      <button title="Play backwards" aria-label="Play backwards" onclick="anim{id}.reverse_animation()">
+          <i class="fa fa-play fa-flip-horizontal"></i></button>
+      <button title="Pause" aria-label="Pause" onclick="anim{id}.pause_animation()">
+          <i class="fa fa-pause"></i></button>
+      <button title="Play" aria-label="Play" onclick="anim{id}.play_animation()">
+          <i class="fa fa-play"></i></button>
+      <button title="Next frame" aria-label="Next frame" onclick="anim{id}.next_frame()">
+          <i class="fa fa-step-forward"></i></button>
+      <button title="Last frame" aria-label="Last frame" onclick="anim{id}.last_frame()">
+          <i class="fa fa-fast-forward"></i></button>
+      <button title="Increase speed" aria-label="Increase speed" onclick="anim{id}.faster()">
+          <i class="fa fa-plus"></i></button>
+    </div>
+    <form title="Repetition mode" aria-label="Repetition mode" action="#n" name="_anim_loop_select{id}"
+          class="anim-state">
+      <input type="radio" name="state" value="once" id="_anim_radio1_{id}"
+             {once_checked}>
+      <label for="_anim_radio1_{id}">Once</label>
+      <input type="radio" name="state" value="loop" id="_anim_radio2_{id}"
+             {loop_checked}>
+      <label for="_anim_radio2_{id}">Loop</label>
+      <input type="radio" name="state" value="reflect" id="_anim_radio3_{id}"
+             {reflect_checked}>
+      <label for="_anim_radio3_{id}">Reflect</label>
+    </form>
+  </div>
+</div>
+
+
+<script language="javascript">
+  /* Instantiate the Animation class. */
+  /* The IDs given should match those used in the template above. */
+  (function() {{
+    var img_id = "_anim_img{id}";
+    var slider_id = "_anim_slider{id}";
+    var loop_select_id = "_anim_loop_select{id}";
+    var frames = new Array({Nframes});
+    {fill_frames}
+
+    /* set a timeout to make sure all the above elements are created before
+       the object is initialized. */
+    setTimeout(function() {{
+        anim{id} = new Animation(frames, img_id, slider_id, {interval},
+                                 loop_select_id);
+    }}, 0);
+  }})()
+</script>
+"""  # noqa: E501
+
+
+INCLUDED_FRAMES = """
+  for (var i=0; i<{Nframes}; i++){{
+    frames[i] = "{frame_dir}/frame" + ("0000000" + i).slice(-7) +
+                ".{frame_format}";
+  }}
+"""

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_blocking_input.py

@@ -0,0 +1,30 @@
+def blocking_input_loop(figure, event_names, timeout, handler):
+    """
+    Run *figure*'s event loop while listening to interactive events.
+
+    The events listed in *event_names* are passed to *handler*.
+
+    This function is used to implement `.Figure.waitforbuttonpress`,
+    `.Figure.ginput`, and `.Axes.clabel`.
+
+    Parameters
+    ----------
+    figure : `~matplotlib.figure.Figure`
+    event_names : list of str
+        The names of the events passed to *handler*.
+    timeout : float
+        If positive, the event loop is stopped after *timeout* seconds.
+    handler : Callable[[Event], Any]
+        Function called for each event; it can force an early exit of the event
+        loop by calling ``canvas.stop_event_loop()``.
+    """
+    if figure.canvas.manager:
+        figure.show()  # Ensure that the figure is shown if we are managing it.
+    # Connect the events to the on_event function call.
+    cids = [figure.canvas.mpl_connect(name, handler) for name in event_names]
+    try:
+        figure.canvas.start_event_loop(timeout)  # Start event loop.
+    finally:  # Run even on exception like ctrl-c.
+        # Disconnect the callbacks.
+        for cid in cids:
+            figure.canvas.mpl_disconnect(cid)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_c_internal_utils.pyi

@@ -0,0 +1,8 @@
+def display_is_valid() -> bool: ...
+def xdisplay_is_valid() -> bool: ...
+
+def Win32_GetForegroundWindow() -> int | None: ...
+def Win32_SetForegroundWindow(hwnd: int) -> None: ...
+def Win32_SetProcessDpiAwareness_max() -> None: ...
+def Win32_SetCurrentProcessExplicitAppUserModelID(appid: str) -> None: ...
+def Win32_GetCurrentProcessExplicitAppUserModelID() -> str | None: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_cm.py

@@ -0,0 +1,1460 @@
+"""
+Nothing here but dictionaries for generating LinearSegmentedColormaps,
+and a dictionary of these dictionaries.
+
+Documentation for each is in pyplot.colormaps().  Please update this
+with the purpose and type of your colormap if you add data for one here.
+"""
+
+from functools import partial
+
+import numpy as np
+
+_binary_data = {
+    'red':    ((0., 1., 1.), (1., 0., 0.)),
+    'green':  ((0., 1., 1.), (1., 0., 0.)),
+    'blue':   ((0., 1., 1.), (1., 0., 0.))
+    }
+
+_autumn_data = {'red':   ((0., 1.0, 1.0), (1.0, 1.0, 1.0)),
+                'green': ((0., 0., 0.), (1.0, 1.0, 1.0)),
+                'blue':  ((0., 0., 0.), (1.0, 0., 0.))}
+
+_bone_data = {'red':   ((0., 0., 0.),
+                        (0.746032, 0.652778, 0.652778),
+                        (1.0, 1.0, 1.0)),
+              'green': ((0., 0., 0.),
+                        (0.365079, 0.319444, 0.319444),
+                        (0.746032, 0.777778, 0.777778),
+                        (1.0, 1.0, 1.0)),
+              'blue':  ((0., 0., 0.),
+                        (0.365079, 0.444444, 0.444444),
+                        (1.0, 1.0, 1.0))}
+
+_cool_data = {'red':   ((0., 0., 0.), (1.0, 1.0, 1.0)),
+              'green': ((0., 1., 1.), (1.0, 0.,  0.)),
+              'blue':  ((0., 1., 1.), (1.0, 1.,  1.))}
+
+_copper_data = {'red':   ((0., 0., 0.),
+                          (0.809524, 1.000000, 1.000000),
+                          (1.0, 1.0, 1.0)),
+                'green': ((0., 0., 0.),
+                          (1.0, 0.7812, 0.7812)),
+                'blue':  ((0., 0., 0.),
+                          (1.0, 0.4975, 0.4975))}
+
+def _flag_red(x): return 0.75 * np.sin((x * 31.5 + 0.25) * np.pi) + 0.5
+def _flag_green(x): return np.sin(x * 31.5 * np.pi)
+def _flag_blue(x): return 0.75 * np.sin((x * 31.5 - 0.25) * np.pi) + 0.5
+_flag_data = {'red': _flag_red, 'green': _flag_green, 'blue': _flag_blue}
+
+def _prism_red(x): return 0.75 * np.sin((x * 20.9 + 0.25) * np.pi) + 0.67
+def _prism_green(x): return 0.75 * np.sin((x * 20.9 - 0.25) * np.pi) + 0.33
+def _prism_blue(x): return -1.1 * np.sin((x * 20.9) * np.pi)
+_prism_data = {'red': _prism_red, 'green': _prism_green, 'blue': _prism_blue}
+
+def _ch_helper(gamma, s, r, h, p0, p1, x):
+    """Helper function for generating picklable cubehelix colormaps."""
+    # Apply gamma factor to emphasise low or high intensity values
+    xg = x ** gamma
+    # Calculate amplitude and angle of deviation from the black to white
+    # diagonal in the plane of constant perceived intensity.
+    a = h * xg * (1 - xg) / 2
+    phi = 2 * np.pi * (s / 3 + r * x)
+    return xg + a * (p0 * np.cos(phi) + p1 * np.sin(phi))
+
+def cubehelix(gamma=1.0, s=0.5, r=-1.5, h=1.0):
+    """
+    Return custom data dictionary of (r, g, b) conversion functions, which can
+    be used with `.ColormapRegistry.register`, for the cubehelix color scheme.
+
+    Unlike most other color schemes cubehelix was designed by D.A. Green to
+    be monotonically increasing in terms of perceived brightness.
+    Also, when printed on a black and white postscript printer, the scheme
+    results in a greyscale with monotonically increasing brightness.
+    This color scheme is named cubehelix because the (r, g, b) values produced
+    can be visualised as a squashed helix around the diagonal in the
+    (r, g, b) color cube.
+
+    For a unit color cube (i.e. 3D coordinates for (r, g, b) each in the
+    range 0 to 1) the color scheme starts at (r, g, b) = (0, 0, 0), i.e. black,
+    and finishes at (r, g, b) = (1, 1, 1), i.e. white. For some fraction *x*,
+    between 0 and 1, the color is the corresponding grey value at that
+    fraction along the black to white diagonal (x, x, x) plus a color
+    element. This color element is calculated in a plane of constant
+    perceived intensity and controlled by the following parameters.
+
+    Parameters
+    ----------
+    gamma : float, default: 1
+        Gamma factor emphasizing either low intensity values (gamma < 1), or
+        high intensity values (gamma > 1).
+    s : float, default: 0.5 (purple)
+        The starting color.
+    r : float, default: -1.5
+        The number of r, g, b rotations in color that are made from the start
+        to the end of the color scheme.  The default of -1.5 corresponds to ->
+        B -> G -> R -> B.
+    h : float, default: 1
+        The hue, i.e. how saturated the colors are. If this parameter is zero
+        then the color scheme is purely a greyscale.
+    """
+    return {'red': partial(_ch_helper, gamma, s, r, h, -0.14861, 1.78277),
+            'green': partial(_ch_helper, gamma, s, r, h, -0.29227, -0.90649),
+            'blue': partial(_ch_helper, gamma, s, r, h, 1.97294, 0.0)}
+
+_cubehelix_data = cubehelix()
+
+_bwr_data = ((0.0, 0.0, 1.0), (1.0, 1.0, 1.0), (1.0, 0.0, 0.0))
+_brg_data = ((0.0, 0.0, 1.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0))
+
+# Gnuplot palette functions
+def _g0(x): return 0
+def _g1(x): return 0.5
+def _g2(x): return 1
+def _g3(x): return x
+def _g4(x): return x ** 2
+def _g5(x): return x ** 3
+def _g6(x): return x ** 4
+def _g7(x): return np.sqrt(x)
+def _g8(x): return np.sqrt(np.sqrt(x))
+def _g9(x): return np.sin(x * np.pi / 2)
+def _g10(x): return np.cos(x * np.pi / 2)
+def _g11(x): return np.abs(x - 0.5)
+def _g12(x): return (2 * x - 1) ** 2
+def _g13(x): return np.sin(x * np.pi)
+def _g14(x): return np.abs(np.cos(x * np.pi))
+def _g15(x): return np.sin(x * 2 * np.pi)
+def _g16(x): return np.cos(x * 2 * np.pi)
+def _g17(x): return np.abs(np.sin(x * 2 * np.pi))
+def _g18(x): return np.abs(np.cos(x * 2 * np.pi))
+def _g19(x): return np.abs(np.sin(x * 4 * np.pi))
+def _g20(x): return np.abs(np.cos(x * 4 * np.pi))
+def _g21(x): return 3 * x
+def _g22(x): return 3 * x - 1
+def _g23(x): return 3 * x - 2
+def _g24(x): return np.abs(3 * x - 1)
+def _g25(x): return np.abs(3 * x - 2)
+def _g26(x): return (3 * x - 1) / 2
+def _g27(x): return (3 * x - 2) / 2
+def _g28(x): return np.abs((3 * x - 1) / 2)
+def _g29(x): return np.abs((3 * x - 2) / 2)
+def _g30(x): return x / 0.32 - 0.78125
+def _g31(x): return 2 * x - 0.84
+def _g32(x):
+    ret = np.zeros(len(x))
+    m = (x < 0.25)
+    ret[m] = 4 * x[m]
+    m = (x >= 0.25) & (x < 0.92)
+    ret[m] = -2 * x[m] + 1.84
+    m = (x >= 0.92)
+    ret[m] = x[m] / 0.08 - 11.5
+    return ret
+def _g33(x): return np.abs(2 * x - 0.5)
+def _g34(x): return 2 * x
+def _g35(x): return 2 * x - 0.5
+def _g36(x): return 2 * x - 1
+
+gfunc = {i: globals()[f"_g{i}"] for i in range(37)}
+
+_gnuplot_data = {
+        'red': gfunc[7],
+        'green': gfunc[5],
+        'blue': gfunc[15],
+}
+
+_gnuplot2_data = {
+        'red': gfunc[30],
+        'green': gfunc[31],
+        'blue': gfunc[32],
+}
+
+_ocean_data = {
+        'red': gfunc[23],
+        'green': gfunc[28],
+        'blue': gfunc[3],
+}
+
+_afmhot_data = {
+        'red': gfunc[34],
+        'green': gfunc[35],
+        'blue': gfunc[36],
+}
+
+_rainbow_data = {
+        'red': gfunc[33],
+        'green': gfunc[13],
+        'blue': gfunc[10],
+}
+
+_seismic_data = (
+        (0.0, 0.0, 0.3), (0.0, 0.0, 1.0),
+        (1.0, 1.0, 1.0), (1.0, 0.0, 0.0),
+        (0.5, 0.0, 0.0))
+
+_terrain_data = (
+        (0.00, (0.2, 0.2, 0.6)),
+        (0.15, (0.0, 0.6, 1.0)),
+        (0.25, (0.0, 0.8, 0.4)),
+        (0.50, (1.0, 1.0, 0.6)),
+        (0.75, (0.5, 0.36, 0.33)),
+        (1.00, (1.0, 1.0, 1.0)))
+
+_gray_data = {'red':   ((0., 0, 0), (1., 1, 1)),
+              'green': ((0., 0, 0), (1., 1, 1)),
+              'blue':  ((0., 0, 0), (1., 1, 1))}
+
+_hot_data = {'red':   ((0., 0.0416, 0.0416),
+                       (0.365079, 1.000000, 1.000000),
+                       (1.0, 1.0, 1.0)),
+             'green': ((0., 0., 0.),
+                       (0.365079, 0.000000, 0.000000),
+                       (0.746032, 1.000000, 1.000000),
+                       (1.0, 1.0, 1.0)),
+             'blue':  ((0., 0., 0.),
+                       (0.746032, 0.000000, 0.000000),
+                       (1.0, 1.0, 1.0))}
+
+_hsv_data = {'red':   ((0., 1., 1.),
+                       (0.158730, 1.000000, 1.000000),
+                       (0.174603, 0.968750, 0.968750),
+                       (0.333333, 0.031250, 0.031250),
+                       (0.349206, 0.000000, 0.000000),
+                       (0.666667, 0.000000, 0.000000),
+                       (0.682540, 0.031250, 0.031250),
+                       (0.841270, 0.968750, 0.968750),
+                       (0.857143, 1.000000, 1.000000),
+                       (1.0, 1.0, 1.0)),
+             'green': ((0., 0., 0.),
+                       (0.158730, 0.937500, 0.937500),
+                       (0.174603, 1.000000, 1.000000),
+                       (0.507937, 1.000000, 1.000000),
+                       (0.666667, 0.062500, 0.062500),
+                       (0.682540, 0.000000, 0.000000),
+                       (1.0, 0., 0.)),
+             'blue':  ((0., 0., 0.),
+                       (0.333333, 0.000000, 0.000000),
+                       (0.349206, 0.062500, 0.062500),
+                       (0.507937, 1.000000, 1.000000),
+                       (0.841270, 1.000000, 1.000000),
+                       (0.857143, 0.937500, 0.937500),
+                       (1.0, 0.09375, 0.09375))}
+
+_jet_data = {'red':   ((0.00, 0, 0),
+                       (0.35, 0, 0),
+                       (0.66, 1, 1),
+                       (0.89, 1, 1),
+                       (1.00, 0.5, 0.5)),
+             'green': ((0.000, 0, 0),
+                       (0.125, 0, 0),
+                       (0.375, 1, 1),
+                       (0.640, 1, 1),
+                       (0.910, 0, 0),
+                       (1.000, 0, 0)),
+             'blue':  ((0.00, 0.5, 0.5),
+                       (0.11, 1, 1),
+                       (0.34, 1, 1),
+                       (0.65, 0, 0),
+                       (1.00, 0, 0))}
+
+_pink_data = {'red':   ((0., 0.1178, 0.1178), (0.015873, 0.195857, 0.195857),
+                        (0.031746, 0.250661, 0.250661),
+                        (0.047619, 0.295468, 0.295468),
+                        (0.063492, 0.334324, 0.334324),
+                        (0.079365, 0.369112, 0.369112),
+                        (0.095238, 0.400892, 0.400892),
+                        (0.111111, 0.430331, 0.430331),
+                        (0.126984, 0.457882, 0.457882),
+                        (0.142857, 0.483867, 0.483867),
+                        (0.158730, 0.508525, 0.508525),
+                        (0.174603, 0.532042, 0.532042),
+                        (0.190476, 0.554563, 0.554563),
+                        (0.206349, 0.576204, 0.576204),
+                        (0.222222, 0.597061, 0.597061),
+                        (0.238095, 0.617213, 0.617213),
+                        (0.253968, 0.636729, 0.636729),
+                        (0.269841, 0.655663, 0.655663),
+                        (0.285714, 0.674066, 0.674066),
+                        (0.301587, 0.691980, 0.691980),
+                        (0.317460, 0.709441, 0.709441),
+                        (0.333333, 0.726483, 0.726483),
+                        (0.349206, 0.743134, 0.743134),
+                        (0.365079, 0.759421, 0.759421),
+                        (0.380952, 0.766356, 0.766356),
+                        (0.396825, 0.773229, 0.773229),
+                        (0.412698, 0.780042, 0.780042),
+                        (0.428571, 0.786796, 0.786796),
+                        (0.444444, 0.793492, 0.793492),
+                        (0.460317, 0.800132, 0.800132),
+                        (0.476190, 0.806718, 0.806718),
+                        (0.492063, 0.813250, 0.813250),
+                        (0.507937, 0.819730, 0.819730),
+                        (0.523810, 0.826160, 0.826160),
+                        (0.539683, 0.832539, 0.832539),
+                        (0.555556, 0.838870, 0.838870),
+                        (0.571429, 0.845154, 0.845154),
+                        (0.587302, 0.851392, 0.851392),
+                        (0.603175, 0.857584, 0.857584),
+                        (0.619048, 0.863731, 0.863731),
+                        (0.634921, 0.869835, 0.869835),
+                        (0.650794, 0.875897, 0.875897),
+                        (0.666667, 0.881917, 0.881917),
+                        (0.682540, 0.887896, 0.887896),
+                        (0.698413, 0.893835, 0.893835),
+                        (0.714286, 0.899735, 0.899735),
+                        (0.730159, 0.905597, 0.905597),
+                        (0.746032, 0.911421, 0.911421),
+                        (0.761905, 0.917208, 0.917208),
+                        (0.777778, 0.922958, 0.922958),
+                        (0.793651, 0.928673, 0.928673),
+                        (0.809524, 0.934353, 0.934353),
+                        (0.825397, 0.939999, 0.939999),
+                        (0.841270, 0.945611, 0.945611),
+                        (0.857143, 0.951190, 0.951190),
+                        (0.873016, 0.956736, 0.956736),
+                        (0.888889, 0.962250, 0.962250),
+                        (0.904762, 0.967733, 0.967733),
+                        (0.920635, 0.973185, 0.973185),
+                        (0.936508, 0.978607, 0.978607),
+                        (0.952381, 0.983999, 0.983999),
+                        (0.968254, 0.989361, 0.989361),
+                        (0.984127, 0.994695, 0.994695), (1.0, 1.0, 1.0)),
+              'green': ((0., 0., 0.), (0.015873, 0.102869, 0.102869),
+                        (0.031746, 0.145479, 0.145479),
+                        (0.047619, 0.178174, 0.178174),
+                        (0.063492, 0.205738, 0.205738),
+                        (0.079365, 0.230022, 0.230022),
+                        (0.095238, 0.251976, 0.251976),
+                        (0.111111, 0.272166, 0.272166),
+                        (0.126984, 0.290957, 0.290957),
+                        (0.142857, 0.308607, 0.308607),
+                        (0.158730, 0.325300, 0.325300),
+                        (0.174603, 0.341178, 0.341178),
+                        (0.190476, 0.356348, 0.356348),
+                        (0.206349, 0.370899, 0.370899),
+                        (0.222222, 0.384900, 0.384900),
+                        (0.238095, 0.398410, 0.398410),
+                        (0.253968, 0.411476, 0.411476),
+                        (0.269841, 0.424139, 0.424139),
+                        (0.285714, 0.436436, 0.436436),
+                        (0.301587, 0.448395, 0.448395),
+                        (0.317460, 0.460044, 0.460044),
+                        (0.333333, 0.471405, 0.471405),
+                        (0.349206, 0.482498, 0.482498),
+                        (0.365079, 0.493342, 0.493342),
+                        (0.380952, 0.517549, 0.517549),
+                        (0.396825, 0.540674, 0.540674),
+                        (0.412698, 0.562849, 0.562849),
+                        (0.428571, 0.584183, 0.584183),
+                        (0.444444, 0.604765, 0.604765),
+                        (0.460317, 0.624669, 0.624669),
+                        (0.476190, 0.643958, 0.643958),
+                        (0.492063, 0.662687, 0.662687),
+                        (0.507937, 0.680900, 0.680900),
+                        (0.523810, 0.698638, 0.698638),
+                        (0.539683, 0.715937, 0.715937),
+                        (0.555556, 0.732828, 0.732828),
+                        (0.571429, 0.749338, 0.749338),
+                        (0.587302, 0.765493, 0.765493),
+                        (0.603175, 0.781313, 0.781313),
+                        (0.619048, 0.796819, 0.796819),
+                        (0.634921, 0.812029, 0.812029),
+                        (0.650794, 0.826960, 0.826960),
+                        (0.666667, 0.841625, 0.841625),
+                        (0.682540, 0.856040, 0.856040),
+                        (0.698413, 0.870216, 0.870216),
+                        (0.714286, 0.884164, 0.884164),
+                        (0.730159, 0.897896, 0.897896),
+                        (0.746032, 0.911421, 0.911421),
+                        (0.761905, 0.917208, 0.917208),
+                        (0.777778, 0.922958, 0.922958),
+                        (0.793651, 0.928673, 0.928673),
+                        (0.809524, 0.934353, 0.934353),
+                        (0.825397, 0.939999, 0.939999),
+                        (0.841270, 0.945611, 0.945611),
+                        (0.857143, 0.951190, 0.951190),
+                        (0.873016, 0.956736, 0.956736),
+                        (0.888889, 0.962250, 0.962250),
+                        (0.904762, 0.967733, 0.967733),
+                        (0.920635, 0.973185, 0.973185),
+                        (0.936508, 0.978607, 0.978607),
+                        (0.952381, 0.983999, 0.983999),
+                        (0.968254, 0.989361, 0.989361),
+                        (0.984127, 0.994695, 0.994695), (1.0, 1.0, 1.0)),
+              'blue':  ((0., 0., 0.), (0.015873, 0.102869, 0.102869),
+                        (0.031746, 0.145479, 0.145479),
+                        (0.047619, 0.178174, 0.178174),
+                        (0.063492, 0.205738, 0.205738),
+                        (0.079365, 0.230022, 0.230022),
+                        (0.095238, 0.251976, 0.251976),
+                        (0.111111, 0.272166, 0.272166),
+                        (0.126984, 0.290957, 0.290957),
+                        (0.142857, 0.308607, 0.308607),
+                        (0.158730, 0.325300, 0.325300),
+                        (0.174603, 0.341178, 0.341178),
+                        (0.190476, 0.356348, 0.356348),
+                        (0.206349, 0.370899, 0.370899),
+                        (0.222222, 0.384900, 0.384900),
+                        (0.238095, 0.398410, 0.398410),
+                        (0.253968, 0.411476, 0.411476),
+                        (0.269841, 0.424139, 0.424139),
+                        (0.285714, 0.436436, 0.436436),
+                        (0.301587, 0.448395, 0.448395),
+                        (0.317460, 0.460044, 0.460044),
+                        (0.333333, 0.471405, 0.471405),
+                        (0.349206, 0.482498, 0.482498),
+                        (0.365079, 0.493342, 0.493342),
+                        (0.380952, 0.503953, 0.503953),
+                        (0.396825, 0.514344, 0.514344),
+                        (0.412698, 0.524531, 0.524531),
+                        (0.428571, 0.534522, 0.534522),
+                        (0.444444, 0.544331, 0.544331),
+                        (0.460317, 0.553966, 0.553966),
+                        (0.476190, 0.563436, 0.563436),
+                        (0.492063, 0.572750, 0.572750),
+                        (0.507937, 0.581914, 0.581914),
+                        (0.523810, 0.590937, 0.590937),
+                        (0.539683, 0.599824, 0.599824),
+                        (0.555556, 0.608581, 0.608581),
+                        (0.571429, 0.617213, 0.617213),
+                        (0.587302, 0.625727, 0.625727),
+                        (0.603175, 0.634126, 0.634126),
+                        (0.619048, 0.642416, 0.642416),
+                        (0.634921, 0.650600, 0.650600),
+                        (0.650794, 0.658682, 0.658682),
+                        (0.666667, 0.666667, 0.666667),
+                        (0.682540, 0.674556, 0.674556),
+                        (0.698413, 0.682355, 0.682355),
+                        (0.714286, 0.690066, 0.690066),
+                        (0.730159, 0.697691, 0.697691),
+                        (0.746032, 0.705234, 0.705234),
+                        (0.761905, 0.727166, 0.727166),
+                        (0.777778, 0.748455, 0.748455),
+                        (0.793651, 0.769156, 0.769156),
+                        (0.809524, 0.789314, 0.789314),
+                        (0.825397, 0.808969, 0.808969),
+                        (0.841270, 0.828159, 0.828159),
+                        (0.857143, 0.846913, 0.846913),
+                        (0.873016, 0.865261, 0.865261),
+                        (0.888889, 0.883229, 0.883229),
+                        (0.904762, 0.900837, 0.900837),
+                        (0.920635, 0.918109, 0.918109),
+                        (0.936508, 0.935061, 0.935061),
+                        (0.952381, 0.951711, 0.951711),
+                        (0.968254, 0.968075, 0.968075),
+                        (0.984127, 0.984167, 0.984167), (1.0, 1.0, 1.0))}
+
+_spring_data = {'red':   ((0., 1., 1.), (1.0, 1.0, 1.0)),
+                'green': ((0., 0., 0.), (1.0, 1.0, 1.0)),
+                'blue':  ((0., 1., 1.), (1.0, 0.0, 0.0))}
+
+
+_summer_data = {'red':   ((0., 0., 0.), (1.0, 1.0, 1.0)),
+                'green': ((0., 0.5, 0.5), (1.0, 1.0, 1.0)),
+                'blue':  ((0., 0.4, 0.4), (1.0, 0.4, 0.4))}
+
+
+_winter_data = {'red':   ((0., 0., 0.), (1.0, 0.0, 0.0)),
+                'green': ((0., 0., 0.), (1.0, 1.0, 1.0)),
+                'blue':  ((0., 1., 1.), (1.0, 0.5, 0.5))}
+
+_nipy_spectral_data = {
+    'red': [
+        (0.0, 0.0, 0.0), (0.05, 0.4667, 0.4667),
+        (0.10, 0.5333, 0.5333), (0.15, 0.0, 0.0),
+        (0.20, 0.0, 0.0), (0.25, 0.0, 0.0),
+        (0.30, 0.0, 0.0), (0.35, 0.0, 0.0),
+        (0.40, 0.0, 0.0), (0.45, 0.0, 0.0),
+        (0.50, 0.0, 0.0), (0.55, 0.0, 0.0),
+        (0.60, 0.0, 0.0), (0.65, 0.7333, 0.7333),
+        (0.70, 0.9333, 0.9333), (0.75, 1.0, 1.0),
+        (0.80, 1.0, 1.0), (0.85, 1.0, 1.0),
+        (0.90, 0.8667, 0.8667), (0.95, 0.80, 0.80),
+        (1.0, 0.80, 0.80),
+    ],
+    'green': [
+        (0.0, 0.0, 0.0), (0.05, 0.0, 0.0),
+        (0.10, 0.0, 0.0), (0.15, 0.0, 0.0),
+        (0.20, 0.0, 0.0), (0.25, 0.4667, 0.4667),
+        (0.30, 0.6000, 0.6000), (0.35, 0.6667, 0.6667),
+        (0.40, 0.6667, 0.6667), (0.45, 0.6000, 0.6000),
+        (0.50, 0.7333, 0.7333), (0.55, 0.8667, 0.8667),
+        (0.60, 1.0, 1.0), (0.65, 1.0, 1.0),
+        (0.70, 0.9333, 0.9333), (0.75, 0.8000, 0.8000),
+        (0.80, 0.6000, 0.6000), (0.85, 0.0, 0.0),
+        (0.90, 0.0, 0.0), (0.95, 0.0, 0.0),
+        (1.0, 0.80, 0.80),
+    ],
+    'blue': [
+        (0.0, 0.0, 0.0), (0.05, 0.5333, 0.5333),
+        (0.10, 0.6000, 0.6000), (0.15, 0.6667, 0.6667),
+        (0.20, 0.8667, 0.8667), (0.25, 0.8667, 0.8667),
+        (0.30, 0.8667, 0.8667), (0.35, 0.6667, 0.6667),
+        (0.40, 0.5333, 0.5333), (0.45, 0.0, 0.0),
+        (0.5, 0.0, 0.0), (0.55, 0.0, 0.0),
+        (0.60, 0.0, 0.0), (0.65, 0.0, 0.0),
+        (0.70, 0.0, 0.0), (0.75, 0.0, 0.0),
+        (0.80, 0.0, 0.0), (0.85, 0.0, 0.0),
+        (0.90, 0.0, 0.0), (0.95, 0.0, 0.0),
+        (1.0, 0.80, 0.80),
+    ],
+}
+
+
+# 34 colormaps based on color specifications and designs
+# developed by Cynthia Brewer (https://colorbrewer2.org/).
+# The ColorBrewer palettes have been included under the terms
+# of an Apache-stype license (for details, see the file
+# LICENSE_COLORBREWER in the license directory of the matplotlib
+# source distribution).
+
+# RGB values taken from Brewer's Excel sheet, divided by 255
+
+_Blues_data = (
+    (0.96862745098039216,  0.98431372549019602,  1.0                ),
+    (0.87058823529411766,  0.92156862745098034,  0.96862745098039216),
+    (0.77647058823529413,  0.85882352941176465,  0.93725490196078431),
+    (0.61960784313725492,  0.792156862745098  ,  0.88235294117647056),
+    (0.41960784313725491,  0.68235294117647061,  0.83921568627450982),
+    (0.25882352941176473,  0.5725490196078431 ,  0.77647058823529413),
+    (0.12941176470588237,  0.44313725490196076,  0.70980392156862748),
+    (0.03137254901960784,  0.31764705882352939,  0.61176470588235299),
+    (0.03137254901960784,  0.18823529411764706,  0.41960784313725491)
+    )
+
+_BrBG_data = (
+    (0.32941176470588235,  0.18823529411764706,  0.0196078431372549 ),
+    (0.5490196078431373 ,  0.31764705882352939,  0.0392156862745098 ),
+    (0.74901960784313726,  0.50588235294117645,  0.17647058823529413),
+    (0.87450980392156863,  0.76078431372549016,  0.49019607843137253),
+    (0.96470588235294119,  0.90980392156862744,  0.76470588235294112),
+    (0.96078431372549022,  0.96078431372549022,  0.96078431372549022),
+    (0.7803921568627451 ,  0.91764705882352937,  0.89803921568627454),
+    (0.50196078431372548,  0.80392156862745101,  0.75686274509803919),
+    (0.20784313725490197,  0.59215686274509804,  0.5607843137254902 ),
+    (0.00392156862745098,  0.4                ,  0.36862745098039218),
+    (0.0                ,  0.23529411764705882,  0.18823529411764706)
+    )
+
+_BuGn_data = (
+    (0.96862745098039216,  0.9882352941176471 ,  0.99215686274509807),
+    (0.89803921568627454,  0.96078431372549022,  0.97647058823529409),
+    (0.8                ,  0.92549019607843142,  0.90196078431372551),
+    (0.6                ,  0.84705882352941175,  0.78823529411764703),
+    (0.4                ,  0.76078431372549016,  0.64313725490196083),
+    (0.25490196078431371,  0.68235294117647061,  0.46274509803921571),
+    (0.13725490196078433,  0.54509803921568623,  0.27058823529411763),
+    (0.0                ,  0.42745098039215684,  0.17254901960784313),
+    (0.0                ,  0.26666666666666666,  0.10588235294117647)
+    )
+
+_BuPu_data = (
+    (0.96862745098039216,  0.9882352941176471 ,  0.99215686274509807),
+    (0.8784313725490196 ,  0.92549019607843142,  0.95686274509803926),
+    (0.74901960784313726,  0.82745098039215681,  0.90196078431372551),
+    (0.61960784313725492,  0.73725490196078436,  0.85490196078431369),
+    (0.5490196078431373 ,  0.58823529411764708,  0.77647058823529413),
+    (0.5490196078431373 ,  0.41960784313725491,  0.69411764705882351),
+    (0.53333333333333333,  0.25490196078431371,  0.61568627450980395),
+    (0.50588235294117645,  0.05882352941176471,  0.48627450980392156),
+    (0.30196078431372547,  0.0                ,  0.29411764705882354)
+    )
+
+_GnBu_data = (
+    (0.96862745098039216,  0.9882352941176471 ,  0.94117647058823528),
+    (0.8784313725490196 ,  0.95294117647058818,  0.85882352941176465),
+    (0.8                ,  0.92156862745098034,  0.77254901960784317),
+    (0.6588235294117647 ,  0.8666666666666667 ,  0.70980392156862748),
+    (0.4823529411764706 ,  0.8                ,  0.7686274509803922 ),
+    (0.30588235294117649,  0.70196078431372544,  0.82745098039215681),
+    (0.16862745098039217,  0.5490196078431373 ,  0.74509803921568629),
+    (0.03137254901960784,  0.40784313725490196,  0.67450980392156867),
+    (0.03137254901960784,  0.25098039215686274,  0.50588235294117645)
+    )
+
+_Greens_data = (
+    (0.96862745098039216,  0.9882352941176471 ,  0.96078431372549022),
+    (0.89803921568627454,  0.96078431372549022,  0.8784313725490196 ),
+    (0.7803921568627451 ,  0.9137254901960784 ,  0.75294117647058822),
+    (0.63137254901960782,  0.85098039215686272,  0.60784313725490191),
+    (0.45490196078431372,  0.7686274509803922 ,  0.46274509803921571),
+    (0.25490196078431371,  0.6705882352941176 ,  0.36470588235294116),
+    (0.13725490196078433,  0.54509803921568623,  0.27058823529411763),
+    (0.0                ,  0.42745098039215684,  0.17254901960784313),
+    (0.0                ,  0.26666666666666666,  0.10588235294117647)
+    )
+
+_Greys_data = (
+    (1.0                ,  1.0                ,  1.0                ),
+    (0.94117647058823528,  0.94117647058823528,  0.94117647058823528),
+    (0.85098039215686272,  0.85098039215686272,  0.85098039215686272),
+    (0.74117647058823533,  0.74117647058823533,  0.74117647058823533),
+    (0.58823529411764708,  0.58823529411764708,  0.58823529411764708),
+    (0.45098039215686275,  0.45098039215686275,  0.45098039215686275),
+    (0.32156862745098042,  0.32156862745098042,  0.32156862745098042),
+    (0.14509803921568629,  0.14509803921568629,  0.14509803921568629),
+    (0.0                ,  0.0                ,  0.0                )
+    )
+
+_Oranges_data = (
+    (1.0                ,  0.96078431372549022,  0.92156862745098034),
+    (0.99607843137254903,  0.90196078431372551,  0.80784313725490198),
+    (0.99215686274509807,  0.81568627450980391,  0.63529411764705879),
+    (0.99215686274509807,  0.68235294117647061,  0.41960784313725491),
+    (0.99215686274509807,  0.55294117647058827,  0.23529411764705882),
+    (0.94509803921568625,  0.41176470588235292,  0.07450980392156863),
+    (0.85098039215686272,  0.28235294117647058,  0.00392156862745098),
+    (0.65098039215686276,  0.21176470588235294,  0.01176470588235294),
+    (0.49803921568627452,  0.15294117647058825,  0.01568627450980392)
+    )
+
+_OrRd_data = (
+    (1.0                ,  0.96862745098039216,  0.92549019607843142),
+    (0.99607843137254903,  0.90980392156862744,  0.78431372549019607),
+    (0.99215686274509807,  0.83137254901960789,  0.61960784313725492),
+    (0.99215686274509807,  0.73333333333333328,  0.51764705882352946),
+    (0.9882352941176471 ,  0.55294117647058827,  0.34901960784313724),
+    (0.93725490196078431,  0.396078431372549  ,  0.28235294117647058),
+    (0.84313725490196079,  0.18823529411764706,  0.12156862745098039),
+    (0.70196078431372544,  0.0                ,  0.0                ),
+    (0.49803921568627452,  0.0                ,  0.0                )
+    )
+
+_PiYG_data = (
+    (0.55686274509803924,  0.00392156862745098,  0.32156862745098042),
+    (0.77254901960784317,  0.10588235294117647,  0.49019607843137253),
+    (0.87058823529411766,  0.46666666666666667,  0.68235294117647061),
+    (0.94509803921568625,  0.71372549019607845,  0.85490196078431369),
+    (0.99215686274509807,  0.8784313725490196 ,  0.93725490196078431),
+    (0.96862745098039216,  0.96862745098039216,  0.96862745098039216),
+    (0.90196078431372551,  0.96078431372549022,  0.81568627450980391),
+    (0.72156862745098038,  0.88235294117647056,  0.52549019607843139),
+    (0.49803921568627452,  0.73725490196078436,  0.25490196078431371),
+    (0.30196078431372547,  0.5725490196078431 ,  0.12941176470588237),
+    (0.15294117647058825,  0.39215686274509803,  0.09803921568627451)
+    )
+
+_PRGn_data = (
+    (0.25098039215686274,  0.0                ,  0.29411764705882354),
+    (0.46274509803921571,  0.16470588235294117,  0.51372549019607838),
+    (0.6                ,  0.4392156862745098 ,  0.6705882352941176 ),
+    (0.76078431372549016,  0.6470588235294118 ,  0.81176470588235294),
+    (0.90588235294117647,  0.83137254901960789,  0.90980392156862744),
+    (0.96862745098039216,  0.96862745098039216,  0.96862745098039216),
+    (0.85098039215686272,  0.94117647058823528,  0.82745098039215681),
+    (0.65098039215686276,  0.85882352941176465,  0.62745098039215685),
+    (0.35294117647058826,  0.68235294117647061,  0.38039215686274508),
+    (0.10588235294117647,  0.47058823529411764,  0.21568627450980393),
+    (0.0                ,  0.26666666666666666,  0.10588235294117647)
+    )
+
+_PuBu_data = (
+    (1.0                ,  0.96862745098039216,  0.98431372549019602),
+    (0.92549019607843142,  0.90588235294117647,  0.94901960784313721),
+    (0.81568627450980391,  0.81960784313725488,  0.90196078431372551),
+    (0.65098039215686276,  0.74117647058823533,  0.85882352941176465),
+    (0.45490196078431372,  0.66274509803921566,  0.81176470588235294),
+    (0.21176470588235294,  0.56470588235294117,  0.75294117647058822),
+    (0.0196078431372549 ,  0.4392156862745098 ,  0.69019607843137254),
+    (0.01568627450980392,  0.35294117647058826,  0.55294117647058827),
+    (0.00784313725490196,  0.2196078431372549 ,  0.34509803921568627)
+    )
+
+_PuBuGn_data = (
+    (1.0                ,  0.96862745098039216,  0.98431372549019602),
+    (0.92549019607843142,  0.88627450980392153,  0.94117647058823528),
+    (0.81568627450980391,  0.81960784313725488,  0.90196078431372551),
+    (0.65098039215686276,  0.74117647058823533,  0.85882352941176465),
+    (0.40392156862745099,  0.66274509803921566,  0.81176470588235294),
+    (0.21176470588235294,  0.56470588235294117,  0.75294117647058822),
+    (0.00784313725490196,  0.50588235294117645,  0.54117647058823526),
+    (0.00392156862745098,  0.42352941176470588,  0.34901960784313724),
+    (0.00392156862745098,  0.27450980392156865,  0.21176470588235294)
+    )
+
+_PuOr_data = (
+    (0.49803921568627452,  0.23137254901960785,  0.03137254901960784),
+    (0.70196078431372544,  0.34509803921568627,  0.02352941176470588),
+    (0.8784313725490196 ,  0.50980392156862742,  0.07843137254901961),
+    (0.99215686274509807,  0.72156862745098038,  0.38823529411764707),
+    (0.99607843137254903,  0.8784313725490196 ,  0.71372549019607845),
+    (0.96862745098039216,  0.96862745098039216,  0.96862745098039216),
+    (0.84705882352941175,  0.85490196078431369,  0.92156862745098034),
+    (0.69803921568627447,  0.6705882352941176 ,  0.82352941176470584),
+    (0.50196078431372548,  0.45098039215686275,  0.67450980392156867),
+    (0.32941176470588235,  0.15294117647058825,  0.53333333333333333),
+    (0.17647058823529413,  0.0                ,  0.29411764705882354)
+    )
+
+_PuRd_data = (
+    (0.96862745098039216,  0.95686274509803926,  0.97647058823529409),
+    (0.90588235294117647,  0.88235294117647056,  0.93725490196078431),
+    (0.83137254901960789,  0.72549019607843135,  0.85490196078431369),
+    (0.78823529411764703,  0.58039215686274515,  0.7803921568627451 ),
+    (0.87450980392156863,  0.396078431372549  ,  0.69019607843137254),
+    (0.90588235294117647,  0.16078431372549021,  0.54117647058823526),
+    (0.80784313725490198,  0.07058823529411765,  0.33725490196078434),
+    (0.59607843137254901,  0.0                ,  0.2627450980392157 ),
+    (0.40392156862745099,  0.0                ,  0.12156862745098039)
+    )
+
+_Purples_data = (
+    (0.9882352941176471 ,  0.98431372549019602,  0.99215686274509807),
+    (0.93725490196078431,  0.92941176470588238,  0.96078431372549022),
+    (0.85490196078431369,  0.85490196078431369,  0.92156862745098034),
+    (0.73725490196078436,  0.74117647058823533,  0.86274509803921573),
+    (0.61960784313725492,  0.60392156862745094,  0.78431372549019607),
+    (0.50196078431372548,  0.49019607843137253,  0.72941176470588232),
+    (0.41568627450980394,  0.31764705882352939,  0.63921568627450975),
+    (0.32941176470588235,  0.15294117647058825,  0.5607843137254902 ),
+    (0.24705882352941178,  0.0                ,  0.49019607843137253)
+    )
+
+_RdBu_data = (
+    (0.40392156862745099,  0.0                ,  0.12156862745098039),
+    (0.69803921568627447,  0.09411764705882353,  0.16862745098039217),
+    (0.83921568627450982,  0.37647058823529411,  0.30196078431372547),
+    (0.95686274509803926,  0.6470588235294118 ,  0.50980392156862742),
+    (0.99215686274509807,  0.85882352941176465,  0.7803921568627451 ),
+    (0.96862745098039216,  0.96862745098039216,  0.96862745098039216),
+    (0.81960784313725488,  0.89803921568627454,  0.94117647058823528),
+    (0.5725490196078431 ,  0.77254901960784317,  0.87058823529411766),
+    (0.2627450980392157 ,  0.57647058823529407,  0.76470588235294112),
+    (0.12941176470588237,  0.4                ,  0.67450980392156867),
+    (0.0196078431372549 ,  0.18823529411764706,  0.38039215686274508)
+    )
+
+_RdGy_data = (
+    (0.40392156862745099,  0.0                ,  0.12156862745098039),
+    (0.69803921568627447,  0.09411764705882353,  0.16862745098039217),
+    (0.83921568627450982,  0.37647058823529411,  0.30196078431372547),
+    (0.95686274509803926,  0.6470588235294118 ,  0.50980392156862742),
+    (0.99215686274509807,  0.85882352941176465,  0.7803921568627451 ),
+    (1.0                ,  1.0                ,  1.0                ),
+    (0.8784313725490196 ,  0.8784313725490196 ,  0.8784313725490196 ),
+    (0.72941176470588232,  0.72941176470588232,  0.72941176470588232),
+    (0.52941176470588236,  0.52941176470588236,  0.52941176470588236),
+    (0.30196078431372547,  0.30196078431372547,  0.30196078431372547),
+    (0.10196078431372549,  0.10196078431372549,  0.10196078431372549)
+    )
+
+_RdPu_data = (
+    (1.0                ,  0.96862745098039216,  0.95294117647058818),
+    (0.99215686274509807,  0.8784313725490196 ,  0.86666666666666667),
+    (0.9882352941176471 ,  0.77254901960784317,  0.75294117647058822),
+    (0.98039215686274506,  0.62352941176470589,  0.70980392156862748),
+    (0.96862745098039216,  0.40784313725490196,  0.63137254901960782),
+    (0.86666666666666667,  0.20392156862745098,  0.59215686274509804),
+    (0.68235294117647061,  0.00392156862745098,  0.49411764705882355),
+    (0.47843137254901963,  0.00392156862745098,  0.46666666666666667),
+    (0.28627450980392155,  0.0                ,  0.41568627450980394)
+    )
+
+_RdYlBu_data = (
+    (0.6470588235294118 , 0.0                 , 0.14901960784313725),
+    (0.84313725490196079, 0.18823529411764706 , 0.15294117647058825),
+    (0.95686274509803926, 0.42745098039215684 , 0.2627450980392157 ),
+    (0.99215686274509807, 0.68235294117647061 , 0.38039215686274508),
+    (0.99607843137254903, 0.8784313725490196  , 0.56470588235294117),
+    (1.0                , 1.0                 , 0.74901960784313726),
+    (0.8784313725490196 , 0.95294117647058818 , 0.97254901960784312),
+    (0.6705882352941176 , 0.85098039215686272 , 0.9137254901960784 ),
+    (0.45490196078431372, 0.67843137254901964 , 0.81960784313725488),
+    (0.27058823529411763, 0.45882352941176469 , 0.70588235294117652),
+    (0.19215686274509805, 0.21176470588235294 , 0.58431372549019611)
+    )
+
+_RdYlGn_data = (
+    (0.6470588235294118 , 0.0                 , 0.14901960784313725),
+    (0.84313725490196079, 0.18823529411764706 , 0.15294117647058825),
+    (0.95686274509803926, 0.42745098039215684 , 0.2627450980392157 ),
+    (0.99215686274509807, 0.68235294117647061 , 0.38039215686274508),
+    (0.99607843137254903, 0.8784313725490196  , 0.54509803921568623),
+    (1.0                , 1.0                 , 0.74901960784313726),
+    (0.85098039215686272, 0.93725490196078431 , 0.54509803921568623),
+    (0.65098039215686276, 0.85098039215686272 , 0.41568627450980394),
+    (0.4                , 0.74117647058823533 , 0.38823529411764707),
+    (0.10196078431372549, 0.59607843137254901 , 0.31372549019607843),
+    (0.0                , 0.40784313725490196 , 0.21568627450980393)
+    )
+
+_Reds_data = (
+    (1.0                , 0.96078431372549022 , 0.94117647058823528),
+    (0.99607843137254903, 0.8784313725490196  , 0.82352941176470584),
+    (0.9882352941176471 , 0.73333333333333328 , 0.63137254901960782),
+    (0.9882352941176471 , 0.5725490196078431  , 0.44705882352941179),
+    (0.98431372549019602, 0.41568627450980394 , 0.29019607843137257),
+    (0.93725490196078431, 0.23137254901960785 , 0.17254901960784313),
+    (0.79607843137254897, 0.094117647058823528, 0.11372549019607843),
+    (0.6470588235294118 , 0.058823529411764705, 0.08235294117647058),
+    (0.40392156862745099, 0.0                 , 0.05098039215686274)
+    )
+
+_Spectral_data = (
+    (0.61960784313725492, 0.003921568627450980, 0.25882352941176473),
+    (0.83529411764705885, 0.24313725490196078 , 0.30980392156862746),
+    (0.95686274509803926, 0.42745098039215684 , 0.2627450980392157 ),
+    (0.99215686274509807, 0.68235294117647061 , 0.38039215686274508),
+    (0.99607843137254903, 0.8784313725490196  , 0.54509803921568623),
+    (1.0                , 1.0                 , 0.74901960784313726),
+    (0.90196078431372551, 0.96078431372549022 , 0.59607843137254901),
+    (0.6705882352941176 , 0.8666666666666667  , 0.64313725490196083),
+    (0.4                , 0.76078431372549016 , 0.6470588235294118 ),
+    (0.19607843137254902, 0.53333333333333333 , 0.74117647058823533),
+    (0.36862745098039218, 0.30980392156862746 , 0.63529411764705879)
+    )
+
+_YlGn_data = (
+    (1.0                , 1.0                 , 0.89803921568627454),
+    (0.96862745098039216, 0.9882352941176471  , 0.72549019607843135),
+    (0.85098039215686272, 0.94117647058823528 , 0.63921568627450975),
+    (0.67843137254901964, 0.8666666666666667  , 0.55686274509803924),
+    (0.47058823529411764, 0.77647058823529413 , 0.47450980392156861),
+    (0.25490196078431371, 0.6705882352941176  , 0.36470588235294116),
+    (0.13725490196078433, 0.51764705882352946 , 0.2627450980392157 ),
+    (0.0                , 0.40784313725490196 , 0.21568627450980393),
+    (0.0                , 0.27058823529411763 , 0.16078431372549021)
+    )
+
+_YlGnBu_data = (
+    (1.0                , 1.0                 , 0.85098039215686272),
+    (0.92941176470588238, 0.97254901960784312 , 0.69411764705882351),
+    (0.7803921568627451 , 0.9137254901960784  , 0.70588235294117652),
+    (0.49803921568627452, 0.80392156862745101 , 0.73333333333333328),
+    (0.25490196078431371, 0.71372549019607845 , 0.7686274509803922 ),
+    (0.11372549019607843, 0.56862745098039214 , 0.75294117647058822),
+    (0.13333333333333333, 0.36862745098039218 , 0.6588235294117647 ),
+    (0.14509803921568629, 0.20392156862745098 , 0.58039215686274515),
+    (0.03137254901960784, 0.11372549019607843 , 0.34509803921568627)
+    )
+
+_YlOrBr_data = (
+    (1.0                , 1.0                 , 0.89803921568627454),
+    (1.0                , 0.96862745098039216 , 0.73725490196078436),
+    (0.99607843137254903, 0.8901960784313725  , 0.56862745098039214),
+    (0.99607843137254903, 0.7686274509803922  , 0.30980392156862746),
+    (0.99607843137254903, 0.6                 , 0.16078431372549021),
+    (0.92549019607843142, 0.4392156862745098  , 0.07843137254901961),
+    (0.8                , 0.29803921568627451 , 0.00784313725490196),
+    (0.6                , 0.20392156862745098 , 0.01568627450980392),
+    (0.4                , 0.14509803921568629 , 0.02352941176470588)
+    )
+
+_YlOrRd_data = (
+    (1.0                , 1.0                 , 0.8                ),
+    (1.0                , 0.92941176470588238 , 0.62745098039215685),
+    (0.99607843137254903, 0.85098039215686272 , 0.46274509803921571),
+    (0.99607843137254903, 0.69803921568627447 , 0.29803921568627451),
+    (0.99215686274509807, 0.55294117647058827 , 0.23529411764705882),
+    (0.9882352941176471 , 0.30588235294117649 , 0.16470588235294117),
+    (0.8901960784313725 , 0.10196078431372549 , 0.10980392156862745),
+    (0.74117647058823533, 0.0                 , 0.14901960784313725),
+    (0.50196078431372548, 0.0                 , 0.14901960784313725)
+    )
+
+
+# ColorBrewer's qualitative maps, implemented using ListedColormap
+# for use with mpl.colors.NoNorm
+
+_Accent_data = (
+    (0.49803921568627452, 0.78823529411764703, 0.49803921568627452),
+    (0.74509803921568629, 0.68235294117647061, 0.83137254901960789),
+    (0.99215686274509807, 0.75294117647058822, 0.52549019607843139),
+    (1.0,                 1.0,                 0.6                ),
+    (0.2196078431372549,  0.42352941176470588, 0.69019607843137254),
+    (0.94117647058823528, 0.00784313725490196, 0.49803921568627452),
+    (0.74901960784313726, 0.35686274509803922, 0.09019607843137254),
+    (0.4,                 0.4,                 0.4                ),
+    )
+
+_Dark2_data = (
+    (0.10588235294117647, 0.61960784313725492, 0.46666666666666667),
+    (0.85098039215686272, 0.37254901960784315, 0.00784313725490196),
+    (0.45882352941176469, 0.4392156862745098,  0.70196078431372544),
+    (0.90588235294117647, 0.16078431372549021, 0.54117647058823526),
+    (0.4,                 0.65098039215686276, 0.11764705882352941),
+    (0.90196078431372551, 0.6705882352941176,  0.00784313725490196),
+    (0.65098039215686276, 0.46274509803921571, 0.11372549019607843),
+    (0.4,                 0.4,                 0.4                ),
+    )
+
+_Paired_data = (
+    (0.65098039215686276, 0.80784313725490198, 0.8901960784313725 ),
+    (0.12156862745098039, 0.47058823529411764, 0.70588235294117652),
+    (0.69803921568627447, 0.87450980392156863, 0.54117647058823526),
+    (0.2,                 0.62745098039215685, 0.17254901960784313),
+    (0.98431372549019602, 0.60392156862745094, 0.6                ),
+    (0.8901960784313725,  0.10196078431372549, 0.10980392156862745),
+    (0.99215686274509807, 0.74901960784313726, 0.43529411764705883),
+    (1.0,                 0.49803921568627452, 0.0                ),
+    (0.792156862745098,   0.69803921568627447, 0.83921568627450982),
+    (0.41568627450980394, 0.23921568627450981, 0.60392156862745094),
+    (1.0,                 1.0,                 0.6                ),
+    (0.69411764705882351, 0.34901960784313724, 0.15686274509803921),
+    )
+
+_Pastel1_data = (
+    (0.98431372549019602, 0.70588235294117652, 0.68235294117647061),
+    (0.70196078431372544, 0.80392156862745101, 0.8901960784313725 ),
+    (0.8,                 0.92156862745098034, 0.77254901960784317),
+    (0.87058823529411766, 0.79607843137254897, 0.89411764705882357),
+    (0.99607843137254903, 0.85098039215686272, 0.65098039215686276),
+    (1.0,                 1.0,                 0.8                ),
+    (0.89803921568627454, 0.84705882352941175, 0.74117647058823533),
+    (0.99215686274509807, 0.85490196078431369, 0.92549019607843142),
+    (0.94901960784313721, 0.94901960784313721, 0.94901960784313721),
+    )
+
+_Pastel2_data = (
+    (0.70196078431372544, 0.88627450980392153, 0.80392156862745101),
+    (0.99215686274509807, 0.80392156862745101, 0.67450980392156867),
+    (0.79607843137254897, 0.83529411764705885, 0.90980392156862744),
+    (0.95686274509803926, 0.792156862745098,   0.89411764705882357),
+    (0.90196078431372551, 0.96078431372549022, 0.78823529411764703),
+    (1.0,                 0.94901960784313721, 0.68235294117647061),
+    (0.94509803921568625, 0.88627450980392153, 0.8                ),
+    (0.8,                 0.8,                 0.8                ),
+    )
+
+_Set1_data = (
+    (0.89411764705882357, 0.10196078431372549, 0.10980392156862745),
+    (0.21568627450980393, 0.49411764705882355, 0.72156862745098038),
+    (0.30196078431372547, 0.68627450980392157, 0.29019607843137257),
+    (0.59607843137254901, 0.30588235294117649, 0.63921568627450975),
+    (1.0,                 0.49803921568627452, 0.0                ),
+    (1.0,                 1.0,                 0.2                ),
+    (0.65098039215686276, 0.33725490196078434, 0.15686274509803921),
+    (0.96862745098039216, 0.50588235294117645, 0.74901960784313726),
+    (0.6,                 0.6,                 0.6),
+    )
+
+_Set2_data = (
+    (0.4,                 0.76078431372549016, 0.6470588235294118 ),
+    (0.9882352941176471,  0.55294117647058827, 0.3843137254901961 ),
+    (0.55294117647058827, 0.62745098039215685, 0.79607843137254897),
+    (0.90588235294117647, 0.54117647058823526, 0.76470588235294112),
+    (0.65098039215686276, 0.84705882352941175, 0.32941176470588235),
+    (1.0,                 0.85098039215686272, 0.18431372549019609),
+    (0.89803921568627454, 0.7686274509803922,  0.58039215686274515),
+    (0.70196078431372544, 0.70196078431372544, 0.70196078431372544),
+    )
+
+_Set3_data = (
+    (0.55294117647058827, 0.82745098039215681, 0.7803921568627451 ),
+    (1.0,                 1.0,                 0.70196078431372544),
+    (0.74509803921568629, 0.72941176470588232, 0.85490196078431369),
+    (0.98431372549019602, 0.50196078431372548, 0.44705882352941179),
+    (0.50196078431372548, 0.69411764705882351, 0.82745098039215681),
+    (0.99215686274509807, 0.70588235294117652, 0.3843137254901961 ),
+    (0.70196078431372544, 0.87058823529411766, 0.41176470588235292),
+    (0.9882352941176471,  0.80392156862745101, 0.89803921568627454),
+    (0.85098039215686272, 0.85098039215686272, 0.85098039215686272),
+    (0.73725490196078436, 0.50196078431372548, 0.74117647058823533),
+    (0.8,                 0.92156862745098034, 0.77254901960784317),
+    (1.0,                 0.92941176470588238, 0.43529411764705883),
+    )
+
+
+# The next 7 palettes are from the Yorick scientific visualization package,
+# an evolution of the GIST package, both by David H. Munro.
+# They are released under a BSD-like license (see LICENSE_YORICK in
+# the license directory of the matplotlib source distribution).
+#
+# Most palette functions have been reduced to simple function descriptions
+# by Reinier Heeres, since the rgb components were mostly straight lines.
+# gist_earth_data and gist_ncar_data were simplified by a script and some
+# manual effort.
+
+_gist_earth_data = {
+    'red': (
+        (0.0, 0.0, 0.0000),
+        (0.2824, 0.1882, 0.1882),
+        (0.4588, 0.2714, 0.2714),
+        (0.5490, 0.4719, 0.4719),
+        (0.6980, 0.7176, 0.7176),
+        (0.7882, 0.7553, 0.7553),
+        (1.0000, 0.9922, 0.9922),
+    ),
+    'green': (
+        (0.0, 0.0, 0.0000),
+        (0.0275, 0.0000, 0.0000),
+        (0.1098, 0.1893, 0.1893),
+        (0.1647, 0.3035, 0.3035),
+        (0.2078, 0.3841, 0.3841),
+        (0.2824, 0.5020, 0.5020),
+        (0.5216, 0.6397, 0.6397),
+        (0.6980, 0.7171, 0.7171),
+        (0.7882, 0.6392, 0.6392),
+        (0.7922, 0.6413, 0.6413),
+        (0.8000, 0.6447, 0.6447),
+        (0.8078, 0.6481, 0.6481),
+        (0.8157, 0.6549, 0.6549),
+        (0.8667, 0.6991, 0.6991),
+        (0.8745, 0.7103, 0.7103),
+        (0.8824, 0.7216, 0.7216),
+        (0.8902, 0.7323, 0.7323),
+        (0.8980, 0.7430, 0.7430),
+        (0.9412, 0.8275, 0.8275),
+        (0.9569, 0.8635, 0.8635),
+        (0.9647, 0.8816, 0.8816),
+        (0.9961, 0.9733, 0.9733),
+        (1.0000, 0.9843, 0.9843),
+    ),
+    'blue': (
+        (0.0, 0.0, 0.0000),
+        (0.0039, 0.1684, 0.1684),
+        (0.0078, 0.2212, 0.2212),
+        (0.0275, 0.4329, 0.4329),
+        (0.0314, 0.4549, 0.4549),
+        (0.2824, 0.5004, 0.5004),
+        (0.4667, 0.2748, 0.2748),
+        (0.5451, 0.3205, 0.3205),
+        (0.7843, 0.3961, 0.3961),
+        (0.8941, 0.6651, 0.6651),
+        (1.0000, 0.9843, 0.9843),
+    )
+}
+
+_gist_gray_data = {
+        'red': gfunc[3],
+        'green': gfunc[3],
+        'blue': gfunc[3],
+}
+
+def _gist_heat_red(x): return 1.5 * x
+def _gist_heat_green(x): return 2 * x - 1
+def _gist_heat_blue(x): return 4 * x - 3
+_gist_heat_data = {
+    'red': _gist_heat_red, 'green': _gist_heat_green, 'blue': _gist_heat_blue}
+
+_gist_ncar_data = {
+    'red': (
+        (0.0, 0.0, 0.0000),
+        (0.3098, 0.0000, 0.0000),
+        (0.3725, 0.3993, 0.3993),
+        (0.4235, 0.5003, 0.5003),
+        (0.5333, 1.0000, 1.0000),
+        (0.7922, 1.0000, 1.0000),
+        (0.8471, 0.6218, 0.6218),
+        (0.8980, 0.9235, 0.9235),
+        (1.0000, 0.9961, 0.9961),
+    ),
+    'green': (
+        (0.0, 0.0, 0.0000),
+        (0.0510, 0.3722, 0.3722),
+        (0.1059, 0.0000, 0.0000),
+        (0.1569, 0.7202, 0.7202),
+        (0.1608, 0.7537, 0.7537),
+        (0.1647, 0.7752, 0.7752),
+        (0.2157, 1.0000, 1.0000),
+        (0.2588, 0.9804, 0.9804),
+        (0.2706, 0.9804, 0.9804),
+        (0.3176, 1.0000, 1.0000),
+        (0.3686, 0.8081, 0.8081),
+        (0.4275, 1.0000, 1.0000),
+        (0.5216, 1.0000, 1.0000),
+        (0.6314, 0.7292, 0.7292),
+        (0.6863, 0.2796, 0.2796),
+        (0.7451, 0.0000, 0.0000),
+        (0.7922, 0.0000, 0.0000),
+        (0.8431, 0.1753, 0.1753),
+        (0.8980, 0.5000, 0.5000),
+        (1.0000, 0.9725, 0.9725),
+    ),
+    'blue': (
+        (0.0, 0.5020, 0.5020),
+        (0.0510, 0.0222, 0.0222),
+        (0.1098, 1.0000, 1.0000),
+        (0.2039, 1.0000, 1.0000),
+        (0.2627, 0.6145, 0.6145),
+        (0.3216, 0.0000, 0.0000),
+        (0.4157, 0.0000, 0.0000),
+        (0.4745, 0.2342, 0.2342),
+        (0.5333, 0.0000, 0.0000),
+        (0.5804, 0.0000, 0.0000),
+        (0.6314, 0.0549, 0.0549),
+        (0.6902, 0.0000, 0.0000),
+        (0.7373, 0.0000, 0.0000),
+        (0.7922, 0.9738, 0.9738),
+        (0.8000, 1.0000, 1.0000),
+        (0.8431, 1.0000, 1.0000),
+        (0.8980, 0.9341, 0.9341),
+        (1.0000, 0.9961, 0.9961),
+    )
+}
+
+_gist_rainbow_data = (
+        (0.000, (1.00, 0.00, 0.16)),
+        (0.030, (1.00, 0.00, 0.00)),
+        (0.215, (1.00, 1.00, 0.00)),
+        (0.400, (0.00, 1.00, 0.00)),
+        (0.586, (0.00, 1.00, 1.00)),
+        (0.770, (0.00, 0.00, 1.00)),
+        (0.954, (1.00, 0.00, 1.00)),
+        (1.000, (1.00, 0.00, 0.75))
+)
+
+_gist_stern_data = {
+        'red': (
+            (0.000, 0.000, 0.000), (0.0547, 1.000, 1.000),
+            (0.250, 0.027, 0.250),  # (0.2500, 0.250, 0.250),
+            (1.000, 1.000, 1.000)),
+        'green': ((0, 0, 0), (1, 1, 1)),
+        'blue': (
+            (0.000, 0.000, 0.000), (0.500, 1.000, 1.000),
+            (0.735, 0.000, 0.000), (1.000, 1.000, 1.000))
+}
+
+def _gist_yarg(x): return 1 - x
+_gist_yarg_data = {'red': _gist_yarg, 'green': _gist_yarg, 'blue': _gist_yarg}
+
+# This bipolar colormap was generated from CoolWarmFloat33.csv of
+# "Diverging Color Maps for Scientific Visualization" by Kenneth Moreland.
+# <http://www.kennethmoreland.com/color-maps/>
+_coolwarm_data = {
+    'red': [
+        (0.0, 0.2298057, 0.2298057),
+        (0.03125, 0.26623388, 0.26623388),
+        (0.0625, 0.30386891, 0.30386891),
+        (0.09375, 0.342804478, 0.342804478),
+        (0.125, 0.38301334, 0.38301334),
+        (0.15625, 0.424369608, 0.424369608),
+        (0.1875, 0.46666708, 0.46666708),
+        (0.21875, 0.509635204, 0.509635204),
+        (0.25, 0.552953156, 0.552953156),
+        (0.28125, 0.596262162, 0.596262162),
+        (0.3125, 0.639176211, 0.639176211),
+        (0.34375, 0.681291281, 0.681291281),
+        (0.375, 0.722193294, 0.722193294),
+        (0.40625, 0.761464949, 0.761464949),
+        (0.4375, 0.798691636, 0.798691636),
+        (0.46875, 0.833466556, 0.833466556),
+        (0.5, 0.865395197, 0.865395197),
+        (0.53125, 0.897787179, 0.897787179),
+        (0.5625, 0.924127593, 0.924127593),
+        (0.59375, 0.944468518, 0.944468518),
+        (0.625, 0.958852946, 0.958852946),
+        (0.65625, 0.96732803, 0.96732803),
+        (0.6875, 0.969954137, 0.969954137),
+        (0.71875, 0.966811177, 0.966811177),
+        (0.75, 0.958003065, 0.958003065),
+        (0.78125, 0.943660866, 0.943660866),
+        (0.8125, 0.923944917, 0.923944917),
+        (0.84375, 0.89904617, 0.89904617),
+        (0.875, 0.869186849, 0.869186849),
+        (0.90625, 0.834620542, 0.834620542),
+        (0.9375, 0.795631745, 0.795631745),
+        (0.96875, 0.752534934, 0.752534934),
+        (1.0, 0.705673158, 0.705673158)],
+    'green': [
+        (0.0, 0.298717966, 0.298717966),
+        (0.03125, 0.353094838, 0.353094838),
+        (0.0625, 0.406535296, 0.406535296),
+        (0.09375, 0.458757618, 0.458757618),
+        (0.125, 0.50941904, 0.50941904),
+        (0.15625, 0.558148092, 0.558148092),
+        (0.1875, 0.604562568, 0.604562568),
+        (0.21875, 0.648280772, 0.648280772),
+        (0.25, 0.688929332, 0.688929332),
+        (0.28125, 0.726149107, 0.726149107),
+        (0.3125, 0.759599947, 0.759599947),
+        (0.34375, 0.788964712, 0.788964712),
+        (0.375, 0.813952739, 0.813952739),
+        (0.40625, 0.834302879, 0.834302879),
+        (0.4375, 0.849786142, 0.849786142),
+        (0.46875, 0.860207984, 0.860207984),
+        (0.5, 0.86541021, 0.86541021),
+        (0.53125, 0.848937047, 0.848937047),
+        (0.5625, 0.827384882, 0.827384882),
+        (0.59375, 0.800927443, 0.800927443),
+        (0.625, 0.769767752, 0.769767752),
+        (0.65625, 0.734132809, 0.734132809),
+        (0.6875, 0.694266682, 0.694266682),
+        (0.71875, 0.650421156, 0.650421156),
+        (0.75, 0.602842431, 0.602842431),
+        (0.78125, 0.551750968, 0.551750968),
+        (0.8125, 0.49730856, 0.49730856),
+        (0.84375, 0.439559467, 0.439559467),
+        (0.875, 0.378313092, 0.378313092),
+        (0.90625, 0.312874446, 0.312874446),
+        (0.9375, 0.24128379, 0.24128379),
+        (0.96875, 0.157246067, 0.157246067),
+        (1.0, 0.01555616, 0.01555616)],
+    'blue': [
+        (0.0, 0.753683153, 0.753683153),
+        (0.03125, 0.801466763, 0.801466763),
+        (0.0625, 0.84495867, 0.84495867),
+        (0.09375, 0.883725899, 0.883725899),
+        (0.125, 0.917387822, 0.917387822),
+        (0.15625, 0.945619588, 0.945619588),
+        (0.1875, 0.968154911, 0.968154911),
+        (0.21875, 0.98478814, 0.98478814),
+        (0.25, 0.995375608, 0.995375608),
+        (0.28125, 0.999836203, 0.999836203),
+        (0.3125, 0.998151185, 0.998151185),
+        (0.34375, 0.990363227, 0.990363227),
+        (0.375, 0.976574709, 0.976574709),
+        (0.40625, 0.956945269, 0.956945269),
+        (0.4375, 0.931688648, 0.931688648),
+        (0.46875, 0.901068838, 0.901068838),
+        (0.5, 0.865395561, 0.865395561),
+        (0.53125, 0.820880546, 0.820880546),
+        (0.5625, 0.774508472, 0.774508472),
+        (0.59375, 0.726736146, 0.726736146),
+        (0.625, 0.678007945, 0.678007945),
+        (0.65625, 0.628751763, 0.628751763),
+        (0.6875, 0.579375448, 0.579375448),
+        (0.71875, 0.530263762, 0.530263762),
+        (0.75, 0.481775914, 0.481775914),
+        (0.78125, 0.434243684, 0.434243684),
+        (0.8125, 0.387970225, 0.387970225),
+        (0.84375, 0.343229596, 0.343229596),
+        (0.875, 0.300267182, 0.300267182),
+        (0.90625, 0.259301199, 0.259301199),
+        (0.9375, 0.220525627, 0.220525627),
+        (0.96875, 0.184115123, 0.184115123),
+        (1.0, 0.150232812, 0.150232812)]
+    }
+
+# Implementation of Carey Rappaport's CMRmap.
+# See `A Color Map for Effective Black-and-White Rendering of Color-Scale
+# Images' by Carey Rappaport
+# https://www.mathworks.com/matlabcentral/fileexchange/2662-cmrmap-m
+_CMRmap_data = {'red':    ((0.000, 0.00, 0.00),
+                           (0.125, 0.15, 0.15),
+                           (0.250, 0.30, 0.30),
+                           (0.375, 0.60, 0.60),
+                           (0.500, 1.00, 1.00),
+                           (0.625, 0.90, 0.90),
+                           (0.750, 0.90, 0.90),
+                           (0.875, 0.90, 0.90),
+                           (1.000, 1.00, 1.00)),
+                'green':  ((0.000, 0.00, 0.00),
+                           (0.125, 0.15, 0.15),
+                           (0.250, 0.15, 0.15),
+                           (0.375, 0.20, 0.20),
+                           (0.500, 0.25, 0.25),
+                           (0.625, 0.50, 0.50),
+                           (0.750, 0.75, 0.75),
+                           (0.875, 0.90, 0.90),
+                           (1.000, 1.00, 1.00)),
+                'blue':   ((0.000, 0.00, 0.00),
+                           (0.125, 0.50, 0.50),
+                           (0.250, 0.75, 0.75),
+                           (0.375, 0.50, 0.50),
+                           (0.500, 0.15, 0.15),
+                           (0.625, 0.00, 0.00),
+                           (0.750, 0.10, 0.10),
+                           (0.875, 0.50, 0.50),
+                           (1.000, 1.00, 1.00))}
+
+
+# An MIT licensed, colorblind-friendly heatmap from Wistia:
+#   https://github.com/wistia/heatmap-palette
+#   https://wistia.com/learn/culture/heatmaps-for-colorblindness
+#
+# >>> import matplotlib.colors as c
+# >>> colors = ["#e4ff7a", "#ffe81a", "#ffbd00", "#ffa000", "#fc7f00"]
+# >>> cm = c.LinearSegmentedColormap.from_list('wistia', colors)
+# >>> _wistia_data = cm._segmentdata
+# >>> del _wistia_data['alpha']
+#
+_wistia_data = {
+    'red': [(0.0, 0.8941176470588236, 0.8941176470588236),
+            (0.25, 1.0, 1.0),
+            (0.5, 1.0, 1.0),
+            (0.75, 1.0, 1.0),
+            (1.0, 0.9882352941176471, 0.9882352941176471)],
+    'green': [(0.0, 1.0, 1.0),
+              (0.25, 0.9098039215686274, 0.9098039215686274),
+              (0.5, 0.7411764705882353, 0.7411764705882353),
+              (0.75, 0.6274509803921569, 0.6274509803921569),
+              (1.0, 0.4980392156862745, 0.4980392156862745)],
+    'blue': [(0.0, 0.47843137254901963, 0.47843137254901963),
+             (0.25, 0.10196078431372549, 0.10196078431372549),
+             (0.5, 0.0, 0.0),
+             (0.75, 0.0, 0.0),
+             (1.0, 0.0, 0.0)],
+}
+
+
+# Categorical palettes from Vega:
+# https://github.com/vega/vega/wiki/Scales
+# (divided by 255)
+#
+
+_tab10_data = (
+    (0.12156862745098039, 0.4666666666666667,  0.7058823529411765  ),  # 1f77b4
+    (1.0,                 0.4980392156862745,  0.054901960784313725),  # ff7f0e
+    (0.17254901960784313, 0.6274509803921569,  0.17254901960784313 ),  # 2ca02c
+    (0.8392156862745098,  0.15294117647058825, 0.1568627450980392  ),  # d62728
+    (0.5803921568627451,  0.403921568627451,   0.7411764705882353  ),  # 9467bd
+    (0.5490196078431373,  0.33725490196078434, 0.29411764705882354 ),  # 8c564b
+    (0.8901960784313725,  0.4666666666666667,  0.7607843137254902  ),  # e377c2
+    (0.4980392156862745,  0.4980392156862745,  0.4980392156862745  ),  # 7f7f7f
+    (0.7372549019607844,  0.7411764705882353,  0.13333333333333333 ),  # bcbd22
+    (0.09019607843137255, 0.7450980392156863,  0.8117647058823529),    # 17becf
+)
+
+_tab20_data = (
+    (0.12156862745098039, 0.4666666666666667,  0.7058823529411765  ),  # 1f77b4
+    (0.6823529411764706,  0.7803921568627451,  0.9098039215686274  ),  # aec7e8
+    (1.0,                 0.4980392156862745,  0.054901960784313725),  # ff7f0e
+    (1.0,                 0.7333333333333333,  0.47058823529411764 ),  # ffbb78
+    (0.17254901960784313, 0.6274509803921569,  0.17254901960784313 ),  # 2ca02c
+    (0.596078431372549,   0.8745098039215686,  0.5411764705882353  ),  # 98df8a
+    (0.8392156862745098,  0.15294117647058825, 0.1568627450980392  ),  # d62728
+    (1.0,                 0.596078431372549,   0.5882352941176471  ),  # ff9896
+    (0.5803921568627451,  0.403921568627451,   0.7411764705882353  ),  # 9467bd
+    (0.7725490196078432,  0.6901960784313725,  0.8352941176470589  ),  # c5b0d5
+    (0.5490196078431373,  0.33725490196078434, 0.29411764705882354 ),  # 8c564b
+    (0.7686274509803922,  0.611764705882353,   0.5803921568627451  ),  # c49c94
+    (0.8901960784313725,  0.4666666666666667,  0.7607843137254902  ),  # e377c2
+    (0.9686274509803922,  0.7137254901960784,  0.8235294117647058  ),  # f7b6d2
+    (0.4980392156862745,  0.4980392156862745,  0.4980392156862745  ),  # 7f7f7f
+    (0.7803921568627451,  0.7803921568627451,  0.7803921568627451  ),  # c7c7c7
+    (0.7372549019607844,  0.7411764705882353,  0.13333333333333333 ),  # bcbd22
+    (0.8588235294117647,  0.8588235294117647,  0.5529411764705883  ),  # dbdb8d
+    (0.09019607843137255, 0.7450980392156863,  0.8117647058823529  ),  # 17becf
+    (0.6196078431372549,  0.8549019607843137,  0.8980392156862745),    # 9edae5
+)
+
+_tab20b_data = (
+    (0.2235294117647059,  0.23137254901960785, 0.4745098039215686 ),  # 393b79
+    (0.3215686274509804,  0.32941176470588235, 0.6392156862745098 ),  # 5254a3
+    (0.4196078431372549,  0.43137254901960786, 0.8117647058823529 ),  # 6b6ecf
+    (0.611764705882353,   0.6196078431372549,  0.8705882352941177 ),  # 9c9ede
+    (0.38823529411764707, 0.4745098039215686,  0.2235294117647059 ),  # 637939
+    (0.5490196078431373,  0.6352941176470588,  0.3215686274509804 ),  # 8ca252
+    (0.7098039215686275,  0.8117647058823529,  0.4196078431372549 ),  # b5cf6b
+    (0.807843137254902,   0.8588235294117647,  0.611764705882353  ),  # cedb9c
+    (0.5490196078431373,  0.42745098039215684, 0.19215686274509805),  # 8c6d31
+    (0.7411764705882353,  0.6196078431372549,  0.2235294117647059 ),  # bd9e39
+    (0.9058823529411765,  0.7294117647058823,  0.3215686274509804 ),  # e7ba52
+    (0.9058823529411765,  0.796078431372549,   0.5803921568627451 ),  # e7cb94
+    (0.5176470588235295,  0.23529411764705882, 0.2235294117647059 ),  # 843c39
+    (0.6784313725490196,  0.28627450980392155, 0.2901960784313726 ),  # ad494a
+    (0.8392156862745098,  0.3803921568627451,  0.4196078431372549 ),  # d6616b
+    (0.9058823529411765,  0.5882352941176471,  0.611764705882353  ),  # e7969c
+    (0.4823529411764706,  0.2549019607843137,  0.45098039215686275),  # 7b4173
+    (0.6470588235294118,  0.3176470588235294,  0.5803921568627451 ),  # a55194
+    (0.807843137254902,   0.42745098039215684, 0.7411764705882353 ),  # ce6dbd
+    (0.8705882352941177,  0.6196078431372549,  0.8392156862745098 ),  # de9ed6
+)
+
+_tab20c_data = (
+    (0.19215686274509805, 0.5098039215686274,  0.7411764705882353  ),  # 3182bd
+    (0.4196078431372549,  0.6823529411764706,  0.8392156862745098  ),  # 6baed6
+    (0.6196078431372549,  0.792156862745098,   0.8823529411764706  ),  # 9ecae1
+    (0.7764705882352941,  0.8588235294117647,  0.9372549019607843  ),  # c6dbef
+    (0.9019607843137255,  0.3333333333333333,  0.050980392156862744),  # e6550d
+    (0.9921568627450981,  0.5529411764705883,  0.23529411764705882 ),  # fd8d3c
+    (0.9921568627450981,  0.6823529411764706,  0.4196078431372549  ),  # fdae6b
+    (0.9921568627450981,  0.8156862745098039,  0.6352941176470588  ),  # fdd0a2
+    (0.19215686274509805, 0.6392156862745098,  0.32941176470588235 ),  # 31a354
+    (0.4549019607843137,  0.7686274509803922,  0.4627450980392157  ),  # 74c476
+    (0.6313725490196078,  0.8509803921568627,  0.6078431372549019  ),  # a1d99b
+    (0.7803921568627451,  0.9137254901960784,  0.7529411764705882  ),  # c7e9c0
+    (0.4588235294117647,  0.4196078431372549,  0.6941176470588235  ),  # 756bb1
+    (0.6196078431372549,  0.6039215686274509,  0.7843137254901961  ),  # 9e9ac8
+    (0.7372549019607844,  0.7411764705882353,  0.8627450980392157  ),  # bcbddc
+    (0.8549019607843137,  0.8549019607843137,  0.9215686274509803  ),  # dadaeb
+    (0.38823529411764707, 0.38823529411764707, 0.38823529411764707 ),  # 636363
+    (0.5882352941176471,  0.5882352941176471,  0.5882352941176471  ),  # 969696
+    (0.7411764705882353,  0.7411764705882353,  0.7411764705882353  ),  # bdbdbd
+    (0.8509803921568627,  0.8509803921568627,  0.8509803921568627  ),  # d9d9d9
+)
+
+
+_petroff10_data = (
+    (0.24705882352941178, 0.5647058823529412,  0.8549019607843137),    # 3f90da
+    (1.0,                 0.6627450980392157,  0.054901960784313725),  # ffa90e
+    (0.7411764705882353,  0.12156862745098039, 0.00392156862745098),   # bd1f01
+    (0.5803921568627451,  0.6431372549019608,  0.6352941176470588),    # 94a4a2
+    (0.5137254901960784,  0.17647058823529413, 0.7137254901960784),    # 832db6
+    (0.6627450980392157,  0.4196078431372549,  0.34901960784313724),   # a96b59
+    (0.9058823529411765,  0.38823529411764707, 0.0),                   # e76300
+    (0.7254901960784313,  0.6745098039215687,  0.4392156862745098),    # b9ac70
+    (0.44313725490196076, 0.4588235294117647,  0.5058823529411764),    # 717581
+    (0.5725490196078431,  0.8549019607843137,  0.8666666666666667),    # 92dadd
+)
+
+
+datad = {
+    'Blues': _Blues_data,
+    'BrBG': _BrBG_data,
+    'BuGn': _BuGn_data,
+    'BuPu': _BuPu_data,
+    'CMRmap': _CMRmap_data,
+    'GnBu': _GnBu_data,
+    'Greens': _Greens_data,
+    'Greys': _Greys_data,
+    'OrRd': _OrRd_data,
+    'Oranges': _Oranges_data,
+    'PRGn': _PRGn_data,
+    'PiYG': _PiYG_data,
+    'PuBu': _PuBu_data,
+    'PuBuGn': _PuBuGn_data,
+    'PuOr': _PuOr_data,
+    'PuRd': _PuRd_data,
+    'Purples': _Purples_data,
+    'RdBu': _RdBu_data,
+    'RdGy': _RdGy_data,
+    'RdPu': _RdPu_data,
+    'RdYlBu': _RdYlBu_data,
+    'RdYlGn': _RdYlGn_data,
+    'Reds': _Reds_data,
+    'Spectral': _Spectral_data,
+    'Wistia': _wistia_data,
+    'YlGn': _YlGn_data,
+    'YlGnBu': _YlGnBu_data,
+    'YlOrBr': _YlOrBr_data,
+    'YlOrRd': _YlOrRd_data,
+    'afmhot': _afmhot_data,
+    'autumn': _autumn_data,
+    'binary': _binary_data,
+    'bone': _bone_data,
+    'brg': _brg_data,
+    'bwr': _bwr_data,
+    'cool': _cool_data,
+    'coolwarm': _coolwarm_data,
+    'copper': _copper_data,
+    'cubehelix': _cubehelix_data,
+    'flag': _flag_data,
+    'gist_earth': _gist_earth_data,
+    'gist_gray': _gist_gray_data,
+    'gist_heat': _gist_heat_data,
+    'gist_ncar': _gist_ncar_data,
+    'gist_rainbow': _gist_rainbow_data,
+    'gist_stern': _gist_stern_data,
+    'gist_yarg': _gist_yarg_data,
+    'gnuplot': _gnuplot_data,
+    'gnuplot2': _gnuplot2_data,
+    'gray': _gray_data,
+    'hot': _hot_data,
+    'hsv': _hsv_data,
+    'jet': _jet_data,
+    'nipy_spectral': _nipy_spectral_data,
+    'ocean': _ocean_data,
+    'pink': _pink_data,
+    'prism': _prism_data,
+    'rainbow': _rainbow_data,
+    'seismic': _seismic_data,
+    'spring': _spring_data,
+    'summer': _summer_data,
+    'terrain': _terrain_data,
+    'winter': _winter_data,
+    # Qualitative
+    'Accent': {'listed': _Accent_data},
+    'Dark2': {'listed': _Dark2_data},
+    'Paired': {'listed': _Paired_data},
+    'Pastel1': {'listed': _Pastel1_data},
+    'Pastel2': {'listed': _Pastel2_data},
+    'Set1': {'listed': _Set1_data},
+    'Set2': {'listed': _Set2_data},
+    'Set3': {'listed': _Set3_data},
+    'tab10': {'listed': _tab10_data},
+    'tab20': {'listed': _tab20_data},
+    'tab20b': {'listed': _tab20b_data},
+    'tab20c': {'listed': _tab20c_data},
+}

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_cm_bivar.py

@@ -0,0 +1,1312 @@
+# auto-generated by https://github.com/trygvrad/multivariate_colormaps
+# date: 2024-05-24
+
+import numpy as np
+from matplotlib.colors import SegmentedBivarColormap
+
+BiPeak = np.array(
+    [0.000, 0.674, 0.931, 0.000, 0.680, 0.922, 0.000, 0.685, 0.914, 0.000,
+     0.691, 0.906, 0.000, 0.696, 0.898, 0.000, 0.701, 0.890, 0.000, 0.706,
+     0.882, 0.000, 0.711, 0.875, 0.000, 0.715, 0.867, 0.000, 0.720, 0.860,
+     0.000, 0.725, 0.853, 0.000, 0.729, 0.845, 0.000, 0.733, 0.838, 0.000,
+     0.737, 0.831, 0.000, 0.741, 0.824, 0.000, 0.745, 0.816, 0.000, 0.749,
+     0.809, 0.000, 0.752, 0.802, 0.000, 0.756, 0.794, 0.000, 0.759, 0.787,
+     0.000, 0.762, 0.779, 0.000, 0.765, 0.771, 0.000, 0.767, 0.764, 0.000,
+     0.770, 0.755, 0.000, 0.772, 0.747, 0.000, 0.774, 0.739, 0.000, 0.776,
+     0.730, 0.000, 0.777, 0.721, 0.000, 0.779, 0.712, 0.021, 0.780, 0.702,
+     0.055, 0.781, 0.693, 0.079, 0.782, 0.682, 0.097, 0.782, 0.672, 0.111,
+     0.782, 0.661, 0.122, 0.782, 0.650, 0.132, 0.782, 0.639, 0.140, 0.781,
+     0.627, 0.147, 0.781, 0.615, 0.154, 0.780, 0.602, 0.159, 0.778, 0.589,
+     0.164, 0.777, 0.576, 0.169, 0.775, 0.563, 0.173, 0.773, 0.549, 0.177,
+     0.771, 0.535, 0.180, 0.768, 0.520, 0.184, 0.766, 0.505, 0.187, 0.763,
+     0.490, 0.190, 0.760, 0.474, 0.193, 0.756, 0.458, 0.196, 0.753, 0.442,
+     0.200, 0.749, 0.425, 0.203, 0.745, 0.408, 0.206, 0.741, 0.391, 0.210,
+     0.736, 0.373, 0.213, 0.732, 0.355, 0.216, 0.727, 0.337, 0.220, 0.722,
+     0.318, 0.224, 0.717, 0.298, 0.227, 0.712, 0.278, 0.231, 0.707, 0.258,
+     0.235, 0.701, 0.236, 0.239, 0.696, 0.214, 0.242, 0.690, 0.190, 0.246,
+     0.684, 0.165, 0.250, 0.678, 0.136, 0.000, 0.675, 0.934, 0.000, 0.681,
+     0.925, 0.000, 0.687, 0.917, 0.000, 0.692, 0.909, 0.000, 0.697, 0.901,
+     0.000, 0.703, 0.894, 0.000, 0.708, 0.886, 0.000, 0.713, 0.879, 0.000,
+     0.718, 0.872, 0.000, 0.722, 0.864, 0.000, 0.727, 0.857, 0.000, 0.731,
+     0.850, 0.000, 0.736, 0.843, 0.000, 0.740, 0.836, 0.000, 0.744, 0.829,
+     0.000, 0.748, 0.822, 0.000, 0.752, 0.815, 0.000, 0.755, 0.808, 0.000,
+     0.759, 0.800, 0.000, 0.762, 0.793, 0.000, 0.765, 0.786, 0.000, 0.768,
+     0.778, 0.000, 0.771, 0.770, 0.000, 0.773, 0.762, 0.051, 0.776, 0.754,
+     0.087, 0.778, 0.746, 0.111, 0.780, 0.737, 0.131, 0.782, 0.728, 0.146,
+     0.783, 0.719, 0.159, 0.784, 0.710, 0.171, 0.785, 0.700, 0.180, 0.786,
+     0.690, 0.189, 0.786, 0.680, 0.196, 0.787, 0.669, 0.202, 0.787, 0.658,
+     0.208, 0.786, 0.647, 0.213, 0.786, 0.635, 0.217, 0.785, 0.623, 0.221,
+     0.784, 0.610, 0.224, 0.782, 0.597, 0.227, 0.781, 0.584, 0.230, 0.779,
+     0.570, 0.232, 0.777, 0.556, 0.234, 0.775, 0.542, 0.236, 0.772, 0.527,
+     0.238, 0.769, 0.512, 0.240, 0.766, 0.497, 0.242, 0.763, 0.481, 0.244,
+     0.760, 0.465, 0.246, 0.756, 0.448, 0.248, 0.752, 0.432, 0.250, 0.748,
+     0.415, 0.252, 0.744, 0.397, 0.254, 0.739, 0.379, 0.256, 0.735, 0.361,
+     0.259, 0.730, 0.343, 0.261, 0.725, 0.324, 0.264, 0.720, 0.304, 0.266,
+     0.715, 0.284, 0.269, 0.709, 0.263, 0.271, 0.704, 0.242, 0.274, 0.698,
+     0.220, 0.277, 0.692, 0.196, 0.280, 0.686, 0.170, 0.283, 0.680, 0.143,
+     0.000, 0.676, 0.937, 0.000, 0.682, 0.928, 0.000, 0.688, 0.920, 0.000,
+     0.694, 0.913, 0.000, 0.699, 0.905, 0.000, 0.704, 0.897, 0.000, 0.710,
+     0.890, 0.000, 0.715, 0.883, 0.000, 0.720, 0.876, 0.000, 0.724, 0.869,
+     0.000, 0.729, 0.862, 0.000, 0.734, 0.855, 0.000, 0.738, 0.848, 0.000,
+     0.743, 0.841, 0.000, 0.747, 0.834, 0.000, 0.751, 0.827, 0.000, 0.755,
+     0.820, 0.000, 0.759, 0.813, 0.000, 0.762, 0.806, 0.003, 0.766, 0.799,
+     0.066, 0.769, 0.792, 0.104, 0.772, 0.784, 0.131, 0.775, 0.777, 0.152,
+     0.777, 0.769, 0.170, 0.780, 0.761, 0.185, 0.782, 0.753, 0.198, 0.784,
+     0.744, 0.209, 0.786, 0.736, 0.219, 0.787, 0.727, 0.228, 0.788, 0.717,
+     0.236, 0.789, 0.708, 0.243, 0.790, 0.698, 0.249, 0.791, 0.688, 0.254,
+     0.791, 0.677, 0.259, 0.791, 0.666, 0.263, 0.791, 0.654, 0.266, 0.790,
+     0.643, 0.269, 0.789, 0.631, 0.272, 0.788, 0.618, 0.274, 0.787, 0.605,
+     0.276, 0.785, 0.592, 0.278, 0.783, 0.578, 0.279, 0.781, 0.564, 0.280,
+     0.779, 0.549, 0.282, 0.776, 0.535, 0.283, 0.773, 0.519, 0.284, 0.770,
+     0.504, 0.285, 0.767, 0.488, 0.286, 0.763, 0.472, 0.287, 0.759, 0.455,
+     0.288, 0.756, 0.438, 0.289, 0.751, 0.421, 0.291, 0.747, 0.403, 0.292,
+     0.742, 0.385, 0.293, 0.738, 0.367, 0.295, 0.733, 0.348, 0.296, 0.728,
+     0.329, 0.298, 0.723, 0.310, 0.300, 0.717, 0.290, 0.302, 0.712, 0.269,
+     0.304, 0.706, 0.247, 0.306, 0.700, 0.225, 0.308, 0.694, 0.201, 0.310,
+     0.688, 0.176, 0.312, 0.682, 0.149, 0.000, 0.678, 0.939, 0.000, 0.683,
+     0.931, 0.000, 0.689, 0.923, 0.000, 0.695, 0.916, 0.000, 0.701, 0.908,
+     0.000, 0.706, 0.901, 0.000, 0.711, 0.894, 0.000, 0.717, 0.887, 0.000,
+     0.722, 0.880, 0.000, 0.727, 0.873, 0.000, 0.732, 0.866, 0.000, 0.736,
+     0.859, 0.000, 0.741, 0.853, 0.000, 0.745, 0.846, 0.000, 0.750, 0.839,
+     0.000, 0.754, 0.833, 0.035, 0.758, 0.826, 0.091, 0.762, 0.819, 0.126,
+     0.765, 0.812, 0.153, 0.769, 0.805, 0.174, 0.772, 0.798, 0.193, 0.775,
+     0.791, 0.209, 0.778, 0.783, 0.223, 0.781, 0.776, 0.236, 0.784, 0.768,
+     0.247, 0.786, 0.760, 0.257, 0.788, 0.752, 0.266, 0.790, 0.743, 0.273,
+     0.791, 0.734, 0.280, 0.793, 0.725, 0.287, 0.794, 0.715, 0.292, 0.794,
+     0.706, 0.297, 0.795, 0.695, 0.301, 0.795, 0.685, 0.305, 0.795, 0.674,
+     0.308, 0.795, 0.662, 0.310, 0.794, 0.651, 0.312, 0.794, 0.638, 0.314,
+     0.792, 0.626, 0.316, 0.791, 0.613, 0.317, 0.789, 0.599, 0.318, 0.787,
+     0.586, 0.319, 0.785, 0.571, 0.320, 0.783, 0.557, 0.320, 0.780, 0.542,
+     0.321, 0.777, 0.527, 0.321, 0.774, 0.511, 0.322, 0.770, 0.495, 0.322,
+     0.767, 0.478, 0.323, 0.763, 0.462, 0.323, 0.759, 0.445, 0.324, 0.755,
+     0.427, 0.325, 0.750, 0.410, 0.325, 0.745, 0.391, 0.326, 0.741, 0.373,
+     0.327, 0.736, 0.354, 0.328, 0.730, 0.335, 0.329, 0.725, 0.315, 0.330,
+     0.720, 0.295, 0.331, 0.714, 0.274, 0.333, 0.708, 0.253, 0.334, 0.702,
+     0.230, 0.336, 0.696, 0.207, 0.337, 0.690, 0.182, 0.339, 0.684, 0.154,
+     0.000, 0.679, 0.942, 0.000, 0.685, 0.934, 0.000, 0.691, 0.927, 0.000,
+     0.696, 0.919, 0.000, 0.702, 0.912, 0.000, 0.708, 0.905, 0.000, 0.713,
+     0.898, 0.000, 0.718, 0.891, 0.000, 0.724, 0.884, 0.000, 0.729, 0.877,
+     0.000, 0.734, 0.871, 0.000, 0.739, 0.864, 0.000, 0.743, 0.857, 0.035,
+     0.748, 0.851, 0.096, 0.752, 0.844, 0.133, 0.757, 0.838, 0.161, 0.761,
+     0.831, 0.185, 0.765, 0.825, 0.205, 0.769, 0.818, 0.223, 0.772, 0.811,
+     0.238, 0.776, 0.804, 0.252, 0.779, 0.797, 0.265, 0.782, 0.790, 0.276,
+     0.785, 0.783, 0.286, 0.788, 0.775, 0.296, 0.790, 0.767, 0.304, 0.792,
+     0.759, 0.311, 0.794, 0.751, 0.318, 0.796, 0.742, 0.324, 0.797, 0.733,
+     0.329, 0.798, 0.723, 0.334, 0.799, 0.714, 0.338, 0.799, 0.703, 0.341,
+     0.800, 0.693, 0.344, 0.800, 0.682, 0.347, 0.799, 0.670, 0.349, 0.799,
+     0.659, 0.351, 0.798, 0.646, 0.352, 0.797, 0.634, 0.353, 0.795, 0.621,
+     0.354, 0.794, 0.607, 0.354, 0.792, 0.593, 0.355, 0.789, 0.579, 0.355,
+     0.787, 0.564, 0.355, 0.784, 0.549, 0.355, 0.781, 0.534, 0.355, 0.778,
+     0.518, 0.355, 0.774, 0.502, 0.355, 0.770, 0.485, 0.355, 0.766, 0.468,
+     0.355, 0.762, 0.451, 0.355, 0.758, 0.434, 0.355, 0.753, 0.416, 0.356,
+     0.748, 0.397, 0.356, 0.743, 0.379, 0.356, 0.738, 0.360, 0.357, 0.733,
+     0.340, 0.357, 0.728, 0.321, 0.358, 0.722, 0.300, 0.359, 0.716, 0.279,
+     0.360, 0.710, 0.258, 0.361, 0.704, 0.235, 0.361, 0.698, 0.212, 0.362,
+     0.692, 0.187, 0.363, 0.686, 0.160, 0.000, 0.680, 0.945, 0.000, 0.686,
+     0.937, 0.000, 0.692, 0.930, 0.000, 0.698, 0.922, 0.000, 0.703, 0.915,
+     0.000, 0.709, 0.908, 0.000, 0.715, 0.901, 0.000, 0.720, 0.894, 0.000,
+     0.726, 0.888, 0.000, 0.731, 0.881, 0.007, 0.736, 0.875, 0.084, 0.741,
+     0.869, 0.127, 0.746, 0.862, 0.159, 0.751, 0.856, 0.185, 0.755, 0.850,
+     0.208, 0.760, 0.843, 0.227, 0.764, 0.837, 0.245, 0.768, 0.830, 0.260,
+     0.772, 0.824, 0.275, 0.776, 0.817, 0.288, 0.779, 0.811, 0.300, 0.783,
+     0.804, 0.310, 0.786, 0.797, 0.320, 0.789, 0.789, 0.329, 0.792, 0.782,
+     0.337, 0.794, 0.774, 0.345, 0.796, 0.766, 0.351, 0.798, 0.758, 0.357,
+     0.800, 0.749, 0.363, 0.801, 0.740, 0.367, 0.803, 0.731, 0.371, 0.803,
+     0.721, 0.375, 0.804, 0.711, 0.378, 0.804, 0.701, 0.380, 0.804, 0.690,
+     0.382, 0.804, 0.679, 0.384, 0.803, 0.667, 0.385, 0.802, 0.654, 0.386,
+     0.801, 0.642, 0.386, 0.800, 0.629, 0.387, 0.798, 0.615, 0.387, 0.796,
+     0.601, 0.387, 0.793, 0.587, 0.387, 0.791, 0.572, 0.387, 0.788, 0.557,
+     0.386, 0.785, 0.541, 0.386, 0.781, 0.525, 0.385, 0.778, 0.509, 0.385,
+     0.774, 0.492, 0.385, 0.770, 0.475, 0.384, 0.765, 0.457, 0.384, 0.761,
+     0.440, 0.384, 0.756, 0.422, 0.384, 0.751, 0.403, 0.384, 0.746, 0.384,
+     0.384, 0.741, 0.365, 0.384, 0.735, 0.346, 0.384, 0.730, 0.326, 0.384,
+     0.724, 0.305, 0.384, 0.718, 0.284, 0.385, 0.712, 0.263, 0.385, 0.706,
+     0.240, 0.386, 0.700, 0.217, 0.386, 0.694, 0.192, 0.387, 0.687, 0.165,
+     0.000, 0.680, 0.948, 0.000, 0.687, 0.940, 0.000, 0.693, 0.933, 0.000,
+     0.699, 0.925, 0.000, 0.705, 0.918, 0.000, 0.711, 0.912, 0.000, 0.716,
+     0.905, 0.000, 0.722, 0.898, 0.050, 0.728, 0.892, 0.109, 0.733, 0.886,
+     0.147, 0.738, 0.879, 0.177, 0.743, 0.873, 0.202, 0.748, 0.867, 0.224,
+     0.753, 0.861, 0.243, 0.758, 0.855, 0.261, 0.763, 0.849, 0.277, 0.767,
+     0.842, 0.292, 0.771, 0.836, 0.305, 0.775, 0.830, 0.318, 0.779, 0.823,
+     0.329, 0.783, 0.817, 0.340, 0.787, 0.810, 0.350, 0.790, 0.803, 0.359,
+     0.793, 0.796, 0.367, 0.796, 0.789, 0.374, 0.798, 0.782, 0.381, 0.801,
+     0.774, 0.387, 0.803, 0.766, 0.393, 0.804, 0.757, 0.397, 0.806, 0.748,
+     0.402, 0.807, 0.739, 0.405, 0.808, 0.729, 0.408, 0.809, 0.719, 0.411,
+     0.809, 0.709, 0.413, 0.809, 0.698, 0.415, 0.808, 0.687, 0.416, 0.808,
+     0.675, 0.417, 0.807, 0.663, 0.417, 0.806, 0.650, 0.417, 0.804, 0.637,
+     0.418, 0.802, 0.623, 0.417, 0.800, 0.609, 0.417, 0.798, 0.594, 0.416,
+     0.795, 0.579, 0.416, 0.792, 0.564, 0.415, 0.789, 0.548, 0.414, 0.785,
+     0.532, 0.414, 0.781, 0.515, 0.413, 0.777, 0.499, 0.412, 0.773, 0.481,
+     0.412, 0.769, 0.464, 0.411, 0.764, 0.446, 0.410, 0.759, 0.428, 0.410,
+     0.754, 0.409, 0.409, 0.749, 0.390, 0.409, 0.743, 0.371, 0.409, 0.738,
+     0.351, 0.409, 0.732, 0.331, 0.408, 0.726, 0.310, 0.408, 0.720, 0.289,
+     0.408, 0.714, 0.268, 0.408, 0.708, 0.245, 0.409, 0.702, 0.222, 0.409,
+     0.695, 0.197, 0.409, 0.689, 0.170, 0.000, 0.681, 0.950, 0.000, 0.688,
+     0.943, 0.000, 0.694, 0.936, 0.000, 0.700, 0.929, 0.000, 0.706, 0.922,
+     0.000, 0.712, 0.915, 0.074, 0.718, 0.908, 0.124, 0.724, 0.902, 0.159,
+     0.730, 0.896, 0.188, 0.735, 0.890, 0.213, 0.740, 0.884, 0.235, 0.746,
+     0.878, 0.255, 0.751, 0.872, 0.273, 0.756, 0.866, 0.289, 0.761, 0.860,
+     0.305, 0.766, 0.854, 0.319, 0.770, 0.848, 0.332, 0.775, 0.842, 0.344,
+     0.779, 0.836, 0.356, 0.783, 0.830, 0.366, 0.787, 0.823, 0.376, 0.790,
+     0.817, 0.385, 0.794, 0.810, 0.394, 0.797, 0.803, 0.401, 0.800, 0.796,
+     0.408, 0.802, 0.789, 0.414, 0.805, 0.781, 0.420, 0.807, 0.773, 0.425,
+     0.809, 0.765, 0.430, 0.810, 0.756, 0.433, 0.812, 0.747, 0.437, 0.813,
+     0.738, 0.440, 0.813, 0.728, 0.442, 0.814, 0.717, 0.444, 0.813, 0.706,
+     0.445, 0.813, 0.695, 0.446, 0.812, 0.683, 0.446, 0.811, 0.671, 0.447,
+     0.810, 0.658, 0.447, 0.809, 0.645, 0.446, 0.807, 0.631, 0.446, 0.804,
+     0.617, 0.445, 0.802, 0.602, 0.444, 0.799, 0.587, 0.443, 0.796, 0.571,
+     0.442, 0.792, 0.555, 0.441, 0.789, 0.539, 0.440, 0.785, 0.522, 0.439,
+     0.781, 0.505, 0.438, 0.776, 0.488, 0.437, 0.772, 0.470, 0.436, 0.767,
+     0.452, 0.435, 0.762, 0.433, 0.435, 0.757, 0.415, 0.434, 0.751, 0.396,
+     0.433, 0.746, 0.376, 0.432, 0.740, 0.356, 0.432, 0.734, 0.336, 0.431,
+     0.728, 0.315, 0.431, 0.722, 0.294, 0.431, 0.716, 0.272, 0.430, 0.710,
+     0.250, 0.430, 0.703, 0.226, 0.430, 0.697, 0.201, 0.430, 0.690, 0.175,
+     0.000, 0.682, 0.953, 0.000, 0.689, 0.946, 0.000, 0.695, 0.938, 0.002,
+     0.701, 0.932, 0.086, 0.708, 0.925, 0.133, 0.714, 0.918, 0.167, 0.720,
+     0.912, 0.196, 0.726, 0.906, 0.221, 0.731, 0.900, 0.243, 0.737, 0.894,
+     0.263, 0.743, 0.888, 0.281, 0.748, 0.882, 0.298, 0.753, 0.876, 0.314,
+     0.759, 0.870, 0.329, 0.764, 0.865, 0.342, 0.768, 0.859, 0.355, 0.773,
+     0.853, 0.368, 0.778, 0.847, 0.379, 0.782, 0.842, 0.390, 0.786, 0.836,
+     0.400, 0.790, 0.830, 0.409, 0.794, 0.823, 0.417, 0.798, 0.817, 0.425,
+     0.801, 0.810, 0.433, 0.804, 0.803, 0.439, 0.807, 0.796, 0.445, 0.809,
+     0.789, 0.451, 0.811, 0.781, 0.456, 0.813, 0.773, 0.460, 0.815, 0.764,
+     0.463, 0.816, 0.755, 0.466, 0.817, 0.746, 0.469, 0.818, 0.736, 0.471,
+     0.818, 0.725, 0.472, 0.818, 0.715, 0.473, 0.818, 0.703, 0.474, 0.817,
+     0.691, 0.474, 0.816, 0.679, 0.474, 0.815, 0.666, 0.474, 0.813, 0.653,
+     0.473, 0.811, 0.639, 0.473, 0.809, 0.624, 0.472, 0.806, 0.610, 0.471,
+     0.803, 0.594, 0.469, 0.800, 0.579, 0.468, 0.796, 0.562, 0.467, 0.792,
+     0.546, 0.466, 0.788, 0.529, 0.464, 0.784, 0.512, 0.463, 0.780, 0.494,
+     0.462, 0.775, 0.476, 0.460, 0.770, 0.458, 0.459, 0.765, 0.439, 0.458,
+     0.759, 0.420, 0.457, 0.754, 0.401, 0.456, 0.748, 0.381, 0.455, 0.742,
+     0.361, 0.454, 0.736, 0.341, 0.453, 0.730, 0.320, 0.453, 0.724, 0.299,
+     0.452, 0.718, 0.277, 0.452, 0.711, 0.254, 0.451, 0.705, 0.231, 0.451,
+     0.698, 0.206, 0.450, 0.691, 0.179, 0.000, 0.683, 0.955, 0.013, 0.689,
+     0.948, 0.092, 0.696, 0.941, 0.137, 0.702, 0.935, 0.171, 0.709, 0.928,
+     0.200, 0.715, 0.922, 0.225, 0.721, 0.916, 0.247, 0.727, 0.909, 0.267,
+     0.733, 0.904, 0.286, 0.739, 0.898, 0.303, 0.745, 0.892, 0.320, 0.750,
+     0.886, 0.335, 0.756, 0.881, 0.350, 0.761, 0.875, 0.363, 0.766, 0.870,
+     0.376, 0.771, 0.864, 0.388, 0.776, 0.859, 0.400, 0.781, 0.853, 0.411,
+     0.785, 0.847, 0.421, 0.790, 0.842, 0.430, 0.794, 0.836, 0.439, 0.798,
+     0.830, 0.448, 0.802, 0.824, 0.455, 0.805, 0.817, 0.462, 0.808, 0.810,
+     0.469, 0.811, 0.804, 0.475, 0.814, 0.796, 0.480, 0.816, 0.789, 0.484,
+     0.818, 0.781, 0.488, 0.820, 0.772, 0.492, 0.821, 0.763, 0.495, 0.822,
+     0.754, 0.497, 0.823, 0.744, 0.499, 0.823, 0.734, 0.500, 0.823, 0.723,
+     0.501, 0.823, 0.712, 0.501, 0.822, 0.700, 0.501, 0.821, 0.687, 0.501,
+     0.819, 0.674, 0.500, 0.818, 0.661, 0.499, 0.815, 0.647, 0.498, 0.813,
+     0.632, 0.497, 0.810, 0.617, 0.496, 0.807, 0.602, 0.494, 0.804, 0.586,
+     0.493, 0.800, 0.569, 0.491, 0.796, 0.553, 0.490, 0.792, 0.536, 0.488,
+     0.787, 0.518, 0.486, 0.783, 0.500, 0.485, 0.778, 0.482, 0.483, 0.773,
+     0.463, 0.482, 0.767, 0.445, 0.480, 0.762, 0.425, 0.479, 0.756, 0.406,
+     0.478, 0.750, 0.386, 0.477, 0.744, 0.366, 0.476, 0.738, 0.345, 0.475,
+     0.732, 0.325, 0.474, 0.726, 0.303, 0.473, 0.719, 0.281, 0.472, 0.713,
+     0.258, 0.471, 0.706, 0.235, 0.470, 0.699, 0.210, 0.469, 0.692, 0.184,
+     0.095, 0.683, 0.958, 0.139, 0.690, 0.951, 0.173, 0.697, 0.944, 0.201,
+     0.703, 0.938, 0.226, 0.710, 0.931, 0.249, 0.716, 0.925, 0.269, 0.723,
+     0.919, 0.288, 0.729, 0.913, 0.306, 0.735, 0.907, 0.323, 0.741, 0.902,
+     0.339, 0.747, 0.896, 0.354, 0.752, 0.891, 0.368, 0.758, 0.885, 0.382,
+     0.764, 0.880, 0.394, 0.769, 0.875, 0.407, 0.774, 0.869, 0.418, 0.779,
+     0.864, 0.429, 0.784, 0.859, 0.440, 0.789, 0.853, 0.450, 0.793, 0.848,
+     0.459, 0.798, 0.842, 0.468, 0.802, 0.836, 0.476, 0.806, 0.830, 0.483,
+     0.809, 0.824, 0.490, 0.812, 0.818, 0.496, 0.815, 0.811, 0.502, 0.818,
+     0.804, 0.507, 0.821, 0.796, 0.512, 0.823, 0.789, 0.515, 0.825, 0.780,
+     0.519, 0.826, 0.772, 0.521, 0.827, 0.762, 0.524, 0.828, 0.753, 0.525,
+     0.828, 0.742, 0.526, 0.828, 0.732, 0.527, 0.828, 0.720, 0.527, 0.827,
+     0.708, 0.527, 0.826, 0.696, 0.526, 0.824, 0.683, 0.525, 0.822, 0.669,
+     0.524, 0.820, 0.655, 0.523, 0.817, 0.640, 0.522, 0.814, 0.625, 0.520,
+     0.811, 0.609, 0.518, 0.808, 0.593, 0.516, 0.804, 0.576, 0.515, 0.800,
+     0.559, 0.513, 0.795, 0.542, 0.511, 0.791, 0.524, 0.509, 0.786, 0.506,
+     0.507, 0.781, 0.488, 0.505, 0.775, 0.469, 0.504, 0.770, 0.450, 0.502,
+     0.764, 0.431, 0.500, 0.759, 0.411, 0.499, 0.753, 0.391, 0.497, 0.746,
+     0.371, 0.496, 0.740, 0.350, 0.495, 0.734, 0.329, 0.494, 0.727, 0.307,
+     0.492, 0.721, 0.285, 0.491, 0.714, 0.262, 0.490, 0.707, 0.239, 0.489,
+     0.700, 0.214, 0.488, 0.693, 0.188, 0.172, 0.684, 0.961, 0.201, 0.691,
+     0.954, 0.226, 0.698, 0.947, 0.248, 0.704, 0.941, 0.269, 0.711, 0.934,
+     0.289, 0.717, 0.928, 0.307, 0.724, 0.922, 0.324, 0.730, 0.917, 0.340,
+     0.736, 0.911, 0.356, 0.743, 0.906, 0.370, 0.749, 0.900, 0.384, 0.755,
+     0.895, 0.398, 0.760, 0.890, 0.411, 0.766, 0.885, 0.423, 0.772, 0.880,
+     0.435, 0.777, 0.874, 0.446, 0.782, 0.869, 0.457, 0.787, 0.864, 0.467,
+     0.792, 0.859, 0.477, 0.797, 0.854, 0.486, 0.801, 0.848, 0.494, 0.806,
+     0.843, 0.502, 0.810, 0.837, 0.510, 0.813, 0.831, 0.517, 0.817, 0.825,
+     0.523, 0.820, 0.818, 0.528, 0.823, 0.811, 0.533, 0.825, 0.804, 0.538,
+     0.828, 0.797, 0.542, 0.829, 0.788, 0.545, 0.831, 0.780, 0.547, 0.832,
+     0.771, 0.549, 0.833, 0.761, 0.551, 0.833, 0.751, 0.552, 0.833, 0.740,
+     0.552, 0.833, 0.729, 0.552, 0.832, 0.717, 0.551, 0.830, 0.704, 0.551,
+     0.829, 0.691, 0.550, 0.827, 0.677, 0.548, 0.824, 0.663, 0.547, 0.822,
+     0.648, 0.545, 0.819, 0.632, 0.543, 0.815, 0.617, 0.541, 0.812, 0.600,
+     0.539, 0.808, 0.583, 0.537, 0.803, 0.566, 0.535, 0.799, 0.549, 0.533,
+     0.794, 0.531, 0.531, 0.789, 0.512, 0.529, 0.784, 0.494, 0.527, 0.778,
+     0.475, 0.525, 0.773, 0.455, 0.523, 0.767, 0.436, 0.521, 0.761, 0.416,
+     0.519, 0.755, 0.396, 0.517, 0.748, 0.375, 0.516, 0.742, 0.354, 0.514,
+     0.735, 0.333, 0.513, 0.729, 0.311, 0.511, 0.722, 0.289, 0.510, 0.715,
+     0.266, 0.509, 0.708, 0.242, 0.507, 0.701, 0.218, 0.506, 0.694, 0.191,
+     0.224, 0.684, 0.963, 0.247, 0.691, 0.956, 0.268, 0.698, 0.950, 0.287,
+     0.705, 0.943, 0.305, 0.712, 0.937, 0.323, 0.719, 0.931, 0.339, 0.725,
+     0.926, 0.355, 0.732, 0.920, 0.370, 0.738, 0.915, 0.385, 0.744, 0.909,
+     0.399, 0.751, 0.904, 0.412, 0.757, 0.899, 0.425, 0.763, 0.894, 0.438,
+     0.768, 0.889, 0.450, 0.774, 0.884, 0.461, 0.780, 0.879, 0.472, 0.785,
+     0.875, 0.483, 0.790, 0.870, 0.493, 0.795, 0.865, 0.502, 0.800, 0.860,
+     0.511, 0.805, 0.855, 0.520, 0.809, 0.849, 0.528, 0.814, 0.844, 0.535,
+     0.818, 0.838, 0.542, 0.821, 0.832, 0.548, 0.824, 0.826, 0.554, 0.827,
+     0.819, 0.559, 0.830, 0.812, 0.563, 0.832, 0.805, 0.567, 0.834, 0.797,
+     0.570, 0.836, 0.788, 0.572, 0.837, 0.779, 0.574, 0.838, 0.770, 0.575,
+     0.838, 0.760, 0.576, 0.838, 0.749, 0.576, 0.838, 0.737, 0.576, 0.837,
+     0.725, 0.575, 0.835, 0.713, 0.574, 0.834, 0.699, 0.573, 0.831, 0.685,
+     0.571, 0.829, 0.671, 0.570, 0.826, 0.656, 0.568, 0.823, 0.640, 0.566,
+     0.819, 0.624, 0.563, 0.815, 0.607, 0.561, 0.811, 0.590, 0.559, 0.807,
+     0.573, 0.556, 0.802, 0.555, 0.554, 0.797, 0.537, 0.552, 0.792, 0.518,
+     0.549, 0.786, 0.499, 0.547, 0.781, 0.480, 0.545, 0.775, 0.460, 0.543,
+     0.769, 0.441, 0.541, 0.763, 0.420, 0.539, 0.756, 0.400, 0.537, 0.750,
+     0.379, 0.535, 0.743, 0.358, 0.533, 0.737, 0.337, 0.531, 0.730, 0.315,
+     0.530, 0.723, 0.293, 0.528, 0.716, 0.270, 0.527, 0.709, 0.246, 0.525,
+     0.702, 0.221, 0.524, 0.694, 0.195, 0.265, 0.685, 0.965, 0.284, 0.692,
+     0.959, 0.303, 0.699, 0.952, 0.320, 0.706, 0.946, 0.337, 0.713, 0.940,
+     0.353, 0.720, 0.935, 0.369, 0.726, 0.929, 0.384, 0.733, 0.924, 0.398,
+     0.739, 0.918, 0.412, 0.746, 0.913, 0.425, 0.752, 0.908, 0.438, 0.759,
+     0.903, 0.451, 0.765, 0.899, 0.463, 0.771, 0.894, 0.475, 0.777, 0.889,
+     0.486, 0.782, 0.884, 0.497, 0.788, 0.880, 0.507, 0.793, 0.875, 0.517,
+     0.799, 0.870, 0.527, 0.804, 0.866, 0.536, 0.809, 0.861, 0.544, 0.813,
+     0.856, 0.552, 0.818, 0.850, 0.560, 0.822, 0.845, 0.566, 0.826, 0.839,
+     0.573, 0.829, 0.833, 0.578, 0.832, 0.827, 0.583, 0.835, 0.820, 0.587,
+     0.837, 0.813, 0.591, 0.839, 0.805, 0.594, 0.841, 0.797, 0.596, 0.842,
+     0.788, 0.598, 0.843, 0.778, 0.599, 0.843, 0.768, 0.600, 0.843, 0.758,
+     0.600, 0.843, 0.746, 0.599, 0.842, 0.734, 0.599, 0.840, 0.721, 0.597,
+     0.838, 0.708, 0.596, 0.836, 0.694, 0.594, 0.834, 0.679, 0.592, 0.831,
+     0.663, 0.590, 0.827, 0.648, 0.587, 0.823, 0.631, 0.585, 0.819, 0.614,
+     0.582, 0.815, 0.597, 0.580, 0.810, 0.579, 0.577, 0.805, 0.561, 0.575,
+     0.800, 0.542, 0.572, 0.795, 0.524, 0.569, 0.789, 0.504, 0.567, 0.783,
+     0.485, 0.565, 0.777, 0.465, 0.562, 0.771, 0.445, 0.560, 0.765, 0.425,
+     0.558, 0.758, 0.404, 0.556, 0.752, 0.383, 0.554, 0.745, 0.362, 0.552,
+     0.738, 0.341, 0.550, 0.731, 0.319, 0.548, 0.724, 0.296, 0.546, 0.717,
+     0.273, 0.544, 0.709, 0.249, 0.542, 0.702, 0.224, 0.541, 0.695, 0.198,
+     0.299, 0.685, 0.968, 0.317, 0.692, 0.961, 0.334, 0.699, 0.955, 0.350,
+     0.706, 0.949, 0.366, 0.713, 0.943, 0.381, 0.720, 0.938, 0.395, 0.727,
+     0.932, 0.410, 0.734, 0.927, 0.423, 0.741, 0.922, 0.437, 0.747, 0.917,
+     0.450, 0.754, 0.912, 0.463, 0.760, 0.907, 0.475, 0.767, 0.903, 0.487,
+     0.773, 0.898, 0.498, 0.779, 0.894, 0.509, 0.785, 0.889, 0.520, 0.791,
+     0.885, 0.531, 0.796, 0.880, 0.540, 0.802, 0.876, 0.550, 0.807, 0.871,
+     0.559, 0.812, 0.867, 0.568, 0.817, 0.862, 0.576, 0.822, 0.857, 0.583,
+     0.826, 0.852, 0.590, 0.830, 0.847, 0.596, 0.834, 0.841, 0.602, 0.837,
+     0.835, 0.607, 0.840, 0.828, 0.611, 0.843, 0.821, 0.615, 0.845, 0.814,
+     0.618, 0.846, 0.805, 0.620, 0.848, 0.797, 0.622, 0.848, 0.787, 0.623,
+     0.849, 0.777, 0.623, 0.849, 0.766, 0.623, 0.848, 0.755, 0.622, 0.847,
+     0.743, 0.621, 0.845, 0.730, 0.620, 0.843, 0.716, 0.618, 0.841, 0.702,
+     0.616, 0.838, 0.687, 0.613, 0.835, 0.671, 0.611, 0.831, 0.655, 0.608,
+     0.827, 0.638, 0.606, 0.823, 0.621, 0.603, 0.818, 0.604, 0.600, 0.814,
+     0.585, 0.597, 0.808, 0.567, 0.594, 0.803, 0.548, 0.592, 0.797, 0.529,
+     0.589, 0.792, 0.510, 0.586, 0.785, 0.490, 0.584, 0.779, 0.470, 0.581,
+     0.773, 0.450, 0.579, 0.766, 0.429, 0.576, 0.760, 0.408, 0.574, 0.753,
+     0.387, 0.572, 0.746, 0.366, 0.569, 0.739, 0.344, 0.567, 0.732, 0.322,
+     0.565, 0.725, 0.299, 0.563, 0.717, 0.276, 0.561, 0.710, 0.252, 0.559,
+     0.703, 0.227, 0.557, 0.695, 0.201, 0.329, 0.685, 0.970, 0.346, 0.692,
+     0.964, 0.362, 0.699, 0.958, 0.377, 0.707, 0.952, 0.392, 0.714, 0.946,
+     0.406, 0.721, 0.941, 0.420, 0.728, 0.935, 0.434, 0.735, 0.930, 0.447,
+     0.742, 0.925, 0.460, 0.749, 0.920, 0.473, 0.756, 0.916, 0.485, 0.762,
+     0.911, 0.497, 0.769, 0.907, 0.509, 0.775, 0.903, 0.521, 0.781, 0.898,
+     0.532, 0.788, 0.894, 0.542, 0.794, 0.890, 0.553, 0.799, 0.886, 0.563,
+     0.805, 0.882, 0.572, 0.811, 0.877, 0.581, 0.816, 0.873, 0.590, 0.821,
+     0.868, 0.598, 0.826, 0.864, 0.606, 0.830, 0.859, 0.613, 0.834, 0.854,
+     0.619, 0.838, 0.848, 0.625, 0.842, 0.842, 0.630, 0.845, 0.836, 0.634,
+     0.848, 0.829, 0.638, 0.850, 0.822, 0.641, 0.852, 0.814, 0.643, 0.853,
+     0.805, 0.645, 0.854, 0.796, 0.645, 0.854, 0.786, 0.646, 0.854, 0.775,
+     0.645, 0.853, 0.764, 0.645, 0.852, 0.751, 0.643, 0.851, 0.738, 0.642,
+     0.848, 0.725, 0.639, 0.846, 0.710, 0.637, 0.843, 0.695, 0.635, 0.839,
+     0.679, 0.632, 0.836, 0.662, 0.629, 0.831, 0.645, 0.626, 0.827, 0.628,
+     0.623, 0.822, 0.610, 0.620, 0.817, 0.592, 0.617, 0.811, 0.573, 0.614,
+     0.806, 0.554, 0.611, 0.800, 0.534, 0.608, 0.794, 0.515, 0.605, 0.788,
+     0.495, 0.602, 0.781, 0.474, 0.599, 0.775, 0.454, 0.597, 0.768, 0.433,
+     0.594, 0.761, 0.412, 0.592, 0.754, 0.391, 0.589, 0.747, 0.369, 0.587,
+     0.740, 0.347, 0.584, 0.733, 0.325, 0.582, 0.725, 0.302, 0.580, 0.718,
+     0.279, 0.577, 0.710, 0.255, 0.575, 0.703, 0.230, 0.573, 0.695, 0.204,
+     0.357, 0.685, 0.972, 0.372, 0.692, 0.966, 0.387, 0.700, 0.960, 0.401,
+     0.707, 0.954, 0.416, 0.714, 0.949, 0.429, 0.722, 0.943, 0.443, 0.729,
+     0.938, 0.456, 0.736, 0.933, 0.469, 0.743, 0.929, 0.482, 0.750, 0.924,
+     0.494, 0.757, 0.919, 0.507, 0.764, 0.915, 0.519, 0.771, 0.911, 0.530,
+     0.777, 0.907, 0.542, 0.784, 0.903, 0.553, 0.790, 0.899, 0.563, 0.796,
+     0.895, 0.574, 0.802, 0.891, 0.584, 0.808, 0.887, 0.593, 0.814, 0.883,
+     0.603, 0.820, 0.879, 0.611, 0.825, 0.875, 0.620, 0.830, 0.870, 0.627,
+     0.835, 0.866, 0.635, 0.839, 0.861, 0.641, 0.843, 0.856, 0.647, 0.847,
+     0.850, 0.652, 0.850, 0.844, 0.657, 0.853, 0.838, 0.660, 0.855, 0.831,
+     0.663, 0.857, 0.823, 0.666, 0.859, 0.814, 0.667, 0.859, 0.805, 0.668,
+     0.860, 0.795, 0.668, 0.860, 0.784, 0.667, 0.859, 0.773, 0.666, 0.858,
+     0.760, 0.665, 0.856, 0.747, 0.663, 0.853, 0.733, 0.661, 0.851, 0.718,
+     0.658, 0.847, 0.703, 0.655, 0.844, 0.687, 0.652, 0.840, 0.670, 0.649,
+     0.835, 0.652, 0.646, 0.830, 0.635, 0.642, 0.825, 0.616, 0.639, 0.820,
+     0.598, 0.636, 0.814, 0.579, 0.633, 0.808, 0.559, 0.629, 0.802, 0.539,
+     0.626, 0.796, 0.519, 0.623, 0.790, 0.499, 0.620, 0.783, 0.479, 0.617,
+     0.776, 0.458, 0.614, 0.769, 0.437, 0.611, 0.762, 0.416, 0.609, 0.755,
+     0.394, 0.606, 0.748, 0.372, 0.603, 0.740, 0.350, 0.601, 0.733, 0.328,
+     0.598, 0.726, 0.305, 0.596, 0.718, 0.282, 0.593, 0.710, 0.257, 0.591,
+     0.703, 0.232, 0.589, 0.695, 0.206, 0.381, 0.684, 0.974, 0.396, 0.692,
+     0.968, 0.410, 0.700, 0.962, 0.424, 0.707, 0.957, 0.438, 0.715, 0.951,
+     0.451, 0.722, 0.946, 0.464, 0.729, 0.941, 0.477, 0.737, 0.936, 0.490,
+     0.744, 0.932, 0.503, 0.751, 0.927, 0.515, 0.758, 0.923, 0.527, 0.765,
+     0.919, 0.539, 0.772, 0.915, 0.550, 0.779, 0.911, 0.562, 0.786, 0.907,
+     0.573, 0.792, 0.903, 0.584, 0.799, 0.900, 0.594, 0.805, 0.896, 0.604,
+     0.811, 0.892, 0.614, 0.817, 0.889, 0.623, 0.823, 0.885, 0.632, 0.829,
+     0.881, 0.641, 0.834, 0.877, 0.649, 0.839, 0.873, 0.656, 0.844, 0.868,
+     0.663, 0.848, 0.863, 0.669, 0.852, 0.858, 0.674, 0.855, 0.852, 0.679,
+     0.858, 0.846, 0.682, 0.861, 0.839, 0.685, 0.863, 0.832, 0.688, 0.864,
+     0.823, 0.689, 0.865, 0.814, 0.690, 0.865, 0.804, 0.690, 0.865, 0.794,
+     0.689, 0.864, 0.782, 0.688, 0.863, 0.769, 0.686, 0.861, 0.756, 0.684,
+     0.858, 0.742, 0.681, 0.855, 0.726, 0.678, 0.852, 0.711, 0.675, 0.848,
+     0.694, 0.672, 0.844, 0.677, 0.668, 0.839, 0.659, 0.665, 0.834, 0.641,
+     0.662, 0.829, 0.622, 0.658, 0.823, 0.603, 0.655, 0.817, 0.584, 0.651,
+     0.811, 0.564, 0.648, 0.805, 0.544, 0.644, 0.798, 0.524, 0.641, 0.791,
+     0.503, 0.638, 0.785, 0.483, 0.635, 0.778, 0.462, 0.631, 0.770, 0.440,
+     0.628, 0.763, 0.419, 0.625, 0.756, 0.397, 0.623, 0.748, 0.375, 0.620,
+     0.741, 0.353, 0.617, 0.733, 0.330, 0.614, 0.726, 0.307, 0.612, 0.718,
+     0.284, 0.609, 0.710, 0.260, 0.606, 0.702, 0.235, 0.604, 0.694, 0.208,
+     0.404, 0.684, 0.977, 0.418, 0.692, 0.971, 0.432, 0.699, 0.965, 0.445,
+     0.707, 0.959, 0.458, 0.715, 0.954, 0.472, 0.722, 0.949, 0.484, 0.730,
+     0.944, 0.497, 0.737, 0.939, 0.510, 0.745, 0.935, 0.522, 0.752, 0.931,
+     0.534, 0.759, 0.926, 0.546, 0.767, 0.922, 0.558, 0.774, 0.919, 0.569,
+     0.781, 0.915, 0.581, 0.788, 0.911, 0.592, 0.794, 0.908, 0.603, 0.801,
+     0.904, 0.613, 0.808, 0.901, 0.624, 0.814, 0.897, 0.633, 0.820, 0.894,
+     0.643, 0.826, 0.891, 0.652, 0.832, 0.887, 0.661, 0.838, 0.883, 0.669,
+     0.843, 0.879, 0.677, 0.848, 0.875, 0.684, 0.853, 0.871, 0.690, 0.857,
+     0.866, 0.695, 0.860, 0.860, 0.700, 0.864, 0.855, 0.704, 0.866, 0.848,
+     0.707, 0.869, 0.841, 0.709, 0.870, 0.833, 0.711, 0.871, 0.824, 0.711,
+     0.871, 0.814, 0.711, 0.871, 0.803, 0.710, 0.870, 0.791, 0.709, 0.868,
+     0.778, 0.707, 0.866, 0.765, 0.704, 0.864, 0.750, 0.701, 0.860, 0.735,
+     0.698, 0.857, 0.718, 0.695, 0.852, 0.702, 0.691, 0.848, 0.684, 0.688,
+     0.843, 0.666, 0.684, 0.837, 0.647, 0.680, 0.832, 0.628, 0.676, 0.826,
+     0.609, 0.673, 0.820, 0.589, 0.669, 0.813, 0.569, 0.665, 0.807, 0.549,
+     0.662, 0.800, 0.528, 0.658, 0.793, 0.507, 0.655, 0.786, 0.486, 0.651,
+     0.779, 0.465, 0.648, 0.771, 0.444, 0.645, 0.764, 0.422, 0.642, 0.756,
+     0.400, 0.639, 0.749, 0.378, 0.636, 0.741, 0.356, 0.633, 0.733, 0.333,
+     0.630, 0.726, 0.310, 0.627, 0.718, 0.286, 0.624, 0.710, 0.262, 0.621,
+     0.702, 0.237, 0.619, 0.694, 0.210, 0.425, 0.683, 0.979, 0.439, 0.691,
+     0.973, 0.452, 0.699, 0.967, 0.465, 0.707, 0.962, 0.478, 0.715, 0.956,
+     0.491, 0.722, 0.951, 0.503, 0.730, 0.947, 0.516, 0.738, 0.942, 0.528,
+     0.745, 0.938, 0.540, 0.753, 0.934, 0.552, 0.760, 0.930, 0.564, 0.768,
+     0.926, 0.576, 0.775, 0.922, 0.588, 0.782, 0.919, 0.599, 0.789, 0.915,
+     0.610, 0.797, 0.912, 0.621, 0.803, 0.909, 0.632, 0.810, 0.906, 0.642,
+     0.817, 0.902, 0.652, 0.823, 0.899, 0.662, 0.830, 0.896, 0.671, 0.836,
+     0.893, 0.680, 0.842, 0.890, 0.689, 0.847, 0.886, 0.697, 0.853, 0.882,
+     0.704, 0.857, 0.878, 0.710, 0.862, 0.874, 0.716, 0.866, 0.869, 0.721,
+     0.869, 0.863, 0.725, 0.872, 0.857, 0.729, 0.874, 0.850, 0.731, 0.876,
+     0.842, 0.732, 0.877, 0.833, 0.733, 0.877, 0.823, 0.732, 0.877, 0.812,
+     0.731, 0.876, 0.800, 0.729, 0.874, 0.787, 0.727, 0.872, 0.773, 0.724,
+     0.869, 0.759, 0.721, 0.865, 0.743, 0.718, 0.861, 0.726, 0.714, 0.857,
+     0.709, 0.710, 0.852, 0.691, 0.706, 0.846, 0.672, 0.702, 0.841, 0.653,
+     0.698, 0.835, 0.634, 0.694, 0.828, 0.614, 0.690, 0.822, 0.594, 0.686,
+     0.815, 0.574, 0.683, 0.808, 0.553, 0.679, 0.801, 0.532, 0.675, 0.794,
+     0.511, 0.672, 0.787, 0.490, 0.668, 0.779, 0.468, 0.665, 0.772, 0.446,
+     0.661, 0.764, 0.425, 0.658, 0.757, 0.403, 0.654, 0.749, 0.380, 0.651,
+     0.741, 0.358, 0.648, 0.733, 0.335, 0.645, 0.725, 0.312, 0.642, 0.717,
+     0.288, 0.639, 0.709, 0.264, 0.636, 0.701, 0.238, 0.633, 0.693, 0.212,
+     0.445, 0.682, 0.981, 0.458, 0.691, 0.975, 0.471, 0.699, 0.969, 0.484,
+     0.707, 0.964, 0.496, 0.715, 0.959, 0.509, 0.722, 0.954, 0.521, 0.730,
+     0.949, 0.534, 0.738, 0.945, 0.546, 0.746, 0.941, 0.558, 0.753, 0.937,
+     0.570, 0.761, 0.933, 0.582, 0.769, 0.929, 0.593, 0.776, 0.926, 0.605,
+     0.784, 0.922, 0.616, 0.791, 0.919, 0.628, 0.798, 0.916, 0.639, 0.806,
+     0.913, 0.649, 0.813, 0.910, 0.660, 0.820, 0.907, 0.670, 0.826, 0.904,
+     0.680, 0.833, 0.902, 0.690, 0.839, 0.899, 0.699, 0.846, 0.896, 0.708,
+     0.851, 0.893, 0.716, 0.857, 0.889, 0.724, 0.862, 0.885, 0.731, 0.867,
+     0.881, 0.737, 0.871, 0.877, 0.742, 0.875, 0.872, 0.746, 0.878, 0.866,
+     0.750, 0.880, 0.859, 0.752, 0.882, 0.851, 0.753, 0.883, 0.843, 0.754,
+     0.883, 0.833, 0.753, 0.883, 0.822, 0.752, 0.882, 0.810, 0.750, 0.880,
+     0.797, 0.747, 0.877, 0.782, 0.744, 0.874, 0.767, 0.740, 0.870, 0.751,
+     0.737, 0.866, 0.734, 0.733, 0.861, 0.716, 0.729, 0.855, 0.697, 0.724,
+     0.850, 0.678, 0.720, 0.844, 0.659, 0.716, 0.837, 0.639, 0.712, 0.831,
+     0.619, 0.708, 0.824, 0.598, 0.704, 0.817, 0.578, 0.699, 0.810, 0.557,
+     0.696, 0.803, 0.535, 0.692, 0.795, 0.514, 0.688, 0.788, 0.493, 0.684,
+     0.780, 0.471, 0.680, 0.772, 0.449, 0.677, 0.765, 0.427, 0.673, 0.757,
+     0.405, 0.670, 0.749, 0.382, 0.666, 0.741, 0.360, 0.663, 0.733, 0.337,
+     0.660, 0.725, 0.313, 0.657, 0.716, 0.289, 0.653, 0.708, 0.265, 0.650,
+     0.700, 0.240, 0.647, 0.692, 0.213, 0.464, 0.681, 0.982, 0.476, 0.690,
+     0.977, 0.489, 0.698, 0.971, 0.501, 0.706, 0.966, 0.514, 0.714, 0.961,
+     0.526, 0.722, 0.956, 0.538, 0.730, 0.952, 0.550, 0.738, 0.947, 0.562,
+     0.746, 0.943, 0.574, 0.754, 0.939, 0.586, 0.762, 0.936, 0.598, 0.769,
+     0.932, 0.610, 0.777, 0.929, 0.621, 0.785, 0.926, 0.633, 0.792, 0.923,
+     0.644, 0.800, 0.920, 0.655, 0.807, 0.917, 0.666, 0.815, 0.915, 0.677,
+     0.822, 0.912, 0.688, 0.829, 0.909, 0.698, 0.836, 0.907, 0.708, 0.843,
+     0.904, 0.717, 0.849, 0.902, 0.727, 0.855, 0.899, 0.735, 0.861, 0.896,
+     0.743, 0.867, 0.893, 0.750, 0.872, 0.889, 0.757, 0.877, 0.885, 0.762,
+     0.881, 0.880, 0.767, 0.884, 0.875, 0.770, 0.887, 0.868, 0.773, 0.888,
+     0.861, 0.774, 0.889, 0.852, 0.774, 0.890, 0.842, 0.774, 0.889, 0.831,
+     0.772, 0.888, 0.819, 0.770, 0.885, 0.806, 0.767, 0.883, 0.791, 0.763,
+     0.879, 0.775, 0.759, 0.875, 0.759, 0.755, 0.870, 0.741, 0.751, 0.865,
+     0.723, 0.747, 0.859, 0.704, 0.742, 0.853, 0.684, 0.738, 0.847, 0.664,
+     0.733, 0.840, 0.644, 0.729, 0.833, 0.623, 0.724, 0.826, 0.603, 0.720,
+     0.819, 0.581, 0.716, 0.811, 0.560, 0.712, 0.804, 0.539, 0.708, 0.796,
+     0.517, 0.704, 0.788, 0.495, 0.700, 0.780, 0.473, 0.696, 0.772, 0.451,
+     0.692, 0.764, 0.429, 0.688, 0.756, 0.407, 0.685, 0.748, 0.384, 0.681,
+     0.740, 0.361, 0.678, 0.732, 0.338, 0.674, 0.724, 0.315, 0.671, 0.715,
+     0.291, 0.667, 0.707, 0.266, 0.664, 0.699, 0.241, 0.661, 0.691, 0.214,
+     0.481, 0.680, 0.984, 0.494, 0.689, 0.978, 0.506, 0.697, 0.973, 0.518,
+     0.705, 0.968, 0.530, 0.713, 0.963, 0.542, 0.722, 0.958, 0.554, 0.730,
+     0.954, 0.566, 0.738, 0.950, 0.578, 0.746, 0.946, 0.590, 0.754, 0.942,
+     0.602, 0.762, 0.939, 0.614, 0.770, 0.935, 0.626, 0.778, 0.932, 0.637,
+     0.786, 0.929, 0.649, 0.794, 0.926, 0.660, 0.801, 0.924, 0.671, 0.809,
+     0.921, 0.683, 0.817, 0.919, 0.694, 0.824, 0.916, 0.704, 0.832, 0.914,
+     0.715, 0.839, 0.912, 0.725, 0.846, 0.910, 0.735, 0.853, 0.908, 0.744,
+     0.859, 0.905, 0.753, 0.866, 0.903, 0.762, 0.872, 0.900, 0.770, 0.877,
+     0.897, 0.776, 0.882, 0.893, 0.782, 0.886, 0.889, 0.787, 0.890, 0.884,
+     0.791, 0.893, 0.878, 0.794, 0.895, 0.871, 0.795, 0.896, 0.862, 0.795,
+     0.896, 0.852, 0.794, 0.895, 0.841, 0.792, 0.894, 0.829, 0.789, 0.891,
+     0.815, 0.786, 0.888, 0.800, 0.782, 0.884, 0.783, 0.778, 0.879, 0.766,
+     0.774, 0.874, 0.748, 0.769, 0.868, 0.729, 0.764, 0.862, 0.710, 0.760,
+     0.856, 0.690, 0.755, 0.849, 0.669, 0.750, 0.842, 0.649, 0.745, 0.835,
+     0.628, 0.741, 0.827, 0.606, 0.736, 0.820, 0.585, 0.732, 0.812, 0.563,
+     0.728, 0.804, 0.542, 0.723, 0.796, 0.520, 0.719, 0.788, 0.498, 0.715,
+     0.780, 0.475, 0.711, 0.772, 0.453, 0.707, 0.764, 0.431, 0.703, 0.756,
+     0.408, 0.699, 0.748, 0.386, 0.696, 0.739, 0.363, 0.692, 0.731, 0.339,
+     0.688, 0.723, 0.316, 0.685, 0.714, 0.292, 0.681, 0.706, 0.267, 0.678,
+     0.697, 0.242, 0.674, 0.689, 0.215, 0.498, 0.679, 0.986, 0.510, 0.687,
+     0.980, 0.522, 0.696, 0.975, 0.534, 0.704, 0.970, 0.546, 0.712, 0.965,
+     0.558, 0.721, 0.961, 0.570, 0.729, 0.956, 0.581, 0.737, 0.952, 0.593,
+     0.746, 0.948, 0.605, 0.754, 0.945, 0.617, 0.762, 0.941, 0.629, 0.770,
+     0.938, 0.640, 0.778, 0.935, 0.652, 0.786, 0.932, 0.664, 0.794, 0.930,
+     0.675, 0.802, 0.927, 0.687, 0.810, 0.925, 0.698, 0.818, 0.923, 0.709,
+     0.826, 0.921, 0.720, 0.834, 0.919, 0.731, 0.841, 0.917, 0.742, 0.849,
+     0.915, 0.752, 0.856, 0.913, 0.762, 0.863, 0.911, 0.771, 0.870, 0.909,
+     0.780, 0.876, 0.907, 0.788, 0.882, 0.904, 0.796, 0.887, 0.901, 0.802,
+     0.892, 0.897, 0.807, 0.896, 0.893, 0.811, 0.899, 0.887, 0.814, 0.902,
+     0.880, 0.815, 0.903, 0.872, 0.815, 0.903, 0.862, 0.814, 0.902, 0.851,
+     0.812, 0.900, 0.838, 0.809, 0.897, 0.824, 0.805, 0.893, 0.808, 0.801,
+     0.889, 0.791, 0.796, 0.884, 0.774, 0.791, 0.878, 0.755, 0.786, 0.872,
+     0.735, 0.781, 0.865, 0.715, 0.776, 0.858, 0.695, 0.771, 0.851, 0.674,
+     0.767, 0.844, 0.653, 0.762, 0.836, 0.631, 0.757, 0.829, 0.610, 0.752,
+     0.821, 0.588, 0.748, 0.813, 0.566, 0.743, 0.805, 0.544, 0.739, 0.796,
+     0.522, 0.734, 0.788, 0.500, 0.730, 0.780, 0.477, 0.726, 0.772, 0.455,
+     0.722, 0.763, 0.432, 0.718, 0.755, 0.410, 0.714, 0.746, 0.387, 0.710,
+     0.738, 0.364, 0.706, 0.730, 0.340, 0.702, 0.721, 0.317, 0.698, 0.713,
+     0.293, 0.694, 0.704, 0.268, 0.691, 0.696, 0.243, 0.687, 0.687, 0.216,
+     0.513, 0.677, 0.987, 0.525, 0.686, 0.982, 0.537, 0.694, 0.977, 0.549,
+     0.703, 0.972, 0.561, 0.711, 0.967, 0.572, 0.720, 0.962, 0.584, 0.728,
+     0.958, 0.596, 0.737, 0.954, 0.608, 0.745, 0.951, 0.619, 0.753, 0.947,
+     0.631, 0.762, 0.944, 0.643, 0.770, 0.941, 0.655, 0.778, 0.938, 0.666,
+     0.787, 0.935, 0.678, 0.795, 0.933, 0.689, 0.803, 0.930, 0.701, 0.811,
+     0.928, 0.713, 0.820, 0.926, 0.724, 0.828, 0.925, 0.735, 0.836, 0.923,
+     0.746, 0.844, 0.921, 0.757, 0.852, 0.920, 0.768, 0.859, 0.918, 0.778,
+     0.867, 0.917, 0.788, 0.874, 0.915, 0.797, 0.881, 0.913, 0.806, 0.887,
+     0.911, 0.814, 0.893, 0.909, 0.821, 0.898, 0.906, 0.827, 0.902, 0.902,
+     0.831, 0.906, 0.897, 0.834, 0.908, 0.890, 0.836, 0.910, 0.882, 0.836,
+     0.910, 0.873, 0.834, 0.909, 0.861, 0.832, 0.906, 0.848, 0.828, 0.903,
+     0.833, 0.824, 0.899, 0.817, 0.819, 0.894, 0.799, 0.814, 0.888, 0.781,
+     0.809, 0.882, 0.761, 0.804, 0.875, 0.741, 0.798, 0.868, 0.720, 0.793,
+     0.861, 0.699, 0.788, 0.853, 0.678, 0.783, 0.845, 0.656, 0.777, 0.837,
+     0.635, 0.772, 0.829, 0.613, 0.768, 0.821, 0.590, 0.763, 0.813, 0.568,
+     0.758, 0.804, 0.546, 0.753, 0.796, 0.524, 0.749, 0.788, 0.501, 0.744,
+     0.779, 0.479, 0.740, 0.771, 0.456, 0.736, 0.762, 0.433, 0.731, 0.754,
+     0.411, 0.727, 0.745, 0.388, 0.723, 0.736, 0.365, 0.719, 0.728, 0.341,
+     0.715, 0.719, 0.317, 0.711, 0.711, 0.293, 0.707, 0.702, 0.268, 0.704,
+     0.694, 0.243, 0.700, 0.685, 0.216, 0.528, 0.675, 0.989, 0.540, 0.684,
+     0.983, 0.551, 0.693, 0.978, 0.563, 0.701, 0.973, 0.575, 0.710, 0.969,
+     0.586, 0.718, 0.964, 0.598, 0.727, 0.960, 0.610, 0.736, 0.956, 0.621,
+     0.744, 0.953, 0.633, 0.753, 0.949, 0.645, 0.761, 0.946, 0.656, 0.770,
+     0.943, 0.668, 0.778, 0.940, 0.680, 0.787, 0.938, 0.691, 0.795, 0.936,
+     0.703, 0.804, 0.933, 0.715, 0.812, 0.932, 0.726, 0.821, 0.930, 0.738,
+     0.829, 0.928, 0.749, 0.837, 0.927, 0.761, 0.846, 0.926, 0.772, 0.854,
+     0.924, 0.783, 0.862, 0.923, 0.794, 0.870, 0.922, 0.804, 0.877, 0.921,
+     0.814, 0.885, 0.920, 0.824, 0.892, 0.918, 0.832, 0.898, 0.917, 0.840,
+     0.904, 0.914, 0.846, 0.909, 0.911, 0.851, 0.913, 0.906, 0.855, 0.915,
+     0.901, 0.856, 0.917, 0.893, 0.856, 0.917, 0.883, 0.854, 0.915, 0.871,
+     0.851, 0.913, 0.858, 0.847, 0.909, 0.842, 0.842, 0.904, 0.825, 0.837,
+     0.898, 0.806, 0.831, 0.892, 0.787, 0.826, 0.885, 0.767, 0.820, 0.878,
+     0.746, 0.814, 0.870, 0.725, 0.809, 0.862, 0.703, 0.803, 0.854, 0.681,
+     0.798, 0.846, 0.659, 0.793, 0.838, 0.637, 0.788, 0.829, 0.615, 0.782,
+     0.821, 0.592, 0.777, 0.812, 0.570, 0.773, 0.804, 0.548, 0.768, 0.795,
+     0.525, 0.763, 0.787, 0.502, 0.758, 0.778, 0.480, 0.754, 0.769, 0.457,
+     0.749, 0.761, 0.434, 0.745, 0.752, 0.411, 0.741, 0.743, 0.388, 0.737,
+     0.735, 0.365, 0.732, 0.726, 0.342, 0.728, 0.717, 0.318, 0.724, 0.709,
+     0.293, 0.720, 0.700, 0.269, 0.716, 0.691, 0.243, 0.712, 0.683, 0.216,
+     0.542, 0.673, 0.990, 0.554, 0.682, 0.985, 0.565, 0.691, 0.980, 0.577,
+     0.700, 0.975, 0.588, 0.708, 0.970, 0.600, 0.717, 0.966, 0.611, 0.726,
+     0.962, 0.623, 0.734, 0.958, 0.634, 0.743, 0.955, 0.646, 0.752, 0.951,
+     0.657, 0.760, 0.948, 0.669, 0.769, 0.945, 0.681, 0.778, 0.943, 0.692,
+     0.786, 0.940, 0.704, 0.795, 0.938, 0.716, 0.804, 0.936, 0.728, 0.812,
+     0.934, 0.739, 0.821, 0.933, 0.751, 0.830, 0.932, 0.763, 0.838, 0.930,
+     0.774, 0.847, 0.929, 0.786, 0.856, 0.929, 0.797, 0.864, 0.928, 0.809,
+     0.873, 0.927, 0.819, 0.881, 0.927, 0.830, 0.889, 0.926, 0.840, 0.896,
+     0.925, 0.850, 0.903, 0.924, 0.858, 0.910, 0.922, 0.865, 0.915, 0.920,
+     0.871, 0.920, 0.916, 0.875, 0.923, 0.911, 0.876, 0.924, 0.903, 0.876,
+     0.924, 0.894, 0.873, 0.922, 0.882, 0.870, 0.919, 0.867, 0.865, 0.914,
+     0.851, 0.860, 0.909, 0.832, 0.854, 0.902, 0.813, 0.848, 0.895, 0.793,
+     0.842, 0.888, 0.772, 0.836, 0.880, 0.750, 0.830, 0.872, 0.729, 0.824,
+     0.864, 0.707, 0.819, 0.855, 0.684, 0.813, 0.847, 0.662, 0.808, 0.838,
+     0.639, 0.802, 0.829, 0.617, 0.797, 0.820, 0.594, 0.792, 0.812, 0.571,
+     0.787, 0.803, 0.549, 0.782, 0.794, 0.526, 0.777, 0.785, 0.503, 0.772,
+     0.776, 0.480, 0.767, 0.768, 0.458, 0.763, 0.759, 0.435, 0.758, 0.750,
+     0.412, 0.754, 0.741, 0.388, 0.749, 0.732, 0.365, 0.745, 0.724, 0.342,
+     0.741, 0.715, 0.318, 0.737, 0.706, 0.293, 0.732, 0.697, 0.269, 0.728,
+     0.689, 0.243, 0.724, 0.680, 0.216, 0.556, 0.671, 0.992, 0.567, 0.680,
+     0.986, 0.578, 0.689, 0.981, 0.590, 0.697, 0.976, 0.601, 0.706, 0.972,
+     0.612, 0.715, 0.968, 0.624, 0.724, 0.964, 0.635, 0.733, 0.960, 0.646,
+     0.741, 0.956, 0.658, 0.750, 0.953, 0.670, 0.759, 0.950, 0.681, 0.768,
+     0.947, 0.693, 0.777, 0.945, 0.704, 0.786, 0.943, 0.716, 0.794, 0.941,
+     0.728, 0.803, 0.939, 0.740, 0.812, 0.937, 0.752, 0.821, 0.936, 0.763,
+     0.830, 0.935, 0.775, 0.839, 0.934, 0.787, 0.848, 0.933, 0.799, 0.857,
+     0.932, 0.811, 0.866, 0.932, 0.822, 0.875, 0.932, 0.834, 0.883, 0.932,
+     0.845, 0.892, 0.931, 0.856, 0.900, 0.931, 0.866, 0.908, 0.931, 0.876,
+     0.915, 0.930, 0.884, 0.922, 0.929, 0.890, 0.927, 0.926, 0.895, 0.930,
+     0.921, 0.896, 0.932, 0.914, 0.896, 0.932, 0.905, 0.893, 0.929, 0.892,
+     0.888, 0.925, 0.876, 0.883, 0.920, 0.859, 0.877, 0.913, 0.840, 0.871,
+     0.906, 0.819, 0.864, 0.898, 0.798, 0.858, 0.890, 0.776, 0.852, 0.882,
+     0.754, 0.845, 0.873, 0.732, 0.839, 0.864, 0.709, 0.833, 0.855, 0.686,
+     0.828, 0.846, 0.664, 0.822, 0.837, 0.641, 0.816, 0.828, 0.618, 0.811,
+     0.819, 0.595, 0.806, 0.810, 0.572, 0.800, 0.801, 0.549, 0.795, 0.792,
+     0.526, 0.790, 0.783, 0.504, 0.785, 0.774, 0.481, 0.781, 0.765, 0.458,
+     0.776, 0.756, 0.435, 0.771, 0.748, 0.412, 0.766, 0.739, 0.388, 0.762,
+     0.730, 0.365, 0.757, 0.721, 0.341, 0.753, 0.712, 0.318, 0.749, 0.703,
+     0.293, 0.744, 0.695, 0.268, 0.740, 0.686, 0.243, 0.736, 0.677, 0.216,
+     0.569, 0.668, 0.993, 0.580, 0.677, 0.987, 0.591, 0.686, 0.982, 0.602,
+     0.695, 0.978, 0.613, 0.704, 0.973, 0.624, 0.713, 0.969, 0.635, 0.722,
+     0.965, 0.647, 0.731, 0.961, 0.658, 0.740, 0.958, 0.670, 0.748, 0.955,
+     0.681, 0.757, 0.952, 0.693, 0.766, 0.949, 0.704, 0.775, 0.947, 0.716,
+     0.784, 0.945, 0.728, 0.793, 0.943, 0.739, 0.802, 0.941, 0.751, 0.812,
+     0.939, 0.763, 0.821, 0.938, 0.775, 0.830, 0.937, 0.787, 0.839, 0.936,
+     0.799, 0.848, 0.936, 0.811, 0.858, 0.936, 0.823, 0.867, 0.935, 0.835,
+     0.876, 0.936, 0.847, 0.886, 0.936, 0.859, 0.895, 0.936, 0.870, 0.904,
+     0.937, 0.882, 0.912, 0.937, 0.892, 0.920, 0.937, 0.901, 0.928, 0.937,
+     0.909, 0.934, 0.936, 0.914, 0.938, 0.932, 0.917, 0.940, 0.926, 0.915,
+     0.940, 0.916, 0.912, 0.936, 0.902, 0.906, 0.931, 0.885, 0.900, 0.925,
+     0.866, 0.893, 0.917, 0.846, 0.887, 0.909, 0.824, 0.880, 0.900, 0.802,
+     0.873, 0.891, 0.780, 0.867, 0.882, 0.757, 0.860, 0.873, 0.734, 0.854,
+     0.864, 0.711, 0.848, 0.855, 0.688, 0.842, 0.845, 0.665, 0.836, 0.836,
+     0.642, 0.830, 0.827, 0.619, 0.824, 0.818, 0.596, 0.819, 0.808, 0.573,
+     0.814, 0.799, 0.549, 0.808, 0.790, 0.527, 0.803, 0.781, 0.504, 0.798,
+     0.772, 0.481, 0.793, 0.763, 0.458, 0.788, 0.754, 0.434, 0.783, 0.745,
+     0.411, 0.779, 0.736, 0.388, 0.774, 0.727, 0.365, 0.769, 0.718, 0.341,
+     0.765, 0.709, 0.317, 0.760, 0.700, 0.293, 0.756, 0.691, 0.268, 0.751,
+     0.683, 0.242, 0.747, 0.674, 0.215, 0.581, 0.665, 0.994, 0.592, 0.674,
+     0.989, 0.603, 0.683, 0.984, 0.614, 0.692, 0.979, 0.625, 0.701, 0.974,
+     0.636, 0.710, 0.970, 0.647, 0.719, 0.966, 0.658, 0.728, 0.963, 0.669,
+     0.737, 0.959, 0.681, 0.746, 0.956, 0.692, 0.755, 0.953, 0.703, 0.765,
+     0.951, 0.715, 0.774, 0.948, 0.727, 0.783, 0.946, 0.738, 0.792, 0.944,
+     0.750, 0.801, 0.943, 0.762, 0.810, 0.941, 0.774, 0.820, 0.940, 0.786,
+     0.829, 0.939, 0.798, 0.839, 0.939, 0.810, 0.848, 0.938, 0.822, 0.858,
+     0.938, 0.834, 0.867, 0.939, 0.847, 0.877, 0.939, 0.859, 0.887, 0.940,
+     0.871, 0.897, 0.940, 0.883, 0.906, 0.942, 0.896, 0.916, 0.943, 0.907,
+     0.925, 0.944, 0.918, 0.933, 0.945, 0.927, 0.941, 0.945, 0.934, 0.946,
+     0.943, 0.937, 0.949, 0.937, 0.935, 0.948, 0.927, 0.930, 0.943, 0.912,
+     0.924, 0.937, 0.893, 0.916, 0.929, 0.872, 0.909, 0.920, 0.850, 0.902,
+     0.911, 0.828, 0.895, 0.901, 0.805, 0.888, 0.892, 0.782, 0.881, 0.882,
+     0.759, 0.874, 0.872, 0.735, 0.868, 0.863, 0.712, 0.861, 0.853, 0.689,
+     0.855, 0.844, 0.665, 0.849, 0.834, 0.642, 0.843, 0.825, 0.619, 0.838,
+     0.815, 0.596, 0.832, 0.806, 0.572, 0.826, 0.797, 0.549, 0.821, 0.787,
+     0.526, 0.816, 0.778, 0.503, 0.811, 0.769, 0.480, 0.805, 0.760, 0.457,
+     0.800, 0.751, 0.434, 0.795, 0.742, 0.411, 0.791, 0.733, 0.387, 0.786,
+     0.724, 0.364, 0.781, 0.715, 0.340, 0.776, 0.706, 0.316, 0.772, 0.697,
+     0.292, 0.767, 0.688, 0.267, 0.762, 0.679, 0.241, 0.758, 0.670, 0.215,
+     0.593, 0.662, 0.995, 0.603, 0.671, 0.990, 0.614, 0.680, 0.985, 0.625,
+     0.689, 0.980, 0.636, 0.699, 0.975, 0.647, 0.708, 0.971, 0.658, 0.717,
+     0.967, 0.669, 0.726, 0.964, 0.680, 0.735, 0.960, 0.691, 0.744, 0.957,
+     0.702, 0.753, 0.955, 0.714, 0.762, 0.952, 0.725, 0.771, 0.950, 0.737,
+     0.781, 0.948, 0.748, 0.790, 0.946, 0.760, 0.799, 0.944, 0.772, 0.809,
+     0.943, 0.784, 0.818, 0.942, 0.796, 0.828, 0.941, 0.808, 0.837, 0.941,
+     0.820, 0.847, 0.940, 0.832, 0.857, 0.941, 0.844, 0.867, 0.941, 0.857,
+     0.877, 0.942, 0.869, 0.887, 0.943, 0.882, 0.897, 0.944, 0.895, 0.908,
+     0.945, 0.908, 0.918, 0.947, 0.920, 0.928, 0.949, 0.933, 0.938, 0.951,
+     0.944, 0.947, 0.953, 0.953, 0.955, 0.954, 0.957, 0.958, 0.950, 0.954,
+     0.956, 0.938, 0.948, 0.949, 0.920, 0.940, 0.941, 0.899, 0.932, 0.931,
+     0.877, 0.924, 0.921, 0.854, 0.916, 0.911, 0.830, 0.909, 0.901, 0.807,
+     0.901, 0.891, 0.783, 0.894, 0.881, 0.759, 0.887, 0.871, 0.736, 0.881,
+     0.861, 0.712, 0.874, 0.851, 0.688, 0.868, 0.841, 0.665, 0.862, 0.832,
+     0.642, 0.856, 0.822, 0.618, 0.850, 0.812, 0.595, 0.844, 0.803, 0.572,
+     0.839, 0.793, 0.549, 0.833, 0.784, 0.525, 0.828, 0.775, 0.502, 0.822,
+     0.766, 0.479, 0.817, 0.756, 0.456, 0.812, 0.747, 0.433, 0.807, 0.738,
+     0.410, 0.802, 0.729, 0.387, 0.797, 0.720, 0.363, 0.792, 0.711, 0.339,
+     0.787, 0.702, 0.315, 0.782, 0.693, 0.291, 0.778, 0.684, 0.266, 0.773,
+     0.675, 0.240, 0.768, 0.666, 0.214, 0.604, 0.659, 0.996, 0.614, 0.668,
+     0.990, 0.625, 0.677, 0.985, 0.636, 0.686, 0.981, 0.646, 0.695, 0.976,
+     0.657, 0.704, 0.972, 0.668, 0.714, 0.968, 0.679, 0.723, 0.965, 0.690,
+     0.732, 0.961, 0.701, 0.741, 0.958, 0.712, 0.750, 0.956, 0.723, 0.759,
+     0.953, 0.735, 0.769, 0.951, 0.746, 0.778, 0.949, 0.758, 0.787, 0.947,
+     0.769, 0.797, 0.945, 0.781, 0.806, 0.944, 0.793, 0.816, 0.943, 0.805,
+     0.826, 0.943, 0.817, 0.836, 0.942, 0.829, 0.845, 0.942, 0.841, 0.855,
+     0.942, 0.853, 0.866, 0.943, 0.866, 0.876, 0.943, 0.879, 0.886, 0.945,
+     0.892, 0.897, 0.946, 0.905, 0.907, 0.948, 0.918, 0.918, 0.950, 0.931,
+     0.930, 0.953, 0.945, 0.941, 0.956, 0.958, 0.952, 0.960, 0.971, 0.963,
+     0.963, 0.978, 0.968, 0.963, 0.972, 0.963, 0.948, 0.963, 0.954, 0.926,
+     0.954, 0.943, 0.903, 0.945, 0.931, 0.879, 0.937, 0.921, 0.855, 0.929,
+     0.910, 0.831, 0.921, 0.899, 0.807, 0.914, 0.889, 0.783, 0.907, 0.878,
+     0.759, 0.900, 0.868, 0.735, 0.893, 0.858, 0.711, 0.887, 0.848, 0.688,
+     0.880, 0.838, 0.664, 0.874, 0.828, 0.641, 0.868, 0.818, 0.617, 0.862,
+     0.809, 0.594, 0.856, 0.799, 0.571, 0.850, 0.790, 0.547, 0.845, 0.780,
+     0.524, 0.839, 0.771, 0.501, 0.834, 0.762, 0.478, 0.828, 0.752, 0.455,
+     0.823, 0.743, 0.432, 0.818, 0.734, 0.409, 0.813, 0.725, 0.385, 0.808,
+     0.716, 0.362, 0.803, 0.707, 0.338, 0.798, 0.698, 0.314, 0.793, 0.689,
+     0.290, 0.788, 0.680, 0.265, 0.783, 0.671, 0.239, 0.778, 0.662, 0.213,
+     0.615, 0.655, 0.996, 0.625, 0.664, 0.991, 0.635, 0.673, 0.986, 0.646,
+     0.683, 0.982, 0.656, 0.692, 0.977, 0.667, 0.701, 0.973, 0.678, 0.710,
+     0.969, 0.688, 0.719, 0.966, 0.699, 0.729, 0.962, 0.710, 0.738, 0.959,
+     0.721, 0.747, 0.956, 0.732, 0.756, 0.954, 0.744, 0.766, 0.952, 0.755,
+     0.775, 0.950, 0.766, 0.784, 0.948, 0.778, 0.794, 0.946, 0.789, 0.804,
+     0.945, 0.801, 0.813, 0.944, 0.813, 0.823, 0.943, 0.825, 0.833, 0.943,
+     0.837, 0.843, 0.943, 0.849, 0.853, 0.943, 0.861, 0.863, 0.944, 0.874,
+     0.873, 0.944, 0.886, 0.884, 0.946, 0.899, 0.895, 0.947, 0.912, 0.906,
+     0.949, 0.926, 0.917, 0.952, 0.939, 0.928, 0.955, 0.953, 0.940, 0.958,
+     0.967, 0.953, 0.963, 0.982, 0.966, 0.969, 0.994, 0.976, 0.972, 0.986,
+     0.966, 0.952, 0.976, 0.953, 0.928, 0.966, 0.941, 0.903, 0.957, 0.929,
+     0.878, 0.949, 0.918, 0.854, 0.941, 0.906, 0.830, 0.933, 0.896, 0.806,
+     0.926, 0.885, 0.782, 0.918, 0.874, 0.758, 0.911, 0.864, 0.734, 0.905,
+     0.854, 0.710, 0.898, 0.844, 0.686, 0.892, 0.834, 0.663, 0.885, 0.824,
+     0.639, 0.879, 0.814, 0.616, 0.873, 0.804, 0.592, 0.867, 0.795, 0.569,
+     0.861, 0.785, 0.546, 0.856, 0.776, 0.523, 0.850, 0.766, 0.500, 0.845,
+     0.757, 0.477, 0.839, 0.748, 0.454, 0.834, 0.739, 0.430, 0.829, 0.729,
+     0.407, 0.823, 0.720, 0.384, 0.818, 0.711, 0.361, 0.813, 0.702, 0.337,
+     0.808, 0.693, 0.313, 0.803, 0.684, 0.289, 0.798, 0.675, 0.264, 0.793,
+     0.666, 0.238, 0.788, 0.657, 0.211, 0.625, 0.651, 0.997, 0.635, 0.660,
+     0.992, 0.645, 0.669, 0.987, 0.656, 0.679, 0.982, 0.666, 0.688, 0.978,
+     0.676, 0.697, 0.974, 0.687, 0.706, 0.970, 0.698, 0.716, 0.966, 0.708,
+     0.725, 0.963, 0.719, 0.734, 0.960, 0.730, 0.743, 0.957, 0.741, 0.753,
+     0.954, 0.752, 0.762, 0.952, 0.763, 0.771, 0.950, 0.774, 0.781, 0.948,
+     0.786, 0.790, 0.947, 0.797, 0.800, 0.945, 0.809, 0.810, 0.945, 0.820,
+     0.819, 0.944, 0.832, 0.829, 0.943, 0.844, 0.839, 0.943, 0.856, 0.849,
+     0.943, 0.868, 0.860, 0.944, 0.880, 0.870, 0.945, 0.893, 0.880, 0.946,
+     0.905, 0.891, 0.947, 0.918, 0.902, 0.949, 0.931, 0.913, 0.951, 0.944,
+     0.924, 0.954, 0.957, 0.936, 0.957, 0.971, 0.947, 0.961, 0.983, 0.958,
+     0.964, 0.991, 0.963, 0.962, 0.990, 0.957, 0.946, 0.983, 0.946, 0.924,
+     0.975, 0.935, 0.900, 0.967, 0.923, 0.876, 0.959, 0.912, 0.851, 0.951,
+     0.901, 0.827, 0.943, 0.890, 0.803, 0.936, 0.880, 0.779, 0.929, 0.869,
+     0.755, 0.922, 0.859, 0.732, 0.915, 0.849, 0.708, 0.909, 0.839, 0.684,
+     0.902, 0.829, 0.661, 0.896, 0.819, 0.637, 0.890, 0.809, 0.614, 0.884,
+     0.800, 0.591, 0.878, 0.790, 0.567, 0.872, 0.780, 0.544, 0.866, 0.771,
+     0.521, 0.861, 0.762, 0.498, 0.855, 0.752, 0.475, 0.850, 0.743, 0.452,
+     0.844, 0.734, 0.429, 0.839, 0.725, 0.406, 0.834, 0.715, 0.382, 0.828,
+     0.706, 0.359, 0.823, 0.697, 0.335, 0.818, 0.688, 0.311, 0.813, 0.679,
+     0.287, 0.808, 0.670, 0.262, 0.803, 0.662, 0.236, 0.798, 0.653, 0.210,
+     0.635, 0.646, 0.998, 0.645, 0.656, 0.992, 0.655, 0.665, 0.987, 0.665,
+     0.674, 0.983, 0.675, 0.684, 0.978, 0.685, 0.693, 0.974, 0.696, 0.702,
+     0.970, 0.706, 0.711, 0.966, 0.717, 0.721, 0.963, 0.727, 0.730, 0.960,
+     0.738, 0.739, 0.957, 0.749, 0.748, 0.955, 0.760, 0.758, 0.952, 0.771,
+     0.767, 0.950, 0.782, 0.777, 0.948, 0.793, 0.786, 0.947, 0.804, 0.796,
+     0.946, 0.816, 0.805, 0.945, 0.827, 0.815, 0.944, 0.839, 0.825, 0.943,
+     0.850, 0.835, 0.943, 0.862, 0.845, 0.943, 0.874, 0.855, 0.943, 0.886,
+     0.865, 0.944, 0.898, 0.875, 0.945, 0.910, 0.886, 0.946, 0.923, 0.896,
+     0.948, 0.935, 0.907, 0.949, 0.947, 0.917, 0.951, 0.959, 0.927, 0.953,
+     0.970, 0.937, 0.955, 0.980, 0.944, 0.955, 0.987, 0.946, 0.949, 0.989,
+     0.942, 0.936, 0.985, 0.935, 0.916, 0.980, 0.925, 0.894, 0.973, 0.915,
+     0.871, 0.966, 0.904, 0.847, 0.959, 0.894, 0.824, 0.952, 0.883, 0.800,
+     0.945, 0.873, 0.776, 0.938, 0.863, 0.752, 0.932, 0.853, 0.729, 0.925,
+     0.843, 0.705, 0.919, 0.833, 0.682, 0.912, 0.823, 0.658, 0.906, 0.813,
+     0.635, 0.900, 0.803, 0.611, 0.894, 0.794, 0.588, 0.888, 0.784, 0.565,
+     0.882, 0.775, 0.542, 0.876, 0.765, 0.519, 0.871, 0.756, 0.496, 0.865,
+     0.747, 0.473, 0.859, 0.738, 0.450, 0.854, 0.728, 0.427, 0.848, 0.719,
+     0.404, 0.843, 0.710, 0.380, 0.838, 0.701, 0.357, 0.833, 0.692, 0.333,
+     0.827, 0.683, 0.310, 0.822, 0.674, 0.285, 0.817, 0.665, 0.260, 0.812,
+     0.656, 0.235, 0.807, 0.648, 0.208, 0.644, 0.642, 0.998, 0.654, 0.651,
+     0.993, 0.664, 0.660, 0.988, 0.674, 0.670, 0.983, 0.684, 0.679, 0.978,
+     0.694, 0.688, 0.974, 0.704, 0.697, 0.970, 0.715, 0.707, 0.967, 0.725,
+     0.716, 0.963, 0.735, 0.725, 0.960, 0.746, 0.735, 0.957, 0.757, 0.744,
+     0.955, 0.767, 0.753, 0.952, 0.778, 0.763, 0.950, 0.789, 0.772, 0.948,
+     0.800, 0.781, 0.947, 0.811, 0.791, 0.945, 0.822, 0.801, 0.944, 0.833,
+     0.810, 0.943, 0.845, 0.820, 0.943, 0.856, 0.830, 0.942, 0.868, 0.839,
+     0.942, 0.879, 0.849, 0.942, 0.891, 0.859, 0.943, 0.902, 0.869, 0.943,
+     0.914, 0.879, 0.944, 0.926, 0.889, 0.945, 0.937, 0.899, 0.946, 0.949,
+     0.908, 0.947, 0.959, 0.917, 0.948, 0.969, 0.924, 0.947, 0.978, 0.929,
+     0.944, 0.984, 0.930, 0.937, 0.986, 0.927, 0.924, 0.986, 0.921, 0.907,
+     0.982, 0.913, 0.887, 0.978, 0.904, 0.865, 0.972, 0.895, 0.842, 0.966,
+     0.885, 0.819, 0.959, 0.875, 0.795, 0.953, 0.865, 0.772, 0.946, 0.855,
+     0.749, 0.940, 0.846, 0.725, 0.934, 0.836, 0.702, 0.927, 0.826, 0.678,
+     0.921, 0.816, 0.655, 0.915, 0.807, 0.632, 0.909, 0.797, 0.609, 0.903,
+     0.788, 0.586, 0.897, 0.778, 0.562, 0.891, 0.769, 0.539, 0.886, 0.759,
+     0.516, 0.880, 0.750, 0.493, 0.874, 0.741, 0.471, 0.869, 0.732, 0.448,
+     0.863, 0.723, 0.425, 0.858, 0.713, 0.402, 0.852, 0.704, 0.378, 0.847,
+     0.695, 0.355, 0.842, 0.686, 0.331, 0.836, 0.677, 0.308, 0.831, 0.669,
+     0.283, 0.826, 0.660, 0.258, 0.821, 0.651, 0.233, 0.815, 0.642, 0.206,
+     0.653, 0.636, 0.998, 0.663, 0.646, 0.993, 0.673, 0.655, 0.988, 0.682,
+     0.665, 0.983, 0.692, 0.674, 0.979, 0.702, 0.683, 0.974, 0.712, 0.692,
+     0.970, 0.722, 0.702, 0.967, 0.733, 0.711, 0.963, 0.743, 0.720, 0.960,
+     0.753, 0.730, 0.957, 0.764, 0.739, 0.954, 0.774, 0.748, 0.952, 0.785,
+     0.757, 0.950, 0.796, 0.767, 0.948, 0.806, 0.776, 0.946, 0.817, 0.786,
+     0.945, 0.828, 0.795, 0.943, 0.839, 0.804, 0.942, 0.850, 0.814, 0.941,
+     0.861, 0.824, 0.941, 0.872, 0.833, 0.940, 0.884, 0.843, 0.940, 0.895,
+     0.852, 0.940, 0.906, 0.862, 0.940, 0.917, 0.871, 0.941, 0.928, 0.880,
+     0.941, 0.939, 0.889, 0.941, 0.949, 0.897, 0.941, 0.959, 0.904, 0.940,
+     0.968, 0.910, 0.938, 0.975, 0.914, 0.933, 0.981, 0.914, 0.925, 0.984,
+     0.912, 0.913, 0.985, 0.907, 0.897, 0.983, 0.900, 0.878, 0.980, 0.893,
+     0.857, 0.976, 0.884, 0.836, 0.971, 0.875, 0.813, 0.965, 0.866, 0.790,
+     0.959, 0.856, 0.767, 0.954, 0.847, 0.744, 0.947, 0.837, 0.721, 0.941,
+     0.828, 0.698, 0.935, 0.818, 0.675, 0.929, 0.809, 0.652, 0.923, 0.800,
+     0.629, 0.917, 0.790, 0.605, 0.912, 0.781, 0.582, 0.906, 0.771, 0.560,
+     0.900, 0.762, 0.537, 0.894, 0.753, 0.514, 0.889, 0.744, 0.491, 0.883,
+     0.735, 0.468, 0.877, 0.725, 0.445, 0.872, 0.716, 0.422, 0.866, 0.707,
+     0.399, 0.861, 0.698, 0.376, 0.856, 0.689, 0.353, 0.850, 0.680, 0.329,
+     0.845, 0.672, 0.305, 0.840, 0.663, 0.281, 0.834, 0.654, 0.256, 0.829,
+     0.645, 0.231, 0.824, 0.636, 0.204, 0.662, 0.631, 0.998, 0.672, 0.641,
+     0.993, 0.681, 0.650, 0.988, 0.691, 0.659, 0.983, 0.700, 0.669, 0.979,
+     0.710, 0.678, 0.974, 0.720, 0.687, 0.970, 0.730, 0.696, 0.966, 0.740,
+     0.706, 0.963, 0.750, 0.715, 0.960, 0.760, 0.724, 0.957, 0.771, 0.733,
+     0.954, 0.781, 0.742, 0.951, 0.791, 0.752, 0.949, 0.802, 0.761, 0.947,
+     0.812, 0.770, 0.945, 0.823, 0.779, 0.943, 0.834, 0.789, 0.942, 0.844,
+     0.798, 0.941, 0.855, 0.807, 0.940, 0.866, 0.817, 0.939, 0.877, 0.826,
+     0.938, 0.887, 0.835, 0.938, 0.898, 0.844, 0.937, 0.909, 0.853, 0.937,
+     0.919, 0.862, 0.937, 0.930, 0.870, 0.936, 0.940, 0.878, 0.936, 0.950,
+     0.885, 0.934, 0.958, 0.891, 0.932, 0.967, 0.896, 0.928, 0.974, 0.898,
+     0.922, 0.979, 0.899, 0.914, 0.982, 0.897, 0.902, 0.984, 0.893, 0.886,
+     0.984, 0.887, 0.869, 0.982, 0.880, 0.849, 0.979, 0.872, 0.828, 0.975,
+     0.864, 0.807, 0.970, 0.856, 0.785, 0.965, 0.847, 0.762, 0.959, 0.838,
+     0.739, 0.954, 0.829, 0.717, 0.948, 0.819, 0.694, 0.943, 0.810, 0.671,
+     0.937, 0.801, 0.648, 0.931, 0.792, 0.625, 0.925, 0.782, 0.602, 0.919,
+     0.773, 0.579, 0.914, 0.764, 0.556, 0.908, 0.755, 0.533, 0.902, 0.746,
+     0.511, 0.897, 0.737, 0.488, 0.891, 0.728, 0.465, 0.886, 0.719, 0.442,
+     0.880, 0.710, 0.420, 0.875, 0.701, 0.397, 0.869, 0.692, 0.374, 0.864,
+     0.683, 0.350, 0.858, 0.674, 0.327, 0.853, 0.665, 0.303, 0.848, 0.657,
+     0.279, 0.842, 0.648, 0.254, 0.837, 0.639, 0.229, 0.832, 0.630, 0.202,
+     0.671, 0.625, 0.998, 0.680, 0.635, 0.993, 0.689, 0.644, 0.988, 0.698,
+     0.654, 0.983, 0.708, 0.663, 0.978, 0.718, 0.672, 0.974, 0.727, 0.681,
+     0.970, 0.737, 0.691, 0.966, 0.747, 0.700, 0.962, 0.757, 0.709, 0.959,
+     0.767, 0.718, 0.956, 0.777, 0.727, 0.953, 0.787, 0.736, 0.950, 0.797,
+     0.745, 0.948, 0.807, 0.755, 0.946, 0.818, 0.764, 0.944, 0.828, 0.773,
+     0.942, 0.839, 0.782, 0.940, 0.849, 0.791, 0.939, 0.859, 0.800, 0.938,
+     0.870, 0.809, 0.937, 0.880, 0.818, 0.936, 0.891, 0.827, 0.935, 0.901,
+     0.835, 0.934, 0.911, 0.844, 0.933, 0.921, 0.852, 0.932, 0.931, 0.859,
+     0.931, 0.941, 0.866, 0.929, 0.950, 0.873, 0.927, 0.958, 0.878, 0.923,
+     0.966, 0.881, 0.919, 0.972, 0.883, 0.912, 0.977, 0.883, 0.903, 0.981,
+     0.882, 0.891, 0.983, 0.878, 0.876, 0.984, 0.873, 0.859, 0.983, 0.867,
+     0.841, 0.980, 0.860, 0.821, 0.977, 0.853, 0.800, 0.974, 0.845, 0.778,
+     0.969, 0.836, 0.756, 0.964, 0.828, 0.734, 0.959, 0.819, 0.712, 0.954,
+     0.810, 0.689, 0.949, 0.801, 0.666, 0.943, 0.792, 0.644, 0.938, 0.783,
+     0.621, 0.932, 0.774, 0.598, 0.927, 0.765, 0.575, 0.921, 0.756, 0.553,
+     0.916, 0.747, 0.530, 0.910, 0.738, 0.507, 0.904, 0.729, 0.485, 0.899,
+     0.721, 0.462, 0.893, 0.712, 0.439, 0.888, 0.703, 0.417, 0.882, 0.694,
+     0.394, 0.877, 0.685, 0.371, 0.871, 0.676, 0.348, 0.866, 0.668, 0.324,
+     0.861, 0.659, 0.301, 0.855, 0.650, 0.277, 0.850, 0.641, 0.252, 0.845,
+     0.633, 0.226, 0.839, 0.624, 0.200, 0.679, 0.619, 0.998, 0.688, 0.629,
+     0.993, 0.697, 0.638, 0.988, 0.706, 0.648, 0.983, 0.715, 0.657, 0.978,
+     0.725, 0.666, 0.974, 0.734, 0.675, 0.969, 0.744, 0.684, 0.965, 0.754,
+     0.693, 0.962, 0.763, 0.703, 0.958, 0.773, 0.712, 0.955, 0.783, 0.721,
+     0.952, 0.793, 0.730, 0.949, 0.803, 0.739, 0.947, 0.813, 0.748, 0.944,
+     0.823, 0.757, 0.942, 0.833, 0.766, 0.940, 0.843, 0.774, 0.938, 0.853,
+     0.783, 0.937, 0.863, 0.792, 0.935, 0.874, 0.801, 0.934, 0.884, 0.809,
+     0.932, 0.894, 0.818, 0.931, 0.904, 0.826, 0.930, 0.913, 0.833, 0.928,
+     0.923, 0.841, 0.927, 0.932, 0.848, 0.925, 0.941, 0.854, 0.922, 0.950,
+     0.859, 0.919, 0.957, 0.864, 0.915, 0.965, 0.867, 0.909, 0.971, 0.868,
+     0.901, 0.976, 0.868, 0.892, 0.980, 0.867, 0.880, 0.982, 0.863, 0.866,
+     0.983, 0.859, 0.849, 0.983, 0.854, 0.832, 0.982, 0.847, 0.812, 0.979,
+     0.840, 0.792, 0.976, 0.833, 0.771, 0.973, 0.825, 0.750, 0.969, 0.817,
+     0.728, 0.964, 0.809, 0.706, 0.959, 0.800, 0.684, 0.954, 0.792, 0.661,
+     0.949, 0.783, 0.639, 0.944, 0.774, 0.617, 0.939, 0.766, 0.594, 0.933,
+     0.757, 0.572, 0.928, 0.748, 0.549, 0.922, 0.739, 0.527, 0.917, 0.731,
+     0.504, 0.911, 0.722, 0.481, 0.906, 0.713, 0.459, 0.901, 0.704, 0.436,
+     0.895, 0.695, 0.414, 0.890, 0.687, 0.391, 0.884, 0.678, 0.368, 0.879,
+     0.669, 0.345, 0.873, 0.661, 0.322, 0.868, 0.652, 0.298, 0.863, 0.643,
+     0.274, 0.857, 0.635, 0.249, 0.852, 0.626, 0.224, 0.846, 0.617, 0.197,
+     0.686, 0.613, 0.998, 0.695, 0.622, 0.993, 0.704, 0.632, 0.987, 0.713,
+     0.641, 0.982, 0.722, 0.650, 0.977, 0.732, 0.660, 0.973, 0.741, 0.669,
+     0.969, 0.750, 0.678, 0.965, 0.760, 0.687, 0.961, 0.769, 0.696, 0.957,
+     0.779, 0.705, 0.954, 0.789, 0.714, 0.951, 0.798, 0.723, 0.948, 0.808,
+     0.731, 0.945, 0.818, 0.740, 0.943, 0.828, 0.749, 0.940, 0.838, 0.758,
+     0.938, 0.847, 0.766, 0.936, 0.857, 0.775, 0.934, 0.867, 0.783, 0.932,
+     0.877, 0.792, 0.930, 0.887, 0.800, 0.929, 0.896, 0.808, 0.927, 0.906,
+     0.815, 0.925, 0.915, 0.823, 0.923, 0.924, 0.829, 0.921, 0.933, 0.836,
+     0.918, 0.942, 0.841, 0.915, 0.950, 0.846, 0.911, 0.957, 0.850, 0.906,
+     0.964, 0.852, 0.899, 0.970, 0.853, 0.891, 0.975, 0.853, 0.881, 0.979,
+     0.852, 0.869, 0.981, 0.849, 0.855, 0.983, 0.845, 0.840, 0.983, 0.840,
+     0.822, 0.982, 0.834, 0.804, 0.981, 0.828, 0.784, 0.978, 0.821, 0.764,
+     0.975, 0.814, 0.743, 0.972, 0.806, 0.722, 0.968, 0.798, 0.700, 0.964,
+     0.790, 0.678, 0.959, 0.782, 0.656, 0.954, 0.773, 0.634, 0.949, 0.765,
+     0.612, 0.944, 0.757, 0.590, 0.939, 0.748, 0.567, 0.934, 0.739, 0.545,
+     0.929, 0.731, 0.523, 0.923, 0.722, 0.500, 0.918, 0.714, 0.478, 0.913,
+     0.705, 0.456, 0.907, 0.696, 0.433, 0.902, 0.688, 0.411, 0.896, 0.679,
+     0.388, 0.891, 0.670, 0.365, 0.886, 0.662, 0.342, 0.880, 0.653, 0.319,
+     0.875, 0.645, 0.295, 0.869, 0.636, 0.271, 0.864, 0.628, 0.247, 0.859,
+     0.619, 0.221, 0.853, 0.611, 0.195, 0.694, 0.606, 0.998, 0.703, 0.616,
+     0.992, 0.711, 0.625, 0.987, 0.720, 0.634, 0.982, 0.729, 0.644, 0.977,
+     0.738, 0.653, 0.972, 0.747, 0.662, 0.968, 0.757, 0.671, 0.964, 0.766,
+     0.680, 0.960, 0.775, 0.689, 0.956, 0.785, 0.698, 0.953, 0.794, 0.706,
+     0.949, 0.804, 0.715, 0.946, 0.813, 0.724, 0.943, 0.823, 0.732, 0.941,
+     0.832, 0.741, 0.938, 0.842, 0.749, 0.936, 0.851, 0.758, 0.933, 0.861,
+     0.766, 0.931, 0.870, 0.774, 0.929, 0.880, 0.782, 0.927, 0.889, 0.790,
+     0.924, 0.899, 0.797, 0.922, 0.908, 0.805, 0.920, 0.917, 0.811, 0.917,
+     0.925, 0.818, 0.914, 0.934, 0.823, 0.911, 0.942, 0.828, 0.907, 0.950,
+     0.832, 0.902, 0.957, 0.836, 0.896, 0.963, 0.838, 0.889, 0.969, 0.839,
+     0.881, 0.974, 0.838, 0.871, 0.978, 0.837, 0.859, 0.980, 0.834, 0.845,
+     0.982, 0.831, 0.830, 0.983, 0.826, 0.813, 0.983, 0.821, 0.795, 0.982,
+     0.815, 0.776, 0.980, 0.809, 0.757, 0.978, 0.802, 0.736, 0.975, 0.794,
+     0.715, 0.971, 0.787, 0.694, 0.967, 0.779, 0.673, 0.963, 0.771, 0.651,
+     0.959, 0.763, 0.629, 0.954, 0.755, 0.607, 0.949, 0.747, 0.585, 0.944,
+     0.739, 0.563, 0.939, 0.730, 0.541, 0.934, 0.722, 0.519, 0.929, 0.714,
+     0.496, 0.924, 0.705, 0.474, 0.919, 0.697, 0.452, 0.913, 0.688, 0.430,
+     0.908, 0.680, 0.407, 0.903, 0.671, 0.385, 0.897, 0.663, 0.362, 0.892,
+     0.654, 0.339, 0.887, 0.646, 0.316, 0.881, 0.637, 0.293, 0.876, 0.629,
+     0.269, 0.870, 0.620, 0.244, 0.865, 0.612, 0.219, 0.860, 0.604, 0.192,
+     0.701, 0.599, 0.997, 0.710, 0.609, 0.992, 0.718, 0.618, 0.986, 0.727,
+     0.627, 0.981, 0.736, 0.636, 0.976, 0.745, 0.645, 0.971, 0.754, 0.655,
+     0.967, 0.763, 0.663, 0.963, 0.772, 0.672, 0.959, 0.781, 0.681, 0.955,
+     0.790, 0.690, 0.951, 0.799, 0.699, 0.948, 0.808, 0.707, 0.944, 0.818,
+     0.716, 0.941, 0.827, 0.724, 0.938, 0.836, 0.732, 0.935, 0.846, 0.741,
+     0.933, 0.855, 0.749, 0.930, 0.864, 0.757, 0.928, 0.874, 0.765, 0.925,
+     0.883, 0.772, 0.923, 0.892, 0.780, 0.920, 0.901, 0.787, 0.917, 0.910,
+     0.793, 0.914, 0.918, 0.800, 0.911, 0.927, 0.805, 0.908, 0.935, 0.811,
+     0.904, 0.942, 0.815, 0.899, 0.950, 0.819, 0.894, 0.956, 0.821, 0.887,
+     0.963, 0.823, 0.880, 0.968, 0.824, 0.871, 0.973, 0.824, 0.860, 0.977,
+     0.822, 0.849, 0.980, 0.820, 0.835, 0.982, 0.817, 0.820, 0.983, 0.812,
+     0.804, 0.983, 0.808, 0.786, 0.983, 0.802, 0.768, 0.981, 0.796, 0.749,
+     0.979, 0.789, 0.729, 0.977, 0.783, 0.709, 0.974, 0.776, 0.688, 0.970,
+     0.768, 0.667, 0.967, 0.761, 0.645, 0.963, 0.753, 0.624, 0.958, 0.745,
+     0.602, 0.954, 0.737, 0.580, 0.949, 0.729, 0.558, 0.944, 0.721, 0.536,
+     0.939, 0.713, 0.514, 0.934, 0.704, 0.492, 0.929, 0.696, 0.470, 0.924,
+     0.688, 0.448, 0.919, 0.680, 0.426, 0.914, 0.671, 0.404, 0.908, 0.663,
+     0.381, 0.903, 0.655, 0.359, 0.898, 0.646, 0.336, 0.893, 0.638, 0.313,
+     0.887, 0.629, 0.290, 0.882, 0.621, 0.266, 0.876, 0.613, 0.241, 0.871,
+     0.604, 0.216, 0.866, 0.596, 0.189, 0.708, 0.592, 0.997, 0.716, 0.601,
+     0.991, 0.725, 0.611, 0.985, 0.733, 0.620, 0.980, 0.742, 0.629, 0.975,
+     0.751, 0.638, 0.970, 0.759, 0.647, 0.966, 0.768, 0.656, 0.961, 0.777,
+     0.665, 0.957, 0.786, 0.673, 0.953, 0.795, 0.682, 0.949, 0.804, 0.690,
+     0.946, 0.813, 0.699, 0.942, 0.822, 0.707, 0.939, 0.831, 0.715, 0.936,
+     0.840, 0.723, 0.933, 0.849, 0.731, 0.930, 0.859, 0.739, 0.927, 0.868,
+     0.747, 0.924, 0.876, 0.754, 0.921, 0.885, 0.762, 0.918, 0.894, 0.769,
+     0.915, 0.903, 0.775, 0.912, 0.911, 0.782, 0.909, 0.920, 0.787, 0.905,
+     0.928, 0.793, 0.901, 0.935, 0.798, 0.896, 0.943, 0.802, 0.891, 0.950,
+     0.805, 0.885, 0.956, 0.807, 0.878, 0.962, 0.809, 0.870, 0.967, 0.809,
+     0.861, 0.972, 0.809, 0.850, 0.976, 0.808, 0.838, 0.979, 0.805, 0.825,
+     0.981, 0.802, 0.810, 0.983, 0.799, 0.795, 0.983, 0.794, 0.778, 0.983,
+     0.789, 0.760, 0.982, 0.783, 0.741, 0.981, 0.777, 0.721, 0.979, 0.771,
+     0.701, 0.976, 0.764, 0.681, 0.973, 0.757, 0.660, 0.970, 0.750, 0.639,
+     0.966, 0.742, 0.618, 0.962, 0.735, 0.597, 0.958, 0.727, 0.575, 0.953,
+     0.719, 0.553, 0.949, 0.711, 0.532, 0.944, 0.703, 0.510, 0.939, 0.695,
+     0.488, 0.934, 0.687, 0.466, 0.929, 0.679, 0.444, 0.924, 0.671, 0.422,
+     0.919, 0.663, 0.400, 0.914, 0.654, 0.378, 0.909, 0.646, 0.355, 0.903,
+     0.638, 0.333, 0.898, 0.630, 0.310, 0.893, 0.621, 0.287, 0.887, 0.613,
+     0.263, 0.882, 0.605, 0.238, 0.877, 0.597, 0.213, 0.871, 0.589, 0.186,
+     0.715, 0.584, 0.996, 0.723, 0.593, 0.990, 0.731, 0.603, 0.984, 0.739,
+     0.612, 0.979, 0.748, 0.621, 0.974, 0.756, 0.630, 0.969, 0.765, 0.639,
+     0.964, 0.774, 0.648, 0.960, 0.782, 0.656, 0.955, 0.791, 0.665, 0.951,
+     0.800, 0.673, 0.947, 0.809, 0.682, 0.943, 0.818, 0.690, 0.940, 0.826,
+     0.698, 0.936, 0.835, 0.706, 0.933, 0.844, 0.714, 0.930, 0.853, 0.722,
+     0.926, 0.862, 0.729, 0.923, 0.871, 0.737, 0.920, 0.879, 0.744, 0.917,
+     0.888, 0.751, 0.913, 0.896, 0.758, 0.910, 0.905, 0.764, 0.906, 0.913,
+     0.770, 0.903, 0.921, 0.775, 0.898, 0.929, 0.780, 0.894, 0.936, 0.784,
+     0.889, 0.943, 0.788, 0.883, 0.950, 0.791, 0.877, 0.956, 0.793, 0.869,
+     0.962, 0.794, 0.861, 0.967, 0.795, 0.851, 0.971, 0.794, 0.841, 0.975,
+     0.793, 0.829, 0.978, 0.791, 0.815, 0.981, 0.788, 0.801, 0.982, 0.785,
+     0.785, 0.983, 0.780, 0.769, 0.983, 0.776, 0.751, 0.983, 0.770, 0.733,
+     0.982, 0.764, 0.714, 0.980, 0.758, 0.694, 0.978, 0.752, 0.674, 0.975,
+     0.745, 0.654, 0.972, 0.738, 0.633, 0.969, 0.731, 0.612, 0.965, 0.724,
+     0.591, 0.961, 0.716, 0.570, 0.957, 0.709, 0.548, 0.953, 0.701, 0.527,
+     0.948, 0.693, 0.505, 0.943, 0.685, 0.484, 0.939, 0.678, 0.462, 0.934,
+     0.670, 0.440, 0.929, 0.662, 0.418, 0.924, 0.654, 0.396, 0.919, 0.646,
+     0.374, 0.914, 0.637, 0.352, 0.908, 0.629, 0.329, 0.903, 0.621, 0.307,
+     0.898, 0.613, 0.283, 0.893, 0.605, 0.260, 0.887, 0.597, 0.235, 0.882,
+     0.589, 0.210, 0.876, 0.581, 0.183, 0.721, 0.576, 0.995, 0.729, 0.585,
+     0.989, 0.737, 0.595, 0.983, 0.745, 0.604, 0.978, 0.754, 0.613, 0.973,
+     0.762, 0.622, 0.968, 0.770, 0.631, 0.963, 0.779, 0.639, 0.958, 0.787,
+     0.648, 0.954, 0.796, 0.656, 0.949, 0.805, 0.665, 0.945, 0.813, 0.673,
+     0.941, 0.822, 0.681, 0.937, 0.830, 0.689, 0.933, 0.839, 0.697, 0.930,
+     0.848, 0.704, 0.926, 0.856, 0.712, 0.923, 0.865, 0.719, 0.919, 0.873,
+     0.726, 0.916, 0.882, 0.733, 0.912, 0.890, 0.740, 0.908, 0.898, 0.746,
+     0.905, 0.906, 0.752, 0.901, 0.914, 0.757, 0.896, 0.922, 0.762, 0.892,
+     0.929, 0.767, 0.887, 0.937, 0.771, 0.881, 0.943, 0.774, 0.875, 0.950,
+     0.777, 0.868, 0.956, 0.779, 0.860, 0.961, 0.780, 0.851, 0.966, 0.780,
+     0.842, 0.971, 0.780, 0.831, 0.975, 0.779, 0.819, 0.978, 0.777, 0.806,
+     0.980, 0.774, 0.791, 0.982, 0.771, 0.776, 0.983, 0.767, 0.760, 0.984,
+     0.762, 0.742, 0.983, 0.757, 0.725, 0.983, 0.752, 0.706, 0.981, 0.746,
+     0.687, 0.979, 0.740, 0.667, 0.977, 0.733, 0.647, 0.974, 0.727, 0.627,
+     0.971, 0.720, 0.606, 0.968, 0.713, 0.585, 0.964, 0.706, 0.564, 0.960,
+     0.698, 0.543, 0.956, 0.691, 0.522, 0.952, 0.683, 0.501, 0.947, 0.676,
+     0.479, 0.943, 0.668, 0.458, 0.938, 0.660, 0.436, 0.933, 0.652, 0.414,
+     0.928, 0.644, 0.392, 0.923, 0.636, 0.370, 0.918, 0.629, 0.348, 0.913,
+     0.621, 0.326, 0.908, 0.613, 0.303, 0.903, 0.605, 0.280, 0.897, 0.597,
+     0.257, 0.892, 0.589, 0.232, 0.887, 0.581, 0.207, 0.881, 0.573, 0.180,
+     0.727, 0.568, 0.994, 0.735, 0.577, 0.988, 0.743, 0.586, 0.982, 0.751,
+     0.595, 0.977, 0.759, 0.604, 0.971, 0.767, 0.613, 0.966, 0.776, 0.622,
+     0.961, 0.784, 0.630, 0.956, 0.792, 0.639, 0.951, 0.801, 0.647, 0.947,
+     0.809, 0.655, 0.943, 0.817, 0.663, 0.938, 0.826, 0.671, 0.934, 0.834,
+     0.679, 0.930, 0.843, 0.687, 0.927, 0.851, 0.694, 0.923, 0.859, 0.702,
+     0.919, 0.868, 0.709, 0.915, 0.876, 0.715, 0.911, 0.884, 0.722, 0.907,
+     0.892, 0.728, 0.903, 0.900, 0.734, 0.899, 0.908, 0.740, 0.895, 0.916,
+     0.745, 0.890, 0.923, 0.750, 0.885, 0.930, 0.754, 0.879, 0.937, 0.758,
+     0.873, 0.944, 0.761, 0.867, 0.950, 0.763, 0.859, 0.956, 0.765, 0.851,
+     0.961, 0.766, 0.842, 0.966, 0.766, 0.832, 0.970, 0.766, 0.821, 0.974,
+     0.764, 0.809, 0.977, 0.762, 0.796, 0.980, 0.760, 0.782, 0.982, 0.757,
+     0.767, 0.983, 0.753, 0.751, 0.984, 0.749, 0.734, 0.984, 0.744, 0.716,
+     0.983, 0.739, 0.698, 0.982, 0.733, 0.679, 0.980, 0.727, 0.660, 0.978,
+     0.721, 0.640, 0.976, 0.715, 0.620, 0.973, 0.708, 0.600, 0.970, 0.701,
+     0.579, 0.967, 0.694, 0.559, 0.963, 0.687, 0.538, 0.959, 0.680, 0.517,
+     0.955, 0.673, 0.496, 0.951, 0.665, 0.474, 0.946, 0.658, 0.453, 0.942,
+     0.650, 0.432, 0.937, 0.643, 0.410, 0.932, 0.635, 0.388, 0.927, 0.627,
+     0.367, 0.922, 0.619, 0.345, 0.917, 0.612, 0.322, 0.912, 0.604, 0.300,
+     0.907, 0.596, 0.277, 0.902, 0.588, 0.253, 0.897, 0.580, 0.229, 0.891,
+     0.572, 0.204, 0.886, 0.564, 0.177, 0.733, 0.559, 0.993, 0.741, 0.568,
+     0.987, 0.749, 0.577, 0.981, 0.757, 0.587, 0.975, 0.765, 0.595, 0.970,
+     0.773, 0.604, 0.964, 0.781, 0.613, 0.959, 0.789, 0.621, 0.954, 0.797,
+     0.630, 0.949, 0.805, 0.638, 0.945, 0.813, 0.646, 0.940, 0.821, 0.654,
+     0.936, 0.830, 0.662, 0.931, 0.838, 0.669, 0.927, 0.846, 0.677, 0.923,
+     0.854, 0.684, 0.919, 0.862, 0.691, 0.915, 0.870, 0.698, 0.911, 0.879,
+     0.704, 0.907, 0.886, 0.711, 0.902, 0.894, 0.717, 0.898, 0.902, 0.722,
+     0.893, 0.910, 0.727, 0.889, 0.917, 0.732, 0.883, 0.924, 0.737, 0.878,
+     0.931, 0.741, 0.872, 0.938, 0.744, 0.866, 0.944, 0.747, 0.859, 0.950,
+     0.749, 0.851, 0.956, 0.751, 0.842, 0.961, 0.751, 0.833, 0.966, 0.752,
+     0.823, 0.970, 0.751, 0.812, 0.974, 0.750, 0.800, 0.977, 0.748, 0.787,
+     0.979, 0.746, 0.773, 0.981, 0.743, 0.758, 0.983, 0.739, 0.742, 0.984,
+     0.735, 0.725, 0.984, 0.731, 0.708, 0.983, 0.726, 0.690, 0.983, 0.721,
+     0.672, 0.981, 0.715, 0.653, 0.980, 0.709, 0.633, 0.977, 0.703, 0.614,
+     0.975, 0.697, 0.594, 0.972, 0.690, 0.573, 0.969, 0.683, 0.553, 0.965,
+     0.676, 0.532, 0.962, 0.669, 0.512, 0.958, 0.662, 0.491, 0.954, 0.655,
+     0.470, 0.949, 0.648, 0.448, 0.945, 0.640, 0.427, 0.941, 0.633, 0.406,
+     0.936, 0.625, 0.384, 0.931, 0.618, 0.363, 0.926, 0.610, 0.341, 0.921,
+     0.602, 0.319, 0.916, 0.595, 0.296, 0.911, 0.587, 0.273, 0.906, 0.579,
+     0.250, 0.901, 0.571, 0.226, 0.896, 0.563, 0.201, 0.890, 0.556, 0.174,
+     0.739, 0.550, 0.992, 0.747, 0.559, 0.986, 0.754, 0.568, 0.980, 0.762,
+     0.577, 0.974, 0.770, 0.586, 0.968, 0.778, 0.595, 0.962, 0.785, 0.603,
+     0.957, 0.793, 0.612, 0.952, 0.801, 0.620, 0.947, 0.809, 0.628, 0.942,
+     0.817, 0.636, 0.937, 0.825, 0.644, 0.933, 0.833, 0.651, 0.928, 0.841,
+     0.659, 0.924, 0.849, 0.666, 0.919, 0.857, 0.673, 0.915, 0.865, 0.680,
+     0.911, 0.873, 0.686, 0.906, 0.881, 0.693, 0.902, 0.889, 0.699, 0.897,
+     0.896, 0.705, 0.892, 0.904, 0.710, 0.887, 0.911, 0.715, 0.882, 0.918,
+     0.720, 0.877, 0.925, 0.724, 0.871, 0.932, 0.727, 0.865, 0.938, 0.730,
+     0.858, 0.944, 0.733, 0.850, 0.950, 0.735, 0.842, 0.956, 0.736, 0.834,
+     0.961, 0.737, 0.824, 0.965, 0.737, 0.814, 0.970, 0.737, 0.802, 0.973,
+     0.736, 0.790, 0.976, 0.734, 0.777, 0.979, 0.732, 0.763, 0.981, 0.729,
+     0.749, 0.982, 0.726, 0.733, 0.983, 0.722, 0.717, 0.984, 0.717, 0.700,
+     0.984, 0.713, 0.682, 0.983, 0.708, 0.664, 0.982, 0.702, 0.645, 0.980,
+     0.697, 0.626, 0.979, 0.691, 0.607, 0.976, 0.685, 0.587, 0.974, 0.678,
+     0.567, 0.971, 0.672, 0.547, 0.967, 0.665, 0.527, 0.964, 0.658, 0.506,
+     0.960, 0.651, 0.485, 0.956, 0.644, 0.465, 0.952, 0.637, 0.444, 0.948,
+     0.630, 0.423, 0.944, 0.623, 0.401, 0.939, 0.615, 0.380, 0.934, 0.608,
+     0.358, 0.930, 0.600, 0.337, 0.925, 0.593, 0.315, 0.920, 0.585, 0.292,
+     0.915, 0.578, 0.270, 0.910, 0.570, 0.246, 0.905, 0.562, 0.222, 0.899,
+     0.555, 0.197, 0.894, 0.547, 0.171, 0.745, 0.540, 0.991, 0.752, 0.550,
+     0.984, 0.760, 0.559, 0.978, 0.767, 0.568, 0.972, 0.775, 0.577, 0.966,
+     0.782, 0.585, 0.960, 0.790, 0.594, 0.955, 0.798, 0.602, 0.950, 0.806,
+     0.610, 0.944, 0.813, 0.618, 0.939, 0.821, 0.626, 0.934, 0.829, 0.634,
+     0.930, 0.837, 0.641, 0.925, 0.845, 0.648, 0.920, 0.852, 0.655, 0.915,
+     0.860, 0.662, 0.911, 0.868, 0.669, 0.906, 0.876, 0.675, 0.901, 0.883,
+     0.681, 0.897, 0.891, 0.687, 0.892, 0.898, 0.692, 0.887, 0.905, 0.697,
+     0.881, 0.912, 0.702, 0.876, 0.919, 0.707, 0.870, 0.926, 0.710, 0.864,
+     0.932, 0.714, 0.857, 0.939, 0.717, 0.850, 0.945, 0.719, 0.842, 0.950,
+     0.721, 0.834, 0.956, 0.722, 0.825, 0.961, 0.723, 0.815, 0.965, 0.723,
+     0.804, 0.969, 0.723, 0.793, 0.973, 0.722, 0.781, 0.976, 0.720, 0.768,
+     0.978, 0.718, 0.754, 0.981, 0.715, 0.739, 0.982, 0.712, 0.724, 0.983,
+     0.708, 0.708, 0.984, 0.704, 0.691, 0.984, 0.700, 0.674, 0.983, 0.695,
+     0.656, 0.982, 0.690, 0.638, 0.981, 0.684, 0.619, 0.979, 0.679, 0.600,
+     0.977, 0.673, 0.581, 0.975, 0.666, 0.561, 0.972, 0.660, 0.541, 0.969,
+     0.654, 0.521, 0.966, 0.647, 0.501, 0.962, 0.640, 0.480, 0.959, 0.634,
+     0.459, 0.955, 0.627, 0.439, 0.951, 0.620, 0.418, 0.946, 0.612, 0.397,
+     0.942, 0.605, 0.376, 0.937, 0.598, 0.354, 0.933, 0.591, 0.333, 0.928,
+     0.583, 0.311, 0.923, 0.576, 0.289, 0.918, 0.568, 0.266, 0.913, 0.561,
+     0.243, 0.908, 0.553, 0.219, 0.903, 0.546, 0.194, 0.898, 0.538, 0.167,
+     0.750, 0.531, 0.989, 0.757, 0.540, 0.983, 0.765, 0.549, 0.976, 0.772,
+     0.558, 0.970, 0.779, 0.567, 0.964, 0.787, 0.575, 0.958, 0.794, 0.584,
+     0.953, 0.802, 0.592, 0.947, 0.810, 0.600, 0.942, 0.817, 0.608, 0.936,
+     0.825, 0.615, 0.931, 0.833, 0.623, 0.926, 0.840, 0.630, 0.921, 0.848,
+     0.637, 0.916, 0.855, 0.644, 0.911, 0.863, 0.651, 0.907, 0.870, 0.657,
+     0.902, 0.878, 0.663, 0.897, 0.885, 0.669, 0.891, 0.893, 0.675, 0.886,
+     0.900, 0.680, 0.881, 0.907, 0.685, 0.875, 0.914, 0.689, 0.869, 0.920,
+     0.693, 0.863, 0.927, 0.697, 0.857, 0.933, 0.700, 0.850, 0.939, 0.703,
+     0.842, 0.945, 0.705, 0.834, 0.950, 0.707, 0.825, 0.956, 0.708, 0.816,
+     0.960, 0.709, 0.806, 0.965, 0.709, 0.795, 0.969, 0.708, 0.784, 0.972,
+     0.707, 0.772, 0.975, 0.706, 0.759, 0.978, 0.704, 0.745, 0.980, 0.701,
+     0.731, 0.982, 0.698, 0.715, 0.983, 0.694, 0.699, 0.984, 0.691, 0.683,
+     0.984, 0.686, 0.666, 0.983, 0.682, 0.648, 0.983, 0.677, 0.630, 0.982,
+     0.672, 0.612, 0.980, 0.666, 0.593, 0.978, 0.660, 0.574, 0.976, 0.655,
+     0.554, 0.973, 0.648, 0.535, 0.971, 0.642, 0.515, 0.967, 0.636, 0.495,
+     0.964, 0.629, 0.475, 0.961, 0.623, 0.454, 0.957, 0.616, 0.434, 0.953,
+     0.609, 0.413, 0.949, 0.602, 0.392, 0.944, 0.595, 0.371, 0.940, 0.588,
+     0.350, 0.936, 0.580, 0.328, 0.931, 0.573, 0.307, 0.926, 0.566, 0.285,
+     0.921, 0.559, 0.262, 0.916, 0.551, 0.239, 0.911, 0.544, 0.215, 0.906,
+     0.536, 0.190, 0.901, 0.529, 0.164, 0.755, 0.521, 0.988, 0.762, 0.530,
+     0.981, 0.770, 0.539, 0.975, 0.777, 0.548, 0.968, 0.784, 0.557, 0.962,
+     0.791, 0.565, 0.956, 0.799, 0.573, 0.950, 0.806, 0.582, 0.944, 0.814,
+     0.589, 0.939, 0.821, 0.597, 0.933, 0.828, 0.605, 0.928, 0.836, 0.612,
+     0.923, 0.843, 0.619, 0.918, 0.851, 0.626, 0.912, 0.858, 0.633, 0.907,
+     0.866, 0.639, 0.902, 0.873, 0.645, 0.897, 0.880, 0.651, 0.892, 0.887,
+     0.657, 0.886, 0.894, 0.662, 0.881, 0.901, 0.667, 0.875, 0.908, 0.672,
+     0.869, 0.915, 0.676, 0.863, 0.921, 0.680, 0.856, 0.928, 0.684, 0.849,
+     0.934, 0.687, 0.842, 0.940, 0.689, 0.834, 0.945, 0.691, 0.826, 0.951,
+     0.693, 0.817, 0.956, 0.694, 0.807, 0.960, 0.695, 0.797, 0.964, 0.695,
+     0.787, 0.968, 0.694, 0.775, 0.972, 0.693, 0.763, 0.975, 0.692, 0.750,
+     0.977, 0.690, 0.736, 0.980, 0.687, 0.722, 0.981, 0.684, 0.707, 0.982,
+     0.681, 0.691, 0.983, 0.677, 0.675, 0.984, 0.673, 0.658, 0.983, 0.669,
+     0.641, 0.983, 0.664, 0.623, 0.982, 0.659, 0.605, 0.980, 0.654, 0.586,
+     0.979, 0.648, 0.567, 0.977, 0.642, 0.548, 0.974, 0.637, 0.529, 0.972,
+     0.630, 0.509, 0.969, 0.624, 0.489, 0.966, 0.618, 0.469, 0.962, 0.611,
+     0.449, 0.959, 0.605, 0.429, 0.955, 0.598, 0.408, 0.951, 0.591, 0.387,
+     0.947, 0.584, 0.367, 0.942, 0.577, 0.346, 0.938, 0.570, 0.324, 0.933,
+     0.563, 0.303, 0.929, 0.556, 0.281, 0.924, 0.549, 0.258, 0.919, 0.541,
+     0.235, 0.914, 0.534, 0.212, 0.909, 0.527, 0.187, 0.904, 0.519, 0.160,
+     0.760, 0.510, 0.986, 0.767, 0.520, 0.979, 0.774, 0.529, 0.973, 0.781,
+     0.538, 0.966, 0.788, 0.546, 0.960, 0.796, 0.555, 0.954, 0.803, 0.563,
+     0.948, 0.810, 0.571, 0.942, 0.817, 0.579, 0.936, 0.825, 0.586, 0.930,
+     0.832, 0.594, 0.925, 0.839, 0.601, 0.919, 0.846, 0.608, 0.914, 0.854,
+     0.615, 0.908, 0.861, 0.621, 0.903, 0.868, 0.627, 0.897, 0.875, 0.633,
+     0.892, 0.882, 0.639, 0.886, 0.889, 0.645, 0.881, 0.896, 0.650, 0.875,
+     0.903, 0.655, 0.869, 0.909, 0.659, 0.863, 0.916, 0.663, 0.856, 0.922,
+     0.667, 0.849, 0.928, 0.670, 0.842, 0.934, 0.673, 0.834, 0.940, 0.675,
+     0.826, 0.945, 0.677, 0.818, 0.951, 0.679, 0.809, 0.955, 0.680, 0.799,
+     0.960, 0.680, 0.789, 0.964, 0.680, 0.778, 0.968, 0.680, 0.766, 0.971,
+     0.679, 0.754, 0.974, 0.677, 0.741, 0.977, 0.676, 0.727, 0.979, 0.673,
+     0.713, 0.981, 0.670, 0.698, 0.982, 0.667, 0.682, 0.983, 0.664, 0.666,
+     0.983, 0.660, 0.650, 0.983, 0.655, 0.633, 0.983, 0.651, 0.615, 0.982,
+     0.646, 0.597, 0.981, 0.641, 0.579, 0.979, 0.636, 0.560, 0.977, 0.630,
+     0.541, 0.975, 0.625, 0.522, 0.973, 0.619, 0.503, 0.970, 0.613, 0.483,
+     0.967, 0.606, 0.463, 0.964, 0.600, 0.443, 0.960, 0.594, 0.423, 0.956,
+     0.587, 0.403, 0.953, 0.580, 0.383, 0.949, 0.574, 0.362, 0.944, 0.567,
+     0.341, 0.940, 0.560, 0.320, 0.936, 0.553, 0.298, 0.931, 0.546, 0.277,
+     0.926, 0.539, 0.254, 0.922, 0.532, 0.232, 0.917, 0.524, 0.208, 0.912,
+     0.517, 0.183, 0.906, 0.510, 0.156, 0.765, 0.499, 0.985, 0.772, 0.509,
+     0.978, 0.779, 0.518, 0.971, 0.786, 0.527, 0.964, 0.793, 0.535, 0.957,
+     0.800, 0.544, 0.951, 0.807, 0.552, 0.945, 0.814, 0.560, 0.939, 0.821,
+     0.568, 0.933, 0.828, 0.575, 0.927, 0.835, 0.582, 0.921, 0.842, 0.589,
+     0.915, 0.849, 0.596, 0.910, 0.856, 0.603, 0.904, 0.863, 0.609, 0.898,
+     0.870, 0.615, 0.893, 0.877, 0.621, 0.887, 0.884, 0.627, 0.881, 0.891,
+     0.632, 0.875, 0.898, 0.637, 0.869, 0.904, 0.642, 0.863, 0.911, 0.646,
+     0.856, 0.917, 0.650, 0.849, 0.923, 0.653, 0.842, 0.929, 0.657, 0.835,
+     0.935, 0.659, 0.827, 0.940, 0.662, 0.818, 0.946, 0.663, 0.810, 0.951,
+     0.665, 0.800, 0.955, 0.666, 0.790, 0.960, 0.666, 0.780, 0.964, 0.666,
+     0.769, 0.967, 0.666, 0.757, 0.971, 0.665, 0.745, 0.974, 0.663, 0.732,
+     0.976, 0.662, 0.718, 0.978, 0.659, 0.704, 0.980, 0.657, 0.689, 0.981,
+     0.654, 0.674, 0.982, 0.650, 0.658, 0.983, 0.646, 0.642, 0.983, 0.642,
+     0.625, 0.983, 0.638, 0.608, 0.982, 0.633, 0.590, 0.981, 0.628, 0.572,
+     0.979, 0.623, 0.553, 0.978, 0.618, 0.535, 0.976, 0.612, 0.516, 0.973,
+     0.607, 0.497, 0.971, 0.601, 0.477, 0.968, 0.595, 0.458, 0.965, 0.589,
+     0.438, 0.961, 0.582, 0.418, 0.958, 0.576, 0.398, 0.954, 0.569, 0.378,
+     0.950, 0.563, 0.357, 0.946, 0.556, 0.336, 0.942, 0.549, 0.315, 0.938,
+     0.542, 0.294, 0.933, 0.536, 0.273, 0.928, 0.529, 0.250, 0.924, 0.522,
+     0.228, 0.919, 0.514, 0.204, 0.914, 0.507, 0.179, 0.909, 0.500, 0.153,
+     0.770, 0.488, 0.983, 0.777, 0.498, 0.976, 0.783, 0.507, 0.969, 0.790,
+     0.516, 0.962, 0.797, 0.524, 0.955, 0.804, 0.533, 0.948, 0.811, 0.541,
+     0.942, 0.817, 0.549, 0.936, 0.824, 0.556, 0.930, 0.831, 0.564, 0.924,
+     0.838, 0.571, 0.918, 0.845, 0.578, 0.912, 0.852, 0.584, 0.906, 0.859,
+     0.591, 0.900, 0.866, 0.597, 0.894, 0.873, 0.603, 0.888, 0.879, 0.609,
+     0.882, 0.886, 0.614, 0.876, 0.893, 0.619, 0.869, 0.899, 0.624, 0.863,
+     0.906, 0.629, 0.856, 0.912, 0.633, 0.850, 0.918, 0.637, 0.843, 0.924,
+     0.640, 0.835, 0.930, 0.643, 0.827, 0.935, 0.646, 0.819, 0.941, 0.648,
+     0.811, 0.946, 0.649, 0.802, 0.951, 0.651, 0.792, 0.955, 0.652, 0.782,
+     0.959, 0.652, 0.771, 0.963, 0.652, 0.760, 0.967, 0.652, 0.749, 0.970,
+     0.651, 0.736, 0.973, 0.649, 0.723, 0.976, 0.647, 0.710, 0.978, 0.645,
+     0.696, 0.980, 0.643, 0.681, 0.981, 0.640, 0.666, 0.982, 0.637, 0.650,
+     0.982, 0.633, 0.634, 0.983, 0.629, 0.617, 0.982, 0.625, 0.600, 0.982,
+     0.620, 0.582, 0.981, 0.616, 0.565, 0.979, 0.611, 0.546, 0.978, 0.605,
+     0.528, 0.976, 0.600, 0.509, 0.974, 0.595, 0.490, 0.971, 0.589, 0.471,
+     0.969, 0.583, 0.452, 0.966, 0.577, 0.432, 0.962, 0.571, 0.413, 0.959,
+     0.565, 0.393, 0.955, 0.558, 0.373, 0.952, 0.552, 0.352, 0.948, 0.545,
+     0.332, 0.943, 0.539, 0.311, 0.939, 0.532, 0.290, 0.935, 0.525, 0.268,
+     0.930, 0.518, 0.246, 0.926, 0.511, 0.224, 0.921, 0.504, 0.200, 0.916,
+     0.497, 0.175, 0.911, 0.490, 0.149, 0.775, 0.477, 0.981, 0.781, 0.486,
+     0.974, 0.788, 0.495, 0.966, 0.794, 0.504, 0.959, 0.801, 0.513, 0.952,
+     0.808, 0.521, 0.946, 0.814, 0.529, 0.939, 0.821, 0.537, 0.933, 0.828,
+     0.545, 0.926, 0.835, 0.552, 0.920, 0.841, 0.559, 0.914, 0.848, 0.566,
+     0.908, 0.855, 0.572, 0.901, 0.862, 0.579, 0.895, 0.868, 0.585, 0.889,
+     0.875, 0.591, 0.883, 0.881, 0.596, 0.877, 0.888, 0.601, 0.870, 0.894,
+     0.606, 0.864, 0.901, 0.611, 0.857, 0.907, 0.615, 0.850, 0.913, 0.619,
+     0.843, 0.919, 0.623, 0.836, 0.925, 0.626, 0.828, 0.930, 0.629, 0.820,
+     0.936, 0.632, 0.812, 0.941, 0.634, 0.803, 0.946, 0.635, 0.794, 0.951,
+     0.637, 0.784, 0.955, 0.637, 0.774, 0.959, 0.638, 0.763, 0.963, 0.638,
+     0.752, 0.967, 0.637, 0.740, 0.970, 0.636, 0.728, 0.973, 0.635, 0.715,
+     0.975, 0.633, 0.701, 0.977, 0.631, 0.687, 0.979, 0.629, 0.672, 0.980,
+     0.626, 0.657, 0.981, 0.623, 0.642, 0.982, 0.619, 0.626, 0.982, 0.616,
+     0.609, 0.982, 0.612, 0.592, 0.981, 0.607, 0.575, 0.981, 0.603, 0.557,
+     0.979, 0.598, 0.540, 0.978, 0.593, 0.521, 0.976, 0.588, 0.503, 0.974,
+     0.582, 0.484, 0.972, 0.577, 0.465, 0.969, 0.571, 0.446, 0.966, 0.565,
+     0.427, 0.963, 0.559, 0.407, 0.960, 0.553, 0.387, 0.956, 0.547, 0.368,
+     0.953, 0.541, 0.347, 0.949, 0.534, 0.327, 0.945, 0.528, 0.306, 0.941,
+     0.521, 0.285, 0.936, 0.514, 0.264, 0.932, 0.508, 0.242, 0.927, 0.501,
+     0.220, 0.922, 0.494, 0.196, 0.918, 0.487, 0.172, 0.913, 0.480, 0.145,
+     0.779, 0.465, 0.979, 0.785, 0.474, 0.971, 0.792, 0.484, 0.964, 0.798,
+     0.492, 0.957, 0.805, 0.501, 0.950, 0.811, 0.509, 0.943, 0.818, 0.517,
+     0.936, 0.824, 0.525, 0.929, 0.831, 0.533, 0.923, 0.838, 0.540, 0.916,
+     0.844, 0.547, 0.910, 0.851, 0.554, 0.904, 0.857, 0.560, 0.897, 0.864,
+     0.566, 0.891, 0.870, 0.572, 0.884, 0.877, 0.578, 0.878, 0.883, 0.583,
+     0.871, 0.890, 0.589, 0.865, 0.896, 0.593, 0.858, 0.902, 0.598, 0.851,
+     0.908, 0.602, 0.844, 0.914, 0.606, 0.837, 0.920, 0.609, 0.829, 0.925,
+     0.613, 0.821, 0.931, 0.615, 0.813, 0.936, 0.618, 0.804, 0.941, 0.620,
+     0.795, 0.946, 0.621, 0.786, 0.950, 0.622, 0.776, 0.955, 0.623, 0.765,
+     0.959, 0.624, 0.755, 0.963, 0.624, 0.743, 0.966, 0.623, 0.731, 0.969,
+     0.622, 0.719, 0.972, 0.621, 0.706, 0.974, 0.619, 0.693, 0.976, 0.617,
+     0.679, 0.978, 0.615, 0.664, 0.979, 0.612, 0.649, 0.980, 0.609, 0.634,
+     0.981, 0.606, 0.618, 0.981, 0.602, 0.601, 0.981, 0.598, 0.585, 0.981,
+     0.594, 0.568, 0.980, 0.590, 0.550, 0.979, 0.585, 0.533, 0.978, 0.580,
+     0.515, 0.976, 0.575, 0.496, 0.974, 0.570, 0.478, 0.972, 0.565, 0.459,
+     0.969, 0.559, 0.440, 0.967, 0.553, 0.421, 0.964, 0.547, 0.402, 0.960,
+     0.542, 0.382, 0.957, 0.535, 0.362, 0.953, 0.529, 0.342, 0.950, 0.523,
+     0.322, 0.946, 0.517, 0.302, 0.942, 0.510, 0.281, 0.937, 0.504, 0.260,
+     0.933, 0.497, 0.238, 0.929, 0.490, 0.216, 0.924, 0.484, 0.192, 0.919,
+     0.477, 0.168, 0.914, 0.470, 0.141, 0.783, 0.453, 0.977, 0.789, 0.462,
+     0.969, 0.796, 0.471, 0.962, 0.802, 0.480, 0.954, 0.808, 0.489, 0.947,
+     0.815, 0.497, 0.940, 0.821, 0.505, 0.933, 0.828, 0.513, 0.926, 0.834,
+     0.520, 0.919, 0.840, 0.527, 0.913, 0.847, 0.534, 0.906, 0.853, 0.541,
+     0.899, 0.860, 0.548, 0.893, 0.866, 0.554, 0.886, 0.873, 0.560, 0.880,
+     0.879, 0.565, 0.873, 0.885, 0.570, 0.866, 0.891, 0.575, 0.859, 0.897,
+     0.580, 0.852, 0.903, 0.585, 0.845, 0.909, 0.589, 0.838, 0.915, 0.592,
+     0.830, 0.921, 0.596, 0.822, 0.926, 0.599, 0.814, 0.931, 0.601, 0.805,
+     0.936, 0.604, 0.797, 0.941, 0.606, 0.787, 0.946, 0.607, 0.778, 0.950,
+     0.608, 0.768, 0.955, 0.609, 0.757, 0.958, 0.609, 0.746, 0.962, 0.609,
+     0.735, 0.965, 0.609, 0.723, 0.968, 0.608, 0.710, 0.971, 0.607, 0.698,
+     0.974, 0.605, 0.684, 0.976, 0.603, 0.670, 0.977, 0.601, 0.656, 0.979,
+     0.598, 0.641, 0.980, 0.596, 0.626, 0.980, 0.592, 0.610, 0.981, 0.589,
+     0.594, 0.981, 0.585, 0.577, 0.980, 0.581, 0.560, 0.980, 0.577, 0.543,
+     0.979, 0.572, 0.526, 0.977, 0.568, 0.508, 0.976, 0.563, 0.490, 0.974,
+     0.558, 0.471, 0.972, 0.552, 0.453, 0.969, 0.547, 0.434, 0.967, 0.541,
+     0.415, 0.964, 0.536, 0.396, 0.961, 0.530, 0.377, 0.958, 0.524, 0.357,
+     0.954, 0.518, 0.337, 0.950, 0.512, 0.317, 0.947, 0.505, 0.297, 0.943,
+     0.499, 0.276, 0.938, 0.493, 0.255, 0.934, 0.486, 0.234, 0.930, 0.480,
+     0.211, 0.925, 0.473, 0.188, 0.920, 0.466, 0.164, 0.916, 0.459, 0.137,
+     0.787, 0.440, 0.975, 0.793, 0.450, 0.967, 0.799, 0.459, 0.959, 0.806,
+     0.468, 0.952, 0.812, 0.476, 0.944, 0.818, 0.485, 0.937, 0.824, 0.493,
+     0.930, 0.831, 0.500, 0.923, 0.837, 0.508, 0.916, 0.843, 0.515, 0.909,
+     0.850, 0.522, 0.902, 0.856, 0.528, 0.895, 0.862, 0.535, 0.888, 0.868,
+     0.541, 0.881, 0.874, 0.547, 0.875, 0.881, 0.552, 0.868, 0.887, 0.557,
+     0.861, 0.893, 0.562, 0.853, 0.899, 0.567, 0.846, 0.904, 0.571, 0.839,
+     0.910, 0.575, 0.831, 0.916, 0.579, 0.823, 0.921, 0.582, 0.815, 0.926,
+     0.585, 0.807, 0.932, 0.587, 0.798, 0.937, 0.590, 0.789, 0.941, 0.591,
+     0.780, 0.946, 0.593, 0.770, 0.950, 0.594, 0.760, 0.954, 0.595, 0.749,
+     0.958, 0.595, 0.738, 0.962, 0.595, 0.727, 0.965, 0.595, 0.715, 0.968,
+     0.594, 0.702, 0.970, 0.593, 0.689, 0.973, 0.591, 0.676, 0.975, 0.589,
+     0.662, 0.976, 0.587, 0.648, 0.978, 0.585, 0.633, 0.979, 0.582, 0.618,
+     0.980, 0.579, 0.602, 0.980, 0.575, 0.586, 0.980, 0.572, 0.570, 0.980,
+     0.568, 0.553, 0.979, 0.564, 0.536, 0.978, 0.559, 0.518, 0.977, 0.555,
+     0.501, 0.975, 0.550, 0.483, 0.974, 0.545, 0.465, 0.972, 0.540, 0.447,
+     0.969, 0.535, 0.428, 0.967, 0.529, 0.409, 0.964, 0.524, 0.390, 0.961,
+     0.518, 0.371, 0.958, 0.512, 0.352, 0.954, 0.506, 0.332, 0.951, 0.500,
+     0.312, 0.947, 0.494, 0.292, 0.943, 0.488, 0.272, 0.939, 0.481, 0.251,
+     0.935, 0.475, 0.229, 0.931, 0.469, 0.207, 0.926, 0.462, 0.184, 0.921,
+     0.455, 0.159, 0.917, 0.449, 0.133, 0.791, 0.427, 0.973, 0.797, 0.437,
+     0.964, 0.803, 0.446, 0.957, 0.809, 0.455, 0.949, 0.815, 0.464, 0.941,
+     0.821, 0.472, 0.934, 0.827, 0.480, 0.926, 0.834, 0.488, 0.919, 0.840,
+     0.495, 0.912, 0.846, 0.502, 0.905, 0.852, 0.509, 0.898, 0.858, 0.515,
+     0.891, 0.864, 0.522, 0.884, 0.870, 0.528, 0.877, 0.876, 0.533, 0.870,
+     0.882, 0.539, 0.862, 0.888, 0.544, 0.855, 0.894, 0.549, 0.848, 0.900,
+     0.553, 0.840, 0.906, 0.557, 0.833, 0.911, 0.561, 0.825, 0.916, 0.565,
+     0.817, 0.922, 0.568, 0.808, 0.927, 0.571, 0.800, 0.932, 0.573, 0.791,
+     0.937, 0.575, 0.782, 0.941, 0.577, 0.772, 0.946, 0.579, 0.762, 0.950,
+     0.580, 0.752, 0.954, 0.580, 0.741, 0.958, 0.581, 0.730, 0.961, 0.581,
+     0.718, 0.964, 0.580, 0.706, 0.967, 0.580, 0.694, 0.970, 0.578, 0.681,
+     0.972, 0.577, 0.667, 0.974, 0.575, 0.654, 0.976, 0.573, 0.639, 0.977,
+     0.571, 0.625, 0.978, 0.568, 0.610, 0.979, 0.565, 0.594, 0.979, 0.562,
+     0.578, 0.979, 0.558, 0.562, 0.979, 0.554, 0.545, 0.978, 0.550, 0.529,
+     0.977, 0.546, 0.511, 0.976, 0.542, 0.494, 0.975, 0.537, 0.476, 0.973,
+     0.532, 0.458, 0.971, 0.527, 0.440, 0.969, 0.522, 0.422, 0.967, 0.517,
+     0.403, 0.964, 0.511, 0.385, 0.961, 0.506, 0.366, 0.958, 0.500, 0.347,
+     0.955, 0.494, 0.327, 0.951, 0.488, 0.307, 0.947, 0.482, 0.287, 0.944,
+     0.476, 0.267, 0.940, 0.470, 0.246, 0.935, 0.464, 0.225, 0.931, 0.458,
+     0.203, 0.927, 0.451, 0.180, 0.922, 0.445, 0.155, 0.917, 0.438, 0.129,
+     0.795, 0.413, 0.970, 0.801, 0.423, 0.962, 0.807, 0.433, 0.954, 0.813,
+     0.442, 0.946, 0.818, 0.450, 0.938, 0.824, 0.459, 0.930, 0.830, 0.467,
+     0.923, 0.836, 0.474, 0.915, 0.842, 0.482, 0.908, 0.848, 0.489, 0.901,
+     0.854, 0.496, 0.894, 0.860, 0.502, 0.886, 0.866, 0.508, 0.879, 0.872,
+     0.514, 0.872, 0.878, 0.520, 0.864, 0.884, 0.525, 0.857, 0.890, 0.530,
+     0.850, 0.895, 0.535, 0.842, 0.901, 0.539, 0.834, 0.906, 0.543, 0.826,
+     0.912, 0.547, 0.818, 0.917, 0.551, 0.810, 0.922, 0.554, 0.801, 0.927,
+     0.557, 0.793, 0.932, 0.559, 0.783, 0.937, 0.561, 0.774, 0.941, 0.563,
+     0.764, 0.946, 0.564, 0.754, 0.950, 0.565, 0.744, 0.953, 0.566, 0.733,
+     0.957, 0.566, 0.722, 0.960, 0.566, 0.710, 0.963, 0.566, 0.698, 0.966,
+     0.565, 0.685, 0.969, 0.564, 0.673, 0.971, 0.563, 0.659, 0.973, 0.561,
+     0.645, 0.975, 0.559, 0.631, 0.976, 0.557, 0.617, 0.977, 0.554, 0.602,
+     0.978, 0.551, 0.586, 0.978, 0.548, 0.571, 0.978, 0.545, 0.554, 0.978,
+     0.541, 0.538, 0.977, 0.537, 0.521, 0.977, 0.533, 0.504, 0.976, 0.529,
+     0.487, 0.974, 0.524, 0.470, 0.973, 0.519, 0.452, 0.971, 0.515, 0.434,
+     0.969, 0.510, 0.416, 0.966, 0.504, 0.398, 0.964, 0.499, 0.379, 0.961,
+     0.494, 0.360, 0.958, 0.488, 0.341, 0.955, 0.482, 0.322, 0.951, 0.477,
+     0.302, 0.948, 0.471, 0.283, 0.944, 0.465, 0.262, 0.940, 0.459, 0.242,
+     0.936, 0.452, 0.220, 0.932, 0.446, 0.198, 0.927, 0.440, 0.175, 0.923,
+     0.434, 0.151, 0.918, 0.427, 0.124, 0.799, 0.399, 0.968, 0.804, 0.409,
+     0.959, 0.810, 0.419, 0.951, 0.816, 0.428, 0.943, 0.822, 0.437, 0.935,
+     0.827, 0.445, 0.927, 0.833, 0.453, 0.919, 0.839, 0.461, 0.912, 0.845,
+     0.468, 0.904, 0.851, 0.475, 0.897, 0.857, 0.482, 0.889, 0.862, 0.489,
+     0.882, 0.868, 0.495, 0.874, 0.874, 0.501, 0.867, 0.880, 0.506, 0.859,
+     0.885, 0.511, 0.852, 0.891, 0.516, 0.844, 0.897, 0.521, 0.836, 0.902,
+     0.525, 0.828, 0.907, 0.529, 0.820, 0.913, 0.533, 0.812, 0.918, 0.537,
+     0.803, 0.923, 0.540, 0.794, 0.928, 0.542, 0.785, 0.932, 0.545, 0.776,
+     0.937, 0.547, 0.767, 0.941, 0.549, 0.757, 0.945, 0.550, 0.747, 0.949,
+     0.551, 0.736, 0.953, 0.552, 0.725, 0.956, 0.552, 0.714, 0.960, 0.552,
+     0.702, 0.963, 0.552, 0.690, 0.965, 0.551, 0.677, 0.968, 0.550, 0.664,
+     0.970, 0.549, 0.651, 0.972, 0.547, 0.637, 0.974, 0.545, 0.623, 0.975,
+     0.543, 0.609, 0.976, 0.540, 0.594, 0.977, 0.537, 0.578, 0.977, 0.534,
+     0.563, 0.977, 0.531, 0.547, 0.977, 0.527, 0.531, 0.976, 0.524, 0.514,
+     0.976, 0.520, 0.497, 0.975, 0.516, 0.480, 0.973, 0.511, 0.463, 0.972,
+     0.507, 0.446, 0.970, 0.502, 0.428, 0.968, 0.497, 0.410, 0.966, 0.492,
+     0.392, 0.963, 0.487, 0.373, 0.960, 0.481, 0.355, 0.957, 0.476, 0.336,
+     0.954, 0.470, 0.317, 0.951, 0.465, 0.297, 0.947, 0.459, 0.278, 0.944,
+     0.453, 0.258, 0.940, 0.447, 0.237, 0.936, 0.441, 0.216, 0.932, 0.435,
+     0.194, 0.927, 0.429, 0.171, 0.923, 0.422, 0.147, 0.918, 0.416, 0.120,
+     0.802, 0.385, 0.965, 0.808, 0.395, 0.957, 0.813, 0.405, 0.948, 0.819,
+     0.414, 0.940, 0.825, 0.423, 0.932, 0.830, 0.431, 0.924, 0.836, 0.439,
+     0.916, 0.842, 0.447, 0.908, 0.847, 0.454, 0.900, 0.853, 0.462, 0.892,
+     0.859, 0.468, 0.885, 0.864, 0.475, 0.877, 0.870, 0.481, 0.869, 0.876,
+     0.487, 0.862, 0.881, 0.492, 0.854, 0.887, 0.498, 0.846, 0.892, 0.502,
+     0.838, 0.898, 0.507, 0.830, 0.903, 0.511, 0.822, 0.908, 0.515, 0.814,
+     0.913, 0.519, 0.805, 0.918, 0.522, 0.797, 0.923, 0.525, 0.788, 0.928,
+     0.528, 0.778, 0.932, 0.530, 0.769, 0.937, 0.532, 0.759, 0.941, 0.534,
+     0.749, 0.945, 0.535, 0.739, 0.949, 0.536, 0.728, 0.952, 0.537, 0.717,
+     0.956, 0.537, 0.706, 0.959, 0.537, 0.694, 0.962, 0.537, 0.682, 0.964,
+     0.536, 0.669, 0.967, 0.536, 0.656, 0.969, 0.534, 0.643, 0.971, 0.533,
+     0.629, 0.972, 0.531, 0.615, 0.974, 0.529, 0.601, 0.975, 0.526, 0.586,
+     0.975, 0.523, 0.571, 0.976, 0.521, 0.555, 0.976, 0.517, 0.540, 0.976,
+     0.514, 0.523, 0.975, 0.510, 0.507, 0.975, 0.506, 0.490, 0.974, 0.502,
+     0.474, 0.972, 0.498, 0.456, 0.971, 0.494, 0.439, 0.969, 0.489, 0.421,
+     0.967, 0.484, 0.404, 0.965, 0.479, 0.386, 0.963, 0.474, 0.367, 0.960,
+     0.469, 0.349, 0.957, 0.464, 0.330, 0.954, 0.458, 0.311, 0.951, 0.453,
+     0.292, 0.947, 0.447, 0.273, 0.944, 0.441, 0.253, 0.940, 0.435, 0.232,
+     0.936, 0.429, 0.211, 0.932, 0.423, 0.190, 0.927, 0.417, 0.167, 0.923,
+     0.411, 0.142, 0.919, 0.405, 0.116, 0.806, 0.370, 0.963, 0.811, 0.380,
+     0.954, 0.816, 0.390, 0.945, 0.822, 0.399, 0.937, 0.827, 0.408, 0.929,
+     0.833, 0.417, 0.920, 0.838, 0.425, 0.912, 0.844, 0.433, 0.904, 0.850,
+     0.440, 0.896, 0.855, 0.447, 0.888, 0.861, 0.454, 0.880, 0.866, 0.461,
+     0.872, 0.872, 0.467, 0.865, 0.877, 0.473, 0.857, 0.883, 0.478, 0.849,
+     0.888, 0.483, 0.841, 0.893, 0.488, 0.833, 0.899, 0.493, 0.824, 0.904,
+     0.497, 0.816, 0.909, 0.501, 0.807, 0.914, 0.505, 0.799, 0.919, 0.508,
+     0.790, 0.923, 0.511, 0.781, 0.928, 0.514, 0.771, 0.932, 0.516, 0.762,
+     0.937, 0.518, 0.752, 0.941, 0.520, 0.742, 0.945, 0.521, 0.731, 0.948,
+     0.522, 0.720, 0.952, 0.523, 0.709, 0.955, 0.523, 0.698, 0.958, 0.523,
+     0.686, 0.961, 0.523, 0.674, 0.964, 0.522, 0.661, 0.966, 0.521, 0.648,
+     0.968, 0.520, 0.635, 0.970, 0.518, 0.621, 0.971, 0.517, 0.607, 0.972,
+     0.514, 0.593, 0.973, 0.512, 0.578, 0.974, 0.509, 0.563, 0.975, 0.507,
+     0.548, 0.975, 0.503, 0.532, 0.975, 0.500, 0.516, 0.974, 0.497, 0.500,
+     0.974, 0.493, 0.483, 0.973, 0.489, 0.467, 0.971, 0.485, 0.450, 0.970,
+     0.480, 0.433, 0.968, 0.476, 0.415, 0.966, 0.471, 0.397, 0.964, 0.466,
+     0.380, 0.962, 0.461, 0.362, 0.959, 0.456, 0.343, 0.956, 0.451, 0.325,
+     0.953, 0.446, 0.306, 0.950, 0.440, 0.287, 0.947, 0.435, 0.268, 0.943,
+     0.429, 0.248, 0.939, 0.423, 0.228, 0.936, 0.417, 0.207, 0.931, 0.411,
+     0.185, 0.927, 0.405, 0.162, 0.923, 0.399, 0.138, 0.918, 0.393, 0.111,
+     0.809, 0.354, 0.960, 0.814, 0.364, 0.951, 0.819, 0.375, 0.942, 0.825,
+     0.384, 0.934, 0.830, 0.393, 0.925, 0.835, 0.402, 0.917, 0.841, 0.410,
+     0.908, 0.846, 0.418, 0.900, 0.852, 0.426, 0.892, 0.857, 0.433, 0.884,
+     0.863, 0.440, 0.876, 0.868, 0.446, 0.868, 0.873, 0.452, 0.860, 0.879,
+     0.458, 0.852, 0.884, 0.464, 0.843, 0.889, 0.469, 0.835, 0.894, 0.474,
+     0.827, 0.899, 0.478, 0.818, 0.904, 0.483, 0.810, 0.909, 0.486, 0.801,
+     0.914, 0.490, 0.792, 0.919, 0.493, 0.783, 0.923, 0.496, 0.774, 0.928,
+     0.499, 0.764, 0.932, 0.501, 0.755, 0.936, 0.503, 0.745, 0.940, 0.505,
+     0.734, 0.944, 0.506, 0.724, 0.948, 0.507, 0.713, 0.951, 0.508, 0.701,
+     0.954, 0.508, 0.690, 0.957, 0.508, 0.678, 0.960, 0.508, 0.666, 0.962,
+     0.507, 0.653, 0.965, 0.507, 0.640, 0.967, 0.505, 0.627, 0.968, 0.504,
+     0.613, 0.970, 0.502, 0.599, 0.971, 0.500, 0.585, 0.972, 0.498, 0.570,
+     0.973, 0.495, 0.555, 0.973, 0.493, 0.540, 0.973, 0.490, 0.525, 0.973,
+     0.486, 0.509, 0.973, 0.483, 0.493, 0.972, 0.479, 0.476, 0.971, 0.475,
+     0.460, 0.970, 0.471, 0.443, 0.969, 0.467, 0.426, 0.967, 0.463, 0.409,
+     0.965, 0.458, 0.391, 0.963, 0.453, 0.374, 0.961, 0.449, 0.356, 0.958,
+     0.444, 0.338, 0.956, 0.438, 0.319, 0.953, 0.433, 0.301, 0.949, 0.428,
+     0.282, 0.946, 0.422, 0.263, 0.943, 0.417, 0.243, 0.939, 0.411, 0.223,
+     0.935, 0.405, 0.202, 0.931, 0.399, 0.181, 0.927, 0.393, 0.158, 0.923,
+     0.387, 0.134, 0.918, 0.381, 0.107,
+     ]).reshape((65, 65, 3))
+
+BiOrangeBlue = np.array(
+    [0.000, 0.000, 0.000, 0.000, 0.062, 0.125, 0.000, 0.125, 0.250, 0.000,
+     0.188, 0.375, 0.000, 0.250, 0.500, 0.000, 0.312, 0.625, 0.000, 0.375,
+     0.750, 0.000, 0.438, 0.875, 0.000, 0.500, 1.000, 0.125, 0.062, 0.000,
+     0.125, 0.125, 0.125, 0.125, 0.188, 0.250, 0.125, 0.250, 0.375, 0.125,
+     0.312, 0.500, 0.125, 0.375, 0.625, 0.125, 0.438, 0.750, 0.125, 0.500,
+     0.875, 0.125, 0.562, 1.000, 0.250, 0.125, 0.000, 0.250, 0.188, 0.125,
+     0.250, 0.250, 0.250, 0.250, 0.312, 0.375, 0.250, 0.375, 0.500, 0.250,
+     0.438, 0.625, 0.250, 0.500, 0.750, 0.250, 0.562, 0.875, 0.250, 0.625,
+     1.000, 0.375, 0.188, 0.000, 0.375, 0.250, 0.125, 0.375, 0.312, 0.250,
+     0.375, 0.375, 0.375, 0.375, 0.438, 0.500, 0.375, 0.500, 0.625, 0.375,
+     0.562, 0.750, 0.375, 0.625, 0.875, 0.375, 0.688, 1.000, 0.500, 0.250,
+     0.000, 0.500, 0.312, 0.125, 0.500, 0.375, 0.250, 0.500, 0.438, 0.375,
+     0.500, 0.500, 0.500, 0.500, 0.562, 0.625, 0.500, 0.625, 0.750, 0.500,
+     0.688, 0.875, 0.500, 0.750, 1.000, 0.625, 0.312, 0.000, 0.625, 0.375,
+     0.125, 0.625, 0.438, 0.250, 0.625, 0.500, 0.375, 0.625, 0.562, 0.500,
+     0.625, 0.625, 0.625, 0.625, 0.688, 0.750, 0.625, 0.750, 0.875, 0.625,
+     0.812, 1.000, 0.750, 0.375, 0.000, 0.750, 0.438, 0.125, 0.750, 0.500,
+     0.250, 0.750, 0.562, 0.375, 0.750, 0.625, 0.500, 0.750, 0.688, 0.625,
+     0.750, 0.750, 0.750, 0.750, 0.812, 0.875, 0.750, 0.875, 1.000, 0.875,
+     0.438, 0.000, 0.875, 0.500, 0.125, 0.875, 0.562, 0.250, 0.875, 0.625,
+     0.375, 0.875, 0.688, 0.500, 0.875, 0.750, 0.625, 0.875, 0.812, 0.750,
+     0.875, 0.875, 0.875, 0.875, 0.938, 1.000, 1.000, 0.500, 0.000, 1.000,
+     0.562, 0.125, 1.000, 0.625, 0.250, 1.000, 0.688, 0.375, 1.000, 0.750,
+     0.500, 1.000, 0.812, 0.625, 1.000, 0.875, 0.750, 1.000, 0.938, 0.875,
+     1.000, 1.000, 1.000,
+     ]).reshape((9, 9, 3))
+
+cmaps = {
+    "BiPeak": SegmentedBivarColormap(
+        BiPeak, 256, "square", (.5, .5), name="BiPeak"),
+    "BiOrangeBlue": SegmentedBivarColormap(
+        BiOrangeBlue, 256, "square", (0, 0), name="BiOrangeBlue"),
+    "BiCone": SegmentedBivarColormap(BiPeak, 256, "circle", (.5, .5), name="BiCone"),
+}

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_cm_multivar.py

@@ -0,0 +1,166 @@
+# auto-generated by https://github.com/trygvrad/multivariate_colormaps
+# date: 2024-05-28
+
+from .colors import LinearSegmentedColormap, MultivarColormap
+import matplotlib as mpl
+_LUTSIZE = mpl.rcParams['image.lut']
+
+_2VarAddA0_data = [[0.000, 0.000, 0.000],
+                   [0.020, 0.026, 0.031],
+                   [0.049, 0.068, 0.085],
+                   [0.075, 0.107, 0.135],
+                   [0.097, 0.144, 0.183],
+                   [0.116, 0.178, 0.231],
+                   [0.133, 0.212, 0.279],
+                   [0.148, 0.244, 0.326],
+                   [0.161, 0.276, 0.374],
+                   [0.173, 0.308, 0.422],
+                   [0.182, 0.339, 0.471],
+                   [0.190, 0.370, 0.521],
+                   [0.197, 0.400, 0.572],
+                   [0.201, 0.431, 0.623],
+                   [0.204, 0.461, 0.675],
+                   [0.204, 0.491, 0.728],
+                   [0.202, 0.520, 0.783],
+                   [0.197, 0.549, 0.838],
+                   [0.187, 0.577, 0.895]]
+
+_2VarAddA1_data = [[0.000, 0.000, 0.000],
+                   [0.030, 0.023, 0.018],
+                   [0.079, 0.060, 0.043],
+                   [0.125, 0.093, 0.065],
+                   [0.170, 0.123, 0.083],
+                   [0.213, 0.151, 0.098],
+                   [0.255, 0.177, 0.110],
+                   [0.298, 0.202, 0.120],
+                   [0.341, 0.226, 0.128],
+                   [0.384, 0.249, 0.134],
+                   [0.427, 0.271, 0.138],
+                   [0.472, 0.292, 0.141],
+                   [0.517, 0.313, 0.142],
+                   [0.563, 0.333, 0.141],
+                   [0.610, 0.353, 0.139],
+                   [0.658, 0.372, 0.134],
+                   [0.708, 0.390, 0.127],
+                   [0.759, 0.407, 0.118],
+                   [0.813, 0.423, 0.105]]
+
+_2VarSubA0_data = [[1.000, 1.000, 1.000],
+                   [0.959, 0.973, 0.986],
+                   [0.916, 0.948, 0.974],
+                   [0.874, 0.923, 0.965],
+                   [0.832, 0.899, 0.956],
+                   [0.790, 0.875, 0.948],
+                   [0.748, 0.852, 0.940],
+                   [0.707, 0.829, 0.934],
+                   [0.665, 0.806, 0.927],
+                   [0.624, 0.784, 0.921],
+                   [0.583, 0.762, 0.916],
+                   [0.541, 0.740, 0.910],
+                   [0.500, 0.718, 0.905],
+                   [0.457, 0.697, 0.901],
+                   [0.414, 0.675, 0.896],
+                   [0.369, 0.652, 0.892],
+                   [0.320, 0.629, 0.888],
+                   [0.266, 0.604, 0.884],
+                   [0.199, 0.574, 0.881]]
+
+_2VarSubA1_data = [[1.000, 1.000, 1.000],
+                   [0.982, 0.967, 0.955],
+                   [0.966, 0.935, 0.908],
+                   [0.951, 0.902, 0.860],
+                   [0.937, 0.870, 0.813],
+                   [0.923, 0.838, 0.765],
+                   [0.910, 0.807, 0.718],
+                   [0.898, 0.776, 0.671],
+                   [0.886, 0.745, 0.624],
+                   [0.874, 0.714, 0.577],
+                   [0.862, 0.683, 0.530],
+                   [0.851, 0.653, 0.483],
+                   [0.841, 0.622, 0.435],
+                   [0.831, 0.592, 0.388],
+                   [0.822, 0.561, 0.340],
+                   [0.813, 0.530, 0.290],
+                   [0.806, 0.498, 0.239],
+                   [0.802, 0.464, 0.184],
+                   [0.801, 0.426, 0.119]]
+
+_3VarAddA0_data = [[0.000, 0.000, 0.000],
+                   [0.018, 0.023, 0.028],
+                   [0.040, 0.056, 0.071],
+                   [0.059, 0.087, 0.110],
+                   [0.074, 0.114, 0.147],
+                   [0.086, 0.139, 0.183],
+                   [0.095, 0.163, 0.219],
+                   [0.101, 0.187, 0.255],
+                   [0.105, 0.209, 0.290],
+                   [0.107, 0.230, 0.326],
+                   [0.105, 0.251, 0.362],
+                   [0.101, 0.271, 0.398],
+                   [0.091, 0.291, 0.434],
+                   [0.075, 0.309, 0.471],
+                   [0.046, 0.325, 0.507],
+                   [0.021, 0.341, 0.546],
+                   [0.021, 0.363, 0.584],
+                   [0.022, 0.385, 0.622],
+                   [0.023, 0.408, 0.661]]
+
+_3VarAddA1_data = [[0.000, 0.000, 0.000],
+                   [0.020, 0.024, 0.016],
+                   [0.047, 0.058, 0.034],
+                   [0.072, 0.088, 0.048],
+                   [0.093, 0.116, 0.059],
+                   [0.113, 0.142, 0.067],
+                   [0.131, 0.167, 0.071],
+                   [0.149, 0.190, 0.074],
+                   [0.166, 0.213, 0.074],
+                   [0.182, 0.235, 0.072],
+                   [0.198, 0.256, 0.068],
+                   [0.215, 0.276, 0.061],
+                   [0.232, 0.296, 0.051],
+                   [0.249, 0.314, 0.037],
+                   [0.270, 0.330, 0.018],
+                   [0.288, 0.347, 0.000],
+                   [0.302, 0.369, 0.000],
+                   [0.315, 0.391, 0.000],
+                   [0.328, 0.414, 0.000]]
+
+_3VarAddA2_data = [[0.000, 0.000, 0.000],
+                   [0.029, 0.020, 0.023],
+                   [0.072, 0.045, 0.055],
+                   [0.111, 0.067, 0.084],
+                   [0.148, 0.085, 0.109],
+                   [0.184, 0.101, 0.133],
+                   [0.219, 0.115, 0.155],
+                   [0.254, 0.127, 0.176],
+                   [0.289, 0.138, 0.195],
+                   [0.323, 0.147, 0.214],
+                   [0.358, 0.155, 0.232],
+                   [0.393, 0.161, 0.250],
+                   [0.429, 0.166, 0.267],
+                   [0.467, 0.169, 0.283],
+                   [0.507, 0.168, 0.298],
+                   [0.546, 0.168, 0.313],
+                   [0.580, 0.172, 0.328],
+                   [0.615, 0.175, 0.341],
+                   [0.649, 0.178, 0.355]]
+
+cmaps = {
+    name: LinearSegmentedColormap.from_list(name, data, _LUTSIZE) for name, data in [
+        ('2VarAddA0', _2VarAddA0_data),
+        ('2VarAddA1', _2VarAddA1_data),
+        ('2VarSubA0', _2VarSubA0_data),
+        ('2VarSubA1', _2VarSubA1_data),
+        ('3VarAddA0', _3VarAddA0_data),
+        ('3VarAddA1', _3VarAddA1_data),
+        ('3VarAddA2', _3VarAddA2_data),
+    ]}
+
+cmap_families = {
+    '2VarAddA': MultivarColormap([cmaps[f'2VarAddA{i}'] for i in range(2)],
+                                 'sRGB_add', name='2VarAddA'),
+    '2VarSubA': MultivarColormap([cmaps[f'2VarSubA{i}'] for i in range(2)],
+                                 'sRGB_sub', name='2VarSubA'),
+    '3VarAddA': MultivarColormap([cmaps[f'3VarAddA{i}'] for i in range(3)],
+                                 'sRGB_add', name='3VarAddA'),
+}

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_color_data.py

@@ -0,0 +1,1141 @@
+BASE_COLORS = {
+    'b': (0, 0, 1),        # blue
+    'g': (0, 0.5, 0),      # green
+    'r': (1, 0, 0),        # red
+    'c': (0, 0.75, 0.75),  # cyan
+    'm': (0.75, 0, 0.75),  # magenta
+    'y': (0.75, 0.75, 0),  # yellow
+    'k': (0, 0, 0),        # black
+    'w': (1, 1, 1),        # white
+}
+
+
+# These colors are from Tableau
+TABLEAU_COLORS = {
+    'tab:blue': '#1f77b4',
+    'tab:orange': '#ff7f0e',
+    'tab:green': '#2ca02c',
+    'tab:red': '#d62728',
+    'tab:purple': '#9467bd',
+    'tab:brown': '#8c564b',
+    'tab:pink': '#e377c2',
+    'tab:gray': '#7f7f7f',
+    'tab:olive': '#bcbd22',
+    'tab:cyan': '#17becf',
+}
+
+
+# This mapping of color names -> hex values is taken from
+# a survey run by Randall Munroe see:
+# https://blog.xkcd.com/2010/05/03/color-survey-results/
+# for more details.  The results are hosted at
+# https://xkcd.com/color/rgb/
+# and also available as a text file at
+# https://xkcd.com/color/rgb.txt
+#
+# License: https://creativecommons.org/publicdomain/zero/1.0/
+XKCD_COLORS = {
+    'cloudy blue': '#acc2d9',
+    'dark pastel green': '#56ae57',
+    'dust': '#b2996e',
+    'electric lime': '#a8ff04',
+    'fresh green': '#69d84f',
+    'light eggplant': '#894585',
+    'nasty green': '#70b23f',
+    'really light blue': '#d4ffff',
+    'tea': '#65ab7c',
+    'warm purple': '#952e8f',
+    'yellowish tan': '#fcfc81',
+    'cement': '#a5a391',
+    'dark grass green': '#388004',
+    'dusty teal': '#4c9085',
+    'grey teal': '#5e9b8a',
+    'macaroni and cheese': '#efb435',
+    'pinkish tan': '#d99b82',
+    'spruce': '#0a5f38',
+    'strong blue': '#0c06f7',
+    'toxic green': '#61de2a',
+    'windows blue': '#3778bf',
+    'blue blue': '#2242c7',
+    'blue with a hint of purple': '#533cc6',
+    'booger': '#9bb53c',
+    'bright sea green': '#05ffa6',
+    'dark green blue': '#1f6357',
+    'deep turquoise': '#017374',
+    'green teal': '#0cb577',
+    'strong pink': '#ff0789',
+    'bland': '#afa88b',
+    'deep aqua': '#08787f',
+    'lavender pink': '#dd85d7',
+    'light moss green': '#a6c875',
+    'light seafoam green': '#a7ffb5',
+    'olive yellow': '#c2b709',
+    'pig pink': '#e78ea5',
+    'deep lilac': '#966ebd',
+    'desert': '#ccad60',
+    'dusty lavender': '#ac86a8',
+    'purpley grey': '#947e94',
+    'purply': '#983fb2',
+    'candy pink': '#ff63e9',
+    'light pastel green': '#b2fba5',
+    'boring green': '#63b365',
+    'kiwi green': '#8ee53f',
+    'light grey green': '#b7e1a1',
+    'orange pink': '#ff6f52',
+    'tea green': '#bdf8a3',
+    'very light brown': '#d3b683',
+    'egg shell': '#fffcc4',
+    'eggplant purple': '#430541',
+    'powder pink': '#ffb2d0',
+    'reddish grey': '#997570',
+    'baby shit brown': '#ad900d',
+    'liliac': '#c48efd',
+    'stormy blue': '#507b9c',
+    'ugly brown': '#7d7103',
+    'custard': '#fffd78',
+    'darkish pink': '#da467d',
+    'deep brown': '#410200',
+    'greenish beige': '#c9d179',
+    'manilla': '#fffa86',
+    'off blue': '#5684ae',
+    'battleship grey': '#6b7c85',
+    'browny green': '#6f6c0a',
+    'bruise': '#7e4071',
+    'kelley green': '#009337',
+    'sickly yellow': '#d0e429',
+    'sunny yellow': '#fff917',
+    'azul': '#1d5dec',
+    'darkgreen': '#054907',
+    'green/yellow': '#b5ce08',
+    'lichen': '#8fb67b',
+    'light light green': '#c8ffb0',
+    'pale gold': '#fdde6c',
+    'sun yellow': '#ffdf22',
+    'tan green': '#a9be70',
+    'burple': '#6832e3',
+    'butterscotch': '#fdb147',
+    'toupe': '#c7ac7d',
+    'dark cream': '#fff39a',
+    'indian red': '#850e04',
+    'light lavendar': '#efc0fe',
+    'poison green': '#40fd14',
+    'baby puke green': '#b6c406',
+    'bright yellow green': '#9dff00',
+    'charcoal grey': '#3c4142',
+    'squash': '#f2ab15',
+    'cinnamon': '#ac4f06',
+    'light pea green': '#c4fe82',
+    'radioactive green': '#2cfa1f',
+    'raw sienna': '#9a6200',
+    'baby purple': '#ca9bf7',
+    'cocoa': '#875f42',
+    'light royal blue': '#3a2efe',
+    'orangeish': '#fd8d49',
+    'rust brown': '#8b3103',
+    'sand brown': '#cba560',
+    'swamp': '#698339',
+    'tealish green': '#0cdc73',
+    'burnt siena': '#b75203',
+    'camo': '#7f8f4e',
+    'dusk blue': '#26538d',
+    'fern': '#63a950',
+    'old rose': '#c87f89',
+    'pale light green': '#b1fc99',
+    'peachy pink': '#ff9a8a',
+    'rosy pink': '#f6688e',
+    'light bluish green': '#76fda8',
+    'light bright green': '#53fe5c',
+    'light neon green': '#4efd54',
+    'light seafoam': '#a0febf',
+    'tiffany blue': '#7bf2da',
+    'washed out green': '#bcf5a6',
+    'browny orange': '#ca6b02',
+    'nice blue': '#107ab0',
+    'sapphire': '#2138ab',
+    'greyish teal': '#719f91',
+    'orangey yellow': '#fdb915',
+    'parchment': '#fefcaf',
+    'straw': '#fcf679',
+    'very dark brown': '#1d0200',
+    'terracota': '#cb6843',
+    'ugly blue': '#31668a',
+    'clear blue': '#247afd',
+    'creme': '#ffffb6',
+    'foam green': '#90fda9',
+    'grey/green': '#86a17d',
+    'light gold': '#fddc5c',
+    'seafoam blue': '#78d1b6',
+    'topaz': '#13bbaf',
+    'violet pink': '#fb5ffc',
+    'wintergreen': '#20f986',
+    'yellow tan': '#ffe36e',
+    'dark fuchsia': '#9d0759',
+    'indigo blue': '#3a18b1',
+    'light yellowish green': '#c2ff89',
+    'pale magenta': '#d767ad',
+    'rich purple': '#720058',
+    'sunflower yellow': '#ffda03',
+    'green/blue': '#01c08d',
+    'leather': '#ac7434',
+    'racing green': '#014600',
+    'vivid purple': '#9900fa',
+    'dark royal blue': '#02066f',
+    'hazel': '#8e7618',
+    'muted pink': '#d1768f',
+    'booger green': '#96b403',
+    'canary': '#fdff63',
+    'cool grey': '#95a3a6',
+    'dark taupe': '#7f684e',
+    'darkish purple': '#751973',
+    'true green': '#089404',
+    'coral pink': '#ff6163',
+    'dark sage': '#598556',
+    'dark slate blue': '#214761',
+    'flat blue': '#3c73a8',
+    'mushroom': '#ba9e88',
+    'rich blue': '#021bf9',
+    'dirty purple': '#734a65',
+    'greenblue': '#23c48b',
+    'icky green': '#8fae22',
+    'light khaki': '#e6f2a2',
+    'warm blue': '#4b57db',
+    'dark hot pink': '#d90166',
+    'deep sea blue': '#015482',
+    'carmine': '#9d0216',
+    'dark yellow green': '#728f02',
+    'pale peach': '#ffe5ad',
+    'plum purple': '#4e0550',
+    'golden rod': '#f9bc08',
+    'neon red': '#ff073a',
+    'old pink': '#c77986',
+    'very pale blue': '#d6fffe',
+    'blood orange': '#fe4b03',
+    'grapefruit': '#fd5956',
+    'sand yellow': '#fce166',
+    'clay brown': '#b2713d',
+    'dark blue grey': '#1f3b4d',
+    'flat green': '#699d4c',
+    'light green blue': '#56fca2',
+    'warm pink': '#fb5581',
+    'dodger blue': '#3e82fc',
+    'gross green': '#a0bf16',
+    'ice': '#d6fffa',
+    'metallic blue': '#4f738e',
+    'pale salmon': '#ffb19a',
+    'sap green': '#5c8b15',
+    'algae': '#54ac68',
+    'bluey grey': '#89a0b0',
+    'greeny grey': '#7ea07a',
+    'highlighter green': '#1bfc06',
+    'light light blue': '#cafffb',
+    'light mint': '#b6ffbb',
+    'raw umber': '#a75e09',
+    'vivid blue': '#152eff',
+    'deep lavender': '#8d5eb7',
+    'dull teal': '#5f9e8f',
+    'light greenish blue': '#63f7b4',
+    'mud green': '#606602',
+    'pinky': '#fc86aa',
+    'red wine': '#8c0034',
+    'shit green': '#758000',
+    'tan brown': '#ab7e4c',
+    'darkblue': '#030764',
+    'rosa': '#fe86a4',
+    'lipstick': '#d5174e',
+    'pale mauve': '#fed0fc',
+    'claret': '#680018',
+    'dandelion': '#fedf08',
+    'orangered': '#fe420f',
+    'poop green': '#6f7c00',
+    'ruby': '#ca0147',
+    'dark': '#1b2431',
+    'greenish turquoise': '#00fbb0',
+    'pastel red': '#db5856',
+    'piss yellow': '#ddd618',
+    'bright cyan': '#41fdfe',
+    'dark coral': '#cf524e',
+    'algae green': '#21c36f',
+    'darkish red': '#a90308',
+    'reddy brown': '#6e1005',
+    'blush pink': '#fe828c',
+    'camouflage green': '#4b6113',
+    'lawn green': '#4da409',
+    'putty': '#beae8a',
+    'vibrant blue': '#0339f8',
+    'dark sand': '#a88f59',
+    'purple/blue': '#5d21d0',
+    'saffron': '#feb209',
+    'twilight': '#4e518b',
+    'warm brown': '#964e02',
+    'bluegrey': '#85a3b2',
+    'bubble gum pink': '#ff69af',
+    'duck egg blue': '#c3fbf4',
+    'greenish cyan': '#2afeb7',
+    'petrol': '#005f6a',
+    'royal': '#0c1793',
+    'butter': '#ffff81',
+    'dusty orange': '#f0833a',
+    'off yellow': '#f1f33f',
+    'pale olive green': '#b1d27b',
+    'orangish': '#fc824a',
+    'leaf': '#71aa34',
+    'light blue grey': '#b7c9e2',
+    'dried blood': '#4b0101',
+    'lightish purple': '#a552e6',
+    'rusty red': '#af2f0d',
+    'lavender blue': '#8b88f8',
+    'light grass green': '#9af764',
+    'light mint green': '#a6fbb2',
+    'sunflower': '#ffc512',
+    'velvet': '#750851',
+    'brick orange': '#c14a09',
+    'lightish red': '#fe2f4a',
+    'pure blue': '#0203e2',
+    'twilight blue': '#0a437a',
+    'violet red': '#a50055',
+    'yellowy brown': '#ae8b0c',
+    'carnation': '#fd798f',
+    'muddy yellow': '#bfac05',
+    'dark seafoam green': '#3eaf76',
+    'deep rose': '#c74767',
+    'dusty red': '#b9484e',
+    'grey/blue': '#647d8e',
+    'lemon lime': '#bffe28',
+    'purple/pink': '#d725de',
+    'brown yellow': '#b29705',
+    'purple brown': '#673a3f',
+    'wisteria': '#a87dc2',
+    'banana yellow': '#fafe4b',
+    'lipstick red': '#c0022f',
+    'water blue': '#0e87cc',
+    'brown grey': '#8d8468',
+    'vibrant purple': '#ad03de',
+    'baby green': '#8cff9e',
+    'barf green': '#94ac02',
+    'eggshell blue': '#c4fff7',
+    'sandy yellow': '#fdee73',
+    'cool green': '#33b864',
+    'pale': '#fff9d0',
+    'blue/grey': '#758da3',
+    'hot magenta': '#f504c9',
+    'greyblue': '#77a1b5',
+    'purpley': '#8756e4',
+    'baby shit green': '#889717',
+    'brownish pink': '#c27e79',
+    'dark aquamarine': '#017371',
+    'diarrhea': '#9f8303',
+    'light mustard': '#f7d560',
+    'pale sky blue': '#bdf6fe',
+    'turtle green': '#75b84f',
+    'bright olive': '#9cbb04',
+    'dark grey blue': '#29465b',
+    'greeny brown': '#696006',
+    'lemon green': '#adf802',
+    'light periwinkle': '#c1c6fc',
+    'seaweed green': '#35ad6b',
+    'sunshine yellow': '#fffd37',
+    'ugly purple': '#a442a0',
+    'medium pink': '#f36196',
+    'puke brown': '#947706',
+    'very light pink': '#fff4f2',
+    'viridian': '#1e9167',
+    'bile': '#b5c306',
+    'faded yellow': '#feff7f',
+    'very pale green': '#cffdbc',
+    'vibrant green': '#0add08',
+    'bright lime': '#87fd05',
+    'spearmint': '#1ef876',
+    'light aquamarine': '#7bfdc7',
+    'light sage': '#bcecac',
+    'yellowgreen': '#bbf90f',
+    'baby poo': '#ab9004',
+    'dark seafoam': '#1fb57a',
+    'deep teal': '#00555a',
+    'heather': '#a484ac',
+    'rust orange': '#c45508',
+    'dirty blue': '#3f829d',
+    'fern green': '#548d44',
+    'bright lilac': '#c95efb',
+    'weird green': '#3ae57f',
+    'peacock blue': '#016795',
+    'avocado green': '#87a922',
+    'faded orange': '#f0944d',
+    'grape purple': '#5d1451',
+    'hot green': '#25ff29',
+    'lime yellow': '#d0fe1d',
+    'mango': '#ffa62b',
+    'shamrock': '#01b44c',
+    'bubblegum': '#ff6cb5',
+    'purplish brown': '#6b4247',
+    'vomit yellow': '#c7c10c',
+    'pale cyan': '#b7fffa',
+    'key lime': '#aeff6e',
+    'tomato red': '#ec2d01',
+    'lightgreen': '#76ff7b',
+    'merlot': '#730039',
+    'night blue': '#040348',
+    'purpleish pink': '#df4ec8',
+    'apple': '#6ecb3c',
+    'baby poop green': '#8f9805',
+    'green apple': '#5edc1f',
+    'heliotrope': '#d94ff5',
+    'yellow/green': '#c8fd3d',
+    'almost black': '#070d0d',
+    'cool blue': '#4984b8',
+    'leafy green': '#51b73b',
+    'mustard brown': '#ac7e04',
+    'dusk': '#4e5481',
+    'dull brown': '#876e4b',
+    'frog green': '#58bc08',
+    'vivid green': '#2fef10',
+    'bright light green': '#2dfe54',
+    'fluro green': '#0aff02',
+    'kiwi': '#9cef43',
+    'seaweed': '#18d17b',
+    'navy green': '#35530a',
+    'ultramarine blue': '#1805db',
+    'iris': '#6258c4',
+    'pastel orange': '#ff964f',
+    'yellowish orange': '#ffab0f',
+    'perrywinkle': '#8f8ce7',
+    'tealish': '#24bca8',
+    'dark plum': '#3f012c',
+    'pear': '#cbf85f',
+    'pinkish orange': '#ff724c',
+    'midnight purple': '#280137',
+    'light urple': '#b36ff6',
+    'dark mint': '#48c072',
+    'greenish tan': '#bccb7a',
+    'light burgundy': '#a8415b',
+    'turquoise blue': '#06b1c4',
+    'ugly pink': '#cd7584',
+    'sandy': '#f1da7a',
+    'electric pink': '#ff0490',
+    'muted purple': '#805b87',
+    'mid green': '#50a747',
+    'greyish': '#a8a495',
+    'neon yellow': '#cfff04',
+    'banana': '#ffff7e',
+    'carnation pink': '#ff7fa7',
+    'tomato': '#ef4026',
+    'sea': '#3c9992',
+    'muddy brown': '#886806',
+    'turquoise green': '#04f489',
+    'buff': '#fef69e',
+    'fawn': '#cfaf7b',
+    'muted blue': '#3b719f',
+    'pale rose': '#fdc1c5',
+    'dark mint green': '#20c073',
+    'amethyst': '#9b5fc0',
+    'blue/green': '#0f9b8e',
+    'chestnut': '#742802',
+    'sick green': '#9db92c',
+    'pea': '#a4bf20',
+    'rusty orange': '#cd5909',
+    'stone': '#ada587',
+    'rose red': '#be013c',
+    'pale aqua': '#b8ffeb',
+    'deep orange': '#dc4d01',
+    'earth': '#a2653e',
+    'mossy green': '#638b27',
+    'grassy green': '#419c03',
+    'pale lime green': '#b1ff65',
+    'light grey blue': '#9dbcd4',
+    'pale grey': '#fdfdfe',
+    'asparagus': '#77ab56',
+    'blueberry': '#464196',
+    'purple red': '#990147',
+    'pale lime': '#befd73',
+    'greenish teal': '#32bf84',
+    'caramel': '#af6f09',
+    'deep magenta': '#a0025c',
+    'light peach': '#ffd8b1',
+    'milk chocolate': '#7f4e1e',
+    'ocher': '#bf9b0c',
+    'off green': '#6ba353',
+    'purply pink': '#f075e6',
+    'lightblue': '#7bc8f6',
+    'dusky blue': '#475f94',
+    'golden': '#f5bf03',
+    'light beige': '#fffeb6',
+    'butter yellow': '#fffd74',
+    'dusky purple': '#895b7b',
+    'french blue': '#436bad',
+    'ugly yellow': '#d0c101',
+    'greeny yellow': '#c6f808',
+    'orangish red': '#f43605',
+    'shamrock green': '#02c14d',
+    'orangish brown': '#b25f03',
+    'tree green': '#2a7e19',
+    'deep violet': '#490648',
+    'gunmetal': '#536267',
+    'blue/purple': '#5a06ef',
+    'cherry': '#cf0234',
+    'sandy brown': '#c4a661',
+    'warm grey': '#978a84',
+    'dark indigo': '#1f0954',
+    'midnight': '#03012d',
+    'bluey green': '#2bb179',
+    'grey pink': '#c3909b',
+    'soft purple': '#a66fb5',
+    'blood': '#770001',
+    'brown red': '#922b05',
+    'medium grey': '#7d7f7c',
+    'berry': '#990f4b',
+    'poo': '#8f7303',
+    'purpley pink': '#c83cb9',
+    'light salmon': '#fea993',
+    'snot': '#acbb0d',
+    'easter purple': '#c071fe',
+    'light yellow green': '#ccfd7f',
+    'dark navy blue': '#00022e',
+    'drab': '#828344',
+    'light rose': '#ffc5cb',
+    'rouge': '#ab1239',
+    'purplish red': '#b0054b',
+    'slime green': '#99cc04',
+    'baby poop': '#937c00',
+    'irish green': '#019529',
+    'pink/purple': '#ef1de7',
+    'dark navy': '#000435',
+    'greeny blue': '#42b395',
+    'light plum': '#9d5783',
+    'pinkish grey': '#c8aca9',
+    'dirty orange': '#c87606',
+    'rust red': '#aa2704',
+    'pale lilac': '#e4cbff',
+    'orangey red': '#fa4224',
+    'primary blue': '#0804f9',
+    'kermit green': '#5cb200',
+    'brownish purple': '#76424e',
+    'murky green': '#6c7a0e',
+    'wheat': '#fbdd7e',
+    'very dark purple': '#2a0134',
+    'bottle green': '#044a05',
+    'watermelon': '#fd4659',
+    'deep sky blue': '#0d75f8',
+    'fire engine red': '#fe0002',
+    'yellow ochre': '#cb9d06',
+    'pumpkin orange': '#fb7d07',
+    'pale olive': '#b9cc81',
+    'light lilac': '#edc8ff',
+    'lightish green': '#61e160',
+    'carolina blue': '#8ab8fe',
+    'mulberry': '#920a4e',
+    'shocking pink': '#fe02a2',
+    'auburn': '#9a3001',
+    'bright lime green': '#65fe08',
+    'celadon': '#befdb7',
+    'pinkish brown': '#b17261',
+    'poo brown': '#885f01',
+    'bright sky blue': '#02ccfe',
+    'celery': '#c1fd95',
+    'dirt brown': '#836539',
+    'strawberry': '#fb2943',
+    'dark lime': '#84b701',
+    'copper': '#b66325',
+    'medium brown': '#7f5112',
+    'muted green': '#5fa052',
+    "robin's egg": '#6dedfd',
+    'bright aqua': '#0bf9ea',
+    'bright lavender': '#c760ff',
+    'ivory': '#ffffcb',
+    'very light purple': '#f6cefc',
+    'light navy': '#155084',
+    'pink red': '#f5054f',
+    'olive brown': '#645403',
+    'poop brown': '#7a5901',
+    'mustard green': '#a8b504',
+    'ocean green': '#3d9973',
+    'very dark blue': '#000133',
+    'dusty green': '#76a973',
+    'light navy blue': '#2e5a88',
+    'minty green': '#0bf77d',
+    'adobe': '#bd6c48',
+    'barney': '#ac1db8',
+    'jade green': '#2baf6a',
+    'bright light blue': '#26f7fd',
+    'light lime': '#aefd6c',
+    'dark khaki': '#9b8f55',
+    'orange yellow': '#ffad01',
+    'ocre': '#c69c04',
+    'maize': '#f4d054',
+    'faded pink': '#de9dac',
+    'british racing green': '#05480d',
+    'sandstone': '#c9ae74',
+    'mud brown': '#60460f',
+    'light sea green': '#98f6b0',
+    'robin egg blue': '#8af1fe',
+    'aqua marine': '#2ee8bb',
+    'dark sea green': '#11875d',
+    'soft pink': '#fdb0c0',
+    'orangey brown': '#b16002',
+    'cherry red': '#f7022a',
+    'burnt yellow': '#d5ab09',
+    'brownish grey': '#86775f',
+    'camel': '#c69f59',
+    'purplish grey': '#7a687f',
+    'marine': '#042e60',
+    'greyish pink': '#c88d94',
+    'pale turquoise': '#a5fbd5',
+    'pastel yellow': '#fffe71',
+    'bluey purple': '#6241c7',
+    'canary yellow': '#fffe40',
+    'faded red': '#d3494e',
+    'sepia': '#985e2b',
+    'coffee': '#a6814c',
+    'bright magenta': '#ff08e8',
+    'mocha': '#9d7651',
+    'ecru': '#feffca',
+    'purpleish': '#98568d',
+    'cranberry': '#9e003a',
+    'darkish green': '#287c37',
+    'brown orange': '#b96902',
+    'dusky rose': '#ba6873',
+    'melon': '#ff7855',
+    'sickly green': '#94b21c',
+    'silver': '#c5c9c7',
+    'purply blue': '#661aee',
+    'purpleish blue': '#6140ef',
+    'hospital green': '#9be5aa',
+    'shit brown': '#7b5804',
+    'mid blue': '#276ab3',
+    'amber': '#feb308',
+    'easter green': '#8cfd7e',
+    'soft blue': '#6488ea',
+    'cerulean blue': '#056eee',
+    'golden brown': '#b27a01',
+    'bright turquoise': '#0ffef9',
+    'red pink': '#fa2a55',
+    'red purple': '#820747',
+    'greyish brown': '#7a6a4f',
+    'vermillion': '#f4320c',
+    'russet': '#a13905',
+    'steel grey': '#6f828a',
+    'lighter purple': '#a55af4',
+    'bright violet': '#ad0afd',
+    'prussian blue': '#004577',
+    'slate green': '#658d6d',
+    'dirty pink': '#ca7b80',
+    'dark blue green': '#005249',
+    'pine': '#2b5d34',
+    'yellowy green': '#bff128',
+    'dark gold': '#b59410',
+    'bluish': '#2976bb',
+    'darkish blue': '#014182',
+    'dull red': '#bb3f3f',
+    'pinky red': '#fc2647',
+    'bronze': '#a87900',
+    'pale teal': '#82cbb2',
+    'military green': '#667c3e',
+    'barbie pink': '#fe46a5',
+    'bubblegum pink': '#fe83cc',
+    'pea soup green': '#94a617',
+    'dark mustard': '#a88905',
+    'shit': '#7f5f00',
+    'medium purple': '#9e43a2',
+    'very dark green': '#062e03',
+    'dirt': '#8a6e45',
+    'dusky pink': '#cc7a8b',
+    'red violet': '#9e0168',
+    'lemon yellow': '#fdff38',
+    'pistachio': '#c0fa8b',
+    'dull yellow': '#eedc5b',
+    'dark lime green': '#7ebd01',
+    'denim blue': '#3b5b92',
+    'teal blue': '#01889f',
+    'lightish blue': '#3d7afd',
+    'purpley blue': '#5f34e7',
+    'light indigo': '#6d5acf',
+    'swamp green': '#748500',
+    'brown green': '#706c11',
+    'dark maroon': '#3c0008',
+    'hot purple': '#cb00f5',
+    'dark forest green': '#002d04',
+    'faded blue': '#658cbb',
+    'drab green': '#749551',
+    'light lime green': '#b9ff66',
+    'snot green': '#9dc100',
+    'yellowish': '#faee66',
+    'light blue green': '#7efbb3',
+    'bordeaux': '#7b002c',
+    'light mauve': '#c292a1',
+    'ocean': '#017b92',
+    'marigold': '#fcc006',
+    'muddy green': '#657432',
+    'dull orange': '#d8863b',
+    'steel': '#738595',
+    'electric purple': '#aa23ff',
+    'fluorescent green': '#08ff08',
+    'yellowish brown': '#9b7a01',
+    'blush': '#f29e8e',
+    'soft green': '#6fc276',
+    'bright orange': '#ff5b00',
+    'lemon': '#fdff52',
+    'purple grey': '#866f85',
+    'acid green': '#8ffe09',
+    'pale lavender': '#eecffe',
+    'violet blue': '#510ac9',
+    'light forest green': '#4f9153',
+    'burnt red': '#9f2305',
+    'khaki green': '#728639',
+    'cerise': '#de0c62',
+    'faded purple': '#916e99',
+    'apricot': '#ffb16d',
+    'dark olive green': '#3c4d03',
+    'grey brown': '#7f7053',
+    'green grey': '#77926f',
+    'true blue': '#010fcc',
+    'pale violet': '#ceaefa',
+    'periwinkle blue': '#8f99fb',
+    'light sky blue': '#c6fcff',
+    'blurple': '#5539cc',
+    'green brown': '#544e03',
+    'bluegreen': '#017a79',
+    'bright teal': '#01f9c6',
+    'brownish yellow': '#c9b003',
+    'pea soup': '#929901',
+    'forest': '#0b5509',
+    'barney purple': '#a00498',
+    'ultramarine': '#2000b1',
+    'purplish': '#94568c',
+    'puke yellow': '#c2be0e',
+    'bluish grey': '#748b97',
+    'dark periwinkle': '#665fd1',
+    'dark lilac': '#9c6da5',
+    'reddish': '#c44240',
+    'light maroon': '#a24857',
+    'dusty purple': '#825f87',
+    'terra cotta': '#c9643b',
+    'avocado': '#90b134',
+    'marine blue': '#01386a',
+    'teal green': '#25a36f',
+    'slate grey': '#59656d',
+    'lighter green': '#75fd63',
+    'electric green': '#21fc0d',
+    'dusty blue': '#5a86ad',
+    'golden yellow': '#fec615',
+    'bright yellow': '#fffd01',
+    'light lavender': '#dfc5fe',
+    'umber': '#b26400',
+    'poop': '#7f5e00',
+    'dark peach': '#de7e5d',
+    'jungle green': '#048243',
+    'eggshell': '#ffffd4',
+    'denim': '#3b638c',
+    'yellow brown': '#b79400',
+    'dull purple': '#84597e',
+    'chocolate brown': '#411900',
+    'wine red': '#7b0323',
+    'neon blue': '#04d9ff',
+    'dirty green': '#667e2c',
+    'light tan': '#fbeeac',
+    'ice blue': '#d7fffe',
+    'cadet blue': '#4e7496',
+    'dark mauve': '#874c62',
+    'very light blue': '#d5ffff',
+    'grey purple': '#826d8c',
+    'pastel pink': '#ffbacd',
+    'very light green': '#d1ffbd',
+    'dark sky blue': '#448ee4',
+    'evergreen': '#05472a',
+    'dull pink': '#d5869d',
+    'aubergine': '#3d0734',
+    'mahogany': '#4a0100',
+    'reddish orange': '#f8481c',
+    'deep green': '#02590f',
+    'vomit green': '#89a203',
+    'purple pink': '#e03fd8',
+    'dusty pink': '#d58a94',
+    'faded green': '#7bb274',
+    'camo green': '#526525',
+    'pinky purple': '#c94cbe',
+    'pink purple': '#db4bda',
+    'brownish red': '#9e3623',
+    'dark rose': '#b5485d',
+    'mud': '#735c12',
+    'brownish': '#9c6d57',
+    'emerald green': '#028f1e',
+    'pale brown': '#b1916e',
+    'dull blue': '#49759c',
+    'burnt umber': '#a0450e',
+    'medium green': '#39ad48',
+    'clay': '#b66a50',
+    'light aqua': '#8cffdb',
+    'light olive green': '#a4be5c',
+    'brownish orange': '#cb7723',
+    'dark aqua': '#05696b',
+    'purplish pink': '#ce5dae',
+    'dark salmon': '#c85a53',
+    'greenish grey': '#96ae8d',
+    'jade': '#1fa774',
+    'ugly green': '#7a9703',
+    'dark beige': '#ac9362',
+    'emerald': '#01a049',
+    'pale red': '#d9544d',
+    'light magenta': '#fa5ff7',
+    'sky': '#82cafc',
+    'light cyan': '#acfffc',
+    'yellow orange': '#fcb001',
+    'reddish purple': '#910951',
+    'reddish pink': '#fe2c54',
+    'orchid': '#c875c4',
+    'dirty yellow': '#cdc50a',
+    'orange red': '#fd411e',
+    'deep red': '#9a0200',
+    'orange brown': '#be6400',
+    'cobalt blue': '#030aa7',
+    'neon pink': '#fe019a',
+    'rose pink': '#f7879a',
+    'greyish purple': '#887191',
+    'raspberry': '#b00149',
+    'aqua green': '#12e193',
+    'salmon pink': '#fe7b7c',
+    'tangerine': '#ff9408',
+    'brownish green': '#6a6e09',
+    'red brown': '#8b2e16',
+    'greenish brown': '#696112',
+    'pumpkin': '#e17701',
+    'pine green': '#0a481e',
+    'charcoal': '#343837',
+    'baby pink': '#ffb7ce',
+    'cornflower': '#6a79f7',
+    'blue violet': '#5d06e9',
+    'chocolate': '#3d1c02',
+    'greyish green': '#82a67d',
+    'scarlet': '#be0119',
+    'green yellow': '#c9ff27',
+    'dark olive': '#373e02',
+    'sienna': '#a9561e',
+    'pastel purple': '#caa0ff',
+    'terracotta': '#ca6641',
+    'aqua blue': '#02d8e9',
+    'sage green': '#88b378',
+    'blood red': '#980002',
+    'deep pink': '#cb0162',
+    'grass': '#5cac2d',
+    'moss': '#769958',
+    'pastel blue': '#a2bffe',
+    'bluish green': '#10a674',
+    'green blue': '#06b48b',
+    'dark tan': '#af884a',
+    'greenish blue': '#0b8b87',
+    'pale orange': '#ffa756',
+    'vomit': '#a2a415',
+    'forrest green': '#154406',
+    'dark lavender': '#856798',
+    'dark violet': '#34013f',
+    'purple blue': '#632de9',
+    'dark cyan': '#0a888a',
+    'olive drab': '#6f7632',
+    'pinkish': '#d46a7e',
+    'cobalt': '#1e488f',
+    'neon purple': '#bc13fe',
+    'light turquoise': '#7ef4cc',
+    'apple green': '#76cd26',
+    'dull green': '#74a662',
+    'wine': '#80013f',
+    'powder blue': '#b1d1fc',
+    'off white': '#ffffe4',
+    'electric blue': '#0652ff',
+    'dark turquoise': '#045c5a',
+    'blue purple': '#5729ce',
+    'azure': '#069af3',
+    'bright red': '#ff000d',
+    'pinkish red': '#f10c45',
+    'cornflower blue': '#5170d7',
+    'light olive': '#acbf69',
+    'grape': '#6c3461',
+    'greyish blue': '#5e819d',
+    'purplish blue': '#601ef9',
+    'yellowish green': '#b0dd16',
+    'greenish yellow': '#cdfd02',
+    'medium blue': '#2c6fbb',
+    'dusty rose': '#c0737a',
+    'light violet': '#d6b4fc',
+    'midnight blue': '#020035',
+    'bluish purple': '#703be7',
+    'red orange': '#fd3c06',
+    'dark magenta': '#960056',
+    'greenish': '#40a368',
+    'ocean blue': '#03719c',
+    'coral': '#fc5a50',
+    'cream': '#ffffc2',
+    'reddish brown': '#7f2b0a',
+    'burnt sienna': '#b04e0f',
+    'brick': '#a03623',
+    'sage': '#87ae73',
+    'grey green': '#789b73',
+    'white': '#ffffff',
+    "robin's egg blue": '#98eff9',
+    'moss green': '#658b38',
+    'steel blue': '#5a7d9a',
+    'eggplant': '#380835',
+    'light yellow': '#fffe7a',
+    'leaf green': '#5ca904',
+    'light grey': '#d8dcd6',
+    'puke': '#a5a502',
+    'pinkish purple': '#d648d7',
+    'sea blue': '#047495',
+    'pale purple': '#b790d4',
+    'slate blue': '#5b7c99',
+    'blue grey': '#607c8e',
+    'hunter green': '#0b4008',
+    'fuchsia': '#ed0dd9',
+    'crimson': '#8c000f',
+    'pale yellow': '#ffff84',
+    'ochre': '#bf9005',
+    'mustard yellow': '#d2bd0a',
+    'light red': '#ff474c',
+    'cerulean': '#0485d1',
+    'pale pink': '#ffcfdc',
+    'deep blue': '#040273',
+    'rust': '#a83c09',
+    'light teal': '#90e4c1',
+    'slate': '#516572',
+    'goldenrod': '#fac205',
+    'dark yellow': '#d5b60a',
+    'dark grey': '#363737',
+    'army green': '#4b5d16',
+    'grey blue': '#6b8ba4',
+    'seafoam': '#80f9ad',
+    'puce': '#a57e52',
+    'spring green': '#a9f971',
+    'dark orange': '#c65102',
+    'sand': '#e2ca76',
+    'pastel green': '#b0ff9d',
+    'mint': '#9ffeb0',
+    'light orange': '#fdaa48',
+    'bright pink': '#fe01b1',
+    'chartreuse': '#c1f80a',
+    'deep purple': '#36013f',
+    'dark brown': '#341c02',
+    'taupe': '#b9a281',
+    'pea green': '#8eab12',
+    'puke green': '#9aae07',
+    'kelly green': '#02ab2e',
+    'seafoam green': '#7af9ab',
+    'blue green': '#137e6d',
+    'khaki': '#aaa662',
+    'burgundy': '#610023',
+    'dark teal': '#014d4e',
+    'brick red': '#8f1402',
+    'royal purple': '#4b006e',
+    'plum': '#580f41',
+    'mint green': '#8fff9f',
+    'gold': '#dbb40c',
+    'baby blue': '#a2cffe',
+    'yellow green': '#c0fb2d',
+    'bright purple': '#be03fd',
+    'dark red': '#840000',
+    'pale blue': '#d0fefe',
+    'grass green': '#3f9b0b',
+    'navy': '#01153e',
+    'aquamarine': '#04d8b2',
+    'burnt orange': '#c04e01',
+    'neon green': '#0cff0c',
+    'bright blue': '#0165fc',
+    'rose': '#cf6275',
+    'light pink': '#ffd1df',
+    'mustard': '#ceb301',
+    'indigo': '#380282',
+    'lime': '#aaff32',
+    'sea green': '#53fca1',
+    'periwinkle': '#8e82fe',
+    'dark pink': '#cb416b',
+    'olive green': '#677a04',
+    'peach': '#ffb07c',
+    'pale green': '#c7fdb5',
+    'light brown': '#ad8150',
+    'hot pink': '#ff028d',
+    'black': '#000000',
+    'lilac': '#cea2fd',
+    'navy blue': '#001146',
+    'royal blue': '#0504aa',
+    'beige': '#e6daa6',
+    'salmon': '#ff796c',
+    'olive': '#6e750e',
+    'maroon': '#650021',
+    'bright green': '#01ff07',
+    'dark purple': '#35063e',
+    'mauve': '#ae7181',
+    'forest green': '#06470c',
+    'aqua': '#13eac9',
+    'cyan': '#00ffff',
+    'tan': '#d1b26f',
+    'dark blue': '#00035b',
+    'lavender': '#c79fef',
+    'turquoise': '#06c2ac',
+    'dark green': '#033500',
+    'violet': '#9a0eea',
+    'light purple': '#bf77f6',
+    'lime green': '#89fe05',
+    'grey': '#929591',
+    'sky blue': '#75bbfd',
+    'yellow': '#ffff14',
+    'magenta': '#c20078',
+    'light green': '#96f97b',
+    'orange': '#f97306',
+    'teal': '#029386',
+    'light blue': '#95d0fc',
+    'red': '#e50000',
+    'brown': '#653700',
+    'pink': '#ff81c0',
+    'blue': '#0343df',
+    'green': '#15b01a',
+    'purple': '#7e1e9c'}
+
+# Normalize name to "xkcd:<name>" to avoid name collisions.
+XKCD_COLORS = {'xkcd:' + name: value for name, value in XKCD_COLORS.items()}
+
+
+# https://drafts.csswg.org/css-color-4/#named-colors
+CSS4_COLORS = {
+    'aliceblue':            '#F0F8FF',
+    'antiquewhite':         '#FAEBD7',
+    'aqua':                 '#00FFFF',
+    'aquamarine':           '#7FFFD4',
+    'azure':                '#F0FFFF',
+    'beige':                '#F5F5DC',
+    'bisque':               '#FFE4C4',
+    'black':                '#000000',
+    'blanchedalmond':       '#FFEBCD',
+    'blue':                 '#0000FF',
+    'blueviolet':           '#8A2BE2',
+    'brown':                '#A52A2A',
+    'burlywood':            '#DEB887',
+    'cadetblue':            '#5F9EA0',
+    'chartreuse':           '#7FFF00',
+    'chocolate':            '#D2691E',
+    'coral':                '#FF7F50',
+    'cornflowerblue':       '#6495ED',
+    'cornsilk':             '#FFF8DC',
+    'crimson':              '#DC143C',
+    'cyan':                 '#00FFFF',
+    'darkblue':             '#00008B',
+    'darkcyan':             '#008B8B',
+    'darkgoldenrod':        '#B8860B',
+    'darkgray':             '#A9A9A9',
+    'darkgreen':            '#006400',
+    'darkgrey':             '#A9A9A9',
+    'darkkhaki':            '#BDB76B',
+    'darkmagenta':          '#8B008B',
+    'darkolivegreen':       '#556B2F',
+    'darkorange':           '#FF8C00',
+    'darkorchid':           '#9932CC',
+    'darkred':              '#8B0000',
+    'darksalmon':           '#E9967A',
+    'darkseagreen':         '#8FBC8F',
+    'darkslateblue':        '#483D8B',
+    'darkslategray':        '#2F4F4F',
+    'darkslategrey':        '#2F4F4F',
+    'darkturquoise':        '#00CED1',
+    'darkviolet':           '#9400D3',
+    'deeppink':             '#FF1493',
+    'deepskyblue':          '#00BFFF',
+    'dimgray':              '#696969',
+    'dimgrey':              '#696969',
+    'dodgerblue':           '#1E90FF',
+    'firebrick':            '#B22222',
+    'floralwhite':          '#FFFAF0',
+    'forestgreen':          '#228B22',
+    'fuchsia':              '#FF00FF',
+    'gainsboro':            '#DCDCDC',
+    'ghostwhite':           '#F8F8FF',
+    'gold':                 '#FFD700',
+    'goldenrod':            '#DAA520',
+    'gray':                 '#808080',
+    'green':                '#008000',
+    'greenyellow':          '#ADFF2F',
+    'grey':                 '#808080',
+    'honeydew':             '#F0FFF0',
+    'hotpink':              '#FF69B4',
+    'indianred':            '#CD5C5C',
+    'indigo':               '#4B0082',
+    'ivory':                '#FFFFF0',
+    'khaki':                '#F0E68C',
+    'lavender':             '#E6E6FA',
+    'lavenderblush':        '#FFF0F5',
+    'lawngreen':            '#7CFC00',
+    'lemonchiffon':         '#FFFACD',
+    'lightblue':            '#ADD8E6',
+    'lightcoral':           '#F08080',
+    'lightcyan':            '#E0FFFF',
+    'lightgoldenrodyellow': '#FAFAD2',
+    'lightgray':            '#D3D3D3',
+    'lightgreen':           '#90EE90',
+    'lightgrey':            '#D3D3D3',
+    'lightpink':            '#FFB6C1',
+    'lightsalmon':          '#FFA07A',
+    'lightseagreen':        '#20B2AA',
+    'lightskyblue':         '#87CEFA',
+    'lightslategray':       '#778899',
+    'lightslategrey':       '#778899',
+    'lightsteelblue':       '#B0C4DE',
+    'lightyellow':          '#FFFFE0',
+    'lime':                 '#00FF00',
+    'limegreen':            '#32CD32',
+    'linen':                '#FAF0E6',
+    'magenta':              '#FF00FF',
+    'maroon':               '#800000',
+    'mediumaquamarine':     '#66CDAA',
+    'mediumblue':           '#0000CD',
+    'mediumorchid':         '#BA55D3',
+    'mediumpurple':         '#9370DB',
+    'mediumseagreen':       '#3CB371',
+    'mediumslateblue':      '#7B68EE',
+    'mediumspringgreen':    '#00FA9A',
+    'mediumturquoise':      '#48D1CC',
+    'mediumvioletred':      '#C71585',
+    'midnightblue':         '#191970',
+    'mintcream':            '#F5FFFA',
+    'mistyrose':            '#FFE4E1',
+    'moccasin':             '#FFE4B5',
+    'navajowhite':          '#FFDEAD',
+    'navy':                 '#000080',
+    'oldlace':              '#FDF5E6',
+    'olive':                '#808000',
+    'olivedrab':            '#6B8E23',
+    'orange':               '#FFA500',
+    'orangered':            '#FF4500',
+    'orchid':               '#DA70D6',
+    'palegoldenrod':        '#EEE8AA',
+    'palegreen':            '#98FB98',
+    'paleturquoise':        '#AFEEEE',
+    'palevioletred':        '#DB7093',
+    'papayawhip':           '#FFEFD5',
+    'peachpuff':            '#FFDAB9',
+    'peru':                 '#CD853F',
+    'pink':                 '#FFC0CB',
+    'plum':                 '#DDA0DD',
+    'powderblue':           '#B0E0E6',
+    'purple':               '#800080',
+    'rebeccapurple':        '#663399',
+    'red':                  '#FF0000',
+    'rosybrown':            '#BC8F8F',
+    'royalblue':            '#4169E1',
+    'saddlebrown':          '#8B4513',
+    'salmon':               '#FA8072',
+    'sandybrown':           '#F4A460',
+    'seagreen':             '#2E8B57',
+    'seashell':             '#FFF5EE',
+    'sienna':               '#A0522D',
+    'silver':               '#C0C0C0',
+    'skyblue':              '#87CEEB',
+    'slateblue':            '#6A5ACD',
+    'slategray':            '#708090',
+    'slategrey':            '#708090',
+    'snow':                 '#FFFAFA',
+    'springgreen':          '#00FF7F',
+    'steelblue':            '#4682B4',
+    'tan':                  '#D2B48C',
+    'teal':                 '#008080',
+    'thistle':              '#D8BFD8',
+    'tomato':               '#FF6347',
+    'turquoise':            '#40E0D0',
+    'violet':               '#EE82EE',
+    'wheat':                '#F5DEB3',
+    'white':                '#FFFFFF',
+    'whitesmoke':           '#F5F5F5',
+    'yellow':               '#FFFF00',
+    'yellowgreen':          '#9ACD32'}

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_color_data.pyi

@@ -0,0 +1,6 @@
+from .typing import ColorType
+
+BASE_COLORS: dict[str, ColorType]
+TABLEAU_COLORS: dict[str, ColorType]
+XKCD_COLORS: dict[str, ColorType]
+CSS4_COLORS: dict[str, ColorType]

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_constrained_layout.py

@@ -0,0 +1,805 @@
+"""
+Adjust subplot layouts so that there are no overlapping Axes or Axes
+decorations.  All Axes decorations are dealt with (labels, ticks, titles,
+ticklabels) and some dependent artists are also dealt with (colorbar,
+suptitle).
+
+Layout is done via `~matplotlib.gridspec`, with one constraint per gridspec,
+so it is possible to have overlapping Axes if the gridspecs overlap (i.e.
+using `~matplotlib.gridspec.GridSpecFromSubplotSpec`).  Axes placed using
+``figure.subplots()`` or ``figure.add_subplots()`` will participate in the
+layout.  Axes manually placed via ``figure.add_axes()`` will not.
+
+See Tutorial: :ref:`constrainedlayout_guide`
+
+General idea:
+-------------
+
+First, a figure has a gridspec that divides the figure into nrows and ncols,
+with heights and widths set by ``height_ratios`` and ``width_ratios``,
+often just set to 1 for an equal grid.
+
+Subplotspecs that are derived from this gridspec can contain either a
+``SubPanel``, a ``GridSpecFromSubplotSpec``, or an ``Axes``.  The ``SubPanel``
+and ``GridSpecFromSubplotSpec`` are dealt with recursively and each contain an
+analogous layout.
+
+Each ``GridSpec`` has a ``_layoutgrid`` attached to it.  The ``_layoutgrid``
+has the same logical layout as the ``GridSpec``.   Each row of the grid spec
+has a top and bottom "margin" and each column has a left and right "margin".
+The "inner" height of each row is constrained to be the same (or as modified
+by ``height_ratio``), and the "inner" width of each column is
+constrained to be the same (as modified by ``width_ratio``), where "inner"
+is the width or height of each column/row minus the size of the margins.
+
+Then the size of the margins for each row and column are determined as the
+max width of the decorators on each Axes that has decorators in that margin.
+For instance, a normal Axes would have a left margin that includes the
+left ticklabels, and the ylabel if it exists.  The right margin may include a
+colorbar, the bottom margin the xaxis decorations, and the top margin the
+title.
+
+With these constraints, the solver then finds appropriate bounds for the
+columns and rows.  It's possible that the margins take up the whole figure,
+in which case the algorithm is not applied and a warning is raised.
+
+See the tutorial :ref:`constrainedlayout_guide`
+for more discussion of the algorithm with examples.
+"""
+
+import logging
+
+import numpy as np
+
+from matplotlib import _api, artist as martist
+import matplotlib.transforms as mtransforms
+import matplotlib._layoutgrid as mlayoutgrid
+
+
+_log = logging.getLogger(__name__)
+
+
+######################################################
+def do_constrained_layout(fig, h_pad, w_pad,
+                          hspace=None, wspace=None, rect=(0, 0, 1, 1),
+                          compress=False):
+    """
+    Do the constrained_layout.  Called at draw time in
+     ``figure.constrained_layout()``
+
+    Parameters
+    ----------
+    fig : `~matplotlib.figure.Figure`
+        `.Figure` instance to do the layout in.
+
+    h_pad, w_pad : float
+      Padding around the Axes elements in figure-normalized units.
+
+    hspace, wspace : float
+       Fraction of the figure to dedicate to space between the
+       Axes.  These are evenly spread between the gaps between the Axes.
+       A value of 0.2 for a three-column layout would have a space
+       of 0.1 of the figure width between each column.
+       If h/wspace < h/w_pad, then the pads are used instead.
+
+    rect : tuple of 4 floats
+        Rectangle in figure coordinates to perform constrained layout in
+        [left, bottom, width, height], each from 0-1.
+
+    compress : bool
+        Whether to shift Axes so that white space in between them is
+        removed. This is useful for simple grids of fixed-aspect Axes (e.g.
+        a grid of images).
+
+    Returns
+    -------
+    layoutgrid : private debugging structure
+    """
+
+    renderer = fig._get_renderer()
+    # make layoutgrid tree...
+    layoutgrids = make_layoutgrids(fig, None, rect=rect)
+    if not layoutgrids['hasgrids']:
+        _api.warn_external('There are no gridspecs with layoutgrids. '
+                           'Possibly did not call parent GridSpec with the'
+                           ' "figure" keyword')
+        return
+
+    for _ in range(2):
+        # do the algorithm twice.  This has to be done because decorations
+        # change size after the first re-position (i.e. x/yticklabels get
+        # larger/smaller).  This second reposition tends to be much milder,
+        # so doing twice makes things work OK.
+
+        # make margins for all the Axes and subfigures in the
+        # figure.  Add margins for colorbars...
+        make_layout_margins(layoutgrids, fig, renderer, h_pad=h_pad,
+                            w_pad=w_pad, hspace=hspace, wspace=wspace)
+        make_margin_suptitles(layoutgrids, fig, renderer, h_pad=h_pad,
+                              w_pad=w_pad)
+
+        # if a layout is such that a columns (or rows) margin has no
+        # constraints, we need to make all such instances in the grid
+        # match in margin size.
+        match_submerged_margins(layoutgrids, fig)
+
+        # update all the variables in the layout.
+        layoutgrids[fig].update_variables()
+
+        warn_collapsed = ('constrained_layout not applied because '
+                          'axes sizes collapsed to zero.  Try making '
+                          'figure larger or Axes decorations smaller.')
+        if check_no_collapsed_axes(layoutgrids, fig):
+            reposition_axes(layoutgrids, fig, renderer, h_pad=h_pad,
+                            w_pad=w_pad, hspace=hspace, wspace=wspace)
+            if compress:
+                layoutgrids = compress_fixed_aspect(layoutgrids, fig)
+                layoutgrids[fig].update_variables()
+                if check_no_collapsed_axes(layoutgrids, fig):
+                    reposition_axes(layoutgrids, fig, renderer, h_pad=h_pad,
+                                    w_pad=w_pad, hspace=hspace, wspace=wspace)
+                else:
+                    _api.warn_external(warn_collapsed)
+
+                if ((suptitle := fig._suptitle) is not None and
+                        suptitle.get_in_layout() and suptitle._autopos):
+                    x, _ = suptitle.get_position()
+                    suptitle.set_position(
+                        (x, layoutgrids[fig].get_inner_bbox().y1 + h_pad))
+                    suptitle.set_verticalalignment('bottom')
+        else:
+            _api.warn_external(warn_collapsed)
+        reset_margins(layoutgrids, fig)
+    return layoutgrids
+
+
+def make_layoutgrids(fig, layoutgrids, rect=(0, 0, 1, 1)):
+    """
+    Make the layoutgrid tree.
+
+    (Sub)Figures get a layoutgrid so we can have figure margins.
+
+    Gridspecs that are attached to Axes get a layoutgrid so Axes
+    can have margins.
+    """
+
+    if layoutgrids is None:
+        layoutgrids = dict()
+        layoutgrids['hasgrids'] = False
+    if not hasattr(fig, '_parent'):
+        # top figure;  pass rect as parent to allow user-specified
+        # margins
+        layoutgrids[fig] = mlayoutgrid.LayoutGrid(parent=rect, name='figlb')
+    else:
+        # subfigure
+        gs = fig._subplotspec.get_gridspec()
+        # it is possible the gridspec containing this subfigure hasn't
+        # been added to the tree yet:
+        layoutgrids = make_layoutgrids_gs(layoutgrids, gs)
+        # add the layoutgrid for the subfigure:
+        parentlb = layoutgrids[gs]
+        layoutgrids[fig] = mlayoutgrid.LayoutGrid(
+            parent=parentlb,
+            name='panellb',
+            parent_inner=True,
+            nrows=1, ncols=1,
+            parent_pos=(fig._subplotspec.rowspan,
+                        fig._subplotspec.colspan))
+    # recursively do all subfigures in this figure...
+    for sfig in fig.subfigs:
+        layoutgrids = make_layoutgrids(sfig, layoutgrids)
+
+    # for each Axes at the local level add its gridspec:
+    for ax in fig._localaxes:
+        gs = ax.get_gridspec()
+        if gs is not None:
+            layoutgrids = make_layoutgrids_gs(layoutgrids, gs)
+
+    return layoutgrids
+
+
+def make_layoutgrids_gs(layoutgrids, gs):
+    """
+    Make the layoutgrid for a gridspec (and anything nested in the gridspec)
+    """
+
+    if gs in layoutgrids or gs.figure is None:
+        return layoutgrids
+    # in order to do constrained_layout there has to be at least *one*
+    # gridspec in the tree:
+    layoutgrids['hasgrids'] = True
+    if not hasattr(gs, '_subplot_spec'):
+        # normal gridspec
+        parent = layoutgrids[gs.figure]
+        layoutgrids[gs] = mlayoutgrid.LayoutGrid(
+                parent=parent,
+                parent_inner=True,
+                name='gridspec',
+                ncols=gs._ncols, nrows=gs._nrows,
+                width_ratios=gs.get_width_ratios(),
+                height_ratios=gs.get_height_ratios())
+    else:
+        # this is a gridspecfromsubplotspec:
+        subplot_spec = gs._subplot_spec
+        parentgs = subplot_spec.get_gridspec()
+        # if a nested gridspec it is possible the parent is not in there yet:
+        if parentgs not in layoutgrids:
+            layoutgrids = make_layoutgrids_gs(layoutgrids, parentgs)
+        subspeclb = layoutgrids[parentgs]
+        # gridspecfromsubplotspec need an outer container:
+        # get a unique representation:
+        rep = (gs, 'top')
+        if rep not in layoutgrids:
+            layoutgrids[rep] = mlayoutgrid.LayoutGrid(
+                parent=subspeclb,
+                name='top',
+                nrows=1, ncols=1,
+                parent_pos=(subplot_spec.rowspan, subplot_spec.colspan))
+        layoutgrids[gs] = mlayoutgrid.LayoutGrid(
+                parent=layoutgrids[rep],
+                name='gridspec',
+                nrows=gs._nrows, ncols=gs._ncols,
+                width_ratios=gs.get_width_ratios(),
+                height_ratios=gs.get_height_ratios())
+    return layoutgrids
+
+
+def check_no_collapsed_axes(layoutgrids, fig):
+    """
+    Check that no Axes have collapsed to zero size.
+    """
+    for sfig in fig.subfigs:
+        ok = check_no_collapsed_axes(layoutgrids, sfig)
+        if not ok:
+            return False
+    for ax in fig.axes:
+        gs = ax.get_gridspec()
+        if gs in layoutgrids:  # also implies gs is not None.
+            lg = layoutgrids[gs]
+            for i in range(gs.nrows):
+                for j in range(gs.ncols):
+                    bb = lg.get_inner_bbox(i, j)
+                    if bb.width <= 0 or bb.height <= 0:
+                        return False
+    return True
+
+
+def compress_fixed_aspect(layoutgrids, fig):
+    gs = None
+    for ax in fig.axes:
+        if ax.get_subplotspec() is None:
+            continue
+        ax.apply_aspect()
+        sub = ax.get_subplotspec()
+        _gs = sub.get_gridspec()
+        if gs is None:
+            gs = _gs
+            extraw = np.zeros(gs.ncols)
+            extrah = np.zeros(gs.nrows)
+        elif _gs != gs:
+            raise ValueError('Cannot do compressed layout if Axes are not'
+                             'all from the same gridspec')
+        orig = ax.get_position(original=True)
+        actual = ax.get_position(original=False)
+        dw = orig.width - actual.width
+        if dw > 0:
+            extraw[sub.colspan] = np.maximum(extraw[sub.colspan], dw)
+        dh = orig.height - actual.height
+        if dh > 0:
+            extrah[sub.rowspan] = np.maximum(extrah[sub.rowspan], dh)
+
+    if gs is None:
+        raise ValueError('Cannot do compressed layout if no Axes '
+                         'are part of a gridspec.')
+    w = np.sum(extraw) / 2
+    layoutgrids[fig].edit_margin_min('left', w)
+    layoutgrids[fig].edit_margin_min('right', w)
+
+    h = np.sum(extrah) / 2
+    layoutgrids[fig].edit_margin_min('top', h)
+    layoutgrids[fig].edit_margin_min('bottom', h)
+    return layoutgrids
+
+
+def get_margin_from_padding(obj, *, w_pad=0, h_pad=0,
+                            hspace=0, wspace=0):
+
+    ss = obj._subplotspec
+    gs = ss.get_gridspec()
+
+    if hasattr(gs, 'hspace'):
+        _hspace = (gs.hspace if gs.hspace is not None else hspace)
+        _wspace = (gs.wspace if gs.wspace is not None else wspace)
+    else:
+        _hspace = (gs._hspace if gs._hspace is not None else hspace)
+        _wspace = (gs._wspace if gs._wspace is not None else wspace)
+
+    _wspace = _wspace / 2
+    _hspace = _hspace / 2
+
+    nrows, ncols = gs.get_geometry()
+    # there are two margins for each direction.  The "cb"
+    # margins are for pads and colorbars, the non-"cb" are
+    # for the Axes decorations (labels etc).
+    margin = {'leftcb': w_pad, 'rightcb': w_pad,
+              'bottomcb': h_pad, 'topcb': h_pad,
+              'left': 0, 'right': 0,
+              'top': 0, 'bottom': 0}
+    if _wspace / ncols > w_pad:
+        if ss.colspan.start > 0:
+            margin['leftcb'] = _wspace / ncols
+        if ss.colspan.stop < ncols:
+            margin['rightcb'] = _wspace / ncols
+    if _hspace / nrows > h_pad:
+        if ss.rowspan.stop < nrows:
+            margin['bottomcb'] = _hspace / nrows
+        if ss.rowspan.start > 0:
+            margin['topcb'] = _hspace / nrows
+
+    return margin
+
+
+def make_layout_margins(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0,
+                        hspace=0, wspace=0):
+    """
+    For each Axes, make a margin between the *pos* layoutbox and the
+    *axes* layoutbox be a minimum size that can accommodate the
+    decorations on the axis.
+
+    Then make room for colorbars.
+
+    Parameters
+    ----------
+    layoutgrids : dict
+    fig : `~matplotlib.figure.Figure`
+        `.Figure` instance to do the layout in.
+    renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+        The renderer to use.
+    w_pad, h_pad : float, default: 0
+        Width and height padding (in fraction of figure).
+    hspace, wspace : float, default: 0
+        Width and height padding as fraction of figure size divided by
+        number of columns or rows.
+    """
+    for sfig in fig.subfigs:  # recursively make child panel margins
+        ss = sfig._subplotspec
+        gs = ss.get_gridspec()
+
+        make_layout_margins(layoutgrids, sfig, renderer,
+                            w_pad=w_pad, h_pad=h_pad,
+                            hspace=hspace, wspace=wspace)
+
+        margins = get_margin_from_padding(sfig, w_pad=0, h_pad=0,
+                                          hspace=hspace, wspace=wspace)
+        layoutgrids[gs].edit_outer_margin_mins(margins, ss)
+
+    for ax in fig._localaxes:
+        if not ax.get_subplotspec() or not ax.get_in_layout():
+            continue
+
+        ss = ax.get_subplotspec()
+        gs = ss.get_gridspec()
+
+        if gs not in layoutgrids:
+            return
+
+        margin = get_margin_from_padding(ax, w_pad=w_pad, h_pad=h_pad,
+                                         hspace=hspace, wspace=wspace)
+        pos, bbox = get_pos_and_bbox(ax, renderer)
+        # the margin is the distance between the bounding box of the Axes
+        # and its position (plus the padding from above)
+        margin['left'] += pos.x0 - bbox.x0
+        margin['right'] += bbox.x1 - pos.x1
+        # remember that rows are ordered from top:
+        margin['bottom'] += pos.y0 - bbox.y0
+        margin['top'] += bbox.y1 - pos.y1
+
+        # make margin for colorbars.  These margins go in the
+        # padding margin, versus the margin for Axes decorators.
+        for cbax in ax._colorbars:
+            # note pad is a fraction of the parent width...
+            pad = colorbar_get_pad(layoutgrids, cbax)
+            # colorbars can be child of more than one subplot spec:
+            cbp_rspan, cbp_cspan = get_cb_parent_spans(cbax)
+            loc = cbax._colorbar_info['location']
+            cbpos, cbbbox = get_pos_and_bbox(cbax, renderer)
+            if loc == 'right':
+                if cbp_cspan.stop == ss.colspan.stop:
+                    # only increase if the colorbar is on the right edge
+                    margin['rightcb'] += cbbbox.width + pad
+            elif loc == 'left':
+                if cbp_cspan.start == ss.colspan.start:
+                    # only increase if the colorbar is on the left edge
+                    margin['leftcb'] += cbbbox.width + pad
+            elif loc == 'top':
+                if cbp_rspan.start == ss.rowspan.start:
+                    margin['topcb'] += cbbbox.height + pad
+            else:
+                if cbp_rspan.stop == ss.rowspan.stop:
+                    margin['bottomcb'] += cbbbox.height + pad
+            # If the colorbars are wider than the parent box in the
+            # cross direction
+            if loc in ['top', 'bottom']:
+                if (cbp_cspan.start == ss.colspan.start and
+                        cbbbox.x0 < bbox.x0):
+                    margin['left'] += bbox.x0 - cbbbox.x0
+                if (cbp_cspan.stop == ss.colspan.stop and
+                        cbbbox.x1 > bbox.x1):
+                    margin['right'] += cbbbox.x1 - bbox.x1
+            # or taller:
+            if loc in ['left', 'right']:
+                if (cbp_rspan.stop == ss.rowspan.stop and
+                        cbbbox.y0 < bbox.y0):
+                    margin['bottom'] += bbox.y0 - cbbbox.y0
+                if (cbp_rspan.start == ss.rowspan.start and
+                        cbbbox.y1 > bbox.y1):
+                    margin['top'] += cbbbox.y1 - bbox.y1
+        # pass the new margins down to the layout grid for the solution...
+        layoutgrids[gs].edit_outer_margin_mins(margin, ss)
+
+    # make margins for figure-level legends:
+    for leg in fig.legends:
+        inv_trans_fig = None
+        if leg._outside_loc and leg._bbox_to_anchor is None:
+            if inv_trans_fig is None:
+                inv_trans_fig = fig.transFigure.inverted().transform_bbox
+            bbox = inv_trans_fig(leg.get_tightbbox(renderer))
+            w = bbox.width + 2 * w_pad
+            h = bbox.height + 2 * h_pad
+            legendloc = leg._outside_loc
+            if legendloc == 'lower':
+                layoutgrids[fig].edit_margin_min('bottom', h)
+            elif legendloc == 'upper':
+                layoutgrids[fig].edit_margin_min('top', h)
+            if legendloc == 'right':
+                layoutgrids[fig].edit_margin_min('right', w)
+            elif legendloc == 'left':
+                layoutgrids[fig].edit_margin_min('left', w)
+
+
+def make_margin_suptitles(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0):
+    # Figure out how large the suptitle is and make the
+    # top level figure margin larger.
+
+    inv_trans_fig = fig.transFigure.inverted().transform_bbox
+    # get the h_pad and w_pad as distances in the local subfigure coordinates:
+    padbox = mtransforms.Bbox([[0, 0], [w_pad, h_pad]])
+    padbox = (fig.transFigure -
+              fig.transSubfigure).transform_bbox(padbox)
+    h_pad_local = padbox.height
+    w_pad_local = padbox.width
+
+    for sfig in fig.subfigs:
+        make_margin_suptitles(layoutgrids, sfig, renderer,
+                              w_pad=w_pad, h_pad=h_pad)
+
+    if fig._suptitle is not None and fig._suptitle.get_in_layout():
+        p = fig._suptitle.get_position()
+        if getattr(fig._suptitle, '_autopos', False):
+            fig._suptitle.set_position((p[0], 1 - h_pad_local))
+            bbox = inv_trans_fig(fig._suptitle.get_tightbbox(renderer))
+            layoutgrids[fig].edit_margin_min('top', bbox.height + 2 * h_pad)
+
+    if fig._supxlabel is not None and fig._supxlabel.get_in_layout():
+        p = fig._supxlabel.get_position()
+        if getattr(fig._supxlabel, '_autopos', False):
+            fig._supxlabel.set_position((p[0], h_pad_local))
+            bbox = inv_trans_fig(fig._supxlabel.get_tightbbox(renderer))
+            layoutgrids[fig].edit_margin_min('bottom',
+                                             bbox.height + 2 * h_pad)
+
+    if fig._supylabel is not None and fig._supylabel.get_in_layout():
+        p = fig._supylabel.get_position()
+        if getattr(fig._supylabel, '_autopos', False):
+            fig._supylabel.set_position((w_pad_local, p[1]))
+            bbox = inv_trans_fig(fig._supylabel.get_tightbbox(renderer))
+            layoutgrids[fig].edit_margin_min('left', bbox.width + 2 * w_pad)
+
+
+def match_submerged_margins(layoutgrids, fig):
+    """
+    Make the margins that are submerged inside an Axes the same size.
+
+    This allows Axes that span two columns (or rows) that are offset
+    from one another to have the same size.
+
+    This gives the proper layout for something like::
+        fig = plt.figure(constrained_layout=True)
+        axs = fig.subplot_mosaic("AAAB\nCCDD")
+
+    Without this routine, the Axes D will be wider than C, because the
+    margin width between the two columns in C has no width by default,
+    whereas the margins between the two columns of D are set by the
+    width of the margin between A and B. However, obviously the user would
+    like C and D to be the same size, so we need to add constraints to these
+    "submerged" margins.
+
+    This routine makes all the interior margins the same, and the spacing
+    between the three columns in A and the two column in C are all set to the
+    margins between the two columns of D.
+
+    See test_constrained_layout::test_constrained_layout12 for an example.
+    """
+
+    axsdone = []
+    for sfig in fig.subfigs:
+        axsdone += match_submerged_margins(layoutgrids, sfig)
+
+    axs = [a for a in fig.get_axes()
+           if (a.get_subplotspec() is not None and a.get_in_layout() and
+               a not in axsdone)]
+
+    for ax1 in axs:
+        ss1 = ax1.get_subplotspec()
+        if ss1.get_gridspec() not in layoutgrids:
+            axs.remove(ax1)
+            continue
+        lg1 = layoutgrids[ss1.get_gridspec()]
+
+        # interior columns:
+        if len(ss1.colspan) > 1:
+            maxsubl = np.max(
+                lg1.margin_vals['left'][ss1.colspan[1:]] +
+                lg1.margin_vals['leftcb'][ss1.colspan[1:]]
+            )
+            maxsubr = np.max(
+                lg1.margin_vals['right'][ss1.colspan[:-1]] +
+                lg1.margin_vals['rightcb'][ss1.colspan[:-1]]
+            )
+            for ax2 in axs:
+                ss2 = ax2.get_subplotspec()
+                lg2 = layoutgrids[ss2.get_gridspec()]
+                if lg2 is not None and len(ss2.colspan) > 1:
+                    maxsubl2 = np.max(
+                        lg2.margin_vals['left'][ss2.colspan[1:]] +
+                        lg2.margin_vals['leftcb'][ss2.colspan[1:]])
+                    if maxsubl2 > maxsubl:
+                        maxsubl = maxsubl2
+                    maxsubr2 = np.max(
+                        lg2.margin_vals['right'][ss2.colspan[:-1]] +
+                        lg2.margin_vals['rightcb'][ss2.colspan[:-1]])
+                    if maxsubr2 > maxsubr:
+                        maxsubr = maxsubr2
+            for i in ss1.colspan[1:]:
+                lg1.edit_margin_min('left', maxsubl, cell=i)
+            for i in ss1.colspan[:-1]:
+                lg1.edit_margin_min('right', maxsubr, cell=i)
+
+        # interior rows:
+        if len(ss1.rowspan) > 1:
+            maxsubt = np.max(
+                lg1.margin_vals['top'][ss1.rowspan[1:]] +
+                lg1.margin_vals['topcb'][ss1.rowspan[1:]]
+            )
+            maxsubb = np.max(
+                lg1.margin_vals['bottom'][ss1.rowspan[:-1]] +
+                lg1.margin_vals['bottomcb'][ss1.rowspan[:-1]]
+            )
+
+            for ax2 in axs:
+                ss2 = ax2.get_subplotspec()
+                lg2 = layoutgrids[ss2.get_gridspec()]
+                if lg2 is not None:
+                    if len(ss2.rowspan) > 1:
+                        maxsubt = np.max([np.max(
+                            lg2.margin_vals['top'][ss2.rowspan[1:]] +
+                            lg2.margin_vals['topcb'][ss2.rowspan[1:]]
+                        ), maxsubt])
+                        maxsubb = np.max([np.max(
+                            lg2.margin_vals['bottom'][ss2.rowspan[:-1]] +
+                            lg2.margin_vals['bottomcb'][ss2.rowspan[:-1]]
+                        ), maxsubb])
+            for i in ss1.rowspan[1:]:
+                lg1.edit_margin_min('top', maxsubt, cell=i)
+            for i in ss1.rowspan[:-1]:
+                lg1.edit_margin_min('bottom', maxsubb, cell=i)
+
+    return axs
+
+
+def get_cb_parent_spans(cbax):
+    """
+    Figure out which subplotspecs this colorbar belongs to.
+
+    Parameters
+    ----------
+    cbax : `~matplotlib.axes.Axes`
+        Axes for the colorbar.
+    """
+    rowstart = np.inf
+    rowstop = -np.inf
+    colstart = np.inf
+    colstop = -np.inf
+    for parent in cbax._colorbar_info['parents']:
+        ss = parent.get_subplotspec()
+        rowstart = min(ss.rowspan.start, rowstart)
+        rowstop = max(ss.rowspan.stop, rowstop)
+        colstart = min(ss.colspan.start, colstart)
+        colstop = max(ss.colspan.stop, colstop)
+
+    rowspan = range(rowstart, rowstop)
+    colspan = range(colstart, colstop)
+    return rowspan, colspan
+
+
+def get_pos_and_bbox(ax, renderer):
+    """
+    Get the position and the bbox for the Axes.
+
+    Parameters
+    ----------
+    ax : `~matplotlib.axes.Axes`
+    renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+
+    Returns
+    -------
+    pos : `~matplotlib.transforms.Bbox`
+        Position in figure coordinates.
+    bbox : `~matplotlib.transforms.Bbox`
+        Tight bounding box in figure coordinates.
+    """
+    fig = ax.get_figure(root=False)
+    pos = ax.get_position(original=True)
+    # pos is in panel co-ords, but we need in figure for the layout
+    pos = pos.transformed(fig.transSubfigure - fig.transFigure)
+    tightbbox = martist._get_tightbbox_for_layout_only(ax, renderer)
+    if tightbbox is None:
+        bbox = pos
+    else:
+        bbox = tightbbox.transformed(fig.transFigure.inverted())
+    return pos, bbox
+
+
+def reposition_axes(layoutgrids, fig, renderer, *,
+                    w_pad=0, h_pad=0, hspace=0, wspace=0):
+    """
+    Reposition all the Axes based on the new inner bounding box.
+    """
+    trans_fig_to_subfig = fig.transFigure - fig.transSubfigure
+    for sfig in fig.subfigs:
+        bbox = layoutgrids[sfig].get_outer_bbox()
+        sfig._redo_transform_rel_fig(
+            bbox=bbox.transformed(trans_fig_to_subfig))
+        reposition_axes(layoutgrids, sfig, renderer,
+                        w_pad=w_pad, h_pad=h_pad,
+                        wspace=wspace, hspace=hspace)
+
+    for ax in fig._localaxes:
+        if ax.get_subplotspec() is None or not ax.get_in_layout():
+            continue
+
+        # grid bbox is in Figure coordinates, but we specify in panel
+        # coordinates...
+        ss = ax.get_subplotspec()
+        gs = ss.get_gridspec()
+        if gs not in layoutgrids:
+            return
+
+        bbox = layoutgrids[gs].get_inner_bbox(rows=ss.rowspan,
+                                              cols=ss.colspan)
+
+        # transform from figure to panel for set_position:
+        newbbox = trans_fig_to_subfig.transform_bbox(bbox)
+        ax._set_position(newbbox)
+
+        # move the colorbars:
+        # we need to keep track of oldw and oldh if there is more than
+        # one colorbar:
+        offset = {'left': 0, 'right': 0, 'bottom': 0, 'top': 0}
+        for nn, cbax in enumerate(ax._colorbars[::-1]):
+            if ax == cbax._colorbar_info['parents'][0]:
+                reposition_colorbar(layoutgrids, cbax, renderer,
+                                    offset=offset)
+
+
+def reposition_colorbar(layoutgrids, cbax, renderer, *, offset=None):
+    """
+    Place the colorbar in its new place.
+
+    Parameters
+    ----------
+    layoutgrids : dict
+    cbax : `~matplotlib.axes.Axes`
+        Axes for the colorbar.
+    renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+        The renderer to use.
+    offset : array-like
+        Offset the colorbar needs to be pushed to in order to
+        account for multiple colorbars.
+    """
+
+    parents = cbax._colorbar_info['parents']
+    gs = parents[0].get_gridspec()
+    fig = cbax.get_figure(root=False)
+    trans_fig_to_subfig = fig.transFigure - fig.transSubfigure
+
+    cb_rspans, cb_cspans = get_cb_parent_spans(cbax)
+    bboxparent = layoutgrids[gs].get_bbox_for_cb(rows=cb_rspans,
+                                                 cols=cb_cspans)
+    pb = layoutgrids[gs].get_inner_bbox(rows=cb_rspans, cols=cb_cspans)
+
+    location = cbax._colorbar_info['location']
+    anchor = cbax._colorbar_info['anchor']
+    fraction = cbax._colorbar_info['fraction']
+    aspect = cbax._colorbar_info['aspect']
+    shrink = cbax._colorbar_info['shrink']
+
+    cbpos, cbbbox = get_pos_and_bbox(cbax, renderer)
+
+    # Colorbar gets put at extreme edge of outer bbox of the subplotspec
+    # It needs to be moved in by: 1) a pad 2) its "margin" 3) by
+    # any colorbars already added at this location:
+    cbpad = colorbar_get_pad(layoutgrids, cbax)
+    if location in ('left', 'right'):
+        # fraction and shrink are fractions of parent
+        pbcb = pb.shrunk(fraction, shrink).anchored(anchor, pb)
+        # The colorbar is at the left side of the parent.  Need
+        # to translate to right (or left)
+        if location == 'right':
+            lmargin = cbpos.x0 - cbbbox.x0
+            dx = bboxparent.x1 - pbcb.x0 + offset['right']
+            dx += cbpad + lmargin
+            offset['right'] += cbbbox.width + cbpad
+            pbcb = pbcb.translated(dx, 0)
+        else:
+            lmargin = cbpos.x0 - cbbbox.x0
+            dx = bboxparent.x0 - pbcb.x0  # edge of parent
+            dx += -cbbbox.width - cbpad + lmargin - offset['left']
+            offset['left'] += cbbbox.width + cbpad
+            pbcb = pbcb.translated(dx, 0)
+    else:  # horizontal axes:
+        pbcb = pb.shrunk(shrink, fraction).anchored(anchor, pb)
+        if location == 'top':
+            bmargin = cbpos.y0 - cbbbox.y0
+            dy = bboxparent.y1 - pbcb.y0 + offset['top']
+            dy += cbpad + bmargin
+            offset['top'] += cbbbox.height + cbpad
+            pbcb = pbcb.translated(0, dy)
+        else:
+            bmargin = cbpos.y0 - cbbbox.y0
+            dy = bboxparent.y0 - pbcb.y0
+            dy += -cbbbox.height - cbpad + bmargin - offset['bottom']
+            offset['bottom'] += cbbbox.height + cbpad
+            pbcb = pbcb.translated(0, dy)
+
+    pbcb = trans_fig_to_subfig.transform_bbox(pbcb)
+    cbax.set_transform(fig.transSubfigure)
+    cbax._set_position(pbcb)
+    cbax.set_anchor(anchor)
+    if location in ['bottom', 'top']:
+        aspect = 1 / aspect
+    cbax.set_box_aspect(aspect)
+    cbax.set_aspect('auto')
+    return offset
+
+
+def reset_margins(layoutgrids, fig):
+    """
+    Reset the margins in the layoutboxes of *fig*.
+
+    Margins are usually set as a minimum, so if the figure gets smaller
+    the minimum needs to be zero in order for it to grow again.
+    """
+    for sfig in fig.subfigs:
+        reset_margins(layoutgrids, sfig)
+    for ax in fig.axes:
+        if ax.get_in_layout():
+            gs = ax.get_gridspec()
+            if gs in layoutgrids:  # also implies gs is not None.
+                layoutgrids[gs].reset_margins()
+    layoutgrids[fig].reset_margins()
+
+
+def colorbar_get_pad(layoutgrids, cax):
+    parents = cax._colorbar_info['parents']
+    gs = parents[0].get_gridspec()
+
+    cb_rspans, cb_cspans = get_cb_parent_spans(cax)
+    bboxouter = layoutgrids[gs].get_inner_bbox(rows=cb_rspans, cols=cb_cspans)
+
+    if cax._colorbar_info['location'] in ['right', 'left']:
+        size = bboxouter.width
+    else:
+        size = bboxouter.height
+
+    return cax._colorbar_info['pad'] * size

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_docstring.py

@@ -0,0 +1,141 @@
+import inspect
+
+from . import _api
+
+
+def kwarg_doc(text):
+    """
+    Decorator for defining the kwdoc documentation of artist properties.
+
+    This decorator can be applied to artist property setter methods.
+    The given text is stored in a private attribute ``_kwarg_doc`` on
+    the method.  It is used to overwrite auto-generated documentation
+    in the *kwdoc list* for artists. The kwdoc list is used to document
+    ``**kwargs`` when they are properties of an artist. See e.g. the
+    ``**kwargs`` section in `.Axes.text`.
+
+    The text should contain the supported types, as well as the default
+    value if applicable, e.g.:
+
+        @_docstring.kwarg_doc("bool, default: :rc:`text.usetex`")
+        def set_usetex(self, usetex):
+
+    See Also
+    --------
+    matplotlib.artist.kwdoc
+
+    """
+    def decorator(func):
+        func._kwarg_doc = text
+        return func
+    return decorator
+
+
+class Substitution:
+    """
+    A decorator that performs %-substitution on an object's docstring.
+
+    This decorator should be robust even if ``obj.__doc__`` is None (for
+    example, if -OO was passed to the interpreter).
+
+    Usage: construct a docstring.Substitution with a sequence or dictionary
+    suitable for performing substitution; then decorate a suitable function
+    with the constructed object, e.g.::
+
+        sub_author_name = Substitution(author='Jason')
+
+        @sub_author_name
+        def some_function(x):
+            "%(author)s wrote this function"
+
+        # note that some_function.__doc__ is now "Jason wrote this function"
+
+    One can also use positional arguments::
+
+        sub_first_last_names = Substitution('Edgar Allen', 'Poe')
+
+        @sub_first_last_names
+        def some_function(x):
+            "%s %s wrote the Raven"
+    """
+    def __init__(self, *args, **kwargs):
+        if args and kwargs:
+            raise TypeError("Only positional or keyword args are allowed")
+        self.params = args or kwargs
+
+    def __call__(self, func):
+        if func.__doc__:
+            func.__doc__ = inspect.cleandoc(func.__doc__) % self.params
+        return func
+
+
+class _ArtistKwdocLoader(dict):
+    def __missing__(self, key):
+        if not key.endswith(":kwdoc"):
+            raise KeyError(key)
+        name = key[:-len(":kwdoc")]
+        from matplotlib.artist import Artist, kwdoc
+        try:
+            cls, = (cls for cls in _api.recursive_subclasses(Artist)
+                    if cls.__name__ == name)
+        except ValueError as e:
+            raise KeyError(key) from e
+        return self.setdefault(key, kwdoc(cls))
+
+
+class _ArtistPropertiesSubstitution:
+    """
+    A class to substitute formatted placeholders in docstrings.
+
+    This is realized in a single instance ``_docstring.interpd``.
+
+    Use `~._ArtistPropertiesSubstition.register` to define placeholders and
+    their substitution, e.g. ``_docstring.interpd.register(name="some value")``.
+
+    Use this as a decorator to apply the substitution::
+
+        @_docstring.interpd
+        def some_func():
+            '''Replace %(name)s.'''
+
+    Decorating a class triggers substitution both on the class docstring and
+    on the class' ``__init__`` docstring (which is a commonly required
+    pattern for Artist subclasses).
+
+    Substitutions of the form ``%(classname:kwdoc)s`` (ending with the
+    literal ":kwdoc" suffix) trigger lookup of an Artist subclass with the
+    given *classname*, and are substituted with the `.kwdoc` of that class.
+    """
+
+    def __init__(self):
+        self.params = _ArtistKwdocLoader()
+
+    def register(self, **kwargs):
+        """
+        Register substitutions.
+
+        ``_docstring.interpd.register(name="some value")`` makes "name" available
+        as a named parameter that will be replaced by "some value".
+        """
+        self.params.update(**kwargs)
+
+    def __call__(self, obj):
+        if obj.__doc__:
+            obj.__doc__ = inspect.cleandoc(obj.__doc__) % self.params
+        if isinstance(obj, type) and obj.__init__ != object.__init__:
+            self(obj.__init__)
+        return obj
+
+
+def copy(source):
+    """Copy a docstring from another source function (if present)."""
+    def do_copy(target):
+        if source.__doc__:
+            target.__doc__ = source.__doc__
+        return target
+    return do_copy
+
+
+# Create a decorator that will house the various docstring snippets reused
+# throughout Matplotlib.
+interpd = _ArtistPropertiesSubstitution()

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_docstring.pyi

@@ -0,0 +1,34 @@
+from collections.abc import Callable
+from typing import Any, TypeVar, overload
+
+
+_T = TypeVar('_T')
+
+
+def kwarg_doc(text: str) -> Callable[[_T], _T]: ...
+
+
+class Substitution:
+    @overload
+    def __init__(self, *args: str): ...
+    @overload
+    def __init__(self, **kwargs: str): ...
+    def __call__(self, func: _T) -> _T: ...
+    def update(self, *args, **kwargs): ...  # type: ignore[no-untyped-def]
+
+
+class _ArtistKwdocLoader(dict[str, str]):
+    def __missing__(self, key: str) -> str: ...
+
+
+class _ArtistPropertiesSubstitution:
+    def __init__(self) -> None: ...
+    def register(self, **kwargs) -> None: ...
+    def __call__(self, obj: _T) -> _T: ...
+
+
+def copy(source: Any) -> Callable[[_T], _T]: ...
+
+
+dedent_interpd: _ArtistPropertiesSubstitution
+interpd: _ArtistPropertiesSubstitution

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_enums.py

@@ -0,0 +1,177 @@
+"""
+Enums representing sets of strings that Matplotlib uses as input parameters.
+
+Matplotlib often uses simple data types like strings or tuples to define a
+concept; e.g. the line capstyle can be specified as one of 'butt', 'round',
+or 'projecting'. The classes in this module are used internally and serve to
+document these concepts formally.
+
+As an end-user you will not use these classes directly, but only the values
+they define.
+"""
+
+from enum import Enum
+from matplotlib import _docstring
+
+
+class JoinStyle(str, Enum):
+    """
+    Define how the connection between two line segments is drawn.
+
+    For a visual impression of each *JoinStyle*, `view these docs online
+    <JoinStyle>`, or run `JoinStyle.demo`.
+
+    Lines in Matplotlib are typically defined by a 1D `~.path.Path` and a
+    finite ``linewidth``, where the underlying 1D `~.path.Path` represents the
+    center of the stroked line.
+
+    By default, `~.backend_bases.GraphicsContextBase` defines the boundaries of
+    a stroked line to simply be every point within some radius,
+    ``linewidth/2``, away from any point of the center line. However, this
+    results in corners appearing "rounded", which may not be the desired
+    behavior if you are drawing, for example, a polygon or pointed star.
+
+    **Supported values:**
+
+    .. rst-class:: value-list
+
+        'miter'
+            the "arrow-tip" style. Each boundary of the filled-in area will
+            extend in a straight line parallel to the tangent vector of the
+            centerline at the point it meets the corner, until they meet in a
+            sharp point.
+        'round'
+            stokes every point within a radius of ``linewidth/2`` of the center
+            lines.
+        'bevel'
+            the "squared-off" style. It can be thought of as a rounded corner
+            where the "circular" part of the corner has been cut off.
+
+    .. note::
+
+        Very long miter tips are cut off (to form a *bevel*) after a
+        backend-dependent limit called the "miter limit", which specifies the
+        maximum allowed ratio of miter length to line width. For example, the
+        PDF backend uses the default value of 10 specified by the PDF standard,
+        while the SVG backend does not even specify the miter limit, resulting
+        in a default value of 4 per the SVG specification. Matplotlib does not
+        currently allow the user to adjust this parameter.
+
+        A more detailed description of the effect of a miter limit can be found
+        in the `Mozilla Developer Docs
+        <https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-miterlimit>`_
+
+    .. plot::
+        :alt: Demo of possible JoinStyle's
+
+        from matplotlib._enums import JoinStyle
+        JoinStyle.demo()
+
+    """
+
+    miter = "miter"
+    round = "round"
+    bevel = "bevel"
+
+    @staticmethod
+    def demo():
+        """Demonstrate how each JoinStyle looks for various join angles."""
+        import numpy as np
+        import matplotlib.pyplot as plt
+
+        def plot_angle(ax, x, y, angle, style):
+            phi = np.radians(angle)
+            xx = [x + .5, x, x + .5*np.cos(phi)]
+            yy = [y, y, y + .5*np.sin(phi)]
+            ax.plot(xx, yy, lw=12, color='tab:blue', solid_joinstyle=style)
+            ax.plot(xx, yy, lw=1, color='black')
+            ax.plot(xx[1], yy[1], 'o', color='tab:red', markersize=3)
+
+        fig, ax = plt.subplots(figsize=(5, 4), constrained_layout=True)
+        ax.set_title('Join style')
+        for x, style in enumerate(['miter', 'round', 'bevel']):
+            ax.text(x, 5, style)
+            for y, angle in enumerate([20, 45, 60, 90, 120]):
+                plot_angle(ax, x, y, angle, style)
+                if x == 0:
+                    ax.text(-1.3, y, f'{angle} degrees')
+        ax.set_xlim(-1.5, 2.75)
+        ax.set_ylim(-.5, 5.5)
+        ax.set_axis_off()
+        fig.show()
+
+
+JoinStyle.input_description = "{" \
+        + ", ".join([f"'{js.name}'" for js in JoinStyle]) \
+        + "}"
+
+
+class CapStyle(str, Enum):
+    r"""
+    Define how the two endpoints (caps) of an unclosed line are drawn.
+
+    How to draw the start and end points of lines that represent a closed curve
+    (i.e. that end in a `~.path.Path.CLOSEPOLY`) is controlled by the line's
+    `JoinStyle`. For all other lines, how the start and end points are drawn is
+    controlled by the *CapStyle*.
+
+    For a visual impression of each *CapStyle*, `view these docs online
+    <CapStyle>` or run `CapStyle.demo`.
+
+    By default, `~.backend_bases.GraphicsContextBase` draws a stroked line as
+    squared off at its endpoints.
+
+    **Supported values:**
+
+    .. rst-class:: value-list
+
+        'butt'
+            the line is squared off at its endpoint.
+        'projecting'
+            the line is squared off as in *butt*, but the filled in area
+            extends beyond the endpoint a distance of ``linewidth/2``.
+        'round'
+            like *butt*, but a semicircular cap is added to the end of the
+            line, of radius ``linewidth/2``.
+
+    .. plot::
+        :alt: Demo of possible CapStyle's
+
+        from matplotlib._enums import CapStyle
+        CapStyle.demo()
+
+    """
+    butt = "butt"
+    projecting = "projecting"
+    round = "round"
+
+    @staticmethod
+    def demo():
+        """Demonstrate how each CapStyle looks for a thick line segment."""
+        import matplotlib.pyplot as plt
+
+        fig = plt.figure(figsize=(4, 1.2))
+        ax = fig.add_axes([0, 0, 1, 0.8])
+        ax.set_title('Cap style')
+
+        for x, style in enumerate(['butt', 'round', 'projecting']):
+            ax.text(x+0.25, 0.85, style, ha='center')
+            xx = [x, x+0.5]
+            yy = [0, 0]
+            ax.plot(xx, yy, lw=12, color='tab:blue', solid_capstyle=style)
+            ax.plot(xx, yy, lw=1, color='black')
+            ax.plot(xx, yy, 'o', color='tab:red', markersize=3)
+
+        ax.set_ylim(-.5, 1.5)
+        ax.set_axis_off()
+        fig.show()
+
+
+CapStyle.input_description = "{" \
+        + ", ".join([f"'{cs.name}'" for cs in CapStyle]) \
+        + "}"
+
+_docstring.interpd.register(
+    JoinStyle=JoinStyle.input_description,
+    CapStyle=CapStyle.input_description,
+)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_enums.pyi

@@ -0,0 +1,19 @@
+from typing import cast
+from enum import Enum
+
+
+class JoinStyle(str, Enum):
+    miter = "miter"
+    round = "round"
+    bevel = "bevel"
+    @staticmethod
+    def demo() -> None: ...
+
+
+class CapStyle(str, Enum):
+    butt = "butt"
+    projecting = "projecting"
+    round = "round"
+
+    @staticmethod
+    def demo() -> None: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_fontconfig_pattern.py

@@ -0,0 +1,111 @@
+"""
+A module for parsing and generating `fontconfig patterns`_.
+
+.. _fontconfig patterns:
+   https://www.freedesktop.org/software/fontconfig/fontconfig-user.html
+"""
+
+# This class logically belongs in `matplotlib.font_manager`, but placing it
+# there would have created cyclical dependency problems, because it also needs
+# to be available from `matplotlib.rcsetup` (for parsing matplotlibrc files).
+
+from functools import lru_cache, partial
+import re
+
+from pyparsing import (
+    Group, Optional, ParseException, Regex, StringEnd, Suppress, ZeroOrMore, one_of)
+
+
+_family_punc = r'\\\-:,'
+_family_unescape = partial(re.compile(r'\\(?=[%s])' % _family_punc).sub, '')
+_family_escape = partial(re.compile(r'(?=[%s])' % _family_punc).sub, r'\\')
+_value_punc = r'\\=_:,'
+_value_unescape = partial(re.compile(r'\\(?=[%s])' % _value_punc).sub, '')
+_value_escape = partial(re.compile(r'(?=[%s])' % _value_punc).sub, r'\\')
+
+
+_CONSTANTS = {
+    'thin':           ('weight', 'light'),
+    'extralight':     ('weight', 'light'),
+    'ultralight':     ('weight', 'light'),
+    'light':          ('weight', 'light'),
+    'book':           ('weight', 'book'),
+    'regular':        ('weight', 'regular'),
+    'normal':         ('weight', 'normal'),
+    'medium':         ('weight', 'medium'),
+    'demibold':       ('weight', 'demibold'),
+    'semibold':       ('weight', 'semibold'),
+    'bold':           ('weight', 'bold'),
+    'extrabold':      ('weight', 'extra bold'),
+    'black':          ('weight', 'black'),
+    'heavy':          ('weight', 'heavy'),
+    'roman':          ('slant', 'normal'),
+    'italic':         ('slant', 'italic'),
+    'oblique':        ('slant', 'oblique'),
+    'ultracondensed': ('width', 'ultra-condensed'),
+    'extracondensed': ('width', 'extra-condensed'),
+    'condensed':      ('width', 'condensed'),
+    'semicondensed':  ('width', 'semi-condensed'),
+    'expanded':       ('width', 'expanded'),
+    'extraexpanded':  ('width', 'extra-expanded'),
+    'ultraexpanded':  ('width', 'ultra-expanded'),
+}
+
+
+@lru_cache  # The parser instance is a singleton.
+def _make_fontconfig_parser():
+    def comma_separated(elem):
+        return elem + ZeroOrMore(Suppress(",") + elem)
+
+    family = Regex(fr"([^{_family_punc}]|(\\[{_family_punc}]))*")
+    size = Regex(r"([0-9]+\.?[0-9]*|\.[0-9]+)")
+    name = Regex(r"[a-z]+")
+    value = Regex(fr"([^{_value_punc}]|(\\[{_value_punc}]))*")
+    prop = Group((name + Suppress("=") + comma_separated(value)) | one_of(_CONSTANTS))
+    return (
+        Optional(comma_separated(family)("families"))
+        + Optional("-" + comma_separated(size)("sizes"))
+        + ZeroOrMore(":" + prop("properties*"))
+        + StringEnd()
+    )
+
+
+# `parse_fontconfig_pattern` is a bottleneck during the tests because it is
+# repeatedly called when the rcParams are reset (to validate the default
+# fonts).  In practice, the cache size doesn't grow beyond a few dozen entries
+# during the test suite.
+@lru_cache
+def parse_fontconfig_pattern(pattern):
+    """
+    Parse a fontconfig *pattern* into a dict that can initialize a
+    `.font_manager.FontProperties` object.
+    """
+    parser = _make_fontconfig_parser()
+    try:
+        parse = parser.parse_string(pattern)
+    except ParseException as err:
+        # explain becomes a plain method on pyparsing 3 (err.explain(0)).
+        raise ValueError("\n" + ParseException.explain(err, 0)) from None
+    parser.reset_cache()
+    props = {}
+    if "families" in parse:
+        props["family"] = [*map(_family_unescape, parse["families"])]
+    if "sizes" in parse:
+        props["size"] = [*parse["sizes"]]
+    for prop in parse.get("properties", []):
+        if len(prop) == 1:
+            prop = _CONSTANTS[prop[0]]
+        k, *v = prop
+        props.setdefault(k, []).extend(map(_value_unescape, v))
+    return props
+
+
+def generate_fontconfig_pattern(d):
+    """Convert a `.FontProperties` to a fontconfig pattern string."""
+    kvs = [(k, getattr(d, f"get_{k}")())
+           for k in ["style", "variant", "weight", "stretch", "file", "size"]]
+    # Families is given first without a leading keyword.  Other entries (which
+    # are necessarily scalar) are given as key=value, skipping Nones.
+    return (",".join(_family_escape(f) for f in d.get_family())
+            + "".join(f":{k}={_value_escape(str(v))}"
+                      for k, v in kvs if v is not None))

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_internal_utils.py

@@ -0,0 +1,64 @@
+"""
+Internal debugging utilities, that are not expected to be used in the rest of
+the codebase.
+
+WARNING: Code in this module may change without prior notice!
+"""
+
+from io import StringIO
+from pathlib import Path
+import subprocess
+
+from matplotlib.transforms import TransformNode
+
+
+def graphviz_dump_transform(transform, dest, *, highlight=None):
+    """
+    Generate a graphical representation of the transform tree for *transform*
+    using the :program:`dot` program (which this function depends on).  The
+    output format (png, dot, etc.) is determined from the suffix of *dest*.
+
+    Parameters
+    ----------
+    transform : `~matplotlib.transform.Transform`
+        The represented transform.
+    dest : str
+        Output filename.  The extension must be one of the formats supported
+        by :program:`dot`, e.g. png, svg, dot, ...
+        (see https://www.graphviz.org/doc/info/output.html).
+    highlight : list of `~matplotlib.transform.Transform` or None
+        The transforms in the tree to be drawn in bold.
+        If *None*, *transform* is highlighted.
+    """
+
+    if highlight is None:
+        highlight = [transform]
+    seen = set()
+
+    def recurse(root, buf):
+        if id(root) in seen:
+            return
+        seen.add(id(root))
+        props = {}
+        label = type(root).__name__
+        if root._invalid:
+            label = f'[{label}]'
+        if root in highlight:
+            props['style'] = 'bold'
+        props['shape'] = 'box'
+        props['label'] = '"%s"' % label
+        props = ' '.join(map('{0[0]}={0[1]}'.format, props.items()))
+        buf.write(f'{id(root)} [{props}];\n')
+        for key, val in vars(root).items():
+            if isinstance(val, TransformNode) and id(root) in val._parents:
+                buf.write(f'"{id(root)}" -> "{id(val)}" '
+                          f'[label="{key}", fontsize=10];\n')
+                recurse(val, buf)
+
+    buf = StringIO()
+    buf.write('digraph G {\n')
+    recurse(transform, buf)
+    buf.write('}\n')
+    subprocess.run(
+        ['dot', '-T', Path(dest).suffix[1:], '-o', dest],
+        input=buf.getvalue().encode('utf-8'), check=True)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_layoutgrid.py

@@ -0,0 +1,547 @@
+"""
+A layoutgrid is a nrows by ncols set of boxes, meant to be used by
+`._constrained_layout`, each box is analogous to a subplotspec element of
+a gridspec.
+
+Each box is defined by left[ncols], right[ncols], bottom[nrows] and top[nrows],
+and by two editable margins for each side.  The main margin gets its value
+set by the size of ticklabels, titles, etc on each Axes that is in the figure.
+The outer margin is the padding around the Axes, and space for any
+colorbars.
+
+The "inner" widths and heights of these boxes are then constrained to be the
+same (relative the values of `width_ratios[ncols]` and `height_ratios[nrows]`).
+
+The layoutgrid is then constrained to be contained within a parent layoutgrid,
+its column(s) and row(s) specified when it is created.
+"""
+
+import itertools
+import kiwisolver as kiwi
+import logging
+import numpy as np
+
+import matplotlib as mpl
+import matplotlib.patches as mpatches
+from matplotlib.transforms import Bbox
+
+_log = logging.getLogger(__name__)
+
+
+class LayoutGrid:
+    """
+    Analogous to a gridspec, and contained in another LayoutGrid.
+    """
+
+    def __init__(self, parent=None, parent_pos=(0, 0),
+                 parent_inner=False, name='', ncols=1, nrows=1,
+                 h_pad=None, w_pad=None, width_ratios=None,
+                 height_ratios=None):
+        Variable = kiwi.Variable
+        self.parent_pos = parent_pos
+        self.parent_inner = parent_inner
+        self.name = name + seq_id()
+        if isinstance(parent, LayoutGrid):
+            self.name = f'{parent.name}.{self.name}'
+        self.nrows = nrows
+        self.ncols = ncols
+        self.height_ratios = np.atleast_1d(height_ratios)
+        if height_ratios is None:
+            self.height_ratios = np.ones(nrows)
+        self.width_ratios = np.atleast_1d(width_ratios)
+        if width_ratios is None:
+            self.width_ratios = np.ones(ncols)
+
+        sn = self.name + '_'
+        if not isinstance(parent, LayoutGrid):
+            # parent can be a rect if not a LayoutGrid
+            # allows specifying a rectangle to contain the layout.
+            self.solver = kiwi.Solver()
+        else:
+            parent.add_child(self, *parent_pos)
+            self.solver = parent.solver
+        # keep track of artist associated w/ this layout.  Can be none
+        self.artists = np.empty((nrows, ncols), dtype=object)
+        self.children = np.empty((nrows, ncols), dtype=object)
+
+        self.margins = {}
+        self.margin_vals = {}
+        # all the boxes in each column share the same left/right margins:
+        for todo in ['left', 'right', 'leftcb', 'rightcb']:
+            # track the value so we can change only if a margin is larger
+            # than the current value
+            self.margin_vals[todo] = np.zeros(ncols)
+
+        sol = self.solver
+
+        self.lefts = [Variable(f'{sn}lefts[{i}]') for i in range(ncols)]
+        self.rights = [Variable(f'{sn}rights[{i}]') for i in range(ncols)]
+        for todo in ['left', 'right', 'leftcb', 'rightcb']:
+            self.margins[todo] = [Variable(f'{sn}margins[{todo}][{i}]')
+                                  for i in range(ncols)]
+            for i in range(ncols):
+                sol.addEditVariable(self.margins[todo][i], 'strong')
+
+        for todo in ['bottom', 'top', 'bottomcb', 'topcb']:
+            self.margins[todo] = np.empty((nrows), dtype=object)
+            self.margin_vals[todo] = np.zeros(nrows)
+
+        self.bottoms = [Variable(f'{sn}bottoms[{i}]') for i in range(nrows)]
+        self.tops = [Variable(f'{sn}tops[{i}]') for i in range(nrows)]
+        for todo in ['bottom', 'top', 'bottomcb', 'topcb']:
+            self.margins[todo] = [Variable(f'{sn}margins[{todo}][{i}]')
+                                  for i in range(nrows)]
+            for i in range(nrows):
+                sol.addEditVariable(self.margins[todo][i], 'strong')
+
+        # set these margins to zero by default. They will be edited as
+        # children are filled.
+        self.reset_margins()
+        self.add_constraints(parent)
+
+        self.h_pad = h_pad
+        self.w_pad = w_pad
+
+    def __repr__(self):
+        str = f'LayoutBox: {self.name:25s} {self.nrows}x{self.ncols},\n'
+        for i in range(self.nrows):
+            for j in range(self.ncols):
+                str += f'{i}, {j}: '\
+                       f'L{self.lefts[j].value():1.3f}, ' \
+                       f'B{self.bottoms[i].value():1.3f}, ' \
+                       f'R{self.rights[j].value():1.3f}, ' \
+                       f'T{self.tops[i].value():1.3f}, ' \
+                       f'ML{self.margins["left"][j].value():1.3f}, ' \
+                       f'MR{self.margins["right"][j].value():1.3f}, ' \
+                       f'MB{self.margins["bottom"][i].value():1.3f}, ' \
+                       f'MT{self.margins["top"][i].value():1.3f}, \n'
+        return str
+
+    def reset_margins(self):
+        """
+        Reset all the margins to zero.  Must do this after changing
+        figure size, for instance, because the relative size of the
+        axes labels etc changes.
+        """
+        for todo in ['left', 'right', 'bottom', 'top',
+                     'leftcb', 'rightcb', 'bottomcb', 'topcb']:
+            self.edit_margins(todo, 0.0)
+
+    def add_constraints(self, parent):
+        # define self-consistent constraints
+        self.hard_constraints()
+        # define relationship with parent layoutgrid:
+        self.parent_constraints(parent)
+        # define relative widths of the grid cells to each other
+        # and stack horizontally and vertically.
+        self.grid_constraints()
+
+    def hard_constraints(self):
+        """
+        These are the redundant constraints, plus ones that make the
+        rest of the code easier.
+        """
+        for i in range(self.ncols):
+            hc = [self.rights[i] >= self.lefts[i],
+                  (self.rights[i] - self.margins['right'][i] -
+                    self.margins['rightcb'][i] >=
+                    self.lefts[i] - self.margins['left'][i] -
+                    self.margins['leftcb'][i])
+                  ]
+            for c in hc:
+                self.solver.addConstraint(c | 'required')
+
+        for i in range(self.nrows):
+            hc = [self.tops[i] >= self.bottoms[i],
+                  (self.tops[i] - self.margins['top'][i] -
+                    self.margins['topcb'][i] >=
+                    self.bottoms[i] - self.margins['bottom'][i] -
+                    self.margins['bottomcb'][i])
+                  ]
+            for c in hc:
+                self.solver.addConstraint(c | 'required')
+
+    def add_child(self, child, i=0, j=0):
+        # np.ix_ returns the cross product of i and j indices
+        self.children[np.ix_(np.atleast_1d(i), np.atleast_1d(j))] = child
+
+    def parent_constraints(self, parent):
+        # constraints that are due to the parent...
+        # i.e. the first column's left is equal to the
+        # parent's left, the last column right equal to the
+        # parent's right...
+        if not isinstance(parent, LayoutGrid):
+            # specify a rectangle in figure coordinates
+            hc = [self.lefts[0] == parent[0],
+                  self.rights[-1] == parent[0] + parent[2],
+                  # top and bottom reversed order...
+                  self.tops[0] == parent[1] + parent[3],
+                  self.bottoms[-1] == parent[1]]
+        else:
+            rows, cols = self.parent_pos
+            rows = np.atleast_1d(rows)
+            cols = np.atleast_1d(cols)
+
+            left = parent.lefts[cols[0]]
+            right = parent.rights[cols[-1]]
+            top = parent.tops[rows[0]]
+            bottom = parent.bottoms[rows[-1]]
+            if self.parent_inner:
+                # the layout grid is contained inside the inner
+                # grid of the parent.
+                left += parent.margins['left'][cols[0]]
+                left += parent.margins['leftcb'][cols[0]]
+                right -= parent.margins['right'][cols[-1]]
+                right -= parent.margins['rightcb'][cols[-1]]
+                top -= parent.margins['top'][rows[0]]
+                top -= parent.margins['topcb'][rows[0]]
+                bottom += parent.margins['bottom'][rows[-1]]
+                bottom += parent.margins['bottomcb'][rows[-1]]
+            hc = [self.lefts[0] == left,
+                  self.rights[-1] == right,
+                  # from top to bottom
+                  self.tops[0] == top,
+                  self.bottoms[-1] == bottom]
+        for c in hc:
+            self.solver.addConstraint(c | 'required')
+
+    def grid_constraints(self):
+        # constrain the ratio of the inner part of the grids
+        # to be the same (relative to width_ratios)
+
+        # constrain widths:
+        w = (self.rights[0] - self.margins['right'][0] -
+             self.margins['rightcb'][0])
+        w = (w - self.lefts[0] - self.margins['left'][0] -
+             self.margins['leftcb'][0])
+        w0 = w / self.width_ratios[0]
+        # from left to right
+        for i in range(1, self.ncols):
+            w = (self.rights[i] - self.margins['right'][i] -
+                 self.margins['rightcb'][i])
+            w = (w - self.lefts[i] - self.margins['left'][i] -
+                 self.margins['leftcb'][i])
+            c = (w == w0 * self.width_ratios[i])
+            self.solver.addConstraint(c | 'strong')
+            # constrain the grid cells to be directly next to each other.
+            c = (self.rights[i - 1] == self.lefts[i])
+            self.solver.addConstraint(c | 'strong')
+
+        # constrain heights:
+        h = self.tops[0] - self.margins['top'][0] - self.margins['topcb'][0]
+        h = (h - self.bottoms[0] - self.margins['bottom'][0] -
+             self.margins['bottomcb'][0])
+        h0 = h / self.height_ratios[0]
+        # from top to bottom:
+        for i in range(1, self.nrows):
+            h = (self.tops[i] - self.margins['top'][i] -
+                 self.margins['topcb'][i])
+            h = (h - self.bottoms[i] - self.margins['bottom'][i] -
+                 self.margins['bottomcb'][i])
+            c = (h == h0 * self.height_ratios[i])
+            self.solver.addConstraint(c | 'strong')
+            # constrain the grid cells to be directly above each other.
+            c = (self.bottoms[i - 1] == self.tops[i])
+            self.solver.addConstraint(c | 'strong')
+
+    # Margin editing:  The margins are variable and meant to
+    # contain things of a fixed size like axes labels, tick labels, titles
+    # etc
+    def edit_margin(self, todo, size, cell):
+        """
+        Change the size of the margin for one cell.
+
+        Parameters
+        ----------
+        todo : string (one of 'left', 'right', 'bottom', 'top')
+            margin to alter.
+
+        size : float
+            Size of the margin.  If it is larger than the existing minimum it
+            updates the margin size. Fraction of figure size.
+
+        cell : int
+            Cell column or row to edit.
+        """
+        self.solver.suggestValue(self.margins[todo][cell], size)
+        self.margin_vals[todo][cell] = size
+
+    def edit_margin_min(self, todo, size, cell=0):
+        """
+        Change the minimum size of the margin for one cell.
+
+        Parameters
+        ----------
+        todo : string (one of 'left', 'right', 'bottom', 'top')
+            margin to alter.
+
+        size : float
+            Minimum size of the margin .  If it is larger than the
+            existing minimum it updates the margin size. Fraction of
+            figure size.
+
+        cell : int
+            Cell column or row to edit.
+        """
+
+        if size > self.margin_vals[todo][cell]:
+            self.edit_margin(todo, size, cell)
+
+    def edit_margins(self, todo, size):
+        """
+        Change the size of all the margin of all the cells in the layout grid.
+
+        Parameters
+        ----------
+        todo : string (one of 'left', 'right', 'bottom', 'top')
+            margin to alter.
+
+        size : float
+            Size to set the margins.  Fraction of figure size.
+        """
+
+        for i in range(len(self.margin_vals[todo])):
+            self.edit_margin(todo, size, i)
+
+    def edit_all_margins_min(self, todo, size):
+        """
+        Change the minimum size of all the margin of all
+        the cells in the layout grid.
+
+        Parameters
+        ----------
+        todo : {'left', 'right', 'bottom', 'top'}
+            The margin to alter.
+
+        size : float
+            Minimum size of the margin.  If it is larger than the
+            existing minimum it updates the margin size. Fraction of
+            figure size.
+        """
+
+        for i in range(len(self.margin_vals[todo])):
+            self.edit_margin_min(todo, size, i)
+
+    def edit_outer_margin_mins(self, margin, ss):
+        """
+        Edit all four margin minimums in one statement.
+
+        Parameters
+        ----------
+        margin : dict
+            size of margins in a dict with keys 'left', 'right', 'bottom',
+            'top'
+
+        ss : SubplotSpec
+            defines the subplotspec these margins should be applied to
+        """
+
+        self.edit_margin_min('left', margin['left'], ss.colspan.start)
+        self.edit_margin_min('leftcb', margin['leftcb'], ss.colspan.start)
+        self.edit_margin_min('right', margin['right'], ss.colspan.stop - 1)
+        self.edit_margin_min('rightcb', margin['rightcb'], ss.colspan.stop - 1)
+        # rows are from the top down:
+        self.edit_margin_min('top', margin['top'], ss.rowspan.start)
+        self.edit_margin_min('topcb', margin['topcb'], ss.rowspan.start)
+        self.edit_margin_min('bottom', margin['bottom'], ss.rowspan.stop - 1)
+        self.edit_margin_min('bottomcb', margin['bottomcb'],
+                             ss.rowspan.stop - 1)
+
+    def get_margins(self, todo, col):
+        """Return the margin at this position"""
+        return self.margin_vals[todo][col]
+
+    def get_outer_bbox(self, rows=0, cols=0):
+        """
+        Return the outer bounding box of the subplot specs
+        given by rows and cols.  rows and cols can be spans.
+        """
+        rows = np.atleast_1d(rows)
+        cols = np.atleast_1d(cols)
+
+        bbox = Bbox.from_extents(
+            self.lefts[cols[0]].value(),
+            self.bottoms[rows[-1]].value(),
+            self.rights[cols[-1]].value(),
+            self.tops[rows[0]].value())
+        return bbox
+
+    def get_inner_bbox(self, rows=0, cols=0):
+        """
+        Return the inner bounding box of the subplot specs
+        given by rows and cols.  rows and cols can be spans.
+        """
+        rows = np.atleast_1d(rows)
+        cols = np.atleast_1d(cols)
+
+        bbox = Bbox.from_extents(
+            (self.lefts[cols[0]].value() +
+                self.margins['left'][cols[0]].value() +
+                self.margins['leftcb'][cols[0]].value()),
+            (self.bottoms[rows[-1]].value() +
+                self.margins['bottom'][rows[-1]].value() +
+                self.margins['bottomcb'][rows[-1]].value()),
+            (self.rights[cols[-1]].value() -
+                self.margins['right'][cols[-1]].value() -
+                self.margins['rightcb'][cols[-1]].value()),
+            (self.tops[rows[0]].value() -
+                self.margins['top'][rows[0]].value() -
+                self.margins['topcb'][rows[0]].value())
+        )
+        return bbox
+
+    def get_bbox_for_cb(self, rows=0, cols=0):
+        """
+        Return the bounding box that includes the
+        decorations but, *not* the colorbar...
+        """
+        rows = np.atleast_1d(rows)
+        cols = np.atleast_1d(cols)
+
+        bbox = Bbox.from_extents(
+            (self.lefts[cols[0]].value() +
+                self.margins['leftcb'][cols[0]].value()),
+            (self.bottoms[rows[-1]].value() +
+                self.margins['bottomcb'][rows[-1]].value()),
+            (self.rights[cols[-1]].value() -
+                self.margins['rightcb'][cols[-1]].value()),
+            (self.tops[rows[0]].value() -
+                self.margins['topcb'][rows[0]].value())
+        )
+        return bbox
+
+    def get_left_margin_bbox(self, rows=0, cols=0):
+        """
+        Return the left margin bounding box of the subplot specs
+        given by rows and cols.  rows and cols can be spans.
+        """
+        rows = np.atleast_1d(rows)
+        cols = np.atleast_1d(cols)
+
+        bbox = Bbox.from_extents(
+            (self.lefts[cols[0]].value() +
+                self.margins['leftcb'][cols[0]].value()),
+            (self.bottoms[rows[-1]].value()),
+            (self.lefts[cols[0]].value() +
+                self.margins['leftcb'][cols[0]].value() +
+                self.margins['left'][cols[0]].value()),
+            (self.tops[rows[0]].value()))
+        return bbox
+
+    def get_bottom_margin_bbox(self, rows=0, cols=0):
+        """
+        Return the left margin bounding box of the subplot specs
+        given by rows and cols.  rows and cols can be spans.
+        """
+        rows = np.atleast_1d(rows)
+        cols = np.atleast_1d(cols)
+
+        bbox = Bbox.from_extents(
+            (self.lefts[cols[0]].value()),
+            (self.bottoms[rows[-1]].value() +
+             self.margins['bottomcb'][rows[-1]].value()),
+            (self.rights[cols[-1]].value()),
+            (self.bottoms[rows[-1]].value() +
+                self.margins['bottom'][rows[-1]].value() +
+             self.margins['bottomcb'][rows[-1]].value()
+             ))
+        return bbox
+
+    def get_right_margin_bbox(self, rows=0, cols=0):
+        """
+        Return the left margin bounding box of the subplot specs
+        given by rows and cols.  rows and cols can be spans.
+        """
+        rows = np.atleast_1d(rows)
+        cols = np.atleast_1d(cols)
+
+        bbox = Bbox.from_extents(
+            (self.rights[cols[-1]].value() -
+                self.margins['right'][cols[-1]].value() -
+                self.margins['rightcb'][cols[-1]].value()),
+            (self.bottoms[rows[-1]].value()),
+            (self.rights[cols[-1]].value() -
+                self.margins['rightcb'][cols[-1]].value()),
+            (self.tops[rows[0]].value()))
+        return bbox
+
+    def get_top_margin_bbox(self, rows=0, cols=0):
+        """
+        Return the left margin bounding box of the subplot specs
+        given by rows and cols.  rows and cols can be spans.
+        """
+        rows = np.atleast_1d(rows)
+        cols = np.atleast_1d(cols)
+
+        bbox = Bbox.from_extents(
+            (self.lefts[cols[0]].value()),
+            (self.tops[rows[0]].value() -
+                self.margins['topcb'][rows[0]].value()),
+            (self.rights[cols[-1]].value()),
+            (self.tops[rows[0]].value() -
+                self.margins['topcb'][rows[0]].value() -
+                self.margins['top'][rows[0]].value()))
+        return bbox
+
+    def update_variables(self):
+        """
+        Update the variables for the solver attached to this layoutgrid.
+        """
+        self.solver.updateVariables()
+
+_layoutboxobjnum = itertools.count()
+
+
+def seq_id():
+    """Generate a short sequential id for layoutbox objects."""
+    return '%06d' % next(_layoutboxobjnum)
+
+
+def plot_children(fig, lg=None, level=0):
+    """Simple plotting to show where boxes are."""
+    if lg is None:
+        _layoutgrids = fig.get_layout_engine().execute(fig)
+        lg = _layoutgrids[fig]
+    colors = mpl.rcParams["axes.prop_cycle"].by_key()["color"]
+    col = colors[level]
+    for i in range(lg.nrows):
+        for j in range(lg.ncols):
+            bb = lg.get_outer_bbox(rows=i, cols=j)
+            fig.add_artist(
+                mpatches.Rectangle(bb.p0, bb.width, bb.height, linewidth=1,
+                                   edgecolor='0.7', facecolor='0.7',
+                                   alpha=0.2, transform=fig.transFigure,
+                                   zorder=-3))
+            bbi = lg.get_inner_bbox(rows=i, cols=j)
+            fig.add_artist(
+                mpatches.Rectangle(bbi.p0, bbi.width, bbi.height, linewidth=2,
+                                   edgecolor=col, facecolor='none',
+                                   transform=fig.transFigure, zorder=-2))
+
+            bbi = lg.get_left_margin_bbox(rows=i, cols=j)
+            fig.add_artist(
+                mpatches.Rectangle(bbi.p0, bbi.width, bbi.height, linewidth=0,
+                                   edgecolor='none', alpha=0.2,
+                                   facecolor=[0.5, 0.7, 0.5],
+                                   transform=fig.transFigure, zorder=-2))
+            bbi = lg.get_right_margin_bbox(rows=i, cols=j)
+            fig.add_artist(
+                mpatches.Rectangle(bbi.p0, bbi.width, bbi.height, linewidth=0,
+                                   edgecolor='none', alpha=0.2,
+                                   facecolor=[0.7, 0.5, 0.5],
+                                   transform=fig.transFigure, zorder=-2))
+            bbi = lg.get_bottom_margin_bbox(rows=i, cols=j)
+            fig.add_artist(
+                mpatches.Rectangle(bbi.p0, bbi.width, bbi.height, linewidth=0,
+                                   edgecolor='none', alpha=0.2,
+                                   facecolor=[0.5, 0.5, 0.7],
+                                   transform=fig.transFigure, zorder=-2))
+            bbi = lg.get_top_margin_bbox(rows=i, cols=j)
+            fig.add_artist(
+                mpatches.Rectangle(bbi.p0, bbi.width, bbi.height, linewidth=0,
+                                   edgecolor='none', alpha=0.2,
+                                   facecolor=[0.7, 0.2, 0.7],
+                                   transform=fig.transFigure, zorder=-2))
+    for ch in lg.children.flat:
+        if ch is not None:
+            plot_children(fig, ch, level=level+1)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_mathtext_data.py

@@ -0,0 +1,1742 @@
+"""
+font data tables for truetype and afm computer modern fonts
+"""
+
+from __future__ import annotations
+from typing import overload
+
+latex_to_bakoma = {
+    '\\__sqrt__'                 : ('cmex10', 0x70),
+    '\\bigcap'                   : ('cmex10', 0x5c),
+    '\\bigcup'                   : ('cmex10', 0x5b),
+    '\\bigodot'                  : ('cmex10', 0x4b),
+    '\\bigoplus'                 : ('cmex10', 0x4d),
+    '\\bigotimes'                : ('cmex10', 0x4f),
+    '\\biguplus'                 : ('cmex10', 0x5d),
+    '\\bigvee'                   : ('cmex10', 0x5f),
+    '\\bigwedge'                 : ('cmex10', 0x5e),
+    '\\coprod'                   : ('cmex10', 0x61),
+    '\\int'                      : ('cmex10', 0x5a),
+    '\\langle'                   : ('cmex10', 0xad),
+    '\\leftangle'                : ('cmex10', 0xad),
+    '\\leftbrace'                : ('cmex10', 0xa9),
+    '\\oint'                     : ('cmex10', 0x49),
+    '\\prod'                     : ('cmex10', 0x59),
+    '\\rangle'                   : ('cmex10', 0xae),
+    '\\rightangle'               : ('cmex10', 0xae),
+    '\\rightbrace'               : ('cmex10', 0xaa),
+    '\\sum'                      : ('cmex10', 0x58),
+    '\\widehat'                  : ('cmex10', 0x62),
+    '\\widetilde'                : ('cmex10', 0x65),
+    '\\{'                        : ('cmex10', 0xa9),
+    '\\}'                        : ('cmex10', 0xaa),
+    '{'                          : ('cmex10', 0xa9),
+    '}'                          : ('cmex10', 0xaa),
+
+    ','                          : ('cmmi10', 0x3b),
+    '.'                          : ('cmmi10', 0x3a),
+    '/'                          : ('cmmi10', 0x3d),
+    '<'                          : ('cmmi10', 0x3c),
+    '>'                          : ('cmmi10', 0x3e),
+    '\\alpha'                    : ('cmmi10', 0xae),
+    '\\beta'                     : ('cmmi10', 0xaf),
+    '\\chi'                      : ('cmmi10', 0xc2),
+    '\\combiningrightarrowabove' : ('cmmi10', 0x7e),
+    '\\delta'                    : ('cmmi10', 0xb1),
+    '\\ell'                      : ('cmmi10', 0x60),
+    '\\epsilon'                  : ('cmmi10', 0xb2),
+    '\\eta'                      : ('cmmi10', 0xb4),
+    '\\flat'                     : ('cmmi10', 0x5b),
+    '\\frown'                    : ('cmmi10', 0x5f),
+    '\\gamma'                    : ('cmmi10', 0xb0),
+    '\\imath'                    : ('cmmi10', 0x7b),
+    '\\iota'                     : ('cmmi10', 0xb6),
+    '\\jmath'                    : ('cmmi10', 0x7c),
+    '\\kappa'                    : ('cmmi10', 0x2219),
+    '\\lambda'                   : ('cmmi10', 0xb8),
+    '\\leftharpoondown'          : ('cmmi10', 0x29),
+    '\\leftharpoonup'            : ('cmmi10', 0x28),
+    '\\mu'                       : ('cmmi10', 0xb9),
+    '\\natural'                  : ('cmmi10', 0x5c),
+    '\\nu'                       : ('cmmi10', 0xba),
+    '\\omega'                    : ('cmmi10', 0x21),
+    '\\phi'                      : ('cmmi10', 0xc1),
+    '\\pi'                       : ('cmmi10', 0xbc),
+    '\\psi'                      : ('cmmi10', 0xc3),
+    '\\rho'                      : ('cmmi10', 0xbd),
+    '\\rightharpoondown'         : ('cmmi10', 0x2b),
+    '\\rightharpoonup'           : ('cmmi10', 0x2a),
+    '\\sharp'                    : ('cmmi10', 0x5d),
+    '\\sigma'                    : ('cmmi10', 0xbe),
+    '\\smile'                    : ('cmmi10', 0x5e),
+    '\\tau'                      : ('cmmi10', 0xbf),
+    '\\theta'                    : ('cmmi10', 0xb5),
+    '\\triangleleft'             : ('cmmi10', 0x2f),
+    '\\triangleright'            : ('cmmi10', 0x2e),
+    '\\upsilon'                  : ('cmmi10', 0xc0),
+    '\\varepsilon'               : ('cmmi10', 0x22),
+    '\\varphi'                   : ('cmmi10', 0x27),
+    '\\varrho'                   : ('cmmi10', 0x25),
+    '\\varsigma'                 : ('cmmi10', 0x26),
+    '\\vartheta'                 : ('cmmi10', 0x23),
+    '\\wp'                       : ('cmmi10', 0x7d),
+    '\\xi'                       : ('cmmi10', 0xbb),
+    '\\zeta'                     : ('cmmi10', 0xb3),
+
+    '!'                          : ('cmr10', 0x21),
+    '%'                          : ('cmr10', 0x25),
+    '&'                          : ('cmr10', 0x26),
+    '('                          : ('cmr10', 0x28),
+    ')'                          : ('cmr10', 0x29),
+    '+'                          : ('cmr10', 0x2b),
+    '0'                          : ('cmr10', 0x30),
+    '1'                          : ('cmr10', 0x31),
+    '2'                          : ('cmr10', 0x32),
+    '3'                          : ('cmr10', 0x33),
+    '4'                          : ('cmr10', 0x34),
+    '5'                          : ('cmr10', 0x35),
+    '6'                          : ('cmr10', 0x36),
+    '7'                          : ('cmr10', 0x37),
+    '8'                          : ('cmr10', 0x38),
+    '9'                          : ('cmr10', 0x39),
+    ':'                          : ('cmr10', 0x3a),
+    ';'                          : ('cmr10', 0x3b),
+    '='                          : ('cmr10', 0x3d),
+    '?'                          : ('cmr10', 0x3f),
+    '@'                          : ('cmr10', 0x40),
+    '['                          : ('cmr10', 0x5b),
+    '\\#'                        : ('cmr10', 0x23),
+    '\\$'                        : ('cmr10', 0x24),
+    '\\%'                        : ('cmr10', 0x25),
+    '\\Delta'                    : ('cmr10', 0xa2),
+    '\\Gamma'                    : ('cmr10', 0xa1),
+    '\\Lambda'                   : ('cmr10', 0xa4),
+    '\\Omega'                    : ('cmr10', 0xad),
+    '\\Phi'                      : ('cmr10', 0xa9),
+    '\\Pi'                       : ('cmr10', 0xa6),
+    '\\Psi'                      : ('cmr10', 0xaa),
+    '\\Sigma'                    : ('cmr10', 0xa7),
+    '\\Theta'                    : ('cmr10', 0xa3),
+    '\\Upsilon'                  : ('cmr10', 0xa8),
+    '\\Xi'                       : ('cmr10', 0xa5),
+    '\\circumflexaccent'         : ('cmr10', 0x5e),
+    '\\combiningacuteaccent'     : ('cmr10', 0xb6),
+    '\\combiningbreve'           : ('cmr10', 0xb8),
+    '\\combiningdiaeresis'       : ('cmr10', 0xc4),
+    '\\combiningdotabove'        : ('cmr10', 0x5f),
+    '\\combininggraveaccent'     : ('cmr10', 0xb5),
+    '\\combiningoverline'        : ('cmr10', 0xb9),
+    '\\combiningtilde'           : ('cmr10', 0x7e),
+    '\\leftbracket'              : ('cmr10', 0x5b),
+    '\\leftparen'                : ('cmr10', 0x28),
+    '\\rightbracket'             : ('cmr10', 0x5d),
+    '\\rightparen'               : ('cmr10', 0x29),
+    '\\widebar'                  : ('cmr10', 0xb9),
+    ']'                          : ('cmr10', 0x5d),
+
+    '*'                          : ('cmsy10', 0xa4),
+    '\N{MINUS SIGN}'             : ('cmsy10', 0xa1),
+    '\\Downarrow'                : ('cmsy10', 0x2b),
+    '\\Im'                       : ('cmsy10', 0x3d),
+    '\\Leftarrow'                : ('cmsy10', 0x28),
+    '\\Leftrightarrow'           : ('cmsy10', 0x2c),
+    '\\P'                        : ('cmsy10', 0x7b),
+    '\\Re'                       : ('cmsy10', 0x3c),
+    '\\Rightarrow'               : ('cmsy10', 0x29),
+    '\\S'                        : ('cmsy10', 0x78),
+    '\\Uparrow'                  : ('cmsy10', 0x2a),
+    '\\Updownarrow'              : ('cmsy10', 0x6d),
+    '\\Vert'                     : ('cmsy10', 0x6b),
+    '\\aleph'                    : ('cmsy10', 0x40),
+    '\\approx'                   : ('cmsy10', 0xbc),
+    '\\ast'                      : ('cmsy10', 0xa4),
+    '\\asymp'                    : ('cmsy10', 0xb3),
+    '\\backslash'                : ('cmsy10', 0x6e),
+    '\\bigcirc'                  : ('cmsy10', 0xb0),
+    '\\bigtriangledown'          : ('cmsy10', 0x35),
+    '\\bigtriangleup'            : ('cmsy10', 0x34),
+    '\\bot'                      : ('cmsy10', 0x3f),
+    '\\bullet'                   : ('cmsy10', 0xb2),
+    '\\cap'                      : ('cmsy10', 0x5c),
+    '\\cdot'                     : ('cmsy10', 0xa2),
+    '\\circ'                     : ('cmsy10', 0xb1),
+    '\\clubsuit'                 : ('cmsy10', 0x7c),
+    '\\cup'                      : ('cmsy10', 0x5b),
+    '\\dag'                      : ('cmsy10', 0x79),
+    '\\dashv'                    : ('cmsy10', 0x61),
+    '\\ddag'                     : ('cmsy10', 0x7a),
+    '\\diamond'                  : ('cmsy10', 0xa6),
+    '\\diamondsuit'              : ('cmsy10', 0x7d),
+    '\\div'                      : ('cmsy10', 0xa5),
+    '\\downarrow'                : ('cmsy10', 0x23),
+    '\\emptyset'                 : ('cmsy10', 0x3b),
+    '\\equiv'                    : ('cmsy10', 0xb4),
+    '\\exists'                   : ('cmsy10', 0x39),
+    '\\forall'                   : ('cmsy10', 0x38),
+    '\\geq'                      : ('cmsy10', 0xb8),
+    '\\gg'                       : ('cmsy10', 0xc0),
+    '\\heartsuit'                : ('cmsy10', 0x7e),
+    '\\in'                       : ('cmsy10', 0x32),
+    '\\infty'                    : ('cmsy10', 0x31),
+    '\\lbrace'                   : ('cmsy10', 0x66),
+    '\\lceil'                    : ('cmsy10', 0x64),
+    '\\leftarrow'                : ('cmsy10', 0xc3),
+    '\\leftrightarrow'           : ('cmsy10', 0x24),
+    '\\leq'                      : ('cmsy10', 0x2219),
+    '\\lfloor'                   : ('cmsy10', 0x62),
+    '\\ll'                       : ('cmsy10', 0xbf),
+    '\\mid'                      : ('cmsy10', 0x6a),
+    '\\mp'                       : ('cmsy10', 0xa8),
+    '\\nabla'                    : ('cmsy10', 0x72),
+    '\\nearrow'                  : ('cmsy10', 0x25),
+    '\\neg'                      : ('cmsy10', 0x3a),
+    '\\ni'                       : ('cmsy10', 0x33),
+    '\\nwarrow'                  : ('cmsy10', 0x2d),
+    '\\odot'                     : ('cmsy10', 0xaf),
+    '\\ominus'                   : ('cmsy10', 0xaa),
+    '\\oplus'                    : ('cmsy10', 0xa9),
+    '\\oslash'                   : ('cmsy10', 0xae),
+    '\\otimes'                   : ('cmsy10', 0xad),
+    '\\pm'                       : ('cmsy10', 0xa7),
+    '\\prec'                     : ('cmsy10', 0xc1),
+    '\\preceq'                   : ('cmsy10', 0xb9),
+    '\\prime'                    : ('cmsy10', 0x30),
+    '\\propto'                   : ('cmsy10', 0x2f),
+    '\\rbrace'                   : ('cmsy10', 0x67),
+    '\\rceil'                    : ('cmsy10', 0x65),
+    '\\rfloor'                   : ('cmsy10', 0x63),
+    '\\rightarrow'               : ('cmsy10', 0x21),
+    '\\searrow'                  : ('cmsy10', 0x26),
+    '\\sim'                      : ('cmsy10', 0xbb),
+    '\\simeq'                    : ('cmsy10', 0x27),
+    '\\slash'                    : ('cmsy10', 0x36),
+    '\\spadesuit'                : ('cmsy10', 0xc4),
+    '\\sqcap'                    : ('cmsy10', 0x75),
+    '\\sqcup'                    : ('cmsy10', 0x74),
+    '\\sqsubseteq'               : ('cmsy10', 0x76),
+    '\\sqsupseteq'               : ('cmsy10', 0x77),
+    '\\subset'                   : ('cmsy10', 0xbd),
+    '\\subseteq'                 : ('cmsy10', 0xb5),
+    '\\succ'                     : ('cmsy10', 0xc2),
+    '\\succeq'                   : ('cmsy10', 0xba),
+    '\\supset'                   : ('cmsy10', 0xbe),
+    '\\supseteq'                 : ('cmsy10', 0xb6),
+    '\\swarrow'                  : ('cmsy10', 0x2e),
+    '\\times'                    : ('cmsy10', 0xa3),
+    '\\to'                       : ('cmsy10', 0x21),
+    '\\top'                      : ('cmsy10', 0x3e),
+    '\\uparrow'                  : ('cmsy10', 0x22),
+    '\\updownarrow'              : ('cmsy10', 0x6c),
+    '\\uplus'                    : ('cmsy10', 0x5d),
+    '\\vdash'                    : ('cmsy10', 0x60),
+    '\\vee'                      : ('cmsy10', 0x5f),
+    '\\vert'                     : ('cmsy10', 0x6a),
+    '\\wedge'                    : ('cmsy10', 0x5e),
+    '\\wr'                       : ('cmsy10', 0x6f),
+    '\\|'                        : ('cmsy10', 0x6b),
+    '|'                          : ('cmsy10', 0x6a),
+
+    '\\_'                        : ('cmtt10', 0x5f)
+}
+
+# Automatically generated.
+
+type12uni = {
+    'aring'          : 229,
+    'quotedblright'  : 8221,
+    'V'              : 86,
+    'dollar'         : 36,
+    'four'           : 52,
+    'Yacute'         : 221,
+    'P'              : 80,
+    'underscore'     : 95,
+    'p'              : 112,
+    'Otilde'         : 213,
+    'perthousand'    : 8240,
+    'zero'           : 48,
+    'dotlessi'       : 305,
+    'Scaron'         : 352,
+    'zcaron'         : 382,
+    'egrave'         : 232,
+    'section'        : 167,
+    'Icircumflex'    : 206,
+    'ntilde'         : 241,
+    'ampersand'      : 38,
+    'dotaccent'      : 729,
+    'degree'         : 176,
+    'K'              : 75,
+    'acircumflex'    : 226,
+    'Aring'          : 197,
+    'k'              : 107,
+    'smalltilde'     : 732,
+    'Agrave'         : 192,
+    'divide'         : 247,
+    'ocircumflex'    : 244,
+    'asciitilde'     : 126,
+    'two'            : 50,
+    'E'              : 69,
+    'scaron'         : 353,
+    'F'              : 70,
+    'bracketleft'    : 91,
+    'asciicircum'    : 94,
+    'f'              : 102,
+    'ordmasculine'   : 186,
+    'mu'             : 181,
+    'paragraph'      : 182,
+    'nine'           : 57,
+    'v'              : 118,
+    'guilsinglleft'  : 8249,
+    'backslash'      : 92,
+    'six'            : 54,
+    'A'              : 65,
+    'icircumflex'    : 238,
+    'a'              : 97,
+    'ogonek'         : 731,
+    'q'              : 113,
+    'oacute'         : 243,
+    'ograve'         : 242,
+    'edieresis'      : 235,
+    'comma'          : 44,
+    'otilde'         : 245,
+    'guillemotright' : 187,
+    'ecircumflex'    : 234,
+    'greater'        : 62,
+    'uacute'         : 250,
+    'L'              : 76,
+    'bullet'         : 8226,
+    'cedilla'        : 184,
+    'ydieresis'      : 255,
+    'l'              : 108,
+    'logicalnot'     : 172,
+    'exclamdown'     : 161,
+    'endash'         : 8211,
+    'agrave'         : 224,
+    'Adieresis'      : 196,
+    'germandbls'     : 223,
+    'Odieresis'      : 214,
+    'space'          : 32,
+    'quoteright'     : 8217,
+    'ucircumflex'    : 251,
+    'G'              : 71,
+    'quoteleft'      : 8216,
+    'W'              : 87,
+    'Q'              : 81,
+    'g'              : 103,
+    'w'              : 119,
+    'question'       : 63,
+    'one'            : 49,
+    'ring'           : 730,
+    'figuredash'     : 8210,
+    'B'              : 66,
+    'iacute'         : 237,
+    'Ydieresis'      : 376,
+    'R'              : 82,
+    'b'              : 98,
+    'r'              : 114,
+    'Ccedilla'       : 199,
+    'minus'          : 8722,
+    'Lslash'         : 321,
+    'Uacute'         : 218,
+    'yacute'         : 253,
+    'Ucircumflex'    : 219,
+    'quotedbl'       : 34,
+    'onehalf'        : 189,
+    'Thorn'          : 222,
+    'M'              : 77,
+    'eight'          : 56,
+    'multiply'       : 215,
+    'grave'          : 96,
+    'Ocircumflex'    : 212,
+    'm'              : 109,
+    'Ugrave'         : 217,
+    'guilsinglright' : 8250,
+    'Ntilde'         : 209,
+    'questiondown'   : 191,
+    'Atilde'         : 195,
+    'ccedilla'       : 231,
+    'Z'              : 90,
+    'copyright'      : 169,
+    'yen'            : 165,
+    'Eacute'         : 201,
+    'H'              : 72,
+    'X'              : 88,
+    'Idieresis'      : 207,
+    'bar'            : 124,
+    'h'              : 104,
+    'x'              : 120,
+    'udieresis'      : 252,
+    'ordfeminine'    : 170,
+    'braceleft'      : 123,
+    'macron'         : 175,
+    'atilde'         : 227,
+    'Acircumflex'    : 194,
+    'Oslash'         : 216,
+    'C'              : 67,
+    'quotedblleft'   : 8220,
+    'S'              : 83,
+    'exclam'         : 33,
+    'Zcaron'         : 381,
+    'equal'          : 61,
+    's'              : 115,
+    'eth'            : 240,
+    'Egrave'         : 200,
+    'hyphen'         : 45,
+    'period'         : 46,
+    'igrave'         : 236,
+    'colon'          : 58,
+    'Ecircumflex'    : 202,
+    'trademark'      : 8482,
+    'Aacute'         : 193,
+    'cent'           : 162,
+    'lslash'         : 322,
+    'c'              : 99,
+    'N'              : 78,
+    'breve'          : 728,
+    'Oacute'         : 211,
+    'guillemotleft'  : 171,
+    'n'              : 110,
+    'idieresis'      : 239,
+    'braceright'     : 125,
+    'seven'          : 55,
+    'brokenbar'      : 166,
+    'ugrave'         : 249,
+    'periodcentered' : 183,
+    'sterling'       : 163,
+    'I'              : 73,
+    'Y'              : 89,
+    'Eth'            : 208,
+    'emdash'         : 8212,
+    'i'              : 105,
+    'daggerdbl'      : 8225,
+    'y'              : 121,
+    'plusminus'      : 177,
+    'less'           : 60,
+    'Udieresis'      : 220,
+    'D'              : 68,
+    'five'           : 53,
+    'T'              : 84,
+    'oslash'         : 248,
+    'acute'          : 180,
+    'd'              : 100,
+    'OE'             : 338,
+    'Igrave'         : 204,
+    't'              : 116,
+    'parenright'     : 41,
+    'adieresis'      : 228,
+    'quotesingle'    : 39,
+    'twodotenleader' : 8229,
+    'slash'          : 47,
+    'ellipsis'       : 8230,
+    'numbersign'     : 35,
+    'odieresis'      : 246,
+    'O'              : 79,
+    'oe'             : 339,
+    'o'              : 111,
+    'Edieresis'      : 203,
+    'plus'           : 43,
+    'dagger'         : 8224,
+    'three'          : 51,
+    'hungarumlaut'   : 733,
+    'parenleft'      : 40,
+    'fraction'       : 8260,
+    'registered'     : 174,
+    'J'              : 74,
+    'dieresis'       : 168,
+    'Ograve'         : 210,
+    'j'              : 106,
+    'z'              : 122,
+    'ae'             : 230,
+    'semicolon'      : 59,
+    'at'             : 64,
+    'Iacute'         : 205,
+    'percent'        : 37,
+    'bracketright'   : 93,
+    'AE'             : 198,
+    'asterisk'       : 42,
+    'aacute'         : 225,
+    'U'              : 85,
+    'eacute'         : 233,
+    'e'              : 101,
+    'thorn'          : 254,
+    'u'              : 117,
+}
+
+uni2type1 = {v: k for k, v in type12uni.items()}
+
+#  The script below is to sort and format the tex2uni dict
+
+## For decimal values: int(hex(v), 16)
+#  newtex = {k: hex(v) for k, v in tex2uni.items()}
+#  sd = dict(sorted(newtex.items(), key=lambda item: item[0]))
+#
+## For formatting the sorted dictionary with proper spacing
+## the value '24' comes from finding the longest string in
+## the newtex keys with len(max(newtex, key=len))
+#  for key in sd:
+#      print("{0:24} : {1: <s},".format("'" + key + "'", sd[key]))
+
+tex2uni = {
+    '#'                      : 0x23,
+    '$'                      : 0x24,
+    '%'                      : 0x25,
+    'AA'                     : 0xc5,
+    'AE'                     : 0xc6,
+    'BbbC'                   : 0x2102,
+    'BbbN'                   : 0x2115,
+    'BbbP'                   : 0x2119,
+    'BbbQ'                   : 0x211a,
+    'BbbR'                   : 0x211d,
+    'BbbZ'                   : 0x2124,
+    'Bumpeq'                 : 0x224e,
+    'Cap'                    : 0x22d2,
+    'Colon'                  : 0x2237,
+    'Cup'                    : 0x22d3,
+    'DH'                     : 0xd0,
+    'Delta'                  : 0x394,
+    'Doteq'                  : 0x2251,
+    'Downarrow'              : 0x21d3,
+    'Equiv'                  : 0x2263,
+    'Finv'                   : 0x2132,
+    'Game'                   : 0x2141,
+    'Gamma'                  : 0x393,
+    'H'                      : 0x30b,
+    'Im'                     : 0x2111,
+    'Join'                   : 0x2a1d,
+    'L'                      : 0x141,
+    'Lambda'                 : 0x39b,
+    'Ldsh'                   : 0x21b2,
+    'Leftarrow'              : 0x21d0,
+    'Leftrightarrow'         : 0x21d4,
+    'Lleftarrow'             : 0x21da,
+    'Longleftarrow'          : 0x27f8,
+    'Longleftrightarrow'     : 0x27fa,
+    'Longrightarrow'         : 0x27f9,
+    'Lsh'                    : 0x21b0,
+    'Nearrow'                : 0x21d7,
+    'Nwarrow'                : 0x21d6,
+    'O'                      : 0xd8,
+    'OE'                     : 0x152,
+    'Omega'                  : 0x3a9,
+    'P'                      : 0xb6,
+    'Phi'                    : 0x3a6,
+    'Pi'                     : 0x3a0,
+    'Psi'                    : 0x3a8,
+    'QED'                    : 0x220e,
+    'Rdsh'                   : 0x21b3,
+    'Re'                     : 0x211c,
+    'Rightarrow'             : 0x21d2,
+    'Rrightarrow'            : 0x21db,
+    'Rsh'                    : 0x21b1,
+    'S'                      : 0xa7,
+    'Searrow'                : 0x21d8,
+    'Sigma'                  : 0x3a3,
+    'Subset'                 : 0x22d0,
+    'Supset'                 : 0x22d1,
+    'Swarrow'                : 0x21d9,
+    'Theta'                  : 0x398,
+    'Thorn'                  : 0xde,
+    'Uparrow'                : 0x21d1,
+    'Updownarrow'            : 0x21d5,
+    'Upsilon'                : 0x3a5,
+    'Vdash'                  : 0x22a9,
+    'Vert'                   : 0x2016,
+    'Vvdash'                 : 0x22aa,
+    'Xi'                     : 0x39e,
+    '_'                      : 0x5f,
+    '__sqrt__'               : 0x221a,
+    'aa'                     : 0xe5,
+    'ac'                     : 0x223e,
+    'acute'                  : 0x301,
+    'acwopencirclearrow'     : 0x21ba,
+    'adots'                  : 0x22f0,
+    'ae'                     : 0xe6,
+    'aleph'                  : 0x2135,
+    'alpha'                  : 0x3b1,
+    'amalg'                  : 0x2a3f,
+    'angle'                  : 0x2220,
+    'approx'                 : 0x2248,
+    'approxeq'               : 0x224a,
+    'approxident'            : 0x224b,
+    'arceq'                  : 0x2258,
+    'ast'                    : 0x2217,
+    'asterisk'               : 0x2a,
+    'asymp'                  : 0x224d,
+    'backcong'               : 0x224c,
+    'backepsilon'            : 0x3f6,
+    'backprime'              : 0x2035,
+    'backsim'                : 0x223d,
+    'backsimeq'              : 0x22cd,
+    'backslash'              : 0x5c,
+    'bagmember'              : 0x22ff,
+    'bar'                    : 0x304,
+    'barleftarrow'           : 0x21e4,
+    'barvee'                 : 0x22bd,
+    'barwedge'               : 0x22bc,
+    'because'                : 0x2235,
+    'beta'                   : 0x3b2,
+    'beth'                   : 0x2136,
+    'between'                : 0x226c,
+    'bigcap'                 : 0x22c2,
+    'bigcirc'                : 0x25cb,
+    'bigcup'                 : 0x22c3,
+    'bigodot'                : 0x2a00,
+    'bigoplus'               : 0x2a01,
+    'bigotimes'              : 0x2a02,
+    'bigsqcup'               : 0x2a06,
+    'bigstar'                : 0x2605,
+    'bigtriangledown'        : 0x25bd,
+    'bigtriangleup'          : 0x25b3,
+    'biguplus'               : 0x2a04,
+    'bigvee'                 : 0x22c1,
+    'bigwedge'               : 0x22c0,
+    'blacksquare'            : 0x25a0,
+    'blacktriangle'          : 0x25b4,
+    'blacktriangledown'      : 0x25be,
+    'blacktriangleleft'      : 0x25c0,
+    'blacktriangleright'     : 0x25b6,
+    'bot'                    : 0x22a5,
+    'bowtie'                 : 0x22c8,
+    'boxbar'                 : 0x25eb,
+    'boxdot'                 : 0x22a1,
+    'boxminus'               : 0x229f,
+    'boxplus'                : 0x229e,
+    'boxtimes'               : 0x22a0,
+    'breve'                  : 0x306,
+    'bullet'                 : 0x2219,
+    'bumpeq'                 : 0x224f,
+    'c'                      : 0x327,
+    'candra'                 : 0x310,
+    'cap'                    : 0x2229,
+    'carriagereturn'         : 0x21b5,
+    'cdot'                   : 0x22c5,
+    'cdotp'                  : 0xb7,
+    'cdots'                  : 0x22ef,
+    'cent'                   : 0xa2,
+    'check'                  : 0x30c,
+    'checkmark'              : 0x2713,
+    'chi'                    : 0x3c7,
+    'circ'                   : 0x2218,
+    'circeq'                 : 0x2257,
+    'circlearrowleft'        : 0x21ba,
+    'circlearrowright'       : 0x21bb,
+    'circledR'               : 0xae,
+    'circledS'               : 0x24c8,
+    'circledast'             : 0x229b,
+    'circledcirc'            : 0x229a,
+    'circleddash'            : 0x229d,
+    'circumflexaccent'       : 0x302,
+    'clubsuit'               : 0x2663,
+    'clubsuitopen'           : 0x2667,
+    'colon'                  : 0x3a,
+    'coloneq'                : 0x2254,
+    'combiningacuteaccent'   : 0x301,
+    'combiningbreve'         : 0x306,
+    'combiningdiaeresis'     : 0x308,
+    'combiningdotabove'      : 0x307,
+    'combiningfourdotsabove' : 0x20dc,
+    'combininggraveaccent'   : 0x300,
+    'combiningoverline'      : 0x304,
+    'combiningrightarrowabove' : 0x20d7,
+    'combiningthreedotsabove' : 0x20db,
+    'combiningtilde'         : 0x303,
+    'complement'             : 0x2201,
+    'cong'                   : 0x2245,
+    'coprod'                 : 0x2210,
+    'copyright'              : 0xa9,
+    'cup'                    : 0x222a,
+    'cupdot'                 : 0x228d,
+    'cupleftarrow'           : 0x228c,
+    'curlyeqprec'            : 0x22de,
+    'curlyeqsucc'            : 0x22df,
+    'curlyvee'               : 0x22ce,
+    'curlywedge'             : 0x22cf,
+    'curvearrowleft'         : 0x21b6,
+    'curvearrowright'        : 0x21b7,
+    'cwopencirclearrow'      : 0x21bb,
+    'd'                      : 0x323,
+    'dag'                    : 0x2020,
+    'dagger'                 : 0x2020,
+    'daleth'                 : 0x2138,
+    'danger'                 : 0x2621,
+    'dashleftarrow'          : 0x290e,
+    'dashrightarrow'         : 0x290f,
+    'dashv'                  : 0x22a3,
+    'ddag'                   : 0x2021,
+    'ddagger'                : 0x2021,
+    'ddddot'                 : 0x20dc,
+    'dddot'                  : 0x20db,
+    'ddot'                   : 0x308,
+    'ddots'                  : 0x22f1,
+    'degree'                 : 0xb0,
+    'delta'                  : 0x3b4,
+    'dh'                     : 0xf0,
+    'diamond'                : 0x22c4,
+    'diamondsuit'            : 0x2662,
+    'digamma'                : 0x3dd,
+    'disin'                  : 0x22f2,
+    'div'                    : 0xf7,
+    'divideontimes'          : 0x22c7,
+    'dot'                    : 0x307,
+    'doteq'                  : 0x2250,
+    'doteqdot'               : 0x2251,
+    'dotminus'               : 0x2238,
+    'dotplus'                : 0x2214,
+    'dots'                   : 0x2026,
+    'dotsminusdots'          : 0x223a,
+    'doublebarwedge'         : 0x2306,
+    'downarrow'              : 0x2193,
+    'downdownarrows'         : 0x21ca,
+    'downharpoonleft'        : 0x21c3,
+    'downharpoonright'       : 0x21c2,
+    'downzigzagarrow'        : 0x21af,
+    'ell'                    : 0x2113,
+    'emdash'                 : 0x2014,
+    'emptyset'               : 0x2205,
+    'endash'                 : 0x2013,
+    'epsilon'                : 0x3b5,
+    'eqcirc'                 : 0x2256,
+    'eqcolon'                : 0x2255,
+    'eqdef'                  : 0x225d,
+    'eqgtr'                  : 0x22dd,
+    'eqless'                 : 0x22dc,
+    'eqsim'                  : 0x2242,
+    'eqslantgtr'             : 0x2a96,
+    'eqslantless'            : 0x2a95,
+    'equal'                  : 0x3d,
+    'equalparallel'          : 0x22d5,
+    'equiv'                  : 0x2261,
+    'eta'                    : 0x3b7,
+    'eth'                    : 0xf0,
+    'exists'                 : 0x2203,
+    'fallingdotseq'          : 0x2252,
+    'flat'                   : 0x266d,
+    'forall'                 : 0x2200,
+    'frakC'                  : 0x212d,
+    'frakZ'                  : 0x2128,
+    'frown'                  : 0x2322,
+    'gamma'                  : 0x3b3,
+    'geq'                    : 0x2265,
+    'geqq'                   : 0x2267,
+    'geqslant'               : 0x2a7e,
+    'gg'                     : 0x226b,
+    'ggg'                    : 0x22d9,
+    'gimel'                  : 0x2137,
+    'gnapprox'               : 0x2a8a,
+    'gneqq'                  : 0x2269,
+    'gnsim'                  : 0x22e7,
+    'grave'                  : 0x300,
+    'greater'                : 0x3e,
+    'gtrapprox'              : 0x2a86,
+    'gtrdot'                 : 0x22d7,
+    'gtreqless'              : 0x22db,
+    'gtreqqless'             : 0x2a8c,
+    'gtrless'                : 0x2277,
+    'gtrsim'                 : 0x2273,
+    'guillemotleft'          : 0xab,
+    'guillemotright'         : 0xbb,
+    'guilsinglleft'          : 0x2039,
+    'guilsinglright'         : 0x203a,
+    'hat'                    : 0x302,
+    'hbar'                   : 0x127,
+    'heartsuit'              : 0x2661,
+    'hermitmatrix'           : 0x22b9,
+    'hookleftarrow'          : 0x21a9,
+    'hookrightarrow'         : 0x21aa,
+    'hslash'                 : 0x210f,
+    'i'                      : 0x131,
+    'iiiint'                 : 0x2a0c,
+    'iiint'                  : 0x222d,
+    'iint'                   : 0x222c,
+    'imageof'                : 0x22b7,
+    'imath'                  : 0x131,
+    'in'                     : 0x2208,
+    'increment'              : 0x2206,
+    'infty'                  : 0x221e,
+    'int'                    : 0x222b,
+    'intercal'               : 0x22ba,
+    'invnot'                 : 0x2310,
+    'iota'                   : 0x3b9,
+    'isinE'                  : 0x22f9,
+    'isindot'                : 0x22f5,
+    'isinobar'               : 0x22f7,
+    'isins'                  : 0x22f4,
+    'isinvb'                 : 0x22f8,
+    'jmath'                  : 0x237,
+    'k'                      : 0x328,
+    'kappa'                  : 0x3ba,
+    'kernelcontraction'      : 0x223b,
+    'l'                      : 0x142,
+    'lambda'                 : 0x3bb,
+    'lambdabar'              : 0x19b,
+    'langle'                 : 0x27e8,
+    'lasp'                   : 0x2bd,
+    'lbrace'                 : 0x7b,
+    'lbrack'                 : 0x5b,
+    'lceil'                  : 0x2308,
+    'ldots'                  : 0x2026,
+    'leadsto'                : 0x21dd,
+    'leftarrow'              : 0x2190,
+    'leftarrowtail'          : 0x21a2,
+    'leftbrace'              : 0x7b,
+    'leftharpoonaccent'      : 0x20d0,
+    'leftharpoondown'        : 0x21bd,
+    'leftharpoonup'          : 0x21bc,
+    'leftleftarrows'         : 0x21c7,
+    'leftparen'              : 0x28,
+    'leftrightarrow'         : 0x2194,
+    'leftrightarrows'        : 0x21c6,
+    'leftrightharpoons'      : 0x21cb,
+    'leftrightsquigarrow'    : 0x21ad,
+    'leftsquigarrow'         : 0x219c,
+    'leftthreetimes'         : 0x22cb,
+    'leq'                    : 0x2264,
+    'leqq'                   : 0x2266,
+    'leqslant'               : 0x2a7d,
+    'less'                   : 0x3c,
+    'lessapprox'             : 0x2a85,
+    'lessdot'                : 0x22d6,
+    'lesseqgtr'              : 0x22da,
+    'lesseqqgtr'             : 0x2a8b,
+    'lessgtr'                : 0x2276,
+    'lesssim'                : 0x2272,
+    'lfloor'                 : 0x230a,
+    'lgroup'                 : 0x27ee,
+    'lhd'                    : 0x25c1,
+    'll'                     : 0x226a,
+    'llcorner'               : 0x231e,
+    'lll'                    : 0x22d8,
+    'lnapprox'               : 0x2a89,
+    'lneqq'                  : 0x2268,
+    'lnsim'                  : 0x22e6,
+    'longleftarrow'          : 0x27f5,
+    'longleftrightarrow'     : 0x27f7,
+    'longmapsto'             : 0x27fc,
+    'longrightarrow'         : 0x27f6,
+    'looparrowleft'          : 0x21ab,
+    'looparrowright'         : 0x21ac,
+    'lq'                     : 0x2018,
+    'lrcorner'               : 0x231f,
+    'ltimes'                 : 0x22c9,
+    'macron'                 : 0xaf,
+    'maltese'                : 0x2720,
+    'mapsdown'               : 0x21a7,
+    'mapsfrom'               : 0x21a4,
+    'mapsto'                 : 0x21a6,
+    'mapsup'                 : 0x21a5,
+    'measeq'                 : 0x225e,
+    'measuredangle'          : 0x2221,
+    'measuredrightangle'     : 0x22be,
+    'merge'                  : 0x2a55,
+    'mho'                    : 0x2127,
+    'mid'                    : 0x2223,
+    'minus'                  : 0x2212,
+    'minuscolon'             : 0x2239,
+    'models'                 : 0x22a7,
+    'mp'                     : 0x2213,
+    'mu'                     : 0x3bc,
+    'multimap'               : 0x22b8,
+    'nLeftarrow'             : 0x21cd,
+    'nLeftrightarrow'        : 0x21ce,
+    'nRightarrow'            : 0x21cf,
+    'nVDash'                 : 0x22af,
+    'nVdash'                 : 0x22ae,
+    'nabla'                  : 0x2207,
+    'napprox'                : 0x2249,
+    'natural'                : 0x266e,
+    'ncong'                  : 0x2247,
+    'ne'                     : 0x2260,
+    'nearrow'                : 0x2197,
+    'neg'                    : 0xac,
+    'neq'                    : 0x2260,
+    'nequiv'                 : 0x2262,
+    'nexists'                : 0x2204,
+    'ngeq'                   : 0x2271,
+    'ngtr'                   : 0x226f,
+    'ngtrless'               : 0x2279,
+    'ngtrsim'                : 0x2275,
+    'ni'                     : 0x220b,
+    'niobar'                 : 0x22fe,
+    'nis'                    : 0x22fc,
+    'nisd'                   : 0x22fa,
+    'nleftarrow'             : 0x219a,
+    'nleftrightarrow'        : 0x21ae,
+    'nleq'                   : 0x2270,
+    'nless'                  : 0x226e,
+    'nlessgtr'               : 0x2278,
+    'nlesssim'               : 0x2274,
+    'nmid'                   : 0x2224,
+    'not'                    : 0x338,
+    'notin'                  : 0x2209,
+    'notsmallowns'           : 0x220c,
+    'nparallel'              : 0x2226,
+    'nprec'                  : 0x2280,
+    'npreccurlyeq'           : 0x22e0,
+    'nrightarrow'            : 0x219b,
+    'nsim'                   : 0x2241,
+    'nsimeq'                 : 0x2244,
+    'nsqsubseteq'            : 0x22e2,
+    'nsqsupseteq'            : 0x22e3,
+    'nsubset'                : 0x2284,
+    'nsubseteq'              : 0x2288,
+    'nsucc'                  : 0x2281,
+    'nsucccurlyeq'           : 0x22e1,
+    'nsupset'                : 0x2285,
+    'nsupseteq'              : 0x2289,
+    'ntriangleleft'          : 0x22ea,
+    'ntrianglelefteq'        : 0x22ec,
+    'ntriangleright'         : 0x22eb,
+    'ntrianglerighteq'       : 0x22ed,
+    'nu'                     : 0x3bd,
+    'nvDash'                 : 0x22ad,
+    'nvdash'                 : 0x22ac,
+    'nwarrow'                : 0x2196,
+    'o'                      : 0xf8,
+    'obar'                   : 0x233d,
+    'ocirc'                  : 0x30a,
+    'odot'                   : 0x2299,
+    'oe'                     : 0x153,
+    'oequal'                 : 0x229c,
+    'oiiint'                 : 0x2230,
+    'oiint'                  : 0x222f,
+    'oint'                   : 0x222e,
+    'omega'                  : 0x3c9,
+    'ominus'                 : 0x2296,
+    'oplus'                  : 0x2295,
+    'origof'                 : 0x22b6,
+    'oslash'                 : 0x2298,
+    'otimes'                 : 0x2297,
+    'overarc'                : 0x311,
+    'overleftarrow'          : 0x20d6,
+    'overleftrightarrow'     : 0x20e1,
+    'parallel'               : 0x2225,
+    'partial'                : 0x2202,
+    'perp'                   : 0x27c2,
+    'perthousand'            : 0x2030,
+    'phi'                    : 0x3d5,
+    'pi'                     : 0x3c0,
+    'pitchfork'              : 0x22d4,
+    'plus'                   : 0x2b,
+    'pm'                     : 0xb1,
+    'prec'                   : 0x227a,
+    'precapprox'             : 0x2ab7,
+    'preccurlyeq'            : 0x227c,
+    'preceq'                 : 0x227c,
+    'precnapprox'            : 0x2ab9,
+    'precnsim'               : 0x22e8,
+    'precsim'                : 0x227e,
+    'prime'                  : 0x2032,
+    'prod'                   : 0x220f,
+    'propto'                 : 0x221d,
+    'prurel'                 : 0x22b0,
+    'psi'                    : 0x3c8,
+    'quad'                   : 0x2003,
+    'questeq'                : 0x225f,
+    'rangle'                 : 0x27e9,
+    'rasp'                   : 0x2bc,
+    'ratio'                  : 0x2236,
+    'rbrace'                 : 0x7d,
+    'rbrack'                 : 0x5d,
+    'rceil'                  : 0x2309,
+    'rfloor'                 : 0x230b,
+    'rgroup'                 : 0x27ef,
+    'rhd'                    : 0x25b7,
+    'rho'                    : 0x3c1,
+    'rightModels'            : 0x22ab,
+    'rightangle'             : 0x221f,
+    'rightarrow'             : 0x2192,
+    'rightarrowbar'          : 0x21e5,
+    'rightarrowtail'         : 0x21a3,
+    'rightassert'            : 0x22a6,
+    'rightbrace'             : 0x7d,
+    'rightharpoonaccent'     : 0x20d1,
+    'rightharpoondown'       : 0x21c1,
+    'rightharpoonup'         : 0x21c0,
+    'rightleftarrows'        : 0x21c4,
+    'rightleftharpoons'      : 0x21cc,
+    'rightparen'             : 0x29,
+    'rightrightarrows'       : 0x21c9,
+    'rightsquigarrow'        : 0x219d,
+    'rightthreetimes'        : 0x22cc,
+    'rightzigzagarrow'       : 0x21dd,
+    'ring'                   : 0x2da,
+    'risingdotseq'           : 0x2253,
+    'rq'                     : 0x2019,
+    'rtimes'                 : 0x22ca,
+    'scrB'                   : 0x212c,
+    'scrE'                   : 0x2130,
+    'scrF'                   : 0x2131,
+    'scrH'                   : 0x210b,
+    'scrI'                   : 0x2110,
+    'scrL'                   : 0x2112,
+    'scrM'                   : 0x2133,
+    'scrR'                   : 0x211b,
+    'scre'                   : 0x212f,
+    'scrg'                   : 0x210a,
+    'scro'                   : 0x2134,
+    'scurel'                 : 0x22b1,
+    'searrow'                : 0x2198,
+    'setminus'               : 0x2216,
+    'sharp'                  : 0x266f,
+    'sigma'                  : 0x3c3,
+    'sim'                    : 0x223c,
+    'simeq'                  : 0x2243,
+    'simneqq'                : 0x2246,
+    'sinewave'               : 0x223f,
+    'slash'                  : 0x2215,
+    'smallin'                : 0x220a,
+    'smallintclockwise'      : 0x2231,
+    'smallointctrcclockwise' : 0x2233,
+    'smallowns'              : 0x220d,
+    'smallsetminus'          : 0x2216,
+    'smallvarointclockwise'  : 0x2232,
+    'smile'                  : 0x2323,
+    'solbar'                 : 0x233f,
+    'spadesuit'              : 0x2660,
+    'spadesuitopen'          : 0x2664,
+    'sphericalangle'         : 0x2222,
+    'sqcap'                  : 0x2293,
+    'sqcup'                  : 0x2294,
+    'sqsubset'               : 0x228f,
+    'sqsubseteq'             : 0x2291,
+    'sqsubsetneq'            : 0x22e4,
+    'sqsupset'               : 0x2290,
+    'sqsupseteq'             : 0x2292,
+    'sqsupsetneq'            : 0x22e5,
+    'ss'                     : 0xdf,
+    'star'                   : 0x22c6,
+    'stareq'                 : 0x225b,
+    'sterling'               : 0xa3,
+    'subset'                 : 0x2282,
+    'subseteq'               : 0x2286,
+    'subseteqq'              : 0x2ac5,
+    'subsetneq'              : 0x228a,
+    'subsetneqq'             : 0x2acb,
+    'succ'                   : 0x227b,
+    'succapprox'             : 0x2ab8,
+    'succcurlyeq'            : 0x227d,
+    'succeq'                 : 0x227d,
+    'succnapprox'            : 0x2aba,
+    'succnsim'               : 0x22e9,
+    'succsim'                : 0x227f,
+    'sum'                    : 0x2211,
+    'supset'                 : 0x2283,
+    'supseteq'               : 0x2287,
+    'supseteqq'              : 0x2ac6,
+    'supsetneq'              : 0x228b,
+    'supsetneqq'             : 0x2acc,
+    'swarrow'                : 0x2199,
+    't'                      : 0x361,
+    'tau'                    : 0x3c4,
+    'textasciiacute'         : 0xb4,
+    'textasciicircum'        : 0x5e,
+    'textasciigrave'         : 0x60,
+    'textasciitilde'         : 0x7e,
+    'textexclamdown'         : 0xa1,
+    'textquestiondown'       : 0xbf,
+    'textquotedblleft'       : 0x201c,
+    'textquotedblright'      : 0x201d,
+    'therefore'              : 0x2234,
+    'theta'                  : 0x3b8,
+    'thickspace'             : 0x2005,
+    'thorn'                  : 0xfe,
+    'tilde'                  : 0x303,
+    'times'                  : 0xd7,
+    'to'                     : 0x2192,
+    'top'                    : 0x22a4,
+    'triangle'               : 0x25b3,
+    'triangledown'           : 0x25bf,
+    'triangleeq'             : 0x225c,
+    'triangleleft'           : 0x25c1,
+    'trianglelefteq'         : 0x22b4,
+    'triangleq'              : 0x225c,
+    'triangleright'          : 0x25b7,
+    'trianglerighteq'        : 0x22b5,
+    'turnednot'              : 0x2319,
+    'twoheaddownarrow'       : 0x21a1,
+    'twoheadleftarrow'       : 0x219e,
+    'twoheadrightarrow'      : 0x21a0,
+    'twoheaduparrow'         : 0x219f,
+    'ulcorner'               : 0x231c,
+    'underbar'               : 0x331,
+    'unlhd'                  : 0x22b4,
+    'unrhd'                  : 0x22b5,
+    'uparrow'                : 0x2191,
+    'updownarrow'            : 0x2195,
+    'updownarrowbar'         : 0x21a8,
+    'updownarrows'           : 0x21c5,
+    'upharpoonleft'          : 0x21bf,
+    'upharpoonright'         : 0x21be,
+    'uplus'                  : 0x228e,
+    'upsilon'                : 0x3c5,
+    'upuparrows'             : 0x21c8,
+    'urcorner'               : 0x231d,
+    'vDash'                  : 0x22a8,
+    'varepsilon'             : 0x3b5,
+    'varisinobar'            : 0x22f6,
+    'varisins'               : 0x22f3,
+    'varkappa'               : 0x3f0,
+    'varlrtriangle'          : 0x22bf,
+    'varniobar'              : 0x22fd,
+    'varnis'                 : 0x22fb,
+    'varnothing'             : 0x2205,
+    'varphi'                 : 0x3c6,
+    'varpi'                  : 0x3d6,
+    'varpropto'              : 0x221d,
+    'varrho'                 : 0x3f1,
+    'varsigma'               : 0x3c2,
+    'vartheta'               : 0x3d1,
+    'vartriangle'            : 0x25b5,
+    'vartriangleleft'        : 0x22b2,
+    'vartriangleright'       : 0x22b3,
+    'vdash'                  : 0x22a2,
+    'vdots'                  : 0x22ee,
+    'vec'                    : 0x20d7,
+    'vee'                    : 0x2228,
+    'veebar'                 : 0x22bb,
+    'veeeq'                  : 0x225a,
+    'vert'                   : 0x7c,
+    'wedge'                  : 0x2227,
+    'wedgeq'                 : 0x2259,
+    'widebar'                : 0x305,
+    'widehat'                : 0x302,
+    'widetilde'              : 0x303,
+    'wp'                     : 0x2118,
+    'wr'                     : 0x2240,
+    'xi'                     : 0x3be,
+    'yen'                    : 0xa5,
+    'zeta'                   : 0x3b6,
+    '{'                      : 0x7b,
+    '|'                      : 0x2016,
+    '}'                      : 0x7d,
+}
+
+# Each element is a 4-tuple of the form:
+#   src_start, src_end, dst_font, dst_start
+
+_EntryTypeIn = tuple[str, str, str, str | int]
+_EntryTypeOut = tuple[int, int, str, int]
+
+_stix_virtual_fonts: dict[str, dict[str, list[_EntryTypeIn]] | list[_EntryTypeIn]] = {
+    'bb': {
+        "rm": [
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER B}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL A}"),
+            ("\N{LATIN CAPITAL LETTER C}",
+             "\N{LATIN CAPITAL LETTER C}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL C}"),
+            ("\N{LATIN CAPITAL LETTER D}",
+             "\N{LATIN CAPITAL LETTER G}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL D}"),
+            ("\N{LATIN CAPITAL LETTER H}",
+             "\N{LATIN CAPITAL LETTER H}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL H}"),
+            ("\N{LATIN CAPITAL LETTER I}",
+             "\N{LATIN CAPITAL LETTER M}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL I}"),
+            ("\N{LATIN CAPITAL LETTER N}",
+             "\N{LATIN CAPITAL LETTER N}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL N}"),
+            ("\N{LATIN CAPITAL LETTER O}",
+             "\N{LATIN CAPITAL LETTER O}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL O}"),
+            ("\N{LATIN CAPITAL LETTER P}",
+             "\N{LATIN CAPITAL LETTER Q}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL P}"),
+            ("\N{LATIN CAPITAL LETTER R}",
+             "\N{LATIN CAPITAL LETTER R}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL R}"),
+            ("\N{LATIN CAPITAL LETTER S}",
+             "\N{LATIN CAPITAL LETTER Y}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL S}"),
+            ("\N{LATIN CAPITAL LETTER Z}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL Z}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK SMALL A}"),
+            ("\N{GREEK CAPITAL LETTER GAMMA}",
+             "\N{GREEK CAPITAL LETTER GAMMA}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL GAMMA}"),
+            ("\N{GREEK CAPITAL LETTER PI}",
+             "\N{GREEK CAPITAL LETTER PI}",
+             "rm",
+             "\N{DOUBLE-STRUCK CAPITAL PI}"),
+            ("\N{GREEK CAPITAL LETTER SIGMA}",
+             "\N{GREEK CAPITAL LETTER SIGMA}",
+             "rm",
+             "\N{DOUBLE-STRUCK N-ARY SUMMATION}"),
+            ("\N{GREEK SMALL LETTER GAMMA}",
+             "\N{GREEK SMALL LETTER GAMMA}",
+             "rm",
+             "\N{DOUBLE-STRUCK SMALL GAMMA}"),
+            ("\N{GREEK SMALL LETTER PI}",
+             "\N{GREEK SMALL LETTER PI}",
+             "rm",
+             "\N{DOUBLE-STRUCK SMALL PI}"),
+        ],
+        "it": [
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER B}",
+             "it",
+             0xe154),
+            ("\N{LATIN CAPITAL LETTER C}",
+             "\N{LATIN CAPITAL LETTER C}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL C}"),
+            ("\N{LATIN CAPITAL LETTER D}",
+             "\N{LATIN CAPITAL LETTER D}",
+             "it",
+             "\N{DOUBLE-STRUCK ITALIC CAPITAL D}"),
+            ("\N{LATIN CAPITAL LETTER E}",
+             "\N{LATIN CAPITAL LETTER G}",
+             "it",
+             0xe156),
+            ("\N{LATIN CAPITAL LETTER H}",
+             "\N{LATIN CAPITAL LETTER H}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL H}"),
+            ("\N{LATIN CAPITAL LETTER I}",
+             "\N{LATIN CAPITAL LETTER M}",
+             "it",
+             0xe159),
+            ("\N{LATIN CAPITAL LETTER N}",
+             "\N{LATIN CAPITAL LETTER N}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL N}"),
+            ("\N{LATIN CAPITAL LETTER O}",
+             "\N{LATIN CAPITAL LETTER O}",
+             "it",
+             0xe15e),
+            ("\N{LATIN CAPITAL LETTER P}",
+             "\N{LATIN CAPITAL LETTER Q}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL P}"),
+            ("\N{LATIN CAPITAL LETTER R}",
+             "\N{LATIN CAPITAL LETTER R}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL R}"),
+            ("\N{LATIN CAPITAL LETTER S}",
+             "\N{LATIN CAPITAL LETTER Y}",
+             "it",
+             0xe15f),
+            ("\N{LATIN CAPITAL LETTER Z}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL Z}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER C}",
+             "it",
+             0xe166),
+            ("\N{LATIN SMALL LETTER D}",
+             "\N{LATIN SMALL LETTER E}",
+             "it",
+             "\N{DOUBLE-STRUCK ITALIC SMALL D}"),
+            ("\N{LATIN SMALL LETTER F}",
+             "\N{LATIN SMALL LETTER H}",
+             "it",
+             0xe169),
+            ("\N{LATIN SMALL LETTER I}",
+             "\N{LATIN SMALL LETTER J}",
+             "it",
+             "\N{DOUBLE-STRUCK ITALIC SMALL I}"),
+            ("\N{LATIN SMALL LETTER K}",
+             "\N{LATIN SMALL LETTER Z}",
+             "it",
+             0xe16c),
+            ("\N{GREEK CAPITAL LETTER GAMMA}",
+             "\N{GREEK CAPITAL LETTER GAMMA}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL GAMMA}"),  # \Gamma (not in beta STIX fonts)
+            ("\N{GREEK CAPITAL LETTER PI}",
+             "\N{GREEK CAPITAL LETTER PI}",
+             "it",
+             "\N{DOUBLE-STRUCK CAPITAL PI}"),
+            ("\N{GREEK CAPITAL LETTER SIGMA}",
+             "\N{GREEK CAPITAL LETTER SIGMA}",
+             "it",
+             "\N{DOUBLE-STRUCK N-ARY SUMMATION}"),  # \Sigma (not in beta STIX fonts)
+            ("\N{GREEK SMALL LETTER GAMMA}",
+             "\N{GREEK SMALL LETTER GAMMA}",
+             "it",
+             "\N{DOUBLE-STRUCK SMALL GAMMA}"),  # \gamma (not in beta STIX fonts)
+            ("\N{GREEK SMALL LETTER PI}",
+             "\N{GREEK SMALL LETTER PI}",
+             "it",
+             "\N{DOUBLE-STRUCK SMALL PI}"),
+        ],
+        "bf": [
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "rm",
+             "\N{MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER B}",
+             "bf",
+             0xe38a),
+            ("\N{LATIN CAPITAL LETTER C}",
+             "\N{LATIN CAPITAL LETTER C}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL C}"),
+            ("\N{LATIN CAPITAL LETTER D}",
+             "\N{LATIN CAPITAL LETTER D}",
+             "bf",
+             "\N{DOUBLE-STRUCK ITALIC CAPITAL D}"),
+            ("\N{LATIN CAPITAL LETTER E}",
+             "\N{LATIN CAPITAL LETTER G}",
+             "bf",
+             0xe38d),
+            ("\N{LATIN CAPITAL LETTER H}",
+             "\N{LATIN CAPITAL LETTER H}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL H}"),
+            ("\N{LATIN CAPITAL LETTER I}",
+             "\N{LATIN CAPITAL LETTER M}",
+             "bf",
+             0xe390),
+            ("\N{LATIN CAPITAL LETTER N}",
+             "\N{LATIN CAPITAL LETTER N}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL N}"),
+            ("\N{LATIN CAPITAL LETTER O}",
+             "\N{LATIN CAPITAL LETTER O}",
+             "bf",
+             0xe395),
+            ("\N{LATIN CAPITAL LETTER P}",
+             "\N{LATIN CAPITAL LETTER Q}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL P}"),
+            ("\N{LATIN CAPITAL LETTER R}",
+             "\N{LATIN CAPITAL LETTER R}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL R}"),
+            ("\N{LATIN CAPITAL LETTER S}",
+             "\N{LATIN CAPITAL LETTER Y}",
+             "bf",
+             0xe396),
+            ("\N{LATIN CAPITAL LETTER Z}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL Z}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER C}",
+             "bf",
+             0xe39d),
+            ("\N{LATIN SMALL LETTER D}",
+             "\N{LATIN SMALL LETTER E}",
+             "bf",
+             "\N{DOUBLE-STRUCK ITALIC SMALL D}"),
+            ("\N{LATIN SMALL LETTER F}",
+             "\N{LATIN SMALL LETTER H}",
+             "bf",
+             0xe3a2),
+            ("\N{LATIN SMALL LETTER I}",
+             "\N{LATIN SMALL LETTER J}",
+             "bf",
+             "\N{DOUBLE-STRUCK ITALIC SMALL I}"),
+            ("\N{LATIN SMALL LETTER K}",
+             "\N{LATIN SMALL LETTER Z}",
+             "bf",
+             0xe3a7),
+            ("\N{GREEK CAPITAL LETTER GAMMA}",
+             "\N{GREEK CAPITAL LETTER GAMMA}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL GAMMA}"),
+            ("\N{GREEK CAPITAL LETTER PI}",
+             "\N{GREEK CAPITAL LETTER PI}",
+             "bf",
+             "\N{DOUBLE-STRUCK CAPITAL PI}"),
+            ("\N{GREEK CAPITAL LETTER SIGMA}",
+             "\N{GREEK CAPITAL LETTER SIGMA}",
+             "bf",
+             "\N{DOUBLE-STRUCK N-ARY SUMMATION}"),
+            ("\N{GREEK SMALL LETTER GAMMA}",
+             "\N{GREEK SMALL LETTER GAMMA}",
+             "bf",
+             "\N{DOUBLE-STRUCK SMALL GAMMA}"),
+            ("\N{GREEK SMALL LETTER PI}",
+             "\N{GREEK SMALL LETTER PI}",
+             "bf",
+             "\N{DOUBLE-STRUCK SMALL PI}"),
+        ],
+    },
+    'cal': [
+        ("\N{LATIN CAPITAL LETTER A}",
+         "\N{LATIN CAPITAL LETTER Z}",
+         "it",
+         0xe22d),
+    ],
+    'frak': {
+        "rm": [
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER B}",
+             "rm",
+             "\N{MATHEMATICAL FRAKTUR CAPITAL A}"),
+            ("\N{LATIN CAPITAL LETTER C}",
+             "\N{LATIN CAPITAL LETTER C}",
+             "rm",
+             "\N{BLACK-LETTER CAPITAL C}"),
+            ("\N{LATIN CAPITAL LETTER D}",
+             "\N{LATIN CAPITAL LETTER G}",
+             "rm",
+             "\N{MATHEMATICAL FRAKTUR CAPITAL D}"),
+            ("\N{LATIN CAPITAL LETTER H}",
+             "\N{LATIN CAPITAL LETTER H}",
+             "rm",
+             "\N{BLACK-LETTER CAPITAL H}"),
+            ("\N{LATIN CAPITAL LETTER I}",
+             "\N{LATIN CAPITAL LETTER I}",
+             "rm",
+             "\N{BLACK-LETTER CAPITAL I}"),
+            ("\N{LATIN CAPITAL LETTER J}",
+             "\N{LATIN CAPITAL LETTER Q}",
+             "rm",
+             "\N{MATHEMATICAL FRAKTUR CAPITAL J}"),
+            ("\N{LATIN CAPITAL LETTER R}",
+             "\N{LATIN CAPITAL LETTER R}",
+             "rm",
+             "\N{BLACK-LETTER CAPITAL R}"),
+            ("\N{LATIN CAPITAL LETTER S}",
+             "\N{LATIN CAPITAL LETTER Y}",
+             "rm",
+             "\N{MATHEMATICAL FRAKTUR CAPITAL S}"),
+            ("\N{LATIN CAPITAL LETTER Z}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "rm",
+             "\N{BLACK-LETTER CAPITAL Z}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "rm",
+             "\N{MATHEMATICAL FRAKTUR SMALL A}"),
+            ],
+        "bf": [
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "bf",
+             "\N{MATHEMATICAL BOLD FRAKTUR CAPITAL A}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "bf",
+             "\N{MATHEMATICAL BOLD FRAKTUR SMALL A}"),
+        ],
+    },
+    'scr': [
+        ("\N{LATIN CAPITAL LETTER A}",
+         "\N{LATIN CAPITAL LETTER A}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL A}"),
+        ("\N{LATIN CAPITAL LETTER B}",
+         "\N{LATIN CAPITAL LETTER B}",
+         "it",
+         "\N{SCRIPT CAPITAL B}"),
+        ("\N{LATIN CAPITAL LETTER C}",
+         "\N{LATIN CAPITAL LETTER D}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL C}"),
+        ("\N{LATIN CAPITAL LETTER E}",
+         "\N{LATIN CAPITAL LETTER F}",
+         "it",
+         "\N{SCRIPT CAPITAL E}"),
+        ("\N{LATIN CAPITAL LETTER G}",
+         "\N{LATIN CAPITAL LETTER G}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL G}"),
+        ("\N{LATIN CAPITAL LETTER H}",
+         "\N{LATIN CAPITAL LETTER H}",
+         "it",
+         "\N{SCRIPT CAPITAL H}"),
+        ("\N{LATIN CAPITAL LETTER I}",
+         "\N{LATIN CAPITAL LETTER I}",
+         "it",
+         "\N{SCRIPT CAPITAL I}"),
+        ("\N{LATIN CAPITAL LETTER J}",
+         "\N{LATIN CAPITAL LETTER K}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL J}"),
+        ("\N{LATIN CAPITAL LETTER L}",
+         "\N{LATIN CAPITAL LETTER L}",
+         "it",
+         "\N{SCRIPT CAPITAL L}"),
+        ("\N{LATIN CAPITAL LETTER M}",
+         "\N{LATIN CAPITAL LETTER M}",
+         "it",
+         "\N{SCRIPT CAPITAL M}"),
+        ("\N{LATIN CAPITAL LETTER N}",
+         "\N{LATIN CAPITAL LETTER Q}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL N}"),
+        ("\N{LATIN CAPITAL LETTER R}",
+         "\N{LATIN CAPITAL LETTER R}",
+         "it",
+         "\N{SCRIPT CAPITAL R}"),
+        ("\N{LATIN CAPITAL LETTER S}",
+         "\N{LATIN CAPITAL LETTER Z}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT CAPITAL S}"),
+        ("\N{LATIN SMALL LETTER A}",
+         "\N{LATIN SMALL LETTER D}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT SMALL A}"),
+        ("\N{LATIN SMALL LETTER E}",
+         "\N{LATIN SMALL LETTER E}",
+         "it",
+         "\N{SCRIPT SMALL E}"),
+        ("\N{LATIN SMALL LETTER F}",
+         "\N{LATIN SMALL LETTER F}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT SMALL F}"),
+        ("\N{LATIN SMALL LETTER G}",
+         "\N{LATIN SMALL LETTER G}",
+         "it",
+         "\N{SCRIPT SMALL G}"),
+        ("\N{LATIN SMALL LETTER H}",
+         "\N{LATIN SMALL LETTER N}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT SMALL H}"),
+        ("\N{LATIN SMALL LETTER O}",
+         "\N{LATIN SMALL LETTER O}",
+         "it",
+         "\N{SCRIPT SMALL O}"),
+        ("\N{LATIN SMALL LETTER P}",
+         "\N{LATIN SMALL LETTER Z}",
+         "it",
+         "\N{MATHEMATICAL SCRIPT SMALL P}"),
+    ],
+    'sf': {
+        "rm": [
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "rm",
+             "\N{MATHEMATICAL SANS-SERIF DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "rm",
+             "\N{MATHEMATICAL SANS-SERIF CAPITAL A}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "rm",
+             "\N{MATHEMATICAL SANS-SERIF SMALL A}"),
+            ("\N{GREEK CAPITAL LETTER ALPHA}",
+             "\N{GREEK CAPITAL LETTER OMEGA}",
+             "rm",
+             0xe17d),
+            ("\N{GREEK SMALL LETTER ALPHA}",
+             "\N{GREEK SMALL LETTER OMEGA}",
+             "rm",
+             0xe196),
+            ("\N{GREEK THETA SYMBOL}",
+             "\N{GREEK THETA SYMBOL}",
+             "rm",
+             0xe1b0),
+            ("\N{GREEK PHI SYMBOL}",
+             "\N{GREEK PHI SYMBOL}",
+             "rm",
+             0xe1b1),
+            ("\N{GREEK PI SYMBOL}",
+             "\N{GREEK PI SYMBOL}",
+             "rm",
+             0xe1b3),
+            ("\N{GREEK RHO SYMBOL}",
+             "\N{GREEK RHO SYMBOL}",
+             "rm",
+             0xe1b2),
+            ("\N{GREEK LUNATE EPSILON SYMBOL}",
+             "\N{GREEK LUNATE EPSILON SYMBOL}",
+             "rm",
+             0xe1af),
+            ("\N{PARTIAL DIFFERENTIAL}",
+             "\N{PARTIAL DIFFERENTIAL}",
+             "rm",
+             0xe17c),
+        ],
+        "it": [
+            # These numerals are actually upright.  We don't actually
+            # want italic numerals ever.
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "rm",
+             "\N{MATHEMATICAL SANS-SERIF DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "it",
+             "\N{MATHEMATICAL SANS-SERIF ITALIC CAPITAL A}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "it",
+             "\N{MATHEMATICAL SANS-SERIF ITALIC SMALL A}"),
+            ("\N{GREEK CAPITAL LETTER ALPHA}",
+             "\N{GREEK CAPITAL LETTER OMEGA}",
+             "rm",
+             0xe17d),
+            ("\N{GREEK SMALL LETTER ALPHA}",
+             "\N{GREEK SMALL LETTER OMEGA}",
+             "it",
+             0xe1d8),
+            ("\N{GREEK THETA SYMBOL}",
+             "\N{GREEK THETA SYMBOL}",
+             "it",
+             0xe1f2),
+            ("\N{GREEK PHI SYMBOL}",
+             "\N{GREEK PHI SYMBOL}",
+             "it",
+             0xe1f3),
+            ("\N{GREEK PI SYMBOL}",
+             "\N{GREEK PI SYMBOL}",
+             "it",
+             0xe1f5),
+            ("\N{GREEK RHO SYMBOL}",
+             "\N{GREEK RHO SYMBOL}",
+             "it",
+             0xe1f4),
+            ("\N{GREEK LUNATE EPSILON SYMBOL}",
+             "\N{GREEK LUNATE EPSILON SYMBOL}",
+             "it",
+             0xe1f1),
+        ],
+        "bf": [
+            ("\N{DIGIT ZERO}",
+             "\N{DIGIT NINE}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD DIGIT ZERO}"),
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD CAPITAL A}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD SMALL A}"),
+            ("\N{GREEK CAPITAL LETTER ALPHA}",
+             "\N{GREEK CAPITAL LETTER OMEGA}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD CAPITAL ALPHA}"),
+            ("\N{GREEK SMALL LETTER ALPHA}",
+             "\N{GREEK SMALL LETTER OMEGA}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA}"),
+            ("\N{GREEK THETA SYMBOL}",
+             "\N{GREEK THETA SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD THETA SYMBOL}"),
+            ("\N{GREEK PHI SYMBOL}",
+             "\N{GREEK PHI SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD PHI SYMBOL}"),
+            ("\N{GREEK PI SYMBOL}",
+             "\N{GREEK PI SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD PI SYMBOL}"),
+            ("\N{GREEK KAPPA SYMBOL}",
+             "\N{GREEK KAPPA SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD KAPPA SYMBOL}"),
+            ("\N{GREEK RHO SYMBOL}",
+             "\N{GREEK RHO SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD RHO SYMBOL}"),
+            ("\N{GREEK LUNATE EPSILON SYMBOL}",
+             "\N{GREEK LUNATE EPSILON SYMBOL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL}"),
+            ("\N{PARTIAL DIFFERENTIAL}",
+             "\N{PARTIAL DIFFERENTIAL}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL}"),
+            ("\N{NABLA}",
+             "\N{NABLA}",
+             "bf",
+             "\N{MATHEMATICAL SANS-SERIF BOLD NABLA}"),
+        ],
+        "bfit": [
+            ("\N{LATIN CAPITAL LETTER A}",
+             "\N{LATIN CAPITAL LETTER Z}",
+             "bfit",
+             "\N{MATHEMATICAL BOLD ITALIC CAPITAL A}"),
+            ("\N{LATIN SMALL LETTER A}",
+             "\N{LATIN SMALL LETTER Z}",
+             "bfit",
+             "\N{MATHEMATICAL BOLD ITALIC SMALL A}"),
+            ("\N{GREEK CAPITAL LETTER GAMMA}",
+             "\N{GREEK CAPITAL LETTER OMEGA}",
+             "bfit",
+             "\N{MATHEMATICAL BOLD ITALIC CAPITAL GAMMA}"),
+            ("\N{GREEK SMALL LETTER ALPHA}",
+             "\N{GREEK SMALL LETTER OMEGA}",
+             "bfit",
+             "\N{MATHEMATICAL BOLD ITALIC SMALL ALPHA}"),
+        ],
+    },
+    'tt': [
+        ("\N{DIGIT ZERO}",
+         "\N{DIGIT NINE}",
+         "rm",
+         "\N{MATHEMATICAL MONOSPACE DIGIT ZERO}"),
+        ("\N{LATIN CAPITAL LETTER A}",
+         "\N{LATIN CAPITAL LETTER Z}",
+         "rm",
+         "\N{MATHEMATICAL MONOSPACE CAPITAL A}"),
+        ("\N{LATIN SMALL LETTER A}",
+         "\N{LATIN SMALL LETTER Z}",
+         "rm",
+         "\N{MATHEMATICAL MONOSPACE SMALL A}")
+    ],
+}
+
+
+@overload
+def _normalize_stix_fontcodes(d: _EntryTypeIn) -> _EntryTypeOut: ...
+
+
+@overload
+def _normalize_stix_fontcodes(d: list[_EntryTypeIn]) -> list[_EntryTypeOut]: ...
+
+
+@overload
+def _normalize_stix_fontcodes(d: dict[str, list[_EntryTypeIn] |
+                                      dict[str, list[_EntryTypeIn]]]
+                              ) -> dict[str, list[_EntryTypeOut] |
+                                        dict[str, list[_EntryTypeOut]]]: ...
+
+
+def _normalize_stix_fontcodes(d):
+    if isinstance(d, tuple):
+        return tuple(ord(x) if isinstance(x, str) and len(x) == 1 else x for x in d)
+    elif isinstance(d, list):
+        return [_normalize_stix_fontcodes(x) for x in d]
+    elif isinstance(d, dict):
+        return {k: _normalize_stix_fontcodes(v) for k, v in d.items()}
+
+
+stix_virtual_fonts: dict[str, dict[str, list[_EntryTypeOut]] | list[_EntryTypeOut]]
+stix_virtual_fonts = _normalize_stix_fontcodes(_stix_virtual_fonts)
+
+# Free redundant list now that it has been normalized
+del _stix_virtual_fonts
+
+# Fix some incorrect glyphs.
+stix_glyph_fixes = {
+    # Cap and Cup glyphs are swapped.
+    0x22d2: 0x22d3,
+    0x22d3: 0x22d2,
+}

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_path.pyi

@@ -0,0 +1,9 @@
+from collections.abc import Sequence
+
+import numpy as np
+
+from .transforms import BboxBase
+
+def affine_transform(points: np.ndarray, trans: np.ndarray) -> np.ndarray: ...
+def count_bboxes_overlapping_bbox(bbox: BboxBase, bboxes: Sequence[BboxBase]) -> int: ...
+def update_path_extents(path, trans, rect, minpos, ignore): ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_pylab_helpers.py

@@ -0,0 +1,134 @@
+"""
+Manage figures for the pyplot interface.
+"""
+
+import atexit
+from collections import OrderedDict
+
+
+class Gcf:
+    """
+    Singleton to maintain the relation between figures and their managers, and
+    keep track of and "active" figure and manager.
+
+    The canvas of a figure created through pyplot is associated with a figure
+    manager, which handles the interaction between the figure and the backend.
+    pyplot keeps track of figure managers using an identifier, the "figure
+    number" or "manager number" (which can actually be any hashable value);
+    this number is available as the :attr:`number` attribute of the manager.
+
+    This class is never instantiated; it consists of an `OrderedDict` mapping
+    figure/manager numbers to managers, and a set of class methods that
+    manipulate this `OrderedDict`.
+
+    Attributes
+    ----------
+    figs : OrderedDict
+        `OrderedDict` mapping numbers to managers; the active manager is at the
+        end.
+    """
+
+    figs = OrderedDict()
+
+    @classmethod
+    def get_fig_manager(cls, num):
+        """
+        If manager number *num* exists, make it the active one and return it;
+        otherwise return *None*.
+        """
+        manager = cls.figs.get(num, None)
+        if manager is not None:
+            cls.set_active(manager)
+        return manager
+
+    @classmethod
+    def destroy(cls, num):
+        """
+        Destroy manager *num* -- either a manager instance or a manager number.
+
+        In the interactive backends, this is bound to the window "destroy" and
+        "delete" events.
+
+        It is recommended to pass a manager instance, to avoid confusion when
+        two managers share the same number.
+        """
+        if all(hasattr(num, attr) for attr in ["num", "destroy"]):
+            manager = num
+            if cls.figs.get(manager.num) is manager:
+                cls.figs.pop(manager.num)
+        else:
+            try:
+                manager = cls.figs.pop(num)
+            except KeyError:
+                return
+        if hasattr(manager, "_cidgcf"):
+            manager.canvas.mpl_disconnect(manager._cidgcf)
+        manager.destroy()
+
+    @classmethod
+    def destroy_fig(cls, fig):
+        """Destroy figure *fig*."""
+        num = next((manager.num for manager in cls.figs.values()
+                    if manager.canvas.figure == fig), None)
+        if num is not None:
+            cls.destroy(num)
+
+    @classmethod
+    def destroy_all(cls):
+        """Destroy all figures."""
+        for manager in list(cls.figs.values()):
+            manager.canvas.mpl_disconnect(manager._cidgcf)
+            manager.destroy()
+        cls.figs.clear()
+
+    @classmethod
+    def has_fignum(cls, num):
+        """Return whether figure number *num* exists."""
+        return num in cls.figs
+
+    @classmethod
+    def get_all_fig_managers(cls):
+        """Return a list of figure managers."""
+        return list(cls.figs.values())
+
+    @classmethod
+    def get_num_fig_managers(cls):
+        """Return the number of figures being managed."""
+        return len(cls.figs)
+
+    @classmethod
+    def get_active(cls):
+        """Return the active manager, or *None* if there is no manager."""
+        return next(reversed(cls.figs.values())) if cls.figs else None
+
+    @classmethod
+    def _set_new_active_manager(cls, manager):
+        """Adopt *manager* into pyplot and make it the active manager."""
+        if not hasattr(manager, "_cidgcf"):
+            manager._cidgcf = manager.canvas.mpl_connect(
+                "button_press_event", lambda event: cls.set_active(manager))
+        fig = manager.canvas.figure
+        fig._number = manager.num
+        label = fig.get_label()
+        if label:
+            manager.set_window_title(label)
+        cls.set_active(manager)
+
+    @classmethod
+    def set_active(cls, manager):
+        """Make *manager* the active manager."""
+        cls.figs[manager.num] = manager
+        cls.figs.move_to_end(manager.num)
+
+    @classmethod
+    def draw_all(cls, force=False):
+        """
+        Redraw all stale managed figures, or, if *force* is True, all managed
+        figures.
+        """
+        for manager in cls.get_all_fig_managers():
+            if force or manager.canvas.figure.stale:
+                manager.canvas.draw_idle()
+
+
+atexit.register(Gcf.destroy_all)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_pylab_helpers.pyi

@@ -0,0 +1,29 @@
+from collections import OrderedDict
+
+from matplotlib.backend_bases import FigureManagerBase
+from matplotlib.figure import Figure
+
+class Gcf:
+    figs: OrderedDict[int, FigureManagerBase]
+    @classmethod
+    def get_fig_manager(cls, num: int) -> FigureManagerBase | None: ...
+    @classmethod
+    def destroy(cls, num: int | FigureManagerBase) -> None: ...
+    @classmethod
+    def destroy_fig(cls, fig: Figure) -> None: ...
+    @classmethod
+    def destroy_all(cls) -> None: ...
+    @classmethod
+    def has_fignum(cls, num: int) -> bool: ...
+    @classmethod
+    def get_all_fig_managers(cls) -> list[FigureManagerBase]: ...
+    @classmethod
+    def get_num_fig_managers(cls) -> int: ...
+    @classmethod
+    def get_active(cls) -> FigureManagerBase | None: ...
+    @classmethod
+    def _set_new_active_manager(cls, manager: FigureManagerBase) -> None: ...
+    @classmethod
+    def set_active(cls, manager: FigureManagerBase) -> None: ...
+    @classmethod
+    def draw_all(cls, force: bool = ...) -> None: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_text_helpers.py

@@ -0,0 +1,82 @@
+"""
+Low-level text helper utilities.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+
+from . import _api
+from .ft2font import FT2Font, Kerning, LoadFlags
+
+
+@dataclasses.dataclass(frozen=True)
+class LayoutItem:
+    ft_object: FT2Font
+    char: str
+    glyph_idx: int
+    x: float
+    prev_kern: float
+
+
+def warn_on_missing_glyph(codepoint, fontnames):
+    _api.warn_external(
+        f"Glyph {codepoint} "
+        f"({chr(codepoint).encode('ascii', 'namereplace').decode('ascii')}) "
+        f"missing from font(s) {fontnames}.")
+
+    block = ("Hebrew" if 0x0590 <= codepoint <= 0x05ff else
+             "Arabic" if 0x0600 <= codepoint <= 0x06ff else
+             "Devanagari" if 0x0900 <= codepoint <= 0x097f else
+             "Bengali" if 0x0980 <= codepoint <= 0x09ff else
+             "Gurmukhi" if 0x0a00 <= codepoint <= 0x0a7f else
+             "Gujarati" if 0x0a80 <= codepoint <= 0x0aff else
+             "Oriya" if 0x0b00 <= codepoint <= 0x0b7f else
+             "Tamil" if 0x0b80 <= codepoint <= 0x0bff else
+             "Telugu" if 0x0c00 <= codepoint <= 0x0c7f else
+             "Kannada" if 0x0c80 <= codepoint <= 0x0cff else
+             "Malayalam" if 0x0d00 <= codepoint <= 0x0d7f else
+             "Sinhala" if 0x0d80 <= codepoint <= 0x0dff else
+             None)
+    if block:
+        _api.warn_external(
+            f"Matplotlib currently does not support {block} natively.")
+
+
+def layout(string, font, *, kern_mode=Kerning.DEFAULT):
+    """
+    Render *string* with *font*.
+
+    For each character in *string*, yield a LayoutItem instance. When such an instance
+    is yielded, the font's glyph is set to the corresponding character.
+
+    Parameters
+    ----------
+    string : str
+        The string to be rendered.
+    font : FT2Font
+        The font.
+    kern_mode : Kerning
+        A FreeType kerning mode.
+
+    Yields
+    ------
+    LayoutItem
+    """
+    x = 0
+    prev_glyph_idx = None
+    char_to_font = font._get_fontmap(string)
+    base_font = font
+    for char in string:
+        # This has done the fallback logic
+        font = char_to_font.get(char, base_font)
+        glyph_idx = font.get_char_index(ord(char))
+        kern = (
+            base_font.get_kerning(prev_glyph_idx, glyph_idx, kern_mode) / 64
+            if prev_glyph_idx is not None else 0.
+        )
+        x += kern
+        glyph = font.load_glyph(glyph_idx, flags=LoadFlags.NO_HINTING)
+        yield LayoutItem(font, char, glyph_idx, x, kern)
+        x += glyph.linearHoriAdvance / 65536
+        prev_glyph_idx = glyph_idx

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_tight_bbox.py

@@ -0,0 +1,84 @@
+"""
+Helper module for the *bbox_inches* parameter in `.Figure.savefig`.
+"""
+
+from matplotlib.transforms import Bbox, TransformedBbox, Affine2D
+
+
+def adjust_bbox(fig, bbox_inches, fixed_dpi=None):
+    """
+    Temporarily adjust the figure so that only the specified area
+    (bbox_inches) is saved.
+
+    It modifies fig.bbox, fig.bbox_inches,
+    fig.transFigure._boxout, and fig.patch.  While the figure size
+    changes, the scale of the original figure is conserved.  A
+    function which restores the original values are returned.
+    """
+    origBbox = fig.bbox
+    origBboxInches = fig.bbox_inches
+    _boxout = fig.transFigure._boxout
+
+    old_aspect = []
+    locator_list = []
+    sentinel = object()
+    for ax in fig.axes:
+        locator = ax.get_axes_locator()
+        if locator is not None:
+            ax.apply_aspect(locator(ax, None))
+        locator_list.append(locator)
+        current_pos = ax.get_position(original=False).frozen()
+        ax.set_axes_locator(lambda a, r, _pos=current_pos: _pos)
+        # override the method that enforces the aspect ratio on the Axes
+        if 'apply_aspect' in ax.__dict__:
+            old_aspect.append(ax.apply_aspect)
+        else:
+            old_aspect.append(sentinel)
+        ax.apply_aspect = lambda pos=None: None
+
+    def restore_bbox():
+        for ax, loc, aspect in zip(fig.axes, locator_list, old_aspect):
+            ax.set_axes_locator(loc)
+            if aspect is sentinel:
+                # delete our no-op function which un-hides the original method
+                del ax.apply_aspect
+            else:
+                ax.apply_aspect = aspect
+
+        fig.bbox = origBbox
+        fig.bbox_inches = origBboxInches
+        fig.transFigure._boxout = _boxout
+        fig.transFigure.invalidate()
+        fig.patch.set_bounds(0, 0, 1, 1)
+
+    if fixed_dpi is None:
+        fixed_dpi = fig.dpi
+    tr = Affine2D().scale(fixed_dpi)
+    dpi_scale = fixed_dpi / fig.dpi
+
+    fig.bbox_inches = Bbox.from_bounds(0, 0, *bbox_inches.size)
+    x0, y0 = tr.transform(bbox_inches.p0)
+    w1, h1 = fig.bbox.size * dpi_scale
+    fig.transFigure._boxout = Bbox.from_bounds(-x0, -y0, w1, h1)
+    fig.transFigure.invalidate()
+
+    fig.bbox = TransformedBbox(fig.bbox_inches, tr)
+
+    fig.patch.set_bounds(x0 / w1, y0 / h1,
+                         fig.bbox.width / w1, fig.bbox.height / h1)
+
+    return restore_bbox
+
+
+def process_figure_for_rasterizing(fig, bbox_inches_restore, fixed_dpi=None):
+    """
+    A function that needs to be called when figure dpi changes during the
+    drawing (e.g., rasterizing).  It recovers the bbox and re-adjust it with
+    the new dpi.
+    """
+
+    bbox_inches, restore_bbox = bbox_inches_restore
+    restore_bbox()
+    r = adjust_bbox(fig, bbox_inches, fixed_dpi)
+
+    return bbox_inches, r

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_tight_layout.py

@@ -0,0 +1,301 @@
+"""
+Routines to adjust subplot params so that subplots are
+nicely fit in the figure. In doing so, only axis labels, tick labels, Axes
+titles and offsetboxes that are anchored to Axes are currently considered.
+
+Internally, this module assumes that the margins (left margin, etc.) which are
+differences between ``Axes.get_tightbbox`` and ``Axes.bbox`` are independent of
+Axes position. This may fail if ``Axes.adjustable`` is ``datalim`` as well as
+such cases as when left or right margin are affected by xlabel.
+"""
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib import _api, artist as martist
+from matplotlib.font_manager import FontProperties
+from matplotlib.transforms import Bbox
+
+
+def _auto_adjust_subplotpars(
+        fig, renderer, shape, span_pairs, subplot_list,
+        ax_bbox_list=None, pad=1.08, h_pad=None, w_pad=None, rect=None):
+    """
+    Return a dict of subplot parameters to adjust spacing between subplots
+    or ``None`` if resulting Axes would have zero height or width.
+
+    Note that this function ignores geometry information of subplot itself, but
+    uses what is given by the *shape* and *subplot_list* parameters.  Also, the
+    results could be incorrect if some subplots have ``adjustable=datalim``.
+
+    Parameters
+    ----------
+    shape : tuple[int, int]
+        Number of rows and columns of the grid.
+    span_pairs : list[tuple[slice, slice]]
+        List of rowspans and colspans occupied by each subplot.
+    subplot_list : list of subplots
+        List of subplots that will be used to calculate optimal subplot_params.
+    pad : float
+        Padding between the figure edge and the edges of subplots, as a
+        fraction of the font size.
+    h_pad, w_pad : float
+        Padding (height/width) between edges of adjacent subplots, as a
+        fraction of the font size.  Defaults to *pad*.
+    rect : tuple
+        (left, bottom, right, top), default: None.
+    """
+    rows, cols = shape
+
+    font_size_inch = (FontProperties(
+        size=mpl.rcParams["font.size"]).get_size_in_points() / 72)
+    pad_inch = pad * font_size_inch
+    vpad_inch = h_pad * font_size_inch if h_pad is not None else pad_inch
+    hpad_inch = w_pad * font_size_inch if w_pad is not None else pad_inch
+
+    if len(span_pairs) != len(subplot_list) or len(subplot_list) == 0:
+        raise ValueError
+
+    if rect is None:
+        margin_left = margin_bottom = margin_right = margin_top = None
+    else:
+        margin_left, margin_bottom, _right, _top = rect
+        margin_right = 1 - _right if _right else None
+        margin_top = 1 - _top if _top else None
+
+    vspaces = np.zeros((rows + 1, cols))
+    hspaces = np.zeros((rows, cols + 1))
+
+    if ax_bbox_list is None:
+        ax_bbox_list = [
+            Bbox.union([ax.get_position(original=True) for ax in subplots])
+            for subplots in subplot_list]
+
+    for subplots, ax_bbox, (rowspan, colspan) in zip(
+            subplot_list, ax_bbox_list, span_pairs):
+        if all(not ax.get_visible() for ax in subplots):
+            continue
+
+        bb = []
+        for ax in subplots:
+            if ax.get_visible():
+                bb += [martist._get_tightbbox_for_layout_only(ax, renderer)]
+
+        tight_bbox_raw = Bbox.union(bb)
+        tight_bbox = fig.transFigure.inverted().transform_bbox(tight_bbox_raw)
+
+        hspaces[rowspan, colspan.start] += ax_bbox.xmin - tight_bbox.xmin  # l
+        hspaces[rowspan, colspan.stop] += tight_bbox.xmax - ax_bbox.xmax  # r
+        vspaces[rowspan.start, colspan] += tight_bbox.ymax - ax_bbox.ymax  # t
+        vspaces[rowspan.stop, colspan] += ax_bbox.ymin - tight_bbox.ymin  # b
+
+    fig_width_inch, fig_height_inch = fig.get_size_inches()
+
+    # margins can be negative for Axes with aspect applied, so use max(, 0) to
+    # make them nonnegative.
+    if not margin_left:
+        margin_left = max(hspaces[:, 0].max(), 0) + pad_inch/fig_width_inch
+        suplabel = fig._supylabel
+        if suplabel and suplabel.get_in_layout():
+            rel_width = fig.transFigure.inverted().transform_bbox(
+                suplabel.get_window_extent(renderer)).width
+            margin_left += rel_width + pad_inch/fig_width_inch
+    if not margin_right:
+        margin_right = max(hspaces[:, -1].max(), 0) + pad_inch/fig_width_inch
+    if not margin_top:
+        margin_top = max(vspaces[0, :].max(), 0) + pad_inch/fig_height_inch
+        if fig._suptitle and fig._suptitle.get_in_layout():
+            rel_height = fig.transFigure.inverted().transform_bbox(
+                fig._suptitle.get_window_extent(renderer)).height
+            margin_top += rel_height + pad_inch/fig_height_inch
+    if not margin_bottom:
+        margin_bottom = max(vspaces[-1, :].max(), 0) + pad_inch/fig_height_inch
+        suplabel = fig._supxlabel
+        if suplabel and suplabel.get_in_layout():
+            rel_height = fig.transFigure.inverted().transform_bbox(
+                suplabel.get_window_extent(renderer)).height
+            margin_bottom += rel_height + pad_inch/fig_height_inch
+
+    if margin_left + margin_right >= 1:
+        _api.warn_external('Tight layout not applied. The left and right '
+                           'margins cannot be made large enough to '
+                           'accommodate all Axes decorations.')
+        return None
+    if margin_bottom + margin_top >= 1:
+        _api.warn_external('Tight layout not applied. The bottom and top '
+                           'margins cannot be made large enough to '
+                           'accommodate all Axes decorations.')
+        return None
+
+    kwargs = dict(left=margin_left,
+                  right=1 - margin_right,
+                  bottom=margin_bottom,
+                  top=1 - margin_top)
+
+    if cols > 1:
+        hspace = hspaces[:, 1:-1].max() + hpad_inch / fig_width_inch
+        # axes widths:
+        h_axes = (1 - margin_right - margin_left - hspace * (cols - 1)) / cols
+        if h_axes < 0:
+            _api.warn_external('Tight layout not applied. tight_layout '
+                               'cannot make Axes width small enough to '
+                               'accommodate all Axes decorations')
+            return None
+        else:
+            kwargs["wspace"] = hspace / h_axes
+    if rows > 1:
+        vspace = vspaces[1:-1, :].max() + vpad_inch / fig_height_inch
+        v_axes = (1 - margin_top - margin_bottom - vspace * (rows - 1)) / rows
+        if v_axes < 0:
+            _api.warn_external('Tight layout not applied. tight_layout '
+                               'cannot make Axes height small enough to '
+                               'accommodate all Axes decorations.')
+            return None
+        else:
+            kwargs["hspace"] = vspace / v_axes
+
+    return kwargs
+
+
+def get_subplotspec_list(axes_list, grid_spec=None):
+    """
+    Return a list of subplotspec from the given list of Axes.
+
+    For an instance of Axes that does not support subplotspec, None is inserted
+    in the list.
+
+    If grid_spec is given, None is inserted for those not from the given
+    grid_spec.
+    """
+    subplotspec_list = []
+    for ax in axes_list:
+        axes_or_locator = ax.get_axes_locator()
+        if axes_or_locator is None:
+            axes_or_locator = ax
+
+        if hasattr(axes_or_locator, "get_subplotspec"):
+            subplotspec = axes_or_locator.get_subplotspec()
+            if subplotspec is not None:
+                subplotspec = subplotspec.get_topmost_subplotspec()
+                gs = subplotspec.get_gridspec()
+                if grid_spec is not None:
+                    if gs != grid_spec:
+                        subplotspec = None
+                elif gs.locally_modified_subplot_params():
+                    subplotspec = None
+        else:
+            subplotspec = None
+
+        subplotspec_list.append(subplotspec)
+
+    return subplotspec_list
+
+
+def get_tight_layout_figure(fig, axes_list, subplotspec_list, renderer,
+                            pad=1.08, h_pad=None, w_pad=None, rect=None):
+    """
+    Return subplot parameters for tight-layouted-figure with specified padding.
+
+    Parameters
+    ----------
+    fig : Figure
+    axes_list : list of Axes
+    subplotspec_list : list of `.SubplotSpec`
+        The subplotspecs of each Axes.
+    renderer : renderer
+    pad : float
+        Padding between the figure edge and the edges of subplots, as a
+        fraction of the font size.
+    h_pad, w_pad : float
+        Padding (height/width) between edges of adjacent subplots.  Defaults to
+        *pad*.
+    rect : tuple (left, bottom, right, top), default: None.
+        rectangle in normalized figure coordinates
+        that the whole subplots area (including labels) will fit into.
+        Defaults to using the entire figure.
+
+    Returns
+    -------
+    subplotspec or None
+        subplotspec kwargs to be passed to `.Figure.subplots_adjust` or
+        None if tight_layout could not be accomplished.
+    """
+
+    # Multiple Axes can share same subplotspec (e.g., if using axes_grid1);
+    # we need to group them together.
+    ss_to_subplots = {ss: [] for ss in subplotspec_list}
+    for ax, ss in zip(axes_list, subplotspec_list):
+        ss_to_subplots[ss].append(ax)
+    if ss_to_subplots.pop(None, None):
+        _api.warn_external(
+            "This figure includes Axes that are not compatible with "
+            "tight_layout, so results might be incorrect.")
+    if not ss_to_subplots:
+        return {}
+    subplot_list = list(ss_to_subplots.values())
+    ax_bbox_list = [ss.get_position(fig) for ss in ss_to_subplots]
+
+    max_nrows = max(ss.get_gridspec().nrows for ss in ss_to_subplots)
+    max_ncols = max(ss.get_gridspec().ncols for ss in ss_to_subplots)
+
+    span_pairs = []
+    for ss in ss_to_subplots:
+        # The intent here is to support Axes from different gridspecs where
+        # one's nrows (or ncols) is a multiple of the other (e.g. 2 and 4),
+        # but this doesn't actually work because the computed wspace, in
+        # relative-axes-height, corresponds to different physical spacings for
+        # the 2-row grid and the 4-row grid.  Still, this code is left, mostly
+        # for backcompat.
+        rows, cols = ss.get_gridspec().get_geometry()
+        div_row, mod_row = divmod(max_nrows, rows)
+        div_col, mod_col = divmod(max_ncols, cols)
+        if mod_row != 0:
+            _api.warn_external('tight_layout not applied: number of rows '
+                               'in subplot specifications must be '
+                               'multiples of one another.')
+            return {}
+        if mod_col != 0:
+            _api.warn_external('tight_layout not applied: number of '
+                               'columns in subplot specifications must be '
+                               'multiples of one another.')
+            return {}
+        span_pairs.append((
+            slice(ss.rowspan.start * div_row, ss.rowspan.stop * div_row),
+            slice(ss.colspan.start * div_col, ss.colspan.stop * div_col)))
+
+    kwargs = _auto_adjust_subplotpars(fig, renderer,
+                                      shape=(max_nrows, max_ncols),
+                                      span_pairs=span_pairs,
+                                      subplot_list=subplot_list,
+                                      ax_bbox_list=ax_bbox_list,
+                                      pad=pad, h_pad=h_pad, w_pad=w_pad)
+
+    # kwargs can be none if tight_layout fails...
+    if rect is not None and kwargs is not None:
+        # if rect is given, the whole subplots area (including
+        # labels) will fit into the rect instead of the
+        # figure. Note that the rect argument of
+        # *auto_adjust_subplotpars* specify the area that will be
+        # covered by the total area of axes.bbox. Thus we call
+        # auto_adjust_subplotpars twice, where the second run
+        # with adjusted rect parameters.
+
+        left, bottom, right, top = rect
+        if left is not None:
+            left += kwargs["left"]
+        if bottom is not None:
+            bottom += kwargs["bottom"]
+        if right is not None:
+            right -= (1 - kwargs["right"])
+        if top is not None:
+            top -= (1 - kwargs["top"])
+
+        kwargs = _auto_adjust_subplotpars(fig, renderer,
+                                          shape=(max_nrows, max_ncols),
+                                          span_pairs=span_pairs,
+                                          subplot_list=subplot_list,
+                                          ax_bbox_list=ax_bbox_list,
+                                          pad=pad, h_pad=h_pad, w_pad=w_pad,
+                                          rect=(left, bottom, right, top))
+
+    return kwargs

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_tri.pyi

@@ -0,0 +1,36 @@
+# This is a private module implemented in C++
+from typing import final
+
+import numpy as np
+import numpy.typing as npt
+
+@final
+class TrapezoidMapTriFinder:
+    def __init__(self, triangulation: Triangulation): ...
+    def find_many(self, x: npt.NDArray[np.float64], y: npt.NDArray[np.float64]) -> npt.NDArray[np.int_]: ...
+    def get_tree_stats(self) -> list[int | float]: ...
+    def initialize(self) -> None: ...
+    def print_tree(self) -> None: ...
+
+@final
+class TriContourGenerator:
+    def __init__(self, triangulation: Triangulation, z: npt.NDArray[np.float64]): ...
+    def create_contour(self, level: float) -> tuple[list[float], list[int]]: ...
+    def create_filled_contour(self, lower_level: float, upper_level: float) -> tuple[list[float], list[int]]: ...
+
+@final
+class Triangulation:
+    def __init__(
+        self,
+        x: npt.NDArray[np.float64],
+        y: npt.NDArray[np.float64],
+        triangles: npt.NDArray[np.int_],
+        mask: npt.NDArray[np.bool_] | tuple[()],
+        edges: npt.NDArray[np.int_] | tuple[()],
+        neighbors: npt.NDArray[np.int_] | tuple[()],
+        correct_triangle_orientation: bool,
+    ): ...
+    def calculate_plane_coefficients(self, z: npt.ArrayLike) -> npt.NDArray[np.float64]: ...
+    def get_edges(self) -> npt.NDArray[np.int_]: ...
+    def get_neighbors(self) -> npt.NDArray[np.int_]: ...
+    def set_mask(self, mask: npt.NDArray[np.bool_] | tuple[()]) -> None: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_type1font.py

@@ -0,0 +1,879 @@
+"""
+A class representing a Type 1 font.
+
+This version reads pfa and pfb files and splits them for embedding in
+pdf files. It also supports SlantFont and ExtendFont transformations,
+similarly to pdfTeX and friends. There is no support yet for subsetting.
+
+Usage::
+
+    font = Type1Font(filename)
+    clear_part, encrypted_part, finale = font.parts
+    slanted_font = font.transform({'slant': 0.167})
+    extended_font = font.transform({'extend': 1.2})
+
+Sources:
+
+* Adobe Technical Note #5040, Supporting Downloadable PostScript
+  Language Fonts.
+
+* Adobe Type 1 Font Format, Adobe Systems Incorporated, third printing,
+  v1.1, 1993. ISBN 0-201-57044-0.
+"""
+
+from __future__ import annotations
+
+import binascii
+import functools
+import logging
+import re
+import string
+import struct
+import typing as T
+
+import numpy as np
+
+from matplotlib.cbook import _format_approx
+from . import _api
+
+_log = logging.getLogger(__name__)
+
+
+class _Token:
+    """
+    A token in a PostScript stream.
+
+    Attributes
+    ----------
+    pos : int
+        Position, i.e. offset from the beginning of the data.
+    raw : str
+        Raw text of the token.
+    kind : str
+        Description of the token (for debugging or testing).
+    """
+    __slots__ = ('pos', 'raw')
+    kind = '?'
+
+    def __init__(self, pos, raw):
+        _log.debug('type1font._Token %s at %d: %r', self.kind, pos, raw)
+        self.pos = pos
+        self.raw = raw
+
+    def __str__(self):
+        return f"<{self.kind} {self.raw} @{self.pos}>"
+
+    def endpos(self):
+        """Position one past the end of the token"""
+        return self.pos + len(self.raw)
+
+    def is_keyword(self, *names):
+        """Is this a name token with one of the names?"""
+        return False
+
+    def is_slash_name(self):
+        """Is this a name token that starts with a slash?"""
+        return False
+
+    def is_delim(self):
+        """Is this a delimiter token?"""
+        return False
+
+    def is_number(self):
+        """Is this a number token?"""
+        return False
+
+    def value(self):
+        return self.raw
+
+
+class _NameToken(_Token):
+    kind = 'name'
+
+    def is_slash_name(self):
+        return self.raw.startswith('/')
+
+    def value(self):
+        return self.raw[1:]
+
+
+class _BooleanToken(_Token):
+    kind = 'boolean'
+
+    def value(self):
+        return self.raw == 'true'
+
+
+class _KeywordToken(_Token):
+    kind = 'keyword'
+
+    def is_keyword(self, *names):
+        return self.raw in names
+
+
+class _DelimiterToken(_Token):
+    kind = 'delimiter'
+
+    def is_delim(self):
+        return True
+
+    def opposite(self):
+        return {'[': ']', ']': '[',
+                '{': '}', '}': '{',
+                '<<': '>>', '>>': '<<'
+                }[self.raw]
+
+
+class _WhitespaceToken(_Token):
+    kind = 'whitespace'
+
+
+class _StringToken(_Token):
+    kind = 'string'
+    _escapes_re = re.compile(r'\\([\\()nrtbf]|[0-7]{1,3})')
+    _replacements = {'\\': '\\', '(': '(', ')': ')', 'n': '\n',
+                     'r': '\r', 't': '\t', 'b': '\b', 'f': '\f'}
+    _ws_re = re.compile('[\0\t\r\f\n ]')
+
+    @classmethod
+    def _escape(cls, match):
+        group = match.group(1)
+        try:
+            return cls._replacements[group]
+        except KeyError:
+            return chr(int(group, 8))
+
+    @functools.lru_cache
+    def value(self):
+        if self.raw[0] == '(':
+            return self._escapes_re.sub(self._escape, self.raw[1:-1])
+        else:
+            data = self._ws_re.sub('', self.raw[1:-1])
+            if len(data) % 2 == 1:
+                data += '0'
+            return binascii.unhexlify(data)
+
+
+class _BinaryToken(_Token):
+    kind = 'binary'
+
+    def value(self):
+        return self.raw[1:]
+
+
+class _NumberToken(_Token):
+    kind = 'number'
+
+    def is_number(self):
+        return True
+
+    def value(self):
+        if '.' not in self.raw:
+            return int(self.raw)
+        else:
+            return float(self.raw)
+
+
+def _tokenize(data: bytes, skip_ws: bool) -> T.Generator[_Token, int, None]:
+    """
+    A generator that produces _Token instances from Type-1 font code.
+
+    The consumer of the generator may send an integer to the tokenizer to
+    indicate that the next token should be _BinaryToken of the given length.
+
+    Parameters
+    ----------
+    data : bytes
+        The data of the font to tokenize.
+
+    skip_ws : bool
+        If true, the generator will drop any _WhitespaceTokens from the output.
+    """
+
+    text = data.decode('ascii', 'replace')
+    whitespace_or_comment_re = re.compile(r'[\0\t\r\f\n ]+|%[^\r\n]*')
+    token_re = re.compile(r'/{0,2}[^]\0\t\r\f\n ()<>{}/%[]+')
+    instring_re = re.compile(r'[()\\]')
+    hex_re = re.compile(r'^<[0-9a-fA-F\0\t\r\f\n ]*>$')
+    oct_re = re.compile(r'[0-7]{1,3}')
+    pos = 0
+    next_binary: int | None = None
+
+    while pos < len(text):
+        if next_binary is not None:
+            n = next_binary
+            next_binary = (yield _BinaryToken(pos, data[pos:pos+n]))
+            pos += n
+            continue
+        match = whitespace_or_comment_re.match(text, pos)
+        if match:
+            if not skip_ws:
+                next_binary = (yield _WhitespaceToken(pos, match.group()))
+            pos = match.end()
+        elif text[pos] == '(':
+            # PostScript string rules:
+            # - parentheses must be balanced
+            # - backslashes escape backslashes and parens
+            # - also codes \n\r\t\b\f and octal escapes are recognized
+            # - other backslashes do not escape anything
+            start = pos
+            pos += 1
+            depth = 1
+            while depth:
+                match = instring_re.search(text, pos)
+                if match is None:
+                    raise ValueError(
+                        f'Unterminated string starting at {start}')
+                pos = match.end()
+                if match.group() == '(':
+                    depth += 1
+                elif match.group() == ')':
+                    depth -= 1
+                else:  # a backslash
+                    char = text[pos]
+                    if char in r'\()nrtbf':
+                        pos += 1
+                    else:
+                        octal = oct_re.match(text, pos)
+                        if octal:
+                            pos = octal.end()
+                        else:
+                            pass  # non-escaping backslash
+            next_binary = (yield _StringToken(start, text[start:pos]))
+        elif text[pos:pos + 2] in ('<<', '>>'):
+            next_binary = (yield _DelimiterToken(pos, text[pos:pos + 2]))
+            pos += 2
+        elif text[pos] == '<':
+            start = pos
+            try:
+                pos = text.index('>', pos) + 1
+            except ValueError as e:
+                raise ValueError(f'Unterminated hex string starting at {start}'
+                                 ) from e
+            if not hex_re.match(text[start:pos]):
+                raise ValueError(f'Malformed hex string starting at {start}')
+            next_binary = (yield _StringToken(pos, text[start:pos]))
+        else:
+            match = token_re.match(text, pos)
+            if match:
+                raw = match.group()
+                if raw.startswith('/'):
+                    next_binary = (yield _NameToken(pos, raw))
+                elif match.group() in ('true', 'false'):
+                    next_binary = (yield _BooleanToken(pos, raw))
+                else:
+                    try:
+                        float(raw)
+                        next_binary = (yield _NumberToken(pos, raw))
+                    except ValueError:
+                        next_binary = (yield _KeywordToken(pos, raw))
+                pos = match.end()
+            else:
+                next_binary = (yield _DelimiterToken(pos, text[pos]))
+                pos += 1
+
+
+class _BalancedExpression(_Token):
+    pass
+
+
+def _expression(initial, tokens, data):
+    """
+    Consume some number of tokens and return a balanced PostScript expression.
+
+    Parameters
+    ----------
+    initial : _Token
+        The token that triggered parsing a balanced expression.
+    tokens : iterator of _Token
+        Following tokens.
+    data : bytes
+        Underlying data that the token positions point to.
+
+    Returns
+    -------
+    _BalancedExpression
+    """
+    delim_stack = []
+    token = initial
+    while True:
+        if token.is_delim():
+            if token.raw in ('[', '{'):
+                delim_stack.append(token)
+            elif token.raw in (']', '}'):
+                if not delim_stack:
+                    raise RuntimeError(f"unmatched closing token {token}")
+                match = delim_stack.pop()
+                if match.raw != token.opposite():
+                    raise RuntimeError(
+                        f"opening token {match} closed by {token}"
+                    )
+                if not delim_stack:
+                    break
+            else:
+                raise RuntimeError(f'unknown delimiter {token}')
+        elif not delim_stack:
+            break
+        token = next(tokens)
+    return _BalancedExpression(
+        initial.pos,
+        data[initial.pos:token.endpos()].decode('ascii', 'replace')
+    )
+
+
+class Type1Font:
+    """
+    A class representing a Type-1 font, for use by backends.
+
+    Attributes
+    ----------
+    parts : tuple
+        A 3-tuple of the cleartext part, the encrypted part, and the finale of
+        zeros.
+
+    decrypted : bytes
+        The decrypted form of ``parts[1]``.
+
+    prop : dict[str, Any]
+        A dictionary of font properties. Noteworthy keys include:
+
+        - FontName: PostScript name of the font
+        - Encoding: dict from numeric codes to glyph names
+        - FontMatrix: bytes object encoding a matrix
+        - UniqueID: optional font identifier, dropped when modifying the font
+        - CharStrings: dict from glyph names to byte code
+        - Subrs: array of byte code subroutines
+        - OtherSubrs: bytes object encoding some PostScript code
+    """
+    __slots__ = ('parts', 'decrypted', 'prop', '_pos', '_abbr')
+    # the _pos dict contains (begin, end) indices to parts[0] + decrypted
+    # so that they can be replaced when transforming the font;
+    # but since sometimes a definition appears in both parts[0] and decrypted,
+    # _pos[name] is an array of such pairs
+    #
+    # _abbr maps three standard abbreviations to their particular names in
+    # this font (e.g. 'RD' is named '-|' in some fonts)
+
+    def __init__(self, input):
+        """
+        Initialize a Type-1 font.
+
+        Parameters
+        ----------
+        input : str or 3-tuple
+            Either a pfb file name, or a 3-tuple of already-decoded Type-1
+            font `~.Type1Font.parts`.
+        """
+        if isinstance(input, tuple) and len(input) == 3:
+            self.parts = input
+        else:
+            with open(input, 'rb') as file:
+                data = self._read(file)
+            self.parts = self._split(data)
+
+        self.decrypted = self._decrypt(self.parts[1], 'eexec')
+        self._abbr = {'RD': 'RD', 'ND': 'ND', 'NP': 'NP'}
+        self._parse()
+
+    def _read(self, file):
+        """Read the font from a file, decoding into usable parts."""
+        rawdata = file.read()
+        if not rawdata.startswith(b'\x80'):
+            return rawdata
+
+        data = b''
+        while rawdata:
+            if not rawdata.startswith(b'\x80'):
+                raise RuntimeError('Broken pfb file (expected byte 128, '
+                                   'got %d)' % rawdata[0])
+            type = rawdata[1]
+            if type in (1, 2):
+                length, = struct.unpack('<i', rawdata[2:6])
+                segment = rawdata[6:6 + length]
+                rawdata = rawdata[6 + length:]
+
+            if type == 1:       # ASCII text: include verbatim
+                data += segment
+            elif type == 2:     # binary data: encode in hexadecimal
+                data += binascii.hexlify(segment)
+            elif type == 3:     # end of file
+                break
+            else:
+                raise RuntimeError('Unknown segment type %d in pfb file' % type)
+
+        return data
+
+    def _split(self, data):
+        """
+        Split the Type 1 font into its three main parts.
+
+        The three parts are: (1) the cleartext part, which ends in a
+        eexec operator; (2) the encrypted part; (3) the fixed part,
+        which contains 512 ASCII zeros possibly divided on various
+        lines, a cleartomark operator, and possibly something else.
+        """
+
+        # Cleartext part: just find the eexec and skip whitespace
+        idx = data.index(b'eexec')
+        idx += len(b'eexec')
+        while data[idx] in b' \t\r\n':
+            idx += 1
+        len1 = idx
+
+        # Encrypted part: find the cleartomark operator and count
+        # zeros backward
+        idx = data.rindex(b'cleartomark') - 1
+        zeros = 512
+        while zeros and data[idx] in b'0' or data[idx] in b'\r\n':
+            if data[idx] in b'0':
+                zeros -= 1
+            idx -= 1
+        if zeros:
+            # this may have been a problem on old implementations that
+            # used the zeros as necessary padding
+            _log.info('Insufficiently many zeros in Type 1 font')
+
+        # Convert encrypted part to binary (if we read a pfb file, we may end
+        # up converting binary to hexadecimal to binary again; but if we read
+        # a pfa file, this part is already in hex, and I am not quite sure if
+        # even the pfb format guarantees that it will be in binary).
+        idx1 = len1 + ((idx - len1 + 2) & ~1)  # ensure an even number of bytes
+        binary = binascii.unhexlify(data[len1:idx1])
+
+        return data[:len1], binary, data[idx+1:]
+
+    @staticmethod
+    def _decrypt(ciphertext, key, ndiscard=4):
+        """
+        Decrypt ciphertext using the Type-1 font algorithm.
+
+        The algorithm is described in Adobe's "Adobe Type 1 Font Format".
+        The key argument can be an integer, or one of the strings
+        'eexec' and 'charstring', which map to the key specified for the
+        corresponding part of Type-1 fonts.
+
+        The ndiscard argument should be an integer, usually 4.
+        That number of bytes is discarded from the beginning of plaintext.
+        """
+
+        key = _api.check_getitem({'eexec': 55665, 'charstring': 4330}, key=key)
+        plaintext = []
+        for byte in ciphertext:
+            plaintext.append(byte ^ (key >> 8))
+            key = ((key+byte) * 52845 + 22719) & 0xffff
+
+        return bytes(plaintext[ndiscard:])
+
+    @staticmethod
+    def _encrypt(plaintext, key, ndiscard=4):
+        """
+        Encrypt plaintext using the Type-1 font algorithm.
+
+        The algorithm is described in Adobe's "Adobe Type 1 Font Format".
+        The key argument can be an integer, or one of the strings
+        'eexec' and 'charstring', which map to the key specified for the
+        corresponding part of Type-1 fonts.
+
+        The ndiscard argument should be an integer, usually 4. That
+        number of bytes is prepended to the plaintext before encryption.
+        This function prepends NUL bytes for reproducibility, even though
+        the original algorithm uses random bytes, presumably to avoid
+        cryptanalysis.
+        """
+
+        key = _api.check_getitem({'eexec': 55665, 'charstring': 4330}, key=key)
+        ciphertext = []
+        for byte in b'\0' * ndiscard + plaintext:
+            c = byte ^ (key >> 8)
+            ciphertext.append(c)
+            key = ((key + c) * 52845 + 22719) & 0xffff
+
+        return bytes(ciphertext)
+
+    def _parse(self):
+        """
+        Find the values of various font properties. This limited kind
+        of parsing is described in Chapter 10 "Adobe Type Manager
+        Compatibility" of the Type-1 spec.
+        """
+        # Start with reasonable defaults
+        prop = {'Weight': 'Regular', 'ItalicAngle': 0.0, 'isFixedPitch': False,
+                'UnderlinePosition': -100, 'UnderlineThickness': 50}
+        pos = {}
+        data = self.parts[0] + self.decrypted
+
+        source = _tokenize(data, True)
+        while True:
+            # See if there is a key to be assigned a value
+            # e.g. /FontName in /FontName /Helvetica def
+            try:
+                token = next(source)
+            except StopIteration:
+                break
+            if token.is_delim():
+                # skip over this - we want top-level keys only
+                _expression(token, source, data)
+            if token.is_slash_name():
+                key = token.value()
+                keypos = token.pos
+            else:
+                continue
+
+            # Some values need special parsing
+            if key in ('Subrs', 'CharStrings', 'Encoding', 'OtherSubrs'):
+                prop[key], endpos = {
+                    'Subrs': self._parse_subrs,
+                    'CharStrings': self._parse_charstrings,
+                    'Encoding': self._parse_encoding,
+                    'OtherSubrs': self._parse_othersubrs
+                }[key](source, data)
+                pos.setdefault(key, []).append((keypos, endpos))
+                continue
+
+            try:
+                token = next(source)
+            except StopIteration:
+                break
+
+            if isinstance(token, _KeywordToken):
+                # constructs like
+                # FontDirectory /Helvetica known {...} {...} ifelse
+                # mean the key was not really a key
+                continue
+
+            if token.is_delim():
+                value = _expression(token, source, data).raw
+            else:
+                value = token.value()
+
+            # look for a 'def' possibly preceded by access modifiers
+            try:
+                kw = next(
+                    kw for kw in source
+                    if not kw.is_keyword('readonly', 'noaccess', 'executeonly')
+                )
+            except StopIteration:
+                break
+
+            # sometimes noaccess def and readonly def are abbreviated
+            if kw.is_keyword('def', self._abbr['ND'], self._abbr['NP']):
+                prop[key] = value
+                pos.setdefault(key, []).append((keypos, kw.endpos()))
+
+            # detect the standard abbreviations
+            if value == '{noaccess def}':
+                self._abbr['ND'] = key
+            elif value == '{noaccess put}':
+                self._abbr['NP'] = key
+            elif value == '{string currentfile exch readstring pop}':
+                self._abbr['RD'] = key
+
+        # Fill in the various *Name properties
+        if 'FontName' not in prop:
+            prop['FontName'] = (prop.get('FullName') or
+                                prop.get('FamilyName') or
+                                'Unknown')
+        if 'FullName' not in prop:
+            prop['FullName'] = prop['FontName']
+        if 'FamilyName' not in prop:
+            extras = ('(?i)([ -](regular|plain|italic|oblique|(semi)?bold|'
+                      '(ultra)?light|extra|condensed))+$')
+            prop['FamilyName'] = re.sub(extras, '', prop['FullName'])
+        # Decrypt the encrypted parts
+        ndiscard = prop.get('lenIV', 4)
+        cs = prop['CharStrings']
+        for key, value in cs.items():
+            cs[key] = self._decrypt(value, 'charstring', ndiscard)
+        if 'Subrs' in prop:
+            prop['Subrs'] = [
+                self._decrypt(value, 'charstring', ndiscard)
+                for value in prop['Subrs']
+            ]
+
+        self.prop = prop
+        self._pos = pos
+
+    def _parse_subrs(self, tokens, _data):
+        count_token = next(tokens)
+        if not count_token.is_number():
+            raise RuntimeError(
+                f"Token following /Subrs must be a number, was {count_token}"
+            )
+        count = count_token.value()
+        array = [None] * count
+        next(t for t in tokens if t.is_keyword('array'))
+        for _ in range(count):
+            next(t for t in tokens if t.is_keyword('dup'))
+            index_token = next(tokens)
+            if not index_token.is_number():
+                raise RuntimeError(
+                    "Token following dup in Subrs definition must be a "
+                    f"number, was {index_token}"
+                )
+            nbytes_token = next(tokens)
+            if not nbytes_token.is_number():
+                raise RuntimeError(
+                    "Second token following dup in Subrs definition must "
+                    f"be a number, was {nbytes_token}"
+                )
+            token = next(tokens)
+            if not token.is_keyword(self._abbr['RD']):
+                raise RuntimeError(
+                    f"Token preceding subr must be {self._abbr['RD']}, "
+                    f"was {token}"
+                )
+            binary_token = tokens.send(1+nbytes_token.value())
+            array[index_token.value()] = binary_token.value()
+
+        return array, next(tokens).endpos()
+
+    @staticmethod
+    def _parse_charstrings(tokens, _data):
+        count_token = next(tokens)
+        if not count_token.is_number():
+            raise RuntimeError(
+                "Token following /CharStrings must be a number, "
+                f"was {count_token}"
+            )
+        count = count_token.value()
+        charstrings = {}
+        next(t for t in tokens if t.is_keyword('begin'))
+        while True:
+            token = next(t for t in tokens
+                         if t.is_keyword('end') or t.is_slash_name())
+            if token.raw == 'end':
+                return charstrings, token.endpos()
+            glyphname = token.value()
+            nbytes_token = next(tokens)
+            if not nbytes_token.is_number():
+                raise RuntimeError(
+                    f"Token following /{glyphname} in CharStrings definition "
+                    f"must be a number, was {nbytes_token}"
+                )
+            next(tokens)  # usually RD or |-
+            binary_token = tokens.send(1+nbytes_token.value())
+            charstrings[glyphname] = binary_token.value()
+
+    @staticmethod
+    def _parse_encoding(tokens, _data):
+        # this only works for encodings that follow the Adobe manual
+        # but some old fonts include non-compliant data - we log a warning
+        # and return a possibly incomplete encoding
+        encoding = {}
+        while True:
+            token = next(t for t in tokens
+                         if t.is_keyword('StandardEncoding', 'dup', 'def'))
+            if token.is_keyword('StandardEncoding'):
+                return _StandardEncoding, token.endpos()
+            if token.is_keyword('def'):
+                return encoding, token.endpos()
+            index_token = next(tokens)
+            if not index_token.is_number():
+                _log.warning(
+                    f"Parsing encoding: expected number, got {index_token}"
+                )
+                continue
+            name_token = next(tokens)
+            if not name_token.is_slash_name():
+                _log.warning(
+                    f"Parsing encoding: expected slash-name, got {name_token}"
+                )
+                continue
+            encoding[index_token.value()] = name_token.value()
+
+    @staticmethod
+    def _parse_othersubrs(tokens, data):
+        init_pos = None
+        while True:
+            token = next(tokens)
+            if init_pos is None:
+                init_pos = token.pos
+            if token.is_delim():
+                _expression(token, tokens, data)
+            elif token.is_keyword('def', 'ND', '|-'):
+                return data[init_pos:token.endpos()], token.endpos()
+
+    def transform(self, effects):
+        """
+        Return a new font that is slanted and/or extended.
+
+        Parameters
+        ----------
+        effects : dict
+            A dict with optional entries:
+
+            - 'slant' : float, default: 0
+                Tangent of the angle that the font is to be slanted to the
+                right. Negative values slant to the left.
+            - 'extend' : float, default: 1
+                Scaling factor for the font width. Values less than 1 condense
+                the glyphs.
+
+        Returns
+        -------
+        `Type1Font`
+        """
+        fontname = self.prop['FontName']
+        italicangle = self.prop['ItalicAngle']
+
+        array = [
+            float(x) for x in (self.prop['FontMatrix']
+                               .lstrip('[').rstrip(']').split())
+        ]
+        oldmatrix = np.eye(3, 3)
+        oldmatrix[0:3, 0] = array[::2]
+        oldmatrix[0:3, 1] = array[1::2]
+        modifier = np.eye(3, 3)
+
+        if 'slant' in effects:
+            slant = effects['slant']
+            fontname += f'_Slant_{int(1000 * slant)}'
+            italicangle = round(
+                float(italicangle) - np.arctan(slant) / np.pi * 180,
+                5
+            )
+            modifier[1, 0] = slant
+
+        if 'extend' in effects:
+            extend = effects['extend']
+            fontname += f'_Extend_{int(1000 * extend)}'
+            modifier[0, 0] = extend
+
+        newmatrix = np.dot(modifier, oldmatrix)
+        array[::2] = newmatrix[0:3, 0]
+        array[1::2] = newmatrix[0:3, 1]
+        fontmatrix = (
+            f"[{' '.join(_format_approx(x, 6) for x in array)}]"
+        )
+        replacements = (
+            [(x, f'/FontName/{fontname} def')
+             for x in self._pos['FontName']]
+            + [(x, f'/ItalicAngle {italicangle} def')
+               for x in self._pos['ItalicAngle']]
+            + [(x, f'/FontMatrix {fontmatrix} readonly def')
+               for x in self._pos['FontMatrix']]
+            + [(x, '') for x in self._pos.get('UniqueID', [])]
+        )
+
+        data = bytearray(self.parts[0])
+        data.extend(self.decrypted)
+        len0 = len(self.parts[0])
+        for (pos0, pos1), value in sorted(replacements, reverse=True):
+            data[pos0:pos1] = value.encode('ascii', 'replace')
+            if pos0 < len(self.parts[0]):
+                if pos1 >= len(self.parts[0]):
+                    raise RuntimeError(
+                        f"text to be replaced with {value} spans "
+                        "the eexec boundary"
+                    )
+                len0 += len(value) - pos1 + pos0
+
+        data = bytes(data)
+        return Type1Font((
+            data[:len0],
+            self._encrypt(data[len0:], 'eexec'),
+            self.parts[2]
+        ))
+
+
+_StandardEncoding = {
+    **{ord(letter): letter for letter in string.ascii_letters},
+    0: '.notdef',
+    32: 'space',
+    33: 'exclam',
+    34: 'quotedbl',
+    35: 'numbersign',
+    36: 'dollar',
+    37: 'percent',
+    38: 'ampersand',
+    39: 'quoteright',
+    40: 'parenleft',
+    41: 'parenright',
+    42: 'asterisk',
+    43: 'plus',
+    44: 'comma',
+    45: 'hyphen',
+    46: 'period',
+    47: 'slash',
+    48: 'zero',
+    49: 'one',
+    50: 'two',
+    51: 'three',
+    52: 'four',
+    53: 'five',
+    54: 'six',
+    55: 'seven',
+    56: 'eight',
+    57: 'nine',
+    58: 'colon',
+    59: 'semicolon',
+    60: 'less',
+    61: 'equal',
+    62: 'greater',
+    63: 'question',
+    64: 'at',
+    91: 'bracketleft',
+    92: 'backslash',
+    93: 'bracketright',
+    94: 'asciicircum',
+    95: 'underscore',
+    96: 'quoteleft',
+    123: 'braceleft',
+    124: 'bar',
+    125: 'braceright',
+    126: 'asciitilde',
+    161: 'exclamdown',
+    162: 'cent',
+    163: 'sterling',
+    164: 'fraction',
+    165: 'yen',
+    166: 'florin',
+    167: 'section',
+    168: 'currency',
+    169: 'quotesingle',
+    170: 'quotedblleft',
+    171: 'guillemotleft',
+    172: 'guilsinglleft',
+    173: 'guilsinglright',
+    174: 'fi',
+    175: 'fl',
+    177: 'endash',
+    178: 'dagger',
+    179: 'daggerdbl',
+    180: 'periodcentered',
+    182: 'paragraph',
+    183: 'bullet',
+    184: 'quotesinglbase',
+    185: 'quotedblbase',
+    186: 'quotedblright',
+    187: 'guillemotright',
+    188: 'ellipsis',
+    189: 'perthousand',
+    191: 'questiondown',
+    193: 'grave',
+    194: 'acute',
+    195: 'circumflex',
+    196: 'tilde',
+    197: 'macron',
+    198: 'breve',
+    199: 'dotaccent',
+    200: 'dieresis',
+    202: 'ring',
+    203: 'cedilla',
+    205: 'hungarumlaut',
+    206: 'ogonek',
+    207: 'caron',
+    208: 'emdash',
+    225: 'AE',
+    227: 'ordfeminine',
+    232: 'Lslash',
+    233: 'Oslash',
+    234: 'OE',
+    235: 'ordmasculine',
+    241: 'ae',
+    245: 'dotlessi',
+    248: 'lslash',
+    249: 'oslash',
+    250: 'oe',
+    251: 'germandbls',
+}

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/_version.py

@@ -0,0 +1 @@
+version = "3.10.7"

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/animation.py

@@ -0,0 +1,1823 @@
+import abc
+import base64
+import contextlib
+from io import BytesIO, TextIOWrapper
+import itertools
+import logging
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+from tempfile import TemporaryDirectory
+import uuid
+import warnings
+
+import numpy as np
+from PIL import Image
+
+import matplotlib as mpl
+from matplotlib._animation_data import (
+    DISPLAY_TEMPLATE, INCLUDED_FRAMES, JS_INCLUDE, STYLE_INCLUDE)
+from matplotlib import _api, cbook
+import matplotlib.colors as mcolors
+
+_log = logging.getLogger(__name__)
+
+# Process creation flag for subprocess to prevent it raising a terminal
+# window. See for example https://stackoverflow.com/q/24130623/
+subprocess_creation_flags = (
+    subprocess.CREATE_NO_WINDOW if sys.platform == 'win32' else 0)
+
+
+def adjusted_figsize(w, h, dpi, n):
+    """
+    Compute figure size so that pixels are a multiple of n.
+
+    Parameters
+    ----------
+    w, h : float
+        Size in inches.
+
+    dpi : float
+        The dpi.
+
+    n : int
+        The target multiple.
+
+    Returns
+    -------
+    wnew, hnew : float
+        The new figure size in inches.
+    """
+
+    # this maybe simplified if / when we adopt consistent rounding for
+    # pixel size across the whole library
+    def correct_roundoff(x, dpi, n):
+        if int(x*dpi) % n != 0:
+            if int(np.nextafter(x, np.inf)*dpi) % n == 0:
+                x = np.nextafter(x, np.inf)
+            elif int(np.nextafter(x, -np.inf)*dpi) % n == 0:
+                x = np.nextafter(x, -np.inf)
+        return x
+
+    wnew = int(w * dpi / n) * n / dpi
+    hnew = int(h * dpi / n) * n / dpi
+    return correct_roundoff(wnew, dpi, n), correct_roundoff(hnew, dpi, n)
+
+
+class MovieWriterRegistry:
+    """Registry of available writer classes by human readable name."""
+
+    def __init__(self):
+        self._registered = dict()
+
+    def register(self, name):
+        """
+        Decorator for registering a class under a name.
+
+        Example use::
+
+            @registry.register(name)
+            class Foo:
+                pass
+        """
+        def wrapper(writer_cls):
+            self._registered[name] = writer_cls
+            return writer_cls
+        return wrapper
+
+    def is_available(self, name):
+        """
+        Check if given writer is available by name.
+
+        Parameters
+        ----------
+        name : str
+
+        Returns
+        -------
+        bool
+        """
+        try:
+            cls = self._registered[name]
+        except KeyError:
+            return False
+        return cls.isAvailable()
+
+    def __iter__(self):
+        """Iterate over names of available writer class."""
+        for name in self._registered:
+            if self.is_available(name):
+                yield name
+
+    def list(self):
+        """Get a list of available MovieWriters."""
+        return [*self]
+
+    def __getitem__(self, name):
+        """Get an available writer class from its name."""
+        if self.is_available(name):
+            return self._registered[name]
+        raise RuntimeError(f"Requested MovieWriter ({name}) not available")
+
+
+writers = MovieWriterRegistry()
+
+
+class AbstractMovieWriter(abc.ABC):
+    """
+    Abstract base class for writing movies, providing a way to grab frames by
+    calling `~AbstractMovieWriter.grab_frame`.
+
+    `setup` is called to start the process and `finish` is called afterwards.
+    `saving` is provided as a context manager to facilitate this process as ::
+
+        with moviewriter.saving(fig, outfile='myfile.mp4', dpi=100):
+            # Iterate over frames
+            moviewriter.grab_frame(**savefig_kwargs)
+
+    The use of the context manager ensures that `setup` and `finish` are
+    performed as necessary.
+
+    An instance of a concrete subclass of this class can be given as the
+    ``writer`` argument of `Animation.save()`.
+    """
+
+    def __init__(self, fps=5, metadata=None, codec=None, bitrate=None):
+        self.fps = fps
+        self.metadata = metadata if metadata is not None else {}
+        self.codec = mpl._val_or_rc(codec, 'animation.codec')
+        self.bitrate = mpl._val_or_rc(bitrate, 'animation.bitrate')
+
+    @abc.abstractmethod
+    def setup(self, fig, outfile, dpi=None):
+        """
+        Setup for writing the movie file.
+
+        Parameters
+        ----------
+        fig : `~matplotlib.figure.Figure`
+            The figure object that contains the information for frames.
+        outfile : str
+            The filename of the resulting movie file.
+        dpi : float, default: ``fig.dpi``
+            The DPI (or resolution) for the file.  This controls the size
+            in pixels of the resulting movie file.
+        """
+        # Check that path is valid
+        Path(outfile).parent.resolve(strict=True)
+        self.outfile = outfile
+        self.fig = fig
+        if dpi is None:
+            dpi = self.fig.dpi
+        self.dpi = dpi
+
+    @property
+    def frame_size(self):
+        """A tuple ``(width, height)`` in pixels of a movie frame."""
+        w, h = self.fig.get_size_inches()
+        return int(w * self.dpi), int(h * self.dpi)
+
+    def _supports_transparency(self):
+        """
+        Whether this writer supports transparency.
+
+        Writers may consult output file type and codec to determine this at runtime.
+        """
+        return False
+
+    @abc.abstractmethod
+    def grab_frame(self, **savefig_kwargs):
+        """
+        Grab the image information from the figure and save as a movie frame.
+
+        All keyword arguments in *savefig_kwargs* are passed on to the
+        `~.Figure.savefig` call that saves the figure.  However, several
+        keyword arguments that are supported by `~.Figure.savefig` may not be
+        passed as they are controlled by the MovieWriter:
+
+        - *dpi*, *bbox_inches*:  These may not be passed because each frame of the
+           animation much be exactly the same size in pixels.
+        - *format*: This is controlled by the MovieWriter.
+        """
+
+    @abc.abstractmethod
+    def finish(self):
+        """Finish any processing for writing the movie."""
+
+    @contextlib.contextmanager
+    def saving(self, fig, outfile, dpi, *args, **kwargs):
+        """
+        Context manager to facilitate writing the movie file.
+
+        ``*args, **kw`` are any parameters that should be passed to `setup`.
+        """
+        if mpl.rcParams['savefig.bbox'] == 'tight':
+            _log.info("Disabling savefig.bbox = 'tight', as it may cause "
+                      "frame size to vary, which is inappropriate for "
+                      "animation.")
+
+        # This particular sequence is what contextlib.contextmanager wants
+        self.setup(fig, outfile, dpi, *args, **kwargs)
+        with mpl.rc_context({'savefig.bbox': None}):
+            try:
+                yield self
+            finally:
+                self.finish()
+
+
+class MovieWriter(AbstractMovieWriter):
+    """
+    Base class for writing movies.
+
+    This is a base class for MovieWriter subclasses that write a movie frame
+    data to a pipe. You cannot instantiate this class directly.
+    See examples for how to use its subclasses.
+
+    Attributes
+    ----------
+    frame_format : str
+        The format used in writing frame data, defaults to 'rgba'.
+    fig : `~matplotlib.figure.Figure`
+        The figure to capture data from.
+        This must be provided by the subclasses.
+    """
+
+    # Builtin writer subclasses additionally define the _exec_key and _args_key
+    # attributes, which indicate the rcParams entries where the path to the
+    # executable and additional command-line arguments to the executable are
+    # stored.  Third-party writers cannot meaningfully set these as they cannot
+    # extend rcParams with new keys.
+
+    # Pipe-based writers only support RGBA, but file-based ones support more
+    # formats.
+    supported_formats = ["rgba"]
+
+    def __init__(self, fps=5, codec=None, bitrate=None, extra_args=None,
+                 metadata=None):
+        """
+        Parameters
+        ----------
+        fps : int, default: 5
+            Movie frame rate (per second).
+        codec : str or None, default: :rc:`animation.codec`
+            The codec to use.
+        bitrate : int, default: :rc:`animation.bitrate`
+            The bitrate of the movie, in kilobits per second.  Higher values
+            means higher quality movies, but increase the file size.  A value
+            of -1 lets the underlying movie encoder select the bitrate.
+        extra_args : list of str or None, optional
+            Extra command-line arguments passed to the underlying movie encoder. These
+            arguments are passed last to the encoder, just before the filename. The
+            default, None, means to use :rc:`animation.[name-of-encoder]_args` for the
+            builtin writers.
+        metadata : dict[str, str], default: {}
+            A dictionary of keys and values for metadata to include in the
+            output file. Some keys that may be of use include:
+            title, artist, genre, subject, copyright, srcform, comment.
+        """
+        if type(self) is MovieWriter:
+            # TODO MovieWriter is still an abstract class and needs to be
+            #      extended with a mixin. This should be clearer in naming
+            #      and description. For now, just give a reasonable error
+            #      message to users.
+            raise TypeError(
+                'MovieWriter cannot be instantiated directly. Please use one '
+                'of its subclasses.')
+
+        super().__init__(fps=fps, metadata=metadata, codec=codec,
+                         bitrate=bitrate)
+        self.frame_format = self.supported_formats[0]
+        self.extra_args = extra_args
+
+    def _adjust_frame_size(self):
+        if self.codec == 'h264':
+            wo, ho = self.fig.get_size_inches()
+            w, h = adjusted_figsize(wo, ho, self.dpi, 2)
+            if (wo, ho) != (w, h):
+                self.fig.set_size_inches(w, h, forward=True)
+                _log.info('figure size in inches has been adjusted '
+                          'from %s x %s to %s x %s', wo, ho, w, h)
+        else:
+            w, h = self.fig.get_size_inches()
+        _log.debug('frame size in pixels is %s x %s', *self.frame_size)
+        return w, h
+
+    def setup(self, fig, outfile, dpi=None):
+        # docstring inherited
+        super().setup(fig, outfile, dpi=dpi)
+        self._w, self._h = self._adjust_frame_size()
+        # Run here so that grab_frame() can write the data to a pipe. This
+        # eliminates the need for temp files.
+        self._run()
+
+    def _run(self):
+        # Uses subprocess to call the program for assembling frames into a
+        # movie file.  *args* returns the sequence of command line arguments
+        # from a few configuration options.
+        command = self._args()
+        _log.info('MovieWriter._run: running command: %s',
+                  cbook._pformat_subprocess(command))
+        PIPE = subprocess.PIPE
+        self._proc = subprocess.Popen(
+            command, stdin=PIPE, stdout=PIPE, stderr=PIPE,
+            creationflags=subprocess_creation_flags)
+
+    def finish(self):
+        """Finish any processing for writing the movie."""
+        out, err = self._proc.communicate()
+        # Use the encoding/errors that universal_newlines would use.
+        out = TextIOWrapper(BytesIO(out)).read()
+        err = TextIOWrapper(BytesIO(err)).read()
+        if out:
+            _log.log(
+                logging.WARNING if self._proc.returncode else logging.DEBUG,
+                "MovieWriter stdout:\n%s", out)
+        if err:
+            _log.log(
+                logging.WARNING if self._proc.returncode else logging.DEBUG,
+                "MovieWriter stderr:\n%s", err)
+        if self._proc.returncode:
+            raise subprocess.CalledProcessError(
+                self._proc.returncode, self._proc.args, out, err)
+
+    def grab_frame(self, **savefig_kwargs):
+        # docstring inherited
+        _validate_grabframe_kwargs(savefig_kwargs)
+        _log.debug('MovieWriter.grab_frame: Grabbing frame.')
+        # Readjust the figure size in case it has been changed by the user.
+        # All frames must have the same size to save the movie correctly.
+        self.fig.set_size_inches(self._w, self._h)
+        # Save the figure data to the sink, using the frame format and dpi.
+        self.fig.savefig(self._proc.stdin, format=self.frame_format,
+                         dpi=self.dpi, **savefig_kwargs)
+
+    def _args(self):
+        """Assemble list of encoder-specific command-line arguments."""
+        return NotImplementedError("args needs to be implemented by subclass.")
+
+    @classmethod
+    def bin_path(cls):
+        """
+        Return the binary path to the commandline tool used by a specific
+        subclass. This is a class method so that the tool can be looked for
+        before making a particular MovieWriter subclass available.
+        """
+        return str(mpl.rcParams[cls._exec_key])
+
+    @classmethod
+    def isAvailable(cls):
+        """Return whether a MovieWriter subclass is actually available."""
+        return shutil.which(cls.bin_path()) is not None
+
+
+class FileMovieWriter(MovieWriter):
+    """
+    `MovieWriter` for writing to individual files and stitching at the end.
+
+    This must be sub-classed to be useful.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.frame_format = mpl.rcParams['animation.frame_format']
+
+    def setup(self, fig, outfile, dpi=None, frame_prefix=None):
+        """
+        Setup for writing the movie file.
+
+        Parameters
+        ----------
+        fig : `~matplotlib.figure.Figure`
+            The figure to grab the rendered frames from.
+        outfile : str
+            The filename of the resulting movie file.
+        dpi : float, default: ``fig.dpi``
+            The dpi of the output file. This, with the figure size,
+            controls the size in pixels of the resulting movie file.
+        frame_prefix : str, optional
+            The filename prefix to use for temporary files.  If *None* (the
+            default), files are written to a temporary directory which is
+            deleted by `finish`; if not *None*, no temporary files are
+            deleted.
+        """
+        # Check that path is valid
+        Path(outfile).parent.resolve(strict=True)
+        self.fig = fig
+        self.outfile = outfile
+        if dpi is None:
+            dpi = self.fig.dpi
+        self.dpi = dpi
+        self._adjust_frame_size()
+
+        if frame_prefix is None:
+            self._tmpdir = TemporaryDirectory()
+            self.temp_prefix = str(Path(self._tmpdir.name, 'tmp'))
+        else:
+            self._tmpdir = None
+            self.temp_prefix = frame_prefix
+        self._frame_counter = 0  # used for generating sequential file names
+        self._temp_paths = list()
+        self.fname_format_str = '%s%%07d.%s'
+
+    def __del__(self):
+        if hasattr(self, '_tmpdir') and self._tmpdir:
+            self._tmpdir.cleanup()
+
+    @property
+    def frame_format(self):
+        """
+        Format (png, jpeg, etc.) to use for saving the frames, which can be
+        decided by the individual subclasses.
+        """
+        return self._frame_format
+
+    @frame_format.setter
+    def frame_format(self, frame_format):
+        if frame_format in self.supported_formats:
+            self._frame_format = frame_format
+        else:
+            _api.warn_external(
+                f"Ignoring file format {frame_format!r} which is not "
+                f"supported by {type(self).__name__}; using "
+                f"{self.supported_formats[0]} instead.")
+            self._frame_format = self.supported_formats[0]
+
+    def _base_temp_name(self):
+        # Generates a template name (without number) given the frame format
+        # for extension and the prefix.
+        return self.fname_format_str % (self.temp_prefix, self.frame_format)
+
+    def grab_frame(self, **savefig_kwargs):
+        # docstring inherited
+        # Creates a filename for saving using basename and counter.
+        _validate_grabframe_kwargs(savefig_kwargs)
+        path = Path(self._base_temp_name() % self._frame_counter)
+        self._temp_paths.append(path)  # Record the filename for later use.
+        self._frame_counter += 1  # Ensures each created name is unique.
+        _log.debug('FileMovieWriter.grab_frame: Grabbing frame %d to path=%s',
+                   self._frame_counter, path)
+        with open(path, 'wb') as sink:  # Save figure to the sink.
+            self.fig.savefig(sink, format=self.frame_format, dpi=self.dpi,
+                             **savefig_kwargs)
+
+    def finish(self):
+        # Call run here now that all frame grabbing is done. All temp files
+        # are available to be assembled.
+        try:
+            self._run()
+            super().finish()
+        finally:
+            if self._tmpdir:
+                _log.debug(
+                    'MovieWriter: clearing temporary path=%s', self._tmpdir
+                )
+                self._tmpdir.cleanup()
+
+
+@writers.register('pillow')
+class PillowWriter(AbstractMovieWriter):
+    def _supports_transparency(self):
+        return True
+
+    @classmethod
+    def isAvailable(cls):
+        return True
+
+    def setup(self, fig, outfile, dpi=None):
+        super().setup(fig, outfile, dpi=dpi)
+        self._frames = []
+
+    def grab_frame(self, **savefig_kwargs):
+        _validate_grabframe_kwargs(savefig_kwargs)
+        buf = BytesIO()
+        self.fig.savefig(
+            buf, **{**savefig_kwargs, "format": "rgba", "dpi": self.dpi})
+        im = Image.frombuffer(
+            "RGBA", self.frame_size, buf.getbuffer(), "raw", "RGBA", 0, 1)
+        if im.getextrema()[3][0] < 255:
+            # This frame has transparency, so we'll just add it as is.
+            self._frames.append(im)
+        else:
+            # Without transparency, we switch to RGB mode, which converts to P mode a
+            # little better if needed (specifically, this helps with GIF output.)
+            self._frames.append(im.convert("RGB"))
+
+    def finish(self):
+        self._frames[0].save(
+            self.outfile, save_all=True, append_images=self._frames[1:],
+            duration=int(1000 / self.fps), loop=0)
+
+
+# Base class of ffmpeg information. Has the config keys and the common set
+# of arguments that controls the *output* side of things.
+class FFMpegBase:
+    """
+    Mixin class for FFMpeg output.
+
+    This is a base class for the concrete `FFMpegWriter` and `FFMpegFileWriter`
+    classes.
+    """
+
+    _exec_key = 'animation.ffmpeg_path'
+    _args_key = 'animation.ffmpeg_args'
+
+    def _supports_transparency(self):
+        suffix = Path(self.outfile).suffix
+        if suffix in {'.apng', '.avif', '.gif', '.webm', '.webp'}:
+            return True
+        # This list was found by going through `ffmpeg -codecs` for video encoders,
+        # running them with _support_transparency() forced to True, and checking that
+        # the "Pixel format" in Kdenlive included alpha. Note this is not a guarantee
+        # that transparency will work; you may also need to pass `-pix_fmt`, but we
+        # trust the user has done so if they are asking for these formats.
+        return self.codec in {
+            'apng', 'avrp', 'bmp', 'cfhd', 'dpx', 'ffv1', 'ffvhuff', 'gif', 'huffyuv',
+            'jpeg2000', 'ljpeg', 'png', 'prores', 'prores_aw', 'prores_ks', 'qtrle',
+            'rawvideo', 'targa', 'tiff', 'utvideo', 'v408', }
+
+    @property
+    def output_args(self):
+        args = []
+        suffix = Path(self.outfile).suffix
+        if suffix in {'.apng', '.avif', '.gif', '.webm', '.webp'}:
+            self.codec = suffix[1:]
+        else:
+            args.extend(['-vcodec', self.codec])
+        extra_args = (self.extra_args if self.extra_args is not None
+                      else mpl.rcParams[self._args_key])
+        # For h264, the default format is yuv444p, which is not compatible
+        # with quicktime (and others). Specifying yuv420p fixes playback on
+        # iOS, as well as HTML5 video in firefox and safari (on both Windows and
+        # macOS). Also fixes internet explorer. This is as of 2015/10/29.
+        if self.codec == 'h264' and '-pix_fmt' not in extra_args:
+            args.extend(['-pix_fmt', 'yuv420p'])
+        # For GIF, we're telling FFmpeg to split the video stream, to generate
+        # a palette, and then use it for encoding.
+        elif self.codec == 'gif' and '-filter_complex' not in extra_args:
+            args.extend(['-filter_complex',
+                         'split [a][b];[a] palettegen [p];[b][p] paletteuse'])
+        # For AVIF, we're telling FFmpeg to split the video stream, extract the alpha,
+        # in order to place it in a secondary stream, as needed by AVIF-in-FFmpeg.
+        elif self.codec == 'avif' and '-filter_complex' not in extra_args:
+            args.extend(['-filter_complex',
+                         'split [rgb][rgba]; [rgba] alphaextract [alpha]',
+                         '-map', '[rgb]', '-map', '[alpha]'])
+        if self.bitrate > 0:
+            args.extend(['-b', '%dk' % self.bitrate])  # %dk: bitrate in kbps.
+        for k, v in self.metadata.items():
+            args.extend(['-metadata', f'{k}={v}'])
+        args.extend(extra_args)
+
+        return args + ['-y', self.outfile]
+
+
+# Combine FFMpeg options with pipe-based writing
+@writers.register('ffmpeg')
+class FFMpegWriter(FFMpegBase, MovieWriter):
+    """
+    Pipe-based ffmpeg writer.
+
+    Frames are streamed directly to ffmpeg via a pipe and written in a single pass.
+
+    This effectively works as a slideshow input to ffmpeg with the fps passed as
+    ``-framerate``, so see also `their notes on frame rates`_ for further details.
+
+    .. _their notes on frame rates: https://trac.ffmpeg.org/wiki/Slideshow#Framerates
+    """
+    def _args(self):
+        # Returns the command line parameters for subprocess to use
+        # ffmpeg to create a movie using a pipe.
+        args = [self.bin_path(), '-f', 'rawvideo', '-vcodec', 'rawvideo',
+                '-s', '%dx%d' % self.frame_size, '-pix_fmt', self.frame_format,
+                '-framerate', str(self.fps)]
+        # Logging is quieted because subprocess.PIPE has limited buffer size.
+        # If you have a lot of frames in your animation and set logging to
+        # DEBUG, you will have a buffer overrun.
+        if _log.getEffectiveLevel() > logging.DEBUG:
+            args += ['-loglevel', 'error']
+        args += ['-i', 'pipe:'] + self.output_args
+        return args
+
+
+# Combine FFMpeg options with temp file-based writing
+@writers.register('ffmpeg_file')
+class FFMpegFileWriter(FFMpegBase, FileMovieWriter):
+    """
+    File-based ffmpeg writer.
+
+    Frames are written to temporary files on disk and then stitched together at the end.
+
+    This effectively works as a slideshow input to ffmpeg with the fps passed as
+    ``-framerate``, so see also `their notes on frame rates`_ for further details.
+
+    .. _their notes on frame rates: https://trac.ffmpeg.org/wiki/Slideshow#Framerates
+    """
+    supported_formats = ['png', 'jpeg', 'tiff', 'raw', 'rgba']
+
+    def _args(self):
+        # Returns the command line parameters for subprocess to use
+        # ffmpeg to create a movie using a collection of temp images
+        args = []
+        # For raw frames, we need to explicitly tell ffmpeg the metadata.
+        if self.frame_format in {'raw', 'rgba'}:
+            args += [
+                '-f', 'image2', '-vcodec', 'rawvideo',
+                '-video_size', '%dx%d' % self.frame_size,
+                '-pixel_format', 'rgba',
+            ]
+        args += ['-framerate', str(self.fps), '-i', self._base_temp_name()]
+        if not self._tmpdir:
+            args += ['-frames:v', str(self._frame_counter)]
+        # Logging is quieted because subprocess.PIPE has limited buffer size.
+        # If you have a lot of frames in your animation and set logging to
+        # DEBUG, you will have a buffer overrun.
+        if _log.getEffectiveLevel() > logging.DEBUG:
+            args += ['-loglevel', 'error']
+        return [self.bin_path(), *args, *self.output_args]
+
+
+# Base class for animated GIFs with ImageMagick
+class ImageMagickBase:
+    """
+    Mixin class for ImageMagick output.
+
+    This is a base class for the concrete `ImageMagickWriter` and
+    `ImageMagickFileWriter` classes, which define an ``input_names`` attribute
+    (or property) specifying the input names passed to ImageMagick.
+    """
+
+    _exec_key = 'animation.convert_path'
+    _args_key = 'animation.convert_args'
+
+    def _supports_transparency(self):
+        suffix = Path(self.outfile).suffix
+        return suffix in {'.apng', '.avif', '.gif', '.webm', '.webp'}
+
+    def _args(self):
+        # ImageMagick does not recognize "raw".
+        fmt = "rgba" if self.frame_format == "raw" else self.frame_format
+        extra_args = (self.extra_args if self.extra_args is not None
+                      else mpl.rcParams[self._args_key])
+        return [
+            self.bin_path(),
+            "-size", "%ix%i" % self.frame_size,
+            "-depth", "8",
+            "-delay", str(100 / self.fps),
+            "-loop", "0",
+            f"{fmt}:{self.input_names}",
+            *extra_args,
+            self.outfile,
+        ]
+
+    @classmethod
+    def bin_path(cls):
+        binpath = super().bin_path()
+        if binpath == 'convert':
+            binpath = mpl._get_executable_info('magick').executable
+        return binpath
+
+    @classmethod
+    def isAvailable(cls):
+        try:
+            return super().isAvailable()
+        except mpl.ExecutableNotFoundError as _enf:
+            # May be raised by get_executable_info.
+            _log.debug('ImageMagick unavailable due to: %s', _enf)
+            return False
+
+
+# Combine ImageMagick options with pipe-based writing
+@writers.register('imagemagick')
+class ImageMagickWriter(ImageMagickBase, MovieWriter):
+    """
+    Pipe-based animated gif writer.
+
+    Frames are streamed directly to ImageMagick via a pipe and written
+    in a single pass.
+    """
+
+    input_names = "-"  # stdin
+
+
+# Combine ImageMagick options with temp file-based writing
+@writers.register('imagemagick_file')
+class ImageMagickFileWriter(ImageMagickBase, FileMovieWriter):
+    """
+    File-based animated gif writer.
+
+    Frames are written to temporary files on disk and then stitched
+    together at the end.
+    """
+
+    supported_formats = ['png', 'jpeg', 'tiff', 'raw', 'rgba']
+    input_names = property(
+        lambda self: f'{self.temp_prefix}*.{self.frame_format}')
+
+
+# Taken directly from jakevdp's JSAnimation package at
+# http://github.com/jakevdp/JSAnimation
+def _included_frames(frame_count, frame_format, frame_dir):
+    return INCLUDED_FRAMES.format(Nframes=frame_count,
+                                  frame_dir=frame_dir,
+                                  frame_format=frame_format)
+
+
+def _embedded_frames(frame_list, frame_format):
+    """frame_list should be a list of base64-encoded png files"""
+    if frame_format == 'svg':
+        # Fix MIME type for svg
+        frame_format = 'svg+xml'
+    template = '  frames[{0}] = "data:image/{1};base64,{2}"\n'
+    return "\n" + "".join(
+        template.format(i, frame_format, frame_data.replace('\n', '\\\n'))
+        for i, frame_data in enumerate(frame_list))
+
+
+@writers.register('html')
+class HTMLWriter(FileMovieWriter):
+    """Writer for JavaScript-based HTML movies."""
+
+    supported_formats = ['png', 'jpeg', 'tiff', 'svg']
+
+    @classmethod
+    def isAvailable(cls):
+        return True
+
+    def __init__(self, fps=30, codec=None, bitrate=None, extra_args=None,
+                 metadata=None, embed_frames=False, default_mode='loop',
+                 embed_limit=None):
+
+        if extra_args:
+            _log.warning("HTMLWriter ignores 'extra_args'")
+        extra_args = ()  # Don't lookup nonexistent rcParam[args_key].
+        self.embed_frames = embed_frames
+        self.default_mode = default_mode.lower()
+        _api.check_in_list(['loop', 'once', 'reflect'],
+                           default_mode=self.default_mode)
+
+        # Save embed limit, which is given in MB
+        self._bytes_limit = mpl._val_or_rc(embed_limit, 'animation.embed_limit')
+        # Convert from MB to bytes
+        self._bytes_limit *= 1024 * 1024
+
+        super().__init__(fps, codec, bitrate, extra_args, metadata)
+
+    def setup(self, fig, outfile, dpi=None, frame_dir=None):
+        outfile = Path(outfile)
+        _api.check_in_list(['.html', '.htm'], outfile_extension=outfile.suffix)
+
+        self._saved_frames = []
+        self._total_bytes = 0
+        self._hit_limit = False
+
+        if not self.embed_frames:
+            if frame_dir is None:
+                frame_dir = outfile.with_name(outfile.stem + '_frames')
+            frame_dir.mkdir(parents=True, exist_ok=True)
+            frame_prefix = frame_dir / 'frame'
+        else:
+            frame_prefix = None
+
+        super().setup(fig, outfile, dpi, frame_prefix)
+        self._clear_temp = False
+
+    def grab_frame(self, **savefig_kwargs):
+        _validate_grabframe_kwargs(savefig_kwargs)
+        if self.embed_frames:
+            # Just stop processing if we hit the limit
+            if self._hit_limit:
+                return
+            f = BytesIO()
+            self.fig.savefig(f, format=self.frame_format,
+                             dpi=self.dpi, **savefig_kwargs)
+            imgdata64 = base64.encodebytes(f.getvalue()).decode('ascii')
+            self._total_bytes += len(imgdata64)
+            if self._total_bytes >= self._bytes_limit:
+                _log.warning(
+                    "Animation size has reached %s bytes, exceeding the limit "
+                    "of %s. If you're sure you want a larger animation "
+                    "embedded, set the animation.embed_limit rc parameter to "
+                    "a larger value (in MB). This and further frames will be "
+                    "dropped.", self._total_bytes, self._bytes_limit)
+                self._hit_limit = True
+            else:
+                self._saved_frames.append(imgdata64)
+        else:
+            return super().grab_frame(**savefig_kwargs)
+
+    def finish(self):
+        # save the frames to an html file
+        if self.embed_frames:
+            fill_frames = _embedded_frames(self._saved_frames,
+                                           self.frame_format)
+            frame_count = len(self._saved_frames)
+        else:
+            # temp names is filled by FileMovieWriter
+            frame_count = len(self._temp_paths)
+            fill_frames = _included_frames(
+                frame_count, self.frame_format,
+                self._temp_paths[0].parent.relative_to(self.outfile.parent))
+        mode_dict = dict(once_checked='',
+                         loop_checked='',
+                         reflect_checked='')
+        mode_dict[self.default_mode + '_checked'] = 'checked'
+
+        interval = 1000 // self.fps
+
+        with open(self.outfile, 'w') as of:
+            of.write(JS_INCLUDE + STYLE_INCLUDE)
+            of.write(DISPLAY_TEMPLATE.format(id=uuid.uuid4().hex,
+                                             Nframes=frame_count,
+                                             fill_frames=fill_frames,
+                                             interval=interval,
+                                             **mode_dict))
+
+        # Duplicate the temporary file clean up logic from
+        # FileMovieWriter.finish.  We cannot call the inherited version of
+        # finish because it assumes that there is a subprocess that we either
+        # need to call to merge many frames together or that there is a
+        # subprocess call that we need to clean up.
+        if self._tmpdir:
+            _log.debug('MovieWriter: clearing temporary path=%s', self._tmpdir)
+            self._tmpdir.cleanup()
+
+
+class Animation:
+    """
+    A base class for Animations.
+
+    This class is not usable as is, and should be subclassed to provide needed
+    behavior.
+
+    .. note::
+
+        You must store the created Animation in a variable that lives as long
+        as the animation should run. Otherwise, the Animation object will be
+        garbage-collected and the animation stops.
+
+    Parameters
+    ----------
+    fig : `~matplotlib.figure.Figure`
+        The figure object used to get needed events, such as draw or resize.
+
+    event_source : object, optional
+        A class that can run a callback when desired events
+        are generated, as well as be stopped and started.
+
+        Examples include timers (see `TimedAnimation`) and file
+        system notifications.
+
+    blit : bool, default: False
+        Whether blitting is used to optimize drawing.  If the backend does not
+        support blitting, then this parameter has no effect.
+
+    See Also
+    --------
+    FuncAnimation,  ArtistAnimation
+    """
+
+    def __init__(self, fig, event_source=None, blit=False):
+        self._draw_was_started = False
+
+        self._fig = fig
+        # Disables blitting for backends that don't support it.  This
+        # allows users to request it if available, but still have a
+        # fallback that works if it is not.
+        self._blit = blit and fig.canvas.supports_blit
+
+        # These are the basics of the animation.  The frame sequence represents
+        # information for each frame of the animation and depends on how the
+        # drawing is handled by the subclasses. The event source fires events
+        # that cause the frame sequence to be iterated.
+        self.frame_seq = self.new_frame_seq()
+        self.event_source = event_source
+
+        # Instead of starting the event source now, we connect to the figure's
+        # draw_event, so that we only start once the figure has been drawn.
+        self._first_draw_id = fig.canvas.mpl_connect('draw_event', self._start)
+
+        # Connect to the figure's close_event so that we don't continue to
+        # fire events and try to draw to a deleted figure.
+        self._close_id = self._fig.canvas.mpl_connect('close_event',
+                                                      self._stop)
+        if self._blit:
+            self._setup_blit()
+
+    def __del__(self):
+        if not getattr(self, '_draw_was_started', True):
+            warnings.warn(
+                'Animation was deleted without rendering anything. This is '
+                'most likely not intended. To prevent deletion, assign the '
+                'Animation to a variable, e.g. `anim`, that exists until you '
+                'output the Animation using `plt.show()` or '
+                '`anim.save()`.'
+            )
+
+    def _start(self, *args):
+        """
+        Starts interactive animation. Adds the draw frame command to the GUI
+        handler, calls show to start the event loop.
+        """
+        # Do not start the event source if saving() it.
+        if self._fig.canvas.is_saving():
+            return
+        # First disconnect our draw event handler
+        self._fig.canvas.mpl_disconnect(self._first_draw_id)
+
+        # Now do any initial draw
+        self._init_draw()
+
+        # Add our callback for stepping the animation and
+        # actually start the event_source.
+        self.event_source.add_callback(self._step)
+        self.event_source.start()
+
+    def _stop(self, *args):
+        # On stop we disconnect all of our events.
+        if self._blit:
+            self._fig.canvas.mpl_disconnect(self._resize_id)
+        self._fig.canvas.mpl_disconnect(self._close_id)
+        self.event_source.remove_callback(self._step)
+        self.event_source = None
+
+    def save(self, filename, writer=None, fps=None, dpi=None, codec=None,
+             bitrate=None, extra_args=None, metadata=None, extra_anim=None,
+             savefig_kwargs=None, *, progress_callback=None):
+        """
+        Save the animation as a movie file by drawing every frame.
+
+        Parameters
+        ----------
+        filename : str
+            The output filename, e.g., :file:`mymovie.mp4`.
+
+        writer : `MovieWriter` or str, default: :rc:`animation.writer`
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        fps : int, optional
+            Movie frame rate (per second).  If not set, the frame rate from the
+            animation's frame interval.
+
+        dpi : float, default: :rc:`savefig.dpi`
+            Controls the dots per inch for the movie frames.  Together with
+            the figure's size in inches, this controls the size of the movie.
+
+        codec : str, default: :rc:`animation.codec`.
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
+        bitrate : int, default: :rc:`animation.bitrate`
+            The bitrate of the movie, in kilobits per second.  Higher values
+            means higher quality movies, but increase the file size.  A value
+            of -1 lets the underlying movie encoder select the bitrate.
+
+        extra_args : list of str or None, optional
+            Extra command-line arguments passed to the underlying movie encoder. These
+            arguments are passed last to the encoder, just before the output filename.
+            The default, None, means to use :rc:`animation.[name-of-encoder]_args` for
+            the builtin writers.
+
+        metadata : dict[str, str], default: {}
+            Dictionary of keys and values for metadata to include in
+            the output file. Some keys that may be of use include:
+            title, artist, genre, subject, copyright, srcform, comment.
+
+        extra_anim : list, default: []
+            Additional `Animation` objects that should be included
+            in the saved movie file. These need to be from the same
+            `.Figure` instance. Also, animation frames will
+            just be simply combined, so there should be a 1:1 correspondence
+            between the frames from the different animations.
+
+        savefig_kwargs : dict, default: {}
+            Keyword arguments passed to each `~.Figure.savefig` call used to
+            save the individual frames.
+
+        progress_callback : function, optional
+            A callback function that will be called for every frame to notify
+            the saving progress. It must have the signature ::
+
+                def func(current_frame: int, total_frames: int) -> Any
+
+            where *current_frame* is the current frame number and *total_frames* is the
+            total number of frames to be saved. *total_frames* is set to None, if the
+            total number of frames cannot be determined. Return values may exist but are
+            ignored.
+
+            Example code to write the progress to stdout::
+
+                progress_callback = lambda i, n: print(f'Saving frame {i}/{n}')
+
+        Notes
+        -----
+        *fps*, *codec*, *bitrate*, *extra_args* and *metadata* are used to
+        construct a `.MovieWriter` instance and can only be passed if
+        *writer* is a string.  If they are passed as non-*None* and *writer*
+        is a `.MovieWriter`, a `RuntimeError` will be raised.
+        """
+
+        all_anim = [self]
+        if extra_anim is not None:
+            all_anim.extend(anim for anim in extra_anim
+                            if anim._fig is self._fig)
+
+        # Disable "Animation was deleted without rendering" warning.
+        for anim in all_anim:
+            anim._draw_was_started = True
+
+        if writer is None:
+            writer = mpl.rcParams['animation.writer']
+        elif (not isinstance(writer, str) and
+              any(arg is not None
+                  for arg in (fps, codec, bitrate, extra_args, metadata))):
+            raise RuntimeError('Passing in values for arguments '
+                               'fps, codec, bitrate, extra_args, or metadata '
+                               'is not supported when writer is an existing '
+                               'MovieWriter instance. These should instead be '
+                               'passed as arguments when creating the '
+                               'MovieWriter instance.')
+
+        if savefig_kwargs is None:
+            savefig_kwargs = {}
+        else:
+            # we are going to mutate this below
+            savefig_kwargs = dict(savefig_kwargs)
+
+        if fps is None and hasattr(self, '_interval'):
+            # Convert interval in ms to frames per second
+            fps = 1000. / self._interval
+
+        # Reuse the savefig DPI for ours if none is given.
+        dpi = mpl._val_or_rc(dpi, 'savefig.dpi')
+        if dpi == 'figure':
+            dpi = self._fig.dpi
+
+        writer_kwargs = {}
+        if codec is not None:
+            writer_kwargs['codec'] = codec
+        if bitrate is not None:
+            writer_kwargs['bitrate'] = bitrate
+        if extra_args is not None:
+            writer_kwargs['extra_args'] = extra_args
+        if metadata is not None:
+            writer_kwargs['metadata'] = metadata
+
+        # If we have the name of a writer, instantiate an instance of the
+        # registered class.
+        if isinstance(writer, str):
+            try:
+                writer_cls = writers[writer]
+            except RuntimeError:  # Raised if not available.
+                writer_cls = PillowWriter  # Always available.
+                _log.warning("MovieWriter %s unavailable; using Pillow "
+                             "instead.", writer)
+            writer = writer_cls(fps, **writer_kwargs)
+        _log.info('Animation.save using %s', type(writer))
+
+        if 'bbox_inches' in savefig_kwargs:
+            _log.warning("Warning: discarding the 'bbox_inches' argument in "
+                         "'savefig_kwargs' as it may cause frame size "
+                         "to vary, which is inappropriate for animation.")
+            savefig_kwargs.pop('bbox_inches')
+
+        # Create a new sequence of frames for saved data. This is different
+        # from new_frame_seq() to give the ability to save 'live' generated
+        # frame information to be saved later.
+        # TODO: Right now, after closing the figure, saving a movie won't work
+        # since GUI widgets are gone. Either need to remove extra code to
+        # allow for this non-existent use case or find a way to make it work.
+
+        def _pre_composite_to_white(color):
+            r, g, b, a = mcolors.to_rgba(color)
+            return a * np.array([r, g, b]) + 1 - a
+
+        # canvas._is_saving = True makes the draw_event animation-starting
+        # callback a no-op; canvas.manager = None prevents resizing the GUI
+        # widget (both are likewise done in savefig()).
+        with (writer.saving(self._fig, filename, dpi),
+              cbook._setattr_cm(self._fig.canvas, _is_saving=True, manager=None)):
+            if not writer._supports_transparency():
+                facecolor = savefig_kwargs.get('facecolor',
+                                               mpl.rcParams['savefig.facecolor'])
+                if facecolor == 'auto':
+                    facecolor = self._fig.get_facecolor()
+                savefig_kwargs['facecolor'] = _pre_composite_to_white(facecolor)
+                savefig_kwargs['transparent'] = False   # just to be safe!
+
+            for anim in all_anim:
+                anim._init_draw()  # Clear the initial frame
+            frame_number = 0
+            # TODO: Currently only FuncAnimation has a save_count
+            #       attribute. Can we generalize this to all Animations?
+            save_count_list = [getattr(a, '_save_count', None)
+                               for a in all_anim]
+            if None in save_count_list:
+                total_frames = None
+            else:
+                total_frames = sum(save_count_list)
+            for data in zip(*[a.new_saved_frame_seq() for a in all_anim]):
+                for anim, d in zip(all_anim, data):
+                    # TODO: See if turning off blit is really necessary
+                    anim._draw_next_frame(d, blit=False)
+                    if progress_callback is not None:
+                        progress_callback(frame_number, total_frames)
+                        frame_number += 1
+                writer.grab_frame(**savefig_kwargs)
+
+    def _step(self, *args):
+        """
+        Handler for getting events. By default, gets the next frame in the
+        sequence and hands the data off to be drawn.
+        """
+        # Returns True to indicate that the event source should continue to
+        # call _step, until the frame sequence reaches the end of iteration,
+        # at which point False will be returned.
+        try:
+            framedata = next(self.frame_seq)
+            self._draw_next_frame(framedata, self._blit)
+            return True
+        except StopIteration:
+            return False
+
+    def new_frame_seq(self):
+        """Return a new sequence of frame information."""
+        # Default implementation is just an iterator over self._framedata
+        return iter(self._framedata)
+
+    def new_saved_frame_seq(self):
+        """Return a new sequence of saved/cached frame information."""
+        # Default is the same as the regular frame sequence
+        return self.new_frame_seq()
+
+    def _draw_next_frame(self, framedata, blit):
+        # Breaks down the drawing of the next frame into steps of pre- and
+        # post- draw, as well as the drawing of the frame itself.
+        self._pre_draw(framedata, blit)
+        self._draw_frame(framedata)
+        self._post_draw(framedata, blit)
+
+    def _init_draw(self):
+        # Initial draw to clear the frame. Also used by the blitting code
+        # when a clean base is required.
+        self._draw_was_started = True
+
+    def _pre_draw(self, framedata, blit):
+        # Perform any cleaning or whatnot before the drawing of the frame.
+        # This default implementation allows blit to clear the frame.
+        if blit:
+            self._blit_clear(self._drawn_artists)
+
+    def _draw_frame(self, framedata):
+        # Performs actual drawing of the frame.
+        raise NotImplementedError('Needs to be implemented by subclasses to'
+                                  ' actually make an animation.')
+
+    def _post_draw(self, framedata, blit):
+        # After the frame is rendered, this handles the actual flushing of
+        # the draw, which can be a direct draw_idle() or make use of the
+        # blitting.
+        if blit and self._drawn_artists:
+            self._blit_draw(self._drawn_artists)
+        else:
+            self._fig.canvas.draw_idle()
+
+    # The rest of the code in this class is to facilitate easy blitting
+    def _blit_draw(self, artists):
+        # Handles blitted drawing, which renders only the artists given instead
+        # of the entire figure.
+        updated_ax = {a.axes for a in artists}
+        # Enumerate artists to cache Axes backgrounds. We do not draw
+        # artists yet to not cache foreground from plots with shared Axes
+        for ax in updated_ax:
+            # If we haven't cached the background for the current view of this
+            # Axes object, do so now. This might not always be reliable, but
+            # it's an attempt to automate the process.
+            cur_view = ax._get_view()
+            view, bg = self._blit_cache.get(ax, (object(), None))
+            if cur_view != view:
+                self._blit_cache[ax] = (
+                    cur_view, ax.figure.canvas.copy_from_bbox(ax.bbox))
+        # Make a separate pass to draw foreground.
+        for a in artists:
+            a.axes.draw_artist(a)
+        # After rendering all the needed artists, blit each Axes individually.
+        for ax in updated_ax:
+            ax.figure.canvas.blit(ax.bbox)
+
+    def _blit_clear(self, artists):
+        # Get a list of the Axes that need clearing from the artists that
+        # have been drawn. Grab the appropriate saved background from the
+        # cache and restore.
+        axes = {a.axes for a in artists}
+        for ax in axes:
+            try:
+                view, bg = self._blit_cache[ax]
+            except KeyError:
+                continue
+            if ax._get_view() == view:
+                ax.figure.canvas.restore_region(bg)
+            else:
+                self._blit_cache.pop(ax)
+
+    def _setup_blit(self):
+        # Setting up the blit requires: a cache of the background for the Axes
+        self._blit_cache = dict()
+        self._drawn_artists = []
+        # _post_draw needs to be called first to initialize the renderer
+        self._post_draw(None, self._blit)
+        # Then we need to clear the Frame for the initial draw
+        # This is typically handled in _on_resize because QT and Tk
+        # emit a resize event on launch, but the macosx backend does not,
+        # thus we force it here for everyone for consistency
+        self._init_draw()
+        # Connect to future resize events
+        self._resize_id = self._fig.canvas.mpl_connect('resize_event',
+                                                       self._on_resize)
+
+    def _on_resize(self, event):
+        # On resize, we need to disable the resize event handling so we don't
+        # get too many events. Also stop the animation events, so that
+        # we're paused. Reset the cache and re-init. Set up an event handler
+        # to catch once the draw has actually taken place.
+        self._fig.canvas.mpl_disconnect(self._resize_id)
+        self.event_source.stop()
+        self._blit_cache.clear()
+        self._init_draw()
+        self._resize_id = self._fig.canvas.mpl_connect('draw_event',
+                                                       self._end_redraw)
+
+    def _end_redraw(self, event):
+        # Now that the redraw has happened, do the post draw flushing and
+        # blit handling. Then re-enable all of the original events.
+        self._post_draw(None, False)
+        self.event_source.start()
+        self._fig.canvas.mpl_disconnect(self._resize_id)
+        self._resize_id = self._fig.canvas.mpl_connect('resize_event',
+                                                       self._on_resize)
+
+    def to_html5_video(self, embed_limit=None):
+        """
+        Convert the animation to an HTML5 ``<video>`` tag.
+
+        This saves the animation as an h264 video, encoded in base64
+        directly into the HTML5 video tag. This respects :rc:`animation.writer`
+        and :rc:`animation.bitrate`. This also makes use of the
+        *interval* to control the speed, and uses the *repeat*
+        parameter to decide whether to loop.
+
+        Parameters
+        ----------
+        embed_limit : float, optional
+            Limit, in MB, of the returned animation. No animation is created
+            if the limit is exceeded.
+            Defaults to :rc:`animation.embed_limit` = 20.0.
+
+        Returns
+        -------
+        str
+            An HTML5 video tag with the animation embedded as base64 encoded
+            h264 video.
+            If the *embed_limit* is exceeded, this returns the string
+            "Video too large to embed."
+        """
+        VIDEO_TAG = r'''<video {size} {options}>
+  <source type="video/mp4" src="data:video/mp4;base64,{video}">
+  Your browser does not support the video tag.
+</video>'''
+        # Cache the rendering of the video as HTML
+        if not hasattr(self, '_base64_video'):
+            # Save embed limit, which is given in MB
+            embed_limit = mpl._val_or_rc(embed_limit, 'animation.embed_limit')
+
+            # Convert from MB to bytes
+            embed_limit *= 1024 * 1024
+
+            # Can't open a NamedTemporaryFile twice on Windows, so use a
+            # TemporaryDirectory instead.
+            with TemporaryDirectory() as tmpdir:
+                path = Path(tmpdir, "temp.m4v")
+                # We create a writer manually so that we can get the
+                # appropriate size for the tag
+                Writer = writers[mpl.rcParams['animation.writer']]
+                writer = Writer(codec='h264',
+                                bitrate=mpl.rcParams['animation.bitrate'],
+                                fps=1000. / self._interval)
+                self.save(str(path), writer=writer)
+                # Now open and base64 encode.
+                vid64 = base64.encodebytes(path.read_bytes())
+
+            vid_len = len(vid64)
+            if vid_len >= embed_limit:
+                _log.warning(
+                    "Animation movie is %s bytes, exceeding the limit of %s. "
+                    "If you're sure you want a large animation embedded, set "
+                    "the animation.embed_limit rc parameter to a larger value "
+                    "(in MB).", vid_len, embed_limit)
+            else:
+                self._base64_video = vid64.decode('ascii')
+                self._video_size = 'width="{}" height="{}"'.format(
+                        *writer.frame_size)
+
+        # If we exceeded the size, this attribute won't exist
+        if hasattr(self, '_base64_video'):
+            # Default HTML5 options are to autoplay and display video controls
+            options = ['controls', 'autoplay']
+
+            # If we're set to repeat, make it loop
+            if getattr(self, '_repeat', False):
+                options.append('loop')
+
+            return VIDEO_TAG.format(video=self._base64_video,
+                                    size=self._video_size,
+                                    options=' '.join(options))
+        else:
+            return 'Video too large to embed.'
+
+    def to_jshtml(self, fps=None, embed_frames=True, default_mode=None):
+        """
+        Generate HTML representation of the animation.
+
+        Parameters
+        ----------
+        fps : int, optional
+            Movie frame rate (per second). If not set, the frame rate from
+            the animation's frame interval.
+        embed_frames : bool, optional
+        default_mode : str, optional
+            What to do when the animation ends. Must be one of ``{'loop',
+            'once', 'reflect'}``. Defaults to ``'loop'`` if the *repeat*
+            parameter is True, otherwise ``'once'``.
+
+        Returns
+        -------
+        str
+            An HTML representation of the animation embedded as a js object as
+            produced with the `.HTMLWriter`.
+        """
+        if fps is None and hasattr(self, '_interval'):
+            # Convert interval in ms to frames per second
+            fps = 1000 / self._interval
+
+        # If we're not given a default mode, choose one base on the value of
+        # the _repeat attribute
+        if default_mode is None:
+            default_mode = 'loop' if getattr(self, '_repeat',
+                                             False) else 'once'
+
+        if not hasattr(self, "_html_representation"):
+            # Can't open a NamedTemporaryFile twice on Windows, so use a
+            # TemporaryDirectory instead.
+            with TemporaryDirectory() as tmpdir:
+                path = Path(tmpdir, "temp.html")
+                writer = HTMLWriter(fps=fps,
+                                    embed_frames=embed_frames,
+                                    default_mode=default_mode)
+                self.save(str(path), writer=writer)
+                self._html_representation = path.read_text()
+
+        return self._html_representation
+
+    def _repr_html_(self):
+        """IPython display hook for rendering."""
+        fmt = mpl.rcParams['animation.html']
+        if fmt == 'html5':
+            return self.to_html5_video()
+        elif fmt == 'jshtml':
+            return self.to_jshtml()
+
+    def pause(self):
+        """Pause the animation."""
+        self.event_source.stop()
+        if self._blit:
+            for artist in self._drawn_artists:
+                artist.set_animated(False)
+
+    def resume(self):
+        """Resume the animation."""
+        self.event_source.start()
+        if self._blit:
+            for artist in self._drawn_artists:
+                artist.set_animated(True)
+
+
+class TimedAnimation(Animation):
+    """
+    `Animation` subclass for time-based animation.
+
+    A new frame is drawn every *interval* milliseconds.
+
+    .. note::
+
+        You must store the created Animation in a variable that lives as long
+        as the animation should run. Otherwise, the Animation object will be
+        garbage-collected and the animation stops.
+
+    Parameters
+    ----------
+    fig : `~matplotlib.figure.Figure`
+        The figure object used to get needed events, such as draw or resize.
+    interval : int, default: 200
+        Delay between frames in milliseconds.
+    repeat_delay : int, default: 0
+        The delay in milliseconds between consecutive animation runs, if
+        *repeat* is True.
+    repeat : bool, default: True
+        Whether the animation repeats when the sequence of frames is completed.
+    blit : bool, default: False
+        Whether blitting is used to optimize drawing.
+    """
+    def __init__(self, fig, interval=200, repeat_delay=0, repeat=True,
+                 event_source=None, *args, **kwargs):
+        self._interval = interval
+        # Undocumented support for repeat_delay = None as backcompat.
+        self._repeat_delay = repeat_delay if repeat_delay is not None else 0
+        self._repeat = repeat
+        # If we're not given an event source, create a new timer. This permits
+        # sharing timers between animation objects for syncing animations.
+        if event_source is None:
+            event_source = fig.canvas.new_timer(interval=self._interval)
+        super().__init__(fig, event_source=event_source, *args, **kwargs)
+
+    def _step(self, *args):
+        """Handler for getting events."""
+        # Extends the _step() method for the Animation class.  If
+        # Animation._step signals that it reached the end and we want to
+        # repeat, we refresh the frame sequence and return True. If
+        # _repeat_delay is set, change the event_source's interval to our loop
+        # delay and set the callback to one which will then set the interval
+        # back.
+        still_going = super()._step(*args)
+        if not still_going:
+            if self._repeat:
+                # Restart the draw loop
+                self._init_draw()
+                self.frame_seq = self.new_frame_seq()
+                self.event_source.interval = self._repeat_delay
+                return True
+            else:
+                # We are done with the animation. Call pause to remove
+                # animated flags from artists that were using blitting
+                self.pause()
+                if self._blit:
+                    # Remove the resize callback if we were blitting
+                    self._fig.canvas.mpl_disconnect(self._resize_id)
+                self._fig.canvas.mpl_disconnect(self._close_id)
+                self.event_source = None
+                return False
+
+        self.event_source.interval = self._interval
+        return True
+
+
+class ArtistAnimation(TimedAnimation):
+    """
+    `TimedAnimation` subclass that creates an animation by using a fixed
+    set of `.Artist` objects.
+
+    Before creating an instance, all plotting should have taken place
+    and the relevant artists saved.
+
+    .. note::
+
+        You must store the created Animation in a variable that lives as long
+        as the animation should run. Otherwise, the Animation object will be
+        garbage-collected and the animation stops.
+
+    Parameters
+    ----------
+    fig : `~matplotlib.figure.Figure`
+        The figure object used to get needed events, such as draw or resize.
+    artists : list
+        Each list entry is a collection of `.Artist` objects that are made
+        visible on the corresponding frame.  Other artists are made invisible.
+    interval : int, default: 200
+        Delay between frames in milliseconds.
+    repeat_delay : int, default: 0
+        The delay in milliseconds between consecutive animation runs, if
+        *repeat* is True.
+    repeat : bool, default: True
+        Whether the animation repeats when the sequence of frames is completed.
+    blit : bool, default: False
+        Whether blitting is used to optimize drawing.
+    """
+
+    def __init__(self, fig, artists, *args, **kwargs):
+        # Internal list of artists drawn in the most recent frame.
+        self._drawn_artists = []
+
+        # Use the list of artists as the framedata, which will be iterated
+        # over by the machinery.
+        self._framedata = artists
+        super().__init__(fig, *args, **kwargs)
+
+    def _init_draw(self):
+        super()._init_draw()
+        # Make all the artists involved in *any* frame invisible
+        figs = set()
+        for f in self.new_frame_seq():
+            for artist in f:
+                artist.set_visible(False)
+                artist.set_animated(self._blit)
+                # Assemble a list of unique figures that need flushing
+                if artist.get_figure() not in figs:
+                    figs.add(artist.get_figure())
+
+        # Flush the needed figures
+        for fig in figs:
+            fig.canvas.draw_idle()
+
+    def _pre_draw(self, framedata, blit):
+        """Clears artists from the last frame."""
+        if blit:
+            # Let blit handle clearing
+            self._blit_clear(self._drawn_artists)
+        else:
+            # Otherwise, make all the artists from the previous frame invisible
+            for artist in self._drawn_artists:
+                artist.set_visible(False)
+
+    def _draw_frame(self, artists):
+        # Save the artists that were passed in as framedata for the other
+        # steps (esp. blitting) to use.
+        self._drawn_artists = artists
+
+        # Make all the artists from the current frame visible
+        for artist in artists:
+            artist.set_visible(True)
+
+
+class FuncAnimation(TimedAnimation):
+    """
+    `TimedAnimation` subclass that makes an animation by repeatedly calling
+    a function *func*.
+
+    .. note::
+
+        You must store the created Animation in a variable that lives as long
+        as the animation should run. Otherwise, the Animation object will be
+        garbage-collected and the animation stops.
+
+    Parameters
+    ----------
+    fig : `~matplotlib.figure.Figure`
+        The figure object used to get needed events, such as draw or resize.
+
+    func : callable
+        The function to call at each frame.  The first argument will
+        be the next value in *frames*.   Any additional positional
+        arguments can be supplied using `functools.partial` or via the *fargs*
+        parameter.
+
+        The required signature is::
+
+            def func(frame, *fargs) -> iterable_of_artists
+
+        It is often more convenient to provide the arguments using
+        `functools.partial`. In this way it is also possible to pass keyword
+        arguments. To pass a function with both positional and keyword
+        arguments, set all arguments as keyword arguments, just leaving the
+        *frame* argument unset::
+
+            def func(frame, art, *, y=None):
+                ...
+
+            ani = FuncAnimation(fig, partial(func, art=ln, y='foo'))
+
+        If ``blit == True``, *func* must return an iterable of all artists
+        that were modified or created. This information is used by the blitting
+        algorithm to determine which parts of the figure have to be updated.
+        The return value is unused if ``blit == False`` and may be omitted in
+        that case.
+
+    frames : iterable, int, generator function, or None, optional
+        Source of data to pass *func* and each frame of the animation
+
+        - If an iterable, then simply use the values provided.  If the
+          iterable has a length, it will override the *save_count* kwarg.
+
+        - If an integer, then equivalent to passing ``range(frames)``
+
+        - If a generator function, then must have the signature::
+
+             def gen_function() -> obj
+
+        - If *None*, then equivalent to passing ``itertools.count``.
+
+        In all of these cases, the values in *frames* is simply passed through
+        to the user-supplied *func* and thus can be of any type.
+
+    init_func : callable, optional
+        A function used to draw a clear frame. If not given, the results of
+        drawing from the first item in the frames sequence will be used. This
+        function will be called once before the first frame.
+
+        The required signature is::
+
+            def init_func() -> iterable_of_artists
+
+        If ``blit == True``, *init_func* must return an iterable of artists
+        to be re-drawn. This information is used by the blitting algorithm to
+        determine which parts of the figure have to be updated.  The return
+        value is unused if ``blit == False`` and may be omitted in that case.
+
+    fargs : tuple or None, optional
+        Additional arguments to pass to each call to *func*. Note: the use of
+        `functools.partial` is preferred over *fargs*. See *func* for details.
+
+    save_count : int, optional
+        Fallback for the number of values from *frames* to cache. This is
+        only used if the number of frames cannot be inferred from *frames*,
+        i.e. when it's an iterator without length or a generator.
+
+    interval : int, default: 200
+        Delay between frames in milliseconds.
+
+    repeat_delay : int, default: 0
+        The delay in milliseconds between consecutive animation runs, if
+        *repeat* is True.
+
+    repeat : bool, default: True
+        Whether the animation repeats when the sequence of frames is completed.
+
+    blit : bool, default: False
+        Whether blitting is used to optimize drawing.  Note: when using
+        blitting, any animated artists will be drawn according to their zorder;
+        however, they will be drawn on top of any previous artists, regardless
+        of their zorder.
+
+    cache_frame_data : bool, default: True
+        Whether frame data is cached.  Disabling cache might be helpful when
+        frames contain large objects.
+    """
+    def __init__(self, fig, func, frames=None, init_func=None, fargs=None,
+                 save_count=None, *, cache_frame_data=True, **kwargs):
+        if fargs:
+            self._args = fargs
+        else:
+            self._args = ()
+        self._func = func
+        self._init_func = init_func
+
+        # Amount of framedata to keep around for saving movies. This is only
+        # used if we don't know how many frames there will be: in the case
+        # of no generator or in the case of a callable.
+        self._save_count = save_count
+        # Set up a function that creates a new iterable when needed. If nothing
+        # is passed in for frames, just use itertools.count, which will just
+        # keep counting from 0. A callable passed in for frames is assumed to
+        # be a generator. An iterable will be used as is, and anything else
+        # will be treated as a number of frames.
+        if frames is None:
+            self._iter_gen = itertools.count
+        elif callable(frames):
+            self._iter_gen = frames
+        elif np.iterable(frames):
+            if kwargs.get('repeat', True):
+                self._tee_from = frames
+                def iter_frames(frames=frames):
+                    this, self._tee_from = itertools.tee(self._tee_from, 2)
+                    yield from this
+                self._iter_gen = iter_frames
+            else:
+                self._iter_gen = lambda: iter(frames)
+            if hasattr(frames, '__len__'):
+                self._save_count = len(frames)
+                if save_count is not None:
+                    _api.warn_external(
+                        f"You passed in an explicit {save_count=} "
+                        "which is being ignored in favor of "
+                        f"{len(frames)=}."
+                    )
+        else:
+            self._iter_gen = lambda: iter(range(frames))
+            self._save_count = frames
+            if save_count is not None:
+                _api.warn_external(
+                    f"You passed in an explicit {save_count=} which is being "
+                    f"ignored in favor of {frames=}."
+                )
+        if self._save_count is None and cache_frame_data:
+            _api.warn_external(
+                f"{frames=!r} which we can infer the length of, "
+                "did not pass an explicit *save_count* "
+                f"and passed {cache_frame_data=}.  To avoid a possibly "
+                "unbounded cache, frame data caching has been disabled. "
+                "To suppress this warning either pass "
+                "`cache_frame_data=False` or `save_count=MAX_FRAMES`."
+            )
+            cache_frame_data = False
+
+        self._cache_frame_data = cache_frame_data
+
+        # Needs to be initialized so the draw functions work without checking
+        self._save_seq = []
+
+        super().__init__(fig, **kwargs)
+
+        # Need to reset the saved seq, since right now it will contain data
+        # for a single frame from init, which is not what we want.
+        self._save_seq = []
+
+    def new_frame_seq(self):
+        # Use the generating function to generate a new frame sequence
+        return self._iter_gen()
+
+    def new_saved_frame_seq(self):
+        # Generate an iterator for the sequence of saved data. If there are
+        # no saved frames, generate a new frame sequence and take the first
+        # save_count entries in it.
+        if self._save_seq:
+            # While iterating we are going to update _save_seq
+            # so make a copy to safely iterate over
+            self._old_saved_seq = list(self._save_seq)
+            return iter(self._old_saved_seq)
+        else:
+            if self._save_count is None:
+                frame_seq = self.new_frame_seq()
+
+                def gen():
+                    try:
+                        while True:
+                            yield next(frame_seq)
+                    except StopIteration:
+                        pass
+                return gen()
+            else:
+                return itertools.islice(self.new_frame_seq(), self._save_count)
+
+    def _init_draw(self):
+        super()._init_draw()
+        # Initialize the drawing either using the given init_func or by
+        # calling the draw function with the first item of the frame sequence.
+        # For blitting, the init_func should return a sequence of modified
+        # artists.
+        if self._init_func is None:
+            try:
+                frame_data = next(self.new_frame_seq())
+            except StopIteration:
+                # we can't start the iteration, it may have already been
+                # exhausted by a previous save or just be 0 length.
+                # warn and bail.
+                warnings.warn(
+                    "Can not start iterating the frames for the initial draw. "
+                    "This can be caused by passing in a 0 length sequence "
+                    "for *frames*.\n\n"
+                    "If you passed *frames* as a generator "
+                    "it may be exhausted due to a previous display or save."
+                )
+                return
+            self._draw_frame(frame_data)
+        else:
+            self._drawn_artists = self._init_func()
+            if self._blit:
+                if self._drawn_artists is None:
+                    raise RuntimeError('The init_func must return a '
+                                       'sequence of Artist objects.')
+                for a in self._drawn_artists:
+                    a.set_animated(self._blit)
+        self._save_seq = []
+
+    def _draw_frame(self, framedata):
+        if self._cache_frame_data:
+            # Save the data for potential saving of movies.
+            self._save_seq.append(framedata)
+            self._save_seq = self._save_seq[-self._save_count:]
+
+        # Call the func with framedata and args. If blitting is desired,
+        # func needs to return a sequence of any artists that were modified.
+        self._drawn_artists = self._func(framedata, *self._args)
+
+        if self._blit:
+
+            err = RuntimeError('The animation function must return a sequence '
+                               'of Artist objects.')
+            try:
+                # check if a sequence
+                iter(self._drawn_artists)
+            except TypeError:
+                raise err from None
+
+            # check each item if it's artist
+            for i in self._drawn_artists:
+                if not isinstance(i, mpl.artist.Artist):
+                    raise err
+
+            self._drawn_artists = sorted(self._drawn_artists,
+                                         key=lambda x: x.get_zorder())
+
+            for a in self._drawn_artists:
+                a.set_animated(self._blit)
+
+
+def _validate_grabframe_kwargs(savefig_kwargs):
+    if mpl.rcParams['savefig.bbox'] == 'tight':
+        raise ValueError(
+            f"{mpl.rcParams['savefig.bbox']=} must not be 'tight' as it "
+            "may cause frame size to vary, which is inappropriate for animation."
+        )
+    for k in ('dpi', 'bbox_inches', 'format'):
+        if k in savefig_kwargs:
+            raise TypeError(
+                f"grab_frame got an unexpected keyword argument {k!r}"
+            )

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/animation.pyi

@@ -0,0 +1,217 @@
+import abc
+from collections.abc import Callable, Collection, Iterable, Sequence, Generator
+import contextlib
+from pathlib import Path
+from matplotlib.artist import Artist
+from matplotlib.backend_bases import TimerBase
+from matplotlib.figure import Figure
+
+from typing import Any
+
+subprocess_creation_flags: int
+
+def adjusted_figsize(w: float, h: float, dpi: float, n: int) -> tuple[float, float]: ...
+
+class MovieWriterRegistry:
+    def __init__(self) -> None: ...
+    def register(
+        self, name: str
+    ) -> Callable[[type[AbstractMovieWriter]], type[AbstractMovieWriter]]: ...
+    def is_available(self, name: str) -> bool: ...
+    def __iter__(self) -> Generator[str, None, None]: ...
+    def list(self) -> list[str]: ...
+    def __getitem__(self, name: str) -> type[AbstractMovieWriter]: ...
+
+writers: MovieWriterRegistry
+
+class AbstractMovieWriter(abc.ABC, metaclass=abc.ABCMeta):
+    fps: int
+    metadata: dict[str, str]
+    codec: str
+    bitrate: int
+    def __init__(
+        self,
+        fps: int = ...,
+        metadata: dict[str, str] | None = ...,
+        codec: str | None = ...,
+        bitrate: int | None = ...,
+    ) -> None: ...
+    outfile: str | Path
+    fig: Figure
+    dpi: float
+
+    @abc.abstractmethod
+    def setup(self, fig: Figure, outfile: str | Path, dpi: float | None = ...) -> None: ...
+    @property
+    def frame_size(self) -> tuple[int, int]: ...
+    @abc.abstractmethod
+    def grab_frame(self, **savefig_kwargs) -> None: ...
+    @abc.abstractmethod
+    def finish(self) -> None: ...
+    @contextlib.contextmanager
+    def saving(
+        self, fig: Figure, outfile: str | Path, dpi: float | None, *args, **kwargs
+    ) -> Generator[AbstractMovieWriter, None, None]: ...
+
+class MovieWriter(AbstractMovieWriter):
+    supported_formats: list[str]
+    frame_format: str
+    extra_args: list[str] | None
+    def __init__(
+        self,
+        fps: int = ...,
+        codec: str | None = ...,
+        bitrate: int | None = ...,
+        extra_args: list[str] | None = ...,
+        metadata: dict[str, str] | None = ...,
+    ) -> None: ...
+    def setup(self, fig: Figure, outfile: str | Path, dpi: float | None = ...) -> None: ...
+    def grab_frame(self, **savefig_kwargs) -> None: ...
+    def finish(self) -> None: ...
+    @classmethod
+    def bin_path(cls) -> str: ...
+    @classmethod
+    def isAvailable(cls) -> bool: ...
+
+class FileMovieWriter(MovieWriter):
+    fig: Figure
+    outfile: str | Path
+    dpi: float
+    temp_prefix: str
+    fname_format_str: str
+    def setup(
+        self,
+        fig: Figure,
+        outfile: str | Path,
+        dpi: float | None = ...,
+        frame_prefix: str | Path | None = ...,
+    ) -> None: ...
+    def __del__(self) -> None: ...
+    @property
+    def frame_format(self) -> str: ...
+    @frame_format.setter
+    def frame_format(self, frame_format: str) -> None: ...
+
+class PillowWriter(AbstractMovieWriter):
+    @classmethod
+    def isAvailable(cls) -> bool: ...
+    def setup(
+        self, fig: Figure, outfile: str | Path, dpi: float | None = ...
+    ) -> None: ...
+    def grab_frame(self, **savefig_kwargs) -> None: ...
+    def finish(self) -> None: ...
+
+class FFMpegBase:
+    codec: str
+    @property
+    def output_args(self) -> list[str]: ...
+
+class FFMpegWriter(FFMpegBase, MovieWriter): ...
+
+class FFMpegFileWriter(FFMpegBase, FileMovieWriter):
+    supported_formats: list[str]
+
+class ImageMagickBase:
+    @classmethod
+    def bin_path(cls) -> str: ...
+    @classmethod
+    def isAvailable(cls) -> bool: ...
+
+class ImageMagickWriter(ImageMagickBase, MovieWriter):
+    input_names: str
+
+class ImageMagickFileWriter(ImageMagickBase, FileMovieWriter):
+    supported_formats: list[str]
+    @property
+    def input_names(self) -> str: ...
+
+class HTMLWriter(FileMovieWriter):
+    supported_formats: list[str]
+    @classmethod
+    def isAvailable(cls) -> bool: ...
+    embed_frames: bool
+    default_mode: str
+    def __init__(
+        self,
+        fps: int = ...,
+        codec: str | None = ...,
+        bitrate: int | None = ...,
+        extra_args: list[str] | None = ...,
+        metadata: dict[str, str] | None = ...,
+        embed_frames: bool = ...,
+        default_mode: str = ...,
+        embed_limit: float | None = ...,
+    ) -> None: ...
+    def setup(
+        self,
+        fig: Figure,
+        outfile: str | Path,
+        dpi: float | None = ...,
+        frame_dir: str | Path | None = ...,
+    ) -> None: ...
+    def grab_frame(self, **savefig_kwargs): ...
+    def finish(self) -> None: ...
+
+class Animation:
+    frame_seq: Iterable[Artist]
+    event_source: Any
+    def __init__(
+        self, fig: Figure, event_source: Any | None = ..., blit: bool = ...
+    ) -> None: ...
+    def __del__(self) -> None: ...
+    def save(
+        self,
+        filename: str | Path,
+        writer: AbstractMovieWriter | str | None = ...,
+        fps: int | None = ...,
+        dpi: float | None = ...,
+        codec: str | None = ...,
+        bitrate: int | None = ...,
+        extra_args: list[str] | None = ...,
+        metadata: dict[str, str] | None = ...,
+        extra_anim: list[Animation] | None = ...,
+        savefig_kwargs: dict[str, Any] | None = ...,
+        *,
+        progress_callback: Callable[[int, int], Any] | None = ...
+    ) -> None: ...
+    def new_frame_seq(self) -> Iterable[Artist]: ...
+    def new_saved_frame_seq(self) -> Iterable[Artist]: ...
+    def to_html5_video(self, embed_limit: float | None = ...) -> str: ...
+    def to_jshtml(
+        self,
+        fps: int | None = ...,
+        embed_frames: bool = ...,
+        default_mode: str | None = ...,
+    ) -> str: ...
+    def _repr_html_(self) -> str: ...
+    def pause(self) -> None: ...
+    def resume(self) -> None: ...
+
+class TimedAnimation(Animation):
+    def __init__(
+        self,
+        fig: Figure,
+        interval: int = ...,
+        repeat_delay: int = ...,
+        repeat: bool = ...,
+        event_source: TimerBase | None = ...,
+        *args,
+        **kwargs
+    ) -> None: ...
+
+class ArtistAnimation(TimedAnimation):
+    def __init__(self, fig: Figure, artists: Sequence[Collection[Artist]], *args, **kwargs) -> None: ...
+
+class FuncAnimation(TimedAnimation):
+    def __init__(
+        self,
+        fig: Figure,
+        func: Callable[..., Iterable[Artist]],
+        frames: Iterable | int | Callable[[], Generator] | None = ...,
+        init_func: Callable[[], Iterable[Artist]] | None = ...,
+        fargs: tuple[Any, ...] | None = ...,
+        save_count: int | None = ...,
+        *,
+        cache_frame_data: bool = ...,
+        **kwargs
+    ) -> None: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/artist.py

@@ -0,0 +1,1855 @@
+from collections import namedtuple
+import contextlib
+from functools import cache, reduce, wraps
+import inspect
+from inspect import Signature, Parameter
+import logging
+from numbers import Number, Real
+import operator
+import re
+import warnings
+
+import numpy as np
+
+import matplotlib as mpl
+from . import _api, cbook
+from .path import Path
+from .transforms import (BboxBase, Bbox, IdentityTransform, Transform, TransformedBbox,
+                         TransformedPatchPath, TransformedPath)
+
+_log = logging.getLogger(__name__)
+
+
+def _prevent_rasterization(draw):
+    # We assume that by default artists are not allowed to rasterize (unless
+    # its draw method is explicitly decorated). If it is being drawn after a
+    # rasterized artist and it has reached a raster_depth of 0, we stop
+    # rasterization so that it does not affect the behavior of normal artist
+    # (e.g., change in dpi).
+
+    @wraps(draw)
+    def draw_wrapper(artist, renderer, *args, **kwargs):
+        if renderer._raster_depth == 0 and renderer._rasterizing:
+            # Only stop when we are not in a rasterized parent
+            # and something has been rasterized since last stop.
+            renderer.stop_rasterizing()
+            renderer._rasterizing = False
+
+        return draw(artist, renderer, *args, **kwargs)
+
+    draw_wrapper._supports_rasterization = False
+    return draw_wrapper
+
+
+def allow_rasterization(draw):
+    """
+    Decorator for Artist.draw method. Provides routines
+    that run before and after the draw call. The before and after functions
+    are useful for changing artist-dependent renderer attributes or making
+    other setup function calls, such as starting and flushing a mixed-mode
+    renderer.
+    """
+
+    @wraps(draw)
+    def draw_wrapper(artist, renderer):
+        try:
+            if artist.get_rasterized():
+                if renderer._raster_depth == 0 and not renderer._rasterizing:
+                    renderer.start_rasterizing()
+                    renderer._rasterizing = True
+                renderer._raster_depth += 1
+            else:
+                if renderer._raster_depth == 0 and renderer._rasterizing:
+                    # Only stop when we are not in a rasterized parent
+                    # and something has be rasterized since last stop
+                    renderer.stop_rasterizing()
+                    renderer._rasterizing = False
+
+            if artist.get_agg_filter() is not None:
+                renderer.start_filter()
+
+            return draw(artist, renderer)
+        finally:
+            if artist.get_agg_filter() is not None:
+                renderer.stop_filter(artist.get_agg_filter())
+            if artist.get_rasterized():
+                renderer._raster_depth -= 1
+            if (renderer._rasterizing and (fig := artist.get_figure(root=True)) and
+                    fig.suppressComposite):
+                # restart rasterizing to prevent merging
+                renderer.stop_rasterizing()
+                renderer.start_rasterizing()
+
+    draw_wrapper._supports_rasterization = True
+    return draw_wrapper
+
+
+def _finalize_rasterization(draw):
+    """
+    Decorator for Artist.draw method. Needed on the outermost artist, i.e.
+    Figure, to finish up if the render is still in rasterized mode.
+    """
+    @wraps(draw)
+    def draw_wrapper(artist, renderer, *args, **kwargs):
+        result = draw(artist, renderer, *args, **kwargs)
+        if renderer._rasterizing:
+            renderer.stop_rasterizing()
+            renderer._rasterizing = False
+        return result
+    return draw_wrapper
+
+
+def _stale_axes_callback(self, val):
+    if self.axes:
+        self.axes.stale = val
+
+
+_XYPair = namedtuple("_XYPair", "x y")
+
+
+class _Unset:
+    def __repr__(self):
+        return "<UNSET>"
+_UNSET = _Unset()
+
+
+class Artist:
+    """
+    Abstract base class for objects that render into a FigureCanvas.
+
+    Typically, all visible elements in a figure are subclasses of Artist.
+    """
+
+    zorder = 0
+
+    def __init_subclass__(cls):
+
+        # Decorate draw() method so that all artists are able to stop
+        # rastrization when necessary. If the artist's draw method is already
+        # decorated (has a `_supports_rasterization` attribute), it won't be
+        # decorated.
+
+        if not hasattr(cls.draw, "_supports_rasterization"):
+            cls.draw = _prevent_rasterization(cls.draw)
+
+        # Inject custom set() methods into the subclass with signature and
+        # docstring based on the subclasses' properties.
+
+        if not hasattr(cls.set, '_autogenerated_signature'):
+            # Don't overwrite cls.set if the subclass or one of its parents
+            # has defined a set method set itself.
+            # If there was no explicit definition, cls.set is inherited from
+            # the hierarchy of auto-generated set methods, which hold the
+            # flag _autogenerated_signature.
+            return
+
+        cls.set = lambda self, **kwargs: Artist.set(self, **kwargs)
+        cls.set.__name__ = "set"
+        cls.set.__qualname__ = f"{cls.__qualname__}.set"
+        cls._update_set_signature_and_docstring()
+
+    _PROPERTIES_EXCLUDED_FROM_SET = [
+        'navigate_mode',  # not a user-facing function
+        'figure',         # changing the figure is such a profound operation
+                          # that we don't want this in set()
+        '3d_properties',  # cannot be used as a keyword due to leading digit
+    ]
+
+    @classmethod
+    def _update_set_signature_and_docstring(cls):
+        """
+        Update the signature of the set function to list all properties
+        as keyword arguments.
+
+        Property aliases are not listed in the signature for brevity, but
+        are still accepted as keyword arguments.
+        """
+        cls.set.__signature__ = Signature(
+            [Parameter("self", Parameter.POSITIONAL_OR_KEYWORD),
+             *[Parameter(prop, Parameter.KEYWORD_ONLY, default=_UNSET)
+               for prop in ArtistInspector(cls).get_setters()
+               if prop not in Artist._PROPERTIES_EXCLUDED_FROM_SET]])
+        cls.set._autogenerated_signature = True
+
+        cls.set.__doc__ = (
+            "Set multiple properties at once.\n\n"
+            "Supported properties are\n\n"
+            + kwdoc(cls))
+
+    def __init__(self):
+        self._stale = True
+        self.stale_callback = None
+        self._axes = None
+        self._parent_figure = None
+
+        self._transform = None
+        self._transformSet = False
+        self._visible = True
+        self._animated = False
+        self._alpha = None
+        self.clipbox = None
+        self._clippath = None
+        self._clipon = True
+        self._label = ''
+        self._picker = None
+        self._rasterized = False
+        self._agg_filter = None
+        # Normally, artist classes need to be queried for mouseover info if and
+        # only if they override get_cursor_data.
+        self._mouseover = type(self).get_cursor_data != Artist.get_cursor_data
+        self._callbacks = cbook.CallbackRegistry(signals=["pchanged"])
+        try:
+            self.axes = None
+        except AttributeError:
+            # Handle self.axes as a read-only property, as in Figure.
+            pass
+        self._remove_method = None
+        self._url = None
+        self._gid = None
+        self._snap = None
+        self._sketch = mpl.rcParams['path.sketch']
+        self._path_effects = mpl.rcParams['path.effects']
+        self._sticky_edges = _XYPair([], [])
+        self._in_layout = True
+
+    def __getstate__(self):
+        d = self.__dict__.copy()
+        d['stale_callback'] = None
+        return d
+
+    def remove(self):
+        """
+        Remove the artist from the figure if possible.
+
+        The effect will not be visible until the figure is redrawn, e.g.,
+        with `.FigureCanvasBase.draw_idle`.  Call `~.axes.Axes.relim` to
+        update the Axes limits if desired.
+
+        Note: `~.axes.Axes.relim` will not see collections even if the
+        collection was added to the Axes with *autolim* = True.
+
+        Note: there is no support for removing the artist's legend entry.
+        """
+
+        # There is no method to set the callback.  Instead, the parent should
+        # set the _remove_method attribute directly.  This would be a
+        # protected attribute if Python supported that sort of thing.  The
+        # callback has one parameter, which is the child to be removed.
+        if self._remove_method is not None:
+            self._remove_method(self)
+            # clear stale callback
+            self.stale_callback = None
+            _ax_flag = False
+            if hasattr(self, 'axes') and self.axes:
+                # remove from the mouse hit list
+                self.axes._mouseover_set.discard(self)
+                self.axes.stale = True
+                self.axes = None  # decouple the artist from the Axes
+                _ax_flag = True
+
+            if (fig := self.get_figure(root=False)) is not None:
+                if not _ax_flag:
+                    fig.stale = True
+                self._parent_figure = None
+
+        else:
+            raise NotImplementedError('cannot remove artist')
+        # TODO: the fix for the collections relim problem is to move the
+        # limits calculation into the artist itself, including the property of
+        # whether or not the artist should affect the limits.  Then there will
+        # be no distinction between axes.add_line, axes.add_patch, etc.
+        # TODO: add legend support
+
+    def have_units(self):
+        """Return whether units are set on any axis."""
+        ax = self.axes
+        return ax and any(axis.have_units() for axis in ax._axis_map.values())
+
+    def convert_xunits(self, x):
+        """
+        Convert *x* using the unit type of the xaxis.
+
+        If the artist is not contained in an Axes or if the xaxis does not
+        have units, *x* itself is returned.
+        """
+        ax = getattr(self, 'axes', None)
+        if ax is None or ax.xaxis is None:
+            return x
+        return ax.xaxis.convert_units(x)
+
+    def convert_yunits(self, y):
+        """
+        Convert *y* using the unit type of the yaxis.
+
+        If the artist is not contained in an Axes or if the yaxis does not
+        have units, *y* itself is returned.
+        """
+        ax = getattr(self, 'axes', None)
+        if ax is None or ax.yaxis is None:
+            return y
+        return ax.yaxis.convert_units(y)
+
+    @property
+    def axes(self):
+        """The `~.axes.Axes` instance the artist resides in, or *None*."""
+        return self._axes
+
+    @axes.setter
+    def axes(self, new_axes):
+        if (new_axes is not None and self._axes is not None
+                and new_axes != self._axes):
+            raise ValueError("Can not reset the Axes. You are probably trying to reuse "
+                             "an artist in more than one Axes which is not supported")
+        self._axes = new_axes
+        if new_axes is not None and new_axes is not self:
+            self.stale_callback = _stale_axes_callback
+
+    @property
+    def stale(self):
+        """
+        Whether the artist is 'stale' and needs to be re-drawn for the output
+        to match the internal state of the artist.
+        """
+        return self._stale
+
+    @stale.setter
+    def stale(self, val):
+        self._stale = val
+
+        # if the artist is animated it does not take normal part in the
+        # draw stack and is not expected to be drawn as part of the normal
+        # draw loop (when not saving) so do not propagate this change
+        if self._animated:
+            return
+
+        if val and self.stale_callback is not None:
+            self.stale_callback(self, val)
+
+    def get_window_extent(self, renderer=None):
+        """
+        Get the artist's bounding box in display space.
+
+        The bounding box' width and height are nonnegative.
+
+        Subclasses should override for inclusion in the bounding box
+        "tight" calculation. Default is to return an empty bounding
+        box at 0, 0.
+
+        Be careful when using this function, the results will not update
+        if the artist window extent of the artist changes.  The extent
+        can change due to any changes in the transform stack, such as
+        changing the Axes limits, the figure size, or the canvas used
+        (as is done when saving a figure).  This can lead to unexpected
+        behavior where interactive figures will look fine on the screen,
+        but will save incorrectly.
+        """
+        return Bbox([[0, 0], [0, 0]])
+
+    def get_tightbbox(self, renderer=None):
+        """
+        Like `.Artist.get_window_extent`, but includes any clipping.
+
+        Parameters
+        ----------
+        renderer : `~matplotlib.backend_bases.RendererBase` subclass, optional
+            renderer that will be used to draw the figures (i.e.
+            ``fig.canvas.get_renderer()``)
+
+        Returns
+        -------
+        `.Bbox` or None
+            The enclosing bounding box (in figure pixel coordinates).
+            Returns None if clipping results in no intersection.
+        """
+        bbox = self.get_window_extent(renderer)
+        if self.get_clip_on():
+            clip_box = self.get_clip_box()
+            if clip_box is not None:
+                bbox = Bbox.intersection(bbox, clip_box)
+            clip_path = self.get_clip_path()
+            if clip_path is not None and bbox is not None:
+                clip_path = clip_path.get_fully_transformed_path()
+                bbox = Bbox.intersection(bbox, clip_path.get_extents())
+        return bbox
+
+    def add_callback(self, func):
+        """
+        Add a callback function that will be called whenever one of the
+        `.Artist`'s properties changes.
+
+        Parameters
+        ----------
+        func : callable
+            The callback function. It must have the signature::
+
+                def func(artist: Artist) -> Any
+
+            where *artist* is the calling `.Artist`. Return values may exist
+            but are ignored.
+
+        Returns
+        -------
+        int
+            The observer id associated with the callback. This id can be
+            used for removing the callback with `.remove_callback` later.
+
+        See Also
+        --------
+        remove_callback
+        """
+        # Wrapping func in a lambda ensures it can be connected multiple times
+        # and never gets weakref-gc'ed.
+        return self._callbacks.connect("pchanged", lambda: func(self))
+
+    def remove_callback(self, oid):
+        """
+        Remove a callback based on its observer id.
+
+        See Also
+        --------
+        add_callback
+        """
+        self._callbacks.disconnect(oid)
+
+    def pchanged(self):
+        """
+        Call all of the registered callbacks.
+
+        This function is triggered internally when a property is changed.
+
+        See Also
+        --------
+        add_callback
+        remove_callback
+        """
+        self._callbacks.process("pchanged")
+
+    def is_transform_set(self):
+        """
+        Return whether the Artist has an explicitly set transform.
+
+        This is *True* after `.set_transform` has been called.
+        """
+        return self._transformSet
+
+    def set_transform(self, t):
+        """
+        Set the artist transform.
+
+        Parameters
+        ----------
+        t : `~matplotlib.transforms.Transform`
+        """
+        self._transform = t
+        self._transformSet = True
+        self.pchanged()
+        self.stale = True
+
+    def get_transform(self):
+        """Return the `.Transform` instance used by this artist."""
+        if self._transform is None:
+            self._transform = IdentityTransform()
+        elif (not isinstance(self._transform, Transform)
+              and hasattr(self._transform, '_as_mpl_transform')):
+            self._transform = self._transform._as_mpl_transform(self.axes)
+        return self._transform
+
+    def get_children(self):
+        r"""Return a list of the child `.Artist`\s of this `.Artist`."""
+        return []
+
+    def _different_canvas(self, event):
+        """
+        Check whether an *event* occurred on a canvas other that this artist's canvas.
+
+        If this method returns True, the event definitely occurred on a different
+        canvas; if it returns False, either it occurred on the same canvas, or we may
+        not have enough information to know.
+
+        Subclasses should start their definition of `contains` as follows::
+
+            if self._different_canvas(mouseevent):
+                return False, {}
+            # subclass-specific implementation follows
+        """
+        return (getattr(event, "canvas", None) is not None
+                and (fig := self.get_figure(root=True)) is not None
+                and event.canvas is not fig.canvas)
+
+    def contains(self, mouseevent):
+        """
+        Test whether the artist contains the mouse event.
+
+        Parameters
+        ----------
+        mouseevent : `~matplotlib.backend_bases.MouseEvent`
+
+        Returns
+        -------
+        contains : bool
+            Whether any values are within the radius.
+        details : dict
+            An artist-specific dictionary of details of the event context,
+            such as which points are contained in the pick radius. See the
+            individual Artist subclasses for details.
+        """
+        _log.warning("%r needs 'contains' method", self.__class__.__name__)
+        return False, {}
+
+    def pickable(self):
+        """
+        Return whether the artist is pickable.
+
+        See Also
+        --------
+        .Artist.set_picker, .Artist.get_picker, .Artist.pick
+        """
+        return self.get_figure(root=False) is not None and self._picker is not None
+
+    def pick(self, mouseevent):
+        """
+        Process a pick event.
+
+        Each child artist will fire a pick event if *mouseevent* is over
+        the artist and the artist has picker set.
+
+        See Also
+        --------
+        .Artist.set_picker, .Artist.get_picker, .Artist.pickable
+        """
+        from .backend_bases import PickEvent  # Circular import.
+        # Pick self
+        if self.pickable():
+            picker = self.get_picker()
+            if callable(picker):
+                inside, prop = picker(self, mouseevent)
+            else:
+                inside, prop = self.contains(mouseevent)
+            if inside:
+                PickEvent("pick_event", self.get_figure(root=True).canvas,
+                          mouseevent, self, **prop)._process()
+
+        # Pick children
+        for a in self.get_children():
+            # make sure the event happened in the same Axes
+            ax = getattr(a, 'axes', None)
+            if (isinstance(a, mpl.figure.SubFigure)
+                    or mouseevent.inaxes is None or ax is None
+                    or mouseevent.inaxes == ax):
+                # we need to check if mouseevent.inaxes is None
+                # because some objects associated with an Axes (e.g., a
+                # tick label) can be outside the bounding box of the
+                # Axes and inaxes will be None
+                # also check that ax is None so that it traverse objects
+                # which do not have an axes property but children might
+                a.pick(mouseevent)
+
+    def set_picker(self, picker):
+        """
+        Define the picking behavior of the artist.
+
+        Parameters
+        ----------
+        picker : None or bool or float or callable
+            This can be one of the following:
+
+            - *None*: Picking is disabled for this artist (default).
+
+            - A boolean: If *True* then picking will be enabled and the
+              artist will fire a pick event if the mouse event is over
+              the artist.
+
+            - A float: If picker is a number it is interpreted as an
+              epsilon tolerance in points and the artist will fire
+              off an event if its data is within epsilon of the mouse
+              event.  For some artists like lines and patch collections,
+              the artist may provide additional data to the pick event
+              that is generated, e.g., the indices of the data within
+              epsilon of the pick event
+
+            - A function: If picker is callable, it is a user supplied
+              function which determines whether the artist is hit by the
+              mouse event::
+
+                hit, props = picker(artist, mouseevent)
+
+              to determine the hit test.  if the mouse event is over the
+              artist, return *hit=True* and props is a dictionary of
+              properties you want added to the PickEvent attributes.
+        """
+        self._picker = picker
+
+    def get_picker(self):
+        """
+        Return the picking behavior of the artist.
+
+        The possible values are described in `.Artist.set_picker`.
+
+        See Also
+        --------
+        .Artist.set_picker, .Artist.pickable, .Artist.pick
+        """
+        return self._picker
+
+    def get_url(self):
+        """Return the url."""
+        return self._url
+
+    def set_url(self, url):
+        """
+        Set the url for the artist.
+
+        Parameters
+        ----------
+        url : str
+        """
+        self._url = url
+
+    def get_gid(self):
+        """Return the group id."""
+        return self._gid
+
+    def set_gid(self, gid):
+        """
+        Set the (group) id for the artist.
+
+        Parameters
+        ----------
+        gid : str
+        """
+        self._gid = gid
+
+    def get_snap(self):
+        """
+        Return the snap setting.
+
+        See `.set_snap` for details.
+        """
+        if mpl.rcParams['path.snap']:
+            return self._snap
+        else:
+            return False
+
+    def set_snap(self, snap):
+        """
+        Set the snapping behavior.
+
+        Snapping aligns positions with the pixel grid, which results in
+        clearer images. For example, if a black line of 1px width was
+        defined at a position in between two pixels, the resulting image
+        would contain the interpolated value of that line in the pixel grid,
+        which would be a grey value on both adjacent pixel positions. In
+        contrast, snapping will move the line to the nearest integer pixel
+        value, so that the resulting image will really contain a 1px wide
+        black line.
+
+        Snapping is currently only supported by the Agg and MacOSX backends.
+
+        Parameters
+        ----------
+        snap : bool or None
+            Possible values:
+
+            - *True*: Snap vertices to the nearest pixel center.
+            - *False*: Do not modify vertex positions.
+            - *None*: (auto) If the path contains only rectilinear line
+              segments, round to the nearest pixel center.
+        """
+        self._snap = snap
+        self.stale = True
+
+    def get_sketch_params(self):
+        """
+        Return the sketch parameters for the artist.
+
+        Returns
+        -------
+        tuple or None
+
+            A 3-tuple with the following elements:
+
+            - *scale*: The amplitude of the wiggle perpendicular to the
+              source line.
+            - *length*: The length of the wiggle along the line.
+            - *randomness*: The scale factor by which the length is
+              shrunken or expanded.
+
+            Returns *None* if no sketch parameters were set.
+        """
+        return self._sketch
+
+    def set_sketch_params(self, scale=None, length=None, randomness=None):
+        """
+        Set the sketch parameters.
+
+        Parameters
+        ----------
+        scale : float, optional
+            The amplitude of the wiggle perpendicular to the source
+            line, in pixels.  If scale is `None`, or not provided, no
+            sketch filter will be provided.
+        length : float, optional
+             The length of the wiggle along the line, in pixels
+             (default 128.0)
+        randomness : float, optional
+            The scale factor by which the length is shrunken or
+            expanded (default 16.0)
+
+            The PGF backend uses this argument as an RNG seed and not as
+            described above. Using the same seed yields the same random shape.
+
+            .. ACCEPTS: (scale: float, length: float, randomness: float)
+        """
+        if scale is None:
+            self._sketch = None
+        else:
+            self._sketch = (scale, length or 128.0, randomness or 16.0)
+        self.stale = True
+
+    def set_path_effects(self, path_effects):
+        """
+        Set the path effects.
+
+        Parameters
+        ----------
+        path_effects : list of `.AbstractPathEffect`
+        """
+        self._path_effects = path_effects
+        self.stale = True
+
+    def get_path_effects(self):
+        return self._path_effects
+
+    def get_figure(self, root=False):
+        """
+        Return the `.Figure` or `.SubFigure` instance the artist belongs to.
+
+        Parameters
+        ----------
+        root : bool, default=False
+            If False, return the (Sub)Figure this artist is on.  If True,
+            return the root Figure for a nested tree of SubFigures.
+        """
+        if root and self._parent_figure is not None:
+            return self._parent_figure.get_figure(root=True)
+
+        return self._parent_figure
+
+    def set_figure(self, fig):
+        """
+        Set the `.Figure` or `.SubFigure` instance the artist belongs to.
+
+        Parameters
+        ----------
+        fig : `~matplotlib.figure.Figure` or `~matplotlib.figure.SubFigure`
+        """
+        # if this is a no-op just return
+        if self._parent_figure is fig:
+            return
+        # if we currently have a figure (the case of both `self.figure`
+        # and *fig* being none is taken care of above) we then user is
+        # trying to change the figure an artist is associated with which
+        # is not allowed for the same reason as adding the same instance
+        # to more than one Axes
+        if self._parent_figure is not None:
+            raise RuntimeError("Can not put single artist in "
+                               "more than one figure")
+        self._parent_figure = fig
+        if self._parent_figure and self._parent_figure is not self:
+            self.pchanged()
+        self.stale = True
+
+    figure = property(get_figure, set_figure,
+                      doc=("The (Sub)Figure that the artist is on.  For more "
+                           "control, use the `get_figure` method."))
+
+    def set_clip_box(self, clipbox):
+        """
+        Set the artist's clip `.Bbox`.
+
+        Parameters
+        ----------
+        clipbox : `~matplotlib.transforms.BboxBase` or None
+            Will typically be created from a `.TransformedBbox`. For instance,
+            ``TransformedBbox(Bbox([[0, 0], [1, 1]]), ax.transAxes)`` is the default
+            clipping for an artist added to an Axes.
+
+        """
+        _api.check_isinstance((BboxBase, None), clipbox=clipbox)
+        if clipbox != self.clipbox:
+            self.clipbox = clipbox
+            self.pchanged()
+            self.stale = True
+
+    def set_clip_path(self, path, transform=None):
+        """
+        Set the artist's clip path.
+
+        Parameters
+        ----------
+        path : `~matplotlib.patches.Patch` or `.Path` or `.TransformedPath` or None
+            The clip path. If given a `.Path`, *transform* must be provided as
+            well. If *None*, a previously set clip path is removed.
+        transform : `~matplotlib.transforms.Transform`, optional
+            Only used if *path* is a `.Path`, in which case the given `.Path`
+            is converted to a `.TransformedPath` using *transform*.
+
+        Notes
+        -----
+        For efficiency, if *path* is a `.Rectangle` this method will set the
+        clipping box to the corresponding rectangle and set the clipping path
+        to ``None``.
+
+        For technical reasons (support of `~.Artist.set`), a tuple
+        (*path*, *transform*) is also accepted as a single positional
+        parameter.
+
+        .. ACCEPTS: Patch or (Path, Transform) or None
+        """
+        from matplotlib.patches import Patch, Rectangle
+
+        success = False
+        if transform is None:
+            if isinstance(path, Rectangle):
+                self.clipbox = TransformedBbox(Bbox.unit(),
+                                               path.get_transform())
+                self._clippath = None
+                success = True
+            elif isinstance(path, Patch):
+                self._clippath = TransformedPatchPath(path)
+                success = True
+            elif isinstance(path, tuple):
+                path, transform = path
+
+        if path is None:
+            self._clippath = None
+            success = True
+        elif isinstance(path, Path):
+            self._clippath = TransformedPath(path, transform)
+            success = True
+        elif isinstance(path, TransformedPatchPath):
+            self._clippath = path
+            success = True
+        elif isinstance(path, TransformedPath):
+            self._clippath = path
+            success = True
+
+        if not success:
+            raise TypeError(
+                "Invalid arguments to set_clip_path, of type "
+                f"{type(path).__name__} and {type(transform).__name__}")
+        # This may result in the callbacks being hit twice, but guarantees they
+        # will be hit at least once.
+        self.pchanged()
+        self.stale = True
+
+    def get_alpha(self):
+        """
+        Return the alpha value used for blending - not supported on all
+        backends.
+        """
+        return self._alpha
+
+    def get_visible(self):
+        """Return the visibility."""
+        return self._visible
+
+    def get_animated(self):
+        """Return whether the artist is animated."""
+        return self._animated
+
+    def get_in_layout(self):
+        """
+        Return boolean flag, ``True`` if artist is included in layout
+        calculations.
+
+        E.g. :ref:`constrainedlayout_guide`,
+        `.Figure.tight_layout()`, and
+        ``fig.savefig(fname, bbox_inches='tight')``.
+        """
+        return self._in_layout
+
+    def _fully_clipped_to_axes(self):
+        """
+        Return a boolean flag, ``True`` if the artist is clipped to the Axes
+        and can thus be skipped in layout calculations. Requires `get_clip_on`
+        is True, one of `clip_box` or `clip_path` is set, ``clip_box.extents``
+        is equivalent to ``ax.bbox.extents`` (if set), and ``clip_path._patch``
+        is equivalent to ``ax.patch`` (if set).
+        """
+        # Note that ``clip_path.get_fully_transformed_path().get_extents()``
+        # cannot be directly compared to ``axes.bbox.extents`` because the
+        # extents may be undefined (i.e. equivalent to ``Bbox.null()``)
+        # before the associated artist is drawn, and this method is meant
+        # to determine whether ``axes.get_tightbbox()`` may bypass drawing
+        clip_box = self.get_clip_box()
+        clip_path = self.get_clip_path()
+        return (self.axes is not None
+                and self.get_clip_on()
+                and (clip_box is not None or clip_path is not None)
+                and (clip_box is None
+                     or np.all(clip_box.extents == self.axes.bbox.extents))
+                and (clip_path is None
+                     or isinstance(clip_path, TransformedPatchPath)
+                     and clip_path._patch is self.axes.patch))
+
+    def get_clip_on(self):
+        """Return whether the artist uses clipping."""
+        return self._clipon
+
+    def get_clip_box(self):
+        """Return the clipbox."""
+        return self.clipbox
+
+    def get_clip_path(self):
+        """Return the clip path."""
+        return self._clippath
+
+    def get_transformed_clip_path_and_affine(self):
+        """
+        Return the clip path with the non-affine part of its
+        transformation applied, and the remaining affine part of its
+        transformation.
+        """
+        if self._clippath is not None:
+            return self._clippath.get_transformed_path_and_affine()
+        return None, None
+
+    def set_clip_on(self, b):
+        """
+        Set whether the artist uses clipping.
+
+        When False, artists will be visible outside the Axes which
+        can lead to unexpected results.
+
+        Parameters
+        ----------
+        b : bool
+        """
+        self._clipon = b
+        # This may result in the callbacks being hit twice, but ensures they
+        # are hit at least once
+        self.pchanged()
+        self.stale = True
+
+    def _set_gc_clip(self, gc):
+        """Set the clip properly for the gc."""
+        if self._clipon:
+            if self.clipbox is not None:
+                gc.set_clip_rectangle(self.clipbox)
+            gc.set_clip_path(self._clippath)
+        else:
+            gc.set_clip_rectangle(None)
+            gc.set_clip_path(None)
+
+    def get_rasterized(self):
+        """Return whether the artist is to be rasterized."""
+        return self._rasterized
+
+    def set_rasterized(self, rasterized):
+        """
+        Force rasterized (bitmap) drawing for vector graphics output.
+
+        Rasterized drawing is not supported by all artists. If you try to
+        enable this on an artist that does not support it, the command has no
+        effect and a warning will be issued.
+
+        This setting is ignored for pixel-based output.
+
+        See also :doc:`/gallery/misc/rasterization_demo`.
+
+        Parameters
+        ----------
+        rasterized : bool
+        """
+        supports_rasterization = getattr(self.draw,
+                                         "_supports_rasterization", False)
+        if rasterized and not supports_rasterization:
+            _api.warn_external(f"Rasterization of '{self}' will be ignored")
+
+        self._rasterized = rasterized
+
+    def get_agg_filter(self):
+        """Return filter function to be used for agg filter."""
+        return self._agg_filter
+
+    def set_agg_filter(self, filter_func):
+        """
+        Set the agg filter.
+
+        Parameters
+        ----------
+        filter_func : callable
+            A filter function, which takes a (m, n, depth) float array
+            and a dpi value, and returns a (m, n, depth) array and two
+            offsets from the bottom left corner of the image
+
+            .. ACCEPTS: a filter function, which takes a (m, n, 3) float array
+                and a dpi value, and returns a (m, n, 3) array and two offsets
+                from the bottom left corner of the image
+        """
+        self._agg_filter = filter_func
+        self.stale = True
+
+    def draw(self, renderer):
+        """
+        Draw the Artist (and its children) using the given renderer.
+
+        This has no effect if the artist is not visible (`.Artist.get_visible`
+        returns False).
+
+        Parameters
+        ----------
+        renderer : `~matplotlib.backend_bases.RendererBase` subclass.
+
+        Notes
+        -----
+        This method is overridden in the Artist subclasses.
+        """
+        if not self.get_visible():
+            return
+        self.stale = False
+
+    def set_alpha(self, alpha):
+        """
+        Set the alpha value used for blending - not supported on all backends.
+
+        Parameters
+        ----------
+        alpha : float or None
+            *alpha* must be within the 0-1 range, inclusive.
+        """
+        if alpha is not None and not isinstance(alpha, Real):
+            raise TypeError(
+                f'alpha must be numeric or None, not {type(alpha)}')
+        if alpha is not None and not (0 <= alpha <= 1):
+            raise ValueError(f'alpha ({alpha}) is outside 0-1 range')
+        if alpha != self._alpha:
+            self._alpha = alpha
+            self.pchanged()
+            self.stale = True
+
+    def _set_alpha_for_array(self, alpha):
+        """
+        Set the alpha value used for blending - not supported on all backends.
+
+        Parameters
+        ----------
+        alpha : array-like or float or None
+            All values must be within the 0-1 range, inclusive.
+            Masked values and nans are not supported.
+        """
+        if isinstance(alpha, str):
+            raise TypeError("alpha must be numeric or None, not a string")
+        if not np.iterable(alpha):
+            Artist.set_alpha(self, alpha)
+            return
+        alpha = np.asarray(alpha)
+        if not (0 <= alpha.min() and alpha.max() <= 1):
+            raise ValueError('alpha must be between 0 and 1, inclusive, '
+                             f'but min is {alpha.min()}, max is {alpha.max()}')
+        self._alpha = alpha
+        self.pchanged()
+        self.stale = True
+
+    def set_visible(self, b):
+        """
+        Set the artist's visibility.
+
+        Parameters
+        ----------
+        b : bool
+        """
+        if b != self._visible:
+            self._visible = b
+            self.pchanged()
+            self.stale = True
+
+    def set_animated(self, b):
+        """
+        Set whether the artist is intended to be used in an animation.
+
+        If True, the artist is excluded from regular drawing of the figure.
+        You have to call `.Figure.draw_artist` / `.Axes.draw_artist`
+        explicitly on the artist. This approach is used to speed up animations
+        using blitting.
+
+        See also `matplotlib.animation` and
+        :ref:`blitting`.
+
+        Parameters
+        ----------
+        b : bool
+        """
+        if self._animated != b:
+            self._animated = b
+            self.pchanged()
+
+    def set_in_layout(self, in_layout):
+        """
+        Set if artist is to be included in layout calculations,
+        E.g. :ref:`constrainedlayout_guide`,
+        `.Figure.tight_layout()`, and
+        ``fig.savefig(fname, bbox_inches='tight')``.
+
+        Parameters
+        ----------
+        in_layout : bool
+        """
+        self._in_layout = in_layout
+
+    def get_label(self):
+        """Return the label used for this artist in the legend."""
+        return self._label
+
+    def set_label(self, s):
+        """
+        Set a label that will be displayed in the legend.
+
+        Parameters
+        ----------
+        s : object
+            *s* will be converted to a string by calling `str`.
+        """
+        label = str(s) if s is not None else None
+        if label != self._label:
+            self._label = label
+            self.pchanged()
+            self.stale = True
+
+    def get_zorder(self):
+        """Return the artist's zorder."""
+        return self.zorder
+
+    def set_zorder(self, level):
+        """
+        Set the zorder for the artist.  Artists with lower zorder
+        values are drawn first.
+
+        Parameters
+        ----------
+        level : float
+        """
+        if level is None:
+            level = self.__class__.zorder
+        if level != self.zorder:
+            self.zorder = level
+            self.pchanged()
+            self.stale = True
+
+    @property
+    def sticky_edges(self):
+        """
+        ``x`` and ``y`` sticky edge lists for autoscaling.
+
+        When performing autoscaling, if a data limit coincides with a value in
+        the corresponding sticky_edges list, then no margin will be added--the
+        view limit "sticks" to the edge. A typical use case is histograms,
+        where one usually expects no margin on the bottom edge (0) of the
+        histogram.
+
+        Moreover, margin expansion "bumps" against sticky edges and cannot
+        cross them.  For example, if the upper data limit is 1.0, the upper
+        view limit computed by simple margin application is 1.2, but there is a
+        sticky edge at 1.1, then the actual upper view limit will be 1.1.
+
+        This attribute cannot be assigned to; however, the ``x`` and ``y``
+        lists can be modified in place as needed.
+
+        Examples
+        --------
+        >>> artist.sticky_edges.x[:] = (xmin, xmax)
+        >>> artist.sticky_edges.y[:] = (ymin, ymax)
+
+        """
+        return self._sticky_edges
+
+    def update_from(self, other):
+        """Copy properties from *other* to *self*."""
+        self._transform = other._transform
+        self._transformSet = other._transformSet
+        self._visible = other._visible
+        self._alpha = other._alpha
+        self.clipbox = other.clipbox
+        self._clipon = other._clipon
+        self._clippath = other._clippath
+        self._label = other._label
+        self._sketch = other._sketch
+        self._path_effects = other._path_effects
+        self.sticky_edges.x[:] = other.sticky_edges.x.copy()
+        self.sticky_edges.y[:] = other.sticky_edges.y.copy()
+        self.pchanged()
+        self.stale = True
+
+    def properties(self):
+        """Return a dictionary of all the properties of the artist."""
+        return ArtistInspector(self).properties()
+
+    def _update_props(self, props, errfmt):
+        """
+        Helper for `.Artist.set` and `.Artist.update`.
+
+        *errfmt* is used to generate error messages for invalid property
+        names; it gets formatted with ``type(self)`` for "{cls}" and the
+        property name for "{prop_name}".
+        """
+        ret = []
+        with cbook._setattr_cm(self, eventson=False):
+            for k, v in props.items():
+                # Allow attributes we want to be able to update through
+                # art.update, art.set, setp.
+                if k == "axes":
+                    ret.append(setattr(self, k, v))
+                else:
+                    func = getattr(self, f"set_{k}", None)
+                    if not callable(func):
+                        raise AttributeError(
+                            errfmt.format(cls=type(self), prop_name=k),
+                            name=k)
+                    ret.append(func(v))
+        if ret:
+            self.pchanged()
+            self.stale = True
+        return ret
+
+    def update(self, props):
+        """
+        Update this artist's properties from the dict *props*.
+
+        Parameters
+        ----------
+        props : dict
+        """
+        return self._update_props(
+            props, "{cls.__name__!r} object has no property {prop_name!r}")
+
+    def _internal_update(self, kwargs):
+        """
+        Update artist properties without prenormalizing them, but generating
+        errors as if calling `set`.
+
+        The lack of prenormalization is to maintain backcompatibility.
+        """
+        return self._update_props(
+            kwargs, "{cls.__name__}.set() got an unexpected keyword argument "
+            "{prop_name!r}")
+
+    def set(self, **kwargs):
+        # docstring and signature are auto-generated via
+        # Artist._update_set_signature_and_docstring() at the end of the
+        # module.
+        return self._internal_update(cbook.normalize_kwargs(kwargs, self))
+
+    @contextlib.contextmanager
+    def _cm_set(self, **kwargs):
+        """
+        `.Artist.set` context-manager that restores original values at exit.
+        """
+        orig_vals = {k: getattr(self, f"get_{k}")() for k in kwargs}
+        try:
+            self.set(**kwargs)
+            yield
+        finally:
+            self.set(**orig_vals)
+
+    def findobj(self, match=None, include_self=True):
+        """
+        Find artist objects.
+
+        Recursively find all `.Artist` instances contained in the artist.
+
+        Parameters
+        ----------
+        match
+            A filter criterion for the matches. This can be
+
+            - *None*: Return all objects contained in artist.
+            - A function with signature ``def match(artist: Artist) -> bool``.
+              The result will only contain artists for which the function
+              returns *True*.
+            - A class instance: e.g., `.Line2D`. The result will only contain
+              artists of this class or its subclasses (``isinstance`` check).
+
+        include_self : bool
+            Include *self* in the list to be checked for a match.
+
+        Returns
+        -------
+        list of `.Artist`
+
+        """
+        if match is None:  # always return True
+            def matchfunc(x):
+                return True
+        elif isinstance(match, type) and issubclass(match, Artist):
+            def matchfunc(x):
+                return isinstance(x, match)
+        elif callable(match):
+            matchfunc = match
+        else:
+            raise ValueError('match must be None, a matplotlib.artist.Artist '
+                             'subclass, or a callable')
+
+        artists = reduce(operator.iadd,
+                         [c.findobj(matchfunc) for c in self.get_children()], [])
+        if include_self and matchfunc(self):
+            artists.append(self)
+        return artists
+
+    def get_cursor_data(self, event):
+        """
+        Return the cursor data for a given event.
+
+        .. note::
+            This method is intended to be overridden by artist subclasses.
+            As an end-user of Matplotlib you will most likely not call this
+            method yourself.
+
+        Cursor data can be used by Artists to provide additional context
+        information for a given event. The default implementation just returns
+        *None*.
+
+        Subclasses can override the method and return arbitrary data. However,
+        when doing so, they must ensure that `.format_cursor_data` can convert
+        the data to a string representation.
+
+        The only current use case is displaying the z-value of an `.AxesImage`
+        in the status bar of a plot window, while moving the mouse.
+
+        Parameters
+        ----------
+        event : `~matplotlib.backend_bases.MouseEvent`
+
+        See Also
+        --------
+        format_cursor_data
+
+        """
+        return None
+
+    def format_cursor_data(self, data):
+        """
+        Return a string representation of *data*.
+
+        .. note::
+            This method is intended to be overridden by artist subclasses.
+            As an end-user of Matplotlib you will most likely not call this
+            method yourself.
+
+        The default implementation converts ints and floats and arrays of ints
+        and floats into a comma-separated string enclosed in square brackets,
+        unless the artist has an associated colorbar, in which case scalar
+        values are formatted using the colorbar's formatter.
+
+        See Also
+        --------
+        get_cursor_data
+        """
+        if np.ndim(data) == 0 and hasattr(self, "_format_cursor_data_override"):
+            # workaround for ScalarMappable to be able to define its own
+            # format_cursor_data(). See ScalarMappable._format_cursor_data_override
+            # for details.
+            return self._format_cursor_data_override(data)
+        else:
+            try:
+                data[0]
+            except (TypeError, IndexError):
+                data = [data]
+            data_str = ', '.join(f'{item:0.3g}' for item in data
+                                 if isinstance(item, Number))
+            return "[" + data_str + "]"
+
+    def get_mouseover(self):
+        """
+        Return whether this artist is queried for custom context information
+        when the mouse cursor moves over it.
+        """
+        return self._mouseover
+
+    def set_mouseover(self, mouseover):
+        """
+        Set whether this artist is queried for custom context information when
+        the mouse cursor moves over it.
+
+        Parameters
+        ----------
+        mouseover : bool
+
+        See Also
+        --------
+        get_cursor_data
+        .ToolCursorPosition
+        .NavigationToolbar2
+        """
+        self._mouseover = bool(mouseover)
+        ax = self.axes
+        if ax:
+            if self._mouseover:
+                ax._mouseover_set.add(self)
+            else:
+                ax._mouseover_set.discard(self)
+
+    mouseover = property(get_mouseover, set_mouseover)  # backcompat.
+
+
+def _get_tightbbox_for_layout_only(obj, *args, **kwargs):
+    """
+    Matplotlib's `.Axes.get_tightbbox` and `.Axis.get_tightbbox` support a
+    *for_layout_only* kwarg; this helper tries to use the kwarg but skips it
+    when encountering third-party subclasses that do not support it.
+    """
+    try:
+        return obj.get_tightbbox(*args, **{**kwargs, "for_layout_only": True})
+    except TypeError:
+        return obj.get_tightbbox(*args, **kwargs)
+
+
+class ArtistInspector:
+    """
+    A helper class to inspect an `~matplotlib.artist.Artist` and return
+    information about its settable properties and their current values.
+    """
+
+    def __init__(self, o):
+        r"""
+        Initialize the artist inspector with an `Artist` or an iterable of
+        `Artist`\s.  If an iterable is used, we assume it is a homogeneous
+        sequence (all `Artist`\s are of the same type) and it is your
+        responsibility to make sure this is so.
+        """
+        if not isinstance(o, Artist):
+            if np.iterable(o):
+                o = list(o)
+                if len(o):
+                    o = o[0]
+
+        self.oorig = o
+        if not isinstance(o, type):
+            o = type(o)
+        self.o = o
+
+        self.aliasd = self.get_aliases()
+
+    def get_aliases(self):
+        """
+        Get a dict mapping property fullnames to sets of aliases for each alias
+        in the :class:`~matplotlib.artist.ArtistInspector`.
+
+        e.g., for lines::
+
+          {'markerfacecolor': {'mfc'},
+           'linewidth'      : {'lw'},
+          }
+        """
+        names = [name for name in dir(self.o)
+                 if name.startswith(('set_', 'get_'))
+                    and callable(getattr(self.o, name))]
+        aliases = {}
+        for name in names:
+            func = getattr(self.o, name)
+            if not self.is_alias(func):
+                continue
+            propname = re.search(f"`({name[:4]}.*)`",  # get_.*/set_.*
+                                 inspect.getdoc(func)).group(1)
+            aliases.setdefault(propname[4:], set()).add(name[4:])
+        return aliases
+
+    _get_valid_values_regex = re.compile(
+        r"\n\s*(?:\.\.\s+)?ACCEPTS:\s*((?:.|\n)*?)(?:$|(?:\n\n))"
+    )
+
+    def get_valid_values(self, attr):
+        """
+        Get the legal arguments for the setter associated with *attr*.
+
+        This is done by querying the docstring of the setter for a line that
+        begins with "ACCEPTS:" or ".. ACCEPTS:", and then by looking for a
+        numpydoc-style documentation for the setter's first argument.
+        """
+
+        name = 'set_%s' % attr
+        if not hasattr(self.o, name):
+            raise AttributeError(f'{self.o} has no function {name}')
+        func = getattr(self.o, name)
+
+        if hasattr(func, '_kwarg_doc'):
+            return func._kwarg_doc
+
+        docstring = inspect.getdoc(func)
+        if docstring is None:
+            return 'unknown'
+
+        if docstring.startswith('Alias for '):
+            return None
+
+        match = self._get_valid_values_regex.search(docstring)
+        if match is not None:
+            return re.sub("\n *", " ", match.group(1))
+
+        # Much faster than list(inspect.signature(func).parameters)[1],
+        # although barely relevant wrt. matplotlib's total import time.
+        param_name = func.__code__.co_varnames[1]
+        # We could set the presence * based on whether the parameter is a
+        # varargs (it can't be a varkwargs) but it's not really worth it.
+        match = re.search(fr"(?m)^ *\*?{param_name} : (.+)", docstring)
+        if match:
+            return match.group(1)
+
+        return 'unknown'
+
+    def _replace_path(self, source_class):
+        """
+        Changes the full path to the public API path that is used
+        in sphinx. This is needed for links to work.
+        """
+        replace_dict = {'_base._AxesBase': 'Axes',
+                        '_axes.Axes': 'Axes'}
+        for key, value in replace_dict.items():
+            source_class = source_class.replace(key, value)
+        return source_class
+
+    def get_setters(self):
+        """
+        Get the attribute strings with setters for object.
+
+        For example, for a line, return ``['markerfacecolor', 'linewidth',
+        ....]``.
+        """
+        setters = []
+        for name in dir(self.o):
+            if not name.startswith('set_'):
+                continue
+            func = getattr(self.o, name)
+            if (not callable(func)
+                    or self.number_of_parameters(func) < 2
+                    or self.is_alias(func)):
+                continue
+            setters.append(name[4:])
+        return setters
+
+    @staticmethod
+    @cache
+    def number_of_parameters(func):
+        """Return number of parameters of the callable *func*."""
+        return len(inspect.signature(func).parameters)
+
+    @staticmethod
+    @cache
+    def is_alias(method):
+        """
+        Return whether the object *method* is an alias for another method.
+        """
+
+        ds = inspect.getdoc(method)
+        if ds is None:
+            return False
+
+        return ds.startswith('Alias for ')
+
+    def aliased_name(self, s):
+        """
+        Return 'PROPNAME or alias' if *s* has an alias, else return 'PROPNAME'.
+
+        For example, for the line markerfacecolor property, which has an
+        alias, return 'markerfacecolor or mfc' and for the transform
+        property, which does not, return 'transform'.
+        """
+        aliases = ''.join(' or %s' % x for x in sorted(self.aliasd.get(s, [])))
+        return s + aliases
+
+    _NOT_LINKABLE = {
+        # A set of property setter methods that are not available in our
+        # current docs. This is a workaround used to prevent trying to link
+        # these setters which would lead to "target reference not found"
+        # warnings during doc build.
+        'matplotlib.image._ImageBase.set_alpha',
+        'matplotlib.image._ImageBase.set_array',
+        'matplotlib.image._ImageBase.set_data',
+        'matplotlib.image._ImageBase.set_filternorm',
+        'matplotlib.image._ImageBase.set_filterrad',
+        'matplotlib.image._ImageBase.set_interpolation',
+        'matplotlib.image._ImageBase.set_interpolation_stage',
+        'matplotlib.image._ImageBase.set_resample',
+        'matplotlib.text._AnnotationBase.set_annotation_clip',
+    }
+
+    def aliased_name_rest(self, s, target):
+        """
+        Return 'PROPNAME or alias' if *s* has an alias, else return 'PROPNAME',
+        formatted for reST.
+
+        For example, for the line markerfacecolor property, which has an
+        alias, return 'markerfacecolor or mfc' and for the transform
+        property, which does not, return 'transform'.
+        """
+        # workaround to prevent "reference target not found"
+        if target in self._NOT_LINKABLE:
+            return f'``{s}``'
+
+        aliases = ''.join(
+            f' or :meth:`{a} <{target}>`' for a in sorted(self.aliasd.get(s, [])))
+        return f':meth:`{s} <{target}>`{aliases}'
+
+    def pprint_setters(self, prop=None, leadingspace=2):
+        """
+        If *prop* is *None*, return a list of strings of all settable
+        properties and their valid values.
+
+        If *prop* is not *None*, it is a valid property name and that
+        property will be returned as a string of property : valid
+        values.
+        """
+        if leadingspace:
+            pad = ' ' * leadingspace
+        else:
+            pad = ''
+        if prop is not None:
+            accepts = self.get_valid_values(prop)
+            return f'{pad}{prop}: {accepts}'
+
+        lines = []
+        for prop in sorted(self.get_setters()):
+            accepts = self.get_valid_values(prop)
+            name = self.aliased_name(prop)
+            lines.append(f'{pad}{name}: {accepts}')
+        return lines
+
+    def pprint_setters_rest(self, prop=None, leadingspace=4):
+        """
+        If *prop* is *None*, return a list of reST-formatted strings of all
+        settable properties and their valid values.
+
+        If *prop* is not *None*, it is a valid property name and that
+        property will be returned as a string of "property : valid"
+        values.
+        """
+        if leadingspace:
+            pad = ' ' * leadingspace
+        else:
+            pad = ''
+        if prop is not None:
+            accepts = self.get_valid_values(prop)
+            return f'{pad}{prop}: {accepts}'
+
+        prop_and_qualnames = []
+        for prop in sorted(self.get_setters()):
+            # Find the parent method which actually provides the docstring.
+            for cls in self.o.__mro__:
+                method = getattr(cls, f"set_{prop}", None)
+                if method and method.__doc__ is not None:
+                    break
+            else:  # No docstring available.
+                method = getattr(self.o, f"set_{prop}")
+            prop_and_qualnames.append(
+                (prop, f"{method.__module__}.{method.__qualname__}"))
+
+        names = [self.aliased_name_rest(prop, target)
+                 .replace('_base._AxesBase', 'Axes')
+                 .replace('_axes.Axes', 'Axes')
+                 for prop, target in prop_and_qualnames]
+        accepts = [self.get_valid_values(prop)
+                   for prop, _ in prop_and_qualnames]
+
+        col0_len = max(len(n) for n in names)
+        col1_len = max(len(a) for a in accepts)
+        table_formatstr = pad + '   ' + '=' * col0_len + '   ' + '=' * col1_len
+
+        return [
+            '',
+            pad + '.. table::',
+            pad + '   :class: property-table',
+            '',
+            table_formatstr,
+            pad + '   ' + 'Property'.ljust(col0_len)
+            + '   ' + 'Description'.ljust(col1_len),
+            table_formatstr,
+            *[pad + '   ' + n.ljust(col0_len) + '   ' + a.ljust(col1_len)
+              for n, a in zip(names, accepts)],
+            table_formatstr,
+            '',
+        ]
+
+    def properties(self):
+        """Return a dictionary mapping property name -> value."""
+        o = self.oorig
+        getters = [name for name in dir(o)
+                   if name.startswith('get_') and callable(getattr(o, name))]
+        getters.sort()
+        d = {}
+        for name in getters:
+            func = getattr(o, name)
+            if self.is_alias(func):
+                continue
+            try:
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore')
+                    val = func()
+            except Exception:
+                continue
+            else:
+                d[name[4:]] = val
+        return d
+
+    def pprint_getters(self):
+        """Return the getters and actual values as list of strings."""
+        lines = []
+        for name, val in sorted(self.properties().items()):
+            if getattr(val, 'shape', ()) != () and len(val) > 6:
+                s = str(val[:6]) + '...'
+            else:
+                s = str(val)
+            s = s.replace('\n', ' ')
+            if len(s) > 50:
+                s = s[:50] + '...'
+            name = self.aliased_name(name)
+            lines.append(f'    {name} = {s}')
+        return lines
+
+
+def getp(obj, property=None):
+    """
+    Return the value of an `.Artist`'s *property*, or print all of them.
+
+    Parameters
+    ----------
+    obj : `~matplotlib.artist.Artist`
+        The queried artist; e.g., a `.Line2D`, a `.Text`, or an `~.axes.Axes`.
+
+    property : str or None, default: None
+        If *property* is 'somename', this function returns
+        ``obj.get_somename()``.
+
+        If it's None (or unset), it *prints* all gettable properties from
+        *obj*.  Many properties have aliases for shorter typing, e.g. 'lw' is
+        an alias for 'linewidth'.  In the output, aliases and full property
+        names will be listed as:
+
+          property or alias = value
+
+        e.g.:
+
+          linewidth or lw = 2
+
+    See Also
+    --------
+    setp
+    """
+    if property is None:
+        insp = ArtistInspector(obj)
+        ret = insp.pprint_getters()
+        print('\n'.join(ret))
+        return
+    return getattr(obj, 'get_' + property)()
+
+# alias
+get = getp
+
+
+def setp(obj, *args, file=None, **kwargs):
+    """
+    Set one or more properties on an `.Artist`, or list allowed values.
+
+    Parameters
+    ----------
+    obj : `~matplotlib.artist.Artist` or list of `.Artist`
+        The artist(s) whose properties are being set or queried.  When setting
+        properties, all artists are affected; when querying the allowed values,
+        only the first instance in the sequence is queried.
+
+        For example, two lines can be made thicker and red with a single call:
+
+        >>> x = arange(0, 1, 0.01)
+        >>> lines = plot(x, sin(2*pi*x), x, sin(4*pi*x))
+        >>> setp(lines, linewidth=2, color='r')
+
+    file : file-like, default: `sys.stdout`
+        Where `setp` writes its output when asked to list allowed values.
+
+        >>> with open('output.log') as file:
+        ...     setp(line, file=file)
+
+        The default, ``None``, means `sys.stdout`.
+
+    *args, **kwargs
+        The properties to set.  The following combinations are supported:
+
+        - Set the linestyle of a line to be dashed:
+
+          >>> line, = plot([1, 2, 3])
+          >>> setp(line, linestyle='--')
+
+        - Set multiple properties at once:
+
+          >>> setp(line, linewidth=2, color='r')
+
+        - List allowed values for a line's linestyle:
+
+          >>> setp(line, 'linestyle')
+          linestyle: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
+
+        - List all properties that can be set, and their allowed values:
+
+          >>> setp(line)
+          agg_filter: a filter function, ...
+          [long output listing omitted]
+
+        `setp` also supports MATLAB style string/value pairs.  For example, the
+        following are equivalent:
+
+        >>> setp(lines, 'linewidth', 2, 'color', 'r')  # MATLAB style
+        >>> setp(lines, linewidth=2, color='r')        # Python style
+
+    See Also
+    --------
+    getp
+    """
+
+    if isinstance(obj, Artist):
+        objs = [obj]
+    else:
+        objs = list(cbook.flatten(obj))
+
+    if not objs:
+        return
+
+    insp = ArtistInspector(objs[0])
+
+    if not kwargs and len(args) < 2:
+        if args:
+            print(insp.pprint_setters(prop=args[0]), file=file)
+        else:
+            print('\n'.join(insp.pprint_setters()), file=file)
+        return
+
+    if len(args) % 2:
+        raise ValueError('The set args must be string, value pairs')
+
+    funcvals = dict(zip(args[::2], args[1::2]))
+    ret = [o.update(funcvals) for o in objs] + [o.set(**kwargs) for o in objs]
+    return list(cbook.flatten(ret))
+
+
+def kwdoc(artist):
+    r"""
+    Inspect an `~matplotlib.artist.Artist` class (using `.ArtistInspector`) and
+    return information about its settable properties and their current values.
+
+    Parameters
+    ----------
+    artist : `~matplotlib.artist.Artist` or an iterable of `Artist`\s
+
+    Returns
+    -------
+    str
+        The settable properties of *artist*, as plain text if
+        :rc:`docstring.hardcopy` is False and as a rst table (intended for
+        use in Sphinx) if it is True.
+    """
+    ai = ArtistInspector(artist)
+    return ('\n'.join(ai.pprint_setters_rest(leadingspace=4))
+            if mpl.rcParams['docstring.hardcopy'] else
+            'Properties:\n' + '\n'.join(ai.pprint_setters(leadingspace=4)))
+
+# We defer this to the end of them module, because it needs ArtistInspector
+# to be defined.
+Artist._update_set_signature_and_docstring()

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/artist.pyi

@@ -0,0 +1,199 @@
+from .axes._base import _AxesBase
+from .backend_bases import RendererBase, MouseEvent
+from .figure import Figure, SubFigure
+from .path import Path
+from .patches import Patch
+from .patheffects import AbstractPathEffect
+from .transforms import (
+    BboxBase,
+    Bbox,
+    Transform,
+    TransformedPatchPath,
+    TransformedPath,
+)
+
+import numpy as np
+
+from collections.abc import Callable, Iterable
+from typing import Any, Literal, NamedTuple, TextIO, overload, TypeVar
+from numpy.typing import ArrayLike
+
+_T_Artist = TypeVar("_T_Artist", bound=Artist)
+
+def allow_rasterization(draw): ...
+
+class _XYPair(NamedTuple):
+    x: ArrayLike
+    y: ArrayLike
+
+class _Unset: ...
+
+class Artist:
+    zorder: float
+    stale_callback: Callable[[Artist, bool], None] | None
+    @property
+    def figure(self) -> Figure | SubFigure: ...
+    clipbox: BboxBase | None
+    def __init__(self) -> None: ...
+    def remove(self) -> None: ...
+    def have_units(self) -> bool: ...
+    # TODO units
+    def convert_xunits(self, x): ...
+    def convert_yunits(self, y): ...
+    @property
+    def axes(self) -> _AxesBase | None: ...
+    @axes.setter
+    def axes(self, new_axes: _AxesBase | None) -> None: ...
+    @property
+    def stale(self) -> bool: ...
+    @stale.setter
+    def stale(self, val: bool) -> None: ...
+    def get_window_extent(self, renderer: RendererBase | None = ...) -> Bbox: ...
+    def get_tightbbox(self, renderer: RendererBase | None = ...) -> Bbox | None: ...
+    def add_callback(self, func: Callable[[Artist], Any]) -> int: ...
+    def remove_callback(self, oid: int) -> None: ...
+    def pchanged(self) -> None: ...
+    def is_transform_set(self) -> bool: ...
+    def set_transform(self, t: Transform | None) -> None: ...
+    def get_transform(self) -> Transform: ...
+    def get_children(self) -> list[Artist]: ...
+    # TODO can these dicts be type narrowed? e.g. str keys
+    def contains(self, mouseevent: MouseEvent) -> tuple[bool, dict[Any, Any]]: ...
+    def pickable(self) -> bool: ...
+    def pick(self, mouseevent: MouseEvent) -> None: ...
+    def set_picker(
+        self,
+        picker: None
+        | bool
+        | float
+        | Callable[[Artist, MouseEvent], tuple[bool, dict[Any, Any]]],
+    ) -> None: ...
+    def get_picker(
+        self,
+    ) -> None | bool | float | Callable[
+        [Artist, MouseEvent], tuple[bool, dict[Any, Any]]
+    ]: ...
+    def get_url(self) -> str | None: ...
+    def set_url(self, url: str | None) -> None: ...
+    def get_gid(self) -> str | None: ...
+    def set_gid(self, gid: str | None) -> None: ...
+    def get_snap(self) -> bool | None: ...
+    def set_snap(self, snap: bool | None) -> None: ...
+    def get_sketch_params(self) -> tuple[float, float, float] | None: ...
+    def set_sketch_params(
+        self,
+        scale: float | None = ...,
+        length: float | None = ...,
+        randomness: float | None = ...,
+    ) -> None: ...
+    def set_path_effects(self, path_effects: list[AbstractPathEffect]) -> None: ...
+    def get_path_effects(self) -> list[AbstractPathEffect]: ...
+    @overload
+    def get_figure(self, root: Literal[True]) -> Figure | None: ...
+    @overload
+    def get_figure(self, root: Literal[False]) -> Figure | SubFigure | None: ...
+    @overload
+    def get_figure(self, root: bool = ...) -> Figure | SubFigure | None: ...
+    def set_figure(self, fig: Figure | SubFigure) -> None: ...
+    def set_clip_box(self, clipbox: BboxBase | None) -> None: ...
+    def set_clip_path(
+        self,
+        path: Patch | Path | TransformedPath | TransformedPatchPath | None,
+        transform: Transform | None = ...,
+    ) -> None: ...
+    def get_alpha(self) -> float | None: ...
+    def get_visible(self) -> bool: ...
+    def get_animated(self) -> bool: ...
+    def get_in_layout(self) -> bool: ...
+    def get_clip_on(self) -> bool: ...
+    def get_clip_box(self) -> Bbox | None: ...
+    def get_clip_path(
+        self,
+    ) -> Patch | Path | TransformedPath | TransformedPatchPath | None: ...
+    def get_transformed_clip_path_and_affine(
+        self,
+    ) -> tuple[None, None] | tuple[Path, Transform]: ...
+    def set_clip_on(self, b: bool) -> None: ...
+    def get_rasterized(self) -> bool: ...
+    def set_rasterized(self, rasterized: bool) -> None: ...
+    def get_agg_filter(self) -> Callable[[ArrayLike, float], tuple[np.ndarray, float, float]] | None: ...
+    def set_agg_filter(
+        self, filter_func: Callable[[ArrayLike, float], tuple[np.ndarray, float, float]] | None
+    ) -> None: ...
+    def draw(self, renderer: RendererBase) -> None: ...
+    def set_alpha(self, alpha: float | None) -> None: ...
+    def set_visible(self, b: bool) -> None: ...
+    def set_animated(self, b: bool) -> None: ...
+    def set_in_layout(self, in_layout: bool) -> None: ...
+    def get_label(self) -> object: ...
+    def set_label(self, s: object) -> None: ...
+    def get_zorder(self) -> float: ...
+    def set_zorder(self, level: float) -> None: ...
+    @property
+    def sticky_edges(self) -> _XYPair: ...
+    def update_from(self, other: Artist) -> None: ...
+    def properties(self) -> dict[str, Any]: ...
+    def update(self, props: dict[str, Any]) -> list[Any]: ...
+    def _internal_update(self, kwargs: Any) -> list[Any]: ...
+    def set(self, **kwargs: Any) -> list[Any]: ...
+
+    @overload
+    def findobj(
+        self,
+        match: None | Callable[[Artist], bool] = ...,
+        include_self: bool = ...,
+    ) -> list[Artist]: ...
+
+    @overload
+    def findobj(
+        self,
+        match: type[_T_Artist],
+        include_self: bool = ...,
+    ) -> list[_T_Artist]: ...
+
+    def get_cursor_data(self, event: MouseEvent) -> Any: ...
+    def format_cursor_data(self, data: Any) -> str: ...
+    def get_mouseover(self) -> bool: ...
+    def set_mouseover(self, mouseover: bool) -> None: ...
+    @property
+    def mouseover(self) -> bool: ...
+    @mouseover.setter
+    def mouseover(self, mouseover: bool) -> None: ...
+
+class ArtistInspector:
+    oorig: Artist | type[Artist]
+    o: type[Artist]
+    aliasd: dict[str, set[str]]
+    def __init__(
+        self, o: Artist | type[Artist] | Iterable[Artist | type[Artist]]
+    ) -> None: ...
+    def get_aliases(self) -> dict[str, set[str]]: ...
+    def get_valid_values(self, attr: str) -> str | None: ...
+    def get_setters(self) -> list[str]: ...
+    @staticmethod
+    def number_of_parameters(func: Callable) -> int: ...
+    @staticmethod
+    def is_alias(method: Callable) -> bool: ...
+    def aliased_name(self, s: str) -> str: ...
+    def aliased_name_rest(self, s: str, target: str) -> str: ...
+    @overload
+    def pprint_setters(
+        self, prop: None = ..., leadingspace: int = ...
+    ) -> list[str]: ...
+    @overload
+    def pprint_setters(self, prop: str, leadingspace: int = ...) -> str: ...
+    @overload
+    def pprint_setters_rest(
+        self, prop: None = ..., leadingspace: int = ...
+    ) -> list[str]: ...
+    @overload
+    def pprint_setters_rest(self, prop: str, leadingspace: int = ...) -> str: ...
+    def properties(self) -> dict[str, Any]: ...
+    def pprint_getters(self) -> list[str]: ...
+
+def getp(obj: Artist, property: str | None = ...) -> Any: ...
+
+get = getp
+
+def setp(obj: Artist, *args, file: TextIO | None = ..., **kwargs) -> list[Any] | None: ...
+def kwdoc(artist: Artist | type[Artist] | Iterable[Artist | type[Artist]]) -> str: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/axis.pyi

@@ -0,0 +1,280 @@
+from collections.abc import Callable, Iterable, Sequence
+import datetime
+from typing import Any, Literal, overload
+from typing_extensions import Self  # < Py 3.11
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+import matplotlib.artist as martist
+from matplotlib import cbook
+from matplotlib.axes import Axes
+from matplotlib.backend_bases import RendererBase
+from matplotlib.lines import Line2D
+from matplotlib.text import Text
+from matplotlib.ticker import Locator, Formatter
+from matplotlib.transforms import Transform, Bbox
+from matplotlib.typing import ColorType
+from matplotlib.units import ConversionInterface
+
+
+GRIDLINE_INTERPOLATION_STEPS: int
+
+class Tick(martist.Artist):
+    axes: Axes
+    tick1line: Line2D
+    tick2line: Line2D
+    gridline: Line2D
+    label1: Text
+    label2: Text
+    def __init__(
+        self,
+        axes: Axes,
+        loc: float,
+        *,
+        size: float | None = ...,
+        width: float | None = ...,
+        color: ColorType | None = ...,
+        tickdir: Literal["in", "inout", "out"] | None = ...,
+        pad: float | None = ...,
+        labelsize: float | None = ...,
+        labelcolor: ColorType | None = ...,
+        labelfontfamily: str | Sequence[str] | None = ...,
+        zorder: float | None = ...,
+        gridOn: bool | None = ...,
+        tick1On: bool = ...,
+        tick2On: bool = ...,
+        label1On: bool = ...,
+        label2On: bool = ...,
+        major: bool = ...,
+        labelrotation: float = ...,
+        grid_color: ColorType | None = ...,
+        grid_linestyle: str | None = ...,
+        grid_linewidth: float | None = ...,
+        grid_alpha: float | None = ...,
+        **kwargs
+    ) -> None: ...
+    def get_tickdir(self) -> Literal["in", "inout", "out"]: ...
+    def get_tick_padding(self) -> float: ...
+    def get_children(self) -> list[martist.Artist]: ...
+    stale: bool
+    def set_pad(self, val: float) -> None: ...
+    def get_pad(self) -> None: ...
+    def get_loc(self) -> float: ...
+    def set_url(self, url: str | None) -> None: ...
+    def get_view_interval(self) -> ArrayLike: ...
+    def update_position(self, loc: float) -> None: ...
+
+class XTick(Tick):
+    __name__: str
+    def __init__(self, *args, **kwargs) -> None: ...
+    stale: bool
+    def update_position(self, loc: float) -> None: ...
+    def get_view_interval(self) -> np.ndarray: ...
+
+class YTick(Tick):
+    __name__: str
+    def __init__(self, *args, **kwargs) -> None: ...
+    stale: bool
+    def update_position(self, loc: float) -> None: ...
+    def get_view_interval(self) -> np.ndarray: ...
+
+class Ticker:
+    def __init__(self) -> None: ...
+    @property
+    def locator(self) -> Locator | None: ...
+    @locator.setter
+    def locator(self, locator: Locator) -> None: ...
+    @property
+    def formatter(self) -> Formatter | None: ...
+    @formatter.setter
+    def formatter(self, formatter: Formatter) -> None: ...
+
+class _LazyTickList:
+    def __init__(self, major: bool) -> None: ...
+    @overload
+    def __get__(self, instance: None, owner: None) -> Self: ...
+    @overload
+    def __get__(self, instance: Axis, owner: type[Axis]) -> list[Tick]: ...
+
+class Axis(martist.Artist):
+    OFFSETTEXTPAD: int
+    isDefault_label: bool
+    axes: Axes
+    major: Ticker
+    minor: Ticker
+    callbacks: cbook.CallbackRegistry
+    label: Text
+    offsetText: Text
+    labelpad: float
+    pickradius: float
+    def __init__(self, axes, *, pickradius: float = ...,
+                 clear: bool = ...) -> None: ...
+    @property
+    def isDefault_majloc(self) -> bool: ...
+    @isDefault_majloc.setter
+    def isDefault_majloc(self, value: bool) -> None: ...
+    @property
+    def isDefault_majfmt(self) -> bool: ...
+    @isDefault_majfmt.setter
+    def isDefault_majfmt(self, value: bool) -> None: ...
+    @property
+    def isDefault_minloc(self) -> bool: ...
+    @isDefault_minloc.setter
+    def isDefault_minloc(self, value: bool) -> None: ...
+    @property
+    def isDefault_minfmt(self) -> bool: ...
+    @isDefault_minfmt.setter
+    def isDefault_minfmt(self, value: bool) -> None: ...
+    majorTicks: _LazyTickList
+    minorTicks: _LazyTickList
+    def get_remove_overlapping_locs(self) -> bool: ...
+    def set_remove_overlapping_locs(self, val: bool) -> None: ...
+    @property
+    def remove_overlapping_locs(self) -> bool: ...
+    @remove_overlapping_locs.setter
+    def remove_overlapping_locs(self, val: bool) -> None: ...
+    stale: bool
+    def set_label_coords(
+        self, x: float, y: float, transform: Transform | None = ...
+    ) -> None: ...
+    def get_transform(self) -> Transform: ...
+    def get_scale(self) -> str: ...
+    def limit_range_for_scale(
+        self, vmin: float, vmax: float
+    ) -> tuple[float, float]: ...
+    def get_children(self) -> list[martist.Artist]: ...
+    # TODO units
+    converter: Any
+    units: Any
+    def clear(self) -> None: ...
+    def reset_ticks(self) -> None: ...
+    def minorticks_on(self) -> None: ...
+    def minorticks_off(self) -> None: ...
+    def set_tick_params(
+        self,
+        which: Literal["major", "minor", "both"] = ...,
+        reset: bool = ...,
+        **kwargs
+    ) -> None: ...
+    def get_tick_params(
+        self, which: Literal["major", "minor"] = ...
+    ) -> dict[str, Any]: ...
+    def get_view_interval(self) -> tuple[float, float]: ...
+    def set_view_interval(
+        self, vmin: float, vmax: float, ignore: bool = ...
+    ) -> None: ...
+    def get_data_interval(self) -> tuple[float, float]: ...
+    def set_data_interval(
+        self, vmin: float, vmax: float, ignore: bool = ...
+    ) -> None: ...
+    def get_inverted(self) -> bool: ...
+    def set_inverted(self, inverted: bool) -> None: ...
+    def set_default_intervals(self) -> None: ...
+    def get_tightbbox(
+        self, renderer: RendererBase | None = ..., *, for_layout_only: bool = ...
+    ) -> Bbox | None: ...
+    def get_tick_padding(self) -> float: ...
+    def get_gridlines(self) -> list[Line2D]: ...
+    def get_label(self) -> Text: ...
+    def get_offset_text(self) -> Text: ...
+    def get_pickradius(self) -> float: ...
+    def get_majorticklabels(self) -> list[Text]: ...
+    def get_minorticklabels(self) -> list[Text]: ...
+    def get_ticklabels(
+        self, minor: bool = ..., which: Literal["major", "minor", "both"] | None = ...
+    ) -> list[Text]: ...
+    def get_majorticklines(self) -> list[Line2D]: ...
+    def get_minorticklines(self) -> list[Line2D]: ...
+    def get_ticklines(self, minor: bool = ...) -> list[Line2D]: ...
+    def get_majorticklocs(self) -> np.ndarray: ...
+    def get_minorticklocs(self) -> np.ndarray: ...
+    def get_ticklocs(self, *, minor: bool = ...) -> np.ndarray: ...
+    def get_ticks_direction(self, minor: bool = ...) -> np.ndarray: ...
+    def get_label_text(self) -> str: ...
+    def get_major_locator(self) -> Locator: ...
+    def get_minor_locator(self) -> Locator: ...
+    def get_major_formatter(self) -> Formatter: ...
+    def get_minor_formatter(self) -> Formatter: ...
+    def get_major_ticks(self, numticks: int | None = ...) -> list[Tick]: ...
+    def get_minor_ticks(self, numticks: int | None = ...) -> list[Tick]: ...
+    def grid(
+        self,
+        visible: bool | None = ...,
+        which: Literal["major", "minor", "both"] = ...,
+        **kwargs
+    ) -> None: ...
+    # TODO units
+    def update_units(self, data): ...
+    def have_units(self) -> bool: ...
+    def convert_units(self, x): ...
+    def get_converter(self) -> ConversionInterface | None: ...
+    def set_converter(self, converter: ConversionInterface) -> None: ...
+    def set_units(self, u) -> None: ...
+    def get_units(self): ...
+    def set_label_text(
+        self, label: str, fontdict: dict[str, Any] | None = ..., **kwargs
+    ) -> Text: ...
+    def set_major_formatter(
+        self, formatter: Formatter | str | Callable[[float, float], str]
+    ) -> None: ...
+    def set_minor_formatter(
+        self, formatter: Formatter | str | Callable[[float, float], str]
+    ) -> None: ...
+    def set_major_locator(self, locator: Locator) -> None: ...
+    def set_minor_locator(self, locator: Locator) -> None: ...
+    def set_pickradius(self, pickradius: float) -> None: ...
+    def set_ticklabels(
+        self,
+        labels: Iterable[str | Text],
+        *,
+        minor: bool = ...,
+        fontdict: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> list[Text]: ...
+    def set_ticks(
+        self,
+        ticks: ArrayLike,
+        labels: Iterable[str] | None = ...,
+        *,
+        minor: bool = ...,
+        **kwargs
+    ) -> list[Tick]: ...
+    def axis_date(self, tz: str | datetime.tzinfo | None = ...) -> None: ...
+    def get_tick_space(self) -> int: ...
+    def get_label_position(self) -> Literal["top", "bottom"]: ...
+    def set_label_position(
+        self, position: Literal["top", "bottom", "left", "right"]
+    ) -> None: ...
+    def get_minpos(self) -> float: ...
+
+class XAxis(Axis):
+    __name__: str
+    axis_name: str
+    def __init__(self, *args, **kwargs) -> None: ...
+    label_position: Literal["bottom", "top"]
+    stale: bool
+    def set_label_position(self, position: Literal["bottom", "top"]) -> None: ...  # type: ignore[override]
+    def set_ticks_position(
+        self, position: Literal["top", "bottom", "both", "default", "none"]
+    ) -> None: ...
+    def tick_top(self) -> None: ...
+    def tick_bottom(self) -> None: ...
+    def get_ticks_position(self) -> Literal["top", "bottom", "default", "unknown"]: ...
+    def get_tick_space(self) -> int: ...
+
+class YAxis(Axis):
+    __name__: str
+    axis_name: str
+    def __init__(self, *args, **kwargs) -> None: ...
+    label_position: Literal["left", "right"]
+    stale: bool
+    def set_label_position(self, position: Literal["left", "right"]) -> None: ...  # type: ignore[override]
+    def set_offset_position(self, position: Literal["left", "right"]) -> None: ...
+    def set_ticks_position(
+        self, position: Literal["left", "right", "both", "default", "none"]
+    ) -> None: ...
+    def tick_right(self) -> None: ...
+    def tick_left(self) -> None: ...
+    def get_ticks_position(self) -> Literal["left", "right", "default", "unknown"]: ...
+    def get_tick_space(self) -> int: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/backend_bases.pyi

@@ -0,0 +1,482 @@
+from enum import Enum, IntEnum
+import os
+from matplotlib import (
+    cbook,
+    transforms,
+    widgets,
+    _api,
+)
+from matplotlib.artist import Artist
+from matplotlib.axes import Axes
+from matplotlib.backend_managers import ToolManager
+from matplotlib.backend_tools import Cursors, ToolBase
+from matplotlib.colorbar import Colorbar
+from matplotlib.figure import Figure
+from matplotlib.font_manager import FontProperties
+from matplotlib.path import Path
+from matplotlib.texmanager import TexManager
+from matplotlib.text import Text
+from matplotlib.transforms import Bbox, BboxBase, Transform, TransformedPath
+
+from collections.abc import Callable, Iterable, Sequence
+from typing import Any, IO, Literal, NamedTuple, TypeVar
+from numpy.typing import ArrayLike
+from .typing import ColorType, LineStyleType, CapStyleType, JoinStyleType
+
+def register_backend(
+    format: str, backend: str | type[FigureCanvasBase], description: str | None = ...
+) -> None: ...
+def get_registered_canvas_class(format: str) -> type[FigureCanvasBase]: ...
+
+class RendererBase:
+    def __init__(self) -> None: ...
+    def open_group(self, s: str, gid: str | None = ...) -> None: ...
+    def close_group(self, s: str) -> None: ...
+    def draw_path(
+        self,
+        gc: GraphicsContextBase,
+        path: Path,
+        transform: Transform,
+        rgbFace: ColorType | None = ...,
+    ) -> None: ...
+    def draw_markers(
+        self,
+        gc: GraphicsContextBase,
+        marker_path: Path,
+        marker_trans: Transform,
+        path: Path,
+        trans: Transform,
+        rgbFace: ColorType | None = ...,
+    ) -> None: ...
+    def draw_path_collection(
+        self,
+        gc: GraphicsContextBase,
+        master_transform: Transform,
+        paths: Sequence[Path],
+        all_transforms: Sequence[ArrayLike],
+        offsets: ArrayLike | Sequence[ArrayLike],
+        offset_trans: Transform,
+        facecolors: ColorType | Sequence[ColorType],
+        edgecolors: ColorType | Sequence[ColorType],
+        linewidths: float | Sequence[float],
+        linestyles: LineStyleType | Sequence[LineStyleType],
+        antialiaseds: bool | Sequence[bool],
+        urls: str | Sequence[str],
+        offset_position: Any,
+    ) -> None: ...
+    def draw_quad_mesh(
+        self,
+        gc: GraphicsContextBase,
+        master_transform: Transform,
+        meshWidth,
+        meshHeight,
+        coordinates: ArrayLike,
+        offsets: ArrayLike | Sequence[ArrayLike],
+        offsetTrans: Transform,
+        facecolors: Sequence[ColorType],
+        antialiased: bool,
+        edgecolors: Sequence[ColorType] | ColorType | None,
+    ) -> None: ...
+    def draw_gouraud_triangles(
+        self,
+        gc: GraphicsContextBase,
+        triangles_array: ArrayLike,
+        colors_array: ArrayLike,
+        transform: Transform,
+    ) -> None: ...
+    def get_image_magnification(self) -> float: ...
+    def draw_image(
+        self,
+        gc: GraphicsContextBase,
+        x: float,
+        y: float,
+        im: ArrayLike,
+        transform: transforms.Affine2DBase | None = ...,
+    ) -> None: ...
+    def option_image_nocomposite(self) -> bool: ...
+    def option_scale_image(self) -> bool: ...
+    def draw_tex(
+        self,
+        gc: GraphicsContextBase,
+        x: float,
+        y: float,
+        s: str,
+        prop: FontProperties,
+        angle: float,
+        *,
+        mtext: Text | None = ...
+    ) -> None: ...
+    def draw_text(
+        self,
+        gc: GraphicsContextBase,
+        x: float,
+        y: float,
+        s: str,
+        prop: FontProperties,
+        angle: float,
+        ismath: bool | Literal["TeX"] = ...,
+        mtext: Text | None = ...,
+    ) -> None: ...
+    def get_text_width_height_descent(
+        self, s: str, prop: FontProperties, ismath: bool | Literal["TeX"]
+    ) -> tuple[float, float, float]: ...
+    def flipy(self) -> bool: ...
+    def get_canvas_width_height(self) -> tuple[float, float]: ...
+    def get_texmanager(self) -> TexManager: ...
+    def new_gc(self) -> GraphicsContextBase: ...
+    def points_to_pixels(self, points: ArrayLike) -> ArrayLike: ...
+    def start_rasterizing(self) -> None: ...
+    def stop_rasterizing(self) -> None: ...
+    def start_filter(self) -> None: ...
+    def stop_filter(self, filter_func) -> None: ...
+
+class GraphicsContextBase:
+    def __init__(self) -> None: ...
+    def copy_properties(self, gc: GraphicsContextBase) -> None: ...
+    def restore(self) -> None: ...
+    def get_alpha(self) -> float: ...
+    def get_antialiased(self) -> int: ...
+    def get_capstyle(self) -> Literal["butt", "projecting", "round"]: ...
+    def get_clip_rectangle(self) -> Bbox | None: ...
+    def get_clip_path(
+        self,
+    ) -> tuple[TransformedPath, Transform] | tuple[None, None]: ...
+    def get_dashes(self) -> tuple[float, ArrayLike | None]: ...
+    def get_forced_alpha(self) -> bool: ...
+    def get_joinstyle(self) -> Literal["miter", "round", "bevel"]: ...
+    def get_linewidth(self) -> float: ...
+    def get_rgb(self) -> tuple[float, float, float, float]: ...
+    def get_url(self) -> str | None: ...
+    def get_gid(self) -> int | None: ...
+    def get_snap(self) -> bool | None: ...
+    def set_alpha(self, alpha: float) -> None: ...
+    def set_antialiased(self, b: bool) -> None: ...
+    def set_capstyle(self, cs: CapStyleType) -> None: ...
+    def set_clip_rectangle(self, rectangle: Bbox | None) -> None: ...
+    def set_clip_path(self, path: TransformedPath | None) -> None: ...
+    def set_dashes(self, dash_offset: float, dash_list: ArrayLike | None) -> None: ...
+    def set_foreground(self, fg: ColorType, isRGBA: bool = ...) -> None: ...
+    def set_joinstyle(self, js: JoinStyleType) -> None: ...
+    def set_linewidth(self, w: float) -> None: ...
+    def set_url(self, url: str | None) -> None: ...
+    def set_gid(self, id: int | None) -> None: ...
+    def set_snap(self, snap: bool | None) -> None: ...
+    def set_hatch(self, hatch: str | None) -> None: ...
+    def get_hatch(self) -> str | None: ...
+    def get_hatch_path(self, density: float = ...) -> Path: ...
+    def get_hatch_color(self) -> ColorType: ...
+    def set_hatch_color(self, hatch_color: ColorType) -> None: ...
+    def get_hatch_linewidth(self) -> float: ...
+    def set_hatch_linewidth(self, hatch_linewidth: float) -> None: ...
+    def get_sketch_params(self) -> tuple[float, float, float] | None: ...
+    def set_sketch_params(
+        self,
+        scale: float | None = ...,
+        length: float | None = ...,
+        randomness: float | None = ...,
+    ) -> None: ...
+
+class TimerBase:
+    callbacks: list[tuple[Callable, tuple, dict[str, Any]]]
+    def __init__(
+        self,
+        interval: int | None = ...,
+        callbacks: list[tuple[Callable, tuple, dict[str, Any]]] | None = ...,
+    ) -> None: ...
+    def __del__(self) -> None: ...
+    def start(self, interval: int | None = ...) -> None: ...
+    def stop(self) -> None: ...
+    @property
+    def interval(self) -> int: ...
+    @interval.setter
+    def interval(self, interval: int) -> None: ...
+    @property
+    def single_shot(self) -> bool: ...
+    @single_shot.setter
+    def single_shot(self, ss: bool) -> None: ...
+    def add_callback(self, func: Callable, *args, **kwargs) -> Callable: ...
+    def remove_callback(self, func: Callable, *args, **kwargs) -> None: ...
+
+class Event:
+    name: str
+    canvas: FigureCanvasBase
+    guiEvent: Any
+    def __init__(
+        self, name: str, canvas: FigureCanvasBase, guiEvent: Any | None = ...
+    ) -> None: ...
+
+class DrawEvent(Event):
+    renderer: RendererBase
+    def __init__(
+        self, name: str, canvas: FigureCanvasBase, renderer: RendererBase
+    ) -> None: ...
+
+class ResizeEvent(Event):
+    width: int
+    height: int
+    def __init__(self, name: str, canvas: FigureCanvasBase) -> None: ...
+
+class CloseEvent(Event): ...
+
+class LocationEvent(Event):
+    x: int
+    y: int
+    inaxes: Axes | None
+    xdata: float | None
+    ydata: float | None
+    def __init__(
+        self,
+        name: str,
+        canvas: FigureCanvasBase,
+        x: int,
+        y: int,
+        guiEvent: Any | None = ...,
+        *,
+        modifiers: Iterable[str] | None = ...,
+    ) -> None: ...
+
+class MouseButton(IntEnum):
+    LEFT = 1
+    MIDDLE = 2
+    RIGHT = 3
+    BACK = 8
+    FORWARD = 9
+
+class MouseEvent(LocationEvent):
+    button: MouseButton | Literal["up", "down"] | None
+    key: str | None
+    step: float
+    dblclick: bool
+    def __init__(
+        self,
+        name: str,
+        canvas: FigureCanvasBase,
+        x: int,
+        y: int,
+        button: MouseButton | Literal["up", "down"] | None = ...,
+        key: str | None = ...,
+        step: float = ...,
+        dblclick: bool = ...,
+        guiEvent: Any | None = ...,
+        *,
+        buttons: Iterable[MouseButton] | None = ...,
+        modifiers: Iterable[str] | None = ...,
+    ) -> None: ...
+
+class PickEvent(Event):
+    mouseevent: MouseEvent
+    artist: Artist
+    def __init__(
+        self,
+        name: str,
+        canvas: FigureCanvasBase,
+        mouseevent: MouseEvent,
+        artist: Artist,
+        guiEvent: Any | None = ...,
+        **kwargs
+    ) -> None: ...
+
+class KeyEvent(LocationEvent):
+    key: str | None
+    def __init__(
+        self,
+        name: str,
+        canvas: FigureCanvasBase,
+        key: str | None,
+        x: int = ...,
+        y: int = ...,
+        guiEvent: Any | None = ...,
+    ) -> None: ...
+
+class FigureCanvasBase:
+    required_interactive_framework: str | None
+
+    @_api.classproperty
+    def manager_class(cls) -> type[FigureManagerBase]: ...
+    events: list[str]
+    fixed_dpi: None | float
+    filetypes: dict[str, str]
+
+    @_api.classproperty
+    def supports_blit(cls) -> bool: ...
+
+    figure: Figure
+    manager: None | FigureManagerBase
+    widgetlock: widgets.LockDraw
+    mouse_grabber: None | Axes
+    toolbar: None | NavigationToolbar2
+    def __init__(self, figure: Figure | None = ...) -> None: ...
+    @property
+    def callbacks(self) -> cbook.CallbackRegistry: ...
+    @property
+    def button_pick_id(self) -> int: ...
+    @property
+    def scroll_pick_id(self) -> int: ...
+    @classmethod
+    def new_manager(cls, figure: Figure, num: int | str) -> FigureManagerBase: ...
+    def is_saving(self) -> bool: ...
+    def blit(self, bbox: BboxBase | None = ...) -> None: ...
+    def inaxes(self, xy: tuple[float, float]) -> Axes | None: ...
+    def grab_mouse(self, ax: Axes) -> None: ...
+    def release_mouse(self, ax: Axes) -> None: ...
+    def set_cursor(self, cursor: Cursors) -> None: ...
+    def draw(self, *args, **kwargs) -> None: ...
+    def draw_idle(self, *args, **kwargs) -> None: ...
+    @property
+    def device_pixel_ratio(self) -> float: ...
+    def get_width_height(self, *, physical: bool = ...) -> tuple[int, int]: ...
+    @classmethod
+    def get_supported_filetypes(cls) -> dict[str, str]: ...
+    @classmethod
+    def get_supported_filetypes_grouped(cls) -> dict[str, list[str]]: ...
+    def print_figure(
+        self,
+        filename: str | os.PathLike | IO,
+        dpi: float | None = ...,
+        facecolor: ColorType | Literal["auto"] | None = ...,
+        edgecolor: ColorType | Literal["auto"] | None = ...,
+        orientation: str = ...,
+        format: str | None = ...,
+        *,
+        bbox_inches: Literal["tight"] | Bbox | None = ...,
+        pad_inches: float | None = ...,
+        bbox_extra_artists: list[Artist] | None = ...,
+        backend: str | None = ...,
+        **kwargs
+    ) -> Any: ...
+    @classmethod
+    def get_default_filetype(cls) -> str: ...
+    def get_default_filename(self) -> str: ...
+    _T = TypeVar("_T", bound=FigureCanvasBase)
+    def mpl_connect(self, s: str, func: Callable[[Event], Any]) -> int: ...
+    def mpl_disconnect(self, cid: int) -> None: ...
+    def new_timer(
+        self,
+        interval: int | None = ...,
+        callbacks: list[tuple[Callable, tuple, dict[str, Any]]] | None = ...,
+    ) -> TimerBase: ...
+    def flush_events(self) -> None: ...
+    def start_event_loop(self, timeout: float = ...) -> None: ...
+    def stop_event_loop(self) -> None: ...
+
+def key_press_handler(
+    event: KeyEvent,
+    canvas: FigureCanvasBase | None = ...,
+    toolbar: NavigationToolbar2 | None = ...,
+) -> None: ...
+def button_press_handler(
+    event: MouseEvent,
+    canvas: FigureCanvasBase | None = ...,
+    toolbar: NavigationToolbar2 | None = ...,
+) -> None: ...
+
+class NonGuiException(Exception): ...
+
+class FigureManagerBase:
+    canvas: FigureCanvasBase
+    num: int | str
+    key_press_handler_id: int | None
+    button_press_handler_id: int | None
+    toolmanager: ToolManager | None
+    toolbar: NavigationToolbar2 | ToolContainerBase | None
+    def __init__(self, canvas: FigureCanvasBase, num: int | str) -> None: ...
+    @classmethod
+    def create_with_canvas(
+        cls, canvas_class: type[FigureCanvasBase], figure: Figure, num: int | str
+    ) -> FigureManagerBase: ...
+    @classmethod
+    def start_main_loop(cls) -> None: ...
+    @classmethod
+    def pyplot_show(cls, *, block: bool | None = ...) -> None: ...
+    def show(self) -> None: ...
+    def destroy(self) -> None: ...
+    def full_screen_toggle(self) -> None: ...
+    def resize(self, w: int, h: int) -> None: ...
+    def get_window_title(self) -> str: ...
+    def set_window_title(self, title: str) -> None: ...
+
+cursors = Cursors
+
+class _Mode(str, Enum):
+    NONE = ""
+    PAN = "pan/zoom"
+    ZOOM = "zoom rect"
+
+class NavigationToolbar2:
+    toolitems: tuple[tuple[str, ...] | tuple[None, ...], ...]
+    UNKNOWN_SAVED_STATUS: object
+    canvas: FigureCanvasBase
+    mode: _Mode
+    def __init__(self, canvas: FigureCanvasBase) -> None: ...
+    def set_message(self, s: str) -> None: ...
+    def draw_rubberband(
+        self, event: Event, x0: float, y0: float, x1: float, y1: float
+    ) -> None: ...
+    def remove_rubberband(self) -> None: ...
+    def home(self, *args) -> None: ...
+    def back(self, *args) -> None: ...
+    def forward(self, *args) -> None: ...
+    def mouse_move(self, event: MouseEvent) -> None: ...
+    def pan(self, *args) -> None: ...
+
+    class _PanInfo(NamedTuple):
+        button: MouseButton
+        axes: list[Axes]
+        cid: int
+    def press_pan(self, event: Event) -> None: ...
+    def drag_pan(self, event: Event) -> None: ...
+    def release_pan(self, event: Event) -> None: ...
+    def zoom(self, *args) -> None: ...
+
+    class _ZoomInfo(NamedTuple):
+        direction: Literal["in", "out"]
+        start_xy: tuple[float, float]
+        axes: list[Axes]
+        cid: int
+        cbar: Colorbar
+    def press_zoom(self, event: Event) -> None: ...
+    def drag_zoom(self, event: Event) -> None: ...
+    def release_zoom(self, event: Event) -> None: ...
+    def push_current(self) -> None: ...
+    subplot_tool: widgets.SubplotTool
+    def configure_subplots(self, *args): ...
+    def save_figure(self, *args) -> str | None | object: ...
+    def update(self) -> None: ...
+    def set_history_buttons(self) -> None: ...
+
+class ToolContainerBase:
+    toolmanager: ToolManager
+    def __init__(self, toolmanager: ToolManager) -> None: ...
+    def add_tool(self, tool: ToolBase, group: str, position: int = ...) -> None: ...
+    def trigger_tool(self, name: str) -> None: ...
+    def add_toolitem(
+        self,
+        name: str,
+        group: str,
+        position: int,
+        image: str,
+        description: str,
+        toggle: bool,
+    ) -> None: ...
+    def toggle_toolitem(self, name: str, toggled: bool) -> None: ...
+    def remove_toolitem(self, name: str) -> None: ...
+    def set_message(self, s: str) -> None: ...
+
+class _Backend:
+    backend_version: str
+    FigureCanvas: type[FigureCanvasBase] | None
+    FigureManager: type[FigureManagerBase]
+    mainloop: None | Callable[[], Any]
+    @classmethod
+    def new_figure_manager(cls, num: int | str, *args, **kwargs) -> FigureManagerBase: ...
+    @classmethod
+    def new_figure_manager_given_figure(cls, num: int | str, figure: Figure) -> FigureManagerBase: ...
+    @classmethod
+    def draw_if_interactive(cls) -> None: ...
+    @classmethod
+    def show(cls, *, block: bool | None = ...) -> None: ...
+    @staticmethod
+    def export(cls) -> type[_Backend]: ...
+
+class ShowBase(_Backend):
+    def __call__(self, block: bool | None = ...) -> None: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/backend_managers.py

@@ -0,0 +1,387 @@
+from matplotlib import _api, backend_tools, cbook, widgets
+
+
+class ToolEvent:
+    """Event for tool manipulation (add/remove)."""
+    def __init__(self, name, sender, tool, data=None):
+        self.name = name
+        self.sender = sender
+        self.tool = tool
+        self.data = data
+
+
+class ToolTriggerEvent(ToolEvent):
+    """Event to inform that a tool has been triggered."""
+    def __init__(self, name, sender, tool, canvasevent=None, data=None):
+        super().__init__(name, sender, tool, data)
+        self.canvasevent = canvasevent
+
+
+class ToolManagerMessageEvent:
+    """
+    Event carrying messages from toolmanager.
+
+    Messages usually get displayed to the user by the toolbar.
+    """
+    def __init__(self, name, sender, message):
+        self.name = name
+        self.sender = sender
+        self.message = message
+
+
+class ToolManager:
+    """
+    Manager for actions triggered by user interactions (key press, toolbar
+    clicks, ...) on a Figure.
+
+    Attributes
+    ----------
+    figure : `.Figure`
+    keypresslock : `~matplotlib.widgets.LockDraw`
+        `.LockDraw` object to know if the `canvas` key_press_event is locked.
+    messagelock : `~matplotlib.widgets.LockDraw`
+        `.LockDraw` object to know if the message is available to write.
+    """
+
+    def __init__(self, figure=None):
+
+        self._key_press_handler_id = None
+
+        self._tools = {}
+        self._keys = {}
+        self._toggled = {}
+        self._callbacks = cbook.CallbackRegistry()
+
+        # to process keypress event
+        self.keypresslock = widgets.LockDraw()
+        self.messagelock = widgets.LockDraw()
+
+        self._figure = None
+        self.set_figure(figure)
+
+    @property
+    def canvas(self):
+        """Canvas managed by FigureManager."""
+        if not self._figure:
+            return None
+        return self._figure.canvas
+
+    @property
+    def figure(self):
+        """Figure that holds the canvas."""
+        return self._figure
+
+    @figure.setter
+    def figure(self, figure):
+        self.set_figure(figure)
+
+    def set_figure(self, figure, update_tools=True):
+        """
+        Bind the given figure to the tools.
+
+        Parameters
+        ----------
+        figure : `.Figure`
+        update_tools : bool, default: True
+            Force tools to update figure.
+        """
+        if self._key_press_handler_id:
+            self.canvas.mpl_disconnect(self._key_press_handler_id)
+        self._figure = figure
+        if figure:
+            self._key_press_handler_id = self.canvas.mpl_connect(
+                'key_press_event', self._key_press)
+        if update_tools:
+            for tool in self._tools.values():
+                tool.figure = figure
+
+    def toolmanager_connect(self, s, func):
+        """
+        Connect event with string *s* to *func*.
+
+        Parameters
+        ----------
+        s : str
+            The name of the event. The following events are recognized:
+
+            - 'tool_message_event'
+            - 'tool_removed_event'
+            - 'tool_added_event'
+
+            For every tool added a new event is created
+
+            - 'tool_trigger_TOOLNAME', where TOOLNAME is the id of the tool.
+
+        func : callable
+            Callback function for the toolmanager event with signature::
+
+                def func(event: ToolEvent) -> Any
+
+        Returns
+        -------
+        cid
+            The callback id for the connection. This can be used in
+            `.toolmanager_disconnect`.
+        """
+        return self._callbacks.connect(s, func)
+
+    def toolmanager_disconnect(self, cid):
+        """
+        Disconnect callback id *cid*.
+
+        Example usage::
+
+            cid = toolmanager.toolmanager_connect('tool_trigger_zoom', onpress)
+            #...later
+            toolmanager.toolmanager_disconnect(cid)
+        """
+        return self._callbacks.disconnect(cid)
+
+    def message_event(self, message, sender=None):
+        """Emit a `ToolManagerMessageEvent`."""
+        if sender is None:
+            sender = self
+
+        s = 'tool_message_event'
+        event = ToolManagerMessageEvent(s, sender, message)
+        self._callbacks.process(s, event)
+
+    @property
+    def active_toggle(self):
+        """Currently toggled tools."""
+        return self._toggled
+
+    def get_tool_keymap(self, name):
+        """
+        Return the keymap associated with the specified tool.
+
+        Parameters
+        ----------
+        name : str
+            Name of the Tool.
+
+        Returns
+        -------
+        list of str
+            List of keys associated with the tool.
+        """
+
+        keys = [k for k, i in self._keys.items() if i == name]
+        return keys
+
+    def _remove_keys(self, name):
+        for k in self.get_tool_keymap(name):
+            del self._keys[k]
+
+    def update_keymap(self, name, key):
+        """
+        Set the keymap to associate with the specified tool.
+
+        Parameters
+        ----------
+        name : str
+            Name of the Tool.
+        key : str or list of str
+            Keys to associate with the tool.
+        """
+        if name not in self._tools:
+            raise KeyError(f'{name!r} not in Tools')
+        self._remove_keys(name)
+        if isinstance(key, str):
+            key = [key]
+        for k in key:
+            if k in self._keys:
+                _api.warn_external(
+                    f'Key {k} changed from {self._keys[k]} to {name}')
+            self._keys[k] = name
+
+    def remove_tool(self, name):
+        """
+        Remove tool named *name*.
+
+        Parameters
+        ----------
+        name : str
+            Name of the tool.
+        """
+        tool = self.get_tool(name)
+        if getattr(tool, 'toggled', False):  # If it's a toggled toggle tool, untoggle
+            self.trigger_tool(tool, 'toolmanager')
+        self._remove_keys(name)
+        event = ToolEvent('tool_removed_event', self, tool)
+        self._callbacks.process(event.name, event)
+        del self._tools[name]
+
+    def add_tool(self, name, tool, *args, **kwargs):
+        """
+        Add *tool* to `ToolManager`.
+
+        If successful, adds a new event ``tool_trigger_{name}`` where
+        ``{name}`` is the *name* of the tool; the event is fired every time the
+        tool is triggered.
+
+        Parameters
+        ----------
+        name : str
+            Name of the tool, treated as the ID, has to be unique.
+        tool : type
+            Class of the tool to be added.  A subclass will be used
+            instead if one was registered for the current canvas class.
+        *args, **kwargs
+            Passed to the *tool*'s constructor.
+
+        See Also
+        --------
+        matplotlib.backend_tools.ToolBase : The base class for tools.
+        """
+
+        tool_cls = backend_tools._find_tool_class(type(self.canvas), tool)
+        if not tool_cls:
+            raise ValueError('Impossible to find class for %s' % str(tool))
+
+        if name in self._tools:
+            _api.warn_external('A "Tool class" with the same name already '
+                               'exists, not added')
+            return self._tools[name]
+
+        tool_obj = tool_cls(self, name, *args, **kwargs)
+        self._tools[name] = tool_obj
+
+        if tool_obj.default_keymap is not None:
+            self.update_keymap(name, tool_obj.default_keymap)
+
+        # For toggle tools init the radio_group in self._toggled
+        if isinstance(tool_obj, backend_tools.ToolToggleBase):
+            # None group is not mutually exclusive, a set is used to keep track
+            # of all toggled tools in this group
+            if tool_obj.radio_group is None:
+                self._toggled.setdefault(None, set())
+            else:
+                self._toggled.setdefault(tool_obj.radio_group, None)
+
+            # If initially toggled
+            if tool_obj.toggled:
+                self._handle_toggle(tool_obj, None, None)
+        tool_obj.set_figure(self.figure)
+
+        event = ToolEvent('tool_added_event', self, tool_obj)
+        self._callbacks.process(event.name, event)
+
+        return tool_obj
+
+    def _handle_toggle(self, tool, canvasevent, data):
+        """
+        Toggle tools, need to untoggle prior to using other Toggle tool.
+        Called from trigger_tool.
+
+        Parameters
+        ----------
+        tool : `.ToolBase`
+        canvasevent : Event
+            Original Canvas event or None.
+        data : object
+            Extra data to pass to the tool when triggering.
+        """
+
+        radio_group = tool.radio_group
+        # radio_group None is not mutually exclusive
+        # just keep track of toggled tools in this group
+        if radio_group is None:
+            if tool.name in self._toggled[None]:
+                self._toggled[None].remove(tool.name)
+            else:
+                self._toggled[None].add(tool.name)
+            return
+
+        # If the tool already has a toggled state, untoggle it
+        if self._toggled[radio_group] == tool.name:
+            toggled = None
+        # If no tool was toggled in the radio_group
+        # toggle it
+        elif self._toggled[radio_group] is None:
+            toggled = tool.name
+        # Other tool in the radio_group is toggled
+        else:
+            # Untoggle previously toggled tool
+            self.trigger_tool(self._toggled[radio_group],
+                              self,
+                              canvasevent,
+                              data)
+            toggled = tool.name
+
+        # Keep track of the toggled tool in the radio_group
+        self._toggled[radio_group] = toggled
+
+    def trigger_tool(self, name, sender=None, canvasevent=None, data=None):
+        """
+        Trigger a tool and emit the ``tool_trigger_{name}`` event.
+
+        Parameters
+        ----------
+        name : str
+            Name of the tool.
+        sender : object
+            Object that wishes to trigger the tool.
+        canvasevent : Event
+            Original Canvas event or None.
+        data : object
+            Extra data to pass to the tool when triggering.
+        """
+        tool = self.get_tool(name)
+        if tool is None:
+            return
+
+        if sender is None:
+            sender = self
+
+        if isinstance(tool, backend_tools.ToolToggleBase):
+            self._handle_toggle(tool, canvasevent, data)
+
+        tool.trigger(sender, canvasevent, data)  # Actually trigger Tool.
+
+        s = 'tool_trigger_%s' % name
+        event = ToolTriggerEvent(s, sender, tool, canvasevent, data)
+        self._callbacks.process(s, event)
+
+    def _key_press(self, event):
+        if event.key is None or self.keypresslock.locked():
+            return
+
+        name = self._keys.get(event.key, None)
+        if name is None:
+            return
+        self.trigger_tool(name, canvasevent=event)
+
+    @property
+    def tools(self):
+        """A dict mapping tool name -> controlled tool."""
+        return self._tools
+
+    def get_tool(self, name, warn=True):
+        """
+        Return the tool object with the given name.
+
+        For convenience, this passes tool objects through.
+
+        Parameters
+        ----------
+        name : str or `.ToolBase`
+            Name of the tool, or the tool itself.
+        warn : bool, default: True
+            Whether a warning should be emitted it no tool with the given name
+            exists.
+
+        Returns
+        -------
+        `.ToolBase` or None
+            The tool or None if no tool with the given name exists.
+        """
+        if (isinstance(name, backend_tools.ToolBase)
+                and name.name in self._tools):
+            return name
+        if name not in self._tools:
+            if warn:
+                _api.warn_external(
+                    f"ToolManager does not control tool {name!r}")
+            return None
+        return self._tools[name]

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/backend_managers.pyi

@@ -0,0 +1,64 @@
+from matplotlib import backend_tools, widgets
+from matplotlib.backend_bases import FigureCanvasBase
+from matplotlib.figure import Figure
+
+from collections.abc import Callable, Iterable
+from typing import Any, TypeVar
+
+class ToolEvent:
+    name: str
+    sender: Any
+    tool: backend_tools.ToolBase
+    data: Any
+    def __init__(self, name, sender, tool, data: Any | None = ...) -> None: ...
+
+class ToolTriggerEvent(ToolEvent):
+    canvasevent: ToolEvent
+    def __init__(
+        self,
+        name,
+        sender,
+        tool,
+        canvasevent: ToolEvent | None = ...,
+        data: Any | None = ...,
+    ) -> None: ...
+
+class ToolManagerMessageEvent:
+    name: str
+    sender: Any
+    message: str
+    def __init__(self, name: str, sender: Any, message: str) -> None: ...
+
+class ToolManager:
+    keypresslock: widgets.LockDraw
+    messagelock: widgets.LockDraw
+    def __init__(self, figure: Figure | None = ...) -> None: ...
+    @property
+    def canvas(self) -> FigureCanvasBase | None: ...
+    @property
+    def figure(self) -> Figure | None: ...
+    @figure.setter
+    def figure(self, figure: Figure) -> None: ...
+    def set_figure(self, figure: Figure, update_tools: bool = ...) -> None: ...
+    def toolmanager_connect(self, s: str, func: Callable[[ToolEvent], Any]) -> int: ...
+    def toolmanager_disconnect(self, cid: int) -> None: ...
+    def message_event(self, message: str, sender: Any | None = ...) -> None: ...
+    @property
+    def active_toggle(self) -> dict[str | None, list[str] | str]: ...
+    def get_tool_keymap(self, name: str) -> list[str]: ...
+    def update_keymap(self, name: str, key: str | Iterable[str]) -> None: ...
+    def remove_tool(self, name: str) -> None: ...
+    _T = TypeVar("_T", bound=backend_tools.ToolBase)
+    def add_tool(self, name: str, tool: type[_T], *args, **kwargs) -> _T: ...
+    def trigger_tool(
+        self,
+        name: str | backend_tools.ToolBase,
+        sender: Any | None = ...,
+        canvasevent: ToolEvent | None = ...,
+        data: Any | None = ...,
+    ) -> None: ...
+    @property
+    def tools(self) -> dict[str, backend_tools.ToolBase]: ...
+    def get_tool(
+        self, name: str | backend_tools.ToolBase, warn: bool = ...
+    ) -> backend_tools.ToolBase | None: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/backend_tools.py

@@ -0,0 +1,998 @@
+"""
+Abstract base classes define the primitives for Tools.
+These tools are used by `matplotlib.backend_managers.ToolManager`
+
+:class:`ToolBase`
+    Simple stateless tool
+
+:class:`ToolToggleBase`
+    Tool that has two states, only one Toggle tool can be
+    active at any given time for the same
+    `matplotlib.backend_managers.ToolManager`
+"""
+
+import enum
+import functools
+import re
+import time
+from types import SimpleNamespace
+import uuid
+from weakref import WeakKeyDictionary
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib._pylab_helpers import Gcf
+from matplotlib import _api, cbook
+
+
+class Cursors(enum.IntEnum):  # Must subclass int for the macOS backend.
+    """Backend-independent cursor types."""
+    POINTER = enum.auto()
+    HAND = enum.auto()
+    SELECT_REGION = enum.auto()
+    MOVE = enum.auto()
+    WAIT = enum.auto()
+    RESIZE_HORIZONTAL = enum.auto()
+    RESIZE_VERTICAL = enum.auto()
+cursors = Cursors  # Backcompat.
+
+
+# _tool_registry, _register_tool_class, and _find_tool_class implement a
+# mechanism through which ToolManager.add_tool can determine whether a subclass
+# of the requested tool class has been registered (either for the current
+# canvas class or for a parent class), in which case that tool subclass will be
+# instantiated instead.  This is the mechanism used e.g. to allow different
+# GUI backends to implement different specializations for ConfigureSubplots.
+
+
+_tool_registry = set()
+
+
+def _register_tool_class(canvas_cls, tool_cls=None):
+    """Decorator registering *tool_cls* as a tool class for *canvas_cls*."""
+    if tool_cls is None:
+        return functools.partial(_register_tool_class, canvas_cls)
+    _tool_registry.add((canvas_cls, tool_cls))
+    return tool_cls
+
+
+def _find_tool_class(canvas_cls, tool_cls):
+    """Find a subclass of *tool_cls* registered for *canvas_cls*."""
+    for canvas_parent in canvas_cls.__mro__:
+        for tool_child in _api.recursive_subclasses(tool_cls):
+            if (canvas_parent, tool_child) in _tool_registry:
+                return tool_child
+    return tool_cls
+
+
+# Views positions tool
+_views_positions = 'viewpos'
+
+
+class ToolBase:
+    """
+    Base tool class.
+
+    A base tool, only implements `trigger` method or no method at all.
+    The tool is instantiated by `matplotlib.backend_managers.ToolManager`.
+    """
+
+    default_keymap = None
+    """
+    Keymap to associate with this tool.
+
+    ``list[str]``: List of keys that will trigger this tool when a keypress
+    event is emitted on ``self.figure.canvas``.  Note that this attribute is
+    looked up on the instance, and can therefore be a property (this is used
+    e.g. by the built-in tools to load the rcParams at instantiation time).
+    """
+
+    description = None
+    """
+    Description of the Tool.
+
+    `str`: Tooltip used if the Tool is included in a Toolbar.
+    """
+
+    image = None
+    """
+    Icon filename.
+
+    ``str | None``: Filename of the Toolbar icon; either absolute, or relative to the
+    directory containing the Python source file where the ``Tool.image`` class attribute
+    is defined (in the latter case, this cannot be defined as an instance attribute).
+    In either case, the extension is optional; leaving it off lets individual backends
+    select the icon format they prefer.  If None, the *name* is used as a label in the
+    toolbar button.
+    """
+
+    def __init__(self, toolmanager, name):
+        self._name = name
+        self._toolmanager = toolmanager
+        self._figure = None
+
+    name = property(
+        lambda self: self._name,
+        doc="The tool id (str, must be unique among tools of a tool manager).")
+    toolmanager = property(
+        lambda self: self._toolmanager,
+        doc="The `.ToolManager` that controls this tool.")
+    canvas = property(
+        lambda self: self._figure.canvas if self._figure is not None else None,
+        doc="The canvas of the figure affected by this tool, or None.")
+
+    def set_figure(self, figure):
+        self._figure = figure
+
+    figure = property(
+        lambda self: self._figure,
+        # The setter must explicitly call self.set_figure so that subclasses can
+        # meaningfully override it.
+        lambda self, figure: self.set_figure(figure),
+        doc="The Figure affected by this tool, or None.")
+
+    def _make_classic_style_pseudo_toolbar(self):
+        """
+        Return a placeholder object with a single `canvas` attribute.
+
+        This is useful to reuse the implementations of tools already provided
+        by the classic Toolbars.
+        """
+        return SimpleNamespace(canvas=self.canvas)
+
+    def trigger(self, sender, event, data=None):
+        """
+        Called when this tool gets used.
+
+        This method is called by `.ToolManager.trigger_tool`.
+
+        Parameters
+        ----------
+        event : `.Event`
+            The canvas event that caused this tool to be called.
+        sender : object
+            Object that requested the tool to be triggered.
+        data : object
+            Extra data.
+        """
+        pass
+
+
+class ToolToggleBase(ToolBase):
+    """
+    Toggleable tool.
+
+    Every time it is triggered, it switches between enable and disable.
+
+    Parameters
+    ----------
+    ``*args``
+        Variable length argument to be used by the Tool.
+    ``**kwargs``
+        `toggled` if present and True, sets the initial state of the Tool
+        Arbitrary keyword arguments to be consumed by the Tool
+    """
+
+    radio_group = None
+    """
+    Attribute to group 'radio' like tools (mutually exclusive).
+
+    `str` that identifies the group or **None** if not belonging to a group.
+    """
+
+    cursor = None
+    """Cursor to use when the tool is active."""
+
+    default_toggled = False
+    """Default of toggled state."""
+
+    def __init__(self, *args, **kwargs):
+        self._toggled = kwargs.pop('toggled', self.default_toggled)
+        super().__init__(*args, **kwargs)
+
+    def trigger(self, sender, event, data=None):
+        """Calls `enable` or `disable` based on `toggled` value."""
+        if self._toggled:
+            self.disable(event)
+        else:
+            self.enable(event)
+        self._toggled = not self._toggled
+
+    def enable(self, event=None):
+        """
+        Enable the toggle tool.
+
+        `trigger` calls this method when `toggled` is False.
+        """
+        pass
+
+    def disable(self, event=None):
+        """
+        Disable the toggle tool.
+
+        `trigger` call this method when `toggled` is True.
+
+        This can happen in different circumstances.
+
+        * Click on the toolbar tool button.
+        * Call to `matplotlib.backend_managers.ToolManager.trigger_tool`.
+        * Another `ToolToggleBase` derived tool is triggered
+          (from the same `.ToolManager`).
+        """
+        pass
+
+    @property
+    def toggled(self):
+        """State of the toggled tool."""
+        return self._toggled
+
+    def set_figure(self, figure):
+        toggled = self.toggled
+        if toggled:
+            if self.figure:
+                self.trigger(self, None)
+            else:
+                # if no figure the internal state is not changed
+                # we change it here so next call to trigger will change it back
+                self._toggled = False
+        super().set_figure(figure)
+        if toggled:
+            if figure:
+                self.trigger(self, None)
+            else:
+                # if there is no figure, trigger won't change the internal
+                # state we change it back
+                self._toggled = True
+
+
+class ToolSetCursor(ToolBase):
+    """
+    Change to the current cursor while inaxes.
+
+    This tool, keeps track of all `ToolToggleBase` derived tools, and updates
+    the cursor when a tool gets triggered.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._id_drag = None
+        self._current_tool = None
+        self._default_cursor = cursors.POINTER
+        self._last_cursor = self._default_cursor
+        self.toolmanager.toolmanager_connect('tool_added_event',
+                                             self._add_tool_cbk)
+        for tool in self.toolmanager.tools.values():  # process current tools
+            self._add_tool_cbk(mpl.backend_managers.ToolEvent(
+                'tool_added_event', self.toolmanager, tool))
+
+    def set_figure(self, figure):
+        if self._id_drag:
+            self.canvas.mpl_disconnect(self._id_drag)
+        super().set_figure(figure)
+        if figure:
+            self._id_drag = self.canvas.mpl_connect(
+                'motion_notify_event', self._set_cursor_cbk)
+
+    def _add_tool_cbk(self, event):
+        """Process every newly added tool."""
+        if getattr(event.tool, 'cursor', None) is not None:
+            self.toolmanager.toolmanager_connect(
+                f'tool_trigger_{event.tool.name}', self._tool_trigger_cbk)
+
+    def _tool_trigger_cbk(self, event):
+        self._current_tool = event.tool if event.tool.toggled else None
+        self._set_cursor_cbk(event.canvasevent)
+
+    def _set_cursor_cbk(self, event):
+        if not event or not self.canvas:
+            return
+        if (self._current_tool and getattr(event, "inaxes", None)
+                and event.inaxes.get_navigate()):
+            if self._last_cursor != self._current_tool.cursor:
+                self.canvas.set_cursor(self._current_tool.cursor)
+                self._last_cursor = self._current_tool.cursor
+        elif self._last_cursor != self._default_cursor:
+            self.canvas.set_cursor(self._default_cursor)
+            self._last_cursor = self._default_cursor
+
+
+class ToolCursorPosition(ToolBase):
+    """
+    Send message with the current pointer position.
+
+    This tool runs in the background reporting the position of the cursor.
+    """
+    def __init__(self, *args, **kwargs):
+        self._id_drag = None
+        super().__init__(*args, **kwargs)
+
+    def set_figure(self, figure):
+        if self._id_drag:
+            self.canvas.mpl_disconnect(self._id_drag)
+        super().set_figure(figure)
+        if figure:
+            self._id_drag = self.canvas.mpl_connect(
+                'motion_notify_event', self.send_message)
+
+    def send_message(self, event):
+        """Call `matplotlib.backend_managers.ToolManager.message_event`."""
+        if self.toolmanager.messagelock.locked():
+            return
+
+        from matplotlib.backend_bases import NavigationToolbar2
+        message = NavigationToolbar2._mouse_event_to_message(event)
+        self.toolmanager.message_event(message, self)
+
+
+class RubberbandBase(ToolBase):
+    """Draw and remove a rubberband."""
+    def trigger(self, sender, event, data=None):
+        """Call `draw_rubberband` or `remove_rubberband` based on data."""
+        if not self.figure.canvas.widgetlock.available(sender):
+            return
+        if data is not None:
+            self.draw_rubberband(*data)
+        else:
+            self.remove_rubberband()
+
+    def draw_rubberband(self, *data):
+        """
+        Draw rubberband.
+
+        This method must get implemented per backend.
+        """
+        raise NotImplementedError
+
+    def remove_rubberband(self):
+        """
+        Remove rubberband.
+
+        This method should get implemented per backend.
+        """
+        pass
+
+
+class ToolQuit(ToolBase):
+    """Tool to call the figure manager destroy method."""
+
+    description = 'Quit the figure'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.quit'])
+
+    def trigger(self, sender, event, data=None):
+        Gcf.destroy_fig(self.figure)
+
+
+class ToolQuitAll(ToolBase):
+    """Tool to call the figure manager destroy method."""
+
+    description = 'Quit all figures'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.quit_all'])
+
+    def trigger(self, sender, event, data=None):
+        Gcf.destroy_all()
+
+
+class ToolGrid(ToolBase):
+    """Tool to toggle the major grids of the figure."""
+
+    description = 'Toggle major grids'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.grid'])
+
+    def trigger(self, sender, event, data=None):
+        sentinel = str(uuid.uuid4())
+        # Trigger grid switching by temporarily setting :rc:`keymap.grid`
+        # to a unique key and sending an appropriate event.
+        with (cbook._setattr_cm(event, key=sentinel),
+              mpl.rc_context({'keymap.grid': sentinel})):
+            mpl.backend_bases.key_press_handler(event, self.figure.canvas)
+
+
+class ToolMinorGrid(ToolBase):
+    """Tool to toggle the major and minor grids of the figure."""
+
+    description = 'Toggle major and minor grids'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.grid_minor'])
+
+    def trigger(self, sender, event, data=None):
+        sentinel = str(uuid.uuid4())
+        # Trigger grid switching by temporarily setting :rc:`keymap.grid_minor`
+        # to a unique key and sending an appropriate event.
+        with (cbook._setattr_cm(event, key=sentinel),
+              mpl.rc_context({'keymap.grid_minor': sentinel})):
+            mpl.backend_bases.key_press_handler(event, self.figure.canvas)
+
+
+class ToolFullScreen(ToolBase):
+    """Tool to toggle full screen."""
+
+    description = 'Toggle fullscreen mode'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.fullscreen'])
+
+    def trigger(self, sender, event, data=None):
+        self.figure.canvas.manager.full_screen_toggle()
+
+
+class AxisScaleBase(ToolToggleBase):
+    """Base Tool to toggle between linear and logarithmic."""
+
+    def trigger(self, sender, event, data=None):
+        if event.inaxes is None:
+            return
+        super().trigger(sender, event, data)
+
+    def enable(self, event=None):
+        self.set_scale(event.inaxes, 'log')
+        self.figure.canvas.draw_idle()
+
+    def disable(self, event=None):
+        self.set_scale(event.inaxes, 'linear')
+        self.figure.canvas.draw_idle()
+
+
+class ToolYScale(AxisScaleBase):
+    """Tool to toggle between linear and logarithmic scales on the Y axis."""
+
+    description = 'Toggle scale Y axis'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.yscale'])
+
+    def set_scale(self, ax, scale):
+        ax.set_yscale(scale)
+
+
+class ToolXScale(AxisScaleBase):
+    """Tool to toggle between linear and logarithmic scales on the X axis."""
+
+    description = 'Toggle scale X axis'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.xscale'])
+
+    def set_scale(self, ax, scale):
+        ax.set_xscale(scale)
+
+
+class ToolViewsPositions(ToolBase):
+    """
+    Auxiliary Tool to handle changes in views and positions.
+
+    Runs in the background and should get used by all the tools that
+    need to access the figure's history of views and positions, e.g.
+
+    * `ToolZoom`
+    * `ToolPan`
+    * `ToolHome`
+    * `ToolBack`
+    * `ToolForward`
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.views = WeakKeyDictionary()
+        self.positions = WeakKeyDictionary()
+        self.home_views = WeakKeyDictionary()
+        super().__init__(*args, **kwargs)
+
+    def add_figure(self, figure):
+        """Add the current figure to the stack of views and positions."""
+
+        if figure not in self.views:
+            self.views[figure] = cbook._Stack()
+            self.positions[figure] = cbook._Stack()
+            self.home_views[figure] = WeakKeyDictionary()
+            # Define Home
+            self.push_current(figure)
+            # Make sure we add a home view for new Axes as they're added
+            figure.add_axobserver(lambda fig: self.update_home_views(fig))
+
+    def clear(self, figure):
+        """Reset the Axes stack."""
+        if figure in self.views:
+            self.views[figure].clear()
+            self.positions[figure].clear()
+            self.home_views[figure].clear()
+            self.update_home_views()
+
+    def update_view(self):
+        """
+        Update the view limits and position for each Axes from the current
+        stack position. If any Axes are present in the figure that aren't in
+        the current stack position, use the home view limits for those Axes and
+        don't update *any* positions.
+        """
+
+        views = self.views[self.figure]()
+        if views is None:
+            return
+        pos = self.positions[self.figure]()
+        if pos is None:
+            return
+        home_views = self.home_views[self.figure]
+        all_axes = self.figure.get_axes()
+        for a in all_axes:
+            if a in views:
+                cur_view = views[a]
+            else:
+                cur_view = home_views[a]
+            a._set_view(cur_view)
+
+        if set(all_axes).issubset(pos):
+            for a in all_axes:
+                # Restore both the original and modified positions
+                a._set_position(pos[a][0], 'original')
+                a._set_position(pos[a][1], 'active')
+
+        self.figure.canvas.draw_idle()
+
+    def push_current(self, figure=None):
+        """
+        Push the current view limits and position onto their respective stacks.
+        """
+        if not figure:
+            figure = self.figure
+        views = WeakKeyDictionary()
+        pos = WeakKeyDictionary()
+        for a in figure.get_axes():
+            views[a] = a._get_view()
+            pos[a] = self._axes_pos(a)
+        self.views[figure].push(views)
+        self.positions[figure].push(pos)
+
+    def _axes_pos(self, ax):
+        """
+        Return the original and modified positions for the specified Axes.
+
+        Parameters
+        ----------
+        ax : matplotlib.axes.Axes
+            The `.Axes` to get the positions for.
+
+        Returns
+        -------
+        original_position, modified_position
+            A tuple of the original and modified positions.
+        """
+
+        return (ax.get_position(True).frozen(),
+                ax.get_position().frozen())
+
+    def update_home_views(self, figure=None):
+        """
+        Make sure that ``self.home_views`` has an entry for all Axes present
+        in the figure.
+        """
+
+        if not figure:
+            figure = self.figure
+        for a in figure.get_axes():
+            if a not in self.home_views[figure]:
+                self.home_views[figure][a] = a._get_view()
+
+    def home(self):
+        """Recall the first view and position from the stack."""
+        self.views[self.figure].home()
+        self.positions[self.figure].home()
+
+    def back(self):
+        """Back one step in the stack of views and positions."""
+        self.views[self.figure].back()
+        self.positions[self.figure].back()
+
+    def forward(self):
+        """Forward one step in the stack of views and positions."""
+        self.views[self.figure].forward()
+        self.positions[self.figure].forward()
+
+
+class ViewsPositionsBase(ToolBase):
+    """Base class for `ToolHome`, `ToolBack` and `ToolForward`."""
+
+    _on_trigger = None
+
+    def trigger(self, sender, event, data=None):
+        self.toolmanager.get_tool(_views_positions).add_figure(self.figure)
+        getattr(self.toolmanager.get_tool(_views_positions),
+                self._on_trigger)()
+        self.toolmanager.get_tool(_views_positions).update_view()
+
+
+class ToolHome(ViewsPositionsBase):
+    """Restore the original view limits."""
+
+    description = 'Reset original view'
+    image = 'mpl-data/images/home'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.home'])
+    _on_trigger = 'home'
+
+
+class ToolBack(ViewsPositionsBase):
+    """Move back up the view limits stack."""
+
+    description = 'Back to previous view'
+    image = 'mpl-data/images/back'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.back'])
+    _on_trigger = 'back'
+
+
+class ToolForward(ViewsPositionsBase):
+    """Move forward in the view lim stack."""
+
+    description = 'Forward to next view'
+    image = 'mpl-data/images/forward'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.forward'])
+    _on_trigger = 'forward'
+
+
+class ConfigureSubplotsBase(ToolBase):
+    """Base tool for the configuration of subplots."""
+
+    description = 'Configure subplots'
+    image = 'mpl-data/images/subplots'
+
+
+class SaveFigureBase(ToolBase):
+    """Base tool for figure saving."""
+
+    description = 'Save the figure'
+    image = 'mpl-data/images/filesave'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.save'])
+
+
+class ZoomPanBase(ToolToggleBase):
+    """Base class for `ToolZoom` and `ToolPan`."""
+    def __init__(self, *args):
+        super().__init__(*args)
+        self._button_pressed = None
+        self._xypress = None
+        self._idPress = None
+        self._idRelease = None
+        self._idScroll = None
+        self.base_scale = 2.
+        self.scrollthresh = .5  # .5 second scroll threshold
+        self.lastscroll = time.time()-self.scrollthresh
+
+    def enable(self, event=None):
+        """Connect press/release events and lock the canvas."""
+        self.figure.canvas.widgetlock(self)
+        self._idPress = self.figure.canvas.mpl_connect(
+            'button_press_event', self._press)
+        self._idRelease = self.figure.canvas.mpl_connect(
+            'button_release_event', self._release)
+        self._idScroll = self.figure.canvas.mpl_connect(
+            'scroll_event', self.scroll_zoom)
+
+    def disable(self, event=None):
+        """Release the canvas and disconnect press/release events."""
+        self._cancel_action()
+        self.figure.canvas.widgetlock.release(self)
+        self.figure.canvas.mpl_disconnect(self._idPress)
+        self.figure.canvas.mpl_disconnect(self._idRelease)
+        self.figure.canvas.mpl_disconnect(self._idScroll)
+
+    def trigger(self, sender, event, data=None):
+        self.toolmanager.get_tool(_views_positions).add_figure(self.figure)
+        super().trigger(sender, event, data)
+        new_navigate_mode = self.name.upper() if self.toggled else None
+        for ax in self.figure.axes:
+            ax.set_navigate_mode(new_navigate_mode)
+
+    def scroll_zoom(self, event):
+        # https://gist.github.com/tacaswell/3144287
+        if event.inaxes is None:
+            return
+
+        if event.button == 'up':
+            # deal with zoom in
+            scl = self.base_scale
+        elif event.button == 'down':
+            # deal with zoom out
+            scl = 1/self.base_scale
+        else:
+            # deal with something that should never happen
+            scl = 1
+
+        ax = event.inaxes
+        ax._set_view_from_bbox([event.x, event.y, scl])
+
+        # If last scroll was done within the timing threshold, delete the
+        # previous view
+        if (time.time()-self.lastscroll) < self.scrollthresh:
+            self.toolmanager.get_tool(_views_positions).back()
+
+        self.figure.canvas.draw_idle()  # force re-draw
+
+        self.lastscroll = time.time()
+        self.toolmanager.get_tool(_views_positions).push_current()
+
+
+class ToolZoom(ZoomPanBase):
+    """A Tool for zooming using a rectangle selector."""
+
+    description = 'Zoom to rectangle'
+    image = 'mpl-data/images/zoom_to_rect'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.zoom'])
+    cursor = cursors.SELECT_REGION
+    radio_group = 'default'
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self._ids_zoom = []
+
+    def _cancel_action(self):
+        for zoom_id in self._ids_zoom:
+            self.figure.canvas.mpl_disconnect(zoom_id)
+        self.toolmanager.trigger_tool('rubberband', self)
+        self.figure.canvas.draw_idle()
+        self._xypress = None
+        self._button_pressed = None
+        self._ids_zoom = []
+        return
+
+    def _press(self, event):
+        """Callback for mouse button presses in zoom-to-rectangle mode."""
+
+        # If we're already in the middle of a zoom, pressing another
+        # button works to "cancel"
+        if self._ids_zoom:
+            self._cancel_action()
+
+        if event.button == 1:
+            self._button_pressed = 1
+        elif event.button == 3:
+            self._button_pressed = 3
+        else:
+            self._cancel_action()
+            return
+
+        x, y = event.x, event.y
+
+        self._xypress = []
+        for i, a in enumerate(self.figure.get_axes()):
+            if (x is not None and y is not None and a.in_axes(event) and
+                    a.get_navigate() and a.can_zoom()):
+                self._xypress.append((x, y, a, i, a._get_view()))
+
+        id1 = self.figure.canvas.mpl_connect(
+            'motion_notify_event', self._mouse_move)
+        id2 = self.figure.canvas.mpl_connect(
+            'key_press_event', self._switch_on_zoom_mode)
+        id3 = self.figure.canvas.mpl_connect(
+            'key_release_event', self._switch_off_zoom_mode)
+
+        self._ids_zoom = id1, id2, id3
+        self._zoom_mode = event.key
+
+    def _switch_on_zoom_mode(self, event):
+        self._zoom_mode = event.key
+        self._mouse_move(event)
+
+    def _switch_off_zoom_mode(self, event):
+        self._zoom_mode = None
+        self._mouse_move(event)
+
+    def _mouse_move(self, event):
+        """Callback for mouse moves in zoom-to-rectangle mode."""
+
+        if self._xypress:
+            x, y = event.x, event.y
+            lastx, lasty, a, ind, view = self._xypress[0]
+            (x1, y1), (x2, y2) = np.clip(
+                [[lastx, lasty], [x, y]], a.bbox.min, a.bbox.max)
+            if self._zoom_mode == "x":
+                y1, y2 = a.bbox.intervaly
+            elif self._zoom_mode == "y":
+                x1, x2 = a.bbox.intervalx
+            self.toolmanager.trigger_tool(
+                'rubberband', self, data=(x1, y1, x2, y2))
+
+    def _release(self, event):
+        """Callback for mouse button releases in zoom-to-rectangle mode."""
+
+        for zoom_id in self._ids_zoom:
+            self.figure.canvas.mpl_disconnect(zoom_id)
+        self._ids_zoom = []
+
+        if not self._xypress:
+            self._cancel_action()
+            return
+
+        done_ax = []
+
+        for cur_xypress in self._xypress:
+            x, y = event.x, event.y
+            lastx, lasty, a, _ind, view = cur_xypress
+            # ignore singular clicks - 5 pixels is a threshold
+            if abs(x - lastx) < 5 or abs(y - lasty) < 5:
+                self._cancel_action()
+                return
+
+            # detect twinx, twiny Axes and avoid double zooming
+            twinx = any(a.get_shared_x_axes().joined(a, a1) for a1 in done_ax)
+            twiny = any(a.get_shared_y_axes().joined(a, a1) for a1 in done_ax)
+            done_ax.append(a)
+
+            if self._button_pressed == 1:
+                direction = 'in'
+            elif self._button_pressed == 3:
+                direction = 'out'
+            else:
+                continue
+
+            a._set_view_from_bbox((lastx, lasty, x, y), direction,
+                                  self._zoom_mode, twinx, twiny)
+
+        self._zoom_mode = None
+        self.toolmanager.get_tool(_views_positions).push_current()
+        self._cancel_action()
+
+
+class ToolPan(ZoomPanBase):
+    """Pan Axes with left mouse, zoom with right."""
+
+    default_keymap = property(lambda self: mpl.rcParams['keymap.pan'])
+    description = 'Pan axes with left mouse, zoom with right'
+    image = 'mpl-data/images/move'
+    cursor = cursors.MOVE
+    radio_group = 'default'
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self._id_drag = None
+
+    def _cancel_action(self):
+        self._button_pressed = None
+        self._xypress = []
+        self.figure.canvas.mpl_disconnect(self._id_drag)
+        self.toolmanager.messagelock.release(self)
+        self.figure.canvas.draw_idle()
+
+    def _press(self, event):
+        if event.button == 1:
+            self._button_pressed = 1
+        elif event.button == 3:
+            self._button_pressed = 3
+        else:
+            self._cancel_action()
+            return
+
+        x, y = event.x, event.y
+
+        self._xypress = []
+        for i, a in enumerate(self.figure.get_axes()):
+            if (x is not None and y is not None and a.in_axes(event) and
+                    a.get_navigate() and a.can_pan()):
+                a.start_pan(x, y, event.button)
+                self._xypress.append((a, i))
+                self.toolmanager.messagelock(self)
+                self._id_drag = self.figure.canvas.mpl_connect(
+                    'motion_notify_event', self._mouse_move)
+
+    def _release(self, event):
+        if self._button_pressed is None:
+            self._cancel_action()
+            return
+
+        self.figure.canvas.mpl_disconnect(self._id_drag)
+        self.toolmanager.messagelock.release(self)
+
+        for a, _ind in self._xypress:
+            a.end_pan()
+        if not self._xypress:
+            self._cancel_action()
+            return
+
+        self.toolmanager.get_tool(_views_positions).push_current()
+        self._cancel_action()
+
+    def _mouse_move(self, event):
+        for a, _ind in self._xypress:
+            # safer to use the recorded button at the _press than current
+            # button: # multiple button can get pressed during motion...
+            a.drag_pan(self._button_pressed, event.key, event.x, event.y)
+        self.toolmanager.canvas.draw_idle()
+
+
+class ToolHelpBase(ToolBase):
+    description = 'Print tool list, shortcuts and description'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.help'])
+    image = 'mpl-data/images/help'
+
+    @staticmethod
+    def format_shortcut(key_sequence):
+        """
+        Convert a shortcut string from the notation used in rc config to the
+        standard notation for displaying shortcuts, e.g. 'ctrl+a' -> 'Ctrl+A'.
+        """
+        return (key_sequence if len(key_sequence) == 1 else
+                re.sub(r"\+[A-Z]", r"+Shift\g<0>", key_sequence).title())
+
+    def _format_tool_keymap(self, name):
+        keymaps = self.toolmanager.get_tool_keymap(name)
+        return ", ".join(self.format_shortcut(keymap) for keymap in keymaps)
+
+    def _get_help_entries(self):
+        return [(name, self._format_tool_keymap(name), tool.description)
+                for name, tool in sorted(self.toolmanager.tools.items())
+                if tool.description]
+
+    def _get_help_text(self):
+        entries = self._get_help_entries()
+        entries = ["{}: {}\n\t{}".format(*entry) for entry in entries]
+        return "\n".join(entries)
+
+    def _get_help_html(self):
+        fmt = "<tr><td>{}</td><td>{}</td><td>{}</td></tr>"
+        rows = [fmt.format(
+            "<b>Action</b>", "<b>Shortcuts</b>", "<b>Description</b>")]
+        rows += [fmt.format(*row) for row in self._get_help_entries()]
+        return ("<style>td {padding: 0px 4px}</style>"
+                "<table><thead>" + rows[0] + "</thead>"
+                "<tbody>".join(rows[1:]) + "</tbody></table>")
+
+
+class ToolCopyToClipboardBase(ToolBase):
+    """Tool to copy the figure to the clipboard."""
+
+    description = 'Copy the canvas figure to clipboard'
+    default_keymap = property(lambda self: mpl.rcParams['keymap.copy'])
+
+    def trigger(self, *args, **kwargs):
+        message = "Copy tool is not available"
+        self.toolmanager.message_event(message, self)
+
+
+default_tools = {'home': ToolHome, 'back': ToolBack, 'forward': ToolForward,
+                 'zoom': ToolZoom, 'pan': ToolPan,
+                 'subplots': ConfigureSubplotsBase,
+                 'save': SaveFigureBase,
+                 'grid': ToolGrid,
+                 'grid_minor': ToolMinorGrid,
+                 'fullscreen': ToolFullScreen,
+                 'quit': ToolQuit,
+                 'quit_all': ToolQuitAll,
+                 'xscale': ToolXScale,
+                 'yscale': ToolYScale,
+                 'position': ToolCursorPosition,
+                 _views_positions: ToolViewsPositions,
+                 'cursor': ToolSetCursor,
+                 'rubberband': RubberbandBase,
+                 'help': ToolHelpBase,
+                 'copy': ToolCopyToClipboardBase,
+                 }
+
+default_toolbar_tools = [['navigation', ['home', 'back', 'forward']],
+                         ['zoompan', ['pan', 'zoom', 'subplots']],
+                         ['io', ['save', 'help']]]
+
+
+def add_tools_to_manager(toolmanager, tools=default_tools):
+    """
+    Add multiple tools to a `.ToolManager`.
+
+    Parameters
+    ----------
+    toolmanager : `.backend_managers.ToolManager`
+        Manager to which the tools are added.
+    tools : {str: class_like}, optional
+        The tools to add in a {name: tool} dict, see
+        `.backend_managers.ToolManager.add_tool` for more info.
+    """
+
+    for name, tool in tools.items():
+        toolmanager.add_tool(name, tool)
+
+
+def add_tools_to_container(container, tools=default_toolbar_tools):
+    """
+    Add multiple tools to the container.
+
+    Parameters
+    ----------
+    container : Container
+        `.backend_bases.ToolContainerBase` object that will get the tools
+        added.
+    tools : list, optional
+        List in the form ``[[group1, [tool1, tool2 ...]], [group2, [...]]]``
+        where the tools ``[tool1, tool2, ...]`` will display in group1.
+        See `.backend_bases.ToolContainerBase.add_tool` for details.
+    """
+
+    for group, grouptools in tools:
+        for position, tool in enumerate(grouptools):
+            container.add_tool(tool, group, position)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/backend_tools.pyi

@@ -0,0 +1,121 @@
+import enum
+from matplotlib import cbook
+from matplotlib.axes import Axes
+from matplotlib.backend_bases import ToolContainerBase, FigureCanvasBase
+from matplotlib.backend_managers import ToolManager, ToolEvent
+from matplotlib.figure import Figure
+from matplotlib.scale import ScaleBase
+
+from typing import Any, cast
+
+class Cursors(enum.IntEnum):
+    POINTER = cast(int, ...)
+    HAND = cast(int, ...)
+    SELECT_REGION = cast(int, ...)
+    MOVE = cast(int, ...)
+    WAIT = cast(int, ...)
+    RESIZE_HORIZONTAL = cast(int, ...)
+    RESIZE_VERTICAL = cast(int, ...)
+
+cursors = Cursors
+
+class ToolBase:
+    @property
+    def default_keymap(self) -> list[str] | None: ...
+    description: str | None
+    image: str | None
+    def __init__(self, toolmanager: ToolManager, name: str) -> None: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def toolmanager(self) -> ToolManager: ...
+    @property
+    def canvas(self) -> FigureCanvasBase | None: ...
+    @property
+    def figure(self) -> Figure | None: ...
+    @figure.setter
+    def figure(self, figure: Figure | None) -> None: ...
+    def set_figure(self, figure: Figure | None) -> None: ...
+    def trigger(self, sender: Any, event: ToolEvent, data: Any = ...) -> None: ...
+
+class ToolToggleBase(ToolBase):
+    radio_group: str | None
+    cursor: Cursors | None
+    default_toggled: bool
+    def __init__(self, *args, **kwargs) -> None: ...
+    def enable(self, event: ToolEvent | None = ...) -> None: ...
+    def disable(self, event: ToolEvent | None = ...) -> None: ...
+    @property
+    def toggled(self) -> bool: ...
+    def set_figure(self, figure: Figure | None) -> None: ...
+
+class ToolSetCursor(ToolBase): ...
+
+class ToolCursorPosition(ToolBase):
+    def send_message(self, event: ToolEvent) -> None: ...
+
+class RubberbandBase(ToolBase):
+    def draw_rubberband(self, *data) -> None: ...
+    def remove_rubberband(self) -> None: ...
+
+class ToolQuit(ToolBase): ...
+class ToolQuitAll(ToolBase): ...
+class ToolGrid(ToolBase): ...
+class ToolMinorGrid(ToolBase): ...
+class ToolFullScreen(ToolBase): ...
+
+class AxisScaleBase(ToolToggleBase):
+    def enable(self, event: ToolEvent | None = ...) -> None: ...
+    def disable(self, event: ToolEvent | None = ...) -> None: ...
+
+class ToolYScale(AxisScaleBase):
+    def set_scale(self, ax: Axes, scale: str | ScaleBase) -> None: ...
+
+class ToolXScale(AxisScaleBase):
+    def set_scale(self, ax, scale: str | ScaleBase) -> None: ...
+
+class ToolViewsPositions(ToolBase):
+    views: dict[Figure | Axes, cbook._Stack]
+    positions: dict[Figure | Axes, cbook._Stack]
+    home_views: dict[Figure, dict[Axes, tuple[float, float, float, float]]]
+    def add_figure(self, figure: Figure) -> None: ...
+    def clear(self, figure: Figure) -> None: ...
+    def update_view(self) -> None: ...
+    def push_current(self, figure: Figure | None = ...) -> None: ...
+    def update_home_views(self, figure: Figure | None = ...) -> None: ...
+    def home(self) -> None: ...
+    def back(self) -> None: ...
+    def forward(self) -> None: ...
+
+class ViewsPositionsBase(ToolBase): ...
+class ToolHome(ViewsPositionsBase): ...
+class ToolBack(ViewsPositionsBase): ...
+class ToolForward(ViewsPositionsBase): ...
+class ConfigureSubplotsBase(ToolBase): ...
+class SaveFigureBase(ToolBase): ...
+
+class ZoomPanBase(ToolToggleBase):
+    base_scale: float
+    scrollthresh: float
+    lastscroll: float
+    def __init__(self, *args) -> None: ...
+    def enable(self, event: ToolEvent | None = ...) -> None: ...
+    def disable(self, event: ToolEvent | None = ...) -> None: ...
+    def scroll_zoom(self, event: ToolEvent) -> None: ...
+
+class ToolZoom(ZoomPanBase): ...
+class ToolPan(ZoomPanBase): ...
+
+class ToolHelpBase(ToolBase):
+    @staticmethod
+    def format_shortcut(key_sequence: str) -> str: ...
+
+class ToolCopyToClipboardBase(ToolBase): ...
+
+default_tools: dict[str, ToolBase]
+default_toolbar_tools: list[list[str | list[str]]]
+
+def add_tools_to_manager(
+    toolmanager: ToolManager, tools: dict[str, type[ToolBase]] = ...
+) -> None: ...
+def add_tools_to_container(container: ToolContainerBase, tools: list[Any] = ...) -> None: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/bezier.py

@@ -0,0 +1,602 @@
+"""
+A module providing some utility functions regarding Bézier path manipulation.
+"""
+
+from functools import lru_cache
+import math
+import warnings
+
+import numpy as np
+
+from matplotlib import _api
+
+
+# same algorithm as 3.8's math.comb
+@np.vectorize
+@lru_cache(maxsize=128)
+def _comb(n, k):
+    if k > n:
+        return 0
+    k = min(k, n - k)
+    i = np.arange(1, k + 1)
+    return np.prod((n + 1 - i)/i).astype(int)
+
+
+class NonIntersectingPathException(ValueError):
+    pass
+
+
+# some functions
+
+
+def get_intersection(cx1, cy1, cos_t1, sin_t1,
+                     cx2, cy2, cos_t2, sin_t2):
+    """
+    Return the intersection between the line through (*cx1*, *cy1*) at angle
+    *t1* and the line through (*cx2*, *cy2*) at angle *t2*.
+    """
+
+    # line1 => sin_t1 * (x - cx1) - cos_t1 * (y - cy1) = 0.
+    # line1 => sin_t1 * x + cos_t1 * y = sin_t1*cx1 - cos_t1*cy1
+
+    line1_rhs = sin_t1 * cx1 - cos_t1 * cy1
+    line2_rhs = sin_t2 * cx2 - cos_t2 * cy2
+
+    # rhs matrix
+    a, b = sin_t1, -cos_t1
+    c, d = sin_t2, -cos_t2
+
+    ad_bc = a * d - b * c
+    if abs(ad_bc) < 1e-12:
+        raise ValueError("Given lines do not intersect. Please verify that "
+                         "the angles are not equal or differ by 180 degrees.")
+
+    # rhs_inverse
+    a_, b_ = d, -b
+    c_, d_ = -c, a
+    a_, b_, c_, d_ = (k / ad_bc for k in [a_, b_, c_, d_])
+
+    x = a_ * line1_rhs + b_ * line2_rhs
+    y = c_ * line1_rhs + d_ * line2_rhs
+
+    return x, y
+
+
+def get_normal_points(cx, cy, cos_t, sin_t, length):
+    """
+    For a line passing through (*cx*, *cy*) and having an angle *t*, return
+    locations of the two points located along its perpendicular line at the
+    distance of *length*.
+    """
+
+    if length == 0.:
+        return cx, cy, cx, cy
+
+    cos_t1, sin_t1 = sin_t, -cos_t
+    cos_t2, sin_t2 = -sin_t, cos_t
+
+    x1, y1 = length * cos_t1 + cx, length * sin_t1 + cy
+    x2, y2 = length * cos_t2 + cx, length * sin_t2 + cy
+
+    return x1, y1, x2, y2
+
+
+# BEZIER routines
+
+# subdividing bezier curve
+# http://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/Bezier/bezier-sub.html
+
+
+def _de_casteljau1(beta, t):
+    next_beta = beta[:-1] * (1 - t) + beta[1:] * t
+    return next_beta
+
+
+def split_de_casteljau(beta, t):
+    """
+    Split a Bézier segment defined by its control points *beta* into two
+    separate segments divided at *t* and return their control points.
+    """
+    beta = np.asarray(beta)
+    beta_list = [beta]
+    while True:
+        beta = _de_casteljau1(beta, t)
+        beta_list.append(beta)
+        if len(beta) == 1:
+            break
+    left_beta = [beta[0] for beta in beta_list]
+    right_beta = [beta[-1] for beta in reversed(beta_list)]
+
+    return left_beta, right_beta
+
+
+def find_bezier_t_intersecting_with_closedpath(
+        bezier_point_at_t, inside_closedpath, t0=0., t1=1., tolerance=0.01):
+    """
+    Find the intersection of the Bézier curve with a closed path.
+
+    The intersection point *t* is approximated by two parameters *t0*, *t1*
+    such that *t0* <= *t* <= *t1*.
+
+    Search starts from *t0* and *t1* and uses a simple bisecting algorithm
+    therefore one of the end points must be inside the path while the other
+    doesn't. The search stops when the distance of the points parametrized by
+    *t0* and *t1* gets smaller than the given *tolerance*.
+
+    Parameters
+    ----------
+    bezier_point_at_t : callable
+        A function returning x, y coordinates of the Bézier at parameter *t*.
+        It must have the signature::
+
+            bezier_point_at_t(t: float) -> tuple[float, float]
+
+    inside_closedpath : callable
+        A function returning True if a given point (x, y) is inside the
+        closed path. It must have the signature::
+
+            inside_closedpath(point: tuple[float, float]) -> bool
+
+    t0, t1 : float
+        Start parameters for the search.
+
+    tolerance : float
+        Maximal allowed distance between the final points.
+
+    Returns
+    -------
+    t0, t1 : float
+        The Bézier path parameters.
+    """
+    start = bezier_point_at_t(t0)
+    end = bezier_point_at_t(t1)
+
+    start_inside = inside_closedpath(start)
+    end_inside = inside_closedpath(end)
+
+    if start_inside == end_inside and start != end:
+        raise NonIntersectingPathException(
+            "Both points are on the same side of the closed path")
+
+    while True:
+
+        # return if the distance is smaller than the tolerance
+        if np.hypot(start[0] - end[0], start[1] - end[1]) < tolerance:
+            return t0, t1
+
+        # calculate the middle point
+        middle_t = 0.5 * (t0 + t1)
+        middle = bezier_point_at_t(middle_t)
+        middle_inside = inside_closedpath(middle)
+
+        if start_inside ^ middle_inside:
+            t1 = middle_t
+            if end == middle:
+                # Edge case where infinite loop is possible
+                # Caused by large numbers relative to tolerance
+                return t0, t1
+            end = middle
+        else:
+            t0 = middle_t
+            if start == middle:
+                # Edge case where infinite loop is possible
+                # Caused by large numbers relative to tolerance
+                return t0, t1
+            start = middle
+            start_inside = middle_inside
+
+
+class BezierSegment:
+    """
+    A d-dimensional Bézier segment.
+
+    Parameters
+    ----------
+    control_points : (N, d) array
+        Location of the *N* control points.
+    """
+
+    def __init__(self, control_points):
+        self._cpoints = np.asarray(control_points)
+        self._N, self._d = self._cpoints.shape
+        self._orders = np.arange(self._N)
+        coeff = [math.factorial(self._N - 1)
+                 // (math.factorial(i) * math.factorial(self._N - 1 - i))
+                 for i in range(self._N)]
+        self._px = (self._cpoints.T * coeff).T
+
+    def __call__(self, t):
+        """
+        Evaluate the Bézier curve at point(s) *t* in [0, 1].
+
+        Parameters
+        ----------
+        t : (k,) array-like
+            Points at which to evaluate the curve.
+
+        Returns
+        -------
+        (k, d) array
+            Value of the curve for each point in *t*.
+        """
+        t = np.asarray(t)
+        return (np.power.outer(1 - t, self._orders[::-1])
+                * np.power.outer(t, self._orders)) @ self._px
+
+    def point_at_t(self, t):
+        """
+        Evaluate the curve at a single point, returning a tuple of *d* floats.
+        """
+        return tuple(self(t))
+
+    @property
+    def control_points(self):
+        """The control points of the curve."""
+        return self._cpoints
+
+    @property
+    def dimension(self):
+        """The dimension of the curve."""
+        return self._d
+
+    @property
+    def degree(self):
+        """Degree of the polynomial. One less the number of control points."""
+        return self._N - 1
+
+    @property
+    def polynomial_coefficients(self):
+        r"""
+        The polynomial coefficients of the Bézier curve.
+
+        .. warning:: Follows opposite convention from `numpy.polyval`.
+
+        Returns
+        -------
+        (n+1, d) array
+            Coefficients after expanding in polynomial basis, where :math:`n`
+            is the degree of the Bézier curve and :math:`d` its dimension.
+            These are the numbers (:math:`C_j`) such that the curve can be
+            written :math:`\sum_{j=0}^n C_j t^j`.
+
+        Notes
+        -----
+        The coefficients are calculated as
+
+        .. math::
+
+            {n \choose j} \sum_{i=0}^j (-1)^{i+j} {j \choose i} P_i
+
+        where :math:`P_i` are the control points of the curve.
+        """
+        n = self.degree
+        # matplotlib uses n <= 4. overflow plausible starting around n = 15.
+        if n > 10:
+            warnings.warn("Polynomial coefficients formula unstable for high "
+                          "order Bezier curves!", RuntimeWarning)
+        P = self.control_points
+        j = np.arange(n+1)[:, None]
+        i = np.arange(n+1)[None, :]  # _comb is non-zero for i <= j
+        prefactor = (-1)**(i + j) * _comb(j, i)  # j on axis 0, i on axis 1
+        return _comb(n, j) * prefactor @ P  # j on axis 0, self.dimension on 1
+
+    def axis_aligned_extrema(self):
+        """
+        Return the dimension and location of the curve's interior extrema.
+
+        The extrema are the points along the curve where one of its partial
+        derivatives is zero.
+
+        Returns
+        -------
+        dims : array of int
+            Index :math:`i` of the partial derivative which is zero at each
+            interior extrema.
+        dzeros : array of float
+            Of same size as dims. The :math:`t` such that :math:`d/dx_i B(t) =
+            0`
+        """
+        n = self.degree
+        if n <= 1:
+            return np.array([]), np.array([])
+        Cj = self.polynomial_coefficients
+        dCj = np.arange(1, n+1)[:, None] * Cj[1:]
+        dims = []
+        roots = []
+        for i, pi in enumerate(dCj.T):
+            r = np.roots(pi[::-1])
+            roots.append(r)
+            dims.append(np.full_like(r, i))
+        roots = np.concatenate(roots)
+        dims = np.concatenate(dims)
+        in_range = np.isreal(roots) & (roots >= 0) & (roots <= 1)
+        return dims[in_range], np.real(roots)[in_range]
+
+
+def split_bezier_intersecting_with_closedpath(
+        bezier, inside_closedpath, tolerance=0.01):
+    """
+    Split a Bézier curve into two at the intersection with a closed path.
+
+    Parameters
+    ----------
+    bezier : (N, 2) array-like
+        Control points of the Bézier segment. See `.BezierSegment`.
+    inside_closedpath : callable
+        A function returning True if a given point (x, y) is inside the
+        closed path. See also `.find_bezier_t_intersecting_with_closedpath`.
+    tolerance : float
+        The tolerance for the intersection. See also
+        `.find_bezier_t_intersecting_with_closedpath`.
+
+    Returns
+    -------
+    left, right
+        Lists of control points for the two Bézier segments.
+    """
+
+    bz = BezierSegment(bezier)
+    bezier_point_at_t = bz.point_at_t
+
+    t0, t1 = find_bezier_t_intersecting_with_closedpath(
+        bezier_point_at_t, inside_closedpath, tolerance=tolerance)
+
+    _left, _right = split_de_casteljau(bezier, (t0 + t1) / 2.)
+    return _left, _right
+
+
+# matplotlib specific
+
+
+def split_path_inout(path, inside, tolerance=0.01, reorder_inout=False):
+    """
+    Divide a path into two segments at the point where ``inside(x, y)`` becomes
+    False.
+    """
+    from .path import Path
+    path_iter = path.iter_segments()
+
+    ctl_points, command = next(path_iter)
+    begin_inside = inside(ctl_points[-2:])  # true if begin point is inside
+
+    ctl_points_old = ctl_points
+
+    iold = 0
+    i = 1
+
+    for ctl_points, command in path_iter:
+        iold = i
+        i += len(ctl_points) // 2
+        if inside(ctl_points[-2:]) != begin_inside:
+            bezier_path = np.concatenate([ctl_points_old[-2:], ctl_points])
+            break
+        ctl_points_old = ctl_points
+    else:
+        raise ValueError("The path does not intersect with the patch")
+
+    bp = bezier_path.reshape((-1, 2))
+    left, right = split_bezier_intersecting_with_closedpath(
+        bp, inside, tolerance)
+    if len(left) == 2:
+        codes_left = [Path.LINETO]
+        codes_right = [Path.MOVETO, Path.LINETO]
+    elif len(left) == 3:
+        codes_left = [Path.CURVE3, Path.CURVE3]
+        codes_right = [Path.MOVETO, Path.CURVE3, Path.CURVE3]
+    elif len(left) == 4:
+        codes_left = [Path.CURVE4, Path.CURVE4, Path.CURVE4]
+        codes_right = [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]
+    else:
+        raise AssertionError("This should never be reached")
+
+    verts_left = left[1:]
+    verts_right = right[:]
+
+    if path.codes is None:
+        path_in = Path(np.concatenate([path.vertices[:i], verts_left]))
+        path_out = Path(np.concatenate([verts_right, path.vertices[i:]]))
+
+    else:
+        path_in = Path(np.concatenate([path.vertices[:iold], verts_left]),
+                       np.concatenate([path.codes[:iold], codes_left]))
+
+        path_out = Path(np.concatenate([verts_right, path.vertices[i:]]),
+                        np.concatenate([codes_right, path.codes[i:]]))
+
+    if reorder_inout and not begin_inside:
+        path_in, path_out = path_out, path_in
+
+    return path_in, path_out
+
+
+def inside_circle(cx, cy, r):
+    """
+    Return a function that checks whether a point is in a circle with center
+    (*cx*, *cy*) and radius *r*.
+
+    The returned function has the signature::
+
+        f(xy: tuple[float, float]) -> bool
+    """
+    r2 = r ** 2
+
+    def _f(xy):
+        x, y = xy
+        return (x - cx) ** 2 + (y - cy) ** 2 < r2
+    return _f
+
+
+# quadratic Bezier lines
+
+def get_cos_sin(x0, y0, x1, y1):
+    dx, dy = x1 - x0, y1 - y0
+    d = (dx * dx + dy * dy) ** .5
+    # Account for divide by zero
+    if d == 0:
+        return 0.0, 0.0
+    return dx / d, dy / d
+
+
+def check_if_parallel(dx1, dy1, dx2, dy2, tolerance=1.e-5):
+    """
+    Check if two lines are parallel.
+
+    Parameters
+    ----------
+    dx1, dy1, dx2, dy2 : float
+        The gradients *dy*/*dx* of the two lines.
+    tolerance : float
+        The angular tolerance in radians up to which the lines are considered
+        parallel.
+
+    Returns
+    -------
+    is_parallel
+        - 1 if two lines are parallel in same direction.
+        - -1 if two lines are parallel in opposite direction.
+        - False otherwise.
+    """
+    theta1 = np.arctan2(dx1, dy1)
+    theta2 = np.arctan2(dx2, dy2)
+    dtheta = abs(theta1 - theta2)
+    if dtheta < tolerance:
+        return 1
+    elif abs(dtheta - np.pi) < tolerance:
+        return -1
+    else:
+        return False
+
+
+def get_parallels(bezier2, width):
+    """
+    Given the quadratic Bézier control points *bezier2*, returns
+    control points of quadratic Bézier lines roughly parallel to given
+    one separated by *width*.
+    """
+
+    # The parallel Bezier lines are constructed by following ways.
+    #  c1 and c2 are control points representing the start and end of the
+    #  Bezier line.
+    #  cm is the middle point
+
+    c1x, c1y = bezier2[0]
+    cmx, cmy = bezier2[1]
+    c2x, c2y = bezier2[2]
+
+    parallel_test = check_if_parallel(c1x - cmx, c1y - cmy,
+                                      cmx - c2x, cmy - c2y)
+
+    if parallel_test == -1:
+        _api.warn_external(
+            "Lines do not intersect. A straight line is used instead.")
+        cos_t1, sin_t1 = get_cos_sin(c1x, c1y, c2x, c2y)
+        cos_t2, sin_t2 = cos_t1, sin_t1
+    else:
+        # t1 and t2 is the angle between c1 and cm, cm, c2.  They are
+        # also an angle of the tangential line of the path at c1 and c2
+        cos_t1, sin_t1 = get_cos_sin(c1x, c1y, cmx, cmy)
+        cos_t2, sin_t2 = get_cos_sin(cmx, cmy, c2x, c2y)
+
+    # find c1_left, c1_right which are located along the lines
+    # through c1 and perpendicular to the tangential lines of the
+    # Bezier path at a distance of width. Same thing for c2_left and
+    # c2_right with respect to c2.
+    c1x_left, c1y_left, c1x_right, c1y_right = (
+        get_normal_points(c1x, c1y, cos_t1, sin_t1, width)
+    )
+    c2x_left, c2y_left, c2x_right, c2y_right = (
+        get_normal_points(c2x, c2y, cos_t2, sin_t2, width)
+    )
+
+    # find cm_left which is the intersecting point of a line through
+    # c1_left with angle t1 and a line through c2_left with angle
+    # t2. Same with cm_right.
+    try:
+        cmx_left, cmy_left = get_intersection(c1x_left, c1y_left, cos_t1,
+                                              sin_t1, c2x_left, c2y_left,
+                                              cos_t2, sin_t2)
+        cmx_right, cmy_right = get_intersection(c1x_right, c1y_right, cos_t1,
+                                                sin_t1, c2x_right, c2y_right,
+                                                cos_t2, sin_t2)
+    except ValueError:
+        # Special case straight lines, i.e., angle between two lines is
+        # less than the threshold used by get_intersection (we don't use
+        # check_if_parallel as the threshold is not the same).
+        cmx_left, cmy_left = (
+            0.5 * (c1x_left + c2x_left), 0.5 * (c1y_left + c2y_left)
+        )
+        cmx_right, cmy_right = (
+            0.5 * (c1x_right + c2x_right), 0.5 * (c1y_right + c2y_right)
+        )
+
+    # the parallel Bezier lines are created with control points of
+    # [c1_left, cm_left, c2_left] and [c1_right, cm_right, c2_right]
+    path_left = [(c1x_left, c1y_left),
+                 (cmx_left, cmy_left),
+                 (c2x_left, c2y_left)]
+    path_right = [(c1x_right, c1y_right),
+                  (cmx_right, cmy_right),
+                  (c2x_right, c2y_right)]
+
+    return path_left, path_right
+
+
+def find_control_points(c1x, c1y, mmx, mmy, c2x, c2y):
+    """
+    Find control points of the Bézier curve passing through (*c1x*, *c1y*),
+    (*mmx*, *mmy*), and (*c2x*, *c2y*), at parametric values 0, 0.5, and 1.
+    """
+    cmx = .5 * (4 * mmx - (c1x + c2x))
+    cmy = .5 * (4 * mmy - (c1y + c2y))
+    return [(c1x, c1y), (cmx, cmy), (c2x, c2y)]
+
+
+def make_wedged_bezier2(bezier2, width, w1=1., wm=0.5, w2=0.):
+    """
+    Being similar to `get_parallels`, returns control points of two quadratic
+    Bézier lines having a width roughly parallel to given one separated by
+    *width*.
+    """
+
+    # c1, cm, c2
+    c1x, c1y = bezier2[0]
+    cmx, cmy = bezier2[1]
+    c3x, c3y = bezier2[2]
+
+    # t1 and t2 is the angle between c1 and cm, cm, c3.
+    # They are also an angle of the tangential line of the path at c1 and c3
+    cos_t1, sin_t1 = get_cos_sin(c1x, c1y, cmx, cmy)
+    cos_t2, sin_t2 = get_cos_sin(cmx, cmy, c3x, c3y)
+
+    # find c1_left, c1_right which are located along the lines
+    # through c1 and perpendicular to the tangential lines of the
+    # Bezier path at a distance of width. Same thing for c3_left and
+    # c3_right with respect to c3.
+    c1x_left, c1y_left, c1x_right, c1y_right = (
+        get_normal_points(c1x, c1y, cos_t1, sin_t1, width * w1)
+    )
+    c3x_left, c3y_left, c3x_right, c3y_right = (
+        get_normal_points(c3x, c3y, cos_t2, sin_t2, width * w2)
+    )
+
+    # find c12, c23 and c123 which are middle points of c1-cm, cm-c3 and
+    # c12-c23
+    c12x, c12y = (c1x + cmx) * .5, (c1y + cmy) * .5
+    c23x, c23y = (cmx + c3x) * .5, (cmy + c3y) * .5
+    c123x, c123y = (c12x + c23x) * .5, (c12y + c23y) * .5
+
+    # tangential angle of c123 (angle between c12 and c23)
+    cos_t123, sin_t123 = get_cos_sin(c12x, c12y, c23x, c23y)
+
+    c123x_left, c123y_left, c123x_right, c123y_right = (
+        get_normal_points(c123x, c123y, cos_t123, sin_t123, width * wm)
+    )
+
+    path_left = find_control_points(c1x_left, c1y_left,
+                                    c123x_left, c123y_left,
+                                    c3x_left, c3y_left)
+    path_right = find_control_points(c1x_right, c1y_right,
+                                     c123x_right, c123y_right,
+                                     c3x_right, c3y_right)
+
+    return path_left, path_right

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/bezier.pyi

@@ -0,0 +1,74 @@
+from collections.abc import Callable
+from typing import Literal
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from .path import Path
+
+class NonIntersectingPathException(ValueError): ...
+
+def get_intersection(
+    cx1: float,
+    cy1: float,
+    cos_t1: float,
+    sin_t1: float,
+    cx2: float,
+    cy2: float,
+    cos_t2: float,
+    sin_t2: float,
+) -> tuple[float, float]: ...
+def get_normal_points(
+    cx: float, cy: float, cos_t: float, sin_t: float, length: float
+) -> tuple[float, float, float, float]: ...
+def split_de_casteljau(beta: ArrayLike, t: float) -> tuple[np.ndarray, np.ndarray]: ...
+def find_bezier_t_intersecting_with_closedpath(
+    bezier_point_at_t: Callable[[float], tuple[float, float]],
+    inside_closedpath: Callable[[tuple[float, float]], bool],
+    t0: float = ...,
+    t1: float = ...,
+    tolerance: float = ...,
+) -> tuple[float, float]: ...
+
+# TODO make generic over d, the dimension? ndarraydim
+class BezierSegment:
+    def __init__(self, control_points: ArrayLike) -> None: ...
+    def __call__(self, t: ArrayLike) -> np.ndarray: ...
+    def point_at_t(self, t: float) -> tuple[float, ...]: ...
+    @property
+    def control_points(self) -> np.ndarray: ...
+    @property
+    def dimension(self) -> int: ...
+    @property
+    def degree(self) -> int: ...
+    @property
+    def polynomial_coefficients(self) -> np.ndarray: ...
+    def axis_aligned_extrema(self) -> tuple[np.ndarray, np.ndarray]: ...
+
+def split_bezier_intersecting_with_closedpath(
+    bezier: ArrayLike,
+    inside_closedpath: Callable[[tuple[float, float]], bool],
+    tolerance: float = ...,
+) -> tuple[np.ndarray, np.ndarray]: ...
+def split_path_inout(
+    path: Path,
+    inside: Callable[[tuple[float, float]], bool],
+    tolerance: float = ...,
+    reorder_inout: bool = ...,
+) -> tuple[Path, Path]: ...
+def inside_circle(
+    cx: float, cy: float, r: float
+) -> Callable[[tuple[float, float]], bool]: ...
+def get_cos_sin(x0: float, y0: float, x1: float, y1: float) -> tuple[float, float]: ...
+def check_if_parallel(
+    dx1: float, dy1: float, dx2: float, dy2: float, tolerance: float = ...
+) -> Literal[-1, False, 1]: ...
+def get_parallels(
+    bezier2: ArrayLike, width: float
+) -> tuple[list[tuple[float, float]], list[tuple[float, float]]]: ...
+def find_control_points(
+    c1x: float, c1y: float, mmx: float, mmy: float, c2x: float, c2y: float
+) -> list[tuple[float, float]]: ...
+def make_wedged_bezier2(
+    bezier2: ArrayLike, width: float, w1: float = ..., wm: float = ..., w2: float = ...
+) -> tuple[list[tuple[float, float]], list[tuple[float, float]]]: ...

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/category.py

@@ -0,0 +1,235 @@
+"""
+Plotting of string "category" data: ``plot(['d', 'f', 'a'], [1, 2, 3])`` will
+plot three points with x-axis values of 'd', 'f', 'a'.
+
+See :doc:`/gallery/lines_bars_and_markers/categorical_variables` for an
+example.
+
+The module uses Matplotlib's `matplotlib.units` mechanism to convert from
+strings to integers and provides a tick locator, a tick formatter, and the
+`.UnitData` class that creates and stores the string-to-integer mapping.
+"""
+
+from collections import OrderedDict
+import dateutil.parser
+import itertools
+import logging
+
+import numpy as np
+
+from matplotlib import _api, cbook, ticker, units
+
+
+_log = logging.getLogger(__name__)
+
+
+class StrCategoryConverter(units.ConversionInterface):
+    @staticmethod
+    def convert(value, unit, axis):
+        """
+        Convert strings in *value* to floats using mapping information stored
+        in the *unit* object.
+
+        Parameters
+        ----------
+        value : str or iterable
+            Value or list of values to be converted.
+        unit : `.UnitData`
+            An object mapping strings to integers.
+        axis : `~matplotlib.axis.Axis`
+            The axis on which the converted value is plotted.
+
+            .. note:: *axis* is unused.
+
+        Returns
+        -------
+        float or `~numpy.ndarray` of float
+        """
+        if unit is None:
+            raise ValueError(
+                'Missing category information for StrCategoryConverter; '
+                'this might be caused by unintendedly mixing categorical and '
+                'numeric data')
+        StrCategoryConverter._validate_unit(unit)
+        # dtype = object preserves numerical pass throughs
+        values = np.atleast_1d(np.array(value, dtype=object))
+        # force an update so it also does type checking
+        unit.update(values)
+        s = np.vectorize(unit._mapping.__getitem__, otypes=[float])(values)
+        return s if not cbook.is_scalar_or_string(value) else s[0]
+
+    @staticmethod
+    def axisinfo(unit, axis):
+        """
+        Set the default axis ticks and labels.
+
+        Parameters
+        ----------
+        unit : `.UnitData`
+            object string unit information for value
+        axis : `~matplotlib.axis.Axis`
+            axis for which information is being set
+
+            .. note:: *axis* is not used
+
+        Returns
+        -------
+        `~matplotlib.units.AxisInfo`
+            Information to support default tick labeling
+
+        """
+        StrCategoryConverter._validate_unit(unit)
+        # locator and formatter take mapping dict because
+        # args need to be pass by reference for updates
+        majloc = StrCategoryLocator(unit._mapping)
+        majfmt = StrCategoryFormatter(unit._mapping)
+        return units.AxisInfo(majloc=majloc, majfmt=majfmt)
+
+    @staticmethod
+    def default_units(data, axis):
+        """
+        Set and update the `~matplotlib.axis.Axis` units.
+
+        Parameters
+        ----------
+        data : str or iterable of str
+        axis : `~matplotlib.axis.Axis`
+            axis on which the data is plotted
+
+        Returns
+        -------
+        `.UnitData`
+            object storing string to integer mapping
+        """
+        # the conversion call stack is default_units -> axis_info -> convert
+        if axis.units is None:
+            axis.set_units(UnitData(data))
+        else:
+            axis.units.update(data)
+        return axis.units
+
+    @staticmethod
+    def _validate_unit(unit):
+        if not hasattr(unit, '_mapping'):
+            raise ValueError(
+                f'Provided unit "{unit}" is not valid for a categorical '
+                'converter, as it does not have a _mapping attribute.')
+
+
+class StrCategoryLocator(ticker.Locator):
+    """Tick at every integer mapping of the string data."""
+    def __init__(self, units_mapping):
+        """
+        Parameters
+        ----------
+        units_mapping : dict
+            Mapping of category names (str) to indices (int).
+        """
+        self._units = units_mapping
+
+    def __call__(self):
+        # docstring inherited
+        return list(self._units.values())
+
+    def tick_values(self, vmin, vmax):
+        # docstring inherited
+        return self()
+
+
+class StrCategoryFormatter(ticker.Formatter):
+    """String representation of the data at every tick."""
+    def __init__(self, units_mapping):
+        """
+        Parameters
+        ----------
+        units_mapping : dict
+            Mapping of category names (str) to indices (int).
+        """
+        self._units = units_mapping
+
+    def __call__(self, x, pos=None):
+        # docstring inherited
+        return self.format_ticks([x])[0]
+
+    def format_ticks(self, values):
+        # docstring inherited
+        r_mapping = {v: self._text(k) for k, v in self._units.items()}
+        return [r_mapping.get(round(val), '') for val in values]
+
+    @staticmethod
+    def _text(value):
+        """Convert text values into utf-8 or ascii strings."""
+        if isinstance(value, bytes):
+            value = value.decode(encoding='utf-8')
+        elif not isinstance(value, str):
+            value = str(value)
+        return value
+
+
+class UnitData:
+    def __init__(self, data=None):
+        """
+        Create mapping between unique categorical values and integer ids.
+
+        Parameters
+        ----------
+        data : iterable
+            sequence of string values
+        """
+        self._mapping = OrderedDict()
+        self._counter = itertools.count()
+        if data is not None:
+            self.update(data)
+
+    @staticmethod
+    def _str_is_convertible(val):
+        """
+        Helper method to check whether a string can be parsed as float or date.
+        """
+        try:
+            float(val)
+        except ValueError:
+            try:
+                dateutil.parser.parse(val)
+            except (ValueError, TypeError):
+                # TypeError if dateutil >= 2.8.1 else ValueError
+                return False
+        return True
+
+    def update(self, data):
+        """
+        Map new values to integer identifiers.
+
+        Parameters
+        ----------
+        data : iterable of str or bytes
+
+        Raises
+        ------
+        TypeError
+            If elements in *data* are neither str nor bytes.
+        """
+        data = np.atleast_1d(np.array(data, dtype=object))
+        # check if convertible to number:
+        convertible = True
+        for val in OrderedDict.fromkeys(data):
+            # OrderedDict just iterates over unique values in data.
+            _api.check_isinstance((str, bytes), value=val)
+            if convertible:
+                # this will only be called so long as convertible is True.
+                convertible = self._str_is_convertible(val)
+            if val not in self._mapping:
+                self._mapping[val] = next(self._counter)
+        if data.size and convertible:
+            _log.info('Using categorical units to plot a list of strings '
+                      'that are all parsable as floats or dates. If these '
+                      'strings should be plotted as numbers, cast to the '
+                      'appropriate data type before plotting.')
+
+
+# Register the converter with Matplotlib's unit framework
+# Intentionally set to a single instance
+units.registry[str] = \
+    units.registry[np.str_] = \
+    units.registry[bytes] = \
+    units.registry[np.bytes_] = StrCategoryConverter()

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/cbook.py

@@ -0,0 +1,2419 @@
+"""
+A collection of utility functions and classes.  Originally, many
+(but not all) were from the Python Cookbook -- hence the name cbook.
+"""
+
+import collections
+import collections.abc
+import contextlib
+import functools
+import gzip
+import itertools
+import math
+import operator
+import os
+from pathlib import Path
+import shlex
+import subprocess
+import sys
+import time
+import traceback
+import types
+import weakref
+
+import numpy as np
+
+try:
+    from numpy.exceptions import VisibleDeprecationWarning  # numpy >= 1.25
+except ImportError:
+    from numpy import VisibleDeprecationWarning
+
+import matplotlib
+from matplotlib import _api, _c_internal_utils
+
+
+class _ExceptionInfo:
+    """
+    A class to carry exception information around.
+
+    This is used to store and later raise exceptions. It's an alternative to
+    directly storing Exception instances that circumvents traceback-related
+    issues: caching tracebacks can keep user's objects in local namespaces
+    alive indefinitely, which can lead to very surprising memory issues for
+    users and result in incorrect tracebacks.
+    """
+
+    def __init__(self, cls, *args):
+        self._cls = cls
+        self._args = args
+
+    @classmethod
+    def from_exception(cls, exc):
+        return cls(type(exc), *exc.args)
+
+    def to_exception(self):
+        return self._cls(*self._args)
+
+
+def _get_running_interactive_framework():
+    """
+    Return the interactive framework whose event loop is currently running, if
+    any, or "headless" if no event loop can be started, or None.
+
+    Returns
+    -------
+    Optional[str]
+        One of the following values: "qt", "gtk3", "gtk4", "wx", "tk",
+        "macosx", "headless", ``None``.
+    """
+    # Use ``sys.modules.get(name)`` rather than ``name in sys.modules`` as
+    # entries can also have been explicitly set to None.
+    QtWidgets = (
+        sys.modules.get("PyQt6.QtWidgets")
+        or sys.modules.get("PySide6.QtWidgets")
+        or sys.modules.get("PyQt5.QtWidgets")
+        or sys.modules.get("PySide2.QtWidgets")
+    )
+    if QtWidgets and QtWidgets.QApplication.instance():
+        return "qt"
+    Gtk = sys.modules.get("gi.repository.Gtk")
+    if Gtk:
+        if Gtk.MAJOR_VERSION == 4:
+            from gi.repository import GLib
+            if GLib.main_depth():
+                return "gtk4"
+        if Gtk.MAJOR_VERSION == 3 and Gtk.main_level():
+            return "gtk3"
+    wx = sys.modules.get("wx")
+    if wx and wx.GetApp():
+        return "wx"
+    tkinter = sys.modules.get("tkinter")
+    if tkinter:
+        codes = {tkinter.mainloop.__code__, tkinter.Misc.mainloop.__code__}
+        for frame in sys._current_frames().values():
+            while frame:
+                if frame.f_code in codes:
+                    return "tk"
+                frame = frame.f_back
+        # Preemptively break reference cycle between locals and the frame.
+        del frame
+    macosx = sys.modules.get("matplotlib.backends._macosx")
+    if macosx and macosx.event_loop_is_running():
+        return "macosx"
+    if not _c_internal_utils.display_is_valid():
+        return "headless"
+    return None
+
+
+def _exception_printer(exc):
+    if _get_running_interactive_framework() in ["headless", None]:
+        raise exc
+    else:
+        traceback.print_exc()
+
+
+class _StrongRef:
+    """
+    Wrapper similar to a weakref, but keeping a strong reference to the object.
+    """
+
+    def __init__(self, obj):
+        self._obj = obj
+
+    def __call__(self):
+        return self._obj
+
+    def __eq__(self, other):
+        return isinstance(other, _StrongRef) and self._obj == other._obj
+
+    def __hash__(self):
+        return hash(self._obj)
+
+
+def _weak_or_strong_ref(func, callback):
+    """
+    Return a `WeakMethod` wrapping *func* if possible, else a `_StrongRef`.
+    """
+    try:
+        return weakref.WeakMethod(func, callback)
+    except TypeError:
+        return _StrongRef(func)
+
+
+class _UnhashDict:
+    """
+    A minimal dict-like class that also supports unhashable keys, storing them
+    in a list of key-value pairs.
+
+    This class only implements the interface needed for `CallbackRegistry`, and
+    tries to minimize the overhead for the hashable case.
+    """
+
+    def __init__(self, pairs):
+        self._dict = {}
+        self._pairs = []
+        for k, v in pairs:
+            self[k] = v
+
+    def __setitem__(self, key, value):
+        try:
+            self._dict[key] = value
+        except TypeError:
+            for i, (k, v) in enumerate(self._pairs):
+                if k == key:
+                    self._pairs[i] = (key, value)
+                    break
+            else:
+                self._pairs.append((key, value))
+
+    def __getitem__(self, key):
+        try:
+            return self._dict[key]
+        except TypeError:
+            pass
+        for k, v in self._pairs:
+            if k == key:
+                return v
+        raise KeyError(key)
+
+    def pop(self, key, *args):
+        try:
+            if key in self._dict:
+                return self._dict.pop(key)
+        except TypeError:
+            for i, (k, v) in enumerate(self._pairs):
+                if k == key:
+                    del self._pairs[i]
+                    return v
+        if args:
+            return args[0]
+        raise KeyError(key)
+
+    def __iter__(self):
+        yield from self._dict
+        for k, v in self._pairs:
+            yield k
+
+
+class CallbackRegistry:
+    """
+    Handle registering, processing, blocking, and disconnecting
+    for a set of signals and callbacks:
+
+        >>> def oneat(x):
+        ...     print('eat', x)
+        >>> def ondrink(x):
+        ...     print('drink', x)
+
+        >>> from matplotlib.cbook import CallbackRegistry
+        >>> callbacks = CallbackRegistry()
+
+        >>> id_eat = callbacks.connect('eat', oneat)
+        >>> id_drink = callbacks.connect('drink', ondrink)
+
+        >>> callbacks.process('drink', 123)
+        drink 123
+        >>> callbacks.process('eat', 456)
+        eat 456
+        >>> callbacks.process('be merry', 456)   # nothing will be called
+
+        >>> callbacks.disconnect(id_eat)
+        >>> callbacks.process('eat', 456)        # nothing will be called
+
+        >>> with callbacks.blocked(signal='drink'):
+        ...     callbacks.process('drink', 123)  # nothing will be called
+        >>> callbacks.process('drink', 123)
+        drink 123
+
+    In practice, one should always disconnect all callbacks when they are
+    no longer needed to avoid dangling references (and thus memory leaks).
+    However, real code in Matplotlib rarely does so, and due to its design,
+    it is rather difficult to place this kind of code.  To get around this,
+    and prevent this class of memory leaks, we instead store weak references
+    to bound methods only, so when the destination object needs to die, the
+    CallbackRegistry won't keep it alive.
+
+    Parameters
+    ----------
+    exception_handler : callable, optional
+       If not None, *exception_handler* must be a function that takes an
+       `Exception` as single parameter.  It gets called with any `Exception`
+       raised by the callbacks during `CallbackRegistry.process`, and may
+       either re-raise the exception or handle it in another manner.
+
+       The default handler prints the exception (with `traceback.print_exc`) if
+       an interactive event loop is running; it re-raises the exception if no
+       interactive event loop is running.
+
+    signals : list, optional
+        If not None, *signals* is a list of signals that this registry handles:
+        attempting to `process` or to `connect` to a signal not in the list
+        throws a `ValueError`.  The default, None, does not restrict the
+        handled signals.
+    """
+
+    # We maintain two mappings:
+    #   callbacks: signal -> {cid -> weakref-to-callback}
+    #   _func_cid_map: {(signal, weakref-to-callback) -> cid}
+
+    def __init__(self, exception_handler=_exception_printer, *, signals=None):
+        self._signals = None if signals is None else list(signals)  # Copy it.
+        self.exception_handler = exception_handler
+        self.callbacks = {}
+        self._cid_gen = itertools.count()
+        self._func_cid_map = _UnhashDict([])
+        # A hidden variable that marks cids that need to be pickled.
+        self._pickled_cids = set()
+
+    def __getstate__(self):
+        return {
+            **vars(self),
+            # In general, callbacks may not be pickled, so we just drop them,
+            # unless directed otherwise by self._pickled_cids.
+            "callbacks": {s: {cid: proxy() for cid, proxy in d.items()
+                              if cid in self._pickled_cids}
+                          for s, d in self.callbacks.items()},
+            # It is simpler to reconstruct this from callbacks in __setstate__.
+            "_func_cid_map": None,
+            "_cid_gen": next(self._cid_gen)
+        }
+
+    def __setstate__(self, state):
+        cid_count = state.pop('_cid_gen')
+        vars(self).update(state)
+        self.callbacks = {
+            s: {cid: _weak_or_strong_ref(func, functools.partial(self._remove_proxy, s))
+                for cid, func in d.items()}
+            for s, d in self.callbacks.items()}
+        self._func_cid_map = _UnhashDict(
+            ((s, proxy), cid)
+            for s, d in self.callbacks.items() for cid, proxy in d.items())
+        self._cid_gen = itertools.count(cid_count)
+
+    def connect(self, signal, func):
+        """Register *func* to be called when signal *signal* is generated."""
+        if self._signals is not None:
+            _api.check_in_list(self._signals, signal=signal)
+        proxy = _weak_or_strong_ref(func, functools.partial(self._remove_proxy, signal))
+        try:
+            return self._func_cid_map[signal, proxy]
+        except KeyError:
+            cid = self._func_cid_map[signal, proxy] = next(self._cid_gen)
+            self.callbacks.setdefault(signal, {})[cid] = proxy
+            return cid
+
+    def _connect_picklable(self, signal, func):
+        """
+        Like `.connect`, but the callback is kept when pickling/unpickling.
+
+        Currently internal-use only.
+        """
+        cid = self.connect(signal, func)
+        self._pickled_cids.add(cid)
+        return cid
+
+    # Keep a reference to sys.is_finalizing, as sys may have been cleared out
+    # at that point.
+    def _remove_proxy(self, signal, proxy, *, _is_finalizing=sys.is_finalizing):
+        if _is_finalizing():
+            # Weakrefs can't be properly torn down at that point anymore.
+            return
+        cid = self._func_cid_map.pop((signal, proxy), None)
+        if cid is not None:
+            del self.callbacks[signal][cid]
+            self._pickled_cids.discard(cid)
+        else:  # Not found
+            return
+        if len(self.callbacks[signal]) == 0:  # Clean up empty dicts
+            del self.callbacks[signal]
+
+    def disconnect(self, cid):
+        """
+        Disconnect the callback registered with callback id *cid*.
+
+        No error is raised if such a callback does not exist.
+        """
+        self._pickled_cids.discard(cid)
+        for signal, proxy in self._func_cid_map:
+            if self._func_cid_map[signal, proxy] == cid:
+                break
+        else:  # Not found
+            return
+        assert self.callbacks[signal][cid] == proxy
+        del self.callbacks[signal][cid]
+        self._func_cid_map.pop((signal, proxy))
+        if len(self.callbacks[signal]) == 0:  # Clean up empty dicts
+            del self.callbacks[signal]
+
+    def process(self, s, *args, **kwargs):
+        """
+        Process signal *s*.
+
+        All of the functions registered to receive callbacks on *s* will be
+        called with ``*args`` and ``**kwargs``.
+        """
+        if self._signals is not None:
+            _api.check_in_list(self._signals, signal=s)
+        for ref in list(self.callbacks.get(s, {}).values()):
+            func = ref()
+            if func is not None:
+                try:
+                    func(*args, **kwargs)
+                # this does not capture KeyboardInterrupt, SystemExit,
+                # and GeneratorExit
+                except Exception as exc:
+                    if self.exception_handler is not None:
+                        self.exception_handler(exc)
+                    else:
+                        raise
+
+    @contextlib.contextmanager
+    def blocked(self, *, signal=None):
+        """
+        Block callback signals from being processed.
+
+        A context manager to temporarily block/disable callback signals
+        from being processed by the registered listeners.
+
+        Parameters
+        ----------
+        signal : str, optional
+            The callback signal to block. The default is to block all signals.
+        """
+        orig = self.callbacks
+        try:
+            if signal is None:
+                # Empty out the callbacks
+                self.callbacks = {}
+            else:
+                # Only remove the specific signal
+                self.callbacks = {k: orig[k] for k in orig if k != signal}
+            yield
+        finally:
+            self.callbacks = orig
+
+
+class silent_list(list):
+    """
+    A list with a short ``repr()``.
+
+    This is meant to be used for a homogeneous list of artists, so that they
+    don't cause long, meaningless output.
+
+    Instead of ::
+
+        [<matplotlib.lines.Line2D object at 0x7f5749fed3c8>,
+         <matplotlib.lines.Line2D object at 0x7f5749fed4e0>,
+         <matplotlib.lines.Line2D object at 0x7f5758016550>]
+
+    one will get ::
+
+        <a list of 3 Line2D objects>
+
+    If ``self.type`` is None, the type name is obtained from the first item in
+    the list (if any).
+    """
+
+    def __init__(self, type, seq=None):
+        self.type = type
+        if seq is not None:
+            self.extend(seq)
+
+    def __repr__(self):
+        if self.type is not None or len(self) != 0:
+            tp = self.type if self.type is not None else type(self[0]).__name__
+            return f"<a list of {len(self)} {tp} objects>"
+        else:
+            return "<an empty list>"
+
+
+def _local_over_kwdict(
+        local_var, kwargs, *keys,
+        warning_cls=_api.MatplotlibDeprecationWarning):
+    out = local_var
+    for key in keys:
+        kwarg_val = kwargs.pop(key, None)
+        if kwarg_val is not None:
+            if out is None:
+                out = kwarg_val
+            else:
+                _api.warn_external(f'"{key}" keyword argument will be ignored',
+                                   warning_cls)
+    return out
+
+
+def strip_math(s):
+    """
+    Remove latex formatting from mathtext.
+
+    Only handles fully math and fully non-math strings.
+    """
+    if len(s) >= 2 and s[0] == s[-1] == "$":
+        s = s[1:-1]
+        for tex, plain in [
+                (r"\times", "x"),  # Specifically for Formatter support.
+                (r"\mathdefault", ""),
+                (r"\rm", ""),
+                (r"\cal", ""),
+                (r"\tt", ""),
+                (r"\it", ""),
+                ("\\", ""),
+                ("{", ""),
+                ("}", ""),
+        ]:
+            s = s.replace(tex, plain)
+    return s
+
+
+def _strip_comment(s):
+    """Strip everything from the first unquoted #."""
+    pos = 0
+    while True:
+        quote_pos = s.find('"', pos)
+        hash_pos = s.find('#', pos)
+        if quote_pos < 0:
+            without_comment = s if hash_pos < 0 else s[:hash_pos]
+            return without_comment.strip()
+        elif 0 <= hash_pos < quote_pos:
+            return s[:hash_pos].strip()
+        else:
+            closing_quote_pos = s.find('"', quote_pos + 1)
+            if closing_quote_pos < 0:
+                raise ValueError(
+                    f"Missing closing quote in: {s!r}. If you need a double-"
+                    'quote inside a string, use escaping: e.g. "the \" char"')
+            pos = closing_quote_pos + 1  # behind closing quote
+
+
+def is_writable_file_like(obj):
+    """Return whether *obj* looks like a file object with a *write* method."""
+    return callable(getattr(obj, 'write', None))
+
+
+def file_requires_unicode(x):
+    """
+    Return whether the given writable file-like object requires Unicode to be
+    written to it.
+    """
+    try:
+        x.write(b'')
+    except TypeError:
+        return True
+    else:
+        return False
+
+
+def to_filehandle(fname, flag='r', return_opened=False, encoding=None):
+    """
+    Convert a path to an open file handle or pass-through a file-like object.
+
+    Consider using `open_file_cm` instead, as it allows one to properly close
+    newly created file objects more easily.
+
+    Parameters
+    ----------
+    fname : str or path-like or file-like
+        If `str` or `os.PathLike`, the file is opened using the flags specified
+        by *flag* and *encoding*.  If a file-like object, it is passed through.
+    flag : str, default: 'r'
+        Passed as the *mode* argument to `open` when *fname* is `str` or
+        `os.PathLike`; ignored if *fname* is file-like.
+    return_opened : bool, default: False
+        If True, return both the file object and a boolean indicating whether
+        this was a new file (that the caller needs to close).  If False, return
+        only the new file.
+    encoding : str or None, default: None
+        Passed as the *mode* argument to `open` when *fname* is `str` or
+        `os.PathLike`; ignored if *fname* is file-like.
+
+    Returns
+    -------
+    fh : file-like
+    opened : bool
+        *opened* is only returned if *return_opened* is True.
+    """
+    if isinstance(fname, os.PathLike):
+        fname = os.fspath(fname)
+    if isinstance(fname, str):
+        if fname.endswith('.gz'):
+            fh = gzip.open(fname, flag)
+        elif fname.endswith('.bz2'):
+            # python may not be compiled with bz2 support,
+            # bury import until we need it
+            import bz2
+            fh = bz2.BZ2File(fname, flag)
+        else:
+            fh = open(fname, flag, encoding=encoding)
+        opened = True
+    elif hasattr(fname, 'seek'):
+        fh = fname
+        opened = False
+    else:
+        raise ValueError('fname must be a PathLike or file handle')
+    if return_opened:
+        return fh, opened
+    return fh
+
+
+def open_file_cm(path_or_file, mode="r", encoding=None):
+    r"""Pass through file objects and context-manage path-likes."""
+    fh, opened = to_filehandle(path_or_file, mode, True, encoding)
+    return fh if opened else contextlib.nullcontext(fh)
+
+
+def is_scalar_or_string(val):
+    """Return whether the given object is a scalar or string like."""
+    return isinstance(val, str) or not np.iterable(val)
+
+
+def get_sample_data(fname, asfileobj=True):
+    """
+    Return a sample data file.  *fname* is a path relative to the
+    :file:`mpl-data/sample_data` directory.  If *asfileobj* is `True`
+    return a file object, otherwise just a file path.
+
+    Sample data files are stored in the 'mpl-data/sample_data' directory within
+    the Matplotlib package.
+
+    If the filename ends in .gz, the file is implicitly ungzipped.  If the
+    filename ends with .npy or .npz, and *asfileobj* is `True`, the file is
+    loaded with `numpy.load`.
+    """
+    path = _get_data_path('sample_data', fname)
+    if asfileobj:
+        suffix = path.suffix.lower()
+        if suffix == '.gz':
+            return gzip.open(path)
+        elif suffix in ['.npy', '.npz']:
+            return np.load(path)
+        elif suffix in ['.csv', '.xrc', '.txt']:
+            return path.open('r')
+        else:
+            return path.open('rb')
+    else:
+        return str(path)
+
+
+def _get_data_path(*args):
+    """
+    Return the `pathlib.Path` to a resource file provided by Matplotlib.
+
+    ``*args`` specify a path relative to the base data path.
+    """
+    return Path(matplotlib.get_data_path(), *args)
+
+
+def flatten(seq, scalarp=is_scalar_or_string):
+    """
+    Return a generator of flattened nested containers.
+
+    For example:
+
+        >>> from matplotlib.cbook import flatten
+        >>> l = (('John', ['Hunter']), (1, 23), [[([42, (5, 23)], )]])
+        >>> print(list(flatten(l)))
+        ['John', 'Hunter', 1, 23, 42, 5, 23]
+
+    By: Composite of Holger Krekel and Luther Blissett
+    From: https://code.activestate.com/recipes/121294-simple-generator-for-flattening-nested-containers/
+    and Recipe 1.12 in cookbook
+    """  # noqa: E501
+    for item in seq:
+        if scalarp(item) or item is None:
+            yield item
+        else:
+            yield from flatten(item, scalarp)
+
+
+class _Stack:
+    """
+    Stack of elements with a movable cursor.
+
+    Mimics home/back/forward in a web browser.
+    """
+
+    def __init__(self):
+        self._pos = -1
+        self._elements = []
+
+    def clear(self):
+        """Empty the stack."""
+        self._pos = -1
+        self._elements = []
+
+    def __call__(self):
+        """Return the current element, or None."""
+        return self._elements[self._pos] if self._elements else None
+
+    def __len__(self):
+        return len(self._elements)
+
+    def __getitem__(self, ind):
+        return self._elements[ind]
+
+    def forward(self):
+        """Move the position forward and return the current element."""
+        self._pos = min(self._pos + 1, len(self._elements) - 1)
+        return self()
+
+    def back(self):
+        """Move the position back and return the current element."""
+        self._pos = max(self._pos - 1, 0)
+        return self()
+
+    def push(self, o):
+        """
+        Push *o* to the stack after the current position, and return *o*.
+
+        Discard all later elements.
+        """
+        self._elements[self._pos + 1:] = [o]
+        self._pos = len(self._elements) - 1
+        return o
+
+    def home(self):
+        """
+        Push the first element onto the top of the stack.
+
+        The first element is returned.
+        """
+        return self.push(self._elements[0]) if self._elements else None
+
+
+def safe_masked_invalid(x, copy=False):
+    x = np.array(x, subok=True, copy=copy)
+    if not x.dtype.isnative:
+        # If we have already made a copy, do the byteswap in place, else make a
+        # copy with the byte order swapped.
+        # Swap to native order.
+        x = x.byteswap(inplace=copy).view(x.dtype.newbyteorder('N'))
+    try:
+        xm = np.ma.masked_where(~(np.isfinite(x)), x, copy=False)
+    except TypeError:
+        return x
+    return xm
+
+
+def print_cycles(objects, outstream=sys.stdout, show_progress=False):
+    """
+    Print loops of cyclic references in the given *objects*.
+
+    It is often useful to pass in ``gc.garbage`` to find the cycles that are
+    preventing some objects from being garbage collected.
+
+    Parameters
+    ----------
+    objects
+        A list of objects to find cycles in.
+    outstream
+        The stream for output.
+    show_progress : bool
+        If True, print the number of objects reached as they are found.
+    """
+    import gc
+
+    def print_path(path):
+        for i, step in enumerate(path):
+            # next "wraps around"
+            next = path[(i + 1) % len(path)]
+
+            outstream.write("   %s -- " % type(step))
+            if isinstance(step, dict):
+                for key, val in step.items():
+                    if val is next:
+                        outstream.write(f"[{key!r}]")
+                        break
+                    if key is next:
+                        outstream.write(f"[key] = {val!r}")
+                        break
+            elif isinstance(step, list):
+                outstream.write("[%d]" % step.index(next))
+            elif isinstance(step, tuple):
+                outstream.write("( tuple )")
+            else:
+                outstream.write(repr(step))
+            outstream.write(" ->\n")
+        outstream.write("\n")
+
+    def recurse(obj, start, all, current_path):
+        if show_progress:
+            outstream.write("%d\r" % len(all))
+
+        all[id(obj)] = None
+
+        referents = gc.get_referents(obj)
+        for referent in referents:
+            # If we've found our way back to the start, this is
+            # a cycle, so print it out
+            if referent is start:
+                print_path(current_path)
+
+            # Don't go back through the original list of objects, or
+            # through temporary references to the object, since those
+            # are just an artifact of the cycle detector itself.
+            elif referent is objects or isinstance(referent, types.FrameType):
+                continue
+
+            # We haven't seen this object before, so recurse
+            elif id(referent) not in all:
+                recurse(referent, start, all, current_path + [obj])
+
+    for obj in objects:
+        outstream.write(f"Examining: {obj!r}\n")
+        recurse(obj, obj, {}, [])
+
+
+class Grouper:
+    """
+    A disjoint-set data structure.
+
+    Objects can be joined using :meth:`join`, tested for connectedness
+    using :meth:`joined`, and all disjoint sets can be retrieved by
+    using the object as an iterator.
+
+    The objects being joined must be hashable and weak-referenceable.
+
+    Examples
+    --------
+    >>> from matplotlib.cbook import Grouper
+    >>> class Foo:
+    ...     def __init__(self, s):
+    ...         self.s = s
+    ...     def __repr__(self):
+    ...         return self.s
+    ...
+    >>> a, b, c, d, e, f = [Foo(x) for x in 'abcdef']
+    >>> grp = Grouper()
+    >>> grp.join(a, b)
+    >>> grp.join(b, c)
+    >>> grp.join(d, e)
+    >>> list(grp)
+    [[a, b, c], [d, e]]
+    >>> grp.joined(a, b)
+    True
+    >>> grp.joined(a, c)
+    True
+    >>> grp.joined(a, d)
+    False
+    """
+
+    def __init__(self, init=()):
+        self._mapping = weakref.WeakKeyDictionary(
+            {x: weakref.WeakSet([x]) for x in init})
+        self._ordering = weakref.WeakKeyDictionary()
+        for x in init:
+            if x not in self._ordering:
+                self._ordering[x] = len(self._ordering)
+        self._next_order = len(self._ordering)  # Plain int to simplify pickling.
+
+    def __getstate__(self):
+        return {
+            **vars(self),
+            # Convert weak refs to strong ones.
+            "_mapping": {k: set(v) for k, v in self._mapping.items()},
+            "_ordering": {**self._ordering},
+        }
+
+    def __setstate__(self, state):
+        vars(self).update(state)
+        # Convert strong refs to weak ones.
+        self._mapping = weakref.WeakKeyDictionary(
+            {k: weakref.WeakSet(v) for k, v in self._mapping.items()})
+        self._ordering = weakref.WeakKeyDictionary(self._ordering)
+
+    def __contains__(self, item):
+        return item in self._mapping
+
+    def join(self, a, *args):
+        """
+        Join given arguments into the same set.  Accepts one or more arguments.
+        """
+        mapping = self._mapping
+        try:
+            set_a = mapping[a]
+        except KeyError:
+            set_a = mapping[a] = weakref.WeakSet([a])
+            self._ordering[a] = self._next_order
+            self._next_order += 1
+        for arg in args:
+            try:
+                set_b = mapping[arg]
+            except KeyError:
+                set_b = mapping[arg] = weakref.WeakSet([arg])
+                self._ordering[arg] = self._next_order
+                self._next_order += 1
+            if set_b is not set_a:
+                if len(set_b) > len(set_a):
+                    set_a, set_b = set_b, set_a
+                set_a.update(set_b)
+                for elem in set_b:
+                    mapping[elem] = set_a
+
+    def joined(self, a, b):
+        """Return whether *a* and *b* are members of the same set."""
+        return (self._mapping.get(a, object()) is self._mapping.get(b))
+
+    def remove(self, a):
+        """Remove *a* from the grouper, doing nothing if it is not there."""
+        self._mapping.pop(a, {a}).remove(a)
+        self._ordering.pop(a, None)
+
+    def __iter__(self):
+        """
+        Iterate over each of the disjoint sets as a list.
+
+        The iterator is invalid if interleaved with calls to join().
+        """
+        unique_groups = {id(group): group for group in self._mapping.values()}
+        for group in unique_groups.values():
+            yield sorted(group, key=self._ordering.__getitem__)
+
+    def get_siblings(self, a):
+        """Return all of the items joined with *a*, including itself."""
+        siblings = self._mapping.get(a, [a])
+        return sorted(siblings, key=self._ordering.get)
+
+
+class GrouperView:
+    """Immutable view over a `.Grouper`."""
+
+    def __init__(self, grouper): self._grouper = grouper
+    def __contains__(self, item): return item in self._grouper
+    def __iter__(self): return iter(self._grouper)
+
+    def joined(self, a, b):
+        """
+        Return whether *a* and *b* are members of the same set.
+        """
+        return self._grouper.joined(a, b)
+
+    def get_siblings(self, a):
+        """
+        Return all of the items joined with *a*, including itself.
+        """
+        return self._grouper.get_siblings(a)
+
+
+def simple_linear_interpolation(a, steps):
+    """
+    Resample an array with ``steps - 1`` points between original point pairs.
+
+    Along each column of *a*, ``(steps - 1)`` points are introduced between
+    each original values; the values are linearly interpolated.
+
+    Parameters
+    ----------
+    a : array, shape (n, ...)
+    steps : int
+
+    Returns
+    -------
+    array
+        shape ``((n - 1) * steps + 1, ...)``
+    """
+    fps = a.reshape((len(a), -1))
+    xp = np.arange(len(a)) * steps
+    x = np.arange((len(a) - 1) * steps + 1)
+    return (np.column_stack([np.interp(x, xp, fp) for fp in fps.T])
+            .reshape((len(x),) + a.shape[1:]))
+
+
+def delete_masked_points(*args):
+    """
+    Find all masked and/or non-finite points in a set of arguments,
+    and return the arguments with only the unmasked points remaining.
+
+    Arguments can be in any of 5 categories:
+
+    1) 1-D masked arrays
+    2) 1-D ndarrays
+    3) ndarrays with more than one dimension
+    4) other non-string iterables
+    5) anything else
+
+    The first argument must be in one of the first four categories;
+    any argument with a length differing from that of the first
+    argument (and hence anything in category 5) then will be
+    passed through unchanged.
+
+    Masks are obtained from all arguments of the correct length
+    in categories 1, 2, and 4; a point is bad if masked in a masked
+    array or if it is a nan or inf.  No attempt is made to
+    extract a mask from categories 2, 3, and 4 if `numpy.isfinite`
+    does not yield a Boolean array.
+
+    All input arguments that are not passed unchanged are returned
+    as ndarrays after removing the points or rows corresponding to
+    masks in any of the arguments.
+
+    A vastly simpler version of this function was originally
+    written as a helper for Axes.scatter().
+
+    """
+    if not len(args):
+        return ()
+    if is_scalar_or_string(args[0]):
+        raise ValueError("First argument must be a sequence")
+    nrecs = len(args[0])
+    margs = []
+    seqlist = [False] * len(args)
+    for i, x in enumerate(args):
+        if not isinstance(x, str) and np.iterable(x) and len(x) == nrecs:
+            seqlist[i] = True
+            if isinstance(x, np.ma.MaskedArray):
+                if x.ndim > 1:
+                    raise ValueError("Masked arrays must be 1-D")
+            else:
+                x = np.asarray(x)
+        margs.append(x)
+    masks = []  # List of masks that are True where good.
+    for i, x in enumerate(margs):
+        if seqlist[i]:
+            if x.ndim > 1:
+                continue  # Don't try to get nan locations unless 1-D.
+            if isinstance(x, np.ma.MaskedArray):
+                masks.append(~np.ma.getmaskarray(x))  # invert the mask
+                xd = x.data
+            else:
+                xd = x
+            try:
+                mask = np.isfinite(xd)
+                if isinstance(mask, np.ndarray):
+                    masks.append(mask)
+            except Exception:  # Fixme: put in tuple of possible exceptions?
+                pass
+    if len(masks):
+        mask = np.logical_and.reduce(masks)
+        igood = mask.nonzero()[0]
+        if len(igood) < nrecs:
+            for i, x in enumerate(margs):
+                if seqlist[i]:
+                    margs[i] = x[igood]
+    for i, x in enumerate(margs):
+        if seqlist[i] and isinstance(x, np.ma.MaskedArray):
+            margs[i] = x.filled()
+    return margs
+
+
+def _combine_masks(*args):
+    """
+    Find all masked and/or non-finite points in a set of arguments,
+    and return the arguments as masked arrays with a common mask.
+
+    Arguments can be in any of 5 categories:
+
+    1) 1-D masked arrays
+    2) 1-D ndarrays
+    3) ndarrays with more than one dimension
+    4) other non-string iterables
+    5) anything else
+
+    The first argument must be in one of the first four categories;
+    any argument with a length differing from that of the first
+    argument (and hence anything in category 5) then will be
+    passed through unchanged.
+
+    Masks are obtained from all arguments of the correct length
+    in categories 1, 2, and 4; a point is bad if masked in a masked
+    array or if it is a nan or inf.  No attempt is made to
+    extract a mask from categories 2 and 4 if `numpy.isfinite`
+    does not yield a Boolean array.  Category 3 is included to
+    support RGB or RGBA ndarrays, which are assumed to have only
+    valid values and which are passed through unchanged.
+
+    All input arguments that are not passed unchanged are returned
+    as masked arrays if any masked points are found, otherwise as
+    ndarrays.
+
+    """
+    if not len(args):
+        return ()
+    if is_scalar_or_string(args[0]):
+        raise ValueError("First argument must be a sequence")
+    nrecs = len(args[0])
+    margs = []  # Output args; some may be modified.
+    seqlist = [False] * len(args)  # Flags: True if output will be masked.
+    masks = []    # List of masks.
+    for i, x in enumerate(args):
+        if is_scalar_or_string(x) or len(x) != nrecs:
+            margs.append(x)  # Leave it unmodified.
+        else:
+            if isinstance(x, np.ma.MaskedArray) and x.ndim > 1:
+                raise ValueError("Masked arrays must be 1-D")
+            try:
+                x = np.asanyarray(x)
+            except (VisibleDeprecationWarning, ValueError):
+                # NumPy 1.19 raises a warning about ragged arrays, but we want
+                # to accept basically anything here.
+                x = np.asanyarray(x, dtype=object)
+            if x.ndim == 1:
+                x = safe_masked_invalid(x)
+                seqlist[i] = True
+                if np.ma.is_masked(x):
+                    masks.append(np.ma.getmaskarray(x))
+            margs.append(x)  # Possibly modified.
+    if len(masks):
+        mask = np.logical_or.reduce(masks)
+        for i, x in enumerate(margs):
+            if seqlist[i]:
+                margs[i] = np.ma.array(x, mask=mask)
+    return margs
+
+
+def _broadcast_with_masks(*args, compress=False):
+    """
+    Broadcast inputs, combining all masked arrays.
+
+    Parameters
+    ----------
+    *args : array-like
+        The inputs to broadcast.
+    compress : bool, default: False
+        Whether to compress the masked arrays. If False, the masked values
+        are replaced by NaNs.
+
+    Returns
+    -------
+    list of array-like
+        The broadcasted and masked inputs.
+    """
+    # extract the masks, if any
+    masks = [k.mask for k in args if isinstance(k, np.ma.MaskedArray)]
+    # broadcast to match the shape
+    bcast = np.broadcast_arrays(*args, *masks)
+    inputs = bcast[:len(args)]
+    masks = bcast[len(args):]
+    if masks:
+        # combine the masks into one
+        mask = np.logical_or.reduce(masks)
+        # put mask on and compress
+        if compress:
+            inputs = [np.ma.array(k, mask=mask).compressed()
+                      for k in inputs]
+        else:
+            inputs = [np.ma.array(k, mask=mask, dtype=float).filled(np.nan).ravel()
+                      for k in inputs]
+    else:
+        inputs = [np.ravel(k) for k in inputs]
+    return inputs
+
+
+def boxplot_stats(X, whis=1.5, bootstrap=None, labels=None, autorange=False):
+    r"""
+    Return a list of dictionaries of statistics used to draw a series of box
+    and whisker plots using `~.Axes.bxp`.
+
+    Parameters
+    ----------
+    X : array-like
+        Data that will be represented in the boxplots. Should have 2 or
+        fewer dimensions.
+
+    whis : float or (float, float), default: 1.5
+        The position of the whiskers.
+
+        If a float, the lower whisker is at the lowest datum above
+        ``Q1 - whis*(Q3-Q1)``, and the upper whisker at the highest datum below
+        ``Q3 + whis*(Q3-Q1)``, where Q1 and Q3 are the first and third
+        quartiles.  The default value of ``whis = 1.5`` corresponds to Tukey's
+        original definition of boxplots.
+
+        If a pair of floats, they indicate the percentiles at which to draw the
+        whiskers (e.g., (5, 95)).  In particular, setting this to (0, 100)
+        results in whiskers covering the whole range of the data.
+
+        In the edge case where ``Q1 == Q3``, *whis* is automatically set to
+        (0, 100) (cover the whole range of the data) if *autorange* is True.
+
+        Beyond the whiskers, data are considered outliers and are plotted as
+        individual points.
+
+    bootstrap : int, optional
+        Number of times the confidence intervals around the median
+        should be bootstrapped (percentile method).
+
+    labels : list of str, optional
+        Labels for each dataset. Length must be compatible with
+        dimensions of *X*.
+
+    autorange : bool, optional (False)
+        When `True` and the data are distributed such that the 25th and 75th
+        percentiles are equal, ``whis`` is set to (0, 100) such that the
+        whisker ends are at the minimum and maximum of the data.
+
+    Returns
+    -------
+    list of dict
+        A list of dictionaries containing the results for each column
+        of data. Keys of each dictionary are the following:
+
+        ========   ===================================
+        Key        Value Description
+        ========   ===================================
+        label      tick label for the boxplot
+        mean       arithmetic mean value
+        med        50th percentile
+        q1         first quartile (25th percentile)
+        q3         third quartile (75th percentile)
+        iqr        interquartile range
+        cilo       lower notch around the median
+        cihi       upper notch around the median
+        whislo     end of the lower whisker
+        whishi     end of the upper whisker
+        fliers     outliers
+        ========   ===================================
+
+    Notes
+    -----
+    Non-bootstrapping approach to confidence interval uses Gaussian-based
+    asymptotic approximation:
+
+    .. math::
+
+        \mathrm{med} \pm 1.57 \times \frac{\mathrm{iqr}}{\sqrt{N}}
+
+    General approach from:
+    McGill, R., Tukey, J.W., and Larsen, W.A. (1978) "Variations of
+    Boxplots", The American Statistician, 32:12-16.
+    """
+
+    def _bootstrap_median(data, N=5000):
+        # determine 95% confidence intervals of the median
+        M = len(data)
+        percentiles = [2.5, 97.5]
+
+        bs_index = np.random.randint(M, size=(N, M))
+        bsData = data[bs_index]
+        estimate = np.median(bsData, axis=1, overwrite_input=True)
+
+        CI = np.percentile(estimate, percentiles)
+        return CI
+
+    def _compute_conf_interval(data, med, iqr, bootstrap):
+        if bootstrap is not None:
+            # Do a bootstrap estimate of notch locations.
+            # get conf. intervals around median
+            CI = _bootstrap_median(data, N=bootstrap)
+            notch_min = CI[0]
+            notch_max = CI[1]
+        else:
+
+            N = len(data)
+            notch_min = med - 1.57 * iqr / np.sqrt(N)
+            notch_max = med + 1.57 * iqr / np.sqrt(N)
+
+        return notch_min, notch_max
+
+    # output is a list of dicts
+    bxpstats = []
+
+    # convert X to a list of lists
+    X = _reshape_2D(X, "X")
+
+    ncols = len(X)
+    if labels is None:
+        labels = itertools.repeat(None)
+    elif len(labels) != ncols:
+        raise ValueError("Dimensions of labels and X must be compatible")
+
+    input_whis = whis
+    for ii, (x, label) in enumerate(zip(X, labels)):
+
+        # empty dict
+        stats = {}
+        if label is not None:
+            stats['label'] = label
+
+        # restore whis to the input values in case it got changed in the loop
+        whis = input_whis
+
+        # note tricksiness, append up here and then mutate below
+        bxpstats.append(stats)
+
+        # if empty, bail
+        if len(x) == 0:
+            stats['fliers'] = np.array([])
+            stats['mean'] = np.nan
+            stats['med'] = np.nan
+            stats['q1'] = np.nan
+            stats['q3'] = np.nan
+            stats['iqr'] = np.nan
+            stats['cilo'] = np.nan
+            stats['cihi'] = np.nan
+            stats['whislo'] = np.nan
+            stats['whishi'] = np.nan
+            continue
+
+        # up-convert to an array, just to be safe
+        x = np.ma.asarray(x)
+        x = x.data[~x.mask].ravel()
+
+        # arithmetic mean
+        stats['mean'] = np.mean(x)
+
+        # medians and quartiles
+        q1, med, q3 = np.percentile(x, [25, 50, 75])
+
+        # interquartile range
+        stats['iqr'] = q3 - q1
+        if stats['iqr'] == 0 and autorange:
+            whis = (0, 100)
+
+        # conf. interval around median
+        stats['cilo'], stats['cihi'] = _compute_conf_interval(
+            x, med, stats['iqr'], bootstrap
+        )
+
+        # lowest/highest non-outliers
+        if np.iterable(whis) and not isinstance(whis, str):
+            loval, hival = np.percentile(x, whis)
+        elif np.isreal(whis):
+            loval = q1 - whis * stats['iqr']
+            hival = q3 + whis * stats['iqr']
+        else:
+            raise ValueError('whis must be a float or list of percentiles')
+
+        # get high extreme
+        wiskhi = x[x <= hival]
+        if len(wiskhi) == 0 or np.max(wiskhi) < q3:
+            stats['whishi'] = q3
+        else:
+            stats['whishi'] = np.max(wiskhi)
+
+        # get low extreme
+        wisklo = x[x >= loval]
+        if len(wisklo) == 0 or np.min(wisklo) > q1:
+            stats['whislo'] = q1
+        else:
+            stats['whislo'] = np.min(wisklo)
+
+        # compute a single array of outliers
+        stats['fliers'] = np.concatenate([
+            x[x < stats['whislo']],
+            x[x > stats['whishi']],
+        ])
+
+        # add in the remaining stats
+        stats['q1'], stats['med'], stats['q3'] = q1, med, q3
+
+    return bxpstats
+
+
+#: Maps short codes for line style to their full name used by backends.
+ls_mapper = {'-': 'solid', '--': 'dashed', '-.': 'dashdot', ':': 'dotted'}
+#: Maps full names for line styles used by backends to their short codes.
+ls_mapper_r = {v: k for k, v in ls_mapper.items()}
+
+
+def contiguous_regions(mask):
+    """
+    Return a list of (ind0, ind1) such that ``mask[ind0:ind1].all()`` is
+    True and we cover all such regions.
+    """
+    mask = np.asarray(mask, dtype=bool)
+
+    if not mask.size:
+        return []
+
+    # Find the indices of region changes, and correct offset
+    idx, = np.nonzero(mask[:-1] != mask[1:])
+    idx += 1
+
+    # List operations are faster for moderately sized arrays
+    idx = idx.tolist()
+
+    # Add first and/or last index if needed
+    if mask[0]:
+        idx = [0] + idx
+    if mask[-1]:
+        idx.append(len(mask))
+
+    return list(zip(idx[::2], idx[1::2]))
+
+
+def is_math_text(s):
+    """
+    Return whether the string *s* contains math expressions.
+
+    This is done by checking whether *s* contains an even number of
+    non-escaped dollar signs.
+    """
+    s = str(s)
+    dollar_count = s.count(r'$') - s.count(r'\$')
+    even_dollars = (dollar_count > 0 and dollar_count % 2 == 0)
+    return even_dollars
+
+
+def _to_unmasked_float_array(x):
+    """
+    Convert a sequence to a float array; if input was a masked array, masked
+    values are converted to nans.
+    """
+    if hasattr(x, 'mask'):
+        return np.ma.asarray(x, float).filled(np.nan)
+    else:
+        return np.asarray(x, float)
+
+
+def _check_1d(x):
+    """Convert scalars to 1D arrays; pass-through arrays as is."""
+    # Unpack in case of e.g. Pandas or xarray object
+    x = _unpack_to_numpy(x)
+    # plot requires `shape` and `ndim`.  If passed an
+    # object that doesn't provide them, then force to numpy array.
+    # Note this will strip unit information.
+    if (not hasattr(x, 'shape') or
+            not hasattr(x, 'ndim') or
+            len(x.shape) < 1):
+        return np.atleast_1d(x)
+    else:
+        return x
+
+
+def _reshape_2D(X, name):
+    """
+    Use Fortran ordering to convert ndarrays and lists of iterables to lists of
+    1D arrays.
+
+    Lists of iterables are converted by applying `numpy.asanyarray` to each of
+    their elements.  1D ndarrays are returned in a singleton list containing
+    them.  2D ndarrays are converted to the list of their *columns*.
+
+    *name* is used to generate the error message for invalid inputs.
+    """
+
+    # Unpack in case of e.g. Pandas or xarray object
+    X = _unpack_to_numpy(X)
+
+    # Iterate over columns for ndarrays.
+    if isinstance(X, np.ndarray):
+        X = X.transpose()
+
+        if len(X) == 0:
+            return [[]]
+        elif X.ndim == 1 and np.ndim(X[0]) == 0:
+            # 1D array of scalars: directly return it.
+            return [X]
+        elif X.ndim in [1, 2]:
+            # 2D array, or 1D array of iterables: flatten them first.
+            return [np.reshape(x, -1) for x in X]
+        else:
+            raise ValueError(f'{name} must have 2 or fewer dimensions')
+
+    # Iterate over list of iterables.
+    if len(X) == 0:
+        return [[]]
+
+    result = []
+    is_1d = True
+    for xi in X:
+        # check if this is iterable, except for strings which we
+        # treat as singletons.
+        if not isinstance(xi, str):
+            try:
+                iter(xi)
+            except TypeError:
+                pass
+            else:
+                is_1d = False
+        xi = np.asanyarray(xi)
+        nd = np.ndim(xi)
+        if nd > 1:
+            raise ValueError(f'{name} must have 2 or fewer dimensions')
+        result.append(xi.reshape(-1))
+
+    if is_1d:
+        # 1D array of scalars: directly return it.
+        return [np.reshape(result, -1)]
+    else:
+        # 2D array, or 1D array of iterables: use flattened version.
+        return result
+
+
+def violin_stats(X, method, points=100, quantiles=None):
+    """
+    Return a list of dictionaries of data which can be used to draw a series
+    of violin plots.
+
+    See the ``Returns`` section below to view the required keys of the
+    dictionary.
+
+    Users can skip this function and pass a user-defined set of dictionaries
+    with the same keys to `~.axes.Axes.violinplot` instead of using Matplotlib
+    to do the calculations. See the *Returns* section below for the keys
+    that must be present in the dictionaries.
+
+    Parameters
+    ----------
+    X : array-like
+        Sample data that will be used to produce the gaussian kernel density
+        estimates. Must have 2 or fewer dimensions.
+
+    method : callable
+        The method used to calculate the kernel density estimate for each
+        column of data. When called via ``method(v, coords)``, it should
+        return a vector of the values of the KDE evaluated at the values
+        specified in coords.
+
+    points : int, default: 100
+        Defines the number of points to evaluate each of the gaussian kernel
+        density estimates at.
+
+    quantiles : array-like, default: None
+        Defines (if not None) a list of floats in interval [0, 1] for each
+        column of data, which represents the quantiles that will be rendered
+        for that column of data. Must have 2 or fewer dimensions. 1D array will
+        be treated as a singleton list containing them.
+
+    Returns
+    -------
+    list of dict
+        A list of dictionaries containing the results for each column of data.
+        The dictionaries contain at least the following:
+
+        - coords: A list of scalars containing the coordinates this particular
+          kernel density estimate was evaluated at.
+        - vals: A list of scalars containing the values of the kernel density
+          estimate at each of the coordinates given in *coords*.
+        - mean: The mean value for this column of data.
+        - median: The median value for this column of data.
+        - min: The minimum value for this column of data.
+        - max: The maximum value for this column of data.
+        - quantiles: The quantile values for this column of data.
+    """
+
+    # List of dictionaries describing each of the violins.
+    vpstats = []
+
+    # Want X to be a list of data sequences
+    X = _reshape_2D(X, "X")
+
+    # Want quantiles to be as the same shape as data sequences
+    if quantiles is not None and len(quantiles) != 0:
+        quantiles = _reshape_2D(quantiles, "quantiles")
+    # Else, mock quantiles if it's none or empty
+    else:
+        quantiles = [[]] * len(X)
+
+    # quantiles should have the same size as dataset
+    if len(X) != len(quantiles):
+        raise ValueError("List of violinplot statistics and quantiles values"
+                         " must have the same length")
+
+    # Zip x and quantiles
+    for (x, q) in zip(X, quantiles):
+        # Dictionary of results for this distribution
+        stats = {}
+
+        # Calculate basic stats for the distribution
+        min_val = np.min(x)
+        max_val = np.max(x)
+        quantile_val = np.percentile(x, 100 * q)
+
+        # Evaluate the kernel density estimate
+        coords = np.linspace(min_val, max_val, points)
+        stats['vals'] = method(x, coords)
+        stats['coords'] = coords
+
+        # Store additional statistics for this distribution
+        stats['mean'] = np.mean(x)
+        stats['median'] = np.median(x)
+        stats['min'] = min_val
+        stats['max'] = max_val
+        stats['quantiles'] = np.atleast_1d(quantile_val)
+
+        # Append to output
+        vpstats.append(stats)
+
+    return vpstats
+
+
+def pts_to_prestep(x, *args):
+    """
+    Convert continuous line to pre-steps.
+
+    Given a set of ``N`` points, convert to ``2N - 1`` points, which when
+    connected linearly give a step function which changes values at the
+    beginning of the intervals.
+
+    Parameters
+    ----------
+    x : array
+        The x location of the steps. May be empty.
+
+    y1, ..., yp : array
+        y arrays to be turned into steps; all must be the same length as ``x``.
+
+    Returns
+    -------
+    array
+        The x and y values converted to steps in the same order as the input;
+        can be unpacked as ``x_out, y1_out, ..., yp_out``.  If the input is
+        length ``N``, each of these arrays will be length ``2N + 1``. For
+        ``N=0``, the length will be 0.
+
+    Examples
+    --------
+    >>> x_s, y1_s, y2_s = pts_to_prestep(x, y1, y2)
+    """
+    steps = np.zeros((1 + len(args), max(2 * len(x) - 1, 0)))
+    # In all `pts_to_*step` functions, only assign once using *x* and *args*,
+    # as converting to an array may be expensive.
+    steps[0, 0::2] = x
+    steps[0, 1::2] = steps[0, 0:-2:2]
+    steps[1:, 0::2] = args
+    steps[1:, 1::2] = steps[1:, 2::2]
+    return steps
+
+
+def pts_to_poststep(x, *args):
+    """
+    Convert continuous line to post-steps.
+
+    Given a set of ``N`` points convert to ``2N + 1`` points, which when
+    connected linearly give a step function which changes values at the end of
+    the intervals.
+
+    Parameters
+    ----------
+    x : array
+        The x location of the steps. May be empty.
+
+    y1, ..., yp : array
+        y arrays to be turned into steps; all must be the same length as ``x``.
+
+    Returns
+    -------
+    array
+        The x and y values converted to steps in the same order as the input;
+        can be unpacked as ``x_out, y1_out, ..., yp_out``.  If the input is
+        length ``N``, each of these arrays will be length ``2N + 1``. For
+        ``N=0``, the length will be 0.
+
+    Examples
+    --------
+    >>> x_s, y1_s, y2_s = pts_to_poststep(x, y1, y2)
+    """
+    steps = np.zeros((1 + len(args), max(2 * len(x) - 1, 0)))
+    steps[0, 0::2] = x
+    steps[0, 1::2] = steps[0, 2::2]
+    steps[1:, 0::2] = args
+    steps[1:, 1::2] = steps[1:, 0:-2:2]
+    return steps
+
+
+def pts_to_midstep(x, *args):
+    """
+    Convert continuous line to mid-steps.
+
+    Given a set of ``N`` points convert to ``2N`` points which when connected
+    linearly give a step function which changes values at the middle of the
+    intervals.
+
+    Parameters
+    ----------
+    x : array
+        The x location of the steps. May be empty.
+
+    y1, ..., yp : array
+        y arrays to be turned into steps; all must be the same length as
+        ``x``.
+
+    Returns
+    -------
+    array
+        The x and y values converted to steps in the same order as the input;
+        can be unpacked as ``x_out, y1_out, ..., yp_out``.  If the input is
+        length ``N``, each of these arrays will be length ``2N``.
+
+    Examples
+    --------
+    >>> x_s, y1_s, y2_s = pts_to_midstep(x, y1, y2)
+    """
+    steps = np.zeros((1 + len(args), 2 * len(x)))
+    x = np.asanyarray(x)
+    steps[0, 1:-1:2] = steps[0, 2::2] = (x[:-1] + x[1:]) / 2
+    steps[0, :1] = x[:1]  # Also works for zero-sized input.
+    steps[0, -1:] = x[-1:]
+    steps[1:, 0::2] = args
+    steps[1:, 1::2] = steps[1:, 0::2]
+    return steps
+
+
+STEP_LOOKUP_MAP = {'default': lambda x, y: (x, y),
+                   'steps': pts_to_prestep,
+                   'steps-pre': pts_to_prestep,
+                   'steps-post': pts_to_poststep,
+                   'steps-mid': pts_to_midstep}
+
+
+def index_of(y):
+    """
+    A helper function to create reasonable x values for the given *y*.
+
+    This is used for plotting (x, y) if x values are not explicitly given.
+
+    First try ``y.index`` (assuming *y* is a `pandas.Series`), if that
+    fails, use ``range(len(y))``.
+
+    This will be extended in the future to deal with more types of
+    labeled data.
+
+    Parameters
+    ----------
+    y : float or array-like
+
+    Returns
+    -------
+    x, y : ndarray
+       The x and y values to plot.
+    """
+    try:
+        return y.index.to_numpy(), y.to_numpy()
+    except AttributeError:
+        pass
+    try:
+        y = _check_1d(y)
+    except (VisibleDeprecationWarning, ValueError):
+        # NumPy 1.19 will warn on ragged input, and we can't actually use it.
+        pass
+    else:
+        return np.arange(y.shape[0], dtype=float), y
+    raise ValueError('Input could not be cast to an at-least-1D NumPy array')
+
+
+def safe_first_element(obj):
+    """
+    Return the first element in *obj*.
+
+    This is a type-independent way of obtaining the first element,
+    supporting both index access and the iterator protocol.
+    """
+    if isinstance(obj, collections.abc.Iterator):
+        # needed to accept `array.flat` as input.
+        # np.flatiter reports as an instance of collections.Iterator but can still be
+        # indexed via []. This has the side effect of re-setting the iterator, but
+        # that is acceptable.
+        try:
+            return obj[0]
+        except TypeError:
+            pass
+        raise RuntimeError("matplotlib does not support generators as input")
+    return next(iter(obj))
+
+
+def _safe_first_finite(obj):
+    """
+    Return the first finite element in *obj* if one is available and skip_nonfinite is
+    True. Otherwise, return the first element.
+
+    This is a method for internal use.
+
+    This is a type-independent way of obtaining the first finite element, supporting
+    both index access and the iterator protocol.
+    """
+    def safe_isfinite(val):
+        if val is None:
+            return False
+        try:
+            return math.isfinite(val)
+        except (TypeError, ValueError):
+            # if the outer object is 2d, then val is a 1d array, and
+            # - math.isfinite(numpy.zeros(3)) raises TypeError
+            # - math.isfinite(torch.zeros(3)) raises ValueError
+            pass
+        try:
+            return np.isfinite(val) if np.isscalar(val) else True
+        except TypeError:
+            # This is something that NumPy cannot make heads or tails of,
+            # assume "finite"
+            return True
+
+    if isinstance(obj, np.flatiter):
+        # TODO do the finite filtering on this
+        return obj[0]
+    elif isinstance(obj, collections.abc.Iterator):
+        raise RuntimeError("matplotlib does not support generators as input")
+    else:
+        for val in obj:
+            if safe_isfinite(val):
+                return val
+        return safe_first_element(obj)
+
+
+def sanitize_sequence(data):
+    """
+    Convert dictview objects to list. Other inputs are returned unchanged.
+    """
+    return (list(data) if isinstance(data, collections.abc.MappingView)
+            else data)
+
+
+def normalize_kwargs(kw, alias_mapping=None):
+    """
+    Helper function to normalize kwarg inputs.
+
+    Parameters
+    ----------
+    kw : dict or None
+        A dict of keyword arguments.  None is explicitly supported and treated
+        as an empty dict, to support functions with an optional parameter of
+        the form ``props=None``.
+
+    alias_mapping : dict or Artist subclass or Artist instance, optional
+        A mapping between a canonical name to a list of aliases, in order of
+        precedence from lowest to highest.
+
+        If the canonical value is not in the list it is assumed to have the
+        highest priority.
+
+        If an Artist subclass or instance is passed, use its properties alias
+        mapping.
+
+    Raises
+    ------
+    TypeError
+        To match what Python raises if invalid arguments/keyword arguments are
+        passed to a callable.
+    """
+    from matplotlib.artist import Artist
+
+    if kw is None:
+        return {}
+
+    # deal with default value of alias_mapping
+    if alias_mapping is None:
+        alias_mapping = {}
+    elif (isinstance(alias_mapping, type) and issubclass(alias_mapping, Artist)
+          or isinstance(alias_mapping, Artist)):
+        alias_mapping = getattr(alias_mapping, "_alias_map", {})
+
+    to_canonical = {alias: canonical
+                    for canonical, alias_list in alias_mapping.items()
+                    for alias in alias_list}
+    canonical_to_seen = {}
+    ret = {}  # output dictionary
+
+    for k, v in kw.items():
+        canonical = to_canonical.get(k, k)
+        if canonical in canonical_to_seen:
+            raise TypeError(f"Got both {canonical_to_seen[canonical]!r} and "
+                            f"{k!r}, which are aliases of one another")
+        canonical_to_seen[canonical] = k
+        ret[canonical] = v
+
+    return ret
+
+
+@contextlib.contextmanager
+def _lock_path(path):
+    """
+    Context manager for locking a path.
+
+    Usage::
+
+        with _lock_path(path):
+            ...
+
+    Another thread or process that attempts to lock the same path will wait
+    until this context manager is exited.
+
+    The lock is implemented by creating a temporary file in the parent
+    directory, so that directory must exist and be writable.
+    """
+    path = Path(path)
+    lock_path = path.with_name(path.name + ".matplotlib-lock")
+    retries = 50
+    sleeptime = 0.1
+    for _ in range(retries):
+        try:
+            with lock_path.open("xb"):
+                break
+        except FileExistsError:
+            time.sleep(sleeptime)
+    else:
+        raise TimeoutError("""\
+Lock error: Matplotlib failed to acquire the following lock file:
+    {}
+This maybe due to another process holding this lock file.  If you are sure no
+other Matplotlib process is running, remove this file and try again.""".format(
+            lock_path))
+    try:
+        yield
+    finally:
+        lock_path.unlink()
+
+
+def _topmost_artist(
+        artists,
+        _cached_max=functools.partial(max, key=operator.attrgetter("zorder"))):
+    """
+    Get the topmost artist of a list.
+
+    In case of a tie, return the *last* of the tied artists, as it will be
+    drawn on top of the others. `max` returns the first maximum in case of
+    ties, so we need to iterate over the list in reverse order.
+    """
+    return _cached_max(reversed(artists))
+
+
+def _str_equal(obj, s):
+    """
+    Return whether *obj* is a string equal to string *s*.
+
+    This helper solely exists to handle the case where *obj* is a numpy array,
+    because in such cases, a naive ``obj == s`` would yield an array, which
+    cannot be used in a boolean context.
+    """
+    return isinstance(obj, str) and obj == s
+
+
+def _str_lower_equal(obj, s):
+    """
+    Return whether *obj* is a string equal, when lowercased, to string *s*.
+
+    This helper solely exists to handle the case where *obj* is a numpy array,
+    because in such cases, a naive ``obj == s`` would yield an array, which
+    cannot be used in a boolean context.
+    """
+    return isinstance(obj, str) and obj.lower() == s
+
+
+def _array_perimeter(arr):
+    """
+    Get the elements on the perimeter of *arr*.
+
+    Parameters
+    ----------
+    arr : ndarray, shape (M, N)
+        The input array.
+
+    Returns
+    -------
+    ndarray, shape (2*(M - 1) + 2*(N - 1),)
+        The elements on the perimeter of the array::
+
+           [arr[0, 0], ..., arr[0, -1], ..., arr[-1, -1], ..., arr[-1, 0], ...]
+
+    Examples
+    --------
+    >>> i, j = np.ogrid[:3, :4]
+    >>> a = i*10 + j
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [10, 11, 12, 13],
+           [20, 21, 22, 23]])
+    >>> _array_perimeter(a)
+    array([ 0,  1,  2,  3, 13, 23, 22, 21, 20, 10])
+    """
+    # note we use Python's half-open ranges to avoid repeating
+    # the corners
+    forward = np.s_[0:-1]      # [0 ... -1)
+    backward = np.s_[-1:0:-1]  # [-1 ... 0)
+    return np.concatenate((
+        arr[0, forward],
+        arr[forward, -1],
+        arr[-1, backward],
+        arr[backward, 0],
+    ))
+
+
+def _unfold(arr, axis, size, step):
+    """
+    Append an extra dimension containing sliding windows along *axis*.
+
+    All windows are of size *size* and begin with every *step* elements.
+
+    Parameters
+    ----------
+    arr : ndarray, shape (N_1, ..., N_k)
+        The input array
+    axis : int
+        Axis along which the windows are extracted
+    size : int
+        Size of the windows
+    step : int
+        Stride between first elements of subsequent windows.
+
+    Returns
+    -------
+    ndarray, shape (N_1, ..., 1 + (N_axis-size)/step, ..., N_k, size)
+
+    Examples
+    --------
+    >>> i, j = np.ogrid[:3, :7]
+    >>> a = i*10 + j
+    >>> a
+    array([[ 0,  1,  2,  3,  4,  5,  6],
+           [10, 11, 12, 13, 14, 15, 16],
+           [20, 21, 22, 23, 24, 25, 26]])
+    >>> _unfold(a, axis=1, size=3, step=2)
+    array([[[ 0,  1,  2],
+            [ 2,  3,  4],
+            [ 4,  5,  6]],
+           [[10, 11, 12],
+            [12, 13, 14],
+            [14, 15, 16]],
+           [[20, 21, 22],
+            [22, 23, 24],
+            [24, 25, 26]]])
+    """
+    new_shape = [*arr.shape, size]
+    new_strides = [*arr.strides, arr.strides[axis]]
+    new_shape[axis] = (new_shape[axis] - size) // step + 1
+    new_strides[axis] = new_strides[axis] * step
+    return np.lib.stride_tricks.as_strided(arr,
+                                           shape=new_shape,
+                                           strides=new_strides,
+                                           writeable=False)
+
+
+def _array_patch_perimeters(x, rstride, cstride):
+    """
+    Extract perimeters of patches from *arr*.
+
+    Extracted patches are of size (*rstride* + 1) x (*cstride* + 1) and
+    share perimeters with their neighbors. The ordering of the vertices matches
+    that returned by ``_array_perimeter``.
+
+    Parameters
+    ----------
+    x : ndarray, shape (N, M)
+        Input array
+    rstride : int
+        Vertical (row) stride between corresponding elements of each patch
+    cstride : int
+        Horizontal (column) stride between corresponding elements of each patch
+
+    Returns
+    -------
+    ndarray, shape (N/rstride * M/cstride, 2 * (rstride + cstride))
+    """
+    assert rstride > 0 and cstride > 0
+    assert (x.shape[0] - 1) % rstride == 0
+    assert (x.shape[1] - 1) % cstride == 0
+    # We build up each perimeter from four half-open intervals. Here is an
+    # illustrated explanation for rstride == cstride == 3
+    #
+    #       T T T R
+    #       L     R
+    #       L     R
+    #       L B B B
+    #
+    # where T means that this element will be in the top array, R for right,
+    # B for bottom and L for left. Each of the arrays below has a shape of:
+    #
+    #    (number of perimeters that can be extracted vertically,
+    #     number of perimeters that can be extracted horizontally,
+    #     cstride for top and bottom and rstride for left and right)
+    #
+    # Note that _unfold doesn't incur any memory copies, so the only costly
+    # operation here is the np.concatenate.
+    top = _unfold(x[:-1:rstride, :-1], 1, cstride, cstride)
+    bottom = _unfold(x[rstride::rstride, 1:], 1, cstride, cstride)[..., ::-1]
+    right = _unfold(x[:-1, cstride::cstride], 0, rstride, rstride)
+    left = _unfold(x[1:, :-1:cstride], 0, rstride, rstride)[..., ::-1]
+    return (np.concatenate((top, right, bottom, left), axis=2)
+              .reshape(-1, 2 * (rstride + cstride)))
+
+
+@contextlib.contextmanager
+def _setattr_cm(obj, **kwargs):
+    """
+    Temporarily set some attributes; restore original state at context exit.
+    """
+    sentinel = object()
+    origs = {}
+    for attr in kwargs:
+        orig = getattr(obj, attr, sentinel)
+        if attr in obj.__dict__ or orig is sentinel:
+            # if we are pulling from the instance dict or the object
+            # does not have this attribute we can trust the above
+            origs[attr] = orig
+        else:
+            # if the attribute is not in the instance dict it must be
+            # from the class level
+            cls_orig = getattr(type(obj), attr)
+            # if we are dealing with a property (but not a general descriptor)
+            # we want to set the original value back.
+            if isinstance(cls_orig, property):
+                origs[attr] = orig
+            # otherwise this is _something_ we are going to shadow at
+            # the instance dict level from higher up in the MRO.  We
+            # are going to assume we can delattr(obj, attr) to clean
+            # up after ourselves.  It is possible that this code will
+            # fail if used with a non-property custom descriptor which
+            # implements __set__ (and __delete__ does not act like a
+            # stack).  However, this is an internal tool and we do not
+            # currently have any custom descriptors.
+            else:
+                origs[attr] = sentinel
+
+    try:
+        for attr, val in kwargs.items():
+            setattr(obj, attr, val)
+        yield
+    finally:
+        for attr, orig in origs.items():
+            if orig is sentinel:
+                delattr(obj, attr)
+            else:
+                setattr(obj, attr, orig)
+
+
+class _OrderedSet(collections.abc.MutableSet):
+    def __init__(self):
+        self._od = collections.OrderedDict()
+
+    def __contains__(self, key):
+        return key in self._od
+
+    def __iter__(self):
+        return iter(self._od)
+
+    def __len__(self):
+        return len(self._od)
+
+    def add(self, key):
+        self._od.pop(key, None)
+        self._od[key] = None
+
+    def discard(self, key):
+        self._od.pop(key, None)
+
+
+# Agg's buffers are unmultiplied RGBA8888, which neither PyQt<=5.1 nor cairo
+# support; however, both do support premultiplied ARGB32.
+
+
+def _premultiplied_argb32_to_unmultiplied_rgba8888(buf):
+    """
+    Convert a premultiplied ARGB32 buffer to an unmultiplied RGBA8888 buffer.
+    """
+    rgba = np.take(  # .take() ensures C-contiguity of the result.
+        buf,
+        [2, 1, 0, 3] if sys.byteorder == "little" else [1, 2, 3, 0], axis=2)
+    rgb = rgba[..., :-1]
+    alpha = rgba[..., -1]
+    # Un-premultiply alpha.  The formula is the same as in cairo-png.c.
+    mask = alpha != 0
+    for channel in np.rollaxis(rgb, -1):
+        channel[mask] = (
+            (channel[mask].astype(int) * 255 + alpha[mask] // 2)
+            // alpha[mask])
+    return rgba
+
+
+def _unmultiplied_rgba8888_to_premultiplied_argb32(rgba8888):
+    """
+    Convert an unmultiplied RGBA8888 buffer to a premultiplied ARGB32 buffer.
+    """
+    if sys.byteorder == "little":
+        argb32 = np.take(rgba8888, [2, 1, 0, 3], axis=2)
+        rgb24 = argb32[..., :-1]
+        alpha8 = argb32[..., -1:]
+    else:
+        argb32 = np.take(rgba8888, [3, 0, 1, 2], axis=2)
+        alpha8 = argb32[..., :1]
+        rgb24 = argb32[..., 1:]
+    # Only bother premultiplying when the alpha channel is not fully opaque,
+    # as the cost is not negligible.  The unsafe cast is needed to do the
+    # multiplication in-place in an integer buffer.
+    if alpha8.min() != 0xff:
+        np.multiply(rgb24, alpha8 / 0xff, out=rgb24, casting="unsafe")
+    return argb32
+
+
+def _get_nonzero_slices(buf):
+    """
+    Return the bounds of the nonzero region of a 2D array as a pair of slices.
+
+    ``buf[_get_nonzero_slices(buf)]`` is the smallest sub-rectangle in *buf*
+    that encloses all non-zero entries in *buf*.  If *buf* is fully zero, then
+    ``(slice(0, 0), slice(0, 0))`` is returned.
+    """
+    x_nz, = buf.any(axis=0).nonzero()
+    y_nz, = buf.any(axis=1).nonzero()
+    if len(x_nz) and len(y_nz):
+        l, r = x_nz[[0, -1]]
+        b, t = y_nz[[0, -1]]
+        return slice(b, t + 1), slice(l, r + 1)
+    else:
+        return slice(0, 0), slice(0, 0)
+
+
+def _pformat_subprocess(command):
+    """Pretty-format a subprocess command for printing/logging purposes."""
+    return (command if isinstance(command, str)
+            else " ".join(shlex.quote(os.fspath(arg)) for arg in command))
+
+
+def _check_and_log_subprocess(command, logger, **kwargs):
+    """
+    Run *command*, returning its stdout output if it succeeds.
+
+    If it fails (exits with nonzero return code), raise an exception whose text
+    includes the failed command and captured stdout and stderr output.
+
+    Regardless of the return code, the command is logged at DEBUG level on
+    *logger*.  In case of success, the output is likewise logged.
+    """
+    logger.debug('%s', _pformat_subprocess(command))
+    proc = subprocess.run(command, capture_output=True, **kwargs)
+    if proc.returncode:
+        stdout = proc.stdout
+        if isinstance(stdout, bytes):
+            stdout = stdout.decode()
+        stderr = proc.stderr
+        if isinstance(stderr, bytes):
+            stderr = stderr.decode()
+        raise RuntimeError(
+            f"The command\n"
+            f"    {_pformat_subprocess(command)}\n"
+            f"failed and generated the following output:\n"
+            f"{stdout}\n"
+            f"and the following error:\n"
+            f"{stderr}")
+    if proc.stdout:
+        logger.debug("stdout:\n%s", proc.stdout)
+    if proc.stderr:
+        logger.debug("stderr:\n%s", proc.stderr)
+    return proc.stdout
+
+
+def _setup_new_guiapp():
+    """
+    Perform OS-dependent setup when Matplotlib creates a new GUI application.
+    """
+    # Windows: If not explicit app user model id has been set yet (so we're not
+    # already embedded), then set it to "matplotlib", so that taskbar icons are
+    # correct.
+    try:
+        _c_internal_utils.Win32_GetCurrentProcessExplicitAppUserModelID()
+    except OSError:
+        _c_internal_utils.Win32_SetCurrentProcessExplicitAppUserModelID(
+            "matplotlib")
+
+
+def _format_approx(number, precision):
+    """
+    Format the number with at most the number of decimals given as precision.
+    Remove trailing zeros and possibly the decimal point.
+    """
+    return f'{number:.{precision}f}'.rstrip('0').rstrip('.') or '0'
+
+
+def _g_sig_digits(value, delta):
+    """
+    Return the number of significant digits to %g-format *value*, assuming that
+    it is known with an error of *delta*.
+    """
+    # For inf or nan, the precision doesn't matter.
+    if not math.isfinite(value):
+        return 0
+    if delta == 0:
+        if value == 0:
+            # if both value and delta are 0, np.spacing below returns 5e-324
+            # which results in rather silly results
+            return 3
+        # delta = 0 may occur when trying to format values over a tiny range;
+        # in that case, replace it by the distance to the closest float.
+        delta = abs(np.spacing(value))
+    # If e.g. value = 45.67 and delta = 0.02, then we want to round to 2 digits
+    # after the decimal point (floor(log10(0.02)) = -2); 45.67 contributes 2
+    # digits before the decimal point (floor(log10(45.67)) + 1 = 2): the total
+    # is 4 significant digits.  A value of 0 contributes 1 "digit" before the
+    # decimal point.
+    return max(
+        0,
+        (math.floor(math.log10(abs(value))) + 1 if value else 1)
+        - math.floor(math.log10(delta)))
+
+
+def _unikey_or_keysym_to_mplkey(unikey, keysym):
+    """
+    Convert a Unicode key or X keysym to a Matplotlib key name.
+
+    The Unicode key is checked first; this avoids having to list most printable
+    keysyms such as ``EuroSign``.
+    """
+    # For non-printable characters, gtk3 passes "\0" whereas tk passes an "".
+    if unikey and unikey.isprintable():
+        return unikey
+    key = keysym.lower()
+    if key.startswith("kp_"):  # keypad_x (including kp_enter).
+        key = key[3:]
+    if key.startswith("page_"):  # page_{up,down}
+        key = key.replace("page_", "page")
+    if key.endswith(("_l", "_r")):  # alt_l, ctrl_l, shift_l.
+        key = key[:-2]
+    if sys.platform == "darwin" and key == "meta":
+        # meta should be reported as command on mac
+        key = "cmd"
+    key = {
+        "return": "enter",
+        "prior": "pageup",  # Used by tk.
+        "next": "pagedown",  # Used by tk.
+    }.get(key, key)
+    return key
+
+
+@functools.cache
+def _make_class_factory(mixin_class, fmt, attr_name=None):
+    """
+    Return a function that creates picklable classes inheriting from a mixin.
+
+    After ::
+
+        factory = _make_class_factory(FooMixin, fmt, attr_name)
+        FooAxes = factory(Axes)
+
+    ``Foo`` is a class that inherits from ``FooMixin`` and ``Axes`` and **is
+    picklable** (picklability is what differentiates this from a plain call to
+    `type`).  Its ``__name__`` is set to ``fmt.format(Axes.__name__)`` and the
+    base class is stored in the ``attr_name`` attribute, if not None.
+
+    Moreover, the return value of ``factory`` is memoized: calls with the same
+    ``Axes`` class always return the same subclass.
+    """
+
+    @functools.cache
+    def class_factory(axes_class):
+        # if we have already wrapped this class, declare victory!
+        if issubclass(axes_class, mixin_class):
+            return axes_class
+
+        # The parameter is named "axes_class" for backcompat but is really just
+        # a base class; no axes semantics are used.
+        base_class = axes_class
+
+        class subcls(mixin_class, base_class):
+            # Better approximation than __module__ = "matplotlib.cbook".
+            __module__ = mixin_class.__module__
+
+            def __reduce__(self):
+                return (_picklable_class_constructor,
+                        (mixin_class, fmt, attr_name, base_class),
+                        self.__getstate__())
+
+        subcls.__name__ = subcls.__qualname__ = fmt.format(base_class.__name__)
+        if attr_name is not None:
+            setattr(subcls, attr_name, base_class)
+        return subcls
+
+    class_factory.__module__ = mixin_class.__module__
+    return class_factory
+
+
+def _picklable_class_constructor(mixin_class, fmt, attr_name, base_class):
+    """Internal helper for _make_class_factory."""
+    factory = _make_class_factory(mixin_class, fmt, attr_name)
+    cls = factory(base_class)
+    return cls.__new__(cls)
+
+
+def _is_torch_array(x):
+    """Return whether *x* is a PyTorch Tensor."""
+    try:
+        # We're intentionally not attempting to import torch. If somebody
+        # has created a torch array, torch should already be in sys.modules.
+        tp = sys.modules.get("torch").Tensor
+    except AttributeError:
+        return False  # Module not imported or a nonstandard module with no Tensor attr.
+    return (isinstance(tp, type)  # Just in case it's a very nonstandard module.
+            and isinstance(x, tp))
+
+
+def _is_jax_array(x):
+    """Return whether *x* is a JAX Array."""
+    try:
+        # We're intentionally not attempting to import jax. If somebody
+        # has created a jax array, jax should already be in sys.modules.
+        tp = sys.modules.get("jax").Array
+    except AttributeError:
+        return False  # Module not imported or a nonstandard module with no Array attr.
+    return (isinstance(tp, type)  # Just in case it's a very nonstandard module.
+            and isinstance(x, tp))
+
+
+def _is_pandas_dataframe(x):
+    """Check if *x* is a Pandas DataFrame."""
+    try:
+        # We're intentionally not attempting to import Pandas. If somebody
+        # has created a Pandas DataFrame, Pandas should already be in sys.modules.
+        tp = sys.modules.get("pandas").DataFrame
+    except AttributeError:
+        return False  # Module not imported or a nonstandard module with no Array attr.
+    return (isinstance(tp, type)  # Just in case it's a very nonstandard module.
+            and isinstance(x, tp))
+
+
+def _is_tensorflow_array(x):
+    """Return whether *x* is a TensorFlow Tensor or Variable."""
+    try:
+        # We're intentionally not attempting to import TensorFlow. If somebody
+        # has created a TensorFlow array, TensorFlow should already be in
+        # sys.modules we use `is_tensor` to not depend on the class structure
+        # of TensorFlow arrays, as `tf.Variables` are not instances of
+        # `tf.Tensor` (they both convert the same way).
+        is_tensor = sys.modules.get("tensorflow").is_tensor
+    except AttributeError:
+        return False
+    try:
+        return is_tensor(x)
+    except Exception:
+        return False  # Just in case it's a very nonstandard module.
+
+
+def _unpack_to_numpy(x):
+    """Internal helper to extract data from e.g. pandas and xarray objects."""
+    if isinstance(x, np.ndarray):
+        # If numpy, return directly
+        return x
+    if hasattr(x, 'to_numpy'):
+        # Assume that any to_numpy() method actually returns a numpy array
+        return x.to_numpy()
+    if hasattr(x, 'values'):
+        xtmp = x.values
+        # For example a dict has a 'values' attribute, but it is not a property
+        # so in this case we do not want to return a function
+        if isinstance(xtmp, np.ndarray):
+            return xtmp
+    if _is_torch_array(x) or _is_jax_array(x) or _is_tensorflow_array(x):
+        # using np.asarray() instead of explicitly __array__(), as the latter is
+        # only _one_ of many methods, and it's the last resort, see also
+        # https://numpy.org/devdocs/user/basics.interoperability.html#using-arbitrary-objects-in-numpy
+        # therefore, let arrays do better if they can
+        xtmp = np.asarray(x)
+
+        # In case np.asarray method does not return a numpy array in future
+        if isinstance(xtmp, np.ndarray):
+            return xtmp
+    return x
+
+
+def _auto_format_str(fmt, value):
+    """
+    Apply *value* to the format string *fmt*.
+
+    This works both with unnamed %-style formatting and
+    unnamed {}-style formatting. %-style formatting has priority.
+    If *fmt* is %-style formattable that will be used. Otherwise,
+    {}-formatting is applied. Strings without formatting placeholders
+    are passed through as is.
+
+    Examples
+    --------
+    >>> _auto_format_str('%.2f m', 0.2)
+    '0.20 m'
+    >>> _auto_format_str('{} m', 0.2)
+    '0.2 m'
+    >>> _auto_format_str('const', 0.2)
+    'const'
+    >>> _auto_format_str('%d or {}', 0.2)
+    '0 or {}'
+    """
+    try:
+        return fmt % (value,)
+    except (TypeError, ValueError):
+        return fmt.format(value)

Scripts_Climate_n_LAI_to_Yield/.venv/lib/python3.10/site-packages/matplotlib/cbook.pyi

@@ -0,0 +1,173 @@
+import collections.abc
+from collections.abc import Callable, Collection, Generator, Iterable, Iterator
+import contextlib
+import os
+from pathlib import Path
+
+from matplotlib.artist import Artist
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from typing import (
+    Any,
+    Generic,
+    IO,
+    Literal,
+    TypeVar,
+    overload,
+)
+
+_T = TypeVar("_T")
+
+def _get_running_interactive_framework() -> str | None: ...
+
+class CallbackRegistry:
+    exception_handler: Callable[[Exception], Any]
+    callbacks: dict[Any, dict[int, Any]]
+    def __init__(
+        self,
+        exception_handler: Callable[[Exception], Any] | None = ...,
+        *,
+        signals: Iterable[Any] | None = ...,
+    ) -> None: ...
+    def connect(self, signal: Any, func: Callable) -> int: ...
+    def disconnect(self, cid: int) -> None: ...
+    def process(self, s: Any, *args, **kwargs) -> None: ...
+    def blocked(
+        self, *, signal: Any | None = ...
+    ) -> contextlib.AbstractContextManager[None]: ...
+
+class silent_list(list[_T]):
+    type: str | None
+    def __init__(self, type: str | None, seq: Iterable[_T] | None = ...) -> None: ...
+
+def strip_math(s: str) -> str: ...
+def is_writable_file_like(obj: Any) -> bool: ...
+def file_requires_unicode(x: Any) -> bool: ...
+@overload
+def to_filehandle(
+    fname: str | os.PathLike | IO,
+    flag: str = ...,
+    return_opened: Literal[False] = ...,
+    encoding: str | None = ...,
+) -> IO: ...
+@overload
+def to_filehandle(
+    fname: str | os.PathLike | IO,
+    flag: str,
+    return_opened: Literal[True],
+    encoding: str | None = ...,
+) -> tuple[IO, bool]: ...
+@overload
+def to_filehandle(
+    fname: str | os.PathLike | IO,
+    *,  # if flag given, will match previous sig
+    return_opened: Literal[True],
+    encoding: str | None = ...,
+) -> tuple[IO, bool]: ...
+def open_file_cm(
+    path_or_file: str | os.PathLike | IO,
+    mode: str = ...,
+    encoding: str | None = ...,
+) -> contextlib.AbstractContextManager[IO]: ...
+def is_scalar_or_string(val: Any) -> bool: ...
+@overload
+def get_sample_data(
+    fname: str | os.PathLike, asfileobj: Literal[True] = ...
+) -> np.ndarray | IO: ...
+@overload
+def get_sample_data(fname: str | os.PathLike, asfileobj: Literal[False]) -> str: ...
+def _get_data_path(*args: Path | str) -> Path: ...
+def flatten(
+    seq: Iterable[Any], scalarp: Callable[[Any], bool] = ...
+) -> Generator[Any, None, None]: ...
+
+class _Stack(Generic[_T]):
+    def __init__(self) -> None: ...
+    def clear(self) -> None: ...
+    def __call__(self) -> _T: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, ind: int) -> _T: ...
+    def forward(self) -> _T: ...
+    def back(self) -> _T: ...
+    def push(self, o: _T) -> _T: ...
+    def home(self) -> _T: ...
+
+def safe_masked_invalid(x: ArrayLike, copy: bool = ...) -> np.ndarray: ...
+def print_cycles(
+    objects: Iterable[Any], outstream: IO = ..., show_progress: bool = ...
+) -> None: ...
+
+class Grouper(Generic[_T]):
+    def __init__(self, init: Iterable[_T] = ...) -> None: ...
+    def __contains__(self, item: _T) -> bool: ...
+    def join(self, a: _T, *args: _T) -> None: ...
+    def joined(self, a: _T, b: _T) -> bool: ...
+    def remove(self, a: _T) -> None: ...
+    def __iter__(self) -> Iterator[list[_T]]: ...
+    def get_siblings(self, a: _T) -> list[_T]: ...
+
+class GrouperView(Generic[_T]):
+    def __init__(self, grouper: Grouper[_T]) -> None: ...
+    def __contains__(self, item: _T) -> bool: ...
+    def __iter__(self) -> Iterator[list[_T]]: ...
+    def joined(self, a: _T, b: _T) -> bool: ...
+    def get_siblings(self, a: _T) -> list[_T]: ...
+
+def simple_linear_interpolation(a: ArrayLike, steps: int) -> np.ndarray: ...
+def delete_masked_points(*args): ...
+def _broadcast_with_masks(*args: ArrayLike, compress: bool = ...) -> list[ArrayLike]: ...
+def boxplot_stats(
+    X: ArrayLike,
+    whis: float | tuple[float, float] = ...,
+    bootstrap: int | None = ...,
+    labels: ArrayLike | None = ...,
+    autorange: bool = ...,
+) -> list[dict[str, Any]]: ...
+
+ls_mapper: dict[str, str]
+ls_mapper_r: dict[str, str]
+
+def contiguous_regions(mask: ArrayLike) -> list[np.ndarray]: ...
+def is_math_text(s: str) -> bool: ...
+def violin_stats(
+    X: ArrayLike, method: Callable, points: int = ..., quantiles: ArrayLike | None = ...
+) -> list[dict[str, Any]]: ...
+def pts_to_prestep(x: ArrayLike, *args: ArrayLike) -> np.ndarray: ...
+def pts_to_poststep(x: ArrayLike, *args: ArrayLike) -> np.ndarray: ...
+def pts_to_midstep(x: np.ndarray, *args: np.ndarray) -> np.ndarray: ...
+
+STEP_LOOKUP_MAP: dict[str, Callable]
+
+def index_of(y: float | ArrayLike) -> tuple[np.ndarray, np.ndarray]: ...
+def safe_first_element(obj: Collection[_T]) -> _T: ...
+def sanitize_sequence(data): ...
+def normalize_kwargs(
+    kw: dict[str, Any],
+    alias_mapping: dict[str, list[str]] | type[Artist] | Artist | None = ...,
+) -> dict[str, Any]: ...
+def _lock_path(path: str | os.PathLike) -> contextlib.AbstractContextManager[None]: ...
+def _str_equal(obj: Any, s: str) -> bool: ...
+def _str_lower_equal(obj: Any, s: str) -> bool: ...
+def _array_perimeter(arr: np.ndarray) -> np.ndarray: ...
+def _unfold(arr: np.ndarray, axis: int, size: int, step: int) -> np.ndarray: ...
+def _array_patch_perimeters(x: np.ndarray, rstride: int, cstride: int) -> np.ndarray: ...
+def _setattr_cm(obj: Any, **kwargs) -> contextlib.AbstractContextManager[None]: ...
+
+class _OrderedSet(collections.abc.MutableSet):
+    def __init__(self) -> None: ...
+    def __contains__(self, key) -> bool: ...
+    def __iter__(self): ...
+    def __len__(self) -> int: ...
+    def add(self, key) -> None: ...
+    def discard(self, key) -> None: ...
+
+def _setup_new_guiapp() -> None: ...
+def _format_approx(number: float, precision: int) -> str: ...
+def _g_sig_digits(value: float, delta: float) -> int: ...
+def _unikey_or_keysym_to_mplkey(unikey: str, keysym: str) -> str: ...
+def _is_torch_array(x: Any) -> bool: ...
+def _is_jax_array(x: Any) -> bool: ...
+def _unpack_to_numpy(x: Any) -> Any: ...
+def _auto_format_str(fmt: str, value: Any) -> str: ...